@myclaw163/clawclaw-cli 0.6.61 → 0.6.64

package/src/sdk/index.ts

@@ -39,7 +39,7 @@ export { Action } from './action.js';
 export { GameClient } from '../lib/game-client.js';
 export type { GameClientConfig } from '../lib/game-client.js';
 export type {
-  GameState, PlayerInfo, PlayerSelf, CorpseInfo, TaskInfo, EmergencyInfo,
+  GameState, PlayerInfo, PlayerSelf, CorpseInfo, TaskInfo, TaskLocation, EmergencyInfo,
   Position, GameEvent, MapRoom, GameResult,
   WsConnectionState, ActionErrorCode,
 } from './types.js';
@@ -104,6 +104,7 @@ export { FindPlayerTop } from '../strategies/goals/find-player-top.js';
 export { SocialTaskTop } from '../strategies/goals/social-task-top.js';
 export { AvoidLoneTop } from '../strategies/goals/avoid-lone-top.js';
 export { AvoidPlayersTop } from '../strategies/goals/avoid-players-top.js';
+export { HideTop } from '../strategies/goals/hide-top.js';
 export { MoveRoomGoal } from '../strategies/goals/move-room-goal.js';
 export { ConversationGoal } from '../strategies/goals/conversation-goal.js';
 

package/src/sdk/types.ts

@@ -105,6 +105,19 @@ export interface TaskInfo {
   faction?: 'lobster' | 'crab';
 }
 
+/**
+ * 全局任务站点（map 的 all_task_locations）：所有玩家共享、开局固定的任务点位置。与 `your_tasks` /
+ * `StrategyContext.taskData`（仅自己被分配、带 status）不同——这里只有位置，没有 status。
+ * faction='lobster' 是正常任务点，'crab' 是破坏点。
+ */
+export interface TaskLocation {
+  name: string;
+  room?: string;
+  x: number;
+  y: number;
+  faction?: 'lobster' | 'crab';
+}
+
 export interface EmergencyInfo extends TaskInfo {
   remaining_secs: number;
 }

package/src/strategies/goals/anchor-linger.ts

@@ -0,0 +1,77 @@
+import type { GameState, PlayerInfo, Position } from '../../sdk/types.js';
+import { dist } from '../game-utils.js';
+
+export interface AnchorLingerOptions {
+  /** 游走环最小半径（px）。 */
+  min?: number;
+  /** 游走环最大半径（px）。 */
+  max?: number;
+  /** 走到离游走点这么近就算到达、换下一个点。 */
+  reached?: number;
+  /** 单个游走点最多停留这么久就强制换点，防止点落在墙里不可达时卡死。 */
+  dwellMs?: number;
+}
+
+/**
+ * 围绕一个锚点 min-max px 的「粘性游走」：游走点一旦选定就粘住，直到走到 / 超时 / 换了锚点，
+ * 不每 tick 重随机——否则主循环对「同一移动目标」的去重永不触发，会每轮打断上一次移动、在原地抖
+ * 而走不出一条游走腿。有 avoid 目标时偏向锚点相对最近目标的对侧。贴尸游走（LingerCorpseGoal）
+ * 与跟随同伴在其任务点假装做任务（FollowCompanionGoal）复用同一套游走机制。
+ */
+export class AnchorLinger {
+  private target: Position | null = null;
+  private until = 0;
+  private key = '';
+  private readonly min: number;
+  private readonly max: number;
+  private readonly reached: number;
+  private readonly dwellMs: number;
+
+  constructor(options: AnchorLingerOptions = {}) {
+    this.min = options.min ?? 40;
+    this.max = options.max ?? 100;
+    this.reached = options.reached ?? 24;
+    this.dwellMs = options.dwellMs ?? 4000;
+  }
+
+  /** 丢弃当前游走点：离开锚点（尸体出视野、同伴起身走动）时调用，下次重新挑点。 */
+  reset(): void {
+    this.target = null;
+  }
+
+  /** 围绕 anchor 取下一个游走点；key 变了（换了锚点）会立即重挑。 */
+  step(state: GameState, key: string, anchor: Position, avoid: PlayerInfo[] = []): Position {
+    const now = Date.now();
+    const reached = this.target != null
+      && dist(state.you.x, state.you.y, this.target.x, this.target.y) <= this.reached;
+    if (this.target == null || this.key !== key || reached || now >= this.until) {
+      this.key = key;
+      this.target = this.pickOffset(state, anchor, avoid);
+      this.until = now + this.dwellMs;
+    }
+    return this.target;
+  }
+
+  private pickOffset(state: GameState, anchor: Position, avoid: PlayerInfo[]): Position {
+    return avoid.length > 0 ? this.farSideOffset(state, anchor, avoid) : this.randomOffset(anchor);
+  }
+
+  private farSideOffset(state: GameState, anchor: Position, avoid: PlayerInfo[]): Position {
+    const nearest = avoid.reduce((best, p) => {
+      const d = p.distance ?? dist(state.you.x, state.you.y, p.x, p.y);
+      const bestD = best.distance ?? dist(state.you.x, state.you.y, best.x, best.y);
+      return d < bestD ? p : best;
+    });
+    const vx = anchor.x - nearest.x;
+    const vy = anchor.y - nearest.y;
+    const len = Math.hypot(vx, vy);
+    if (len === 0) return this.randomOffset(anchor);
+    return { x: anchor.x + (vx / len) * this.max, y: anchor.y + (vy / len) * this.max };
+  }
+
+  private randomOffset(anchor: Position): Position {
+    const angle = Math.random() * 2 * Math.PI;
+    const radius = this.min + Math.random() * (this.max - this.min);
+    return { x: anchor.x + Math.cos(angle) * radius, y: anchor.y + Math.sin(angle) * radius };
+  }
+}

