@myclaw163/clawclaw-cli 0.6.76 → 0.6.78

package/src/strategies/goals/emergency-hunt-goal.ts

@@ -1,28 +1,28 @@
-import type { GameState } from '../../sdk/types.js';
-import { Action } from '../../sdk/action.js';
-import { nonTeammatesVisible, patrolStep, PatrolState, roomAwayFromPlayers } from '../game-utils.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-import { Goal } from './goal.js';
-import type { LoneKillCore } from './lone-kill-core.js';
-
-/**
- * 紧急（自己触发破坏警报）期间的搜猎子目标（叶子，由上层以 URGENT 优先级挂载）：虾群涌向维修点，
- * 蟹不做任务，朝人少方向走去抓真正掉队的——警报期杀人照样会被举报，所以不在人前乱杀、只清落单；
- * 看不到非队友就按房间游走搜寻。永远有动作。
- * stop_on_player 复用 core.patrolStopOnPlayer()（身边只有队友时别撞着队友停下）。
- */
-export class EmergencyHuntGoal extends Goal {
-  constructor(
-    private readonly core: LoneKillCore,
-    private readonly patrol: PatrolState,
-  ) {
-    super();
-  }
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    const crowd = nonTeammatesVisible(state, ctx);
-    const room = roomAwayFromPlayers(state, ctx, crowd);
-    if (room) return [{ action: Action.move({ x: room.x, y: room.y }, false) }];
-    return patrolStep(state, ctx, this.patrol, this.core.patrolStopOnPlayer());
-  }
-}
+import type { GameState } from '../../sdk/types.js';
+import { Action } from '../../sdk/action.js';
+import { nonTeammatesVisible, patrolStep, PatrolState, roomAwayFromPlayers } from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+import type { LoneKillCore } from './lone-kill-core.js';
+
+/**
+ * 紧急（自己触发破坏警报）期间的搜猎子目标（叶子，由上层以 URGENT 优先级挂载）：虾群涌向维修点，
+ * 蟹不做任务，朝人少方向走去抓真正掉队的——警报期杀人照样会被举报，所以不在人前乱杀、只清落单；
+ * 看不到非队友就按房间游走搜寻。永远有动作。
+ * stop_on_player 复用 core.patrolStopOnPlayer()（身边只有队友时别撞着队友停下）。
+ */
+export class EmergencyHuntGoal extends Goal {
+  constructor(
+    private readonly core: LoneKillCore,
+    private readonly patrol: PatrolState,
+  ) {
+    super();
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const crowd = nonTeammatesVisible(state, ctx);
+    const room = roomAwayFromPlayers(state, ctx, crowd);
+    if (room) return [{ action: Action.move({ x: room.x, y: room.y }, false) }];
+    return patrolStep(state, ctx, this.patrol, this.core.patrolStopOnPlayer());
+  }
+}

package/src/strategies/goals/find-player-top.ts

