@nayan-ui/games 1.19.0 → 1.20.0

package/lib/typescript/src/games/reversi/ReversiConstants.d.ts

@@ -1,66 +1,35 @@
-export declare const BOARD_N = 8;
-export declare const BOARD_3D: {
-    readonly PADDING: 12 | 9;
-    readonly DEPTH: 12 | 9;
-    readonly RADIUS: 14 | 18;
-    readonly TOP: "#0f3d24";
-    readonly FRONT: "#0a2c1a";
-    readonly INNER: "#0a3520";
-    readonly HIGHLIGHT: "#2e6b48";
-};
-export declare const CELL: number;
-export declare const INNER_SIZE: number;
-export declare const BOARD_OUTER_W: number;
-export declare const BOARD_OUTER_H: number;
-export declare const PIECE_RADIUS: number;
-export declare const REVERSI_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
+import type { TiltView } from '../shared/EngineTilt';
+export declare const GAME_DURATION = 300;
+export declare const POINTS_PER_FLIP = 200;
+export declare const WIN_BONUS = 5000;
+export declare const AI_DELAY = 0.5;
+export declare const TAP_SLOP = 12;
+export declare const FLIP_TIME = 0.24;
+export declare const RIPPLE = 0.07;
+export declare const PLACE_LEAD = 0.09;
+export declare const COLORS: {
     readonly FELT: "#1F7A46";
-    readonly GRID: "rgba(0,0,0,0.35)";
-    readonly STAR: "rgba(0,0,0,0.55)";
-    readonly HINT_RING: "rgba(255,255,255,0.75)";
+    readonly BOARD_BORDER: "#0F3D24";
+    readonly GRID: "#155a33";
+    readonly STAR: "#0d3b21";
+    readonly HINT: "rgba(255,255,255,0.75)";
     readonly LAST_MOVE: "rgba(255,213,79,0.9)";
+    readonly BLACK: "#2A2A2A";
+    readonly WHITE: "#F2F2F2";
 };
