@nayan-ui/games 1.18.0 → 1.20.0

package/lib/typescript/src/games/snakes-and-ladders/SnakesAndLaddersConstants.d.ts

@@ -1,63 +1,71 @@
 export declare const BOARD_SIZE = 10;
-export declare const TOTAL_CELLS: number;
 export declare const WINNING_POSITION = 100;
-export declare const BOARD_DIMENSION: number;
-export declare const INNER_BOARD_DIMENSION: number;
-export declare const CELL_SIZE: number;
-export declare const TOKEN_RADIUS: number;
-export declare const SNL_LAYOUT: {
-    readonly BOARD_DIMENSION: number;
-    readonly INNER_BOARD_DIMENSION: number;
-    readonly CELL_SIZE: number;
-    readonly TOKEN_RADIUS: number;
-};
-export interface SnakeData {
+export declare const MAX_SIXES = 3;
+export type SnakeData = {
     head: number;
     tail: number;
     color: string;
     accent: string;
     belly: string;
-}
-export declare const SNAKES: ReadonlyArray<SnakeData>;
-export interface LadderData {
+};
+export type LadderData = {
     bottom: number;
     top: number;
     color: string;
     highlight: string;
-}
-export declare const LADDERS: ReadonlyArray<LadderData>;
-export declare const CELL_TRANSITIONS: ReadonlyMap<number, number>;
-export interface CellPosition {
-    row: number;
-    col: number;
-    x: number;
-    y: number;
-    cx: number;
-    cy: number;
-}
-export declare const CELL_POSITIONS: ReadonlyArray<CellPosition>;
-export declare const CELL_COLORS: ReadonlyArray<string>;
-export declare const SNAKE_HEAD_SET: ReadonlySet<number>;
-export declare const LADDER_BASE_SET: ReadonlySet<number>;
-export declare const SNL_COLORS: {
-    readonly BOARD_BG: "#FFF8E1";
-    readonly BOARD_FRAME: "#5c4033";
-    readonly CELL_BORDER: "rgba(0, 0, 0, 0.08)";
-    readonly PLAYER_COLOR: "#1E88E5";
-    readonly PLAYER_ACCENT: "#1565C0";
-    readonly PLAYER_DARK: "#0D47A1";
-    readonly AI_COLOR: "#E53935";
-    readonly AI_ACCENT: "#C62828";
-    readonly AI_DARK: "#B71C1C";
-    readonly CELL_NUMBER: "rgba(0, 0, 0, 0.55)";
-    readonly CELL_NUMBER_STAR: "#F57F17";
-    readonly SNAKE_CELL_TINT: "rgba(244, 67, 54, 0.12)";
-    readonly LADDER_CELL_TINT: "rgba(76, 175, 80, 0.12)";
-    readonly START_CELL: "#E8F5E9";
-    readonly FINISH_CELL: "#FFF3E0";
 };
-export declare const SNL_GAME_CONFIG: {
-    readonly ANIMATION_DURATION: 300;
-    readonly AI_DELAY: 800;
-    readonly DICE_ROLL_DURATION: 500;
+/** Head (high) to tail (low): land on a head and slide down. */
+export declare const SNAKES: readonly SnakeData[];
+/** Bottom (low) to top (high): land on a foot and climb. */
+export declare const LADDERS: readonly LadderData[];
+export declare const SNAKE_AT: ReadonlyMap<number, SnakeData>;
+export declare const LADDER_AT: ReadonlyMap<number, LadderData>;
+/** Where a roll from `from` ends: past 100 it doesn't move; a snake or ladder at the landing cell is taken. */
+export declare function landing(from: number, roll: number): {
+    step: number;
+    end: number;
+};
+/** The player's score: 100 a cell, or 10,000 plus 50 for every cell the opponent is short of 100 on a win. */
+export declare function scoreFor(you: number, opponent: number): number;
+/** Pastel cells, cycling along the diagonals as the original board did. */
+export declare const CELL_PALETTE: string[];
+export declare const START_CELL = "#E8F5E9";
+export declare const FINISH_CELL = "#FFF3E0";
+export declare const NUMBER_COLOR = "#5B4E42";
+export declare const STAR_NUMBER_COLOR = "#F57F17";
+export declare const PLAYER_COLOR = "#43A047";
+export declare const AI_COLOR = "#E53935";
+export declare const ROLL_TIME = 0.9;
+export declare const MOVE_DELAY = 0.4;
+export declare const HOP_TIME = 0.17;
+export declare const SLIDE_PAUSE = 0.15;
+export declare const NEXT_TURN_DELAY = 0.4;
+export declare const PENALTY_DELAY = 1;
+export declare const CANT_MOVE_DELAY = 0.5;
+export declare const AI_DELAY = 0.8;
+/** The camera leans back this far from straight down, so the board's depth, snakes and pawns read as 3D. */
+export declare const TILT = 0.35;
+/** 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;
+/** In board units (the board's playing area is 1 across, centred on the origin, y up the board). */
+export declare const RIM = 0.014;
+export declare const TILE_TOP = 0.013;
+export declare const DIE_SIZE = 0.15;
+export declare const DIE_Y: number;
+export declare const START_X = -0.33;
+export declare const START_Z = 0.01;
+export declare const TOKEN_HEIGHT = 0.062;
+export type Layout = {
+    width: number;
+    height: number;
+    /** Points per board unit. */
+    size: number;
+    /** Where the board's centre is in the view. */
+    centerY: number;
 };
+/** The board as wide as the game area, centred between the scoreboard and the controls, the die below it. */
+export declare function getLayout(width: number, height: number, offset: number): Layout;
+/** Where a point on (or `z` above) the board, in board units, appears in the view. */
+export declare function toView(l: Layout, x: number, y: number, z?: number): [number, number];
+/** A cell's centre in board units: row 1 runs left to right along the bottom, then the rows snake upward. */
+export declare function cellCenter(cell: number): [number, number];

package/lib/typescript/src/games/snakes-and-ladders/SnakesAndLaddersGame.d.ts

@@ -0,0 +1,45 @@
+import { type Camera, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './SnakesAndLaddersConstants';
+import { type Scene } from './SnakesAndLaddersScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** 0 is you, 1 the AI. */
+export type Turn = 0 | 1;
+export type GameEvent = 'tap' | 'roll' | 'six' | 'penalty' | 'cantMove' | 'move' | 'snake' | 'ladder';
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    /** Each player's cell: 0 before the first move. */
+    positions: [number, number];
+    turn: Turn;
+    /** Sixes in a row this turn. */
+    sixes: number;
+    /** A roll is in play (rolling, moving, or the AI thinking). */
+    busy: boolean;
+    /** The die is rolling or a pawn moving. */
+    rolling: boolean;
+    /** The score lives in the engine (Rust). */
+    readonly score: number;
+    won: boolean;
+    onPhase: (_p: Phase) => void;
+    onPositions: (_you: number, _ai: number) => void;
+    onScore: (_s: number) => void;
+    onTurn: (_t: Turn) => void;
+    onEvent: (_e: GameEvent, _who: Turn) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the scene out for the view (first layout, header height, rotation): rebuilt from the game's state. */
+export declare function setLayout(g: Game, l: Layout): void;
+/** A new theme repaints the backdrop; the board keeps its classic colors, as the original board did. */
+export declare function setTheme(g: Game, theme: GameTheme): void;
+export declare function start(g: Game): void;
+/** A fresh game (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;
+/** Whether a tap at a view point should roll: the player's turn, nothing moving, the finger on the die. */
+export declare function tap(g: Game, x: number, y: number): void;

package/lib/typescript/src/games/snakes-and-ladders/SnakesAndLaddersScene.d.ts

@@ -0,0 +1,50 @@
+import { type Camera, type Entity, type Quat, type Vec3, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type LadderData, type Layout, type SnakeData } from './SnakesAndLaddersConstants';
+/**
+ * A snake's spine from its head (t = 0) to its tail tip (t = 1): an S-curve across the board, on the
+ * cells (with `raised`, at the height of its round body, before the board flattens it onto them).
+ */
+export declare function snakePath(s: SnakeData, raised?: boolean): Vec3[];
+/** The ladder's line, from its foot to its top, on the cells where a pawn climbs it. */
+export declare function ladderPath(l: LadderData): Vec3[];
+export declare const SHADOW_Z: number;
+/** The die showing `value` toward the camera (shared/EngineDice), turned `twist` round its up axis. */
+export declare const dieRotation: (value: number, twist?: number) => Quat;
+export type Scene = {
+    backdrop: Entity;
+    board: Entity;
+    tokens: [Entity, Entity];
+    shadows: [Entity, Entity];
+    die: Entity;
+    dieShadow: Entity;
+    ring: Entity;
+};
+/** Board units to world units (view points). */
+export declare const toWorld: (l: Layout, x: number, y: number, z: number) => Vec3;
+/** Points the camera at the board so it lands where the layout puts it. */
+export declare const aimCamera: (camera: Camera, l: Layout) => void;
+export declare function buildScene(world: World, l: Layout, theme: GameTheme): Scene;
+export declare function removeScene(world: World, s: Scene): void;
+export declare function setSceneTheme(world: World, s: Scene, theme: GameTheme): void;
+export declare const dieRest: (l: Layout) => Vec3;
+/** The die is tossed, tumbles and bounces to rest showing `value` (shared/EngineDice). */
+export declare function rollDie(world: World, l: Layout, s: Scene, value: number, time: number, disposed?: () => boolean): void;
+/** The gold ring under the die pulses while it's the player's roll. */
+export declare function showRollHint(world: World, l: Layout, s: Scene, on: boolean): void;
+/** A pawn's place on a board point (x, y) at height z, and its shadow's under it. */
+export declare function placeToken(world: World, l: Layout, s: Scene, who: number, at: Vec3): void;
+/**
+ * Moves a pawn through board points (x, y, z) in `time` seconds, along a smooth curve; with `hop`, it
+ * arcs up between them. Its shadow follows along the board.
+ */
+export declare function moveToken(world: World, l: Layout, s: Scene, who: number, points: Vec3[], time: number, hop?: number): void;
+/** The pawn whose turn it is bobs gently. */
+export declare function bobToken(world: World, l: Layout, s: Scene, who: number | null): void;
+/** A snake's bite: the pawn shakes and the board jolts. */
+export declare function snakeBite(world: World, l: Layout, s: Scene, camera: Camera, who: number): void;
+/** Sparkles at a board point (a ladder's top). */
+export declare function sparkle(world: World, l: Layout, at: Vec3): void;
+/** Confetti over the winning pawn. */
+export declare function confetti(world: World, l: Layout, at: Vec3): void;
+export declare function slidePath(from: number): Vec3[] | null;

package/lib/typescript/src/games/space-fighter/SpaceFighter.d.ts

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

package/lib/typescript/src/games/space-fighter/SpaceFighterConstants.d.ts

@@ -1,24 +1,34 @@
-export declare const SPACE_FIGHTER_GAME_CONFIG: {
-    GAME_DURATION: number;
-    SPACECRAFT_SIZE: number;
-    SPACECRAFT_SPEED: number;
-    ASTEROID_WIDTH: number;
-    ASTEROID_GAP: number;
-    ASTEROID_SPAWN_INTERVAL: number;
-    ASTEROID_SPEED: number;
-    GRAVITY: number;
-    BOUNCE_DAMPING: number;
-    FRICTION: number;
-    MAX_VELOCITY: number;
-    COLLISION_TOLERANCE: number;
-    COLLISION_COOLDOWN: number;
-};
-export declare const SPACE_FIGHTER_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly SPACECRAFT: "#00d4ff";
-    readonly ASTEROID: "#8b4513";
-    readonly ASTEROID_SHADOW: "#654321";
-    readonly STARS: "#ffffff";
-    readonly UI: "#ffffff";
+import type { Light } from '@nayan-ui/engine';
+export declare const TIME_LIMIT = 120;
+export declare const LIVES = 3;
+export declare const DODGE_POINTS = 500;
+export declare const HIT_COOLDOWN = 2;
+export declare const BASE_FRAME = 0.016;
+export declare const MAX_FRAME = 0.064;
+/** How far ahead of the camera the game plays, in world units: screen points map onto this plane. */
+export declare const PLAY_DEPTH = 12;
+export declare const FOV = 0.9;
+export declare const BACKGROUND = "#050311";
+export declare const DAY_BACKGROUND = "#A8DCF7";
+/** A cool starlight from the upper left, a touch of violet in the shadows. */
+export declare const LIGHT: Light;
+export type Layout = {
+    width: number;
+    height: number;
+    offset: number;
+    /** World units per screen point on the play plane. */
+    k: number;
+    shipSize: number;
+    shipY: number;
+    beltHeight: number;
+    gap: number;
+    spawnInterval: number;
+    /** Points per second. */
+    fallSpeed: number;
+    spawnY: number;
+    /** Where the scoreboard ends, for the start hint. */
+    scoreboardBottom: number;
 };
+export declare function getLayout(width: number, height: number, offset: number): Layout;
+/** Where a pair's opening goes: near the centre, wandering a little, never squeezing a belt off the edge. */
+export declare function gapLeft(l: Layout, random?: () => number): number;

package/lib/typescript/src/games/space-fighter/SpaceFighterGame.d.ts

@@ -0,0 +1,58 @@
+import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './SpaceFighterConstants';
+import { type Belt, type Ship, type Space } from './SpaceFighterScene';
+export type Phase = 'ready' | 'playing' | 'over';
+export type GameEvent = 'grab' | 'release' | 'dodge' | 'hit';
+/** A falling pair: the top of its belts (screen y), where its gap starts, and whether it's been passed. */
+type Pair = {
+    top: number;
+    gapLeft: number;
+    passed: boolean;
+    seed: number;
+    belts: Belt | null;
+};
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    layout: Layout | null;
+    space: Space | null;
+    /** Day (the sun) or night (the moon), from the theme. */
+    day: boolean;
+    ship: Ship | null;
+    phase: Phase;
+    /** Score, lives and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    readonly lives: number;
+    readonly timeLeft: number;
+    won: boolean;
+    shipX: number;
+    bank: number;
+    lastShipX: number;
+    dragging: boolean;
+    dragFrom: number;
+    dragStart: number;
+    pairs: Pair[];
+    nextSpawn: number;
+    lastHit: number;
+    clock: number;
+    seed: number;
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onLives: (_n: number) => void;
+    onTime: (_t: number) => void;
+    onEvent: (_e: GameEvent) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** A new theme: the sun comes out by day, the moon by night; the run carries on. */
+export declare function setTheme(g: Game, theme: GameTheme): void;
+/** Lays the world out for the view (first layout, header height, rotation): rebuilt from the game's state. */
+export declare function setLayout(g: Game, l: Layout): void;
+export declare function start(g: Game): void;
+/** Back to a fresh, unstarted game (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, frame: number): void;
+/** Dragging anywhere moves the ship sideways by as much as the finger moves. */
+export declare function drag(g: Game, { phase, x }: DragEvent): void;
+export {};

package/lib/typescript/src/games/space-fighter/SpaceFighterScene.d.ts

@@ -0,0 +1,51 @@
+import { type Entity, type MutableQuat, type Quat, type Vec3, type World } from '@nayan-ui/engine';
+import { type Layout } from './SpaceFighterConstants';
+/** A screen point on the play plane (or `depth` ahead), in world units. */
+export declare const toWorld: (l: Layout, x: number, y: number, depth?: number) => Vec3;
+/** The ship's lean and bank; pass `out` to reuse it (the result is only valid until the next call with it). */
+export declare const shipRotation: (bank: number, out?: MutableQuat) => Quat;
+export type Ship = {
+    root: Entity;
+    body: Entity;
+    flames: Entity[];
+};
+export declare function spawnShip(world: World, l: Layout, x: number): Ship;
+/** The exhausts flicker; dragging (thrusters on) burns them bigger and white-blue. */
+export declare function flicker(world: World, _l: Layout, s: Ship, boost: boolean): void;
+/** A run starts: the ship zooms up into place from below the screen. */
+export declare function launchShip(world: World, l: Layout, s: Ship): void;
+export declare function placeShip(world: World, l: Layout, s: Ship, x: number, bank: number): void;
+/** Hit: the ship barrel-rolls off the blow and blinks through its safe spell. */
+export declare function blinkShip(world: World, s: Ship): void;
+export declare function steadyShip(world: World, s: Ship): void;
+export type Belt = {
+    root: Entity;
+};
+/**
+ * A pair's two belts of tumbling asteroids, its top edge at screen y: one from the left edge to the
+ * gap's left side, one from its right side to the right edge. The rocks reach the gap's edges exactly,
+ * as the belts' hitboxes do, with smaller ones filling the corners; sizes vary along each belt.
+ */
+export declare function spawnBelts(world: World, l: Layout, top: number, gapLeft: number, seed: number): Belt;
+export declare function placeBelts(world: World, l: Layout, b: Belt, top: number): void;
+/** A hit: fire and debris where the ship struck. */
+export declare function explode(world: World, l: Layout, x: number, y: number): void;
+/** A ringed ice planet: banded in pale blues and teals, its rings tilted round it. */
+export type Space = {
+    all: Entity[];
+    /** The sun (day) or the moon (night), with its glow. */ sky: Entity[];
+    stars: {
+        e: Entity;
+        x: number;
+        y: number;
+        z: number;
+        since: number;
+    }[];
+};
+export declare const STAR_DRIFT = 5;
+/** A new theme: the sun comes out by day, the moon by night. */
+export declare function setSpaceTheme(world: World, l: Layout, space: Space, day: boolean): void;
+export declare function spawnSpace(world: World, l: Layout, clock: number, day: boolean): Space;
+/** Stars that have drifted below the view come back in above it. */
+export declare function wrapStars(world: World, s: Space, clock: number): void;
+export declare function removeAll(world: World, entities: Entity[]): void;

package/lib/typescript/src/games/spider-solitaire/SpiderSolitaire.d.ts

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

package/lib/typescript/src/games/spider-solitaire/SpiderSolitaireConstants.d.ts

@@ -1,37 +1,54 @@
-export declare const SMALL_CARD_WIDTH: number;
-export declare const SMALL_CARD_HEIGHT: number;
-export declare const CARD_WIDTH: number;
-export declare const CARD_HEIGHT: number;
-export declare const CARD_OVERLAP: number;
-export declare const CARD_FACE_DOWN_OVERLAP: number;
-export declare const SPIDER_SOLITAIRE_COLORS: {
-    BACKGROUND: string;
-    PRIMARY: string;
-    CARD_BACK: string;
-    CARD_FRONT: string;
-    CARD_RED: string;
-    CARD_BLACK: string;
-    EMPTY_PILE: string;
-    SELECTED_BORDER: string;
-    CARD_SHADOW: string;
+import { type TiltView } from '../shared/EngineTilt';
+import type { Suit } from './SpiderSolitaireRules';
+/** A win scores by its time against ten minutes, as the original game did. */
+export declare const EXPECTED_TIME = 600;
+export declare const BASE_SCORE = 100;
+export declare const TAP_SLOP = 10;
+export declare const MOVE_TIME = 0.24;
+export declare const DEAL_STAGGER = 0.05;
+export declare const RUN_STAGGER = 0.045;
+export declare const WIN_DELAY = 1.1;
+export declare const COLORS: {
+    readonly FACE: "#FFFFFF";
+    readonly BACK: "#1565C0";
+    readonly BACK_LIGHT: "#3B82D6";
+    readonly BACK_FRAME: "#E3F2FD";
+    readonly RED: "#DC2626";
+    readonly BLACK: "#1F2937";
+    readonly SELECTED: "#FFE082";
+    readonly CLASSIC_SLOT: "rgba(255, 255, 255, 0.35)";
 };
-export declare const SPIDER_SOLITAIRE_GAME_CONFIG: {
-    SCREEN_WIDTH: number;
-    SCREEN_HEIGHT: number;
-    CARD_WIDTH: number;
-    CARD_HEIGHT: number;
-    CARD_OVERLAP: number;
-    CARD_FACE_DOWN_OVERLAP: number;
-    PILE_SPACING: number;
-    FOUNDATION_TOP: number;
-    TABLEAU_TOP: number;
-};
-export declare const SPIDER_SOLITAIRE_CONSTANTS: {
-    maxTime: number;
-};
-export declare const SUITS: readonly ["hearts", "diamonds", "clubs", "spades"];
-export declare const VALUES: readonly ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"];
-export type Suit = (typeof SUITS)[number];
-export type Value = (typeof VALUES)[number];
-export declare const SUIT_SYMBOLS: Record<Suit, string>;
 export declare const SUIT_COLORS: Record<Suit, string>;
+/** The camera leans back a little from straight down, so the cards' thickness and the stacks read as 3D. */
+export declare const TILT = 0.2;
+/** Lit from the upper left; surfaces facing up off the table (+z) keep their exact color. */
+export declare const LIGHT: import("@nayan-ui/engine").Light;
+/** A card is 1.4 times as tall as it is wide, and this thin (of its width). */
+export declare const CARD_RATIO = 1.4;
+export declare const THICKNESS = 0.024;
+/** How far down a pile each card shows below the one under it (of a card's height), as the original piles. */
+export declare const FACE_DOWN_STEP = 0.15;
+export declare const FACE_UP_STEP = 0.25;
+/** The deck and the finished runs along the bottom are drawn at this size. */
+export declare const SMALL = 0.74;
+export type Layout = TiltView & {
+    /** A tableau card's width and height. */
+    card: number;
+    cardH: number;
+    /** Each pile's centre (world x). */
+    columns: number[];
+    pitch: number;
+    /** The top edge of a pile's first card, and the lowest a pile may reach (world y). */
+    pileTop: number;
+    pileBottom: number;
+    /** The bottom row: its centre (world y), the deck's right edge and the first finished run's centre (world x). */
+    rowY: number;
+    stockRight: number;
+    foundationX: number;
+    /** Heights between stacked cards (world z). */
+    dz: number;
+};
+/** All ten piles side by side across the game area (the original piles scrolled sideways), the deck and runs below. */
+export declare function getLayout(width: number, height: number, offset: number, tablet: boolean): Layout;
+/** Where a table point at height z shows in the view. */
+export declare const onScreen: (l: Layout, x: number, y: number, z: number) => [number, number];

package/lib/typescript/src/games/spider-solitaire/SpiderSolitaireGame.d.ts

@@ -0,0 +1,67 @@
+import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './SpiderSolitaireConstants';
+import { type Board } from './SpiderSolitaireRules';
+import { type Held, type Scene } from './SpiderSolitaireScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** select / deselect: a run picked up or put back; invalid: a move or deal not allowed; place: a run moved; deal: a row dealt; complete: a run lifted off; win: the eighth. */
+export type GameEvent = 'select' | 'deselect' | 'invalid' | 'place' | 'deal' | 'complete' | 'win';
+/** What a finger is on: a pile's card, a pile (its empty place or below its cards), or the deck. */
+type Hit = {
+    kind: 'card';
+    pile: number;
+    index: number;
+} | {
+    kind: 'pile';
+    pile: number;
+} | {
+    kind: 'stock';
+} | null;
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    board: Board;
+    /** The run picked up (tapped), or being dragged. */
+    held: Held;
+    /** A finger down: where, on what, and (once it's moved off) where it grabbed the dragged run. */
+    press: {
+        x: number;
+        y: number;
+        hit: Hit;
+        grab: [number, number] | null;
+        dragging: boolean;
+    } | null;
+    /** Seconds since the start (the original game's elapsed clock), and the score a win reports: both in the engine (Rust). */
+    readonly time: number;
+    readonly score: number;
+    won: boolean;
+    onPhase: (_p: Phase) => void;
+    onDeals: (_n: number) => void;
+    onCompleted: (_n: number) => void;
+    onEvent: (_e: GameEvent) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the table out for the view (first layout, header height, rotation); the first deal glides out of the deck. */
+export declare function setLayout(g: Game, l: Layout): void;
+export declare function setTheme(g: Game, theme: GameTheme): void;
+/** Starts play on the deal already on the table. */
+export declare function start(g: Game): void;
+/** A fresh shuffle dealt out, 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;
+/** What's under a view point: the top-most card there, a pile's column, or the deck. */
+export declare function hitAt(g: Game, sx: number, sy: number): Hit;
+/** A quick tap does what it did in the original game; a finger that moves off a face-up run drags it. */
+export declare function drag(g: Game, e: DragEvent): void;
+/** A card tapped: put back the run if it's the one picked up, move the picked-up run here, or pick up from here. */
+export declare function select(g: Game, pile: number, index: number): void;
+/** Puts the picked-up run on a pile, if it may go there. */
+export declare function moveTo(g: Game, to: number): void;
+/** One card onto every pile from the deck (not while a pile is empty). */
+export declare function deal(g: Game): void;
+export {};

package/lib/typescript/src/games/spider-solitaire/SpiderSolitaireRules.d.ts

@@ -0,0 +1,39 @@
+export declare const SUITS: readonly ["hearts", "diamonds", "clubs", "spades"];
+export declare const VALUES: readonly ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"];
+export type Suit = (typeof SUITS)[number];
+export type Value = (typeof VALUES)[number];
+export type Card = {
+    id: string;
+    suit: Suit;
+    value: Value;
+    faceUp: boolean;
+};
+/** The 10 piles, the stock (dealt from its end) and the runs lifted out so far (each K first). */
+export type Board = {
+    tableau: Card[][];
+    stock: Card[];
+    completed: Card[][];
+};
+export declare const PILES = 10;
+export declare const RUNS_TO_WIN = 8;
+/** As the original game: always two suits. */
+export declare const SUIT_COUNT = 2;
+export declare const rank: (v: Value) => number;
+/** A fresh deal: six cards in each of the first four piles, five in the rest, only the top ones face up; 50 left to deal. */
+export declare function newBoard(): Board;
+/** Descending by one all the way down (any suit), so it can be picked up together. */
+export declare function isValidSequence(cards: Card[]): boolean;
+/** Whether a run can go on a pile: anything on an empty one, else one rank below its face-up top card. */
+export declare function canMove(b: Board, cards: Card[], to: number): boolean;
+/** The run from `index` down, if it may be picked up (a single face-up card always may). */
+export declare function pickable(b: Board, pile: number, index: number): Card[] | null;
+/** Moves the run from `from` at `index` onto `to` (already checked), turning up the card it uncovers. */
+export declare function moveRun(b: Board, from: number, index: number, to: number): void;
+/** Why a row can't be dealt (an empty pile, or nothing left), or null if it can. */
+export declare const dealBlocked: (b: Board) => "empty-pile" | "no-stock" | null;
+/** One card face up onto every pile, from the stock's end. */
+export declare function dealRow(b: Board): void;
+/** Lifts a finished King-to-Ace run of one suit off the end of a pile, if there is one; returns it. */
+export declare function takeCompletedRun(b: Board, pile: number): Card[] | null;
+/** Deals left (each a row of 10). */
+export declare const dealsLeft: (b: Board) => number;