@@ -1,93 +1,93 @@
-import type { GameState } from '../../sdk/types.js';
-import { Action } from '../../sdk/action.js';
-import {
-  dist,
-  isTargetAlive,
-  nearestVisibleTarget,
-  PatrolState,
-  PATROL_REACHED_DISTANCE,
-  PROGRESS_INTERVAL_MS,
-  pursueVisibleTarget,
-} from '../game-utils.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-import { Goal } from './goal.js';
-
-const DEFAULT_TRACK_DISTANCE = 40;
-const LAST_SEEN_ARRIVE = 20;
-
-export class FindPlayerTop extends Goal {
-  private readonly patrol = new PatrolState();
-  private lastSeenX: number | null = null;
-  private lastSeenY: number | null = null;
-  private foundNotified = false;
-
-  constructor(
-    private readonly target: string,
-    private readonly trackDistance: number = DEFAULT_TRACK_DISTANCE,
-  ) {
-    super();
-  }
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    if (!isTargetAlive(state, this.target, ctx)) {
-      ctx.notifications.push('目标已死亡');
-      this.emitProgress(state, ctx);
-      return [];
-    }
-
-    const target = nearestVisibleTarget(state, ctx, [this.target]);
-    if (target) {
-      this.lastSeenX = target.x;
-      this.lastSeenY = target.y;
-      if (!this.foundNotified) {
-        this.foundNotified = true;
-        ctx.notifications.push('我已经牢牢跟住他了！');
-      }
-      const decision = pursueVisibleTarget(state, target, { kill: false, followDistance: this.trackDistance });
-      this.emitProgress(state, ctx);
-      return decision ? [decision] : [];
-    }
-
-    this.foundNotified = false;
-
-    if (this.lastSeenX != null && this.lastSeenY != null) {
-      if (dist(state.you.x, state.you.y, this.lastSeenX, this.lastSeenY) > LAST_SEEN_ARRIVE) {
-        this.emitProgress(state, ctx);
-        return [{ action: Action.move({ x: this.lastSeenX, y: this.lastSeenY }) }];
-      }
-      this.lastSeenX = null;
-      this.lastSeenY = null;
-    }
-
-    this.emitProgress(state, ctx);
-    return this.patrolDecision(state, ctx);
-  }
-
-  private patrolDecision(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    let room = this.patrol.nextRoom(ctx);
-    if (!room) return [];
-    if (dist(state.you.x, state.you.y, room.x, room.y) <= PATROL_REACHED_DISTANCE) {
-      this.patrol.advance(ctx);
-      const next = this.patrol.nextRoom(ctx);
-      if (next) room = next;
-    }
-    return [{ action: Action.move({ x: room.x, y: room.y }) }];
-  }
-
-  private emitProgress(state: GameState, ctx: StrategyContext): void {
-    const now = Date.now();
-    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
-    ctx.lastProgressNotifyAt = now;
-
-    const room = state.you.room ?? '未知';
-    if (this.foundNotified) {
-      const t = nearestVisibleTarget(state, ctx, [this.target]);
-      const d = t ? (t.distance ?? dist(state.you.x, state.you.y, t.x, t.y)) : 0;
-      ctx.notifications.push(`[进度] 当前在${room}，正在跟踪目标${this.target}，距离${Math.round(d)}px。`);
-    } else if (this.lastSeenX != null) {
-      ctx.notifications.push(`[进度] 当前在${room}，跟丢了，正赶往${this.target}最后出现的位置。`);
-    } else {
-      ctx.notifications.push(`[进度] 当前在${room}，正在巡逻寻找${this.target}。`);
-    }
-  }
-}
+import type { GameState } from '../../sdk/types.js';
+import { Action } from '../../sdk/action.js';
+import {
+  dist,
+  isTargetAlive,
+  nearestVisibleTarget,
+  PatrolState,
+  PATROL_REACHED_DISTANCE,
+  PROGRESS_INTERVAL_MS,
+  pursueVisibleTarget,
+} from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+
+const DEFAULT_TRACK_DISTANCE = 40;
+const LAST_SEEN_ARRIVE = 20;
+
+export class FindPlayerTop extends Goal {
+  private readonly patrol = new PatrolState();
+  private lastSeenX: number | null = null;
+  private lastSeenY: number | null = null;
+  private foundNotified = false;
+
+  constructor(
+    private readonly target: string,
+    private readonly trackDistance: number = DEFAULT_TRACK_DISTANCE,
+  ) {
+    super();
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    if (!isTargetAlive(state, this.target, ctx)) {
+      ctx.notifications.push('目标已死亡');
+      this.emitProgress(state, ctx);
+      return [];
+    }
+
+    const target = nearestVisibleTarget(state, ctx, [this.target]);
+    if (target) {
+      this.lastSeenX = target.x;
+      this.lastSeenY = target.y;
+      if (!this.foundNotified) {
+        this.foundNotified = true;
+        ctx.notifications.push('我已经牢牢跟住他了！');
+      }
+      const decision = pursueVisibleTarget(state, target, { kill: false, followDistance: this.trackDistance });
+      this.emitProgress(state, ctx);
+      return decision ? [decision] : [];
+    }
+
+    this.foundNotified = false;
+
+    if (this.lastSeenX != null && this.lastSeenY != null) {
+      if (dist(state.you.x, state.you.y, this.lastSeenX, this.lastSeenY) > LAST_SEEN_ARRIVE) {
+        this.emitProgress(state, ctx);
+        return [{ action: Action.move({ x: this.lastSeenX, y: this.lastSeenY }) }];
+      }
+      this.lastSeenX = null;
+      this.lastSeenY = null;
+    }
+
+    this.emitProgress(state, ctx);
+    return this.patrolDecision(state, ctx);
+  }
+
+  private patrolDecision(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    let room = this.patrol.nextRoom(ctx);
+    if (!room) return [];
+    if (dist(state.you.x, state.you.y, room.x, room.y) <= PATROL_REACHED_DISTANCE) {
+      this.patrol.advance(ctx);
+      const next = this.patrol.nextRoom(ctx);
+      if (next) room = next;
+    }
+    return [{ action: Action.move({ x: room.x, y: room.y }) }];
+  }
+
+  private emitProgress(state: GameState, ctx: StrategyContext): void {
+    const now = Date.now();
+    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
+    ctx.lastProgressNotifyAt = now;
+
+    const room = state.you.room ?? '未知';
+    if (this.foundNotified) {
+      const t = nearestVisibleTarget(state, ctx, [this.target]);
+      const d = t ? (t.distance ?? dist(state.you.x, state.you.y, t.x, t.y)) : 0;
+      ctx.notifications.push(`[进度] 当前在${room}，正在跟踪目标${this.target}，距离${Math.round(d)}px。`);
+    } else if (this.lastSeenX != null) {
+      ctx.notifications.push(`[进度] 当前在${room}，跟丢了，正赶往${this.target}最后出现的位置。`);
+    } else {
+      ctx.notifications.push(`[进度] 当前在${room}，正在巡逻寻找${this.target}。`);
+    }
+  }
+}

