ZCrosserover
约 14872 字
概述
ZCrosserover 是一个机器人足球中的"过人/交叉传球"技能,核心逻辑分为两大部分:
- 初始化与感知计算 (
plan()函数):实时采集视觉数据,计算关键几何关系,检测敌人持球状态,预判球路抢断。 - 状态机裁决 (
judgeState()函数):根据场上态势决定机器人当前应处的状态,实现接球、触球、追球、突破等行为的智能切换。
本文档详细解析 ZCrosserover 的代码实现与决策逻辑。
初始化:plan() 函数
ZCrosserover::plan() 函数完成环境的感知与关键参数的准备,是技能执行的基础。
1. 基本参数读取
int runner = task().executor;
bool is_blackCar = false;
ZSS::ZParamManager::instance()->loadParam(is_blackCar, ...);- runner:当前执行该技能的机器人编号。
- is_blackCar:从参数配置中读取该机器人是否为"黑车"(不同型号机器人的硬件差异标记)。
2. 视觉数据采集
_ball = pVision->ball();
_me = pVision->ourPlayer(runner);
_receiver = pVision->ourPlayer(MessiDecision::Instance()->receiverNum());
_bestene = MessiDecision::Instance()->EnemyInfo().enemy[ene_idx];- 从视觉模块获取球、自身、接球队友、最近敌人的实时状态。
ene_idx通过MessiDecision(决策模块)的enemy2Me索引排序选出离自己最近的敌人。
3. 目标位置计算
target = judbestshootpos(target);
if (state == WAIT_TOUCH && me.RawPos().dist(ball.Pos()) < 1000)
target = last_Point;
else
last_Point = target = judbestshootpos(target);- 调用
judbestshootpos()计算最佳射门/传球目标点。 - 当处于
WAIT_TOUCH(等待触球)状态且机器人距球 < 1000mm 时,冻结目标点防止抖动。
4. 关键向量计算
const CVector me2ball = ballPos - me.RawPos();
CVector me2target = target - me.RawPos();
CVector ball2target = target - ball.Pos();
const CVector enemy2ball = ball.Pos() - bestene.RawPos();计算一组空间向量,为后续几何判断提供基础:
| 向量 | 含义 |
|---|---|
me2ball | 自身到球 |
me2target | 自身到目标 |
ball2target | 球到目标 |
enemy2me | 自身到最近敌人 |
enemy2ball | 最近敌人到球 |
5. 几何结构构建
CGeoLine ballVelLine(ballPos, ballVelDir);
CGeoSegment me2targetseg(me.RawPos(), target);
CGeoSegment front_seg(...); // 球门前沿线段构建用于碰撞检测、投影计算的几何对象,包括:
- 球的速度延长线 (
ballVelLine) - 自身到目标的线段
- 球场前端线段
6. 触球位置计算
CGeoPoint touchPos = ballline.projection(...) + Utils::Polar2Vector(...);计算理想触球点:将机器人中心投影到球运动线上,再偏移一个机器人到球心的距离,得到让机器人能够刚好触到球的位置。
7. 球线截取点计算
ballLineProjection = ballVelLine.projection(mousePos);
CVector ball2Projection = ballLineProjection - ball.Pos();计算机器人"嘴部"(mousePos = 机器人中心 + 朝向偏移)在球速线上的投影点,用于判断机器人是否对准了球的来向。
8. 持球检测与截球点更新
_holding_ball = Utils::isBallInFace(pVision, runner, ...);
interTime = ZSkillUtils::instance()->getOurInterTime(runner);
interPoint = ZSkillUtils::instance()->getOurInterPoint(runner);
if (ballVelMod > 500)
interPoint = interPoint + Utils::Polar2Vector(500, ballVelDir); // 超前预判
if (interPoint.dist(lastInterPoint) < 500 && me2ball.mod() > 1000)
interPoint = lastInterPoint; // 稳定滤波- 检测机器人是否正在持球。
- 获取预测截球时间和截球点。
- 若球速较快(> 500 mm/s),截球点沿球速方向前移 500mm(超前量补偿)。
- 截球点变化不大且离球较远时,保持上一帧截球点(防止抖动)。
9. 持球状态影响决策更新
if (_holding_ball)
MessiDecision::Instance()->setnoUpdate(true); // 持球时冻结决策更新
else
MessiDecision::Instance()->setnoUpdate(false);持球时暂停决策模块的接球者/目标更新,避免持球过程中目标跳变。
10. 敌人持球检测
enemy_dribble = 0;
if (enemy2ball.mod() < 500 &&
fabs(Utils::Normalize(enemy2ball.dir() - bestene.Dir())) < PI / 3)触发条件:最近敌人距球 < 500mm,且敌人朝向与"敌人→球"方向的夹角 < 60°(说明敌人正朝着球的方向)。
满足后分两种子情况:
子情况 A:敌人接近但未完全控球(enemy2ball.mod() > 200)
ballPos = bestene.Pos() + Utils::Polar2Vector(enemy2ball.mod(), bestene.Dir());视觉可能丢失球(被机器人遮挡),用敌人位置 + 敌人朝向 + 原始距离重建球的估计位置,修正 ballPos。
子情况 B:敌人几乎完全控球(enemy2ball.mod() <= 200)
if (!ball.Valid())
{
ballPos = bestene.Pos() + Utils::Polar2Vector(
PARAM::Vehicle::V2::PLAYER_CENTER_TO_BALL_CENTER + 90, bestene.Dir());
}
enemy_dribble = 1;- 若摄像头完全丢球(
!ball.Valid()):将球位置估计为敌人机器人嘴部前方(PLAYER_CENTER_TO_BALL_CENTER + 90mm)。 - 无论球是否可见,设
enemy_dribble = 1,标记敌人正在带球,后续逻辑会据此切换追球策略。
11. 预判球路抢断
触发前提:
if (!enemy_dribble && fabs(Utils::Normalize(me2ball.dir() - ballVelDir)) > 70 * PI / 180)- 敌人没有带球。
- 机器人自身方向与球速方向夹角 > 70°(说明球不是朝着自己飞来,自己不在球的主路径上)。
构建球的滚动轨迹线段
CGeoSegment ball2tarSeg(
ballPos + Utils::Polar2Vector(2 * ballVelMod * ballVelMod / FRICTION, ballVelDir),
ballPos);利用运动学公式 v2=2as,即 s=2av2,但这里写的是 2v2/a(系数为2,可能是该物理环境下的经验值),计算球从当前位置到完全停止的轨迹线段。
找最可能截球的敌人
int ene_prj_idx = MessiDecision::Instance()
->indicesMap()[MessiDecision::Instance()->enemy2ballLinePrjDist][0];
PlayerVisionT bestenePrj = ...; // 距球运动线投影最近的敌人
CGeoPoint eneInterPos = ball2tarSeg.projection(bestenePrj.RawPos()); // 该敌人在球路上的投影点enemy2ballLinePrjDist 是按"到球速线距离"排序的敌人索引,取第 0 个即最可能拦截球的敌人。
判断是否需要抢断,并计算抢断位置
if (!Utils::InTheirPenaltyArea(me.RawPos(), 600) && // 自己不在禁区内
eneInterPos.dist(bestenePrj.RawPos()) < 600 && // 敌人距投影点 <600mm(敌人能到达)
ball2tarSeg.IsPointOnLineOnSegment(eneInterPos) && // 投影点在球的滚动轨迹上
eneInterPos.dist(ballPos) < interPoint.dist(ballPos) + 200 && // 敌人比我们更早能截到球
eneInterPos.dist(ballPos) > 200) // 排除球刚出脚的瞬间
{
need_grab = 1;
need_grabPos = eneInterPos + Utils::Polar2Vector(
PARAM::Vehicle::V2::PLAYER_CENTER_TO_BALL_CENTER * 2,
(ball.Pos() - eneInterPos).dir());
}五个条件全部满足时,标记 need_grab = 1,并计算抢断目标位置:在敌人截球点沿"球→截球点"反方向偏移 2×机器人半径,即抢在敌人前面守住那个位置。
状态机裁决:judgeState() 函数
judgeState() 是整个技能的状态机裁决函数,每帧调用一次,根据当前场上态势决定机器人应该处于哪个状态。
第一部分:预计算各判断标志
基础物理量
double roll_dist = ballVelMod * ballVelMod / FRICTION; // 球的滚动距离 s=v²/a
CGeoPoint ballstop_pos = ballPos + Utils::Polar2Vector(roll_dist, ballveldir); // 球停止点用运动学公式 s=v2/a 预测球会停在哪里。
禁区相关标志
| 标志 | 含义 |
|---|---|
penalty_recv | 自己已在对方禁区附近(11× 机器人尺寸范围内) |
recvinpenalty | 接球点在禁区内,但投影点不在禁区内(需要在禁区边缘接球) |
核心判断标志
is_recv(应该接球而非触球)
double touchAnglediff = fabs(Normalize(touchPoint2target.dir() - ballveldir + PI));
bool is_recv = touchAnglediff > TOUCH_ANGLE * PI / 180.0; // >70°用投影点→目标方向与球速方向的夹角判断:
- 夹角 > 70°:球来的方向和目标方向差太多,需要先接住球再处理(
RECV模式) - 夹角 ≤ 70°:可以直接顺势触球弹射到目标(
TOUCH模式)
can_recv(投影点对正了球的来向)
bool can_recv = fabs(Normalize(proj2balldir - ballveldir)) < 0.1;自身在球速线上的投影点,到球的方向与球速方向夹角 < 0.1 rad(约 5.7°),说明机器人已经对准了球路。
need_recvortouch(需要截球/触球的总开关)
bool need_recvortouch = !_holding_ball // 没持球
&& ballVelMod > 500 // 球在快速运动
&& fabs(ball2me.dir() - ballveldir) < PI/2; // 球大致朝向自己飞来(<90°)use_waittouch(可以用等待触球模式)
bool use_waittouch =
proj2stop与ballveldir平行(投影点在球停止前的路径上)
&& (球离投影点足够远 OR 球和我都很近投影点)
&& 投影点不在对方禁区综合判断投影点是否是一个合理的"等待触球"位置。
meinBallLine(自己已经在球速线上)
bool meinBallLine =
(proj2balldir ≈ ballveldir && proj2me.mod() < 90) // 投影点到我距离很小
|| 自己在禁区内cangoproj(可以直接冲到投影点)
bool cangoproj =
投影点对正球方向
&& (自己极近投影点 OR 在禁区内且较近)
&& 投影点不在对方禁区
&& (接球点在禁区内 OR 截球点也在球速线上)是最严格的"可以立刻去接球"条件,满足时跳过 _interlock 防抖。
第二部分:最高优先级——GET_BALL
if (last_state != WAIT_TOUCH
&& ball2me.mod() < bestene.dist(ballPos) - 300 // 我比最近敌人更靠近球300mm以上
&& (球速慢 OR (球接近停止且球就在截球点附近))
&& !_holding_ball
&& ballPos.dist(me.Pos()) < 500) // 球就在脚边500mm内
→ GET_BALL球几乎静止且就在脚边,且我比敌人更近:直接拿球,最高优先级,立即返回。
第三部分:截球/触球状态分支
进入条件(必须全部满足):
!enemy_dribble:敌人没带球!need_grab:不需要去抢断球路need_recvortouch:球在飞且朝向我- 截球点离去够近(
< 1500mm),或自己已经极近投影点
进入后,根据 is_recv 分两路:
路径A:is_recv = true(接球模式)
可以直接去投影点?(penalty_recv && recvinpenalty && !_interlock) || cangoproj
├─ 是 → WAIT_RECV(站在接球点等球)
└─ 否 → INTER_RECV(跑向截球点侧面,绕开球路线再接)
_interlock = !meinBallLine(已在球路线上则解锁)路径B:is_recv = false(触球模式)
可以直接等待触球?(can_recv && use_waittouch && !_interlock) || cangoproj
├─ 是 → WAIT_TOUCH(站在触球点等球飞来直接弹射)
└─ 否 → INTER_TOUCH(移动到合适触球角度,边跑边等)
_interlock = !meinBallLine_interlock 是防止机器人在球速线上来回横穿的互锁机制:一旦发现自己不在球路线上就加锁,必须等到对准了才解锁,避免"反复横跳"。
第四部分:兜底状态
以上所有截球条件不满足:
!_holding_ball → CHASE_BALL(追球)
_holding_ball → BREAK(持球突破)
else → NOTHING(待机)状态转移图
以下为 judgeState() 函数的状态转移逻辑,使用 Mermaid 流程图表示:
继续初始化
static int break_time = 0;
break_time = this->state == BREAK ? break_time + 1 : 0;
// 用静态变量逐帧累计处于 BREAK(持球突破)状态的帧数,其他状态时归零。
// 后续 BREAK 分支用它判断是否持球超时,超时后触发换方向逻辑。
TaskT wait_task(task());
wait_task.player.rotate_acc = 0;
// RECEIVE PARAM
CGeoPoint touch_p = touchPos; // 触球点(球速线上的理想接触位置)
CGeoPoint recv_p = projection; // 接球点(球速线上机器人的投影点)
CVector projection2ball = projection - ball.Pos();
double inVel; //球的末速度
// 球到达时的末速度计算
// 计算球滚到机器人位置时剩余的速度 inVel,若已经滚不到就直接用当前球速。
// 这个值用于后面的触球偏转角计算。
if (ball.Vel().mod2() > FRICTION * me2ball.mod())
inVel = sqrt(ball.Vel().mod2() - FRICTION * me2ball.mod());
else
inVel = ball.Vel().mod();
// 机器人触球时需要朝哪个方向,才能让球弹射到目标点。
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);
}
// 这是一个碰撞物理模型的隐式方程,用牛顿法迭代求根:
// 将碰撞分解为法向(垂直机器人面)和切向(平行机器人面)两个分量,
// 通过调整机器人朝向 α,使合成出球方向恰好指向目标。迭代5次收敛即得到精确解。
_taskFlag |= PlayerStatus::NOT_AVOID_THEIR_VEHICLE;
// _taskFlag|=PlayerStatus::NOT_AVOID_PENALTY;
if (me2ball.mod() < 1500)
{
_taskFlag |= PlayerStatus::NOT_AVOID_OUR_VEHICLE;
}
// 进攻时关闭机器人碰撞绕路,允许顶住敌人/穿过队友直接冲向球,
// 避免运动规划器为了绕开障碍而绕路导致错过截球时机。这段代码完成三件事:BREAK状态计时、球到达时的末速度计算、触球偏转角求解(牛顿迭代),以及碰撞避让标志设置。
1. BREAK 状态计时器(490~491行)
static int break_time = 0;
break_time = this->state == BREAK ? break_time + 1 : 0;用静态变量逐帧累计处于 BREAK(持球突破)状态的帧数,其他状态时归零。后续 BREAK 分支用它判断是否持球超时,超时后触发换方向逻辑。
2. 任务与接触点初始化(492~498行)
TaskT wait_task(task()); // 复制当前任务作为本帧执行任务
wait_task.player.rotate_acc = 0;
CGeoPoint touch_p = touchPos; // 触球点(球速线上的理想接触位置)
CGeoPoint recv_p = projection; // 接球点(球速线上机器人的投影点)
CVector projection2ball = projection - ball.Pos();为后续各 case 分支提供可修改的任务副本和初始位置值。
3. 球到达时的末速度计算(499~503行)
if (ball.Vel().mod2() > FRICTION * me2ball.mod())
inVel = sqrt(ball.Vel().mod2() - FRICTION * me2ball.mod());
else
inVel = ball.Vel().mod();用运动学公式 v2=v02−2a⋅s,即:
vin=v02−μ⋅d
其中 μ 为摩擦系数(FRICTION),d 为机器人到球的距离(me2ball.mod())。
计算球滚到机器人位置时剩余的速度 inVel,若已经滚不到就直接用当前球速。这个值用于后面的触球偏转角计算。
4. 触球偏转角求解——牛顿迭代法(504~519行)
这是整段代码的核心,用于计算机器人触球时需要朝哪个方向,才能让球弹射到目标点。
beta:入射角与目标角的关系
double beta = Utils::Normalize(
ball.Vel().dir() + PI - (target - me.RawPos()).dir()
);β=球速反方向−我到目标方向
即:球来的方向(反向)与"我要把球打去的方向"之间的夹角。
alpha:机器人朝向偏转量(牛顿迭代求解)
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);
}这是一个碰撞物理模型的隐式方程,用牛顿法迭代求根:
f(α)=Psinα+knvinsinαcos(β−α)−ktvincosαsin(β−α)=0
其中:
| 符号 | 含义 |
|---|---|
| α | 机器人朝向相对于目标方向的偏转角(待求) |
| β | 球来向与目标方向的夹角 |
| P | 击球力度(power) |
| vin | 球到达时的速度 |
| kn=0.3 | 法向碰撞恢复系数(弹性分量) |
| kt=0.6 | 切向摩擦系数(滑动分量) |
物理意义:将碰撞分解为法向(垂直机器人面)和切向(平行机器人面)两个分量,通过调整机器人朝向 α,使合成出球方向恰好指向目标。迭代5次收敛即得到精确解。
5. 碰撞避让标志设置(520~523行)
_taskFlag |= PlayerStatus::NOT_AVOID_THEIR_VEHICLE; // 永远不躲避敌方机器人
if (me2ball.mod() < 1500)
_taskFlag |= PlayerStatus::NOT_AVOID_OUR_VEHICLE; // 距球<1500mm时不躲避友方机器人进攻时关闭机器人碰撞绕路,允许顶住敌人/穿过队友直接冲向球,避免运动规划器为了绕开障碍而绕路导致错过截球时机。
从这里开始,就是状态机部分
WAIT_TASK
switch (this->state)
{
case WAIT_TASK:
{ // 球在禁区里面,等 Goalie 清球
// 此部分在 judge_state 的里面被注释掉了,不会进这个状态
aim_time = 0;
// 此时不需要进行瞄准计时
if (Utils::InOurPenaltyArea(ballPos, 9 * 10))
{ // 若球在己方禁区附近(扩展 90mm 的缓冲范围),
// 将机器人目标位置设为 (-500, 90),即己方半场中部偏左的安全位置,
// 避免机器人进入己方禁区。
targetPos = CGeoPoint(0 - 500, 90);
}
if (Utils::InTheirPenaltyArea(ballPos, -PARAM::Field::BALL_SIZE))
{ // 若球在对方禁区内部(收缩一个球半径,确保球已完全入禁区),
// 将目标位置设为 (1000, -1500),即对方半场边缘等待区。
// 这是为了绕开对方禁区规则限制(比赛规则不允许攻方机器人进入对方禁区)。
targetPos = CGeoPoint(1000, -1500);
}
targetDir = me2ball.dir();
break;
}这段代码是状态机 switch 块中的 WAIT_TASK 分支,处理机器人"等待任务"状态下的位置和朝向决策。
逐行解析
case WAIT_TASK:
{
aim_time = 0;进入等待任务状态时,将瞄准计时器 aim_time 归零,说明此时不需要进行瞄准倒计时。
if (Utils::InOurPenaltyArea(ballPos, 9 * 10))
{
targetPos = CGeoPoint(0 - 500, 90);
}若球在己方禁区附近(扩展 90mm 的缓冲范围),将机器人目标位置设为 (-500, 90),即己方半场中部偏左的安全位置,避免机器人进入己方禁区干扰守门员。
if (Utils::InTheirPenaltyArea(ballPos, -PARAM::Field::BALL_SIZE))
{
targetPos = CGeoPoint(1000, -1500);
}若球在对方禁区内部(收缩一个球半径,确保球已完全入禁区),将目标位置设为 (1000, -1500),即对方半场边缘等待区。这是为了绕开对方禁区规则限制(比赛规则不允许攻方机器人进入对方禁区)。
注意:两个
if是独立判断,若两个条件都满足(理论上不可能同时成立),后者会覆盖前者。
targetDir = me2ball.dir();
break;
}无论上面哪种情况,机器人的朝向都始终对准球(me2ball.dir() = 机器人到球的方向),保持视野跟踪,随时准备响应任务切换。
WAIT_TOUCH
case WAIT_TOUCH:
{
targetDir = me2target.dir() + alpha;
// me2target.dir() 是机器人指向目标点的方向
// alpha 是之前通过牛顿迭代求出的触球偏转角(碰撞物理补偿)
// 两者叠加,得到机器人触球时应朝向的精确角度,保证触球后球能弹射到目标点
getPenaltyTouchPos(target, touch_p, targetDir, Touch);
// 修正触球位置(禁区边界处理)
// 调用 getPenaltyTouchPos 计算禁区边缘的触球点
// 若球路穿过禁区,将触球点修正到禁区外边界处,避免机器人冲入禁区犯规
// 机器人目标位置设为修正后的 touch_p
targetPos = touch_p;
if (Utils::InTheirPenaltyArea(target, 0))
{ // 目标在禁区内 → 认为是射门
if (fabs(Utils::Normalize(me.RawDir() - targetDir)) < PARAM::Math::PI / 3)
{ // 朝向误差 < 60°(π/3)时触发踢球,力度固定 7000
// 较宽松的角度容忍,抢时机射门
KickStatus::Instance()->setKick(runner, 7000.0);
// KickStatus::Instance()->setChipKick(runner,power);
}
}
else
{ // 传球/横传场景
if (fabs(Utils::Normalize(me.RawDir() - targetDir)) < PARAM::Math::PI / 1.5)
{ // 朝向误差 < 120°(π/1.5)时触发,允许更大的角度偏差(来不及对准也要传)
// 踢球力度由 flatpower() 动态计算
//(根据接球者位置、距离、到达时间),再乘 1.5 倍做补偿)
power = flatpower(ball, receiver, target, 1000) * 1.5;
KickStatus::Instance()->setKick(runner, power);
// KickStatus::Instance()->setChipKick(runner,power);
}
}
break;
}这段代码是状态机中的 WAIT_TOUCH 分支,处理机器人原地等待来球并直接弹射(一脚触球) 的执行逻辑。
逐步解析
1. 计算机器人目标朝向
targetDir = me2target.dir() + alpha;me2target.dir()是机器人指向目标点的方向alpha是之前通过牛顿迭代求出的触球偏转角(碰撞物理补偿)- 两者叠加,得到机器人触球时应朝向的精确角度,保证触球后球能弹射到目标点
2. 修正触球位置(禁区边界处理)
getPenaltyTouchPos(target, touch_p, targetDir, Touch);
targetPos = touch_p;- 调用
getPenaltyTouchPos计算禁区边缘的触球点 - 若球路穿过禁区,将触球点修正到禁区外边界处,避免机器人冲入禁区犯规
- 机器人目标位置设为修正后的
touch_p
3. 触发踢球指令(分两种场景)
场景 A:目标点在对方禁区内(直接射门场景)
if (Utils::InTheirPenaltyArea(target, 0))
{
if (fabs(Utils::Normalize(me.RawDir() - targetDir)) < PARAM::Math::PI / 3)
{
KickStatus::Instance()->setKick(runner, 7000.0);
}
}- 目标在禁区内 → 认为是射门
- 朝向误差 < 60°(
π/3)时触发踢球,力度固定 7000(较宽松的角度容忍,抢时机射门)
场景 B:目标点不在禁区(传球/横传场景)
else
{
if (fabs(Utils::Normalize(me.RawDir() - targetDir)) < PARAM::Math::PI / 1.5)
{
power = flatpower(ball, receiver, target, 1000) * 1.5;
KickStatus::Instance()->setKick(runner, power);
}
}- 目标不在禁区 → 认为是传球
- 朝向误差 < 120°(
π/1.5)时触发,允许更大的角度偏差(来不及对准也要传) - 踢球力度由
flatpower()动态计算(根据接球者位置、距离、到达时间),再乘 1.5 倍做补偿
INTER_TOUCH
case INTER_TOUCH:
{
if (Utils::InTheirPenaltyArea(target, 0) &&
fabs(Utils::Normalize(projection2ball.dir() - ball.Vel().dir())) < 0.1 &&
projection2me.mod() < 20)
{ // 已经极度对位且目标点在对方禁区(射门)
targetPos = touchPos;
}
else
{ // 还未对位,需要绕到球的侧面
if (fabs(Utils::Normalize(me2ball.dir() - ball.Vel().dir())) <
PARAM::Math::PI / 4.0 ||
(fabs(Utils::Normalize(me2ball.dir() - ball.Vel().dir())) <
PARAM::Math::PI / 18.0 * 10 &&
me2ball.mod() <= 40 * 10))
{ // 机器人与球的连线方向和球速方向夹角 < 45°(正对球飞来),或在较近距离内夹角<100°
// 此时如果直接冲向截球点,会正面撞上飞来的球
targetPos = interPoint +
(projection2me / (projection2me.mod())) * 40 * 10; //跑到球的侧面
}
else
{ // 不需要侧面绕行,把车嘴对准理想触球位置
targetPos = interPoint +
Utils::Polar2Vector(
-PARAM::Vehicle::V2::PLAYER_CENTER_TO_BALL_CENTER, targetDir);
}
}
// 朝向规划
targetDir = me2target.dir() + alpha;
// 机器人指向目标方向 + 碰撞物理偏转角 alpha,使触球后球能弹射到目标。
if (Utils::InTheirPenaltyArea(target, 0))
{ // 射门
if (fabs(Utils::Normalize(me.RawDir() - targetDir)) < PARAM::Math::PI / 3)
{
KickStatus::Instance()->setKick(runner, 7000.0);
}
}
else
{ // 传球
if (fabs(Utils::Normalize(me.RawDir() - targetDir)) < PARAM::Math::PI / 3)
{
power = flatpower(ball, receiver, target, 1000) * 1.5;
KickStatus::Instance()->setKick(runner, power);
// KickStatus::Instance()->setChipKick(runner,power);
}
}
break;
}这段代码是状态机中的 INTER_TOUCH 分支,处理机器人在移动过程中调整到合适位置后完成触球弹射的逻辑。与 WAIT_TOUCH(原地等球)不同,此状态下机器人还没到位,需要边跑边调整。
一、位置规划(targetPos)
特殊情况:已经极度对位且目标在禁区
if (Utils::InTheirPenaltyArea(target, 0) &&
fabs(Utils::Normalize(projection2ball.dir() - ball.Vel().dir())) < 0.1 &&
projection2me.mod() < 20)
{
targetPos = touchPos;
}满足以下全部条件时,直接冲向预计算的触球点 touchPos:
- 目标点在对方禁区内(射门场景)
- 投影点已对准球的来向(误差 < 0.1 rad ≈ 5.7°)
- 机器人与投影点距离 < 20mm(几乎已在球路上)
一般情况:还未对位,需要绕到球的侧面
情况 A:机器人几乎在球速线上(正对球飞来方向)
if (fabs(Utils::Normalize(me2ball.dir() - ball.Vel().dir())) < PARAM::Math::PI / 4.0 ||
(fabs(...) < PARAM::Math::PI / 18.0 * 10 && me2ball.mod() <= 40 * 10))
{
targetPos = interPoint + (projection2me / projection2me.mod()) * 40 * 10;
}- 机器人与球的连线方向和球速方向夹角 < 45°(正对球飞来),或在较近距离内夹角 < 100°
- 此时如果直接冲向截球点,会正面撞上飞来的球,造成鲁棒性差
- 解决方案:在截球点
interPoint基础上,沿 投影点→机器人 方向偏移 400mm,即向球路侧面绕开,等球飞过后再走上球路
情况 B:机器人不在球速线正前方
else
{
targetPos = interPoint + Utils::Polar2Vector(
-PARAM::Vehicle::V2::PLAYER_CENTER_TO_BALL_CENTER, targetDir);
}- 不需要侧面绕行,直接目标设为截球点
interPoint沿目标方向后退一个机器人到球心距离,即把机器人质心对准理想触球位置
二、朝向规划(targetDir)
targetDir = me2target.dir() + alpha;与 WAIT_TOUCH 完全相同:机器人指向目标方向 + 碰撞物理偏转角 alpha,使触球后球能弹射到目标。
三、触发踢球指令
与 WAIT_TOUCH 相比,踢球条件更严格(角度容忍更小):
| 场景 | 角度容忍 | 力度 |
|---|---|---|
| 目标在禁区(射门) | < 60°(π/3) | 固定 7000 |
| 目标不在禁区(传球) | < 60°(π/3,比 WAIT_TOUCH 的 120° 严格一倍) | flatpower() × 1.5 动态计算 |
传球场景比 WAIT_TOUCH 更严格的原因:INTER_TOUCH 时机器人还在运动中,朝向不稳定,角度偏差大时踢球精度差,需要更严格的条件保证传球质量。
总结
INTER_TOUCH = "跑位中的触球模式",其核心逻辑是:
1. 计算是否已极度对位 → 是:直接冲触球点
2. 否:判断是否正面对球
→ 是:向侧面绕行(避免被球直接撞到)
→ 否:冲向截球点后方(偏移一个机器人半径)
3. 朝向 = 目标方向 + 触球偏转角 alpha
4. 对准后触发踢球(较严格的 60° 容忍)WAIT_RECV
case WAIT_RECV:
{ // 原地等待来球并将其稳定接住
// 接球模式(Receive)的目标是把球稳稳停下来,而不是弹射出去。
// 机器人需要正面迎球,让球直接滚进"嘴部"(dribbler),朝向球是最优姿态。
// 这与 WAIT_TOUCH 不同
// ——后者需要加 alpha 偏转角来控制弹射方向,WAIT_RECV 只需对准球即可。
targetDir = me2ball.dir();
getPenaltyTouchPos(target, recv_p, targetDir, Receive);
// 调用禁区边界修正函数,传入 Receive 模式:
// 计算球路与对方禁区边界的交点
// 若球路穿过禁区,将接球位置 recv_p 修正到禁区外边界处
// 在 Receive 模式下,Touch_Pos 直接设为交点本身(不像 Touch
// 模式还要额外偏移一个机器人半径), 因为接球只需站在球路上,不需要考虑触球角度补偿
targetPos = recv_p;
break;
}这段代码是状态机中的 WAIT_RECV 分支,是所有接/触球状态中最简洁的一个,处理机器人原地等待来球并将其稳定接住的逻辑。
逐行解析
targetDir = me2ball.dir();机器人朝向始终对准球(me2ball = 机器人 → 球的方向)。
原因:接球模式(Receive)的目标是把球稳稳停下来,而不是弹射出去。机器人需要正面迎球,让球直接滚进"嘴部"(dribbler),朝向球是最优姿态。这与 WAIT_TOUCH 不同——后者需要加 alpha 偏转角来控制弹射方向,WAIT_RECV 只需对准球即可。
getPenaltyTouchPos(target, recv_p, targetDir, Receive);调用禁区边界修正函数,传入 Receive 模式:
- 计算球路与对方禁区边界的交点
- 若球路穿过禁区,将接球位置
recv_p修正到禁区外边界处 - 在
Receive模式下,Touch_Pos直接设为交点本身(不像Touch模式还要额外偏移一个机器人半径),因为接球只需站在球路上,不需要考虑触球角度补偿
targetPos = recv_p;机器人的目标位置设为经过禁区修正后的接球点 recv_p。
初始值 recv_p = projection(机器人在球速线上的投影点),即球速线上离自己最近的点。若 getPenaltyTouchPos 检测到球路经过禁区边界并成功修正,则 recv_p 会被更新为禁区边界上的接球点。
与其他状态的对比
| 状态 | 目标朝向 | 目标位置 | 是否踢球 |
|---|---|---|---|
WAIT_TOUCH | me2target.dir() + alpha(偏转弹射) | 禁区边界触球点 | 是 |
WAIT_RECV | me2ball.dir()(正对球) | 禁区边界接球点 | 否 |
INTER_TOUCH | me2target.dir() + alpha | 需绕行后的触球点 | 是(跑位中) |
总结
WAIT_RECV = "站在接球点,正面对球,等球滚进来"。
逻辑极简:确定接球位置(球路投影点,必要时修正到禁区边界),朝向对准球,不踢球、不弹射,纯粹等待接球控球,后续由 GET_BALL 或 BREAK 状态接管后续处理。
INTER_RECV
case INTER_RECV:
{ // 过渡状态:球在飞行,机器人还没对准球路,需要先跑到球路线旁边,再滑入接球位置,
// 而不是直接横穿球的飞行路径(否则会被球打偏或错过截球)。
if (fabs(Utils::Normalize(projection2ball.dir() - ball.Vel().dir())) < 0.1 &&
projection2me.mod() < 20)
{ // 已经对位且极近投影点
// 直接将目标位置设为球速线上的投影点 projection,停在那里等接球。
targetPos = projection;
}
else
{ // 需要侧面绕行(防止被球正面撞上)
if (fabs(Utils::Normalize(me2ball.dir() - ball.Vel().dir())) <
PARAM::Math::PI / 4.0 ||
(fabs(Utils::Normalize(me2ball.dir() - ball.Vel().dir())) <
PARAM::Math::PI / 18.0 * 10 &&
me2ball.mod() <= 40 * 10))
// 触发条件(二选一):
// A: 机器人→球的方向与球速方向夹角 < 45°(π/4):
// 说明球几乎朝着机器人正面飞来,此时直冲截球点会被球打偏
// B: 夹角 < 100°(π/18 × 10) 且距球 ≤ 400mm:
// 近距离时放宽角度判断,同样需要侧绕
{ // 在截球点的侧方 400mm 处等待
targetPos = interPoint +
(projection2me / (projection2me.mod())) * 40 * 10; //跑到球的侧面
}
else
{ // 不满足以上任何侧绕条件时(即机器人不在球的主飞行路径上),直接跑向预测截球点
targetPos = interPoint;
}
}
targetDir = me2ball.dir();
break;
}读取 [](file:///home/lkh/robocup/rocos2026/lumina/main/Medusa/src/Strategy/skill/Crosserover.cpp#665-665),行 665 到 690
这段代码是状态机中 INTER_RECV(移动接球)状态的处理逻辑,负责在机器人尚未到达理想接球位置时,规划如何安全地跑到截球点。
INTER_RECV 是过渡状态:球在飞行,机器人还没对准球路,需要先跑到球路线旁边,再滑入接球位置,而不是直接横穿球的飞行路径(否则会被球打偏或错过截球)。
第一分支:已经对位且极近投影点
if (fabs(Utils::Normalize(projection2ball.dir() - ball.Vel().dir())) < 0.1 &&
projection2me.mod() < 20)
{
targetPos = projection;
}| 条件 | 含义 |
|---|---|
projection2ball.dir() ≈ ball.Vel().dir() (误差 < 0.1 rad ≈ 5.7°) | 投影点已经在球速方向的前方,即机器人的"嘴部投影"对准了球的来向 |
projection2me.mod() < 20mm | 机器人已经几乎站在投影点上 |
两个条件都满足时,说明机器人已经完美对位,直接将目标位置设为球速线上的投影点 projection,停在那里等接球。
第二分支:需要侧面绕行(防止被球正面撞上)
if (fabs(Utils::Normalize(me2ball.dir() - ball.Vel().dir())) < PARAM::Math::PI / 4.0 ||
(fabs(Utils::Normalize(me2ball.dir() - ball.Vel().dir())) < PARAM::Math::PI / 18.0 * 10 &&
me2ball.mod() <= 40 * 10))
{
targetPos = interPoint + (projection2me / projection2me.mod()) * 40 * 10;
}触发条件(二选一):
- 机器人→球的方向与球速方向夹角 < 45°(π/4):说明球几乎朝着机器人正面飞来,此时直冲截球点会被球打偏
- 夹角 < 100°(π/18 × 10) 且距球 ≤ 400mm:近距离时放宽角度判断,同样需要侧绕
目标位置计算:
targetPos = interPoint + (projection2me / projection2me.mod()) * 400projection2me / projection2me.mod():从投影点指向机器人的单位向量(即垂直于球速线、指向机器人当前一侧的方向)- 乘以 400mm:在截球点的侧方 400mm 处等待
这样机器人会站在球路线的旁边,等球快到时再横向切入,而不是迎头冲上去。
第三分支:直接冲向截球点
else
{
targetPos = interPoint;
}不满足以上任何侧绕条件时(即机器人不在球的主飞行路径上),直接跑向预测截球点 interPoint。
朝向设定
targetDir = me2ball.dir();无论位置如何规划,机器人的朝向始终对准球,确保到位时能第一时间用嘴部接住球。这与 WAIT_TOUCH 不同(后者需要加 α 偏转角控制弹射方向)。
流程图
INTER_RECV
│
├─ 已对位且紧贴投影点?─YES─→ targetPos = projection(站在球路线上等球)
│
├─ 球正面飞来风险?─────YES─→ targetPos = 截球点侧方400mm(侧面绕行)
│ (夹角<45° 或 近距离夹角<100°)
│
└─ 否──────────────────────→ targetPos = interPoint(直冲截球点)
朝向: 始终对准球 (me2ball.dir())GET_BALL
case GET_BALL:
{ // 球几乎静止且就在脚边
//////////////////////////////////* 位置规划
///*//////////////////////////////////////////////////////////////////////////////////////////
if (ballVelMod > 500 && fabs(Utils::Normalize(me2ball.dir() - ballVelDir)) > PI / 4 &&
fabs(Utils::Normalize(me2ball.dir() - ballVelDir)) < 3 * PI / 4)
{ // 分支 A: 球在快速横向运动
// 此时不能直追球(球会跑掉),直接跑到预测截球点 interPoint,在球到达前抢先卡位
targetPos = interPoint;
}
else if (ballVelMod < low_speed_threshold / 1 &&
fabs(Utils::Normalize(me2ball.dir() - me.RawDir())) <
8 * PI / 180 /*&& me.RawRotVel()<1.5*/)
{ // 分支 B:球慢且机器人已对准(精准推球入口)
targetPos = ballPos + Utils::Polar2Vector(
100, /*ballVelMod>100?ballVelDir/10 :*/ me2ball.dir());
// 目标位置设为球的正后方 100mm(嘴插进去100mm),让机器人轻柔地接球而不是撞飞它。
if (me.RawVel().mod() < 1500)
{ // 如果我方车没有速度了,主动注入 1.5m/s 的指向速度,保证有足够冲劲把球推进嘴里
wait_task.player.vel =
Utils::Polar2Vector(1500, (targetPos - me.RawPos()).dir());
// wait_task.player.max_speed=4000;
}
// wait_task.player.max_acceleration=6000;
wait_task.player.rotate_acc = 5;
// 此时最需要的是直线冲进去,不要因为转向干扰位置
}
else
{ // 分支 C:默认追球,球慢但还没对准
targetPos = ballPos + Utils::Polar2Vector(-10, me2ball.dir());
// wait_task.player.vel=Utils::Polar2Vector(400+ballVelMod,(targetPos-me.RawPos()).dir());;
wait_task.player.rotate_acc = 30;
// 目标设为球正前方 10mm,即机器人正对球心,用力顶上去。
// rotate_acc = 30 允许较快转向对准
}
// 黑车性能更强,单独做了两档限速保护,防止冲劲太大把球顶飞或冲过头。
if (is_blackCar)
{
if (me2ball.mod() < 800 && me.RawVel().mod() > 2000)
{
wait_task.player.rotate_acc = 15;
wait_task.player.max_speed = 2000;
}
else if (me.RawVel().mod() > 3000)
{
wait_task.player.rotate_acc = 20;
wait_task.player.max_speed = 2500;
}
}
else
{
wait_task.player.rotate_acc = 20;
wait_task.player.max_speed = 3000;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////* 角度矫正
///*//////////////////////////////////////////////////////////////////////////////////////////
double dribbleDir = (ball.Pos() - dribblePos).dir(); // 车嘴朝向
targetDir = (ball.Pos() - dribblePos).dir();
if (fabs(Utils::Normalize(targetDir - me.Dir())) >
PARAM::Math::PI * 0.5 / 180 /*&& me2ball.mod()>1000*/)
{// 当朝向误差 > 0.5° 时,将 targetPos 沿"目标点→球"反方向额外偏移 10mm:
// 是一个微小补偿,通过让整体目标位置稍微偏向朝向误差的反方向,
// "引导"运动控制器在移动时顺带把车头转正,减少纯角度控制的抖动。
targetPos =
targetPos +
Utils::Polar2Vector(
10, (targetPos - ball.Pos()).dir() -
Utils::Normalize(me.Dir() - (targetPos - ball.Pos()).dir()));
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////* 危险情况
///*/////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
break;
}这段代码是状态机中 GET_BALL(直接拿球)状态的处理逻辑,应对「球几乎静止且就在脚边」的场景,分为位置规划和角度矫正两个部分。
分支1:球在快速横向运动
if (ballVelMod > 500 &&
fabs(me2ball.dir() - ballVelDir) > PI/4 &&
fabs(me2ball.dir() - ballVelDir) < 3*PI/4)
{
targetPos = interPoint;
}| 条件 | 含义 |
|---|---|
ballVelMod > 500 | 球速 > 500mm/s,球在运动中 |
| 夹角在 45°~135° 之间 | 球在向侧面运动(不是朝机器人飞来,也不是背离) |
此时不能直追球(球会跑掉),直接跑到预测截球点 interPoint,在球到达前抢先卡位。
分支2:球慢且机器人已对准(精准推球入口)
else if (ballVelMod < low_speed_threshold &&
fabs(me2ball.dir() - me.RawDir()) < 8*PI/180)
{
targetPos = ballPos + Polar2Vector(100, me2ball.dir());
if (me.RawVel().mod() < 1500)
wait_task.player.vel = Polar2Vector(1500, (targetPos - me.RawPos()).dir());
wait_task.player.rotate_acc = 5;
}| 条件 | 含义 |
|---|---|
ballVelMod < 1000 | 球几乎静止 |
| 机器人朝向与球的方向误差 < 8° | 机器人嘴部已经精准对准了球 |
目标位置设为球的正后方 100mm(嘴插进去 100mm),让机器人轻柔地"叼住"球而不是撞飞它。
- 若当前车速 < 1500mm/s → 主动注入 1500mm/s 的指向速度,保证有足够冲劲把球推进嘴里
rotate_acc = 5(极低旋转加速度):此时最需要的是直线冲进去,不要因为转向干扰位置
分支3:默认追球
else
{
targetPos = ballPos + Polar2Vector(-10, me2ball.dir());
wait_task.player.rotate_acc = 30;
}其他情况(球慢但还没对准):目标设为球正前方 10mm,即机器人正对球心,用力顶上去。rotate_acc = 30 允许较快转向对准。
二、车型差异化速度限制
if (is_blackCar)
{
if (me2ball.mod() < 800 && me.RawVel().mod() > 2000)
→ rotate_acc=15, max_speed=2000 // 快速接近球时限速防冲过
else if (me.RawVel().mod() > 3000)
→ rotate_acc=20, max_speed=2500 // 高速时通用限速
}
else
{
rotate_acc=20, max_speed=3000 // 普通车
}黑车(is_blackCar)性能更强,单独做了两档限速保护,防止冲劲太大把球顶飞或撞出禁区。
三、角度矫正(精细对齐)
double dribbleDir = (ball.Pos() - dribblePos).dir();
targetDir = (ball.Pos() - dribblePos).dir();
if (fabs(targetDir - me.Dir()) > 0.5*PI/180)
{
targetPos = targetPos + Polar2Vector(10,
(targetPos - ball.Pos()).dir() - Normalize(me.Dir() - (targetPos - ball.Pos()).dir()));
}dribblePos 是机器人当前嘴部位置(传感器实测值),而 me.Pos() 是机器人中心。
targetDir = (ball.Pos() - dribblePos).dir():目标朝向 = 从嘴部指向球的方向,使嘴部精确对准球心(比用中心点更精准 ~90mm 的偏差)当朝向误差 > 0.5° 时,将
targetPos沿"目标点→球"反方向额外偏移 10mm:这是一个微小补偿,通过让整体目标位置稍微偏向朝向误差的反方向,"引导"运动控制器在移动时顺带把车头转正,减少纯角度控制的抖动。
流程图
GET_BALL
│
├─ 球横向快速运动? ──YES──→ targetPos = interPoint(截击)
│
├─ 球慢且已对准(<8°)?─YES──→ targetPos = 球后方100mm + 注入速度(轻柔叼球)
│
└─ 否 ────────────────────→ targetPos = 球正中(直接顶上去)
│
├─ 速度限制(黑车/普通车分别处理)
│
└─ 角度矫正:用嘴部传感器位置精确对准球心,误差>0.5°时微调目标位置消除抖动BREAK
case BREAK: // 持球突破
{ // 带球对抗敌人防守、寻找射门/传球时机
// target=THEIR_GOAL;
static double rotate_flag =
Utils::Normalize(enemy2me.dir() + PI - me.Dir()) > 0 ? -1 : 1;
// 决定持球时向左(-1)还是向右(+1)转体突破。
if ((fabs(Utils::Normalize(me2target.dir() + PI - me.Dir() + PI)) < PI / 18 &&
break_time > 600) ||
last_state != BREAK)
// 重置触发条件(二选一):
// A: 刚进入 BREAK 状态(last_state != BREAK):
// 重新根据目标方向计算转向
// B: 持球超时(>600帧)且已基本对准目标(误差 < 10°):
// 说明这个方向突破失败了,重置换方向重试,同时清零 break_time 和 BREAK_FLAG
{
rotate_flag = Utils::Normalize(me2target.dir() + PI - me.Dir() + PI) > 0 ? 1 : -1;
// rotate_flag=Utils::Normalize(enemy2me.dir()+PI-me.Dir())>0?-1:1;
break_time = 0;
BREAK_FLAG = 0;
}
CGeoSegment ball2tarSeg(
ballPos + Utils::Polar2Vector(2 * ballVelMod * ballVelMod / FRICTION, ballVelDir),
ballPos); // // 球的滚动路径线段
int ene_prj_idx =
MessiDecision::Instance()
->indicesMap()[MessiDecision::Instance()->enemy2ballLinePrjDist][0];
PlayerVisionT bestenePrj = MessiDecision::Instance()->EnemyInfo().enemy[ene_prj_idx];
CGeoPoint eneInterPos = ball2tarSeg.projection(bestenePrj.RawPos());
if (eneInterPos.dist(bestenePrj.RawPos()) < 500 && // 最佳拦截敌人接近球路
ball2tarSeg.IsPointOnLineOnSegment(eneInterPos) && // 拦截点在球路上
(!Utils::InTheirPenaltyArea(target, 0) &&
me.X() < 1000) && // 不在禁区且我还在己方半场一侧
(me.RawDir() > leftdir && me.RawDir() < rightdir)) // 朝向在球门范围内
{ // 紧急挑球(对方有人要截球)
KickStatus::Instance()->setChipKick(runner, 8000.0);
}
if (fabs(Utils::Normalize(me2target.dir() - me.Dir())) <
(BREAK_FLAG * 3 + 10) * PI / 180 && // 在被贴近时放宽容忍、强行出球
!(me2targetseg.IsPointOnLineOnSegment(me2targetseg.projection(bestene.RawPos())) &&
me2targetseg.dist2Point(bestene.RawPos()) < 100 &&
bestene.RawPos().dist(ballPos) < 300)) // 排除被贴身卡死的情况
{ // 常规射门/传球(朝向对准时触发)
if (Utils::InTheirPenaltyArea(target, 0))
{
if (ballPos.x() > 1500 && me.RawDir() > leftdir && me.RawDir() < rightdir)
{ // 目标在对方禁区内(射门),球在前场
KickStatus::Instance()->setKick(runner, is_blackCar ? 9000 : 7000);
}
else if (ballPos.x() < 1500 && me.RawDir() > leftdir && me.RawDir() < rightdir)
{ // 目标在对方禁区内(射门),球在中场(x<1500)
if (is_blackCar)
{
KickStatus::Instance()->setKick(runner, 11000.0);
}
else
{
KickStatus::Instance()->setKick(runner, 7000.0);
}
}
}
else if (Utils::InTheirPenaltyArea(target, 1000) &&
fabs(Utils::Normalize(me2target.dir() - me.Dir())) <
(BREAK_FLAG * 3 + 2) * PI / 180)
{ // 目标在禁区外扩 1000mm 范围内(前场传球)
power = flatpower(ball, receiver, target, 1000);
KickStatus::Instance()->setKick(runner, power);
}
else
{ // 其他情况(一般传球)
power = flatpower(ball, receiver, target, 1000);
KickStatus::Instance()->setKick(runner, power);
}
// KickStatus::Instance()->setChipKick(runner,power);
}
// break_center=bestene.RawPos();
// break_radius=300;
// Rotate_around_ball(targetPos,targetDir,break_center+Utils::Polar2Vector(break_radius*10,(me.RawPos()-break_center).dir()));
if ((enemy2me.mod() < 400 &&
fabs(Utils::Normalize(enemy2me.dir() + PI - me.Dir())) < PI / 3) ||
BREAK_FLAG)
{ // 路径A:被敌人贴身
BREAK_FLAG = 1;
targetPos = me.Pos() + Utils::Polar2Vector(-10, me.Dir() + rotate_flag * PI / 9);
// 当前位置向斜后方 10mm(PI/9 ≈ 20° 偏转),原地微顿
targetDir = me.Dir() + rotate_flag * PI / 2;
// 向 rotate_flag 方向旋转 90°,快速用身体护球转体
wait_task.player.rotate_acc = 55;
// 慢下来让转向跟上,用车身遮挡球
wait_task.player.max_speed = 1000;
wait_task.player.max_acceleration = 2000;
if (me.RawVel().mod() > 1500)
{ // 高速的时候,一转要掉球的,贴住球
targetPos = ball.Pos();
}
else if (me.RawVel().mod() < 1000)
{
// wait_task.player.max_speed=3000;
}
DribbleStatus::Instance()->setDribbleCommand(runner, 3);
}
else
{ // 路径B:正常带球突破
Rotate_around_ball(targetPos, targetDir, target);
// 以机器人嘴前方 150mm 为圆心做绕球转体,逐步将车头朝向目标方向。
if (me.RawVel().mod() > 1500)
{// 高速时 targetPos = ball.Pos():先刹住,保证不冲过球
targetPos = ball.Pos();
}
wait_task.player.max_speed = 2500;
wait_task.player.max_acceleration = 2000;
BREAK_FLAG = 0;
DribbleStatus::Instance()->setDribbleCommand(runner, 3);
}
break;
}读取 [](file:///home/lkh/robocup/rocos2026/lumina/main/Medusa/src/Strategy/skill/Crosserover.cpp#783-783),行 783 到 894
这段代码是状态机中 BREAK(持球突破)状态的处理逻辑,负责机器人带球对抗敌人防守、寻找射门/传球时机。分为三个核心部分:方向初始化、射门决策、突破运动。
一、突破方向初始化与重置
static double rotate_flag =
Utils::Normalize(enemy2me.dir() + PI - me.Dir()) > 0 ? -1 : 1;
if ((fabs(me2target.dir() + PI - me.Dir() + PI) < PI/18 && break_time > 600) ||
last_state != BREAK)
{
rotate_flag = Utils::Normalize(me2target.dir() + PI - me.Dir() + PI) > 0 ? 1 : -1;
break_time = 0;
BREAK_FLAG = 0;
}rotate_flag 是静态变量,决定持球时向左(-1)还是向右(+1)转体突破。
重置触发条件(二选一):
- 刚进入 BREAK 状态(
last_state != BREAK):重新根据目标方向计算转向 - 持球超时(>600帧)且已基本对准目标(误差 < 10°):说明这个方向突破失败了,重置换方向重试,同时清零
break_time和BREAK_FLAG
rotate_flag 的方向选择逻辑:me2target.dir() + PI - me.Dir() + PI 本质上是计算"机器人背面"相对于"目标方向背面"的角度差,正值→向右突破,负值→向左突破,选择能更快转过去的一侧。
二、射门决策
紧急挑球(对方有人要截球)
CGeoSegment ball2tarSeg(ballPos + Polar2Vector(2*v²/FRICTION, ballVelDir), ballPos);
// 球的滚动路径线段
if (eneInterPos.dist(bestenePrj.RawPos()) < 500 && // 最佳拦截敌人接近球路
ball2tarSeg.IsPointOnLineOnSegment(eneInterPos) && // 拦截点在球路上
!InTheirPenaltyArea(target, 0) && me.X() < 1000 && // 不在禁区且还在己方半场一侧
me.RawDir() > leftdir && me.RawDir() < rightdir) // 朝向在球门范围内
{
KickStatus::Instance()->setChipKick(runner, 8000.0); // 挑球越过拦截者
}检测到最近敌人正在冲向球的行进路线(距离 <500mm),且自身朝向已对准球门扇区时,立即发出挑球命令,力度 8000,越过拦截者。
常规射门/传球(朝向对准时触发)
if (朝向误差 < (BREAK_FLAG*3 + 10)° &&
!(敌人卡在我和目标之间且距球<300mm)) // 排除被贴身卡死的情况角度容忍 = (BREAK_FLAG×3 + 10)°,BREAK_FLAG 为 1 时容忍最大 13°,为 0 时 10°。阶梯化设计用于在被贴近时放宽容忍、强行出球。
| 场景 | 条件 | 踢球力度 |
|---|---|---|
| 目标在对方禁区内(射门),球在前场(x>1500) | 朝向误差 < 10° | 黑车 9000 / 普通 7000 |
| 目标在对方禁区内(射门),球在中场(x<1500) | 朝向误差 < 10° | 黑车 11000 / 普通 7000 |
| 目标在禁区外扩 1000mm 范围内(前场传球) | 误差 < BREAK_FLAG×3+2° | flatpower() 动态计算 |
| 其他情况(一般传球) | 误差 < 10° | flatpower() 动态计算 |
三、突破运动规划
路径A:被敌人贴身(BREAK_FLAG = 1)
if ((enemy2me.mod() < 400 &&
fabs(enemy2me.dir() + PI - me.Dir()) < PI/3) ||
BREAK_FLAG)触发条件:敌人距离 < 400mm 且从正后方逼近(背后 ±60° 内),或已经在紧急模式中。
BREAK_FLAG = 1;
targetPos = me.Pos() + Polar2Vector(-10, me.Dir() + rotate_flag * PI/9);
targetDir = me.Dir() + rotate_flag * PI/2;
wait_task.player.rotate_acc = 55; // 极高转速
wait_task.player.max_speed = 1000; // 极限限速
wait_task.player.max_acceleration = 2000;- 目标位置:当前位置向斜后方 10mm(
PI/9 ≈ 20°偏转),原地微顿 - 目标朝向:向
rotate_flag方向旋转 90°,快速用身体护球转体 - 速度限制极低(1000mm/s):慢下来让转向跟上,用车身遮挡球
若当前速度 > 1500mm/s → targetPos = ball.Pos()(别跑远了,贴住球)
路径B:正常带球突破
else
{
Rotate_around_ball(targetPos, targetDir, target);
if (me.RawVel().mod() > 1500)
targetPos = ball.Pos();
wait_task.player.max_speed = 2500;
wait_task.player.max_acceleration = 2000;
BREAK_FLAG = 0;
}调用 Rotate_around_ball(),以机器人嘴前方 150mm 为圆心做绕球转体,逐步将车头朝向目标方向。
- 高速(>1500mm/s)时
targetPos = ball.Pos():先刹住,保证不冲过球 - 两路都会开启
DribbleStatus::setDribbleCommand(runner, 3),保持拨球轮转动护球
Rotate_around_ball 函数
/**
* @name: ZCrosserover::Rotate_around_ball
* @description: 以球为圆心、让机器人绕球转体直到车头对准目标的行为。
* @param {CGeoPoint} &rotate_pos
* @param {double} &robot_dir
* @param {CGeoPoint} target
* @return {*}
* @details
* 机器人持球时,球在嘴部(车头前方 150mm)。
* 要换方向射门,不能原地转身(会丢球),必须绕着球做圆周运动,同时旋转车身,让球始终贴在嘴里。
*/
void ZCrosserover::Rotate_around_ball(CGeoPoint &rotate_pos, double &robot_dir, CGeoPoint target)
{
const MobileVisionT &ball = _ball->get();
const PlayerVisionT &me = _me->get();
const PlayerVisionT &bestene = _bestene->get();
CGeoPoint center_pos = me.RawPos() + Utils::Polar2Vector(150, me.RawDir());
CVector ball2me = me.RawPos() - center_pos;
CVector target2ball = center_pos - target;
double dist = ball2me.mod() > 100 ? 100 : ball2me.mod();
int pos_flag = 0, angle_flag = 0;
double pos_diff_dir = Utils::Normalize(target2ball.dir() + 2 * PARAM::Math::PI -
(ball2me.dir() + 2 * PARAM::Math::PI));
if (pos_diff_dir != 0)
pos_flag = pos_diff_dir > 0 ? 1 : -1;
// 正差值 → 机器人需要逆时针绕球转(pos_flag = +1),负差值 → 顺时针(-1)。
double angle_diff_dir =
Utils::Normalize(target2ball.dir() + 3 * PARAM::Math::PI -
((center_pos - me.RawPos()).dir() + 2 * PARAM::Math::PI));
// center_pos - me.RawPos() 是机器人朝向(嘴部方向),与目标期望朝向对比,决定车身旋转方向。
if (angle_diff_dir != 0)
angle_flag = angle_diff_dir > 0 ? 1 : -1;
// 粗调阶段(朝向误差 ≥ 20°)
rotate_pos =
center_pos + Utils::Polar2Vector(150, ball2me.dir() + pos_flag * PARAM::Math::PI / 3.0);
// 从球心出发,沿 ball2me 方向旋转 ±60° 后距离 150mm 处
// 机器人绕球移动一步(每帧圆弧位移)
robot_dir = me.RawDir() + angle_flag * PARAM::Math::PI / 2;
// 车身快速大角度旋转
// 每帧执行一次,机器人沿以球为圆心的圆弧滑动,同时车头旋转,逐渐将嘴部对准目标方向。
if (fabs(Utils::Normalize((me.RawDir() - (target - me.RawPos()).dir()))) <
PARAM::Math::PI / 9.0)
{ // 精调阶段(朝向误差 < 20°)
robot_dir = me.RawDir();
rotate_pos = me.Pos();
if (fabs(Utils::Normalize(me.RawDir() - (target - me.Pos()).dir())) >
PARAM::Math::PI / 180.0 * 2)
{
// > 2°
// 每帧固定步进 15°,平滑收敛
robot_dir = me.RawDir() +
PARAM::Math::PI / 180.0 * 15 * ((target - me.Pos()).dir() - me.RawDir()) /
(0.0001 + fabs((target - me.RawPos()).dir() - me.RawDir()));
}
else
{ // ≤ 2°
// 直接锁定到精确目标朝向
robot_dir = (target - me.RawPos()).dir();
}
GDebugEngine::Instance()->gui_debug_msg(
target, QString("small_flag:%1")
.arg(fabs(Utils::Normalize((me.RawDir() - (target - me.RawPos()).dir()))))
.toLatin1());
}
}机器人持球时,球在嘴部(车头前方 150mm)。要换方向射门,不能原地转身(会丢球),必须绕着球做圆周运动,同时旋转车身,让球始终贴在嘴里。
一、几何变量建立
CGeoPoint center_pos = me.RawPos() + Polar2Vector(150, me.RawDir());
// center_pos ≈ 球的位置(机器人正前方150mm,即嘴部位置)
CVector ball2me = me.RawPos() - center_pos; // 球→机器人中心 的向量
CVector target2ball = center_pos - target; // 目标→球 的向量以 center_pos(估算球位)为旋转圆心,150mm 为半径进行绕行。
二、计算绕行方向
位置方向(pos_flag)
double pos_diff_dir = Normalize(target2ball.dir() + 2π - (ball2me.dir() + 2π));
pos_flag = pos_diff_dir > 0 ? 1 : -1;比较两个方向:
target2ball.dir():目标→球的方向(即球应该最终对准的方向反向)ball2me.dir():当前球→机器人的方向
正差值 → 机器人需要逆时针绕球转(pos_flag = +1),负差值 → 顺时针(-1)。
朝向方向(angle_flag)
double angle_diff_dir = Normalize(target2ball.dir() + 3π - ((center_pos - me.RawPos()).dir() + 2π));
angle_flag = angle_diff_dir > 0 ? 1 : -1;center_pos - me.RawPos() 是机器人朝向(嘴部方向),与目标期望朝向对比,决定车身旋转方向。
三、粗调阶段(朝向误差 ≥ 20°)
rotate_pos = center_pos + Polar2Vector(150, ball2me.dir() + pos_flag * PI/3.0);
robot_dir = me.RawDir() + angle_flag * PI/2;| 输出量 | 计算方式 | 效果 |
|---|---|---|
rotate_pos | 从球心出发,沿 ball2me 方向旋转 ±60° 后距离 150mm 处 | 机器人绕球移动一步(每帧圆弧位移) |
robot_dir | 当前朝向 ±90° | 车身快速大角度旋转 |
每帧执行一次,机器人沿以球为圆心的圆弧滑动,同时车头旋转,逐渐将嘴部对准目标方向。
下图直观展示单步运动:
目标
↑
| center_pos(球)
| ●
| ↗ ← ball2me方向
| 机器人
→ rotate_pos(+60°弧步)四、精调阶段(朝向误差 < 20° = π/9)
当机器人已经基本对准目标(误差进入 20° 以内),切换到精细对齐模式:
robot_dir = me.RawDir(); // 先保持当前朝向
rotate_pos = me.Pos(); // 停止位移,原地旋转然后分两档精细调整朝向:
| 误差范围 | 调整方式 | 说明 |
|---|---|---|
| > 2° | robot_dir += 15° × 符号 × 归一化 | 每帧固定步进 15°,平滑收敛 |
| ≤ 2° | robot_dir = (target - me.RawPos()).dir() | 直接锁定到精确目标朝向 |
这个分段设计避免了在目标附近震荡——远时快速步进,近时直接锁定。
GDebugEngine → 调试显示当前对准误差值总结流程图
Rotate_around_ball()
│
├─ 建立几何关系:以嘴部位置(center_pos)为球心,150mm为半径
│
├─ 计算绕行方向(pos_flag)和旋转方向(angle_flag)
│
├─ 朝向误差 ≥ 20°?──YES──→ 粗调:每帧绕球弧移60° + 车身转90°
│
└─ 朝向误差 < 20°?──YES──→ 精调:原地停止,误差>2°步进15°,≤2°直接锁定流程图
BREAK(持球突破)
│
├─ [初始化] 计算转向方向(rotate_flag),超时或重进则重置
│
├─ [射门决策]
│ ├─ 敌人要截球路?───→ 挑球 8000
│ └─ 已对准目标?─────→ 按场景选择踢球力度
│
└─ [运动规划]
├─ 被贴身(<400mm 背后逼近)?
│ └─ BREAK_FLAG=1:原地转体90°护球,限速1000
└─ 正常状态
└─ Rotate_around_ball:绕球转向目标方向,限速2500CHASE_BALL
case CHASE_BALL:
{ // 在没有持球时追上球或抢断敌人
CGeoPoint chasePos = ballPos + Utils::Polar2Vector(-50, me2ball.dir());
targetPos = interPoint; //默认值先设置为截球点
targetDir = me2ball.dir();
// 然后根据球的运动状态分三档细化:
if (ballVelMod > 500 && fabs(Utils::Normalize(me2ball.dir() - ballVelDir)) > PI / 4 &&
fabs(Utils::Normalize(me2ball.dir() - ballVelDir)) < 3 * PI / 4)
{ // 档1:球在横向快速运动(截击模式)
// 球在侧向跑,直追跟不上,跑到预测截球点提前卡位。
targetPos = interPoint;
}
else if ((ballVelMod < 500 ||
(ballVelMod > 500 &&
fabs(Utils::Normalize(me2ball.dir() - ballVelDir)) < 10 * PI / 180 &&
ballVelLine.projection(me.RawPos()).dist(me.RawPos()) < 200)) &&
me2ball.mod() < 1500)
// 档2:球慢或球朝我飞来且距离近(直接上去拿)
{ // 球几乎静止,或球朝我飞来且我已在球路上:直接冲向球正后方 100mm,让球进嘴。
targetPos = ballPos + Utils::Polar2Vector(100, me2ball.dir());
}
else if (ballVelMod < 1000 &&
fabs(Utils::Normalize(me2ball.dir() - me.RawDir())) < 10 * PI / 180)
{ // 档3:球慢且已经对准(最后微调)
// 已经基本对准了球,直接顶上去。
targetPos = ballPos;
}
if (enemy_dribble)
{ // 检测到敌人在带球,放弃截球点计算,直接冲向球的位置抢断。
targetPos = ballPos;
targetDir = me2ball.dir();
}
if (need_grab)
{ // 需要拦截敌人截球路线
// 跑到预先计算好的抢断卡位点
targetPos = need_grabPos;
targetDir = (ball.Pos() - me.Pos()).dir();
GDebugEngine::Instance()->gui_debug_msg(need_grabPos + CVector(0, 300),
QString("grab fucking here!").toLatin1());
}
if (enemy_dribble &&
(fabs(Utils::Normalize(enemy2ball.dir() - enemy2me.dir())) > PI / 3 ||
fabs(Utils::Normalize(me2ball.dir() - me.Dir())) > PI / 3))
{ // 敌人持球但我没能正面顶上去时,绕到敌人嘴部侧面
int ene_mouse_flag = 0;
ene_mouse_flag = Utils::Normalize(enemy2me.dir() - enemy2ball.dir()) > 0 ? 1 : -1;
// ene_mouse_flag 决定从左侧还是右侧绕,总是选择绕行距离短的一侧。
targetPos =
bestene.Pos() +
Utils::Polar2Vector(PARAM::Vehicle::V2::PLAYER_CENTER_TO_BALL_CENTER * 4,
enemy2ball.dir() + ene_mouse_flag * 3 / PI);
// (4倍机器人半径处,偏转约 0.95rad ≈ 54°),从侧面插入把球顶开。
wait_task.player.max_speed = 5000;
}
crash_ene(targetPos, pVision); // 动态避让路径上的敌人
int ene_prj_idx =
MessiDecision::Instance()
->indicesMap()[MessiDecision::Instance()->enemy2ballLinePrjDist][0];
// GDebugEngine::Instance()->gui_debug_msg(their_proj+CVector(100,300),QString("TLeader%1").toLatin1());CGeoPoint(500,-500),QString("grab
// id: %1").arg(ene_prj_idx).toLatin1()
GDebugEngine::Instance()->gui_debug_msg(
CGeoPoint(500, -700),
QString("TLeader id: (%1,%2)").arg(their_proj.x()).arg(their_proj.y()).toLatin1());
if (their_proj.dist(ballPos) < 99999 &&
fabs(Utils::Normalize((ballPos - their_proj).dir() -
(me.Pos() - their_proj).dir())) > PI / 3)
{ // 敌人的拦截投影点存在,且球、投影点、我三者形成的角度 > 60°
// 说明敌人挡在球和我之间的侧面,需要绕过去
int avoid_flag = Utils::Normalize((targetPos - me.Pos()).dir() -
(their_proj - me.Pos()).dir()) > 0
? 1
: -1;
GDebugEngine::Instance()->gui_debug_line(
targetPos, their_proj_posint +
Utils::Polar2Vector(500, (their_proj_posint - me.Pos()).dir() +
avoid_flag * PI / 2.5));
double avoidAngle = // 绕行方向
PI / 2 * (1 - 0.8 * (their_proj_posint - me.RawPos()).mod() / 2000);
// 绕行角度随距离动态缩放:离拦截点越近,绕行角度越小
avoidAngle = (avoidAngle < 0) ? 0 : avoidAngle;
CGeoPoint avoidpos = their_proj_posint +
Utils::Polar2Vector(500, (their_proj_posint - me.Pos()).dir() +
avoid_flag * avoidAngle);
targetPos = !Utils::InTheirPenaltyArea(avoidpos, 100) ? avoidpos : targetPos;
// 若绕行点不在禁区内则采用,否则保持原目标
if (ballPos.x() < -1000)
{ // 若球在我方后场,绕行方向改为朝向己方半场中央,避免跑进死角。
avoidpos =
their_proj_posint +
Utils::Polar2Vector(
500, (CGeoPoint(-PARAM::Field::PITCH_LENGTH / 2, 0) - their_proj_posint)
.dir());
}
GDebugEngine::Instance()->gui_debug_msg(
targetPos + Utils::Polar2Vector(500, -1 * PI / 4),
QString("avoidpos %1")
.arg(180 *
fabs(Utils::Normalize((ballPos - their_proj).dir() -
(me.RawPos() - their_proj).dir())) /
PI)
.toLatin1());
wait_task.player.rotate_acc = 10;
need_avoid = 1;
}
else if (me.RawPos().dist(ballPos) > bestene.RawPos().dist(ballPos) &&
me.RawPos().dist(targetPos) < 1500 && targetPos.dist(ballPos) > 100 &&
!enemy_dribble)
{
CGeoSegment ball2tarSeg(targetPos, ballPos);
if (ball2tarSeg.projection(bestene.RawPos()).dist(bestene.RawPos()) < 500 &&
ball2tarSeg.IsPointOnLineOnSegment(ball2tarSeg.projection(bestene.RawPos())))
{ // 敌人在我→截球点的线段上(500mm内)
// 插到敌人和球之间,卡住敌人的截球路线
targetPos =
ball2tarSeg.projection(bestene.RawPos()) +
Utils::Polar2Vector(PARAM::Vehicle::V2::PLAYER_CENTER_TO_BALL_CENTER * 2,
enemy2ball.dir());
targetDir = (targetPos - me.RawPos()).dir();
}
}
// if(enemy_dribble){
// targetDir=enemy2me.dir()+PI;
// }
// wait_task.player.rotate_acc=100;
break;
}读取 [](file:///home/lkh/robocup/rocos2026/lumina/main/Medusa/src/Strategy/skill/Crosserover.cpp#906-906),行 906 到 1027
这段代码是状态机中 CHASE_BALL(追球)状态的处理逻辑,负责在没有持球时追上球或抢断敌人,包含五层优先级递进的目标位置决策。
一、基础追球位置规划
默认值先设置为截球点:
targetPos = interPoint;
targetDir = me2ball.dir();然后根据球的运动状态分三档细化:
档1:球在横向快速运动(截击模式)
if (ballVelMod > 500 &&
夹角在 45°~135° 之间)
{
targetPos = interPoint; // 预判截球点
}球在侧向跑,直追跟不上,跑到预测截球点提前卡位。
档2:球慢或球朝我飞来且距离近(直接上去拿)
else if ((ballVelMod < 500 ||
(球朝我飞来且我在球速线上200mm内)) &&
me2ball.mod() < 1500)
{
targetPos = ballPos + Polar2Vector(100, me2ball.dir());
}球几乎静止,或球朝我飞来且我已在球路上:直接冲向球正后方 100mm,让球进嘴。
档3:球慢且已经对准(最后微调)
else if (ballVelMod < 1000 &&
朝向误差 < 10°)
{
targetPos = ballPos; // 直接对准球心
}已经基本对准了球,直接顶上去。
二、敌人持球时——贴身压迫
if (enemy_dribble)
{
targetPos = ballPos;
targetDir = me2ball.dir();
}检测到敌人在带球,放弃截球点计算,直接冲向球的位置抢断。
三、需要拦截敌人截球路线(need_grab 优先级最高)
if (need_grab)
{
targetPos = need_grabPos; // 之前judgeState计算好的抢断位
targetDir = (ball.Pos() - me.Pos()).dir();
// 调试信息:"grab fucking here!"
}若 judgeState 已标记需要抢断球路(need_grab=1),跑到预先计算好的抢断卡位点 need_grabPos(敌人截球点前方一个车身距离处)。
四、敌人持球且角度不对——绕到敌人嘴侧
if (enemy_dribble &&
(敌人与球的方向和敌人与我的方向夹角 > 60° ||
我的朝向和球方向夹角 > 60°))
{
ene_mouse_flag = 敌人嘴偏我的哪一侧 (+1/-1)
targetPos = 敌人位置 + Polar2Vector(
4×机器人半径,
enemy2ball.dir() + ene_mouse_flag × 3/π
)
max_speed = 5000 // 全速冲
}敌人持球但我没能正面顶上去时,绕到敌人嘴部侧面(4倍机器人半径处,偏转约 0.95rad ≈ 54°),从侧面插入把球顶开。ene_mouse_flag 决定从左侧还是右侧绕,总是选择绕行距离短的一侧。
五、动态避让路径上的敌人(crash_ene + 绕障)
5a:路径上有敌人正面拦截
crash_ene(targetPos, pVision); // 检测并修正:若敌人挡在路上且我高速冲过去,把目标改到敌人的投影点(故意冲撞)然后判断是否需要绕行:
if (their_proj.dist(ballPos) < 99999 &&
fabs((ballPos - their_proj).dir() - (me.Pos() - their_proj).dir()) > 60°)敌人的拦截投影点存在,且球、投影点、我三者形成的角度 > 60°(说明敌人挡在球和我之间的侧面,需要绕过去):
// 绕行角度随距离动态缩放:离拦截点越近,绕行角度越小
avoidAngle = PI/2 × (1 - 0.8 × dist/2000)
// 绕行方向(avoid_flag):选我→目标方向和我→障碍方向的左右关系
avoidpos = their_proj_posint + Polar2Vector(500, 障碍方向 + avoid_flag × avoidAngle)
// 若绕行点不在禁区内则采用,否则保持原目标
targetPos = !InTheirPenaltyArea(avoidpos) ? avoidpos : targetPos
rotate_acc = 10 // 降低旋转加速度配合绕行
need_avoid = 1特殊情况:若球在我方后场(x < -1000),绕行方向改为朝向己方半场中央,避免跑进死角。
5b:我比敌人离球远且敌人卡在我去截球点的路上
else if (我比敌人离球远 && 我离截球点<1500 && 不是enemy_dribble)
{
// 敌人在我→截球点的线段上(500mm内)
targetPos = 敌人在线段上的投影点 + Polar2Vector(2×车身, 球→敌人方向)
// 插到敌人和球之间,卡住敌人的截球路线
}总结优先级流程
CHASE_BALL
│
├─ [1] 基础追球:按球速/方向选档 → interPoint / 球后100mm / 球心
│
├─ [2] enemy_dribble → 直冲球位
│
├─ [3] need_grab(最高优先级)→ 跑到预算好的抢断卡位点
│
├─ [4] enemy_dribble且角度差 → 绕到敌人嘴侧插入
│
└─ [5] 路径障碍处理
├─ crash_ene:路上有敌人且高速→故意冲撞
├─ their_proj存在且成角>60°→动态弧线绕障
└─ 敌人卡在我和截球点之间→插入敌人和球中间卡位剩余状态
case RECEIVE_BALL: // 弃用
targetPos = projection; // 站到球路上等球
targetDir = me2ball.dir();
break;
case NOTHING: // 重置,兜底
targetPos = me.Pos();
wait_task.player.rotate_acc = 15;
targetDir = me.Dir();
KickStatus::Instance()->setKick(runner, 1500);
// 防带球过度 Dribble_BALL_TOO_FAR
DribbleStatus::Instance()->setDribbleCommand(runner, 3);
// }
break;
default: // 兜底
targetPos = me.Pos();
wait_task.player.rotate_acc = 30;
targetDir = me2ball.dir();
if (_holding_ball)
{ // 紧急保护动作,让机器人背对球方向,利用身体护球,同时避免误射
targetDir = me.Dir() + PI;
}
break;
}这段代码包含三个状态的处理逻辑:RECEIVE_BALL、NOTHING 和 default,它们都是简单的兜底/特殊状态。
RECEIVE_BALL(接球)
case RECEIVE_BALL:
targetPos = projection;
targetDir = me2ball.dir();
break;将机器人目标位置设为球速线上的垂足投影点(projection = 机器人在球速线上的最近点),朝向对准球。
这是一个纯粹"站到球路上等球"的接球模式,逻辑极简。注意:目前代码中 judgeState 里并没有主动跳转到此状态的路径,实际应该是保留接口或由外部任务强制指定。
NOTHING(无操作/原地待命)
case NOTHING:
targetPos = me.Pos(); // 原地不动
wait_task.player.rotate_acc = 15; // 低旋转加速度(轻柔)
targetDir = me.Dir(); // 保持当前朝向
KickStatus::Instance()->setKick(runner, 1500); // 低功率踢球(弹开球)
DribbleStatus::Instance()->setDribbleCommand(runner, 3); // 开启拨球轮
break;机器人完全原地待命,但仍做两件事:
- 低功率踢球 1500:若此时恰好有球蹭到嘴部,以较小力量弹开,避免被球卡住或意外带球犯规
- 开启拨球轮:保持拨球轮转动,防止球粘住嘴部
这是所有状态都无法匹配时的安全兜底,保证机器人不会静止持球。
default(未知状态)
default:
targetPos = me.Pos();
wait_task.player.rotate_acc = 30;
targetDir = me2ball.dir(); // 朝向球
if (_holding_ball)
targetDir = me.Dir() + PI; // 持球时朝向反转(背对球逃离)
break;兜底的兜底,处理状态机出现意外枚举值的情况:
- 原地停止,朝向球
- 若正在持球,则将朝向翻转 180°(
+PI)——这是一个紧急保护动作,让机器人背对球方向,利用身体护球,同时避免误射
三者对比
| 状态 | 位置 | 朝向 | 特殊指令 | 用途 |
|---|---|---|---|---|
RECEIVE_BALL | 球速线投影点 | 对准球 | 无 | 接球等待 |
NOTHING | 原地 | 不变 | 低踢+拨球轮 | 安全待命 |
default | 原地 | 对准球(持球则反转) | 无 | 异常保护 |
执行
if ((me2ball.mod() < 1000 || me.Pos().dist(targetPos) < 1000) && this->state != BREAK)
// 两个条件满足其一(且不在 BREAK 状态)就开启拨球轮:
// A: 距球 < 1000mm:靠近球时开轮,做好接球准备
// B: 距目标点 < 1000mm:快到位时开轮,防止到位瞬间球蹭到嘴部飞走
// P.S. BREAK 状态在各自分支内部已单独控制拨球轮,此处跳过避免冲突。
{
DribbleStatus::Instance()->setDribbleCommand(runner, 3);
}
// GDebugEngine::Instance()->gui_debug_line(me.RawPos(),me.Pos()+Utils::Polar2Vector(500,me.RawVel().dir()));
GDebugEngine::Instance()->gui_debug_arc(interPoint, 300, 0, 360, COLOR_GRAY);
GDebugEngine::Instance()->gui_debug_arc(targetPos, 300, 0, 360, COLOR_ORANGE);
GDebugEngine::Instance()->gui_debug_line(me.Pos(), target, COLOR_GRAY);
MessiDecision::Instance()->setLeaderSkillState(QString(debug_state.c_str()));
if (this->state != BREAK)
{
BREAK_FLAG = 0;
}
// if(!BREAK_FLAG){
wait_task.player.pos = targetPos;
wait_task.player.angle = targetDir;
wait_task.executor = runner;
wait_task.player.flag = _taskFlag;
GDebugEngine::Instance()->gui_debug_line(
me.Pos(), me.Pos() + Utils::Polar2Vector(1000, wait_task.player.angle));
// 速度前馈注入(car_vel_mod)
// 不依赖运动规划器自己计算速度,而是主动注入一个初始速度向量,加速响应。
CVector car_vel_moudle(0, 0);
double car_vel_mod = (targetPos.dist(me.Pos()) - 200) * 2;
// 速度大小 = (距目标点 - 200mm) × 2,
// 距目标越近速度越小,距离 200mm 以内速度归零,形成自然减速曲线。最大前馈速度 2500mm/s。
car_vel_mod = fmax(0, car_vel_mod);
car_vel_mod = fmin(2500, car_vel_mod);
// 限幅 [0, 2500]
if (((ballVelMod < 300 && // 球慢且我对准球 < 8°
fabs(Utils::Normalize(me2ball.dir() - me.Dir())) < 8 * PI / 180) ||
(ballVelMod > 300 && // 球快且我在球速线上200mm内
fabs(Utils::Normalize(me2ball.dir() - ballVelDir)) < 8 * PI / 180 &&
ballVelLine.projection(me.RawPos()).dist(me.RawPos()) < 200)) &&
me2ball.mod() < 1500)
{ // 情况A:即将接触球时(精准注速)
// car_vel_mod=(targetPos.dist(me.Pos()))*2;
car_vel_mod = 1500;
// 固定注入1500,保证有足够冲劲叼球
}
if (need_grab || need_avoid ||
(enemy_dribble &&
(fabs(Utils::Normalize(enemy2ball.dir() - enemy2me.dir())) > PI / 3 ||
fabs(Utils::Normalize(me2ball.dir() - me.Dir())) > PI / 3))) // 敌人持球且需要绕侧
{ // 情况B:紧急追球/绕障时(强制提速)
car_vel_mod = 2000; // 强制2000,全力追
}
else
{
if (me2ball.mod() < 300 && me.RawVel().mod() > 1000)
{ // 已经极近球且高速→清零,让车自然停下来不撞飞球
car_vel_mod = 0;
}
}
car_vel_moudle = Utils::Polar2Vector(car_vel_mod, (targetPos - me.RawPos()).dir());
wait_task.player.vel = car_vel_moudle;
// 最终将速度向量写入任务
if (is_blackCar && !(this->state == BREAK))
{ // 黑车 (Break 自行规划)
if (me2ball.mod() < 1000 && me.RawVel().mod() > 2500)
{ // 黑车 靠近球(<1000mm)且高速(>2500)
wait_task.player.rotate_acc = 20;
if (enemy_dribble)
{
wait_task.player.rotate_acc = 30;
}
wait_task.player.max_speed = 2500;
}
else if (me.RawVel().mod() > 3500)
{ // 速度>3500 ,限制下来
wait_task.player.rotate_acc = 20;
wait_task.player.max_speed = 3000;
}
else
{ // 正常
wait_task.player.max_speed = 5000;
wait_task.player.rotate_acc = 30;
wait_task.player.max_acceleration = 6000;
}
}
else
{
if (!is_blackCar)
{ // 普通车
wait_task.player.max_speed = 3500;
wait_task.player.rotate_acc = 40;
}
else
{ // 黑车转太快球直接飞了
wait_task.player.max_speed = 3500;
wait_task.player.rotate_acc = 25;
}
}
if (!no_send_task)
{
if (is_blackCar)
{
// GDebugEngine::Instance()->gui_debug_robot(me.RawPos(),me.Dir(),COLOR_BLACK);
setSubTask(TaskFactoryV2::Instance()->SmartGotoposition_Black(wait_task));
}
else
{
setSubTask(TaskFactoryV2::Instance()->SmartGotoPosition(wait_task));
}
}
else
{
MessiDecision::Instance()->setUseDirectCmd(runner);
}
// }
ZSkillUtils::instance()->setOurInterVel(runner, wait_task.player.vel);
// 保存帧间状态(下一帧用)
last_ballveldir = ball.Vel().dir();
lastInterPoint = interPoint;
last_target = target;
last_state = this->state;
}
return CPlayerTask::plan(pVision);
}