@myclaw163/clawclaw-cli 0.6.56 → 0.6.57

package/src/strategies/goals/paradise-fish-top.ts

@@ -1,219 +1,219 @@
-import type { GameState, PlayerInfo, Position } from '../../sdk/types.js';
-import { Action } from '../../sdk/action.js';
-import {
-  corpseAtScene,
-  dist,
-  hasKnownCorpse,
-  isKnowledgeThreat,
-  isKnowledgeTrusted,
-  nonTeammatesVisible,
-  PatrolState,
-  PROGRESS_INTERVAL_MS,
-  safePatrolStep,
-} from '../game-utils.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-import { GreetingTracker } from '../greeting.js';
-import { Goal } from './goal.js';
-import { KeepAwayGoal, type KeepAwayGoalOptions, type ThreatResolver } from './keep-away-goal.js';
-import { LingerCorpseGoal } from './linger-corpse-goal.js';
-
-const SUB_PRIORITY = 0.5;
-const HUDDLE_DISTANCE = 80;
-const AVOID_ROUTE_MEMORY_MS = 10_000;
-const WITNESS_EXEMPT_COUNT = 2;
-
-type Tier = 'corpse' | 'flee-bad' | 'keep-distance' | 'huddle' | 'wander';
-
-export class ParadiseFishTop extends Goal {
-  private readonly linger = new LingerCorpseGoal((state, ctx) => this.visibleAvoidTargets(state, ctx));
-  private readonly patrol = new PatrolState();
-  private readonly greeting: GreetingTracker;
-  private readonly recentAvoidPoints = new Map<string, { point: Position; until: number; threat: boolean }>();
-
-  constructor(greetingPhrases: string[] = []) {
-    super();
-    this.greeting = new GreetingTracker(greetingPhrases);
-  }
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    const visible = nonTeammatesVisible(state, ctx);
-    const threatTargets = visible.filter(p => this.isThreat(p, ctx));
-    const trustedTargets = visible.filter(p => this.isTrusted(p, ctx));
-    const strangerAvoidTargets = this.strangerAvoidTargets(visible, ctx);
-    this.rememberAvoidPoints(visible, ctx, strangerAvoidTargets.length > 0);
-    const decisions: BehaviorDecision[] = [];
-    const greeting = this.greeting.tryGreeting(state);
-    if (greeting) decisions.push(greeting);
-
-    if (threatTargets.length > 0) {
-      this.setKeepAway('pf-flee-bad', (s, c) => nonTeammatesVisible(s, c).filter(p => this.isThreat(p, c)), {
-        threatRadius: Infinity,
-        noun: '认定带刀坏人',
-      });
-      this.emitProgress(state, ctx, visible, 'flee-bad');
-      return decisions;
-    }
-
-    if (strangerAvoidTargets.length > 0) {
-      this.setKeepAway('pf-keep-distance', (s, c) => this.strangerAvoidTargets(nonTeammatesVisible(s, c), c), {
-        threatRadius: Infinity,
-        noun: '陌生人',
-        planOpts: { steps: 4 },
-      });
-      this.emitProgress(state, ctx, visible, 'keep-distance');
-      return decisions;
-    }
-
-    // 贴尸游走制造嫌疑是「往尸体处移动」的导航行为（不灭口/不报警/不栽赃），与 corpse-patrol 一致用记忆
-    // 驱动：记得某处有尸体就走回去徘徊，尸体离开视野也不丢，直到开会清场（LingerCorpseGoal 内部按
-    // nearestKnownCorpseNav 导航——有坐标就贴尸 40-100 游走，只记得房间没坐标时先走向房间锚点，
-    // 人进视野后坐标自然补全，再切到贴尸游走）。
-    if (hasKnownCorpse(ctx)) {
-      this.clearSub();
-      const linger = this.linger.tick(state, ctx);
-      if (linger.length > 0) {
-        this.emitProgress(state, ctx, visible, 'corpse');
-        return [...linger, ...decisions];
-      }
-    }
-
-    const trusted = trustedTargets;
-    if (trusted.length > 0) {
-      this.clearSub();
-      this.emitProgress(state, ctx, visible, 'huddle');
-      return [...this.huddle(state, trusted), ...decisions];
-    }
-
-    this.clearSub();
-    this.emitProgress(state, ctx, visible, 'wander');
-    return [...this.wander(state, ctx), ...decisions];
-  }
-
-  private isThreat(p: PlayerInfo, ctx: StrategyContext): boolean {
-    return isKnowledgeThreat(p, ctx) && !this.isTrusted(p, ctx);
-  }
-
-  private isTrusted(p: PlayerInfo, ctx: StrategyContext): boolean {
-    return isKnowledgeTrusted(p, ctx);
-  }
-
-  private strangerAvoidTargets(visible: PlayerInfo[], ctx: StrategyContext): PlayerInfo[] {
-    if (visible.some(p => this.isTrusted(p, ctx))) return [];
-    const nonBad = visible.filter(p => !this.isThreat(p, ctx));
-    if (nonBad.length >= WITNESS_EXEMPT_COUNT) return [];
-    return visible.filter(p => !this.isTrusted(p, ctx) && !this.isThreat(p, ctx));
-  }
-
-  private visibleAvoidTargets(state: GameState, ctx: StrategyContext): PlayerInfo[] {
-    const visible = nonTeammatesVisible(state, ctx);
-    const threats = visible.filter(p => this.isThreat(p, ctx));
-    return threats.length > 0 ? threats : this.strangerAvoidTargets(visible, ctx);
-  }
-
-  private huddle(state: GameState, trusted: PlayerInfo[]): BehaviorDecision[] {
-    if (trusted.length === 0) return [];
-    const mate = trusted.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 d = mate.distance ?? dist(state.you.x, state.you.y, mate.x, mate.y);
-    if (d > HUDDLE_DISTANCE) {
-      return [{ action: Action.move({ x: mate.x, y: mate.y }) }];
-    }
-    return [];
-  }
-
-  private wander(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    return safePatrolStep(state, ctx, this.patrol, false, {
-      threatPoints: this.activeAvoidPoints(),
-    });
-  }
-
-  private rememberAvoidPoints(visible: PlayerInfo[], ctx: StrategyContext, avoidNonThreat: boolean): void {
-    const now = Date.now();
-    if (visible.length > 0 && !avoidNonThreat) {
-      for (const [key, item] of this.recentAvoidPoints) {
-        if (!item.threat) this.recentAvoidPoints.delete(key);
-      }
-    }
-    for (const p of visible) {
-      const key = this.playerKey(p);
-      if (!key) continue;
-      if (this.isTrusted(p, ctx)) {
-        this.recentAvoidPoints.delete(key);
-        continue;
-      }
-      const threat = this.isThreat(p, ctx);
-      if (!threat && !avoidNonThreat) {
-        this.recentAvoidPoints.delete(key);
-        continue;
-      }
-      this.recentAvoidPoints.set(key, {
-        point: { x: p.x, y: p.y },
-        until: now + AVOID_ROUTE_MEMORY_MS,
-        threat,
-      });
-    }
-    for (const [key, item] of this.recentAvoidPoints) {
-      if (item.until <= now) this.recentAvoidPoints.delete(key);
-    }
-  }
-
-  private activeAvoidPoints(): Position[] {
-    const now = Date.now();
-    const points: Position[] = [];
-    for (const [key, item] of this.recentAvoidPoints) {
-      if (item.until <= now) {
-        this.recentAvoidPoints.delete(key);
-      } else {
-        points.push(item.point);
-      }
-    }
-    return points;
-  }
-
-  private playerKey(p: PlayerInfo): string {
-    return p.name || (p.seat != null ? String(p.seat) : `${Math.round(p.x)},${Math.round(p.y)}`);
-  }
-
-  private setKeepAway(key: string, resolve: ThreatResolver, options: KeepAwayGoalOptions): void {
-    const worker = this.subGoal;
-    if (worker instanceof KeepAwayGoal && worker.key === key) return;
-    if (this.subGoal) this.removeSubGoal();
-    this.setSubGoal(new KeepAwayGoal(key, resolve, options), SUB_PRIORITY);
-  }
-
-  private clearSub(): void {
-    if (this.subGoal) this.removeSubGoal();
-  }
-
-  private emitProgress(state: GameState, ctx: StrategyContext, visible: PlayerInfo[], tier: Tier): void {
-    const now = Date.now();
-    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
-    ctx.lastProgressNotifyAt = now;
-
-    const room = state.you.room ?? '未知';
-    let msg = `[进度] 当前在${room}`;
-    if (tier === 'corpse') {
-      // corpseAtScene=已贴近尸体(≤150px)；仅凭记忆走向尸体房间、人还没到时别谎报「在尸体附近游走」。
-      if (!corpseAtScene(state)) {
-        msg += '，记得有尸体，正前往尸体处（不报警）。';
-      } else {
-        msg += visible.length > 0
-          ? '，发现尸体，远离旁人但仍在尸体附近游走（不报警）。'
-          : '，发现尸体，附近无人，贴着尸体游走制造嫌疑（不报警）。';
-      }
-    } else if (tier === 'flee-bad') {
-      const names = visible.filter(p => this.isThreat(p, ctx)).map(p => p.name).join('、');
-      msg += `，发现认定带刀坏人${names}，正在远离。`;
-    } else if (tier === 'keep-distance') {
-      msg += `，附近有${visible.length}人但无可信同伴，保持距离中。`;
-    } else if (tier === 'huddle') {
-      msg += '，附近有可信同伴，抱团假装做任务。';
-    } else {
-      msg += '，附近无人，四处游荡。';
-    }
-    ctx.notifications.push(msg);
-  }
-}
+import type { GameState, PlayerInfo, Position } from '../../sdk/types.js';
+import { Action } from '../../sdk/action.js';
+import {
+  corpseAtScene,
+  dist,
+  hasKnownCorpse,
+  isKnowledgeThreat,
+  isKnowledgeTrusted,
+  nonTeammatesVisible,
+  PatrolState,
+  PROGRESS_INTERVAL_MS,
+  safePatrolStep,
+} from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { GreetingTracker } from '../greeting.js';
+import { Goal } from './goal.js';
+import { KeepAwayGoal, type KeepAwayGoalOptions, type ThreatResolver } from './keep-away-goal.js';
+import { LingerCorpseGoal } from './linger-corpse-goal.js';
+
+const SUB_PRIORITY = 0.5;
+const HUDDLE_DISTANCE = 80;
+const AVOID_ROUTE_MEMORY_MS = 10_000;
+const WITNESS_EXEMPT_COUNT = 2;
+
+type Tier = 'corpse' | 'flee-bad' | 'keep-distance' | 'huddle' | 'wander';
+
+export class ParadiseFishTop extends Goal {
+  private readonly linger = new LingerCorpseGoal((state, ctx) => this.visibleAvoidTargets(state, ctx));
+  private readonly patrol = new PatrolState();
+  private readonly greeting: GreetingTracker;
+  private readonly recentAvoidPoints = new Map<string, { point: Position; until: number; threat: boolean }>();
+
+  constructor(greetingPhrases: string[] = []) {
+    super();
+    this.greeting = new GreetingTracker(greetingPhrases);
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const visible = nonTeammatesVisible(state, ctx);
+    const threatTargets = visible.filter(p => this.isThreat(p, ctx));
+    const trustedTargets = visible.filter(p => this.isTrusted(p, ctx));
+    const strangerAvoidTargets = this.strangerAvoidTargets(visible, ctx);
+    this.rememberAvoidPoints(visible, ctx, strangerAvoidTargets.length > 0);
+    const decisions: BehaviorDecision[] = [];
+    const greeting = this.greeting.tryGreeting(state);
+    if (greeting) decisions.push(greeting);
+
+    if (threatTargets.length > 0) {
+      this.setKeepAway('pf-flee-bad', (s, c) => nonTeammatesVisible(s, c).filter(p => this.isThreat(p, c)), {
+        threatRadius: Infinity,
+        noun: '认定带刀坏人',
+      });
+      this.emitProgress(state, ctx, visible, 'flee-bad');
+      return decisions;
+    }
+
+    if (strangerAvoidTargets.length > 0) {
+      this.setKeepAway('pf-keep-distance', (s, c) => this.strangerAvoidTargets(nonTeammatesVisible(s, c), c), {
+        threatRadius: Infinity,
+        noun: '陌生人',
+        planOpts: { steps: 4 },
+      });
+      this.emitProgress(state, ctx, visible, 'keep-distance');
+      return decisions;
+    }
+
+    // 贴尸游走制造嫌疑是「往尸体处移动」的导航行为（不灭口/不报警/不栽赃），与 corpse-patrol 一致用记忆
+    // 驱动：记得某处有尸体就走回去徘徊，尸体离开视野也不丢，直到开会清场（LingerCorpseGoal 内部按
+    // nearestKnownCorpseNav 导航——有坐标就贴尸 40-100 游走，只记得房间没坐标时先走向房间锚点，
+    // 人进视野后坐标自然补全，再切到贴尸游走）。
+    if (hasKnownCorpse(ctx)) {
+      this.clearSub();
+      const linger = this.linger.tick(state, ctx);
+      if (linger.length > 0) {
+        this.emitProgress(state, ctx, visible, 'corpse');
+        return [...linger, ...decisions];
+      }
+    }
+
+    const trusted = trustedTargets;
+    if (trusted.length > 0) {
+      this.clearSub();
+      this.emitProgress(state, ctx, visible, 'huddle');
+      return [...this.huddle(state, trusted), ...decisions];
+    }
+
+    this.clearSub();
+    this.emitProgress(state, ctx, visible, 'wander');
+    return [...this.wander(state, ctx), ...decisions];
+  }
+
+  private isThreat(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return isKnowledgeThreat(p, ctx) && !this.isTrusted(p, ctx);
+  }
+
+  private isTrusted(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return isKnowledgeTrusted(p, ctx);
+  }
+
+  private strangerAvoidTargets(visible: PlayerInfo[], ctx: StrategyContext): PlayerInfo[] {
+    if (visible.some(p => this.isTrusted(p, ctx))) return [];
+    const nonBad = visible.filter(p => !this.isThreat(p, ctx));
+    if (nonBad.length >= WITNESS_EXEMPT_COUNT) return [];
+    return visible.filter(p => !this.isTrusted(p, ctx) && !this.isThreat(p, ctx));
+  }
+
+  private visibleAvoidTargets(state: GameState, ctx: StrategyContext): PlayerInfo[] {
+    const visible = nonTeammatesVisible(state, ctx);
+    const threats = visible.filter(p => this.isThreat(p, ctx));
+    return threats.length > 0 ? threats : this.strangerAvoidTargets(visible, ctx);
+  }
+
+  private huddle(state: GameState, trusted: PlayerInfo[]): BehaviorDecision[] {
+    if (trusted.length === 0) return [];
+    const mate = trusted.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 d = mate.distance ?? dist(state.you.x, state.you.y, mate.x, mate.y);
+    if (d > HUDDLE_DISTANCE) {
+      return [{ action: Action.move({ x: mate.x, y: mate.y }) }];
+    }
+    return [];
+  }
+
+  private wander(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    return safePatrolStep(state, ctx, this.patrol, false, {
+      threatPoints: this.activeAvoidPoints(),
+    });
+  }
+
+  private rememberAvoidPoints(visible: PlayerInfo[], ctx: StrategyContext, avoidNonThreat: boolean): void {
+    const now = Date.now();
+    if (visible.length > 0 && !avoidNonThreat) {
+      for (const [key, item] of this.recentAvoidPoints) {
+        if (!item.threat) this.recentAvoidPoints.delete(key);
+      }
+    }
+    for (const p of visible) {
+      const key = this.playerKey(p);
+      if (!key) continue;
+      if (this.isTrusted(p, ctx)) {
+        this.recentAvoidPoints.delete(key);
+        continue;
+      }
+      const threat = this.isThreat(p, ctx);
+      if (!threat && !avoidNonThreat) {
+        this.recentAvoidPoints.delete(key);
+        continue;
+      }
+      this.recentAvoidPoints.set(key, {
+        point: { x: p.x, y: p.y },
+        until: now + AVOID_ROUTE_MEMORY_MS,
+        threat,
+      });
+    }
+    for (const [key, item] of this.recentAvoidPoints) {
+      if (item.until <= now) this.recentAvoidPoints.delete(key);
+    }
+  }
+
+  private activeAvoidPoints(): Position[] {
+    const now = Date.now();
+    const points: Position[] = [];
+    for (const [key, item] of this.recentAvoidPoints) {
+      if (item.until <= now) {
+        this.recentAvoidPoints.delete(key);
+      } else {
+        points.push(item.point);
+      }
+    }
+    return points;
+  }
+
+  private playerKey(p: PlayerInfo): string {
+    return p.name || (p.seat != null ? String(p.seat) : `${Math.round(p.x)},${Math.round(p.y)}`);
+  }
+
+  private setKeepAway(key: string, resolve: ThreatResolver, options: KeepAwayGoalOptions): void {
+    const worker = this.subGoal;
+    if (worker instanceof KeepAwayGoal && worker.key === key) return;
+    if (this.subGoal) this.removeSubGoal();
+    this.setSubGoal(new KeepAwayGoal(key, resolve, options), SUB_PRIORITY);
+  }
+
+  private clearSub(): void {
+    if (this.subGoal) this.removeSubGoal();
+  }
+
+  private emitProgress(state: GameState, ctx: StrategyContext, visible: PlayerInfo[], tier: Tier): void {
+    const now = Date.now();
+    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
+    ctx.lastProgressNotifyAt = now;
+
+    const room = state.you.room ?? '未知';
+    let msg = `[进度] 当前在${room}`;
+    if (tier === 'corpse') {
+      // corpseAtScene=已贴近尸体(≤150px)；仅凭记忆走向尸体房间、人还没到时别谎报「在尸体附近游走」。
+      if (!corpseAtScene(state)) {
+        msg += '，记得有尸体，正前往尸体处（不报警）。';
+      } else {
+        msg += visible.length > 0
+          ? '，发现尸体，远离旁人但仍在尸体附近游走（不报警）。'
+          : '，发现尸体，附近无人，贴着尸体游走制造嫌疑（不报警）。';
+      }
+    } else if (tier === 'flee-bad') {
+      const names = visible.filter(p => this.isThreat(p, ctx)).map(p => p.name).join('、');
+      msg += `，发现认定带刀坏人${names}，正在远离。`;
+    } else if (tier === 'keep-distance') {
+      msg += `，附近有${visible.length}人但无可信同伴，保持距离中。`;
+    } else if (tier === 'huddle') {
+      msg += '，附近有可信同伴，抱团假装做任务。';
+    } else {
+      msg += '，附近无人，四处游荡。';
+    }
+    ctx.notifications.push(msg);
+  }
+}