package/src/strategies/goals/flee-players-goal.ts

@@ -1,53 +1,53 @@
-import type { GameState, PlayerInfo } from '../../sdk/types.js';
-import { dist, hasReachedRoomTarget, resolveRoom, roomAwayFromPlayers } from '../game-utils.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-import { Goal } from './goal.js';
-import { MoveRoomGoal } from './move-room-goal.js';
-
-export type FleePlayerResolver = (state: GameState, ctx: StrategyContext) => PlayerInfo[];
-
-export interface FleePlayersGoalOptions {
-  emitProgress?: boolean;
-  finishWhenEmpty?: boolean;
-  stopOnPlayer?: boolean;
-}
-
-export class FleePlayersGoal extends Goal {
-  constructor(
-    public readonly key: string,
-    private readonly resolvePlayers: FleePlayerResolver,
-    private readonly options: FleePlayersGoalOptions = {},
-  ) {
-    super();
-  }
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    const players = this.resolvePlayers(state, ctx);
-    const worker = this.subGoal;
-    if (worker instanceof MoveRoomGoal && this.canKeepTarget(worker, state, ctx, players)) return [];
-
-    const room = roomAwayFromPlayers(state, ctx, players);
-    if (!room) return [];
-
-    if (!(worker instanceof MoveRoomGoal) || worker.room !== room.name) {
-      if (this.subGoal) this.removeSubGoal();
-      this.setSubGoal(new MoveRoomGoal(room.name, hasReachedRoomTarget, {
-        emitProgress: this.options.emitProgress ?? false,
-        stopOnPlayer: this.options.stopOnPlayer ?? false,
-      }), 0.2);
-    }
-    return [];
-  }
-
-  isFinish(state: GameState, ctx: StrategyContext): boolean {
-    return (this.options.finishWhenEmpty ?? true) && this.resolvePlayers(state, ctx).length === 0;
-  }
-
-  private canKeepTarget(worker: MoveRoomGoal, state: GameState, ctx: StrategyContext, players: PlayerInfo[]): boolean {
-    const target = resolveRoom(worker.room, ctx);
-    if (!target) return false;
-    if (hasReachedRoomTarget(state, target)) return true;
-    if (ctx.blockedMoveTarget && dist(target.x, target.y, ctx.blockedMoveTarget.x, ctx.blockedMoveTarget.y) <= 10) return false;
-    return !players.some(player => player.room?.toLowerCase() === target.name.toLowerCase());
-  }
-}
+import type { GameState, PlayerInfo } from '../../sdk/types.js';
+import { dist, hasReachedRoomTarget, resolveRoom, roomAwayFromPlayers } from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+import { MoveRoomGoal } from './move-room-goal.js';
+
+export type FleePlayerResolver = (state: GameState, ctx: StrategyContext) => PlayerInfo[];
+
+export interface FleePlayersGoalOptions {
+  emitProgress?: boolean;
+  finishWhenEmpty?: boolean;
+  stopOnPlayer?: boolean;
+}
+
+export class FleePlayersGoal extends Goal {
+  constructor(
+    public readonly key: string,
+    private readonly resolvePlayers: FleePlayerResolver,
+    private readonly options: FleePlayersGoalOptions = {},
+  ) {
+    super();
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const players = this.resolvePlayers(state, ctx);
+    const worker = this.subGoal;
+    if (worker instanceof MoveRoomGoal && this.canKeepTarget(worker, state, ctx, players)) return [];
+
+    const room = roomAwayFromPlayers(state, ctx, players);
+    if (!room) return [];
+
+    if (!(worker instanceof MoveRoomGoal) || worker.room !== room.name) {
+      if (this.subGoal) this.removeSubGoal();
+      this.setSubGoal(new MoveRoomGoal(room.name, hasReachedRoomTarget, {
+        emitProgress: this.options.emitProgress ?? false,
+        stopOnPlayer: this.options.stopOnPlayer ?? false,
+      }), 0.2);
+    }
+    return [];
+  }
+
+  isFinish(state: GameState, ctx: StrategyContext): boolean {
+    return (this.options.finishWhenEmpty ?? true) && this.resolvePlayers(state, ctx).length === 0;
+  }
+
+  private canKeepTarget(worker: MoveRoomGoal, state: GameState, ctx: StrategyContext, players: PlayerInfo[]): boolean {
+    const target = resolveRoom(worker.room, ctx);
+    if (!target) return false;
+    if (hasReachedRoomTarget(state, target)) return true;
+    if (ctx.blockedMoveTarget && dist(target.x, target.y, ctx.blockedMoveTarget.x, ctx.blockedMoveTarget.y) <= 10) return false;
+    return !players.some(player => player.room?.toLowerCase() === target.name.toLowerCase());
+  }
+}

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

