@nayan-ui/games 1.18.0 → 1.20.0

package/src/games/mine-sweeper/MineSweeperRules.ts

@@ -0,0 +1,67 @@
+// Mine Sweeper's board and moves, as plain functions: the grid, mines laid after the first reveal (never
+// in the 3 x 3 round it), adjacent counts, and the flood reveal out from an empty cell. Ported from the
+// original version's service (games/mine-sweeper), in the same order, so boards play the same.
+import type { Board } from './MineSweeperConstants';
+
+export enum CellState {
+  HIDDEN = 'hidden',
+  REVEALED = 'revealed',
+  FLAGGED = 'flagged'
+}
+
+export type Cell = { row: number; col: number; isMine: boolean; state: CellState; adjacentMines: number };
+
+export function emptyGrid(b: Board): Cell[][] {
+  return Array.from({ length: b.rows }, (_, row) =>
+    Array.from({ length: b.cols }, (_, col): Cell => ({ row, col, isMine: false, state: CellState.HIDDEN, adjacentMines: 0 }))
+  );
+}
+
+/** Lays the mines anywhere but the 3 x 3 round the first reveal, then counts each cell's neighbours. */
+export function placeMines(grid: Cell[][], b: Board, safeRow: number, safeCol: number) {
+  let placed = 0;
+  while (placed < b.mines) {
+    const r = Math.floor(Math.random() * b.rows);
+    const c = Math.floor(Math.random() * b.cols);
+    if ((Math.abs(r - safeRow) > 1 || Math.abs(c - safeCol) > 1) && !grid[r]![c]!.isMine) {
+      grid[r]![c]!.isMine = true;
+      placed++;
+    }
+  }
+  for (let r = 0; r < b.rows; r++)
+    for (let c = 0; c < b.cols; c++) {
+      if (grid[r]![c]!.isMine) continue;
+      let count = 0;
+      for (let dr = -1; dr <= 1; dr++)
+        for (let dc = -1; dc <= 1; dc++) {
+          if (!dr && !dc) continue;
+          if (grid[r + dr]?.[c + dc]?.isMine) count++;
+        }
+      grid[r]![c]!.adjacentMines = count;
+    }
+}
+
+/** The cells a reveal opens, breadth first from the tapped one: past every empty cell to its neighbours, stopping at flags and mines. */
+export function floodReveal(grid: Cell[][], b: Board, startRow: number, startCol: number): Cell[] {
+  const queue: [number, number][] = [[startRow, startCol]];
+  const visited = new Uint8Array(b.rows * b.cols);
+  visited[startRow * b.cols + startCol] = 1;
+  const out: Cell[] = [];
+  for (let head = 0; head < queue.length; head++) {
+    const [row, col] = queue[head]!;
+    const cell = grid[row]?.[col];
+    if (!cell || cell.state !== CellState.HIDDEN || cell.isMine) continue;
+    out.push(cell);
+    if (cell.adjacentMines !== 0) continue;
+    for (let dr = -1; dr <= 1; dr++)
+      for (let dc = -1; dc <= 1; dc++) {
+        if (!dr && !dc) continue;
+        const nr = row + dr;
+        const nc = col + dc;
+        if (nr < 0 || nr >= b.rows || nc < 0 || nc >= b.cols || visited[nr * b.cols + nc]) continue;
+        visited[nr * b.cols + nc] = 1;
+        queue.push([nr, nc]);
+      }
+  }
+  return out;
+}

package/src/games/mine-sweeper/MineSweeperScene.ts

