@myclaw163/clawclaw-cli 0.6.58 → 0.6.60

package/src/strategies/goals/warrior-shrimp-top.ts

@@ -1,248 +1,248 @@
-import type { GameState, PlayerInfo } from '../../sdk/types.js';
-import { Action } from '../../sdk/action.js';
-import {
-  canUseKill,
-  corpseAtScene,
-  dist,
-  firstAvailableTask,
-  hasKnownCorpse,
-  isKnowledgeHostile,
-  isKnowledgeThreat,
-  isKnowledgeTrusted,
-  killCooldownSecs,
-  killCommitRange,
-  matchesAnyTarget,
-  nonTeammatesVisible,
-  PROGRESS_INTERVAL_MS,
-  reportCorpseDecision,
-  SHRIMP_VISION_RANGE,
-  SHRIMP_VISION_RELEASE_RANGE,
-  taskMoveDecision,
-} from '../game-utils.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-import { Goal } from './goal.js';
-import { KeepAwayGoal, type KeepAwayGoalOptions } from './keep-away-goal.js';
-import { KillVisibleTargetGoal } from './kill-target-goal.js';
-import { SafeTaskOrPatrolGoal } from './safe-task-goal.js';
-
-const SUB_PRIORITY = 0.5;
-const STRANGER_TRIGGER_RADIUS = SHRIMP_VISION_RANGE;
-const STRANGER_RELEASE_RADIUS = SHRIMP_VISION_RELEASE_RANGE;
-const WITNESS_MEMORY_MS = 0;
-const WITNESS_EXEMPT_COUNT = 2;
-const TASK_RETURN_INERTIA_MS = 2_000;
-const FLEE_KEY = 'warrior-flee';
-const STRANGER_KEY = 'warrior-stranger-distance';
-
-type ProgressTier = 'flee-bad' | 'keep-distance' | 'task';
-
-/**
- * 带刀虾·记忆进阶版（武士虾/枪虾，带刀好人）。好人阵营但能出刀，按行为表的优先级逐条判断：
- *
- * - P0 发现尸体：旁边有非保护对象且刀可用 → 先出刀；否则报警（靠近至可报距离）。
- * - P1 处理危险：明确猎杀目标（启动参数 / hostile）刀好就追杀；
- *   suspect 只表示可疑，始终回避，不会仅凭怀疑主动出刀；
- *   无可信同伴且单个无标记陌生人贴近 → 按普通虾 B 档先拉开距离。
- * - P2 紧急任务：无危险时优先处理。
- * - P3 兜底：做任务 / 巡逻
- *   （SafeTaskOrPatrolGoal：测地最近、威胁旁/途经威胁的任务硬排除、带粘性）。
- *
- * 谁算「认定坏人」「可信同伴」来自 ctx.knowledge（见 warrior-memory.knowledge.md），
- * 队友由游戏事实判定（nonTeammatesVisible），知识库只提供推断。
- */
-export class WarriorShrimpTop extends Goal {
-  private readonly taskGoal = new SafeTaskOrPatrolGoal(
-    // 威胁点 = 当前会触发追杀/后撤的对象，或未被目击者豁免的无标记陌生人；保护对象不算。
-    (s, c) => nonTeammatesVisible(s, c)
-      .filter(p => !this.isTrusted(p, c))
-      .filter(p => this.isThreat(p, c) || !this.witnessExempt)
-      .map(p => ({ x: p.x, y: p.y })),
-  );
-  private readonly strangerSeenAt = new Map<string, number>();
-  private witnessExempt = false;
-
-  constructor(private readonly huntTargets: string[] = []) {
-    super();
-  }
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    const visible = nonTeammatesVisible(state, ctx);
-    this.updateWitnessMemory(visible, ctx);
-    const killReady = canUseKill(state);
-
-    // ── P0 发现尸体 ──
-    // 灭口贴脸目击者只在「此刻就在命案现场」（当帧视野有尸体）时考虑——记忆里某处有尸体不算现场，
-    // 否则会变成随便撞见一个人就灭口。
-    if (corpseAtScene(state) && killReady) {
-      const victim = this.nearestKillable(state, ctx, visible);
-      if (victim) {
-        this.clearSub();
-        return [{ action: Action.kill(victim.name) }];
-      }
-    }
-    // 报尸 / 前往报尸：可以追着记忆里看见过、已离开视野的尸体走回去报告。
-    if (hasKnownCorpse(ctx)) {
-      const report = reportCorpseDecision(state, ctx, { respectBlock: true });
-      if (report) {
-        this.clearSub();
-        return [report];
-      }
-    }
-
-    // ── P1-A hostile 刀好就追；suspect 只回避 ──
-    const threats = visible.filter(p => this.isThreat(p, ctx));
-    if (threats.length > 0) {
-      const huntTargets = threats.filter(p => this.isHuntTarget(p, ctx));
-      if (killReady && huntTargets.length > 0) {
-        this.setHunt(this.nearestByDistance(state, huntTargets).name);
-        return [];
-      }
-      this.taskGoal.planTask(state, ctx, { holdUnsafeCurrentForMs: TASK_RETURN_INERTIA_MS });
-      this.setFlee();
-      this.emitProgress(state, ctx, visible, 'flee-bad');
-      return [];
-    }
-
-    // ── P1-B 无可信同伴且无标记陌生人贴近 → 按普通虾 B 档拉开距离 ──
-    const trustedVisible = visible.some(p => this.isTrusted(p, ctx));
-    if (!trustedVisible) {
-      const worker = this.subGoal;
-      const strangerClose = visible.some(p =>
-        this.isUnmarkedStranger(p, ctx)
-        && (p.distance ?? dist(p.x, p.y, state.you.x, state.you.y)) <= STRANGER_TRIGGER_RADIUS);
-      const stillBackingOff = worker instanceof KeepAwayGoal && worker.key === STRANGER_KEY && !worker.isFinish(state, ctx);
-      if (!this.witnessExempt && (strangerClose || stillBackingOff)) {
-        this.taskGoal.planTask(state, ctx, { holdUnsafeCurrentForMs: TASK_RETURN_INERTIA_MS });
-        this.setStrangerKeepAway();
-        this.emitProgress(state, ctx, visible, 'keep-distance');
-        return [];
-      }
-    }
-
-    // ── P2 紧急任务 ──
-    const emergency = firstAvailableTask([], t => t.faction !== 'crab', ctx.emergency, ctx.blockedMoveTarget);
-    if (emergency) {
-      this.clearSub();
-      return [taskMoveDecision(state, ctx, emergency)];
-    }
-
-    // ── P3 普通任务 / 巡逻 ──
-    this.clearSub();
-    this.emitProgress(state, ctx, visible, 'task');
-    return this.taskGoal.tick(state, ctx);
-  }
-
-  /** 目击者豁免：当前只按本轮可见玩家判断，见到 2 个以上陌生人时不对无标记者后撤。 */
-  private updateWitnessMemory(visible: PlayerInfo[], ctx: StrategyContext): void {
-    const now = Date.now();
-    for (const p of visible) {
-      if (!this.isUnmarkedStranger(p, ctx)) continue;
-      const key = p.name || String(p.seat ?? '');
-      if (key) this.strangerSeenAt.set(key, now);
-    }
-    for (const [key, at] of this.strangerSeenAt) {
-      if (now - at > WITNESS_MEMORY_MS) this.strangerSeenAt.delete(key);
-    }
-    this.witnessExempt = this.strangerSeenAt.size >= WITNESS_EXEMPT_COUNT;
-  }
-
-  private isUnmarkedStranger(p: PlayerInfo, ctx: StrategyContext): boolean {
-    return !this.isTrusted(p, ctx) && !this.isThreat(p, ctx);
-  }
-
-  /** 知识里 trusted 的玩家：可信同伴，永不击杀。 */
-  private isTrusted(p: PlayerInfo, ctx: StrategyContext): boolean {
-    return isKnowledgeTrusted(p, ctx);
-  }
-
-  /** 明确猎杀目标：启动参数或 hostile；suspect 不在这里。 */
-  private isHuntTarget(p: PlayerInfo, ctx: StrategyContext): boolean {
-    return !this.isTrusted(p, ctx)
-      && (matchesAnyTarget(p, this.huntTargets, ctx) || isKnowledgeHostile(p, ctx));
-  }
-
-  /** 威胁：明确猎杀目标，或知识库 suspect 标记；trusted 永远排除。 */
-  private isThreat(p: PlayerInfo, ctx: StrategyContext): boolean {
-    return !this.isTrusted(p, ctx)
-      && (this.isHuntTarget(p, ctx) || isKnowledgeThreat(p, ctx));
-  }
-
-  /** 尸体场景下「认定坏人/身份不明」= 视野内最近的非保护非队友，且在出刀范围内。 */
-  private nearestKillable(state: GameState, ctx: StrategyContext, visible: PlayerInfo[]): PlayerInfo | null {
-    return visible
-      .filter(p => !this.isTrusted(p, ctx))
-      .map(p => ({ p, d: p.distance ?? dist(state.you.x, state.you.y, p.x, p.y) }))
-      .filter(x => x.d <= killCommitRange(state.you.role))
-      .sort((a, b) => a.d - b.d)[0]?.p ?? null;
-  }
-
-  private nearestByDistance(state: GameState, players: PlayerInfo[]): PlayerInfo {
-    return players
-      .map(p => ({ p, d: p.distance ?? dist(state.you.x, state.you.y, p.x, p.y) }))
-      .sort((a, b) => a.d - b.d)[0].p;
-  }
-
-  private setHunt(targetName: string): void {
-    const worker = this.subGoal;
-    if (worker instanceof KillVisibleTargetGoal && worker.targetName === targetName) return;
-    if (this.subGoal) this.removeSubGoal();
-    this.setSubGoal(new KillVisibleTargetGoal(targetName, [], true), SUB_PRIORITY);
-  }
-
-  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).filter(p => this.isThreat(p, c)),
-      { threatRadius: Infinity, noun: '认定坏人' } satisfies KeepAwayGoalOptions,
-    ), SUB_PRIORITY);
-  }
-
-  private setStrangerKeepAway(): void {
-    const worker = this.subGoal;
-    if (worker instanceof KeepAwayGoal && worker.key === STRANGER_KEY) return;
-    if (this.subGoal) this.removeSubGoal();
-    this.setSubGoal(new KeepAwayGoal(
-      STRANGER_KEY,
-      (s, c) => nonTeammatesVisible(s, c).filter(p => this.isUnmarkedStranger(p, c)),
-      {
-        threatRadius: STRANGER_RELEASE_RADIUS,
-        noun: '陌生人',
-        planOpts: { steps: 4 },
-      } satisfies KeepAwayGoalOptions,
-    ), SUB_PRIORITY);
-  }
-
-  private clearSub(): void {
-    if (this.subGoal) this.removeSubGoal();
-  }
-
-  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 cd = killCooldownSecs(state);
-    const killsRemaining = state.you.kills_remaining;
-
-    let msg = `[进度] 当前在${room}`;
-    if (visible.length === 0) {
-      msg += '，附近无人，做任务/巡逻。';
-    } else if (tier === 'keep-distance') {
-      msg += '，无标记陌生人靠得太近，先拉开距离再做任务。';
-    } else {
-      const bad = visible.filter(p => this.isThreat(p, ctx)).map(p => p.name);
-      if (bad.length > 0) msg += `，发现认定坏人${bad.join('、')}`;
-      else if (this.witnessExempt) msg += `，附近有${visible.length}个无标记陌生人互为目击者，正常做任务`;
-      else msg += `，附近有${visible.length}人，正常做任务`;
-      if (tier === 'flee-bad') msg += killCooldownSecs(state) > 0 ? '，刀在冷却，正在回避' : '，正在处理';
-      if (cd > 0) msg += `（攻击冷却${cd}s）`;
-      if (killsRemaining === 0) msg += '（出刀次数已用完）';
-      msg += '。';
-    }
-    ctx.notifications.push(msg);
-  }
-}
+import type { GameState, PlayerInfo } from '../../sdk/types.js';
+import { Action } from '../../sdk/action.js';
+import {
+  canUseKill,
+  corpseAtScene,
+  dist,
+  firstAvailableTask,
+  hasKnownCorpse,
+  isKnowledgeHostile,
+  isKnowledgeThreat,
+  isKnowledgeTrusted,
+  killCooldownSecs,
+  killCommitRange,
+  matchesAnyTarget,
+  nonTeammatesVisible,
+  PROGRESS_INTERVAL_MS,
+  reportCorpseDecision,
+  SHRIMP_VISION_RANGE,
+  SHRIMP_VISION_RELEASE_RANGE,
+  taskMoveDecision,
+} from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+import { KeepAwayGoal, type KeepAwayGoalOptions } from './keep-away-goal.js';
+import { KillVisibleTargetGoal } from './kill-target-goal.js';
+import { SafeTaskOrPatrolGoal } from './safe-task-goal.js';
+
+const SUB_PRIORITY = 0.5;
+const STRANGER_TRIGGER_RADIUS = SHRIMP_VISION_RANGE;
+const STRANGER_RELEASE_RADIUS = SHRIMP_VISION_RELEASE_RANGE;
+const WITNESS_MEMORY_MS = 0;
+const WITNESS_EXEMPT_COUNT = 2;
+const TASK_RETURN_INERTIA_MS = 2_000;
+const FLEE_KEY = 'warrior-flee';
+const STRANGER_KEY = 'warrior-stranger-distance';
+
+type ProgressTier = 'flee-bad' | 'keep-distance' | 'task';
+
+/**
+ * 带刀虾·记忆进阶版（武士虾/枪虾，带刀好人）。好人阵营但能出刀，按行为表的优先级逐条判断：
+ *
+ * - P0 发现尸体：旁边有非保护对象且刀可用 → 先出刀；否则报警（靠近至可报距离）。
+ * - P1 处理危险：明确猎杀目标（启动参数 / hostile）刀好就追杀；
+ *   suspect 只表示可疑，始终回避，不会仅凭怀疑主动出刀；
+ *   无可信同伴且单个无标记陌生人贴近 → 按普通虾 B 档先拉开距离。
+ * - P2 紧急任务：无危险时优先处理。
+ * - P3 兜底：做任务 / 巡逻
+ *   （SafeTaskOrPatrolGoal：测地最近、威胁旁/途经威胁的任务硬排除、带粘性）。
+ *
+ * 谁算「认定坏人」「可信同伴」来自 ctx.knowledge（见 warrior-memory.knowledge.md），
+ * 队友由游戏事实判定（nonTeammatesVisible），知识库只提供推断。
+ */
+export class WarriorShrimpTop extends Goal {
+  private readonly taskGoal = new SafeTaskOrPatrolGoal(
+    // 威胁点 = 当前会触发追杀/后撤的对象，或未被目击者豁免的无标记陌生人；保护对象不算。
+    (s, c) => nonTeammatesVisible(s, c)
+      .filter(p => !this.isTrusted(p, c))
+      .filter(p => this.isThreat(p, c) || !this.witnessExempt)
+      .map(p => ({ x: p.x, y: p.y })),
+  );
+  private readonly strangerSeenAt = new Map<string, number>();
+  private witnessExempt = false;
+
+  constructor(private readonly huntTargets: string[] = []) {
+    super();
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const visible = nonTeammatesVisible(state, ctx);
+    this.updateWitnessMemory(visible, ctx);
+    const killReady = canUseKill(state);
+
+    // ── P0 发现尸体 ──
+    // 灭口贴脸目击者只在「此刻就在命案现场」（当帧视野有尸体）时考虑——记忆里某处有尸体不算现场，
+    // 否则会变成随便撞见一个人就灭口。
+    if (corpseAtScene(state) && killReady) {
+      const victim = this.nearestKillable(state, ctx, visible);
+      if (victim) {
+        this.clearSub();
+        return [{ action: Action.kill(victim.name) }];
+      }
+    }
+    // 报尸 / 前往报尸：可以追着记忆里看见过、已离开视野的尸体走回去报告。
+    if (hasKnownCorpse(ctx)) {
+      const report = reportCorpseDecision(state, ctx, { respectBlock: true });
+      if (report) {
+        this.clearSub();
+        return [report];
+      }
+    }
+
+    // ── P1-A hostile 刀好就追；suspect 只回避 ──
+    const threats = visible.filter(p => this.isThreat(p, ctx));
+    if (threats.length > 0) {
+      const huntTargets = threats.filter(p => this.isHuntTarget(p, ctx));
+      if (killReady && huntTargets.length > 0) {
+        this.setHunt(this.nearestByDistance(state, huntTargets).name);
+        return [];
+      }
+      this.taskGoal.planTask(state, ctx, { holdUnsafeCurrentForMs: TASK_RETURN_INERTIA_MS });
+      this.setFlee();
+      this.emitProgress(state, ctx, visible, 'flee-bad');
+      return [];
+    }
+
+    // ── P1-B 无可信同伴且无标记陌生人贴近 → 按普通虾 B 档拉开距离 ──
+    const trustedVisible = visible.some(p => this.isTrusted(p, ctx));
+    if (!trustedVisible) {
+      const worker = this.subGoal;
+      const strangerClose = visible.some(p =>
+        this.isUnmarkedStranger(p, ctx)
+        && (p.distance ?? dist(p.x, p.y, state.you.x, state.you.y)) <= STRANGER_TRIGGER_RADIUS);
+      const stillBackingOff = worker instanceof KeepAwayGoal && worker.key === STRANGER_KEY && !worker.isFinish(state, ctx);
+      if (!this.witnessExempt && (strangerClose || stillBackingOff)) {
+        this.taskGoal.planTask(state, ctx, { holdUnsafeCurrentForMs: TASK_RETURN_INERTIA_MS });
+        this.setStrangerKeepAway();
+        this.emitProgress(state, ctx, visible, 'keep-distance');
+        return [];
+      }
+    }
+
+    // ── P2 紧急任务 ──
+    const emergency = firstAvailableTask([], t => t.faction !== 'crab', ctx.emergency, ctx.blockedMoveTarget);
+    if (emergency) {
+      this.clearSub();
+      return [taskMoveDecision(state, ctx, emergency)];
+    }
+
+    // ── P3 普通任务 / 巡逻 ──
+    this.clearSub();
+    this.emitProgress(state, ctx, visible, 'task');
+    return this.taskGoal.tick(state, ctx);
+  }
+
+  /** 目击者豁免：当前只按本轮可见玩家判断，见到 2 个以上陌生人时不对无标记者后撤。 */
+  private updateWitnessMemory(visible: PlayerInfo[], ctx: StrategyContext): void {
+    const now = Date.now();
+    for (const p of visible) {
+      if (!this.isUnmarkedStranger(p, ctx)) continue;
+      const key = p.name || String(p.seat ?? '');
+      if (key) this.strangerSeenAt.set(key, now);
+    }
+    for (const [key, at] of this.strangerSeenAt) {
+      if (now - at > WITNESS_MEMORY_MS) this.strangerSeenAt.delete(key);
+    }
+    this.witnessExempt = this.strangerSeenAt.size >= WITNESS_EXEMPT_COUNT;
+  }
+
+  private isUnmarkedStranger(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return !this.isTrusted(p, ctx) && !this.isThreat(p, ctx);
+  }
+
+  /** 知识里 trusted 的玩家：可信同伴，永不击杀。 */
+  private isTrusted(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return isKnowledgeTrusted(p, ctx);
+  }
+
+  /** 明确猎杀目标：启动参数或 hostile；suspect 不在这里。 */
+  private isHuntTarget(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return !this.isTrusted(p, ctx)
+      && (matchesAnyTarget(p, this.huntTargets, ctx) || isKnowledgeHostile(p, ctx));
+  }
+
+  /** 威胁：明确猎杀目标，或知识库 suspect 标记；trusted 永远排除。 */
+  private isThreat(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return !this.isTrusted(p, ctx)
+      && (this.isHuntTarget(p, ctx) || isKnowledgeThreat(p, ctx));
+  }
+
+  /** 尸体场景下「认定坏人/身份不明」= 视野内最近的非保护非队友，且在出刀范围内。 */
+  private nearestKillable(state: GameState, ctx: StrategyContext, visible: PlayerInfo[]): PlayerInfo | null {
+    return visible
+      .filter(p => !this.isTrusted(p, ctx))
+      .map(p => ({ p, d: p.distance ?? dist(state.you.x, state.you.y, p.x, p.y) }))
+      .filter(x => x.d <= killCommitRange(state.you.role))
+      .sort((a, b) => a.d - b.d)[0]?.p ?? null;
+  }
+
+  private nearestByDistance(state: GameState, players: PlayerInfo[]): PlayerInfo {
+    return players
+      .map(p => ({ p, d: p.distance ?? dist(state.you.x, state.you.y, p.x, p.y) }))
+      .sort((a, b) => a.d - b.d)[0].p;
+  }
+
+  private setHunt(targetName: string): void {
+    const worker = this.subGoal;
+    if (worker instanceof KillVisibleTargetGoal && worker.targetName === targetName) return;
+    if (this.subGoal) this.removeSubGoal();
+    this.setSubGoal(new KillVisibleTargetGoal(targetName, [], true), SUB_PRIORITY);
+  }
+
+  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).filter(p => this.isThreat(p, c)),
+      { threatRadius: Infinity, noun: '认定坏人' } satisfies KeepAwayGoalOptions,
+    ), SUB_PRIORITY);
+  }
+
+  private setStrangerKeepAway(): void {
+    const worker = this.subGoal;
+    if (worker instanceof KeepAwayGoal && worker.key === STRANGER_KEY) return;
+    if (this.subGoal) this.removeSubGoal();
+    this.setSubGoal(new KeepAwayGoal(
+      STRANGER_KEY,
+      (s, c) => nonTeammatesVisible(s, c).filter(p => this.isUnmarkedStranger(p, c)),
+      {
+        threatRadius: STRANGER_RELEASE_RADIUS,
+        noun: '陌生人',
+        planOpts: { steps: 4 },
+      } satisfies KeepAwayGoalOptions,
+    ), SUB_PRIORITY);
+  }
+
+  private clearSub(): void {
+    if (this.subGoal) this.removeSubGoal();
+  }
+
+  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 cd = killCooldownSecs(state);
+    const killsRemaining = state.you.kills_remaining;
+
+    let msg = `[进度] 当前在${room}`;
+    if (visible.length === 0) {
+      msg += '，附近无人，做任务/巡逻。';
+    } else if (tier === 'keep-distance') {
+      msg += '，无标记陌生人靠得太近，先拉开距离再做任务。';
+    } else {
+      const bad = visible.filter(p => this.isThreat(p, ctx)).map(p => p.name);
+      if (bad.length > 0) msg += `，发现认定坏人${bad.join('、')}`;
+      else if (this.witnessExempt) msg += `，附近有${visible.length}个无标记陌生人互为目击者，正常做任务`;
+      else msg += `，附近有${visible.length}人，正常做任务`;
+      if (tier === 'flee-bad') msg += killCooldownSecs(state) > 0 ? '，刀在冷却，正在回避' : '，正在处理';
+      if (cd > 0) msg += `（攻击冷却${cd}s）`;
+      if (killsRemaining === 0) msg += '（出刀次数已用完）';
+      msg += '。';
+    }
+    ctx.notifications.push(msg);
+  }
+}

