@myclaw163/clawclaw-cli 0.6.55 → 0.6.57

package/src/strategies/goals/leaf-goal.ts

@@ -1,25 +1,25 @@
-import type { BehaviorDecision } from '../types.js';
-import { Goal } from './goal.js';
-
-export const URGENT_GOAL_PRIORITY = 1;
-export const WANDER_GOAL_PRIORITY = 0.2;
-
-export class LeafGoal extends Goal {
-  constructor(private readonly decisions: BehaviorDecision[]) {
-    super();
-  }
-
-  tick(): BehaviorDecision[] {
-    return this.decisions;
-  }
-}
-
-export function setBehavior(parent: Goal, child: Goal, priority: number): BehaviorDecision[] {
-  if (parent.subGoal) parent.removeSubGoal();
-  parent.setSubGoal(child, priority);
-  return [];
-}
-
-export function emitLeaf(parent: Goal, decisions: BehaviorDecision[], priority: number): BehaviorDecision[] {
-  return setBehavior(parent, new LeafGoal(decisions), priority);
-}
+import type { BehaviorDecision } from '../types.js';
+import { Goal } from './goal.js';
+
+export const URGENT_GOAL_PRIORITY = 1;
+export const WANDER_GOAL_PRIORITY = 0.2;
+
+export class LeafGoal extends Goal {
+  constructor(private readonly decisions: BehaviorDecision[]) {
+    super();
+  }
+
+  tick(): BehaviorDecision[] {
+    return this.decisions;
+  }
+}
+
+export function setBehavior(parent: Goal, child: Goal, priority: number): BehaviorDecision[] {
+  if (parent.subGoal) parent.removeSubGoal();
+  parent.setSubGoal(child, priority);
+  return [];
+}
+
+export function emitLeaf(parent: Goal, decisions: BehaviorDecision[], priority: number): BehaviorDecision[] {
+  return setBehavior(parent, new LeafGoal(decisions), priority);
+}

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

@@ -1,79 +1,79 @@
-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 { 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 = '';
-
-  constructor(private readonly avoidResolver?: (state: GameState, ctx: StrategyContext) => PlayerInfo[]) {
-    super();
-  }
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    const body = nearestKnownCorpse(state, ctx);
-    if (!body) {
-      // 还没拿到尸体坐标：朝尸体所在房间靠近，人进视野后坐标自然补全，再切到下面的贴尸游走。
-      this.wanderTarget = null;
-      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)) }];
-  }
-
-  // Nav / 非 Nav 的不对称是有意的：tick 取坐标用严格的 nearestKnownCorpse（没坐标无法定点游走），
-  // 但只要还记得尸体在某房间（nearestKnownCorpseNav 非空）就不该 finish——此时应继续走向房间锚点，
-  // 等人进视野把坐标补全，否则尸体一离开视野就提前结束、再也走不回去。
-  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 };
-  }
-}
+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 { 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 = '';
+
+  constructor(private readonly avoidResolver?: (state: GameState, ctx: StrategyContext) => PlayerInfo[]) {
+    super();
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const body = nearestKnownCorpse(state, ctx);
+    if (!body) {
+      // 还没拿到尸体坐标：朝尸体所在房间靠近，人进视野后坐标自然补全，再切到下面的贴尸游走。
+      this.wanderTarget = null;
+      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)) }];
+  }
+
+  // Nav / 非 Nav 的不对称是有意的：tick 取坐标用严格的 nearestKnownCorpse（没坐标无法定点游走），
+  // 但只要还记得尸体在某房间（nearestKnownCorpseNav 非空）就不该 finish——此时应继续走向房间锚点，
+  // 等人进视野把坐标补全，否则尸体一离开视野就提前结束、再也走不回去。
+  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/lone-kill-core.ts