package/src/strategies/goals/patrol-top.ts

@@ -1,57 +1,57 @@
-import type { GameState } from '../../sdk/types.js';
-import { hasReachedRoomTarget, PatrolState, PROGRESS_INTERVAL_MS } from '../game-utils.js';
-import type { BehaviorDecision, RoomTarget, StrategyContext } from '../types.js';
-import { Goal } from './goal.js';
-import { MoveRoomGoal } from './move-room-goal.js';
-
-const PATROL_PRIORITY = 0.2;
-
-export class PatrolTop extends Goal {
-  private readonly patrol = new PatrolState();
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    let room = this.patrol.nextRoom(ctx);
-    if (!room) {
-      this.emitProgress(state, ctx, null);
-      return [];
-    }
-
-    if (hasReachedRoomTarget(state, room)) {
-      this.patrol.advance(ctx);
-      room = this.patrol.nextRoom(ctx);
-      if (!room) {
-        this.emitProgress(state, ctx, null);
-        return [];
-      }
-    }
-
-    const worker = this.subGoal;
-    if (worker instanceof MoveRoomGoal) {
-      if (worker.room !== room.name) {
-        this.removeSubGoal();
-        this.setSubGoal(new MoveRoomGoal(room.name, hasReachedRoomTarget, { emitProgress: false }), PATROL_PRIORITY);
-      }
-    } else {
-      this.setSubGoal(new MoveRoomGoal(room.name, hasReachedRoomTarget, { emitProgress: false }), PATROL_PRIORITY);
-    }
-    this.emitProgress(state, ctx, room);
-    return [];
-  }
-
-  private emitProgress(state: GameState, ctx: StrategyContext, target: RoomTarget | null): void {
-    const now = Date.now();
-    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
-    ctx.lastProgressNotifyAt = now;
-
-    const room = state.you.room ?? '未知';
-    const totalRooms = ctx.rooms.length;
-
-    let msg = `[进度] 当前在${room}`;
-    if (target) {
-      msg += `，正在巡逻前往${target.name}`;
-    }
-    msg += `。共${totalRooms}个房间。`;
-
-    ctx.notifications.push(msg);
-  }
-}
+import type { GameState } from '../../sdk/types.js';
+import { hasReachedRoomTarget, PatrolState, PROGRESS_INTERVAL_MS } from '../game-utils.js';
+import type { BehaviorDecision, RoomTarget, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+import { MoveRoomGoal } from './move-room-goal.js';
+
+const PATROL_PRIORITY = 0.2;
+
+export class PatrolTop extends Goal {
+  private readonly patrol = new PatrolState();
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    let room = this.patrol.nextRoom(ctx);
+    if (!room) {
+      this.emitProgress(state, ctx, null);
+      return [];
+    }
+
+    if (hasReachedRoomTarget(state, room)) {
+      this.patrol.advance(ctx);
+      room = this.patrol.nextRoom(ctx);
+      if (!room) {
+        this.emitProgress(state, ctx, null);
+        return [];
+      }
+    }
+
+    const worker = this.subGoal;
+    if (worker instanceof MoveRoomGoal) {
+      if (worker.room !== room.name) {
+        this.removeSubGoal();
+        this.setSubGoal(new MoveRoomGoal(room.name, hasReachedRoomTarget, { emitProgress: false }), PATROL_PRIORITY);
+      }
+    } else {
+      this.setSubGoal(new MoveRoomGoal(room.name, hasReachedRoomTarget, { emitProgress: false }), PATROL_PRIORITY);
+    }
+    this.emitProgress(state, ctx, room);
+    return [];
+  }
+
+  private emitProgress(state: GameState, ctx: StrategyContext, target: RoomTarget | null): void {
+    const now = Date.now();
+    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
+    ctx.lastProgressNotifyAt = now;
+
+    const room = state.you.room ?? '未知';
+    const totalRooms = ctx.rooms.length;
+
+    let msg = `[进度] 当前在${room}`;
+    if (target) {
+      msg += `，正在巡逻前往${target.name}`;
+    }
+    msg += `。共${totalRooms}个房间。`;
+
+    ctx.notifications.push(msg);
+  }
+}