@@ -0,0 +1,262 @@
+// Everything Mine Sweeper draws: a board (themed, as the original board) of raised grass tiles in two
+// shades, which sink to sand as they're revealed (rippling out from the tap) showing their count in 3D
+// digits, red pennant flags, and black spiked sea mines on red tiles when one goes off. Seen from a
+// little in front of straight down (shared/EngineTilt: an orthographic camera leaning back, one world
+// unit per point). Tiles, flags, mines and each digit share one mesh apiece (one instanced draw each).
+import {
+  type Camera,
+  effects,
+  type Entity,
+  extrude,
+  type GeometryPart,
+  lathe,
+  merge,
+  type Model,
+  Path,
+  quat,
+  shapeGeometry,
+  tube,
+  type Vec3,
+  type World
+} from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { setBackdropTheme, spawnBackdrop } from '../shared/EngineBackdrop';
+import { GLYPH_RADIUS, glyphMesh } from '../shared/EngineGlyphs';
+import { cacheGameAsset, createGameMesh as createShape } from '../shared/EngineMeshes';
+import { placeTiltedBackdrop } from '../shared/EngineTilt';
+import { toColor } from '../shared/EngineUtils';
+import { cellCentre, COLORS, type Layout, NUMBER_COLORS, REVEAL_STEP } from './MineSweeperConstants';
+import { type Cell, CellState } from './MineSweeperRules';
+
+const meshes = new Map<string, Model>();
+const cached = (key: string, build: () => Model) => {
+  let m = meshes.get(key);
+  if (!m) {
+    m = cacheGameAsset('mine-sweeper/MineSweeperScene:' + key, build);
+    meshes.set(key, m);
+  }
+  return m;
+};
+const STAND_UP = quat.x(Math.PI / 2);
+const BOARD_DEPTH = 10;
+const BACKDROP_DEPTH = 25;
+const RAISED = 0.32; // a hidden tile's height, of a cell
+const SUNK = 0.08; // a revealed one's
+
+// ── Meshes (one cell across) ──────────────────────────────────────────
+
+/** A sea mine: a black ball with eight spikes and a glint, standing on the origin. */
+const mineMesh = () =>
+  cached('ms-mine', () => {
+    const spike = lathe(
+      [
+        [0.07, 0],
+        [0.04, 0.14],
+        [0.001, 0.2]
+      ],
+      { segments: 10 }
+    );
+    const parts: GeometryPart[] = [{ geometry: shapeGeometry('sphere'), position: [0, 0, 0.32], scale: 0.48, color: [0.12, 0.12, 0.14, 1] }];
+    for (let i = 0; i < 8; i++) {
+      const a = (i / 8) * Math.PI * 2;
+      const tilt = i % 2 ? 0.45 : -0.45;
+      // Each spike: stood up, leaned out, turned round the ball
+      const rotation = quat.multiply(quat.z(a), quat.multiply(quat.y(Math.PI / 2 + tilt), STAND_UP));
+      parts.push({ geometry: spike, position: [Math.cos(a) * 0.2, Math.sin(a) * 0.2, 0.32 + tilt * 0.3], rotation, color: [0.2, 0.2, 0.22, 1] });
+    }
+    parts.push({ geometry: shapeGeometry('sphere'), position: [-0.08, 0.08, 0.5], scale: 0.09, color: [0.9, 0.9, 0.95, 1] });
+    return createShape(merge(parts), { center: false, shine: 0.8 });
+  });
+
+/** A flag: a pole on a little base with a red pennant, standing on the origin. */
+const flagMesh = () =>
+  cached('ms-flag', () => {
+    const cloth = extrude(new Path().moveTo(0, 0).lineTo(0.36, 0.12).lineTo(0, 0.26).close(), { depth: 0.03 });
+    return createShape(
+      merge([
+        {
+          geometry: lathe(
+            [
+              [0.001, 0.05],
+              [0.18, 0.05],
+              [0.2, 0],
+              [0.001, 0]
+            ],
+            { segments: 18 }
+          ),
+          rotation: STAND_UP,
+          color: [0.33, 0.33, 0.33, 1]
+        },
+        {
+          geometry: tube(
+            [
+              [-0.06, 0, 0.04],
+              [-0.06, 0, 0.72]
+            ],
+            { radius: 0.03, sides: 8 }
+          ),
+          color: toColor('#8B4513')
+        },
+        { geometry: cloth, position: [-0.06, 0, 0.72], rotation: STAND_UP, color: toColor('#E74C3C') }
+      ]),
+      { center: false, shine: 0.4 }
+    );
+  });
+
+const panelMesh = (w: number, h: number, radius: number) =>
+  cached(`ms-panel:${w}x${h}:${radius}`, () =>
+    createShape(extrude(new Path().addRoundedRect(-w / 2, -h / 2, w, h, radius), { depth: BOARD_DEPTH }), { shine: 0.2 })
+  );
+
+// ── Spawning ──────────────────────────────────────────────────────────
+
+export type Scene = {
+  backdrop: Entity;
+  panel: Entity;
+  grid: Entity | null;
+  tiles: Entity[];
+  /** What sits on each cell: its count, a flag or a mine (null when nothing does). */
+  marks: (Entity | null)[];
+};
+
+const alt = (row: number, col: number) => (row + col) % 2 === 1;
+const hiddenColor = (row: number, col: number) => toColor(alt(row, col) ? COLORS.HIDDEN_ALT : COLORS.HIDDEN);
+const revealedColor = (cell: Cell) => toColor(cell.isMine ? COLORS.MINE : alt(cell.row, cell.col) ? COLORS.REVEALED_ALT : COLORS.REVEALED);
+const panelColor = (theme: GameTheme) => toColor(theme.mode === 'classic' ? COLORS.CLASSIC_BOARD : theme.BOARD.SURFACE);
+
+export function buildScene(world: World, l: Layout, theme: GameTheme, grid: Cell[][]): Scene {
+  const backdrop = spawnBackdrop(world, l.width, l.height, -BACKDROP_DEPTH, theme);
+  placeTiltedBackdrop(world, backdrop, l, BACKDROP_DEPTH);
+  const classic = theme.mode === 'classic';
+  const panel = world.spawn({
+    mesh: panelMesh(l.boardWidth, l.boardHeight, classic ? 12 : 8),
+    position: [0, 0, -BOARD_DEPTH / 2],
+    color: panelColor(theme),
+    pickable: false
+  });
+  const gridBox = classic
+    ? world.spawn({
+        mesh: panelMesh(l.gridWidth, l.gridHeight, 8),
+        position: [0, 0, -BOARD_DEPTH / 2 + 0.3],
+        color: toColor(COLORS.CLASSIC_GRID),
+        pickable: false
+      })
+    : null;
+  const tiles: Entity[] = [];
+  const marks: (Entity | null)[] = [];
+  for (const row of grid)
+    for (const cell of row) {
+      const [x, y] = cellCentre(l, cell.row, cell.col);
+      const shown = cell.state === CellState.REVEALED;
+      const h = l.cell * (shown ? SUNK : RAISED);
+      tiles.push(
+        world.spawn({
+          mesh: 'roundedBox',
+          position: [x, y, h / 2],
+          scale: [l.cell, l.cell, h],
+          color: shown ? revealedColor(cell) : hiddenColor(cell.row, cell.col),
+          pickable: false
+        })
+      );
+      marks.push(null);
+    }
+  const s = { backdrop, panel, grid: gridBox, tiles, marks };
+  for (const row of grid) for (const cell of row) mark(world, l, s, cell, false);
+  return s;
+}
+
+export function removeScene(world: World, s: Scene) {
+  for (const e of [s.backdrop, s.panel, s.grid, ...s.tiles, ...s.marks]) if (e != null) world.despawn(e);
+}
+
+export function setSceneTheme(world: World, l: Layout, s: Scene, theme: GameTheme) {
+  setBackdropTheme(world, s.backdrop, theme);
+  world.set(s.panel, { mesh: panelMesh(l.boardWidth, l.boardHeight, theme.mode === 'classic' ? 12 : 8), color: panelColor(theme) });
+  if (s.grid != null) world.set(s.grid, { scale: theme.mode === 'classic' ? 1 : 0 });
+}
+
+const at = (l: Layout, cell: Cell, z: number): Vec3 => {
+  const [x, y] = cellCentre(l, cell.row, cell.col);
+  return [x, y, z];
+};
+
+/** Puts what belongs on a cell there: its count once revealed, a flag while flagged, a mine when revealed as one. */
+function mark(world: World, l: Layout, s: Scene, cell: Cell, animate: boolean, delay = 0) {
+  const i = cell.row * l.cols + cell.col;
+  const old = s.marks[i];
+  if (old != null) world.despawn(old);
+  s.marks[i] = null;
+  let e: Entity | null = null;
+  if (cell.state === CellState.FLAGGED) {
+    e = world.spawn({ mesh: flagMesh(), position: at(l, cell, l.cell * RAISED), scale: l.cell * 0.8, pickable: false });
+  } else if (cell.state === CellState.REVEALED && cell.isMine) {
+    e = world.spawn({ mesh: mineMesh(), position: at(l, cell, l.cell * SUNK), scale: l.cell * 0.85, pickable: false });
+  } else if (cell.state === CellState.REVEALED && cell.adjacentMines > 0) {
+    const size = l.cell * 0.56;
+    e = world.spawn({
+      mesh: glyphMesh(String(cell.adjacentMines)),
+      position: at(l, cell, l.cell * SUNK + GLYPH_RADIUS * size),
+      scale: size,
+      color: toColor(NUMBER_COLORS[cell.adjacentMines]!),
+      pickable: false
+    });
+  }
+  s.marks[i] = e;
+  if (e != null && animate) {
+    const full = cell.state === CellState.FLAGGED ? l.cell * 0.8 : cell.state === CellState.REVEALED && cell.isMine ? l.cell * 0.85 : l.cell * 0.56;
+    world.set(e, { scale: 0.01 });
+    world.animate(e, { scale: full }, { duration: 0.22, delay, easing: 'back' });
+  }
+}
+
+// ── Motion ────────────────────────────────────────────────────────────
+
+/** Revealed cells sink to sand one after another, rippling out from the first, and show what they hold. */
+export function reveal(world: World, l: Layout, s: Scene, cells: Cell[], origin: Cell) {
+  for (const cell of cells) {
+    const delay = Math.hypot(cell.row - origin.row, cell.col - origin.col) * REVEAL_STEP;
+    const tile = s.tiles[cell.row * l.cols + cell.col]!;
+    const h = l.cell * SUNK;
+    world.animate(
+      tile,
+      { position: at(l, cell, h / 2), scale: [l.cell, l.cell, h], color: revealedColor(cell) },
+      { duration: 0.16, delay, easing: 'easeIn' }
+    );
+    mark(world, l, s, cell, true, delay + 0.1);
+  }
+}
+
+/** A flag goes up, or comes down. */
+export function flag(world: World, l: Layout, s: Scene, cell: Cell) {
+  mark(world, l, s, cell, true);
+}
+
+/** A mine goes off: a fireball, a jolt, and every mine shows. */
+export function explode(world: World, l: Layout, s: Scene, camera: Camera, hit: Cell, mines: Cell[]) {
+  reveal(world, l, s, mines, hit);
+  const [x, y] = cellCentre(l, hit.row, hit.col);
+  effects.explosion(world, {
+    position: [x, y, l.cell * 0.4],
+    count: 28,
+    size: l.cell * 0.9,
+    speed: l.cell * 4,
+    lifetime: 0.6,
+    direction: [0, 0, 1],
+    spread: 1.4,
+    debris: [toColor('#3E4A58'), toColor('#8D6E63'), toColor('#5A5A5A')]
+  });
+  camera.shake = l.cell * 0.25;
+}
+
+/** Every safe cell cleared: confetti over the board. */
+export function celebrate(world: World, l: Layout) {
+  effects.confetti(world, {
+    position: [0, 0, l.cell],
+    count: 60,
+    size: l.cell * 0.2,
+    speed: l.boardWidth * 1.4,
+    lifetime: 1.3,
+    gravity: -l.boardWidth * 2.4,
+    colors: ['#FFD700', '#4CAF50', '#2196F3', '#E74C3C'].map((c) => toColor(c))
+  });
+}

