@nayan-ui/games 1.19.0 → 1.20.0

package/lib/typescript/src/games/tank-1990/Tank1990Scene.d.ts

@@ -0,0 +1,38 @@
+import { type Entity, type Vec3, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Direction, type Layout } from './Tank1990Constants';
+import type { Bullet, Tank, Tile } from './Tank1990Rules';
+export declare const heading: (d: Direction) => import("@nayan-ui/engine").MutableQuat;
+/** Board points to the world, at height z. */
+export declare const toWorld: (l: Layout, x: number, y: number, z?: number) => Vec3;
+export type TankView = {
+    body: Entity;
+    shield: Entity;
+    direction: Direction;
+    shielded: boolean;
+    x: number;
+    y: number;
+};
+export type Scene = {
+    backdrop: Entity;
+    field: Entity;
+    frame: Entity;
+    grid: Entity;
+    /** Each tile's wall, row by row (null where it's open ground). */
+    walls: (Entity | null)[][];
+    tanks: Map<number, TankView>;
+    bullets: Map<number, Entity>;
+};
+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's wall after a hit: a layer down, or gone in a shower of rubble. */
+export declare function updateWall(world: World, l: Layout, s: Scene, x: number, y: number, t: Tile, was: Tile['type']): void;
+/** Builds a fresh map's walls (a new board). */
+export declare function rebuildWalls(world: World, l: Layout, s: Scene, tiles: Tile[][]): void;
+/** Puts every live tank and shell where the battle has them (spawning newcomers, clearing the gone). */
+export declare function syncUnits(world: World, l: Layout, s: Scene, tanks: Tank[], bullets: Bullet[], now: number): void;
+/** A muzzle flash at the end of a tank's barrel. */
+export declare function muzzleFlash(world: World, l: Layout, t: Tank): void;
+/** An explosion at a board point: a fireball and smoke, bigger for a tank. */
+export declare function explode(world: World, l: Layout, x: number, y: number, big: boolean): void;

package/lib/typescript/src/games/tic-tac-toe/TicTacToe.d.ts

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

package/lib/typescript/src/games/tic-tac-toe/TicTacToeConstants.d.ts

@@ -1,72 +1,35 @@
-export declare const TIC_TAC_TOE_COLORS: {
-    BACKGROUND: string;
-    PRIMARY: string;
-    X_COLOR: string;
-    O_COLOR: string;
-    WIN_LINE: string;
-    GRID_LINE: string;
-    CELL_BACKGROUND: string;
-    CELL_HOVER: string;
-    BACKGROUND_COLORS: string[];
-};
-export declare const TIC_TAC_TOE_GAME_CONFIG: {
-    SCREEN_WIDTH: number;
-    SCREEN_HEIGHT: number;
-    BOARD_SIZE: number;
-    CELL_SIZE: number;
-    LINE_WIDTH: number;
-    SYMBOL_SIZE: number;
-    SYMBOL_STROKE_WIDTH: number;
-};
-export declare const TIC_TAC_TOE_CONSTANTS: {
-    maxTime: number;
-    winScore: number;
-    drawScore: number;
-    loseScore: number;
-};
-export type Player = 'X' | 'O' | null;
-export type CellValue = Player;
-export type Board = CellValue[];
-export declare const WINNING_COMBINATIONS: number[][];
-export declare const BOARD_3D: {
-    readonly DEPTH: 10 | 8;
-    readonly PADDING: 10 | 8;
-    readonly RADIUS: 16 | 12;
-    readonly BOARD_TOP: "#5c4033";
-    readonly BOARD_FRONT: "#4a3228";
-    readonly BOARD_INNER: "#3a2518";
-    readonly BOARD_HIGHLIGHT: "#7a5a45";
-};
-export declare const GRID_3D: {
-    readonly line: "#7a5a45";
-    readonly lineLight: "#8d6e5a";
-    readonly shadow: "rgba(0,0,0,0.35)";
-    readonly highlight: "#9e8070";
-    readonly depth: 3;
-};
-export declare const X_3D: {
-    readonly stroke: string[];
-    readonly shadow: string;
-    readonly highlight: string;
-    readonly outerGlow: "rgba(229,57,53,0.35)";
-    readonly glow: string[];
-    readonly winStroke: string[];
-};
-export declare const O_3D: {
-    readonly stroke: string[];
-    readonly shadow: string;
-    readonly highlight: string;
-    readonly outerGlow: "rgba(46,125,50,0.35)";
-    readonly glow: string[];
-    readonly winStroke: string[];
-};
-export declare const WIN_3D: {
-    readonly stroke: string[];
-    readonly glow: string[];
-    readonly shadow: "rgba(255,152,0,0.4)";
-};
-export declare const CELL_3D: {
-    readonly face: "rgba(122,90,69,0.08)";
-    readonly faceAlt: "rgba(122,90,69,0.04)";
-    readonly hover: "rgba(122,90,69,0.10)";
-};
+import type { TiltView } from '../shared/EngineTilt';
+export declare const TIME_LIMIT = 120;
+export declare const WIN_SCORE = 10000;
+export declare const DRAW_SCORE = 5000;
+export declare const LOSE_SCORE = 0;
+/** Points for every second still on the clock when a game is won (half this for a draw). */
+export declare const TIME_BONUS = 50;
+export declare const ROBOT_DELAY = 0.5;
+export declare const COLORS: {
+    readonly X: "#E53935";
+    readonly O: "#2E7D32";
+    readonly WIN: "#FFC107";
+    readonly FRAME: "#5c4033";
+    readonly WELL: "#3a2518";
+    readonly SURFACE: "#6b4c3b";
+    readonly SURFACE_ALT: "#735342";
+    readonly GRID: "#8d6e5a";
+    readonly X_BADGE: "#F44336";
+    readonly O_BADGE: "#4CAF50";
+};
+/** The camera leans back from straight down, so the board's depth and the pieces stand up. */
+export declare const TILT = 0.42;
+/** 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;
+    pad: number;
+};
+/** The board as big as the original board (85% of the width, at most 350 points, 420 on a tablet), smaller if the screen is short. */
+export declare function getLayout(width: number, height: number, offset: number, tablet: boolean): Layout;
+/** A cell's centre (0 top left, row by row), in world units. */
+export declare function cellCentre(l: Layout, i: number): [number, number];
+/** The cell under a board point, or -1. */
+export declare function cellAt(l: Layout, x: number, y: number): number;

