@nayan-ui/games 1.19.0 → 1.20.0

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

@@ -0,0 +1,138 @@
+import { type Color, type Entity, type Font, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+/** A scoreboard column: text (optionally colored), or `lives` drawn as hearts. */
+export type HudColumn = {
+    label: string;
+    value: string;
+    color?: string;
+    valueColor?: string;
+    lives?: {
+        count: number;
+        max: number;
+    };
+};
+/** Top edge of the scoreboard; `offset` is the height of the host app's header, 0 when there is none. */
+export declare const getScoreBoardTop: (offset?: number) => number;
+/** Insets for a React touch surface over the scene, leaving the native HUD's controls reachable. */
+export declare const getSceneInputInsets: (offset?: number) => {
+    top: number;
+    bottom: number;
+};
+/** The usual columns. */
+export declare const scoreColumn: (score: number, label?: string, format?: (n: number) => string) => HudColumn;
+/** Time as m:ss, red at or under `lowAt` seconds (0: only at zero). */
+export declare const timerColumn: (seconds: number, theme: GameTheme, lowAt?: number, label?: string) => HudColumn;
+export declare const livesColumn: (count: number, max: number, label?: string) => HudColumn;
+export declare const textColumn: (label: string, value: string | number, color?: string) => HudColumn;
+export type HudButton = 'main' | 'leaderboard' | 'share' | 'choice';
+export type HudActions = {
+    onStart: () => void;
+    onStop: () => void;
+    onShare?: () => void;
+    onShowLeaderboard?: () => void;
+};
+export type GameOverCard = {
+    title: string;
+    message?: string;
+    scoreLabel: string;
+    score: number;
+    formatter?: (score: number) => string;
+    buttonText: string;
+    onPlayAgain: () => void;
+    onShare?: () => void;
+};
+export interface HudChoice {
+    id: string;
+    label: string;
+    selected?: boolean;
+    onPress: () => void;
+}
+/** Events coalesce until the next engine frame; consuming them never triggers a React render. */
+export interface HudFeedback {
+    flash?: boolean;
+    message?: string;
+}
+type Fonts = {
+    semi: Font;
+    regular: Font;
+};
+/** Inter SemiBold for all HUD text, flat (depth 0) like normal text: loaded once per app. */
+export declare function loadHudFonts(): Promise<Fonts>;
+/** The engine-drawn scoreboard and controls. Feed it state; pass `world` as GameView's `overlay`. */
+export declare class EngineHud {
+    readonly world: World;
+    private theme;
+    private size;
+    private columns;
+    private playing;
+    private subtext;
+    private actions;
+    private board;
+    private controls;
+    private values;
+    private buttons;
+    private pressed;
+    private over;
+    private overReserve;
+    private disposed;
+    private feedback;
+    private waiting;
+    private layers;
+    private choices;
+    private choiceRoot;
+    private choiceButtons;
+    private choicePage;
+    get ready(): boolean;
+    get viewport(): {
+        width: number;
+        height: number;
+        offset: number;
+    };
+    layer(key: string): Entity;
+    clearLayer(key: string): void;
+    text(parent: Entity, text: string, x: number, y: number, size: number, color: Color): Entity;
+    rectangle(parent: Entity, x: number, y: number, width: number, height: number, color: Color, z?: number): Entity;
+    setChoices(choices: HudChoice[]): void;
+    private buildChoices;
+    constructor(theme: GameTheme, capacity?: number);
+    setActions(actions: HudActions): void;
+    layout(width: number, height: number, offset: number): void;
+    setTheme(theme: GameTheme): void;
+    /** The scoreboard's columns; only values that changed are redrawn. */
+    setColumns(columns: HudColumn[]): void;
+    setPlaying(playing: boolean, subtext?: string): void;
+    update(dt: number, feedback?: HudFeedback): void;
+    private showFeedback;
+    private layoutFeedback;
+    private clearFeedback;
+    /** Shows the game-over card over everything (it takes every touch until hidden). */
+    showGameOver(card: GameOverCard): void;
+    hideGameOver(): void;
+    /** Where an RN banner ad sits under the card's buttons (null: no card). */
+    get gameOverBanner(): {
+        top: number;
+        width: number;
+    } | null;
+    /** Room left in the card for the banner ad (its measured height), in points. */
+    setGameOverReserve(height: number): void;
+    /** GameView's onOverlayTouch: true when a button took the touch. */
+    touch: (phase: "start" | "move" | "end" | "cancel", x: number, y: number) => boolean;
+    dispose(): void;
+    private release;
+    private pulse;
+    private fire;
+    /** A themed button panel (border behind the face) under a root at its centre. */
+    private panel;
+    private setOverScore;
+    /** The card, laid out top to bottom as GameOverModal; `animate` plays its entrance. */
+    private buildOver;
+    private buildBoard;
+    /** The same primary control for keyboard input, including the results card. */
+    activatePrimary(): void;
+    /** A column's value: its text, or a row of hearts. */
+    private spawnValue;
+    private buildControls;
+}
+/** Reusable assets; the game loader advances one builder per frame. */
+export declare function warmAssets(): Iterable<() => unknown>;
+export {};

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

@@ -0,0 +1,77 @@
+import { type Camera, type Font, World } from '@nayan-ui/engine';
+import { GAME_IDS, type GameThemeMode } from '../../services/UtilsService';
+export type LoadingScene = 'forest' | 'penguin' | 'car' | 'bike' | 'ninja' | 'merger' | 'tiles' | 'tua' | 'chameleon' | 'paper' | 'crossing';
+export interface LoadingColours {
+    sky: string;
+    horizon: string;
+    ground: string;
+    accent: string;
+    second: string;
+    text: string;
+    muted: string;
+}
+interface Look {
+    scene: LoadingScene;
+    tag: string;
+    message: string;
+    dark: LoadingColours;
+    light: LoadingColours;
+}
+export declare function loadingLook(gameId: GAME_IDS, mode?: GameThemeMode): Look & {
+    colours: LoadingColours;
+};
+export declare const LOADING_LIGHT: import("@nayan-ui/engine").Light;
+export declare function loadingPlacement(width: number, height: number, offset?: number): {
+    scale: number;
+    top: number;
+    retryBounds: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+};
+export interface LoadingStatus {
+    label: string;
+    error: boolean;
+    message?: string;
+    retry: boolean;
+    reducedMotion: boolean;
+}
+export declare class EngineLoading {
+    private font;
+    readonly world: World;
+    readonly camera: Camera;
+    readonly look: ReturnType<typeof loadingLook>;
+    readonly clearColor: readonly [number, number, number];
+    private backdrop;
+    private content;
+    private progress;
+    private retryButton;
+    private statusText;
+    private messageText;
+    private motions;
+    private status;
+    private disposed;
+    private retryBox;
+    constructor(gameId: GAME_IDS, mode: GameThemeMode | undefined, font: Font);
+    private box;
+    private disc;
+    private path;
+    private text;
+    private motion;
+    private tree;
+    private fruit;
+    private drawHero;
+    layout(width: number, height: number, offset?: number): void;
+    get retryBounds(): {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    setStatus(status: LoadingStatus): void;
+    update(dt: number): void;
+    dispose(): void;
+}
+export {};

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

@@ -0,0 +1,90 @@
+import { type Camera, type Color, type Entity, type Light, type Model, type Quat, type Vec3, type World } from '@nayan-ui/engine';
+import { type GameTheme } from '../../services/ThemeService';
+/** How a game frames the meadow. */
+export type Rig = {
+    /** Metres from the ground to the eye. Default 1.6. */
+    eyeHeight?: number;
+    /** How far down the screen the horizon sits, 0..1. Default 0.62. */
+    horizon?: number;
+    /** Metres from the eye to the play plane; keep it nearer than the ground at the screen's bottom edge. Default 3.6. */
+    playDepth?: number;
+};
+export type View3D = {
+    width: number;
+    height: number;
+    eye: Vec3;
+    /** Camera axes: looking along `forward`, `up` and `right` span the screen. */
+    forward: Vec3;
+    up: Vec3;
+    /** tan(fov / 2). */
+    tanHalf: number;
+    /** The camera's pitch up, radians. */
+    pitch: number;
+    horizon: number;
+    playDepth: number;
+};
+export declare function makeView(width: number, height: number, rig?: Rig): View3D;
+export declare function cameraFor(v: View3D): Camera;
+/** Metres per screen point on a plane `depth` metres ahead. */
+export declare const pointSize: (v: View3D, depth?: number) => number;
+/** Where screen point (x, y) lands on the plane `depth` metres ahead. */
+export declare function at(v: View3D, x: number, y: number, depth?: number): Vec3;
+/** A screen-plane vector (points per second, y down) in world metres per second at the play plane. */
+export declare function planeVector(v: View3D, dx: number, dy: number): Vec3;
+/** Turns something drawn facing +z to face the camera, then by `angle` in the screen's plane. */
+export declare function facing(v: View3D, angle?: number): Quat;
+/** The direction from the eye through screen point (x, y). */
+export declare function rayThrough(v: View3D, x: number, y: number): Vec3;
+export declare const add: (a: Vec3, b: Vec3) => Vec3;
+export declare const scale: (a: Vec3, k: number) => Vec3;
+export declare const lightFor: (theme: GameTheme) => Light;
+type RGB = [number, number, number];
+/** What far-off things fade toward. */
+export declare const HAZE: RGB;
+/** The color multiplier scenery takes for a theme (night dims and cools it), for games adding their own. */
+export declare const sceneryTint: (theme: GameTheme) => Color;
+/** Value noise, 0..1. */
+export declare function noise(x: number, y: number): number;
+export declare const fbm: (x: number, y: number) => number;
+export declare function random(seed: number): () => number;
+/** Where the scene is: green rolling hills and a grass meadow, or sandstone mesas over a desert. */
+export type Biome = 'meadow' | 'desert';
+/** A pine about one unit tall: a trunk and stacked cones, each a little narrower. */
+export declare const pineMesh: () => Model;
+/** A bush about half a unit tall: a few overlapping leafy clumps. */
+export declare const bushMesh: () => Model;
+/** A weathered grey boulder, one unit across. */
+export declare const rockMesh: () => Model;
+/** A tuft of grass blades, about a third of a unit tall, dark at the root and sunlit at the tips. */
+export declare const tuftMesh: () => Model;
+/** A little flower: white petals (tinted where it's placed) round a golden centre. */
+export declare const flowerMesh: () => Model;
+/** What's in a game's meadow, and where the sun and clouds sit on its screen. */
+export type MeadowOptions = {
+    /** The sun (or moon), as fractions of the screen. Default [0.8, 0.2]. */
+    sun?: readonly [number, number];
+    /** The band of sky the clouds sit in, as fractions down the screen. Default [0.1, 0.42]. */
+    clouds?: readonly [number, number];
+    /** The big oak and pine framing the play area. Default true. */
+    framingTrees?: boolean;
+    /** Grass tufts and flowers right in front. Default true. */
+    foreground?: boolean;
+    /** Hot-air balloons drifting far off. Default 0. */
+    hotAirBalloons?: number;
+    /** Meadow (default) or desert. */
+    biome?: Biome;
+    /**
+     * The ground and everything standing on it (treeline, framing trees, bushes, rocks, foreground).
+     * Default true; a game that scrolls its own ground passes false and gets only the sky and far hills.
+     */
+    near?: boolean;
+    /** Trees, bushes, rocks and foreground plants on the ground. Default true. */
+    groundDetails?: boolean;
+};
+/** Spawns the whole world for a view and theme; returns every entity, to despawn on a new layout or theme. */
+export declare function spawnWorld(world: World, v: View3D, theme: GameTheme, options?: MeadowOptions): Entity[];
+/** The clear color behind everything (only ever peeks out at the very edges). */
+export declare const backgroundFor: (theme: GameTheme) => readonly [number, number, number];
+/** Fixed scenery shared by the meadow games; seeded placement remains per run. */
+export declare function warmAssets(theme: GameTheme, biomes?: readonly Biome[]): Iterable<() => unknown>;
+export {};

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

@@ -0,0 +1,3 @@
+/** Product recipe revisioning is separate from the engine's geometry/storage format. */
+export declare function cacheGameAsset<T>(key: string, build: () => T): T;
+export declare const flushProceduralCache: () => Promise<void>;

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

@@ -0,0 +1,3 @@
+import { type Geometry, type Model, type ShapeOptions } from '@nayan-ui/engine';
+export declare function createGameMesh(geometry: Geometry, options?: ShapeOptions): Model;
+export { cacheGameAsset } from './EngineMeshCache';

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

@@ -0,0 +1,11 @@
+import type { Camera, Vec3 } from '@nayan-ui/engine';
+type Vector = [number, number, number];
+export declare const createChase: () => {
+    eye: Vector;
+    target: Vector;
+    initialized: boolean;
+};
+export type Chase = ReturnType<typeof createChase>;
+/** Filter camera offsets only: translation stays locked to the exact displayed car pose. */
+export declare function updateChase(chase: Chase, camera: Camera, anchor: Vec3, eye: Vec3, target: Vec3, dt: number): void;
+export {};

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

@@ -0,0 +1,15 @@
+/** Responsive lane targeting with filtered input and an analytically damped movement curve. */
+export type SteeringState = {
+    d: number;
+    target: number;
+    lateral: number;
+    steeringGoal?: number;
+};
+export declare function stepSteering(state: SteeringState, goal: number, dt: number, maxSpeed?: number, response?: number, playing?: boolean): void;
+/** Closing speed across the road: moving away or travelling alongside does not trigger a wreck. */
+export declare function sideImpactSpeed(playerLateral: number, trafficLateral: number, offset: number): number;
+/** Ease the displayed yaw and lean independently so quick input changes do not snap the body. */
+export declare function smoothSteeringPose(pose: {
+    yaw: number;
+    roll: number;
+}, lateral: number, speed: number, dt: number): void;

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

@@ -0,0 +1,2 @@
+/** Asset loaders warm the engine before mounting a game, so it can draw immediately. */
+export declare const EngineReadyContext: import("react").Context<boolean>;

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

@@ -0,0 +1,19 @@
+import type { Camera, Entity, World } from '@nayan-ui/engine';
+export type TiltView = {
+    width: number;
+    height: number;
+    centerY: number;
+    tilt: number;
+};
+/** Where a world point appears in the view. */
+export declare function project(v: TiltView, x: number, y: number, z?: number): [number, number];
+/** The world point at height `z` under a view point (a finger on the board). */
+export declare function unproject(v: TiltView, sx: number, sy: number, z?: number): [number, number];
+/** Points the camera so the board lands where the view puts it. */
+export declare function aimTilted(camera: Camera, v: TiltView): void;
+/**
+ * Lays a game backdrop (shared/EngineBackdrop, drawn from its top-left) flat `depth` below the board,
+ * stretched so it fills the view from its top-left as the original screens drew it. Lying flat, it faces
+ * up (+z) like the board, so a front light keeps its exact colors.
+ */
+export declare function placeTiltedBackdrop(world: World, backdrop: Entity, v: TiltView, depth: number): void;

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

@@ -0,0 +1,20 @@
+export interface EngineContact {
+    identifier: number;
+    pageX: number;
+    pageY: number;
+    timeStamp: number;
+}
+interface EngineTouchSurfaceProps {
+    enabled: boolean;
+    insets: {
+        top: number;
+        bottom: number;
+    };
+    onStart: (contact: EngineContact) => void;
+    onMove: (contact: EngineContact) => void;
+    onEnd: (contact: EngineContact) => void;
+    onCancel: () => void;
+}
+/** Host adapter for simultaneous contacts until GameView exposes raw multi-touch itself. */
+export declare const EngineTouchSurface: import("react").MemoExoticComponent<({ enabled, insets, onStart, onMove, onEnd, onCancel }: EngineTouchSurfaceProps) => import("react").JSX.Element>;
+export {};

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

@@ -0,0 +1,18 @@
+import type { Color, Light } from '@nayan-ui/engine';
+/** A theme color ('#RRGGBB', '#RRGGBBAA', 'rgb(a)(…)' or 'transparent') as an engine color, 0..1. */
+export declare function toColor(css: string, alpha?: number): Color;
+/** A theme color's RGB, for GameView's `background`. */
+export declare function toRgb(css: string): readonly [number, number, number];
+/**
+ * A light whose brightness is set so a surface facing the camera (normal +z) is lit at exactly 1: flat
+ * panels, lines and masks show their theme color unchanged, while rounded shapes keep their shading
+ * (lighter toward the light, darker away). Mirrors the engine's shading: ambient × hemisphere (0.8 for
+ * a sideways normal) plus diffuse. Shadows are off: these are flat, point-sized board scenes.
+ */
+export declare function frontLight(direction: [number, number, number], ambient: number): Light;
+export { MAX_GAME_WIDTH, gameWidthFor } from './EngineGameWidth';
+/** Ages a due intro by `dt`; once it's played long enough, clears `intro` so later rebuilds show the board at rest. */
+export declare function introPlayed(g: {
+    intro: boolean;
+    introAge: number;
+}, dt: number): void;

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

@@ -0,0 +1,3 @@
+/** Hosts own navigation; the library reports play state without depending on a navigator. */
+export declare const GamePlayingContext: import("react").Context<((playing: boolean) => void) | undefined>;
+export declare function useGamePlaying(playing: boolean): void;

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

@@ -0,0 +1,14 @@
+import type { GAME_IDS, GameThemeMode } from '../../services/UtilsService';
+interface GameLoadingProps {
+    gameId: GAME_IDS;
+    theme?: GameThemeMode;
+    label?: string;
+    error?: boolean;
+    message?: string;
+    onRetry?: () => void;
+    offset?: number;
+    visible?: boolean;
+}
+/** Shared engine loading world; only engine-unavailable/bootstrap failures use the text fallback. */
+export declare const GameLoading: import("react").MemoExoticComponent<({ gameId, theme, label, error, message, onRetry, offset, visible }: GameLoadingProps) => import("react").JSX.Element>;
+export {};

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

@@ -0,0 +1,9 @@
+import { type ReactNode } from 'react';
+interface GameLoadingTransitionProps {
+    ready: boolean;
+    loader: ReactNode;
+    children: ReactNode;
+}
+/** Keep the loading surface over the first game frame, then release it after fading. */
+export declare const GameLoadingTransition: import("react").MemoExoticComponent<({ ready, loader, children }: GameLoadingTransitionProps) => import("react").JSX.Element>;
+export {};

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

@@ -0,0 +1 @@
+export declare const PROCEDURAL_CACHE_VERSION = "6db8360ff38ef1524ff6b80f67938974";

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

@@ -0,0 +1,69 @@
+import type { Camera, DragEvent, World } from '@nayan-ui/engine';
+import { type HapticType } from '../../services/HapticsService';
+import { type SoundConfig } from '../../services/SoundsService';
+import { type GameTheme } from '../../services/ThemeService';
+import type { GameProps } from '../../services/UtilsService';
+import type { EngineGameScreenProps } from './EngineGameScreen';
+import type { EngineHud, GameOverCard, HudFeedback } from './EngineHud';
+type Phase = 'ready' | 'playing' | 'over';
+/** How an ended game came out; a draw is reported as a cancel. */
+export type GameResult = 'win' | 'lose' | 'draw';
+/** What every engine game's state exposes to its screen. */
+export type EngineGameModel = {
+    world: World | null;
+    camera: Camera;
+    score?: number;
+    phase: Phase;
+    won?: boolean;
+    onPhase: (phase: Phase) => void;
+    hudFeedback?: HudFeedback;
+};
+/** Plays a sound and/or a haptic, each only if the player has it switched on. */
+export type Feedback = (sound?: SoundConfig | null, haptic?: HapticType | null) => void;
+export type EngineGameSpec<G extends EngineGameModel> = {
+    gameId: string;
+    create: (theme: GameTheme) => G;
+    start: (g: G) => void;
+    reset: (g: G) => void;
+    /** What Play Again does; `reset` by default. */
+    replay?: (g: G) => void;
+    dispose: (g: G) => void;
+    tick?: (g: G, dt: number) => void;
+    hud?: (g: G, hud: EngineHud) => void;
+    setTheme?: (g: G, theme: GameTheme) => void;
+    setActive?: (g: G, active: boolean) => void;
+    resize?: (g: G, width: number, height: number, offset: number) => number | void;
+    drag?: (g: G, e: DragEvent) => void;
+    tap?: (g: G, x: number, y: number) => void;
+    /** How an ended game came out (reported, and returned as `status`); from `g.won` by default. */
+    outcome?: (g: G) => GameResult;
+    /** The score reported with a result; `g.score` by default. */
+    reportScore?: (g: G, status: 'win' | 'lose' | 'cancel') => number;
+    /** Optional game-specific completion metrics, sampled at the same time as the final score. */
+    reportData?: (g: G, status: 'win' | 'lose' | 'cancel') => Record<string, unknown>;
+    /** Hooks the game's events up to React state and feedback; called once. May return a cleanup, run on leaving. */
+    wire?: (g: G, fx: Feedback) => void | (() => void);
+    /** Cached ahead of the first sound. */
+    sounds?: Record<string, SoundConfig>;
+    /** Feedback on Start / Stop. */
+    onStart?: (fx: Feedback) => void;
+    onStop?: (fx: Feedback) => void;
+    onPlayAgain?: (fx: Feedback) => void;
+    /** Feedback as the game ends, beyond what its own events play. */
+    onOver?: (fx: Feedback, status: GameResult, game: G) => void;
+    /** Lets an ending play out (ms) before the game-over card covers it. */
+    resultsDelay?: (status: GameResult) => number;
+};
+type ScreenProps = Pick<EngineGameScreenProps, 'onActiveChange' | 'feedback' | 'gameId' | 'settings' | 'onSettingsChange' | 'onShare' | 'onShowLeaderboard' | 'bannerAd' | 'source' | 'camera' | 'onUpdate' | 'onResize' | 'onDrag' | 'onTap' | 'playing' | 'onStart' | 'onStop'>;
+export declare function useEngineGame<G extends EngineGameModel>(props: GameProps & {
+    settings: NonNullable<GameProps['settings']>;
+}, spec: EngineGameSpec<G>): {
+    game: G;
+    theme: GameTheme;
+    phase: Phase;
+    status: GameResult;
+    fx: Feedback;
+    screen: ScreenProps;
+    gameOver: (card: Omit<GameOverCard, "onPlayAgain" | "onShare">) => GameOverCard | null;
+};
+export {};

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

@@ -0,0 +1,2 @@
+/** Keep native resources through React's effect replay; release them after a real unmount. */
+export declare function useGameResource<T>(create: () => T, connect: (value: T) => () => void): T;

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

@@ -0,0 +1,4 @@
+type SetState<T> = (next: T | ((previous: T) => T)) => void;
+/** Like `useState`, but its updates show at once even while the frame loop keeps the JS thread busy (see above). */
+export declare function useLiveState<T>(initial: T | (() => T), minInterval?: number): [T, SetState<T>];
+export {};

package/lib/typescript/src/games/sliding-numbers/SlidingNumbers.d.ts

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

package/lib/typescript/src/games/sliding-numbers/SlidingNumbersConstants.d.ts

@@ -1,42 +1,34 @@
-export declare const GRID_SIZE = 3;
-export declare const TOTAL_TILES: number;
-export declare const SLIDING_NUMBERS_GAME_CONFIG: {
-    readonly TILE_SIZE: number;
-    readonly TILE_GAP: 4 | 6;
-    readonly BOARD_PADDING: 14 | 18;
-    readonly BOARD_DEPTH: 10 | 8;
-    readonly BOARD_WIDTH: number;
-    readonly BOARD_INNER: number;
-    readonly GAME_DURATION: 300;
-    readonly SHUFFLE_MOVES: 100;
-    readonly TILE_DEPTH: 4 | 6;
-    readonly TILE_RADIUS: 14 | 10;
+import type { TiltView } from '../shared/EngineTilt';
+export declare const GAME_DURATION = 300;
+export declare const SLIDE_TIME = 0.2;
+export declare const PRESS_SCALE = 0.92;
+export declare const TAP_SLOP = 10;
+export declare const SWIPE = 18;
+/** Tiles 1..8, as the original tiles. */
+export declare const TILE_COLORS: readonly ["#FF6B6B", "#51CF66", "#339AF0", "#FCC419", "#CC5DE8", "#FF922B", "#22B8CF", "#F06595"];
+export declare const NUMBER_WORDS: readonly ["", "ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT"];
+export declare const COLORS: {
+    readonly FRAME: "#5c4033";
+    readonly WELL: "#3a2518";
+    readonly SLOT: "#2e1d12";
+    readonly NUMBER: "#FFFFFF";
 };
-export declare const SLIDING_NUMBERS_ANIMATION_CONFIG: {
-    readonly TILE_SLIDE_DURATION: 200;
-    readonly TILE_PRESS_SCALE: 0.92;
-    readonly COMPLETION_SCALE: 1.04;
+/** The camera leans back from straight down, so the tiles stand up off the board. */
+export declare const TILT = 0;
+/** Lit straight on, with no light falling from the top: every face toward the camera keeps its exact color. */
+export declare const LIGHT: import("@nayan-ui/engine").Light;
+/** A tile's height, of its width. */
+export declare const TILE_HEIGHT = 0.4;
+export type Layout = TiltView & {
+    tile: number;
+    gap: number;
+    pitch: number;
+    pad: number;
+    size: number;
 };
-interface Tile3DColors {
-    top: string;
-    topHighlight: string;
-    front: string;
-    frontBottom: string;
-    side: string;
-    text: string;
-    number: string;
-}
-export declare const getTile3DColors: (tileValue: number) => Tile3DColors;
-export declare const SLIDING_NUMBERS_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly BOARD_TOP: "#5c4033";
-    readonly BOARD_FRONT: "#4a3228";
-    readonly BOARD_INNER: "#3a2518";
-    readonly BOARD_HIGHLIGHT: "#7a5a45";
-    readonly SLOT_BG: "rgba(0, 0, 0, 0.25)";
-    readonly TIMER_TEXT: "#f59e0b";
-    readonly TEXT_PRIMARY: "#FFFFFF";
-};
-export declare const NUMBER_WORDS: Record<number, string>;
-export {};
+/** The board as big as the original board (88% of the width, at most 340 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 on the board (row 0 along the top), in world units. */
+export declare const cellCentre: (l: Layout, row: number, col: number) => [number, number];
+/** The cell under a board point, or null. */
+export declare function cellAt(l: Layout, x: number, y: number): [number, number] | null;

package/lib/typescript/src/games/sliding-numbers/SlidingNumbersGame.d.ts

@@ -0,0 +1,48 @@
+import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './SlidingNumbersConstants';
+import { type Board, type Tile } from './SlidingNumbersRules';
+import { type Scene } from './SlidingNumbersScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** move: a tile slid; blocked: a tile that can't move; win / lose: how it ended. */
+export type GameEvent = 'move' | 'blocked' | 'win' | 'lose';
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    board: Board;
+    won: boolean;
+    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    readonly timeLeft: number;
+    /** A finger down on a tile: where, and which. */
+    press: {
+        x: number;
+        y: number;
+        id: number;
+    } | null;
+    onPhase: (_p: Phase) => 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;
+/** Starts on the board already shown. */
+export declare function start(g: Game): void;
+/** Stop: the same board, the clock back to five minutes (as the original game). */
+export declare function stop(g: Game): void;
+/** Play Again: a fresh shuffle, the tiles gliding to their new places. */
+export declare function newBoard(g: Game): void;
+export declare function dispose(g: Game): void;
+export declare function tick(g: Game, dt: number): void;
+/** Slides a tile into the gap if it's beside it; shakes it if not. A solved board wins. */
+export declare function move(g: Game, t: Tile): void;
+/** The tile under a view point (on the tiles' tops), or null. */
+export declare function tileUnder(g: Game, x: number, y: number): Tile | null;
+/** A finger down sinks the tile under it; a tap slides it, and so does a swipe toward the gap. */
+export declare function drag(g: Game, { phase, x, y }: DragEvent): void;