@nayan-ui/games 1.18.0 → 1.20.0

package/lib/typescript/src/games/mine-sweeper/MineSweeperScene.d.ts

@@ -0,0 +1,23 @@
+import { type Camera, type Entity, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './MineSweeperConstants';
+import { type Cell } from './MineSweeperRules';
+export type Scene = {
+    backdrop: Entity;
+    panel: Entity;
+    grid: Entity | null;
+    tiles: Entity[];
+    /** What sits on each cell: its count, a flag or a mine (null when nothing does). */
+    marks: (Entity | null)[];
+};
+export declare function buildScene(world: World, l: Layout, theme: GameTheme, grid: Cell[][]): Scene;
+export declare function removeScene(world: World, s: Scene): void;
+export declare function setSceneTheme(world: World, l: Layout, s: Scene, theme: GameTheme): void;
+/** Revealed cells sink to sand one after another, rippling out from the first, and show what they hold. */
+export declare function reveal(world: World, l: Layout, s: Scene, cells: Cell[], origin: Cell): void;
+/** A flag goes up, or comes down. */
+export declare function flag(world: World, l: Layout, s: Scene, cell: Cell): void;
+/** A mine goes off: a fireball, a jolt, and every mine shows. */
+export declare function explode(world: World, l: Layout, s: Scene, camera: Camera, hit: Cell, mines: Cell[]): void;
+/** Every safe cell cleared: confetti over the board. */
+export declare function celebrate(world: World, l: Layout): void;

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

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

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

@@ -1,89 +1,103 @@
-export declare const LANE_INNER = 0.86;
-export declare const GATE_REF_Y: number;
+import type { Light } from '@nayan-ui/engine';
 export declare const MOB_CONFIG: {
-    readonly SCREEN_WIDTH: number;
-    readonly SCREEN_HEIGHT: number;
-    readonly FIELD_TOP: number;
-    readonly FIELD_BOTTOM: number;
-    readonly ENEMY_LINE: number;
-    readonly PLAYER_LINE: number;
-    readonly ROAD_TOP_Y: number;
-    readonly ROAD_BOTTOM_Y: number;
-    readonly ROAD_HALF_TOP: number;
-    readonly ROAD_HALF_BOTTOM: number;
-    readonly DEPTH_FAR_SCALE: 0.78;
-    readonly DEPTH_NEAR_SCALE: 1.25;
-    readonly ENEMY_SCALE: 1.28;
-    readonly CANNON_Y: number;
-    readonly CANNON_WIDTH: 90 | 68;
-    readonly BLOB_MIN_RADIUS: 16 | 13;
-    readonly BLOB_MAX_RADIUS: 28 | 34;
-    readonly PLAYER_BLOB_SPEED: 7 | 5.6;
-    readonly ENEMY_BLOB_SPEED: 1.1 | 0.85;
-    readonly MAX_COUNT: 80;
-    readonly MAX_BLOBS: 28;
-    readonly ENEMY_COUNT_CAP: 40;
-    readonly FIRE_INTERVAL_MS: 480;
-    readonly FIRE_COUNT: 2;
-    readonly GATE_HEIGHT: 46 | 38;
-    readonly GATE_SPEED: 1.1 | 1.4;
-    readonly GATE_SPAWN_INTERVAL_MS: 3200;
-    readonly MAX_GATES: 2;
-    readonly ENEMY_BASE_HP: 40;
-    readonly ENEMY_HP_PER_LEVEL: 20;
-    readonly PLAYER_HP: 30;
-    readonly ENEMY_SPAWN_INTERVAL_MS: 3600;
-    readonly ENEMY_SPAWN_MIN_MS: 2200;
-    readonly ENEMY_LEVEL_CAP: 10;
-    readonly SCORE_PER_KILL: 100;
-    readonly SCORE_PER_LEVEL: 1000;
-    readonly GAME_DURATION_MS: 120000;
+    readonly HALF_WIDTH: 5.2;
+    readonly TRACK_NEAR_Z: 30;
+    readonly TRACK_FAR_Z: -150;
+    readonly CANNON_LIMIT: 4.25;
+    readonly CANNON_Z: 1.2;
+    readonly SPAWN_Z: -0.9;
+    readonly BASE_Z: -32;
+    readonly TARGET_LINE: -29.5;
+    readonly BREACH_Z: 0.15;
+    readonly PLAYER_HP: 1200;
+    readonly PLAYER_SLOTS: 640;
+    readonly ENEMY_SLOTS: 384;
+    readonly CAPACITY: 1024;
+    readonly BASE_HP: 1000;
+    readonly CORE_HP: 1400;
+    readonly ENEMY_WAVE_SIZE: 14;
+    readonly ENEMY_WAVE_INTERVAL: 1.35;
+    readonly ENEMY_SURGE_INTERVAL: 15;
+    readonly ENEMY_MAX_SURGE: 8;
+    readonly MAX_STRENGTH: 4096;
+    readonly PLAYER_SPEED: 4.8;
+    readonly ENEMY_SPEED: 2.65;
+    readonly FIRE_INTERVAL: 0.105;
+    readonly CHAMPION_CHARGE: 100;
+    readonly CHAMPION_PER_SHOT: 1.6;
+    readonly CHAMPION_STRENGTH: 42;
+    readonly CHAMPION_SPEED: 6.2;
+    readonly BOSS_STRENGTH: 170;
+    readonly BOSS_SPEED: 1.55;
+    readonly BOOST_SPEED: 1.65;
+    readonly BOOST_DURATION: 1.4;
+    readonly FLIGHT_DURATION: 0.38;
+    readonly COLLISION_RADIUS: 0.34;
+    readonly GRID_SIZE: 0.8;
+    readonly GRID_COLUMNS: 14;
+    readonly GRID_ROWS: 46;
+    readonly MAX_COLLISION_VISITS: 48;
+    readonly MAX_SEPARATION_VISITS: 12;
+    readonly STEP: number;
+    readonly MAX_FRAME: 0.05;
+    readonly HUD_INTERVAL: 0.12;
+    readonly EFFECT_INTERVAL: 0.075;
+    readonly MAX_EFFECTS: 6;
+    readonly WORLD_CAPACITY: 640;
+    readonly KILL_POINTS: 5;
+    readonly BASE_POINTS: 350;
+    readonly LEVEL_POINTS: 500;
 };
-export type GateOp = {
-    kind: 'mul';
-    value: number;
-} | {
-    kind: 'add';
-    value: number;
-};
-export declare const GATE_OPS: GateOp[];
-export declare const gateLabel: (op: GateOp) => string;
-export declare const radiusForCount: (count: number) => number;
+export interface Gate {
+    id: number;
+    x: number;
+    originX: number;
+    z: number;
+    halfWidth: number;
+    factor: number;
+    operation: 'multiply' | 'add' | 'divide';
+    moving: boolean;
+    hits: number;
+    remainder: number;
+}
+export interface Barrier {
+    x: number;
+    z: number;
+    halfWidth: number;
+    hp: number;
+    maxHp: number;
+}
+export interface BoostPad {
+    x: number;
+    z: number;
+    halfWidth: number;
+    halfLength: number;
+}
+export interface Base {
+    x: number;
+    z: number;
+    hp: number;
+    maxHp: number;
+    spawnClock: number;
+}
 export declare const MOB_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly PLAYER: "#4D96FF";
-    readonly PLAYER_LIGHT: "#B9D6FF";
-    readonly PLAYER_DARK: "#1E52A8";
-    readonly ENEMY: "#FF5C5C";
-    readonly ENEMY_LIGHT: "#FFC2C2";
-    readonly ENEMY_DARK: "#B32B2B";
-    readonly BLOB_SHADOW: "rgba(0,0,0,0.22)";
-    readonly GRASS_TOP: "#82C24A";
-    readonly GRASS_BOTTOM: "#5FA336";
-    readonly GRASS_DARK: "#3F7A28";
-    readonly SAND_FAR: "#A8916A";
-    readonly SAND_NEAR: "#C4AF86";
-    readonly SAND_EDGE: "rgba(70,50,24,0.30)";
-    readonly FLOWER_1: "#FFFFFF";
-    readonly FLOWER_2: "#FFD34A";
-    readonly FLOWER_3: "#FF7BAC";
-    readonly GATE_GOOD: "#6BCB77";
-    readonly GATE_GOOD_DARK: "#3C8F4C";
-    readonly GATE_ADD: "#FFB443";
-    readonly GATE_ADD_DARK: "#D9861E";
-    readonly GATE_FRAME: "#2B3A2E";
-    readonly ENEMY_BASE: "#C24350";
-    readonly ENEMY_BASE_DARK: "#7A2732";
-    readonly ENEMY_BASE_TOP: "#E36572";
-    readonly ENEMY_BASE_SIDE: "#94303C";
-    readonly CANNON: "#4E8FD6";
-    readonly CANNON_LIGHT: "#8FC0F5";
-    readonly CANNON_DARK: "#234E7D";
-    readonly CANNON_METAL: "#3A4A5E";
-    readonly CANNON_METAL_DARK: "#232E3D";
-    readonly HP_BAR_BG: "rgba(0,0,0,0.35)";
-    readonly HP_BAR_ENEMY: "#FF5C5C";
-    readonly HP_BAR_PLAYER: "#6BCB77";
-    readonly TEXT: "#ffffff";
+    readonly PLAYER: "#3998FF";
+    readonly ENEMY: "#F25467";
+    readonly PLAYER_DARK: "#1D568F";
+    readonly ENEMY_DARK: "#8D2D42";
+    readonly GATE: "#29BFFF";
+    readonly GATE_HIGH: "#A14CF5";
+    readonly GATE_DANGER: "#F16B68";
+    readonly FRAME: "#1763A8";
+    readonly ROAD: "#CDD0D2";
+    readonly ROAD_EDGE: "#E6BA78";
+    readonly GROUND: "#D7AB72";
+    readonly CHAMPION: "#FFC83E";
+    readonly BOOST: "#7DECF1";
+    readonly HP_PLAYER: "#54CDA2";
+    readonly HP_ENEMY: "#F25467";
 };
