moshcode 0.39.0 → 0.41.0

package/src/games-chess.mjs

@@ -0,0 +1,376 @@
+// Chess. Real rules — castling, en passant, promotion, check, checkmate,
+// stalemate — against an alpha-beta search that is about as strong as a friend
+// who plays sometimes. You are white; the machine answers immediately.
+//
+// The board is 64 squares of FEN letters: uppercase white, lowercase black,
+// null empty, index 0 = a8 and index 63 = h1. Everything below is pure, so a
+// position can be set up in a test and asked what it thinks.
+import { acid, amber, ash, bone, danger, dim, rgb } from "./ui.mjs";
+
+export const START = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR";
+
+const VALUE = { p: 100, n: 320, b: 330, r: 500, q: 900, k: 20000 };
+const KNIGHT_STEPS = [[1, 2], [2, 1], [-1, 2], [-2, 1], [1, -2], [2, -1], [-1, -2], [-2, -1]];
+const DIAGONALS = [[1, 1], [1, -1], [-1, 1], [-1, -1]];
+const STRAIGHTS = [[1, 0], [-1, 0], [0, 1], [0, -1]];
+const ROYAL = [...DIAGONALS, ...STRAIGHTS];
+
+export const isWhite = (piece) => Boolean(piece) && piece === piece.toUpperCase();
+const friendly = (a, b) => Boolean(a) && Boolean(b) && isWhite(a) === isWhite(b);
+const fileOf = (i) => i % 8;
+const rankOf = (i) => Math.floor(i / 8);
+const square = (x, y) => y * 8 + x;
+const inside = (x, y) => x >= 0 && x < 8 && y >= 0 && y < 8;
+/** The piece on a square, `null` if empty and `undefined` if off the board. */
+const at = (board, x, y) => (inside(x, y) ? board[square(x, y)] : undefined);
+
+/** Board rows of a FEN position (the placement field only). */
+export function parseBoard(fen = START) {
+  const board = Array.from({ length: 64 }, () => null);
+  let i = 0;
+  for (const char of fen.split(" ")[0]) {
+    if (char === "/") continue;
+    if (/\d/.test(char)) { i += Number(char); continue; }
+    board[i++] = char;
+  }
+  return board;
+}
+
+/** Algebraic name of a square — for the move list down the side. */
+export const name = (i) => "abcdefgh"[fileOf(i)] + (8 - rankOf(i));
+
+/**
+ * Every move the piece on `from` could make if the king's safety were somebody
+ * else's problem. `attacksOnly` drops pawn pushes and castling, because a pawn
+ * does not attack the square in front of it and a rook cannot be taken by a
+ * castle — that distinction is what makes check detection correct.
+ */
+export function pseudoMoves(state, from, { attacksOnly = false } = {}) {
+  const { board } = state;
+  const piece = board[from];
+  if (!piece) return [];
+  const white = isWhite(piece);
+  const type = piece.toLowerCase();
+  const x = fileOf(from);
+  const y = rankOf(from);
+  const moves = [];
+  const add = (to, extra = {}) => moves.push({ from, to, ...extra });
+
+  const slide = (dirs) => {
+    for (const [dx, dy] of dirs) {
+      for (let step = 1; step < 8; step++) {
+        const nx = x + dx * step;
+        const ny = y + dy * step;
+        const target = at(board, nx, ny);
+        if (target === undefined) break;
+        if (target === null) { add(square(nx, ny)); continue; }
+        if (!friendly(piece, target)) add(square(nx, ny), { capture: true });
+        break;
+      }
+    }
+  };
+  const hop = (steps) => {
+    for (const [dx, dy] of steps) {
+      const nx = x + dx;
+      const ny = y + dy;
+      const target = at(board, nx, ny);
+      if (target === undefined) continue;
+      if (target === null) add(square(nx, ny));
+      else if (!friendly(piece, target)) add(square(nx, ny), { capture: true });
+    }
+  };
+
+  if (type === "p") {
+    const dir = white ? -1 : 1;
+    const start = white ? 6 : 1;
+    const last = white ? 0 : 7;
+    if (!attacksOnly) {
+      if (at(board, x, y + dir) === null) {
+        add(square(x, y + dir), y + dir === last ? { promotion: true } : {});
+        if (y === start && at(board, x, y + 2 * dir) === null) {
+          add(square(x, y + 2 * dir), { double: true });
+        }
+      }
+    }
+    for (const dx of [-1, 1]) {
+      const nx = x + dx;
+      const ny = y + dir;
+      const target = at(board, nx, ny);
+      if (target === undefined) continue;
+      if (attacksOnly) { add(square(nx, ny)); continue; }
+      if (target && !friendly(piece, target)) {
+        add(square(nx, ny), ny === last ? { capture: true, promotion: true } : { capture: true });
+      } else if (target === null && state.ep === square(nx, ny)) {
+        add(square(nx, ny), { capture: true, enPassant: true });
+      }
+    }
+    return moves;
+  }
+  if (type === "n") hop(KNIGHT_STEPS);
+  else if (type === "b") slide(DIAGONALS);
+  else if (type === "r") slide(STRAIGHTS);
+  else if (type === "q") slide(ROYAL);
+  else if (type === "k") {
+    hop(ROYAL);
+    if (!attacksOnly) {
+      const home = white ? 60 : 4;
+      const rights = state.castling || {};
+      const empty = (...squares) => squares.every((s) => board[s] === null);
+      const safe = (...squares) => squares.every((s) => !attacked(state, s, !white));
+      if (from === home && !attacked(state, home, !white)) {
+        if (rights[white ? "K" : "k"] && empty(home + 1, home + 2) && safe(home + 1, home + 2)) {
+          add(home + 2, { castle: "K" });
+        }
+        if (rights[white ? "Q" : "q"] && empty(home - 1, home - 2, home - 3) && safe(home - 1, home - 2)) {
+          add(home - 2, { castle: "Q" });
+        }
+      }
+    }
+  }
+  return moves;
+}
+
+/** Is `target` attacked by the side `byWhite`? */
+export function attacked(state, target, byWhite) {
+  for (let i = 0; i < 64; i++) {
+    const piece = state.board[i];
+    if (!piece || isWhite(piece) !== byWhite) continue;
+    for (const move of pseudoMoves(state, i, { attacksOnly: true })) {
+      if (move.to === target) return true;
+    }
+  }
+  return false;
+}
+
+export const findKing = (board, white) => board.indexOf(white ? "K" : "k");
+
+export function inCheck(state, white) {
+  const king = findKing(state.board, white);
+  return king >= 0 && attacked(state, king, !white);
+}
+
+/** A new position with the move played. Never mutates what it was given. */
+export function apply(state, move) {
+  const board = state.board.slice();
+  const piece = board[move.from];
+  const white = isWhite(piece);
+  const castling = { ...state.castling };
+
+  board[move.from] = null;
+  board[move.to] = move.promotion ? (white ? "Q" : "q") : piece;
+  if (move.enPassant) board[square(fileOf(move.to), rankOf(move.from))] = null;
+  if (move.castle) {
+    const home = white ? 60 : 4;
+    const [rookFrom, rookTo] = move.castle === "K" ? [home + 3, home + 1] : [home - 4, home - 1];
+    board[rookTo] = board[rookFrom];
+    board[rookFrom] = null;
+  }
+
+  // Rights are lost by moving the king or a rook, and by capturing a rook on
+  // the square it started on — the last one is the case everybody forgets.
+  if (piece === "K") { castling.K = false; castling.Q = false; }
+  if (piece === "k") { castling.k = false; castling.q = false; }
+  for (const [corner, right] of [[63, "K"], [56, "Q"], [7, "k"], [0, "q"]]) {
+    if (move.from === corner || move.to === corner) castling[right] = false;
+  }
+
+  return {
+    ...state,
+    board,
+    castling,
+    ep: move.double ? square(fileOf(move.from), (rankOf(move.from) + rankOf(move.to)) / 2) : null,
+    turn: white ? "b" : "w",
+  };
+}
+
+/** Pseudo-legal minus everything that walks into check. */
+export function legalMoves(state, from) {
+  const piece = state.board[from];
+  if (!piece) return [];
+  const white = isWhite(piece);
+  return pseudoMoves(state, from).filter((move) => !inCheck(apply(state, move), white));
+}
+
+export function allMoves(state, white = state.turn === "w") {
+  const moves = [];
+  for (let i = 0; i < 64; i++) {
+    if (state.board[i] && isWhite(state.board[i]) === white) moves.push(...legalMoves(state, i));
+  }
+  return moves;
+}
+
+/** "checkmate", "stalemate", or null. */
+export function outcome(state) {
+  if (allMoves(state).length) return null;
+  return inCheck(state, state.turn === "w") ? "checkmate" : "stalemate";
+}
+
+/* --------------------------------------------------------------------- ai */
+
+// Material, plus a nudge toward the middle. Enough to make it take free pieces
+// and develop rather than shuffle a rook, which is all this needs to be.
+const CENTER = [0, 1, 2, 3, 3, 2, 1, 0];
+
+export function evaluate(state) {
+  let total = 0;
+  for (let i = 0; i < 64; i++) {
+    const piece = state.board[i];
+    if (!piece) continue;
+    const worth = VALUE[piece.toLowerCase()] + CENTER[fileOf(i)] + CENTER[rankOf(i)];
+    total += isWhite(piece) ? worth : -worth;
+  }
+  return state.turn === "w" ? total : -total;
+}
+
+function negamax(state, depth, alpha, beta) {
+  if (depth === 0) return evaluate(state);
+  const moves = allMoves(state);
+  if (!moves.length) return inCheck(state, state.turn === "w") ? -90000 - depth : 0;
+  // Captures first: cheap ordering, and it is most of what alpha-beta needs to
+  // prune a depth-3 search down to something that answers instantly.
+  moves.sort((a, b) => Number(Boolean(b.capture)) - Number(Boolean(a.capture)));
+  let best = -Infinity;
+  for (const move of moves) {
+    const value = -negamax(apply(state, move), depth - 1, -beta, -alpha);
+    if (value > best) best = value;
+    if (best > alpha) alpha = best;
+    if (alpha >= beta) break;
+  }
+  return best;
+}
+
+/** The machine's reply. Ties broken at random so it is not the same game twice. */
+export function chooseMove(state, { depth = 3, rng = Math.random } = {}) {
+  const moves = allMoves(state);
+  if (!moves.length) return null;
+  let best = -Infinity;
+  let picks = [];
+  for (const move of moves) {
+    const value = -negamax(apply(state, move), depth - 1, -Infinity, Infinity);
+    if (value > best) { best = value; picks = [move]; }
+    else if (value === best) picks.push(move);
+  }
+  return picks[Math.floor(rng() * picks.length) % picks.length];
+}
+
+/* ------------------------------------------------------------------- game */
+
+// White is upper case and black is lower, the way a FEN reads — so the board is
+// still playable with NO_COLOR set, where the two colours are the same colour.
+const GLYPH = (piece) => (isWhite(piece) ? piece.toUpperCase() : piece.toLowerCase());
+const WHITE_PIECE = bone;
+const BLACK_PIECE = rgb(255, 120, 180);
+
+function settle(state) {
+  const done = outcome(state);
+  if (!done) {
+    state.note = inCheck(state, state.turn === "w") ? "check" : "";
+    return state;
+  }
+  state.over = done === "stalemate"
+    ? "stalemate — nobody wins"
+    : state.turn === "w" ? "checkmate — the machine takes it" : "checkmate — you win 🤘";
+  return state;
+}
+
+export const CHESS = {
+  key: "chess",
+  aliases: ["ches", "kasparov"],
+  title: "CHESS",
+  blurb: "full rules, real opponent, pawns auto-queen",
+  keys: "← ↑ ↓ → move · enter pick then place · r new game · q quit",
+  // The search blocks for a few hundred milliseconds in an open position, so it
+  // runs on the clock rather than inside the keypress: your own move is on the
+  // board and drawn before the machine starts thinking about it. The idle beat
+  // is slow because nothing happens on it — the driver skips a redraw that
+  // would change nothing.
+  tickMs: (state) => (state.turn === "b" ? 80 : 400),
+
+  create() {
+    return {
+      board: parseBoard(START),
+      turn: "w",
+      castling: { K: true, Q: true, k: true, q: true },
+      ep: null,
+      cursor: 52, // e2, where most games start
+      selected: null,
+      targets: [],
+      played: [],
+      note: "",
+      over: null,
+    };
+  },
+
+  onKey(state, pressed, { rng = Math.random } = {}) {
+    const x = fileOf(state.cursor);
+    const y = rankOf(state.cursor);
+    if (pressed === "left") state.cursor = square((x + 7) % 8, y);
+    else if (pressed === "right") state.cursor = square((x + 1) % 8, y);
+    else if (pressed === "up") state.cursor = square(x, (y + 7) % 8);
+    else if (pressed === "down") state.cursor = square(x, (y + 1) % 8);
+    else if (pressed === "enter" || pressed === "space") {
+      if (state.selected === null) {
+        const piece = state.board[state.cursor];
+        if (!piece || !isWhite(piece)) return state;
+        state.selected = state.cursor;
+        state.targets = legalMoves(state, state.cursor);
+        return state;
+      }
+      // Enter on the piece again (or on a square it cannot reach) puts it back
+      // down. No cancel key to learn, and no way to get stuck holding a rook.
+      const move = state.targets.find((m) => m.to === state.cursor);
+      state.selected = null;
+      state.targets = [];
+      if (!move) return state;
+
+      Object.assign(state, apply(state, move));
+      state.played.push(`${name(move.from)}${move.capture ? "x" : "-"}${name(move.to)}`);
+      settle(state);
+    }
+    return state;
+  },
+
+  /** The machine's turn, one move per beat. Idle while white is thinking. */
+  tick(state, { rng = Math.random } = {}) {
+    if (state.turn !== "b" || state.over) return state;
+    const reply = chooseMove(state, { rng });
+    if (!reply) return settle(state);
+    Object.assign(state, apply(state, reply));
+    state.played.push(`${name(reply.from)}${reply.capture ? "x" : "-"}${name(reply.to)}`);
+    return settle(state);
+  },
+
+  status(state) {
+    if (state.over) return state.over;
+    if (state.turn === "b") return `${ash("black is thinking…")}`;
+    const last = state.played.slice(-1)[0];
+    return `you ${bone("white")}${last ? ash(` · last ${last}`) : ""}${state.note ? ` · ${danger(state.note.toUpperCase())}` : ""}`;
+  },
+
+  render(state) {
+    const targets = new Set(state.targets.map((m) => m.to));
+    const rows = [];
+    for (let y = 0; y < 8; y++) {
+      let row = `${ash(String(8 - y))} `;
+      for (let x = 0; x < 8; x++) {
+        const i = square(x, y);
+        const piece = state.board[i];
+        const dark = (x + y) % 2 === 1;
+        let glyph = piece
+          ? (isWhite(piece) ? WHITE_PIECE : BLACK_PIECE)(GLYPH(piece))
+          : targets.has(i) ? acid("◦") : dark ? dim("·") : " ";
+        // A piece you could take is lit up rather than dotted — the dot would
+        // be hidden underneath it.
+        if (targets.has(i) && piece) glyph = amber(GLYPH(piece));
+        if (i === state.cursor) row += `${acid("[")}${glyph}${acid("]")}`;
+        else if (i === state.selected) row += `${amber("‹")}${glyph}${amber("›")}`;
+        else row += ` ${glyph} `;
+      }
+      rows.push(row);
+    }
+    rows.push(`  ${ash(" a  b  c  d  e  f  g  h ")}`);
+    rows.push("");
+    rows.push(`  ${dim(state.selected === null ? "enter picks a piece up" : "enter puts it down")}`);
+    return rows;
+  },
+};

