@myclaw163/clawclaw-cli 0.6.76 → 0.6.77

package/src/strategies/goals/task-only-top.ts

@@ -1,57 +1,57 @@
-import type { GameState } from '../../sdk/types.js';
-import { firstAvailableTask, PROGRESS_INTERVAL_MS, taskMoveDecision } from '../game-utils.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-import { Goal } from './goal.js';
-
-export class TaskOnlyTop extends Goal {
-  private lastEmergencyNotified = false;
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    if (state.emergency && !this.lastEmergencyNotified) {
-      this.lastEmergencyNotified = true;
-      ctx.notifications.push(`紧急任务出现！优先处理。`);
-    } else if (!state.emergency) {
-      this.lastEmergencyNotified = false;
-    }
-
-    const task = firstAvailableTask(ctx.taskData, () => true, ctx.emergency, ctx.blockedMoveTarget);
-    if (!task) {
-      this.emitProgress(state, ctx);
-      return [];
-    }
-
-    if (state.you.doing_task && task !== ctx.emergency) {
-      this.emitProgress(state, ctx);
-      return [];
-    }
-
-    const decisions = [taskMoveDecision(state, ctx, task)];
-    this.emitProgress(state, ctx);
-    return decisions;
-  }
-
-  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 completed = ctx.taskData.filter(t => t.status === 'completed').length;
-    const total = ctx.taskData.length;
-    const current = firstAvailableTask(ctx.taskData, () => true, ctx.emergency);
-
-    let msg = `[进度] 当前在${room}`;
-    if (current) {
-      msg += `，正在前往${current.room}做任务「${current.task_name}」`;
-    } else {
-      msg += `，没有可用任务`;
-    }
-    msg += `。已完成 ${completed}/${total} 个任务。`;
-
-    if (state.emergency) {
-      msg += ` 紧急任务进行中！`;
-    }
-
-    ctx.notifications.push(msg);
-  }
-}
+import type { GameState } from '../../sdk/types.js';
+import { firstAvailableTask, PROGRESS_INTERVAL_MS, taskMoveDecision } from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+
+export class TaskOnlyTop extends Goal {
+  private lastEmergencyNotified = false;
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    if (state.emergency && !this.lastEmergencyNotified) {
+      this.lastEmergencyNotified = true;
+      ctx.notifications.push(`紧急任务出现！优先处理。`);
+    } else if (!state.emergency) {
+      this.lastEmergencyNotified = false;
+    }
+
+    const task = firstAvailableTask(ctx.taskData, () => true, ctx.emergency, ctx.blockedMoveTarget);
+    if (!task) {
+      this.emitProgress(state, ctx);
+      return [];
+    }
+
+    if (state.you.doing_task && task !== ctx.emergency) {
+      this.emitProgress(state, ctx);
+      return [];
+    }
+
+    const decisions = [taskMoveDecision(state, ctx, task)];
+    this.emitProgress(state, ctx);
+    return decisions;
+  }
+
+  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 completed = ctx.taskData.filter(t => t.status === 'completed').length;
+    const total = ctx.taskData.length;
+    const current = firstAvailableTask(ctx.taskData, () => true, ctx.emergency);
+
+    let msg = `[进度] 当前在${room}`;
+    if (current) {
+      msg += `，正在前往${current.room}做任务「${current.task_name}」`;
+    } else {
+      msg += `，没有可用任务`;
+    }
+    msg += `。已完成 ${completed}/${total} 个任务。`;
+
+    if (state.emergency) {
+      msg += ` 紧急任务进行中！`;
+    }
+
+    ctx.notifications.push(msg);
+  }
+}

package/src/strategies/goals/task-or-patrol-goal.ts

