@nayan-ui/games 1.18.0 → 1.20.0

package/lib/typescript/src/games/connect-em-all/ConnectEmAllScene.d.ts

@@ -0,0 +1,49 @@
+import { type Color, type Entity, type Vec3, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import type { PopBurstOptions } from '../shared/EngineBlasts';
+import { type Layout } from './ConnectEmAllConstants';
+/** A view point (from the top-left) at depth `z`, in world space. */
+export declare const toWorld: (l: Layout, x: number, y: number, z?: number) => Vec3;
+/** Centre of the dot at (row, col), in view points. `row` may be negative: above the board, falling in. */
+export declare const dotPoint: (l: Layout, row: number, col: number) => [number, number];
+export declare const dotPosition: (l: Layout, row: number, col: number) => Vec3;
+export type Board = {
+    backdrop: Entity;
+    panel: Entity;
+    rim: Entity;
+};
+/** The game background, and behind the whole grid the board panel and its rim, as Block Blast's: in the theme's board colors. */
+export declare function buildBoard(world: World, l: Layout, theme: GameTheme): Board;
+export declare function removeBoard(world: World, b: Board): void;
+export declare const dotColor: (colorIndex: number) => Color;
+export declare const lineColor: (colorIndex: number) => Color;
+export declare function loadGlowTexture(): void;
+/** A dot and its glow: a soft halo behind it, shown while it's in the chain. */
+export declare function spawnDot(world: World, l: Layout, row: number, col: number, colorIndex: number): {
+    entity: Entity;
+    glow: Entity;
+};
+/** The halo blooms in (overshooting a touch) and stays steady while the dot is in the chain, or fades away. */
+export declare function showGlow(world: World, glow: Entity, on: boolean): void;
+/** Where a cleared dot's burst flies from (in front of it) and glows (behind it, over the chain lines). */
+export declare function dotBurst(l: Layout, row: number, col: number, colorIndex: number): PopBurstOptions;
+/** A dot's scale at rest (for popping it away). */
+export declare const dotScale: (l: Layout) => number;
+/** A chain segment: its drop shadow and the line itself. */
+export type Segment = {
+    shadow: Entity;
+    line: Entity;
+};
+export declare function spawnSegment(world: World): Segment;
+export declare const lineWidth: (l: Layout) => number;
+export declare function showSegment(world: World, l: Layout, s: Segment, a: [number, number], b: [number, number], color: Color): void;
+export declare function hideSegment(world: World, s: Segment): void;
+/** The line from the chain's last dot to the finger, with a round end at the finger. */
+export type Trail = {
+    line: Entity;
+    cap: Entity;
+};
+export declare function spawnTrail(world: World): Trail;
+export declare function showTrail(world: World, l: Layout, t: Trail, from: [number, number], to: [number, number], color: Color): void;
+export declare function hideTrail(world: World, t: Trail): void;
+export declare const DOT_COUNT: number;

package/lib/typescript/src/games/crossy-road/CrossyRoad.d.ts

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

package/lib/typescript/src/games/crossy-road/CrossyRoadCamera.d.ts

@@ -0,0 +1,14 @@
+import type { Camera } from '@nayan-ui/engine';
+import { type Layout } from './CrossyRoadConstants';
+type V3 = [number, number, number];
+/** The view point of a world point, for a camera at `eye` looking along +y tilted down by the pitch. */
+export declare function viewPoint(l: Layout, eye: V3, p: V3): [number, number];
+/**
+ * Places the camera to frame the board (world units, a tenth of view points). With the pitch fixed, a
+ * board point a distance `a` ahead of the eye shows at view height n (-1 bottom .. 1 top) when
+ * a = h * g(n), h the eye's height; so the near and far edges' wanted heights give h and the eye's place
+ * exactly. The far constraint includes the pedestrian's head, so the scoreboard cannot hide them at
+ * the goal. If the nine columns wouldn't fit across the nearest lane, the band is narrowed until they do.
+ */
+export declare function frameCamera(camera: Camera, l: Layout): void;
+export {};

package/lib/typescript/src/games/crossy-road/CrossyRoadConstants.d.ts

@@ -1,52 +1,84 @@
-export declare const CROSSY_CONFIG: {
-    readonly COLS: 9;
-    readonly TILE: number;
-    readonly LANE_H: number;
-    readonly GRID_W: number;
-    readonly GRID_LEFT: number;
-    readonly ANCHOR_Y: number;
-    readonly BOARD_BOTTOM_Y: number;
-    readonly TOTAL_LANES: number;
-    readonly TOTAL_ROADS: 9;
-    readonly LANE_TYPES: ("grass" | "road")[];
-    readonly GAME_DURATION_MS: 120000;
-    readonly ROWS_ABOVE: number;
-    readonly ROWS_BELOW: number;
-    readonly HOP_MS: 130;
-    readonly CREEP_DELAY_MS: 3000;
-    readonly CREEP_ROWS_PER_SEC: 0.55;
-    readonly BEHIND_DEATH_ROWS: number;
-    readonly CAR_SPEED_MIN: 2.2 | 1.7;
-    readonly CAR_SPEED_MAX: 4.6 | 3.6;
-    readonly LOG_SPEED_MIN: 1.6 | 1.2;
-    readonly LOG_SPEED_MAX: 3 | 2.4;
-    readonly TRAIN_SPEED: 12 | 9.5;
-    readonly SCREEN_WIDTH: number;
-    readonly SCREEN_HEIGHT: number;
-};
-export type LaneType = 'grass' | 'road' | 'water' | 'rail';
-export declare const CROSSY_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly GRASS_LIGHT: "#7EC850";
-    readonly GRASS_DARK: "#6FBF44";
-    readonly ROAD: "#4A4A55";
-    readonly ROAD_LINE: "rgba(255,255,255,0.35)";
+import type { Light } from '@nayan-ui/engine';
+export declare const COLS = 9;
+export declare const TOTAL_ROADS = 9;
+export type LaneType = 'grass' | 'road';
+/** A grass start lane, nine roads with a grass rest lane after every three, a grass goal lane (bottom to top). */
+export declare const LANE_TYPES: LaneType[];
+export declare const TOTAL_LANES: number;
+export declare const GOAL_ROW: number;
+export declare const GAME_DURATION = 120;
+export declare const SCORE_PER_CROSS = 2000;
+export declare const LOW_TIME = 10;
+export declare const CAR_SPEED_MIN: number;
+export declare const CAR_SPEED_MAX: number;
+export declare const STEP_MS: number;
+export declare const MAX_PENDING_MS = 50;
+/** Traffic speeds up a little with every road crossed. */
+export declare const speedScale: (crossings: number) => number;
+export declare const MOVE_TIME = 0.2;
+export declare const SWIPE = 18;
+export declare const TAP_MAX = 0.25;
+export declare const COLORS: {
+    readonly GRASS_LIGHT: "#95CF69";
+    readonly GRASS_DARK: "#83BF5C";
+    readonly GRASS_TUFT: "#4E9A2E";
+    readonly ROAD: "#4B5667";
     readonly ROAD_EDGE: "#3C3C46";
-    readonly WATER: "#3AA0E3";
-    readonly WATER_DARK: "#2E86C4";
-    readonly RAIL: "#5A5560";
-    readonly RAIL_TIE: "#43404A";
-    readonly RAIL_TRACK: "#8A8594";
-    readonly LOG: "#8B5A2B";
-    readonly LOG_DARK: "#6E4520";
-    readonly CAR_COLORS: readonly ["#FF5C5C", "#FFD93D", "#6BCB77", "#A66CFF", "#FF9F45", "#4D96FF"];
-    readonly TRAIN: "#B23A48";
-    readonly TRAIN_DARK: "#7A2732";
-    readonly PLAYER: "#E43B3B";
-    readonly PLAYER_DARK: "#B62828";
-    readonly PLAYER_BEAK: "#FF8A3D";
-    readonly PLAYER_COMB: "#8E1B1B";
-    readonly EYE: "#2C2C44";
-    readonly WARNING: "#FF3B30";
+    readonly ROAD_LINE: "#C9C9CF";
+    readonly CAR_COLORS: readonly ["#FF5C5C", "#FFD93D", "#6BCB77", "#A66CFF", "#FF9F45", "#4D96FF", "#37C7C2", "#F2EEE2", "#EF7CAB"];
+    readonly WHEEL: "#15151A";
+    readonly WINDOW: "#2A3442";
+    readonly PLAYER: "#3B82C4";
+    readonly TRUNK: "#7A4E2D";
+    readonly LEAVES: "#3FA34D";
+    readonly FLOWERS: readonly ["#FFFFFF", "#FFD1EC", "#C7B3FF", "#FFF2B0"];
+    readonly CURB: "#C9C6BE";
+    readonly LINE: "#F2F2EE";
+    readonly BUSH: "#3E8E3A";
+    readonly ROCK: "#8E8C88";
+};
+export declare const PERSON: {
+    readonly SCALE: 0.82;
+    readonly HEIGHT: 1.817;
+    readonly STRIDE: 0.5;
+};
+export declare const PERSON_COLORS: {
+    readonly SKIN: "#DCA67D";
+    readonly JACKET: "#3B82C4";
+    readonly PANTS: "#3B4558";
+    readonly HAIR: "#352B27";
+    readonly SHOE: "#39434C";
+    readonly SOLE: "#F0ECE1";
+    readonly BACKPACK: "#CE8248";
+    readonly STRAP: "#72513A";
+};
+/**
+ * The rules are in view points (a lane is about 40 of them), but the engine draws only what's within
+ * 500 units of the camera and shadows a few dozen units round it, so the whole scene hangs off a root
+ * scaled to a tenth: one world unit is ten points.
+ */
+export declare const WORLD_SCALE = 0.1;
+/** A perspective camera behind and above the start lane, looking up the board at this angle below level. */
+export declare const CAMERA_PITCH = 0.92;
+export declare const CAMERA_FOV = 0.7;
+export declare const SKY_DAY: readonly [0.62, 0.78, 0.95];
+export declare const SKY_NIGHT: readonly [0.227, 0.192, 0.376];
+/** The sun high to the front left (z is up off the board), shadows falling up and right; the night's dim bluish moonlight. */
+export declare const DAY_LIGHT: Light;
+export declare const NIGHT_LIGHT: Light;
+export type Layout = {
+    width: number;
+    height: number;
+    /** A column's width, a lane's depth, the player grid's width and its left edge (view x). */
+    tile: number;
+    laneH: number;
+    gridW: number;
+    gridLeft: number;
+    /** The view's band between the scoreboard and the controls, where the board is framed (view y). */
+    top: number;
+    bottom: number;
 };
+/** Wider lanes fill more of the view while the camera keeps all nine columns reachable. */
+export declare function getLayout(width: number, height: number, offset: number): Layout;
+/** A column's centre (view x). */
+export declare const colX: (l: Layout, col: number) => number;

package/lib/typescript/src/games/crossy-road/CrossyRoadGame.d.ts

@@ -0,0 +1,64 @@
+import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
+import { type Layout } from './CrossyRoadConstants';
+import { type Hop, type Player, type Vehicle } from './CrossyRoadRules';
+import { type Scene } from './CrossyRoadScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** hop: a hop taken; cross: a road crossed (and the goal reached); crash: hit; timeUp: the clock ran out. */
+export type GameEvent = 'hop' | 'cross' | 'crash' | 'timeUp';
+type Dir = 'up' | 'down' | 'left' | 'right';
+type MovingHop = {
+    from: Player;
+    to: Player;
+    result: Hop;
+    elapsed: number;
+    direction: Dir;
+};
+export declare function createGame(night: boolean): {
+    world: World;
+    camera: Camera;
+    assets: import("./CrossyRoadMeshes").CrossyMeshes;
+    night: boolean;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    traffic: Vehicle[];
+    nextId: number;
+    player: Player;
+    hopping: MovingHop | null;
+    queuedHop: Dir | null;
+    alive: boolean;
+    won: boolean;
+    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    /** The whole seconds shown. */
+    timeLeft: number;
+    pending: number;
+    clock: number;
+    /** A finger down: where and when, and whether it's already swiped. */
+    press: {
+        x: number;
+        y: number;
+        at: number;
+        swiped: boolean;
+    } | null;
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number, _crossings: 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): a fresh board is dealt for the new size. */
+export declare function setLayout(g: Game, l: Layout): void;
+/** Day or night (the dark theme): the scene is rebuilt where things stand. */
+export declare function setNight(g: Game, night: boolean): void;
+/** Start: a fresh board, and the clock running (as the original Start dealt one). */
+export declare function start(g: Game): void;
+/** Stop and Play Again: a fresh board, waiting. 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;
+/** Finish the active hop before taking one buffered move; taps cannot teleport through traffic. */
+export declare function hopTo(g: Game, dir: Dir): void;
+/** A tap hops forward; a swipe hops its way (as soon as it's gone far enough, once per touch). */
+export declare function drag(g: Game, { phase, x, y, cancelled }: DragEvent): void;
+export {};

package/lib/typescript/src/games/crossy-road/CrossyRoadMeshes.d.ts

@@ -0,0 +1,16 @@
+import { type Model } from '@nayan-ui/engine';
+export type VehicleStyle = 'compact' | 'taxi' | 'pickup' | 'bus';
+export interface VehicleMeshes {
+    body: Model;
+    details: Model;
+    lights: Model;
+}
+export interface CrossyMeshes {
+    vehicles: Record<VehicleStyle, VehicleMeshes>;
+    tree: Model;
+    bush: Model;
+    rock: Model;
+}
+export declare function crossyMeshes(): CrossyMeshes;
+/** Reusable assets; the game loader advances one builder per frame. */
+export declare function warmAssets(): Iterable<() => unknown>;

package/lib/typescript/src/games/crossy-road/CrossyRoadPerson.d.ts

@@ -0,0 +1,10 @@
+import { type Model } from '@nayan-ui/engine';
+export interface PedestrianMeshes {
+    torso: Model;
+    arm: Model;
+    leg: Model;
+    shoe: Model;
+}
+export declare function pedestrianMeshes(): PedestrianMeshes;
+/** Reusable assets; the game loader advances one builder per frame. */
+export declare function warmAssets(): Iterable<() => unknown>;

package/lib/typescript/src/games/crossy-road/CrossyRoadRules.d.ts

@@ -0,0 +1,36 @@
+import { type Layout } from './CrossyRoadConstants';
+import type { VehicleStyle } from './CrossyRoadMeshes';
+export type Vehicle = {
+    id: number;
+    row: number;
+    x: number;
+    width: number;
+    speed: number;
+    colorIndex: number;
+    style: VehicleStyle;
+};
+/** Every road's traffic: one bus (sometimes two) or two cars (sometimes three), evenly spaced, all one way. */
+export declare function buildTraffic(l: Layout, firstId?: number): Vehicle[];
+/** One 60 Hz frame of traffic, wrapping off one side onto the other. */
+export declare function moveTraffic(l: Layout, vs: Vehicle[], scale: number): void;
+/** Whether traffic overlaps the pedestrian, including fractional rows while a step is in progress. */
+export declare function hit(l: Layout, vs: Vehicle[], row: number, x: number): boolean;
+/** The player: its lane and column, the furthest lane it's reached, and the roads crossed. */
+export type Player = {
+    row: number;
+    col: number;
+    maxRow: number;
+    crossings: number;
+};
+export declare const startPlayer: () => Player;
+/** A hop's outcome: whether it moved, whether it crossed a road, whether it reached the goal. */
+export type Hop = {
+    moved: boolean;
+    crossed: boolean;
+    goal: boolean;
+};
+export declare function hopForward(p: Player): Hop;
+export declare function hopBack(p: Player): Hop;
+export declare function hopSide(p: Player, dir: -1 | 1): Hop;
+export declare const playerX: (l: Layout, p: Player) => number;
+export declare const scaleFor: (p: Player) => number;

package/lib/typescript/src/games/crossy-road/CrossyRoadScene.d.ts

@@ -0,0 +1,38 @@
+import { type Entity, type World } from '@nayan-ui/engine';
+import { type Layout } from './CrossyRoadConstants';
+import type { CrossyMeshes } from './CrossyRoadMeshes';
+import type { Vehicle } from './CrossyRoadRules';
+/** A lane's centre (world y) and its surface height. */
+export declare const laneY: (l: Layout, row: number) => number;
+export declare const laneTop: (row: number) => number;
+/** A view x on the board as world x. */
+export declare const worldX: (l: Layout, x: number) => number;
+export type Scene = {
+    /** Everything hangs off this root, scaled to the world. */
+    root: Entity;
+    ground: Entity[];
+    vehicles: Map<number, Entity>;
+    player: {
+        root: Entity;
+        body: Entity;
+        arms: [Entity, Entity];
+        legs: [Entity, Entity];
+        feet: [Entity, Entity];
+    };
+    night: boolean;
+};
+/** Keeps every vehicle where the rules have it. */
+export declare function placeVehicles(world: World, l: Layout, s: Scene, vs: Vehicle[]): void;
+/** The pedestrian on a lane and column, at once (a new board). */
+export declare function placePlayer(world: World, l: Layout, s: Scene, row: number, col: number): void;
+/** Grounded translation with alternating strides. Ankles counter-rotate so shoes stay level. */
+export declare function hop(world: World, l: Layout, s: Scene, from: [number, number], to: [number, number], facing: 'up' | 'down' | 'left' | 'right'): void;
+/** Run over: a non-graphic stumble and a small puff of road dust. */
+export declare function stumble(world: World, l: Layout, s: Scene, row: number, col: number): void;
+/** Made it across: a wave and confetti, standing on the finish lane. */
+export declare function celebrate(world: World, l: Layout, s: Scene, row: number, col: number): void;
+export declare function buildScene(world: World, l: Layout, a: CrossyMeshes, night: boolean, vs: Vehicle[]): Scene;
+/** Replaces the traffic with a new board's (its vehicles are new ones, so recolored and resized). */
+export declare function setTraffic(world: World, l: Layout, a: CrossyMeshes, s: Scene, vs: Vehicle[]): void;
+/** Everything goes with the root. */
+export declare function removeScene(world: World, s: Scene): void;

package/lib/typescript/src/games/dino-jump/DinoJump.d.ts

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

package/lib/typescript/src/games/dino-jump/DinoJumpConstants.d.ts

@@ -1,73 +1,49 @@
-export declare const DINO_JUMP_CONSTANTS: {
-    readonly gravity: 1.4;
-    readonly jumpForce: -28;
-    readonly gameSpeed: 6;
-    readonly baseScore: 1;
-    readonly scoreMultiplier: 1.5;
-    readonly speedIncreaseRate: 0.001;
-    readonly maxSpeed: 12;
-    readonly timeLimit: 120;
-    readonly lives: 3;
-    readonly maxLives: 3;
-};
-export declare const DINO_JUMP_GAME_CONFIG: {
-    readonly SCREEN_WIDTH: number;
-    readonly SCREEN_HEIGHT: number;
-    readonly GROUND_HEIGHT: 150;
-    readonly DINOSAUR_WIDTH: 70;
-    readonly DINOSAUR_HEIGHT: 75;
-    readonly DINOSAUR_X: 50;
-    readonly OBSTACLE_WIDTH: 20;
-    readonly OBSTACLE_HEIGHT: 40;
-    readonly OBSTACLE_SPAWN_DISTANCE: 600;
-    readonly GAME_DURATION: 120;
-    readonly PHYSICS_FRAME_RATE: 60;
-    readonly OBSTACLE_SPAWN_INTERVAL: 2000;
-    readonly JUMP_DURATION: 600;
-    readonly GROUND_SCROLL_SPEED: 4;
-};
-export declare const getGroundHeight: (offset?: number) => number;
-export declare const getGroundY: (offset?: number) => number;
-export declare const DINO_JUMP_ANIMATION_CONFIG: {
-    readonly DINO_JUMP: {
-        readonly damping: 15;
-        readonly stiffness: 300;
-        readonly mass: 1;
-    };
-    readonly OBSTACLE_MOVE: {
-        readonly duration: 3000;
-    };
-    readonly COLLISION_FEEDBACK: {
-        readonly duration: 200;
-        readonly intensity: 0.1;
-    };
-};
-export declare const DINO_JUMP_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly SKY_TOP: "#3a3a5e";
-    readonly SKY_BOTTOM: "#FECFEF";
-    readonly GROUND: "#FFD93D";
-    readonly GROUND_LINE: "#FF6B6B";
-    readonly DINOSAUR_PRIMARY: "#4ECDC4";
-    readonly DINOSAUR_SECONDARY: "#45B7D1";
-    readonly DINOSAUR_OUTLINE: "#2C3E50";
-    readonly OBSTACLE_PRIMARY: "#2ECC71";
-    readonly OBSTACLE_SECONDARY: "#27AE60";
-    readonly OBSTACLE_OUTLINE: "#1E8449";
-    readonly TEXT_PRIMARY: "#FFFFFF";
-    readonly TEXT_SECONDARY: "#ECF0F1";
-    readonly CLOUD_COLOR: "#FFFFFF";
-    readonly CLOUD_SHADOW: "rgba(52, 152, 219, 0.2)";
-};
-export declare const DINOSAUR_STATES: {
-    readonly RUNNING: "running";
-    readonly JUMPING: "jumping";
-    readonly DUCKING: "ducking";
-    readonly DEAD: "dead";
-};
-export declare const OBSTACLE_TYPES: {
-    readonly CACTUS_SMALL: "cactus_small";
-    readonly CACTUS_LARGE: "cactus_large";
-    readonly BIRD: "bird";
+import type { MeadowOptions, Rig } from '../shared/EngineMeadow';
+export declare const TIME_LIMIT = 120;
+export declare const LIVES = 3;
+export declare const POINTS_PER_SECOND = 200;
+export declare const MUSHROOM_POINTS = 1000;
+export type ObstacleKind = 'cactus_small' | 'cactus_large' | 'mushroom';
+/** Each obstacle's size in screen points (its collision box, and what's drawn). */
+export declare const OBSTACLE_SIZE: Record<ObstacleKind, {
+    width: number;
+    height: number;
+}>;
+export declare const MUSHROOM_CHANCE = 0.05;
+export declare const SMALL_CHANCE = 0.5;
+export declare const STEP: number;
+export declare const STEP_TOLERANCE = 0.002;
+export declare const MAX_PENDING = 0.05;
+export declare const GRAVITY = 1.4;
+export declare const JUMP_FORCE = -28;
+export declare const RUN_SPEED = 6;
+export declare const DINO_X = 50;
+export declare const DINO_WIDTH = 70;
+export declare const DINO_HEIGHT = 75;
+export declare const DINO_HIT_WIDTH = 50;
+export declare const DINO_HIT_HEIGHT = 60;
+export declare const MAX_OBSTACLES = 5;
+export declare const MIN_OBSTACLE_GAP = 300;
+export declare const REMOVE_X = -100;
+export declare const FIRST_OBSTACLE = 1.5;
+export declare const SPAWN_MIN = 2.5;
+export declare const SPAWN_SPREAD = 2;
+export declare const STRIDE_TIME = 0.16;
+export declare const DUST_INTERVAL = 0.24;
+/** The screen line the dino runs on: higher with no header, as the original ground strip was. */
+export declare const groundLine: (height: number, offset: number) => number;
+/**
+ * A low camera over the desert floor, at the height that puts the real ground under the play plane
+ * exactly on the original game's ground line: the dino runs on the sand, which runs on to the horizon.
+ */
+export declare function rigFor(height: number, offset: number): Rig;
+export declare const MEADOW: MeadowOptions;
+/** The scrolling desert floor comes in tiles this many metres wide (three cover any view). */
+export declare const TILE = 80;
+export type Layout = {
+    width: number;
+    height: number;
+    offset: number;
+    groundY: number;
 };
+export declare const getLayout: (width: number, height: number, offset: number) => Layout;

package/lib/typescript/src/games/dino-jump/DinoJumpGame.d.ts

@@ -0,0 +1,60 @@
+import { type Camera, type Color, type Entity, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type View3D } from '../shared/EngineMeadow';
+import { type Layout, type ObstacleKind } from './DinoJumpConstants';
+import { type DinoView, type Tiles } from './DinoJumpScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** An obstacle: its box's left edge (screen points). */
+type Obstacle = {
+    kind: ObstacleKind;
+    x: number;
+    root: Entity;
+};
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    tint: Color;
+    layout: Layout | null;
+    view: View3D | null;
+    scenery: Entity[];
+    desert: Tiles | null;
+    dino: DinoView | 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;
+    /** Game clock, seconds: drives the spawns and the dust (it pauses with the frame loop). */
+    time: number;
+    pending: number;
+    /** The dino's height above the ground (points, negative is up) and its vertical speed. */
+    jumpY: number;
+    velocity: number;
+    jumping: boolean;
+    /** How far the desert has scrolled, in points at the play plane. */
+    scroll: number;
+    dustTimer: number;
+    obstacles: Obstacle[];
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onLives: (_n: number) => void;
+    onTime: (_t: number) => void;
+    onJump: () => void;
+    onHit: (_last: boolean) => void;
+    onCollect: () => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the world out for the view and header (the camera height follows the ground line). */
+export declare function setLayout(g: Game, l: Layout): void;
+/** A new theme: day or night (the screen swaps the light); the run carries on. */
+export declare function setTheme(g: Game, theme: GameTheme): void;
+export declare function start(g: Game): void;
+/** A fresh run (Stop, Play Again): the dino back on the ground, standing. The world is kept. */
+export declare function reset(g: Game): void;
+export declare function dispose(g: Game): void;
+export declare function tick(g: Game, dt: number): void;
+/** Finger down: jump, if on the ground. */
+export declare function jump(g: Game): void;
+export {};

package/lib/typescript/src/games/dino-jump/DinoJumpScene.d.ts

@@ -0,0 +1,35 @@
+import { type Color, type Entity, type TransformBatch, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type View3D } from '../shared/EngineMeadow';
+import { type Layout, type ObstacleKind } from './DinoJumpConstants';
+/** An obstacle standing on the ground line, its box's left edge at screen x. */
+export declare function spawnObstacle(world: World, v: View3D, l: Layout, kind: ObstacleKind, x: number, tint: Color): Entity;
+export declare function placeObstacle(world: World, v: View3D, l: Layout, e: Entity, kind: ObstacleKind, x: number, updates?: TransformBatch): void;
+export type DinoView = {
+    root: Entity;
+    body: Entity;
+    near: Entity;
+    far: Entity;
+};
+/** The dino, its feet on screen point (x, y) (its box's bottom middle). */
+export declare function spawnDino(world: World, v: View3D, x: number, y: number, tint: Color): DinoView;
+export declare const dinoCentre: (x: number) => number;
+export declare function placeDino(world: World, v: View3D, d: DinoView, x: number, y: number): void;
+/** Running: the legs swing in turn and the body bobs; otherwise they hold a pose (tucked in the air). */
+export declare function setGait(world: World, v: View3D, d: DinoView, gait: 'stand' | 'run' | 'air'): void;
+/** A hit: the dino flashes red and shakes. */
+export declare function hurtDino(world: World, d: DinoView, tint: Color): void;
+/** A mushroom eaten: a golden glow. */
+export declare function cheerDino(world: World, d: DinoView, tint: Color): void;
+/** A puff of sand at screen point (x, y): kicked up running, or a bigger one landing. */
+export declare function dust(world: World, v: View3D, x: number, y: number, big: boolean): void;
+/** Bits fly where the dino hit an obstacle (green and sand for a cactus, red and white for a mushroom). */
+export declare function hitBurst(world: World, v: View3D, x: number, y: number, mushroom: boolean): void;
+export type Tiles = {
+    roots: Entity[];
+};
+/** Three desert tiles side by side, each its floor with its plants and rocks as children. */
+export declare function spawnDesert(world: World, theme: GameTheme, runZ: number): Tiles;
+/** Scrolls the desert `travelled` metres: each tile wraps round to the far side once it's well out of view. */
+export declare function placeDesert(world: World, t: Tiles, travelled: number): void;
+export declare function removeDesert(world: World, t: Tiles): void;

package/lib/typescript/src/games/dots-and-boxes/DotsAndBoxes.d.ts

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