@nayan-ui/games 1.20.0 → 1.21.0

package/src/games/pac-man/PacManConstants.ts

@@ -1,169 +0,0 @@
-// Pac-Man's maze, rules, timings and layout, on the Nayan engine. The maze, scoring and lives match
-// the original version (games/pac-man), so scores carry over: 100 a dot, 500 a power pellet, 500 a ghost
-// (doubling in a chain), 300 the fruit, three lives, clear every dot within five minutes to win.
-import { getScoreBoardTop } from '../shared/EngineHud';
-import type { TiltView } from '../shared/EngineTilt';
-import { frontLight, gameWidthFor } from '../shared/EngineUtils';
-
-// ── Grid ──────────────────────────────────────────────────────────────
-
-export const COLS = 19;
-export const ROWS = 21;
-
-// ── Rules / scoring (as the original version) ─────────────────────────────
-
-export const POINTS_PER_DOT = 100;
-export const POINTS_PER_POWER_PELLET = 500;
-export const POINTS_PER_GHOST = 500; // doubles for each ghost eaten in a chain
-export const POINTS_PER_FRUIT = 300;
-export const INITIAL_LIVES = 3;
-export const TIME_LIMIT = 300; // seconds; clear every dot in this time or lose
-
-// ── Timings (seconds) ─────────────────────────────────────────────────
-
-export const PAC_STEP = 0.16; // seconds Pac-Man takes to cross a cell
-export const GHOST_STEP = 0.25; // slightly slower pursuit gives the player more room to react
-export const GHOST_EATEN_STEP = 0.1; // eyes race back to the house
-export const POWER_PELLET_TIME = 7; // ghosts frightened this long
-export const FLASH_TIME = 2; // frightened ghosts flash for the last of it
-export const SCATTER_TIME = 7;
-export const CHASE_TIME = 20;
-export const FRUIT_TIME = 10; // the fruit waits this long
-export const FRUIT_SPAWN_DOTS = [70, 170]; // dots eaten when the fruit appears
-export const CHOMP_TIME = 0.16; // one open/close of the mouth
-
-// ── Cells, ghosts ─────────────────────────────────────────────────────
-
-export enum CellType {
-  EMPTY = 0,
-  WALL = 1,
-  DOT = 2,
-  POWER_PELLET = 3,
-  GHOST_HOUSE = 4,
-  GHOST_DOOR = 5,
-  TUNNEL = 6
-}
-
-export enum GhostMode {
-  SCATTER = 'scatter',
-  CHASE = 'chase',
-  FRIGHTENED = 'frightened',
-  EATEN = 'eaten',
-  IN_HOUSE = 'in_house',
-  LEAVING_HOUSE = 'leaving_house'
-}
-
-export enum GhostName {
-  BLINKY = 'blinky',
-  PINKY = 'pinky',
-  INKY = 'inky',
-  CLYDE = 'clyde'
-}
-
-export type Direction = 'UP' | 'DOWN' | 'LEFT' | 'RIGHT' | 'NONE';
-export const DIRECTIONS: Record<Direction, { x: number; y: number }> = {
-  UP: { x: 0, y: -1 },
-  DOWN: { x: 0, y: 1 },
-  LEFT: { x: -1, y: 0 },
-  RIGHT: { x: 1, y: 0 },
-  NONE: { x: 0, y: 0 }
-};
-export const OPPOSITE: Record<Direction, Direction> = { UP: 'DOWN', DOWN: 'UP', LEFT: 'RIGHT', RIGHT: 'LEFT', NONE: 'NONE' };
-
-export const GHOST_LIST = [GhostName.BLINKY, GhostName.PINKY, GhostName.INKY, GhostName.CLYDE] as const;
-
-export const GHOST_COLORS: Record<GhostName, string> = {
-  [GhostName.BLINKY]: '#FF2E2E',
-  [GhostName.PINKY]: '#FFB8FF',
-  [GhostName.INKY]: '#36E2FF',
-  [GhostName.CLYDE]: '#FFB852'
-};
-
-export const COLORS = {
-  BOARD: '#0A0A2E',
-  WALL: '#2742F0',
-  WALL_EDGE: '#5A72FF',
-  DOT: '#FFE2B0',
-  PELLET: '#FFF4D6',
-  PACMAN: '#FFE000',
-  FRUIT: '#FF4040',
-  FRUIT_STEM: '#4CAF50',
-  FRIGHTENED: '#2334E8',
-  FRIGHTENED_FLASH: '#F4F4FF',
-  EYE: '#FFFFFF',
-  PUPIL: '#1A1A6E'
-} as const;
-
-// Lit from the upper left; surfaces facing up off the board keep their exact color.
-export const LIGHT = frontLight([-0.35, 0.5, 1], 0.5);
-export const TILT = 0.34;
-
-// ── Classic maze (0 empty, 1 wall, 2 dot, 3 pellet, 4 house, 5 door, 6 tunnel) ──
-
-export const PACMAN_MAZE: number[][] = [
-  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
-  [1, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 1],
-  [1, 3, 1, 1, 2, 1, 1, 1, 2, 1, 2, 1, 1, 1, 2, 1, 1, 3, 1],
-  [1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1],
-  [1, 2, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 2, 1],
-  [1, 2, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 1],
-  [1, 1, 1, 1, 2, 1, 1, 1, 0, 1, 0, 1, 1, 1, 2, 1, 1, 1, 1],
-  [0, 0, 0, 1, 2, 1, 0, 0, 0, 0, 0, 0, 0, 1, 2, 1, 0, 0, 0],
-  [1, 1, 1, 1, 2, 1, 0, 1, 1, 5, 1, 1, 0, 1, 2, 1, 1, 1, 1],
-  [6, 0, 0, 0, 2, 0, 0, 1, 4, 4, 4, 1, 0, 0, 2, 0, 0, 0, 6],
-  [1, 1, 1, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 2, 1, 1, 1, 1],
-  [0, 0, 0, 1, 2, 1, 0, 0, 0, 0, 0, 0, 0, 1, 2, 1, 0, 0, 0],
-  [1, 1, 1, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 2, 1, 1, 1, 1],
-  [1, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 1],
-  [1, 2, 1, 1, 2, 1, 1, 1, 2, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1],
-  [1, 3, 2, 1, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 1, 2, 3, 1],
-  [1, 1, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 1],
-  [1, 2, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 1],
-  [1, 2, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 2, 1],
-  [1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1],
-  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
-];
-
-export const PACMAN_START = { x: 9, y: 15 };
-export const GHOST_START: Record<GhostName, { x: number; y: number }> = {
-  [GhostName.BLINKY]: { x: 9, y: 7 },
-  [GhostName.PINKY]: { x: 9, y: 9 },
-  [GhostName.INKY]: { x: 8, y: 9 },
-  [GhostName.CLYDE]: { x: 10, y: 9 }
-};
-export const GHOST_SCATTER: Record<GhostName, { x: number; y: number }> = {
-  [GhostName.BLINKY]: { x: 17, y: 0 },
-  [GhostName.PINKY]: { x: 1, y: 0 },
-  [GhostName.INKY]: { x: 17, y: 20 },
-  [GhostName.CLYDE]: { x: 1, y: 20 }
-};
-/** Seconds after the game starts before each ghost leaves the house. */
-export const GHOST_RELEASE: Record<GhostName, number> = {
-  [GhostName.BLINKY]: 0,
-  [GhostName.PINKY]: 2,
-  [GhostName.INKY]: 5,
-  [GhostName.CLYDE]: 8
-};
-export const HOUSE_DOOR = { x: 9, y: 9 }; // where eaten ghosts return
-
-// ── Layout (view points) ──────────────────────────────────────────────
-
-const SCOREBOARD_HEIGHT = 82;
-const CONTROLS_HEIGHT = 120;
-const RIM = 0; // no frame round the maze: it fills the game width
-const WALL_STAND = 1.4; // how much the raised walls add to the board's height on screen
-
-export type Layout = TiltView & { cell: number; sizeX: number; sizeY: number };
-
-/** The maze as wide as the game area, centred between the scoreboard and the controls. */
-export function getLayout(width: number, height: number, offset: number): Layout {
-  const top = getScoreBoardTop(offset) + SCOREBOARD_HEIGHT;
-  const room = Math.max(200, height - top - CONTROLS_HEIGHT);
-  const fromWidth = gameWidthFor(width) / (COLS + RIM * 2);
-  const fromHeight = room / (Math.cos(TILT) * (ROWS + RIM * 2) + Math.sin(TILT) * WALL_STAND);
-  const cell = Math.max(6, Math.floor(Math.min(fromWidth, fromHeight)));
-  return { width, height, tilt: TILT, centerY: top + room / 2, cell, sizeX: cell * COLS, sizeY: cell * ROWS };
-}
-
-/** A grid point (cell units, 0.5 = a cell's centre) on the maze, in world units. Row 0 is the top. */
-export const gridPoint = (l: Layout, x: number, y: number): [number, number] => [x * l.cell - l.sizeX / 2, l.sizeY / 2 - y * l.cell];