@@ -1,41 +1,41 @@
-import type { GameState, TaskInfo } from '../../sdk/types.js';
-import { Action } from '../../sdk/action.js';
-import { dist, firstAvailableTask, PATROL_REACHED_DISTANCE, PatrolState, taskMoveDecision } from '../game-utils.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-import { Goal } from './goal.js';
-
-export type TaskPredicate = (task: TaskInfo) => boolean;
-const NON_CRAB: TaskPredicate = t => t.faction !== 'crab';
-
-/**
- * 好人虾的默认劳作循环：有可做任务（含紧急任务，由 firstAvailableTask 自动优先）就去做，
- * 没任务就按房间顺序巡逻。抽自 task-report.tryTask，供 task-report / 武士虾共用
- * （进阶普通虾用其安全选任务变体 SafeTaskOrPatrolGoal）。
- *
- * 直接产出 move/doTask 决策、不挂子目标，因此既能作为子目标接入 GoalManager，
- * 也能被编排型 Goal 持有并直接 tick（见 WarriorShrimpTop）。
- * 自身不发进度通知，进度由调用方按场景统一播报。
- */
-export class TaskOrPatrolGoal extends Goal {
-  private readonly patrol = new PatrolState();
-
-  constructor(private readonly predicate: TaskPredicate = NON_CRAB) {
-    super();
-  }
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    if (state.you.doing_task) return [];
-
-    const task = firstAvailableTask(ctx.taskData, this.predicate, ctx.emergency, ctx.blockedMoveTarget);
-    if (task) return [taskMoveDecision(state, ctx, task)];
-
-    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 }) }];
-  }
-}
+import type { GameState, TaskInfo } from '../../sdk/types.js';
+import { Action } from '../../sdk/action.js';
+import { dist, firstAvailableTask, PATROL_REACHED_DISTANCE, PatrolState, taskMoveDecision } from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+
+export type TaskPredicate = (task: TaskInfo) => boolean;
+const NON_CRAB: TaskPredicate = t => t.faction !== 'crab';
+
+/**
+ * 好人虾的默认劳作循环：有可做任务（含紧急任务，由 firstAvailableTask 自动优先）就去做，
+ * 没任务就按房间顺序巡逻。抽自 task-report.tryTask，供 task-report / 武士虾共用
+ * （进阶普通虾用其安全选任务变体 SafeTaskOrPatrolGoal）。
+ *
+ * 直接产出 move/doTask 决策、不挂子目标，因此既能作为子目标接入 GoalManager，
+ * 也能被编排型 Goal 持有并直接 tick（见 WarriorShrimpTop）。
+ * 自身不发进度通知，进度由调用方按场景统一播报。
+ */
+export class TaskOrPatrolGoal extends Goal {
+  private readonly patrol = new PatrolState();
+
+  constructor(private readonly predicate: TaskPredicate = NON_CRAB) {
+    super();
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    if (state.you.doing_task) return [];
+
+    const task = firstAvailableTask(ctx.taskData, this.predicate, ctx.emergency, ctx.blockedMoveTarget);
+    if (task) return [taskMoveDecision(state, ctx, task)];
+
+    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 }) }];
+  }
+}

package/src/strategies/goals/task-report-top.ts

@@ -1,57 +1,57 @@
-import type { GameState } from '../../sdk/types.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-import { firstAvailableTask, reportCorpseDecision, PROGRESS_INTERVAL_MS } from '../game-utils.js';
-import { GreetingTracker } from '../greeting.js';
-import { Goal } from './goal.js';
-import { TaskOrPatrolGoal } from './task-or-patrol-goal.js';
-
-export class TaskReportTop extends Goal {
-  private readonly taskGoal = new TaskOrPatrolGoal();
-  private readonly greeting: GreetingTracker;
-
-  constructor(greetingPhrases: string[]) {
-    super();
-    this.greeting = new GreetingTracker(greetingPhrases);
-  }
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    const decisions: BehaviorDecision[] = [];
-
-    const greetingDecision = this.greeting.tryGreeting(state);
-    if (greetingDecision) decisions.push(greetingDecision);
-
-    const reportDecision = reportCorpseDecision(state, ctx, { respectBlock: true });
-    if (reportDecision) {
-      decisions.unshift(reportDecision);
-      return decisions;
-    }
-
-    decisions.push(...this.taskGoal.tick(state, ctx));
-
-    this.emitProgress(state, ctx);
-    return decisions;
-  }
-
-  private emitProgress(state: GameState, ctx: StrategyContext): void {
-    const now = Date.now();
-    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
-    ctx.lastProgressNotifyAt = now;
-
-    const completed = ctx.taskData.filter(t => t.status === 'completed').length;
-    const total = ctx.taskData.filter(t => t.faction !== 'crab').length;
-    const current = firstAvailableTask(ctx.taskData, t => t.faction !== 'crab', ctx.emergency, ctx.blockedMoveTarget);
-    const room = state.you.room ?? '未知';
-
-    let msg = `[进度] 当前在${room}`;
-    if (current) {
-      msg += `，正在前往${current.room}做任务「${current.task_name}」`;
-    }
-    msg += `。已完成 ${completed}/${total} 个任务。`;
-
-    if (state.emergency) {
-      msg += ` 紧急任务进行中！`;
-    }
-
-    ctx.notifications.push(msg);
-  }
-}
+import type { GameState } from '../../sdk/types.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { firstAvailableTask, reportCorpseDecision, PROGRESS_INTERVAL_MS } from '../game-utils.js';
+import { GreetingTracker } from '../greeting.js';
+import { Goal } from './goal.js';
+import { TaskOrPatrolGoal } from './task-or-patrol-goal.js';
+
+export class TaskReportTop extends Goal {
+  private readonly taskGoal = new TaskOrPatrolGoal();
+  private readonly greeting: GreetingTracker;
+
+  constructor(greetingPhrases: string[]) {
+    super();
+    this.greeting = new GreetingTracker(greetingPhrases);
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const decisions: BehaviorDecision[] = [];
+
+    const greetingDecision = this.greeting.tryGreeting(state);
+    if (greetingDecision) decisions.push(greetingDecision);
+
+    const reportDecision = reportCorpseDecision(state, ctx, { respectBlock: true });
+    if (reportDecision) {
+      decisions.unshift(reportDecision);
+      return decisions;
+    }
+
+    decisions.push(...this.taskGoal.tick(state, ctx));
+
+    this.emitProgress(state, ctx);
+    return decisions;
+  }
+
+  private emitProgress(state: GameState, ctx: StrategyContext): void {
+    const now = Date.now();
+    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
+    ctx.lastProgressNotifyAt = now;
+
+    const completed = ctx.taskData.filter(t => t.status === 'completed').length;
+    const total = ctx.taskData.filter(t => t.faction !== 'crab').length;
+    const current = firstAvailableTask(ctx.taskData, t => t.faction !== 'crab', ctx.emergency, ctx.blockedMoveTarget);
+    const room = state.you.room ?? '未知';
+
+    let msg = `[进度] 当前在${room}`;
+    if (current) {
+      msg += `，正在前往${current.room}做任务「${current.task_name}」`;
+    }
+    msg += `。已完成 ${completed}/${total} 个任务。`;
+
+    if (state.emergency) {
+      msg += ` 紧急任务进行中！`;
+    }
+
+    ctx.notifications.push(msg);
+  }
+}

