@nayan-ui/games 1.18.0 → 1.20.0

package/src/games/penguin-run/PenguinRun.tsx

@@ -0,0 +1,77 @@
+// Penguin Run's screen, on the Nayan engine: the penguin dashing down an ancient jungle causeway seen
+// from a low chase camera, under Playtura's scoreboard, controls and modals. The rules are in
+// PenguinRunGame.ts, the world in PenguinRunScene.ts, the penguin and its animations in PenguinModel.ts.
+import { useMemo } from 'react';
+import { HapticType } from '../../services/HapticsService';
+import { GAME_SOUNDS } from '../../services/SoundsService';
+import { GAME_IDS } from '../../services/UtilsService';
+import { engineGame, EngineGameScreen } from '../shared/EngineGameScreen';
+import { livesColumn, scoreColumn, textColumn } from '../shared/EngineHud';
+import { useEngineGame } from '../shared/useEngineGame';
+import { useLiveState } from '../shared/useLiveState';
+import { MAX_LIVES, RESULTS_DELAY_LOSE, RESULTS_DELAY_WIN, TRACK_LENGTH } from './PenguinRunConstants';
+import { createGame, dispose, reset, setLayout, setTheme, start, steer, tick } from './PenguinRunGame';
+import { backgroundFor, FOG, lightFor } from './PenguinRunScene';
+
+const SFX = GAME_SOUNDS.PENGUIN_RUN;
+
+export const PenguinRun = engineGame(GAME_IDS.PENGUIN_RUN, (props) => {
+  const [score, setScore] = useLiveState(0);
+  const [coins, setCoins] = useLiveState(0);
+  const [lives, setLives] = useLiveState(MAX_LIVES);
+  const [distance, setDistance] = useLiveState(0);
+
+  const { theme, status, screen, gameOver } = useEngineGame(props, {
+    gameId: GAME_IDS.PENGUIN_RUN,
+    create: createGame,
+    start,
+    reset,
+    dispose,
+    tick,
+    setTheme,
+    resize: (g, width, height) => setLayout(g, width, height),
+    drag: (g, { phase, x, y }) => steer(g, phase, x, y),
+    sounds: SFX,
+    // The fall or the dance plays out before the results card covers it
+    resultsDelay: (s) => (s === 'win' ? RESULTS_DELAY_WIN : RESULTS_DELAY_LOSE),
+    onStart: (fx) => fx(SFX.START),
+    wire: (g, fx) => {
+      g.onScore = setScore;
+      g.onCoins = setCoins;
+      g.onLives = setLives;
+      g.onDistance = setDistance;
+      g.onCoin = (gem) => fx(gem ? SFX.GEM : SFX.COIN, gem ? HapticType.LIGHT : null);
+      g.onJump = () => fx(SFX.JUMP);
+      g.onSlide = () => fx(SFX.SLIDE);
+      g.onLane = () => fx(SFX.LANE_SWITCH, HapticType.LIGHT);
+      g.onHurt = () => fx(SFX.CRASH, HapticType.HEAVY);
+      g.onCrash = () => {
+        fx(SFX.CRASH, HapticType.HEAVY);
+        g.world.after(0.5, () => fx(SFX.GAME_OVER));
+      };
+      g.onWin = () => fx(GAME_SOUNDS.WELL_DONE, HapticType.SUCCESS);
+    }
+  });
+
+  const light = useMemo(() => lightFor(theme), [theme]);
+  const background = useMemo(() => backgroundFor(theme), [theme]);
+
+  return (
+    <EngineGameScreen
+      {...screen}
+      light={light}
+      background={background}
+      fog={FOG}
+      columns={[scoreColumn(score), livesColumn(lives, MAX_LIVES), textColumn('TRACK', `${TRACK_LENGTH - distance} m`)]}
+      subtext="Swipe, jump and slide!"
+      gameOver={gameOver({
+        title: status === 'win' ? 'YOU MADE IT!' : 'OUCH!',
+        message:
+          status === 'win' ? `Made it to the finish with ${coins} coins!` : `Out of lives after ${distance} of ${TRACK_LENGTH} m. Try a new track!`,
+        scoreLabel: 'Score',
+        score,
+        buttonText: status === 'win' ? 'Run Again!' : 'Try Again!'
+      })}
+    />
+  );
+});