package/src/games/mob-control/MobControl.tsx

@@ -0,0 +1,73 @@
+import { useMemo } from 'react';
+import { HapticType } from '../../services/HapticsService';
+import { GAME_SOUNDS, type SoundConfig } from '../../services/SoundsService';
+import { GAME_IDS } from '../../services/UtilsService';
+import { engineGame, EngineGameScreen } from '../shared/EngineGameScreen';
+import { scoreColumn, textColumn } from '../shared/EngineHud';
+import { useEngineGame } from '../shared/useEngineGame';
+import { useLiveState } from '../shared/useLiveState';
+import { DAY_LIGHT, MOB_COLORS, MOB_CONFIG as C, NIGHT_LIGHT, SKY_DAY, SKY_NIGHT } from './MobControlConstants';
+import { aim, createGame, dispose, type GameEvent, INITIAL_HUD, replay, reset, setActive, setLayout, setTheme, start, tick } from './MobControlGame';
+
+const SOUNDS = GAME_SOUNDS.MOB_CONTROL;
+const FEEDBACK: Record<GameEvent, { sound?: SoundConfig; haptic?: HapticType }> = {
+  shoot: { sound: SOUNDS.SHOOT },
+  gate: { sound: SOUNDS.GATE, haptic: HapticType.LIGHT },
+  hit: { sound: SOUNDS.HIT },
+  clash: { sound: SOUNDS.CLASH, haptic: HapticType.LIGHT },
+  boss: { sound: SOUNDS.LEVEL_UP, haptic: HapticType.SUCCESS },
+  damage: { sound: SOUNDS.DAMAGE, haptic: HapticType.WARNING },
+  champion: { sound: SOUNDS.LEVEL_UP, haptic: HapticType.HEAVY },
+  win: { sound: GAME_SOUNDS.WELL_DONE, haptic: HapticType.SUCCESS },
+  lose: { sound: SOUNDS.GAME_OVER, haptic: HapticType.ERROR }
+};
+export const MobControl = engineGame(GAME_IDS.MOB_CONTROL, (props) => {
+  const [hud, setHud] = useLiveState(INITIAL_HUD, 0);
+  const { game, theme, status, screen, gameOver } = useEngineGame(props, {
+    gameId: GAME_IDS.MOB_CONTROL,
+    create: createGame,
+    start,
+    reset,
+    replay,
+    dispose,
+    tick,
+    setTheme,
+    setActive,
+    resize: setLayout,
+    drag: (g, e) => {
+      if (!e.cancelled && e.phase !== 'end') aim(g, e.x);
+    },
+    sounds: SOUNDS,
+    onStart: (fx) => fx(SOUNDS.START, HapticType.SUCCESS),
+    resultsDelay: (result) => (result === 'win' ? 1300 : 650),
+    wire: (g, fx) => {
+      g.onHud = setHud;
+      g.onEvent = (event) => fx(FEEDBACK[event].sound, FEEDBACK[event].haptic);
+    }
+  });
+
+  const night = theme.mode === 'dark';
+  const shield = Math.ceil((hud.hp / C.PLAYER_HP) * 100);
+  const light = useMemo(() => (night ? NIGHT_LIGHT : DAY_LIGHT), [night]);
+  return (
+    <EngineGameScreen
+      {...screen}
+      source={game.renderer}
+      light={light}
+      background={night ? SKY_NIGHT : SKY_DAY}
+      fog={0.007}
+      columns={[scoreColumn(hud.score), textColumn('SHIELD', `${shield}%`, MOB_COLORS.HP_PLAYER), textColumn('ARMY', hud.army)]}
+      subtext="Aim and grow mobs!"
+      gameOver={gameOver({
+        title: status === 'win' ? 'LEVEL CLEARED!' : 'DEFENSE BREACHED',
+        message:
+          status === 'win'
+            ? `Level ${hud.level} conquered! ${shield}% shield remaining.`
+            : `Your cannon fell in level ${hud.level}. Chain multiplier gates and use your champion to stop the red mob.`,
+        scoreLabel: 'Battle Score',
+        score: hud.score,
+        buttonText: status === 'win' ? 'Next Level!' : 'Try Again!'
+      })}
+    />
+  );
+});

