@nayan-ui/games 1.20.0 → 1.21.0

package/src/games/memory-match/MemoryMatchScene.ts

@@ -1,268 +0,0 @@
-// Raised, bevelled tiles with patterned backs, ivory faces and real 3D fruit.
-// Each match gets a mint border and a check seal; all decoration shares cached meshes.
-import {
-  type Color,
-  effects,
-  type Entity,
-  extrude,
-  merge,
-  type Model,
-  Path,
-  type Quat,
-  quat,
-  recolor,
-  type Vec3,
-  type World
-} from '@nayan-ui/engine';
-import type { GameTheme } from '../../services/ThemeService';
-import { setBackdropTheme, spawnBackdrop } from '../shared/EngineBackdrop';
-import { spawnRaisedBlock } from '../shared/EngineBlocks';
-import { getFruit } from '../shared/EngineFruits';
-import { cacheGameAsset, createGameMesh as createShape } from '../shared/EngineMeshes';
-import { placeTiltedBackdrop } from '../shared/EngineTilt';
-import { toColor } from '../shared/EngineUtils';
-import { cardCentre, COLORS, FACE_SIZE, FLIP_TIME, FRUIT_DETAIL, FRUIT_SIZE, type Layout, THICKNESS } from './MemoryMatchConstants';
-import { type Card, FRUIT_SYMBOLS } from './MemoryMatchRules';
-
-const meshes = new Map<string, Model>();
-const cached = (key: string, build: () => Model) => {
-  let m = meshes.get(key);
-  if (!m) {
-    m = cacheGameAsset('memory-match/MemoryMatchScene:' + key, build);
-    meshes.set(key, m);
-  }
-  return m;
-};
-const BACKDROP_DEPTH = 30;
-const RADIUS = 0.16;
-const FACE_UP: Quat = [0, 0, 0, 1];
-const FACE_DOWN = quat.y(Math.PI);
-const EDGE_ON = quat.y(Math.PI / 2);
-
-const square = (inset: number, path = new Path()) =>
-  path.addRoundedRect(-0.5 + inset, -0.5 + inset, 1 - inset * 2, 1 - inset * 2, Math.max(0.01, RADIUS - inset));
-
-const flat = (path: Path, z: number, color: Color) => ({
-  geometry: extrude(path, { depth: 0, fillRule: 'evenodd' as const }),
-  position: [0, 0, z] as Vec3,
-  color
-});
-const outline = (inset: number, width: number) => square(inset + width, square(inset));
-
-/** Matte ink avoids the moving white glare of glossy cards under the scene light. */
-const backMesh = () =>
-  cached('mm-back', () => {
-    const top = toColor(COLORS.BACK_TOP);
-    const bottom = toColor(COLORS.BACK_BOTTOM);
-    const gradient = recolor(extrude(square(0.012), { depth: 0 }), ({ position: [x, y] }) => {
-      const t = Math.max(0, Math.min(1, (x + 0.5 + (0.5 - y)) / 2));
-      return [top[0] + (bottom[0] - top[0]) * t, top[1] + (bottom[1] - top[1]) * t, top[2] + (bottom[2] - top[2]) * t, 1];
-    });
-    const mini = extrude(new Path().addRoundedRect(-0.12, -0.165, 0.24, 0.33, 0.04), { depth: 0.008 });
-    const dots = new Path();
-    for (const x of [-0.35, 0.35]) for (const y of [-0.35, 0.35]) dots.addCircle(x, y, 0.012);
-    const print = merge([
-      { geometry: gradient },
-      flat(outline(0.065, 0.009), 0.002, toColor(COLORS.BACK_BORDER)),
-      flat(new Path().addCircle(0, 0, 0.275), 0.003, toColor(COLORS.BACK_HALO)),
-      flat(dots, 0.003, toColor(COLORS.BACK_BORDER)),
-      { geometry: mini, position: [-0.065, 0.025, 0.009], rotation: quat.z(0.2), color: toColor(COLORS.BACK_PAIR) },
-      { geometry: mini, position: [0.065, -0.025, 0.022], rotation: quat.z(-0.18), color: toColor(COLORS.BACK_MOTIF) },
-      flat(new Path().addCircle(0.065, 0.025, 0.035), 0.028, toColor(COLORS.BACK_TOP))
-    ]);
-    return createShape(merge([{ geometry: print, rotation: FACE_DOWN, position: [0, 0, -THICKNESS / 2 - 0.002] }]), { center: false, shine: 0 });
-  });
-
-const frontMesh = () =>
-  cached('mm-front', () => createShape(extrude(outline(0.065, 0.01), { depth: 0, fillRule: 'evenodd' }), { center: false, shine: 0 }));
-
-const sealMesh = () =>
-  cached('mm-seal', () =>
-    createShape(
-      merge([
-        flat(new Path().addCircle(0, 0, 0.075), 0, toColor(COLORS.MATCHED_BADGE)),
-        flat(
-          new Path().addPolygon([
-            [-0.037, 0],
-            [-0.012, 0.025],
-            [0.04, -0.027],
-            [0.029, -0.038],
-            [-0.012, 0.003],
-            [-0.026, -0.011]
-          ]),
-          0.002,
-          [1, 1, 1, 1]
-        )
-      ]),
-      { center: false, shine: 0 }
-    )
-  );
-
-// ── Spawning ──────────────────────────────────────────────────────────
-
-/** A shared transform keeps the stock, printed faces, match seal and fruit together during a flip. */
-type CardView = { root: Entity; body: Entity; backBody: Entity; back: Entity; front: Entity; seal: Entity; fruit: Entity; fruitScale: number };
-export type Scene = { backdrop: Entity; cards: CardView[] };
-
-const SURFACE = 0;
-const restZ = (l: Layout) => SURFACE + (l.card * THICKNESS) / 2;
-const frontColor = (state: Card['state']): Color => toColor(state === 'matched' ? COLORS.CARD_MATCHED : COLORS.CARD_FRONT);
-const borderColor = (state: Card['state']): Color => toColor(state === 'matched' ? COLORS.MATCHED_BORDER : COLORS.FRONT_BORDER);
-
-/** Center the fruit's projected bounds on the face, accounting for its height under the tilted camera. */
-function fruitFit(symbol: number, tilt: number) {
-  const f = getFruit(FRUIT_SYMBOLS[symbol]!, FRUIT_DETAIL);
-  const lean = Math.tan(tilt);
-  const s = FRUIT_SIZE / Math.max(f.whole.size[0], f.whole.size[1] + f.whole.size[2] * lean);
-  const depth = f.whole.size[2] * s;
-  const lift = depth / 2 + 0.01;
-  return {
-    model: f.whole,
-    scale: s,
-    position: [-f.center[0] * s, -f.center[1] * s - lift * lean, THICKNESS / 2 + lift - f.center[2] * s] as Vec3
-  };
-}
-
-function spawnCard(world: World, l: Layout, i: number, card: Card): CardView {
-  const [x, y] = cardCentre(l, i);
-  const up = card.state !== 'down';
-  const root = world.spawn({ mesh: 'none', position: [x, y, restZ(l)], rotation: up ? FACE_UP : FACE_DOWN, scale: l.card, pickable: false });
-  // Two shared Tile Home blocks meet at the middle, so either face has a rounded raised rim when flipped.
-  const body = spawnRaisedBlock(world, {
-    parent: root,
-    position: [0, 0, THICKNESS / 4],
-    size: [1, 1, THICKNESS / 2],
-    color: frontColor(card.state),
-    gloss: false,
-    shadow: false
-  });
-  const backBody = spawnRaisedBlock(world, {
-    parent: root,
-    position: [0, 0, -THICKNESS / 4],
-    size: [1, 1, THICKNESS / 2],
-    color: toColor(COLORS.BACK_BOTTOM),
-    gloss: false,
-    shadow: false
-  });
-  world.set(backBody, { rotation: FACE_DOWN });
-  const back = world.spawn({ mesh: backMesh(), parent: root, scale: [FACE_SIZE, FACE_SIZE, 1], pickable: false });
-  const front = world.spawn({
-    mesh: frontMesh(),
-    parent: root,
-    position: [0, 0, THICKNESS / 2 + 0.002],
-    scale: [FACE_SIZE, FACE_SIZE, 1],
-    color: borderColor(card.state),
-    pickable: false
-  });
-  const seal = world.spawn({
-    mesh: sealMesh(),
-    parent: root,
-    position: [0.34 * FACE_SIZE, 0.34 * FACE_SIZE, THICKNESS / 2 + 0.006],
-    scale: card.state === 'matched' ? FACE_SIZE : 0,
-    pickable: false
-  });
-  const f = fruitFit(card.symbol, l.tilt);
-  const fruit = world.spawn({ mesh: f.model, parent: root, position: f.position, scale: up ? f.scale : 0, pickable: false });
-  return { root, body, backBody, back, front, seal, fruit, fruitScale: f.scale };
-}
-
-export function buildScene(world: World, l: Layout, theme: GameTheme, cards: Card[]): Scene {
-  const backdrop = spawnBackdrop(world, l.width, l.height, -BACKDROP_DEPTH, theme);
-  placeTiltedBackdrop(world, backdrop, l, BACKDROP_DEPTH);
-  return { backdrop, cards: cards.map((c, i) => spawnCard(world, l, i, c)) };
-}
-
-export function removeScene(world: World, s: Scene) {
-  for (const e of [s.backdrop, ...s.cards.map((c) => c.root)]) world.despawn(e);
-}
-
-export function setSceneTheme(world: World, s: Scene, theme: GameTheme) {
-  setBackdropTheme(world, s.backdrop, theme);
-}
-
-// ── Motion ────────────────────────────────────────────────────────────
-
-/** A new deal: every card face down with its new fruit, popping in one after another. */
-export function deal(world: World, l: Layout, s: Scene, cards: Card[]) {
-  cards.forEach((card, i) => {
-    const old = s.cards[i];
-    if (old) world.despawn(old.root);
-    const v = spawnCard(world, l, i, card);
-    s.cards[i] = v;
-    world.set(v.root, { scale: 0.01 });
-    world.animate(v.root, { scale: l.card }, { duration: 0.26, delay: i * 0.022, easing: 'back' });
-  });
-}
-
-/** A card turns over (face up or face down), lifting off the table as it turns; its fruit shows only face up. */
-export function flip(world: World, l: Layout, s: Scene, i: number, up: boolean) {
-  const v = s.cards[i];
-  if (!v) return;
-  const [x, y] = cardCentre(l, i);
-  const z = restZ(l);
-  world.stopAnimation(v.root);
-  world.animate(
-    v.root,
-    [
-      { rotation: EDGE_ON, position: [x, y, z + l.card * 0.28], at: 0.5 },
-      { rotation: up ? FACE_UP : FACE_DOWN, position: [x, y, z] }
-    ],
-    { duration: FLIP_TIME, easing: 'easeInOut' }
-  );
-  world.stopAnimation(v.fruit);
-  if (up) {
-    world.set(v.fruit, { scale: 0 });
-    world.animate(v.fruit, { scale: v.fruitScale }, { duration: FLIP_TIME / 2, delay: FLIP_TIME / 2, easing: 'easeOut' });
-  } else world.animate(v.fruit, { scale: 0 }, { duration: FLIP_TIME / 2, easing: 'easeIn' });
-}
-
-/** A pair found: both cards turn green and pulse. */
-export function matched(world: World, l: Layout, s: Scene, i: number) {
-  const v = s.cards[i];
-  if (!v) return;
-  world.set(v.body, { color: frontColor('matched') });
-  world.set(v.front, { color: borderColor('matched') });
-  world.animate(v.seal, { scale: FACE_SIZE }, { duration: 0.18, delay: FLIP_TIME, easing: 'back' });
-  world.animate(v.root, [{ scale: l.card * 1.04, at: 0.4 }, { scale: l.card }], { duration: 0.32, delay: FLIP_TIME, easing: 'easeOut' });
-}
-
-/** A miss: both cards shake. */
-export function mismatch(world: World, l: Layout, s: Scene, i: number) {
-  const v = s.cards[i];
-  if (v) world.animate(v.root, { shake: l.card * 0.06 }, { duration: 0.26, delay: FLIP_TIME });
-}
-
-/** Every pair found: a pulse wave across the board, and confetti. */
-export function celebrate(world: World, l: Layout, s: Scene) {
-  world.animate(
-    s.cards.map((v) => v.root),
-    [{ scale: l.card * 1.05, at: 0.4 }, { scale: l.card }],
-    {
-      duration: 0.32,
-      delay: 0.25,
-      stagger: 0.035,
-      easing: 'easeOut'
-    }
-  );
-  effects.confetti(world, {
-    position: [0, 0, l.card],
-    count: 70,
-    size: l.card * 0.08,
-    speed: l.boardW * 1.4,
-    lifetime: 1.3,
-    gravity: -l.boardW * 2.4,
-    colors: ['#FFD700', '#4CAF50', '#5b7cfa', '#FF6B6B'].map((c) => toColor(c))
-  });
-}
-
-/** Out of time: the cards not matched dim. */
-export function timeUp(world: World, s: Scene, cards: Card[]) {
-  const grey: Color = [0.55, 0.55, 0.6, 1];
-  const targets: Entity[] = [];
-  cards.forEach((c, i) => {
-    const v = s.cards[i];
-    if (!v || c.state === 'matched') return;
-    targets.push(v.body, v.backBody, v.back);
-  });
-  world.animate(targets, { color: grey }, { duration: 0.4 });
-}

