@trolleroof/tui 0.2.4 → 0.2.6

package/src/games/g2048/engine.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, it } from "bun:test";
+import { Rng } from "../../core/rng.js";
+import { canMove, emptyBoard, highestTile, move, spawnTile, type Board } from "./engine.js";
+import { Game2048 } from "./game2048.js";
+
+const B = (rows: number[][]): Board => rows;
+
+describe("move", () => {
+  it("slides tiles left into empty space", () => {
+    const res = move(B([[0, 2, 0, 2], [0, 0, 4, 0], [0, 0, 0, 0], [0, 0, 0, 0]]), "left");
+    expect(res.board[0]).toEqual([4, 0, 0, 0]);
+    expect(res.board[1]).toEqual([4, 0, 0, 0]);
+    expect(res.gained).toBe(4);
+    expect(res.moved).toBe(true);
+  });
+
+  it("merges each tile at most once per move", () => {
+    const res = move(B([[2, 2, 2, 2], [4, 4, 8, 8], [0, 0, 0, 0], [0, 0, 0, 0]]), "left");
+    expect(res.board[0]).toEqual([4, 4, 0, 0]);
+    expect(res.board[1]).toEqual([8, 16, 0, 0]);
+    expect(res.gained).toBe(4 + 4 + 8 + 16);
+  });
+
+  it("does not merge cascades in a single move (4,2,2 → 4,4 not 8)", () => {
+    const res = move(B([[4, 2, 2, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]), "left");
+    expect(res.board[0]).toEqual([4, 4, 0, 0]);
+  });
+
+  it("merges toward the move direction on right", () => {
+    const res = move(B([[2, 2, 2, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]), "right");
+    expect(res.board[0]).toEqual([0, 0, 2, 4]);
+  });
+
+  it("handles up and down via transpose", () => {
+    const start = B([[2, 0, 0, 0], [2, 0, 0, 0], [4, 0, 0, 0], [0, 0, 0, 0]]);
+    const up = move(start, "up");
+    expect(up.board.map((r) => r[0])).toEqual([4, 4, 0, 0]);
+    const down = move(start, "down");
+    expect(down.board.map((r) => r[0])).toEqual([0, 0, 4, 4]);
+  });
+
+  it("reports moved=false when nothing changes", () => {
+    const res = move(B([[2, 4, 8, 16], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]), "up");
+    expect(res.moved).toBe(false);
+    expect(res.gained).toBe(0);
+  });
+
+  it("never mutates the input board", () => {
+    const start = B([[2, 2, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]);
+    const copy = start.map((r) => [...r]);
+    move(start, "left");
+    expect(start).toEqual(copy);
+  });
+});
+
+describe("spawnTile", () => {
+  it("adds exactly one 2 or 4 to an empty cell", () => {
+    const board = spawnTile(emptyBoard(), new Rng(42));
+    const tiles = board.flat().filter((v) => v !== 0);
+    expect(tiles).toHaveLength(1);
+    expect([2, 4]).toContain(tiles[0]!);
+  });
+
+  it("is deterministic for a given seed", () => {
+    const a = spawnTile(spawnTile(emptyBoard(), new Rng(7)), new Rng(7));
+    const b = spawnTile(spawnTile(emptyBoard(), new Rng(7)), new Rng(7));
+    expect(a).toEqual(b);
+  });
+});
+
+describe("canMove", () => {
+  it("is true with empty cells or adjacent equal tiles", () => {
+    expect(canMove(emptyBoard())).toBe(true);
+    expect(canMove(B([[2, 4, 2, 4], [4, 2, 4, 2], [2, 4, 2, 4], [4, 2, 4, 4]]))).toBe(true);
+  });
+
+  it("is false on a full checkerboard", () => {
+    expect(canMove(B([[2, 4, 2, 4], [4, 2, 4, 2], [2, 4, 2, 4], [4, 2, 4, 2]]))).toBe(false);
+  });
+});
+
+describe("Game2048 episodes", () => {
+  it("plays a full seeded episode deterministically", () => {
+    const play = (seed: number) => {
+      const g = new Game2048();
+      g.reset(seed);
+      const dirs = ["up", "left", "down", "right"] as const;
+      let total = 0;
+      for (let i = 0; i < 5000 && !g.isOver(); i++) {
+        total += g.step(dirs[i % 4]!).reward;
+      }
+      return { score: g.score(), total, state: g.state() };
+    };
+    const a = play(123);
+    const b = play(123);
+    expect(a).toEqual(b);
+    expect(a.score).toBe(a.total); // score is the sum of rewards
+    expect(highestTile(a.state.board)).toBeGreaterThanOrEqual(8);
+  });
+
+  it("ignores illegal moves without reward", () => {
+    const g = new Game2048();
+    g.reset(1);
+    // Exhaust one direction until it becomes illegal, then verify no-op.
+    let res = g.step("left");
+    while (res.moved && !res.done) res = g.step("left");
+    if (!res.done) {
+      const before = g.state();
+      const again = g.step("left");
+      expect(again.moved).toBe(false);
+      expect(again.reward).toBe(0);
+      expect(g.state()).toEqual(before);
+    }
+  });
+
+  it("reports the realized tile spawn for recording", () => {
+    const g = new Game2048();
+    g.reset(9);
+    const result = g.step("left");
+    if (!result.moved) throw new Error("seed should permit a left move");
+    expect(result.randomEffects).toMatchObject({
+      kind: "tile_spawned",
+      value: expect.any(Number),
+      x: expect.any(Number),
+      y: expect.any(Number),
+    });
+  });
+
+  it("keeps variants deterministic while changing their rules", () => {
+    const rush = new Game2048("rush");
+    const chaos = new Game2048("chaos");
+    rush.reset(42);
+    chaos.reset(42);
+    expect(rush.variation.goal).toBe("Reach 512");
+    expect(chaos.variation.id).toBe("chaos");
+    expect(rush.state()).not.toEqual(chaos.state());
+  });
+});

package/src/games/g2048/engine.ts

@@ -0,0 +1,109 @@
+import { Rng } from "../../core/rng.js";
+
+export type Direction = "up" | "down" | "left" | "right";
+export type Board = number[][]; // 4x4, 0 = empty, otherwise tile value (2, 4, 8, ...)
+
+export const SIZE = 4;
+export const WIN_TILE = 2048;
+
+export interface MoveResult {
+  board: Board;
+  /** Sum of merged tile values created by this move (standard 2048 scoring). */
+  gained: number;
+  /** False when the move changes nothing (illegal in that direction). */
+  moved: boolean;
+}
+
+export function emptyBoard(): Board {
+  return Array.from({ length: SIZE }, () => Array<number>(SIZE).fill(0));
+}
+
+export function cloneBoard(board: Board): Board {
+  return board.map((row) => [...row]);
+}
+
+function emptyCells(board: Board): Array<[number, number]> {
+  const cells: Array<[number, number]> = [];
+  for (let r = 0; r < SIZE; r++) {
+    for (let c = 0; c < SIZE; c++) {
+      if (board[r]![c] === 0) cells.push([r, c]);
+    }
+  }
+  return cells;
+}
+
+/** Place a random tile (90% → 2, 10% → 4) in a random empty cell. */
+export function spawnTile(board: Board, rng: Rng, fourChance = 0.1): Board {
+  const cells = emptyCells(board);
+  if (cells.length === 0) return board;
+  const [r, c] = cells[rng.int(cells.length)]!;
+  const next = cloneBoard(board);
+  next[r]![c] = rng.next() < 1 - fourChance ? 2 : 4;
+  return next;
+}
+
+/** Slide and merge one row toward index 0. Each tile merges at most once. */
+function collapseRow(row: number[]): { row: number[]; gained: number } {
+  const tiles = row.filter((v) => v !== 0);
+  const out: number[] = [];
+  let gained = 0;
+  for (let i = 0; i < tiles.length; i++) {
+    if (i + 1 < tiles.length && tiles[i] === tiles[i + 1]) {
+      const merged = tiles[i]! * 2;
+      out.push(merged);
+      gained += merged;
+      i++; // skip the tile we merged with
+    } else {
+      out.push(tiles[i]!);
+    }
+  }
+  while (out.length < SIZE) out.push(0);
+  return { row: out, gained };
+}
+
+function transpose(board: Board): Board {
+  return board[0]!.map((_, c) => board.map((row) => row[c]!));
+}
+
+function reverseRows(board: Board): Board {
+  return board.map((row) => [...row].reverse());
+}
+
+/** Apply a move without spawning. Pure: never mutates the input. */
+export function move(board: Board, dir: Direction): MoveResult {
+  // Normalize every direction to "collapse rows leftward".
+  let grid = cloneBoard(board);
+  if (dir === "up") grid = transpose(grid);
+  else if (dir === "down") grid = reverseRows(transpose(grid));
+  else if (dir === "right") grid = reverseRows(grid);
+
+  let gained = 0;
+  grid = grid.map((row) => {
+    const res = collapseRow(row);
+    gained += res.gained;
+    return res.row;
+  });
+
+  if (dir === "up") grid = transpose(grid);
+  else if (dir === "down") grid = transpose(reverseRows(grid));
+  else if (dir === "right") grid = reverseRows(grid);
+
+  const moved = grid.some((row, r) => row.some((v, c) => v !== board[r]![c]));
+  return { board: grid, gained, moved };
+}
+
+export function highestTile(board: Board): number {
+  return Math.max(...board.flat());
+}
+
+export function canMove(board: Board): boolean {
+  if (emptyCells(board).length > 0) return true;
+  for (let r = 0; r < SIZE; r++) {
+    for (let c = 0; c < SIZE; c++) {
+      const v = board[r]![c]!;
+      if (r + 1 < SIZE && board[r + 1]![c] === v) return true;
+      if (c + 1 < SIZE && board[r]![c + 1] === v) return true;
+    }
+  }
+  return false;
+}

package/src/games/g2048/game2048.ts

@@ -0,0 +1,104 @@
+import type { Game, GameVariation, StepResult } from "../../core/game.js";
+import { Rng } from "../../core/rng.js";
+import {
+  Board,
+  Direction,
+  WIN_TILE,
+  canMove,
+  emptyBoard,
+  highestTile,
+  move,
+  spawnTile,
+} from "./engine.js";
+
+export interface State2048 {
+  board: Board;
+  score: number;
+  highest: number;
+}
+
+export class Game2048 implements Game<State2048, Direction> {
+  static readonly VARIATIONS: readonly GameVariation[] = [
+    { id: "classic", title: "Standard", description: "Standard 2048 rules.", goal: "Reach 2048" },
+    { id: "rush", title: "Rush", description: "Reach 512 before the board fills.", goal: "Reach 512" },
+    { id: "chaos", title: "Chaos", description: "More 4 tiles, faster-changing boards.", goal: "Reach 1024" },
+  ];
+
+  readonly name = "2048";
+  readonly actions = ["up", "down", "left", "right"] as const;
+  readonly variation: GameVariation;
+
+  private board: Board = emptyBoard();
+  private points = 0;
+  private rng = new Rng(0);
+  private won = false;
+  private over = false;
+  private readonly winTile: number;
+  private fourChance = 0.1;
+
+  constructor(variationId = "classic") {
+    this.variation = Game2048.VARIATIONS.find(({ id }) => id === variationId) ?? Game2048.VARIATIONS[0]!;
+    this.winTile = this.variation.id === "rush" ? 512 : this.variation.id === "chaos" ? 1024 : WIN_TILE;
+    this.fourChance = this.variation.id === "chaos" ? 0.35 : 0.1;
+  }
+
+  reset(seed: number): void {
+    this.rng = new Rng(seed);
+    this.fourChance = this.variation.id === "chaos" ? 0.2 + new Rng(seed).next() * 0.3 : 0.1;
+    this.points = 0;
+    this.won = false;
+    this.over = false;
+    this.board = spawnTile(spawnTile(emptyBoard(), this.rng, this.fourChance), this.rng, this.fourChance);
+  }
+
+  step(action: Direction): StepResult {
+    if (this.over) return { reward: 0, moved: false, done: true, success: this.won };
+
+    const res = move(this.board, action);
+    if (!res.moved) {
+      return { reward: 0, moved: false, done: false, success: this.won };
+    }
+
+    this.board = spawnTile(res.board, this.rng, this.fourChance);
+    let spawned: { kind: "tile_spawned"; x: number; y: number; value: number } | undefined;
+    for (let y = 0; y < this.board.length; y++) {
+      for (let x = 0; x < this.board[y]!.length; x++) {
+        if (res.board[y]![x] === 0 && this.board[y]![x] !== 0) {
+          spawned = { kind: "tile_spawned", x, y, value: this.board[y]![x]! };
+        }
+      }
+    }
+    this.points += res.gained;
+    if (!this.won && highestTile(this.board) >= this.winTile) this.won = true;
+    if (!canMove(this.board)) this.over = true;
+
+    return {
+      reward: res.gained,
+      moved: true,
+      done: this.over,
+      success: this.won,
+      ...(spawned ? { randomEffects: spawned } : {}),
+    };
+  }
+
+  state(): State2048 {
+    return {
+      board: this.board.map((row) => [...row]),
+      score: this.points,
+      highest: highestTile(this.board),
+    };
+  }
+
+  score(): number {
+    return this.points;
+  }
+
+  isOver(): boolean {
+    return this.over;
+  }
+
+  hasWon(): boolean {
+    return this.won;
+  }
+
+}

package/src/games/minesweeper/engine.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from "bun:test";
+import { Rng } from "../../core/rng.js";
+import { HEIGHT, MINES, WIDTH, isCleared, newField, placeMines, reveal, toggleFlag } from "./engine.js";
+import { MinesweeperGame } from "./minesweeper.js";
+
+describe("minesweeper engine", () => {
+  it("places exactly MINES mines, none near the first click", () => {
+    const field = newField();
+    placeMines(field, 4, 4, new Rng(3));
+    const mines = field.cells.flat().filter((c) => c.mine).length;
+    expect(mines).toBe(MINES);
+    for (let dy = -1; dy <= 1; dy++) {
+      for (let dx = -1; dx <= 1; dx++) {
+        expect(field.cells[4 + dy]![4 + dx]!.mine).toBe(false);
+      }
+    }
+  });
+
+  it("first reveal is always safe and flood-fills zeros", () => {
+    const field = newField();
+    const gained = reveal(field, 4, 4, new Rng(9));
+    expect(gained).toBeGreaterThan(0);
+    expect(field.exploded).toBe(false);
+  });
+
+  it("revealing a mine explodes", () => {
+    const field = newField();
+    reveal(field, 0, 0, new Rng(5));
+    let mineAt: [number, number] | null = null;
+    field.cells.forEach((row, y) =>
+      row.forEach((c, x) => {
+        if (c.mine && !mineAt) mineAt = [x, y];
+      }),
+    );
+    expect(mineAt).not.toBeNull();
+    const res = reveal(field, mineAt![0], mineAt![1], new Rng(5));
+    expect(res).toBe(-1);
+    expect(field.exploded).toBe(true);
+  });
+
+  it("flags block reveals and toggle off again", () => {
+    const field = newField();
+    expect(toggleFlag(field, 2, 2)).toBe(true);
+    expect(reveal(field, 2, 2, new Rng(1))).toBe(0);
+    expect(toggleFlag(field, 2, 2)).toBe(true);
+    expect(field.cells[2]![2]!.flagged).toBe(false);
+  });
+
+  it("clearing all safe cells wins", () => {
+    const field = newField();
+    reveal(field, 4, 4, new Rng(11));
+    for (let y = 0; y < HEIGHT; y++) {
+      for (let x = 0; x < WIDTH; x++) {
+        if (!field.cells[y]![x]!.mine) reveal(field, x, y, new Rng(11));
+      }
+    }
+    expect(isCleared(field)).toBe(true);
+  });
+});
+
+describe("MinesweeperGame", () => {
+  it("reports the realized mine layout on the first reveal", () => {
+    const g = new MinesweeperGame();
+    g.reset(123);
+    const result = g.step("reveal");
+    const effects = result.randomEffects as { kind: string; positions: unknown[] };
+    expect(effects.kind).toBe("mine_layout");
+    expect(Array.isArray(effects.positions)).toBe(true);
+    expect(effects.positions).toHaveLength(MINES);
+    expect(g.state()).not.toHaveProperty("mines");
+    expect(g.checkpointState().mines).toHaveLength(MINES);
+  });
+
+  it("moves the cursor within bounds and rewards reveals", () => {
+    const g = new MinesweeperGame();
+    g.reset(123);
+    for (let i = 0; i < 20; i++) g.step("left"); // clamp at edge
+    expect(g.state().cursor.x).toBe(0);
+    const res = g.step("reveal");
+    expect(res.moved).toBe(true);
+    expect(Math.abs(res.reward)).toBeGreaterThan(0);
+  });
+});

package/src/games/minesweeper/engine.ts

@@ -0,0 +1,112 @@
+import type { Rng } from "../../core/rng.js";
+
+/**
+ * Pure minesweeper rules on a 9×9 / 10-mine beginner board. Mines are laid
+ * out on the first reveal so the opening click (and its neighbors) is
+ * always safe.
+ */
+
+export const WIDTH = 9;
+export const HEIGHT = 9;
+export const MINES = 10;
+
+export interface Cell {
+  mine: boolean;
+  revealed: boolean;
+  flagged: boolean;
+  /** Adjacent mine count, valid once mines are placed. */
+  adjacent: number;
+}
+
+export interface Field {
+  cells: Cell[][];
+  minesPlaced: boolean;
+  exploded: boolean;
+}
+
+export function newField(): Field {
+  const cells = Array.from({ length: HEIGHT }, () =>
+    Array.from({ length: WIDTH }, (): Cell => ({ mine: false, revealed: false, flagged: false, adjacent: 0 })),
+  );
+  return { cells, minesPlaced: false, exploded: false };
+}
+
+function neighbors(x: number, y: number): Array<[number, number]> {
+  const out: Array<[number, number]> = [];
+  for (let dy = -1; dy <= 1; dy++) {
+    for (let dx = -1; dx <= 1; dx++) {
+      if (dx === 0 && dy === 0) continue;
+      const nx = x + dx;
+      const ny = y + dy;
+      if (nx >= 0 && ny >= 0 && nx < WIDTH && ny < HEIGHT) out.push([nx, ny]);
+    }
+  }
+  return out;
+}
+
+/** Lay mines everywhere except the first-clicked cell and its neighbors. */
+export function placeMines(field: Field, safeX: number, safeY: number, rng: Rng): void {
+  const banned = new Set([`${safeX},${safeY}`, ...neighbors(safeX, safeY).map(([x, y]) => `${x},${y}`)]);
+  const spots: Array<[number, number]> = [];
+  for (let y = 0; y < HEIGHT; y++) {
+    for (let x = 0; x < WIDTH; x++) {
+      if (!banned.has(`${x},${y}`)) spots.push([x, y]);
+    }
+  }
+  for (let i = 0; i < MINES; i++) {
+    const idx = rng.int(spots.length);
+    const [x, y] = spots.splice(idx, 1)[0]!;
+    field.cells[y]![x]!.mine = true;
+  }
+  for (let y = 0; y < HEIGHT; y++) {
+    for (let x = 0; x < WIDTH; x++) {
+      field.cells[y]![x]!.adjacent = neighbors(x, y).filter(([nx, ny]) => field.cells[ny]![nx]!.mine).length;
+    }
+  }
+  field.minesPlaced = true;
+}
+
+/**
+ * Reveal a cell (flood-filling zeros). Returns how many cells were newly
+ * revealed, or -1 if a mine went off.
+ */
+export function reveal(field: Field, x: number, y: number, rng: Rng): number {
+  const cell = field.cells[y]?.[x];
+  if (!cell || cell.revealed || cell.flagged || field.exploded) return 0;
+  if (!field.minesPlaced) placeMines(field, x, y, rng);
+  if (cell.mine) {
+    field.exploded = true;
+    cell.revealed = true;
+    return -1;
+  }
+  let count = 0;
+  const stack: Array<[number, number]> = [[x, y]];
+  while (stack.length > 0) {
+    const [cx, cy] = stack.pop()!;
+    const c = field.cells[cy]![cx]!;
+    if (c.revealed || c.flagged || c.mine) continue;
+    c.revealed = true;
+    count++;
+    if (c.adjacent === 0) stack.push(...neighbors(cx, cy));
+  }
+  return count;
+}
+
+export function toggleFlag(field: Field, x: number, y: number): boolean {
+  const cell = field.cells[y]?.[x];
+  if (!cell || cell.revealed || field.exploded) return false;
+  cell.flagged = !cell.flagged;
+  return true;
+}
+
+export function revealedCount(field: Field): number {
+  return field.cells.flat().filter((c) => c.revealed && !c.mine).length;
+}
+
+export function isCleared(field: Field): boolean {
+  return !field.exploded && revealedCount(field) === WIDTH * HEIGHT - MINES;
+}
+
+export function flagCount(field: Field): number {
+  return field.cells.flat().filter((c) => c.flagged).length;
+}

package/src/games/minesweeper/minesweeper.ts

@@ -0,0 +1,107 @@
+import type { Game, StepResult } from "../../core/game.js";
+import { Rng } from "../../core/rng.js";
+import {
+  HEIGHT,
+  MINES,
+  WIDTH,
+  flagCount,
+  isCleared,
+  newField,
+  reveal,
+  revealedCount,
+  toggleFlag,
+  type Field,
+} from "./engine.js";
+
+export type MinesweeperAction = "up" | "down" | "left" | "right" | "reveal" | "flag";
+
+export interface MinesweeperState {
+  /** -1 hidden, -2 flagged, -3 mine (shown once exploded), 0-8 revealed counts. */
+  view: number[][];
+  cursor: { x: number; y: number };
+  revealed: number;
+  exploded: boolean;
+}
+
+
+export class MinesweeperGame implements Game<MinesweeperState, MinesweeperAction> {
+  readonly name = "minesweeper";
+  readonly actions = ["up", "down", "left", "right", "reveal", "flag"] as const;
+  readonly keymap = { space: "reveal", enter: "reveal", f: "flag" } as const;
+
+  private rng = new Rng(0);
+  private field: Field = newField();
+  private cx = Math.floor(WIDTH / 2);
+  private cy = Math.floor(HEIGHT / 2);
+  private cleared = false;
+
+  reset(seed: number): void {
+    this.rng = new Rng(seed);
+    this.field = newField();
+    this.cx = Math.floor(WIDTH / 2);
+    this.cy = Math.floor(HEIGHT / 2);
+    this.cleared = false;
+  }
+
+  step(action: MinesweeperAction): StepResult {
+    if (this.isOver()) return { reward: 0, moved: false, done: true, success: this.cleared };
+    if (action === "up" || action === "down" || action === "left" || action === "right") {
+      const nx = this.cx + (action === "left" ? -1 : action === "right" ? 1 : 0);
+      const ny = this.cy + (action === "up" ? -1 : action === "down" ? 1 : 0);
+      if (nx < 0 || ny < 0 || nx >= WIDTH || ny >= HEIGHT) return { reward: 0, moved: false, done: false, success: false };
+      this.cx = nx;
+      this.cy = ny;
+      return { reward: 0, moved: true, done: false, success: false };
+    }
+    if (action === "flag") {
+      const moved = toggleFlag(this.field, this.cx, this.cy);
+      return { reward: 0, moved, done: false, success: false };
+    }
+    const placedMines = !this.field.minesPlaced;
+    const gained = reveal(this.field, this.cx, this.cy, this.rng);
+    const randomEffects = placedMines
+      ? {
+          kind: "mine_layout",
+          positions: this.field.cells.flatMap((row, y) =>
+            row.flatMap((cell, x) => cell.mine ? [{ x, y }] : [])
+          ),
+        }
+      : undefined;
+    if (gained === 0) return { reward: 0, moved: false, done: false, success: false };
+    if (gained < 0) return { reward: 0, moved: true, done: true, success: false, randomEffects };
+    this.cleared = isCleared(this.field);
+    return { reward: gained, moved: true, done: this.cleared, success: this.cleared, randomEffects };
+  }
+
+  state(): MinesweeperState {
+    const view = this.field.cells.map((row) =>
+      row.map((c) => {
+        if (c.revealed) return c.mine ? -3 : c.adjacent;
+        if (c.flagged) return -2;
+        return -1;
+      }),
+    );
+    return { view, cursor: { x: this.cx, y: this.cy }, revealed: revealedCount(this.field), exploded: this.field.exploded };
+  }
+
+  checkpointState(): MinesweeperState & { mines: Array<{ x: number; y: number }> } {
+    return {
+      ...this.state(),
+      mines: this.field.cells.flatMap((row, y) =>
+        row.flatMap((cell, x) => cell.mine ? [{ x, y }] : [])
+      ),
+    };
+  }
+
+  score(): number {
+    return revealedCount(this.field);
+  }
+
+  isOver(): boolean {
+    return this.field.exploded || this.cleared;
+  }
+
+  hasWon(): boolean {
+    return this.cleared;
+  }
+}

package/src/games/registry.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "bun:test";
+import { playableGames } from "./registry.js";
+
+describe("registry", () => {
+  for (const entry of playableGames()) {
+    for (const variation of entry.variations) {
+      it(`${entry.id} (${variation.id}) is not over immediately after reset`, () => {
+        for (const seed of [0, 1, 2, 42, 12345]) {
+          const game = entry.create!(variation.id);
+          game.reset(seed);
+          expect(game.isOver()).toBe(false);
+        }
+      });
+    }
+  }
+});