@nayan-ui/games 1.19.0 → 1.20.0

package/lib/typescript/src/games/knife-hit/KnifeHitGame.d.ts

@@ -0,0 +1,49 @@
+import { type Camera, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './KnifeHitConstants';
+import { type Scene } from './KnifeHitScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** throw: a knife left the hand; stick / apple / clash: how it landed. */
+export type GameEvent = 'throw' | 'stick' | 'apple' | 'clash';
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    /** The knives in the log (angles: the play area's, y down), the apple if there is one. */
+    stuck: number[];
+    apple: number | null;
+    appleTaken: boolean;
+    rotation: number;
+    speed: number;
+    direction: number;
+    turnTimer: number;
+    turnInterval: number;
+    /** The knife in flight: its tip's height in the play area, or null. */
+    flying: number | null;
+    knivesLeft: number;
+    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    readonly timeLeft: number;
+    won: boolean;
+    pending: number;
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onTime: (_t: number) => void;
+    onKnives: (_n: number) => void;
+    onEvent: (_e: GameEvent) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the log out for the view (first layout, header height, rotation): rebuilt from the round's state. */
+export declare function setLayout(g: Game, l: Layout): void;
+export declare function setTheme(g: Game, theme: GameTheme): void;
+/** A fresh round: three knives in the log, sometimes an apple, the log's speed and turns varied a little. */
+export declare function start(g: Game): void;
+/** Back to the still preview log (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;
+/** A finger down throws the next knife, if one's ready and none is in the air. */
+export declare function throwKnife(g: Game): void;

package/lib/typescript/src/games/knife-hit/KnifeHitScene.d.ts

@@ -0,0 +1,37 @@
+import { type Entity, type Vec3, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './KnifeHitConstants';
+/** A play-area point (y down) in the world, at height z. */
+export declare function toWorld(l: Layout, x: number, y: number, z?: number): Vec3;
+export type Scene = {
+    countShown?: number;
+    backdrop: Entity;
+    /** The log's pivot (spins), and what rides on it. */
+    pivot: Entity;
+    log: Entity;
+    stuck: Entity[];
+    apple: Entity | null;
+    /** The knife in hand. */
+    knife: Entity;
+    /** The round's knives, counted down the left. */
+    counters: Entity[];
+};
+export declare function buildScene(world: World, l: Layout, theme: GameTheme): Scene;
+export declare function removeScene(world: World, s: Scene): void;
+export declare function setSceneTheme(world: World, s: Scene, theme: GameTheme): void;
+/** The log's knives and apple for a round (or the preview), the log back at rest. */
+export declare function dressLog(world: World, l: Layout, s: Scene, angles: number[], apple: number | null): void;
+/** The log turned to `rotation` (radians, clockwise on screen). */
+export declare function spinLog(world: World, s: Scene, rotation: number): void;
+/** The knife in hand, its tip at play-area height `y`; hidden when there's none to throw. */
+export declare function placeKnife(world: World, l: Layout, s: Scene, y: number, shown: boolean): void;
+/** The count down the left: bright for knives left, dim for those thrown. */
+export declare function showCount(world: World, s: Scene, left: number): void;
+/** A knife sinks into the rim: it joins the log, the log jumps a touch, chips fly. */
+export declare function stick(world: World, l: Layout, s: Scene, a: number): void;
+/** A knife strikes another: sparks, the log shudders, the thrown knife spins away and falls. */
+export declare function clash(world: World, l: Layout, s: Scene, tipY: number): void;
+/** The apple's hit: it bursts in a spray of juice. */
+export declare function burstApple(world: World, l: Layout, s: Scene): void;
+/** Every knife in: a shower of confetti from the log. */
+export declare function celebrate(world: World, l: Layout): void;

package/lib/typescript/src/games/ludo-king/LudoKing.d.ts

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

package/lib/typescript/src/games/ludo-king/LudoKingConstants.d.ts

@@ -1,37 +1,59 @@
 export type PlayerColor = 'red' | 'green' | 'yellow' | 'blue';
-export declare const LUDO_KING_COLORS: {
-    RED: string;
-    GREEN: string;
-    YELLOW: string;
-    BLUE: string;
-    BOARD_BACKGROUND: string;
-    BOARD_BORDER: string;
-    PATH_COLOR: string;
-    STAR_COLOR: string;
-    DICE_BACKGROUND: string;
-    DICE_DOT: string;
-};
-export declare const LUDO_KING_PLAYER_COLORS: Record<PlayerColor, string>;
-export declare const LUDO_KING_GAME_CONFIG: {
-    BOARD_SIZE: number;
-    TOKENS_PER_PLAYER: number;
-    DICE_MIN: number;
-    DICE_MAX: number;
-    PATH_LENGTH: number;
-    ANIMATION_DURATION: number;
-};
-export declare const HOME_POSITIONS: Record<PlayerColor, {
-    row: number;
-    col: number;
-}[]>;
-export declare const ENTRY_POSITIONS: Record<PlayerColor, number>;
+export declare const GRID = 15;
+export declare const TOKENS_PER_PLAYER = 4;
+export declare const TRACK_LENGTH = 56;
+export declare const MAX_SIXES = 3;
+export declare const PLAYER_COLORS: Record<PlayerColor, string>;
+export declare const BOARD_WHITE = "#FBF7EC";
+export declare const BOARD_FRAME = "#2A2550";
+export declare const STAR_COLOR = "#8A8AA0";
+export declare const PLAYER_COLOR: string;
+export declare const AI_COLOR: string;
+export declare const ROLL_TIME = 0.9;
+export declare const MOVE_DELAY = 0.35;
+export declare const HOP_TIME = 0.14;
+export declare const NEXT_TURN_DELAY = 0.45;
+export declare const PENALTY_DELAY = 0.9;
+export declare const CANT_MOVE_DELAY = 0.6;
+export declare const AI_THINK = 0.7;
+export declare const TILT = 0.35;
+export declare const LIGHT: import("@nayan-ui/engine").Light;
+export declare const RIM = 0.014;
+export declare const TILE_TOP = 0.012;
+export declare const DIE_SIZE = 0.15;
+export declare const DIE_Y: number;
+export declare const TOKEN_HEIGHT = 0.07;
+/** Absolute index on MAIN_PATH where each player joins. */
+export declare const ENTRY: Record<PlayerColor, number>;
+/** Entry cells and stars: no capture here. */
 export declare const SAFE_POSITIONS: number[];
+/** The 52 shared cells, clockwise, as {row, col} on the 15 x 15 grid. */
 export declare const MAIN_PATH: {
     row: number;
     col: number;
 }[];
-export declare const HOME_STRETCH_PATHS: Record<PlayerColor, {
+/** Each player's 6 home-stretch cells, from the first inside the arm to the centre. */
+export declare const HOME_STRETCH: Record<PlayerColor, {
+    row: number;
+    col: number;
+}[]>;
+/** The four token yards in each player's home base. */
+export declare const HOME_YARDS: Record<PlayerColor, {
     row: number;
     col: number;
 }[]>;
-export declare const HOME_STRETCH_ENTRY: Record<PlayerColor, number>;
+export declare const CENTER: {
+    row: number;
+    col: number;
+};
+/** A grid cell (row, col; may be fractional for yards) as a board-unit point (x right, y up, centred). */
+export declare function cellPoint(row: number, col: number): [number, number];
+export type Layout = {
+    width: number;
+    height: number;
+    size: number;
+    centerY: number;
+};
+export declare function getLayout(width: number, height: number, offset: number): Layout;
+/** Where a point on (or `z` above) the board, in board units, appears in the view. */
+export declare function toView(l: Layout, x: number, y: number, z?: number): [number, number];

package/lib/typescript/src/games/ludo-king/LudoKingGame.d.ts

@@ -0,0 +1,40 @@
+import { type Camera, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './LudoKingConstants';
+import { type Player } from './LudoKingRules';
+import { type Scene } from './LudoKingScene';
+export type Phase = 'ready' | 'playing' | 'over';
+export type Turn = 0 | 1;
+/** 'rolling' waits for your die tap, 'await' for your token tap, others animate or are the AI's. */
+type Stage = 'rolling' | 'await' | 'busy' | 'thinking';
+export type GameEvent = 'tap' | 'roll' | 'six' | 'penalty' | 'cantMove' | 'move' | 'capture' | 'finish';
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    players: Player[];
+    turn: Turn;
+    dice: number;
+    stage: Stage;
+    sixes: number;
+    /** The score lives in the engine (Rust). */
+    readonly score: number;
+    won: boolean;
+    onPhase: (_p: Phase) => void;
+    onFinished: (_you: number, _ai: number) => void;
+    onScore: (_s: number) => void;
+    onTurn: (_t: Turn) => void;
+    onEvent: (_e: GameEvent, _who: Turn) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+export declare function setLayout(g: Game, l: Layout): 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 tick(g: Game, dt: number): void;
+export declare function tap(g: Game, x: number, y: number): void;
+export {};

package/lib/typescript/src/games/ludo-king/LudoKingRules.d.ts

@@ -0,0 +1,42 @@
+import { type PlayerColor } from './LudoKingConstants';
+export type Token = {
+    id: string;
+    player: PlayerColor;
+    /** -1 yard, 0..56 along the route (56 = home). */
+    progress: number;
+};
+export type Player = {
+    color: PlayerColor;
+    tokens: Token[];
+    isAI: boolean;
+    finishedTokens: number;
+};
+export type GamePhase = 'rolling' | 'moving' | 'ai_turn' | 'over';
+export declare const isInYard: (t: Token) => boolean;
+export declare const isFinished: (t: Token) => boolean;
+export declare const rollDice: () => number;
+export declare function createPlayers(you: PlayerColor, ai: PlayerColor[]): Player[];
+/** The absolute index on the shared track for a token `steps` from its entry (0..50). */
+export declare const mainIndexAt: (player: PlayerColor, steps: number) => number;
+export declare function canMove(token: Token, dice: number): boolean;
+export declare const movableTokens: (player: Player, dice: number) => Token[];
+/** The grid cell a token stands on now. */
+export declare function tokenCell(token: Token): {
+    row: number;
+    col: number;
+};
+/** The cells a token passes through for a move of `dice` (for the hop animation), start included. */
+export declare function journey(token: Token, dice: number): {
+    row: number;
+    col: number;
+}[];
+/** Applies a move, returning the moved token and any opponent token it captured. */
+export declare function moveToken(token: Token, dice: number, players: Player[]): {
+    moved: Token;
+    captured: Token | null;
+};
+export declare const isGameOver: (players: Player[]) => boolean;
+export declare const getWinner: (players: Player[]) => Player | null;
+/** The AI's pick: a weighted score per move, best 70% of the time (as the original medium AI). */
+export declare function selectAIMove(player: Player, dice: number, players: Player[]): Token | null;
+export declare function calculateScore(player: Player): number;

package/lib/typescript/src/games/ludo-king/LudoKingScene.d.ts

@@ -0,0 +1,53 @@
+import { type Camera, type Entity, type Quat, type Vec3, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout, type PlayerColor } from './LudoKingConstants';
+/** Above every layer of the board: pawn shadows, then the pawns and hint rings over them. */
+export declare const SHADOW_Z: number;
+export declare const PAWN_Z: number;
+/** The die showing `value` toward the camera (shared/EngineDice), turned `twist` round its up axis. */
+export declare const dieRotation: (value: number, twist?: number) => Quat;
+export type Scene = {
+    backdrop: Entity;
+    board: Entity;
+    tokens: Map<string, Entity>;
+    tokenAt: Map<Entity, string>;
+    bobbing: Set<string>;
+    shadows: Map<string, Entity>;
+    die: Entity;
+    dieShadow: Entity;
+    ring: Entity;
+    hints: Entity[];
+};
+export declare const toWorld: (l: Layout, x: number, y: number, z: number) => Vec3;
+export declare const aimCamera: (camera: Camera, l: Layout) => void;
+export declare const dieRest: (l: Layout) => Vec3;
+export declare function buildScene(world: World, l: Layout, theme: GameTheme, tokenIds: {
+    id: string;
+    color: PlayerColor;
+}[]): Scene;
+export declare function removeScene(world: World, s: Scene): void;
+export declare function setSceneTheme(world: World, s: Scene, theme: GameTheme): void;
+/** When players share a cell they shoulder apart a little. */
+export declare function placeToken(world: World, l: Layout, s: Scene, id: string, cell: {
+    row: number;
+    col: number;
+}, offset?: number): void;
+/** Hops a token through a run of cells. */
+export declare function hopToken(world: World, l: Layout, s: Scene, id: string, cells: {
+    row: number;
+    col: number;
+}[], time: number): void;
+export declare function bobToken(world: World, l: Layout, s: Scene, ids: string[]): void;
+export declare function showHints(world: World, l: Layout, s: Scene, cells: {
+    row: number;
+    col: number;
+}[]): void;
+/** The die is tossed, tumbles and bounces to rest showing `value` (shared/EngineDice). */
+export declare function rollDie(world: World, l: Layout, s: Scene, value: number, time: number, disposed?: () => boolean): void;
+export declare function showRollHint(world: World, l: Layout, s: Scene, on: boolean): void;
+export declare function captureBurst(world: World, l: Layout, cell: {
+    row: number;
+    col: number;
+}): void;
+export declare function finishBurst(world: World, l: Layout): void;
+export declare function confetti(world: World, l: Layout, winner: PlayerColor): void;

package/lib/typescript/src/games/maze-runner/MazeRunner.d.ts

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

package/lib/typescript/src/games/maze-runner/MazeRunnerConstants.d.ts

@@ -1,12 +1,36 @@
-export declare const MAZE_RUNNER_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
+import type { TiltView } from '../shared/EngineTilt';
+export declare const GRID = 14;
+export declare const GAME_DURATION = 120;
+/** A win scores by its time against the full three minutes. */
+export declare const BASE_SCORE = 100;
+export declare const GAME_OVER_DELAY = 0.5;
+export declare const COLORS: {
+    readonly WALLS: readonly ["#7A4A24", "#8B4513", "#A0522D", "#9A5B2E"];
+    readonly WALL_TOP: "#D2A06A";
+    readonly BALL: "#4ECDC4";
+    readonly BALL_BAND: "#FFFFFF";
+    readonly BALL_DOT: "#2C8C86";
+    readonly START: "#4CAF50";
+    readonly START_INNER: "#81C784";
+    readonly GOAL: "#FF5722";
+    readonly GOAL_INNER: "#FF8A65";
 };
-export declare const MAZE_RUNNER_GAME_CONFIG: {
-    readonly gridSize: 10;
-    readonly timeBonus: 1.2;
-    readonly scoreMultiplier: 1.2;
-    readonly hintAvailable: false;
-    readonly gameDuration: 180;
+/** Directly overhead so raised walls do not obscure the maze's passages. */
+export declare const TILT = 0;
+/** Overhead light, with cast shadows disabled by frontLight. */
+export declare const LIGHT: import("@nayan-ui/engine").Light;
+/** A wall's thickness and height, and the ball's size, of a cell. */
+export declare const WALL_THICKNESS = 0.14;
+export declare const WALL_HEIGHT = 0.42;
+export declare const BALL_SIZE = 0.56;
+/** The board's rim round the maze, in points: it counts toward the max width. */
+export declare const BORDER = 6;
+export type Layout = TiltView & {
+    n: number;
+    cell: number;
+    size: number;
 };
-export declare const MAZE_ADVENTURE_COLORS: readonly ["#FF6B6B", "#4ECDC4", "#45B7D1", "#96CEB4", "#FFEAA7", "#DDA0DD", "#98D8C8", "#F7DC6F", "#BB8FCE", "#85C1E9", "#82E0AA", "#F8C471", "#D7BDE2", "#A9DFBF", "#FAD7A0", "#D5A6BD"];
+/** The maze square as big as the game area allows, viewed directly overhead. */
+export declare function getLayout(width: number, height: number, offset: number): Layout;
+/** A cell's centre (or any point in cells: 0.5 is the middle of the first column / row), in world units. */
+export declare function cellPoint(l: Layout, cx: number, cy: number): [number, number];

package/lib/typescript/src/games/maze-runner/MazeRunnerGame.d.ts

@@ -0,0 +1,44 @@
+import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './MazeRunnerConstants';
+import { type Scene } from './MazeRunnerScene';
+/** ready: the maze waits; playing: rolling; over: won or lost (the game-over card comes up a beat later, through `onCard`). */
+export type Phase = 'ready' | 'playing' | 'over';
+/** turn: a swipe taken; bump: rolled into a wall; win / lose: how it ended. */
+export type GameEvent = 'turn' | 'bump' | 'win' | 'lose';
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    open: number[];
+    ball: import("./MazeRunnerRules").Roll;
+    /** Where the ball was last drawn (in cells), so its turn follows how far it rolled. */
+    drawn: [number, number];
+    /** Running: the clock's ticking and swipes roll the ball (false from the moment it ends). */
+    running: boolean;
+    /** Seconds played and the score: the clock and score live in the engine (Rust), advanced by world.update. */
+    readonly elapsed: number;
+    readonly score: number;
+    won: boolean;
+    onPhase: (_p: Phase) => void;
+    onCard: () => void;
+    onTime: (_remaining: number) => void;
+    onEvent: (_e: GameEvent) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the maze 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 maze already shown, the ball at the start. */
+export declare function start(g: Game): void;
+/** Stop: the same maze, the ball back at the start, not running (as the original game). */
+export declare function stop(g: Game): void;
+/** Play Again: a new maze rises, the ball at the start, not running. */
+export declare function newMaze(g: Game): void;
+export declare function dispose(g: Game): void;
+export declare function tick(g: Game, dt: number): void;
+/** Swipes anywhere: each stretch of a drag one way is a swipe, so one drag can chain turns. */
+export declare function drag(g: Game, e: DragEvent): void;

package/lib/typescript/src/games/maze-runner/MazeRunnerRules.d.ts

@@ -0,0 +1,34 @@
+/** Directions: 0 none, 1 up, 2 right, 3 down, 4 left. A cell's open sides are a bitmask (1 << (dir - 1)). */
+export declare const NONE = 0;
+export declare const UP = 1;
+export declare const RIGHT = 2;
+export declare const DOWN = 3;
+export declare const LEFT = 4;
+export declare const ROLL_CELLS_PER_SEC = 5;
+export declare const SWIPE_PX = 16;
+export declare const FRAME_MS = 16.67;
+export declare const dirDX: (d: number) => 1 | 0 | -1;
+export declare const dirDY: (d: number) => 1 | 0 | -1;
+/** A fresh maze: the hardest of several carved ones, by the length of the way through and its choices. */
+export declare function generateMaze(n: number): number[];
+export declare const isOpen: (open: number[], n: number, x: number, y: number, d: number) => boolean;
+/** The ball's roll: the cell it last centred on, how far (0..1) it's gone toward the next, and which way. */
+export type Roll = {
+    cx: number;
+    cy: number;
+    p: number;
+    dir: number;
+    queued: number;
+    anchorX: number;
+    anchorY: number;
+};
+export declare const homeRoll: () => Roll;
+/** A finger moved to (x, y): a swipe once it's gone SWIPE_PX one way from where the last began. Returns whether a new way was taken. */
+export declare function swipe(r: Roll, x: number, y: number): boolean;
+/** One display frame of rolling. Says whether the ball bumped a wall, and the cell it reached (if it reached one). */
+export declare function roll(r: Roll, open: number[], n: number, frameMs: number): {
+    bumped: boolean;
+    reached: [number, number] | null;
+};
+/** Where the ball is drawn, in cells (its centre: 0.5 is the middle of the first column / row). */
+export declare const rollAt: (r: Roll) => [number, number];

package/lib/typescript/src/games/maze-runner/MazeRunnerScene.d.ts

@@ -0,0 +1,29 @@
+import { type Entity, type Quat, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './MazeRunnerConstants';
+export type Scene = {
+    backdrop: Entity;
+    floor: Entity;
+    inner: Entity | null;
+    walls: Entity[];
+    pads: Entity[];
+    ring: Entity;
+    ball: Entity;
+    /** The ball's turn so far, from rolling. */
+    spin: Quat;
+};
+export declare function buildScene(world: World, l: Layout, theme: GameTheme, open: number[]): Scene;
+export declare function removeScene(world: World, s: Scene): void;
+export declare function setSceneTheme(world: World, l: Layout, s: Scene, theme: GameTheme): void;
+/** Builds a maze's walls; on a new maze they rise out of the board, from the start corner outward. */
+export declare function setMaze(world: World, l: Layout, s: Scene, open: number[], animate: boolean): void;
+/** The ball at a point (in cells), turned by how far it rolled to get there from (px, py). */
+export declare function placeBall(world: World, l: Layout, s: Scene, cx: number, cy: number, px: number, py: number): void;
+/** Back to the start's look (a new game, or the preview). */
+export declare function resetBall(world: World, l: Layout, s: Scene): void;
+/** It ran into a wall: a little jolt. */
+export declare function bump(world: World, l: Layout, s: Scene): void;
+/** The exit reached: the ball turns gold with a pop, and confetti bursts over the maze. */
+export declare function celebrate(world: World, l: Layout, s: Scene): void;
+/** Out of time: the ball dims where it stopped. */
+export declare function timeUp(world: World, s: Scene): void;

package/lib/typescript/src/games/memory-match/MemoryMatch.d.ts

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

package/lib/typescript/src/games/memory-match/MemoryMatchConstants.d.ts

@@ -1,49 +1,49 @@
-export interface GridSpec {
-    rows: number;
-    cols: number;
-}
-export declare const GRID: GridSpec;
-export declare const MEMORY_MATCH_CONFIG: {
-    readonly GAME_DURATION: 300;
-    readonly MISMATCH_DELAY: 800;
-    readonly POINTS_PER_MATCH: 1000;
-    readonly TIME_BONUS_PER_SECOND: 50;
-    readonly WIN_BONUS: 5000;
+import type { TiltView } from '../shared/EngineTilt';
+export declare const GAME_DURATION = 300;
+export declare const MISMATCH_DELAY = 0.8;
+export declare const POINTS_PER_MATCH = 1000;
+export declare const WIN_BONUS = 5000;
+export declare const FLIP_TIME = 0.22;
+export declare const TAP_SLOP = 12;
+export declare const COLORS: {
+    readonly CARD_FRONT: "#FFFDF7";
+    readonly CARD_MATCHED: "#E5F7EC";
+    readonly FRONT_BORDER: "#DFE3F1";
+    readonly MATCHED_BORDER: "#8BD3AD";
+    readonly MATCHED_BADGE: "#32A875";
+    readonly BACK_TOP: "#6378E0";
+    readonly BACK_BOTTOM: "#3E4EAE";
+    readonly BACK_BORDER: "#97A7EF";
+    readonly BACK_HALO: "#6072CE";
+    readonly BACK_MOTIF: "#EAF0FF";
+    readonly BACK_PAIR: "#B9CCFF";
 };
-export declare const MEMORY_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly CARD_FRONT: "#FDF6E3";
-    readonly CARD_MATCHED: "#D7F5DC";
-    readonly CARD_BORDER: "rgba(0,0,0,0.16)";
-    readonly CARD_SHADOW: "rgba(0,0,0,0.28)";
-    readonly BACK_TOP: "#5b7cfa";
-    readonly BACK_BOTTOM: "#3a4fd6";
-    readonly BACK_MOTIF: "rgba(255,255,255,0.28)";
-};
-export type FruitSymbol = 'apple' | 'orange' | 'banana' | 'grapes' | 'kiwi' | 'strawberry' | 'mango' | 'peach' | 'cherries' | 'pineapple' | 'watermelon' | 'pomegranate';
-export declare const FRUIT_SYMBOLS: FruitSymbol[];
-export declare const MAX_PAIRS: number;
-export interface CardRect {
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-    cx: number;
-    cy: number;
-}
-export interface BoardLayout {
+/** The camera leans back a little from straight down, so the cards and fruit stand up. */
+export declare const TILT = 0.2;
+/** Lit from the upper left; surfaces facing up off the table (+z) keep their exact color. */
+export declare const LIGHT: import("@nayan-ui/engine").Light;
+/** A card's thickness, and its fruit's size, of its width. */
+export declare const THICKNESS = 0.28;
+/** The flat face of EngineBlocks' bevel occupies 78% of the block's width. */
+export declare const FACE_SIZE = 0.78;
+export declare const FRUIT_SIZE = 0.62;
+/**
+ * Mesh detail for the card fruit (EngineFruits): about as big on screen as Fruit Ninja's, so the same
+ * lighter models serve both games; ten full-detail fruit would be built in one frame on the first deal.
+ */
+export declare const FRUIT_DETAIL: number;
+export type Layout = TiltView & {
     rows: number;
     cols: number;
     card: number;
     gap: number;
+    pitch: number;
     boardW: number;
     boardH: number;
-    rects: CardRect[];
-}
-export declare const computeLayout: () => BoardLayout;
-export type CardState = 'down' | 'up' | 'matched';
-export interface Card {
-    symbol: number;
-    state: CardState;
-}
+};
+/** Fill the shared game width without outer gutters; fit shorter screens inside the available height. */
+export declare function getLayout(width: number, height: number, offset: number, tablet: boolean): Layout;
+/** A card's centre on the table (index row-major, row 0 along the top), in world units. */
+export declare function cardCentre(l: Layout, i: number): [number, number];
+/** The card under a table point (not in the gaps), or -1. */
+export declare function cardAt(l: Layout, x: number, y: number): number;

package/lib/typescript/src/games/memory-match/MemoryMatchGame.d.ts

@@ -0,0 +1,53 @@
+import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './MemoryMatchConstants';
+import { type Card } from './MemoryMatchRules';
+import { type Scene } from './MemoryMatchScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** flip: a first card turned; match / wrong: how a pair went; win / lose: how it ended. */
+export type GameEvent = 'flip' | 'match' | 'wrong' | 'win' | 'lose';
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    cards: Card[];
+    totalPairs: number;
+    firstIndex: number;
+    /** Input is locked while a miss is shown. */
+    lock: boolean;
+    matchedPairs: number;
+    moves: number;
+    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    readonly timeLeft: number;
+    won: boolean;
+    press: {
+        x: number;
+        y: number;
+        index: number;
+    } | null;
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onPairs: (_matched: number, _total: number) => void;
+    onTime: (_t: number) => void;
+    onEvent: (_e: GameEvent) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the table 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 play on the deal already on the table. */
+export declare function start(g: Game): void;
+/** A fresh deal, not started (Stop, Play Again), as the original store's reset. The world is kept. */
+export declare function reset(g: Game): void;
+export declare function dispose(g: Game): void;
+export declare function tick(g: Game, dt: number): void;
+/** Turns a card over: the first of a pair waits, the second matches or misses. */
+export declare function flipCard(g: Game, index: number): void;
+/** The card under a view point (on the cards' tops), or -1. */
+export declare function cardUnder(g: Game, x: number, y: number): number;
+/** A tap (down and up without wandering, however long) turns the card under it. */
+export declare function drag(g: Game, { phase, x, y }: DragEvent): void;