@myclaw163/clawclaw-cli 0.6.61 → 0.6.63

package/src/strategies/hide-spots.ts

@@ -0,0 +1,123 @@
+import type { Position } from '../sdk/types.js';
+import { dist } from './game-utils.js';
+import { assessRoutes } from './pathfind/escape-planner.js';
+
+export interface HideSpot {
+  /** 世界像素坐标，与 GameState / 可行走网格同坐标系。 */
+  x: number;
+  y: number;
+  /** 所在房间，仅供日志/调试。 */
+  room: string;
+}
+
+/**
+ * 躲藏点：离线从服务端烘焙地图（config/clawclaw/clawclaw.tmj.baked.npz）算出的「藏身角落」。筛选条件：
+ *  - 所在房间有 ≥2 个出口（非死胡同，被追能逃）；**走廊**（做任务的必经路线）一律排除；
+ *  - 出口 ≥4 的枢纽房间排除（穿行人流太大，藏不住）；
+ *  - 取房间内「离各出口最深、且远离任务点/出生点」的可走格（缩在内侧角落，避开穿行线与刷新点）。
+ *
+ * 重新生成：scripts/find-hide-spots.py（用后端 venv 解释器跑，读 baked.npz，打印可粘贴的本数组）。
+ * 这是离线烘焙数据，和 pathfind 的可行走网格一样：运行时按需 snap 到最近可走格即可。
+ */
+export const HIDE_SPOTS: readonly HideSpot[] = [
+  { x: 2882, y: 1362, room: '导航仓' },
+  { x: 2386, y: 1138, room: '健身房' },
+  { x: 1922, y: 1234, room: '酒吧' },
+  { x: 2418, y: 2130, room: '休闲会所' },
+  { x: 1538, y: 1826, room: '监控室' },
+  { x: 514, y: 2402, room: '动力监控室' },
+  { x: 1538, y: 2514, room: '自助餐厅' },
+  { x: 1314, y: 2674, room: '制氧舱' },
+  { x: 2514, y: 2882, room: '中央厨房' },
+  { x: 2882, y: 2994, room: '冷库' },
+  { x: 3858, y: 2434, room: '情报室' },
+];
+
+/** 躲藏点离任一威胁多近就硬排除（与 nearestSafeTask 的端点排除同量级）。 */
+export const HIDE_THREAT_EXCLUDE_RANGE = 500;
+/** 去躲藏点的测地路径经过威胁这个距离内也排除（避免走向把守者）。 */
+export const HIDE_PATH_THREAT_RADIUS = 350;
+
+export interface NearestSafeHideOptions {
+  threatExcludeRadius?: number;
+  pathThreatRadius?: number;
+  /** 当前已选躲藏点：仍是合法候选就保持不变，杜绝等距摇摆。 */
+  stickyTo?: HideSpot | null;
+  /** 被标记为不可达的移动目标：在其附近的点跳过。 */
+  blockedTarget?: Position | null;
+}
+
+const BLOCKED_RADIUS = 12;
+
+function sameSpot(a: HideSpot, b: HideSpot): boolean {
+  return a.x === b.x && a.y === b.y;
+}
+
+/** 所有点都被威胁封死时的兜底：离威胁最远的点（仍好过原地等死）。 */
+function farthestFromThreats(threatPoints: Position[], blocked?: Position | null): HideSpot | null {
+  let best: HideSpot | null = null;
+  let bestMin = -Infinity;
+  for (const s of HIDE_SPOTS) {
+    if (blocked && dist(s.x, s.y, blocked.x, blocked.y) <= BLOCKED_RADIUS) continue;
+    const minD = threatPoints.length === 0 ? 0 : Math.min(...threatPoints.map(p => dist(s.x, s.y, p.x, p.y)));
+    if (minD > bestMin) {
+      bestMin = minD;
+      best = s;
+    }
+  }
+  return best;
+}
+
+/**
+ * 选「最近的安全躲藏点」：与 nearestSafeTask 同构——威胁旁的点硬排除、去路经过威胁附近的点排除，
+ * 余者取测地最近（distance-field 一次扫描；测地不可达按欧氏垫底），带粘性（当前点仍合法就不换）。
+ * 全部被威胁封死时退回「离威胁最远」的点。
+ */
+export function nearestSafeHideSpot(
+  from: Position,
+  threatPoints: Position[] = [],
+  opts: NearestSafeHideOptions = {},
+): HideSpot | null {
+  const excludeR = opts.threatExcludeRadius ?? HIDE_THREAT_EXCLUDE_RANGE;
+  const blocked = opts.blockedTarget ?? null;
+
+  const candidates = HIDE_SPOTS.filter(s =>
+    (!blocked || dist(s.x, s.y, blocked.x, blocked.y) > BLOCKED_RADIUS)
+    && !threatPoints.some(p => dist(s.x, s.y, p.x, p.y) <= excludeR));
+
+  if (candidates.length === 0) return farthestFromThreats(threatPoints, blocked);
+
+  // 无威胁时粘性可零成本短路（不必为路径检查扫距离场）。
+  if (opts.stickyTo && threatPoints.length === 0) {
+    const sticky = candidates.find(c => sameSpot(c, opts.stickyTo!));
+    if (sticky) return sticky;
+  }
+
+  const routes = assessRoutes(
+    from,
+    candidates.map(c => ({ x: c.x, y: c.y })),
+    threatPoints,
+    opts.pathThreatRadius ?? HIDE_PATH_THREAT_RADIUS,
+  );
+  const indexed = candidates.map((c, i) => ({ c, i }));
+  const viable = routes == null ? indexed : indexed.filter(({ i }) => !routes[i].nearThreat);
+  const pool = viable.length > 0 ? viable : indexed;
+
+  if (opts.stickyTo) {
+    const sticky = pool.find(({ c }) => sameSpot(c, opts.stickyTo!));
+    if (sticky) return sticky.c;
+  }
+
+  let best = pool[0].c;
+  let bestScore = Infinity;
+  for (const { c, i } of pool) {
+    const euclid = dist(from.x, from.y, c.x, c.y);
+    const geo = routes?.[i].distancePx;
+    const score = geo == null ? euclid : geo !== Infinity ? geo : euclid + 1e6;
+    if (score < bestScore) {
+      bestScore = score;
+      best = c;
+    }
+  }
+  return best;
+}

