@nayan-ui/games 1.20.0 → 1.21.0

package/src/games/treasure-hunt/TreasureHuntRules.ts

@@ -1,1210 +0,0 @@
-import { type Quat } from '@nayan-ui/engine';
-// Treasure Hunt: Seeded terrain, collision and game rules; independent of the native renderer.
-import {
-  ATTACK_COOLDOWN,
-  ATTACK_HIT_TIME,
-  ATTACK_RANGE,
-  ENEMY_COUNT,
-  GEM_GOAL,
-  HUMAN_HEIGHT,
-  MAX_HEALTH,
-  MINIMAP_SIZE,
-  MOVEMENT_START,
-  MOVEMENT_STOP,
-  PLAYER_RADIUS,
-  PLAYER_SPEED,
-  type Point,
-  POINTS_GEM,
-  POINTS_HEALTH_BONUS,
-  POINTS_ROBOT_DEFEAT,
-  POINTS_ROBOT_HIT,
-  TERRAIN_PROFILES,
-  WORLD_EDGE
-} from './TreasureHuntConstants';
-
-// Scenery collision shapes.
-
-export const SOLID_CELL = 8;
-
-const INDEX_MARGIN = 1.5;
-
-export const ROCK_RINGS = 12;
-
-export const ROCK_SIDES = 18;
-
-export const CAVE_INNER_WIDTH = 3.5;
-
-export const CAVE_INNER_HEIGHT = 4.8;
-
-export const BRIDGE_RAIL_INSET = 0.15;
-
-export const BRIDGE_RAIL_DEPTH = 0.09;
-
-export const BRIDGE_POST_WIDTH = 0.3;
-
-export const BRIDGE_POST_HEIGHT = 1.12;
-
-export type SolidTag = 'tree' | 'rock' | 'bridge-rail' | 'bridge-post';
-
-interface SolidBounds extends Point {
-  tag: SolidTag;
-  bottom: number;
-  top: number;
-  minX: number;
-  maxX: number;
-  minZ: number;
-  maxZ: number;
-}
-
-export type Solid = SolidBounds & ({ shape: 'circle'; radius: number } | { shape: 'polygon'; points: Point[] });
-
-export type SolidCells = Map<string, Solid[]>;
-
-/** Shared surface samples keep rendered boulders and their collision hulls in agreement. */
-export function rockSurface(style: number, a: number, b: number) {
-  const rough = 1 + Math.sin(a * 3 + b * 5 + style) * 0.12 + Math.cos(a * 7 - b * 3) * 0.05;
-  const normal: [number, number, number] = [Math.sin(b) * Math.cos(a), Math.cos(b), Math.sin(b) * Math.sin(a)];
-  const position: [number, number, number] = [normal[0] * rough, Math.max(-0.2, normal[1] * rough * 0.8 + 0.45), normal[2] * rough * 0.9];
-  return { position, normal };
-}
-
-const rockHulls = new Map<number, { points: Point[]; bottom: number; top: number }>();
-
-function rockHull(style: number) {
-  const cached = rockHulls.get(style);
-  if (cached) return cached;
-  const points: Point[] = [];
-  let bottom = Infinity,
-    top = -Infinity;
-  for (let ring = 0; ring <= ROCK_RINGS; ring++)
-    for (let side = 0; side < ROCK_SIDES; side++) {
-      const {
-        position: [x, y, z]
-      } = rockSurface(style, (side / ROCK_SIDES) * Math.PI * 2, (ring / ROCK_RINGS) * Math.PI);
-      points.push({ x, z });
-      bottom = Math.min(bottom, y);
-      top = Math.max(top, y);
-    }
-  points.sort((a, b) => a.x - b.x || a.z - b.z);
-  const cross = (a: Point, b: Point, c: Point) => (b.x - a.x) * (c.z - a.z) - (b.z - a.z) * (c.x - a.x);
-  const half = (input: Point[]) => {
-    const result: Point[] = [];
-    for (const p of input) {
-      while (result.length > 1 && cross(result[result.length - 2]!, result[result.length - 1]!, p) <= 0) result.pop();
-      result.push(p);
-    }
-    result.pop();
-    return result;
-  };
-  const hull = { points: [...half(points), ...half([...points].reverse())], bottom, top };
-  rockHulls.set(style, hull);
-  return hull;
-}
-
-export function circleSolid(tag: SolidTag, x: number, z: number, radius: number, bottom: number, top: number): Solid {
-  return { shape: 'circle', tag, x, z, radius, bottom, top, minX: x - radius, maxX: x + radius, minZ: z - radius, maxZ: z + radius };
-}
-
-function polygonSolid(tag: SolidTag, x: number, z: number, points: Point[], bottom: number, top: number): Solid {
-  return {
-    shape: 'polygon',
-    tag,
-    x,
-    z,
-    points,
-    bottom,
-    top,
-    minX: Math.min(...points.map((p) => p.x)),
-    maxX: Math.max(...points.map((p) => p.x)),
-    minZ: Math.min(...points.map((p) => p.z)),
-    maxZ: Math.max(...points.map((p) => p.z))
-  };
-}
-
-export function boxSolid(tag: SolidTag, x: number, z: number, halfX: number, halfZ: number, yaw: number, bottom: number, top: number) {
-  const cos = Math.cos(yaw),
-    sin = Math.sin(yaw);
-  const points = [
-    [-halfX, -halfZ],
-    [halfX, -halfZ],
-    [halfX, halfZ],
-    [-halfX, halfZ]
-  ].map(([u, v]) => ({ x: x + cos * u! + sin * v!, z: z - sin * u! + cos * v! }));
-  return polygonSolid(tag, x, z, points, bottom, top);
-}
-
-export function rockSolid(x: number, y: number, z: number, scale: readonly [number, number, number], yaw: number, style: number) {
-  const hull = rockHull(style),
-    cos = Math.cos(yaw),
-    sin = Math.sin(yaw);
-  const points = hull.points.map((p) => ({ x: x + cos * p.x * scale[0] + sin * p.z * scale[2], z: z - sin * p.x * scale[0] + cos * p.z * scale[2] }));
-  return polygonSolid('rock', x, z, points, y + hull.bottom * scale[1], y + hull.top * scale[1]);
-}
-
-/** Signed distance to the full visible footprint, including rounded corners around an actor. */
-export function solidDistance(solid: Solid, x: number, z: number) {
-  if (solid.shape === 'circle') return Math.hypot(x - solid.x, z - solid.z) - solid.radius;
-  let distance2 = Infinity,
-    inside = true;
-  for (let i = 0; i < solid.points.length; i++) {
-    const a = solid.points[i]!,
-      b = solid.points[(i + 1) % solid.points.length]!;
-    const dx = b.x - a.x,
-      dz = b.z - a.z,
-      length2 = dx * dx + dz * dz;
-    if (dx * (z - a.z) - dz * (x - a.x) < -1e-10) inside = false;
-    const t = Math.max(0, Math.min(1, ((x - a.x) * dx + (z - a.z) * dz) / length2));
-    distance2 = Math.min(distance2, (x - a.x - dx * t) ** 2 + (z - a.z - dz * t) ** 2);
-  }
-  return Math.sqrt(distance2) * (inside ? -1 : 1);
-}
-
-export function indexSolid(cells: SolidCells, solid: Solid) {
-  for (let ix = Math.floor((solid.minX - INDEX_MARGIN) / SOLID_CELL); ix <= Math.floor((solid.maxX + INDEX_MARGIN) / SOLID_CELL); ix++)
-    for (let iz = Math.floor((solid.minZ - INDEX_MARGIN) / SOLID_CELL); iz <= Math.floor((solid.maxZ + INDEX_MARGIN) / SOLID_CELL); iz++) {
-      const key = `${ix},${iz}`,
-        bucket = cells.get(key) ?? [];
-      bucket.push(solid);
-      cells.set(key, bucket);
-    }
-}
-
-export function solidClearance(cells: SolidCells, x: number, z: number, radius: number, bottom: number, top: number) {
-  let clearance = Infinity;
-  for (const solid of cells.get(`${Math.floor(x / SOLID_CELL)},${Math.floor(z / SOLID_CELL)}`) ?? []) {
-    if (solid.top <= bottom + 0.001 || solid.bottom >= top) continue;
-    clearance = Math.min(clearance, solidDistance(solid, x, z) - radius);
-  }
-  return clearance;
-}
-
-export interface BridgeBarrier extends Point {
-  kind: 'rail' | 'post';
-  halfX: number;
-  halfZ: number;
-}
-
-/** The renderer and collision system share every railing and post position. */
-export function bridgeBarriers(bridge: { halfLength: number; halfWidth: number }): BridgeBarrier[] {
-  const result: BridgeBarrier[] = [];
-  for (const side of [-1, 1]) {
-    const z = side * (bridge.halfWidth - BRIDGE_RAIL_INSET);
-    result.push({ kind: 'rail', x: 0, z, halfX: bridge.halfLength, halfZ: BRIDGE_RAIL_DEPTH / 2 });
-    for (let x = -bridge.halfLength + 0.2; x <= bridge.halfLength; x += 2)
-      result.push({ kind: 'post', x, z, halfX: BRIDGE_POST_WIDTH / 2, halfZ: BRIDGE_POST_WIDTH / 2 });
-  }
-  return result;
-}
-// Seeded terrain and navigation.
-
-export interface Hill extends Point {
-  height: number;
-  width: number;
-  depth: number;
-  yaw: number;
-}
-
-export interface Cave extends Point {
-  y: number;
-  length: number;
-}
-
-export interface Bridge extends Point {
-  halfLength: number;
-  halfWidth: number;
-  y: number;
-}
-
-export type TerrainSurface = 'grass' | 'hill' | 'river' | 'shore' | 'cave' | 'bridge';
-
-export const TERRAIN_STEP = 1.6;
-
-// A coarse outer apron supports distant scenery while the playable ground keeps its fine grid.
-export const TERRAIN_EDGE = WORLD_EDGE + 48;
-
-const APRON_CELLS = 8;
-
-const PLAYABLE_CELLS = Math.round((WORLD_EDGE * 2) / TERRAIN_STEP);
-
-export const TERRAIN_GRID = Float32Array.from([
-  ...Array.from({ length: APRON_CELLS }, (_, i) => -TERRAIN_EDGE + i * 6),
-  ...Array.from({ length: PLAYABLE_CELLS + 1 }, (_, i) => -WORLD_EDGE + (i * WORLD_EDGE * 2) / PLAYABLE_CELLS),
-  ...Array.from({ length: APRON_CELLS }, (_, i) => WORLD_EDGE + (i + 1) * 6)
-]);
-
-const terrainSamples = new WeakMap<Landscape, Float32Array>();
-
-export interface NatureProp extends Point {
-  kind: 'pine' | 'birch' | 'rock';
-  scale: number;
-  yaw: number;
-  style: number;
-}
-
-export interface NatureDecoration extends Point {
-  kind: 'rock' | 'pine';
-  area: 'horizon' | 'cave-roof' | 'cave-entrance';
-  y: number;
-  scale: [number, number, number];
-  yaw: number;
-  style: number;
-}
-
-export interface Landscape {
-  profile: number;
-  phase: number;
-  hills: Hill[];
-  caves: Cave[];
-  bridges: Bridge[];
-}
-
-export interface NatureMap {
-  seed: number;
-  edge: number;
-  rotation: number;
-  landscape: Landscape;
-  spawn: Point;
-  props: NatureProp[];
-  decorations: NatureDecoration[];
-  obstacleCells: SolidCells;
-  reachable: Point[];
-  gems: Point[];
-  enemies: Point[];
-}
-
-let cursor = (Math.random() * 0xffffffff) >>> 0;
-
-export function random(seed: number) {
-  let value = seed >>> 0;
-  return () => {
-    value += 0x6d2b79f5;
-    let t = Math.imul(value ^ (value >>> 15), 1 | value);
-    t ^= t + Math.imul(t ^ (t >>> 7), 61 | t);
-    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-  };
-}
-
-const profiles = new Map<number, Landscape>();
-const hillAxes = new WeakMap<Landscape, { hill: Hill; cos: number; sin: number }[]>();
-const rotations = new WeakMap<object, { angle: number; cos: number; sin: number }>();
-// The centre plus the same eight footprint samples used by collision and navigation.
-const FOOTPRINT = Array.from({ length: 9 }, (_, i) => {
-  const angle = ((i - 1) / 8) * Math.PI * 2;
-  return [i ? Math.cos(angle) : 0, i ? Math.sin(angle) : 0] as const;
-});
-
-const smooth = (n: number) => {
-  const t = Math.max(0, Math.min(1, n));
-  return t * t * (3 - 2 * t);
-};
-
-const gap = (a: Point, b: Point) => Math.hypot(a.x - b.x, a.z - b.z);
-
-/** Bounded geometry library: native mesh IDs live for the app's lifetime. Seeds also rotate the
- * landscape and independently scatter vegetation, formations, enemies and treasure each run. */
-export function landscapeFor(profile: number): Landscape {
-  const cached = profiles.get(profile);
-  if (cached) return cached;
-  const rng = random(profile * 7919 + 314159);
-  const landscape: Landscape = {
-    profile,
-    phase: rng() * Math.PI * 2,
-    hills: Array.from({ length: 9 }, (_, i) => ({
-      x: (i % 2 ? -1 : 1) * (34 + rng() * 65),
-      z: -95 + rng() * 190,
-      height: 2 + rng() * 4,
-      width: 16 + rng() * 22,
-      depth: 16 + rng() * 22,
-      yaw: rng() * Math.PI * 2
-    })),
-    caves: [],
-    bridges: []
-  };
-  for (const [x, z] of [
-    [-36 - rng() * 12, 15 + rng() * 13],
-    [47 + rng() * 12, -45 + rng() * 12]
-  ]) {
-    const cave = { x: x!, z: z!, y: waterLevel(landscape, z!) + 1 + meadowRolling(landscape, x!, z!), length: 20 };
-    landscape.caves.push(cave);
-  }
-  for (const z of [-46, -2, 58])
-    landscape.bridges.push({
-      x: riverX(landscape, z),
-      z,
-      halfLength: riverWidth(landscape, z) + 4.5,
-      halfWidth: 2.8,
-      y: waterLevel(landscape, z) + 1.08
-    });
-  profiles.set(profile, landscape);
-  return landscape;
-}
-
-export function riverX(landscape: Landscape, z: number) {
-  return 10 + Math.sin(z * 0.035 + landscape.phase) * 11 + Math.sin(z * 0.073) * 2;
-}
-
-export function riverWidth(landscape: Landscape, z: number) {
-  return 4.8 + Math.sin(z * 0.05 + landscape.phase) * 0.6;
-}
-
-export function waterLevel(_landscape: Landscape, z: number) {
-  return 0.018 * z;
-}
-
-/** Compact rocky hills leave broad, gently rolling grassland between their distinct foothills. */
-export function hillRise(landscape: Landscape, x: number, z: number) {
-  let axes = hillAxes.get(landscape);
-  if (!axes) {
-    axes = landscape.hills.map((hill) => ({ hill, cos: Math.cos(hill.yaw), sin: Math.sin(hill.yaw) }));
-    hillAxes.set(landscape, axes);
-  }
-  let height = 0;
-  for (const { hill, cos, sin } of axes) {
-    const radius = hill.width * 0.8;
-    const dx = x - hill.x,
-      dz = z - hill.z;
-    const u = (dx * cos + dz * sin) / radius,
-      v = (-dx * sin + dz * cos) / (hill.depth * 0.8);
-    const influence = Math.max(0, 1 - u * u - v * v);
-    height += hill.height * influence ** 2;
-  }
-  // Most of the map is open meadow. Fading a zero hill contribution cannot change its height.
-  const edge = 6 * smooth((Math.hypot(x, z) - 111) / 17);
-  if (height === 0) return edge;
-  const bankDistance = Math.abs(x - riverX(landscape, z)) - riverWidth(landscape, z);
-  for (const bridge of landscape.bridges) {
-    const end = Math.max(0, Math.abs(x - bridge.x) - bridge.halfLength - 3);
-    const distance = Math.hypot(end, z - bridge.z);
-    height *= smooth((distance - bridge.halfWidth - 2) / 6);
-  }
-  for (const cave of landscape.caves) height *= smooth((caveDistance(cave, x, z) - 8.5) / 5);
-  return height * smooth((bankDistance - 3) / 10) + edge;
-}
-
-function meadowRolling(landscape: Landscape, x: number, z: number) {
-  return 0.08 * Math.sin(x * 0.12 + landscape.phase) * Math.cos(z * 0.11);
-}
-
-function baseHeight(landscape: Landscape, x: number, z: number) {
-  const distance = Math.abs(x - riverX(landscape, z)),
-    width = riverWidth(landscape, z);
-  const level = waterLevel(landscape, z);
-  if (distance <= width) return level - 1.8 * (1 - (distance / width) ** 4);
-  const bank = smooth((distance - width) / 1.4);
-  const rolling = meadowRolling(landscape, x, z);
-  return level + bank * (1 + rolling + hillRise(landscape, x, z));
-}
-
-export function terrainHeight(landscape: Landscape, x: number, z: number) {
-  let height = baseHeight(landscape, x, z);
-  for (const cave of landscape.caves) {
-    const weight = 1 - smooth((caveDistance(cave, x, z) - 5.8) / 4);
-    height += (cave.y - height) * weight;
-  }
-  return height;
-}
-
-/** Sample the same triangle planes the renderer draws, including clipped material boundaries. */
-export function terrainMeshHeight(landscape: Landscape, x: number, z: number): number {
-  let heights = terrainSamples.get(landscape);
-  const width = TERRAIN_GRID.length;
-  if (!heights) {
-    heights = Float32Array.from({ length: width * width }, (_, i) =>
-      terrainHeight(landscape, TERRAIN_GRID[i % width]!, TERRAIN_GRID[Math.floor(i / width)]!)
-    );
-    terrainSamples.set(landscape, heights);
-  }
-  const cell = (value: number) =>
-    Math.max(
-      0,
-      Math.min(
-        width - 2,
-        value < -WORLD_EDGE
-          ? Math.floor((value + TERRAIN_EDGE) / 6)
-          : value < WORLD_EDGE
-            ? APRON_CELLS + Math.floor((value + WORLD_EDGE) / TERRAIN_STEP)
-            : APRON_CELLS + PLAYABLE_CELLS + Math.floor((value - WORLD_EDGE) / 6)
-      )
-    );
-  const col = cell(x),
-    row = cell(z),
-    at = row * width + col;
-  const u = Math.max(0, Math.min(1, (x - TERRAIN_GRID[col]!) / (TERRAIN_GRID[col + 1]! - TERRAIN_GRID[col]!))),
-    v = Math.max(0, Math.min(1, (z - TERRAIN_GRID[row]!) / (TERRAIN_GRID[row + 1]! - TERRAIN_GRID[row]!)));
-  return u + v <= 1
-    ? heights[at]! + u * (heights[at + 1]! - heights[at]!) + v * (heights[at + width]! - heights[at]!)
-    : heights[at + width + 1]! +
-        (1 - u) * (heights[at + width]! - heights[at + width + 1]!) +
-        (1 - v) * (heights[at + 1]! - heights[at + width + 1]!);
-}
-
-/** Rounded cave surrounds avoid rectangular terrain cutouts at the entrances. */
-export function caveDistance(cave: Cave, x: number, z: number) {
-  return Math.hypot(x - cave.x, Math.max(0, Math.abs(z - cave.z) - cave.length / 2 + 3.5));
-}
-
-export function caveClearance(landscape: Landscape, x: number, z: number) {
-  return Math.min(...landscape.caves.map((cave) => caveDistance(cave, x, z) - 7), Infinity);
-}
-
-/** Continuous contours are shared by visible terrain, movement and contact normals. */
-export function terrainSurface(landscape: Landscape, x: number, z: number): Exclude<TerrainSurface, 'bridge'> {
-  const distance = Math.abs(x - riverX(landscape, z)),
-    width = riverWidth(landscape, z);
-  if (distance <= width) return 'river';
-  if (distance < width + 1.4) return 'shore';
-  if (caveClearance(landscape, x, z) < 0) return 'cave';
-  return hillRise(landscape, x, z) > 0.35 ? 'hill' : 'grass';
-}
-
-export function toWorld(map: Pick<NatureMap, 'rotation'>, x: number, z: number): Point {
-  const { sin, cos } = rotationAxes(map);
-  return { x: cos * x + sin * z, z: -sin * x + cos * z };
-}
-
-export function toLocal(map: Pick<NatureMap, 'rotation'>, x: number, z: number): Point {
-  const { sin, cos } = rotationAxes(map);
-  return { x: cos * x - sin * z, z: sin * x + cos * z };
-}
-
-function rotationAxes(map: Pick<NatureMap, 'rotation'>) {
-  let axes = rotations.get(map);
-  if (!axes || axes.angle !== map.rotation) {
-    axes = { angle: map.rotation, sin: Math.sin(map.rotation), cos: Math.cos(map.rotation) };
-    rotations.set(map, axes);
-  }
-  return axes;
-}
-
-export function groundHeight(map: NatureMap, x: number, z: number) {
-  const p = toLocal(map, x, z);
-  return bridgeAtLocal(map.landscape, p.x, p.z)?.y ?? terrainMeshHeight(map.landscape, p.x, p.z);
-}
-
-/** Surface tilt in a parent's yaw basis, for contact shadows that lie against the ground. */
-export function groundTilt(map: NatureMap, x: number, z: number, yaw = 0): Quat {
-  const c = Math.cos(yaw) * 0.12,
-    s = Math.sin(yaw) * 0.12;
-  const dx = (groundHeight(map, x + c, z - s) - groundHeight(map, x - c, z + s)) / 0.24,
-    dz = (groundHeight(map, x + s, z + c) - groundHeight(map, x - s, z - c)) / 0.24;
-  const length = Math.hypot(dx, 1, dz);
-  const q = [-dz / length, 0, dx / length, 1 + 1 / length];
-  const norm = Math.hypot(...q);
-  return [q[0]! / norm, 0, q[2]! / norm, q[3]! / norm];
-}
-
-function bridgeAtLocal(landscape: Landscape, x: number, z: number) {
-  return landscape.bridges.find((bridge) => Math.abs(x - bridge.x) <= bridge.halfLength && Math.abs(z - bridge.z) <= bridge.halfWidth);
-}
-
-export function bridgeAt(map: NatureMap, x: number, z: number) {
-  const p = toLocal(map, x, z);
-  return bridgeAtLocal(map.landscape, p.x, p.z);
-}
-
-export function surfaceAt(map: NatureMap, x: number, z: number): TerrainSurface {
-  const p = toLocal(map, x, z);
-  return bridgeAtLocal(map.landscape, p.x, p.z) ? 'bridge' : terrainSurface(map.landscape, p.x, p.z);
-}
-
-interface Overview {
-  row: number;
-  cells: (TerrainSurface | null)[];
-}
-const overviews = new WeakMap<NatureMap, Map<number, Overview>>();
-function overviewFor(map: NatureMap, size: number): Overview {
-  let sizes = overviews.get(map);
-  if (!sizes) {
-    sizes = new Map();
-    overviews.set(map, sizes);
-  }
-  let overview = sizes.get(size);
-  if (!overview) {
-    overview = { row: 0, cells: Array(size * size).fill(null) };
-    sizes.set(size, overview);
-  }
-  return overview;
-}
-function sampleOverviewRows(map: NatureMap, size: number, overview: Overview, count: number) {
-  const end = Math.min(size, overview.row + count);
-  for (; overview.row < end; overview.row++) {
-    const z = (((overview.row + 0.5) / size) * 2 - 1) * WORLD_EDGE;
-    for (let col = 0; col < size; col++) {
-      const x = (((col + 0.5) / size) * 2 - 1) * WORLD_EDGE;
-      overview.cells[overview.row * size + col] = Math.hypot(x, z) > map.edge - 4 ? null : surfaceAt(map, x, z);
-    }
-  }
-}
-
-/** Immutable terrain samples; the screen owns colours, paths and live objective markers. */
-export function mapOverview(map: NatureMap, size: number): readonly (TerrainSurface | null)[] {
-  const overview = overviewFor(map, size);
-  sampleOverviewRows(map, size, overview, size);
-  return overview.cells;
-}
-
-export function waterDepth(map: NatureMap, x: number, z: number) {
-  const p = toLocal(map, x, z);
-  return Math.abs(p.x - riverX(map.landscape, p.z)) <= riverWidth(map.landscape, p.z)
-    ? Math.max(0, waterLevel(map.landscape, p.z) - terrainHeight(map.landscape, p.x, p.z))
-    : 0;
-}
-
-export function caveAt(map: NatureMap, x: number, z: number) {
-  const p = toLocal(map, x, z);
-  return map.landscape.caves.find((c) => Math.abs(p.x - c.x) < 5.8 && Math.abs(p.z - c.z) < c.length / 2 + 0.2);
-}
-
-/** Passage width accounts for the explorer's height beneath the actual curved arch. */
-export function cavePassageClearance(landscape: Landscape, x: number, z: number) {
-  const halfWidth = CAVE_INNER_WIDTH * 0.975 * Math.sqrt(1 - ((HUMAN_HEIGHT + 0.12) / (CAVE_INNER_HEIGHT * 0.975)) ** 2);
-  let clearance = -Infinity;
-  for (const cave of landscape.caves)
-    clearance = Math.max(clearance, Math.min(halfWidth - Math.abs(x - cave.x), cave.length / 2 + 5 - Math.abs(z - cave.z)));
-  return clearance;
-}
-
-function terrainClearance(land: Landscape, x: number, z: number) {
-  const grass = Math.min(Math.abs(x - riverX(land, z)) - riverWidth(land, z) - 1.4, 0.35 - hillRise(land, x, z), caveClearance(land, x, z));
-  let clearance = Math.max(grass, cavePassageClearance(land, x, z));
-  for (const bridge of land.bridges)
-    clearance = Math.max(clearance, Math.min(bridge.halfLength - Math.abs(x - bridge.x), bridge.halfWidth - Math.abs(z - bridge.z)));
-  return clearance;
-}
-
-/** Terrain and visible solids supply the same contact normals used by swept movement. */
-export function navigationClearance(map: NatureMap, x: number, z: number, radius = PLAYER_RADIUS) {
-  let clearance = map.edge - 4 - radius - Math.hypot(x, z);
-  for (const [dx, dz] of FOOTPRINT) {
-    const p = toLocal(map, x + dx * radius, z + dz * radius);
-    clearance = Math.min(clearance, terrainClearance(map.landscape, p.x, p.z));
-  }
-  const floor = groundHeight(map, x, z);
-  return Math.min(clearance, solidClearance(map.obstacleCells, x, z, radius, floor + 0.02, floor + HUMAN_HEIGHT));
-}
-
-/** Grass, bridge decks and cave passages are walkable; complete body footprints stay outside solids. */
-export function isWalkable(map: NatureMap, x: number, z: number, radius = PLAYER_RADIUS) {
-  if (!Number.isFinite(x + z) || Math.hypot(x, z) + radius > map.edge - 4) return false;
-  const y = groundHeight(map, x, z);
-  for (const [dx, dz] of FOOTPRINT) {
-    const sx = x + dx * radius,
-      sz = z + dz * radius;
-    const p = toLocal(map, sx, sz);
-    if (terrainClearance(map.landscape, p.x, p.z) < -1e-8) return false;
-    if (Math.abs(groundHeight(map, sx, sz) - y) > Math.max(0.25, radius * 0.5)) return false;
-  }
-  return solidClearance(map.obstacleCells, x, z, radius, y + 0.02, y + HUMAN_HEIGHT) >= -1e-8;
-}
-
-function indexProp(map: NatureMap, prop: NatureProp) {
-  const y = groundHeight(map, prop.x, prop.z) - 0.07;
-  indexSolid(
-    map.obstacleCells,
-    prop.kind === 'rock'
-      ? rockSolid(prop.x, y, prop.z, [prop.scale, prop.scale, prop.scale], prop.yaw, prop.style)
-      : circleSolid('tree', prop.x, prop.z, 0.32 * prop.scale, y - 0.45 * prop.scale, y + (prop.kind === 'pine' ? 9.4 : 8.2) * prop.scale)
-  );
-}
-
-/** All decorative rocks and trees are generated before navigation, then rendered from this same data. */
-function generateScenery(map: NatureMap) {
-  const rng = random(map.seed ^ 0x679be3);
-  const add = (decoration: NatureDecoration) => {
-    map.decorations.push(decoration);
-    indexSolid(
-      map.obstacleCells,
-      decoration.kind === 'rock'
-        ? rockSolid(decoration.x, decoration.y, decoration.z, decoration.scale, decoration.yaw, decoration.style)
-        : circleSolid(
-            'tree',
-            decoration.x,
-            decoration.z,
-            0.32 * decoration.scale[0],
-            decoration.y - 0.45 * decoration.scale[1],
-            decoration.y + 9.4 * decoration.scale[1]
-          )
-    );
-  };
-  for (const bridge of map.landscape.bridges)
-    for (const part of bridgeBarriers(bridge)) {
-      const p = toWorld(map, bridge.x + part.x, bridge.z + part.z);
-      indexSolid(
-        map.obstacleCells,
-        boxSolid(
-          part.kind === 'rail' ? 'bridge-rail' : 'bridge-post',
-          p.x,
-          p.z,
-          part.halfX,
-          part.halfZ,
-          map.rotation,
-          bridge.y + (part.kind === 'rail' ? 0.445 : 0),
-          bridge.y + (part.kind === 'rail' ? 1.025 : BRIDGE_POST_HEIGHT)
-        )
-      );
-    }
-  for (let i = 0; i < 90; i++) {
-    const a = (i / 90) * Math.PI * 2,
-      r = map.edge + 7 + rng() * 18,
-      x = Math.cos(a) * r,
-      z = Math.sin(a) * r;
-    add({
-      kind: 'rock',
-      area: 'horizon',
-      x,
-      z,
-      y: groundHeight(map, x, z) - 2,
-      scale: [5 + rng() * 5, 3 + rng() * 4, 5 + rng() * 5],
-      yaw: a,
-      style: i % 4
-    });
-    add({
-      kind: 'pine',
-      area: 'horizon',
-      x: x * 0.92,
-      z: z * 0.92,
-      y: groundHeight(map, x * 0.92, z * 0.92),
-      scale: [1.8, 1.8, 1.8],
-      yaw: a,
-      style: i % 4
-    });
-  }
-  for (const cave of map.landscape.caves) {
-    for (let i = 0; i < 14; i++) {
-      const q = toWorld(map, cave.x + (rng() - 0.5) * 5, cave.z - 8 + (i % 7) * 2.6);
-      const y = cave.y + 5.5 + rng() * 0.4,
-        scale: [number, number, number] = [2 + rng(), 1 + rng(), 1.7 + rng()];
-      add({ kind: 'rock', area: 'cave-roof', ...q, y, scale, yaw: rng() * Math.PI * 2, style: i % 4 });
-    }
-    for (const side of [-1, 1])
-      for (let i = 0; i < 7; i++) {
-        const q = toWorld(map, cave.x + side * (5.4 + rng() * 1.6), cave.z - 9 + i * 3);
-        add({ kind: 'rock', area: 'cave-entrance', ...q, y: cave.y - 0.2, scale: [1.5, 1.8 + rng(), 2], yaw: i, style: i % 4 });
-      }
-  }
-}
-
-/** A conservative connected navigation grid prevents unreachable treasure behind cliffs or rocks. */
-function* reachableFromSpawn(map: NatureMap): Generator<void, Point[]> {
-  const size = 3,
-    visited = new Set<string>(['0,0']),
-    queue: [number, number][] = [[0, 0]],
-    points: Point[] = [];
-  // Navigation edges share a half-unit lattice. Cache complete footprint/solid checks only for
-  // this flood fill; live movement still samples the current map at its exact position.
-  const minX = Math.floor((-map.edge - map.spawn.x) * 2),
-    minZ = Math.floor((-map.edge - map.spawn.z) * 2),
-    width = Math.ceil(map.edge * 4) + 3,
-    walkable = new Uint8Array(width * width);
-  const clearAt = (x: number, z: number) => {
-    const col = x - minX,
-      row = z - minZ;
-    if (col < 0 || row < 0 || col >= width || row >= width) return false;
-    const index = row * width + col;
-    let value = walkable[index]!;
-    if (!value) {
-      value = isWalkable(map, map.spawn.x + x * 0.5, map.spawn.z + z * 0.5, 0.75) ? 1 : 2;
-      walkable[index] = value;
-    }
-    return value === 1;
-  };
-  for (let index = 0; index < queue.length; index++) {
-    if (index && index % 64 === 0) yield;
-    const [cx, cz] = queue[index]!;
-    const current = { x: map.spawn.x + cx * size, z: map.spawn.z + cz * size };
-    points.push(current);
-    for (const [dx, dz] of [
-      [1, 0],
-      [-1, 0],
-      [0, 1],
-      [0, -1],
-      [1, 1],
-      [-1, 1],
-      [1, -1],
-      [-1, -1]
-    ]) {
-      const nx = cx + dx!,
-        nz = cz + dz!,
-        key = `${nx},${nz}`;
-      if (visited.has(key)) continue;
-      if (!clearAt(nx * 6, nz * 6)) {
-        visited.add(key);
-        continue;
-      }
-      let clear = true;
-      for (let step = 1; step < 6; step++)
-        if (!clearAt(cx * 6 + dx! * step, cz * 6 + dz! * step)) {
-          clear = false;
-          break;
-        }
-      if (clear) {
-        visited.add(key);
-        queue.push([nx, nz]);
-      }
-    }
-  }
-  return points;
-}
-
-function* generateNatureSteps(seed: number): Generator<void, NatureMap> {
-  const rng = random(seed),
-    landscape = landscapeFor((seed >>> 0) % TERRAIN_PROFILES);
-  const map: NatureMap = {
-    seed,
-    edge: WORLD_EDGE,
-    rotation: rng() * Math.PI * 2,
-    landscape,
-    spawn: { x: 0, z: 0 },
-    props: [],
-    decorations: [],
-    obstacleCells: new Map(),
-    reachable: [],
-    gems: [],
-    enemies: []
-  };
-  // A level grass clearing near the central bridge faces upstream.
-  const preferred = { x: riverX(landscape, -16) - 13, z: -16 };
-  let spawn = toWorld(map, preferred.x, preferred.z);
-  for (let ring = 0; ring < 30 && !isWalkable(map, spawn.x, spawn.z, 1.2); ring++) {
-    for (let i = 0; i < 24; i++) {
-      const candidate = toWorld(map, preferred.x + Math.cos((i / 24) * Math.PI * 2) * ring, preferred.z + Math.sin((i / 24) * Math.PI * 2) * ring);
-      if (surfaceAt(map, candidate.x, candidate.z) === 'grass' && isWalkable(map, candidate.x, candidate.z, 1.2)) {
-        spawn = candidate;
-        break;
-      }
-    }
-  }
-  map.spawn = spawn;
-  generateScenery(map);
-  yield;
-  for (let i = 0; i < 700; i++) {
-    if (i && i % 100 === 0) yield;
-    const angle = rng() * Math.PI * 2,
-      r = Math.sqrt(rng()) * (WORLD_EDGE - 7);
-    const x = Math.cos(angle) * r,
-      z = Math.sin(angle) * r,
-      local = toLocal(map, x, z);
-    if (gap({ x, z }, map.spawn) < 9 || Math.abs(local.x - riverX(landscape, local.z)) < riverWidth(landscape, local.z) + 2.5) continue;
-    if (
-      landscape.bridges.some((bridge) => Math.abs(local.z - bridge.z) < bridge.halfWidth + 3 && Math.abs(local.x - bridge.x) < bridge.halfLength + 5)
-    )
-      continue;
-    if (landscape.caves.some((c) => Math.abs(local.x - c.x) < 10 && Math.abs(local.z - c.z) < 18)) continue;
-    if (!isWalkable(map, x, z, 1.1)) continue;
-    const kind = rng() < 0.24 ? 'rock' : rng() < 0.65 ? 'pine' : 'birch';
-    const scale = kind === 'rock' ? 0.65 + rng() * 2.2 : 0.75 + rng() * 1.05;
-    const prop: NatureProp = {
-      x,
-      z,
-      kind,
-      scale,
-      yaw: rng() * Math.PI * 2,
-      style: Math.floor(rng() * 4)
-    };
-    map.props.push(prop);
-    indexProp(map, prop);
-  }
-  map.reachable = yield* reachableFromSpawn(map);
-  const candidates = [...map.reachable];
-  for (let i = candidates.length - 1; i > 0; i--) {
-    const at = Math.floor(rng() * (i + 1));
-    [candidates[i], candidates[at]] = [candidates[at]!, candidates[i]!];
-  }
-  const place = (target: Point[], count: number, spacing: number, fromSpawn: number) => {
-    for (const p of candidates) {
-      if (target.length === count) break;
-      if (gap(p, map.spawn) >= fromSpawn && target.every((other) => gap(p, other) >= spacing)) target.push({ ...p });
-    }
-    if (target.length !== count) throw new Error('The wilderness needs more reachable objective positions');
-  };
-  place(map.gems, GEM_GOAL, 12, 6);
-  place(map.enemies, ENEMY_COUNT, 24, 22);
-  return map;
-}
-
-function finishMap(builder: Generator<void, NatureMap>): NatureMap {
-  let next = builder.next();
-  while (!next.done) next = builder.next();
-  return next.value;
-}
-
-const nextSeed = () => (cursor = (cursor + 0x9e3779b9) >>> 0);
-export function generateNature(seed = nextSeed()): NatureMap {
-  return finishMap(generateNatureSteps(seed));
-}
-
-interface PendingMap {
-  seed: number;
-  builder: Generator<void, NatureMap>;
-  done: boolean;
-  map?: NatureMap;
-}
-let nextMap: PendingMap | undefined;
-
-/** Prepare one fresh layout in bounded batches, without creating a world, actors or game state. */
-export function* warmNextMap(): Iterable<() => void> {
-  if (!nextMap) {
-    const seed = nextSeed();
-    nextMap = { seed, builder: generateNatureSteps(seed), done: false };
-  }
-  const pending = nextMap;
-  while (!pending.done)
-    yield () => {
-      if (pending.done) return;
-      let step: IteratorResult<void, NatureMap>;
-      try {
-        step = pending.builder.next();
-      } catch (error) {
-        pending.builder = generateNatureSteps(pending.seed);
-        throw error;
-      }
-      if (step.done) {
-        pending.map = step.value;
-        pending.done = true;
-      }
-    };
-  if (nextMap !== pending) return;
-  const map = pending.map!;
-  const overview = overviewFor(map, MINIMAP_SIZE);
-  while (nextMap === pending && overview.row < MINIMAP_SIZE) yield () => sampleOverviewRows(map, MINIMAP_SIZE, overview, 4);
-}
-
-export const peekNextMap = (): NatureMap | undefined => nextMap?.map;
-
-function takeNextMap(): NatureMap {
-  const pending = nextMap;
-  nextMap = undefined;
-  if (!pending) return generateNature();
-  if (!pending.done) {
-    pending.map = finishMap(pending.builder);
-    pending.done = true;
-  }
-  return pending.map!;
-}
-// Movement, combat and objectives.
-
-export type Phase = 'ready' | 'playing' | 'won' | 'lost';
-
-export interface Enemy extends Point {
-  id: number;
-  home: Point;
-  health: number;
-  yaw: number;
-  windup: number;
-  recovery: number;
-  stagger: number;
-  moving: boolean;
-}
-
-export interface Gem extends Point {
-  id: number;
-  taken: boolean;
-}
-
-export interface NatureState {
-  map: NatureMap;
-  phase: Phase;
-  player: Point;
-  yaw: number;
-  health: number;
-  gems: number;
-  defeated: number;
-  score: number;
-  time: number;
-  attackCooldown: number;
-  attackPending: number;
-  invulnerable: number;
-  moving: boolean;
-  speed: number;
-  velocity: Point;
-  yawVelocity: number;
-  enemies: Enemy[];
-  pickups: Gem[];
-}
-
-export interface NatureInput {
-  x: number;
-  y: number;
-  attack: boolean;
-}
-
-export interface NatureEvent {
-  kind: 'attack' | 'hit' | 'defeated' | 'gem' | 'hurt' | 'won' | 'lost';
-  x: number;
-  z: number;
-  id?: number;
-}
-
-export const distance = (a: Point, b: Point) => Math.hypot(a.x - b.x, a.z - b.z);
-
-export function createState(seed?: number): NatureState {
-  const map = seed === undefined ? takeNextMap() : generateNature(seed);
-  return {
-    map,
-    phase: 'ready',
-    player: { ...map.spawn },
-    yaw: map.rotation,
-    health: MAX_HEALTH,
-    gems: 0,
-    defeated: 0,
-    score: 0,
-    time: 0,
-    attackCooldown: 0,
-    attackPending: 0,
-    invulnerable: 0,
-    moving: false,
-    speed: 0,
-    velocity: { x: 0, z: 0 },
-    yawVelocity: 0,
-    enemies: map.enemies.map((p, id) => ({
-      ...p,
-      home: { ...p },
-      id,
-      health: 2,
-      yaw: 0,
-      windup: 0,
-      recovery: 0,
-      stagger: 0,
-      moving: false
-    })),
-    pickups: map.gems.map((p, id) => ({ ...p, id, taken: false }))
-  };
-}
-
-/** Sweep the full direction, settle just before contact, then slide along its continuous normal. */
-export interface ActorBody extends Point {
-  radius: number;
-}
-
-export function moveActor(map: NatureMap, point: Point, dx: number, dz: number, radius = PLAYER_RADIUS, bodies: readonly ActorBody[] = []) {
-  const clear = (x: number, z: number) =>
-    isWalkable(map, x, z, radius) &&
-    bodies.every((body) => {
-      const next = Math.hypot(x - body.x, z - body.z),
-        current = Math.hypot(point.x - body.x, point.z - body.z);
-      return next >= radius + body.radius - 1e-8 || (current < radius + body.radius && next > current + 1e-8);
-    });
-  const clearance = (x: number, z: number) =>
-    Math.min(navigationClearance(map, x, z, radius), ...bodies.map((body) => Math.hypot(x - body.x, z - body.z) - body.radius - radius));
-  const steps = Math.max(1, Math.ceil(Math.hypot(dx, dz) / 0.2));
-  const sx = dx / steps,
-    sz = dz / steps,
-    length = Math.hypot(sx, sz);
-  if (length < 1e-8) return;
-  for (let i = 0; i < steps; i++) {
-    if (clear(point.x + sx, point.z + sz)) {
-      point.x += sx;
-      point.z += sz;
-      continue;
-    }
-    let low = 0,
-      high = 1;
-    for (let search = 0; search < 9; search++) {
-      const t = (low + high) / 2;
-      if (clear(point.x + sx * t, point.z + sz * t)) low = t;
-      else high = t;
-    }
-    const fraction = Math.max(0, low - 0.003 / length);
-    point.x += sx * fraction;
-    point.z += sz * fraction;
-    const probe = 0.08;
-    const nx = clearance(point.x + probe, point.z) - clearance(point.x - probe, point.z);
-    const nz = clearance(point.x, point.z + probe) - clearance(point.x, point.z - probe);
-    const norm = Math.hypot(nx, nz);
-    if (norm < 1e-8) continue;
-    const normalX = nx / norm,
-      normalZ = nz / norm,
-      dot = Math.min(0, sx * normalX + sz * normalZ);
-    const slideX = (sx - dot * normalX) * (1 - fraction),
-      slideZ = (sz - dot * normalZ) * (1 - fraction);
-    if (Math.hypot(slideX, slideZ) < 0.002) continue;
-    for (const amount of [1, 0.5, 0.25]) {
-      if (clear(point.x + slideX * amount, point.z + slideZ * amount)) {
-        point.x += slideX * amount;
-        point.z += slideZ * amount;
-        break;
-      }
-    }
-  }
-}
-
-function actorBodies(state: NatureState, moving: Point): ActorBody[] {
-  const bodies = state.enemies.filter((enemy) => enemy !== moving && enemy.health > 0).map((enemy) => ({ x: enemy.x, z: enemy.z, radius: 0.5 }));
-  if (moving !== state.player) bodies.push({ ...state.player, radius: PLAYER_RADIUS });
-  return bodies;
-}
-
-function canSee(map: NatureMap, a: Point, b: Point) {
-  if (Math.abs(groundHeight(map, a.x, a.z) - groundHeight(map, b.x, b.z)) > 1.6) return false;
-  const steps = Math.ceil(distance(a, b) / 0.4);
-  for (let i = 1; i < steps; i++) {
-    const t = i / steps;
-    if (!isWalkable(map, a.x + (b.x - a.x) * t, a.z + (b.z - a.z) * t, 0.25)) return false;
-  }
-  return true;
-}
-
-/** No React or native calls: rules emit events for the engine's effects and HUD. */
-export function step(state: NatureState, input: NatureInput, elapsed: number): NatureEvent[] {
-  if (state.phase !== 'playing') return [];
-  const dt = Math.min(0.05, Math.max(0, elapsed));
-  if (dt === 0) return [];
-  const events: NatureEvent[] = [];
-  const emit = (kind: NatureEvent['kind'], point: Point, id?: number) => events.push({ kind, ...point, id });
-  state.time += dt;
-  state.attackCooldown = Math.max(0, state.attackCooldown - dt);
-  state.invulnerable = Math.max(0, state.invulnerable - dt);
-  const magnitude = Math.hypot(input.x, input.y);
-  const moving = magnitude >= (state.moving ? MOVEMENT_STOP : MOVEMENT_START);
-  const dx = moving ? input.x / Math.max(1, magnitude) : 0;
-  const dz = moving ? -input.y / Math.max(1, magnitude) : 0;
-  if (input.attack && state.attackCooldown === 0) {
-    const target = state.enemies
-      .filter((e) => e.health > 0 && distance(e, state.player) <= ATTACK_RANGE && canSee(state.map, state.player, e))
-      .sort((a, b) => distance(a, state.player) - distance(b, state.player))[0];
-    if (target) {
-      state.yaw = Math.atan2(target.x - state.player.x, target.z - state.player.z);
-      state.yawVelocity = 0;
-    }
-    state.attackCooldown = ATTACK_COOLDOWN;
-    state.attackPending = ATTACK_HIT_TIME;
-    emit('attack', state.player);
-  }
-  const previousX = state.player.x;
-  const previousZ = state.player.z;
-  const speed = PLAYER_SPEED * (state.attackPending > 0 ? 0.3 : 1);
-  const blend = 1 - Math.exp(-dt / 0.065);
-  if (!moving) {
-    state.velocity.x = 0;
-    state.velocity.z = 0;
-    state.yawVelocity = 0;
-  }
-  if (moving && state.attackPending <= 0) {
-    const targetYaw = Math.atan2(dx, dz);
-    const difference = Math.atan2(Math.sin(targetYaw - state.yaw), Math.cos(targetYaw - state.yaw));
-    // A critically damped heading spring eases angular acceleration and braking without orbit jitter.
-    const omega = 12,
-      decay = Math.exp(-omega * dt),
-      impulse = (state.yawVelocity - omega * difference) * dt;
-    const nextError = (-difference + impulse) * decay;
-    let change = Math.max(-5 * dt, Math.min(5 * dt, difference + nextError));
-    state.yawVelocity = Math.max(-5, Math.min(5, (state.yawVelocity - omega * impulse) * decay));
-    if (change * difference > 0 && Math.abs(change) > Math.abs(difference)) {
-      change = difference;
-      state.yawVelocity = 0;
-    }
-    state.yaw += change;
-  }
-  if (moving) {
-    const forwardX = Math.sin(state.yaw),
-      forwardZ = Math.cos(state.yaw);
-    // Slow into sharp turns and pivot before reversing, rather than playing a forward gait backwards.
-    const alignment = Math.max(0, (dx * forwardX + dz * forwardZ) / Math.max(1e-8, Math.hypot(dx, dz)));
-    const turnSpeed = speed * alignment * alignment;
-    state.velocity.x += (dx * turnSpeed - state.velocity.x) * blend;
-    state.velocity.z += (dz * turnSpeed - state.velocity.z) * blend;
-    const backward = Math.min(0, state.velocity.x * forwardX + state.velocity.z * forwardZ);
-    state.velocity.x -= backward * forwardX;
-    state.velocity.z -= backward * forwardZ;
-  }
-  moveActor(state.map, state.player, state.velocity.x * dt, state.velocity.z * dt, PLAYER_RADIUS, actorBodies(state, state.player));
-  state.velocity.x = (state.player.x - previousX) / dt;
-  state.velocity.z = (state.player.z - previousZ) / dt;
-  state.speed = Math.hypot(state.player.x - previousX, state.player.z - previousZ) / dt;
-  state.moving = state.speed > 0.001;
-
-  if (state.attackPending > 0) {
-    state.attackPending = Math.max(0, state.attackPending - dt);
-    if (state.attackPending === 0) {
-      for (const enemy of state.enemies) {
-        const d = distance(enemy, state.player);
-        if (enemy.health <= 0 || d > ATTACK_RANGE || !canSee(state.map, state.player, enemy)) continue;
-        const facing = ((enemy.x - state.player.x) * Math.sin(state.yaw) + (enemy.z - state.player.z) * Math.cos(state.yaw)) / (d || 1);
-        if (facing < 0.15 && d > 0.8) continue;
-        enemy.health--;
-        enemy.stagger = 0.35;
-        enemy.windup = 0;
-        moveActor(state.map, enemy, Math.sin(state.yaw) * 0.65, Math.cos(state.yaw) * 0.65, 0.65, actorBodies(state, enemy));
-        emit(enemy.health === 0 ? 'defeated' : 'hit', enemy, enemy.id);
-        state.score += enemy.health === 0 ? POINTS_ROBOT_DEFEAT : POINTS_ROBOT_HIT;
-        if (enemy.health === 0) {
-          state.defeated++;
-          // Enemies leave a bonus gem; collecting 24 of the available 32 completes the gem objective.
-          state.pickups.push({
-            x: enemy.x,
-            z: enemy.z,
-            id: state.pickups.length,
-            taken: false
-          });
-        }
-      }
-    }
-  }
-
-  for (const enemy of state.enemies) {
-    enemy.moving = false;
-    if (enemy.health <= 0) continue;
-    enemy.recovery = Math.max(0, enemy.recovery - dt);
-    enemy.stagger = Math.max(0, enemy.stagger - dt);
-    if (enemy.stagger > 0) continue;
-    const d = distance(enemy, state.player);
-    if (enemy.windup > 0) {
-      enemy.windup = Math.max(0, enemy.windup - dt);
-      if (enemy.windup === 0) {
-        enemy.recovery = 1.2;
-        if (d < 2.1 && state.invulnerable === 0 && canSee(state.map, enemy, state.player)) {
-          state.health--;
-          state.invulnerable = 1.2;
-          emit('hurt', state.player);
-          if (state.health === 0) {
-            state.phase = 'lost';
-            emit('lost', state.player);
-            return events;
-          }
-        }
-      }
-      continue;
-    }
-    const visible = d < 13 && canSee(state.map, enemy, state.player);
-    if (visible && d < 1.25 && enemy.recovery === 0) {
-      enemy.windup = 0.6;
-      enemy.yaw = Math.atan2(state.player.x - enemy.x, state.player.z - enemy.z);
-    } else {
-      const patrol = {
-        x: enemy.home.x + Math.sin(state.time * 0.45 + enemy.id) * 1.8,
-        z: enemy.home.z + Math.cos(state.time * 0.45 + enemy.id) * 1.8
-      };
-      const target = visible ? state.player : patrol;
-      const tx = target.x - enemy.x;
-      const tz = target.z - enemy.z;
-      const length = Math.hypot(tx, tz);
-      if (length > (visible ? 1.05 : 0.2)) {
-        const speed = visible ? 2.7 : 1.1;
-        const previous = { x: enemy.x, z: enemy.z };
-        moveActor(state.map, enemy, (tx / length) * speed * dt, (tz / length) * speed * dt, 0.65, actorBodies(state, enemy));
-        enemy.yaw = Math.atan2(tx, tz);
-        enemy.moving = distance(previous, enemy) / dt > 0.05;
-      }
-    }
-  }
-
-  for (const gem of state.pickups) {
-    if (
-      !gem.taken &&
-      distance(gem, state.player) < 1.2 &&
-      Math.abs(groundHeight(state.map, gem.x, gem.z) - groundHeight(state.map, state.player.x, state.player.z)) < 1.2 &&
-      canSee(state.map, state.player, gem)
-    ) {
-      gem.taken = true;
-      state.gems++;
-      state.score += POINTS_GEM;
-      emit('gem', gem, gem.id);
-    }
-  }
-  if (state.gems >= GEM_GOAL && state.defeated === state.enemies.length) {
-    state.phase = 'won';
-    state.score += state.health * POINTS_HEALTH_BONUS;
-    emit('won', state.player);
-  }
-  return events;
-}