@myclaw163/clawclaw-cli 0.6.60 → 0.6.63

package/src/strategies/goals/hide-top.ts

@@ -0,0 +1,197 @@
+import type { GameState, PlayerInfo, Position } from '../../sdk/types.js';
+import { Action } from '../../sdk/action.js';
+import {
+  canUseKill,
+  dist,
+  killCommitRange,
+  nonTeammatesVisible,
+  PROGRESS_INTERVAL_MS,
+  SHRIMP_KILL_RANGE,
+} from '../game-utils.js';
+import { nearestSafeHideSpot, type HideSpot } from '../hide-spots.js';
+import { planEscape, type EscapeOptions } from '../pathfind/escape-planner.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+import { KeepAwayGoal } from './keep-away-goal.js';
+
+const SUB_PRIORITY = 0.5;
+const FLEE_KEY = 'hide-flee';
+/** 走到躲藏点这个距离内就算到位，原地潜伏不动。 */
+const REACHED_DISTANCE = 40;
+/** 威胁离开视野后，其位置仍在选点时被回避这么久——逃完不会立刻又选回威胁刚待过的点。 */
+const THREAT_MEMORY_MS = 5_000;
+/**
+ * 「无处可逃」用的逃跑推演参数：与 KeepAwayGoal 同款保守模型（killRange=160，按枪虾/武士虾兜底）。
+ * 理由是「连我自己用来逃跑的同一套推演都判定必被追上，逃就没意义，才出刀自保」，判据自洽。
+ */
+const ESCAPE_OPTS: EscapeOptions = { killRange: SHRIMP_KILL_RANGE, steps: 7, beamWidth: 8, directions: 16, fieldRadius: 900 };
+
+type ProgressTier = 'flee' | 'relocate' | 'hidden';
+type ThreatPointResolver = () => Position[];
+
+/**
+ * 躲藏点劳作循环：与 SafeTaskOrPatrolGoal 同构——planSpot 边逃边预重算（粘性、威胁硬排除），
+ * tick 执行（走向躲藏点；到位则原地不动）。没有可用点时不动。
+ */
+class HideSpotGoal extends Goal {
+  private current: HideSpot | null = null;
+
+  constructor(private readonly threatPoints: ThreatPointResolver) {
+    super();
+  }
+
+  get currentSpot(): HideSpot | null {
+    return this.current;
+  }
+
+  reset(): void {
+    this.current = null;
+  }
+
+  /** 重算并记住安全躲藏点，不发移动指令（逃跑期间可安全调用）。 */
+  planSpot(state: GameState, ctx: StrategyContext): HideSpot | null {
+    const spot = nearestSafeHideSpot(
+      { x: state.you.x, y: state.you.y },
+      this.threatPoints(),
+      { stickyTo: this.current, blockedTarget: ctx.blockedMoveTarget },
+    );
+    this.current = spot;
+    return spot;
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const spot = this.planSpot(state, ctx);
+    if (!spot) return [];
+    if (dist(state.you.x, state.you.y, spot.x, spot.y) <= REACHED_DISTANCE) return []; // 到位，原地潜伏
+    return [{ action: Action.move({ x: spot.x, y: spot.y }).withThinking(`前往躲藏点${spot.room}潜伏`) }];
+  }
+}
+
+/**
+ * 躲藏策略顶层：在离线算好的藏身角落里选测地最近且不挨威胁的一个潜伏不动，直到有人进入视野。
+ * 有人来就 ① 用 KeepAwayGoal 保持距离甩开，② 边逃边重算排除该威胁的新躲藏点——与 shrimp-memory 的
+ * 「躲人 + 重选任务」同构，只是把任务换成躲藏点。蟹不躲队友（威胁统一用 nonTeammatesVisible 过滤队友）。
+ *
+ * killWhenCornered：被**单个**对手逼进出刀距离、且 planEscape 判定无路可逃时才出刀自保。
+ * null = 按角色默认：蟹 / 章鱼开，武士虾 / 枪虾（及无刀角色）关。
+ */
+export class HideTop extends Goal {
+  private readonly spotGoal = new HideSpotGoal(() => this.threatPointsFor());
+  private readonly recentThreats = new Map<string, { x: number; y: number; until: number }>();
+
+  constructor(private readonly killWhenCornered: boolean | null = null) {
+    super();
+  }
+
+  onMeetingResume(): void {
+    this.spotGoal.reset();
+    this.recentThreats.clear();
+    if (this.subGoal) this.removeSubGoal();
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const visible = nonTeammatesVisible(state, ctx);
+    this.rememberThreats(visible);
+
+    // ── 被单个对手逼到死角且刀好 → 出刀自保（按角色 / 参数开关） ──
+    if (this.killEnabled(state) && canUseKill(state)) {
+      const victim = this.corneredVictim(state, visible);
+      if (victim) {
+        if (this.subGoal) this.removeSubGoal();
+        ctx.notifications.push(`被${victim.name}逼到无处可逃，出刀自保！`);
+        return [{ action: Action.kill(victim.name).withThinking(`被${victim.name}逼进出刀距离又逃不掉，先下手自保。`) }];
+      }
+    }
+
+    // ── 视野里有人 → 保持距离甩开 + 边逃边重算安全躲藏点 ──
+    if (visible.length > 0) {
+      this.spotGoal.planSpot(state, ctx); // 重算（排除威胁），逃完落到新点
+      this.setFlee();
+      this.emitProgress(state, ctx, visible, 'flee');
+      return [];
+    }
+
+    // ── 无人 → 走向最近安全躲藏点并潜伏 ──
+    if (this.subGoal) this.removeSubGoal();
+    const decisions = this.spotGoal.tick(state, ctx);
+    this.emitProgress(state, ctx, visible, decisions.length === 0 ? 'hidden' : 'relocate');
+    return decisions;
+  }
+
+  private killEnabled(state: GameState): boolean {
+    if (!roleHasKnife(state)) return false; // 无刀角色（普通虾）永不出刀，传 kill 参数也不行
+    return this.killWhenCornered ?? defaultKillWhenCornered(state);
+  }
+
+  /** 单个对手、进入出刀距离、且 planEscape 判定必被追上 → 返回该对手，否则 null。 */
+  private corneredVictim(state: GameState, visible: PlayerInfo[]): PlayerInfo | null {
+    // 只在单个追兵时自保：2 人以上当众动手仍会被另一人举报，逃跑（推演偏悲观，真人有视野盲区）反而更优。
+    if (visible.length !== 1) return null;
+    const target = visible[0];
+    const d = target.distance ?? dist(state.you.x, state.you.y, target.x, target.y);
+    if (d > killCommitRange(state.you.role)) return null;
+    const plan = planEscape({ x: state.you.x, y: state.you.y }, [{ x: target.x, y: target.y }], ESCAPE_OPTS);
+    return plan.caught ? target : null;
+  }
+
+  private setFlee(): void {
+    const worker = this.subGoal;
+    if (worker instanceof KeepAwayGoal && worker.key === FLEE_KEY) return;
+    if (this.subGoal) this.removeSubGoal();
+    this.setSubGoal(new KeepAwayGoal(FLEE_KEY, (s, c) => nonTeammatesVisible(s, c), {
+      threatRadius: Infinity,
+      noun: '靠近的人',
+    }), SUB_PRIORITY);
+  }
+
+  /** 记住近期见过的非队友位置（按名字去重 + TTL），供威胁离开视野后选点继续回避。 */
+  private rememberThreats(visible: PlayerInfo[]): void {
+    const now = Date.now();
+    for (const p of visible) {
+      const key = p.name || String(p.seat ?? '');
+      if (key) this.recentThreats.set(key, { x: p.x, y: p.y, until: now + THREAT_MEMORY_MS });
+    }
+    for (const [key, v] of this.recentThreats) if (v.until <= now) this.recentThreats.delete(key);
+  }
+
+  private threatPointsFor(): Position[] {
+    const now = Date.now();
+    const out: Position[] = [];
+    for (const v of this.recentThreats.values()) if (v.until > now) out.push({ x: v.x, y: v.y });
+    return out;
+  }
+
+  private emitProgress(state: GameState, ctx: StrategyContext, visible: PlayerInfo[], tier: ProgressTier): void {
+    const now = Date.now();
+    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
+    ctx.lastProgressNotifyAt = now;
+
+    const room = state.you.room ?? '未知';
+    const spot = this.spotGoal.currentSpot;
+    let msg = `[进度] 当前在${room}`;
+    if (tier === 'flee') {
+      const names = visible.map(p => p.name).join('、');
+      msg += `，${names}靠近，保持距离甩开${spot ? `，改藏到${spot.room}` : ''}。`;
+    } else if (tier === 'relocate') {
+      msg += spot ? `，前往躲藏点${spot.room}潜伏。` : '，寻找躲藏点。';
+    } else {
+      msg += spot ? `，已在${spot.room}潜伏，按兵不动。` : '，附近无可用躲藏点，原地待命。';
+    }
+    ctx.notifications.push(msg);
+  }
+}
+
+/** 是否带刀（有击杀能力）：蟹 / 章鱼 / 武士虾 / 枪虾。普通虾无刀。 */
+function roleHasKnife(state: GameState): boolean {
+  const role = state.you.role ?? '';
+  const faction = state.you.faction ?? '';
+  return faction === 'crab' || role.includes('crab') || role.includes('octopus')
+    || role === 'shrimp_warrior' || role === 'shrimp_pistol';
+}
+
+/** 角色默认是否「死角自保出刀」：蟹 / 章鱼开；武士虾 / 枪虾及其余关。 */
+function defaultKillWhenCornered(state: GameState): boolean {
+  const role = state.you.role ?? '';
+  const faction = state.you.faction ?? '';
+  return faction === 'crab' || role.includes('crab') || role.includes('octopus');
+}