package/src/games-hangman.mjs

@@ -0,0 +1,97 @@
+// Hangman. Type a letter; the gallows does the rest.
+import { acid, amber, ash, bone, danger, dim } from "./ui.mjs";
+
+/** Six wrong guesses, and the gallows is finished. */
+export const GALLOWS = [
+  ["  ┌────┐", "  │     ", "  │     ", "  │     ", "  │     ", " ═╧══════"],
+  ["  ┌────┐", "  │    ○", "  │     ", "  │     ", "  │     ", " ═╧══════"],
+  ["  ┌────┐", "  │    ○", "  │    │", "  │     ", "  │     ", " ═╧══════"],
+  ["  ┌────┐", "  │    ○", "  │   ╱│", "  │     ", "  │     ", " ═╧══════"],
+  ["  ┌────┐", "  │    ○", "  │   ╱│╲", "  │     ", "  │     ", " ═╧══════"],
+  ["  ┌────┐", "  │    ○", "  │   ╱│╲", "  │    │", "  │   ╱ ", " ═╧══════"],
+  ["  ┌────┐", "  │    ☹", "  │   ╱│╲", "  │    │", "  │   ╱ ╲", " ═╧══════"],
+];
+
+export const MISSES_ALLOWED = GALLOWS.length - 1;
+
+/** Words a moshcoder might actually shout. Nothing needing a hyphen. */
+export const WORDS = [
+  "moshcode", "distortion", "compiler", "kernel", "segfault", "refactor",
+  "closure", "promise", "daemon", "binary", "pointer", "monorepo", "terminal",
+  "runtime", "abstraction", "recursion", "interface", "payload", "protocol",
+  "semaphore", "mutex", "stacktrace", "breakpoint", "heuristic", "idempotent",
+  "bytecode", "checksum", "firewall", "namespace", "regression", "sandbox",
+  "throughput", "waveform", "amplifier", "feedback", "headbang", "overdrive",
+  "fretboard", "downbeat", "crowdsurf", "backline", "encryption", "quantum",
+];
+
+const LETTERS = "abcdefghijklmnopqrstuvwxyz";
+
+/** The word with everything unguessed still hidden. */
+export function mask(state) {
+  return state.word.split("").map((c) => (state.guessed.has(c) ? c.toUpperCase() : "_"));
+}
+
+/**
+ * Apply one letter. Repeats are free — guessing `e` twice costs nothing but
+ * also tells you nothing, which is the same deal every hangman has ever run.
+ */
+export function guess(state, letter) {
+  const c = String(letter).toLowerCase();
+  if (!LETTERS.includes(c) || state.guessed.has(c) || state.missed.includes(c)) return state;
+  if (state.word.includes(c)) {
+    state.guessed.add(c);
+    if (state.word.split("").every((ch) => state.guessed.has(ch))) state.over = "got it 🤘";
+    return state;
+  }
+  state.missed.push(c);
+  if (state.missed.length >= MISSES_ALLOWED) state.over = `hanged — it was ${state.word.toUpperCase()}`;
+  return state;
+}
+
+export const HANGMAN = {
+  key: "hangman",
+  aliases: ["hang", "gallows"],
+  title: "HANGMAN",
+  blurb: "six wrong letters and you are done for",
+  keys: "a–z guess · r new word · q quit",
+
+  create({ rng = Math.random } = {}) {
+    return {
+      word: WORDS[Math.floor(rng() * WORDS.length) % WORDS.length],
+      guessed: new Set(),
+      missed: [],
+      over: null,
+    };
+  },
+
+  onKey(state, pressed) {
+    if (pressed.length !== 1) return state;
+    return guess(state, pressed);
+  },
+
+  status(state) {
+    if (state.over) return state.over;
+    const left = MISSES_ALLOWED - state.missed.length;
+    return `${left} wrong ${left === 1 ? "guess" : "guesses"} left`;
+  },
+
+  render(state) {
+    const art = GALLOWS[Math.min(state.missed.length, MISSES_ALLOWED)];
+    const shown = state.over && state.over.startsWith("hanged")
+      ? state.word.split("").map((c) => c.toUpperCase())
+      : mask(state);
+    const word = shown.map((c) => (c === "_" ? ash("_") : acid(c))).join(" ");
+    const missed = state.missed.length
+      ? `${ash("missed ")}${danger(state.missed.join(" ").toUpperCase())}`
+      : dim("no wrong letters yet");
+    return [
+      ...art.map((line) => bone(line)),
+      "",
+      `  ${word}`,
+      "",
+      `  ${missed}`,
+      `  ${amber("✳".repeat(MISSES_ALLOWED - state.missed.length))}${dim("✳".repeat(state.missed.length))}`,
+    ];
+  },
+};