package/src/games/mob-control/MobControlConstants.ts

@@ -0,0 +1,106 @@
+// World-space metres and seconds. These limits bound simulation, rendering and effects separately.
+import type { Light } from '@nayan-ui/engine';
+
+export const MOB_CONFIG = {
+  HALF_WIDTH: 5.2,
+  TRACK_NEAR_Z: 30,
+  TRACK_FAR_Z: -150,
+  CANNON_LIMIT: 4.25,
+  CANNON_Z: 1.2,
+  SPAWN_Z: -0.9,
+  BASE_Z: -32,
+  TARGET_LINE: -29.5,
+  BREACH_Z: 0.15,
+  PLAYER_HP: 1200,
+  PLAYER_SLOTS: 640,
+  ENEMY_SLOTS: 384,
+  CAPACITY: 1024,
+  BASE_HP: 1000,
+  CORE_HP: 1400,
+  ENEMY_WAVE_SIZE: 14,
+  ENEMY_WAVE_INTERVAL: 1.35,
+  ENEMY_SURGE_INTERVAL: 15,
+  ENEMY_MAX_SURGE: 8,
+  MAX_STRENGTH: 4096,
+  PLAYER_SPEED: 4.8,
+  ENEMY_SPEED: 2.65,
+  FIRE_INTERVAL: 0.105,
+  CHAMPION_CHARGE: 100,
+  CHAMPION_PER_SHOT: 1.6,
+  CHAMPION_STRENGTH: 42,
+  CHAMPION_SPEED: 6.2,
+  BOSS_STRENGTH: 170,
+  BOSS_SPEED: 1.55,
+  BOOST_SPEED: 1.65,
+  BOOST_DURATION: 1.4,
+  FLIGHT_DURATION: 0.38,
+  COLLISION_RADIUS: 0.34,
+  GRID_SIZE: 0.8,
+  GRID_COLUMNS: 14,
+  GRID_ROWS: 46,
+  MAX_COLLISION_VISITS: 48,
+  MAX_SEPARATION_VISITS: 12,
+  STEP: 1 / 30,
+  MAX_FRAME: 0.05,
+  HUD_INTERVAL: 0.12,
+  EFFECT_INTERVAL: 0.075,
+  MAX_EFFECTS: 6,
+  WORLD_CAPACITY: 640,
+  KILL_POINTS: 5,
+  BASE_POINTS: 350,
+  LEVEL_POINTS: 500
+} as const;
+
+export interface Gate {
+  id: number;
+  x: number;
+  originX: number;
+  z: number;
+  halfWidth: number;
+  factor: number; // positive multiplies, negative divides by its magnitude
+  operation: 'multiply' | 'add' | 'divide';
+  moving: boolean;
+  hits: number;
+  remainder: number;
+}
+export interface Barrier {
+  x: number;
+  z: number;
+  halfWidth: number;
+  hp: number;
+  maxHp: number;
+}
+export interface BoostPad {
+  x: number;
+  z: number;
+  halfWidth: number;
+  halfLength: number;
+}
+export interface Base {
+  x: number;
+  z: number;
+  hp: number;
+  maxHp: number;
+  spawnClock: number;
+}
+export const MOB_COLORS = {
+  PLAYER: '#3998FF',
+  ENEMY: '#F25467',
+  PLAYER_DARK: '#1D568F',
+  ENEMY_DARK: '#8D2D42',
+  GATE: '#29BFFF',
+  GATE_HIGH: '#A14CF5',
+  GATE_DANGER: '#F16B68',
+  FRAME: '#1763A8',
+  ROAD: '#CDD0D2',
+  ROAD_EDGE: '#E6BA78',
+  GROUND: '#D7AB72',
+  CHAMPION: '#FFC83E',
+  BOOST: '#7DECF1',
+  HP_PLAYER: '#54CDA2',
+  HP_ENEMY: '#F25467'
+} as const;
+export const SKY_DAY = [0.67, 0.81, 0.88] as const;
+export const SKY_NIGHT = [0.035, 0.07, 0.13] as const;
+export const DAY_LIGHT: Light = { direction: [-0.45, 0.85, 0.4], ambient: 0.55, color: [1.04, 1.02, 0.98], shadows: true, shadowExtent: 27 };
+export const NIGHT_LIGHT: Light = { direction: [-0.3, 0.85, 0.4], ambient: 0.65, color: [0.76, 0.86, 1.1], shadows: true, shadowExtent: 27 };