package/src/strategies/goals/wander-task-goal.ts

@@ -1,33 +1,33 @@
-import type { GameState, TaskInfo } from '../../sdk/types.js';
-import { approachOrDoTaskStep, patrolStep, PatrolState } from '../game-utils.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-import { Goal } from './goal.js';
-
-export type TaskPicker = (state: GameState, ctx: StrategyContext) => TaskInfo | null;
-
-/**
- * 任务伪装 + 巡逻子目标（叶子，由上层以 WANDER 优先级挂载）：先按 pickTask 取一个任务靠近 / 提交，
- * 没有可做任务、或到点暂不可提交，就按房间巡逻，绝不停在原地。供 lone-kill-task / crab-sabotage 复用，
- * pickTask 决定做哪类任务，stopOnPlayer 通常接 LoneKillCore.patrolStopOnPlayer()，patrol 由上层注入以共享巡逻进度。
- */
-export class WanderTaskGoal extends Goal {
-  constructor(
-    private readonly pickTask: TaskPicker,
-    private readonly stopOnPlayer: () => boolean,
-    private readonly patrol: PatrolState,
-  ) {
-    super();
-  }
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    if (state.you.doing_task) return [];
-
-    const task = this.pickTask(state, ctx);
-    if (task) {
-      const decision = approachOrDoTaskStep(state, ctx, task, this.stopOnPlayer());
-      if (decision) return decision;
-      // 到点却暂时无法提交 → 转巡逻，避免卡在任务点
-    }
-    return patrolStep(state, ctx, this.patrol, this.stopOnPlayer());
-  }
-}
+import type { GameState, TaskInfo } from '../../sdk/types.js';
+import { approachOrDoTaskStep, patrolStep, PatrolState } from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+
+export type TaskPicker = (state: GameState, ctx: StrategyContext) => TaskInfo | null;
+
+/**
+ * 任务伪装 + 巡逻子目标（叶子，由上层以 WANDER 优先级挂载）：先按 pickTask 取一个任务靠近 / 提交，
+ * 没有可做任务、或到点暂不可提交，就按房间巡逻，绝不停在原地。供 lone-kill-task / crab-sabotage 复用，
+ * pickTask 决定做哪类任务，stopOnPlayer 通常接 LoneKillCore.patrolStopOnPlayer()，patrol 由上层注入以共享巡逻进度。
+ */
+export class WanderTaskGoal extends Goal {
+  constructor(
+    private readonly pickTask: TaskPicker,
+    private readonly stopOnPlayer: () => boolean,
+    private readonly patrol: PatrolState,
+  ) {
+    super();
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    if (state.you.doing_task) return [];
+
+    const task = this.pickTask(state, ctx);
+    if (task) {
+      const decision = approachOrDoTaskStep(state, ctx, task, this.stopOnPlayer());
+      if (decision) return decision;
+      // 到点却暂时无法提交 → 转巡逻，避免卡在任务点
+    }
+    return patrolStep(state, ctx, this.patrol, this.stopOnPlayer());
+  }
+}

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