package/src/games/penguin-run/PenguinRunConstants.ts

@@ -0,0 +1,69 @@
+// Penguin Run's tuning. Distances are metres, times seconds. The penguin runs toward -z.
+
+export const PENGUIN_SIZE = 1.2;
+
+/** Lane centres across the temple causeway. */
+export const LANE_X = [-1.7, 0, 1.7] as const;
+/** Lane changes follow a critically damped spring (higher = snappier), leaning into the move. */
+export const LANE_STIFFNESS = 14;
+export const LEAN_ROLL = 0.045;
+export const LEAN_YAW = 0.035;
+export const MAX_LEAN = 0.32;
+/** How quickly the camera drifts after the penguin's lane. */
+export const CAMERA_FOLLOW = 6;
+
+/** Run speed, held for the whole track. */
+export const SPEED_START = 7;
+
+/** The track is this long; crossing the finish line wins. */
+export const TRACK_LENGTH = 1000;
+/** Clear running at the start and before the finish. */
+export const START_CLEAR = 14;
+export const FINISH_CLEAR = 6;
+/** Paving rows are this long; a gap is one missing slab. */
+export const SLAB = 2;
+/** After a crash or a win, the scene plays (fall, dance) for this long before the results card. */
+export const RESULTS_DELAY_LOSE = 1700;
+export const RESULTS_DELAY_WIN = 2600;
+
+/** The causeway is built from tiles this long; this many stay ahead of the penguin. */
+export const TILE_LENGTH = 12;
+export const TILES_AHEAD = 9;
+export const TILES_BEHIND = 2;
+/** Causeway laid behind the start line (ending at a temple), so the start screen has scenery all round. */
+export const TILES_BEFORE_START = 3;
+/** Causeway past the finish line before the far temple. */
+export const TILES_PAST_FINISH = 3;
+
+/**
+ * Jumps and slides cover a set distance rather than a set time: the clips play faster as the run
+ * speeds up, so a jump timed the same way always clears a gap. Metres spent airborne / ducked, and
+ * the clip-length limits that keep them from feeling floaty when slow or frantic when fast.
+ */
+export const JUMP_AIR_METRES = 5.5;
+export const SLIDE_LOW_METRES = 7;
+export const JUMP_TIME: [number, number] = [0.7, 1.15];
+export const SLIDE_TIME: [number, number] = [0.8, 1.25];
+/**
+ * Fractions of each clip during which the penguin counts as off the ground (clears a gap) or low
+ * enough to pass under a gateway: generous, from just after it springs or drops to just before it lands
+ * or rises.
+ */
+export const GAP_WINDOW: [number, number] = [0.15, 0.9];
+export const LOW_WINDOW: [number, number] = [0.08, 0.94];
+/** How far from a gap's centre the penguin falls in (the slab is SLAB long; the broken edges forgive). */
+export const GAP_HALF = 0.45;
+
+/** Hits the penguin can take; after one it stumbles on and can't be hurt again for a moment. */
+export const MAX_LIVES = 3;
+export const HURT_INVULNERABLE = 2.2;
+
+/** How deep (along z) an obstacle is for collisions, and how close in x counts as the same lane. */
+export const HIT_DEPTH = 0.3;
+export const LANE_TOLERANCE = 0.7;
+export const COIN_RADIUS = 1.1;
+
+// Points
+export const POINTS_PER_METRE = 2;
+export const POINTS_COIN = 20;
+export const POINTS_GEM = 200;

package/src/games/penguin-run/PenguinRunGame.ts

