@nayan-ui/games 1.19.0 → 1.20.0

package/lib/typescript/src/games/perfect-circle/PerfectCircleGame.d.ts

@@ -0,0 +1,40 @@
+import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './PerfectCircleConstants';
+import { type Point } from './PerfectCircleRules';
+import { type Scene } from './PerfectCircleScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** begin / end: the finger went down / lifted; scored: the stroke's accuracy is in (not for one too short to count). */
+export type GameEvent = 'begin' | 'end' | 'scored';
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    /** The stroke so far (view points, kept inside the guide), and whether a finger is drawing it. */
+    points: Point[];
+    drawing: boolean;
+    accuracy: number;
+    won: boolean;
+    fit: {
+        cx: number;
+        cy: number;
+        r: number;
+    } | null;
+    onPhase: (_p: Phase) => void;
+    onAccuracy: (_a: number) => void;
+    onEvent: (_e: GameEvent) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the plate out for the view (first layout, header height, rotation); a stroke on it is cleared. */
+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;
+/** An empty plate, 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;
+/** One stroke per round: down starts it, every move of 4 points or more adds to it, lifting scores it. */
+export declare function drag(g: Game, { phase, x, y }: DragEvent): void;

package/lib/typescript/src/games/perfect-circle/PerfectCircleRules.d.ts

@@ -0,0 +1,55 @@
+export type Point = {
+    x: number;
+    y: number;
+};
+export type Circle = {
+    centerX: number;
+    centerY: number;
+    radius: number;
+};
+export declare const MIN_POINTS = 20;
+export declare const WIN_ACCURACY = 80;
+export declare const SUCCESS_ACCURACY = 70;
+/** The circle that best fits the points (least squares), or the centroid's average radius if they're degenerate. */
+export declare function fitCircle(points: Point[]): Circle;
+/** The stroke's accuracy (0..100) against the guide circle (centre and radius in view points). */
+export declare function accuracyOf(points: Point[], guide: Circle): number;
+/** The accuracy levels the game-over card names, best first. */
+export declare const ACCURACY_LEVELS: readonly [{
+    readonly min: 95;
+    readonly label: "PERFECT!";
+}, {
+    readonly min: 90;
+    readonly label: "EXCELLENT!";
+}, {
+    readonly min: 85;
+    readonly label: "GREAT!";
+}, {
+    readonly min: 80;
+    readonly label: "GOOD!";
+}, {
+    readonly min: 70;
+    readonly label: "NICE TRY!";
+}, {
+    readonly min: 0;
+    readonly label: "KEEP TRYING!";
+}];
+export declare const levelOf: (accuracy: number) => {
+    readonly min: 95;
+    readonly label: "PERFECT!";
+} | {
+    readonly min: 90;
+    readonly label: "EXCELLENT!";
+} | {
+    readonly min: 85;
+    readonly label: "GREAT!";
+} | {
+    readonly min: 80;
+    readonly label: "GOOD!";
+} | {
+    readonly min: 70;
+    readonly label: "NICE TRY!";
+} | {
+    readonly min: 0;
+    readonly label: "KEEP TRYING!";
+};

package/lib/typescript/src/games/perfect-circle/PerfectCircleScene.d.ts

