@myclaw163/clawclaw-cli 0.6.64 → 0.6.66

package/src/strategies/pathfind/escape-planner.test.ts

@@ -1,197 +1,197 @@
-import { describe, expect, it } from 'vitest';
-import type { Position } from '../../sdk/types.js';
-import { FieldCalculator, PX_PER_UNIT, UNITS_PER_PX } from './distance-field.js';
-import { planEscape, type EscapeOptions } from './escape-planner.js';
-import { loadWalkableGrid } from './walkable-grid.js';
-
-const grid = loadWalkableGrid();
-const sampleCells = collectWalkableCells(3);
-
-const stressOpts = {
-  steps: 4,
-  stepDist: 144,
-  killRange: 80,
-  beamWidth: 6,
-  fieldRadius: 720,
-  directions: 12,
-} satisfies EscapeOptions;
-
-interface Scenario {
-  name: string;
-  shrimp: Position;
-  crabs: Position[];
-}
-
-function collectWalkableCells(stride: number): number[] {
-  const cells: number[] = [];
-  for (let ty = 0; ty < grid.height; ty += stride) {
-    for (let tx = 0; tx < grid.width; tx += stride) {
-      const cell = ty * grid.width + tx;
-      if (grid.isWalkableCell(cell)) cells.push(cell);
-    }
-  }
-  return cells;
-}
-
-function makeRng(seed: number): () => number {
-  let state = seed >>> 0;
-  return () => {
-    state = (state * 1664525 + 1013904223) >>> 0;
-    return state / 0x100000000;
-  };
-}
-
-function randomCell(rng: () => number): number {
-  return sampleCells[Math.floor(rng() * sampleCells.length)];
-}
-
-function toCell(pos: Position): number {
-  return grid.snapToWalkable(grid.worldToCell(pos.x, pos.y));
-}
-
-function expectWalkablePosition(pos: Position): void {
-  const cell = toCell(pos);
-  expect(cell).toBeGreaterThanOrEqual(0);
-  expect(grid.isWalkableCell(cell)).toBe(true);
-}
-
-function nearbyCells(source: number, minPx: number, maxPx: number, rng: () => number, limit: number): number[] {
-  const calc = new FieldCalculator(grid);
-  const maxUnits = Math.round(maxPx * UNITS_PER_PX);
-  const minUnits = Math.round(minPx * UNITS_PER_PX);
-  const field = calc.compute(source, maxUnits, maxUnits, 8);
-  const start = Math.floor(rng() * sampleCells.length);
-  const cells: number[] = [];
-
-  for (let i = 0; i < sampleCells.length && cells.length < limit; i++) {
-    const cell = sampleCells[(start + i) % sampleCells.length];
-    const dist = field.distOf(cell);
-    if (cell !== source && dist >= minUnits && dist <= maxUnits) cells.push(cell);
-  }
-
-  return cells;
-}
-
-function buildScenarios(): Scenario[] {
-  const rng = makeRng(0xdecafbad);
-  const scenarios: Scenario[] = [];
-
-  for (let i = 0; i < 48; i++) {
-    const crabCount = 1 + Math.floor(rng() * 4);
-    scenarios.push({
-      name: `global-${i}`,
-      shrimp: grid.cellToWorld(randomCell(rng)),
-      crabs: Array.from({ length: crabCount }, () => grid.cellToWorld(randomCell(rng))),
-    });
-  }
-
-  let localCount = 0;
-  for (let attempts = 0; localCount < 48 && attempts < 300; attempts++) {
-    const source = randomCell(rng);
-    const near = nearbyCells(source, 88, 360, rng, 32);
-    if (near.length < 4) continue;
-
-    const crabCount = 1 + (localCount % 4);
-    const crabs: Position[] = [];
-    for (let i = 0; i < crabCount; i++) {
-      const index = Math.floor(((i + 0.5) * near.length) / crabCount);
-      crabs.push(grid.cellToWorld(near[index]));
-    }
-
-    scenarios.push({
-      name: `local-${localCount}`,
-      shrimp: grid.cellToWorld(source),
-      crabs,
-    });
-    localCount++;
-  }
-
-  expect(localCount).toBe(48);
-  return scenarios;
-}
-
-function replayPlan(
-  shrimp: Position,
-  crabs: Position[],
-  path: Position[],
-  opts: typeof stressOpts,
-): { minCrabDistance: number; finalCell: number } {
-  const calc = new FieldCalculator(grid);
-  const stepUnits = Math.round(opts.stepDist * UNITS_PER_PX);
-  const radiusUnits = Math.round(opts.fieldRadius * UNITS_PER_PX);
-  let shrimpCell = toCell(shrimp);
-  let crabCells = crabs.map(toCell).filter(cell => cell >= 0);
-
-  for (const waypoint of path) {
-    const nextCell = toCell(waypoint);
-    const field = calc.compute(shrimpCell, radiusUnits, stepUnits, opts.directions);
-    const moveUnits = field.distOf(nextCell);
-    expect(moveUnits).toBeLessThanOrEqual(stepUnits);
-    crabCells = crabCells.map(cell => calc.descend(cell, stepUnits).end);
-    shrimpCell = nextCell;
-  }
-
-  const finalField = calc.compute(shrimpCell, radiusUnits, stepUnits, opts.directions);
-  const minUnits =
-    crabCells.length > 0 ? Math.min(...crabCells.map(cell => Math.min(finalField.distOf(cell), radiusUnits))) : Infinity;
-  return { minCrabDistance: minUnits * PX_PER_UNIT, finalCell: shrimpCell };
-}
-
-function expectPlanShape(plan: ReturnType<typeof planEscape>, opts: typeof stressOpts): void {
-  expect(plan.survivedSteps).toBeGreaterThanOrEqual(0);
-  expect(plan.survivedSteps).toBeLessThanOrEqual(opts.steps);
-  expect(plan.path).toHaveLength(plan.survivedSteps);
-  expect(Number.isNaN(plan.minCrabDistance)).toBe(false);
-  expectWalkablePosition(plan.target);
-  for (const waypoint of plan.path) expectWalkablePosition(waypoint);
-
-  if (plan.survivedSteps > 0) {
-    expect(plan.target).toEqual(plan.path[plan.path.length - 1]);
-  }
-  if (plan.caught) {
-    expect(plan.survivedSteps).toBeLessThan(opts.steps);
-  } else {
-    expect(plan.survivedSteps).toBe(opts.steps);
-  }
-}
-
-describe('planEscape', () => {
-  it('plans a full horizon with infinite safety when there are no crabs', () => {
-    const start = grid.cellToWorld(sampleCells[Math.floor(sampleCells.length / 2)]);
-    const plan = planEscape(start, [], stressOpts);
-
-    expect(plan.caught).toBe(false);
-    expect(plan.survivedSteps).toBe(stressOpts.steps);
-    expect(plan.path).toHaveLength(stressOpts.steps);
-    expect(plan.minCrabDistance).toBe(Infinity);
-    expectPlanShape(plan, stressOpts);
-  });
-
-  it('reports no survived step when crabs already occupy the shrimp tile', () => {
-    const start = grid.cellToWorld(sampleCells[Math.floor(sampleCells.length / 3)]);
-    const plan = planEscape(start, [start, start, start, start], stressOpts);
-
-    expect(plan.caught).toBe(true);
-    expect(plan.survivedSteps).toBe(0);
-    expect(plan.path).toEqual([]);
-    expect(plan.minCrabDistance).toBe(0);
-    expectPlanShape(plan, stressOpts);
-  });
-
-  it('keeps movement and distance invariants across seeded global and local pressure cases', () => {
-    const scenarios = buildScenarios();
-    expect(scenarios).toHaveLength(96);
-
-    for (const scenario of scenarios) {
-      const plan = planEscape(scenario.shrimp, scenario.crabs, stressOpts);
-      const replay = replayPlan(scenario.shrimp, scenario.crabs, plan.path, stressOpts);
-
-      expectPlanShape(plan, stressOpts);
-      expect(toCell(plan.target), scenario.name).toBe(replay.finalCell);
-      expect(plan.minCrabDistance, scenario.name).toBeCloseTo(replay.minCrabDistance, 5);
-      if (!plan.caught) {
-        expect(plan.minCrabDistance, scenario.name).toBeGreaterThan(stressOpts.killRange);
-      }
-    }
-  }, 15_000);
-});
+import { describe, expect, it } from 'vitest';
+import type { Position } from '../../sdk/types.js';
+import { FieldCalculator, PX_PER_UNIT, UNITS_PER_PX } from './distance-field.js';
+import { planEscape, type EscapeOptions } from './escape-planner.js';
+import { loadWalkableGrid } from './walkable-grid.js';
+
+const grid = loadWalkableGrid();
+const sampleCells = collectWalkableCells(3);
+
+const stressOpts = {
+  steps: 4,
+  stepDist: 144,
+  killRange: 80,
+  beamWidth: 6,
+  fieldRadius: 720,
+  directions: 12,
+} satisfies EscapeOptions;
+
+interface Scenario {
+  name: string;
+  shrimp: Position;
+  crabs: Position[];
+}
+
+function collectWalkableCells(stride: number): number[] {
+  const cells: number[] = [];
+  for (let ty = 0; ty < grid.height; ty += stride) {
+    for (let tx = 0; tx < grid.width; tx += stride) {
+      const cell = ty * grid.width + tx;
+      if (grid.isWalkableCell(cell)) cells.push(cell);
+    }
+  }
+  return cells;
+}
+
+function makeRng(seed: number): () => number {
+  let state = seed >>> 0;
+  return () => {
+    state = (state * 1664525 + 1013904223) >>> 0;
+    return state / 0x100000000;
+  };
+}
+
+function randomCell(rng: () => number): number {
+  return sampleCells[Math.floor(rng() * sampleCells.length)];
+}
+
+function toCell(pos: Position): number {
+  return grid.snapToWalkable(grid.worldToCell(pos.x, pos.y));
+}
+
+function expectWalkablePosition(pos: Position): void {
+  const cell = toCell(pos);
+  expect(cell).toBeGreaterThanOrEqual(0);
+  expect(grid.isWalkableCell(cell)).toBe(true);
+}
+
+function nearbyCells(source: number, minPx: number, maxPx: number, rng: () => number, limit: number): number[] {
+  const calc = new FieldCalculator(grid);
+  const maxUnits = Math.round(maxPx * UNITS_PER_PX);
+  const minUnits = Math.round(minPx * UNITS_PER_PX);
+  const field = calc.compute(source, maxUnits, maxUnits, 8);
+  const start = Math.floor(rng() * sampleCells.length);
+  const cells: number[] = [];
+
+  for (let i = 0; i < sampleCells.length && cells.length < limit; i++) {
+    const cell = sampleCells[(start + i) % sampleCells.length];
+    const dist = field.distOf(cell);
+    if (cell !== source && dist >= minUnits && dist <= maxUnits) cells.push(cell);
+  }
+
+  return cells;
+}
+
+function buildScenarios(): Scenario[] {
+  const rng = makeRng(0xdecafbad);
+  const scenarios: Scenario[] = [];
+
+  for (let i = 0; i < 48; i++) {
+    const crabCount = 1 + Math.floor(rng() * 4);
+    scenarios.push({
+      name: `global-${i}`,
+      shrimp: grid.cellToWorld(randomCell(rng)),
+      crabs: Array.from({ length: crabCount }, () => grid.cellToWorld(randomCell(rng))),
+    });
+  }
+
+  let localCount = 0;
+  for (let attempts = 0; localCount < 48 && attempts < 300; attempts++) {
+    const source = randomCell(rng);
+    const near = nearbyCells(source, 88, 360, rng, 32);
+    if (near.length < 4) continue;
+
+    const crabCount = 1 + (localCount % 4);
+    const crabs: Position[] = [];
+    for (let i = 0; i < crabCount; i++) {
+      const index = Math.floor(((i + 0.5) * near.length) / crabCount);
+      crabs.push(grid.cellToWorld(near[index]));
+    }
+
+    scenarios.push({
+      name: `local-${localCount}`,
+      shrimp: grid.cellToWorld(source),
+      crabs,
+    });
+    localCount++;
+  }
+
+  expect(localCount).toBe(48);
+  return scenarios;
+}
+
+function replayPlan(
+  shrimp: Position,
+  crabs: Position[],
+  path: Position[],
+  opts: typeof stressOpts,
+): { minCrabDistance: number; finalCell: number } {
+  const calc = new FieldCalculator(grid);
+  const stepUnits = Math.round(opts.stepDist * UNITS_PER_PX);
+  const radiusUnits = Math.round(opts.fieldRadius * UNITS_PER_PX);
+  let shrimpCell = toCell(shrimp);
+  let crabCells = crabs.map(toCell).filter(cell => cell >= 0);
+
+  for (const waypoint of path) {
+    const nextCell = toCell(waypoint);
+    const field = calc.compute(shrimpCell, radiusUnits, stepUnits, opts.directions);
+    const moveUnits = field.distOf(nextCell);
+    expect(moveUnits).toBeLessThanOrEqual(stepUnits);
+    crabCells = crabCells.map(cell => calc.descend(cell, stepUnits).end);
+    shrimpCell = nextCell;
+  }
+
+  const finalField = calc.compute(shrimpCell, radiusUnits, stepUnits, opts.directions);
+  const minUnits =
+    crabCells.length > 0 ? Math.min(...crabCells.map(cell => Math.min(finalField.distOf(cell), radiusUnits))) : Infinity;
+  return { minCrabDistance: minUnits * PX_PER_UNIT, finalCell: shrimpCell };
+}
+
+function expectPlanShape(plan: ReturnType<typeof planEscape>, opts: typeof stressOpts): void {
+  expect(plan.survivedSteps).toBeGreaterThanOrEqual(0);
+  expect(plan.survivedSteps).toBeLessThanOrEqual(opts.steps);
+  expect(plan.path).toHaveLength(plan.survivedSteps);
+  expect(Number.isNaN(plan.minCrabDistance)).toBe(false);
+  expectWalkablePosition(plan.target);
+  for (const waypoint of plan.path) expectWalkablePosition(waypoint);
+
+  if (plan.survivedSteps > 0) {
+    expect(plan.target).toEqual(plan.path[plan.path.length - 1]);
+  }
+  if (plan.caught) {
+    expect(plan.survivedSteps).toBeLessThan(opts.steps);
+  } else {
+    expect(plan.survivedSteps).toBe(opts.steps);
+  }
+}
+
+describe('planEscape', () => {
+  it('plans a full horizon with infinite safety when there are no crabs', () => {
+    const start = grid.cellToWorld(sampleCells[Math.floor(sampleCells.length / 2)]);
+    const plan = planEscape(start, [], stressOpts);
+
+    expect(plan.caught).toBe(false);
+    expect(plan.survivedSteps).toBe(stressOpts.steps);
+    expect(plan.path).toHaveLength(stressOpts.steps);
+    expect(plan.minCrabDistance).toBe(Infinity);
+    expectPlanShape(plan, stressOpts);
+  });
+
+  it('reports no survived step when crabs already occupy the shrimp tile', () => {
+    const start = grid.cellToWorld(sampleCells[Math.floor(sampleCells.length / 3)]);
+    const plan = planEscape(start, [start, start, start, start], stressOpts);
+
+    expect(plan.caught).toBe(true);
+    expect(plan.survivedSteps).toBe(0);
+    expect(plan.path).toEqual([]);
+    expect(plan.minCrabDistance).toBe(0);
+    expectPlanShape(plan, stressOpts);
+  });
+
+  it('keeps movement and distance invariants across seeded global and local pressure cases', () => {
+    const scenarios = buildScenarios();
+    expect(scenarios).toHaveLength(96);
+
+    for (const scenario of scenarios) {
+      const plan = planEscape(scenario.shrimp, scenario.crabs, stressOpts);
+      const replay = replayPlan(scenario.shrimp, scenario.crabs, plan.path, stressOpts);
+
+      expectPlanShape(plan, stressOpts);
+      expect(toCell(plan.target), scenario.name).toBe(replay.finalCell);
+      expect(plan.minCrabDistance, scenario.name).toBeCloseTo(replay.minCrabDistance, 5);
+      if (!plan.caught) {
+        expect(plan.minCrabDistance, scenario.name).toBeGreaterThan(stressOpts.killRange);
+      }
+    }
+  }, 15_000);
+});