@@ -1,106 +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;
-  }
-}
+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/goal-manager.ts

@@ -1,41 +1,41 @@
-import type { GameState } from '../../sdk/types.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-import { Goal } from './goal.js';
-
-export class GoalManager {
-  private top: Goal | null = null;
-
-  setTop(goal: Goal): void {
-    this.top = goal;
-  }
-
-  getTop(): Goal | null {
-    return this.top;
-  }
-
-  clear(): void {
-    this.top = null;
-  }
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    const decisions: BehaviorDecision[] = [];
-    let parent: Goal | null = null;
-    let node: Goal | null = this.top;
-
-    while (node !== null) {
-      if (node.isFinish(state, ctx)) {
-        if (parent === null) {
-          this.top = null;
-        } else {
-          parent.removeSubGoal();
-        }
-        break;
-      }
-      decisions.push(...node.tick(state, ctx));
-      parent = node;
-      node = node.subGoal;
-    }
-
-    return decisions;
-  }
-}
+import type { GameState } from '../../sdk/types.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+
+export class GoalManager {
+  private top: Goal | null = null;
+
+  setTop(goal: Goal): void {
+    this.top = goal;
+  }
+
+  getTop(): Goal | null {
+    return this.top;
+  }
+
+  clear(): void {
+    this.top = null;
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const decisions: BehaviorDecision[] = [];
+    let parent: Goal | null = null;
+    let node: Goal | null = this.top;
+
+    while (node !== null) {
+      if (node.isFinish(state, ctx)) {
+        if (parent === null) {
+          this.top = null;
+        } else {
+          parent.removeSubGoal();
+        }
+        break;
+      }
+      decisions.push(...node.tick(state, ctx));
+      parent = node;
+      node = node.subGoal;
+    }
+
+    return decisions;
+  }
+}