@myclaw163/clawclaw-cli 0.6.54

package/src/strategies/goals/crab-sabotage-top.ts

@@ -0,0 +1,197 @@
+import type { GameState, TaskInfo } from '../../sdk/types.js';
+import { Action } from '../../sdk/action.js';
+import {
+  approachOrDoTaskStep,
+  firstAvailableTask,
+  killCooldownSecs,
+  nonTeammatesVisible,
+  PatrolState,
+  PROGRESS_INTERVAL_MS,
+} from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+import { LoneKillCore } from './lone-kill-core.js';
+import { LoneKillGoal } from './lone-kill-goal.js';
+import { WanderTaskGoal } from './wander-task-goal.js';
+import { EmergencyHuntGoal } from './emergency-hunt-goal.js';
+import { emitLeaf, setBehavior, URGENT_GOAL_PRIORITY, WANDER_GOAL_PRIORITY } from './leaf-goal.js';
+import { corpseReportWithNonTeammate, immediateLoneKillDecision } from './crab-octopus-reflexes.js';
+
+const SABOTAGE_ALARM_DEDUPE_MS = 90_000;
+
+/**
+ * 蟹的「破坏 + 落单猎杀 + 任务伪装」编排 top。本身不产决策，每 tick 自上而下判定该走哪条分支、
+ * 把对应**叶子子目标**挂为唯一子目标（产出动作的是叶子；URGENT/WANDER 优先级供 ConversationGoal 判断）：
+ *
+ * 0a. 反射·立刻出刀（crab-octopus-reflexes，URGENT）：落单非队友贴脸(≤KILL_RANGE)且刀好 → 立刻出刀，
+ *     无视暂停窗口、不管自己是否正在做破坏任务。
+ * 0b. 反射·报尸（crab-octopus-reflexes，URGENT）：有尸体且附近有非队友 → 报警/靠近报警，不管尸体是谁造成的。
+ * 1a. 破坏完成 → 触发紧急警报（一次性动作，LeafGoal 承载，URGENT）。
+ * 1b. 去做真实破坏任务（到点遇阻返回 null → 回退去猎杀，故 LeafGoal 承载，WANDER）；破坏点紧挨已知尸体时跳过。
+ * 1c. 正在做任务（doing_task）→ 本 tick 不产决策，不撇下任务去猎杀（0a 的贴脸反射刀仍生效）。
+ * 2.  落单猎杀（LoneKillGoal，URGENT）：assess 判 hunt（刀好且有落单目标）→ 叶子 pursue；
+ *     刀在冷却时 assess 返回 idle，不追不等，直接下沉到破坏/任务/巡逻。
+ * 3.  紧急期搜猎（EmergencyHuntGoal，URGENT）：往人少处找真正落单的，永远有动作（不在人前乱杀）。
+ * 4.  任务伪装 / 巡逻（WanderTaskGoal，WANDER）：先真实任务再虾的伪装任务，跳过紧挨已知尸体的任务，没任务就巡逻。
+ */
+export class CrabSabotageTop extends Goal {
+  private readonly killCore = new LoneKillCore();
+  private readonly patrol = new PatrolState();
+  private readonly triggeredSabotageTasks = new Map<string, { at: number; tick: number | null }>();
+  private readonly loneKillGoal = new LoneKillGoal(this.killCore);
+  private readonly emergencyHuntGoal = new EmergencyHuntGoal(this.killCore, this.patrol);
+  private readonly wanderGoal = new WanderTaskGoal(
+    (state, ctx) =>
+      firstAvailableTask(ctx.taskData, t => this.isWorkableTask(t) && !t.is_fake_shrimp, undefined, ctx.blockedMoveTarget, ctx.knownCorpses)
+      ?? firstAvailableTask(ctx.taskData, t => this.isWorkableTask(t) && !!t.is_fake_shrimp, undefined, ctx.blockedMoveTarget, ctx.knownCorpses),
+    () => this.killCore.patrolStopOnPlayer(),
+    this.patrol,
+  );
+
+  onMeetingResume(): void {
+    this.killCore.reset();
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    this.emitProgress(state, ctx);
+
+    const immediateKill = immediateLoneKillDecision(state, ctx);
+    if (immediateKill) return emitLeaf(this, immediateKill, URGENT_GOAL_PRIORITY);
+
+    const corpseReport = corpseReportWithNonTeammate(state, ctx);
+    if (corpseReport) return emitLeaf(this, corpseReport, URGENT_GOAL_PRIORITY);
+
+    // 1a. 破坏完成 → 触发紧急警报（紧急一次性动作）
+    const alarm = this.trySabotageAlarm(state, ctx);
+    if (alarm) return emitLeaf(this, alarm, URGENT_GOAL_PRIORITY);
+
+    // 1b. 去做真实破坏任务（游走类工作；到点遇阻返回 null → 下沉去猎杀，故可回退）
+    const crabTask = this.tryCrabTask(state, ctx);
+    if (crabTask) return emitLeaf(this, crabTask, WANDER_GOAL_PRIORITY);
+
+    if (state.you.doing_task) {
+      if (this.subGoal) this.removeSubGoal();
+      return [];
+    }
+
+    // 2. 落单猎杀（紧急；紧急期 bypass 暂停窗口持续盯防）
+    const target = this.killCore.assess(state, ctx, { bypassIgnoreWindow: !!ctx.emergency });
+    if (target.kind === 'hunt') {
+      this.loneKillGoal.setTarget(target.target);
+      return setBehavior(this, this.loneKillGoal, URGENT_GOAL_PRIORITY);
+    }
+
+    // 3. 紧急期搜猎（紧急）：虾群涌向维修点，蟹不做任务，往人少处找真正落单的（警报期照样会被举报，不在人前乱杀）
+    if (ctx.emergency) return setBehavior(this, this.emergencyHuntGoal, URGENT_GOAL_PRIORITY);
+
+    // 4. 任务伪装 / 巡逻（游走）
+    return setBehavior(this, this.wanderGoal, WANDER_GOAL_PRIORITY);
+  }
+
+  // ── 1a. 破坏完成 → 触发紧急警报 ──
+  private trySabotageAlarm(state: GameState, ctx: StrategyContext): BehaviorDecision[] | null {
+    if (state.you.faction !== 'crab') return null;
+    if (ctx.emergency) return null;
+
+    const now = Date.now();
+    const completed = ctx.taskData.find(t =>
+      t.faction === 'crab'
+      && !t.is_fake_shrimp
+      && t.status === 'completed'
+      && this.shouldTriggerSabotageAlarm(t, state, now),
+    );
+    if (completed && !state.you.doing_task) {
+      this.markSabotageTriggered(completed, state, now);
+      ctx.alarmDone = true;
+      ctx.notifications.push('破坏任务完成，开启紧急警报！警报期照样会被举报，只清落单目标。');
+      return [{ action: Action.triggerAlarm() }];
+    }
+    return null;
+  }
+
+  // ── 1b. 去做真实破坏任务（破坏点紧挨已知尸体时跳过；到点遇阻返回 null，让上层回退去猎杀）──
+  private tryCrabTask(state: GameState, ctx: StrategyContext): BehaviorDecision[] | null {
+    if (state.you.faction !== 'crab') return null;
+    if (ctx.emergency) return null;
+    if (state.you.doing_task) return null;
+
+    const task = firstAvailableTask(
+      ctx.taskData,
+      t => t.faction === 'crab' && !t.is_fake_shrimp,
+      undefined,
+      ctx.blockedMoveTarget,
+      ctx.knownCorpses,
+    );
+    if (task) return approachOrDoTaskStep(state, ctx, task, false);
+    return null;
+  }
+
+  private isWorkableTask(task: TaskInfo): boolean {
+    return task.status !== 'emergency';
+  }
+
+  // ── 破坏警报去重（自旧实现原样保留）──
+
+  private sabotageTaskKey(task: TaskInfo): string {
+    const x = task.x == null ? '' : Math.round(task.x);
+    const y = task.y == null ? '' : Math.round(task.y);
+    return `${task.task_id || task.task_name}:${x}:${y}`;
+  }
+
+  private shouldTriggerSabotageAlarm(task: TaskInfo, state: GameState, now: number): boolean {
+    const record = this.triggeredSabotageTasks.get(this.sabotageTaskKey(task));
+    if (!record) return true;
+    if (now - record.at < SABOTAGE_ALARM_DEDUPE_MS) return false;
+    return this.hasFreshSabotageEvent(task, state, record.tick);
+  }
+
+  private markSabotageTriggered(task: TaskInfo, state: GameState, now: number): void {
+    this.triggeredSabotageTasks.set(this.sabotageTaskKey(task), {
+      at: now,
+      tick: this.numericTick(state.tick),
+    });
+  }
+
+  private hasFreshSabotageEvent(task: TaskInfo, state: GameState, lastTriggeredTick: number | null): boolean {
+    const taskNames = new Set([task.task_id, task.task_name].filter(Boolean));
+    return (state.new_events ?? []).some(evt => {
+      if (evt?.type !== 'task_sabotaged') return false;
+      const eventTick = this.numericTick(evt.tick);
+      if (lastTriggeredTick != null && eventTick != null && eventTick <= lastTriggeredTick) return false;
+      const eventTaskName = typeof evt.task_name === 'string' ? evt.task_name : '';
+      return taskNames.has(eventTaskName);
+    });
+  }
+
+  private numericTick(value: unknown): number | null {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+  }
+
+  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 nonTeammates = nonTeammatesVisible(state, ctx);
+
+    let msg = `[进度] 当前在${room}`;
+    if (nonTeammates.length === 0) {
+      msg += '，视野内没有落单目标，继续巡逻做任务。';
+    } else if (nonTeammates.length === 1) {
+      msg += `，视野内发现落单目标${nonTeammates[0].name}。`;
+      if (cd > 0) msg += `攻击冷却中(${cd}s)，先做任务、冷却好再下手。`;
+      if (killsRemaining === 0) msg += '出刀次数已用完，继续巡逻做任务。';
+    } else {
+      msg += `，视野内有${nonTeammates.length}人，不适合动手。`;
+    }
+
+    if (state.emergency) {
+      msg += ' 紧急警报进行中，往人少处找真正落单的目标，别在人前动手。';
+    }
+
+    ctx.notifications.push(msg);
+  }
+}

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