package/src/strategies/greeting.ts

@@ -1,53 +1,53 @@
-import { Action } from '../sdk/action.js';
-import type { GameState } from '../sdk/types.js';
-import type { BehaviorDecision } from './types.js';
-import { TTS_TEXT_MAX_LENGTH } from '../lib/tts-keys.js';
-import { stripRoleIds } from './player-targets.js';
-
-export const MAX_GREETING_PHRASES = 3;
-export const GREETING_COOLDOWN_MS = 120_000;
-
-/**
- * 解析「打招呼话术」启动参数：剥掉 role-id 噪声与空串，校验条数（≤3）与单条长度（≤TTS 上限）。
- * 供 task-report / corpse-patrol / shrimp-memory / paradise-fish 共用——它们的启动参数语义都是「打招呼话术」。
- *
- * @param strategyId 仅用于错误文案。
- */
-export function parseGreetingArgs(args: string[] | undefined, strategyId: string): string[] {
-  if (!args || args.length === 0) return [];
-
-  const phrases = args.map(a => stripRoleIds(a)).filter(a => a.length > 0);
-  if (phrases.length === 0) return [];
-
-  if (phrases.length > MAX_GREETING_PHRASES) {
-    throw new Error(`${strategyId} strategy accepts 0-${MAX_GREETING_PHRASES} greeting phrases (got ${phrases.length}).`);
-  }
-  for (const phrase of phrases) {
-    if (phrase.length > TTS_TEXT_MAX_LENGTH) {
-      throw new Error(`Greeting phrase too long (${phrase.length} chars, max ${TTS_TEXT_MAX_LENGTH}).`);
-    }
-  }
-  return phrases;
-}
-
-/**
- * 打招呼节流器：视野内有人时随机发一条话术，之后 GREETING_COOLDOWN_MS 内不再发。
- * 被多个编排型 Top Goal（TaskReportTop / NormalShrimpTop 等）持有复用。
- */
-export class GreetingTracker {
-  private lastGreetingAt: number | null = null;
-
-  constructor(private readonly phrases: string[]) {}
-
-  tryGreeting(state: GameState): BehaviorDecision | null {
-    if (this.phrases.length === 0) return null;
-    if (state.players.length === 0) return null;
-
-    const now = Date.now();
-    if (this.lastGreetingAt !== null && now - this.lastGreetingAt < GREETING_COOLDOWN_MS) return null;
-
-    const text = this.phrases[Math.floor(Math.random() * this.phrases.length)];
-    this.lastGreetingAt = now;
-    return { action: Action.speech(text) };
-  }
-}
+import { Action } from '../sdk/action.js';
+import type { GameState } from '../sdk/types.js';
+import type { BehaviorDecision } from './types.js';
+import { TTS_TEXT_MAX_LENGTH } from '../lib/tts-keys.js';
+import { stripRoleIds } from './player-targets.js';
+
+export const MAX_GREETING_PHRASES = 3;
+export const GREETING_COOLDOWN_MS = 120_000;
+
+/**
+ * 解析「打招呼话术」启动参数：剥掉 role-id 噪声与空串，校验条数（≤3）与单条长度（≤TTS 上限）。
+ * 供 task-report / corpse-patrol / shrimp-memory / paradise-fish 共用——它们的启动参数语义都是「打招呼话术」。
+ *
+ * @param strategyId 仅用于错误文案。
+ */
+export function parseGreetingArgs(args: string[] | undefined, strategyId: string): string[] {
+  if (!args || args.length === 0) return [];
+
+  const phrases = args.map(a => stripRoleIds(a)).filter(a => a.length > 0);
+  if (phrases.length === 0) return [];
+
+  if (phrases.length > MAX_GREETING_PHRASES) {
+    throw new Error(`${strategyId} strategy accepts 0-${MAX_GREETING_PHRASES} greeting phrases (got ${phrases.length}).`);
+  }
+  for (const phrase of phrases) {
+    if (phrase.length > TTS_TEXT_MAX_LENGTH) {
+      throw new Error(`Greeting phrase too long (${phrase.length} chars, max ${TTS_TEXT_MAX_LENGTH}).`);
+    }
+  }
+  return phrases;
+}
+
+/**
+ * 打招呼节流器：视野内有人时随机发一条话术，之后 GREETING_COOLDOWN_MS 内不再发。
+ * 被多个编排型 Top Goal（TaskReportTop / NormalShrimpTop 等）持有复用。
+ */
+export class GreetingTracker {
+  private lastGreetingAt: number | null = null;
+
+  constructor(private readonly phrases: string[]) {}
+
+  tryGreeting(state: GameState): BehaviorDecision | null {
+    if (this.phrases.length === 0) return null;
+    if (state.players.length === 0) return null;
+
+    const now = Date.now();
+    if (this.lastGreetingAt !== null && now - this.lastGreetingAt < GREETING_COOLDOWN_MS) return null;
+
+    const text = this.phrases[Math.floor(Math.random() * this.phrases.length)];
+    this.lastGreetingAt = now;
+    return { action: Action.speech(text) };
+  }
+}