package/src/strategies/goals/follow-companion-goal.ts

@@ -0,0 +1,106 @@
+import type { GameState, PlayerInfo, Position } from '../../sdk/types.js';
+import { Action } from '../../sdk/action.js';
+import { dist, nearestPlayerByDistance } from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { AnchorLinger } from './anchor-linger.js';
+import { Goal } from './goal.js';
+
+/** 同伴移动时跟到这么近（px）就停手，不再补发移动，免得贴身打转；停住后改在锚点附近 40-100 游走。 */
+const FOLLOW_STOP = 80;
+/** 同伴本帧位置离上次记下的停留点小于这么多（px）就算「没动」。走路一步上百 px，远大于此。 */
+const STILL_EPS = 30;
+/** 同伴「没动」持续这么久（ms）就当作在做任务，切到在其停留点假装做任务（≈ 一个轮询间隔的余量）。 */
+const PARKED_MS = 1500;
+/** 距上次 tick 超过这么久（ms，被开会/高优先级行为打断）就重置跟踪，避免拿陈旧停留点误判同伴已停住。 */
+const STALE_MS = 5000;
+/** 同伴停留点离某个真实任务站点这么近（px）就以站点为晃荡中心，否则就地在停留点附近晃。 */
+const TASK_ANCHOR_RANGE = 100;
+
+type CompanionResolver = (state: GameState, ctx: StrategyContext) => PlayerInfo[];
+
+/**
+ * 跟随可信同伴：同伴走动时跟在其身后，同伴停下（推断在做任务）时就在其停留点附近 40-100 px 游走
+ * 「假装做任务」，融入人群躲投票——天堂鱼无刀、不做任务，靠贴着可信同伴显得正常。无法直接观测他人
+ * 是否在做任务（PlayerInfo 不含 doing_task），故以「同伴位置连续 PARKED_MS 没动」作为代理判据。
+ * 任务点游走复用 AnchorLinger（与贴尸 LingerCorpseGoal 同一套粘性游走）。优先级由调用方（天堂鱼
+ * tick 的 if 链顺序）控制：排在贴尸游走之后，故跟随天然低于在尸体上晃荡。
+ */
+export class FollowCompanionGoal extends Goal {
+  private readonly wander = new AnchorLinger();
+  private mateKey = '';
+  private mateAnchor: Position | null = null;
+  private stillSince = 0;
+  private lastTickAt = 0;
+
+  constructor(
+    private readonly resolveCompanions: CompanionResolver,
+    private readonly resolveAvoid?: CompanionResolver,
+  ) {
+    super();
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const now = Date.now();
+    const stale = now - this.lastTickAt > STALE_MS;
+    this.lastTickAt = now;
+
+    const mate = nearestPlayerByDistance(state, this.resolveCompanions(state, ctx));
+    if (!mate) {
+      this.resetTracking();
+      return [];
+    }
+
+    const key = this.mateKeyOf(mate);
+    const moved = this.mateAnchor == null
+      || dist(mate.x, mate.y, this.mateAnchor.x, this.mateAnchor.y) > STILL_EPS;
+    if (stale || this.mateKey !== key || moved) {
+      this.mateKey = key;
+      this.mateAnchor = { x: mate.x, y: mate.y };
+      this.stillSince = now;
+    }
+
+    if (now - this.stillSince >= PARKED_MS) {
+      // 同伴停住够久（多半在做任务）：优先以其附近真实任务站点为晃荡中心——更像在做任务、坐标也比同伴
+      // 上报位置稳；附近没有任务站点（如只是站着闲聊）就退回在停留点附近晃。旁边有要避开的人就偏到对侧。
+      const avoid = this.resolveAvoid?.(state, ctx) ?? [];
+      const spot = this.taskAnchorNear(ctx, this.mateAnchor!)
+        ?? { x: this.mateAnchor!.x, y: this.mateAnchor!.y, key: `mate:${key}` };
+      return [{ action: Action.move(this.wander.step(state, spot.key, spot, avoid)) }];
+    }
+
+    // 同伴在移动：跟上去，跟到 FOLLOW_STOP 内就不再补发移动。
+    this.wander.reset();
+    const d = mate.distance ?? dist(state.you.x, state.you.y, mate.x, mate.y);
+    return d > FOLLOW_STOP ? [{ action: Action.move({ x: mate.x, y: mate.y }) }] : [];
+  }
+
+  isFinish(state: GameState, ctx: StrategyContext): boolean {
+    return this.resolveCompanions(state, ctx).length === 0;
+  }
+
+  private mateKeyOf(mate: PlayerInfo): string {
+    return mate.name || (mate.seat != null ? String(mate.seat) : `${Math.round(mate.x)},${Math.round(mate.y)}`);
+  }
+
+  /** 同伴停留点附近最近的真实任务站点（蟹的破坏点除外），带稳定 key 供 AnchorLinger 粘住游走。 */
+  private taskAnchorNear(ctx: StrategyContext, near: Position): { x: number; y: number; key: string } | null {
+    let best: { x: number; y: number; key: string } | null = null;
+    let bestD = TASK_ANCHOR_RANGE;
+    for (const t of ctx.taskLocations ?? []) {
+      if (t.faction === 'crab') continue;
+      const d = dist(near.x, near.y, t.x, t.y);
+      if (d <= bestD) {
+        best = { x: t.x, y: t.y, key: `task:${t.name}` };
+        bestD = d;
+      }
+    }
+    return best;
+  }
+
+  private resetTracking(): void {
+    this.wander.reset();
+    this.mateKey = '';
+    this.mateAnchor = null;
+    this.stillSince = 0;
+  }
+}

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

