@myclaw163/clawclaw-cli 0.6.68 → 0.6.69

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/off-route-points.ts

@@ -0,0 +1,105 @@
+import type { Position } from '../sdk/types.js';
+import { dist } from './game-utils.js';
+import { assessRoutes } from './pathfind/escape-planner.js';
+
+/**
+ * 离线从烘焙地图算出的「离路点」：远离任务点/出生点、避开走廊与枢纽的低人流坐标
+ * （世界像素，与 GameState / 可行走网格同坐标系）。HIDE_SPOTS（藏身角落）是它的具体集合，
+ * 共用下面的选点器。
+ */
+export interface OffRoutePoint extends Position {
+  /** 所在房间，仅供日志/调试。 */
+  room: string;
+}
+
+export interface NearestSafePointOptions<T extends Position = Position> {
+  /** 点离任一威胁多近就硬排除。 */
+  threatExcludeRadius: number;
+  /** 去该点的测地路径经过威胁这个距离内也排除（避免走向把守者）。 */
+  pathThreatRadius: number;
+  /** 当前已选点：仍是合法候选就保持不变，杜绝等距摇摆。 */
+  stickyTo?: T | null;
+  /** 被标记为不可达的移动目标：在其附近的点跳过。 */
+  blockedTarget?: Position | null;
+}
+
+const BLOCKED_RADIUS = 12;
+
+function samePoint(a: Position, b: Position): boolean {
+  return a.x === b.x && a.y === b.y;
+}
+
+/** 所有点都被威胁封死时的兜底：离威胁最远的点（仍好过原地等死）。 */
+function farthestFromThreats<T extends Position>(
+  points: readonly T[],
+  threatPoints: Position[],
+  blocked?: Position | null,
+): T | null {
+  let best: T | null = null;
+  let bestMin = -Infinity;
+  for (const s of points) {
+    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;
+}
+
+/**
+ * 从离线点集里选「测地最近的安全点」：威胁旁的点硬排除、去路经过威胁附近的点排除，余者取测地最近
+ * （distance-field 一次扫描；测地不可达按欧氏垫底），带粘性（当前点仍合法就不换）。全部被威胁封死
+ * 时退回「离威胁最远」的点。nearestSafeHideSpot 复用此选点器。
+ */
+export function nearestSafePoint<T extends Position>(
+  points: readonly T[],
+  from: Position,
+  threatPoints: Position[],
+  opts: NearestSafePointOptions<T>,
+): T | null {
+  const excludeR = opts.threatExcludeRadius;
+  const blocked = opts.blockedTarget ?? null;
+
+  const candidates = points.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(points, threatPoints, blocked);
+
+  // 无威胁时粘性可零成本短路（不必为路径检查扫距离场）。
+  if (opts.stickyTo && threatPoints.length === 0) {
+    const sticky = candidates.find(c => samePoint(c, opts.stickyTo!));
+    if (sticky) return sticky;
+  }
+
+  const routes = assessRoutes(
+    from,
+    candidates.map(c => ({ x: c.x, y: c.y })),
+    threatPoints,
+    opts.pathThreatRadius,
+  );
+  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 }) => samePoint(c, opts.stickyTo!));
+    if (sticky) return sticky.c;
+  }
+
+  // 测地最近（distance-field 距离；测地不可达按欧氏垫底）。
+  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;
+}

package/src/strategies/warrior-memory.knowledge.md

@@ -6,9 +6,9 @@
 |------|------|
 | `hostile`（坏人） | 敌对：刀可用时主动追杀；刀冷却或枪虾无次数时硬回避 |
 | `trusted`（好人） | 可信：绝不攻击，也不会因其在场而对被怀疑者后撤 |
-| 未标记（被怀疑） | 默认回避观察，刀可用也不主动猎杀；仅「绝境自卫」例外（见下） |
+| 未标记（被怀疑） | 默认回避观察，刀可用也**绝不出刀**（无自卫例外） |
 