package/src/strategies/kill-frenzy.ts

@@ -1,12 +1,12 @@
-import type { StrategyEntry } from './types.js';
-import { GoalRootStrategy } from './goals/goal-root-strategy.js';
-import { KillFrenzyTop } from './goals/kill-frenzy-top.js';
-
-export const strategy: StrategyEntry = {
-  id: 'kill-frenzy',
-  description:
-    '疯狂砍人：见谁杀谁（除队友外所有可见玩家），多人在场也照杀。按房间顺序巡逻，视野里只要有非队友就冲向最近的那个，50内且冷却好就出刀，冷却中保持10距离贴身跟随等冷却。与 kill-lone 不同，不会因为周围人多而暂停攻击。永不停手。',
-  create() {
-    return new GoalRootStrategy('kill-frenzy', () => new KillFrenzyTop(), { resetOnMeetingResume: false });
-  },
-};
+import type { StrategyEntry } from './types.js';
+import { GoalRootStrategy } from './goals/goal-root-strategy.js';
+import { KillFrenzyTop } from './goals/kill-frenzy-top.js';
+
+export const strategy: StrategyEntry = {
+  id: 'kill-frenzy',
+  description:
+    '疯狂砍人：见谁杀谁（除队友外所有可见玩家），多人在场也照杀。按房间顺序巡逻，视野里只要有非队友就冲向最近的那个，50内且冷却好就出刀，冷却中保持10距离贴身跟随等冷却。与 kill-lone 不同，不会因为周围人多而暂停攻击。永不停手。',
+  create() {
+    return new GoalRootStrategy('kill-frenzy', () => new KillFrenzyTop(), { resetOnMeetingResume: false });
+  },
+};