-export declare const BLACK_3D: {
-    readonly top: string;
-    readonly bottom: string;
-    readonly rim: "#000000";
-    readonly highlight: string;
-    readonly shadow: "rgba(0,0,0,0.5)";
-};
-export declare const WHITE_3D: {
-    readonly top: "#FFFFFF";
-    readonly bottom: string;
-    readonly rim: string;
-    readonly highlight: "#FFFFFF";
-    readonly shadow: "rgba(0,0,0,0.4)";
-};
-export declare const REVERSI_CONFIG: {
-    readonly BOARD_N: 8;
-    readonly GAME_DURATION: 240;
-    readonly POINTS_PER_FLIP: 200;
-    readonly WIN_BONUS: 5000;
-    readonly AI_MOVE_DELAY: 500;
-    readonly AI_DEPTH: 2;
-    readonly AI_RANDOM_MOVE_CHANCE: 0.2;
-    readonly AI_SCORE_MARGIN: 12;
-};
-export type ReversiPlayer = 'black' | 'white';
-export interface Disc {
-    player: ReversiPlayer;
-}
-export type Cell = Disc | null;
-export type ReversiBoard = Cell[];
-export interface Move {
-    index: number;
-    flips: number[];
-}
-export declare const rc: (index: number) => {
-    row: number;
-    col: number;
+/** Directly overhead, like Checkers: a flat board with only the discs raised in 3D. */
+export declare const TILT = 0;
+export declare const BOARD_BORDER_WIDTH = 3;
+export declare const BOARD_SURFACE = 0.2;
+/** Lit from the upper left; surfaces facing up off the board (+z) keep their exact color. */
+export declare const LIGHT: import("@nayan-ui/engine").Light;
+export type Layout = TiltView & {
+    cell: number;
+    size: number;
 };
-export declare const idx: (row: number, col: number) => number;
-export declare const inBounds: (row: number, col: number) => boolean;
-export declare const DIRECTIONS: ReadonlyArray<readonly [number, number]>;
-export declare const WEIGHTS: ReadonlyArray<number>;
+/** Use Checkers' centered board sizing, reserving space for the thin outer border. */
+export declare function getLayout(width: number, height: number, offset: number): Layout;
+/** A cell's centre (row 0 along the top), in world units. */
+export declare const cellCentre: (l: Layout, index: 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/reversi/ReversiGame.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 './ReversiConstants';
+import { type Player } from './ReversiRules';
+import { type Scene } from './ReversiScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** place / robot: a disc down; invalid: a tap off the legal moves; pass: a side couldn't move; win / lose: how it ended (a timeout is silent). */
+export type GameEvent = 'place' | 'robot' | 'invalid' | 'pass' | 'win' | 'lose';
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    board: import("./ReversiRules").Board;
+    turn: Player;
+    /** Your legal moves (shown as rings; none on the robot's turn). */
+    hints: number[];
+    last: number;
+    winner: Player | null;
+    timedOut: boolean;
+    black: number;
+    white: number;
+    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    readonly timeLeft: number;
+    press: {
+        x: number;
+        y: number;
+    } | null;
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onCounts: (_black: number, _white: number) => void;
+    onTurn: (_p: Player) => void;
+    onTime: (_t: number) => void;
+    onEvent: (_e: GameEvent) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the board out for the view (first layout, header height, rotation): rebuilt where things stand. */
+export declare function setLayout(g: Game, l: Layout): void;
+export declare function setTheme(g: Game, theme: GameTheme): void;
+/** A fresh board, your move. */
+export declare function start(g: Game): void;
+/** The opening 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: a legal one is played, anything else just buzzes. */
+export declare function select(g: Game, index: number): void;
+/** The cell under a view point (on the felt), or -1. */
+export declare function cellUnder(g: Game, x: number, y: number): number;
+/** A tap (a finger down and up without wandering) on a cell. */
+export declare function drag(g: Game, { phase, x, y }: DragEvent): void;

package/lib/typescript/src/games/reversi/ReversiRules.d.ts

@@ -0,0 +1,22 @@
+export declare const N = 8;
+export type Player = 'black' | 'white';
+export type Board = (Player | null)[];
+export type Move = {
+    index: number;
+    flips: number[];
+};
+/** You play black and move first; the robot plays white. */
+export declare const HUMAN: Player;
+export declare const AI: Player;
+export declare const opponent: (p: Player) => Player;
+export declare function initialBoard(): Board;
+/** The discs a move at `index` would flip (none: not a legal move). */
+export declare function flipsFor(b: Board, index: number, player: Player): number[];
+export declare function validMoves(b: Board, player: Player): Move[];
+export declare function applyMove(b: Board, m: Move, player: Player): Board;
+export declare function counts(b: Board): {
+    black: number;
+    white: number;
+};
+/** The robot's move: now and then a random one, otherwise a random pick among those near the best. */
+export declare function chooseAIMove(b: Board): Move | null;

package/lib/typescript/src/games/reversi/ReversiScene.d.ts

@@ -0,0 +1,27 @@
+import { type Entity, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './ReversiConstants';
+import type { Board, Player } from './ReversiRules';
+export type Scene = {
+    backdrop: Entity;
+    /** The felt, grid and star points (the same in every theme). */
+    felt: Entity[];
+    discs: (Entity | null)[];
+    hints: Entity[];
+    last: Entity;
+};
+export declare function buildScene(world: World, l: Layout, theme: GameTheme, board: Board, hints: number[], last: number): Scene;
+export declare function removeScene(world: World, s: Scene): void;
+export declare function setSceneTheme(world: World, s: Scene, theme: GameTheme): void;
+/** A disc set down on a cell: it drops on and settles (or is just there). */
+export declare function placeDisc(world: World, l: Layout, s: Scene, i: number, p: Player, animate?: boolean): void;
+/** Captured discs turn over to `p`, a ring at a time outward from the placed disc at `from`. */
+export declare function flipDiscs(world: World, l: Layout, s: Scene, from: number, flips: number[], p: Player): void;
+/** A ring on every legal move. */
+export declare function showHints(world: World, l: Layout, s: Scene, hints: number[]): void;
+/** The gold outline on the last move (-1: none). */
+export declare function showLast(world: World, l: Layout, s: Scene, last: number): void;
+/** A tap on a cell that isn't a legal move: the cell's disc (if any) shrugs. */
+export declare function nudge(world: World, l: Layout, s: Scene, i: number): void;
+/** You won: your discs hop in a wave and confetti bursts over the board. */
+export declare function celebrate(world: World, l: Layout, s: Scene, board: Board): void;

package/lib/typescript/src/games/search-grid/SearchGrid.d.ts

@@ -0,0 +1,20 @@
+import type React from 'react';
+import type { SoundConfig } from '../../services/SoundsService';
+import type { GAME_IDS, GameProps } from '../../services/UtilsService';
+import { type Content } from './SearchGridGame';
+export type SearchGameConfig = Content & {
+    gameId: GAME_IDS;
+    sounds: {
+        START: SoundConfig;
+        FOUND: SoundConfig;
+        WIN: SoundConfig;
+        GAME_OVER: SoundConfig;
+    };
+    /** 'ALL WORDS FOUND!', 'Great word hunting!', 'Find hidden words!' */
+    winTitle: string;
+    winMessage: string;
+    startSubtext: string;
+    variant: 'word' | 'number';
+    displayName: string;
+};
+export declare function createSearchGame(config: SearchGameConfig): React.FC<GameProps>;

package/lib/typescript/src/games/search-grid/SearchGridConstants.d.ts

@@ -0,0 +1,60 @@
+import type { TiltView } from '../shared/EngineTilt';
+export declare const GRID_SIZE = 10;
+export declare const ITEMS = 8;
+export declare const TIME_LIMIT = 300;
+export declare const FIND_POINTS = 1000;
+export type Cell = {
+    row: number;
+    col: number;
+};
+export type Placed = {
+    text: string;
+    cells: Cell[];
+};
+/**
+ * A fresh grid: `ITEMS` entries from `list` placed in random directions (each tries the directions,
+ * then the positions, in a random order, and may cross another where the characters agree), the rest
+ * filled from `alphabet`.
+ */
+export declare function generate(list: readonly string[], alphabet: string): {
+    grid: string[][];
+    placed: Placed[];
+};
+/** The cells from one to another along a row, column or diagonal; none if they're not on one line. */
+export declare function lineCells(from: Cell, to: Cell): Cell[];
+/**
+ * The not-yet-found entry the selected cells spell exactly (either way along the line), if any. Any line
+ * spelling it counts, not only where it was hidden: with few characters (Number Search's ten digits) an
+ * entry often turns up again by chance, and finding that copy is just as right.
+ */
+export declare function matchOf(cells: Cell[], grid: string[][], placed: Placed[], found: ReadonlySet<string>): Placed | null;
+/** One per entry, by its place in the list: its found highlight and its chip. */
+export declare const HIGHLIGHT_COLORS: string[];
+export declare const SELECTION_COLOR = "rgba(77, 166, 255, 0.85)";
+export declare const TILE_COLOR = "#FFFFFF";
+export declare const INK_COLOR = "#333333";
+export declare const CLASSIC_BOARD = "rgba(255, 255, 255, 0.3)";
+/** The camera leans back from straight down, so the tiles and the lettering stand up off the board. */
+export declare const TILT = 0.3;
+/** 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 declare const SELECT_TIME = 0.12;
+export declare const FIND_TIME = 0.32;
+/** Room above the board for the list of entries to find. */
+export declare const LIST_HEIGHT = 52;
+export type Layout = TiltView & {
+    boardSize: number;
+    cell: number;
+    padding: number;
+    /** Height of the tiles' top faces. */
+    tileTop: number;
+    /** Where the list goes (view points, from the top). */
+    listTop: number;
+    listWidth: number;
+};
+/** The board as wide as the game area (as the original board), the list above it, both centred under the scoreboard. */
+export declare function getLayout(width: number, height: number, offset: number): Layout;
+/** A cell's centre on the board (row 0 along the top), in world units. */
+export declare function cellCentre(l: Layout, row: number, col: number): [number, number];
+/** The cell under a board point (world units), or null off the grid. */
+export declare function cellAt(l: Layout, x: number, y: number): Cell | null;

package/lib/typescript/src/games/search-grid/SearchGridGame.d.ts

@@ -0,0 +1,52 @@
+import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Cell, type Layout, type Placed } from './SearchGridConstants';
+import { type Scene } from './SearchGridScene';
+export type Phase = 'ready' | 'playing' | 'over';
+export type Content = {
+    list: readonly string[];
+    alphabet: string;
+};
+export declare function createGame(theme: GameTheme, content: Content): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    content: Content;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    grid: string[][];
+    placed: Placed[];
+    found: Set<string>;
+    /** The line being dragged: its first cell and where it ends now. */
+    start: Cell | null;
+    end: Cell | null;
+    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    readonly timeLeft: number;
+    won: boolean;
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onTime: (_t: number) => void;
+    /** A new grid's entries, in placement order (their colors follow it). */
+    onEntries: (_entries: string[]) => void;
+    onFound: (_found: ReadonlySet<string>) => void;
+    /** One more entry found (its sound and haptic), then `onWin` if it was the last. */
+    onFind: () => void;
+    onWin: () => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the scene out for the view (first layout, header height, rotation): rebuilt from the game's state. */
+export declare function setLayout(g: Game, l: Layout): void;
+export declare function setTheme(g: Game, theme: GameTheme): void;
+/** Plays the grid that's showing. */
+export declare function start(g: Game): void;
+/** A fresh grid, not started (Stop, Play Again). The world, and the GPU view drawing it, are kept. */
+export declare function reset(g: Game): void;
+export declare const entries: (g: Game) => string[];
+export declare function dispose(g: Game): void;
+export declare function tick(g: Game, dt: number): void;
+/** The cell under a view point, as seen on the tiles' tops. */
+export declare function cellUnder(g: Game, x: number, y: number): Cell | null;
+/** Start a line on the cell under the finger, stretch it along a row, column or diagonal, check it on release. */
+export declare function drag(g: Game, { phase, x, y }: DragEvent): void;

package/lib/typescript/src/games/search-grid/SearchGridScene.d.ts

@@ -0,0 +1,43 @@
+import { type Entity, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import type { EngineHud } from '../shared/EngineHud';
+import { type Cell, type Layout } from './SearchGridConstants';
+/** A pill: its middle and two round ends. */
+export type Pill = [Entity, Entity, Entity];
+/** The live selection's ends: where they're drawn now and where they're heading (world x, y). */
+type Ends = {
+    ax: number;
+    ay: number;
+    bx: number;
+    by: number;
+    tax: number;
+    tay: number;
+    tbx: number;
+    tby: number;
+    on: boolean;
+};
+export type Scene = {
+    backdrop: Entity;
+    panel: Entity;
+    tiles: Entity[];
+    glyphs: Entity[];
+    selection: Pill;
+    ends: Ends;
+    found: Pill[];
+};
+export declare function buildScene(world: World, l: Layout, theme: GameTheme, grid: string[][]): Scene;
+/** A new grid's characters on the same tiles. */
+export declare function relabel(world: World, l: Layout, s: Scene, grid: string[][]): void;
+export declare function removeScene(world: World, s: Scene): void;
+export declare function setSceneTheme(world: World, l: Layout, s: Scene, theme: GameTheme): void;
+/** The live selection, from its first cell to where the finger is now: `fresh` snaps it there, else it glides (followSelection). */
+export declare function showSelection(world: World, l: Layout, s: Scene, from: Cell, to: Cell, fresh: boolean): void;
+/** Eases the live selection's ends toward their targets each frame (frame-rate independent), redrawing it only while it moves. */
+export declare function followSelection(world: World, l: Layout, s: Scene, dt: number): void;
+export declare function hideSelection(world: World, s: Scene): void;
+/** A found entry: circled in its color, its tiles bouncing one after another, a few sparkles. */
+export declare function markFound(world: World, l: Layout, s: Scene, cells: Cell[], colorIndex: number, animate: boolean): void;
+/** Confetti over the board when everything's found. */
+export declare function celebrate(world: World, l: Layout): void;
+export declare function drawEntryList(hud: EngineHud, entries: readonly string[], found: ReadonlySet<string>, layout: Layout): void;
+export {};

package/lib/typescript/src/games/shared/BackdropCard.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const BackdropCard: React.MemoExoticComponent<() => React.JSX.Element>;

package/lib/typescript/src/games/shared/EngineBackdrop.d.ts

@@ -0,0 +1,19 @@
+import { type Entity, type Model, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+/** Any front light works: these flat meshes face the camera, which it lights at exactly 1. */
+export declare const BACKDROP_LIGHT: import("@nayan-ui/engine").Light;
+/** The background mesh in pattern space: x right, y up from the window's top-left (y runs to -height). */
+export declare function backdropMesh(theme: GameTheme): Model;
+/**
+ * A modal card's background: the window pattern's top-left `width` x `height` (its gradients and
+ * shapes, without the grid lines), cut to a rounded rectangle of corner `radius`. Same space as
+ * `backdropMesh` (from the top-left, y up).
+ */
+export declare function cardBackdropMesh(theme: GameTheme, width: number, height: number, radius: number): Model;
+/**
+ * The background behind a centred, one-unit-per-point scene `width` x `height` (the view's size), at
+ * depth `z`: the pattern starts at the view's top-left, as the original screens draw it.
+ */
+export declare function spawnBackdrop(world: World, width: number, height: number, z: number, theme: GameTheme): Entity;
+/** Repaints a backdrop for a new theme. */
+export declare function setBackdropTheme(world: World, backdrop: Entity, theme: GameTheme): void;

package/lib/typescript/src/games/shared/EngineBlasts.d.ts

@@ -0,0 +1,26 @@
+import { type Color, type Entity, type PopOptions, type Quat, type Vec3, type World } from '@nayan-ui/engine';
+export type PopBurstOptions = {
+    /** Where the beads fly out from (a little in front of the piece reads best). */
+    position: Vec3;
+    /** The piece's size across, which the burst scales with. */
+    size: number;
+    /** The piece's color. */
+    color: Color;
+    /** Depth of the glow (behind the piece, in front of the board). Default the burst's own depth. */
+    glowZ?: number;
+    /** Beads and glints, about. Default 8. */
+    count?: number;
+};
+/** Bright beads and glints in the piece's color and white, over a glow that swells and fades behind it. */
+export declare function popBurst(world: World, o: PopBurstOptions): void;
+/** Both: the piece pops away and bursts as it swells. Resolves when it's gone (despawning it is the caller's). */
+export declare function popAndBurst(world: World, entity: Entity, pop: PopOptions, burst: PopBurstOptions): Promise<void>;
+/** A baton catch: a full-body pop, expanding ring, colorful splinters and two tip sprays. */
+export declare function stickBlast(world: World, entity: Entity, o: {
+    position: Vec3;
+    rotation: Quat;
+    scale: Vec3;
+    color: Color;
+}): Promise<void>;
+/** Reusable assets; the game loader advances one builder per frame. */
+export declare function warmAssets(): Iterable<() => unknown>;

package/lib/typescript/src/games/shared/EngineBlocks.d.ts

@@ -0,0 +1,19 @@
+import { type Color, type Entity, type Vec3, type World } from '@nayan-ui/engine';
+/** The scale that makes a block `size` (width, height, depth): for animating one back to full size (pops, grow-ins). */
+export declare const raisedBlockScale: (size: Vec3) => Vec3;
+export type BlockOptions = {
+    /** The block's centre. */
+    position: Vec3;
+    /** Width, height and depth. */
+    size: Vec3;
+    color: Color;
+    parent?: Entity;
+    /** The block's scale as a fraction of `size` (0 to grow it in). Default 1. */
+    grow?: number;
+    /** A glossy finish (else matte). Default true. */
+    gloss?: boolean;
+    /** Its soft shadow on the board. Default true. */
+    shadow?: boolean;
+};
+/** A block and its shadow; the block is returned (scale, move, tint and despawn it as one). */
+export declare function spawnRaisedBlock(world: World, { position, size, color, parent, grow, gloss, shadow }: BlockOptions): Entity;

package/lib/typescript/src/games/shared/EngineControlText.d.ts

@@ -0,0 +1,2 @@
+/** Fit a short control subtitle into its measured inner width without splitting Unicode code points. */
+export declare function fitControlSubtitle(text: string, maxWidth: number, measure: (value: string) => number): string;

package/lib/typescript/src/games/shared/EngineDice.d.ts

@@ -0,0 +1,24 @@
+import { type Entity, type Model, type Quat, type Vec3, type World } from '@nayan-ui/engine';
+/** The die, one unit across, centred. Made once per app. */
+export declare function dieMesh(): Model;
+/** The die showing `value` toward a camera leaning back by `tilt`, turned `twist` round its up axis. */
+export declare const dieRotation: (tilt: number, value: number, twist?: number) => Quat;
+export type DieRoll = {
+    die: Entity;
+    shadow: Entity;
+    /** Where the die rests (its centre), and its shadow's place and size there. */
+    rest: Vec3;
+    shadowAt: Vec3;
+    shadowScale: Vec3;
+    /** The die's edge, in world units. */
+    size: number;
+    /** The camera's lean (the rolled face ends up facing it). */
+    tilt: number;
+    value: number;
+    /** Seconds, from the toss to the die at rest. */
+    duration: number;
+    /** For delayed effects (the landing dust): whether the scene is gone. */
+    disposed?: () => boolean;
+};
+/** Rolls the die to `value`: tossed up, tumbling, bouncing to rest on its spot showing `value`. */
+export declare function rollDie(world: World, r: DieRoll): void;

package/lib/typescript/src/games/shared/EngineFootprint.d.ts

@@ -0,0 +1,17 @@
+/** A vehicle's outline from above: its length, and its half width at each point along it (model z, front at -length / 2). */
+export type Footprint = {
+    length: number;
+    halfWidth: (z: number) => number;
+};
+/**
+ * How far two footprints overlap sideways (> 0 when they touch): `b` is `ahead` metres in front of
+ * `a` along the road and `gap` across it, both facing down the road. Sampled along the stretch where
+ * they overlap lengthways; -Infinity when they don't.
+ */
+export declare function overlapAcross(a: Footprint, b: Footprint, ahead: number, gap: number, samples?: number): number;
+/**
+ * Whether a contact that just began was nose to tail (a front hit) rather than side by side: they were
+ * still (almost) clear lengthways a frame ago. `wasAhead` and `ahead` are the gap along the road then
+ * and now. Allows for how far they closed in the frame and for tapered noses and tails.
+ */
+export declare function frontHit(a: Footprint, b: Footprint, wasAhead: number, ahead: number, taper?: number): boolean;

package/lib/typescript/src/games/shared/EngineFruits.d.ts

@@ -0,0 +1,27 @@
+import { type Color, type Model, type Vec3 } from '@nayan-ui/engine';
+export type FruitKind = 'apple' | 'orange' | 'lemon' | 'pear' | 'strawberry' | 'watermelon' | 'banana' | 'cherries' | 'grapes' | 'kiwi' | 'mango' | 'peach' | 'pineapple' | 'pomegranate' | 'papaya';
+export type Fruit = {
+    whole: Model;
+    /** The left and right pieces after a slice. */
+    pieces: [Model, Model];
+    /** Color of its juice (for splashes). */
+    juice: Color;
+    /** Centre of the whole fruit's bounding box (stems and leaves included), in its own units. */
+    center: Vec3;
+};
+/**
+ * One fruit, built on first use (mesh ids last for the whole app). Needs the native core.
+ * `level` < 1 builds a lighter mesh for fruit shown small (0.35 still looks round at 60 points).
+ */
+export declare function getFruit(kind: FruitKind, level?: number): Fruit;
+/** Whether `kind` is cached at `level`, including its sliced models when `withSlices` is true. */
+export declare const isFruitBuilt: (kind: FruitKind, level?: number, withSlices?: boolean) => boolean;
+/**
+ * Builds `kinds` one per frame, so the screen keeps animating while they're made, then calls `done`.
+ * Already built fruit cost nothing. Returns a cancel function.
+ */
+export declare function loadFruits(kinds: readonly FruitKind[], done: () => void, level?: number): () => void;
+/** Every fruit, built once (mesh ids last for the whole app). Needs the native core. */
+export declare function getFruits(): Record<FruitKind, Fruit>;
+/** Whole bodies and cut pieces are separate jobs; board games never build unused slices. */
+export declare function warmAssets(kinds: readonly FruitKind[], level: number, pieces?: boolean): Iterable<() => unknown>;

package/lib/typescript/src/games/shared/EngineGameLoader.d.ts

@@ -0,0 +1,4 @@
+import { type ComponentType } from 'react';
+import { type GAME_IDS, type GameProps } from '../../services/UtilsService';
+/** The game module and its world are evaluated after the native loading animation is visible. */
+export declare function withGameLoading(id: GAME_IDS, load: () => ComponentType<GameProps>): ComponentType<GameProps>;

package/lib/typescript/src/games/shared/EngineGameScreen.d.ts

@@ -0,0 +1,48 @@
+import React from 'react';
+import { GameView } from '@nayan-ui/engine';
+import { type GAME_IDS, type GameProps } from '../../services/UtilsService';
+import { EngineHud, type GameOverCard, type HudChoice, type HudColumn, type HudFeedback } from './EngineHud';
+/** Everything GameView takes, but the HUD's overlay and the frame hooks this screen owns. */
+type SceneProps = Omit<React.ComponentProps<typeof GameView>, 'overlay' | 'onOverlayTouch' | 'onUpdate' | 'onStats' | 'background' | 'source'> & {
+    /** What to draw; null until the game has made its world (the view waits for it). */
+    source: React.ComponentProps<typeof GameView>['source'] | null;
+    /** The clear color; the theme's background by default. */
+    background?: React.ComponentProps<typeof GameView>['background'];
+};
+export type EngineGameScreenProps = SceneProps & Pick<GameProps, 'settings' | 'onSettingsChange' | 'onShare' | 'onShowLeaderboard' | 'bannerAd'> & {
+    gameId: string;
+    /** Reserve overlay entities for dense engine-drawn interfaces. */
+    hudCapacity?: number;
+    /** Host fallback when the rendering surface reports an error. */
+    errorMessage?: string;
+    /** Transient game feedback rendered and animated by the engine HUD. */
+    feedback?: HudFeedback;
+    choices?: HudChoice[];
+    /** Suspend/resume a game-owned audio loop with app activity, pause and sound settings. */
+    onAudioChange?: (audible: boolean) => void;
+    onActiveChange?: (active: boolean) => void;
+    /** Called every frame before the HUD animates (the game's tick). */
+    onUpdate?: (dt: number, hud: EngineHud) => void;
+    /** The view's size and the header offset, whenever they change: lay the scene out for them. */
+    onResize?: (width: number, height: number, offset: number) => number | void;
+    /** The scoreboard's columns. */
+    columns: HudColumn[];
+    playing: boolean;
+    /** The line under the controls while playing. */
+    subtext?: string;
+    onStart: () => void;
+    onStop: () => void;
+    /** The game-over card, or null while there's none. Android back plays again on it. */
+    gameOver: GameOverCard | null;
+    /** React Native views over the scene (under the settings modal). */
+    children?: React.ReactNode;
+};
+export declare const EngineGameScreen: React.FC<EngineGameScreenProps>;
+/**
+ * Makes an engine game's component: memoised, with default settings, inside the game theme and a
+ * container and the selected game's loader while the engine warms up.
+ */
+export declare function engineGame(id: GAME_IDS, Game: React.FC<GameProps & {
+    settings: NonNullable<GameProps['settings']>;
+}>): React.FC<GameProps>;
+export {};

package/lib/typescript/src/games/shared/EngineGameWidth.d.ts

@@ -0,0 +1,3 @@
+/** Native boards retain the established game width. */
+export declare const MAX_GAME_WIDTH = 500;
+export declare const gameWidthFor: (viewWidth: number) => number;

package/lib/typescript/src/games/shared/EngineGameWidth.web.d.ts

@@ -0,0 +1,3 @@
+/** Keep browser boards compact, with room around raised pieces and the shared HUD. */
+export declare const MAX_GAME_WIDTH = 420;
+export declare const gameWidthFor: (viewWidth: number) => number;

package/lib/typescript/src/games/shared/EngineGlyphs.d.ts

@@ -0,0 +1,15 @@
+import { type Model } from '@nayan-ui/engine';
+/** A stroke's tube radius, and the space a character takes in a run of text (both in glyph heights). */
+export declare const GLYPH_RADIUS = 0.1;
+export declare const GLYPH_ADVANCE = 0.72;
+export declare const GLYPH_WIDTH = 0.6;
+/** Whether a character has a glyph. */
+export declare const hasGlyph: (char: string) => boolean;
+/** A character's mesh, one glyph height tall at scale 1 (spawn it with `scale` = the height you want). */
+export declare function glyphMesh(char: string): Model;
+/**
+ * A character printed flat and matte (numbers on a board, not standing up): the glyph pressed to a
+ * twentieth of its depth, with no highlight, so it reads evenly everywhere on a flat surface. `weight`
+ * thickens its strokes (1 is the usual; bolder reads better small).
+ */
+export declare function flatGlyphMesh(char: string, weight?: number): Model;