package/src/games/mine-sweeper/MineSweeper.tsx

@@ -1,77 +0,0 @@
-// Mine Sweeper's screen, on the Nayan engine: the board, tiles, counts, flags and mines are one 3D scene
-// (an orthographic camera leaning back over the board), under Playtura's scoreboard, controls and
-// modals. The play is in MineSweeperGame.ts (the board's rules in MineSweeperRules.ts), what it draws
-// in MineSweeperScene.ts.
-//
-// One world serves the whole visit: Start, Stop and Play Again reset it in place and a theme change
-// repaints the board, so the GPU view is never rebuilt. Reveals, flags and explosions animate in the
-// engine's Rust core; JS reads the finger and steps the clock and the world once a frame.
-import { HapticType } from '../../services/HapticsService';
-import { GAME_SOUNDS } from '../../services/SoundsService';
-import { GAME_IDS, isTablet } from '../../services/UtilsService';
-import { engineGame, EngineGameScreen } from '../shared/EngineGameScreen';
-import { scoreColumn, textColumn, timerColumn } from '../shared/EngineHud';
-import { useEngineGame } from '../shared/useEngineGame';
-import { useLiveState } from '../shared/useLiveState';
-import { boardFor, getLayout, LIGHT, TIME_LIMIT } from './MineSweeperConstants';
-import { createGame, dispose, drag, type GameEvent, reset, setLayout, setTheme, start, tick } from './MineSweeperGame';
-
-const SOUNDS = GAME_SOUNDS.MINE_SWEEPER;
-// As the original game: the board's size is fixed for the device
-const BOARD = boardFor(isTablet);
-
-/** Each event's sound and haptic, as the original version played them. */
-const FEEDBACK: Record<GameEvent, { sound: (typeof SOUNDS)[keyof typeof SOUNDS]; haptic: HapticType }> = {
-  reveal: { sound: SOUNDS.REVEAL, haptic: HapticType.LIGHT },
-  flag: { sound: SOUNDS.FLAG, haptic: HapticType.MEDIUM },
-  mine: { sound: SOUNDS.MINE_HIT, haptic: HapticType.ERROR }
-};
-
-export const MineSweeper = engineGame(GAME_IDS.MINE_SWEEPER, (props) => {
-  const [score, setScore] = useLiveState(0);
-  const [time, setTime] = useLiveState(TIME_LIMIT);
-  const [mines, setMines] = useLiveState(BOARD.mines);
-
-  // Win or lose when the round ends
-  const { theme, status, screen, gameOver } = useEngineGame(props, {
-    gameId: GAME_IDS.MINE_SWEEPER,
-    create: (t) => createGame(t, BOARD),
-    start,
-    reset,
-    dispose,
-    tick,
-    setTheme,
-    resize: (g, width, height, offset) => {
-      const l = getLayout(width, height, offset, BOARD);
-      setLayout(g, l);
-      return l.boardWidth;
-    },
-    drag,
-    sounds: SOUNDS,
-    onStart: (fx) => fx(SOUNDS.START, HapticType.SUCCESS),
-    onStop: (fx) => fx(null, HapticType.MEDIUM),
-    onOver: (fx, s) => fx(s === 'win' ? SOUNDS.WIN : SOUNDS.GAME_OVER, s === 'win' ? HapticType.SUCCESS : HapticType.ERROR),
-    wire: (g, fx) => {
-      g.onScore = setScore;
-      g.onTime = setTime;
-      g.onMines = setMines;
-      g.onEvent = (event) => fx(FEEDBACK[event].sound, FEEDBACK[event].haptic);
-    }
-  });
-
-  return (
-    <EngineGameScreen
-      {...screen}
-      light={LIGHT}
-      columns={[scoreColumn(score), textColumn('MINES', mines), timerColumn(time, theme)]}
-      subtext="Reveal cells, flag mines!"
-      gameOver={gameOver({
-        title: status === 'win' ? 'YOU WON!' : 'BOOM!',
-        message: status === 'win' ? 'All mines cleared!' : 'You hit a mine!',
-        scoreLabel: 'Final Score',
-        score,
-        buttonText: 'Sweep Again!'
-      })}
-    />
-  );
-});

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

