@myclaw163/clawclaw-cli 0.6.74 → 0.6.77

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

@@ -1,221 +1,221 @@
-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;
-/**
- * keep-away 逃跑推演基线参数。各档（FLEE 不覆盖；陌生人覆盖 steps:4）在此基础上合并 options.planOpts。
- * killRange 取 SHRIMP_KILL_RANGE(160) 而非 planner 默认 80：本层威胁只有坐标、没有角色（resolver
- * 返回可见非队友的裸位置，本游戏看不到他人身份），无法逐威胁取 killRangeFor，故统一用带刀虾兜底，
- * 宁可对蟹/章鱼多拉开也不对带刀好人少逃；带刀好人遇到未确认对象也只复用这一层做回避，不再自卫出刀。
- */
-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];
-
-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 | ((p: PlayerInfo, ctx: StrategyContext) => 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;
-    this.planOpts = { ...KEEP_AWAY_BASE_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 noun = this.options.noun;
-    const body = typeof noun === 'function'
-      ? threats.map(p => `${noun(p, ctx)}${p.name}`).join('、')
-      : `${noun ?? ''}${threats.map(p => p.name).join('、')}`;
-    this.notice(
-      ctx,
-      `${verb}:${targetKey(target)}`,
-      `发现${body}，${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;
+/**
+ * keep-away 逃跑推演基线参数。各档（FLEE 不覆盖；陌生人覆盖 steps:4）在此基础上合并 options.planOpts。
+ * killRange 取 SHRIMP_KILL_RANGE(160) 而非 planner 默认 80：本层威胁只有坐标、没有角色（resolver
+ * 返回可见非队友的裸位置，本游戏看不到他人身份），无法逐威胁取 killRangeFor，故统一用带刀虾兜底，
+ * 宁可对蟹/章鱼多拉开也不对带刀好人少逃；带刀好人遇到未确认对象也只复用这一层做回避，不再自卫出刀。
+ */
+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];
+
+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 | ((p: PlayerInfo, ctx: StrategyContext) => 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;
+    this.planOpts = { ...KEEP_AWAY_BASE_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 noun = this.options.noun;
+    const body = typeof noun === 'function'
+      ? threats.map(p => `${noun(p, ctx)}${p.name}`).join('、')
+      : `${noun ?? ''}${threats.map(p => p.name).join('、')}`;
+    this.notice(
+      ctx,
+      `${verb}:${targetKey(target)}`,
+      `发现${body}，${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);
+  }
+}

package/src/strategies/goals/kill-frenzy-top.ts

@@ -1,80 +1,80 @@
-import type { GameState, PlayerInfo } from '../../sdk/types.js';
-import {
-  dist,
-  killCooldownSecs,
-  killCommitRange,
-  LONE_FOLLOW_DISTANCE,
-  nearestPlayerByDistance,
-  nonTeammatesVisible,
-  patrolStep,
-  PatrolState,
-  PROGRESS_INTERVAL_MS,
-  pursueVisibleTarget,
-} from '../game-utils.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-import { Goal } from './goal.js';
-
-/**
- * 疯狂砍人：见谁杀谁（除队友外的所有可见玩家），不挑落单、不看人数、不看知识库。
- * 与 kill-lone 不同——周围人多也照杀，绝不因人多而暂停。
- *
- * 逐 tick：
- * - 视野内有非队友 → 锁定最近那个，贴上去：出刀范围内且冷却好就出刀，
- *   冷却中保持 LONE_FOLLOW_DISTANCE 贴身跟随等待。
- * - 否则 → 按房间顺序巡逻找猎物。永不停手。
- *
- * 与 kill-target 复用同一套「锁定后追/砍/等冷却」体验（pursueVisibleTarget，
- * kill=true、followDistance=LONE_FOLLOW_DISTANCE），仅目标选取规则不同：
- * kill-target 追指定名单，kill-frenzy 追最近的任意非队友。
- */
-export class KillFrenzyTop extends Goal {
-  private readonly patrol = new PatrolState();
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    const target = this.nearestVictim(state, ctx);
-    if (target) {
-      const decision = pursueVisibleTarget(state, target, { kill: true, followDistance: LONE_FOLLOW_DISTANCE });
-      if (decision?.action.type === 'kill') {
-        ctx.notifications.push(`发现目标${target.name}在攻击范围内，出刀！`);
-      } else {
-        const d = target.distance ?? dist(state.you.x, state.you.y, target.x, target.y);
-        if (d > killCommitRange(state.you.role)) ctx.notifications.push(`发现目标${target.name}，正在靠近！`);
-      }
-      this.emitProgress(state, ctx);
-      return decision ? [decision] : [];
-    }
-
-    this.emitProgress(state, ctx);
-    return patrolStep(state, ctx, this.patrol, false);
-  }
-
-  private nearestVictim(state: GameState, ctx: StrategyContext): PlayerInfo | null {
-    return nearestPlayerByDistance(state, nonTeammatesVisible(state, ctx));
-  }
-
-  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 ?? '未知';
-    const cd = killCooldownSecs(state);
-    const killsRemaining = state.you.kills_remaining;
-    const victims = nonTeammatesVisible(state, ctx);
-
-    let msg = `[进度] 当前在${room}`;
-    if (victims.length === 0) {
-      msg += '，视野内没有目标，继续巡逻寻找猎物。';
-    } else {
-      const nearest = victims.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;
-      });
-      msg += `，视野内发现${victims.length}个目标，最近是${nearest.name}。`;
-      if (cd > 0) msg += `攻击冷却中(${cd}s)。`;
-      if (killsRemaining === 0) msg += '出刀次数已用完。';
-    }
-    ctx.notifications.push(msg);
-  }
-}
+import type { GameState, PlayerInfo } from '../../sdk/types.js';
+import {
+  dist,
+  killCooldownSecs,
+  killCommitRange,
+  LONE_FOLLOW_DISTANCE,
+  nearestPlayerByDistance,
+  nonTeammatesVisible,
+  patrolStep,
+  PatrolState,
+  PROGRESS_INTERVAL_MS,
+  pursueVisibleTarget,
+} from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+
+/**
+ * 疯狂砍人：见谁杀谁（除队友外的所有可见玩家），不挑落单、不看人数、不看知识库。
+ * 与 kill-lone 不同——周围人多也照杀，绝不因人多而暂停。
+ *
+ * 逐 tick：
+ * - 视野内有非队友 → 锁定最近那个，贴上去：出刀范围内且冷却好就出刀，
+ *   冷却中保持 LONE_FOLLOW_DISTANCE 贴身跟随等待。
+ * - 否则 → 按房间顺序巡逻找猎物。永不停手。
+ *
+ * 与 kill-target 复用同一套「锁定后追/砍/等冷却」体验（pursueVisibleTarget，
+ * kill=true、followDistance=LONE_FOLLOW_DISTANCE），仅目标选取规则不同：
+ * kill-target 追指定名单，kill-frenzy 追最近的任意非队友。
+ */
+export class KillFrenzyTop extends Goal {
+  private readonly patrol = new PatrolState();
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const target = this.nearestVictim(state, ctx);
+    if (target) {
+      const decision = pursueVisibleTarget(state, target, { kill: true, followDistance: LONE_FOLLOW_DISTANCE });
+      if (decision?.action.type === 'kill') {
+        ctx.notifications.push(`发现目标${target.name}在攻击范围内，出刀！`);
+      } else {
+        const d = target.distance ?? dist(state.you.x, state.you.y, target.x, target.y);
+        if (d > killCommitRange(state.you.role)) ctx.notifications.push(`发现目标${target.name}，正在靠近！`);
+      }
+      this.emitProgress(state, ctx);
+      return decision ? [decision] : [];
+    }
+
+    this.emitProgress(state, ctx);
+    return patrolStep(state, ctx, this.patrol, false);
+  }
+
+  private nearestVictim(state: GameState, ctx: StrategyContext): PlayerInfo | null {
+    return nearestPlayerByDistance(state, nonTeammatesVisible(state, ctx));
+  }
+
+  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 ?? '未知';
+    const cd = killCooldownSecs(state);
+    const killsRemaining = state.you.kills_remaining;
+    const victims = nonTeammatesVisible(state, ctx);
+
+    let msg = `[进度] 当前在${room}`;
+    if (victims.length === 0) {
+      msg += '，视野内没有目标，继续巡逻寻找猎物。';
+    } else {
+      const nearest = victims.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;
+      });
+      msg += `，视野内发现${victims.length}个目标，最近是${nearest.name}。`;
+      if (cd > 0) msg += `攻击冷却中(${cd}s)。`;
+      if (killsRemaining === 0) msg += '出刀次数已用完。';
+    }
+    ctx.notifications.push(msg);
+  }
+}