@myclaw163/clawclaw-cli 0.6.66 → 0.6.68

package/src/strategies/new-events-backfill.ts

@@ -1,98 +1,98 @@
-import { closeSync, existsSync, openSync, readSync, statSync } from 'fs';
-import { extractNewEvents } from '../pipeline/event-store.js';
-
-const SUPPLEMENTAL_TYPES = new Set([
-  'corpse_spotted', 'crab_teammates',
-  'meeting_ended', 'meeting_result_pending', 'meeting_start', 'meeting_started',
-  'move_end', 'move_interrupted',
-  'wandering_speech',
-]);
-
-const KEY_FIELDS = [
-  'type', 'tick', 'actor_name', 'spotted_name', 'killer_name', 'result_target',
-  'target_name', 'corpse_name', 'task_name', 'reason', 'text', 'content',
-];
-
-export function createStrategyNewEventsBackfill(eventLogPath: string): {
-  correct(stateNewEvents: any): Record<string, any>[];
-} {
-  let pos = sizeOf(eventLogPath);
-
-  return {
-    correct(stateNewEvents: any): Record<string, any>[] {
-      const httpEvents = extractNewEvents(stateNewEvents);
-      const httpKeys = new Set(httpEvents.map(eventKey));
-      const out: Array<{ event: Record<string, any>; order: number }> = [];
-      const seen = new Set<string>();
-      let order = 0;
-      const add = (evt: any, supplemental = false) => {
-        if (!evt || typeof evt !== 'object' || typeof evt.type !== 'string' || evt.synthetic) return;
-        if (supplemental && !SUPPLEMENTAL_TYPES.has(evt.type)) return;
-        const key = eventKey(evt);
-        if (supplemental && httpKeys.has(key)) return;
-        if (seen.has(key)) return;
-        seen.add(key);
-        out.push({ event: evt, order: order++ });
-      };
-
-      for (const line of readNewLines()) {
-        const events = extractNewEvents(line);
-        for (const evt of events.length > 0 ? events : [line]) add(evt, true);
-      }
-      for (const evt of httpEvents) add(evt);
-      return out.sort(compareEvents).map(item => item.event);
-    },
-  };
-
-  function readNewLines(): Record<string, any>[] {
-    if (!existsSync(eventLogPath)) { pos = 0; return []; }
-    let stat;
-    try { stat = statSync(eventLogPath); } catch { return []; }
-    if (stat.size < pos) pos = 0;
-    if (stat.size === pos) return [];
-
-    let fd: number;
-    try { fd = openSync(eventLogPath, 'r'); } catch { return []; }
-    const buf = Buffer.alloc(stat.size - pos);
-    try {
-      readSync(fd, buf, 0, buf.length, pos);
-    } finally {
-      closeSync(fd);
-    }
-
-    const cut = buf.lastIndexOf(0x0A);
-    if (cut < 0) return [];
-    const chunk = buf.subarray(0, cut).toString('utf8');
-    pos += cut + 1;
-    return chunk.split('\n').flatMap(parseLine);
-  }
-}
-
-function eventKey(evt: Record<string, any>): string {
-  return evt.tick == null ? JSON.stringify(evt) : KEY_FIELDS.map(k => evt[k] ?? '').join('|');
-}
-
-function compareEvents(a: { event: Record<string, any>; order: number }, b: { event: Record<string, any>; order: number }): number {
-  const at = typeof a.event.tick === 'number' && Number.isFinite(a.event.tick) ? a.event.tick : null;
-  const bt = typeof b.event.tick === 'number' && Number.isFinite(b.event.tick) ? b.event.tick : null;
-  if (at != null && bt != null && at !== bt) return at - bt;
-  return a.order - b.order;
-}
-
-function parseLine(line: string): Record<string, any>[] {
-  if (!line.trim()) return [];
-  try {
-    const obj = JSON.parse(line);
-    return obj && typeof obj === 'object' ? [obj] : [];
-  } catch {
-    return [];
-  }
-}
-
-function sizeOf(path: string): number {
-  try {
-    return existsSync(path) ? statSync(path).size : 0;
-  } catch {
-    return 0;
-  }
-}
+import { closeSync, existsSync, openSync, readSync, statSync } from 'fs';
+import { extractNewEvents } from '../pipeline/event-store.js';
+
+const SUPPLEMENTAL_TYPES = new Set([
+  'corpse_spotted', 'crab_teammates',
+  'meeting_ended', 'meeting_result_pending', 'meeting_start', 'meeting_started',
+  'move_end', 'move_interrupted',
+  'wandering_speech',
+]);
+
+const KEY_FIELDS = [
+  'type', 'tick', 'actor_name', 'spotted_name', 'killer_name', 'result_target',
+  'target_name', 'corpse_name', 'task_name', 'reason', 'text', 'content',
+];
+
+export function createStrategyNewEventsBackfill(eventLogPath: string): {
+  correct(stateNewEvents: any): Record<string, any>[];
+} {
+  let pos = sizeOf(eventLogPath);
+
+  return {
+    correct(stateNewEvents: any): Record<string, any>[] {
+      const httpEvents = extractNewEvents(stateNewEvents);
+      const httpKeys = new Set(httpEvents.map(eventKey));
+      const out: Array<{ event: Record<string, any>; order: number }> = [];
+      const seen = new Set<string>();
+      let order = 0;
+      const add = (evt: any, supplemental = false) => {
+        if (!evt || typeof evt !== 'object' || typeof evt.type !== 'string' || evt.synthetic) return;
+        if (supplemental && !SUPPLEMENTAL_TYPES.has(evt.type)) return;
+        const key = eventKey(evt);
+        if (supplemental && httpKeys.has(key)) return;
+        if (seen.has(key)) return;
+        seen.add(key);
+        out.push({ event: evt, order: order++ });
+      };
+
+      for (const line of readNewLines()) {
+        const events = extractNewEvents(line);
+        for (const evt of events.length > 0 ? events : [line]) add(evt, true);
+      }
+      for (const evt of httpEvents) add(evt);
+      return out.sort(compareEvents).map(item => item.event);
+    },
+  };
+
+  function readNewLines(): Record<string, any>[] {
+    if (!existsSync(eventLogPath)) { pos = 0; return []; }
+    let stat;
+    try { stat = statSync(eventLogPath); } catch { return []; }
+    if (stat.size < pos) pos = 0;
+    if (stat.size === pos) return [];
+
+    let fd: number;
+    try { fd = openSync(eventLogPath, 'r'); } catch { return []; }
+    const buf = Buffer.alloc(stat.size - pos);
+    try {
+      readSync(fd, buf, 0, buf.length, pos);
+    } finally {
+      closeSync(fd);
+    }
+
+    const cut = buf.lastIndexOf(0x0A);
+    if (cut < 0) return [];
+    const chunk = buf.subarray(0, cut).toString('utf8');
+    pos += cut + 1;
+    return chunk.split('\n').flatMap(parseLine);
+  }
+}
+
+function eventKey(evt: Record<string, any>): string {
+  return evt.tick == null ? JSON.stringify(evt) : KEY_FIELDS.map(k => evt[k] ?? '').join('|');
+}
+
+function compareEvents(a: { event: Record<string, any>; order: number }, b: { event: Record<string, any>; order: number }): number {
+  const at = typeof a.event.tick === 'number' && Number.isFinite(a.event.tick) ? a.event.tick : null;
+  const bt = typeof b.event.tick === 'number' && Number.isFinite(b.event.tick) ? b.event.tick : null;
+  if (at != null && bt != null && at !== bt) return at - bt;
+  return a.order - b.order;
+}
+
+function parseLine(line: string): Record<string, any>[] {
+  if (!line.trim()) return [];
+  try {
+    const obj = JSON.parse(line);
+    return obj && typeof obj === 'object' ? [obj] : [];
+  } catch {
+    return [];
+  }
+}
+
+function sizeOf(path: string): number {
+  try {
+    return existsSync(path) ? statSync(path).size : 0;
+  } catch {
+    return 0;
+  }
+}

