@myclaw163/clawclaw-cli 0.6.68 → 0.6.70

package/src/strategies/goals/warrior-shrimp-top.ts

@@ -1,7 +1,5 @@
-import type { GameState, PlayerInfo, Position } from '../../sdk/types.js';
+import type { GameState, PlayerInfo } from '../../sdk/types.js';
 import { Action } from '../../sdk/action.js';
-import { planEscape } from '../pathfind/escape-planner.js';
-import { loadWalkableGrid, type WalkableGrid } from '../pathfind/walkable-grid.js';
 import {
   canUseKill,
   corpseAtScene,
@@ -12,7 +10,6 @@ import {
   isKnowledgeTrusted,
   killCooldownSecs,
   killCommitRange,
-  killRangeFor,
   matchesAnyTarget,
   nonTeammatesVisible,
   PROGRESS_INTERVAL_MS,
@@ -23,7 +20,7 @@ import {
 } from '../game-utils.js';
 import type { BehaviorDecision, StrategyContext } from '../types.js';
 import { Goal } from './goal.js';
-import { KEEP_AWAY_BASE_PLAN_OPTS, KeepAwayGoal, type KeepAwayGoalOptions } from './keep-away-goal.js';
+import { KeepAwayGoal, type KeepAwayGoalOptions } from './keep-away-goal.js';
 import { KillVisibleTargetGoal } from './kill-target-goal.js';
 import { SafeTaskOrPatrolGoal } from './safe-task-goal.js';
 
@@ -38,66 +35,19 @@ const STRANGER_KEY = 'warrior-stranger-distance';
 // 尸体现场灭口开关：false=站在尸体旁也绝不因「身边有未报警的身份不明者」先手灭口，只报警（hostile/启动目标仍按 P1 追杀）；
 // true=刀可用时先击杀尸体旁最近的非 trusted 非队友。关掉是为根治「把尸体边未报警的无辜虾当凶手灭口」的误杀。
 const CORPSE_SCENE_KILL_ENABLED: boolean = false;
-// 自卫总开关：false=遇到被怀疑者一律只回避（绝不变向试探、绝不自卫出刀），等同纯回避档；true=启用下方绝境自卫流程。
-const SELF_DEFENSE_ENABLED: boolean = true;
-// 自卫出刀只能由「主动变向试探 + 验证对方跟随」达成，绝不靠被动转角/方位判定——那些会被走廊弯曲、寻路曲线、
-// 贴身掠过污染（对方只是顺着走廊转、并非在追我，却累积出大转角）。流程：
-// ① 同一被怀疑者连续 JUKE_STREAK 帧「朝我贴身追击」（aimedPursuit：相对上帧位移 ≥ MOVE_EPS 且方向与「指向我」
-//    夹角余弦 ≥ TOWARD_COS；cone 半角≈31.8°）且 planEscape 判定甩不掉 → 被咬住又逃不掉，开始试探；
-// ② 主动横向变一次向（jukeTarget），变向幅度足够大，使「不跟随者」必然掉出 cone；
-// ③ 变向后 JUKE_WINDOW 帧内，比较对方【变向前朝向 hBefore】与【当前朝向 hNow】：朝向变化(hNow−hBefore)沿我 juke
-//    方向偏转 reaim≥MARGIN、且当前朝向仍对准我新位置 = 跟随一次（jukeFollowed）。只认对方朝向【响应我变向】的再
-//    瞄准——同向匀速通勤的虾朝向恒定(hNow≈hBefore，reaim≈0)，无论它是否恰好直行掠过我旧位置都攒不到跟随；走廊弯
-//    曲/几何发散一概不算。变向后第 1 帧对方因反应延迟可能短暂未转向，故用 WINDOW 容忍这一帧；窗口内始终不跟 → 重置。
-// ④ 攒够 JUKE_FOLLOWS 次跟随、且已进 killRangeFor 射程、视线无墙，才出刀（趁 160 射程在合拢阶段先手，蟹只有 80）。
-const SELF_DEFENSE_JUKE_STREAK = 2;
-const SELF_DEFENSE_JUKE_WINDOW = 3;
-const SELF_DEFENSE_JUKE_FOLLOWS = 2;
-const SELF_DEFENSE_MOVE_EPS = 40;
-const SELF_DEFENSE_TOWARD_COS = 0.85;
-// 跟随判定的「再瞄准余量」：变向后对方【朝向变化】(hNow−hBefore)沿我 juke 方向的分量须达到这个余量，才算它响应了
-// 我的变向。同向匀速通勤者朝向恒定、朝向变化≈0 → reaim≈0 天然被拒；真跟随者转向追我新位置、朝向变化沿 juke 方向 →
-// reaim 为正（近距离 >0.2，越远越小但仍 ≫ 位置噪声）。取一个略高于噪声（≪0.01）的小正数即可分开两者；过大会误拒
-// 中远距离的真跟随者、削弱真自卫。
-const SELF_DEFENSE_REAIM_MARGIN = 0.05;
-// 主动变向试探：横向位移目标距离；方向以横向为主、略带「背离对方」分量以免试探时丢距离；落点至少这么远才算有效变向。
-const SELF_DEFENSE_JUKE_DIST = 170;
-const SELF_DEFENSE_JUKE_LATERAL = 0.85;
-const SELF_DEFENSE_JUKE_AWAY = 0.45;
-const SELF_DEFENSE_JUKE_MIN_MOVE = 60;
 
 type ProgressTier = 'flee-bad' | 'keep-distance' | 'task';
 
-/** 单位向量；长度过小（重合）返回 null。 */
-function unitVec(x: number, y: number): { x: number; y: number } | null {
-  const m = Math.hypot(x, y);
-  if (m < 1e-6) return null;
-  return { x: x / m, y: y / m };
-}
-
-/** 两点世界坐标连线是否整段可走（无墙）。沿线段每半格采样一次，任一采样点落在墙上即判被挡。 */
-function segmentWalkable(grid: WalkableGrid, ax: number, ay: number, bx: number, by: number): boolean {
-  const span = Math.hypot(bx - ax, by - ay);
-  const steps = Math.max(1, Math.ceil(span / (grid.tileSize * 0.5)));
-  for (let i = 0; i <= steps; i++) {
-    const t = i / steps;
-    const x = ax + (bx - ax) * t;
-    const y = ay + (by - ay) * t;
-    if (!grid.isWalkable(Math.floor(x / grid.tileSize), Math.floor(y / grid.tileSize))) return false;
-  }
-  return true;
-}
-
 /**
  * 带刀虾·记忆进阶版（武士虾/枪虾，带刀好人）。好人阵营但能出刀，按行为表的优先级逐条判断：
  *
  * - P0 发现尸体：旁边是 hostile/启动猎杀目标且刀可用 → 现场先手击杀；未报警的身份不明者默认不灭口
  *   （CORPSE_SCENE_KILL_ENABLED，根治误杀）；否则报警（靠近至可报距离）。
- * - P1 处理危险：坏人（启动参数 / 知识库 hostile）刀好就追杀；
- *   其余非 trusted 一律按「被怀疑」处理（未标记 = 默认被怀疑，不再有 suspect 标记），默认只回避，绝不仅凭怀疑或被动观察出刀——
- *   只有被同一个被怀疑者持续贴身追击、主动变向试探验证它跟着我变向咬住、退无可退才自卫先手
- *   （实战里真凶常没来得及标记就追杀，故对所有被怀疑者都适用，不要求先标记）；坏人刀冷时硬躲所有非好人；
- *   无可信同伴且单个被怀疑者贴近（未触发自卫）→ 按普通虾 B 档先拉开距离（多人互为目击者则照常做任务）。
+ * - P1 处理危险：**只对【已确认 hostile】（启动参数 / 知识库 hostile）出刀**——刀好就追杀，刀冷就硬躲所有非好人。
+ *   其余非 trusted 一律按「被怀疑」处理（未标记 = 默认被怀疑）：**只回避、绝不出刀**——无可信同伴且单个被怀疑者
+ *   贴近 → 按普通虾 B 档先拉开距离（多人互为目击者则照常做任务）。
+ *   （历史上的「贴身追击判定 + 诱饵试探 + 绝境自卫反杀」整套已删除：几何上无法把「贴身跟我观察的好人」和「贴身追我的
+ *   凶手」区分开，自卫出刀迟早误杀同阵营好人、触发 warrior_shrimp_self_destruct 直接崩盘，代价远大于收益。）
  * - P2 紧急任务：无危险时优先处理。
  * - P3 兜底：做任务 / 巡逻
  *   （SafeTaskOrPatrolGoal：测地最近、威胁旁/途经威胁的任务硬排除、带粘性）。
@@ -115,31 +65,11 @@ export class WarriorShrimpTop extends Goal {
   );
   private readonly strangerSeenAt = new Map<string, number>();
   private witnessExempt = false;
-  /** 自卫：当前被判定在追我的被怀疑者 key、它上一帧坐标、它本帧朝向、连续「朝我贴身追击」帧数（决定何时开始试探）、
-   *  变向后等待对方跟随的剩余帧数（0=未在等）、发起变向那刻我的坐标（验证跟随用）、已验证的跟随次数、
-   *  本轮是否已推过自卫简报。 */
-  private selfDefenseTargetKey: string | null = null;
-  private selfDefensePursuerPrev: { x: number; y: number } | null = null;
-  /** 追击者本帧朝向（上一帧→本帧的单位位移），aimedPursuit 每帧维护；jukeFollowed 用它判定对方是否响应我变向改朝向。 */
-  private selfDefensePursuerHeading: { x: number; y: number } | null = null;
-  private selfDefenseStreak = 0;
-  private selfDefenseJukeWatch = 0;
-  private selfDefenseJukeFromPos: { x: number; y: number } | null = null;
-  /** 发起变向那刻追击者的朝向（hBefore）：jukeFollowed 比较它与变向后当前朝向的【变化】，判定对方是否真的转向追我新位置。 */
-  private selfDefenseJukePursuerHeading: { x: number; y: number } | null = null;
-  private selfDefenseJukeFollows = 0;
-  private selfDefenseAlerted = false;
 
   constructor(private readonly huntTargets: string[] = []) {
     super();
   }
 
-  /** warrior-memory 开会后不重建 Top（resetOnMeetingResume:false）；自卫追击计数按「连续游荡」语义，
-   *  开会是天然中断点，恢复后从零重算，避免拿会议前的追击 streak 一恢复就秒杀。 */
-  onMeetingResume(): void {
-    this.resetSelfDefense();
-  }
-
   tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
     const visible = nonTeammatesVisible(state, ctx);
     this.updateWitnessMemory(visible, ctx);
@@ -173,17 +103,11 @@ export class WarriorShrimpTop extends Goal {
       const huntTargets = threats.filter(p => this.isHuntTarget(p, ctx));
       // P1-A 坏人/启动目标且刀好 → 主动追杀。
       if (killReady && huntTargets.length > 0) {
-        this.resetSelfDefense();
         this.setHunt(this.nearestByDistance(state, huntTargets).name);
         return [];
       }
-      // P1-B 绝境自卫：对被怀疑的贴身追击者（非坏人、非 trusted）——连续确认朝我追击、主动变向试探它每次都跟着咬住、
-      // 已进 160 射程、退无可退、视线无墙，才自卫先下手（趁 reach 优势在合拢阶段先手）+ Agent 自卫简报。
-      // 不要求先标 suspect：实战里真凶常没来得及标记就开始追杀，所以对所有被怀疑者都适用（juke 验证保证不误杀顺路虾）。
-      const selfDefense = this.selfDefenseKill(state, ctx, threats, killReady);
-      if (selfDefense) return selfDefense;
 
-      // P1-C 有坏人/启动目标但刀冷（杀不了）→ 硬躲所有非好人。
+      // P1-B 有坏人/启动目标但刀冷（杀不了）→ 硬躲所有非好人。
       if (huntTargets.length > 0) {
         this.taskGoal.planTask(state, ctx, { holdUnsafeCurrentForMs: TASK_RETURN_INERTIA_MS });
         this.setFlee();
@@ -191,8 +115,8 @@ export class WarriorShrimpTop extends Goal {
         return [];
       }
 
-      // P1-D 只剩被怀疑者：无可信同伴且单个贴近、且未被目击者豁免 → 按普通虾 B 档拉开距离；
-      // 多个被怀疑者互为目击者（witnessExempt）则不后撤，落到下面照常做任务（自卫追踪已在 selfDefenseKill 内按需维护）。
+      // P1-C 只剩被怀疑者（无已确认坏人）：无可信同伴且单个贴近、且未被目击者豁免 → 按普通虾 B 档拉开距离（只回避，绝不出刀）；
+      // 多个被怀疑者互为目击者（witnessExempt）则不后撤，落到下面照常做任务。
       const trustedVisible = visible.some(p => this.isTrusted(p, ctx));
       const worker = this.subGoal;
       const suspectedClose = threats.some(p =>
@@ -204,8 +128,6 @@ export class WarriorShrimpTop extends Goal {
         this.emitProgress(state, ctx, visible, 'keep-distance');
         return [];
       }
-    } else {
-      this.resetSelfDefense();
     }
 
     // ── P2 紧急任务 ──
@@ -235,7 +157,7 @@ export class WarriorShrimpTop extends Goal {
     this.witnessExempt = this.strangerSeenAt.size >= WITNESS_EXEMPT_COUNT;
   }
 
-  /** 被怀疑者：非 trusted（好人）且非坏人/启动目标——未标记的默认就落这档，对应 B 档保持距离 + 绝境自卫。 */
+  /** 被怀疑者：非 trusted（好人）且非坏人/启动目标——未标记的默认就落这档，对应 B 档保持距离（只回避、绝不出刀）。 */
   private isSuspected(p: PlayerInfo, ctx: StrategyContext): boolean {
     return !this.isTrusted(p, ctx) && !this.isHuntTarget(p, ctx);
   }
@@ -278,222 +200,6 @@ export class WarriorShrimpTop extends Goal {
       .sort((a, b) => a.d - b.d)[0].p;
   }
 
-  /**
-   * 自卫击杀 / 变向试探：只处理「被怀疑者」（非坏人、非 trusted）持续贴身追击的情形（坏人在上面已优先追杀/硬躲）。
-   * 实战里真凶往往还没被标记就开始追杀，所以这里对所有被怀疑者都适用，不要求先标 suspect——juke 验证保证只杀真在追我的。
-   * 出刀只能由「主动变向 + 验证对方跟随」达成，绝不靠被动转角/方位，避免「对方只是顺着走廊转、并非在追我」被误判。
-   * 每帧：
-   * ① aimedPursuit 判定本帧是否「朝我贴身追击」，维护连续帧数（变向等待期内的一帧不朝我是预期的反应延迟，先容忍）。
-   * ② 若处在变向等待期：它重新指向我的新位置 = 跟随一次（攒一次）；窗口内始终不重新瞄准 = 没跟 → 重置。
-   * ③ 攒够 SELF_DEFENSE_JUKE_FOLLOWS 次跟随、已进 killRangeFor 射程、planEscape 判定甩不掉、视线无墙 → 出刀，
-   *    并给 Agent 推一条「被动自卫」简报（区别于主动猎杀，免得之后发言/投票露馅）。
-   * ④ 否则若已被贴身追够 JUKE_STREAK 帧、甩不掉、且不在等待期 → 主动横向变一次向逼它暴露（窄道无处可变才交回常规逃跑）。
-   *
-   * 趁 reach 优势：武士虾出刀范围(160)远大于蟹(80)，确认在追后在合拢阶段先手，而不是等贴脸拼手速。出刀确认前
-   * 不清零追击状态——空刀（极端情况）下进度不该白丢；真杀掉后对方消失，下一帧威胁清空自然重置。
-   */
-  private selfDefenseKill(
-    state: GameState,
-    ctx: StrategyContext,
-    threats: PlayerInfo[],
-    killReady: boolean,
-  ): BehaviorDecision[] | null {
-    if (!SELF_DEFENSE_ENABLED) return null; // 开关关闭：直接回退到「只回避」，不进入任何试探/出刀逻辑。
-    // 目击者豁免同样限制自卫：现场≥2 个互为目击者的被怀疑者时不试探、不出刀。人多时蟹不敢当众动手（嫌疑会落到自己头上），
-    // 而拥挤又会把自卫的「退无可退」前提（escapeHopeless 把在场每个人都当障碍）刷成恒真；此档只做任务/回避，杜绝在人堆里误杀。
-    if (this.witnessExempt) {
-      this.resetSelfDefense();
-      return null;
-    }
-    const pursuers = threats.filter(p => !this.isHuntTarget(p, ctx));
-    if (pursuers.length === 0) {
-      this.resetSelfDefense();
-      return null;
-    }
-    const nearest = this.nearestByDistance(state, pursuers);
-    const aimed = this.aimedPursuit(state, nearest);
-
-    if (!killReady) return null;
-
-    // 维护「朝我贴身追击」连续帧数（决定何时开始试探）。某帧不再朝我 = 追击中断，清零进度但【保留当前目标身份】
-    // 继续跟它（softResetPursuit，不是 resetSelfDefense——后者会把目标也丢掉、下一帧又当「第一次见到」永远攒不起来）。
-    // 例外：变向等待期内的一帧不朝我是预期的反应延迟，先容忍不清零。
-    if (aimed) {
-      this.selfDefenseStreak++;
-    } else if (this.selfDefenseJukeWatch === 0) {
-      this.softResetPursuit();
-      return null;
-    }
-
-    // 变向等待期：它重新指向我的【新】位置 = 跟随一次。但必须等我相对变向起点真的横向拉开够远
-    // （jukeFollowed：站在对方位置看，「我变向前」与「我现在」已分得比 cone 还开）才算数——否则我变向移动还没生效、
-    // 或位移太小直线仍落在 cone 内时，会把「持续朝旧/当前位置走」误判成「响应我变向重新咬住」。窗口内始终凑不出
-    // 一次有效跟随 = 没跟（不是在追我）→ 清零进度重新观察。
-    if (this.selfDefenseJukeWatch > 0) {
-      if (aimed && this.jukeFollowed(state, nearest)) {
-        this.selfDefenseJukeFollows++;
-        this.selfDefenseJukeWatch = 0;
-      } else if (--this.selfDefenseJukeWatch === 0) {
-        this.softResetPursuit();
-        return null;
-      }
-    }
-
-    const hopeless = this.escapeHopeless(state, threats);
-    const d = nearest.distance ?? dist(state.you.x, state.you.y, nearest.x, nearest.y);
-    if (
-      this.selfDefenseJukeFollows >= SELF_DEFENSE_JUKE_FOLLOWS
-      && d <= killRangeFor(state.you.role)
-      && hopeless
-      && this.hasShotLine(state, nearest)
-    ) {
-      this.clearSub();
-      if (!this.selfDefenseAlerted) {
-        this.selfDefenseAlerted = true;
-        ctx.notifications.push(`连续确认被${nearest.name}贴身追击、变向试探它每次都跟着咬住、退无可退，自卫先手出刀。`);
-        ctx.agentAlerts.push(
-          `我被${nearest.name}持续贴身追击、几次变向试探它都跟着甩不掉、已被逼到退无可退，刚出于自卫先下手把对方击杀了。`
-          + `这是被动自卫不是主动猎杀：接下来发言/投票按「对方一直追着我跑、我被逼到死角才自保」的口径走，别承认无故先手。`,
-        );
-      }
-      return [{ action: Action.kill(nearest.name) }];
-    }
-
-    // 还没攒够跟随：被贴身追够、甩不掉、且不在等待期时，主动横向变一次向逼它暴露。无处可变（窄道）才交回常规逃跑。
-    if (this.selfDefenseStreak >= SELF_DEFENSE_JUKE_STREAK && this.selfDefenseJukeWatch === 0 && hopeless) {
-      const juke = this.jukeTarget(state, nearest);
-      if (juke) {
-        this.selfDefenseJukeWatch = SELF_DEFENSE_JUKE_WINDOW;
-        this.selfDefenseJukeFromPos = { x: state.you.x, y: state.you.y };
-        // hBefore：变向前对方朝向，jukeFollowed 拿它和窗口内的当前朝向比【变化量】判断是否响应我变向。
-        this.selfDefenseJukePursuerHeading = this.selfDefensePursuerHeading;
-        this.clearSub();
-        return [{ action: Action.move(juke).withThinking('换个方向甩开') }];
-      }
-    }
-    return null;
-  }
-
-  /**
-   * 变向跟随是否成立（对方【朝向变化】响应判定，非几何发散）：比较追击者在我发起变向前的朝向（hBefore）与变向后
-   * 本帧的朝向（hNow），看朝向【变化量】(hNow−hBefore)是否朝我 juke 的方向偏转，且当前朝向确实对准我的新位置：
-   *   · jukeDir = 我从变向起点到现在的实际位移方向（我往哪侧 juke）。
-   *   · reaim = (hNow−hBefore)·jukeDir：对方朝向沿我 juke 方向偏转了多少。
-   * 同向匀速通勤者朝向恒定（hNow≈hBefore）→ reaim≈0 → 判否，与它是否恰好直行掠过我旧位置无关——这正是旧公式的
-   * 漏洞：旧公式只拿【当前朝向】比对【新旧位置】，追击者直行掠过旧位置时「指向旧位置」会翻到它身后，reaim 被刷到
-   * ≈2 误判成跟随。真跟随者为追我的横向变向把朝向转向新位置 → (hNow−hBefore) 沿 jukeDir 为正 → 判真。再加 headingAtNew
-   * 须 ≥ TOWARD_COS，排除「朝向变了但不是冲我新位置来」。不依赖任何固定转角阈值。
-   */
-  private jukeFollowed(state: GameState, pursuer: PlayerInfo): boolean {
-    const from = this.selfDefenseJukeFromPos;
-    const hBefore = this.selfDefenseJukePursuerHeading;
-    const hNow = this.selfDefensePursuerHeading;
-    if (!from || !hBefore || !hNow) return false;
-    // 我相对变向起点还没真的拉开（位移太小）时，朝向变化无从衡量、jukeDir 也是噪声 → 先不判，留给窗口里后续帧。
-    const jukeDir = unitVec(state.you.x - from.x, state.you.y - from.y);
-    if (!jukeDir || dist(from.x, from.y, state.you.x, state.you.y) < SELF_DEFENSE_JUKE_MIN_MOVE) return false;
-    const aimNew = unitVec(state.you.x - pursuer.x, state.you.y - pursuer.y);
-    if (!aimNew) return false;
-    const headingAtNew = hNow.x * aimNew.x + hNow.y * aimNew.y;
-    const reaim = (hNow.x - hBefore.x) * jukeDir.x + (hNow.y - hBefore.y) * jukeDir.y;
-    return headingAtNew >= SELF_DEFENSE_TOWARD_COS && reaim >= SELF_DEFENSE_REAIM_MARGIN;
-  }
-
-  /**
-   * 本帧同一追击者是否「朝我贴身追击」：相对上一帧位移 ≥ MOVE_EPS（确实在动，排除站桩做任务）且位移方向
-   * 与「指向我当前位置」夹角余弦 ≥ TOWARD_COS（朝我来；cone 半角≈31.8°）。换目标时整体重置并返回 false。
-   * 只读对方位移与「指向我」的关系，参考点一致；不累计任何转角（转角会被走廊弯曲污染，确认改由变向跟随负责）。
-   * 注意：这只是【触发器】，不是敌意判别——直线追我与直线通勤在被试探前逐帧完全相同（朝向都恒定、都指向我），
-   * 单凭每帧朝向/方差无法区分；判别力全在 jukeFollowed（试探后对方是否改朝向响应）。顺手把本帧朝向存进
-   * selfDefensePursuerHeading 供其使用（仅在 movedFar 时被消费，故站桩噪声朝向进不去）。
-   */
-  private aimedPursuit(state: GameState, nearest: PlayerInfo): boolean {
-    const key = nearest.name || String(nearest.seat ?? '');
-    const curS = { x: nearest.x, y: nearest.y };
-    if (key !== this.selfDefenseTargetKey) {
-      this.resetSelfDefense();
-      this.selfDefenseTargetKey = key;
-      this.selfDefensePursuerPrev = curS;
-      return false;
-    }
-    const sPrev = this.selfDefensePursuerPrev;
-    this.selfDefensePursuerPrev = curS;
-    if (!sPrev) {
-      this.selfDefensePursuerHeading = null;
-      return false;
-    }
-
-    const heading = unitVec(curS.x - sPrev.x, curS.y - sPrev.y);
-    this.selfDefensePursuerHeading = heading;
-    const aim = unitVec(state.you.x - sPrev.x, state.you.y - sPrev.y);
-    const movedFar = dist(sPrev.x, sPrev.y, curS.x, curS.y) >= SELF_DEFENSE_MOVE_EPS;
-    return !!heading && !!aim && movedFar
-      && heading.x * aim.x + heading.y * aim.y >= SELF_DEFENSE_TOWARD_COS;
-  }
-
-  /** planEscape 判定每条逃跑分支都会在推演内被追上（避不开）；用与 KeepAwayGoal 一致的基线参数。
-   *  这是自卫的【必要条件】（退无可退才试探/出刀），不是敌意证据——死路里它对任何人都恒真、与对方是否敌对无关；
-   *  敌意判别 100% 来自 jukeFollowed 的朝向响应。 */
-  private escapeHopeless(state: GameState, threats: PlayerInfo[]): boolean {
-    const threatPoints = threats.map(p => ({ x: p.x, y: p.y }));
-    return planEscape(state.you, threatPoints, KEEP_AWAY_BASE_PLAN_OPTS).caught;
-  }
-
-  /** 我到目标的连线是否无墙——确认了也别对着墙空刀（target_blocked_by_wall）。 */
-  private hasShotLine(state: GameState, target: PlayerInfo): boolean {
-    return segmentWalkable(loadWalkableGrid(), state.you.x, state.you.y, target.x, target.y);
-  }
-
-  /**
-   * 主动变向试探的落点：垂直于「背离追击者」轴的横向点（略带背离分量以免丢距离），取两侧中离追击者更远、
-   * 且我到落点整段无墙的一侧。两侧都不可走 / 反而明显贴近追击者（窄道、贴墙）时返回 null，交回常规逃跑。
-   */
-  private jukeTarget(state: GameState, pursuer: PlayerInfo): Position | null {
-    const grid = loadWalkableGrid();
-    const me = state.you;
-    const curSep = dist(me.x, me.y, pursuer.x, pursuer.y);
-    const away = unitVec(me.x - pursuer.x, me.y - pursuer.y) ?? { x: 1, y: 0 };
-    const sides = [{ x: -away.y, y: away.x }, { x: away.y, y: -away.x }];
-    let best: { target: Position; sep: number } | null = null;
-    for (const perp of sides) {
-      const dir = unitVec(
-        perp.x * SELF_DEFENSE_JUKE_LATERAL + away.x * SELF_DEFENSE_JUKE_AWAY,
-        perp.y * SELF_DEFENSE_JUKE_LATERAL + away.y * SELF_DEFENSE_JUKE_AWAY,
-      );
-      if (!dir) continue;
-      const raw = { x: me.x + dir.x * SELF_DEFENSE_JUKE_DIST, y: me.y + dir.y * SELF_DEFENSE_JUKE_DIST };
-      const cell = grid.snapToWalkable(grid.worldToCell(raw.x, raw.y), 6);
-      if (cell < 0) continue;
-      const target = grid.cellToWorld(cell);
-      if (dist(me.x, me.y, target.x, target.y) < SELF_DEFENSE_JUKE_MIN_MOVE) continue;
-      if (!segmentWalkable(grid, me.x, me.y, target.x, target.y)) continue;
-      const sep = dist(target.x, target.y, pursuer.x, pursuer.y);
-      if (!best || sep > best.sep) best = { target, sep };
-    }
-    // 不往追击者身上凑：最优侧也比当前明显更近就放弃变向（交回常规逃跑）。
-    if (best && best.sep < curSep - SELF_DEFENSE_JUKE_MIN_MOVE) return null;
-    return best?.target ?? null;
-  }
-
-  /** 追击中断（某帧不再朝我 / 变向窗口内没凑出有效跟随）：清零追击进度，但【保留当前目标身份与上一帧坐标】，
-   *  它若重新咬住可继续累计——区别于 resetSelfDefense 连目标一起丢（那样下一帧又当「第一次见到」永远攒不起来）。 */
-  private softResetPursuit(): void {
-    this.selfDefenseStreak = 0;
-    this.selfDefenseJukeWatch = 0;
-    this.selfDefenseJukeFromPos = null;
-    this.selfDefenseJukePursuerHeading = null;
-    this.selfDefenseJukeFollows = 0;
-    this.selfDefenseAlerted = false;
-  }
-
-  /** 整体重置：连当前追击目标身份一起丢（换目标、目标消失、开会、转入主动猎杀时用）。 */
-  private resetSelfDefense(): void {
-    this.selfDefenseTargetKey = null;
-    this.selfDefensePursuerPrev = null;
-    this.selfDefensePursuerHeading = null;
-    this.softResetPursuit();
-  }
-
   private setHunt(targetName: string): void {
     const worker = this.subGoal;
     if (worker instanceof KillVisibleTargetGoal && worker.targetName === targetName) return;
@@ -508,7 +214,8 @@ export class WarriorShrimpTop extends Goal {
     this.setSubGoal(new KeepAwayGoal(
       FLEE_KEY,
       (s, c) => nonTeammatesVisible(s, c).filter(p => this.isThreat(p, c)),
-      { threatRadius: Infinity, noun: '认定坏人' } satisfies KeepAwayGoalOptions,
+      // 行为不变（仍躲所有非 trusted）；措辞按真实身份逐个标注，免得把一起躲的被怀疑者也叫成「认定坏人」。
+      { threatRadius: Infinity, noun: (p, c) => this.isHuntTarget(p, c) ? '认定坏人' : '被怀疑者' } satisfies KeepAwayGoalOptions,
     ), SUB_PRIORITY);
   }
 

package/src/strategies/hide-spots.ts

@@ -1,14 +1,8 @@
 import type { Position } from '../sdk/types.js';
-import { dist } from './game-utils.js';
-import { assessRoutes } from './pathfind/escape-planner.js';
+import { nearestSafePoint, type OffRoutePoint } from './off-route-points.js';
 
-export interface HideSpot {
-  /** 世界像素坐标，与 GameState / 可行走网格同坐标系。 */
-  x: number;
-  y: number;
-  /** 所在房间，仅供日志/调试。 */
-  room: string;
-}
+/** 藏身角落，离路点的一种（见 OffRoutePoint）。 */
+export type HideSpot = OffRoutePoint;
 
 /**
  * 躲藏点：离线从服务端烘焙地图（config/clawclaw/clawclaw.tmj.baked.npz）算出的「藏身角落」。筛选条件：
@@ -47,77 +41,19 @@ export interface NearestSafeHideOptions {
   blockedTarget?: Position | null;
 }
 
-const BLOCKED_RADIUS = 12;
-
-function sameSpot(a: HideSpot, b: HideSpot): boolean {
-  return a.x === b.x && a.y === b.y;
-}
-
-/** 所有点都被威胁封死时的兜底：离威胁最远的点（仍好过原地等死）。 */
-function farthestFromThreats(threatPoints: Position[], blocked?: Position | null): HideSpot | null {
-  let best: HideSpot | null = null;
-  let bestMin = -Infinity;
-  for (const s of HIDE_SPOTS) {
-    if (blocked && dist(s.x, s.y, blocked.x, blocked.y) <= BLOCKED_RADIUS) continue;
-    const minD = threatPoints.length === 0 ? 0 : Math.min(...threatPoints.map(p => dist(s.x, s.y, p.x, p.y)));
-    if (minD > bestMin) {
-      bestMin = minD;
-      best = s;
-    }
-  }
-  return best;
-}
-
 /**
- * 选「最近的安全躲藏点」：与 nearestSafeTask 同构——威胁旁的点硬排除、去路经过威胁附近的点排除，
- * 余者取测地最近（distance-field 一次扫描；测地不可达按欧氏垫底），带粘性（当前点仍合法就不换）。
- * 全部被威胁封死时退回「离威胁最远」的点。
+ * 选「最近的安全躲藏点」：威胁旁的点硬排除、去路经过威胁附近的点排除，余者取测地最近，带粘性
+ * （当前点仍合法就不换），全部被封死时退回「离威胁最远」的点。实现复用 nearestSafePoint。
  */
 export function nearestSafeHideSpot(
   from: Position,
   threatPoints: Position[] = [],
   opts: NearestSafeHideOptions = {},
 ): HideSpot | null {
-  const excludeR = opts.threatExcludeRadius ?? HIDE_THREAT_EXCLUDE_RANGE;
-  const blocked = opts.blockedTarget ?? null;
-
-  const candidates = HIDE_SPOTS.filter(s =>
-    (!blocked || dist(s.x, s.y, blocked.x, blocked.y) > BLOCKED_RADIUS)
-    && !threatPoints.some(p => dist(s.x, s.y, p.x, p.y) <= excludeR));
-
-  if (candidates.length === 0) return farthestFromThreats(threatPoints, blocked);
-
-  // 无威胁时粘性可零成本短路（不必为路径检查扫距离场）。
-  if (opts.stickyTo && threatPoints.length === 0) {
-    const sticky = candidates.find(c => sameSpot(c, opts.stickyTo!));
-    if (sticky) return sticky;
-  }
-
-  const routes = assessRoutes(
-    from,
-    candidates.map(c => ({ x: c.x, y: c.y })),
-    threatPoints,
-    opts.pathThreatRadius ?? HIDE_PATH_THREAT_RADIUS,
-  );
-  const indexed = candidates.map((c, i) => ({ c, i }));
-  const viable = routes == null ? indexed : indexed.filter(({ i }) => !routes[i].nearThreat);
-  const pool = viable.length > 0 ? viable : indexed;
-
-  if (opts.stickyTo) {
-    const sticky = pool.find(({ c }) => sameSpot(c, opts.stickyTo!));
-    if (sticky) return sticky.c;
-  }
-
-  let best = pool[0].c;
-  let bestScore = Infinity;
-  for (const { c, i } of pool) {
-    const euclid = dist(from.x, from.y, c.x, c.y);
-    const geo = routes?.[i].distancePx;
-    const score = geo == null ? euclid : geo !== Infinity ? geo : euclid + 1e6;
-    if (score < bestScore) {
-      bestScore = score;
-      best = c;
-    }
-  }
-  return best;
+  return nearestSafePoint(HIDE_SPOTS, from, threatPoints, {
+    threatExcludeRadius: opts.threatExcludeRadius ?? HIDE_THREAT_EXCLUDE_RANGE,
+    pathThreatRadius: opts.pathThreatRadius ?? HIDE_PATH_THREAT_RADIUS,
+    stickyTo: opts.stickyTo ?? null,
+    blockedTarget: opts.blockedTarget ?? null,
+  });
 }

package/src/strategies/hide.ts

@@ -14,6 +14,7 @@ export function parseHideKillArg(args?: string[]): boolean | null {
 
 export const strategy: StrategyEntry = {
   id: 'hide',
+  name: '躲藏',
   description:
     '躲藏策略：在离线从地图算好的若干「非走廊、≥2 出口可逃、远离任务点/出生点」的藏身角落里，选测地最近且不挨威胁的一个潜伏不动；视野里一出现非队友，就像 shrimp-memory 那样保持距离甩开（KeepAway），并边逃边重算排除该威胁的新藏点，逃完落到新点继续潜伏。蟹不躲队友。可选参数 kill / nokill 控制「被单个对手逼进出刀距离且无路可逃时是否出刀自保」——缺省按角色：蟹/章鱼默认开，武士虾/枪虾（及无刀角色）默认关。',
   create(args?: string[]) {

package/src/strategies/kill-frenzy.ts

@@ -4,6 +4,7 @@ import { KillFrenzyTop } from './goals/kill-frenzy-top.js';
 
 export const strategy: StrategyEntry = {
   id: 'kill-frenzy',
+  name: '屠夫',
   description:
     '疯狂砍人：见谁杀谁（除队友外所有可见玩家），多人在场也照杀。按房间顺序巡逻，视野里只要有非队友就冲向最近的那个，50内且冷却好就出刀，冷却中保持10距离贴身跟随等冷却。与 kill-lone 不同，不会因为周围人多而暂停攻击。永不停手。',
   create() {

package/src/strategies/kill-lone.ts

@@ -5,6 +5,7 @@ import { parseTargetArgs } from './player-targets.js';
 
 export const strategy: StrategyEntry = {
   id: 'kill-lone',
+  name: '猎独',
   description: '按照房间顺序进行巡逻，巡逻时遇到人会判断。可传入避免击杀的座位号或名字列表。视野里只有一个非队友且不在避免名单内就靠近，进入50距离就出刀；冷却中贴在10距离附近等。视野里出现两人以上时，暂停攻击10秒并继续巡逻。',
   create(args?: string[]) {
     const protectedTargets = args ? parseTargetArgs(args) : [];

package/src/strategies/kill-target.ts

@@ -5,6 +5,7 @@ import { parseTargetArgs } from './player-targets.js';
 
 export const strategy: StrategyEntry = {
   id: 'kill-target',
+  name: '追杀',
   description: '专门追杀指定目标（传入座位号或名字，可多人）。按照房间顺序进行巡逻，目标进入视野就冲上去，50内且冷却好就出刀；冷却中保持10距离贴身跟随等待。找目标时路过其他玩家不会停步。所有目标死亡后停止。',
   create(args?: string[]) {
     const targets = args ? parseTargetArgs(args) : [];

package/src/strategies/loader.ts

@@ -136,9 +136,16 @@ async function ensureLoaded(): Promise<void> {
   if (userDir) await loadFromDir(userDir, false);
 }
 
-export async function getStrategyEntry(id: string): Promise<StrategyEntry | undefined> {
+export async function getStrategyEntry(idOrName: string): Promise<StrategyEntry | undefined> {
   await ensureLoaded();
-  return strategyMap.get(id);
+  const byId = strategyMap.get(idOrName);
+  if (byId) return byId;
+  // Fall back to the Chinese display name (StrategyEntry.name). id always wins,
+  // so this only resolves an alias when no id matched.
+  for (const entry of strategyMap.values()) {
+    if (entry.name === idOrName) return entry;
+  }
+  return undefined;
 }
 
 export async function listStrategyEntries(): Promise<StrategyEntry[]> {

package/src/strategies/lone-kill-task.ts

@@ -6,6 +6,7 @@ import { SpeechModule, getSpeechConfigForRole } from './speech-module.js';
 
 export const strategy: StrategyEntry = {
   id: 'lone-kill-task',
+  name: '潜伏猎手',
   description: '视野里只有一个非队友且冷却可用就靠近，进入50距离就立刻出刀；刀在冷却时不追不等、改做低优先级任务伪装，冷却好且目标仍落单可见再出刀（贴脸且刀好仍会立刻出刀）。发现尸体且附近有非队友、但当前不能原地出刀时，会靠近并报告尸体。视野里出现两人以上时，暂停攻击10秒并做任意阵营的真实任务伪装；选任务时会跳过紧挨已知尸体（含看见过、已离开视野的）的任务，不在命案现场做任务。没有可做任务时按房间巡逻，绝不停在原地。残局（已知存活≤6）出现紧急维修任务时，会高优先级抢着去做（仍低于击杀落单），阻止蟹靠破坏倒计时取胜。（章鱼默认）',
   create(args?: string[]) {
     const role = args?.[0] ?? 'neutral_octopus';

package/src/strategies/move-room.ts

@@ -4,6 +4,7 @@ import { MoveRoomGoal } from './goals/move-room-goal.js';
 
 export const strategy: StrategyEntry = {
   id: 'move-room',
+  name: '前往',
   description: '前往指定房间，到达后停下。参数为目标房间名（如 酒吧）。单纯走位，不做任务、不打人、不报告。',
   create(args?: string[]) {
     const targetRoom = args?.join(' ').trim() ?? '';