@@ -1,94 +0,0 @@
-// Mine Sweeper's rules, colors, timings and layout. Rules, board sizes and scoring match the original version
-// (games/mine-sweeper), so scores carry over.
-import { getScoreBoardTop } from '../shared/EngineHud';
-import type { TiltView } from '../shared/EngineTilt';
-import { frontLight, gameWidthFor } from '../shared/EngineUtils';
-
-// ── Rules ─────────────────────────────────────────────────────────────
-
-export type Board = { rows: number; cols: number; mines: number };
-/** 9 x 10 on a phone, 12 x 14 on a tablet (as the original game sized it), with 5 mines on either. */
-export const boardFor = (tablet: boolean): Board => (tablet ? { rows: 14, cols: 12, mines: 5 } : { rows: 10, cols: 9, mines: 5 });
-
-export const TIME_LIMIT = 180; // seconds
-export const POINTS_PER_REVEAL = 100;
-export const POINTS_PER_FLAG = 50;
-export const WIN_BONUS = 5000;
-
-// ── Touch and feel ────────────────────────────────────────────────────
-
-export const FLAG_HOLD = 0.3; // seconds a finger rests on a cell to flag it (as the original long press)
-export const TAP_SLOP = 10; // points a finger may wander and still tap or flag
-export const TAP_MAX = 0.5; // seconds: longer and a lift isn't a tap (as the original tap)
-export const GAME_OVER_DELAY = 0.4; // after a mine goes off
-export const REVEAL_STEP = 0.025; // revealed cells ripple out from the tap, this much a cell
-
-// ── Colors ────────────────────────────────────────────────────────────
-
-export const NUMBER_COLORS = ['', '#2196F3', '#4CAF50', '#F44336', '#9C27B0', '#FF9800', '#00BCD4', '#795548', '#607D8B'];
-export const COLORS = {
-  HIDDEN: '#3D7A4E',
-  HIDDEN_ALT: '#5DA86E',
-  REVEALED: '#F0E6D0',
-  REVEALED_ALT: '#E5DABE',
-  MINE: '#E74C3C',
-  CLASSIC_BOARD: 'rgba(255, 255, 255, 0.30)',
-  CLASSIC_GRID: 'rgba(255, 255, 255, 0.10)'
-} as const;
-
-// ── The scene ─────────────────────────────────────────────────────────
-
-/** The camera leans back from straight down, so the raised tiles, flags and mines stand up. */
-export const TILT = 0.34;
-/** Lit from the upper left; surfaces facing up off the board (+z) keep their exact color. */
-export const LIGHT = frontLight([-0.4, 0.5, 1], 0.45);
-
-// ── Layout (view points) ──────────────────────────────────────────────
-
-const SCOREBOARD_HEIGHT = 82;
-const CONTROLS_HEIGHT = 110;
-export const SPACING = 3; // between cells
-const PADDING = 6; // round the grid
-
-export type Layout = TiltView &
-  Board & { cell: number; pitch: number; gridWidth: number; gridHeight: number; boardWidth: number; boardHeight: number };
-
-/** Whole-point cells as wide as the game area allows (as the original board), smaller if the screen is short. */
-export function getLayout(width: number, height: number, offset: number, b: Board): Layout {
-  const gameWidth = gameWidthFor(width);
-  const top = getScoreBoardTop(offset) + SCOREBOARD_HEIGHT;
-  const room = Math.max(200, height - top - CONTROLS_HEIGHT);
-  const fromWidth = (gameWidth - PADDING * 2 - SPACING * (b.cols + 1)) / b.cols;
-  const fromHeight = (room / Math.cos(TILT) - PADDING * 2 - SPACING * (b.rows + 1)) / b.rows;
-  const cell = Math.max(10, Math.floor(Math.min(fromWidth, fromHeight)));
-  const gridWidth = b.cols * (cell + SPACING) + SPACING;
-  const gridHeight = b.rows * (cell + SPACING) + SPACING;
-  return {
-    ...b,
-    width,
-    height,
-    tilt: TILT,
-    centerY: top + room / 2,
-    cell,
-    pitch: cell + SPACING,
-    gridWidth,
-    gridHeight,
-    boardWidth: gridWidth + PADDING * 2,
-    boardHeight: gridHeight + PADDING * 2
-  };
-}
-
-/** A cell's centre on the board (row 0 along the top), in world units. */
-export function cellCentre(l: Layout, row: number, col: number): [number, number] {
-  return [-l.gridWidth / 2 + SPACING + col * l.pitch + l.cell / 2, l.gridHeight / 2 - SPACING - row * l.pitch - l.cell / 2];
-}
-
-/** The cell a board point is on (not in the gaps between cells), or null. */
-export function cellAt(l: Layout, x: number, y: number): [number, number] | null {
-  const lx = x + l.gridWidth / 2 - SPACING;
-  const ly = l.gridHeight / 2 - SPACING - y;
-  const col = Math.floor(lx / l.pitch);
-  const row = Math.floor(ly / l.pitch);
-  if (row < 0 || row >= l.rows || col < 0 || col >= l.cols) return null;
-  return lx - col * l.pitch <= l.cell && ly - row * l.pitch <= l.cell ? [row, col] : null;
-}

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