@@ -0,0 +1,406 @@
+// Penguin Run's rules: a TRACK_LENGTH dash down an ancient jungle causeway, laid out fresh by
+// `generateTrack` for every attempt. The penguin runs on its own, faster and faster; swipe left/right
+// to change lane (and chase the coin trail), up to jump broken gaps, down to slide under spiked
+// gateways. Coins add to the score. A mistake costs one of three lives (the
+// penguin stumbles on, briefly untouchable); losing the last ends the run with a fall or crash played
+// out before the results. Reaching the finish line wins and the penguin dances.
+//
+// The world stays put and the penguin (and camera) run toward -z; tiles are built ahead and cleared
+// behind, so only the penguin and camera move every frame.
+import { type Camera, type MutableQuat, quat, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { CLIP_TIME, placePenguin, playPenguin, preparePenguin, spawnPenguin } from './PenguinModel';
+import {
+  CAMERA_FOLLOW,
+  COIN_RADIUS,
+  GAP_HALF,
+  GAP_WINDOW,
+  HIT_DEPTH,
+  HURT_INVULNERABLE,
+  JUMP_AIR_METRES,
+  JUMP_TIME,
+  LANE_STIFFNESS,
+  LANE_TOLERANCE,
+  LANE_X,
+  LEAN_ROLL,
+  LEAN_YAW,
+  LOW_WINDOW,
+  MAX_LEAN,
+  MAX_LIVES,
+  PENGUIN_SIZE,
+  POINTS_COIN,
+  POINTS_GEM,
+  POINTS_PER_METRE,
+  SLIDE_LOW_METRES,
+  SLIDE_TIME,
+  SPEED_START,
+  TILE_LENGTH,
+  TILES_AHEAD,
+  TILES_BEFORE_START,
+  TILES_BEHIND,
+  TRACK_LENGTH
+} from './PenguinRunConstants';
+import {
+  coinSparkle,
+  crashDust,
+  despawnTile,
+  generateTrack,
+  LAST_TILE,
+  prepareRunMeshes,
+  spawnTile,
+  type Tile,
+  type TrackPlan
+} from './PenguinRunScene';
+
+export type Phase = 'ready' | 'playing' | 'over';
+type Action = 'jump' | 'slide' | 'hit' | null;
+
+const noop = () => {};
+const newSeed = () => Math.floor(Math.random() * 1e9);
+
+export function createGame(theme: GameTheme) {
+  preparePenguin();
+  prepareRunMeshes();
+  const world = new World(1800);
+  const g = {
+    world,
+    theme,
+    penguin: spawnPenguin(world, [0, 0, 0], PENGUIN_SIZE),
+    camera: { eye: [0, 3.1, 5.4], target: [0, 1.1, -6], fov: 0.9 } as Camera,
+    phase: 'ready' as Phase,
+    won: false,
+    plan: generateTrack(newSeed()) as TrackPlan,
+    tiles: [] as Tile[],
+    nextTile: 0,
+    lane: 1,
+    x: 0,
+    vx: 0,
+    camX: 0,
+    z: 0,
+    speed: SPEED_START,
+    distance: 0,
+    lastDistance: 0,
+    coins: 0,
+    gems: 0,
+    score: 0,
+    lives: MAX_LIVES,
+    invulnerable: 0,
+    action: null as Action,
+    /** A jump / slide swiped while the same one was still playing: it goes as soon as that one ends, if within QUEUE_TIME. */
+    queued: null as 'jump' | 'slide' | null,
+    queuedT: 0,
+    actionT: 0,
+    actionDur: 0,
+    orbit: 0,
+    onPhase: noop as (phase: Phase) => void,
+    onScore: noop as (score: number) => void,
+    onCoins: noop as (coins: number) => void,
+    onLives: noop as (lives: number) => void,
+    onHurt: noop,
+    onDistance: noop as (metres: number) => void,
+    onCoin: noop as (gem: boolean) => void,
+    onJump: noop,
+    onSlide: noop,
+    onLane: noop,
+    onCrash: noop,
+    onWin: noop
+  };
+  reset(g);
+  return g;
+}
+export type Game = ReturnType<typeof createGame>;
+
+const runPace = (g: Game) => Math.min(1.7, Math.max(1, g.speed / SPEED_START));
+
+/** Builds tiles out to TILES_AHEAD in front of the penguin and clears those well behind it. */
+function keepTiles(g: Game) {
+  while (g.nextTile <= LAST_TILE && g.nextTile * TILE_LENGTH < -g.z + TILES_AHEAD * TILE_LENGTH) {
+    g.tiles.push(spawnTile(g.world, g.nextTile, g.theme, g.plan));
+    g.nextTile++;
+  }
+  while (g.tiles.length && g.tiles[0]!.z - TILE_LENGTH > g.z + TILES_BEHIND * TILE_LENGTH) despawnTile(g.world, g.tiles.shift()!);
+}
+
+// Scratch for the per-frame root rotation (world.set copies it).
+const LEAN_Q: MutableQuat = [0, 0, 0, 1];
+const TURN_Q: MutableQuat = [0, 0, 0, 1];
+const ROOT_Q: MutableQuat = [0, 0, 0, 1];
+
+function place(g: Game) {
+  // Facing down the causeway, turned and banked a little into a lane change
+  const lean = Math.max(-MAX_LEAN, Math.min(MAX_LEAN, g.vx * LEAN_ROLL));
+  const turn = Math.max(-MAX_LEAN, Math.min(MAX_LEAN, g.vx * LEAN_YAW));
+  g.world.set(g.penguin.root, { position: [g.x, 0, g.z], rotation: quat.multiply(quat.z(-lean, LEAN_Q), quat.y(Math.PI - turn, TURN_Q), ROOT_Q) });
+  g.penguin.x = g.x;
+  g.penguin.yaw = Math.PI - turn;
+  aimCamera(g);
+}
+
+/** Chase camera: low behind the penguin, drifting after its lane, looking down the causeway. */
+function aimCamera(g: Game) {
+  g.camera.eye = [g.camX, 3.1, g.z + 5.4];
+  g.camera.target = [g.camX, 1.1, g.z - 6];
+}
+
+/** Start screen: circling the waiting penguin, as Car Racing circles its car. */
+function orbitCamera(g: Game, dt: number) {
+  g.orbit += dt * 0.35;
+  const a = g.orbit + 0.9;
+  g.camera.eye = [g.x + Math.sin(a) * 4.2, 1.9, g.z + Math.cos(a) * 4.2];
+  g.camera.target = [g.x, 0.8, g.z];
+}
+
+/** A fresh attempt: a newly generated track, the penguin waiting at the start. */
+export function reset(g: Game) {
+  g.world.cancelTimers();
+  for (const t of g.tiles) despawnTile(g.world, t);
+  g.tiles = [];
+  g.nextTile = -TILES_BEFORE_START;
+  g.plan = generateTrack(newSeed());
+  g.won = false;
+  g.lane = 1;
+  g.x = LANE_X[1];
+  g.vx = 0;
+  g.camX = 0;
+  g.z = 0;
+  g.speed = SPEED_START;
+  g.distance = g.coins = g.gems = g.score = 0;
+  g.lives = MAX_LIVES;
+  g.invulnerable = 0;
+  g.action = null;
+  g.queued = null;
+  g.orbit = 0;
+  g.world.stopAnimation(g.penguin.root);
+  placePenguin(g.world, g.penguin, 0, Math.PI);
+  keepTiles(g);
+  place(g);
+  playPenguin(g.world, g.penguin, 'idle');
+  setPhase(g, 'ready');
+  g.onScore(0);
+  g.onCoins(0);
+  g.onLives(MAX_LIVES);
+  g.lastDistance = 0;
+  g.onDistance(0);
+}
+
+function setPhase(g: Game, phase: Phase) {
+  g.phase = phase;
+  g.onPhase(phase);
+}
+
+export function start(g: Game) {
+  if (g.phase === 'over') reset(g);
+  playPenguin(g.world, g.penguin, 'run');
+  aimCamera(g);
+  setPhase(g, 'playing');
+}
+
+export function swipe(g: Game, direction: 'left' | 'right' | 'up' | 'down') {
+  if (g.phase !== 'playing') return;
+  if (direction === 'left' || direction === 'right') {
+    const lane = Math.max(0, Math.min(2, g.lane + (direction === 'left' ? -1 : 1)));
+    if (lane === g.lane) return;
+    g.lane = lane;
+    g.onLane();
+    return;
+  }
+  const action = direction === 'up' ? 'jump' : 'slide';
+  if (g.action === action) {
+    g.queued = action;
+    g.queuedT = QUEUE_TIME;
+    return;
+  }
+  g.queued = null;
+  g.action = action;
+  g.actionT = 0;
+  // Long enough to stay airborne / low for a set distance at the current speed, within limits
+  const [metres, window, [minT, maxT]] = action === 'jump' ? [JUMP_AIR_METRES, GAP_WINDOW, JUMP_TIME] : [SLIDE_LOW_METRES, LOW_WINDOW, SLIDE_TIME];
+  g.actionDur = Math.min(maxT, Math.max(minT, metres / ((window[1] - window[0]) * g.speed)));
+  playPenguin(g.world, g.penguin, action, CLIP_TIME[action] / g.actionDur);
+  if (action === 'jump') g.onJump();
+  else g.onSlide();
+}
+
+const DRAG_THRESHOLD = 18;
+/** How long a jump / slide swiped too early is kept for (seconds). */
+const QUEUE_TIME = 0.35;
+const drag = { x: 0, y: 0, fired: false };
+
+/**
+ * Drag controls, as in the other engine games: a move fires mid-stroke as soon as the finger has
+ * travelled DRAG_THRESHOLD points (no waiting for release), one move per stroke.
+ */
+export function steer(g: Game, phase: 'start' | 'move' | 'end', x: number, y: number) {
+  if (phase === 'start') {
+    drag.x = x;
+    drag.y = y;
+    drag.fired = false;
+    return;
+  }
+  if (phase === 'end' || drag.fired) return;
+  const dx = x - drag.x;
+  const dy = y - drag.y;
+  if (Math.max(Math.abs(dx), Math.abs(dy)) < DRAG_THRESHOLD) return;
+  drag.fired = true;
+  if (Math.abs(dx) > Math.abs(dy)) swipe(g, dx < 0 ? 'left' : 'right');
+  else swipe(g, dy < 0 ? 'up' : 'down');
+}
+
+/** Where the penguin is in its jump or slide, 0..1 (the clip starts after a short blend). */
+const actionFrac = (g: Game) => Math.max(0, g.actionT - 0.06) / g.actionDur;
+const airborne = (g: Game) => g.action === 'jump' && actionFrac(g) >= GAP_WINDOW[0] && actionFrac(g) <= GAP_WINDOW[1];
+const ducking = (g: Game) => g.action === 'slide' && actionFrac(g) >= LOW_WINDOW[0] && actionFrac(g) <= LOW_WINDOW[1];
+
+/** A hit with lives to spare: a life lost, a stumble, and a moment when nothing can hurt it. */
+function hurt(g: Game) {
+  g.lives--;
+  g.onLives(g.lives);
+  g.invulnerable = HURT_INVULNERABLE;
+  g.action = 'hit';
+  g.actionT = 0;
+  g.actionDur = CLIP_TIME.hit / 1.3;
+  playPenguin(g.world, g.penguin, 'hit', 1.3);
+  crashDust(g.world, [g.x, 0.5, g.z - 0.4]);
+  g.camera.shake = 0.22;
+  g.onHurt();
+}
+
+/** Smacked into a gateway: knocked down where it stands, then the results. */
+function crash(g: Game) {
+  g.lives = 0;
+  g.onLives(0);
+  g.action = null;
+  playPenguin(g.world, g.penguin, 'dead');
+  crashDust(g.world, [g.x, 0.6, g.z - 0.4]);
+  g.camera.shake = 0.35;
+  g.onCrash();
+  setPhase(g, 'over');
+}
+
+/** Ran into a gap: tumbles down into the chasm as it topples, the camera watching from the edge. */
+function fall(g: Game) {
+  g.lives = 0;
+  g.onLives(0);
+  g.action = null;
+  playPenguin(g.world, g.penguin, 'dead', 1.4);
+  g.world.animate(g.penguin.root, { position: [g.x, -7, g.z - 1.2] }, { duration: 1.3, easing: 'easeIn' });
+  crashDust(g.world, [g.x, 0, g.z - 0.6]);
+  g.camera.shake = 0.15;
+  g.onCrash();
+  setPhase(g, 'over');
+}
+
+/** Crossed the finish line: slows to a stop, turns to the camera and dances. */
+function win(g: Game) {
+  g.won = true;
+  g.action = null;
+  g.world.animate(g.penguin.root, { rotation: quat.y(0) }, { duration: 0.5, delay: 0.5, easing: 'easeInOut' });
+  playPenguin(g.world, g.penguin, 'dance');
+  g.onWin();
+  setPhase(g, 'over');
+}
+
+export function tick(g: Game, dt: number) {
+  if (g.world.isDisposed) return;
+  if (g.phase === 'playing') {
+    g.speed = SPEED_START;
+    const step = g.speed * dt;
+    g.z -= step;
+    g.distance += step;
+
+    // Lane change: a critically damped spring toward the lane (smooth, and a second swipe mid-move
+    // just retargets it); sub-stepped so it stays stable on long frames
+    const w = LANE_STIFFNESS;
+    const steps = Math.max(1, Math.ceil(dt / 0.008));
+    const h = dt / steps;
+    for (let i = 0; i < steps; i++) {
+      g.vx += (w * w * (LANE_X[g.lane]! - g.x) - 2 * w * g.vx) * h;
+      g.x += g.vx * h;
+    }
+    g.camX += (g.x * 0.4 - g.camX) * (1 - Math.exp(-dt * CAMERA_FOLLOW));
+    g.invulnerable = Math.max(0, g.invulnerable - dt);
+
+    // Jump / slide timing; back to running when it ends
+    g.queuedT = Math.max(0, g.queuedT - dt);
+    if (g.action) {
+      g.actionT += dt;
+      if (g.actionT >= g.actionDur + 0.06) {
+        g.action = null;
+        const next = g.queuedT > 0 ? g.queued : null;
+        g.queued = null;
+        if (next) swipe(g, next === 'jump' ? 'up' : 'down');
+        else playPenguin(g.world, g.penguin, 'run', runPace(g));
+      }
+    }
+
+    keepTiles(g);
+    place(g);
+
+    // Obstacles and coins level with the penguin
+    for (const tile of g.tiles) {
+      if (tile.z < g.z - TILE_LENGTH || tile.z - TILE_LENGTH > g.z + TILE_LENGTH) continue;
+      for (const o of tile.obstacles) {
+        if (g.invulnerable > 0 || Math.abs(LANE_X[o.lane]! - g.x) > LANE_TOLERANCE) continue;
+        const hit =
+          o.kind === 'gap' ? Math.abs(o.z - g.z) < GAP_HALF && !airborne(g) : Math.abs(o.z - g.z) < HIT_DEPTH && !(o.kind === 'beam' && ducking(g));
+        if (!hit) continue;
+        if (g.lives > 1) {
+          hurt(g);
+          break;
+        }
+        return finish(g, dt, o.kind === 'gap' ? fall : crash);
+      }
+      for (const p of tile.pickups) {
+        if (p.taken || Math.abs(p.z - g.z) > COIN_RADIUS || Math.abs(LANE_X[p.lane]! - g.x) > LANE_TOLERANCE) continue;
+        p.taken = true;
+        g.world.despawn(p.e);
+        coinSparkle(g.world, [LANE_X[p.lane]!, p.y, p.z], p.gem);
+        if (p.gem) g.gems++;
+        else g.coins++;
+        g.onCoins(g.coins + g.gems * 10);
+        g.onCoin(p.gem);
+      }
+    }
+
+    const metres = Math.min(TRACK_LENGTH, Math.floor(g.distance));
+    const score = metres * POINTS_PER_METRE + g.coins * POINTS_COIN + g.gems * POINTS_GEM;
+    if (score !== g.score) {
+      g.score = score;
+      g.onScore(score);
+    }
+    if (metres !== g.lastDistance) {
+      g.lastDistance = metres;
+      g.onDistance(metres);
+    }
+    if (g.distance >= TRACK_LENGTH) return finish(g, dt, win);
+  } else if (g.phase === 'over' && g.won && g.speed > 0) {
+    // Running on past the line, slowing to a stop
+    g.speed = Math.max(0, g.speed - 22 * dt);
+    g.z -= g.speed * dt;
+    g.world.set(g.penguin.root, { position: [g.x, 0, g.z] });
+    aimCamera(g);
+  } else if (g.phase === 'ready') orbitCamera(g, dt);
+  g.world.update(dt);
+}
+
+function finish(g: Game, dt: number, end: (g: Game) => void) {
+  end(g);
+  g.world.update(dt);
+}
+
+export function setLayout(g: Game, width: number, height: number) {
+  g.camera.fov = width / Math.max(1, height) < 0.7 ? 1.0 : 0.85;
+}
+
+/** Day or night: rebuilds the tiles in view with the new lighting tint (the run carries on). */
+export function setTheme(g: Game, theme: GameTheme) {
+  if (theme === g.theme || g.world.isDisposed) return;
+  g.theme = theme;
+  const indices = g.tiles.map((t) => t.index);
+  for (const t of g.tiles) despawnTile(g.world, t);
+  g.tiles = indices.map((i) => spawnTile(g.world, i, theme, g.plan));
+}
+
+export function dispose(g: Game) {
+  g.world.dispose();
+}