@myclaw163/clawclaw-cli 0.6.60 → 0.6.63

package/src/strategies/goals/kill-frenzy-top.ts

@@ -1,80 +1,80 @@
-import type { GameState, PlayerInfo } from '../../sdk/types.js';
-import {
-  dist,
-  killCooldownSecs,
-  killCommitRange,
-  LONE_FOLLOW_DISTANCE,
-  nearestPlayerByDistance,
-  nonTeammatesVisible,
-  patrolStep,
-  PatrolState,
-  PROGRESS_INTERVAL_MS,
-  pursueVisibleTarget,
-} from '../game-utils.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-import { Goal } from './goal.js';
-
-/**
- * 疯狂砍人：见谁杀谁（除队友外的所有可见玩家），不挑落单、不看人数、不看知识库。
- * 与 kill-lone 不同——周围人多也照杀，绝不因人多而暂停。
- *
- * 逐 tick：
- * - 视野内有非队友 → 锁定最近那个，贴上去：出刀范围内且冷却好就出刀，
- *   冷却中保持 LONE_FOLLOW_DISTANCE 贴身跟随等待。
- * - 否则 → 按房间顺序巡逻找猎物。永不停手。
- *
- * 与 kill-target 复用同一套「锁定后追/砍/等冷却」体验（pursueVisibleTarget，
- * kill=true、followDistance=LONE_FOLLOW_DISTANCE），仅目标选取规则不同：
- * kill-target 追指定名单，kill-frenzy 追最近的任意非队友。
- */
-export class KillFrenzyTop extends Goal {
-  private readonly patrol = new PatrolState();
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    const target = this.nearestVictim(state, ctx);
-    if (target) {
-      const decision = pursueVisibleTarget(state, target, { kill: true, followDistance: LONE_FOLLOW_DISTANCE });
-      if (decision?.action.type === 'kill') {
-        ctx.notifications.push(`发现目标${target.name}在攻击范围内，出刀！`);
-      } else {
-        const d = target.distance ?? dist(state.you.x, state.you.y, target.x, target.y);
-        if (d > killCommitRange(state.you.role)) ctx.notifications.push(`发现目标${target.name}，正在靠近！`);
-      }
-      this.emitProgress(state, ctx);
-      return decision ? [decision] : [];
-    }
-
-    this.emitProgress(state, ctx);
-    return patrolStep(state, ctx, this.patrol, false);
-  }
-
-  private nearestVictim(state: GameState, ctx: StrategyContext): PlayerInfo | null {
-    return nearestPlayerByDistance(state, nonTeammatesVisible(state, ctx));
-  }
-
-  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 victims = nonTeammatesVisible(state, ctx);
-
-    let msg = `[进度] 当前在${room}`;
-    if (victims.length === 0) {
-      msg += '，视野内没有目标，继续巡逻寻找猎物。';
-    } else {
-      const nearest = victims.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;
-      });
-      msg += `，视野内发现${victims.length}个目标，最近是${nearest.name}。`;
-      if (cd > 0) msg += `攻击冷却中(${cd}s)。`;
-      if (killsRemaining === 0) msg += '出刀次数已用完。';
-    }
-    ctx.notifications.push(msg);
-  }
-}
+import type { GameState, PlayerInfo } from '../../sdk/types.js';
+import {
+  dist,
+  killCooldownSecs,
+  killCommitRange,
+  LONE_FOLLOW_DISTANCE,
+  nearestPlayerByDistance,
+  nonTeammatesVisible,
+  patrolStep,
+  PatrolState,
+  PROGRESS_INTERVAL_MS,
+  pursueVisibleTarget,
+} from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+
+/**
+ * 疯狂砍人：见谁杀谁（除队友外的所有可见玩家），不挑落单、不看人数、不看知识库。
+ * 与 kill-lone 不同——周围人多也照杀，绝不因人多而暂停。
+ *
+ * 逐 tick：
+ * - 视野内有非队友 → 锁定最近那个，贴上去：出刀范围内且冷却好就出刀，
+ *   冷却中保持 LONE_FOLLOW_DISTANCE 贴身跟随等待。
+ * - 否则 → 按房间顺序巡逻找猎物。永不停手。
+ *
+ * 与 kill-target 复用同一套「锁定后追/砍/等冷却」体验（pursueVisibleTarget，
+ * kill=true、followDistance=LONE_FOLLOW_DISTANCE），仅目标选取规则不同：
+ * kill-target 追指定名单，kill-frenzy 追最近的任意非队友。
+ */
+export class KillFrenzyTop extends Goal {
+  private readonly patrol = new PatrolState();
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const target = this.nearestVictim(state, ctx);
+    if (target) {
+      const decision = pursueVisibleTarget(state, target, { kill: true, followDistance: LONE_FOLLOW_DISTANCE });
+      if (decision?.action.type === 'kill') {
+        ctx.notifications.push(`发现目标${target.name}在攻击范围内，出刀！`);
+      } else {
+        const d = target.distance ?? dist(state.you.x, state.you.y, target.x, target.y);
+        if (d > killCommitRange(state.you.role)) ctx.notifications.push(`发现目标${target.name}，正在靠近！`);
+      }
+      this.emitProgress(state, ctx);
+      return decision ? [decision] : [];
+    }
+
+    this.emitProgress(state, ctx);
+    return patrolStep(state, ctx, this.patrol, false);
+  }
+
+  private nearestVictim(state: GameState, ctx: StrategyContext): PlayerInfo | null {
+    return nearestPlayerByDistance(state, nonTeammatesVisible(state, ctx));
+  }
+
+  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 victims = nonTeammatesVisible(state, ctx);
+
+    let msg = `[进度] 当前在${room}`;
+    if (victims.length === 0) {
+      msg += '，视野内没有目标，继续巡逻寻找猎物。';
+    } else {
+      const nearest = victims.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;
+      });
+      msg += `，视野内发现${victims.length}个目标，最近是${nearest.name}。`;
+      if (cd > 0) msg += `攻击冷却中(${cd}s)。`;
+      if (killsRemaining === 0) msg += '出刀次数已用完。';
+    }
+    ctx.notifications.push(msg);
+  }
+}

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

