WDrag
约 10119 字
相关信息
WDrag 这个 SKill 用于在特定点位等待,它在 Lua 层可以传入一个坐标,它会去那个坐标等候,如果有敌方车盯上他了,会和敌方车拉扯,还能盯防附近的敌方车
在 NormalPlay 阶段,如果有的车没事干,就给他分配 WDrag 任务,然后从 PosModule 找个点发给它就行了,它自己会干活的。
初始化
void CWDrag::plan(const CVisionModule *pVision)
{
if (pVision->getCycle() - _lastCycle > PARAM::Vision::FRAME_RATE * 0.1)
{
setState(BEGINNING);
enemyNum = -999;
markDist = 999999;
v1.setVector(0, 0);
v2 = v1;
finalVelVec = v2;
antiTarget.fill(0, 0);
realTarget.fill(0, 0);
freeBallDist = 3000;
freeCount = 0;
antiCnt = 0;
antiVelCount = 0;
realCnt = 0;
escapeCnt = 0;
} // 上一帧寄了,重置一下
int vecNumber = task().executor;
CGeoPoint target = task().player.pos;
CGeoPoint purposeTarget = CGeoPoint(task().player.kickpower, task().player.chipkickpower);
const PlayerVisionT &self = pVision->ourPlayer(vecNumber);
const double self2BallDir = Utils::Normalize((pVision->ball().RawPos() - self.RawPos()).dir());
const CGeoPoint interPoint =
ZSkillUtils::instance()->predictedTheirInterPoint(self.RawPos(), pVision->ball().RawPos());
const double self2InterPoint = self.RawPos().dist(interPoint);
//需要拉扯的点赋值
//如果给了那优先给的点 如果没给则离球200mm的点
if (Utils::IsInField(purposeTarget) && purposeTarget.dist(target) > 1000)
{ // Lua 给的 target 有效 (不是平常用的第一个 Lua 参数 Pos ,是第二个参数 target,拉扯点)
purposeMode = true;
}
else
{ // 自动计算目标点:在球的反方向200mm处
purposeMode = false;
purposeTarget = pVision->ball().RawPos() + CVector(-200, 0).rotate(self2BallDir);
//如果加了避球的flag后,点不能直接发在球上
}这段代码是 CWDrag::plan 函数的初始化部分,主要负责状态重置和目标点计算。我来详细解释:
第一部分:状态重置
if(pVision->getCycle() - _lastCycle > PARAM::Vision::FRAME_RATE*0.1)作用:检测是否长时间未执行该技能(超过0.1秒)
- 如果距离上次执行时间超过帧率的10%,说明可能是重新启动或长时间暂停
- 此时需要将所有状态变量重置为初始值:
setState(BEGINNING)- 重置状态机enemyNum = -999- 清除标记的敌方车辆编号markDist = 999999- 重置标记距离为极大值v1, v2, finalVelVec- 清零速度向量antiTarget, realTarget- 清零目标点坐标freeBallDist = 3000- 重置自由球距离- 各种计数器(
freeCount, antiCnt, antiVelCount, realCnt, escapeCnt)归零
目的:避免使用过时的状态数据,确保技能从干净的状态开始执行。
第二部分:变量初始化
int vecNumber = task().executor; // 执行该任务的机器人编号
CGeoPoint target = task().player.pos; // 任务指定的目标位置
CGeoPoint purposeTarget = CGeoPoint(...) // 从kickpower和chipkickpower构造特殊目标点
const PlayerVisionT& self = pVision->ourPlayer(vecNumber); // 获取己方机器人视觉信息
const double self2BallDir = ... // 计算机器人到球的方向角
const CGeoPoint interPoint = ... // 预测对方的拦截点
const double self2InterPoint = ... // 计算到拦截点的距离第三部分:拉扯目标点判断
这是关键的逻辑判断部分:
//需要拉扯的点赋值
//如果给了那优先给的点 如果没给则离球200mm的点
if(Utils::IsInField(purposeTarget) && purposeTarget.dist(target) > 1000){
purposeMode = true; // 启用特定目的地模式
} else {
purposeMode = false; // 使用默认模式
// 默认目标点:在球后方200mm处(避球方向)
purposeTarget = pVision->ball().RawPos() + CVector(-200,0).rotate(self2BallDir);
}判断逻辑:
如果
purposeTarget在场地内 且 距离target超过1000mm:- 说明上层策略给定了明确的拉扯目标点
- 启用
purposeMode,优先使用该指定点
否则:
- 使用默认模式
- 自动计算目标点:在球的反方向200mm处
- 注释说明:避免直接站在球上(因为启用了避球标志)
GOTO/FREE 状态跳转
if (_state == GOTO || _state == FREE)
{
//如果到点了
// now_state = "Normal GOTO";
if (target.dist(self.RawPos()) < PARAM::Vehicle::V2::PLAYER_SIZE * 2)
{ // 机器人距离目标点是否小于 2 倍车体尺寸(约到达目标点)
int enemyMarkCar = -999;
std::vector<int> enemyNumVec;
//获取有几台敌方车会比我方车先到截球点
int num = getEnemyAmountInArea(interPoint, self2InterPoint, enemyNumVec, 200, pVision);
// GDebugEngine::Instance()->gui_debug_msg(CGeoPoint(0, 2000), QString("num:
// %1").arg(QString::number(num)).toLatin1(), COLOR_PURPLE);
//获取敌方最优防守车
if (num > 0)
{
for (int i = 0; i < num; i++)
{
auto &enemy = pVision->theirPlayer(enemyNumVec[i]);
if (enemy.Valid())
{
double tmpDist = enemy.Pos().dist(self.RawPos());
if (tmpDist < markDist)
{
markDist = tmpDist;
enemyMarkCar = enemyNumVec[i];
// 记录最近的敌方车
// markDist -= 200;
}
}
}
}
enemyNum = enemyMarkCar;
//如果有敌方车在防守则进入跑位状态
if (enemyNum > 0)
{ // 有威胁 → 被盯防状态
_state = MARKED;
}
else
{ // 无威胁 → FREE 状态
_state = FREE;
enemyNum = -999;
freeBallDist = 3000;
}
}
else
{
//还没到呢,继续跑目标点
_state = GOTO;
}
}这段代码是 GOTO/FREE 状态的核心决策逻辑,负责检测机器人是否到达目标点,并根据敌方威胁情况进行状态转换。
if (_state == GOTO || _state == FREE) // 当前处于前往目标点或自由状态第一层判断:是否到达目标点
if (target.dist(self.RawPos()) < PARAM::Vehicle::V2::PLAYER_SIZE * 2)判断条件:机器人距离目标点是否小于 2 倍车体尺寸(约到达目标点)
情况A:已到达目标点 → 威胁评估模块
步骤1:扫描威胁区域
int enemyMarkCar = -999;
std::vector<int> enemyNumVec;
int num = getEnemyAmountInArea(interPoint, self2InterPoint, enemyNumVec, 200, pVision);- 功能:在预测的拦截点(
interPoint)周围搜索敌方车辆 - 搜索半径:
self2InterPoint + 200(己方到拦截点的距离 + 200mm 缓冲) - 目的:找出所有能比己方车更早到达拦截点的敌方车辆
步骤2:识别最危险的防守车
if (num > 0) {
for (int i = 0; i < num; i++) {
auto &enemy = pVision->theirPlayer(enemyNumVec[i]);
if (enemy.Valid()) {
double tmpDist = enemy.Pos().dist(self.RawPos());
if (tmpDist < markDist) {
markDist = tmpDist;
enemyMarkCar = enemyNumVec[i]; // 记录最近的敌方车
}
}
}
}
enemyNum = enemyMarkCar;筛选标准:在威胁区域内的所有敌方车中,选择距离己方车最近的车辆作为主要防守对象
- 遍历所有威胁车辆
- 计算每辆敌方车到己方车的距离
- 保留距离最小的敌方车编号
步骤3:状态转换决策
if (enemyNum > 0) {
_state = MARKED; // 有威胁 → 被盯防状态
} else {
_state = FREE; // 无威胁 → 自由状态
enemyNum = -999;
freeBallDist = 3000;
}决策逻辑:
- ✅ 有敌方车威胁 → 转入
MARKED状态(准备拉扯跑位) - ✅ 无敌方车威胁 → 转入
FREE状态(保持自由等待)
情况B:未到达目标点
else {
_state = GOTO; // 继续前往目标点
}保持 GOTO 状态,继续移动到目标位置。
拉扯方向计算
CGeoPoint ball = pVision->ball().RawPos();
//如果传了waitpos就换点
if (purposeMode)
{
ball = purposeTarget;
}
double judgeNum = -1;
double self2BallAngle = Utils::Normalize((ball - self.RawPos()).dir());
double self2BallDist = self.RawPos().dist(ball);
double enemy2BallDist = 99999;
double enemy2selfDist = 99999;
double enemy2InterPointDist = 99999;
if (enemyNum > 0)
{ // 存在标记的敌方防守车
judgeNum = // 二维叉积(Cross Product)计算
((ball.x() - self.X()) * (pVision->theirPlayer(enemyNum).Y() - self.Y()) -
(pVision->theirPlayer(enemyNum).X() - self.X()) * (ball.y() - self.Y())) *
(purposeMode ? -1 : 1); //判断公式,正值为顺时针,负为逆时针 // purposeMode下需要反拉
enemy2BallDist = pVision->theirPlayer(enemyNum).Pos().dist(ball);
enemy2selfDist = pVision->theirPlayer(enemyNum).Pos().dist(self.RawPos());
enemy2InterPointDist = pVision->theirPlayer(enemyNum).Pos().dist(interPoint);
}这段代码是 几何关系计算模块,为后续的拉扯方向决策提供关键的空间位置数据。
第一部分:参考点确定
CGeoPoint ball = pVision->ball().RawPos();
if (purposeMode) {
ball = purposeTarget; // 使用特定拉扯点代替真实球位置
}作用:根据模式选择参考点
- 普通模式:使用真实球位置
- 特定目标模式(
purposeMode):使用预设的拉扯目标点
这个灵活切换确保后续计算始终围绕"关注的核心点"进行。
第二部分:空间变量初始化
double judgeNum = -1; // 方向判断值(待计算)
double self2BallAngle = Utils::Normalize((ball - self.RawPos()).dir()); // 己方车到球的角度
double self2BallDist = self.RawPos().dist(ball); // 己方车到球的距离
double enemy2BallDist = 99999; // 敌方车到球的距离(默认极大值)
double enemy2selfDist = 99999; // 敌方车到己方车的距离
double enemy2InterPointDist = 99999; // 敌方车到拦截点的距离初始化策略:
- ✅ 立即计算己方相关数据(已知信息)
- ⏸️ 敌方相关数据先设为极大值(待有效敌方车时更新)
第三部分:敌方威胁几何分析
核心:方向判断算法(judgeNum)
if (enemyNum > 0) { // 存在标记的敌方防守车
judgeNum =
((ball.x() - self.X()) * (enemy.Y() - self.Y()) -
(enemy.X() - self.X()) * (ball.y() - self.Y())) *
(purposeMode ? -1 : 1);这是一个二维叉积(Cross Product)计算:
judgeNum=v1×v2=(x1⋅y2−x2⋅y1)
其中:
- v1 = 从己方车指向球的向量
- v2 = 从己方车指向敌方车的向量
判断逻辑:
| judgeNum 符号 | 几何含义 | 拉扯方向 |
|---|---|---|
| 正值 (+) | 敌方车在己方→球连线的右侧(顺时针) | 向左拉扯 |
| 负值 (-) | 敌方车在己方→球连线的左侧(逆时针) | 向右拉扯 |
特殊处理:
* (purposeMode ? -1 : 1) // purposeMode下需要反拉- 普通模式:远离敌方车拉扯
- 特定目标模式:可能需要反向拉扯以达到目标点
可视化示意:
球 ⚽
↑
|
己方车 🤖 --- 敌方车 👾 (judgeNum > 0,敌方在右侧)
拉扯方向: ←(向左,远离敌方车)距离数据更新
enemy2BallDist = enemy.Pos().dist(ball); // 敌方→球
enemy2selfDist = enemy.Pos().dist(self.RawPos());// 敌方→己方
enemy2InterPointDist = enemy.Pos().dist(interPoint); // 敌方→拦截点这三个距离用于后续状态判断:
- enemy2BallDist:判断敌方是否靠近球
- enemy2selfDist:计算拉扯距离
- enemy2InterPointDist:评估敌方是否能成功拦截
MARKED 状态调转
if (_state == MARKED)
{ // 计算反拉扯目标点并决定下一步状态转换
// now_state = "MARKED";
if (self.Vel().mod() < 100)
{ // 己方车速度小于100mm/s
v1.setVector(3 * (enemy2selfDist > 500 ? enemy2selfDist : 500), 0);
// 计算反拉扯向量 v1
v1 = v1.rotate(self2BallAngle + (judgeNum > 0 ? 1 : -1) * 90 * PARAM::Math::PI / 180);
// 根据前面叉积算出来的拉扯方向决定是往左转90°还是往右转90°
antiTarget = self.RawPos() + v1;
// 计算最终反拉扯目标点
if (purposeMode && pVision->theirPlayer(enemyNum).Pos().dist(purposeTarget) - 200 >
self.RawPos().dist(purposeTarget))
{ // 己方已经更靠近目标点,无需拉扯,直接尝试脱离防守
_state = ESCAPE; // 直接逃脱
}
else
{
//如果直线碰到禁区线则退出
for (int i = 0; i < 6; i++)
{ // 遍历6条禁区边界线(敌我双方各3条)
if (CGeoSegment(self.RawPos(), antiTarget)
.IsSegmentsIntersect(PENALTY_BORDER[i]))
{ // 检查从当前位置到 antiTarget 的路径是否与禁区相交
_state = BLOCK; // 如果相交 → 转入 BLOCK 状态(需要绕行)
break;
}
_state = ANTIDRAG; // 如果安全 → 转入 ANTIDRAG 状态(开始反拉扯)
}
}
}
}这段代码是 MARKED 状态的核心处理逻辑,负责计算反拉扯目标点并决定下一步状态转换。这是拉扯战术的关键决策点。
if (_state == MARKED) {
if (self.Vel().mod() < 100) { // 己方车速度小于100mm/s
// 计算反拉扯点 + 状态转换决策
}
}前置条件:只有当己方车几乎静止时才执行(避免运动中突然改变方向)
步骤1:计算反拉扯向量 v1
v1.setVector(3 * (enemy2selfDist > 500 ? enemy2selfDist : 500), 0);向量长度计算:
- 基础长度 =
敌我距离 × 3(放大系数,确保拉开足够距离) - 最小保证 =
500mm(防止敌方过近时目标点太近)
v1 = v1.rotate(self2BallAngle + (judgeNum > 0 ? 1 : -1) * 90 * PARAM::Math::PI / 180);方向计算:
- 基准方向:
self2BallAngle(己方→球的角度) - 旋转策略:
- 如果
judgeNum > 0(敌方在右侧)→ 逆时针旋转90°(向左拉) - 如果
judgeNum ≤ 0(敌方在左侧)→ 顺时针旋转90°(向右拉)
- 如果
几何可视化:
场景A: judgeNum > 0 (敌方在右)
球 ⚽
↑
|
己方🤖 ←─── 敌方👾
|
antiTarget ⭐ (向左拉扯)
场景B: judgeNum < 0 (敌方在左)
球 ⚽
↑
|
敌方👾 ───→ 己方🤖
|
⭐ antiTarget (向右拉扯)antiTarget = self.RawPos() + v1; // 计算最终反拉扯目标点步骤2:状态转换决策树
分支1:特定目标模式优先检查
if (purposeMode &&
pVision->theirPlayer(enemyNum).Pos().dist(purposeTarget) - 200 >
self.RawPos().dist(purposeTarget))
{
_state = ESCAPE; // 直接逃脱
}条件:
- ✅ 处于特定目标模式
- ✅ 敌方车到目标点的距离 > 己方到目标点的距离 + 200mm
逻辑:己方已经更靠近目标点,无需拉扯,直接尝试脱离防守
分支2:禁区碰撞检测
else {
for (int i = 0; i < 6; i++) {
if (CGeoSegment(self.RawPos(), antiTarget)
.IsSegmentsIntersect(PENALTY_BORDER[i]))
{
_state = BLOCK; // 路径被禁区阻挡
break;
}
_state = ANTIDRAG; // 路径安全,执行反拉扯
}
}检测逻辑:
- 遍历6条禁区边界线(敌我双方各3条)
- 检查从当前位置到
antiTarget的路径是否与禁区相交 - 如果相交 → 转入
BLOCK状态(需要绕行) - 如果安全 → 转入
ANTIDRAG状态(开始反拉扯)
注意:这个循环有个逻辑小瑕疵
for (int i = 0; i < 6; i++) {
if (相交) {
_state = BLOCK;
break; // 发现相交立即停止
}
_state = ANTIDRAG; // 每次循环都会执行(除非break)
}实际效果:只要有任何一条边相交就是 BLOCK,否则是 ANTIDRAG
状态转换流程图
MARKED 状态(被盯防)
↓
速度 < 100?
↓ 是
计算 antiTarget(垂直于球方向的拉扯点)
↓
purposeMode且更接近目标?
↓ 是 ↓ 否
ESCAPE 路径穿过禁区?
↓ 是 ↓ 否
BLOCK ANTIDRAGANTIDRAG 预拉扯
if (_state == ANTIDRAG) // 预拉扯阶段
{ // 己方车已经开始向 antiTarget 移动,此时监视敌方是否跟随,并根据其反应决定下一步。
// now_state = "ANTIDRAG";
antiCnt = pVision->theirPlayer(enemyNum).Vel().mod() < 300 ? antiCnt + 1 : 0;
if (antiCnt > CHECK_MARK_TIME)
{ // 等了 72 帧了(一秒左右),敌方车都不带动的,那么拉扯无意义,直接切换到 ESCAPE
antiCnt = 0;
_state = ESCAPE;
}
if (pVision->theirPlayer(enemyNum).Vel().mod() > MIN_SPEED_FOR_ENEMY) // 敌方速度超过 1500mm/s
{ // 敌方高速冲来 → 升级为真实拉扯,说明上钩了
_state = REALDRAG;
v2.setVector(3 * (enemy2selfDist > 1000 ? enemy2selfDist : 1000), 0);
v2 = v2.rotate(v1.dir() + PARAM::Math::PI); // v1 的反方向
realTarget = self.RawPos() + v2;
}
antiVelCount = self.RawPos().dist(antiTarget) < 500 ? antiVelCount + 1 : 0;
if (antiVelCount > CHECK_FREE_REDRAG_TIME)
{ // 己方已到达 antiTarget 附近 → 重置拉扯
// 持续20帧后 → 说明己方已经走完了预定路径,但拉扯没有成功,敌方没追也没冲过来
// 重置回 MARKED,重新计算下一个拉扯目标点
_state = MARKED;
antiVelCount = 0;
}
}这段代码是 ANTIDRAG(预拉扯)状态的核心监控逻辑,负责在己方向 antiTarget 移动期间,持续观察敌方反应并决定下一步行动。
1. 敌方未动计数器
antiCnt = pVision->theirPlayer(enemyNum).Vel().mod() < 300 ? antiCnt + 1 : 0;- 每帧检查敌方速度是否 < 300mm/s(基本静止)
- 是 →
antiCnt + 1(累计"敌方没动"的帧数) - 否 → 重置为 0(敌方开始动了,重新计时)
if (antiCnt > CHECK_MARK_TIME) // CHECK_MARK_TIME = 72帧 ≈ 1秒
{
antiCnt = 0;
_state = ESCAPE;
}- 结论:等了约 1 秒,敌方完全不理会己方的假动作
- 应对:拉扯已无意义,直接切
ESCAPE溜向目标点
2. 敌方高速冲来检测
if (pVision->theirPlayer(enemyNum).Vel().mod() > MIN_SPEED_FOR_ENEMY) // > 1500mm/s
{
_state = REALDRAG;
v2.setVector(3 * (enemy2selfDist > 1000 ? enemy2selfDist : 1000), 0);
v2 = v2.rotate(v1.dir() + PARAM::Math::PI); // v1 的反方向
realTarget = self.RawPos() + v2;
}- 敌方速度超过 1500mm/s → 上钩了,升级为真实拉扯
- 计算
realTarget(真实冲刺目标点):- 向量长度:3×max(enemy2selfDist, 1000),即 3 倍敌我距离(至少 3000mm),确保冲出足够远
- 方向:
v1.dir() + π,即与预拉扯方向完全相反,利用敌方惯性将其甩开
- 状态切入
REALDRAG
3. 己方已到达 antiTarget 附近的超时检测
antiVelCount = self.RawPos().dist(antiTarget) < 500 ? antiVelCount + 1 : 0;
if (antiVelCount > CHECK_FREE_REDRAG_TIME) // > 20帧 ≈ 0.28秒
{
_state = MARKED;
antiVelCount = 0;
}- 每帧检查己方是否已到达
antiTarget附近(距离 < 500mm) - 若持续 20 帧都在附近 → 说明己方已完走预定路径,但:
- 敌方没跑(否则
antiCnt会触发 ESCAPE) - 敌方也没冲(否则上面 1500mm/s 判断会触发 REALDRAG)
- 敌方没跑(否则
- 应对:这次假动作失败了,回到
MARKED重新计算一个新的拉扯方向,再试一次
三种出口总结
| 敌方反应 | 触发条件 | 下一状态 | 含义 |
|---|---|---|---|
| 不动 | antiCnt > 72帧 | ESCAPE | 拉扯无效,直接溜 |
| 高速冲来 | 速度 > 1500mm/s | REALDRAG | 上钩,反向甩开 |
| 己方已到点但无反应 | antiVelCount > 20帧 | MARKED | 假动作失败,换方向重试 |
REALDRAG 真实拉扯
if (_state == REALDRAG)
{ // 真实拉扯,敌方已经上钩了,我们可以逗傻子了
// now_state = "REALDRAG";
if (purposeMode) // Lua 给了拉扯点
{
CGeoLine purposeLine(self.RawPos(), purposeTarget); // 己方→目标点的直线
CGeoSegment purposeSegment(self.RawPos(), purposeTarget); // 己方→目标点的线段
CGeoPoint purposeProjection =
purposeLine.projection(pVision->theirPlayer(enemyNum).Pos()); // 敌方到直线的垂足
if (purposeSegment.IsPointOnLineOnSegment(purposeProjection) &&
// 垂足在线段上:说明敌方的"拦截点"确实在己方前进路径中
self.RawPos().dist(purposeProjection) <
pVision->theirPlayer(enemyNum).Pos().dist(purposeProjection) &&
// 己方比敌方更靠近垂足:说明己方已经在敌方前面,敌方无法提前拦截
pVision->theirPlayer(enemyNum).Pos().dist(purposeProjection) > 70)
// 敌方距垂足 > 70mm : 敌方离路径有足够距离,不构成有效拦截
{ // 判断拦截路径是否已被清空,三个条件同时满足才能切换到 ESCAPE
_state = ESCAPE;
}
}
else if (enemy2InterPointDist >
(self2InterPoint > 500 ? self2InterPoint : (self2InterPoint + CHECK_FREE_DIST)))
// 当己方离拦截点较远时(>500mm):只要敌方比己方更远就切 BLOCK
// 当己方已经很近时(≤500mm):要求敌方还要额外比己方远300mm(更严格的条件,防止误判)
// 意思是:己方通过拉扯已经比敌方更靠近球的拦截点 → 拉扯成功
{ // 普通模式下的脱离判断,比较敌我到拦截点的距离
_state = BLOCK; // 拉扯成功,转入 BLOCK 做防守站位
}
realCnt = self.RawPos().dist(realTarget) < 1000 ? realCnt + 1 : 0;
if (realCnt > CHECK_FREE_REDRAG_TIME)
{ // 说明己方已完成反向冲刺,但没有触发任何成功退出条件
_state = MARKED; // 重置回 MARKED,重新结算拉扯方向
realCnt = 0;
}
}这段代码是 REALDRAG 状态的处理逻辑,是整个拉扯战术的收尾判断阶段——判断真实拉扯是否成功,并决定何时脱离。
REALDRAG 是"真实拉扯阶段":己方车正在向 realTarget(与 antiTarget 反方向)高速冲去,敌方已经上钩并被拖拽。此时需要实时监测拉扯是否完成。
分支1:特定目标模式下的脱离判断
if (purposeMode) {
CGeoLine purposeLine(self.RawPos(), purposeTarget); // 己方→目标点的直线
CGeoSegment purposeSegment(self.RawPos(), purposeTarget); // 己方→目标点的线段
CGeoPoint purposeProjection = purposeLine.projection(enemy.Pos()); // 敌方到直线的垂足
if (purposeSegment.IsPointOnLineOnSegment(purposeProjection) // 条件1
&& self.RawPos().dist(purposeProjection) < enemy.Pos().dist(purposeProjection) // 条件2
&& enemy.Pos().dist(purposeProjection) > 70) // 条件3
{
_state = ESCAPE;
}
}核心思路:计算敌方车到"己方→目标点连线"的垂足,判断拦截路径是否已被清空。
三个条件同时满足才能切换到 ESCAPE:
| 条件 | 含义 |
|---|---|
| 条件1:垂足在线段上 | 敌方的"拦截点"确实在己方前进路径中(而不是在延长线外) |
| 条件2:己方比敌方更靠近垂足 | 己方已经在敌方前面,敌方无法提前拦截 |
| 条件3:敌方距垂足 > 70mm | 敌方离路径有足够距离,不构成有效拦截 |
几何可视化:
条件满足时(可以ESCAPE):
目标点 ⭐
↑
| ← 己方前进路径
|
P(垂足,己方比敌方更近)
|
🤖 己方
👾 敌方(距P > 70mm,拦截无效)分支2:普通模式下的脱离判断
else if (enemy2InterPointDist >
(self2InterPoint > 500 ? self2InterPoint : (self2InterPoint + CHECK_FREE_DIST)))
{
_state = BLOCK;
}判断逻辑:比较敌我到拦截点的距离
enemy2InterPoint>{self2InterPointself2InterPoint+300若 self2InterPoint>500若 self2InterPoint≤500
- 当己方离拦截点较远时(>500mm):只要敌方比己方更远就切
BLOCK - 当己方已经很近时(≤500mm):要求敌方还要额外比己方远300mm(更严格的条件,防止误判)
战术意义:己方通过拉扯已经比敌方更靠近球的拦截点 → 拉扯成功,转入 BLOCK 做防守站位
分支3:到达 realTarget 后重置
realCnt = self.RawPos().dist(realTarget) < 1000 ? realCnt + 1 : 0;
if (realCnt > CHECK_FREE_REDRAG_TIME) { // 20帧
_state = MARKED;
realCnt = 0;
}逻辑:
- 己方接近
realTarget(距离 < 1000mm)时开始计帧 - 持续20帧后 → 说明己方已完成反向冲刺,但没有触发任何成功退出条件
- 重置回
MARKED,重新结算拉扯方向
ESCAPE
if (_state == ESCAPE)
{ // ESCAPE 的目标是让机器人冲向 purposeTarget,同时监测是否真正成功脱离。
// now_state = "ESCAPE";
if (purposeMode) // Lua 传了拉扯点
{
escapeCnt = (self.RawPos().dist(purposeTarget) < PARAM::Vehicle::V2::PLAYER_SIZE * 2)
? escapeCnt + 1
: 0;
// 持续检测己方是否到达 purposeTarget(距离 < 2倍车体尺寸)
if (escapeCnt > MAX_WAIT_TIME)
{ // 只要一直停留在目标点附近且持续5秒 → 说明任务完成(或陷入僵局)
// 超时退出,切回 GOTO 重新规划
_state = GOTO;
markDist = 99999;
escapeCnt = 0;
}
}
else
{ // 普通模式,冲出去又跑回来
//阶段性位移,位移一会就回去
if (!confirmFreeBallDist)
{
freeBallDist = self2BallDist * 0.6;
// 记录当前距球距离的60%
// 即从当前位置往球跑,当距离缩短到快照值的60%时算"回来了"
confirmFreeBallDist = true;
}
if (self2BallDist < (freeBallDist < 2000 ? 2000 : freeBallDist))
// 如果 freeBallDist < 2000:用 2000mm 作为底线(防止快照距离太小导致立刻回头)
{// 机器人跑向目标,当靠近球超过门槛时,说明拉扯空间已经恢复,切回 GOTO 重新去目标点
_state = GOTO;
markDist = 99999;
confirmFreeBallDist = false;
}
if (enemy2BallDist - self2BallDist > 400 && !(enemy2BallDist > 88888))
{// 己方比敌方更靠近球超过400mm,排除敌方数据无效的情况(88888是敌方不存在时的默认初始值)
// 己方已经在位置博弈中领先,可以进入 FREE 状态静待接球时机,不必再强行跑位。
_state = FREE;
confirmFreeBallDist = false;
}
}
}这段代码是 ESCAPE 状态的处理逻辑,是机器人从拉扯战术成功脱离后、尝试真正摆脱防守的阶段,根据两种模式有截然不同的退出策略。
ESCAPE 状态的触发来源有多个:
MARKED:己方已更靠近purposeTarget,直接尝试脱离ANTIDRAG:敌方一秒内不动,放弃拉扯直接跑REALDRAG:拉扯成功后路径已通畅
ESCAPE 的目标是让机器人冲向 purposeTarget,同时监测是否真正成功脱离。
分支1:Lua 传入了拉扯点
if (purposeMode) {
escapeCnt = (self.RawPos().dist(purposeTarget) < PARAM::Vehicle::V2::PLAYER_SIZE * 2)
? escapeCnt + 1
: 0;
if (escapeCnt > MAX_WAIT_TIME) { // MAX_WAIT_TIME = FRAME_RATE * 5 ≈ 5秒
_state = GOTO;
markDist = 99999;
escapeCnt = 0;
}
}逻辑:
- 持续检测己方是否到达
purposeTarget(距离 < 2倍车体尺寸) - 只要一直停留在目标点附近且持续5秒 → 说明任务完成(或陷入僵局),切回
GOTO重新规划
注意:这里没有"成功"退出,而是超时退出——即到达目标后等待一段时间再重置,给策略层足够的时间决定接下来要做什么。
分支2:Lua 未传入拉扯点,自行计算
这是一个"冲出去又跑回来"的设计,分三步:
步骤1:锁定逃脱基准距离
if (!confirmFreeBallDist) {
freeBallDist = self2BallDist * 0.6; // 记录当前距球距离的60%
confirmFreeBallDist = true;
}- 进入 ESCAPE 后只执行一次,快照当前到球的距离
- 乘以 0.6 作为"跑向球的门槛":即从当前位置往球跑,当距离缩短到快照值的60%时算"回来了"
confirmFreeBallDist标志防止每帧重复更新
步骤2:判断是否"跑回来"了 → 回到 GOTO
if (self2BallDist < (freeBallDist < 2000 ? 2000 : freeBallDist)) {
_state = GOTO;
markDist = 99999;
confirmFreeBallDist = false;
}双重保底:
- 如果
freeBallDist < 2000:用 2000mm 作为底线(防止快照距离太小导致立刻回头) - 如果
freeBallDist ≥ 2000:使用快照的60%距离
机器人跑向目标,当靠近球超过门槛时,说明拉扯空间已经恢复,切回 GOTO 重新去目标点
步骤3:己方已领先 → 转为自由状态
if (enemy2BallDist - self2BallDist > 400 && !(enemy2BallDist > 88888)) {
_state = FREE;
confirmFreeBallDist = false;
}条件:
- 己方比敌方更靠近球超过400mm
!(enemy2BallDist > 88888):排除敌方数据无效的情况(88888是敌方不存在时的默认初始值)
战术意义:己方已经在位置博弈中领先,可以进入 FREE 状态静待接球时机,不必再强行跑位。
两种模式的本质差异
| 对比 | purposeMode | 普通模式 |
|---|---|---|
| 目标 | 冲向指定 purposeTarget | 冲向球的方向 |
| 成功条件 | 到达目标点并等待5秒 | 己方距球更近>400mm |
| 失败/重置 | 超时5秒 → GOTO | 己方靠近球超过门槛 → GOTO |
状态转换总结
ESCAPE 状态(向目标冲去)
│
├─ purposeMode:到达目标且停留 5 秒 ────→ GOTO(重新规划)
│
├─ 普通模式:己方已比敌方近 400mm ──────→ FREE(占位等待)
│
└─ 普通模式:己方已逼近球(跑回来了)──→ GOTO(重新去目标点)BLOCK
if (_state == BLOCK)
{ // BLOCK 状态下,机器人会站在敌方车和球之间的最优拦截位置
// now_state = "BLOCK";
if (self2BallDist < 2000)
{ // 机器人在防守站位过程中,如果发现自己已经很靠近球了,
// 说明防守阵地已经足够前压,不再需要做拦截站位,应该切回 GOTO 直接去执行目标任务。
_state = GOTO;
markDist = 99999;
}
if (pVision->theirPlayer(enemyNum).Vel().mod() < 50)
{// 敌方停止运动
// BLOCK 状态存在的意义是拦截一个正在运动的威胁车辆
// 如果敌方已经停下来,威胁已消除,没有必要继续做拦截站位,切换到 FREE 静待时机。
_state = FREE;
}
}这段代码是 BLOCK 状态的处理逻辑,是整个状态机中最简洁的一个状态,仅有两个独立的退出条件。
BLOCK 状态的触发来源:
MARKED:计算出的拉扯路径穿越禁区,拉扯不安全REALDRAG:普通模式下己方已获得拦截点距离优势
BLOCK 状态下,机器人会执行 getMarkingPoint() 计算出的防守站位(见 switch 的 BLOCK case),即站在敌方车和球之间的最优拦截位置。此状态的监测代码只负责判断何时退出。
两个退出条件
条件1:己方已经靠近球 → 回到 GOTO
if (self2BallDist < 2000) {
_state = GOTO;
markDist = 99999;
}逻辑:己方车与球的距离 < 2000mm(2米)
语义:机器人在防守站位过程中,如果发现自己已经很靠近球了,说明防守阵地已经足够前压,不再需要做拦截站位,应该切回 GOTO 直接去执行目标任务。
同时重置 markDist = 99999,清除对该敌方车的标记记忆,下次重新选择防守对象。
条件2:敌方停止运动 → 转为自由状态
if (pVision->theirPlayer(enemyNum).Vel().mod() < 50) {
_state = FREE;
}逻辑:敌方车速度 < 50mm/s(基本静止)
语义:BLOCK 状态存在的意义是拦截一个正在运动的威胁车辆。如果敌方已经停下来,威胁已消除,没有必要继续做拦截站位,切换到 FREE 静待时机。
两个条件的优先级关系
需要注意这两个 if 是串行非互斥的:
if (self2BallDist < 2000) {
_state = GOTO; // 先设置 GOTO
}
if (enemy.Vel() < 50) {
_state = FREE; // 可能覆盖前面的 GOTO
}如果两个条件同时满足(己方靠近球 且 敌方静止),最终状态将是 FREE(后者覆盖前者)。实际上这是合理的:已经靠近球且敌方静止,直接进入 FREE 等待是最优策略。
状态转换总结
BLOCK 状态(防守拦截站位中)
│
├─ 己方距球 < 2000mm ──────────────→ GOTO(足够近,直接去目标)
│
└─ 敌方速度 < 50mm/s(停下来了)──→ FREE(威胁消除,等待)| 退出条件 | 目标状态 | 战术含义 |
|---|---|---|
self2BallDist < 2000 | GOTO | 己方已前压到位,主动出击 |
enemyVel < 50 | FREE | 威胁消除,保持位置静待 |
FREE 待命
if (_state == FREE)
{ // 原地静止,朝向球,等待时机
// now_state = "FREE";
if (enemy2BallDist - self2BallDist < 200 || // 敌方开始追上己方的距离优势
self2BallDist < (freeBallDist < 2000 ? 2000 : freeBallDist))
// 己方已经足够靠近球,不应该继续傻站着,应该切回 GOTO 主动争球
{
_state = GOTO;
markDist = 99999;
}
}这段代码是 FREE 状态的处理逻辑,是整个状态机中最简短但语义最微妙的一个状态,只有单一的退出判断。
FREE 状态的触发来源:
GOTO/FREE到点评估后:敌方拦截区内无威胁车辆ESCAPE普通模式:己方比敌方更靠近球超过400mmBLOCK:敌方停止运动,威胁消除
FREE 状态下机器人执行 StopRobot()——原地静止,朝向球,等待时机。
退出条件(OR 逻辑)
if (enemy2BallDist - self2BallDist < 200 ||
self2BallDist < (freeBallDist < 2000 ? 2000 : freeBallDist))
{
_state = GOTO;
markDist = 99999;
}两个子条件用 || 连接,任一满足即切回 GOTO:
子条件1:敌方开始追上己方的距离优势
enemy2BallDist - self2BallDist < 200语义:己方比敌方更靠近球的优势缩小到不足 200mm
| 场景 | enemy2BallDist - self2BallDist | 含义 |
|---|---|---|
| 己方明显领先 | 例如 800mm | 继续 FREE,保持静止 |
| 优势收窄 | < 200mm | 敌方追上来了,需要主动跑位 |
| 敌方反超 | 负值 | 同样触发退出 |
战术意义:FREE 状态之所以能静止,是因为己方有位置优势。一旦这个优势被侵蚀,必须立刻重新主动跑位。
子条件2:己方已经很靠近球
self2BallDist < (freeBallDist < 2000 ? 2000 : freeBallDist)与 ESCAPE 状态中完全相同的双重保底逻辑:
门槛=max(freeBallDist,2000mm)
- 如果
freeBallDist ≥ 2000:使用freeBallDist作为门槛 - 如果
freeBallDist < 2000:用 2000mm 保底,防止门槛过低
语义:己方已经足够靠近球,不应该继续傻站着,应该切回 GOTO 主动争球。
FREE 和 GOTO 的对比
| FREE | GOTO | |
|---|---|---|
| 行为 | 原地静止 | 移动到目标点 |
| 适用场景 | 己方有位置优势,等待 | 需要主动移动 |
| 持有条件 | 优势 > 200mm 且离球还远 | — |
状态转换总结
FREE 状态(原地等待,己方有位置优势)
│
└─ 以下任一满足 ──────────────────→ GOTO(主动跑位)
├─ 敌方追近:距球差 < 200mm(优势被蚕食)
└─ 己方已靠近球超过门槛(时机成熟,主动出击)超时强制换位
//强制换位置 escape的位置和goto对换 每五秒换一次
// 兜底保障,确保任何情况下机器人都不会无限期停在同一位置。
freeCount = self.RawPos().dist(task().player.pos) < PARAM::Vehicle::V2::PLAYER_SIZE * 2
? ++freeCount
: 0;
if (freeCount > MAX_WAIT_TIME)
{ // 卡里面了,强制切一下
_state = ESCAPE;
freeCount = 0;
}这段代码是全局超时强制换位机制,独立于所有状态机逻辑之外,在每帧末尾无条件执行。
// 强制换位置 escape的位置和goto对换 每五秒换一次
freeCount = self.RawPos().dist(task().player.pos) < PARAM::Vehicle::V2::PLAYER_SIZE * 2
? ++freeCount
: 0;
if (freeCount > MAX_WAIT_TIME) { // MAX_WAIT_TIME = FRAME_RATE * 5 ≈ 5秒
_state = ESCAPE;
freeCount = 0;
}计数器逻辑
freeCount = 条件 ? ++freeCount : 0;触发条件:self.RawPos().dist(task().player.pos) < PARAM::Vehicle::V2::PLAYER_SIZE * 2
即己方车停留在任务目标点(target)附近(距离 < 2倍车体尺寸)时,freeCount 每帧递增,否则归零。
核心作用:打破僵局
场景还原:
机器人到达 target(GOTO完成)
↓
评估后进入 FREE / MARKED 等状态
↓
由于种种原因一直待在 target 附近(敌方也在僵持)
↓
5秒后 → 强制切到 ESCAPE,冲向 purposeTarget
↓
换了个位置,重置局面为什么需要这个机制:
正常状态转换依赖实时感知数据(敌方速度、距离等),但存在以下无法自然退出的僵局情形:
- 敌方车紧贴己方,速度忽快忽慢,导致状态在 MARKED/ANTIDRAG 之间反复横跳而不前进
- 拉扯无法展开,机器人卡在原地
这5秒的超时机制是兜底保障,确保任何情况下机器人都不会无限期停在同一位置。
与 ESCAPE 状态的关系
注释说"escape的位置和goto对换",意思是:
- 正常时:机器人在
target(GOTO目标点)待着 - 超时后:强制跑到
purposeTarget(ESCAPE目标点)
这两个点通常是策略层设计的一对互补位置——一个是主要站位,另一个是备选走位,每5秒强制在两者之间切换一次,形成周期性的位置交换,持续骚扰敌方防守节奏。
这段代码放在所有状态 if 块之后,意味着它可以强制覆盖任何状态:
MARKED → 超时5秒 → 强制变成 ESCAPE
ANTIDRAG → 超时5秒 → 强制变成 ESCAPE
FREE → 超时5秒 → 强制变成 ESCAPE
...(所有状态均适用)这是整个状态机的最高优先级保险机制,确保系统永不死锁。
边界安全处理
//防止车出场
if (!Utils::IsInField(antiTarget, PARAM::Vehicle::V2::PLAYER_SIZE * 2))
antiTarget = Utils::MakeInField(antiTarget, PARAM::Vehicle::V2::PLAYER_SIZE * 2);
if (!Utils::IsInField(realTarget, PARAM::Vehicle::V2::PLAYER_SIZE * 2))
realTarget = Utils::MakeInField(realTarget, PARAM::Vehicle::V2::PLAYER_SIZE * 2);
//防止车进入禁区
if (Utils::InTheirPenaltyArea(antiTarget, PARAM::Vehicle::V2::PLAYER_SIZE * 2))
antiTarget =
Utils::MakeOutOfTheirPenaltyArea(antiTarget, PARAM::Vehicle::V2::PLAYER_SIZE * 2);
if (Utils::InOurPenaltyArea(antiTarget, PARAM::Vehicle::V2::PLAYER_SIZE * 2))
antiTarget =
Utils::MakeOutOfOurPenaltyArea(antiTarget, PARAM::Vehicle::V2::PLAYER_SIZE * 2);
if (Utils::InTheirPenaltyArea(realTarget, PARAM::Vehicle::V2::PLAYER_SIZE * 2))
realTarget =
Utils::MakeOutOfTheirPenaltyArea(realTarget, PARAM::Vehicle::V2::PLAYER_SIZE * 2);
if (Utils::InOurPenaltyArea(realTarget, PARAM::Vehicle::V2::PLAYER_SIZE * 2))
realTarget =
Utils::MakeOutOfOurPenaltyArea(realTarget, PARAM::Vehicle::V2::PLAYER_SIZE * 2);这段代码是 plan() 函数末尾的边界安全处理部分,分两层防护,确保计算出的目标点合法。
第一层:防止目标点出场地
if (!Utils::IsInField(antiTarget, PARAM::Vehicle::V2::PLAYER_SIZE * 2))
antiTarget = Utils::MakeInField(antiTarget, PARAM::Vehicle::V2::PLAYER_SIZE * 2);
if (!Utils::IsInField(realTarget, PARAM::Vehicle::V2::PLAYER_SIZE * 2))
realTarget = Utils::MakeInField(realTarget, PARAM::Vehicle::V2::PLAYER_SIZE * 2);IsInField(point, margin)检查点是否在场地内,且距边界至少margin(即2 × 车体半径)- 若
antiTarget(反拉扯目标点)或realTarget(真实拉扯目标点)超出场地,则调用MakeInField将其夹回场地内 margin用车体尺寸是为了保证车体本身也不会越界,而不只是圆心在场内
第二层:防止目标点进入禁区
// antiTarget 的禁区检查
if (Utils::InTheirPenaltyArea(antiTarget, PARAM::Vehicle::V2::PLAYER_SIZE * 2))
antiTarget = Utils::MakeOutOfTheirPenaltyArea(antiTarget, PARAM::Vehicle::V2::PLAYER_SIZE * 2);
if (Utils::InOurPenaltyArea(antiTarget, PARAM::Vehicle::V2::PLAYER_SIZE * 2))
antiTarget = Utils::MakeOutOfOurPenaltyArea(antiTarget, PARAM::Vehicle::V2::PLAYER_SIZE * 2);
// realTarget 的禁区检查(同上)
if (Utils::InTheirPenaltyArea(realTarget, ...))
realTarget = Utils::MakeOutOfTheirPenaltyArea(realTarget, ...);
if (Utils::InOurPenaltyArea(realTarget, ...))
realTarget = Utils::MakeOutOfOurPenaltyArea(realTarget, ...);- 分别对敌方禁区和己方禁区做检查
InTheirPenaltyArea / InOurPenaltyArea:带 margin 的禁区判断MakeOutOf...:将点推出禁区边界外(同样保留车体安全距离)
为什么需要这段代码
在前面的拉扯逻辑中,antiTarget 和 realTarget 是通过向量计算得出的:
antiTarget = self.RawPos() + v1; // 反拉扯方向
realTarget = self.RawPos() + v2; // 反向的真实拉扯目标这种纯几何计算不考虑场地边界和禁区规则,计算结果可能落在场外或禁区内。这段代码作为最终兜底修正,在目标点被实际发给运动规划器之前,统一做一次合法性裁剪,避免非法位置导致违规或运动规划异常。
flag
TaskT dragTask(task());
dragTask.player.flag |= PlayerStatus::ALLOW_DSS | PlayerStatus::DODGE_BALL;
// ALLOW_DSS 允许动态速度缩放(Dynamic Speed Scaling)
// 运动规划器可根据障碍情况自动降速,提高安全性和稳定性
// DODGE_BALL 避球这两行是 switch 分发之前的任务初始化与行为标志配置:
第一行:TaskT dragTask(task());
task()返回上层(Lua/策略层)传入的原始任务对象(类型TaskT)TaskT dragTask(task())是拷贝构造,创建一个本地副本dragTask- 目的是在不修改原始任务的前提下,对本帧的执行任务做定制化修改
- 后续
switch中对dragTask.player.pos、dragTask.player.angle等字段的修改,都基于这个副本
第二行:dragTask.player.flag |= PlayerStatus::ALLOW_DSS | PlayerStatus::DODGE_BALL;
用位或赋值在 flag 中追加两个行为标志,不影响已有的其他 flag 位:
| 标志 | 含义 |
|---|---|
ALLOW_DSS | 允许动态速度缩放(Dynamic Speed Scaling),运动规划器可根据障碍情况自动降速,提高安全性和稳定性 |
DODGE_BALL | 主动绕球行进,在路径规划时会把球本身视为障碍物并自动绕开,防止机器人在运动过程中无意间触碰球(在非持球技能中尤为重要) |
为什么这两个标志在这里设置
WDrag 是一个无球跑位/拉扯技能,机器人不应持球也不应碰球,所以:
DODGE_BALL确保在所有 7 种状态(GOTO / ANTIDRAG / REALDRAG 等)的移动中都不会意外碰球ALLOW_DSS则让机器人在高速拉扯过程中仍然保持运动安全裕度
这两个标志统一在 switch 之前设置,避免了在每个 case 分支里重复写,属于所有状态共享的基础行为配置。
任务下发
switch (_state)
{
case GOTO:
// 机器人正在前往 Lua 指定的跑位目标点,尚未到达或尚未发现威胁
GDebugEngine::Instance()->gui_debug_msg(self.RawPos() + CVector(0, 200),
QString("GOTO").toLatin1(), COLOR_PURPLE);
dragTask.player.pos = target;
dragTask.player.angle = self2BallDir;
setSubTask(TaskFactoryV2::Instance()->SmartGotoPosition(dragTask));
break;
case MARKED:
// 机器人已到达目标点,且发现了威胁敌方车,原地停止等待
GDebugEngine::Instance()->gui_debug_msg(self.RawPos() + CVector(0, 200),
QString("MARKED").toLatin1(), COLOR_PURPLE);
setSubTask(TaskFactoryV2::Instance()->StopRobot(dragTask));
break;
case ANTIDRAG:
// 预拉扯阶段:机器人往 antiTarget 方向快速移动
GDebugEngine::Instance()->gui_debug_msg(self.RawPos() + CVector(0, 200),
QString("ANTIDRAG").toLatin1(), COLOR_PURPLE);
GDebugEngine::Instance()->gui_debug_msg(antiTarget, QString("ANTI").toLatin1(),
COLOR_PURPLE);
dragTask.player.pos = antiTarget;
dragTask.player.angle = self2BallDir;
setSubTask(TaskFactoryV2::Instance()->SmartGotoPosition(dragTask));
break;
case REALDRAG:
// 真实拉扯阶段:敌方已经高速冲来,己方立刻反向全速冲刺甩开敌方
GDebugEngine::Instance()->gui_debug_msg(self.RawPos() + CVector(0, 200),
QString("REALDRAG").toLatin1(), COLOR_PURPLE);
dragTask.player.pos = realTarget;
dragTask.player.angle = self2BallDir;
// dragTask.player.vel = finalVelVec;
setSubTask(TaskFactoryV2::Instance()->SmartGotoPosition(dragTask));
break;
case ESCAPE:
// 脱离阶段:拉扯成功,路径已清空,直接冲向 purposeTarget
GDebugEngine::Instance()->gui_debug_msg(self.RawPos() + CVector(0, 200),
QString("ESCAPE").toLatin1(), COLOR_PURPLE);
dragTask.player.pos = purposeTarget;
dragTask.player.angle = self2BallDir;
setSubTask(TaskFactoryV2::Instance()->SmartGotoPosition(dragTask));
break;
case BLOCK:
// 拦截站位阶段:己方站在敌方与球之间的最优拦截点
GDebugEngine::Instance()->gui_debug_msg(self.RawPos() + CVector(0, 200),
QString("BLOCK").toLatin1(), COLOR_PURPLE);
dragTask.player.angle = self2BallDir;
dragTask.player.pos = ZSkillUtils::instance()->getMarkingPoint(
pVision->theirPlayer(enemyNum).Pos(), pVision->theirPlayer(enemyNum).Vel(), 4500, 4500,
450, 3000, pVision->ball().RawPos());
setSubTask(TaskFactoryV2::Instance()->SmartGotoPosition(dragTask));
break;
case FREE:
// 原地等待阶段:己方已具备位置优势,停止运动,朝向球静待时机
GDebugEngine::Instance()->gui_debug_msg(self.RawPos() + CVector(0, 200),
QString("FREE").toLatin1(), COLOR_PURPLE);
markDist = 99999;
dragTask.player.angle = self2BallDir;
// dragTask.player.max_acceleration = MAX_ACC - 200;
setSubTask(TaskFactoryV2::Instance()->StopRobot(dragTask));
break;
default:
// 兜底分支:状态寄了,那就去 Lua 给的原始目标点
GDebugEngine::Instance()->gui_debug_msg(self.RawPos() + CVector(0, 200),
QString("NULL").toLatin1(), COLOR_PURPLE);
dragTask.player.pos = target;
dragTask.player.angle = self2BallDir;
setSubTask(TaskFactoryV2::Instance()->SmartGotoPosition(dragTask));
break;
}
_lastCycle = pVision->getCycle();
_lastState = _state;
return CStatedTask::plan(pVision);
}这段 switch 是 plan() 函数的执行输出层:根据当前状态机的状态,为 dragTask 填写目标位置/朝向,并调用底层运动技能。每帧最终都会落到这里,将状态翻译为机器人指令。
case GOTO
dragTask.player.pos = target; // 上层 Lua 传入的原始目标点
dragTask.player.angle = self2BallDir; // 朝向球
setSubTask(SmartGotoPosition(dragTask));- 机器人正在前往 Lua 指定的跑位目标点,尚未到达或尚未发现威胁
- 使用
SmartGotoPosition:带路径规划的智能导航,会自动绕障
case MARKED
setSubTask(StopRobot(dragTask));- 机器人已到达目标点,且发现了威胁敌方车,原地停止等待
- 此时上层状态机正在计算
antiTarget(反拉扯方向),速度需 < 100mm/s 才能触发计算 - 停车是为了让己方车"站稳",下一帧再决定往哪个方向假动作
case ANTIDRAG
dragTask.player.pos = antiTarget; // 反拉扯目标点(垂直于球-己方连线方向)
dragTask.player.angle = self2BallDir;
setSubTask(SmartGotoPosition(dragTask));- 预拉扯阶段:机器人往
antiTarget方向快速移动 - 同时调试信息额外在
antiTarget位置打出 "ANTI" 标签,便于观察 - 目的是诱骗敌方追过来,若敌方速度超过 1500mm/s 则判定"上钩",升级为
REALDRAG
case REALDRAG
dragTask.player.pos = realTarget; // 反向的真实冲刺目标(v2 方向,与 v1 反向)
dragTask.player.angle = self2BallDir;
// dragTask.player.vel = finalVelVec; // 被注释:曾用直接设速度,现改为位置控制
setSubTask(SmartGotoPosition(dragTask));- 真实拉扯阶段:敌方已经高速冲来,己方立刻反向全速冲刺甩开敌方
realTarget是antiTarget的反方向点,使敌方惯性无法跟上- 注释掉的速度直控说明曾尝试过更激进的速度叠加,目前回退为位置规划
case ESCAPE
dragTask.player.pos = purposeTarget; // 拉扯完成后的真正目的地(接球点/等待点)
dragTask.player.angle = self2BallDir;
setSubTask(SmartGotoPosition(dragTask));- 脱离阶段:拉扯成功,路径已清空,直接冲向
purposeTarget purposeMode下:目标是 Lua 指定的拉扯点;普通模式下:目标是球附近 200mm 处- 此状态下的位置管理逻辑在上方
if (_state == ESCAPE)块中已完成,这里只负责发指令
case BLOCK
dragTask.player.pos = ZSkillUtils::instance()->getMarkingPoint(
theirPlayer(enemyNum).Pos(), // 敌方位置
theirPlayer(enemyNum).Vel(), // 敌方速度(预测运动方向)
4500, 4500, // 场地范围限制
450, // 站位偏置距离
3000, // 最大影响距离
ball.RawPos() // 球的位置(三角站位参考)
);
dragTask.player.angle = self2BallDir;
setSubTask(SmartGotoPosition(dragTask));- 拦截站位阶段:己方站在敌方与球之间的最优拦截点
getMarkingPoint会综合敌方速度和球位,计算出使敌方最难绕过己方的最优位置- 两个退出条件(见上方逻辑):距球 < 2000mm 切 GOTO;敌方停止切 FREE
case FREE
markDist = 99999; // 重置标记距离,清除对敌方的追踪
dragTask.player.angle = self2BallDir;
// dragTask.player.max_acceleration = MAX_ACC - 200; // 曾限制加速度,已注释
setSubTask(StopRobot(dragTask));- 原地等待阶段:己方已具备位置优势,停止运动,朝向球静待时机
- 重置
markDist = 99999是为了清除历史标记,下次重新找威胁车 - 注释的加速度限制说明曾考虑过柔和制动,目前直接停车
default
dragTask.player.pos = target;
dragTask.player.angle = self2BallDir;
setSubTask(SmartGotoPosition(dragTask));- 兜底分支:状态值异常时退化为最保守行为——去 Lua 给的原始目标点
- 正常运行时不应触发
贡献者
更新日志
eadb3-WMarking 与 WDrag于