package/src/strategies/paradise-fish.knowledge.md

@@ -1,20 +1,19 @@
-# paradise-fish 知识契约
-
-`paradise-fish` 只读取统一的玩家三档标记：
-
-| 标记 | 行为 |
-|------|------|
-| `suspect` | 可疑：无尸体时进入视野便寻路远离 |
-| `hostile` | 敌对：无尸体时进入视野便寻路远离 |
-| `trusted` | 可信：可与其抱团、靠近站定伪装做任务 |
-
-天堂鱼不出刀，因此 suspect 与 hostile 都表现为回避。发现尸体时仍优先执行尸体旁游走逻辑，不报警。
-
-```bash
-ccl knowledge mark 5 suspect --confidence 0.7 --note "行为可疑"
-ccl knowledge mark 5 hostile --confidence 0.9 --note "确认危险"
-ccl knowledge mark 3 trusted --note "可以抱团"
-ccl knowledge del player 5
-```
-
-`role` 是纯身份事实，不直接控制策略。
+# paradise-fish 知识契约
+
+`paradise-fish` 只读取两档玩家标记，**未标记的一律默认「被怀疑」**：
+
+| 标记 | 行为 |
+|------|------|
+| `hostile`（坏人） | 敌对带刀者：无尸体时进入视野便硬寻路远离 |
+| `trusted`（好人） | 可信：可与其抱团、靠近站定伪装做任务 |
+| 未标记（被怀疑） | 无尸体、无可信同伴且单人贴近时保持距离；多人互为目击者则照常活动 |
+
+天堂鱼不出刀，因此坏人与被怀疑者都表现为回避（坏人硬躲、被怀疑者按目击者规则保持距离）。发现尸体时仍优先执行尸体旁游走逻辑，不报警。
+
+```bash
+ccl knowledge mark 5 hostile --note "确认危险"
+ccl knowledge mark 3 trusted --note "可以抱团"
+ccl knowledge del player 5            # 取消标记 → 回到默认「被怀疑」
+```
+
+`role` 是纯身份事实，不直接控制策略。