@@ -1,82 +1,82 @@
-import type { GameState, PlayerInfo } from '../../sdk/types.js';
-import { Action } from '../../sdk/action.js';
-import {
-  canUseKill,
-  dist,
-  KILL_RANGE,
-  LONE_IGNORE_MS,
-  nonTeammatesVisible,
-} from '../game-utils.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-
-export interface LoneKillOptions {
-  /** 紧急期调用方可无视「刚遇到人群」后的短暂停手窗口。 */
-  bypassIgnoreWindow?: boolean;
-}
-
-export type LoneKillAssessment =
-  | { kind: 'hunt'; target: PlayerInfo }
-  | { kind: 'idle' };
-
-/**
- * crab-sabotage 与 lone-kill-task 共享的落单猎杀状态机。
- * 刀在冷却（或出刀用完）时一律返回 idle，让上层下沉去做低优先级任务，而不是追/原地等刀。
- */
-export class LoneKillCore {
-  private loneIgnoreUntil = 0;
-  private suppressStop = false;
-
-  reset(): void {
-    this.loneIgnoreUntil = 0;
-    this.suppressStop = false;
-  }
-
-  /** 兜底任务/巡逻移动是否应 stop_on_player。 */
-  patrolStopOnPlayer(): boolean {
-    return !this.suppressStop;
-  }
-
-  assess(state: GameState, ctx: StrategyContext, opts: LoneKillOptions = {}): LoneKillAssessment {
-    const now = Date.now();
-    this.suppressStop = false;
-    const nonTeammates = nonTeammatesVisible(state, ctx);
-
-    if (nonTeammates.length === 0) {
-      if (state.players.length > 0) {
-        this.loneIgnoreUntil = now + LONE_IGNORE_MS;
-        this.suppressStop = true;
-      }
-      return { kind: 'idle' };
-    }
-
-    if (nonTeammates.length > 1) {
-      this.loneIgnoreUntil = now + LONE_IGNORE_MS;
-      this.suppressStop = true;
-      return { kind: 'idle' };
-    }
-
-    if (!opts.bypassIgnoreWindow && now < this.loneIgnoreUntil) {
-      this.suppressStop = true;
-      return { kind: 'idle' };
-    }
-
-    if (!canUseKill(state)) {
-      // 刀在冷却或出刀已用完：不追不等，下沉做低优先级伪装任务，冷却好再下手
-      //（贴脸反射刀 immediateLoneKillDecision 仍会在冷却结束瞬间生效，不丢顺手的杀）。
-      this.suppressStop = true;
-      return { kind: 'idle' };
-    }
-
-    return { kind: 'hunt', target: nonTeammates[0] };
-  }
-
-  pursue(state: GameState, ctx: StrategyContext, target: PlayerInfo): BehaviorDecision {
-    const d = target.distance ?? dist(state.you.x, state.you.y, target.x, target.y);
-    if (d <= KILL_RANGE && canUseKill(state)) {
-      ctx.notifications.push(`发现落单目标${target.name}，出刀！`);
-      return { action: Action.kill(target.name) };
-    }
-    if (d > KILL_RANGE) ctx.notifications.push(`发现落单目标${target.name}，正在靠近！`);
-    return { action: Action.move({ x: target.x, y: target.y }) };
-  }
-}
+import type { GameState, PlayerInfo } from '../../sdk/types.js';
+import { Action } from '../../sdk/action.js';
+import {
+  canUseKill,
+  dist,
+  killCommitRange,
+  LONE_IGNORE_MS,
+  nonTeammatesVisible,
+} from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+
+export interface LoneKillOptions {
+  /** 紧急期调用方可无视「刚遇到人群」后的短暂停手窗口。 */
+  bypassIgnoreWindow?: boolean;
+}
+
+export type LoneKillAssessment =
+  | { kind: 'hunt'; target: PlayerInfo }
+  | { kind: 'idle' };
+
+/**
+ * crab-sabotage 与 lone-kill-task 共享的落单猎杀状态机。
+ * 刀在冷却（或出刀用完）时一律返回 idle，让上层下沉去做低优先级任务，而不是追/原地等刀。
+ */
+export class LoneKillCore {
+  private loneIgnoreUntil = 0;
+  private suppressStop = false;
+
+  reset(): void {
+    this.loneIgnoreUntil = 0;
+    this.suppressStop = false;
+  }
+
+  /** 兜底任务/巡逻移动是否应 stop_on_player。 */
+  patrolStopOnPlayer(): boolean {
+    return !this.suppressStop;
+  }
+
+  assess(state: GameState, ctx: StrategyContext, opts: LoneKillOptions = {}): LoneKillAssessment {
+    const now = Date.now();
+    this.suppressStop = false;
+    const nonTeammates = nonTeammatesVisible(state, ctx);
+
+    if (nonTeammates.length === 0) {
+      if (state.players.length > 0) {
+        this.loneIgnoreUntil = now + LONE_IGNORE_MS;
+        this.suppressStop = true;
+      }
+      return { kind: 'idle' };
+    }
+
+    if (nonTeammates.length > 1) {
+      this.loneIgnoreUntil = now + LONE_IGNORE_MS;
+      this.suppressStop = true;
+      return { kind: 'idle' };
+    }
+
+    if (!opts.bypassIgnoreWindow && now < this.loneIgnoreUntil) {
+      this.suppressStop = true;
+      return { kind: 'idle' };
+    }
+
+    if (!canUseKill(state)) {
+      // 刀在冷却或出刀已用完：不追不等，下沉做低优先级伪装任务，冷却好再下手
+      //（贴脸反射刀 immediateLoneKillDecision 仍会在冷却结束瞬间生效，不丢顺手的杀）。
+      this.suppressStop = true;
+      return { kind: 'idle' };
+    }
+
+    return { kind: 'hunt', target: nonTeammates[0] };
+  }
+
+  pursue(state: GameState, ctx: StrategyContext, target: PlayerInfo): BehaviorDecision {
+    const d = target.distance ?? dist(state.you.x, state.you.y, target.x, target.y);
+    if (d <= killCommitRange(state.you.role) && canUseKill(state)) {
+      ctx.notifications.push(`发现落单目标${target.name}，出刀！`);
+      return { action: Action.kill(target.name) };
+    }
+    if (d > killCommitRange(state.you.role)) ctx.notifications.push(`发现落单目标${target.name}，正在靠近！`);
+    return { action: Action.move({ x: target.x, y: target.y }) };
+  }
+}