package/src/games/pac-man/PacManGame.ts

@@ -1,406 +0,0 @@
-// Pac-Man's play, with no React: build a game with `createGame`, give it a layout, `start` it and
-// `tick` it every frame. Pac-Man creeps a cell every PAC_STEP on the game's own clock; the ghosts step
-// on theirs, leave the house on a timer, chase or scatter, and turn blue when a power pellet is eaten.
-// Eat every dot to win; lose all three lives or run the five minutes out to lose.
-import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
-import type { GameTheme } from '../../services/ThemeService';
-import { aimTilted } from '../shared/EngineTilt';
-import {
-  CHASE_TIME,
-  CHOMP_TIME,
-  type Direction,
-  FLASH_TIME,
-  FRUIT_SPAWN_DOTS,
-  FRUIT_TIME,
-  GHOST_LIST,
-  GHOST_RELEASE,
-  GHOST_STEP,
-  GhostMode,
-  GhostName,
-  INITIAL_LIVES,
-  type Layout,
-  PAC_STEP,
-  POINTS_PER_FRUIT,
-  POINTS_PER_GHOST,
-  POWER_PELLET_TIME,
-  SCATTER_TIME,
-  TIME_LIMIT
-} from './PacManConstants';
-import {
-  collides,
-  eatAt,
-  frightenGhosts,
-  initGhosts,
-  initMaze,
-  initPacman,
-  moveGhost as aiMoveGhost,
-  reachedHouse,
-  releaseGhost,
-  stepPacman
-} from './PacManRules';
-import {
-  buildScene,
-  clearDots,
-  dressGhost,
-  eatDot,
-  fruitEaten,
-  ghostEaten,
-  moveGhost as sceneMoveGhost,
-  movePacman,
-  pacmanHit,
-  placeFruit,
-  removeScene,
-  type Scene,
-  setPacman,
-  setSceneTheme,
-  startChomp,
-  stopChomp
-} from './PacManScene';
-
-export type Phase = 'ready' | 'playing' | 'over';
-export type GameEvent = 'chomp' | 'pellet' | 'fruit' | 'eatGhost' | 'eatGhostCombo' | 'lifeLost';
-
-const WORLD_CAPACITY = 500;
-const MAX_STEP = 0.1;
-const SWIPE = 15;
-
-export function createGame(theme: GameTheme) {
-  const world = new World(WORLD_CAPACITY);
-  const camera: Camera = { eye: [0, 0, 240], target: [0, 0, 0], fov: 1, ortho: 1 };
-  const maze = initMaze();
-  const g = {
-    world,
-    camera,
-    theme,
-    layout: null as Layout | null,
-    scene: null as Scene | null,
-    phase: 'ready' as Phase,
-    maze,
-    pacman: initPacman(),
-    ghosts: initGhosts(),
-    fruit: null as { x: number; y: number } | null,
-    fruitExpireAt: 0,
-    /** Score, lives and the countdown live in the engine (Rust), advanced by world.update. */
-    get score() {
-      return world.scoreboard.score;
-    },
-    get lives() {
-      return world.scoreboard.lives;
-    },
-    won: false,
-    combo: 0,
-    mode: GhostMode.SCATTER as GhostMode.SCATTER | GhostMode.CHASE,
-    modeTimer: SCATTER_TIME,
-    elapsed: 0, // seconds this life has been running (for ghost release)
-    get timeLeft() {
-      return world.scoreboard.shownSeconds;
-    },
-    clock: 0,
-    pacPending: 0,
-    ghostPending: 0,
-    anchor: null as [number, number] | null,
-    // UI hooks, set by the screen.
-    onPhase: (_p: Phase) => {},
-    onScore: (_s: number) => {},
-    onLives: (_l: number) => {},
-    onTime: (_t: number) => {},
-    onEvent: (_e: GameEvent) => {}
-  };
-  world.scoreboard.reset(INITIAL_LIVES, TIME_LIMIT);
-  world.scoreboard.handlers = {
-    onScore: (s) => g.onScore(s),
-    onSecond: (t) => g.onTime(t),
-    onTimeUp: () => g.phase === 'playing' && lose(g)
-  };
-  return g;
-}
-export type Game = ReturnType<typeof createGame>;
-
-// ── Scene ─────────────────────────────────────────────────────────────
-
-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);
-  redraw(g);
-  // A rebuilt scene (a new layout mid-game) picks the chomping back up
-  if (g.phase === 'playing') startChomp(g.world, g.scene, CHOMP_TIME);
-  else stopChomp(g.world, g.scene);
-}
-
-export function setTheme(g: Game, theme: GameTheme) {
-  g.theme = theme;
-  if (g.scene) setSceneTheme(g.world, g.scene, theme);
-}
-
-/** Puts every piece where the state says, with no gliding (first layout, resets). */
-function redraw(g: Game) {
-  const { layout: l, scene: s } = g;
-  if (!l || !s) return;
-  setPacman(g.world, l, s, g.pacman.x, g.pacman.y, g.pacman.direction);
-  for (const name of GHOST_LIST) {
-    const gh = g.ghosts.find((x) => x.name === name)!;
-    sceneMoveGhost(g.world, l, s, name, gh.x, gh.y, 0, true);
-    dressGhost(g.world, l, s, name, gh.mode, gh.isFlashing);
-  }
-  placeFruit(g.world, l, s, g.fruit);
-}
-
-// ── Run ───────────────────────────────────────────────────────────────
-
-function home(g: Game) {
-  g.maze = initMaze();
-  g.pacman = initPacman();
-  g.ghosts = initGhosts();
-  g.fruit = null;
-  g.won = false;
-  g.combo = 0;
-  g.mode = GhostMode.SCATTER;
-  g.modeTimer = SCATTER_TIME;
-  g.elapsed = 0;
-  g.pacPending = 0;
-  g.ghostPending = 0;
-  g.world.scoreboard.reset(INITIAL_LIVES, TIME_LIMIT);
-  if (g.scene) {
-    clearDots(g.world, g.scene);
-    removeScene(g.world, g.scene);
-    g.scene = g.layout ? buildScene(g.world, g.layout, g.theme) : null;
-  }
-  redraw(g);
-}
-
-export function start(g: Game) {
-  if (g.phase !== 'ready') return;
-  home(g);
-  g.world.scoreboard.startCountdown(TIME_LIMIT);
-  g.phase = 'playing';
-  if (g.scene) startChomp(g.world, g.scene, CHOMP_TIME);
-  g.onScore(0);
-  g.onLives(INITIAL_LIVES);
-  g.onTime(TIME_LIMIT);
-  g.onPhase('playing');
-}
-
-export function reset(g: Game) {
-  home(g);
-  g.phase = 'ready';
-  g.anchor = null;
-  if (g.scene) stopChomp(g.world, g.scene);
-  g.onScore(0);
-  g.onLives(INITIAL_LIVES);
-  g.onTime(TIME_LIMIT);
-  g.onPhase('ready');
-}
-
-export function dispose(g: Game) {
-  g.world.dispose();
-}
-
-// ── The finger ────────────────────────────────────────────────────────
-
-export function drag(g: Game, { phase, x, y }: DragEvent) {
-  if (phase === 'start') {
-    g.anchor = [x, y];
-    return;
-  }
-  const a = g.anchor;
-  if (!a || g.phase !== 'playing') return;
-  const dx = x - a[0];
-  const dy = y - a[1];
-  if (Math.abs(dx) <= SWIPE && Math.abs(dy) <= SWIPE) return;
-  // The board is seen from the front, so a swipe up the screen heads up the maze (toward row 0).
-  const dir: Direction = Math.abs(dx) > Math.abs(dy) ? (dx > 0 ? 'RIGHT' : 'LEFT') : dy > 0 ? 'DOWN' : 'UP';
-  g.pacman.nextDirection = dir;
-  g.anchor = phase === 'end' ? null : [x, y];
-}
-
-// ── Tick ──────────────────────────────────────────────────────────────
-
-export function tick(g: Game, dt: number) {
-  if (g.world.isDisposed) return;
-  const step = Math.min(dt, MAX_STEP);
-  g.clock += step;
-  if (g.phase === 'playing') {
-    g.elapsed += step;
-    {
-      advanceModes(g, step);
-      advanceFright(g, step);
-      g.pacPending += step;
-      while (g.phase === 'playing' && g.pacPending >= PAC_STEP) {
-        g.pacPending -= PAC_STEP;
-        pacStep(g);
-      }
-      g.ghostPending += step;
-      while (g.phase === 'playing' && g.ghostPending >= GHOST_STEP) {
-        g.ghostPending -= GHOST_STEP;
-        ghostStep(g);
-      }
-      // The fruit waits its turn, then goes
-      if (g.fruit && g.clock >= g.fruitExpireAt) {
-        g.fruit = null;
-        if (g.layout && g.scene) placeFruit(g.world, g.layout, g.scene, null);
-      }
-    }
-  }
-  g.world.update(dt);
-}
-
-/** Scatter and chase take turns; the ghosts not frightened or eaten switch with them. */
-function advanceModes(g: Game, dt: number) {
-  g.modeTimer -= dt;
-  if (g.modeTimer > 0) return;
-  const next = g.mode === GhostMode.SCATTER ? GhostMode.CHASE : GhostMode.SCATTER;
-  g.mode = next;
-  g.modeTimer = next === GhostMode.SCATTER ? SCATTER_TIME : CHASE_TIME;
-  for (const gh of g.ghosts) if (gh.mode === GhostMode.SCATTER || gh.mode === GhostMode.CHASE) gh.mode = next;
-  dressAll(g);
-}
-
-/** Frightened ghosts count down, flash near the end, then go back to what they were doing. */
-function advanceFright(g: Game, dt: number) {
-  let changed = false;
-  for (const gh of g.ghosts) {
-    if (gh.mode !== GhostMode.FRIGHTENED) continue;
-    gh.frightenedTimer -= dt;
-    const flashing = gh.frightenedTimer < FLASH_TIME;
-    if (flashing !== gh.isFlashing) {
-      gh.isFlashing = flashing;
-      changed = true;
-    }
-    if (gh.frightenedTimer <= 0) {
-      gh.mode = g.mode;
-      gh.isFlashing = false;
-      changed = true;
-    }
-  }
-  if (changed) dressAll(g);
-}
-
-function pacStep(g: Game) {
-  const { layout: l, scene: s } = g;
-  if (!l || !s) return;
-  const { moved, wrapped } = stepPacman(g.pacman, g.maze.cells);
-  if (moved) movePacman(g.world, l, s, g.pacman.x, g.pacman.y, g.pacman.direction, PAC_STEP, wrapped);
-
-  // Eat whatever is here
-  const bite = eatAt(g.maze, g.pacman.x, g.pacman.y);
-  if (bite) {
-    g.world.scoreboard.add(bite.points);
-    eatDot(g.world, s, g.pacman.x, g.pacman.y);
-    if (bite.pellet) {
-      g.ghosts = frightenGhosts(g.ghosts, POWER_PELLET_TIME);
-      g.combo = 0;
-      dressAll(g);
-      g.onEvent('pellet');
-    } else {
-      g.onEvent('chomp');
-    }
-    const eaten = g.maze.totalDots - g.maze.dotsRemaining;
-    if (!g.fruit && FRUIT_SPAWN_DOTS.includes(eaten)) {
-      g.fruit = { x: 9, y: 11 };
-      g.fruitExpireAt = g.clock + FRUIT_TIME;
-      placeFruit(g.world, l, s, g.fruit);
-    }
-  }
-
-  // The fruit
-  if (g.fruit && g.pacman.x === g.fruit.x && g.pacman.y === g.fruit.y) {
-    g.world.scoreboard.add(POINTS_PER_FRUIT);
-    fruitEaten(g.world, l, s, g.fruit.x, g.fruit.y);
-    g.fruit = null;
-    g.onEvent('fruit');
-  }
-
-  if (checkCollisions(g)) return;
-
-  if (g.maze.dotsRemaining === 0) win(g);
-}
-
-function ghostStep(g: Game) {
-  const { layout: l, scene: s } = g;
-  if (!l || !s) return;
-  // Release any whose time has come
-  for (let i = 0; i < g.ghosts.length; i++) {
-    const gh = g.ghosts[i]!;
-    if (gh.mode === GhostMode.IN_HOUSE && g.elapsed >= GHOST_RELEASE[gh.name]) g.ghosts[i] = releaseGhost(gh);
-  }
-  const blinky = g.ghosts.find((x) => x.name === GhostName.BLINKY) ?? null;
-  const blinkyPos = blinky ? { x: blinky.x, y: blinky.y } : null;
-  for (let i = 0; i < g.ghosts.length; i++) {
-    let gh = reachedHouse(g.ghosts[i]!);
-    const beforeX = gh.x;
-    gh = aiMoveGhost(g.maze.cells, gh, g.pacman, blinkyPos);
-    g.ghosts[i] = gh;
-    const wrapped = Math.abs(gh.x - beforeX) > 1;
-    sceneMoveGhost(g.world, l, s, gh.name, gh.x, gh.y, GHOST_STEP, wrapped);
-  }
-  dressAll(g);
-  checkCollisions(g);
-}
-
-/** Pac-Man and a ghost on the same cell: eats a frightened one, otherwise loses a life. Returns true if a life was lost. */
-function checkCollisions(g: Game): boolean {
-  const { layout: l, scene: s } = g;
-  if (!l || !s) return false;
-  for (let i = 0; i < g.ghosts.length; i++) {
-    const gh = g.ghosts[i]!;
-    if (!collides(g.pacman, gh)) continue;
-    if (gh.mode === GhostMode.FRIGHTENED) {
-      g.combo++;
-      g.world.scoreboard.add(POINTS_PER_GHOST * Math.pow(2, g.combo - 1));
-      gh.mode = GhostMode.EATEN;
-      gh.isFlashing = false;
-      dressGhost(g.world, l, s, gh.name, gh.mode, false);
-      ghostEaten(g.world, l, gh.x, gh.y);
-      g.onEvent(g.combo > 1 ? 'eatGhostCombo' : 'eatGhost');
-    } else if (gh.mode !== GhostMode.EATEN && gh.mode !== GhostMode.IN_HOUSE && gh.mode !== GhostMode.LEAVING_HOUSE) {
-      loseLife(g);
-      return true;
-    }
-  }
-  return false;
-}
-
-function loseLife(g: Game) {
-  const { layout: l, scene: s } = g;
-  g.onLives(Math.max(0, g.world.scoreboard.addLives(-1)));
-  if (l && s) pacmanHit(g.world, l, g.pacman.x, g.pacman.y);
-  if (g.lives <= 0) {
-    lose(g);
-    return;
-  }
-  g.onEvent('lifeLost');
-  // Back to the start cells; the maze, dots and score stay
-  g.pacman = { ...initPacman(), direction: 'NONE', nextDirection: 'NONE' };
-  g.ghosts = initGhosts();
-  g.combo = 0;
-  g.elapsed = 0;
-  g.pacPending = 0;
-  g.ghostPending = 0;
-  redraw(g);
-}
-
-function win(g: Game) {
-  g.won = true;
-  end(g);
-}
-
-function lose(g: Game) {
-  g.won = false;
-  end(g);
-}
-
-function end(g: Game) {
-  g.world.scoreboard.stop();
-  g.phase = 'over';
-  g.anchor = null;
-  if (g.scene) stopChomp(g.world, g.scene);
-  g.onPhase('over');
-}
-
-function dressAll(g: Game) {
-  const { layout: l, scene: s } = g;
-  if (!l || !s) return;
-  for (const gh of g.ghosts) dressGhost(g.world, l, s, gh.name, gh.mode, gh.isFlashing);
-}