package/src/strategies/paradise-fish.ts

@@ -1,25 +1,25 @@
-import type { StrategyEntry } from './types.js';
-import { GoalRootStrategy } from './goals/goal-root-strategy.js';
-import { ParadiseFishTop } from './goals/paradise-fish-top.js';
-import { parseGreetingArgs } from './greeting.js';
-
-class ParadiseFishStrategy extends GoalRootStrategy {
-  constructor(private readonly greetingPhrases: string[]) {
-    super('paradise-fish', () => new ParadiseFishTop(greetingPhrases), {
-      resetOnMeetingResume: false,
-    });
-  }
-
-  speechWarmupTexts(): string[] {
-    return this.greetingPhrases;
-  }
-}
-
-export const strategy: StrategyEntry = {
-  id: 'paradise-fish',
-  description:
-    '天堂鱼·进阶版（中立，不报警、不做任务，靠被投票出局取胜；corpse-patrol 的带记忆升级）。统一读取 ccl knowledge 三档标记：suspect/hostile 都视为危险并寻路远离，trusted 视为可抱团的可信同伴。发现尸体绝不报警，贴着尸体游走制造嫌疑；附近有人时远离那人但仍在尸体附近活动。传入打招呼话术时，视野内出现人就随机发送一条，之后120秒内不再发言。',
-  create(args?: string[]) {
-    return new ParadiseFishStrategy(parseGreetingArgs(args, 'paradise-fish'));
-  },
-};
+import type { StrategyEntry } from './types.js';
+import { GoalRootStrategy } from './goals/goal-root-strategy.js';
+import { ParadiseFishTop } from './goals/paradise-fish-top.js';
+import { parseGreetingArgs } from './greeting.js';
+
+class ParadiseFishStrategy extends GoalRootStrategy {
+  constructor(private readonly greetingPhrases: string[]) {
+    super('paradise-fish', () => new ParadiseFishTop(greetingPhrases), {
+      resetOnMeetingResume: false,
+    });
+  }
+
+  speechWarmupTexts(): string[] {
+    return this.greetingPhrases;
+  }
+}
+
+export const strategy: StrategyEntry = {
+  id: 'paradise-fish',
+  description:
+    '天堂鱼·进阶版（中立，不报警、不做任务，靠被投票出局取胜；corpse-patrol 的带记忆升级）。读取 ccl knowledge 两档标记（hostile=坏人 / trusted=好人），未标记的一律默认被怀疑：hostile 视为危险硬寻路远离，被怀疑者按目击者规则保持距离，trusted 视为可抱团的可信同伴。发现尸体绝不报警，贴着尸体游走制造嫌疑；附近有人时远离那人但仍在尸体附近活动。残局（已知存活≤6）出现紧急维修任务时，会在没有带刀坏人需要躲避时优先抢着去做（先于对陌生人保持距离/贴尸/抱团），阻止蟹靠破坏倒计时取胜。传入打招呼话术时，视野内出现人就随机发送一条，之后120秒内不再发言。',
+  create(args?: string[]) {
+    return new ParadiseFishStrategy(parseGreetingArgs(args, 'paradise-fish'));
+  },
+};

