@nayan-ui/games 1.19.0 → 1.20.0

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

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

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