package/lib/typescript/src/games/tic-tac-toe/TicTacToeGame.d.ts

@@ -0,0 +1,54 @@
+import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './TicTacToeConstants';
+import { type Board, type Player } from './TicTacToeRules';
+import { type Scene } from './TicTacToeScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** How a game ended. */
+export type Result = 'win' | 'lose' | 'draw' | 'timeout';
+/** place / robot: a piece down; win / lose / draw: how a move ended it (a timeout is silent, as in the original game). */
+export type GameEvent = 'place' | 'robot' | 'win' | 'lose' | 'draw';
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    board: Board;
+    turn: Player;
+    result: Result | null;
+    finalScore: number;
+    line: readonly [number, number, number] | null;
+    /** The countdown lives in the engine (Rust), advanced by world.update. */
+    readonly timeLeft: number;
+    /** A finger down on a cell (shown as a ghost O until it lifts). */
+    press: number;
+    onPhase: (_p: Phase) => void;
+    onTurn: (_p: Player) => void;
+    onTime: (_t: number) => void;
+    onEvent: (_e: GameEvent) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** A finished game's score: the result's points, plus a bonus for the time left (a win's full, a draw's half). */
+export declare const scoreFor: (r: Result | null, timeLeft: number) => number;
+/** The game-over card's score. */
+export declare const shownScore: (g: {
+    result: Result | null;
+    finalScore: number;
+}) => number;
+/** 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;
+/** A fresh board, your move first. */
+export declare function start(g: Game): void;
+/** An empty 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;
+/** Your move on a cell, if it's your turn and the cell is empty; the robot answers after its think. */
+export declare function play(g: Game, i: number): void;
+/** The cell under a view point (on the board's surface), or -1. */
+export declare function cellUnder(g: Game, x: number, y: number): number;
+/** A finger down on an empty cell shows a ghost O there; lifting on the same cell plays it. */
+export declare function drag(g: Game, { phase, x, y }: DragEvent): void;

package/lib/typescript/src/games/tic-tac-toe/TicTacToeRules.d.ts