package/src/strategies/pathfind/distance-field.ts

@@ -1,150 +1,150 @@
-import type { WalkableGrid } from './walkable-grid.js';
-
-// Geodesic distance field over the walkable grid, integer octile costs:
-// straight 5, diagonal 7 (~1:1.4). One tile = 4px = 5 units.
-export const COST_STRAIGHT = 5;
-export const COST_DIAG = 7;
-export const UNITS_PER_PX = COST_STRAIGHT / 4;
-export const PX_PER_UNIT = 4 / COST_STRAIGHT;
-
-export interface FieldResult {
-  /** Geodesic cost in units from the source; Infinity if unreached. Valid until the next compute(). */
-  distOf(cell: number): number;
-  /** Per angle bucket, the farthest settled cell with dist <= ringUnits; -1 for empty buckets. */
-  ringCandidates: Int32Array;
-}
-
-export class FieldCalculator {
-  private readonly dist: Int32Array;
-  private readonly stamp: Int32Array;
-  private gen = 0;
-  private source = -1;
-
-  constructor(private readonly grid: WalkableGrid) {
-    this.dist = new Int32Array(grid.width * grid.height);
-    this.stamp = new Int32Array(grid.width * grid.height);
-  }
-
-  /**
-   * Dial's-bucket Dijkstra from sourceCell, settling cells up to maxCostUnits.
-   * Diagonal steps require both orthogonal neighbors walkable (no corner
-   * cutting, matching the server's supercover line checks).
-   */
-  compute(sourceCell: number, maxCostUnits: number, ringUnits: number, bucketCount = 16): FieldResult {
-    const { grid, dist, stamp } = this;
-    const W = grid.width;
-    this.gen++;
-    this.source = sourceCell;
-    const gen = this.gen;
-
-    const ringCandidates = new Int32Array(bucketCount).fill(-1);
-    const ringDist = new Int32Array(bucketCount).fill(-1);
-    const sx = sourceCell % W;
-    const sy = Math.floor(sourceCell / W);
-
-    const buckets: (number[] | undefined)[] = new Array(maxCostUnits + COST_DIAG + 1);
-    dist[sourceCell] = 0;
-    stamp[sourceCell] = gen;
-    buckets[0] = [sourceCell];
-
-    for (let c = 0; c <= maxCostUnits; c++) {
-      const bucket = buckets[c];
-      if (!bucket) continue;
-      for (const cell of bucket) {
-        if (dist[cell] !== c || stamp[cell] !== gen) continue; // stale entry
-        const tx = cell % W;
-        const ty = Math.floor(cell / W);
-        if (c > 0 && c <= ringUnits) {
-          const b = Math.floor(((Math.atan2(ty - sy, tx - sx) + Math.PI) / (2 * Math.PI)) * bucketCount) % bucketCount;
-          if (c > ringDist[b]) {
-            ringDist[b] = c;
-            ringCandidates[b] = cell;
-          }
-        }
-        const e = grid.isWalkable(tx + 1, ty);
-        const w = grid.isWalkable(tx - 1, ty);
-        const s = grid.isWalkable(tx, ty + 1);
-        const n = grid.isWalkable(tx, ty - 1);
-        this.relax(cell + 1, c + COST_STRAIGHT, e, buckets, gen);
-        this.relax(cell - 1, c + COST_STRAIGHT, w, buckets, gen);
-        this.relax(cell + W, c + COST_STRAIGHT, s, buckets, gen);
-        this.relax(cell - W, c + COST_STRAIGHT, n, buckets, gen);
-        this.relax(cell + W + 1, c + COST_DIAG, e && s && grid.isWalkable(tx + 1, ty + 1), buckets, gen);
-        this.relax(cell + W - 1, c + COST_DIAG, w && s && grid.isWalkable(tx - 1, ty + 1), buckets, gen);
-        this.relax(cell - W + 1, c + COST_DIAG, e && n && grid.isWalkable(tx + 1, ty - 1), buckets, gen);
-        this.relax(cell - W - 1, c + COST_DIAG, w && n && grid.isWalkable(tx - 1, ty - 1), buckets, gen);
-      }
-      buckets[c] = undefined;
-    }
-
-    const distOf = (cell: number) => (stamp[cell] === gen ? dist[cell] : Infinity);
-    return { distOf, ringCandidates };
-  }
-
-  private relax(cell: number, cost: number, walkable: boolean, buckets: (number[] | undefined)[], gen: number): void {
-    if (!walkable) return;
-    if (this.stamp[cell] === gen && this.dist[cell] <= cost) return;
-    this.dist[cell] = cost;
-    this.stamp[cell] = gen;
-    (buckets[cost] ??= []).push(cell);
-  }
-
-  /**
-   * Walk from fromCell down the latest field's gradient toward its source,
-   * stopping once >= budgetUnits is spent (the last step may overshoot).
-   * Unreached cells stay frozen in place. Returns visited cells incl. ends.
-   */
-  descend(fromCell: number, budgetUnits: number): { end: number; cells: number[] } {
-    const cells = [fromCell];
-    if (this.distOfCurrent(fromCell) === Infinity) return { end: fromCell, cells };
-    let cur = fromCell;
-    let spent = 0;
-    while (spent < budgetUnits && this.distOfCurrent(cur) > 0) {
-      const next = this.bestNeighbor(cur);
-      if (next < 0) break;
-      spent += this.distOfCurrent(cur) - this.distOfCurrent(next);
-      cur = next;
-      cells.push(cur);
-    }
-    return { end: cur, cells };
-  }
-
-  /** Shrimp step path: cells from the latest field's source to fromCell. */
-  pathToSource(fromCell: number): number[] {
-    return this.descend(fromCell, Number.MAX_SAFE_INTEGER).cells.reverse();
-  }
-
-  private distOfCurrent(cell: number): number {
-    return this.stamp[cell] === this.gen ? this.dist[cell] : Infinity;
-  }
-
-  private bestNeighbor(cell: number): number {
-    const { grid } = this;
-    const W = grid.width;
-    const tx = cell % W;
-    const ty = Math.floor(cell / W);
-    const e = grid.isWalkable(tx + 1, ty);
-    const w = grid.isWalkable(tx - 1, ty);
-    const s = grid.isWalkable(tx, ty + 1);
-    const n = grid.isWalkable(tx, ty - 1);
-    let best = -1;
-    let bestDist = this.distOfCurrent(cell);
-    const consider = (c: number, walkable: boolean) => {
-      if (!walkable) return;
-      const d = this.distOfCurrent(c);
-      if (d < bestDist) {
-        bestDist = d;
-        best = c;
-      }
-    };
-    consider(cell + 1, e);
-    consider(cell - 1, w);
-    consider(cell + W, s);
-    consider(cell - W, n);
-    consider(cell + W + 1, e && s && grid.isWalkable(tx + 1, ty + 1));
-    consider(cell + W - 1, w && s && grid.isWalkable(tx - 1, ty + 1));
-    consider(cell - W + 1, e && n && grid.isWalkable(tx + 1, ty - 1));
-    consider(cell - W - 1, w && n && grid.isWalkable(tx - 1, ty - 1));
-    return best;
-  }
-}
+import type { WalkableGrid } from './walkable-grid.js';
+
+// Geodesic distance field over the walkable grid, integer octile costs:
+// straight 5, diagonal 7 (~1:1.4). One tile = 4px = 5 units.
+export const COST_STRAIGHT = 5;
+export const COST_DIAG = 7;
+export const UNITS_PER_PX = COST_STRAIGHT / 4;
+export const PX_PER_UNIT = 4 / COST_STRAIGHT;
+
+export interface FieldResult {
+  /** Geodesic cost in units from the source; Infinity if unreached. Valid until the next compute(). */
+  distOf(cell: number): number;
+  /** Per angle bucket, the farthest settled cell with dist <= ringUnits; -1 for empty buckets. */
+  ringCandidates: Int32Array;
+}
+
+export class FieldCalculator {
+  private readonly dist: Int32Array;
+  private readonly stamp: Int32Array;
+  private gen = 0;
+  private source = -1;
+
+  constructor(private readonly grid: WalkableGrid) {
+    this.dist = new Int32Array(grid.width * grid.height);
+    this.stamp = new Int32Array(grid.width * grid.height);
+  }
+
+  /**
+   * Dial's-bucket Dijkstra from sourceCell, settling cells up to maxCostUnits.
+   * Diagonal steps require both orthogonal neighbors walkable (no corner
+   * cutting, matching the server's supercover line checks).
+   */
+  compute(sourceCell: number, maxCostUnits: number, ringUnits: number, bucketCount = 16): FieldResult {
+    const { grid, dist, stamp } = this;
+    const W = grid.width;
+    this.gen++;
+    this.source = sourceCell;
+    const gen = this.gen;
+
+    const ringCandidates = new Int32Array(bucketCount).fill(-1);
+    const ringDist = new Int32Array(bucketCount).fill(-1);
+    const sx = sourceCell % W;
+    const sy = Math.floor(sourceCell / W);
+
+    const buckets: (number[] | undefined)[] = new Array(maxCostUnits + COST_DIAG + 1);
+    dist[sourceCell] = 0;
+    stamp[sourceCell] = gen;
+    buckets[0] = [sourceCell];
+
+    for (let c = 0; c <= maxCostUnits; c++) {
+      const bucket = buckets[c];
+      if (!bucket) continue;
+      for (const cell of bucket) {
+        if (dist[cell] !== c || stamp[cell] !== gen) continue; // stale entry
+        const tx = cell % W;
+        const ty = Math.floor(cell / W);
+        if (c > 0 && c <= ringUnits) {
+          const b = Math.floor(((Math.atan2(ty - sy, tx - sx) + Math.PI) / (2 * Math.PI)) * bucketCount) % bucketCount;
+          if (c > ringDist[b]) {
+            ringDist[b] = c;
+            ringCandidates[b] = cell;
+          }
+        }
+        const e = grid.isWalkable(tx + 1, ty);
+        const w = grid.isWalkable(tx - 1, ty);
+        const s = grid.isWalkable(tx, ty + 1);
+        const n = grid.isWalkable(tx, ty - 1);
+        this.relax(cell + 1, c + COST_STRAIGHT, e, buckets, gen);
+        this.relax(cell - 1, c + COST_STRAIGHT, w, buckets, gen);
+        this.relax(cell + W, c + COST_STRAIGHT, s, buckets, gen);
+        this.relax(cell - W, c + COST_STRAIGHT, n, buckets, gen);
+        this.relax(cell + W + 1, c + COST_DIAG, e && s && grid.isWalkable(tx + 1, ty + 1), buckets, gen);
+        this.relax(cell + W - 1, c + COST_DIAG, w && s && grid.isWalkable(tx - 1, ty + 1), buckets, gen);
+        this.relax(cell - W + 1, c + COST_DIAG, e && n && grid.isWalkable(tx + 1, ty - 1), buckets, gen);
+        this.relax(cell - W - 1, c + COST_DIAG, w && n && grid.isWalkable(tx - 1, ty - 1), buckets, gen);
+      }
+      buckets[c] = undefined;
+    }
+
+    const distOf = (cell: number) => (stamp[cell] === gen ? dist[cell] : Infinity);
+    return { distOf, ringCandidates };
+  }
+
+  private relax(cell: number, cost: number, walkable: boolean, buckets: (number[] | undefined)[], gen: number): void {
+    if (!walkable) return;
+    if (this.stamp[cell] === gen && this.dist[cell] <= cost) return;
+    this.dist[cell] = cost;
+    this.stamp[cell] = gen;
+    (buckets[cost] ??= []).push(cell);
+  }
+
+  /**
+   * Walk from fromCell down the latest field's gradient toward its source,
+   * stopping once >= budgetUnits is spent (the last step may overshoot).
+   * Unreached cells stay frozen in place. Returns visited cells incl. ends.
+   */
+  descend(fromCell: number, budgetUnits: number): { end: number; cells: number[] } {
+    const cells = [fromCell];
+    if (this.distOfCurrent(fromCell) === Infinity) return { end: fromCell, cells };
+    let cur = fromCell;
+    let spent = 0;
+    while (spent < budgetUnits && this.distOfCurrent(cur) > 0) {
+      const next = this.bestNeighbor(cur);
+      if (next < 0) break;
+      spent += this.distOfCurrent(cur) - this.distOfCurrent(next);
+      cur = next;
+      cells.push(cur);
+    }
+    return { end: cur, cells };
+  }
+
+  /** Shrimp step path: cells from the latest field's source to fromCell. */
+  pathToSource(fromCell: number): number[] {
+    return this.descend(fromCell, Number.MAX_SAFE_INTEGER).cells.reverse();
+  }
+
+  private distOfCurrent(cell: number): number {
+    return this.stamp[cell] === this.gen ? this.dist[cell] : Infinity;
+  }
+
+  private bestNeighbor(cell: number): number {
+    const { grid } = this;
+    const W = grid.width;
+    const tx = cell % W;
+    const ty = Math.floor(cell / W);
+    const e = grid.isWalkable(tx + 1, ty);
+    const w = grid.isWalkable(tx - 1, ty);
+    const s = grid.isWalkable(tx, ty + 1);
+    const n = grid.isWalkable(tx, ty - 1);
+    let best = -1;
+    let bestDist = this.distOfCurrent(cell);
+    const consider = (c: number, walkable: boolean) => {
+      if (!walkable) return;
+      const d = this.distOfCurrent(c);
+      if (d < bestDist) {
+        bestDist = d;
+        best = c;
+      }
+    };
+    consider(cell + 1, e);
+    consider(cell - 1, w);
+    consider(cell + W, s);
+    consider(cell - W, n);
+    consider(cell + W + 1, e && s && grid.isWalkable(tx + 1, ty + 1));
+    consider(cell + W - 1, w && s && grid.isWalkable(tx - 1, ty + 1));
+    consider(cell - W + 1, e && n && grid.isWalkable(tx + 1, ty - 1));
+    consider(cell - W - 1, w && n && grid.isWalkable(tx - 1, ty - 1));
+    return best;
+  }
+}