@nayan-ui/games 1.20.0 → 1.21.0

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

@@ -1,67 +0,0 @@
-// 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

@@ -1,262 +0,0 @@
-// 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

@@ -1,73 +0,0 @@
-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

@@ -1,106 +0,0 @@
-// 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

@@ -1,176 +0,0 @@
-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');
-  }
-}