@nayan-ui/games 1.20.0 → 1.21.0

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

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

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

@@ -1,406 +0,0 @@
-// 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();
-}