ZAttackV2
约 9222 字
获球模式(GetBallMode)- 9 个状态
| 状态 | 值 | 触发条件 | 目的 | 特点 |
|---|---|---|---|---|
| CHASE_KICK | 4 | 无球 | 冲向球 | 加速度模型,越接近越快 |
| WAIT_TOUCH | 0 | 球动,我方在截球线上,可触球 | 等球到达后触球 | 预计触球时间点;计算反弹角 |
| INTER_TOUCH | 1 | 球动,需要边跑边触 | 拦截触球 | 跑到球侧面40mm;有时补偿目标方向 |
| WAIT_RECV | 2 | 球动,处在禁区内接球 | 等待接传 | 用 getPenaltyTouchPos() 计算安全接点 |
| INTER_RECV | 3 | 球动,禁区外或需要移动接 | 边跑边接 | 动态追踪截球点 |
| SNATCH_BALL | 8 | 敌机抢球,我距球<500mm | 抢球 | 与敌对抗,需要避开敌机 |
| WAIT_BALL | 5 | 禁区内球静止 | 等待空档 | 位置转移到安全地带 |
| BREAK_SOLVER | 6 | 持球+周围敌多 | 摆脱压迫 | 调用 makeItZBreak() |
| KICK_BALL | 9 | 已持球 | 直接射门/传球 | 主要输出模式 |
| CHIP_SOLVER | 7 | 飞行时期 | 挑传 | (代码中注释掉) |
状态机设计
ZAttackV2 是一个基于状态机的进攻技能,通过 9 种状态覆盖从获球到射门/传球的完整流程。状态机的核心设计思想是优先级决策:按照固定的优先级顺序判断当前最合适的状态,一旦满足条件立即返回,确保响应实时性。
状态转移逻辑
状态判断由 judge_State() 函数实现,其优先级顺序如下(从上到下):
- 禁区等待 (
WAIT_BALL):球在禁区内且静止,避免犯规 - 接球/触球决策 (
WAIT_RECV/INTER_RECV/WAIT_TOUCH/INTER_TOUCH):球在运动中,根据角度判断接球还是触球 - 抢球 (
SNATCH_BALL):敌方试图抢球,主动争夺 - 追球 (
CHASE_KICK):无持球且无特殊场景,单纯追球 - 突破 (
BREAK_SOLVER):持球且周围有敌方压迫 - 射门/传球 (
KICK_BALL):稳定持球,执行最终动作
状态切换稳定性
为防止状态抖动,ZAttackV2 引入了以下机制:
- 锁定触球目标:在
WAIT_TOUCH状态下,若球速方向变化小于 6° 且球速足够快,则保持上一帧的目标点和状态,避免因计算抖动导致切换。 - 持球计数:使用红外传感器计数 (
fraredOn),连续多帧检测到持球才认为“稳定持球”,避免单帧误判。 - 禁区特殊处理:球在禁区内静止时强制进入
WAIT_BALL,避免违规拿球。
设计哲学
- 安全性优先:禁区处理、碰撞检测等确保不犯规、不冲突。
- 效率最大化:根据球速、角度动态选择接球/触球策略,减少多余动作。
- 对抗性增强:抢球、突破状态专门应对敌方干扰,提升进攻韧性。
状态转移示意图
注:此流程图简化了 judge_State() 的实际判断逻辑,但反映了核心的优先级顺序。
judge_State
/**
* @name: CZAttackV2::judge_State
* @description: 判断当前状态
* @param {CVisionModule*} pVision 视觉指针
* @param {int} runner 此 SKill 的车号
* @param {CGeoPoint} target 射门目标(不是跑位的点)
* @param {CGeoPoint} projection 我在球速线上的投影点
* @param {double} tarj_dir target 方向(带反弹角alpha修正)
* @param {double} proj2balldir 投影到球的方向
* @param {int} taskFlag 任务标志位
* @return {*}
*/
void CZAttackV2::judge_State(const CVisionModule *pVision, const int runner, CGeoPoint target,
CGeoPoint projection, double tarj_dir, double proj2balldir,
int taskFlag)此函数用于判断当前的状态,决定 getBallMode 是什么状态
我来详细分析这个 judge_State 函数,这是状态决策的核心。
初始化
// 基本状态信息
const PlayerVisionT &me = pVision->ourPlayer(runner);
const MobileVisionT &ball = pVision->ball();
const PlayerVisionT& bestene = pVision->theirPlayer(Utils::BestNearEne(ball.Pos(), pVision));
// 球的基本参数
const CGeoPoint ballPos = ball.Pos();
const double ballVelMod = ball.Vel().mod(); // 球速大小
// 向量关系
const CVector me2ball = ballPos - me.RawPos(); // 我到球
const CVector ball2me = me.RawPos() - ballPos; // 球到我
const CVector enemy2ball = ball.Pos() - bestene.RawPos(); // 敌到球
// 预测性参数
dribblePoint = RobotSensor::Instance()->dribblePoint(runner); // 我的带球点预测
CGeoPoint temp_recvpos;
getPenaltyTouchPos(pVision, runner, target, temp_recvpos, tarj_dir, Receive);
// 预先计算禁区内的接球位置
// 位置检查
bool penalty_recv = Utils::InTheirPenaltyArea(me.RawPos(), PARAM::Vehicle::V2::PLAYER_SIZE*11);
// 我是否在敌方禁区内(扩大11倍机器人尺寸的判定)
bool recvinpenalty = Utils::InTheirPenaltyArea(temp_recvpos, PARAM::Vehicle::V2::PLAYER_SIZE*3);
// 预计接球位置是否在禁区内(扩大3倍)关键判断条件
is_recv - 接收还是触球?
CVector touchPoint2target = target - projection; // 投影点到目标的向量
double touchAnglediff = fabs(Utils::Normalize(touchPoint2target.dir() - ball.Vel().dir() + PARAM::Math::PI));
// 计算:从投影点指向目标的方向 与 球的反向 的夹角
bool is_recv = touchAnglediff > TOUCH_ANGLE * PARAM::Math::PI / 180.0;
// 是_recv = 触球角度 > 70°物理含义:
- 如果 touchAnglediff > 70°:
意味着"投影点→目标"的方向与"球的反向"夹角很大
不适合直接触球改向(需要大转向)
采用"接收"策略(等球过来自己去接)
- 如果 touchAnglediff ≤ 70°:
意味着能相对直接地改变球的方向
采用"触球"策略(直接触碰改向)
can_recv - 能否精确接收?
bool can_recv = fabs(Utils::Normalize(proj2balldir - ball.Vel().dir())) < 0.1;
// 投影→球的方向 与 球速方向 的差 < 0.1 rad(≈5.7°)物理含义:
- 当投影点到球的方向和球速方向几乎平行(误差<6°)时
- 说明我正好站在球的轨迹上,能精确截球
- 这是最优接球条件
use_waittouch - 适合等待触球吗?
double roll_dist = ball.Vel().mod() * ball.Vel().mod() / FRICTION;
// 球停止所需的距离 = v² / (2μ)
CGeoPoint ballstop_pos = ball.RawPos() + Utils::Polar2Vector(roll_dist, ball.Vel().dir());
// 球的预计停止位置
CVector proj2stop = ballstop_pos - projection; // 投影→球停止位置
CVector proj2ball = ball.RawPos() - projection; // 投影→球当前位置
CVector proj2me = me.RawPos() - projection; // 投影→我
bool use_waittouch = fabs(proj2stop.dir() - ball.Vel().dir()) < 0.1 &&
(proj2ball.mod() > 100*10 ||
(proj2ball.mod() < 100*10 && proj2me.mod() < 30*10));三层判断:
第1层:fabs(proj2stop.dir() - ball.Vel().dir()) < 0.1
→ 球的停止位置方向与球速方向几乎相同
→ 说明球会继续沿着当前方向滚动到停止
第2层:proj2ball.mod() > 1000mm
→ 球距离投影点较远(>1米)
→ 有充足时间等待球滚到投影附近
第3层:proj2ball.mod() < 1000mm && proj2me.mod() < 300mm
→ 球很近 & 我也很近投影
→ 可以直接等球到达触碰结论: use_waittouch = TRUE 时适合采用 WAIT_TOUCH 模式
holding_ball - 持球判断
bool holding_ball = RobotSensor::Instance()->fraredOn(runner);
// 注意:注释掉了 Utils::isBallInFace() 的判断
// 改用了红外传感器的持球计数
// 在 judge_State 末尾会更新持球计数:
fraredOn = holding_ball ? fraredOn + 1 : 0;
// 如果持球,计数器 +1;如果失球,重置为 0物理含义:
- 不是简单的"球在机器人前面"判断
- 而是红外传感器的累计计数
- 需要连续几个周期都有红外信号才认为"稳定持球"
need_recvortouch - 是否需要接球/触球?
bool need_recvortouch = !holding_ball &&
ballVelMod > 50*10 &&
fabs(Utils::Normalize(ball2me.dir() - ball.Vel().dir())) < PARAM::Math::PI/3.0;
// 无球 & 球在运动 & 我能追上三层条件:
1. !holding_ball
→ 当前没有持球
2. ballVelMod > 500mm/s
→ 球体在运动中(不是静止)
3. |ball→me 方向 - 球速方向| < 60°
→ 球朝向我(相对)
→ 我能追上球条件 6:need_waitball - 禁区特殊情况
bool need_waitball = ((Utils::InTheirPenaltyArea(ballPos, -PARAM::Field::BALL_SIZE) ||
Utils::InOurPenaltyArea(ballPos, 9*10)) &&
ballVelMod < 50*10) &&
!(taskFlag & PlayerStatus::NOT_AVOID_PENALTY);触发条件(全部满足):
- 球在敌方禁区内(缩小球半径,即球完全进入禁区)或球在我方禁区内
- 球速 < 500mm/s(球几乎静止)
- 任务标志位不是"不避免禁区"
场景: 禁区内球停了,应该让位,不能直接拿
条件 7:need_snatchball - 抢球条件
bool need_snatchball = !holding_ball &&
(me2ball.mod() < 500 && ene_disturb_pass) ||
(fabs(Utils::Normalize(bestene.Dir() - enemy2ball.dir())) < PARAM::Math::PI/9.0 &&
enemy2ball.mod() < 135) &&
!holding_ball;条件逻辑(注意括号):
need_snatchball = TRUE 当满足以下情况之一:
情况A:我距球 < 500mm && 敌方挡路(ene_disturb_pass=TRUE)
→ 敌机在我与球之间,需要抢球绕过
情况B:敌机朝向与敌→球向量夹角 < 20° && 敌→球距离 < 135mm
→ 敌机正对准要抢球,我要快速抢先ene_disturb_pass 的定义:
CGeoSegment me_dir_seg(me.RawPos(), me.RawPos() + Utils::Polar2Vector(1000, me.RawDir()));
// 我沿着当前朝向的线段
bool ene_disturb_pass = false;
if(bestene.Pos().dist(me.RawPos()) < 300 &&
me_dir_seg.IsPointOnLineOnSegment(me_dir_seg.projection(bestene.Pos()))) {
// 敌机靠近 < 300mm && 敌机在我的前进方向线上
ene_disturb_pass = (me_dir_seg.projection(bestene.Pos()).dist(bestene.Pos()) < 105);
// 敌机距离我的前进方向 < 105mm(在我的冲刺路径上)
}条件 8:need_break - 摆脱条件
bool need_break = WorldModel::Instance()->getEnemyAmountInArea(dribblePoint, minBreakDist, enemyNumVec, 0) > 0 &&
fraredOn > 3;
// 周围 1000mm 内有敌方 & 已经稳定持球(> 3 周期)第四部分:状态判断的优先级流程
// 优先级顺序(从上到下,一旦满足即返回):
1️⃣ if(need_waitball) {
getBallMode = WAIT_BALL;// 球在禁区,我们不能拿,等着清球
return;
}
2️⃣ if(need_recvortouch) {// 无球 & 球在运动 & 我能追上
if(is_recv) {//触球角度 > 70° , 需要大转向才能接到球,采用接球策略
if(penalty_recv && recvinpenalty) {
getBallMode = WAIT_RECV;// 禁区内,等着球来
} else {
getBallMode = INTER_RECV;// 在禁区外,跑到截球点去接
}
} else {// 触球角度小,差不多是传球传过来的,采用触球策略
if(can_recv && use_waittouch) {
getBallMode = WAIT_TOUCH;// 禁区内,等着球来
} else {
getBallMode = INTER_TOUCH; // 禁区外,截球触球
}
}
return;
}
3️⃣ if(need_snatchball) {
getBallMode = SNATCH_BALL;// 敌方想抢,抢球策略
return;
}
4️⃣ if(!holding_ball) {
getBallMode = CHASE_KICK;// 没拿着球,去追球
return;
}
5️⃣ if(need_break) {
getBallMode = BREAK_SOLVER;// 被敌人缠上了,需要突破
return;
}
6️⃣ if(fraredOn > 3) {
getBallMode = KICK_BALL;// 球拿稳了,赶紧传球或者射门
return;
}第五部分:关键参数对照表
| 参数 | 数值 | 含义 |
|---|---|---|
| TOUCH_ANGLE | 70° | 触球有效角度范围 |
| 球运动阈值 | 500 mm/s | ballVelMod > 50*10 |
| 抢球距离 | 500 mm | me2ball.mod() < 500 |
| 敌方挡路距离 | 300 mm | 敌机到我的距离 |
| 挡路偏差 | 105 mm | 敌机距离前进方向线的偏差 |
| 敌对球距离 | 135 mm | 敌距球的触发距离 |
| 敌朝向差 | ±20° | 敌朝向与敌→球的角度 |
| 摆脱周围距离 | 1000 mm | 周围敌机检测范围 |
| 持球稳定周期 | > 3 | fraredOn > 3 |
| 禁区等待球速 | < 500 mm/s | 球速静止判定 |
| 我在投影距离 | < 300 mm | proj2me.mod() < 300mm |
锁定触球目标
if (lastGetBallMode == WAIT_TOUCH &&
fabs(ball.Vel().dir() - last_ballveldir) < 6 * PARAM::Math::PI / 180.0 &&
ball.Vel().mod() > 50 * 10)
{ // 锁定触球目标,防止因球速方向抖动导致状态切换
target = last_target;
me2target = target - me.RawPos();
interPoint2target = target - interPoint;
ball2target = target - ball.Pos();
getBallMode = WAIT_TOUCH;
}这段代码的作用是锁定触球目标,防止因球速方向抖动导致状态切换。
具体逻辑:当满足以下三个条件时,强制保持 WAIT_TOUCH(等待触球)模式:
- 上一帧也是
WAIT_TOUCH状态 —lastGetBallMode == WAIT_TOUCH - 球速方向变化很小(小于 6°)— 说明球仍在按原轨迹运动,方向未发生突变
- 球速足够快(> 500,单位 mm/s × 10)— 说明球确实在运动中,非静止状态
满足条件后:
- 恢复上一帧的
target(即last_target),避免目标点因judbestshootpos重新计算而跳变 - 重新推导
me2target、interPoint2target、ball2target等方向向量 - 强制将
getBallMode置为WAIT_TOUCH,覆盖judge_State()刚刚计算的新状态
本质:一个滞后(hysteresis)保护机制,确保在球飞来过程中机器人触球姿态和目标方向保持稳定,不会因每帧重新计算而抖动。
计算触球偏转角 alpha
double inVel; //球的末速度
if (ball.Vel().mod2() > FRICTION * me2ball.mod())
inVel = sqrt(ball.Vel().mod2() - FRICTION * me2ball.mod());
else
inVel = ball.Vel().mod();
// 计算球到达时的末速度 inVel
double beta = Utils::Normalize(ball.Vel().dir() + PARAM::Math::PI -
(target - me.RawPos()).dir()); //球速反方向和我到目标点连线的夹角
// double alpha = atan2(power * sin(beta) / 0.42 + 1e-5, inVel + power * cos(beta) / 0.42 +
// 1e-5);//通过击球力度分量和球的撞击速度算一个beta中间的角度
double alpha = beta / 2;
for (int j = 0; j < 5; j++)
{
alpha = alpha - (power * sin(alpha) + kn * inVel * sin(alpha) * cos(beta - alpha) -
kt * inVel * cos(alpha) * sin(beta - alpha)) /
(power * cos(alpha) + (kn + kt) * inVel * cos(2 * alpha - beta) + 1e-5);
}
taskFlag |= PlayerStatus::NOT_AVOID_THEIR_VEHICLE;
int dribble_power = 3;这段代码的作用是计算触球偏转角 alpha,用于确定触球时机器人应朝向的角度,使球在碰撞后能弹向目标点。
分三步:
1. 计算球到达时的末速度 inVel
vin=v02−FRICTION⋅d
用能量衰减模型估算球运动到机器人处时剩余的速度(摩擦力做功)。
2. 计算入射角 beta
β=normalize(vball方向的反向−me→target方向)
即球速反方向与「机器人→目标」连线之间的夹角,描述了理想反射需要偏转多少。
3. 用牛顿迭代法求触球角 alpha
迭代方程来自碰撞模型(法向系数 kn、切向系数 kt):
f(α)=Psinα+knvinsinαcos(β−α)−ktvincosαsin(β−α)=0
其中 α 是机器人朝向相对于「me→target」方向的偏转量。初始值取 α=β/2,迭代5次收敛。
最终用途:后续 WAIT_TOUCH / INTER_TOUCH 状态中用 me2target.dir() + alpha 作为 targetDir,使机器人以正确角度等待触球,将来球弹射到目标方向。
冻结 Messi 更新
/*****************************************************************
*** KEEP_TARGET ***
******************************************************************/
if (holding_ball &&
fabs(Utils::Normalize(me2target.dir() - me.RawDir())) < PARAM::Math::PI / 3.0)
{
MessiDecision::Instance()->setnoUpdate(true);
}
else
{
MessiDecision::Instance()->setnoUpdate(false);
}这段代码的作用是持球时冻结接球者选择,防止传球目标在射门途中频繁切换。
逻辑:当机器人持球(holding_ball == true)且朝向大致对准目标(角度偏差 < 60°)时,调用 setnoUpdate(true) 告知 MessiDecision 不要重新计算接球者;否则恢复正常更新。
KICK_BALL 模式
/*****************************************************************
*** KICK_BALL ***
******************************************************************/
if (getBallMode == KICK_BALL)
{
targetDir = rot_dir(pVision, runner, target); // me2target.dir();
targetPos = me.Pos();
double diff_dir = fabs(Utils::Normalize(me2target.dir() - me.RawDir()));
CVector car_vel_moudle = Utils::Polar2Vector(
200 * (exp(2.5 * diff_dir / PARAM::Math::PI) - 1), (targetPos - me.RawPos()).dir());
DribbleStatus::Instance()->setDribbleCommand(runner, dribble_power);
setSubTask(
PlayerRole::makeItGoto(runner, targetPos, targetDir, car_vel_moudle, 0, taskFlag));
}这段代码是 KICK_BALL 模式的执行逻辑:机器人已持球,原地旋转对准目标后射门。
具体行为:
计算目标朝向
targetDir:调用rot_dir()获取朝向目标的最优角度,见下文原地不动
targetPos = me.Pos():不需要移动,只需转体瞄准计算旋转辅助速度
car_vel_moudle:
v=200⋅(e2.5⋅∣Δθ/π∣−1)
角度偏差越大,辅助速度越大,帮助机器人快速转向;角度接近0时速度趋近于0,避免过冲
开启吸球
setDribbleCommand:确保持球稳定发送运动指令:机器人原地转向至
targetDir
注意:这个模式下没有触发
KickStatus::setKick(),射门触发逻辑在其后的InTheirPenaltyArea/else分支中处理(根据朝向误差判断是否开踢)。
rot_dir
/**
* @name: rot_dir
* @description:
* 计算机器人持球时应该朝向的方向,在对准射门目标的同时,智能地规避近距离敌方球员的干扰
* @param {CVisionModule} *pVision
* @param {int} vecNumber
* @param {CGeoPoint} target
* @return {*}
*/
double rot_dir(const CVisionModule *pVision, const int vecNumber, CGeoPoint target)
{
const PlayerVisionT &me = pVision->ourPlayer(vecNumber);
const MobileVisionT &ball = pVision->ball();
const PlayerVisionT &bestene =
pVision->theirPlayer(Utils::BestNearEne(ball.Pos(), pVision));
CVector me2target = target - me.RawPos();
CVector me2enemy = bestene.RawPos() - me.RawPos();
double target2enemydiff = Utils::Normalize(me2target.dir() - me2enemy.dir());
double target2mediff = Utils::Normalize(me2target.dir() - me.RawDir());
double enemy2mediff = Utils::Normalize(me2enemy.dir() - me.RawDir());
bool enemyTooClose = me2enemy.mod() < 40 * 10;
bool anti_rot = fabs(enemy2mediff) + fabs(target2enemydiff) <= fabs(target2mediff) + 0.1 &&
enemyTooClose;
// 绕过敌人方向旋转到目标,是否比直接旋转到目标更"顺路"
if (anti_rot && fabs(target2mediff) > 10.0 * PARAM::Math::PI / 180.0)
{ // 绕开敌人旋转,避免在转动中被对方干扰断球
double middle_angle = Utils::Normalize(me2enemy.dir() + PARAM::Math::PI);
return middle_angle;
}
else
{ // 直接返回指向目标方向 me2target.dir(),让机器人正常对准射门目标
return me2target.dir();
}
}这个函数的核心目的是:计算机器人持球时应该朝向的方向,在对准射门目标的同时,智能地规避近距离敌方球员的干扰。
基本信息收集
函数首先从视觉模块获取三个关键角色的信息:自身机器人 me、球 ball、以及距离球最近的敌方球员 bestene。然后计算两个关键向量:
me2target:从自身指向射门目标的向量me2enemy:从自身指向最近敌人的向量
角度差计算
函数计算了三个关键的角度差,均通过 Utils::Normalize 将结果归一化到 [−π,π] 范围内:
target2enemydiff:目标方向与敌人方向之差 —— 描述目标和敌人在我方视角下的相对夹角target2mediff:目标方向与当前朝向之差 —— 描述还需要转多少角度才能对准目标enemy2mediff:敌人方向与当前朝向之差 —— 描述敌人相对于当前朝向的偏差
enemyTooClose 判断敌人是否在 400mm 以内,这是触发防干扰逻辑的距离阈值。
核心逻辑:三角不等式判断
anti_rot = |enemy2mediff| + |target2enemydiff| <= |target2mediff| + 0.1 && enemyTooClose这个条件本质上是在判断:绕过敌人方向旋转到目标,是否比直接旋转到目标更"顺路"。根据角度三角不等式,如果 ∣θenemy−me∣+∣θtarget−enemy∣≤∣θtarget−me∣+0.1,说明敌人方向位于自身朝向和目标方向之间,直接旋转会"穿过"敌人。
最终决策
当 anti_rot 为真且当前与目标的角度偏差大于 10° 时,函数返回敌人反方向(me2enemy.dir() + π),即绕开敌人旋转,避免在转动中被对方干扰断球。否则,直接返回指向目标方向 me2target.dir(),让机器人正常对准射门目标。
射门踢球逻辑
if (Utils::InTheirPenaltyArea(target, 0))
{// 踢球目标点在对方禁区
if((me.RawDir() > leftdir && me.RawDir() < rightdir) /*&& fabs(Utils::Normalize(me.RawDir()-me2target.dir()))<PARAM::Math::PI/18*/)
{// 是否对准球门范围
aim_time++;// 累计瞄准帧数
// 根据最近敌人距离分三档触发射门
if (bestene.Pos().dist(me.RawPos()) > 1000)
{// 敌人距离 > 1000:角度误差 < 4 ° 时射门
dribble_power = 3;
if (fabs(Utils::Normalize(me.RawDir() - me2target.dir())) <
PARAM::Math::PI / 45.0 /*&& me.RawRotVel()<1.5 && me.RawVel().mod()<700*/)
{
KickStatus::Instance()->setKick(runner, 8000);
}
}
else if (bestene.Pos().dist(me.RawPos()) > 500)
{// 敌人距离 500~1000:角度误差 < 5 ° 时射门
dribble_power = 3;
if (fabs(Utils::Normalize(me.RawDir() - me2target.dir())) <
PARAM::Math::PI / 36.0 /*&& me.RawRotVel()<1.5 && me.RawVel().mod()<700*/)
{
KickStatus::Instance()->setKick(runner, 8000);
}
}
else
{// 敌人贴近,直接射门,不等角度对准
dribble_power = 3;
KickStatus::Instance()->setKick(runner, 8000);
}
if (aim_time > 15 && holding_ball)
{// 超时兜底射门
KickStatus::Instance()->setKick(runner, 8000);
}
else if (aim_time > 30)
{// 超时兜底射门
KickStatus::Instance()->setKick(runner, 8000);
}
break_flag = false;
}
else
{// 未对准球门, 重置 aim_time = 0
aim_time = 0;
}
}这段代码是在对方禁区内的射门瞄准与触发逻辑,具体分为以下几部分:
前提条件: target 在对方禁区内(Utils::InTheirPenaltyArea)
瞄准角度判断(leftdir ~ rightdir): 机器人朝向(me.RawDir())是否对准球门范围(左门柱到右门柱之间的角度区间)。
若对准球门(主分支):
aim_time++:累计瞄准帧数- 根据最近敌人距离分三档触发射门:
- 敌人距离 > 1000:角度误差 < 4° 时射门
- 敌人距离 > 500: 角度误差 < 5° 时射门
- 其他(敌人贴近): 直接射门,不等角度对准
- 超时兜底射门:
aim_time > 15且持球:强制射门aim_time > 30:无论如何强制射门
- 清除
break_flag
若未对准球门(else):
- 重置
aim_time = 0
传球踢球逻辑
else
{// 不是准备射门
aim_time = 0;// 重置瞄准计时器
if (fabs(Utils::Normalize(me.RawDir() - me2target.dir())) < PARAM::Math::PI / 18.0 ||
(fabs(Utils::Normalize(me.RawDir() - me2target.dir())) < PARAM::Math::PI / 18.0 &&
(receiver.Pos().dist(target) < 100 || receiver.RawVel().mod() < 700)))
{// 机器人朝向与目标方向的角度偏差 < 10°(PI/18)时,触发传球
if (bestene.Pos().dist(me.RawPos()) > 500)
{
dribble_power = 3;
if (true)
{
power = flatpower(ball, receiver, target, 1000);
KickStatus::Instance()->setKick(runner, power);
}
}
else
{
dribble_power = 3;
power = flatpower(ball, receiver, target, 1000);
KickStatus::Instance()->setKick(runner, power);
}
}
}这段代码是非禁区内的传球射门逻辑:
当目标点不在对方禁区时(else 分支),执行以下操作:
重置瞄准计时器
aim_time = 0判断朝向条件:机器人朝向与目标方向的角度偏差 < 10°(
PI/18)时,触发传球根据最近敌人距离决定是否传球:
- 敌人距离 > 500:进入
if (true)块(无条件执行)计算传球力度并发出传球指令 - 敌人距离 ≤ 500(贴近):同样计算并发出传球指令
两个分支逻辑完全相同,
if (true)是冗余结构,实际上无论敌人远近,只要角度满足条件都会传球。- 敌人距离 > 500:进入
传球力度通过 flatpower(ball, receiver, target, 1000) 计算,根据球、接球者、目标点动态确定平射力度。
球在禁区(WAIT_BALL)
/*****************************************************************
*** WAIT_BALL ***
******************************************************************/
if (getBallMode == WAIT_BALL)
{
if (Utils::InOurPenaltyArea(ballPos, 9 * 10))
{
targetPos = CGeoPoint(0 - 500, 90);
}
if (Utils::InTheirPenaltyArea(ballPos, -PARAM::Field::BALL_SIZE))
{
targetPos = CGeoPoint(0 + 500, 90);
}
targetDir = me2ball.dir();
setSubTask(PlayerRole::makeItGoto(runner, targetPos, targetDir, taskFlag));
}这段是 WAIT_BALL 状态下的等待逻辑,机器人当前无法直接获球,处于等待状态:
根据球的位置决定等待点:
- 球在己方禁区内(扩展 90mm):机器人移动到
(-500, 90),即场地中偏己方半场的位置等待 - 球在对方禁区内(缩进一个球半径):机器人移动到
(+500, 90),即场地中偏对方半场的位置等待 - 否则:保持原有
targetPos(即上一帧的interPoint)
- 球在己方禁区内(扩展 90mm):机器人移动到
朝向始终面向球
targetDir = me2ball.dir()发出移动指令
makeItGoto前往目标等待点并面向球
本质:球在危险区域时,机器人移动到合适的中间位置待命,随时准备接应球,同时始终朝向球保持视野。
抢球 SNATCH_BALL
/*****************************************************************
*** SNATCH_BALL ***
******************************************************************/
if (getBallMode == SNATCH_BALL)
{ // 机器人主动与敌人抢球
if (!avoid_enemy(ball, me, bestene, targetPos) && me.RawPos().dist(ball.Pos()) < 300)
{ // 无需规避敌人且距球较近时
if (me.RawRotVel() < 1.5 &&
fabs(Utils::Normalize((ball.Pos() - me.RawPos()).dir() - me.RawDir())) <
PARAM::Math::PI / 18.0)
{ // 自身旋转速度低 且 朝向对准球(< 10°):直接冲向球心
targetPos = ball.Pos();
targetDir = me2ball.dir();
}
else
{ // 否则:目标为球后方 60mm 处(略微靠近,避免过冲)
targetPos = ball.Pos() + Utils::Polar2Vector(60, ball2me.dir());
targetDir = me2ball.dir();
}
if ((fabs(Utils::Normalize(bestene.Dir() - enemy2ball.dir())) < PARAM::Math::PI / 6.0 &&
enemy2ball.mod() < 135))
{ // 若敌人正持球(敌人朝向对准球方向 < 30° 且距球 < 135mm):目标改为从敌人身后 170mm
// 处插入抢断
targetPos = bestene.Pos() + Utils::Polar2Vector(170, enemy2ball.dir());
}
}
else if (!avoid_enemy(ball, me, bestene, targetPos))
{
targetDir = me2ball.dir();
}
if (me.RawPos().dist(ball.Pos()) > 300)
{ // 离球远
if (fabs(Utils::Normalize((targetPos - me.RawPos()).dir() - me.RawDir())) >
PARAM::Math::PI / 9.0)
{ // 前进方向与当前朝向偏差 > 20°(PI/9):转向目标点
targetDir = (targetPos - me.RawPos()).dir();
}
else
{ // 否则:保持当前朝向,避免频繁转向
targetDir = me.RawDir();
}
}
double goto_dist = (targetPos - me.RawPos()).mod();
double car_vel_mod = (goto_dist - 500) * 2;
//计算到目标点距离 goto_dist,用 (goto_dist - 500) * 2 做变速基础值(近距离时为 0)
car_vel_mod = car_vel_mod < 0 ? 0 : car_vel_mod;
if (not_use_crash_ene || !crash_ene(me, targetPos, pVision))
{ // 若无碰撞风险(not_use_crash_ene 或 !crash_ene):速度 = 基础值 + 700(平滑加速)
car_vel_moudle =
Utils::Polar2Vector(car_vel_mod + 700, (targetPos - me.RawPos()).dir());
}
else
{ // 若有碰撞风险:速度固定为 1400(全速冲撞抢球)
car_vel_moudle = Utils::Polar2Vector(1400, (targetPos - me.RawPos()).dir());
}
setSubTask(
PlayerRole::makeItGoto(runner, targetPos, targetDir, car_vel_moudle, 0, taskFlag));
}这段代码是 SNATCH_BALL(抢球)模式下的运动控制逻辑,分三个层次:
1. 近球阶段(距球 < 300mm)
- 若自身旋转速度低且朝向对准球(< 10°):直接冲向球心
- 否则:目标设为球后方 60mm 处,避免过冲
- 特例:若敌人正持球(朝向偏差 < 30° 且距球 < 135mm),则改为从敌人身后 170mm 处插入抢断
2. 远球阶段(距球 > 300mm)
- 若前进方向与当前朝向偏差 > 20°(PI/9):转向目标点
- 否则:保持当前朝向,避免频繁转向
3. 速度控制
- 计算到目标点距离
goto_dist,用(goto_dist - 500) * 2做变速基础值(近距离时为 0) - 若无碰撞风险(
not_use_crash_ene或!crash_ene):速度 = 基础值 + 700(平滑加速) - 若有碰撞风险:速度固定为 1400(全速冲撞抢球)
最终通过 makeItGoto 下发运动指令。
突破 BREAK_SOLVER
if (getBallMode == BREAK_SOLVER)
{
setSubTask(PlayerRole::makeItZBreak(runner, target, 0, -1, 3, false));
}这段代码是 BREAK_SOLVER 模式的处理逻辑:
当 getBallMode == BREAK_SOLVER 时,机器人会执行抢断/突破动作
调用 ZBreak 让执行者(runner)朝目标点(target)发起突破,参数依次为:
执行者编号、目标点、初始角度偏置 0、无指定接球者 -1、最大速度档位 3、DirectCmd false。
CHASE_KICK 追球取球
if (getBallMode == CHASE_KICK || getBallMode == WAIT_TOUCH || getBallMode == INTER_TOUCH ||
getBallMode == WAIT_RECV || getBallMode == INTER_RECV)
{
/*****************************************************************
*** CHASE_MODULE ***
******************************************************************/
if (getBallMode == CHASE_KICK)
{
get_ball_pos(ball, me, target, targetPos);
if (me2ball.mod() > 1000)
{
if (fabs(Utils::Normalize((targetPos - me.RawPos()).dir() - me.RawDir())) >
PARAM::Math::PI / 6.0)
{
targetDir = (targetPos - me.RawPos()).dir();
}
else
{
targetDir = me.RawDir();
}
}
else
{
targetDir = me2ball.dir();
if (enemy2ball.mod() > 200 && me2ball.mod() < 200 &&
((ball.Vel().mod() < 1000 && ball.Vel().mod() > 400 && me.RawRotVel() > 1.5)))
{
targetPos =
me.RawPos() +
Utils::Polar2Vector(PARAM::Vehicle::V2::PLAYER_CENTER_TO_BALL_CENTER - 30,
ball2me.dir());
}
else
{
targetPos =
ball.Pos() +
Utils::Polar2Vector(PARAM::Vehicle::V2::PLAYER_CENTER_TO_BALL_CENTER - 30,
ball2me.dir());
}
}
}这段代码是 CHASE_KICK 模式下的追球取球逻辑,分两段距离处理:
远距离(me2ball > 1000mm)
- 用
get_ball_pos预测球的目标位置 - 若前进方向与当前朝向偏差 > 30°(π/6),则先转向目标点;否则保持当前朝向直冲,避免频繁摇摆
近距离(me2ball ≤ 1000mm)
- 朝向锁定为面向球(
me2ball.dir()) - 有一个特殊情况:当:
敌人离球较远(>200mm)、
自身已经很近(<200mm)
且球速适中(400~1000mm/s)
并且自身旋转速度较大(>1.5rad/s)
——说明机器人正在快速旋转对准中,此时目标点设为自身位置前方偏移处(防止冲过球);
- 一般情况下目标点设为球的位置前方偏移
PLAYER_CENTER_TO_BALL_CENTER - 30处,即机器人中心到球心的标准距离再退后 30mm,确保球恰好被拨轮捕获而不过冲。
总结:这段逻辑的核心目标是让机器人快速、稳定地冲向球并将球纳入拨轮控制范围,远距离优先对准减少绕路,近距离根据旋转状态动态调整停靠点防止过冲。
// RECEIVE PARAM
CGeoPoint touch_p = touchPos;
CGeoPoint recv_p = projection;
CVector projection2ball = projection - ball.Pos();
/*****************************************************************
*** WAIT_TOUCH ***
******************************************************************/
if (getBallMode == WAIT_TOUCH)
{
targetDir = me2target.dir() + alpha;
getPenaltyTouchPos(pVision, runner, target, touch_p, targetDir, Touch);
targetPos = touch_p;
if (Utils::InTheirPenaltyArea(target, 0))
{
if (fabs(Utils::Normalize(me.RawDir() - targetDir)) < PARAM::Math::PI / 3)
{
KickStatus::Instance()->setKick(runner, 7000);
}
}
else
{
if (fabs(Utils::Normalize(me.RawDir() - targetDir)) < PARAM::Math::PI / 3)
{
power = flatpower(ball, receiver, target, 1000);
KickStatus::Instance()->setKick(runner, power);
}
}
}这段代码是 WAIT_TOUCH 模式下的等待触球逻辑,即球正在滚来、机器人等待拦截并一脚触射的场景:
目标位置计算
targetDir = me2target.dir() + alpha:朝向为"我到目标点方向"加上触球偏转角alpha(alpha是根据来球速度和出球方向用牛顿迭代预算出的反弹修正角),确保球碰到机器人后能偏向目标getPenaltyTouchPos(...)计算最终触球等待点touch_p,并赋给targetPos——机器人移动到这个点等待来球
触球时机判断(角度差 < 60°,即π/3)
- 若目标在对方禁区:直接以固定力度
7000射门(禁区内无需精确传球,优先打门) - 若目标不在禁区(传球):用
flatpower根据接球者位置动态计算合适的传球力度,再触发setKick
总结:机器人在球飞来前提前跑到最佳触球位置,并以预计算的身体朝向等待来球,球到达时直接通过身体反弹将球导向目标,实现"一触即射"或"一触即传"。
INTER_TOUCH 截球
/*****************************************************************
*** INTER_TOUCH ***
******************************************************************/
if (getBallMode == INTER_TOUCH)
{ // 运动中触球,球和机器人都在运动,需要边跑边调整位置去拦截
if (Utils::InTheirPenaltyArea(target, 0) // 目标在对方禁区
&& fabs(Utils::Normalize(projection2ball.dir() - ball.Vel().dir())) <
0.1 // 球的投影方向与球速方向对齐
&& projection2me.mod() < 20) // 机器人已很接近投影点
{ // 直接跑到预计算好的 touchPos(精确触球点),准备一触即射
targetPos = touchPos;
}
else
{
if (fabs(Utils::Normalize(me2ball.dir() - ball.Vel().dir())) <
PARAM::Math::PI / 4.0 || // 机器人到球的方向与球速方向夹角 < 45°
(fabs(Utils::Normalize(me2ball.dir() - ball.Vel().dir())) <
PARAM::Math::PI / 18.0 * 10 &&
me2ball.mod() <= 40 * 10)) // 或夹角较小且距球 ≤ 400mm
{ // 机器人正处于球飞行路径的"正面",容易被球冲到导致误触
// 跑到球的侧面,避开球的正面轨迹后再找触球角度
targetPos = interPoint +
(projection2me / (projection2me.mod())) * 40 * 10; //跑到球的侧面
}
else
{ // 目标为 interPoint 后退一个机器人半径距离,留出身体空间,避免跑过头
targetPos = interPoint +
Utils::Polar2Vector(
-PARAM::Vehicle::V2::PLAYER_CENTER_TO_BALL_CENTER, targetDir);
}
}
targetDir = me2target.dir() + alpha; // 带反弹修正角
if (Utils::InTheirPenaltyArea(target, 0))
{ // 对方禁区内:固定力度 7000 射门
if (fabs(Utils::Normalize(me.RawDir() - targetDir)) < PARAM::Math::PI / 3)
{
KickStatus::Instance()->setKick(runner, 7000);
}
}
else
{ // flatpower 动态计算传球力度
if (fabs(Utils::Normalize(me.RawDir() - targetDir)) < PARAM::Math::PI / 3)
{
power = flatpower(ball, receiver, target, 1000);
KickStatus::Instance()->setKick(runner, power);
}
}
}这段代码是 INTER_TOUCH 模式下的运动中触球逻辑,与 WAIT_TOUCH(原地等待)的区别是:球和机器人都在运动,需要边跑边调整位置去拦截。
目标位置计算(三种情况)
情况1:目标在对方禁区 + 球的投影方向与球速方向对齐(误差 < 0.1rad)+ 机器人已很接近投影点(< 20mm) → 直接跑到预计算好的 touchPos(精确触球点),准备一触即射
情况2:机器人到球的方向与球速方向夹角 < 45°(π/4),或夹角较小且距球 ≤ 400mm → 说明机器人正处于球飞行路径的"正面",容易被球冲到导致误触; 目标改为 interPoint + projection2me方向 * 400,即跑到球的侧面,避开球的正面轨迹后再找触球角度
情况3:其余情况 → 目标为 interPoint 后退一个机器人半径距离,留出身体空间,避免跑过头
触球触发(同 WAIT_TOUCH)
targetDir = me2target.dir() + alpha(带反弹修正角)- 对方禁区内:固定力度 7000 射门
- 其他情况:
flatpower动态计算传球力度
总结:INTER_TOUCH 的核心是在球运动过程中动态调整跑位——避免被球直接冲撞,从侧面切入到最佳触球点,同时保持身体朝向已对准出球方向,球到达即触射。
WAIT_RECV 等待接球
/*****************************************************************
*** WAIT_RECV ***
******************************************************************/
if (getBallMode == WAIT_RECV)
{
targetDir =
me2ball.dir(); // 朝向始终面向球(接球模式下不需要预判反弹角,直接对准来球方向)
getPenaltyTouchPos(pVision, runner, target, recv_p, targetDir, Receive);
// 以 Receive 模式计算等待位置 recv_p——与 WAIT_TOUCH 中传入 Touch 模式不同,Receive
// 模式会计算适合停球控球的位置,而非触射偏转位置
targetPos = recv_p;
}这段代码是 WAIT_RECV 模式下的等待接球逻辑,非常简洁,只做三件事:
targetDir = me2ball.dir():朝向始终面向球(接球模式下不需要预判反弹角,直接对准来球方向)getPenaltyTouchPos(..., Receive):以Receive模式计算等待位置recv_p——与WAIT_TOUCH中传入Touch模式不同,Receive模式会计算适合停球控球的位置,而非触射偏转位置targetPos = recv_p:机器人移动到该接球等待点
与 WAIT_TOUCH 的对比:
| WAIT_TOUCH | WAIT_RECV | |
|---|---|---|
| 目标方向 | me2target.dir() + alpha(带反弹修正) | me2ball.dir()(直接面球) |
| 位置计算模式 | Touch(触射偏转点) | Receive(停球控球点) |
| 是否触发射门/传球 | 是 | 否(只移位等待) |
总结:WAIT_RECV 是纯跑位逻辑——球静止或缓慢滚来,机器人提前跑到最佳接球点,朝向正对来球,准备将球停下控住,不触发任何射门/传球指令。
getPenaltyTouchPos
/**
* @name: getPenaltyTouchPos
* @description: 计算球进入对方禁区时,机器人应该跑到的触球/接球等待点
* @return {*}
*/
bool getPenaltyTouchPos(const CVisionModule *pVision, const int vecNumber, CGeoPoint target,
CGeoPoint &Touch_Pos, double targetDir, int mode)
{
// 用球速方向作射线,与禁区矩形求交点(最多两个),选离机器人更近的那个交点作为候选等待位置。
const PlayerVisionT &me = pVision->ourPlayer(vecNumber);
const MobileVisionT &ball = pVision->ball();
//禁区这个长方形
CGeoRectangle rec(LEFT_PENALTY_TOP, RIGHT_PENALTY_DOWN);
CGeoLine ballLine(ball.Pos(), ball.Vel().dir());
CGeoLineRectangleIntersection Intersection(ballLine, rec);
CVector touchPoint2target1 = target - Intersection.point1();
CVector touchPoint2target2 = target - Intersection.point2();
// 构建禁区矩形:用 LEFT_PENALTY_TOP 和 RIGHT_PENALTY_DOWN 定义禁区边界,与球速射线求交点
// point1 / point2
double touchAnglediff1 =
fabs(Utils::Normalize(touchPoint2target1.dir() - ball.Vel().dir() + PARAM::Math::PI));
double touchAnglediff2 =
fabs(Utils::Normalize(touchPoint2target2.dir() - ball.Vel().dir() + PARAM::Math::PI));
bool can_touch1 = touchAnglediff1 < TOUCH_ANGLE * PARAM::Math::PI / 180.0;
bool can_touch2 = touchAnglediff2 < TOUCH_ANGLE * PARAM::Math::PI / 180.0;
//车本身垂足点
if (Intersection.intersectant())
{
if (me.RawPos().dist(Intersection.point1()) < me.RawPos().dist(Intersection.point2()))
{ // 选机器人距离更近的交点,对立的判断分支和这里步骤相同,是 point2 的情况
CVector ball2intersection = Intersection.point1() - ball.Pos();
if (Intersection.point1().x() < PARAM::Field::PITCH_LENGTH / 2 - 50 &&
// 交点不能太靠近球门线
fabs(Utils::Normalize(ball2intersection.dir() - ball.Vel().dir())) < 0.1)
// 球→交点方向与球速方向基本一致,说明球确实是朝这个点飞去的
{
if (me.RawPos().dist(Intersection.point1()) < 100 * 10 &&
ball.Pos().dist(Intersection.point1()) > 30 * 10)
{ // 机器人到交点距离 < 1000mm(能赶得到)
// 且球到交点距离 > 300mm(球还没到,有时间准备)
if (mode == Receive)
Touch_Pos = Intersection.point1();
// Receive 模式:直接站在交点上(停球控球)
else if (can_touch1)
// Touch 模式:先检查触球角度是否 < 70°(can_touch),
// 若可以,站在交点退后一个机器人半径的位置(留出身体空间,让球恰好触到拨轮)
Touch_Pos =
Intersection.point1() +
Utils::Polar2Vector(
-PARAM::Vehicle::V2::PLAYER_CENTER_TO_BALL_CENTER, targetDir);
}
return true;
} // true 表示计算成功(球线确实穿过禁区且条件满足),
// false 表示无有效交点或条件不满足,调用方保持原有 targetPos 不变
else
return false;
}
else
{
CVector ball2intersection = Intersection.point2() - ball.Pos();
if (Intersection.point2().x() < PARAM::Field::PITCH_LENGTH / 2 - 50 &&
fabs(Utils::Normalize(ball2intersection.dir() - ball.Vel().dir())) < 0.1)
{
if (me.RawPos().dist(Intersection.point2()) < 100 * 10 &&
ball.Pos().dist(Intersection.point1()) > 30 * 10)
{
if (mode == Receive)
Touch_Pos = Intersection.point2();
else if (can_touch2)
Touch_Pos =
Intersection.point2() +
Utils::Polar2Vector(
-PARAM::Vehicle::V2::PLAYER_CENTER_TO_BALL_CENTER, targetDir);
}
return true;
}
else
return false;
}
}
else
return false;
}这个函数 getPenaltyTouchPos 的作用是:计算球进入对方禁区时,机器人应该跑到的触球/接球等待点。
整体思路
用球速方向作射线,与禁区矩形求交点(最多两个),选离机器人更近的那个交点作为候选等待位置。
详细步骤
构建禁区矩形:用
LEFT_PENALTY_TOP和RIGHT_PENALTY_DOWN定义禁区边界,与球速射线求交点point1/point2选近点:选机器人距离更近的交点(
point1或point2)有效性校验(三个条件需同时满足):
- 交点不能太靠近球门线(
x < PITCH_LENGTH/2 - 50),避免站进球门里 - 球→交点方向与球速方向基本一致(误差 < 0.1 rad),说明球确实是朝这个点飞去的
- 机器人到交点距离 < 1000mm(能赶得到)且球到交点距离 > 300mm(球还没到,有时间准备)
- 交点不能太靠近球门线(
根据
mode写入不同位置:Receive模式:直接站在交点上(停球控球)Touch模式:先检查触球角度是否 < 70°(can_touch),若可以,站在交点退后一个机器人半径的位置(留出身体空间,让球恰好触到拨轮)
返回值:
true表示计算成功(球线确实穿过禁区且条件满足),false表示无有效交点或条件不满足,调用方保持原有targetPos不变。
crash_ene
/**
* @name: crash_ene
* @description: 检测我方机器人前进路径上是否存在碰撞风险的敌方球员
* @return {*}
*/
bool CZAttackV2::crash_ene(const PlayerVisionT &me, CGeoPoint &target_pos,
const CVisionModule *pVision)
{
CGeoSegment me2targetpos_l(me.RawPos(), target_pos);
double me2crash_dist = 999999;
if (me.RawPos().dist(target_pos) < 500)
{ // 若机器人距目标点 < 500mm,认为不需要碰撞检测,直接返回 false
return false;
}
for (int i = 0; i < PARAM::Field::MAX_PLAYER; i++)
{
if (pVision->theirPlayer(i).Valid())
{
CGeoPoint ene_prj = me2targetpos_l.projection(pVision->theirPlayer(i).Pos());
// 计算该敌方球员在"我 → 目标点"线段上的投影点 ene_prj
double dist = ene_prj.dist(pVision->theirPlayer(i).Pos());
// 投影点与敌方球员的垂直距离 dist
if (me2crash_dist < ene_prj.dist(me.RawPos()))
{ // 只取最近的威胁
continue;
}
if (me.Vel().mod() > 1500 &&
// 我方速度 > 1500 mm/s(高速移动中)
(me.RawPos().dist(pVision->theirPlayer(i).Pos()) < 2000 &&
// 我方与该敌方距离 < 2000mm
me2targetpos_l.IsPointOnLineOnSegment(ene_prj) && dist < 300))
// 投影点落在线段范围内(敌方确实挡在路上)
// 投影点距敌方 < 300mm(敌方足够靠近路径中线)
{// 满足条件则将 target_pos 修改为投影点,记录该距离为最近碰撞距离
target_pos = ene_prj;
me2crash_dist = ene_prj.dist(me.RawPos());
}
}
}
if (me2crash_dist < 999999)
{// 若找到碰撞威胁返回 true,否则返回 false。
return true;
}
return false;
}正在优化工具选择...crash_ene 函数用于检测我方机器人前进路径上是否存在碰撞风险的敌方球员,并在有风险时修改目标点。
具体逻辑:
早退条件:若机器人距目标点 < 500mm,认为不需要碰撞检测,直接返回
false。遍历所有敌方球员,对每个有效敌方球员:
- 计算该敌方球员在"我 → 目标点"线段上的投影点
ene_prj - 计算投影点与敌方球员的垂直距离
dist - 跳过条件:如果该投影点比当前已记录的最近碰撞点还远,跳过(只取最近的威胁)
- 碰撞判定:同时满足以下条件时,认为存在碰撞风险:
- 我方速度 > 1500 mm/s(高速移动中)
- 我方与该敌方距离 < 2000mm
- 投影点落在线段范围内(敌方确实挡在路上)
- 投影点距敌方 < 300mm(敌方足够靠近路径中线)
- 满足条件则将
target_pos修改为投影点,记录该距离为最近碰撞距离
- 计算该敌方球员在"我 → 目标点"线段上的投影点
返回值:若找到碰撞威胁返回
true,否则返回false。
使用场景:调用方(SNATCH_BALL 和 CHASE_KICK 等模式)根据返回值决定速度策略——有碰撞风险时以固定高速(1400)冲向敌人位置,实现有意冲撞而非绕避。