@@ -0,0 +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());
+  }
+}

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

@@ -0,0 +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}。`);
+    }
+  }
+}

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

@@ -0,0 +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());
+  }
+}

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

@@ -0,0 +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;
+  }
+}

package/src/strategies/goals/goal-root-strategy.ts

@@ -0,0 +1,49 @@
+import type { GameState } from '../../sdk/types.js';
+import type { BehaviorDecision, CustomModule, Strategy, StrategyContext } from '../types.js';
+import type { Goal } from './goal.js';
+import { GoalManager } from './goal-manager.js';
+
+export interface GoalRootStrategyOptions {
+  resetOnMeetingResume?: boolean;
+  customModules?: CustomModule[];
+  onUpdateRole?: (role: string) => void;
+}
+
+export class GoalRootStrategy implements Strategy {
+  readonly name: string;
+  private readonly mgr = new GoalManager();
+  private readonly makeTop: () => Goal;
+  private readonly resetOnMeetingResume: boolean;
+  private readonly modules: CustomModule[];
+  private readonly onUpdateRole?: (role: string) => void;
+
+  constructor(name: string, makeTop: () => Goal, options?: GoalRootStrategyOptions) {
+    this.name = name;
+    this.makeTop = makeTop;
+    this.resetOnMeetingResume = options?.resetOnMeetingResume ?? true;
+    this.modules = options?.customModules ?? [];
+    this.onUpdateRole = options?.onUpdateRole;
+    this.mgr.setTop(makeTop());
+  }
+
+  decide(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    if (this.mgr.getTop() === null) this.mgr.setTop(this.makeTop());
+    return this.mgr.tick(state, ctx);
+  }
+
+  onMeetingResume(): void {
+    if (this.resetOnMeetingResume) {
+      this.mgr.setTop(this.makeTop());
+      return;
+    }
+    this.mgr.getTop()?.onMeetingResume();
+  }
+
+  customModules(): CustomModule[] {
+    return this.modules;
+  }
+
+  updateRole(role: string): void {
+    this.onUpdateRole?.(role);
+  }
+}

package/src/strategies/goals/goal.ts

@@ -0,0 +1,28 @@
+import type { GameState } from '../../sdk/types.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+
+export abstract class Goal {
+  subGoal: Goal | null = null;
+  priority = 0;
+
+  abstract tick(state: GameState, ctx: StrategyContext): BehaviorDecision[];
+
+  isFinish(_state: GameState, _ctx: StrategyContext): boolean {
+    return false;
+  }
+
+  onMeetingResume(): void {}
+
+  setSubGoal(child: Goal, priority: number): boolean {
+    if (this.subGoal !== null && this.subGoal.priority >= priority) {
+      return false;
+    }
+    child.priority = priority;
+    this.subGoal = child;
+    return true;
+  }
+
+  removeSubGoal(): void {
+    this.subGoal = null;
+  }
+}