package/src/strategies/goals/lone-kill-goal.ts

@@ -1,24 +1,24 @@
-import type { GameState, PlayerInfo } from '../../sdk/types.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-import { Goal } from './goal.js';
-import type { LoneKillCore } from './lone-kill-core.js';
-
-/**
- * 落单猎杀子目标（叶子，由上层以 URGENT 优先级挂载）：对上层经 {@link LoneKillCore.assess} 选中、
- * 并经 setTarget() 注入的目标产出追击 / 出刀决策。判定逻辑在 core/上层，本叶子只负责产出动作。
- */
-export class LoneKillGoal extends Goal {
-  private target: PlayerInfo | null = null;
-
-  constructor(private readonly core: LoneKillCore) {
-    super();
-  }
-
-  setTarget(target: PlayerInfo): void {
-    this.target = target;
-  }
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    return this.target ? [this.core.pursue(state, ctx, this.target)] : [];
-  }
-}
+import type { GameState, PlayerInfo } from '../../sdk/types.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+import type { LoneKillCore } from './lone-kill-core.js';
+
+/**
+ * 落单猎杀子目标（叶子，由上层以 URGENT 优先级挂载）：对上层经 {@link LoneKillCore.assess} 选中、
+ * 并经 setTarget() 注入的目标产出追击 / 出刀决策。判定逻辑在 core/上层，本叶子只负责产出动作。
+ */
+export class LoneKillGoal extends Goal {
+  private target: PlayerInfo | null = null;
+
+  constructor(private readonly core: LoneKillCore) {
+    super();
+  }
+
+  setTarget(target: PlayerInfo): void {
+    this.target = target;
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    return this.target ? [this.core.pursue(state, ctx, this.target)] : [];
+  }
+}

package/src/strategies/goals/lone-kill-task-top.test.ts