@@ -0,0 +1,32 @@
+import { type Entity, type Vec3, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './PerfectCircleConstants';
+import type { Point } from './PerfectCircleRules';
+export type Scene = {
+    backdrop: Entity;
+    plate: Entity;
+    ring: Entity;
+    tip: Entity;
+    /** The stroke's segments and joints, in drawing order. */
+    stroke: Entity[];
+    fit: Entity[];
+};
+/** A view point on the plate, in the world. */
+export declare const toWorld: (l: Layout, p: Point, z?: number) => Vec3;
+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 finger's first point: the pen tip comes down there. */
+export declare function beginStroke(world: World, l: Layout, s: Scene, p: Point): void;
+/** The stroke reaches a new point: a segment out to it and a joint there; the pen tip follows. */
+export declare function extendStroke(world: World, l: Layout, s: Scene, from: Point, to: Point): void;
+/** The finger lifts: the pen tip goes. */
+export declare function endStroke(world: World, s: Scene): void;
+/** The verdict: the stroke tints to green or red with a pulse, and the best-fit circle traces round over it. */
+export declare function verdict(world: World, l: Layout, s: Scene, won: boolean, fit: {
+    cx: number;
+    cy: number;
+    r: number;
+} | null, theme: GameTheme): void;
+/** Clears the stroke and the trace (a new game). */
+export declare function clearStroke(world: World, s: Scene): void;

package/lib/typescript/src/games/pipe-connect/PipeConnect.d.ts

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

package/lib/typescript/src/games/pipe-connect/PipeConnectConstants.d.ts

@@ -1,45 +1,49 @@
+import type { TiltView } from '../shared/EngineTilt';
+export declare const TIME_LIMIT = 120;
+export declare const POINTS_PER_PUZZLE = 5000;
+/** The grid is 7 x 7 on a phone, 8 x 8 on a tablet (as the original game decided it). */
+export declare const gridSizeFor: (tablet: boolean) => 8 | 7;
 export declare enum PipeType {
     EMPTY = "empty",
-    STRAIGHT = "straight",// vertical or horizontal
-    CORNER = "corner",// 90° bend
-    CROSS = "cross",// 4-way intersection
-    T_SHAPE = "t-shape",// 3-way T junction
-    SOURCE = "source",// water source (fixed)
+    STRAIGHT = "straight",
+    CORNER = "corner",
+    CROSS = "cross",
+    T_SHAPE = "t-shape",
+    SOURCE = "source",
     SINK = "sink"
 }
+/** Open sides, as a bitmask. */
 export declare const DIRECTION: {
     readonly TOP: 1;
     readonly RIGHT: 2;
     readonly BOTTOM: 4;
     readonly LEFT: 8;
 };
+/** Each piece's open sides at rotations 0..3 (a quarter turn clockwise each). */
 export declare const PIPE_OPENINGS: Record<PipeType, number[]>;
-export declare const PIPE_CONNECT_GAME_CONFIG: {
-    readonly GRID_COLS: 7 | 8;
-    readonly GRID_ROWS: 7 | 8;
-    readonly GRID_PADDING: 16 | 12;
-    readonly CELL_SIZE: number;
-    readonly GAME_WIDTH: number;
-    readonly TIME_LIMIT: 300;
-    readonly POINTS_PER_PUZZLE: 5000;
-    readonly TIME_BONUS_MULTIPLIER: 5;
+export declare const TURN_TIME = 0.2;
+export declare const FLOW_STEP = 0.045;
+export declare const WIN_STEP = 0.03;
+/** The camera leans back from straight down, so the pipes stand up off their tiles. */
+export declare const TILT = 0.32;
+/** 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 COLORS: {
+    readonly PIPE: "#8B9DC3";
+    readonly WATER: "#4FC3F7";
+    readonly SOURCE: "#4CAF50";
+    readonly SINK: "#FF7043";
+    readonly CLASSIC_BOARD: "rgba(255, 255, 255, 0.30)";
+    readonly CLASSIC_CELL: "rgba(255, 255, 255, 0.10)";
 };
-export declare const PIPE_CONNECT_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly PIPE_BODY: "#8B9DC3";
-    readonly PIPE_HIGHLIGHT: "#B0C4DE";
-    readonly PIPE_SHADOW: "#4A5568";
-    readonly PIPE_INNER: "#2D3748";
-    readonly WATER_COLOR: "#4FC3F7";
-    readonly WATER_GLOW: "#81D4FA";
-    readonly WATER_DARK: "#0288D1";
-    readonly SOURCE_COLOR: "#4CAF50";
-    readonly SOURCE_GLOW: "#81C784";
-    readonly SINK_COLOR: "#FF7043";
-    readonly SINK_GLOW: "#FF8A65";
-    readonly GRID_BACKGROUND: "rgba(255, 255, 255, 0.14)";
-    readonly GRID_BORDER: "rgba(255, 255, 255, 0.15)";
-    readonly CELL_BACKGROUND: "rgba(255, 255, 255, 0.10)";
-    readonly CELL_BORDER: "rgba(255, 255, 255, 0.1)";
+export type Layout = TiltView & {
+    size: number;
+    cell: number;
+    padding: number;
+    board: number;
 };
+/** Whole-point cells as wide as the game area allows (as the original board), smaller if the screen is short. */
+export declare function getLayout(width: number, height: number, offset: number, size: number): Layout;
+export declare const isTabletWidth: (width: number) => boolean;
+/** 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];

package/lib/typescript/src/games/pipe-connect/PipeConnectGame.d.ts

@@ -0,0 +1,40 @@
+import { type Camera, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './PipeConnectConstants';
+import { type PipeCell } from './PipeConnectRules';
+import { type Scene } from './PipeConnectScene';
+export type Phase = 'ready' | 'playing' | 'over';
+export declare function createGame(theme: GameTheme, size: number): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    size: number;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    grid: PipeCell[][];
+    wet: Map<string, number>;
+    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    readonly time: number;
+    won: boolean;
+    onPhase: (_p: Phase) => void;
+    onTime: (_t: number) => void;
+    /** A pipe turned; `solved` when that turn reached the sink. */
+    onTurn: (_solved: boolean) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the board out for the view (first layout, header height, rotation): rebuilt from the puzzle's state. */
+export declare function setLayout(g: Game, l: Layout): void;
+export declare function setTheme(g: Game, theme: GameTheme): void;
+/** Plays the puzzle that's showing. */
+export declare function start(g: Game): void;
+/** A fresh puzzle, 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;
+/** The cell under a view point (as seen on the pipes, a little above the tiles). */
+export declare function cellAt(g: Game, x: number, y: number): [number, number] | null;
+export declare function tap(g: Game, x: number, y: number): void;
+/** Turns the pipe in a cell (not the source, sink or an empty one), then lets the water find its way. */
+export declare function rotateAt(g: Game, row: number, col: number): void;

package/lib/typescript/src/games/pipe-connect/PipeConnectRules.d.ts

@@ -0,0 +1,16 @@
+import { PipeType } from './PipeConnectConstants';
+export interface PipeCell {
+    id: string;
+    row: number;
+    col: number;
+    type: PipeType;
+    rotation: number;
+    filled: boolean;
+    fixed: boolean;
+}
+export declare const getOpenDirections: (cell: PipeCell) => number;
+export declare const findConnectedPath: (grid: PipeCell[][]) => Set<string>;
+export declare const isPuzzleCompleteFromSet: (grid: PipeCell[][], connected: Set<string>) => boolean;
+export declare const isPuzzleComplete: (grid: PipeCell[][]) => boolean;
+export declare const generatePuzzle: (size: number) => PipeCell[][];
+export declare const rotatePipe: (cell: PipeCell) => PipeCell;

package/lib/typescript/src/games/pipe-connect/PipeConnectScene.d.ts

@@ -0,0 +1,28 @@
+import { type Color, type Entity, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './PipeConnectConstants';
+import type { PipeCell } from './PipeConnectRules';
+/** A quarter turn clockwise per rotation step, as seen on the board. */
+export declare const pieceRotation: (rotation: number) => import("@nayan-ui/engine").MutableQuat;
+export type Scene = {
+    backdrop: Entity;
+    panel: Entity;
+    tiles: Entity[];
+    pieces: (Entity | null)[];
+};
+/** A piece's paint: the source green, the sink orange, other pipes steel-blue dry and water-blue wet. */
+export declare const pieceColor: (cell: PipeCell, wet: boolean) => Color;
+export declare function buildScene(world: World, l: Layout, theme: GameTheme, grid: PipeCell[][], wet: ReadonlySet<string>): Scene;
+export declare function removeScene(world: World, s: Scene): void;
+export declare function setSceneTheme(world: World, l: Layout, s: Scene, theme: GameTheme): void;
+/** A pipe swings a quarter turn clockwise into its new rotation, overshooting a touch. */
+export declare function turnPiece(world: World, e: Entity, rotation: number): void;
+/**
+ * The water's reach changed: pipes it now reaches fill one after another out from the source (`order`
+ * is each one's place along the path, `base` the first new one's), and pipes it left drain at once.
+ */
+export declare function flow(world: World, l: Layout, e: Entity, cell: PipeCell, wet: boolean, order: number, base: number): void;
+/** Solved: every pipe the water runs through pulses, out from the source. */
+export declare function winPulse(world: World, l: Layout, e: Entity, order: number): void;
+/** A splash of water at the sink when it fills. */
+export declare function splash(world: World, l: Layout, row: number, col: number): void;

package/lib/typescript/src/games/play-with-tua/PlayWithTua.d.ts

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

package/lib/typescript/src/games/play-with-tua/PlayWithTuaConstants.d.ts

@@ -0,0 +1,64 @@
+import type { Light } from '@nayan-ui/engine';
+import type { GAME_SOUNDS } from '../../services/SoundsService';
+/** Clip IDs are also the names embedded in play-with-tua.glb for other glTF viewers. */
+export declare const PLAY_WITH_TUA_ANIMATIONS: {
+    readonly standing: {
+        readonly duration: 9.6;
+        readonly loop: true;
+    };
+    readonly walking: {
+        readonly duration: 3.75;
+        readonly loop: true;
+    };
+    readonly running: {
+        readonly duration: 3;
+        readonly loop: true;
+    };
+    readonly jumping: {
+        readonly duration: 2.5;
+        readonly loop: false;
+    };
+    readonly waving: {
+        readonly duration: 2.7;
+        readonly loop: false;
+    };
+    readonly winking: {
+        readonly duration: 1.65;
+        readonly loop: false;
+    };
+    readonly dancing: {
+        readonly duration: 5.25;
+        readonly loop: true;
+    };
+    readonly laughing: {
+        readonly duration: 3.6;
+        readonly loop: true;
+    };
+    readonly fighting: {
+        readonly duration: 7.8;
+        readonly loop: false;
+    };
+    readonly falling: {
+        readonly duration: 4.25;
+        readonly loop: false;
+    };
+};
+export type PlayWithTuaAnimation = keyof typeof PLAY_WITH_TUA_ANIMATIONS;
+export interface ActionSoundCue {
+    at: number;
+    sound: keyof typeof GAME_SOUNDS.PLAY_WITH_TUA;
+    once?: boolean;
+}
+/** Contact times sampled from the shipped GLB: no JS skinning or timers during playback. */
+export declare const PLAY_WITH_TUA_SOUND_CUES: Readonly<Record<PlayWithTuaAnimation, readonly ActionSoundCue[]>>;
+/** Feet at y=0, facing +Z. Scale the spawned entity for other sizes. */
+export declare const PLAY_WITH_TUA_HEIGHT = 3.2;
+export declare const PLAY_WITH_TUA_MODEL_SCALE = 1.21;
+export declare const PLAY_WITH_TUA_CAMERA_HEIGHT: number;
+export declare const PLAY_WITH_TUA_WORLD_CAPACITY = 16;
+export declare const PLAY_WITH_TUA_ACTIONS: readonly {
+    id: PlayWithTuaAnimation;
+    label: string;
+}[];
+export declare const PLAY_WITH_TUA_LIGHT: Light;
+export declare const PLAY_WITH_TUA_CONTROLS_HEIGHT = 156;

package/lib/typescript/src/games/play-with-tua/PlayWithTuaGame.d.ts

@@ -0,0 +1,34 @@
+import { type DragEvent, type LoadedModel, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type ActionSoundCue, type PlayWithTuaAnimation } from './PlayWithTuaConstants';
+import { type Scene } from './PlayWithTuaScene';
+export interface Game extends Scene {
+    world: World;
+    phase: 'ready' | 'playing';
+    score: number;
+    move: PlayWithTuaAnimation;
+    angle: number;
+    dragStart: number;
+    dragging: boolean;
+    inputTop: number;
+    inputBottom: number;
+    audible: boolean;
+    moveTime: number;
+    soundTime: number;
+    onSound: (cue: ActionSoundCue) => void;
+    onSilence: () => void;
+    onPhase: (phase: 'ready' | 'playing' | 'over') => void;
+    onScore: (score: number) => void;
+    onMove: (move: PlayWithTuaAnimation) => void;
+}
+export declare function createGame(model: LoadedModel, theme: GameTheme): Game;
+export declare function reset(g: Game): void;
+export declare function start(g: Game): void;
+export declare function selectMove(g: Game, move: PlayWithTuaAnimation): void;
+export declare function cycleMove(g: Game): void;
+export declare function drag(g: Game, event: DragEvent): void;
+export declare function resize(g: Game, width: number, height: number, offset: number): void;
+export declare function setTheme(g: Game, theme: GameTheme): void;
+export declare function tick(g: Game, dt: number): void;
+export declare function setAudible(g: Game, audible: boolean): void;
+export declare function dispose(g: Game): void;

package/lib/typescript/src/games/play-with-tua/PlayWithTuaModel.d.ts

@@ -0,0 +1,9 @@
+import type { ClipOptions, Entity, LoadedModel, World } from '@nayan-ui/engine';
+import { type PlayWithTuaAnimation } from './PlayWithTuaConstants';
+export declare const getCachedCharacter: () => LoadedModel | null;
+export declare function loadCharacter(): Promise<LoadedModel>;
+export declare function spawnCharacter(world: World, model: LoadedModel): Entity;
+/** Native clip playback; independent poses per entity, with no JS vertex updates. */
+export declare function playAnimation(world: World, entity: Entity, animation: PlayWithTuaAnimation, options?: ClipOptions): boolean;
+/** Reusable assets; the game loader advances one builder per frame. */
+export declare function warmAssets(): Iterable<() => unknown>;

package/lib/typescript/src/games/play-with-tua/PlayWithTuaScene.d.ts

@@ -0,0 +1,13 @@
+import type { Camera, Entity, LoadedModel, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+export interface Scene {
+    character: Entity;
+    floor: Entity;
+    camera: Camera;
+}
+export declare function buildScene(world: World, model: LoadedModel, theme: GameTheme): Scene;
+export declare function layoutScene(scene: Scene, width: number, height: number, offset: number): {
+    top: number;
+    bottom: number;
+};
+export declare function setSceneTheme(world: World, scene: Scene, theme: GameTheme): void;

package/lib/typescript/src/games/popit-fidget/PopitFidget.d.ts

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

package/lib/typescript/src/games/popit-fidget/PopitFidgetConstants.d.ts

@@ -1,37 +1,26 @@
-export declare const POPIT_FIDGET_GAME_CONFIG: {
-    readonly GAME_DURATION: 120;
-    readonly POINTS_PER_BUBBLE: 200;
-    readonly COMPLETION_BONUS: 5000;
-    readonly TIME_BONUS_MULTIPLIER: 5;
-    readonly BUBBLE_SIZE: number;
-    readonly ANIMATION_DURATION: 300;
-    readonly PARTICLE_COUNT: 4;
-    readonly PARTICLE_LIFETIME: 800;
-    readonly GRID_SIZE: 6;
+import type { TiltView } from '../shared/EngineTilt';
+export declare const GRID_SIZE = 6;
+export declare const TIME_LIMIT = 120;
+export declare const POINTS_PER_BUBBLE = 250;
+export declare const TIME_WARNING = 10;
+/** One vivid color per row, top to bottom. */
+export declare const ROW_COLORS: readonly ["#FF3B3B", "#32CD32", "#FFD700", "#4DA6FF", "#BF5AF2", "#FF9500"];
+export declare const PRESS_TIME = 0.07;
+export declare const FLIP_TIME = 0.16;
+/** The camera leans back from straight down, so the domes stand up off the sheet. */
+export declare const TILT = 0.4;
+/** Lit from straight overhead with strong ambient, so nothing falls into shadow; surfaces facing up off the sheet (+z) keep their exact color. */
+export declare const LIGHT: import("@nayan-ui/engine").Light;
+export type Layout = TiltView & {
+    bubble: number;
+    spacing: number;
+    /** The sheet: the bubbles plus `GRID_PADDING` all round. */
+    sheet: number;
 };
-export declare const POPIT_FIDGET_ANIMATION_CONFIG: {
-    readonly POP_SCALE: 1.3;
-    readonly POP_DURATION: 200;
-    readonly FADE_DURATION: 300;
-    readonly BOUNCE_SCALE: 0.9;
-    readonly PARTICLE_VELOCITY: 3;
-    readonly PARTICLE_GRAVITY: 0.2;
-};
-export declare const POPIT_FIDGET_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly FIDGET_BORDER: "#333";
-    readonly FIDGET_SHADOW: "rgba(0,0,0,0.45)";
-    readonly POPPED_BUBBLE: "#8a8a8a";
-    readonly PARTICLE_GLOW: "rgba(255,255,255,0.9)";
-    readonly FIDGET_BASE: "#ffffff";
-    readonly BUBBLE_SHADOW: "rgba(0,0,0,0.3)";
-    readonly BUBBLE_HIGHLIGHT: "rgba(255,255,255,0.7)";
-    readonly UI: "#ffffff";
-    readonly GRID_FILL: "rgba(255, 255, 255, 0.30)";
-    readonly GRID_BORDER: "rgba(255, 255, 255, 0.40)";
-    readonly GRID_SHADOW: "rgba(0, 0, 0, 0.5)";
-    readonly GRID_INNER_SHADOW: "rgba(0, 0, 0, 0.15)";
-};
-export declare const RAINBOW_COLORS: readonly ["#FF3B3B", "#32CD32", "#FFD700", "#4DA6FF", "#BF5AF2", "#FF9500"];
-export declare const BUBBLE_COLORS: readonly ["#FF3B3B", "#32CD32", "#FFD700", "#4DA6FF", "#BF5AF2", "#FF9500"];
+/**
+ * A bubble as big as the original grid had it (the game area, 30 narrower than the screen and at most 500
+ * across, filled edge to edge), smaller if the screen is short; the sheet centred under the scoreboard.
+ */
+export declare function getLayout(width: number, height: number, offset: number): Layout;
+/** A bubble's centre on the sheet (row 0 along the top), in world units. */
+export declare function bubbleCentre(l: Layout, row: number, col: number): [number, number];

package/lib/typescript/src/games/popit-fidget/PopitFidgetGame.d.ts

@@ -0,0 +1,37 @@
+import { type Camera, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './PopitFidgetConstants';
+import { type Scene } from './PopitFidgetScene';
+export type Phase = 'ready' | 'playing' | 'over';
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    popped: boolean[];
+    count: number;
+    /** 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;
+    onPop: () => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the scene out for the view (first layout, header height, rotation): rebuilt from the sheet's state. */
+export declare function setLayout(g: Game, l: Layout): void;
+export declare function setTheme(g: Game, theme: GameTheme): void;
+/** A fresh sheet, and the clock running. */
+export declare function start(g: Game): void;
+/** A fresh sheet, 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;
+/** The unpopped bubble under a view point, if any. */
+export declare function bubbleAt(g: Game, x: number, y: number): number | null;
+/** A finger comes down: pops the bubble under it. */
+export declare function press(g: Game, x: number, y: number): void;

package/lib/typescript/src/games/popit-fidget/PopitFidgetScene.d.ts

@@ -0,0 +1,19 @@
+import { type Entity, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './PopitFidgetConstants';
+export type Scene = {
+    backdrop: Entity;
+    sheet: Entity;
+    lip: Entity;
+    domes: Entity[];
+    dimples: Entity[];
+};
+export declare function buildScene(world: World, l: Layout, theme: GameTheme, popped: readonly boolean[]): Scene;
+export declare function removeScene(world: World, s: Scene): void;
+export declare function setSceneTheme(world: World, s: Scene, theme: GameTheme): void;
+/** Pop: the dome squashes flat under the finger and a dimple springs out in its place, with a few flecks. */
+export declare function pop(world: World, l: Layout, s: Scene, index: number): void;
+/** Every bubble back up (a new sheet). */
+export declare function restore(world: World, l: Layout, s: Scene): void;
+/** Confetti over the sheet when every bubble's popped. */
+export declare function celebrate(world: World, l: Layout): void;

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

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