@nayan-ui/games 1.19.0 → 1.20.0

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

@@ -0,0 +1,1210 @@
+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;
+}