@nayan-ui/games 1.19.0 → 1.21.0

package/lib/typescript/src/games/mob-control/MobControlScene.d.ts

@@ -0,0 +1,58 @@
+import { type Camera, type Entity, type World } from '@nayan-ui/engine';
+import type { Sim } from './MobControlRules';
+export interface View {
+    width: number;
+    height: number;
+    k: number;
+}
+interface BaseView {
+    root: Entity;
+    body: Entity;
+    bar: Entity;
+    digits: Entity[];
+    shown: string;
+    hp: number;
+    captured: boolean;
+}
+interface GateView {
+    root: Entity;
+    panel: Entity;
+    hits: number;
+    factor: number;
+}
+interface BarrierView {
+    root: Entity;
+    digits: Entity[];
+    shown: number;
+    broken: boolean;
+}
+interface BossView {
+    root: Entity;
+    bar: Entity;
+    digits: Entity[];
+    shown: number;
+    visible: boolean;
+}
+export interface Scene {
+    root: Entity;
+    battleRoot: Entity;
+    cannon: Entity;
+    barrel: Entity;
+    chargeBar: Entity;
+    chargeShown: number;
+    battle: Sim | null;
+    bases: BaseView[];
+    gates: GateView[];
+    barriers: BarrierView[];
+    boss: BossView | null;
+    night: boolean;
+}
+export declare function makeView(width: number, height: number, camera: Camera): View;
+export declare function buildScene(world: World, night: boolean, sim: Sim): Scene;
+export declare function syncScene(world: World, s: Scene, sim: Sim, labels: boolean): void;
+export declare function recoil(world: World, s: Scene): void;
+export declare function battleEffect(world: World, x: number, z: number, player: boolean): void;
+export declare function captured(world: World, x: number, z: number): void;
+export declare function celebrate(world: World): void;
+export declare function removeScene(world: World, s: Scene): void;
+export {};

package/lib/typescript/src/games/number-search/NumberSearch.d.ts

@@ -1,3 +1 @@
-import React from 'react';
-import { type GameProps } from '../../services/UtilsService';
-export declare const NumberSearch: React.FC<GameProps>;
+export declare const NumberSearch: import("react").FC<import("../..").GameProps>;

package/lib/typescript/src/games/number-search/NumberSearchNumbers.d.ts

@@ -0,0 +1 @@
+export declare const NUMBERS: readonly string[];

package/lib/typescript/src/games/nuts-and-bolts/NutsAndBolts.d.ts

@@ -1,3 +1 @@
-import React from 'react';
-import { type GameProps } from '../../services/UtilsService';
-export declare const NutsAndBolts: React.FC<GameProps>;
+export declare const NutsAndBolts: import("react").FC<import("../..").GameProps>;

package/lib/typescript/src/games/nuts-and-bolts/NutsAndBoltsConstants.d.ts