@@ -1,160 +1,160 @@
-import type { GameState, PlayerInfo } from '../../sdk/types.js';
-import {
-  hasKillUseRemaining,
-  hasReachedRoomTarget,
-  isKnowledgeHostile,
-  isKnowledgeTrusted,
-  killCooldownSecs,
-  LONE_IGNORE_MS,
-  matchesAnyTarget,
-  nearestPlayerByDistance,
-  nonTeammatesVisible,
-  PatrolState,
-  PROGRESS_INTERVAL_MS,
-} from '../game-utils.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-import { Goal } from './goal.js';
-import { KillVisibleTargetGoal } from './kill-target-goal.js';
-import { MoveRoomGoal } from './move-room-goal.js';
-
-const PATROL_PRIORITY = 0.2;
-const HUNT_PRIORITY = 0.5;
-
-export class KillLoneTop extends Goal {
-  private readonly patrol = new PatrolState();
-  private loneIgnoreUntil = 0;
-  private patrolStopOnPlayer: boolean | null = null;
-  private lastFlaggedTarget = '';
-
-  constructor(private readonly protectedTargets: string[] = []) {
-    super();
-  }
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    const now = Date.now();
-    const nonTeammates = nonTeammatesVisible(state, ctx);
-
-    if (!hasKillUseRemaining(state)) {
-      this.setPatrolGoal(state, ctx, false);
-      this.emitProgress(state, ctx);
-      return [];
-    }
-
-    const flagged = nearestPlayerByDistance(
-      state,
-      nonTeammates.filter(p => isKnowledgeHostile(p, ctx) && !this.isProtected(p, ctx)),
-    );
-    if (flagged) {
-      if (flagged.name !== this.lastFlaggedTarget) {
-        ctx.notifications.push(`根据情报，${flagged.name}被标记为目标，主动出击！`);
-        this.lastFlaggedTarget = flagged.name;
-      }
-      this.setHuntGoal(flagged.name, true);
-      return [];
-    } else {
-      this.lastFlaggedTarget = '';
-    }
-
-    if (nonTeammates.length === 0 && state.players.length > 0) {
-      this.loneIgnoreUntil = now + LONE_IGNORE_MS;
-    }
-
-    if (now < this.loneIgnoreUntil || nonTeammates.length === 0) {
-      this.setPatrolGoal(state, ctx, now >= this.loneIgnoreUntil);
-      this.emitProgress(state, ctx);
-      return [];
-    }
-
-    if (nonTeammates.length > 1) {
-      this.loneIgnoreUntil = now + LONE_IGNORE_MS;
-      this.setPatrolGoal(state, ctx, false);
-      this.emitProgress(state, ctx);
-      return [];
-    }
-
-    const target = nonTeammates[0];
-    if (this.isProtected(target, ctx)) {
-      this.loneIgnoreUntil = now + LONE_IGNORE_MS;
-      this.setPatrolGoal(state, ctx, false);
-      this.emitProgress(state, ctx);
-      return [];
-    }
-
-    this.setHuntGoal(target.name);
-    this.emitProgress(state, ctx);
-    return [];
-  }
-
-  /** args 保护名单 ∪ 知识里 trusted 的玩家，永不击杀。 */
-  private isProtected(p: PlayerInfo, ctx: StrategyContext): boolean {
-    return matchesAnyTarget(p, this.protectedTargets, ctx) || isKnowledgeTrusted(p, ctx);
-  }
-
-  private setHuntGoal(targetName: string, ignoreCrowd = false): void {
-    const worker = this.subGoal;
-    if (worker instanceof KillVisibleTargetGoal && worker.targetName === targetName && worker.ignoreCrowd === ignoreCrowd) return;
-    if (this.subGoal) this.removeSubGoal();
-    this.setSubGoal(new KillVisibleTargetGoal(targetName, this.protectedTargets, ignoreCrowd), HUNT_PRIORITY);
-    this.patrolStopOnPlayer = null;
-  }
-
-  private setPatrolGoal(state: GameState, ctx: StrategyContext, stopOnPlayer: boolean): void {
-    let room = this.patrol.nextRoom(ctx);
-    if (!room) {
-      this.clearGoal();
-      return;
-    }
-
-    if (hasReachedRoomTarget(state, room)) {
-      this.patrol.advance(ctx);
-      room = this.patrol.nextRoom(ctx);
-      if (!room) {
-        this.clearGoal();
-        return;
-      }
-    }
-
-    const worker = this.subGoal;
-    if (worker instanceof MoveRoomGoal && worker.room === room.name && this.patrolStopOnPlayer === stopOnPlayer) return;
-    if (this.subGoal) this.removeSubGoal();
-    this.setSubGoal(new MoveRoomGoal(room.name, hasReachedRoomTarget, {
-      emitProgress: false,
-      stopOnPlayer,
-    }), PATROL_PRIORITY);
-    this.patrolStopOnPlayer = stopOnPlayer;
-  }
-
-  private clearGoal(): void {
-    if (this.subGoal) this.removeSubGoal();
-    this.patrolStopOnPlayer = 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) {
-      const target = nonTeammates[0];
-      if (this.isProtected(target, ctx)) {
-        msg += `，视野内发现保护目标${target.name}，不动手。`;
-      } else {
-        msg += `，视野内发现落单目标${target.name}。`;
-      }
-      if (cd > 0) msg += `攻击冷却中(${cd}s)。`;
-      if (killsRemaining === 0) msg += '出刀次数已用完。';
-    } else {
-      msg += `，视野内有${nonTeammates.length}人，不适合动手，暂时回避。`;
-    }
-
-    ctx.notifications.push(msg);
-  }
-}
+import type { GameState, PlayerInfo } from '../../sdk/types.js';
+import {
+  hasKillUseRemaining,
+  hasReachedRoomTarget,
+  isKnowledgeHostile,
+  isKnowledgeTrusted,
+  killCooldownSecs,
+  LONE_IGNORE_MS,
+  matchesAnyTarget,
+  nearestPlayerByDistance,
+  nonTeammatesVisible,
+  PatrolState,
+  PROGRESS_INTERVAL_MS,
+} from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+import { KillVisibleTargetGoal } from './kill-target-goal.js';
+import { MoveRoomGoal } from './move-room-goal.js';
+
+const PATROL_PRIORITY = 0.2;
+const HUNT_PRIORITY = 0.5;
+
+export class KillLoneTop extends Goal {
+  private readonly patrol = new PatrolState();
+  private loneIgnoreUntil = 0;
+  private patrolStopOnPlayer: boolean | null = null;
+  private lastFlaggedTarget = '';
+
+  constructor(private readonly protectedTargets: string[] = []) {
+    super();
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const now = Date.now();
+    const nonTeammates = nonTeammatesVisible(state, ctx);
+
+    if (!hasKillUseRemaining(state)) {
+      this.setPatrolGoal(state, ctx, false);
+      this.emitProgress(state, ctx);
+      return [];
+    }
+
+    const flagged = nearestPlayerByDistance(
+      state,
+      nonTeammates.filter(p => isKnowledgeHostile(p, ctx) && !this.isProtected(p, ctx)),
+    );
+    if (flagged) {
+      if (flagged.name !== this.lastFlaggedTarget) {
+        ctx.notifications.push(`根据情报，${flagged.name}被标记为目标，主动出击！`);
+        this.lastFlaggedTarget = flagged.name;
+      }
+      this.setHuntGoal(flagged.name, true);
+      return [];
+    } else {
+      this.lastFlaggedTarget = '';
+    }
+
+    if (nonTeammates.length === 0 && state.players.length > 0) {
+      this.loneIgnoreUntil = now + LONE_IGNORE_MS;
+    }
+
+    if (now < this.loneIgnoreUntil || nonTeammates.length === 0) {
+      this.setPatrolGoal(state, ctx, now >= this.loneIgnoreUntil);
+      this.emitProgress(state, ctx);
+      return [];
+    }
+
+    if (nonTeammates.length > 1) {
+      this.loneIgnoreUntil = now + LONE_IGNORE_MS;
+      this.setPatrolGoal(state, ctx, false);
+      this.emitProgress(state, ctx);
+      return [];
+    }
+
+    const target = nonTeammates[0];
+    if (this.isProtected(target, ctx)) {
+      this.loneIgnoreUntil = now + LONE_IGNORE_MS;
+      this.setPatrolGoal(state, ctx, false);
+      this.emitProgress(state, ctx);
+      return [];
+    }
+
+    this.setHuntGoal(target.name);
+    this.emitProgress(state, ctx);
+    return [];
+  }
+
+  /** args 保护名单 ∪ 知识里 trusted 的玩家，永不击杀。 */
+  private isProtected(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return matchesAnyTarget(p, this.protectedTargets, ctx) || isKnowledgeTrusted(p, ctx);
+  }
+
+  private setHuntGoal(targetName: string, ignoreCrowd = false): void {
+    const worker = this.subGoal;
+    if (worker instanceof KillVisibleTargetGoal && worker.targetName === targetName && worker.ignoreCrowd === ignoreCrowd) return;
+    if (this.subGoal) this.removeSubGoal();
+    this.setSubGoal(new KillVisibleTargetGoal(targetName, this.protectedTargets, ignoreCrowd), HUNT_PRIORITY);
+    this.patrolStopOnPlayer = null;
+  }
+
+  private setPatrolGoal(state: GameState, ctx: StrategyContext, stopOnPlayer: boolean): void {
+    let room = this.patrol.nextRoom(ctx);
+    if (!room) {
+      this.clearGoal();
+      return;
+    }
+
+    if (hasReachedRoomTarget(state, room)) {
+      this.patrol.advance(ctx);
+      room = this.patrol.nextRoom(ctx);
+      if (!room) {
+        this.clearGoal();
+        return;
+      }
+    }
+
+    const worker = this.subGoal;
+    if (worker instanceof MoveRoomGoal && worker.room === room.name && this.patrolStopOnPlayer === stopOnPlayer) return;
+    if (this.subGoal) this.removeSubGoal();
+    this.setSubGoal(new MoveRoomGoal(room.name, hasReachedRoomTarget, {
+      emitProgress: false,
+      stopOnPlayer,
+    }), PATROL_PRIORITY);
+    this.patrolStopOnPlayer = stopOnPlayer;
+  }
+
+  private clearGoal(): void {
+    if (this.subGoal) this.removeSubGoal();
+    this.patrolStopOnPlayer = 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) {
+      const target = nonTeammates[0];
+      if (this.isProtected(target, ctx)) {
+        msg += `，视野内发现保护目标${target.name}，不动手。`;
+      } else {
+        msg += `，视野内发现落单目标${target.name}。`;
+      }
+      if (cd > 0) msg += `攻击冷却中(${cd}s)。`;
+      if (killsRemaining === 0) msg += '出刀次数已用完。';
+    } else {
+      msg += `，视野内有${nonTeammates.length}人，不适合动手，暂时回避。`;
+    }
+
+    ctx.notifications.push(msg);
+  }
+}

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

