@nayan-ui/games 1.19.0 → 1.20.0

package/lib/typescript/src/games/sliding-numbers/SlidingNumbersRules.d.ts

@@ -0,0 +1,22 @@
+export declare const GRID = 3;
+/** Tile ids 0..8 (8 is the gap, value 0); each tile's cell, row-major. */
+export type Tile = {
+    id: number;
+    value: number;
+    row: number;
+    col: number;
+};
+export type Board = {
+    tiles: Tile[];
+    emptyRow: number;
+    emptyCol: number;
+};
+/** A fresh board shuffled by 200 random slides of the gap, as the original store did (the same random draws). */
+export declare function shuffled(): Board;
+export declare const tileAt: (b: Board, row: number, col: number) => Tile | null;
+/** Whether a tile is beside the gap (and so can slide into it). */
+export declare function canSlide(b: Board, t: Tile): boolean;
+/** Slides a tile into the gap (already checked). */
+export declare function slide(b: Board, t: Tile): void;
+/** Every tile home: 1..8 in reading order, the gap bottom right. */
+export declare const solved: (b: Board) => boolean;

package/lib/typescript/src/games/sliding-numbers/SlidingNumbersScene.d.ts

@@ -0,0 +1,30 @@
+import { type Entity, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './SlidingNumbersConstants';
+import type { Tile } from './SlidingNumbersRules';
+/** A tile: its root (moved), and its block (pressed, tinted). */
+type TileView = {
+    root: Entity;
+    block: Entity;
+};
+export type Scene = {
+    backdrop: Entity;
+    board: Entity[];
+    tiles: Map<number, TileView>;
+};
+export declare function buildScene(world: World, l: Layout, theme: GameTheme, tiles: Tile[]): Scene;
+export declare function removeScene(world: World, s: Scene): void;
+export declare function setSceneTheme(world: World, l: Layout, s: Scene, theme: GameTheme): void;
+/** A tile glides to its cell (or is put there at once). */
+export declare function placeTile(world: World, l: Layout, s: Scene, t: Tile, animate?: boolean): void;
+/** A finger down on a tile sinks it a little; lifting brings it back. */
+export declare function press(world: World, s: Scene, id: number, down: boolean): void;
+/** A tile that can't move (not beside the gap): a quick shake. */
+export declare function shake(world: World, l: Layout, s: Scene, id: number): void;
+/** Solved: the tiles hop in a wave across the board, and confetti bursts over it. */
+export declare function celebrate(world: World, l: Layout, s: Scene, tiles: Tile[]): void;
+/** Out of time: the tiles dim. */
+export declare function dim(world: World, s: Scene, tiles: Tile[]): void;
+/** Back to their own colors (a new game). */
+export declare function undim(world: World, s: Scene, tiles: Tile[]): void;
+export {};

package/lib/typescript/src/games/snake-3d/Snake3D.d.ts

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

package/lib/typescript/src/games/snake-3d/Snake3DConstants.d.ts

@@ -1,70 +1,33 @@
-export declare const BOARD_RADIUS: number;
-export declare const BOARD_INSET: number;
-export declare const BOARD_TOTAL_SIZE: number;
-export declare const SNAKE_3D_GAME_CONFIG: {
-    readonly GRID_SIZE: 20;
-    readonly CELL_SIZE: number;
-    readonly GAME_SPEED: {
-        readonly easy: 400;
-        readonly medium: 300;
-        readonly hard: 200;
-    };
-    readonly POINTS_PER_FOOD: 500;
-    readonly POINTS_PER_SPECIAL_FOOD: 1000;
-    readonly DIFFICULTY_MULTIPLIER: {
-        readonly easy: 1;
-        readonly medium: 2;
-        readonly hard: 3;
-    };
-    readonly SPECIAL_FOOD_CHANCE: 0.15;
-    readonly SPECIAL_FOOD_DURATION: 10000;
-    readonly INITIAL_SNAKE_LENGTH: 3;
+import type { TiltView } from '../shared/EngineTilt';
+export declare const TIME_LIMIT = 300;
+/** One move every 300 ms, the original game's fixed speed. */
+export declare const TICK_MS = 300;
+/** A long frame counts for at most this much, so the snake never jumps two cells or fast-forwards. */
+export declare const MAX_FRAME_MS = 100;
+export declare const SWIPE = 15;
+export declare const COLORS: {
+    readonly HEAD: "#00c853";
+    readonly BODY: "#00a344";
+    readonly TAIL: "#008035";
+    readonly BELLY: "#7CF2A8";
+    readonly EYE: "#FFFFFF";
+    readonly PUPIL: "#111111";
+    readonly TONGUE: "#E53935";
+    readonly SPECIAL: "#ffa502";
+    readonly CRASH: "#ff4757";
+    readonly CLASSIC_BOARD: "rgba(255, 255, 255, 0.30)";
+    readonly CLASSIC_DARK: "rgba(255, 255, 255, 0.10)";
+    readonly CLASSIC_RIM: "rgba(255, 255, 255, 0.55)";
 };
-export declare const SNAKE_3D_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly GRID_BACKGROUND: "rgba(255, 255, 255, 0.30)";
-    readonly GRID_LINE: "rgba(255, 255, 255, 0.32)";
-    readonly GRID_BORDER: "rgba(255, 255, 255, 0.40)";
-    readonly SNAKE_HEAD: "#00c853";
-    readonly SNAKE_BODY: "#00a344";
-    readonly SNAKE_TAIL: "#008035";
-    readonly SNAKE_OUTLINE: "#004d26";
-    readonly FOOD_NORMAL: "#ff4757";
-    readonly FOOD_SPECIAL: "#ffa502";
-    readonly FOOD_GLOW: "rgba(255, 71, 87, 0.5)";
-    readonly COLLISION_COLOR: "#ff4757";
+/** The camera looks straight down at the board. */
+export declare const TILT = 0;
+/** 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 type Layout = TiltView & {
+    cell: number;
+    size: number;
 };
-export interface Segment3DColors {
-    top: string;
-    topHighlight: string;
-    front: string;
-    side: string;
-}
-export declare const getSegment3DColors: (key: string) => Segment3DColors;
-export interface Food3DColors {
-    top: string;
-    topHighlight: string;
-    front: string;
-    glow: string;
-}
-export declare const getFood3DColors: (isSpecial: boolean) => Food3DColors;
-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;
-    };
-};
-export type Direction = keyof typeof DIRECTIONS;
+/** The board as wide as the screen allows (as the original board, which filled the width), smaller if the screen is short. */
+export declare function getLayout(width: number, height: number, offset: number): Layout;
+/** A grid point (cells, 0.5 = the middle of the first) on the board, in world units. */
+export declare const gridPoint: (l: Layout, x: number, y: number) => [number, number];

package/lib/typescript/src/games/snake-3d/Snake3DGame.d.ts

@@ -0,0 +1,42 @@
+import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './Snake3DConstants';
+import { type Scene } from './Snake3DScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** eat / special: food eaten; crash: a wall or the body. */
+export type GameEvent = 'eat' | 'special' | 'crash';
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    st: import("./Snake3DRules").SnakeState;
+    /** The cells as of the move before last, for the glide. */
+    prev: number[];
+    pending: number;
+    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    readonly timeLeft: number;
+    /** Seconds on the game's clock (the bonus food's expiry runs on it, so a pause can't expire it). */
+    clock: number;
+    moves: number;
+    /** Where the current drag stretch began (each 15 points one way is a swipe). */
+    anchor: [number, number] | null;
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onTime: (_t: number) => void;
+    onEvent: (_e: GameEvent) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the board out for the view (first layout, header height, rotation): rebuilt where things stand. */
+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;
+/** Stop and Play Again: the idle board. 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;
+/** Swipes anywhere turn the snake: each stretch of 15 points one way is a turn, so one drag can chain them. */
+export declare function drag(g: Game, { phase, x, y, cancelled }: DragEvent): void;

package/lib/typescript/src/games/snake-3d/Snake3DMotion.d.ts

@@ -0,0 +1,3 @@
+import type { Snake } from './Snake3DRules';
+/** A bead's position and travel tangent, in grid units. The body follows the head's curved path. */
+export declare function sampleSnakeMotion(prev: Snake, cur: Snake, index: number, fraction: number): [number, number, number, number];

package/lib/typescript/src/games/snake-3d/Snake3DRules.d.ts

@@ -0,0 +1,42 @@
+export declare const GRID = 20;
+export declare const INITIAL_LENGTH = 3;
+/** Points per food: the original base points x its "medium" multiplier of 2. */
+export declare const POINTS_PER_FOOD = 1000;
+export declare const POINTS_PER_SPECIAL_FOOD = 2000;
+export declare const SPECIAL_FOOD_CHANCE = 0.15;
+export declare const SPECIAL_FOOD_DURATION = 10;
+export type Direction = 'UP' | 'DOWN' | 'LEFT' | 'RIGHT';
+export declare const VECTORS: Record<Direction, [number, number]>;
+/** expiresAt: game-clock seconds (bonus food only). */
+export type Food = {
+    id: number;
+    x: number;
+    y: number;
+    isSpecial: boolean;
+    expiresAt?: number;
+};
+/** The snake's cells, head first, flattened [x0, y0, x1, y1, …]. */
+export type Snake = number[];
+/** In the middle of the grid, heading right. */
+export declare function initialSnake(): Snake;
+/** A random cell off the snake (giving up after 100 tries, as before). */
+export declare function generateFood(s: Snake, isSpecial: boolean, id: number, now: number): Food;
+export type SnakeState = {
+    snake: Snake;
+    direction: Direction;
+    nextDirection: Direction;
+    turns: Direction[];
+    food: Food | null;
+    nextFoodId: number;
+};
+export declare const freshState: () => SnakeState;
+/** Buffer up to two turns in swipe order; refuse duplicates and reversals against the queued heading. */
+export declare function turn(st: SnakeState, d: Direction): void;
+export type StepResult = {
+    crash: boolean;
+    ate: Food | null;
+    newFood: Food | null;
+    grew: boolean;
+};
+/** One move: the head steps on, the tail follows; walls and the body kill; food grows it by one. */
+export declare function step(st: SnakeState, now: number): StepResult;

package/lib/typescript/src/games/snake-3d/Snake3DScene.d.ts

@@ -0,0 +1,35 @@
+import { type Camera, type Entity, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './Snake3DConstants';
+import { type Direction, type Food } from './Snake3DRules';
+export type Scene = {
+    backdrop: Entity;
+    board: Entity[];
+    /** The head (eyes and tongue attached), the beads behind it, and the joints between them. */
+    head: Entity;
+    tongue: Entity;
+    beads: Entity[];
+    joints: Entity[];
+    food: Entity | null;
+    foodId: number;
+};
+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, l: Layout, s: Scene, theme: GameTheme): void;
+/**
+ * Every bead follows the head's rounded turns between cells, `t` of the way (0..1).
+ * `prev` and `cur` are the cells (flattened x, y), head first.
+ */
+export declare function drawSnake(world: World, l: Layout, s: Scene, prev: number[], cur: number[], t: number): void;
+/** The head turns to face the way it's heading. */
+export declare function faceHead(world: World, s: Scene, d: Direction): void;
+/** The tongue flicks out now and then while it's moving. */
+export declare function flick(world: World, s: Scene): void;
+/** A fresh snake's look (a new game or the preview). */
+export declare function resetSnake(world: World, l: Layout, s: Scene): void;
+/** Food eaten: the head gulps and the food bursts. */
+export declare function gulp(world: World, l: Layout, s: Scene, food: Food): void;
+/** A crash: the snake flushes red, a jolt runs through the board. */
+export declare function crash(world: World, l: Layout, s: Scene, camera: Camera): void;
+/** The food on the board (an apple, or a spinning gold star for a bonus), or none. */
+export declare function placeFood(world: World, l: Layout, s: Scene, food: Food | null): void;

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

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

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 {};