+export declare const SKY_DAY: readonly [0.67, 0.81, 0.88];
+export declare const SKY_NIGHT: readonly [0.035, 0.07, 0.13];
+export declare const DAY_LIGHT: Light;
+export declare const NIGHT_LIGHT: Light;

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

@@ -0,0 +1,45 @@
+import { type Camera, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { MobControlRenderer } from './MobControlRenderer';
+import { type Scene, type View } from './MobControlScene';
+export type Phase = 'ready' | 'playing' | 'over';
+export type GameEvent = 'shoot' | 'gate' | 'hit' | 'clash' | 'boss' | 'damage' | 'champion' | 'win' | 'lose';
+export interface Hud {
+    score: number;
+    hp: number;
+    army: number;
+    level: number;
+}
+export declare const INITIAL_HUD: Hud;
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    renderer: MobControlRenderer;
+    sim: import("./MobControlRules").Sim;
+    camera: Camera;
+    night: boolean;
+    view: View | null;
+    scene: Scene | null;
+    phase: Phase;
+    won: boolean;
+    active: boolean;
+    pending: number;
+    clock: number;
+    lastHud: number;
+    lastEffect: number;
+    hudKey: string;
+    feedback: Partial<Record<GameEvent, number>>;
+    readonly score: number;
+    onPhase: (_phase: Phase) => void;
+    onHud: (_hud: Hud) => void;
+    onEvent: (_event: GameEvent) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+export declare function setLayout(g: Game, width: number, height: number): void;
+export declare function setTheme(g: Game, theme: GameTheme): void;
+export declare function reset(g: Game): void;
+export declare function replay(g: Game): void;
+export declare function start(g: Game): void;
+export declare function aim(g: Game, x: number): void;
+export declare function setActive(g: Game, active: boolean): void;
+export declare function dispose(g: Game): void;
+export declare function tick(g: Game, dt: number): void;

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

@@ -0,0 +1,2 @@
+import { type Model } from '@nayan-ui/engine';
+export declare function unitMeshes(): readonly [Model, Model];

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

@@ -0,0 +1,20 @@
+import { type Model, type RenderSource, type World } from '@nayan-ui/engine';
+import type { Sim } from './MobControlRules';
+export declare class MobControlRenderer implements RenderSource {
+    private readonly world;
+    private readonly poses;
+    readonly capacity: number;
+    readonly matrices: Float32Array;
+    readonly colors: Float32Array;
+    readonly regions: Float32Array;
+    readonly ranges: Uint32Array;
+    count: number;
+    private disposed;
+    private readonly sizeStrength;
+    private readonly sizeKind;
+    private readonly sizes;
+    constructor(world: World, poses: readonly [Model, Model]);
+    sync(s: Sim, alpha: number, clock: number): void;
+    setView(matrix: Float32Array, width: number, height: number): void;
+    dispose(): void;
+}

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

@@ -0,0 +1,68 @@
+import { type Barrier, type Base, type BoostPad, type Gate } from './MobControlConstants';
+export interface Events {
+    shots: number;
+    gates: number;
+    clashes: number;
+    hits: number;
+    breaches: number;
+    captured: number;
+    champion: boolean;
+    barrierBroken: number;
+    bossDefeated: boolean;
+    won: boolean;
+    lost: boolean;
+    effectCount: number;
+    effectX: Float32Array;
+    effectZ: Float32Array;
+    effectTeam: Uint8Array;
+}
+export interface Sim {
+    alive: Uint8Array;
+    x: Float32Array;
+    z: Float32Array;
+    previousX: Float32Array;
+    previousZ: Float32Array;
+    strength: Uint16Array;
+    gatesPassed: Uint8Array;
+    ticket: Uint32Array;
+    kind: Uint8Array;
+    boost: Float32Array;
+    flight: Float32Array;
+    next: Int16Array;
+    playerGrid: Int16Array;
+    enemyGrid: Int16Array;
+    freePlayer: Uint16Array;
+    freeEnemy: Uint16Array;
+    freePlayerCount: number;
+    freeEnemyCount: number;
+    playerCount: number;
+    enemyCount: number;
+    playerStrength: number;
+    enemyStrength: number;
+    championCount: number;
+    bossCount: number;
+    charge: number;
+    serial: number;
+    seed: number;
+    level: number;
+    elapsed: number;
+    battleClock: number;
+    fireClock: number;
+    cannonX: number;
+    targetX: number;
+    hp: number;
+    score: number;
+    finished: boolean;
+    won: boolean;
+    gates: Gate[];
+    bases: Base[];
+    barriers: Barrier[];
+    boostPad: BoostPad | null;
+    events: Events;
+    collisionVisits: number;
+}
+export declare const isPlayer: (i: number) => boolean;
+export declare function createSim(seed?: number, level?: number): Sim;
+/** Pool pressure packs strength into an existing slot; it never silently deletes a multiplied army. */
+export declare function spawn(s: Sim, player: boolean, x: number, z: number, strength?: number, passed?: number, kind?: number, airborne?: boolean): number;
+export declare function step(s: Sim, dt: number): Events;

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;