package/src/strategies/goals/keep-away-goal.ts

@@ -1,209 +1,209 @@
-import { Action } from '../../sdk/action.js';
-import type { GameState, PlayerInfo, Position } from '../../sdk/types.js';
-import { dist, SHRIMP_KILL_RANGE } from '../game-utils.js';
-import { assessEscapeTarget, planEscape, type EscapeOptions } from '../pathfind/escape-planner.js';
-import { loadWalkableGrid } from '../pathfind/walkable-grid.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-import { Goal } from './goal.js';
-
-const PANIC_RADIUS = 190;
-const CRITICAL_RADIUS = 100;
-const REACHED_DISTANCE = 28;
-const MIN_USEFUL_TARGET_DISTANCE = 120;
-const MAX_THREATS = 4;
-const CRITICAL_REPLAN_INTERVAL_MS = 1600;
-const PANIC_REPLAN_INTERVAL_MS = 2500;
-const PANIC_REPLAN_TARGET_SHIFT = 220;
-const PLAN_OPTS: EscapeOptions = { steps: 7, beamWidth: 8, directions: 16, fieldRadius: 900 };
-const FALLBACK_DISTANCES = [330, 260, 200, 140];
-const FALLBACK_ANGLE_OFFSETS = [0, Math.PI / 6, -Math.PI / 6, Math.PI / 3, -Math.PI / 3, Math.PI / 2, -Math.PI / 2, Math.PI];
-
-export type ThreatResolver = (state: GameState, ctx: StrategyContext) => PlayerInfo[];
-
-export interface KeepAwayGoalOptions {
-  /** 交战兼结束半径（px）；Infinity = resolver 返回的全算威胁。所有调用点必须显式传，无默认值。 */
-  threatRadius: number;
-  /** 半径内无威胁时 isFinish=true，供父节点自然回收；独立 keep-away 策略作为顶层须传 false，否则每个安静 tick 被 GoalManager 清掉再重建、idle 通知刷屏。 */
-  finishWhenClear?: boolean;
-  /** 无威胁时的 idle/coast 通知；作为子目标默认关闭（父节点自有进度播报）。 */
-  idleNotices?: boolean;
-  /** 通知措辞里威胁的称呼：发现{noun}{names}，{verb}到 (x, y)。 */
-  noun?: string;
-  /** 覆盖 planEscape 参数（与 PLAN_OPTS 合并）。 */
-  planOpts?: EscapeOptions;
-}
-
-function targetKey(target: Position): string {
-  return `${Math.round(target.x)},${Math.round(target.y)}`;
-}
-
-function fallbackEscapeTarget(you: Position, threats: PlayerInfo[]): Position | null {
-  if (threats.length === 0) return null;
-  let vx = 0;
-  let vy = 0;
-  for (const t of threats) {
-    const dx = you.x - t.x;
-    const dy = you.y - t.y;
-    const d = Math.max(1, Math.hypot(dx, dy));
-    const weight = 1 / Math.max(80, d);
-    vx += (dx / d) * weight;
-    vy += (dy / d) * weight;
-  }
-  if (Math.hypot(vx, vy) < 0.001) {
-    vx = you.x - threats[0].x;
-    vy = you.y - threats[0].y;
-  }
-  if (Math.hypot(vx, vy) < 0.001) vx = 1;
-
-  const grid = loadWalkableGrid();
-  const baseAngle = Math.atan2(vy, vx);
-  const nearestBefore = Math.min(...threats.map(t => dist(you.x, you.y, t.x, t.y)));
-  let best: { target: Position; score: number } | null = null;
-
-  for (const distancePx of FALLBACK_DISTANCES) {
-    for (const offset of FALLBACK_ANGLE_OFFSETS) {
-      const angle = baseAngle + offset;
-      const raw = {
-        x: you.x + Math.cos(angle) * distancePx,
-        y: you.y + Math.sin(angle) * distancePx,
-      };
-      const cell = grid.snapToWalkable(grid.worldToCell(raw.x, raw.y), 10);
-      if (cell < 0) continue;
-      const target = grid.cellToWorld(cell);
-      const moveDistance = dist(you.x, you.y, target.x, target.y);
-      if (moveDistance < MIN_USEFUL_TARGET_DISTANCE) continue;
-      const nearestAfter = Math.min(...threats.map(t => dist(target.x, target.y, t.x, t.y)));
-      const score = (nearestAfter - nearestBefore) * 4 + moveDistance - Math.abs(offset) * 80;
-      if (!best || score > best.score) best = { target, score };
-    }
-  }
-
-  return best?.target ?? null;
-}
-
-/**
- * 寻路躲避 Goal：用路径推演（planEscape）给出较远可走点并承诺该目标，移动中滑行，
- * 只有路径变危险、被贴近或卡路才重规划。威胁来源、交战半径、结束条件均由构造参数定制，
- * 供独立 keep-away 测试策略与 NormalShrimpTop 的 A/B 档共用。
- */
-export class KeepAwayGoal extends Goal {
-  private committed: Position | null = null;
-  private lastNoticeKey = '';
-  private lastCommitAt = 0;
-  private lastCommitWasPanic = false;
-  private readonly threatRadius: number;
-  private readonly planOpts: EscapeOptions;
-
-  constructor(
-    public readonly key: string,
-    private readonly resolveThreats: ThreatResolver,
-    private readonly options: KeepAwayGoalOptions,
-  ) {
-    super();
-    this.threatRadius = options.threatRadius;
-    // 逃跑推演对「会不会被追上」用保守击杀距离：威胁在本层只有坐标、没有角色（resolver 返回
-    // 的是可见非队友的裸位置，本游戏看不到他人身份），无法逐威胁取 killRangeFor(role)，故统一用
-    // 武士虾/枪虾的 SHRIMP_KILL_RANGE(160) 兜底，宁可对蟹/章鱼多拉开距离也不对带刀好人少逃。
-    // escape-planner 自身默认 80（服务端 base kill_range），此处刻意覆盖。
-    this.planOpts = { killRange: SHRIMP_KILL_RANGE, ...PLAN_OPTS, ...options.planOpts };
-  }
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    const you = state.you;
-    const threats = this.threatsOf(state, ctx);
-
-    if (threats.length === 0) return this.handleNoThreat(you, ctx);
-
-    const threatPoints = threats.map(p => ({ x: p.x, y: p.y }));
-    const nearestThreat = dist(threats[0].x, threats[0].y, you.x, you.y);
-    const shouldPanic = nearestThreat <= PANIC_RADIUS;
-
-    if (this.committed && (
-      dist(you.x, you.y, this.committed.x, this.committed.y) <= REACHED_DISTANCE
-      || (ctx.blockedMoveTarget && dist(this.committed.x, this.committed.y, ctx.blockedMoveTarget.x, ctx.blockedMoveTarget.y) <= 24)
-    )) {
-      this.committed = null;
-    }
-
-    const committedAssessment = this.committed
-      ? assessEscapeTarget(you, threatPoints, this.committed, this.planOpts)
-      : null;
-    const committedBad = committedAssessment
-      ? committedAssessment.caught || committedAssessment.distanceToTarget === Infinity
-      : false;
-
-    if (this.committed && !shouldPanic && !committedBad) return [];
-    if (this.committed && shouldPanic) {
-      const elapsed = Date.now() - this.lastCommitAt;
-      const isCritical = nearestThreat <= CRITICAL_RADIUS;
-      if (!committedBad && isCritical && this.lastCommitWasPanic && elapsed < CRITICAL_REPLAN_INTERVAL_MS) return [];
-      if (!committedBad && !isCritical && elapsed < PANIC_REPLAN_INTERVAL_MS) return [];
-    }
-
-    if (!this.committed || shouldPanic || committedBad) {
-      const plan = planEscape(you, threatPoints, this.planOpts);
-      const target = plan.target;
-      const targetDistance = dist(you.x, you.y, target.x, target.y);
-      const caughtDetail = plan.caught
-        ? `规划已被追上，逃点${Math.round(targetDistance)}px，最近威胁${Math.round(nearestThreat)}px，最小安全距${Math.round(plan.minCrabDistance)}px。`
-        : '';
-      if (targetDistance < MIN_USEFUL_TARGET_DISTANCE) {
-        const fallback = fallbackEscapeTarget(you, threats);
-        const detail = `规划${plan.caught ? '已被追上' : '逃点太近'}，逃点${Math.round(targetDistance)}px，最近威胁${Math.round(nearestThreat)}px，最小安全距${Math.round(plan.minCrabDistance)}px。`;
-        if (!fallback) {
-          this.notice(ctx, `planner-stuck:${Math.round(nearestThreat)}:${Math.round(targetDistance)}`, `躲避规划没有可用逃点：${detail}`);
-          return [];
-        }
-        this.commit(ctx, fallback, threats, '兜底远离', true, detail);
-      } else if (!this.committed) {
-        this.commit(ctx, target, threats, plan.caught ? '挣脱' : shouldPanic ? '急避' : '远离', shouldPanic, caughtDetail);
-      } else if (dist(target.x, target.y, this.committed.x, this.committed.y) > PANIC_REPLAN_TARGET_SHIFT) {
-        this.commit(ctx, target, threats, plan.caught ? '改挣脱' : '改避', true, caughtDetail);
-      } else {
-        return [];
-      }
-    }
-
-    const target = this.committed!;
-    return [{ action: Action.move(target).withThinking(`躲避${threats.map(p => p.name).join('、')}，前往 (${Math.round(target.x)}, ${Math.round(target.y)})`) }];
-  }
-
-  isFinish(state: GameState, ctx: StrategyContext): boolean {
-    return (this.options.finishWhenClear ?? true) && this.threatsOf(state, ctx).length === 0;
-  }
-
-  private threatsOf(state: GameState, ctx: StrategyContext): PlayerInfo[] {
-    const you = state.you;
-    return this.resolveThreats(state, ctx)
-      .filter(p => this.threatRadius === Infinity || dist(p.x, p.y, you.x, you.y) < this.threatRadius)
-      .sort((a, b) => dist(a.x, a.y, you.x, you.y) - dist(b.x, b.y, you.x, you.y))
-      .slice(0, MAX_THREATS);
-  }
-
-  private handleNoThreat(you: Position & { currently_moving?: boolean }, ctx: StrategyContext): BehaviorDecision[] {
-    this.committed = null;
-    if (this.options.idleNotices) {
-      if (!you.currently_moving) this.notice(ctx, 'idle', `附近 ${this.threatRadius}px 内无人，原地待命。`);
-      else this.notice(ctx, 'coast', '威胁解除，继续完成当前移动，不再补发停步指令。');
-    }
-    return [];
-  }
-
-  private commit(ctx: StrategyContext, target: Position, threats: PlayerInfo[], verb: string, panic = false, detail = ''): void {
-    this.committed = target;
-    this.lastCommitAt = Date.now();
-    this.lastCommitWasPanic = panic;
-    const names = threats.map(p => p.name).join('、');
-    this.notice(
-      ctx,
-      `${verb}:${targetKey(target)}`,
-      `发现${this.options.noun ?? ''}${names}，${verb}到 (${Math.round(target.x)}, ${Math.round(target.y)})。${detail}`,
-    );
-  }
-
-  private notice(ctx: StrategyContext, key: string, msg: string): void {
-    if (key === this.lastNoticeKey) return;
-    this.lastNoticeKey = key;
-    ctx.notifications.push(msg);
-  }
-}
+import { Action } from '../../sdk/action.js';
+import type { GameState, PlayerInfo, Position } from '../../sdk/types.js';
+import { dist, SHRIMP_KILL_RANGE } from '../game-utils.js';
+import { assessEscapeTarget, planEscape, type EscapeOptions } from '../pathfind/escape-planner.js';
+import { loadWalkableGrid } from '../pathfind/walkable-grid.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+
+const PANIC_RADIUS = 190;
+const CRITICAL_RADIUS = 100;
+const REACHED_DISTANCE = 28;
+const MIN_USEFUL_TARGET_DISTANCE = 120;
+const MAX_THREATS = 4;
+const CRITICAL_REPLAN_INTERVAL_MS = 1600;
+const PANIC_REPLAN_INTERVAL_MS = 2500;
+const PANIC_REPLAN_TARGET_SHIFT = 220;
+const PLAN_OPTS: EscapeOptions = { steps: 7, beamWidth: 8, directions: 16, fieldRadius: 900 };
+const FALLBACK_DISTANCES = [330, 260, 200, 140];
+const FALLBACK_ANGLE_OFFSETS = [0, Math.PI / 6, -Math.PI / 6, Math.PI / 3, -Math.PI / 3, Math.PI / 2, -Math.PI / 2, Math.PI];
+
+export type ThreatResolver = (state: GameState, ctx: StrategyContext) => PlayerInfo[];
+
+export interface KeepAwayGoalOptions {
+  /** 交战兼结束半径（px）；Infinity = resolver 返回的全算威胁。所有调用点必须显式传，无默认值。 */
+  threatRadius: number;
+  /** 半径内无威胁时 isFinish=true，供父节点自然回收；独立 keep-away 策略作为顶层须传 false，否则每个安静 tick 被 GoalManager 清掉再重建、idle 通知刷屏。 */
+  finishWhenClear?: boolean;
+  /** 无威胁时的 idle/coast 通知；作为子目标默认关闭（父节点自有进度播报）。 */
+  idleNotices?: boolean;
+  /** 通知措辞里威胁的称呼：发现{noun}{names}，{verb}到 (x, y)。 */
+  noun?: string;
+  /** 覆盖 planEscape 参数（与 PLAN_OPTS 合并）。 */
+  planOpts?: EscapeOptions;
+}
+
+function targetKey(target: Position): string {
+  return `${Math.round(target.x)},${Math.round(target.y)}`;
+}
+
+function fallbackEscapeTarget(you: Position, threats: PlayerInfo[]): Position | null {
+  if (threats.length === 0) return null;
+  let vx = 0;
+  let vy = 0;
+  for (const t of threats) {
+    const dx = you.x - t.x;
+    const dy = you.y - t.y;
+    const d = Math.max(1, Math.hypot(dx, dy));
+    const weight = 1 / Math.max(80, d);
+    vx += (dx / d) * weight;
+    vy += (dy / d) * weight;
+  }
+  if (Math.hypot(vx, vy) < 0.001) {
+    vx = you.x - threats[0].x;
+    vy = you.y - threats[0].y;
+  }
+  if (Math.hypot(vx, vy) < 0.001) vx = 1;
+
+  const grid = loadWalkableGrid();
+  const baseAngle = Math.atan2(vy, vx);
+  const nearestBefore = Math.min(...threats.map(t => dist(you.x, you.y, t.x, t.y)));
+  let best: { target: Position; score: number } | null = null;
+
+  for (const distancePx of FALLBACK_DISTANCES) {
+    for (const offset of FALLBACK_ANGLE_OFFSETS) {
+      const angle = baseAngle + offset;
+      const raw = {
+        x: you.x + Math.cos(angle) * distancePx,
+        y: you.y + Math.sin(angle) * distancePx,
+      };
+      const cell = grid.snapToWalkable(grid.worldToCell(raw.x, raw.y), 10);
+      if (cell < 0) continue;
+      const target = grid.cellToWorld(cell);
+      const moveDistance = dist(you.x, you.y, target.x, target.y);
+      if (moveDistance < MIN_USEFUL_TARGET_DISTANCE) continue;
+      const nearestAfter = Math.min(...threats.map(t => dist(target.x, target.y, t.x, t.y)));
+      const score = (nearestAfter - nearestBefore) * 4 + moveDistance - Math.abs(offset) * 80;
+      if (!best || score > best.score) best = { target, score };
+    }
+  }
+
+  return best?.target ?? null;
+}
+
+/**
+ * 寻路躲避 Goal：用路径推演（planEscape）给出较远可走点并承诺该目标，移动中滑行，
+ * 只有路径变危险、被贴近或卡路才重规划。威胁来源、交战半径、结束条件均由构造参数定制，
+ * 供独立 keep-away 测试策略与 NormalShrimpTop 的 A/B 档共用。
+ */
+export class KeepAwayGoal extends Goal {
+  private committed: Position | null = null;
+  private lastNoticeKey = '';
+  private lastCommitAt = 0;
+  private lastCommitWasPanic = false;
+  private readonly threatRadius: number;
+  private readonly planOpts: EscapeOptions;
+
+  constructor(
+    public readonly key: string,
+    private readonly resolveThreats: ThreatResolver,
+    private readonly options: KeepAwayGoalOptions,
+  ) {
+    super();
+    this.threatRadius = options.threatRadius;
+    // 逃跑推演对「会不会被追上」用保守击杀距离：威胁在本层只有坐标、没有角色（resolver 返回
+    // 的是可见非队友的裸位置，本游戏看不到他人身份），无法逐威胁取 killRangeFor(role)，故统一用
+    // 武士虾/枪虾的 SHRIMP_KILL_RANGE(160) 兜底，宁可对蟹/章鱼多拉开距离也不对带刀好人少逃。
+    // escape-planner 自身默认 80（服务端 base kill_range），此处刻意覆盖。
+    this.planOpts = { killRange: SHRIMP_KILL_RANGE, ...PLAN_OPTS, ...options.planOpts };
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const you = state.you;
+    const threats = this.threatsOf(state, ctx);
+
+    if (threats.length === 0) return this.handleNoThreat(you, ctx);
+
+    const threatPoints = threats.map(p => ({ x: p.x, y: p.y }));
+    const nearestThreat = dist(threats[0].x, threats[0].y, you.x, you.y);
+    const shouldPanic = nearestThreat <= PANIC_RADIUS;
+
+    if (this.committed && (
+      dist(you.x, you.y, this.committed.x, this.committed.y) <= REACHED_DISTANCE
+      || (ctx.blockedMoveTarget && dist(this.committed.x, this.committed.y, ctx.blockedMoveTarget.x, ctx.blockedMoveTarget.y) <= 24)
+    )) {
+      this.committed = null;
+    }
+
+    const committedAssessment = this.committed
+      ? assessEscapeTarget(you, threatPoints, this.committed, this.planOpts)
+      : null;
+    const committedBad = committedAssessment
+      ? committedAssessment.caught || committedAssessment.distanceToTarget === Infinity
+      : false;
+
+    if (this.committed && !shouldPanic && !committedBad) return [];
+    if (this.committed && shouldPanic) {
+      const elapsed = Date.now() - this.lastCommitAt;
+      const isCritical = nearestThreat <= CRITICAL_RADIUS;
+      if (!committedBad && isCritical && this.lastCommitWasPanic && elapsed < CRITICAL_REPLAN_INTERVAL_MS) return [];
+      if (!committedBad && !isCritical && elapsed < PANIC_REPLAN_INTERVAL_MS) return [];
+    }
+
+    if (!this.committed || shouldPanic || committedBad) {
+      const plan = planEscape(you, threatPoints, this.planOpts);
+      const target = plan.target;
+      const targetDistance = dist(you.x, you.y, target.x, target.y);
+      const caughtDetail = plan.caught
+        ? `规划已被追上，逃点${Math.round(targetDistance)}px，最近威胁${Math.round(nearestThreat)}px，最小安全距${Math.round(plan.minCrabDistance)}px。`
+        : '';
+      if (targetDistance < MIN_USEFUL_TARGET_DISTANCE) {
+        const fallback = fallbackEscapeTarget(you, threats);
+        const detail = `规划${plan.caught ? '已被追上' : '逃点太近'}，逃点${Math.round(targetDistance)}px，最近威胁${Math.round(nearestThreat)}px，最小安全距${Math.round(plan.minCrabDistance)}px。`;
+        if (!fallback) {
+          this.notice(ctx, `planner-stuck:${Math.round(nearestThreat)}:${Math.round(targetDistance)}`, `躲避规划没有可用逃点：${detail}`);
+          return [];
+        }
+        this.commit(ctx, fallback, threats, '兜底远离', true, detail);
+      } else if (!this.committed) {
+        this.commit(ctx, target, threats, plan.caught ? '挣脱' : shouldPanic ? '急避' : '远离', shouldPanic, caughtDetail);
+      } else if (dist(target.x, target.y, this.committed.x, this.committed.y) > PANIC_REPLAN_TARGET_SHIFT) {
+        this.commit(ctx, target, threats, plan.caught ? '改挣脱' : '改避', true, caughtDetail);
+      } else {
+        return [];
+      }
+    }
+
+    const target = this.committed!;
+    return [{ action: Action.move(target).withThinking(`躲避${threats.map(p => p.name).join('、')}，拉开距离`) }];
+  }
+
+  isFinish(state: GameState, ctx: StrategyContext): boolean {
+    return (this.options.finishWhenClear ?? true) && this.threatsOf(state, ctx).length === 0;
+  }
+
+  private threatsOf(state: GameState, ctx: StrategyContext): PlayerInfo[] {
+    const you = state.you;
+    return this.resolveThreats(state, ctx)
+      .filter(p => this.threatRadius === Infinity || dist(p.x, p.y, you.x, you.y) < this.threatRadius)
+      .sort((a, b) => dist(a.x, a.y, you.x, you.y) - dist(b.x, b.y, you.x, you.y))
+      .slice(0, MAX_THREATS);
+  }
+
+  private handleNoThreat(you: Position & { currently_moving?: boolean }, ctx: StrategyContext): BehaviorDecision[] {
+    this.committed = null;
+    if (this.options.idleNotices) {
+      if (!you.currently_moving) this.notice(ctx, 'idle', `附近 ${this.threatRadius}px 内无人，原地待命。`);
+      else this.notice(ctx, 'coast', '威胁解除，继续完成当前移动，不再补发停步指令。');
+    }
+    return [];
+  }
+
+  private commit(ctx: StrategyContext, target: Position, threats: PlayerInfo[], verb: string, panic = false, detail = ''): void {
+    this.committed = target;
+    this.lastCommitAt = Date.now();
+    this.lastCommitWasPanic = panic;
+    const names = threats.map(p => p.name).join('、');
+    this.notice(
+      ctx,
+      `${verb}:${targetKey(target)}`,
+      `发现${this.options.noun ?? ''}${names}，${verb}到 (${Math.round(target.x)}, ${Math.round(target.y)})。${detail}`,
+    );
+  }
+
+  private notice(ctx: StrategyContext, key: string, msg: string): void {
+    if (key === this.lastNoticeKey) return;
+    this.lastNoticeKey = key;
+    ctx.notifications.push(msg);
+  }
+}