@@ -14,7 +14,19 @@ 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 };
+/**
+ * keep-away 逃跑推演基线参数。各档（FLEE 不覆盖；陌生人覆盖 steps:4）在此基础上合并 options.planOpts。
+ * killRange 取 SHRIMP_KILL_RANGE(160) 而非 planner 默认 80：本层威胁只有坐标、没有角色（resolver
+ * 返回可见非队友的裸位置，本游戏看不到他人身份），无法逐威胁取 killRangeFor，故统一用带刀虾兜底，
+ * 宁可对蟹/章鱼多拉开也不对带刀好人少逃。武士虾自卫判定（warrior-shrimp-top）复用它，保证「避不开」口径一致。
+ */
+export const KEEP_AWAY_BASE_PLAN_OPTS: EscapeOptions = {
+  killRange: SHRIMP_KILL_RANGE,
+  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];
 
@@ -101,11 +113,7 @@ export class KeepAwayGoal extends Goal {
   ) {
     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 };
+    this.planOpts = { ...KEEP_AWAY_BASE_PLAN_OPTS, ...options.planOpts };
   }
 
   tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
@@ -165,7 +173,7 @@ export class KeepAwayGoal extends Goal {
     }
 
     const target = this.committed!;
-    return [{ action: Action.move(target).withThinking(`躲避${threats.map(p => p.name).join('、')}，前往 (${Math.round(target.x)}, ${Math.round(target.y)})`) }];
+    return [{ action: Action.move(target).withThinking(`躲避${threats.map(p => p.name).join('、')}，拉开距离`) }];
   }
 
   isFinish(state: GameState, ctx: StrategyContext): boolean {

package/src/strategies/goals/linger-corpse-goal.ts

@@ -1,20 +1,12 @@
 import type { GameState, PlayerInfo } from '../../sdk/types.js';
 import { Action } from '../../sdk/action.js';
-import { dist, nearestKnownCorpse, nearestKnownCorpseNav } from '../game-utils.js';
-import type { BehaviorDecision, CorpseTarget, StrategyContext } from '../types.js';
+import { nearestKnownCorpse, nearestKnownCorpseNav } from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { AnchorLinger } from './anchor-linger.js';
 import { Goal } from './goal.js';
 
-const LINGER_MIN = 40;
-const LINGER_MAX = 100;
-/** 走到离游走点这么近就算到达、换下一个点（贴尸游走半径 40-100，单步约 144px）。 */
-const LINGER_REACHED = 24;
-/** 单个游走点最多停留这么久就强制换点，防止点落在墙里不可达时卡死。 */
-const LINGER_DWELL_MS = 4000;
-
 export class LingerCorpseGoal extends Goal {
-  private wanderTarget: { x: number; y: number } | null = null;
-  private wanderUntil = 0;
-  private anchorKey = '';
+  private readonly wander = new AnchorLinger();
 
   constructor(private readonly avoidResolver?: (state: GameState, ctx: StrategyContext) => PlayerInfo[]) {
     super();
@@ -24,13 +16,14 @@ export class LingerCorpseGoal extends Goal {
     const body = nearestKnownCorpse(state, ctx);
     if (!body) {
       // 还没拿到尸体坐标：朝尸体所在房间靠近，人进视野后坐标自然补全，再切到下面的贴尸游走。
-      this.wanderTarget = null;
+      this.wander.reset();
       const nav = nearestKnownCorpseNav(state, ctx);
       return nav ? [{ action: Action.move({ x: nav.x, y: nav.y }) }] : [];
     }
-    // 有坐标：在尸体周围 40-100 徘徊。目标「粘住」直到到点 / 超时 / 换了尸体——不再每 tick 重随机，
-    // 否则主循环对「同一移动目标」的去重永不触发，会每轮打断上一次移动、在原地抖而走不出一条游走腿。
-    return [{ action: Action.move(this.resolveWanderTarget(state, ctx, body)) }];
+    // 有坐标：在尸体周围 40-100 粘性徘徊（AnchorLinger 负责粘住游走点、按 avoid 偏到对侧）。
+    const key = body.name ?? `${Math.round(body.x)},${Math.round(body.y)}`;
+    const avoid = this.avoidResolver?.(state, ctx) ?? [];
+    return [{ action: Action.move(this.wander.step(state, key, body, avoid)) }];
   }
 
   // Nav / 非 Nav 的不对称是有意的：tick 取坐标用严格的 nearestKnownCorpse（没坐标无法定点游走），
@@ -39,41 +32,4 @@ export class LingerCorpseGoal extends Goal {
   isFinish(state: GameState, ctx: StrategyContext): boolean {
     return nearestKnownCorpseNav(state, ctx) == null;
   }
-
-  private resolveWanderTarget(state: GameState, ctx: StrategyContext, corpse: CorpseTarget): { x: number; y: number } {
-    const key = corpse.name ?? `${Math.round(corpse.x)},${Math.round(corpse.y)}`;
-    const now = Date.now();
-    const reached = this.wanderTarget != null
-      && dist(state.you.x, state.you.y, this.wanderTarget.x, this.wanderTarget.y) <= LINGER_REACHED;
-    if (this.wanderTarget == null || this.anchorKey !== key || reached || now >= this.wanderUntil) {
-      this.anchorKey = key;
-      this.wanderTarget = this.pickOffset(state, ctx, corpse);
-      this.wanderUntil = now + LINGER_DWELL_MS;
-    }
-    return this.wanderTarget;
-  }
-
-  private pickOffset(state: GameState, ctx: StrategyContext, corpse: CorpseTarget): { x: number; y: number } {
-    const avoid = this.avoidResolver?.(state, ctx) ?? [];
-    return avoid.length > 0 ? this.farSideOffset(state, corpse, avoid) : this.randomOffset(corpse);
-  }
-
-  private farSideOffset(state: GameState, corpse: CorpseTarget, avoid: PlayerInfo[]): { x: number; y: number } {
-    const nearest = avoid.reduce((best, p) => {
-      const d = p.distance ?? dist(state.you.x, state.you.y, p.x, p.y);
-      const bestD = best.distance ?? dist(state.you.x, state.you.y, best.x, best.y);
-      return d < bestD ? p : best;
-    });
-    const vx = corpse.x - nearest.x;
-    const vy = corpse.y - nearest.y;
-    const len = Math.hypot(vx, vy);
-    if (len === 0) return this.randomOffset(corpse);
-    return { x: corpse.x + (vx / len) * LINGER_MAX, y: corpse.y + (vy / len) * LINGER_MAX };
-  }
-
-  private randomOffset(corpse: CorpseTarget): { x: number; y: number } {
-    const angle = Math.random() * 2 * Math.PI;
-    const radius = LINGER_MIN + Math.random() * (LINGER_MAX - LINGER_MIN);
-    return { x: corpse.x + Math.cos(angle) * radius, y: corpse.y + Math.sin(angle) * radius };
-  }
 }

package/src/strategies/goals/paradise-fish-top.ts

@@ -1,8 +1,6 @@
 import type { GameState, PlayerInfo, Position } from '../../sdk/types.js';
-import { Action } from '../../sdk/action.js';
 import {
   corpseAtScene,
-  dist,
   hasKnownCorpse,
   isKnowledgeThreat,
   isKnowledgeTrusted,
@@ -13,12 +11,12 @@ import {
 } from '../game-utils.js';
 import type { BehaviorDecision, StrategyContext } from '../types.js';
 import { GreetingTracker } from '../greeting.js';
+import { FollowCompanionGoal } from './follow-companion-goal.js';
 import { Goal } from './goal.js';
 import { KeepAwayGoal, type KeepAwayGoalOptions, type ThreatResolver } from './keep-away-goal.js';
 import { LingerCorpseGoal } from './linger-corpse-goal.js';
 
 const SUB_PRIORITY = 0.5;
-const HUDDLE_DISTANCE = 80;
 const AVOID_ROUTE_MEMORY_MS = 10_000;
 const WITNESS_EXEMPT_COUNT = 2;
 
@@ -26,6 +24,10 @@ type Tier = 'corpse' | 'flee-bad' | 'keep-distance' | 'huddle' | 'wander';
 
 export class ParadiseFishTop extends Goal {
   private readonly linger = new LingerCorpseGoal((state, ctx) => this.visibleAvoidTargets(state, ctx));
+  private readonly follow = new FollowCompanionGoal(
+    (state, ctx) => nonTeammatesVisible(state, ctx).filter(p => this.isTrusted(p, ctx)),
+    (state, ctx) => this.visibleAvoidTargets(state, ctx),
+  );
   private readonly patrol = new PatrolState();
   private readonly greeting: GreetingTracker;
   private readonly recentAvoidPoints = new Map<string, { point: Position; until: number; threat: boolean }>();
@@ -77,11 +79,11 @@ export class ParadiseFishTop extends Goal {
       }
     }
 
-    const trusted = trustedTargets;
-    if (trusted.length > 0) {
+    if (trustedTargets.length > 0) {
       this.clearSub();
+      const follow = this.follow.tick(state, ctx);
       this.emitProgress(state, ctx, visible, 'huddle');
-      return [...this.huddle(state, trusted), ...decisions];
+      return [...follow, ...decisions];
     }
 
     this.clearSub();
@@ -110,20 +112,6 @@ export class ParadiseFishTop extends Goal {
     return threats.length > 0 ? threats : this.strangerAvoidTargets(visible, ctx);
   }
 
-  private huddle(state: GameState, trusted: PlayerInfo[]): BehaviorDecision[] {
-    if (trusted.length === 0) return [];
-    const mate = trusted.reduce((best, p) => {
-      const d = p.distance ?? dist(state.you.x, state.you.y, p.x, p.y);
-      const bestD = best.distance ?? dist(state.you.x, state.you.y, best.x, best.y);
-      return d < bestD ? p : best;
-    });
-    const d = mate.distance ?? dist(state.you.x, state.you.y, mate.x, mate.y);
-    if (d > HUDDLE_DISTANCE) {
-      return [{ action: Action.move({ x: mate.x, y: mate.y }) }];
-    }
-    return [];
-  }
-
   private wander(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
     return safePatrolStep(state, ctx, this.patrol, false, {
       threatPoints: this.activeAvoidPoints(),