package/src/games-pacman.mjs

@@ -0,0 +1,205 @@
+// Pac-Man, arcade-sized. One maze, 240-odd dots, four power pellets and three
+// ghosts that are not quite as clever as the ones in 1980 — on purpose. This is
+// a game you can win on a coffee break.
+import { acid, amber, ash, dim, rgb } from "./ui.mjs";
+
+/**
+ * `#` wall · `.` dot · `o` power pellet · `P` where pac starts · `G` the pen.
+ *
+ * Symmetric, fully connected, and small enough that the whole board fits above
+ * the pit's prompt without scrolling.
+ */
+export const MAZE = [
+  "###################",
+  "#........#........#",
+  "#o##.###.#.###.##o#",
+  "#.................#",
+  "#.##.#.#####.#.##.#",
+  "#....#...G...#....#",
+  "####.##.###.##.####",
+  "#........P........#",
+  "#.##.####.####.##.#",
+  "#o...............o#",
+  "###################",
+];
+
+export const WIDTH = MAZE[0].length;
+export const HEIGHT = MAZE.length;
+
+const WALL = ash("██");
+const DOT = dim("· ");
+const POWER = amber("✳ ");
+const PAC = acid("● ");
+const BLANK = "  ";
+const GHOST_COLORS = [rgb(255, 77, 61), rgb(255, 120, 180), rgb(90, 220, 250)];
+const SCARED = rgb(90, 140, 255);
+
+const DIRS = { up: [0, -1], down: [0, 1], left: [-1, 0], right: [1, 0] };
+const OPPOSITE = { up: "down", down: "up", left: "right", right: "left" };
+const FRIGHT_TICKS = 40;
+
+export const isWall = (x, y) => MAZE[y]?.[x] === "#" || MAZE[y]?.[x] === undefined;
+const cellKey = (x, y) => `${x},${y}`;
+const distance = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+
+/** Every dot and pellet in the maze, as a fresh map. */
+export function pellets() {
+  const map = new Map();
+  for (let y = 0; y < HEIGHT; y++) {
+    for (let x = 0; x < WIDTH; x++) {
+      const cell = MAZE[y][x];
+      if (cell === "." || cell === "o") map.set(cellKey(x, y), cell);
+    }
+  }
+  return map;
+}
+
+function find(char) {
+  for (let y = 0; y < HEIGHT; y++) {
+    const x = MAZE[y].indexOf(char);
+    if (x >= 0) return { x, y };
+  }
+  return { x: 1, y: 1 };
+}
+
+/** Where everything stands at the start of a life. */
+function positions() {
+  const pen = find("G");
+  const pac = find("P");
+  return {
+    pac: { ...pac, dir: "left", want: "left" },
+    // Three ghosts abreast in the pen — the two beside it are open corridor in
+    // this maze, which is what keeps them from stepping on each other at spawn.
+    ghosts: [
+      { x: pen.x, y: pen.y },
+      { x: pen.x - 1, y: pen.y },
+      { x: pen.x + 1, y: pen.y },
+    ].map((g, i) => ({ ...g, home: { x: g.x, y: g.y }, dir: "up", color: i })),
+  };
+}
+
+/** Directions a ghost may take from where it stands. */
+export function options(ghost, { allowReverse = false } = {}) {
+  const open = Object.entries(DIRS)
+    .filter(([name, [dx, dy]]) => !isWall(ghost.x + dx, ghost.y + dy)
+      && (allowReverse || name !== OPPOSITE[ghost.dir]));
+  // A dead end is the one place reversing is the only move there is.
+  return open.length ? open : Object.entries(DIRS).filter(([, [dx, dy]]) => !isWall(ghost.x + dx, ghost.y + dy));
+}
+
+/**
+ * One ghost step. Chases by Manhattan distance, flees while you are lit up,
+ * and takes a random legal turn one time in five so the three of them do not
+ * arrive in a single-file line.
+ */
+export function moveGhost(ghost, pac, { frightened = false, rng = Math.random } = {}) {
+  const open = options(ghost);
+  if (!open.length) return ghost;
+  const scored = open.map(([name, [dx, dy]]) => ({
+    name,
+    dx,
+    dy,
+    d: distance({ x: ghost.x + dx, y: ghost.y + dy }, pac),
+  }));
+  let choice;
+  if (rng() < 0.2) choice = scored[Math.floor(rng() * scored.length) % scored.length];
+  else {
+    const sorted = scored.slice().sort((a, b) => (frightened ? b.d - a.d : a.d - b.d));
+    choice = sorted[0];
+  }
+  ghost.dir = choice.name;
+  ghost.x += choice.dx;
+  ghost.y += choice.dy;
+  return ghost;
+}
+
+function caught(state) {
+  const hits = state.ghosts.filter((g) => g.x === state.pac.x && g.y === state.pac.y);
+  if (!hits.length) return false;
+  if (state.fright > 0) {
+    for (const g of hits) {
+      state.score += 200;
+      Object.assign(g, { x: g.home.x, y: g.home.y, dir: "up" });
+    }
+    return false;
+  }
+  state.lives--;
+  if (state.lives <= 0) { state.over = "game over"; return true; }
+  Object.assign(state, positions(), { fright: 0 });
+  return true;
+}
+
+export const PACMAN = {
+  key: "pacman",
+  aliases: ["pac", "pacmam", "puckman"],
+  title: "PAC-MAN",
+  blurb: "eat the dots, dodge the ghosts, ✳ makes them edible",
+  keys: "← ↑ ↓ → steer · q quit",
+  tickMs: 150,
+
+  create({ rng = Math.random } = {}) {
+    return { ...positions(), dots: pellets(), score: 0, lives: 3, fright: 0, frame: 0, over: null, rng };
+  },
+
+  tick(state) {
+    state.frame++;
+    const pac = state.pac;
+    // A turn is remembered until it becomes legal, which is what makes a corner
+    // feel like a corner rather than a keypress you have to time.
+    const wanted = DIRS[pac.want];
+    if (wanted && !isWall(pac.x + wanted[0], pac.y + wanted[1])) pac.dir = pac.want;
+    const [dx, dy] = DIRS[pac.dir];
+    if (!isWall(pac.x + dx, pac.y + dy)) { pac.x += dx; pac.y += dy; }
+
+    const here = state.dots.get(cellKey(pac.x, pac.y));
+    if (here) {
+      state.dots.delete(cellKey(pac.x, pac.y));
+      state.score += here === "o" ? 50 : 10;
+      if (here === "o") state.fright = FRIGHT_TICKS;
+    }
+    if (!state.dots.size) { state.over = "maze cleared 🤘"; return state; }
+    if (caught(state)) return state;
+
+    // Ghosts move at half speed, and slower still while they are running away.
+    const beat = state.fright > 0 ? 3 : 2;
+    if (state.frame % beat === 0) {
+      for (const ghost of state.ghosts) {
+        moveGhost(ghost, pac, { frightened: state.fright > 0, rng: state.rng });
+      }
+      caught(state);
+    }
+    if (state.fright > 0) state.fright--;
+    return state;
+  },
+
+  onKey(state, pressed) {
+    if (DIRS[pressed]) state.pac.want = pressed;
+    return state;
+  },
+
+  status(state) {
+    const left = state.dots.size;
+    if (state.over) return `${state.over} · ${state.score} points`;
+    return `score ${state.score} · lives ${"●".repeat(Math.max(0, state.lives))} · dots ${left}`
+      + (state.fright > 0 ? " · RUN" : "");
+  },
+
+  render(state) {
+    const rows = [];
+    for (let y = 0; y < HEIGHT; y++) {
+      let row = "";
+      for (let x = 0; x < WIDTH; x++) {
+        const ghost = state.ghosts.find((g) => g.x === x && g.y === y);
+        if (state.pac.x === x && state.pac.y === y) row += PAC;
+        else if (ghost) row += (state.fright > 0 ? SCARED : GHOST_COLORS[ghost.color])("▲ ");
+        else if (MAZE[y][x] === "#") row += WALL;
+        else {
+          const pellet = state.dots.get(cellKey(x, y));
+          row += pellet === "o" ? POWER : pellet === "." ? DOT : BLANK;
+        }
+      }
+      rows.push(row);
+    }
+    return rows;
+  },
+};