@@ -1,59 +1,59 @@
-import type { GameState, PlayerInfo } from '../../sdk/types.js';
-import { Action } from '../../sdk/action.js';
-import {
-  canUseKill,
-  dist,
-  hasKillUseRemaining,
-  isKnowledgeTrusted,
-  killCommitRange,
-  LONE_FOLLOW_DISTANCE,
-  matchesAnyTarget,
-  nonTeammatesVisible,
-} from '../game-utils.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-import { Goal } from './goal.js';
-
-export class KillVisibleTargetGoal extends Goal {
-  constructor(
-    public readonly targetName: string,
-    private readonly protectedTargets: string[],
-    public readonly ignoreCrowd = false,
-  ) {
-    super();
-  }
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    const target = this.target(state, ctx);
-    if (!target) return [];
-    if (!hasKillUseRemaining(state)) return [];
-
-    const d = target.distance ?? dist(state.you.x, state.you.y, target.x, target.y);
-
-    if (d <= killCommitRange(state.you.role)) {
-      if (canUseKill(state)) {
-        ctx.notifications.push(`发现追杀目标${target.name}，出刀！`);
-        return [{ action: Action.kill(target.name) }];
-      }
-      return d > LONE_FOLLOW_DISTANCE
-        ? [{ action: Action.move({ x: target.x, y: target.y }) }]
-        : [];
-    }
-
-    ctx.notifications.push(`发现追杀目标${target.name}，正在靠近！`);
-    return [{ action: Action.move({ x: target.x, y: target.y }) }];
-  }
-
-  isFinish(state: GameState, ctx: StrategyContext): boolean {
-    return this.target(state, ctx) == null;
-  }
-
-  private target(state: GameState, ctx: StrategyContext): PlayerInfo | null {
-    const visible = nonTeammatesVisible(state, ctx);
-    if (!this.ignoreCrowd && visible.length !== 1) return null;
-    const target = visible.find(p => p.name === this.targetName) ?? null;
-    if (!target) return null;
-    if (matchesAnyTarget(target, this.protectedTargets, ctx)) return null;
-    if (isKnowledgeTrusted(target, ctx)) return null;
-    return target;
-  }
-}
+import type { GameState, PlayerInfo } from '../../sdk/types.js';
+import { Action } from '../../sdk/action.js';
+import {
+  canUseKill,
+  dist,
+  hasKillUseRemaining,
+  isKnowledgeTrusted,
+  killCommitRange,
+  LONE_FOLLOW_DISTANCE,
+  matchesAnyTarget,
+  nonTeammatesVisible,
+} from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+
+export class KillVisibleTargetGoal extends Goal {
+  constructor(
+    public readonly targetName: string,
+    private readonly protectedTargets: string[],
+    public readonly ignoreCrowd = false,
+  ) {
+    super();
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const target = this.target(state, ctx);
+    if (!target) return [];
+    if (!hasKillUseRemaining(state)) return [];
+
+    const d = target.distance ?? dist(state.you.x, state.you.y, target.x, target.y);
+
+    if (d <= killCommitRange(state.you.role)) {
+      if (canUseKill(state)) {
+        ctx.notifications.push(`发现追杀目标${target.name}，出刀！`);
+        return [{ action: Action.kill(target.name) }];
+      }
+      return d > LONE_FOLLOW_DISTANCE
+        ? [{ action: Action.move({ x: target.x, y: target.y }) }]
+        : [];
+    }
+
+    ctx.notifications.push(`发现追杀目标${target.name}，正在靠近！`);
+    return [{ action: Action.move({ x: target.x, y: target.y }) }];
+  }
+
+  isFinish(state: GameState, ctx: StrategyContext): boolean {
+    return this.target(state, ctx) == null;
+  }
+
+  private target(state: GameState, ctx: StrategyContext): PlayerInfo | null {
+    const visible = nonTeammatesVisible(state, ctx);
+    if (!this.ignoreCrowd && visible.length !== 1) return null;
+    const target = visible.find(p => p.name === this.targetName) ?? null;
+    if (!target) return null;
+    if (matchesAnyTarget(target, this.protectedTargets, ctx)) return null;
+    if (isKnowledgeTrusted(target, ctx)) return null;
+    return target;
+  }
+}