@nayan-ui/games 1.19.0 → 1.21.0

package/lib/typescript/src/games/colors-sort/ColorsSortGame.d.ts

@@ -0,0 +1,41 @@
+import { type Camera, type Entity, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './ColorsSortConstants';
+import { type Scene } from './ColorsSortScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** pick: a puck lifted; drop: a puck put back; move: one moved; refuse: an empty pick-up or a full tube; complete: all sorted. */
+export type GameEvent = 'pick' | 'drop' | 'move' | 'refuse' | 'complete';
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    tubes: number[][];
+    /** Each tube's puck entities, parallel to `tubes`. */
+    pieces: Entity[][];
+    selected: number | null;
+    /** Seconds played, and left: the countdown lives in the engine (Rust), advanced by world.update. */
+    readonly time: number;
+    readonly timeLeft: number;
+    timedOut: boolean;
+    onPhase: (_p: Phase) => void;
+    onTime: (_t: number) => void;
+    onEvent: (_e: GameEvent) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the scene out for the view (first layout, header height, rotation): rebuilt from the board. */
+export declare function setLayout(g: Game, l: Layout): void;
+export declare function setTheme(g: Game, theme: GameTheme): void;
+/** Plays the board that's showing. */
+export declare function start(g: Game): void;
+/** A freshly shuffled board, 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;
+/** The tube under a view point: its column, from just under its shelf to above its mouth (where a puck hovers). */
+export declare function tubeAt(g: Game, x: number, y: number): number | null;
+export declare function tap(g: Game, x: number, y: number): void;
+/** The tube tapped: pick up from it, put back into it, or move the lifted puck onto it. */
+export declare function choose(g: Game, t: number): void;

package/lib/typescript/src/games/colors-sort/ColorsSortScene.d.ts

@@ -0,0 +1,33 @@
+import { type Color, type Entity, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './ColorsSortConstants';
+export declare const pieceColor: (colorIndex: number) => Color;
+export type Tube = {
+    glass: Entity;
+    rim: Entity;
+    streak: Entity;
+    edges: Entity[];
+    cork: Entity;
+};
+export type Scene = {
+    backdrop: Entity;
+    tubes: Tube[];
+};
+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 function spawnPiece(world: World, l: Layout, colorIndex: number, tube: number, slot: number): Entity;
+/** Picked up: the top puck springs up out of its tube and hovers. */
+export declare function liftPiece(world: World, l: Layout, piece: Entity, tube: number): void;
+/** Put back: it drops into its own slot again. */
+export declare function lowerPiece(world: World, l: Layout, piece: Entity, tube: number, slot: number): void;
+/** Moved: it flies over to the other tube's mouth, then drops in and settles with a bounce. */
+export declare function movePiece(world: World, l: Layout, piece: Entity, from: number, to: number, slot: number): void;
+/** A refused tap: the tube and what's in it shake. */
+export declare function shakeTube(world: World, l: Layout, t: Tube, pieces: Entity[]): void;
+/** A whole color in one tube: it pops, sparkles in that color and a cork drops into its mouth. */
+export declare function completeTube(world: World, l: Layout, t: Tube, tube: number, colorIndex: number): void;
+/** The cork in a sorted tube's mouth (dropping in, or simply there), or taken away. */
+export declare function showCork(world: World, l: Layout, t: Tube, tube: number, on: boolean, animate?: boolean): void;
+/** Confetti over the shelves when everything's sorted. */
+export declare function celebrate(world: World, l: Layout): void;

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

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

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

@@ -1,19 +1,45 @@
-export declare const CONNECT_EM_ALL_COLORS: {
-    BACKGROUND: string;
-    PRIMARY: string;
-    GRID_BACKGROUND: string;
-    BOARD_BACKGROUND: string;
-    DOT_COLORS: string[];
-    LINE_COLOR: string;
-    SCORE_TEXT: string;
-    COMBO_TEXT: string;
+export declare const GRID_SIZE = 7;
+export declare const MIN_CONNECT = 3;
+export declare const TIME_LIMIT = 300;
+export declare const LOOP_BONUS = 250;
+export declare const DOT_COLORS: readonly ["#FF3B3B", "#32CD32", "#FFD700", "#4DA6FF", "#BF5AF2"];
+/** 50 a dot, plus 75 for every dot past the third. */
+export declare const scoreFor: (dots: number) => number;
+export declare const FALL_TIME = 0.35;
+export declare const INTRO_COL_STAGGER = 0.035;
+export declare const INTRO_ROW_STAGGER = 0.03;
+export declare const INTRO_SPRING: {
+    damping: number;
+    stiffness: number;
+    mass: number;
 };
-export declare const CONNECT_EM_ALL_GAME_CONFIG: {
-    GRID_SIZE: number;
-    DOT_RADIUS: number;
-    DOT_SPACING: number;
-    BOARD_PADDING: number;
-    MIN_CONNECT: number;
-    TIME_LIMIT: number;
-    FALL_DURATION: number;
+export declare const POP_SCALE = 1.24;
+export declare const CONNECTED_SCALE = 1.08;
+export declare const POP_TIME = 0.2;
+export declare const RELEASE_TIME = 0.14;
+export declare const CLEAR_TIME = 0.45;
+export declare const TRAIL_ALPHA = 0.75;
+/** The halo round a connected dot: its size as a share of the dot, and its opacity at the dot's edge (it fades smoothly to nothing). */
+export declare const GLOW_SIZE = 1.6;
+export declare const GLOW_ALPHA = 0.38;
+export declare const GLOW_IN_TIME = 0.2;
+export declare const GLOW_OUT_TIME = 0.12;
+/** The board panel's corner radius (points), as Block Blast's. */
+export declare const BOARD_RADIUS = 8;
+export declare const LIGHT: import("@nayan-ui/engine").Light;
+export declare const DOT_SHINE = 0.4;
+export type Layout = {
+    /** The GameView's size. */
+    width: number;
+    height: number;
+    boardLeft: number;
+    boardTop: number;
+    boardSize: number;
+    /** From the board's edge to the outer dots' centres. */
+    padding: number;
+    spacing: number;
+    radius: number;
+    hitRadius: number;
 };
+/** Board as wide as the game area (360 phones / 500 tablets), centred in the space below the header. */
+export declare function getLayout(width: number, height: number, offset: number): Layout;

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

@@ -0,0 +1,54 @@
+import { type Camera, type Entity, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './ConnectEmAllConstants';
+import { type Board, type Segment, type Trail } from './ConnectEmAllScene';
+export type Phase = 'ready' | 'playing' | 'over';
+type Dot = {
+    colorIndex: number;
+    entity: Entity | null;
+    glow: Entity | null;
+};
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    board: Board | null;
+    phase: Phase;
+    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    readonly timeLeft: number;
+    won: boolean;
+    /** Row-major, `GRID_SIZE` x `GRID_SIZE`. */
+    dots: Dot[];
+    /** Dot indices, in the order they were joined. */
+    chain: number[];
+    touching: boolean;
+    lastIndex: number;
+    finger: [number, number];
+    segments: Segment[];
+    trail: Trail | null;
+    /** The next board to appear rains in. */
+    intro: boolean;
+    /** Game seconds the current intro has been playing (-1 until its board spawns). */
+    introAge: number;
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onTime: (_t: number) => void;
+    onConnect: () => void;
+    onClear: () => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the scene out for the view (first layout, header height, rotation): rebuilt from the run's state. */
+export declare function setLayout(g: Game, l: Layout): void;
+/** A new theme: the background and board are rebuilt; the dots and the run carry on. */
+export declare function setTheme(g: Game, theme: GameTheme): void;
+export declare function start(g: Game): void;
+/** A fresh board and timer (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;
+export declare function touchStart(g: Game, x: number, y: number): void;
+export declare function touchMove(g: Game, x: number, y: number): void;
+export declare function touchEnd(g: Game): void;
+export {};

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