@@ -1,85 +1,85 @@
-import { describe, expect, it } from 'vitest';
-import type { GameState, TaskInfo } from '../../sdk/types.js';
-import type { StrategyContext } from '../types.js';
-import { LoneKillTaskTop } from './lone-kill-task-top.js';
-
-function state(overrides: Partial<GameState> = {}): GameState {
-  return {
-    phase: 'wandering',
-    tick: 1,
-    you: {
-      name: 'octopus',
-      x: 0,
-      y: 0,
-      room: 'control',
-      role: 'neutral_octopus',
-      faction: 'neutral',
-      is_alive: true,
-      kill_cooldown_secs: 10,
-    },
-    your_tasks: [],
-    players: [],
-    corpses: [],
-    stale: false,
-    ...overrides,
-  };
-}
-
-function task(task_name: string, x: number, y: number): TaskInfo {
-  return {
-    task_id: task_name,
-    task_name,
-    room: 'control',
-    status: 'normal',
-    x,
-    y,
-    is_fake_shrimp: true,
-  };
-}
-
-function context(overrides: Partial<StrategyContext> = {}): StrategyContext {
-  return {
-    taskData: [],
-    emergency: null,
-    taskLocalBlockedUntil: 0,
-    reportCorpseTarget: null,
-    reportBlockedUntil: 0,
-    notifications: [],
-    lastProgressNotifyAt: Date.now(),
-    teammates: new Set(),
-    alarmDone: false,
-    rooms: [{ name: 'patrol', x: 500, y: 0 }],
-    playerNamesBySeat: {},
-    forcePatrolAdvance: false,
-    blockedMoveTarget: null,
-    mySeat: 1,
-    speechNotifications: [],
-    agentAlerts: [],
-    ...overrides,
-  };
-}
-
-describe('LoneKillTaskTop', () => {
-  it('does not try to repair emergency tasks as octopus', () => {
-    const top = new LoneKillTaskTop();
-    const ctx = context({
-      taskData: [task('fake-clean', 100, 0)],
-      emergency: {
-        task_id: 'repair',
-        task_name: 'repair',
-        room: 'control',
-        status: 'emergency',
-        x: 0,
-        y: 0,
-        remaining_secs: 60,
-      },
-    });
-
-    top.tick(state(), ctx);
-    const decisions = top.subGoal?.tick(state(), ctx) ?? [];
-
-    expect(decisions).toHaveLength(1);
-    expect(decisions[0].action.type).toBe('move');
-    expect(decisions[0].action.payload).toMatchObject({ target_x: 100, target_y: 0 });
-  });
-});
+import { describe, expect, it } from 'vitest';
+import type { GameState, TaskInfo } from '../../sdk/types.js';
+import type { StrategyContext } from '../types.js';
+import { LoneKillTaskTop } from './lone-kill-task-top.js';
+
+function state(overrides: Partial<GameState> = {}): GameState {
+  return {
+    phase: 'wandering',
+    tick: 1,
+    you: {
+      name: 'octopus',
+      x: 0,
+      y: 0,
+      room: 'control',
+      role: 'neutral_octopus',
+      faction: 'neutral',
+      is_alive: true,
+      kill_cooldown_secs: 10,
+    },
+    your_tasks: [],
+    players: [],
+    corpses: [],
+    stale: false,
+    ...overrides,
+  };
+}
+
+function task(task_name: string, x: number, y: number): TaskInfo {
+  return {
+    task_id: task_name,
+    task_name,
+    room: 'control',
+    status: 'normal',
+    x,
+    y,
+    is_fake_shrimp: true,
+  };
+}
+
+function context(overrides: Partial<StrategyContext> = {}): StrategyContext {
+  return {
+    taskData: [],
+    emergency: null,
+    taskLocalBlockedUntil: 0,
+    reportCorpseTarget: null,
+    reportBlockedUntil: 0,
+    notifications: [],
+    lastProgressNotifyAt: Date.now(),
+    teammates: new Set(),
+    alarmDone: false,
+    rooms: [{ name: 'patrol', x: 500, y: 0 }],
+    playerNamesBySeat: {},
+    forcePatrolAdvance: false,
+    blockedMoveTarget: null,
+    mySeat: 1,
+    speechNotifications: [],
+    agentAlerts: [],
+    ...overrides,
+  };
+}
+
+describe('LoneKillTaskTop', () => {
+  it('does not try to repair emergency tasks as octopus', () => {
+    const top = new LoneKillTaskTop();
+    const ctx = context({
+      taskData: [task('fake-clean', 100, 0)],
+      emergency: {
+        task_id: 'repair',
+        task_name: 'repair',
+        room: 'control',
+        status: 'emergency',
+        x: 0,
+        y: 0,
+        remaining_secs: 60,
+      },
+    });
+
+    top.tick(state(), ctx);
+    const decisions = top.subGoal?.tick(state(), ctx) ?? [];
+
+    expect(decisions).toHaveLength(1);
+    expect(decisions[0].action.type).toBe('move');
+    expect(decisions[0].action.payload).toMatchObject({ target_x: 100, target_y: 0 });
+  });
+});