-**绝境自卫例外（对所有被怀疑者适用）**：当被同一个被怀疑者连续贴身追击、且逃跑推演判定甩不掉时，武士虾会主动横向变一次向试探。只有它跟着变向重新咬住（确认是在追我、不是顺路赶路）、已进 160px 射程、且我到它视线无墙，才会出于自卫先手击杀，并向 agent 推一条「被动自卫」简报（供后续发言/投票口径对齐，别承认无故先手）。直奔身后任务点、顺路掠过的虾不会跟着变向，会被自然甩开、绝不误杀。**不要求先把对方标成坏人**——实战里真凶往往还没被标记就开始追杀，所以对任何被怀疑者都适用。这是最后手段——多数情况下变向只是把追兵甩开，并不出刀。
+**不对被怀疑者出刀（无自卫机制）**：武士虾只对【已确认 hostile / 启动猎杀目标】出刀。历史上的「被怀疑者持续贴身追击 → 诱饵死角试探 → 绝境自卫先手」整套已删除：几何上无法把「贴身跟我观察/盯防的好人」与「贴身追我的凶手」区分开（两者跟随轨迹一样），自卫出刀迟早误杀同阵营好人、触发 warrior_shrimp_self_destruct 直接崩盘，代价远大于收益。被怀疑者贴身追来也只回避（拉开距离 / 借人多互为目击掩护），绝不反杀。
 
 被怀疑者（未标记）平时按陌生人处理：不主动猎杀；无 trusted 同伴且单个被怀疑者贴近 270px 内时先拉开距离，多个互为目击者时照常做任务；坏人刀冷时硬躲所有非好人。尸体场景对【未报警的身份不明者】只报警不灭口：站在尸体旁即便身边有被怀疑者，也绝不先手击杀，一律靠近报警；但若尸体旁是 hostile 或启动猎杀目标、刀可用，仍会现场先手击杀（凶手就在身边照杀）。
 

package/src/strategies/warrior-memory.ts

@@ -6,7 +6,7 @@ import { parseTargetArgs } from './player-targets.js';
 export const strategy: StrategyEntry = {
   id: 'warrior-memory',
   description:
-    '带刀虾·记忆进阶版（武士虾/枪虾通用，好人带刀；kill-lone 的带记忆升级）。读取 ccl knowledge 两档标记（hostile=坏人 / trusted=好人），未标记的一律默认被怀疑：hostile 刀好时主动追杀、刀不好时硬回避，trusted 视为可信同伴且绝不攻击，被怀疑者默认只回避观察——仅当被同一个被怀疑者持续贴身追击、避让判定甩不掉时主动横向变向试探，只有它跟着变向仍咬住、进了射程且视线无墙才自卫先手击杀（被动自卫，会推 agent 简报；直奔任务点顺路掠过的虾不跟变向、自然甩开不误杀；不要求先标记，实战里真凶常没来得及标就追杀）。发现尸体优先报警；尸体旁若是 hostile/启动猎杀目标且刀可用会现场先手击杀，但绝不会因尸体旁有未报警的身份不明者就灭口（已根治该误杀）；无可信同伴且单个被怀疑者贴近270内时先拉开到300再做任务；无危险时优先紧急任务，否则做任务/巡逻。枪虾会尊重剩余出刀次数。',
+    '带刀虾·记忆进阶版（武士虾/枪虾通用，好人带刀；kill-lone 的带记忆升级）。读取 ccl knowledge 两档标记（hostile=坏人 / trusted=好人），未标记的一律默认被怀疑：hostile 刀好时主动追杀、刀不好时硬回避，trusted 视为可信同伴且绝不攻击。**只对【已确认 hostile / 启动猎杀目标】出刀**——被怀疑者一律只回避、绝不出刀（无可信同伴且单个被怀疑者贴近270内时先拉开到300再做任务，多人互为目击者则照常做任务）；不再有任何贴身追击判定/诱饵试探/绝境自卫（几何上分不开"贴身跟我观察的好人"和"贴身追我的凶手"，自卫迟早误杀同阵营好人触发武士虾自爆，整套已删除）。发现尸体优先报警；尸体旁若是 hostile/启动猎杀目标且刀可用会现场先手击杀，但绝不会因尸体旁有未报警的身份不明者就灭口（已根治该误杀）；无危险时优先紧急任务，否则做任务/巡逻。枪虾会尊重剩余出刀次数。',
   create(args?: string[]) {
     const huntTargets = args ? parseTargetArgs(args) : [];
     return new GoalRootStrategy('warrior-memory', () => new WarriorShrimpTop(huntTargets), {