package/src/strategies/hide.ts

@@ -0,0 +1,23 @@
+import type { StrategyEntry } from './types.js';
+import { GoalRootStrategy } from './goals/goal-root-strategy.js';
+import { HideTop } from './goals/hide-top.js';
+
+/** 解析参数：kill/fight → 死角自保开；nokill/flee/pacifist → 关；缺省（null）= 按角色默认。 */
+export function parseHideKillArg(args?: string[]): boolean | null {
+  for (const raw of args ?? []) {
+    const a = raw.trim().toLowerCase();
+    if (a === 'kill' || a === 'fight' || a === 'kill=on') return true;
+    if (a === 'nokill' || a === 'flee' || a === 'pacifist' || a === 'kill=off') return false;
+  }
+  return null;
+}
+
+export const strategy: StrategyEntry = {
+  id: 'hide',
+  description:
+    '躲藏策略：在离线从地图算好的若干「非走廊、≥2 出口可逃、远离任务点/出生点」的藏身角落里，选测地最近且不挨威胁的一个潜伏不动；视野里一出现非队友，就像 shrimp-memory 那样保持距离甩开（KeepAway），并边逃边重算排除该威胁的新藏点，逃完落到新点继续潜伏。蟹不躲队友。可选参数 kill / nokill 控制「被单个对手逼进出刀距离且无路可逃时是否出刀自保」——缺省按角色：蟹/章鱼默认开，武士虾/枪虾（及无刀角色）默认关。',
+  create(args?: string[]) {
+    const killWhenCornered = parseHideKillArg(args);
+    return new GoalRootStrategy('hide', () => new HideTop(killWhenCornered), { resetOnMeetingResume: false });
+  },
+};

package/src/strategies/strategy-loop.ts

@@ -379,6 +379,7 @@ export async function runStrategyLoop(strategyId: string, args?: string[]): Prom
 
   const ctx: StrategyContext = {
     taskData: [],
+    taskLocations: [],
     emergency: null,
     taskLocalBlockedUntil: 0,
     reportCorpseTarget: null,
@@ -669,6 +670,9 @@ export async function runStrategyLoop(strategyId: string, args?: string[]): Prom
           is_fake_shrimp: t.is_fake_shrimp ?? false,
           faction: taskFactionByName.get(t.name),
         }));
+        ctx.taskLocations = (mapData?.all_task_locations ?? [])
+          .filter((t: any) => t && typeof t.name === 'string' && typeof t.x === 'number' && typeof t.y === 'number')
+          .map((t: any) => ({ name: t.name, room: t.room, x: t.x, y: t.y, faction: t.faction }));
         if (Array.isArray(mapData?.rooms)) {
           if (ctx.rooms.length === 0) {
             const byRoom = taskLocationsByRoom(mapData?.all_task_locations);

package/src/strategies/types.ts

@@ -1,4 +1,4 @@
-import type { GameState, TaskInfo, EmergencyInfo, CorpseInfo } from '../sdk/types.js';
+import type { GameState, TaskInfo, TaskLocation, EmergencyInfo, CorpseInfo } from '../sdk/types.js';
 import type { Action } from '../sdk/action.js';
 import type { KnowledgeView } from '../lib/knowledge-store.js';
 
@@ -57,6 +57,12 @@ export interface RoomTarget {
 
 export interface StrategyContext {
   taskData: TaskInfo[];
+  /**
+   * 全局任务站点（map 的 all_task_locations），strategy-loop 加载地图后写入。与 taskData（仅自己被
+   * 分配、带 status）不同：这是地图上所有任务点的位置，开局固定。用于「同伴停在任务点附近 → 在真实
+   * 任务点假装做任务」这类定点行为。首次地图加载前可能为空/未设置。
+   */
+  taskLocations?: TaskLocation[];
   emergency: EmergencyInfo | null;
   taskLocalBlockedUntil: number;
   reportCorpseTarget: CorpseTarget | null;