@nayan-ui/games 1.19.0 → 1.21.0

package/lib/typescript/src/games/candy-crush/CandyCrushGame.d.ts

@@ -0,0 +1,65 @@
+import { type Camera, type Entity, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './CandyCrushConstants';
+import { type Scenery } from './CandyCrushScene';
+export type Phase = 'ready' | 'playing' | 'over';
+export type Direction = 'up' | 'down' | 'left' | 'right';
+type Candy = {
+    type: number;
+    row: number;
+    col: number;
+    root: Entity | null;
+};
+type Grid = (Candy | null)[];
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scenery: Scenery | null;
+    phase: Phase;
+    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    readonly timeLeft: number;
+    /** Game clock, seconds: drives the delayed steps (they pause with the frame loop). */
+    time: number;
+    grid: Grid;
+    /** A swap is resolving (matches, falls, cascades): no new moves until it settles. */
+    busy: boolean;
+    combo: number;
+    /** The candy under the finger. */
+    dragging: Candy | 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;
+    onSelect: () => void;
+    onSwap: () => void;
+    onInvalid: () => void;
+    onMatch: (_combo: number) => void;
+    /** A color bomb was made. */
+    onBomb: () => void;
+    /** A color bomb went off. */
+    onBlast: () => void;
+    onWarning: (_secondsLeft: number) => void;
+    onTimeUp: () => 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 repainted; the candies and the run carry on. */
+export declare function setTheme(g: Game, theme: GameTheme): void;
+export declare function start(g: Game): void;
+/** A new 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;
+/** Finger down: the candy under it lifts and follows the finger. */
+export declare function touchStart(g: Game, x: number, y: number): void;
+export declare function touchMove(g: Game, dx: number, dy: number): void;
+/** Finger up: a long enough drag swaps toward its main direction; otherwise the candy settles back. */
+export declare function touchEnd(g: Game, dx: number, dy: number, cancelled?: boolean): void;
+export {};

package/lib/typescript/src/games/candy-crush/CandyCrushScene.d.ts

@@ -0,0 +1,28 @@
+import { type Color, type Entity, type Vec3, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './CandyCrushConstants';
+/** 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;
+export declare const dragZ: (l: Layout) => number;
+/** Where the candy at (row, col) rests (row may be negative: above the board). */
+export declare const candyPosition: (l: Layout, row: number, col: number, z?: number) => Vec3;
+export type Scenery = {
+    backdrop: Entity;
+    parts: Entity[];
+};
+export declare function buildScenery(world: World, l: Layout, theme: GameTheme): Scenery;
+export declare function removeScenery(world: World, s: Scenery): void;
+/** A new theme: the background is repainted and the board rebuilt in its colors. */
+export declare function setSceneryTheme(world: World, l: Layout, s: Scenery, theme: GameTheme): void;
+export declare const candyColor: (type: number) => Color;
+/**
+ * A candy at view-world `position`, `scale` of full size. A color bomb is a block blending all the
+ * colors, gently pulsing so it stands out.
+ */
+export declare function spawnCandy(world: World, l: Layout, type: number, position: Vec3, scale: number): Entity;
+/** A color bomb just made: it grows in where its match was, with a little overshoot. */
+export declare function popInBomb(world: World, root: Entity): void;
+/** A thin zap from a color bomb to a block it clears, fading. */
+export declare function zap(world: World, l: Layout, from: Vec3, to: Vec3, type: number, delay: number): void;
+/** A matched candy pops as Block Blast's blocks do (shared/EngineBlasts): it swells, flashes white, settles and shrinks away, bursting in its color over a fading glow. Resolves when it's gone. */
+export declare function crushCandy(world: World, l: Layout, root: Entity, type: number, at: Vec3, duration: number, delay?: number): Promise<void>;

package/lib/typescript/src/games/car-racing/CarMeshes.d.ts

@@ -0,0 +1,44 @@
+import { type Color, type Geometry, type Model, type Quat, type Vec3 } from '@nayan-ui/engine';
+import type { Footprint } from '../shared/EngineFootprint';
+/** Turns a lathe's axis (y) onto x, for wheels. */
+export declare const AXLE_X: Quat;
+export type WheelOptions = {
+    /** The rim's radius as a share of the wheel's (a low-profile tyre is around 0.75). Default 0.7. */
+    rim?: number;
+    /** Spokes. Default 10. */
+    spokes?: number;
+    /** The rim's and the spokes' colors. Default gunmetal and bright silver. */
+    rimColor?: Color;
+    spokeColor?: Color;
+    /** What shows between the spokes (the brake disc on a car; dark on a bike, as if open). Default disc grey. */
+    gapColor?: Color;
+    /** A red brake caliper behind the spokes, toward the front (-z) and up, as on a car. Default false. */
+    caliper?: boolean;
+};
+/**
+ * A wheel `radius` across and `width` wide around the y axis (turn it with AXLE_X): a tyre with a
+ * rounded tread and darker sidewall, around a dished alloy rim with slim spokes over a brake disc.
+ * Wheels don't spin in these games, so the caliper is painted where it shows.
+ */
+export declare function wheel(radius: number, width: number, options?: WheelOptions): Geometry;
+export type CarMeshes = {
+    body: Model;
+    glass: Model;
+    trim: Model;
+};
+/** The car's three meshes, built once per app. */
+export declare function carMeshes(): CarMeshes;
+/**
+ * The car's outline from above, for collisions: the body's own half widths along its length (the
+ * mirrors fold in on contact, so they don't count), a couple of centimetres inside the paint.
+ */
+export declare const CAR_FOOTPRINT: Footprint;
+/** Where the car's lamps are (for the night glow over them): the headlights' centres and the tail-light bar. */
+export declare const CAR_LAMPS: {
+    headlights: Vec3[];
+    headlightSize: Vec3;
+    tail: Vec3;
+    tailSize: Vec3;
+};
+/** A low-poly pine about 1.2 tall and 1.5 across, its base at the origin: a trunk under three tiers. */
+export declare function treeMesh(): Model;

package/lib/typescript/src/games/car-racing/CarRacing.d.ts

@@ -1,3 +1,4 @@
 import React from 'react';
-import type { GameProps } from '../../services/UtilsService';
+import { type GameProps } from '../../services/UtilsService';
+export { preloadRacing as preloadCarRacing } from './CarRacingConstants';
 export declare const CarRacing: React.FC<GameProps>;

package/lib/typescript/src/games/car-racing/CarRacingConstants.d.ts

@@ -1,31 +1,62 @@
-export declare const CAR_RACING_GAME_CONFIG: {
-    GAME_DURATION: number;
-    CAR_WIDTH: number;
-    CAR_HEIGHT: number;
-    OBSTACLE_WIDTH: number;
-    OBSTACLE_HEIGHT: number;
-    ROAD_LANES: number;
-    LANE_WIDTH: number;
-    ROAD_SPEED: number;
-    OBSTACLE_SPAWN_INTERVAL: number;
-    COLLISION_TOLERANCE: number;
-    POINTS_PER_OBSTACLE_PASSED: number;
-    LANE_SWITCH_DURATION: number;
-    PLAYER_BOTTOM_MARGIN: number;
+import { type Color, type Font, type Light, type Model, type SoundBank, type Texture, type Vec3 } from '@nayan-ui/engine';
+import { type SceneryMeshes } from './CarRacingScenery';
+export declare const TRACK_LENGTH = 2000;
+export declare const LIVES = 3;
+export declare const POINTS_PER_CAR_PASSED = 500;
+/** No traffic is spawned this close to the finish, so the line is clear to cross. */
+export declare const FINISH_CLEAR = 30;
+export declare const LANE_W = 3.4;
+export declare const LANES: number[];
+export declare const ROAD_HALF: number;
+export declare const EDGE: number;
+export declare const START_SPEED = 20;
+export declare const CAMERA_FOV = 0.95;
+export declare const LATERAL_SPEED = 9;
+export declare const STEER_RESPONSE = 10.5;
+export declare const STEER_WIDTH = 0.6;
+export declare const TRAFFIC_SPEED = 12;
+export declare const SPAWN_AHEAD = 170;
+export declare const CRASH_SLOWDOWN = 0.55;
+export declare const INVULNERABLE = 1.6;
+export declare const SEG_LEN = 6;
+export declare const SEGMENTS = 42;
+export declare const RS = 0.2;
+export declare const BEHIND = 8;
+export declare const SKY: readonly [0.62, 0.78, 0.95];
+export declare const NIGHT_SKY: readonly [0.227, 0.192, 0.376];
+export declare const DAY_LIGHT: Light;
+export declare const NIGHT_LIGHT: Light;
+export declare const LAMP: Color;
+export declare const LAMP_LIT: Color;
+export declare const LINE: Color;
+export declare const RAIL: Color;
+export declare const PAINTS: Color[];
+export declare const PLAYER_PAINT: Color;
+export declare const AUTOPLAY: boolean;
+export declare const getRacingSounds: () => SoundBank<"win" | "hit" | "engine" | "nitro" | "point" | "die" | "bump">;
+/**
+ * One car for everyone, built in code (CarMeshes): a glossy white body each entity paints its own
+ * color, the windows, and untinted trim (tyres, lights).
+ */
+export type CarModel = {
+    body: Model;
+    glass: Model;
+    trim: Model;
+    size: Vec3;
 };
-export declare const CAR_RACING_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly ROAD_DARK: "#3a3a5e";
-    readonly ROAD_LIGHT: "#3a3a3a";
-    readonly ROAD_LINE: "#ffffff";
-    readonly GRASS_GREEN: "#2d5016";
-    readonly GRASS_DARK: "#1a3009";
-    readonly SKY_BLUE: "#87ceeb";
-    readonly PLAYER_CAR: "#ff4444";
-    readonly OBSTACLE_CAR_1: "#4444ff";
-    readonly OBSTACLE_CAR_2: "#44ff44";
-    readonly OBSTACLE_CAR_3: "#ffff44";
-    readonly UI: "#ffffff";
+export type Assets = {
+    car: CarModel;
+    asphalt: Texture;
+    facade: Texture;
+    grass: Texture;
+    ads: Texture[];
+    tree: Model;
+    scenery: SceneryMeshes;
+    font: Font;
 };
-export declare const getLanePosition: (laneIndex: number, screenWidth: number) => number;
+export declare const getCachedAssets: () => Assets | null;
+export declare function loadAssets(): Promise<Assets>;
+/** Starts loading the game's textures and building its models (they're cached), so opening it is quick. */
+export declare function preloadRacing(): void;
+/** Decode one texture per job before the asset bundle's cached assembly. */
+export declare function warmAssets(): Iterable<() => unknown>;

package/lib/typescript/src/games/car-racing/CarRacingFacade.d.ts

@@ -0,0 +1,5 @@
+import type { Vec3 } from '@nayan-ui/engine';
+export declare function facadeWindowQuads(): Iterable<{
+    corners: [Vec3, Vec3, Vec3, Vec3];
+    normal: Vec3;
+}>;

package/lib/typescript/src/games/car-racing/CarRacingGame.d.ts

@@ -0,0 +1,96 @@
+import { type Camera, type Entity, type Voice, World } from '@nayan-ui/engine';
+import type { HudFeedback } from '../shared/EngineHud';
+import { type Assets } from './CarRacingConstants';
+import { type Fire, Track } from './CarRacingScene';
+export type Phase = 'ready' | 'playing' | 'over';
+export declare function createGame(a: Assets, night: boolean): {
+    world: World;
+    night: boolean;
+    track: Track;
+    chase: {
+        eye: [number, number, number];
+        target: [number, number, number];
+        initialized: boolean;
+    };
+    assets: Assets;
+    camera: Camera;
+    player: {
+        root: Entity;
+        body: Entity;
+        glass: Entity;
+        trim: Entity;
+        lights: Entity[];
+    };
+    horizon: Entity;
+    segments: import("./CarRacingScene").Segment[];
+    traffic: Car[];
+    /** Wrecks on fire. */
+    burning: Fire[];
+    phase: Phase;
+    time: number;
+    s: number;
+    d: number;
+    target: number;
+    dragX: number;
+    speed: number;
+    lateral: number;
+    steeringPose: {
+        yaw: number;
+        roll: number;
+    };
+    steeringGoal: number;
+    spawnTimer: number;
+    invulnerable: number;
+    scrape: number;
+    orbit: number;
+    /** Score, lives and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    readonly lives: number;
+    /** Metres left to the finish gate. */
+    left: number;
+    shake: number;
+    engine: Voice | null;
+    audible: boolean;
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onLives: (_l: number) => void;
+    onDistance: (_metres: number) => void;
+    hudFeedback: HudFeedback;
+};
+export type Game = ReturnType<typeof createGame>;
+export declare function start(g: Game): void;
+/** Mirrors the shared screen's audible state without letting an engine loop leak to another screen. */
+export declare function setAudible(g: Game, enabled: boolean): void;
+/** Change only lighting and celestial details; preserve the current race and scenery layout. */
+export declare function setNight(g: Game, night: boolean): void;
+/** Steers toward the finger: `dx` is the drag's distance so far, `metresPerPoint` how far that moves the car. */
+export declare function steer(g: Game, phase: 'start' | 'move' | 'end', dx: number, metresPerPoint: number): void;
+/** Stops the run's sounds and frees its world (the screen unmounting). */
+export declare function dispose(g: Game): void;
+export declare function tick(g: Game, dt: number): void;
+export type Car = {
+    root: Entity;
+    lights: Entity[];
+    s: number;
+    d: number;
+    /** The lane it spawned in (a sideswipe can shove it out of it). */
+    lane: number;
+    /** Sideways speed from a sideswipe, fading back to 0. */
+    vd: number;
+    passed: boolean;
+    crashed: boolean;
+    /** It was sideswiped (no near-miss bonus for it). */
+    bumped: boolean;
+    /** Seconds until another sideswipe makes a sound again. */
+    bumpCooldown: number;
+    /** Closest it came beside the player, for near misses. */
+    closest: number;
+    /** How far ahead of the player it was last frame, and whether it's touching (and met nose to tail). */
+    wasAhead: number;
+    touching: boolean;
+    headOn: boolean;
+};
+/** Traffic ahead, in a lane that doesn't close the road: cars close together always leave a lane open. */
+export declare function spawnTraffic(g: Game, ahead?: number): void;
+/** Demo bot: head for the lane whose next car is furthest away. */
+export declare function autopilot(g: Game): void;

package/lib/typescript/src/games/car-racing/CarRacingScene.d.ts

@@ -0,0 +1,97 @@
+import { type Camera, type Color, type Entity, type Font, type Quat, type Vec3, type World } from '@nayan-ui/engine';
+import { type Assets } from './CarRacingConstants';
+export declare const rand: (min: number, max: number) => number;
+export declare const pick: <T>(items: readonly T[]) => NonNullable<T>;
+export declare const clamp: (v: number, lo: number, hi: number) => number;
+export type Sample = {
+    x: number;
+    y: number;
+    z: number;
+    heading: number;
+    pitch: number;
+};
+export declare const newSample: () => Sample;
+/** The centre line, integrated a metre at a time as the player drives. */
+export declare class Track {
+    private xs;
+    private zs;
+    private hs;
+    private ensure;
+    sample(s: number, out: Sample): Sample;
+}
+export declare const forwardOf: (h: number) => Vec3;
+export declare const rightOf: (h: number) => Vec3;
+/** The world point at a track sample, `d` to the right and `h` above the road. */
+export declare function placeAt(t: Sample, d: number, h: number, out: [number, number, number]): [number, number, number];
+/** Facing along `heading` (turned `yaw` further right), nose up by `pitch`, rolled left by `roll`. */
+export declare function orient(heading: number, pitch: number, yaw?: number, roll?: number, out?: [number, number, number, number]): Quat;
+/** A car: an invisible root at its middle (the collider's centre once wrecked) with body, glass and trim attached. */
+export declare function spawnCar(world: World, a: Assets, paint: Color, position: Vec3, night: boolean): {
+    root: Entity;
+    body: Entity;
+    glass: Entity;
+    trim: Entity;
+    lights: Entity[];
+};
+/** Toggle lamp meshes in place so switching theme preserves every car's pose and physics. */
+export declare function setCarNight(world: World, car: {
+    root: Entity;
+    lights: Entity[];
+}, night: boolean, height: number): void;
+/** A stretch of road; `props` is its scenery, rebuilt for the zone it lands in each time it jumps ahead. */
+export type Segment = {
+    root: Entity;
+    s: number;
+    props: Entity[];
+    lights: {
+        entity: Entity;
+        day: Color;
+        night: Color;
+    }[];
+};
+/** What the scenery needs from the game. */
+export type SceneryContext = {
+    world: World;
+    assets: Assets;
+    night: boolean;
+    track: Track;
+};
+/**
+ * Road segments: a root carrying the ground collider, with asphalt, curbs, markings, rails and
+ * scenery attached. Segments that fall behind jump ahead with everything on them.
+ */
+export declare function buildRoad(world: World, a: Assets): Segment[];
+/** Mountains and rolling hills all around (and, at night, a moon and stars), on a root that rides along with the player so they never get closer. */
+export declare function buildHorizon(world: World, night: boolean): Entity;
+export declare function setHorizonNight(world: World, horizon: Entity, night: boolean): void;
+/** Puts a segment where its distance along the track is. */
+export declare function placeSegment(g: SceneryContext, seg: Segment): void;
+/** Fills a segment's roadside for its zone. Positions are in the segment's frame: x across, z along, y up. */
+export declare function spawnProps(g: SceneryContext, seg: Segment): void;
+/** Segments left behind jump to the front, with fresh scenery. */
+export declare function recycleRoad(g: SceneryContext, segments: Segment[], s: number): void;
+/** A wreck on fire: flames and smoke come off it until `until` (game time). */
+export type Fire = {
+    root: Entity;
+    until: number;
+    flame: number;
+    smoke: number;
+    ember: number;
+};
+export declare const burning: (root: Entity, until: number) => Fire;
+/**
+ * A crash: a white-hot flash, a fireball that swells and cools to red, sparks and car bits thrown out,
+ * and smoke that billows up and thins.
+ */
+export declare function explode(w: World, at: Vec3): void;
+export declare function burn(world: World, camera: Camera, fires: Fire[], time: number, dt: number): void;
+/**
+ * The race's start line (at `startS`) and finish gate (at `finishS`), placed on the road and facing the
+ * driver, with FINISH written on the gate's banner once the HUD's font is in.
+ */
+export declare function spawnRaceMarkers(world: World, track: Track, startS: number, finishS: number, font: Font): {
+    start: Entity;
+    finish: Entity;
+};
+/** Reusable assets; the game loader advances one builder per frame. */
+export declare function warmAssets(): Iterable<() => unknown>;

package/lib/typescript/src/games/car-racing/CarRacingScenery.d.ts

@@ -0,0 +1,22 @@
+import { type Model } from '@nayan-ui/engine';
+declare function buildScenery(): {
+    podium: Model;
+    roofs: Model[];
+    facades: Model[];
+    windows: Model;
+    bench: Model;
+    planter: Model;
+    bin: Model;
+    shelter: Model;
+    grass: Model;
+    flowers: Model;
+    pavement: Model;
+    drain: Model;
+    house: Model;
+    grassGround: Model;
+    routeSign: Model;
+    cloud: Model;
+};
+export type SceneryMeshes = ReturnType<typeof buildScenery>;
+export declare function sceneryMeshes(): SceneryMeshes;
+export {};

package/lib/typescript/src/games/chameleon-run/ChameleonRun.d.ts

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

package/lib/typescript/src/games/chameleon-run/ChameleonRunBackdrop.d.ts

@@ -0,0 +1,14 @@
+import { type Entity, type Light, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+type RGB = readonly [number, number, number];
+export declare const lightFor: (theme: GameTheme) => Light;
+export declare const backgroundFor: (theme: GameTheme) => RGB;
+export interface Backdrop {
+    root: Entity;
+    alive: boolean;
+}
+export declare function spawnBackdrop(world: World, theme: GameTheme): Backdrop;
+export declare function removeBackdrop(world: World, backdrop: Backdrop): void;
+/** Landscape models depend only on the theme, not a running game. */
+export declare function warmAssets(theme: GameTheme): Iterable<() => unknown>;
+export {};

package/lib/typescript/src/games/chameleon-run/ChameleonRunConstants.d.ts

@@ -1,44 +1,46 @@
-export declare const CHAMELEON_CONFIG: {
-    readonly CHAMELEON_SIZE: 60 | 46;
-    readonly ANCHOR_X: number;
-    readonly GROUND_Y: number;
-    readonly PLATFORM_TOP_MIN: number;
-    readonly PLATFORM_TOP_MAX: number;
-    readonly STEP_MAX: 60 | 45;
-    readonly PLATFORM_BOTTOM: number;
-    readonly PLATFORM_MIN_WIDTH: 300 | 220;
-    readonly PLATFORM_MAX_WIDTH: 600 | 440;
-    readonly GAP_MIN: 90 | 70;
-    readonly GAP_MAX: 100 | 130;
-    readonly JUMP_MARGIN: 60 | 80;
-    readonly BASE_SPEED: 6.5 | 5.2;
-    readonly MAX_SPEED: 6.5 | 5.2;
-    readonly SPEED_RAMP: 0;
-    readonly GRAVITY: 0.95 | 0.88;
-    readonly JUMP_VELOCITY: -18 | -16;
-    readonly DOUBLE_JUMP_VELOCITY: -15.5 | -14;
-    readonly MAX_JUMPS: 2;
-    readonly FALL_THRESHOLD_Y: number;
-    readonly STAR_RADIUS: 14 | 18;
-    readonly STAR_POINTS: 250;
-    readonly STAR_CHANCE: 0.65;
-    readonly DISTANCE_PER_POINT: 6 | 8;
-    readonly GAME_DURATION: 120;
-    readonly SCREEN_HEIGHT: number;
-    readonly SCREEN_WIDTH: number;
+/** Match Penguin Run: a fixed-distance run at a steady pace, with three lives. */
+export declare const TRACK_LENGTH = 500;
+export declare const MAX_LIVES = 3;
+export declare const HURT_INVULNERABLE = 2.2;
+export declare const RESULTS_DELAY_LOSE = 1700;
+export declare const RESULTS_DELAY_WIN = 2600;
+export declare const POINTS_PER_METRE = 1;
+export declare const DRAG_THRESHOLD = 18;
+export declare const STEP_SECONDS: number;
+export declare const MAX_FRAME_SECONDS = 0.05;
+export declare const SCORE_SYNC = 0.1;
+export declare const STAR_POINTS = 250;
+export declare const MAX_JUMPS = 2;
+export declare const JUMP_BUFFER = 0.12;
+export declare const COYOTE_TIME = 0.1;
+export declare const COLOR_GRACE = 0.12;
+export declare const BASE_SPEED = 7;
+export type RunColor = 'yellow' | 'pink';
+export declare const RUN_COLORS: {
+    readonly yellow: "#FFD447";
+    readonly pink: "#F653A6";
 };
-export declare const PLATFORM_COLOR = "#C67B4E";
-export declare const PLATFORM_COLOR_DARK = "#9E5A34";
-export declare const CHAMELEON_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly BODY: "#4CAF50";
-    readonly BODY_DARK: "#2E7D32";
-    readonly EYE: "#2C2C44";
-    readonly STAR: "#FFE040";
-    readonly STAR_LIGHT: "#FFF8B0";
-    readonly STAR_DARK: "#E5A000";
-    readonly STAR_GLOW: "rgba(255, 200, 0, 0.7)";
-    readonly HILL_FAR: "rgba(255, 255, 255, 0.08)";
-    readonly HILL_NEAR: "rgba(255, 255, 255, 0.14)";
+export declare const COLOR_NAMES: {
+    readonly yellow: "YELLOW · STRIPES";
+    readonly pink: "PINK · DOTS";
+};
+export interface Config {
+    width: number;
+    height: number;
+    trackWidth: number;
+    lookAhead: number;
+    gravity: number;
+    jump: number;
+    doubleJump: number;
+    fallY: number;
+}
+export declare function configFor(width: number, height: number): Config;
+export declare const COLORS: {
+    readonly STONE: "#496578";
+    readonly STONE_DARK: "#304556";
+    readonly NEUTRAL: "#D6E9EC";
+    readonly STAR: "#FFF09A";
+    readonly BELLY: "#FFF5DC";
+    readonly EYE: "#16243A";
+    readonly RIM: "#F5FCFF";
 };

package/lib/typescript/src/games/chameleon-run/ChameleonRunGame.d.ts

@@ -0,0 +1,60 @@
+import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Config, type RunColor } from './ChameleonRunConstants';
+import { type Failure, type Run } from './ChameleonRunRules';
+import { type Scene } from './ChameleonRunScene';
+export type Phase = 'ready' | 'playing' | 'over';
+export type GameEvent = 'jump' | 'land' | 'star' | 'swap' | 'hurt' | 'fall' | 'win';
+export interface RunHud {
+    color: RunColor;
+    next: RunColor | null;
+    combo: number;
+    jumps: number;
+    progress: number;
+    failure: Failure | null;
+}
+export declare const INITIAL_HUD: RunHud;
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    config: Config | null;
+    scene: Scene | null;
+    run: Run | null;
+    phase: Phase;
+    running: boolean;
+    won: boolean;
+    active: boolean;
+    pending: number;
+    clock: number;
+    lastScoreSync: number;
+    syncedScore: number;
+    shownDistance: number;
+    shownLives: number;
+    finishSpeed: number;
+    coast: number;
+    dragFired: boolean;
+    hudKey: string;
+    cameraLift: number;
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onStars: (_n: number) => void;
+    onDistance: (_metres: number) => void;
+    onLives: (_lives: number) => void;
+    onHud: (_hud: RunHud) => void;
+    onEvent: (_e: GameEvent) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+export declare function setLayout(g: Game, width: number, height: number): void;
+export declare function setTheme(g: Game, theme: GameTheme): void;
+export declare function start(g: Game): void;
+export declare function reset(g: Game): void;
+export declare function dispose(g: Game): void;
+export declare function setActive(g: Game, active: boolean): void;
+export declare function tick(g: Game, dt: number): void;
+export declare function tap(g: Game): void;
+export declare function swap(g: Game): void;
+/** Penguin Run's mid-stroke response: one jump as soon as an upward swipe passes 18 points. */
+export declare function steer(g: Game, e: DragEvent): void;
+/** A stroke that already jumped must never also switch color when its finger is released. */
+export declare function changeColor(g: Game): void;

package/lib/typescript/src/games/chameleon-run/ChameleonRunMeshes.d.ts

@@ -0,0 +1,20 @@
+import { type Model } from '@nayan-ui/engine';
+/** Facing +x, with the feet at -0.5. Shape and pigment remain readable from the chase camera. */
+export declare const bodyMesh: () => Model;
+/** Restrained throat folds, a closed jaw seam and tiny nostrils; no smile or cartoon eye whites. */
+export declare const detailsMesh: () => Model;
+/** Scaly turret eyelids with only a small forward-facing opening. Local +z is the gaze direction. */
+export declare const eyeMesh: () => Model;
+export declare const eyeDetailsMesh: () => Model;
+export declare const tailMesh: () => Model;
+export interface LimbDefinition {
+    x: number;
+    y: number;
+    side: -1 | 1;
+    hind: boolean;
+}
+export declare const LIMBS: readonly LimbDefinition[];
+export declare const legMesh: (side: number, hind?: boolean) => Model;
+export declare const starMesh: () => Model;
+/** Reusable assets; the game loader advances one builder per frame. */
+export declare function warmAssets(): Iterable<() => unknown>;