@@ -1,80 +1,28 @@
-export declare const NUTS_AND_BOLTS_COLORS: {
-    BACKGROUND: string;
-    PRIMARY: string;
-    BOARD_BG: string;
-    BOARD_BORDER: string;
-    BOARD_INNER: string;
-    BOLT_OUTER_TOP: string;
-    BOLT_OUTER_FACE: string;
-    BOLT_OUTER_BOTTOM: string;
-    BOLT_OUTER_SHADOW: string;
-    BOLT_RING_TOP: string;
-    BOLT_RING_FACE: string;
-    BOLT_RING_BOTTOM: string;
-    BOLT_CENTER_TOP: string;
-    BOLT_CENTER_FACE: string;
-    BOLT_CENTER_BOTTOM: string;
-    BOLT_SLOT: string;
-    BOLT_SPECULAR: string;
-    BOLT_RIM_LIGHT: string;
-    BOLT_THREAD: string;
-    BOLT_SEL_OUTER_TOP: string;
-    BOLT_SEL_OUTER_FACE: string;
-    BOLT_SEL_OUTER_BOTTOM: string;
-    BOLT_SEL_GLOW: string;
-    BOLT_SEL_RING_TOP: string;
-    BOLT_SEL_RING_FACE: string;
-    BOLT_SEL_RING_BOTTOM: string;
-    BOLT_SEL_CENTER_TOP: string;
-    BOLT_SEL_CENTER_FACE: string;
-    BOLT_SEL_CENTER_BOTTOM: string;
-    BOLT_SEL_SLOT: string;
-    BOLT_SEL_SPECULAR: string;
-    PLANK_H_TOP: string;
-    PLANK_H_FACE: string;
-    PLANK_H_BOTTOM: string;
-    PLANK_H_SHADOW: string;
-    PLANK_H_HIGHLIGHT: string;
-    PLANK_H_GRAIN1: string;
-    PLANK_H_GRAIN2: string;
-    PLANK_H_EDGE_TOP: string;
-    PLANK_H_EDGE_BOTTOM: string;
-    PLANK_H_KNOT: string;
-    PLANK_V_TOP: string;
-    PLANK_V_FACE: string;
-    PLANK_V_BOTTOM: string;
-    PLANK_V_SHADOW: string;
-    PLANK_V_HIGHLIGHT: string;
-    PLANK_V_GRAIN1: string;
-    PLANK_V_GRAIN2: string;
-    PLANK_V_EDGE_TOP: string;
-    PLANK_V_EDGE_BOTTOM: string;
-    PLANK_V_RIVET: string;
-    HOLE_RIM: string;
-    HOLE_RIM_HIGHLIGHT: string;
-    HOLE_DEPTH: string;
-    HOLE_INNER: string;
-    HOLE_INNER_SHADOW: string;
-    HOLE_SHADOW: string;
-    HOLE_EXTRA_RIM: string;
-    HOLE_EXTRA_RIM_HIGHLIGHT: string;
-    HOLE_EXTRA_DEPTH: string;
-    HOLE_EXTRA_INNER: string;
-    HOLE_EXTRA_INNER_SHADOW: string;
-    HOLE_EXTRA_SHADOW: string;
-    SEPARATOR: string;
-    SCORE_TEXT: string;
-};
-export declare const NUTS_AND_BOLTS_GAME_CONFIG: {
-    BOARD_COLS: number;
-    BOARD_ROWS: number;
-    HOLE_RADIUS: number;
-    BOLT_RADIUS: number;
-    CELL_SIZE: number;
-    BOARD_PADDING: number;
-    PLANK_HEIGHT: number;
-    EXTRA_HOLES: number;
-    TIME_LIMIT: number;
-    BASE_SCORE: number;
-    TIME_BONUS_PER_SECOND: number;
+import type { TiltView } from '../shared/EngineTilt';
+export declare const BOARD_COLS = 5;
+export declare const BOARD_ROWS = 5;
+export declare const EXTRA_HOLES = 3;
+export declare const TIME_LIMIT = 120;
+export declare const LIFT_TIME = 0.26;
+export declare const MOVE_TIME = 0.6;
+export declare const FALL_TIME = 0.6;
+/** The camera leans back from straight down, so the planks' stack and the bolt heads stand up. */
+export declare const TILT = 0.38;
+/** Lit from the upper left; surfaces facing up off the board (+z) keep their exact color. */
+export declare const LIGHT: import("@nayan-ui/engine").Light;
+export declare const CLASSIC_BOARD = "rgba(255, 255, 255, 0.30)";
+export declare const CLASSIC_SEPARATOR = "rgba(255, 255, 255, 0.1)";
+export type Layout = TiltView & {
+    cell: number;
+    padding: number;
+    boardWidth: number;
+    boardHeight: number;
 };
+/** The board as the original version sized it (5 x 5 points and the swap row below), smaller if the screen is short. */
+export declare function getLayout(width: number, height: number, offset: number): Layout;
+/** A grid point (row 0 along the top) on the board, in world units: the 5 x 5 points centred across, in the board's top part. */
+export declare function pointAt(l: Layout, row: number, col: number): [number, number];
+/** Swap hole `i`'s centre, along the bottom, 1.2 cells apart. */
+export declare function swapAt(l: Layout, i: number): [number, number];
+/** The line between the grid and the swap row. */
+export declare const separatorY: (l: Layout) => number;

package/lib/typescript/src/games/nuts-and-bolts/NutsAndBoltsGame.d.ts

@@ -0,0 +1,56 @@
+import { type Camera, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './NutsAndBoltsConstants';
+import { type Bolt, type Hole, type Plank } from './NutsAndBoltsRules';
+import { type Scene } from './NutsAndBoltsScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** select: a bolt picked up; place: one screwed into a new hole; complete: the last plank's down. */
+export type GameEvent = 'select' | 'place' | 'complete';
+export declare function createGame(theme: GameTheme): {
+    selected: string | null;
+    score: number;
+    time: number;
+    won: boolean;
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onTime: (_t: number) => void;
+    onPlanks: (_n: number) => void;
+    onEvent: (_e: GameEvent) => void;
+    holes: Hole[];
+    bolts: Bolt[];
+    planks: Plank[];
+    homes: {
+        row: number;
+        col: number;
+    }[];
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the board out for the view (first layout, header height, rotation): rebuilt from the puzzle's state. */
+export declare function setLayout(g: Game, l: Layout): void;
+export declare function setTheme(g: Game, theme: GameTheme): void;
+/** Plays the puzzle that's showing. */
+export declare function start(g: Game): void;
+/** A fresh puzzle, not started (Stop, Play Again). The world, and the GPU view drawing it, are kept. */
+export declare function reset(g: Game): void;
+export declare function dispose(g: Game): void;
+export declare function tick(g: Game, dt: number): void;
+type Target = {
+    row: number;
+    col: number;
+    holeId: string | null;
+};
+/**
+ * What a view point is on, within half a cell, checked as the original board did: the swap holes, then the
+ * empty bolt holes on the board, then the bolts on it.
+ */
+export declare function targetAt(g: Game, x: number, y: number): Target | null;
+export declare function tap(g: Game, x: number, y: number): void;
+/** The store's handleTap: pick up, put back, switch to another bolt, or move the picked-up bolt. */
+export declare function choose(g: Game, t: Target): void;
+export {};

package/lib/typescript/src/games/nuts-and-bolts/NutsAndBoltsRules.d.ts

@@ -0,0 +1,65 @@
+export interface Hole {
+    id: string;
+    row: number;
+    col: number;
+    boltId: string | null;
+}
+export interface Bolt {
+    id: string;
+    row: number;
+    col: number;
+    originalRow: number;
+    originalCol: number;
+    holeId: string | null;
+}
+export interface Plank {
+    id: string;
+    orientation: 'horizontal' | 'vertical';
+    startRow: number;
+    startCol: number;
+    length: number;
+    color: string;
+    zIndex: number;
+}
+export interface PuzzleState {
+    holes: Hole[];
+    bolts: Bolt[];
+    planks: Plank[];
+}
+export declare const getPlankPositions: (plank: Plank) => {
+    row: number;
+    col: number;
+}[];
+export declare const plankCoversPosition: (plank: Plank, row: number, col: number) => boolean;
+export declare const generatePuzzle: () => PuzzleState;
+export declare const getBoltById: (boltId: string, bolts: Bolt[]) => Bolt | null;
+export declare const getBoltAtPosition: (row: number, col: number, bolts: Bolt[]) => Bolt | null;
+export declare const getHoleById: (holeId: string, holes: Hole[]) => Hole | null;
+export declare const getPlanksAtPosition: (row: number, col: number, planks: Plank[]) => Plank[];
+export declare const getPlankIntersections: (planks: Plank[]) => {
+    row: number;
+    col: number;
+}[];
+export declare const getValidBoltPositions: (planks: Plank[]) => {
+    row: number;
+    col: number;
+}[];
+export declare const getEmptyGridHoles: (_planks: Plank[], bolts: Bolt[]) => {
+    row: number;
+    col: number;
+}[];
+export declare const canSelectBolt: (bolt: Bolt, planks: Plank[]) => boolean;
+export declare const canPlaceBoltInHole: (hole: Hole) => boolean;
+export declare const moveBoltToHole: (boltId: string, holeId: string, bolts: Bolt[], holes: Hole[]) => {
+    bolts: Bolt[];
+    holes: Hole[];
+};
+export declare const moveBoltToGrid: (boltId: string, row: number, col: number, bolts: Bolt[], holes: Hole[]) => {
+    bolts: Bolt[];
+    holes: Hole[];
+};
+export declare const checkPlankRemoval: (planks: Plank[], bolts: Bolt[]) => {
+    removedPlanks: Plank[];
+    remainingPlanks: Plank[];
+};
+export declare const isPuzzleComplete: (planks: Plank[]) => boolean;

package/lib/typescript/src/games/nuts-and-bolts/NutsAndBoltsScene.d.ts

@@ -0,0 +1,48 @@
+import { type Entity, type Vec3, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './NutsAndBoltsConstants';
+import { type Plank } from './NutsAndBoltsRules';
+export declare const holeRadius: (l: Layout) => number;
+export declare const boltRadius: (l: Layout) => number;
+/** Where a bolt sits: on top of the highest plank at its point (or the board). */
+export declare const boltRest: (planks: Plank[], row: number, col: number) => number;
+export type Scene = {
+    backdrop: Entity;
+    panel: Entity;
+    rim: Entity | null;
+    separator: Entity;
+    sockets: Entity[];
+    swaps: Entity[];
+    planks: Map<string, Entity>;
+    /** Each bolt: an unturned pivot (position and spin about z) carrying the standing bolt (its color). */
+    bolts: Map<string, {
+        pivot: Entity;
+        body: Entity;
+    }>;
+};
+export declare function buildScene(world: World, l: Layout, theme: GameTheme, homes: {
+    row: number;
+    col: number;
+}[]): Scene;
+export declare function removeScene(world: World, s: Scene): void;
+export declare function setSceneTheme(world: World, l: Layout, s: Scene, theme: GameTheme): void;
+/** The sockets at the bolts' homes (a new puzzle). */
+export declare function placeSockets(world: World, l: Layout, s: Scene, homes: {
+    row: number;
+    col: number;
+}[]): void;
+export declare function spawnPlank(world: World, l: Layout, s: Scene, p: Plank): void;
+/** A freed plank swings down off the board and fades, then goes. Returns how long that takes. */
+export declare function dropPlank(world: World, l: Layout, s: Scene, p: Plank): number;
+export declare function spawnBolt(world: World, l: Layout, s: Scene, id: string, at: Vec3): void;
+export declare function removeBolts(world: World, s: Scene): void;
+/** Picked up: the bolt turns gold and unscrews up out of its hole (turning as it rises), then hovers. */
+export declare function liftBolt(world: World, l: Layout, s: Scene, id: string, at: Vec3): void;
+/** Put back where it was: it screws back down (turning clockwise as it sinks) and seats, in silver. */
+export declare function lowerBolt(world: World, l: Layout, s: Scene, id: string, at: Vec3): void;
+/** A bolt whose plank underneath fell: it drops onto the next one down. */
+export declare function settleBolt(world: World, s: Scene, id: string, at: Vec3): void;
+/** Moved: it lifts clear, arcs over above the planks, then screws down into its new hole and seats. */
+export declare function moveBolt(world: World, l: Layout, s: Scene, id: string, from: Vec3, to: Vec3): void;
+/** Confetti over the board when every plank's down. */
+export declare function celebrate(world: World, l: Layout): void;

package/lib/typescript/src/games/pac-man/PacMan.d.ts

@@ -1,3 +1 @@
-import React from 'react';
-import { type GameProps } from '../../services/UtilsService';
-export declare const PacMan: React.FC<GameProps>;
+export declare const PacMan: import("react").FC<import("../..").GameProps>;

package/lib/typescript/src/games/pac-man/PacManConstants.d.ts

@@ -1,22 +1,22 @@
-export declare const PACMAN_GAME_CONFIG: {
-    readonly GRID_COLS: 19;
-    readonly GRID_ROWS: 21;
-    readonly CELL_SIZE: number;
-    readonly GAME_SPEED: 31;
-    readonly SUB_STEPS: 8;
-    readonly MOVE_SPEED: 0.125;
-    readonly GHOST_SPEED_RATIO: 0.45;
-    readonly POINTS_PER_DOT: 100;
-    readonly POINTS_PER_POWER_PELLET: 500;
-    readonly POINTS_PER_GHOST: 500;
-    readonly POINTS_PER_FRUIT: 300;
-    readonly POWER_PELLET_DURATION: 7000;
-    readonly SCATTER_DURATION: 7000;
-    readonly CHASE_DURATION: 20000;
-    readonly INITIAL_LIVES: 3;
-    readonly FRUIT_SPAWN_DOTS: readonly [70, 170];
-    readonly FRUIT_DURATION: 10000;
-};
+import type { TiltView } from '../shared/EngineTilt';
+export declare const COLS = 19;
+export declare const ROWS = 21;
+export declare const POINTS_PER_DOT = 100;
+export declare const POINTS_PER_POWER_PELLET = 500;
+export declare const POINTS_PER_GHOST = 500;
+export declare const POINTS_PER_FRUIT = 300;
+export declare const INITIAL_LIVES = 3;
+export declare const TIME_LIMIT = 300;
+export declare const PAC_STEP = 0.16;
+export declare const GHOST_STEP = 0.25;
+export declare const GHOST_EATEN_STEP = 0.1;
+export declare const POWER_PELLET_TIME = 7;
+export declare const FLASH_TIME = 2;
+export declare const SCATTER_TIME = 7;
+export declare const CHASE_TIME = 20;
+export declare const FRUIT_TIME = 10;
+export declare const FRUIT_SPAWN_DOTS: number[];
+export declare const CHOMP_TIME = 0.16;
 export declare enum CellType {
     EMPTY = 0,
     WALL = 1,
@@ -35,100 +35,60 @@ export declare enum GhostMode {
     LEAVING_HOUSE = "leaving_house"
 }
 export declare enum GhostName {
-    BLINKY = "blinky",// Red - chases directly
-    PINKY = "pinky",// Pink - ambushes ahead
-    INKY = "inky",// Cyan - unpredictable
+    BLINKY = "blinky",
+    PINKY = "pinky",
+    INKY = "inky",
     CLYDE = "clyde"
 }
-export declare const PACMAN_COLORS: {
-    readonly BACKGROUND: "#000000";
-    readonly GRID_BACKGROUND: "rgba(255, 255, 255, 0.15)";
-    readonly MAZE_WALL: "#2121DE";
-    readonly MAZE_WALL_INNER: "#0000AA";
-    readonly PACMAN_BODY: "#FFFF00";
-    readonly PACMAN_MOUTH: "#000000";
-    readonly DOT: "#FFFFFF";
-    readonly POWER_PELLET: "#FFFFFF";
-    readonly GHOST_BLINKY: "#FF0000";
-    readonly GHOST_PINKY: "#FFB8FF";
-    readonly GHOST_INKY: "#00FFFF";
-    readonly GHOST_CLYDE: "#FFB852";
-    readonly GHOST_FRIGHTENED: "#2121FF";
-    readonly GHOST_FRIGHTENED_FLASH: "#FFFFFF";
-    readonly GHOST_EATEN: "#FFFFFF";
-    readonly GHOST_EYES: "#FFFFFF";
-    readonly GHOST_PUPILS: "#2121DE";
-    readonly FRUIT_CHERRY: "#FF0000";
-    readonly GAME_OVER_COLOR: "#FF0000";
-    readonly READY_TEXT: "#FFFF00";
-};
-export declare const DIRECTIONS: {
-    readonly UP: {
-        readonly x: 0;
-        readonly y: -1;
-    };
-    readonly DOWN: {
-        readonly x: 0;
-        readonly y: 1;
-    };
-    readonly LEFT: {
-        readonly x: -1;
-        readonly y: 0;
-    };
-    readonly RIGHT: {
-        readonly x: 1;
-        readonly y: 0;
-    };
-    readonly NONE: {
-        readonly x: 0;
-        readonly y: 0;
-    };
+export type Direction = 'UP' | 'DOWN' | 'LEFT' | 'RIGHT' | 'NONE';
+export declare const DIRECTIONS: Record<Direction, {
+    x: number;
+    y: number;
+}>;
+export declare const OPPOSITE: Record<Direction, Direction>;
+export declare const GHOST_LIST: readonly [GhostName.BLINKY, GhostName.PINKY, GhostName.INKY, GhostName.CLYDE];
+export declare const GHOST_COLORS: Record<GhostName, string>;
+export declare const COLORS: {
+    readonly BOARD: "#0A0A2E";
+    readonly WALL: "#2742F0";
+    readonly WALL_EDGE: "#5A72FF";
+    readonly DOT: "#FFE2B0";
+    readonly PELLET: "#FFF4D6";
+    readonly PACMAN: "#FFE000";
+    readonly FRUIT: "#FF4040";
+    readonly FRUIT_STEM: "#4CAF50";
+    readonly FRIGHTENED: "#2334E8";
+    readonly FRIGHTENED_FLASH: "#F4F4FF";
+    readonly EYE: "#FFFFFF";
+    readonly PUPIL: "#1A1A6E";
 };
-export type Direction = keyof typeof DIRECTIONS;
+export declare const LIGHT: import("@nayan-ui/engine").Light;
+export declare const TILT = 0.34;
 export declare const PACMAN_MAZE: number[][];
 export declare const PACMAN_START: {
     x: number;
     y: number;
 };
-export declare const GHOST_START_POSITIONS: {
-    blinky: {
-        x: number;
-        y: number;
-    };
-    pinky: {
-        x: number;
-        y: number;
-    };
-    inky: {
-        x: number;
-        y: number;
-    };
-    clyde: {
-        x: number;
-        y: number;
-    };
-};
-export declare const GHOST_SCATTER_TARGETS: {
-    blinky: {
-        x: number;
-        y: number;
-    };
-    pinky: {
-        x: number;
-        y: number;
-    };
-    inky: {
-        x: number;
-        y: number;
-    };
-    clyde: {
-        x: number;
-        y: number;
-    };
+export declare const GHOST_START: Record<GhostName, {
+    x: number;
+    y: number;
+}>;
+export declare const GHOST_SCATTER: Record<GhostName, {
+    x: number;
+    y: number;
+}>;
+/** Seconds after the game starts before each ghost leaves the house. */
+export declare const GHOST_RELEASE: Record<GhostName, number>;
+export declare const HOUSE_DOOR: {
+    x: number;
+    y: number;
 };
-export declare const GHOST_RELEASE_TIMING: {
-    readonly blinky: 0;
-    readonly pinky: 2000;
-    readonly inky: 5000;
-    readonly clyde: 8000;
+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 declare function getLayout(width: number, height: number, offset: number): Layout;
+/** A grid point (cell units, 0.5 = a cell's centre) on the maze, in world units. Row 0 is the top. */
+export declare const gridPoint: (l: Layout, x: number, y: number) => [number, number];

package/lib/typescript/src/games/pac-man/PacManGame.d.ts

@@ -0,0 +1,48 @@
+import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { GhostMode, type Layout } from './PacManConstants';
+import { type Scene } from './PacManScene';
+export type Phase = 'ready' | 'playing' | 'over';
+export type GameEvent = 'chomp' | 'pellet' | 'fruit' | 'eatGhost' | 'eatGhostCombo' | 'lifeLost';
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    maze: import("./PacManRules").Maze;
+    pacman: import("./PacManRules").Pacman;
+    ghosts: import("./PacManRules").Ghost[];
+    fruit: {
+        x: number;
+        y: number;
+    } | null;
+    fruitExpireAt: number;
+    /** Score, lives and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    readonly lives: number;
+    won: boolean;
+    combo: number;
+    mode: GhostMode.SCATTER | GhostMode.CHASE;
+    modeTimer: number;
+    elapsed: number;
+    readonly timeLeft: number;
+    clock: number;
+    pacPending: number;
+    ghostPending: number;
+    anchor: [number, number] | null;
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onLives: (_l: number) => void;
+    onTime: (_t: number) => void;
+    onEvent: (_e: GameEvent) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+export declare function setLayout(g: Game, l: Layout): void;
+export declare function setTheme(g: Game, theme: GameTheme): void;
+export declare function start(g: Game): void;
+export declare function reset(g: Game): void;
+export declare function dispose(g: Game): void;
+export declare function drag(g: Game, { phase, x, y }: DragEvent): void;
+export declare function tick(g: Game, dt: number): void;

package/lib/typescript/src/games/pac-man/PacManRules.d.ts

@@ -0,0 +1,52 @@
+import { type Direction, GhostMode, GhostName } from './PacManConstants';
+export type Position = {
+    x: number;
+    y: number;
+};
+export type Pacman = {
+    x: number;
+    y: number;
+    direction: Direction;
+    nextDirection: Direction;
+};
+export type Ghost = {
+    name: GhostName;
+    x: number;
+    y: number;
+    direction: Direction;
+    mode: GhostMode;
+    previousMode: GhostMode;
+    /** Seconds of fright left. */
+    frightenedTimer: number;
+    isFlashing: boolean;
+};
+export type Fruit = {
+    x: number;
+    y: number;
+} | null;
+export type Maze = {
+    cells: number[][];
+    dotsRemaining: number;
+    totalDots: number;
+};
+export declare function initMaze(): Maze;
+export declare const initPacman: () => Pacman;
+export declare const initGhosts: () => Ghost[];
+export declare function canMove(cells: number[][], x: number, y: number): boolean;
+export declare function canGhostMove(cells: number[][], x: number, y: number, ghost: Ghost): boolean;
+/** One cell forward, taking the queued turn when it opens up. Returns whether the maze wrapped round the side. */
+export declare function stepPacman(p: Pacman, cells: number[][]): {
+    moved: boolean;
+    wrapped: boolean;
+};
+/** Eats whatever is on a cell. */
+export declare function eatAt(maze: Maze, x: number, y: number): {
+    points: number;
+    pellet: boolean;
+} | null;
+/** One cell of ghost movement, by its mode. `blinky` is Blinky's cell before this step (Inky aims off it). */
+export declare function moveGhost(cells: number[][], ghost: Ghost, pacman: Pacman, blinky: Position | null): Ghost;
+export declare function frightenGhosts(ghosts: Ghost[], duration: number): Ghost[];
+export declare const releaseGhost: (g: Ghost) => Ghost;
+export declare const reachedHouse: (g: Ghost) => Ghost;
+export declare const collides: (p: Pacman, g: Ghost) => boolean;