@@ -0,0 +1,10 @@
+export type Player = 'X' | 'O';
+export type Cell = Player | null;
+export type Board = Cell[];
+export declare const LINES: readonly [readonly [0, 1, 2], readonly [3, 4, 5], readonly [6, 7, 8], readonly [0, 3, 6], readonly [1, 4, 7], readonly [2, 5, 8], readonly [0, 4, 8], readonly [2, 4, 6]];
+export declare const emptyBoard: () => Board;
+/** The line three in a row, if there is one. */
+export declare function winningLine(b: Board): readonly [number, number, number] | null;
+export declare const winnerOf: (b: Board) => Player | null;
+/** A forgiving opponent that takes wins, sometimes misses blocks, and occasionally looks ahead. */
+export declare function robotMove(b: Board): number;

package/lib/typescript/src/games/tic-tac-toe/TicTacToeScene.d.ts

@@ -0,0 +1,26 @@
+import { type Entity, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './TicTacToeConstants';
+import type { Player } from './TicTacToeRules';
+export type Scene = {
+    backdrop: Entity;
+    /** The board's frame, well and surface, its cells and grid bars (rebuilt on a theme change). */
+    board: Entity[];
+    pieces: (Entity | null)[];
+    ghost: Entity;
+    line: Entity | null;
+};
+export declare function buildScene(world: World, l: Layout, theme: GameTheme, board: (Player | null)[]): Scene;
+export declare function removeScene(world: World, s: Scene): void;
+export declare function setSceneTheme(world: World, l: Layout, s: Scene, theme: GameTheme): void;
+/** A piece on a cell: it grows out of the cell with a little turn and settles (or is just there). */
+export declare function place(world: World, l: Layout, s: Scene, i: number, p: Player, animate?: boolean): void;
+/** A faint O over an empty cell while a finger rests on it. */
+export declare function showGhost(world: World, l: Layout, s: Scene, i: number): void;
+export declare function hideGhost(world: World, s: Scene): void;
+/** Three in a row: they turn gold and hop, and a gold bar is laid across them, glowing softly. */
+export declare function markWin(world: World, l: Layout, s: Scene, line: readonly [number, number, number]): void;
+/** A draw: every piece gives a little shrug. */
+export declare function shrug(world: World, l: Layout, s: Scene): void;
+/** A fresh board: the pieces lift off and fade, and the win bar goes. */
+export declare function clearPieces(world: World, s: Scene): void;

package/lib/typescript/src/games/tile-home/TileHome.d.ts

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

package/lib/typescript/src/games/tile-home/TileHomeConstants.d.ts

@@ -1,72 +1,74 @@
-export declare const TILE_HOME_COLORS: {
-    BACKGROUND: string;
-    PRIMARY: string;
-    TILE_BACKGROUND: string;
-    TILE_BORDER: string;
-    TILE_SHADOW: string;
-    SLOT_BACKGROUND: string;
-    SLOT_BORDER: string;
-    GRID_BACKGROUND: string;
+import type { FruitKind } from '../shared/EngineFruits';
+export declare const BOARD_COLS = 6;
+export declare const BOARD_ROWS = 7;
+export declare const LAYER_COUNT = 3;
+export declare const TILES_PER_TYPE = 6;
+export declare const SLOT_CAPACITY = 7;
+export declare const MATCH_COUNT = 3;
+export declare const TIME_LIMIT = 300;
+export declare const POINTS_PER_SET = 500;
+/** The 12 fruits, by tile type id (the original version's order), with each one's burst color. */
+export declare const TILE_TYPES: readonly {
+    fruit: FruitKind;
+    color: string;
+}[];
+/** Sets of three in a board: 24. */
+export declare const TOTAL_SETS: number;
+export declare const FLY_TIME = 0.25;
+export declare const LIFT_AT = 0.28;
+export declare const LIFT_SCALE = 1.08;
+export declare const MATCH_CHECK_DELAY = 0.3;
+export declare const MATCH_REMOVE_DELAY = 0.4;
+export declare const MATCH_BURST_TIME = 0.55;
+export declare const SHADE_TIME = 0.22;
+export declare const SHIFT_SPRING: {
+    stiffness: number;
+    damping: number;
 };
-export declare const TILE_TYPES: readonly [{
-    readonly id: 0;
-    readonly name: "apple";
-    readonly color: "#dc2626";
-}, {
-    readonly id: 1;
-    readonly name: "orange";
-    readonly color: "#f97316";
-}, {
-    readonly id: 2;
-    readonly name: "banana";
-    readonly color: "#fbbf24";
-}, {
-    readonly id: 3;
-    readonly name: "grapes";
-    readonly color: "#7c3aed";
-}, {
-    readonly id: 4;
-    readonly name: "kiwi";
-    readonly color: "#84cc16";
-}, {
-    readonly id: 5;
-    readonly name: "strawberry";
-    readonly color: "#ef4444";
-}, {
-    readonly id: 6;
-    readonly name: "mango";
-    readonly color: "#f59e0b";
-}, {
-    readonly id: 7;
-    readonly name: "cherries";
-    readonly color: "#be123c";
-}, {
-    readonly id: 8;
-    readonly name: "pineapple";
-    readonly color: "#eab308";
-}, {
-    readonly id: 9;
-    readonly name: "watermelon";
-    readonly color: "#22c55e";
-}, {
-    readonly id: 10;
-    readonly name: "peach";
-    readonly color: "#fda4af";
-}, {
-    readonly id: 11;
-    readonly name: "pomegranate";
-    readonly color: "#9f1239";
-}];
-export declare const TILE_HOME_GAME_CONFIG: {
-    BOARD_COLS: number;
-    BOARD_ROWS: number;
-    TILE_SIZE: number;
-    TILE_MARGIN: number;
-    BOARD_PADDING: number;
-    LAYER_OFFSET: number;
-    SLOT_CAPACITY: number;
-    MATCH_COUNT: number;
-    LAYER_COUNT: number;
-    TILES_PER_TYPE: number;
-    ANIMATION_DURATION: number;
+export declare const LAND_SPRING: {
+    stiffness: number;
+    damping: number;
 };
+export declare const LAND_SQUASH = 1.12;
+export declare const INTRO_SPRING: {
+    stiffness: number;
+    damping: number;
+    mass: number;
+};
+export declare const RIPPLE_TIME = 0.3;
+export declare const LAYER_STAGGER = 0.07;
+/** How dark a covered tile is: more tiles over it, darker. */
+export declare const shadeFor: (blockingCount: number) => number;
+export declare const LIGHT: import("@nayan-ui/engine").Light;
+export declare const TILE_FACE = "#fffdf7";
+export declare const TILE_THICKNESS = 0.4;
+export declare const CLASSIC_BOARD = "rgba(255, 255, 255, 0.35)";
+export declare const CLASSIC_TRAY = "rgba(255, 255, 255, 0.45)";
+export declare const CLASSIC_TRAY_BORDER = "rgba(255, 255, 255, 0.6)";
+export declare const CLASSIC_SLOT = "rgba(255, 255, 255, 0.25)";
+export declare const CLASSIC_SLOT_BORDER = "rgba(255, 255, 255, 0.5)";
+export type Layout = {
+    /** The GameView's size. */
+    width: number;
+    height: number;
+    boardLeft: number;
+    boardTop: number;
+    boardWidth: number;
+    boardHeight: number;
+    cell: number;
+    /** A board tile's side. */
+    tile: number;
+    /** The fruit's size on a board tile. */
+    fruit: number;
+    trayLeft: number;
+    trayTop: number;
+    trayWidth: number;
+    trayHeight: number;
+    /** A tray tile's side. */
+    slot: number;
+};
+export declare function getLayout(width: number, height: number, offset: number): Layout;
+/** A board tile's top-left, in view points. */
+export declare const tileOrigin: (l: Layout, col: number, row: number, layer: number) => [number, number];
+/** Tray slot `index`'s top-left, in view points. */
+export declare const slotOrigin: (l: Layout, index: number) => [number, number];

package/lib/typescript/src/games/tile-home/TileHomeGame.d.ts

@@ -0,0 +1,72 @@
+import { type Camera, type Entity, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import type { Fruit, FruitKind } from '../shared/EngineFruits';
+import { type Layout } from './TileHomeConstants';
+import { type FruitModels } from './TileHomeScene';
+export type Phase = 'ready' | 'playing' | 'over';
+type Tile = {
+    typeId: number;
+    col: number;
+    row: number;
+    layer: number;
+    /** Tiles on higher layers covering this one (0 = free to pick). */
+    blocking: number;
+    /** Lower tiles uncovered when this tile leaves the board (computed once per deal). */
+    covers: Tile[];
+    root: Entity | null;
+    shade: Entity | null;
+    /** Its fruit, once that model is built (the tile shows before it). */
+    fruit: Entity | null;
+    parts: Entity[];
+};
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    fruits: FruitModels;
+    scenery: Entity[];
+    phase: Phase;
+    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    won: boolean;
+    board: Tile[];
+    /** The tray, in order. */
+    slot: Tile[];
+    /** The tile on its way to the tray, and the slot it's headed for. */
+    flying: {
+        tile: Tile;
+        index: number;
+    } | null;
+    /** Tray tiles bursting, removed when the burst has shown. */
+    matching: Tile[];
+    /** The next board to appear plays the intro. */
+    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;
+    onPick: () => void;
+    onMatch: () => void;
+    onWin: () => void;
+    onLose: () => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/**
+ * One kind of fruit's model is ready (they're built once per app, one per frame after the screen
+ * opens): it pops onto every tile of that kind already showing, and is used for any made from now on.
+ */
+export declare function addFruit(g: Game, kind: FruitKind, fruit: Fruit): void;
+/** Lays the scene out for the view and header. Same tile size: everything just moves; else it's rebuilt. */
+export declare function setLayout(g: Game, l: Layout): void;
+/** A new theme: the background, board and tray are rebuilt; the tiles 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), springing in. The world and its GPU view 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;
+/** A tap: sends the uncovered tile under it to the tray. */
+export declare function tap(g: Game, x: number, y: number): void;
+export {};

package/lib/typescript/src/games/tile-home/TileHomeScene.d.ts

@@ -0,0 +1,28 @@
+import { type Entity, type Vec3, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import type { Fruit, FruitKind } from '../shared/EngineFruits';
+import { type Layout } from './TileHomeConstants';
+export declare const Z_BACKDROP = 1;
+export declare const Z_FLYING = 420;
+export declare const layerZ: (layer: number) => number;
+export declare const trayZ = 20;
+/** 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 type Scenery = Entity[];
+/** The background, the board panel and the tray with its empty slots, for a theme. */
+export declare function buildScenery(world: World, l: Layout, theme: GameTheme): Scenery;
+export type TileEntities = {
+    root: Entity;
+    shade: Entity;
+    fruit: Entity | null; /** Body and fruit, for the match flash. */
+    parts: Entity[];
+};
+/**
+ * A tile at view point (cx, cy) (its centre), depth z: body, fruit and a hidden shade. Without its
+ * fruit model yet (still being built), the tile shows straight away and the fruit is added later.
+ */
+export declare function spawnTile(world: World, l: Layout, fruit: Fruit | undefined, cx: number, cy: number, z: number, scale: number): TileEntities;
+/** Puts `fruit` on a tile's face (filling it, centred on its bounding box, a point above the middle like the original icon); `pop` springs it in. */
+export declare function addTileFruit(world: World, l: Layout, root: Entity, fruit: Fruit, pop: boolean): Entity;
+/** The fruit models built so far (they arrive one kind at a time). */
+export type FruitModels = Partial<Record<FruitKind, Fruit>>;

package/lib/typescript/src/games/treasure-hunt/TreasureHunt.d.ts

@@ -0,0 +1,3 @@
+import { type GameProps } from '../../services/UtilsService';
+/** Shared Playtura chrome and lifecycle around the imported explorer and procedural wilderness. */
+export declare const TreasureHunt: import("react").FC<GameProps>;

package/lib/typescript/src/games/treasure-hunt/TreasureHuntConstants.d.ts

@@ -0,0 +1,144 @@
+import { type Light, type SoundBank, type Texture } from '@nayan-ui/engine';
+import type { HumanAssets } from './TreasureHuntModel';
+/** Shared strike timing and offline skeletal choreography for the imported explorer. */
+export declare const HUMAN_PUNCH_TIME = 0.52;
+export declare const HUMAN_CONTACT_TIME = 0.16;
+export declare const HUMAN_GUARD_TIME = 1.15;
+type Vector = [number, number, number];
+interface HandTarget {
+    pos: Vector;
+    pole: Vector;
+    dir: Vector;
+    palm: Vector;
+}
+export interface CombatPose {
+    bones: Record<string, Vector>;
+    root: {
+        ground: boolean;
+    };
+    ik?: {
+        Left: HandTarget;
+        Right: HandTarget;
+    };
+    thumbs?: {
+        Left: number;
+        Right: number;
+    };
+    blend?: {
+        sample: CombatPose;
+        w: number;
+    };
+}
+interface CombatClip {
+    id: string;
+    name: string;
+    category: 'Actions';
+    duration: number;
+    loop: boolean;
+    sample(time: number): CombatPose;
+}
+/** Both hands share a planted stance. Only the striking shoulder, torso and arm change sides. */
+export declare function fightingPose(hand: 'Left' | 'Right' | null, time: number): CombatPose;
+export declare function createCombatClips(idle: {
+    sample(time: number): CombatPose;
+}): CombatClip[];
+export declare const HUMAN_HEIGHT: number;
+export declare const HUMAN_CAMERA_HEIGHT: number;
+export declare const HUMAN_CLIPS: {
+    idle: {
+        duration: number;
+        loop: boolean;
+    };
+    walk: {
+        duration: number;
+        loop: boolean;
+    };
+    run: {
+        duration: number;
+        loop: boolean;
+    };
+    punchStart: {
+        duration: number;
+        loop: boolean;
+    };
+    punchRight: {
+        duration: number;
+        loop: boolean;
+    };
+    punchLeft: {
+        duration: number;
+        loop: boolean;
+    };
+    combatIdle: {
+        duration: number;
+        loop: boolean;
+    };
+    combatExit: {
+        duration: number;
+        loop: boolean;
+    };
+    hit: {
+        duration: number;
+        loop: boolean;
+    };
+    fall: {
+        duration: number;
+        loop: boolean;
+    };
+    celebrate: {
+        duration: number;
+        loop: boolean;
+    };
+};
+export type HumanAnimation = keyof typeof HUMAN_CLIPS;
+export declare const HUMAN_CLIP_TIME: Record<HumanAnimation, number>;
+export declare const HUMAN_LOOPS: Set<"hit" | "idle" | "walk" | "run" | "punchStart" | "punchRight" | "punchLeft" | "combatIdle" | "combatExit" | "fall" | "celebrate">;
+/** Hysteresis stops tiny gesture changes from repeatedly switching walk and run. */
+export declare function locomotionAnimation(speed: number, previous?: HumanAnimation | null): 'idle' | 'walk' | 'run';
+/** A margin around cadence buckets prevents finger noise from repeatedly rebuilding native tracks. */
+export declare function locomotionRate(speed: number, previous?: number): number;
+export declare const WORLD_EDGE = 128;
+export declare const TERRAIN_PROFILES = 16;
+export declare const MINIMAP_SIZE = 124;
+export declare const MAX_HEALTH = 5;
+export declare const GEM_GOAL = 24;
+export declare const POINTS_GEM = 200;
+export declare const POINTS_ROBOT_HIT = 50;
+export declare const POINTS_ROBOT_DEFEAT = 300;
+export declare const POINTS_HEALTH_BONUS = 400;
+export declare const PLAYER_SPEED = 6;
+export declare const PLAYER_RADIUS = 0.5;
+export declare const MOVEMENT_START = 0.08;
+export declare const MOVEMENT_STOP = 0.04;
+export declare const ATTACK_RANGE = 1.9;
+export declare const ATTACK_COOLDOWN = 0.52;
+export declare const ATTACK_HIT_TIME = 0.16;
+export declare const ENEMY_COUNT = 8;
+export declare const SKY: readonly [0.62, 0.77, 0.86];
+export declare const NATURE_LIGHT: Light;
+export declare const NIGHT_SKY: readonly [0.07, 0.13, 0.2];
+export declare const NIGHT_LIGHT: Light;
+export interface Point {
+    x: number;
+    z: number;
+}
+export interface NatureAssets {
+    meadow: Texture;
+    stone: Texture;
+    bark: Texture;
+    pine: Texture;
+    leaves: Texture;
+    water: Texture;
+}
+export interface GameAssets extends NatureAssets {
+    human: HumanAssets;
+}
+type SoundName = 'gem' | 'punch' | 'impact' | 'defeat' | 'hurt' | 'win' | 'footstepWalk' | 'footstepRun';
+export declare let sounds: SoundBank<SoundName> | undefined;
+/** Use fulfilled prepared resources on the first render, without another loading frame. */
+export declare const getCachedAssets: () => GameAssets | null;
+/** Load native resources once; tuning and rules remain usable without a native renderer. */
+export declare function loadAssets(): Promise<GameAssets>;
+/** Start the explorer and terrain downloads together, without serial idle/network round trips. */
+export declare function warmAssets(): Iterable<() => unknown>;
+export {};