package/src/games/mob-control/MobControlGame.ts

@@ -0,0 +1,176 @@
+import { type Camera, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { MOB_CONFIG as C } from './MobControlConstants';
+import { unitMeshes } from './MobControlMeshes';
+import { MobControlRenderer } from './MobControlRenderer';
+import { createSim, step } from './MobControlRules';
+import { battleEffect, buildScene, captured, celebrate, makeView, recoil, removeScene, type Scene, syncScene, type View } from './MobControlScene';
+
+export type Phase = 'ready' | 'playing' | 'over';
+export type GameEvent = 'shoot' | 'gate' | 'hit' | 'clash' | 'boss' | 'damage' | 'champion' | 'win' | 'lose';
+export interface Hud {
+  score: number;
+  hp: number;
+  army: number;
+  level: number;
+}
+export const INITIAL_HUD: Hud = { score: 0, hp: C.PLAYER_HP, army: 0, level: 1 };
+export function createGame(theme: GameTheme) {
+  const world = new World(C.WORLD_CAPACITY);
+  return {
+    world,
+    renderer: new MobControlRenderer(world, unitMeshes()),
+    sim: createSim(),
+    camera: { eye: [0, 19, 15], target: [0, 0, -13], fov: 0.9 } as Camera,
+    night: theme.mode === 'dark',
+    view: null as View | null,
+    scene: null as Scene | null,
+    phase: 'ready' as Phase,
+    won: false,
+    active: true,
+    pending: 0,
+    clock: 0,
+    lastHud: -1,
+    lastEffect: -1,
+    hudKey: '',
+    feedback: {} as Partial<Record<GameEvent, number>>,
+    get score() {
+      return this.sim.score;
+    },
+    onPhase: (_phase: Phase) => {},
+    onHud: (_hud: Hud) => {},
+    onEvent: (_event: GameEvent) => {}
+  };
+}
+export type Game = ReturnType<typeof createGame>;
+export function setLayout(g: Game, width: number, height: number) {
+  if (g.world.isDisposed || width <= 0 || height <= 0) return;
+  g.view = makeView(width, height, g.camera);
+  if (!g.scene) g.scene = buildScene(g.world, g.night, g.sim);
+  syncScene(g.world, g.scene, g.sim, true);
+  g.world.update(0);
+  g.renderer.sync(g.sim, 1, g.clock);
+}
+export function setTheme(g: Game, theme: GameTheme) {
+  const night = theme.mode === 'dark';
+  if (g.world.isDisposed || night === g.night) return;
+  g.night = night;
+  if (g.scene) {
+    removeScene(g.world, g.scene);
+    g.scene = buildScene(g.world, g.night, g.sim);
+  }
+}
+function publish(g: Game, force = false) {
+  if (!force && g.clock - g.lastHud < C.HUD_INTERVAL) return false;
+  g.lastHud = g.clock;
+  const s = g.sim;
+  const key = `${s.score}/${s.hp}/${s.playerStrength}/${s.level}`;
+  if (key !== g.hudKey) {
+    g.hudKey = key;
+    g.onHud({ score: s.score, hp: s.hp, army: s.playerStrength, level: s.level });
+  }
+  return true;
+}
+export function reset(g: Game) {
+  resetLevel(g, g.sim.level);
+}
+export function replay(g: Game) {
+  resetLevel(g, g.sim.level + (g.won ? 1 : 0));
+}
+function resetLevel(g: Game, level: number) {
+  if (g.world.isDisposed) return;
+  g.sim = createSim(undefined, level);
+  g.won = false;
+  g.pending = 0;
+  g.camera.shake = 0;
+  g.hudKey = '';
+  g.feedback = {};
+  g.world.cancelTimers();
+  if (g.scene) {
+    g.world.stopAnimation(g.scene.barrel);
+    g.world.set(g.scene.barrel, { position: [0, 0.92, -0.1] });
+    syncScene(g.world, g.scene, g.sim, true);
+  }
+  g.phase = 'ready';
+  publish(g, true);
+  g.onPhase('ready');
+  g.world.update(0);
+  g.renderer.sync(g.sim, 1, g.clock);
+}
+export function start(g: Game) {
+  if (g.world.isDisposed || !g.scene || g.phase !== 'ready') return;
+  g.pending = 0;
+  g.phase = 'playing';
+  g.onPhase('playing');
+}
+export function aim(g: Game, x: number) {
+  if (g.world.isDisposed || !g.active || g.phase !== 'playing' || !g.view) return;
+  g.sim.targetX = Math.max(-C.CANNON_LIMIT, Math.min(C.CANNON_LIMIT, (x - g.view.width / 2) / g.view.k));
+}
+export function setActive(g: Game, active: boolean) {
+  g.active = active;
+  g.pending = 0;
+}
+export function dispose(g: Game) {
+  if (g.world.isDisposed) return;
+  g.renderer.dispose();
+  g.world.dispose();
+}
+function emit(g: Game, event: GameEvent, interval = 0) {
+  if (g.clock - (g.feedback[event] ?? -100) < interval) return;
+  g.feedback[event] = g.clock;
+  g.onEvent(event);
+}
+export function tick(g: Game, dt: number) {
+  if (g.world.isDisposed || !g.active || !Number.isFinite(dt) || dt < 0) return;
+  dt = Math.min(dt, C.MAX_FRAME);
+  g.clock += dt;
+  if (g.phase === 'playing') {
+    g.pending = Math.min(g.pending + dt, C.MAX_FRAME + C.STEP);
+    while (g.phase === 'playing' && g.pending + 1e-9 >= C.STEP) {
+      g.pending = Math.max(0, g.pending - C.STEP);
+      apply(g);
+    }
+  }
+  const labels = publish(g);
+  if (g.scene) syncScene(g.world, g.scene, g.sim, labels);
+  g.world.update(dt);
+  g.renderer.sync(g.sim, g.phase === 'playing' ? Math.min(1, g.pending / C.STEP) : 1, g.clock);
+}
+function apply(g: Game) {
+  const e = step(g.sim, C.STEP),
+    s = g.scene;
+  if (e.shots) {
+    emit(g, 'shoot');
+    if (s) recoil(g.world, s);
+  }
+  if (e.gates) emit(g, 'gate', 0.14);
+  if (e.champion) emit(g, 'champion');
+  if (e.bossDefeated && !e.won) {
+    emit(g, 'boss');
+    celebrate(g.world);
+  }
+  if (e.clashes) emit(g, 'clash', 0.15);
+  if (e.hits) emit(g, 'hit', 0.13);
+  if (e.breaches) {
+    g.camera.shake = 0.18;
+    emit(g, 'damage', 0.35);
+  }
+  if (s && e.captured)
+    for (let i = 0; i < g.sim.bases.length; i++)
+      if (g.sim.bases[i]!.hp === 0 && !s.bases[i]!.captured) captured(g.world, g.sim.bases[i]!.x, g.sim.bases[i]!.z);
+  if (e.won) {
+    celebrate(g.world);
+  }
+  if (e.effectCount && g.clock - g.lastEffect >= C.EFFECT_INTERVAL) {
+    g.lastEffect = g.clock;
+    for (let i = 0; i < Math.min(2, e.effectCount); i++) battleEffect(g.world, e.effectX[i]!, e.effectZ[i]!, e.effectTeam[i] === 1);
+  }
+  if (e.won || e.lost) {
+    g.won = e.won;
+    g.phase = 'over';
+    publish(g, true);
+    emit(g, e.won ? 'win' : 'lose');
+    g.onPhase('over');
+  }
+}