@@ -1,87 +1,87 @@
-import { describe, expect, it } from 'vitest';
-import { buildKnowledgeView, type KnowledgeFile } from '../../lib/knowledge-store.js';
-import type { GameState } from '../../sdk/types.js';
-import type { StrategyContext } from '../types.js';
-import { KeepAwayGoal } from './keep-away-goal.js';
-import { KillVisibleTargetGoal } from './kill-target-goal.js';
-import { WarriorShrimpTop } from './warrior-shrimp-top.js';
-
-function state(): GameState {
-  return {
-    phase: 'wandering',
-    tick: 1,
-    you: {
-      name: 'warrior',
-      x: 0,
-      y: 0,
-      room: 'control',
-      role: 'shrimp_warrior',
-      faction: 'lobster',
-      is_alive: true,
-      kill_cooldown_secs: 0,
-      kills_remaining: 1,
-    },
-    your_tasks: [],
-    players: [{ name: 'target', seat: 2, x: 100, y: 0, room: 'control', distance: 100 }],
-    all_players: [{ name: 'target', seat: 2, role: 'unknown', is_alive: true }],
-    corpses: [],
-    stale: false,
-  };
-}
-
-function knowledge(mark: 'hostile' | 'trusted') {
-  const ts = Date.now();
-  const file: KnowledgeFile = {
-    version: 1,
-    gameId: 'game-1',
-    subjects: {
-      'player:target': {
-        type: 'player',
-        selector: 'target',
-        tags: { [mark]: { ts } },
-      },
-    },
-  };
-  return buildKnowledgeView(file);
-}
-
-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: { '2': 'target' },
-    forcePatrolAdvance: false,
-    blockedMoveTarget: null,
-    mySeat: 1,
-    speechNotifications: [],
-    agentAlerts: [],
-    ...overrides,
-  };
-}
-
-describe('WarriorShrimpTop knowledge tiers', () => {
-  it('keeps distance from an unmarked (suspected-by-default) player even when the weapon is ready', () => {
-    const top = new WarriorShrimpTop();
-
-    // 不打任何标记：未标记 = 默认被怀疑 → 只保持距离，刀好也不主动出刀。
-    top.tick(state(), context());
-
-    expect(top.subGoal).toBeInstanceOf(KeepAwayGoal);
-  });
-
-  it('hunts hostile targets', () => {
-    const top = new WarriorShrimpTop();
-
-    top.tick(state(), context({ knowledge: knowledge('hostile') }));
-
-    expect(top.subGoal).toBeInstanceOf(KillVisibleTargetGoal);
-  });
-});
+import { describe, expect, it } from 'vitest';
+import { buildKnowledgeView, type KnowledgeFile } from '../../lib/knowledge-store.js';
+import type { GameState } from '../../sdk/types.js';
+import type { StrategyContext } from '../types.js';
+import { KeepAwayGoal } from './keep-away-goal.js';
+import { KillVisibleTargetGoal } from './kill-target-goal.js';
+import { WarriorShrimpTop } from './warrior-shrimp-top.js';
+
+function state(): GameState {
+  return {
+    phase: 'wandering',
+    tick: 1,
+    you: {
+      name: 'warrior',
+      x: 0,
+      y: 0,
+      room: 'control',
+      role: 'shrimp_warrior',
+      faction: 'lobster',
+      is_alive: true,
+      kill_cooldown_secs: 0,
+      kills_remaining: 1,
+    },
+    your_tasks: [],
+    players: [{ name: 'target', seat: 2, x: 100, y: 0, room: 'control', distance: 100 }],
+    all_players: [{ name: 'target', seat: 2, role: 'unknown', is_alive: true }],
+    corpses: [],
+    stale: false,
+  };
+}
+
+function knowledge(mark: 'hostile' | 'trusted') {
+  const ts = Date.now();
+  const file: KnowledgeFile = {
+    version: 1,
+    gameId: 'game-1',
+    subjects: {
+      'player:target': {
+        type: 'player',
+        selector: 'target',
+        tags: { [mark]: { ts } },
+      },
+    },
+  };
+  return buildKnowledgeView(file);
+}
+
+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: { '2': 'target' },
+    forcePatrolAdvance: false,
+    blockedMoveTarget: null,
+    mySeat: 1,
+    speechNotifications: [],
+    agentAlerts: [],
+    ...overrides,
+  };
+}
+
+describe('WarriorShrimpTop knowledge tiers', () => {
+  it('keeps distance from an unmarked (suspected-by-default) player even when the weapon is ready', () => {
+    const top = new WarriorShrimpTop();
+
+    // 不打任何标记：未标记 = 默认被怀疑 → 只保持距离，刀好也不主动出刀。
+    top.tick(state(), context());
+
+    expect(top.subGoal).toBeInstanceOf(KeepAwayGoal);
+  });
+
+  it('hunts hostile targets', () => {
+    const top = new WarriorShrimpTop();
+
+    top.tick(state(), context({ knowledge: knowledge('hostile') }));
+
+    expect(top.subGoal).toBeInstanceOf(KillVisibleTargetGoal);
+  });
+});