@@ -1,234 +0,0 @@
-// Mine Sweeper's play, with no React: build a game with `createGame`, give it a layout, `start` it and
-// `tick` it every frame. Tap a cell to reveal it (the mines are laid on the first reveal, never round
-// it, and an empty cell opens its neighbours); rest a finger on one to flag or unflag it. Reveal every
-// safe cell inside three minutes to win; a mine, or the clock running out, loses. The original service's and
-// store's rules, ported as they were.
-import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
-import { calculateTimeBasedScore } from '../../services/ScoringService';
-import type { GameTheme } from '../../services/ThemeService';
-import { aimTilted, unproject } from '../shared/EngineTilt';
-import {
-  type Board,
-  cellAt,
-  FLAG_HOLD,
-  GAME_OVER_DELAY,
-  type Layout,
-  POINTS_PER_FLAG,
-  POINTS_PER_REVEAL,
-  TAP_MAX,
-  TAP_SLOP,
-  TIME_LIMIT,
-  WIN_BONUS
-} from './MineSweeperConstants';
-import { type Cell, CellState, emptyGrid, floodReveal, placeMines } from './MineSweeperRules';
-import { buildScene, celebrate, explode, flag, removeScene, reveal, type Scene, setSceneTheme } from './MineSweeperScene';
-
-export type Phase = 'ready' | 'playing' | 'over';
-/** reveal: cells opened; flag: a flag planted; mine: one went off. */
-export type GameEvent = 'reveal' | 'flag' | 'mine';
-
-const WORLD_CAPACITY = 600; // up to 168 tiles and as many marks, the board, and the bursts
-
-export function createGame(theme: GameTheme, board: Board) {
-  const world = new World(WORLD_CAPACITY);
-  const camera: Camera = { eye: [0, 0, 240], target: [0, 0, 0], fov: 1, ortho: 1 };
-  const g = {
-    world,
-    camera,
-    theme,
-    board,
-    layout: null as Layout | null,
-    scene: null as Scene | null,
-    phase: 'ready' as Phase,
-    grid: emptyGrid(board),
-    firstReveal: true,
-    /** Set the moment a mine goes off: nothing more counts in the beat before the round ends. */
-    mineHit: false,
-    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
-    get score() {
-      return world.scoreboard.score;
-    },
-    get timeRemaining() {
-      return world.scoreboard.shownSeconds;
-    },
-    minesRemaining: board.mines,
-    revealed: 0,
-    won: false,
-    /** A finger down on the board: where, when, and whether it's already flagged (so the lift isn't a tap). */
-    press: null as { x: number; y: number; at: number; cell: [number, number] | null; flagged: boolean } | null,
-    /** Seconds on the game's clock, for telling taps from presses. */
-    clock: 0,
-    // UI hooks, set by the screen.
-    onPhase: (_p: Phase) => {},
-    onScore: (_s: number) => {},
-    onTime: (_t: number) => {},
-    onMines: (_n: number) => {},
-    onEvent: (_e: GameEvent) => {}
-  };
-  world.scoreboard.reset(0, TIME_LIMIT);
-  world.scoreboard.handlers = {
-    onSecond: (t) => g.onTime(t),
-    onTimeUp: () => g.phase === 'playing' && end(g, false)
-  };
-  return g;
-}
-export type Game = ReturnType<typeof createGame>;
-
-const safeCells = (b: Board) => b.rows * b.cols - b.mines;
-
-// ── Scene ─────────────────────────────────────────────────────────────
-
-/** Lays the board out for the view (first layout, header height, rotation): rebuilt from the grid's state. */
-export function setLayout(g: Game, l: Layout) {
-  if (g.scene) removeScene(g.world, g.scene);
-  g.layout = l;
-  aimTilted(g.camera, l);
-  g.scene = buildScene(g.world, l, g.theme, g.grid);
-}
-
-export function setTheme(g: Game, theme: GameTheme) {
-  g.theme = theme;
-  if (g.layout && g.scene) setSceneTheme(g.world, g.layout, g.scene, theme);
-}
-
-// ── Run ───────────────────────────────────────────────────────────────
-
-export function start(g: Game) {
-  if (g.phase !== 'ready') return;
-  g.phase = 'playing';
-  g.world.scoreboard.reset();
-  g.world.scoreboard.startCountdown(TIME_LIMIT);
-  g.revealed = 0;
-  g.firstReveal = true;
-  g.mineHit = false;
-  g.onScore(0);
-  g.onTime(TIME_LIMIT);
-  g.onPhase('playing');
-}
-
-/** A fresh, hidden board, not started (Stop, Play Again). The world, and the GPU view drawing it, are kept. */
-export function reset(g: Game) {
-  g.world.cancelTimers();
-  g.grid = emptyGrid(g.board);
-  g.firstReveal = true;
-  g.mineHit = false;
-  g.world.scoreboard.reset(0, TIME_LIMIT);
-  g.minesRemaining = g.board.mines;
-  g.revealed = 0;
-  g.won = false;
-  g.press = null;
-  g.phase = 'ready';
-  if (g.layout) setLayout(g, g.layout);
-  g.onScore(0);
-  g.onTime(TIME_LIMIT);
-  g.onMines(g.minesRemaining);
-  g.onPhase('ready');
-}
-
-export function dispose(g: Game) {
-  g.world.dispose();
-}
-
-export function tick(g: Game, dt: number) {
-  if (g.world.isDisposed) return;
-  g.clock += Math.min(dt, 0.25);
-  // A finger resting on a cell long enough flags it
-  const p = g.press;
-  if (p && !p.flagged && p.cell && g.clock - p.at >= FLAG_HOLD) {
-    p.flagged = true;
-    toggleFlag(g, p.cell[0], p.cell[1]);
-  }
-  g.world.update(dt);
-}
-
-function end(g: Game, won: boolean) {
-  g.world.scoreboard.stop();
-  g.won = won;
-  g.phase = 'over';
-  g.press = null;
-  g.onPhase('over');
-}
-
-// ── The finger ────────────────────────────────────────────────────────
-
-/** The cell under a view point (on the raised tiles' tops), or null between cells or off the board. */
-export function cellUnder(g: Game, x: number, y: number): [number, number] | null {
-  const l = g.layout;
-  if (!l) return null;
-  const [wx, wy] = unproject(l, x, y, l.cell * 0.32);
-  return cellAt(l, wx, wy);
-}
-
-/** Down on a cell starts a press; resting there flags it (in `tick`); a quick lift without wandering reveals it. */
-export function drag(g: Game, { phase, x, y }: DragEvent) {
-  if (phase === 'start') {
-    g.press = { x, y, at: g.clock, cell: cellUnder(g, x, y), flagged: false };
-    return;
-  }
-  const p = g.press;
-  if (!p) return;
-  if (Math.hypot(x - p.x, y - p.y) > TAP_SLOP) {
-    g.press = null; // a drag, not a tap or a press
-    return;
-  }
-  if (phase !== 'end') return;
-  g.press = null;
-  if (!p.flagged && p.cell && g.clock - p.at < TAP_MAX) revealAt(g, p.cell[0], p.cell[1]);
-}
-
-// ── Moves ─────────────────────────────────────────────────────────────
-
-/** Reveals a cell: a mine ends the round; otherwise it (and any empty run) opens, 100 points a cell. */
-export function revealAt(g: Game, row: number, col: number) {
-  if (g.phase !== 'playing' || g.mineHit) return;
-  const cell = g.grid[row]?.[col];
-  if (!cell || cell.state !== CellState.HIDDEN) return;
-  if (g.firstReveal) {
-    g.firstReveal = false;
-    placeMines(g.grid, g.board, row, col);
-  }
-  const { layout: l, scene: s } = g;
-  if (cell.isMine) {
-    g.mineHit = true;
-    const mines = g.grid.flat().filter((c) => c.isMine && c.state !== CellState.REVEALED);
-    for (const m of mines) m.state = CellState.REVEALED;
-    if (l && s) explode(g.world, l, s, g.camera, cell, mines);
-    g.onEvent('mine');
-    // The clock stops with the blast: the round ends on the mine, not the timer
-    g.world.scoreboard.stop();
-    g.world.after(GAME_OVER_DELAY, () => end(g, false));
-    return;
-  }
-  const opened: Cell[] = floodReveal(g.grid, g.board, row, col);
-  if (!opened.length) return;
-  for (const c of opened) c.state = CellState.REVEALED;
-  g.revealed += opened.length;
-  g.world.scoreboard.add(opened.length * POINTS_PER_REVEAL);
-  if (l && s) reveal(g.world, l, s, opened, cell);
-  g.onEvent('reveal');
-  if (g.revealed >= safeCells(g.board)) {
-    g.world.scoreboard.set(calculateTimeBasedScore(TIME_LIMIT - g.timeRemaining, TIME_LIMIT, g.score + WIN_BONUS));
-    g.onScore(g.score);
-    if (l) celebrate(g.world, l);
-    end(g, true);
-    return;
-  }
-  g.onScore(g.score);
-}
-
-/** Flags a hidden cell (50 points, one fewer mine to find) or takes its flag back off. */
-export function toggleFlag(g: Game, row: number, col: number) {
-  if (g.phase !== 'playing' || g.mineHit) return;
-  const cell = g.grid[row]?.[col];
-  if (!cell || cell.state === CellState.REVEALED) return;
-  const planting = cell.state === CellState.HIDDEN;
-  cell.state = planting ? CellState.FLAGGED : CellState.HIDDEN;
-  g.minesRemaining += planting ? -1 : 1;
-  if (planting) g.world.scoreboard.add(POINTS_PER_FLAG);
-  if (g.layout && g.scene) flag(g.world, g.layout, g.scene, cell);
-  g.onMines(g.minesRemaining);
-  if (planting) {
-    g.onScore(g.score);
-    g.onEvent('flag');
-  }
-}