@nayan-ui/games 1.19.0 → 1.21.0

package/lib/typescript/src/games/dino-jump/DinoJumpConstants.d.ts

@@ -1,73 +1,49 @@
-export declare const DINO_JUMP_CONSTANTS: {
-    readonly gravity: 1.4;
-    readonly jumpForce: -28;
-    readonly gameSpeed: 6;
-    readonly baseScore: 1;
-    readonly scoreMultiplier: 1.5;
-    readonly speedIncreaseRate: 0.001;
-    readonly maxSpeed: 12;
-    readonly timeLimit: 120;
-    readonly lives: 3;
-    readonly maxLives: 3;
-};
-export declare const DINO_JUMP_GAME_CONFIG: {
-    readonly SCREEN_WIDTH: number;
-    readonly SCREEN_HEIGHT: number;
-    readonly GROUND_HEIGHT: 150;
-    readonly DINOSAUR_WIDTH: 70;
-    readonly DINOSAUR_HEIGHT: 75;
-    readonly DINOSAUR_X: 50;
-    readonly OBSTACLE_WIDTH: 20;
-    readonly OBSTACLE_HEIGHT: 40;
-    readonly OBSTACLE_SPAWN_DISTANCE: 600;
-    readonly GAME_DURATION: 120;
-    readonly PHYSICS_FRAME_RATE: 60;
-    readonly OBSTACLE_SPAWN_INTERVAL: 2000;
-    readonly JUMP_DURATION: 600;
-    readonly GROUND_SCROLL_SPEED: 4;
-};
-export declare const getGroundHeight: (offset?: number) => number;
-export declare const getGroundY: (offset?: number) => number;
-export declare const DINO_JUMP_ANIMATION_CONFIG: {
-    readonly DINO_JUMP: {
-        readonly damping: 15;
-        readonly stiffness: 300;
-        readonly mass: 1;
-    };
-    readonly OBSTACLE_MOVE: {
-        readonly duration: 3000;
-    };
-    readonly COLLISION_FEEDBACK: {
-        readonly duration: 200;
-        readonly intensity: 0.1;
-    };
-};
-export declare const DINO_JUMP_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly SKY_TOP: "#3a3a5e";
-    readonly SKY_BOTTOM: "#FECFEF";
-    readonly GROUND: "#FFD93D";
-    readonly GROUND_LINE: "#FF6B6B";
-    readonly DINOSAUR_PRIMARY: "#4ECDC4";
-    readonly DINOSAUR_SECONDARY: "#45B7D1";
-    readonly DINOSAUR_OUTLINE: "#2C3E50";
-    readonly OBSTACLE_PRIMARY: "#2ECC71";
-    readonly OBSTACLE_SECONDARY: "#27AE60";
-    readonly OBSTACLE_OUTLINE: "#1E8449";
-    readonly TEXT_PRIMARY: "#FFFFFF";
-    readonly TEXT_SECONDARY: "#ECF0F1";
-    readonly CLOUD_COLOR: "#FFFFFF";
-    readonly CLOUD_SHADOW: "rgba(52, 152, 219, 0.2)";
-};
-export declare const DINOSAUR_STATES: {
-    readonly RUNNING: "running";
-    readonly JUMPING: "jumping";
-    readonly DUCKING: "ducking";
-    readonly DEAD: "dead";
-};
-export declare const OBSTACLE_TYPES: {
-    readonly CACTUS_SMALL: "cactus_small";
-    readonly CACTUS_LARGE: "cactus_large";
-    readonly BIRD: "bird";
+import type { MeadowOptions, Rig } from '../shared/EngineMeadow';
+export declare const TIME_LIMIT = 120;
+export declare const LIVES = 3;
+export declare const POINTS_PER_SECOND = 200;
+export declare const MUSHROOM_POINTS = 1000;
+export type ObstacleKind = 'cactus_small' | 'cactus_large' | 'mushroom';
+/** Each obstacle's size in screen points (its collision box, and what's drawn). */
+export declare const OBSTACLE_SIZE: Record<ObstacleKind, {
+    width: number;
+    height: number;
+}>;
+export declare const MUSHROOM_CHANCE = 0.05;
+export declare const SMALL_CHANCE = 0.5;
+export declare const STEP: number;
+export declare const STEP_TOLERANCE = 0.002;
+export declare const MAX_PENDING = 0.05;
+export declare const GRAVITY = 1.4;
+export declare const JUMP_FORCE = -28;
+export declare const RUN_SPEED = 6;
+export declare const DINO_X = 50;
+export declare const DINO_WIDTH = 70;
+export declare const DINO_HEIGHT = 75;
+export declare const DINO_HIT_WIDTH = 50;
+export declare const DINO_HIT_HEIGHT = 60;
+export declare const MAX_OBSTACLES = 5;
+export declare const MIN_OBSTACLE_GAP = 300;
+export declare const REMOVE_X = -100;
+export declare const FIRST_OBSTACLE = 1.5;
+export declare const SPAWN_MIN = 2.5;
+export declare const SPAWN_SPREAD = 2;
+export declare const STRIDE_TIME = 0.16;
+export declare const DUST_INTERVAL = 0.24;
+/** The screen line the dino runs on: higher with no header, as the original ground strip was. */
+export declare const groundLine: (height: number, offset: number) => number;
+/**
+ * A low camera over the desert floor, at the height that puts the real ground under the play plane
+ * exactly on the original game's ground line: the dino runs on the sand, which runs on to the horizon.
+ */
+export declare function rigFor(height: number, offset: number): Rig;
+export declare const MEADOW: MeadowOptions;
+/** The scrolling desert floor comes in tiles this many metres wide (three cover any view). */
+export declare const TILE = 80;
+export type Layout = {
+    width: number;
+    height: number;
+    offset: number;
+    groundY: number;
 };
+export declare const getLayout: (width: number, height: number, offset: number) => Layout;

package/lib/typescript/src/games/dino-jump/DinoJumpGame.d.ts

@@ -0,0 +1,60 @@
+import { type Camera, type Color, type Entity, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type View3D } from '../shared/EngineMeadow';
+import { type Layout, type ObstacleKind } from './DinoJumpConstants';
+import { type DinoView, type Tiles } from './DinoJumpScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** An obstacle: its box's left edge (screen points). */
+type Obstacle = {
+    kind: ObstacleKind;
+    x: number;
+    root: Entity;
+};
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    tint: Color;
+    layout: Layout | null;
+    view: View3D | null;
+    scenery: Entity[];
+    desert: Tiles | null;
+    dino: DinoView | null;
+    phase: Phase;
+    /** Score, lives and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    readonly lives: number;
+    readonly timeLeft: number;
+    won: boolean;
+    /** Game clock, seconds: drives the spawns and the dust (it pauses with the frame loop). */
+    time: number;
+    pending: number;
+    /** The dino's height above the ground (points, negative is up) and its vertical speed. */
+    jumpY: number;
+    velocity: number;
+    jumping: boolean;
+    /** How far the desert has scrolled, in points at the play plane. */
+    scroll: number;
+    dustTimer: number;
+    obstacles: Obstacle[];
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onLives: (_n: number) => void;
+    onTime: (_t: number) => void;
+    onJump: () => void;
+    onHit: (_last: boolean) => void;
+    onCollect: () => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the world out for the view and header (the camera height follows the ground line). */
+export declare function setLayout(g: Game, l: Layout): void;
+/** A new theme: day or night (the screen swaps the light); the run carries on. */
+export declare function setTheme(g: Game, theme: GameTheme): void;
+export declare function start(g: Game): void;
+/** A fresh run (Stop, Play Again): the dino back on the ground, standing. 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;
+/** Finger down: jump, if on the ground. */
+export declare function jump(g: Game): void;
+export {};

package/lib/typescript/src/games/dino-jump/DinoJumpScene.d.ts

@@ -0,0 +1,35 @@
+import { type Color, type Entity, type TransformBatch, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type View3D } from '../shared/EngineMeadow';
+import { type Layout, type ObstacleKind } from './DinoJumpConstants';
+/** An obstacle standing on the ground line, its box's left edge at screen x. */
+export declare function spawnObstacle(world: World, v: View3D, l: Layout, kind: ObstacleKind, x: number, tint: Color): Entity;
+export declare function placeObstacle(world: World, v: View3D, l: Layout, e: Entity, kind: ObstacleKind, x: number, updates?: TransformBatch): void;
+export type DinoView = {
+    root: Entity;
+    body: Entity;
+    near: Entity;
+    far: Entity;
+};
+/** The dino, its feet on screen point (x, y) (its box's bottom middle). */
+export declare function spawnDino(world: World, v: View3D, x: number, y: number, tint: Color): DinoView;
+export declare const dinoCentre: (x: number) => number;
+export declare function placeDino(world: World, v: View3D, d: DinoView, x: number, y: number): void;
+/** Running: the legs swing in turn and the body bobs; otherwise they hold a pose (tucked in the air). */
+export declare function setGait(world: World, v: View3D, d: DinoView, gait: 'stand' | 'run' | 'air'): void;
+/** A hit: the dino flashes red and shakes. */
+export declare function hurtDino(world: World, d: DinoView, tint: Color): void;
+/** A mushroom eaten: a golden glow. */
+export declare function cheerDino(world: World, d: DinoView, tint: Color): void;
+/** A puff of sand at screen point (x, y): kicked up running, or a bigger one landing. */
+export declare function dust(world: World, v: View3D, x: number, y: number, big: boolean): void;
+/** Bits fly where the dino hit an obstacle (green and sand for a cactus, red and white for a mushroom). */
+export declare function hitBurst(world: World, v: View3D, x: number, y: number, mushroom: boolean): void;
+export type Tiles = {
+    roots: Entity[];
+};
+/** Three desert tiles side by side, each its floor with its plants and rocks as children. */
+export declare function spawnDesert(world: World, theme: GameTheme, runZ: number): Tiles;
+/** Scrolls the desert `travelled` metres: each tile wraps round to the far side once it's well out of view. */
+export declare function placeDesert(world: World, t: Tiles, travelled: number): void;
+export declare function removeDesert(world: World, t: Tiles): void;

package/lib/typescript/src/games/dots-and-boxes/DotsAndBoxes.d.ts

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

package/lib/typescript/src/games/dots-and-boxes/DotsAndBoxesConstants.d.ts

@@ -1,37 +1,32 @@
-export declare const DOTS_AND_BOXES_COLORS: {
-    BACKGROUND: string;
-    PRIMARY: string;
-    DOT_HIGHLIGHT: string;
-    DOT_BASE: string;
-    DOT_SHADOW: string;
-    DOT_RING: string;
-    LINE_INACTIVE: string;
-    LINE_INACTIVE_HOVER: string;
-    LINE_PLAYER: string;
-    LINE_PLAYER_LIGHT: string;
-    LINE_PLAYER_DARK: string;
-    LINE_PLAYER_GLOW: string;
-    LINE_OPPONENT: string;
-    LINE_OPPONENT_LIGHT: string;
-    LINE_OPPONENT_DARK: string;
-    LINE_OPPONENT_GLOW: string;
-    BOX_PLAYER: string;
-    BOX_PLAYER_GRAD_TOP: string;
-    BOX_PLAYER_GRAD_BOTTOM: string;
-    BOX_PLAYER_BORDER: string;
-    BOX_OPPONENT: string;
-    BOX_OPPONENT_GRAD_TOP: string;
-    BOX_OPPONENT_GRAD_BOTTOM: string;
-    BOX_OPPONENT_BORDER: string;
-    PLAYER_COLOR: string;
-    OPPONENT_COLOR: string;
-    BOARD_BG: string;
-    BOARD_BORDER: string;
-};
-export declare const DOTS_AND_BOXES_GAME_CONFIG: {
-    GRID_SIZE: number;
-    DOT_RADIUS: number;
-    LINE_WIDTH: number;
-    BOARD_PADDING: number;
-    ANIMATION_DURATION: number;
+import type { TiltView } from '../shared/EngineTilt';
+export declare const GRID_SIZE = 6;
+export declare const BOX_POINTS = 2000;
+export declare const PLAYER_COLOR = "#34D399";
+export declare const OPPONENT_COLOR = "#F87171";
+export declare const DOT_COLOR = "#D5DCE6";
+export declare const CLASSIC_BOARD = "rgba(255, 255, 255, 0.25)";
+export declare const CLASSIC_RIM = "rgba(255, 255, 255, 0.3)";
+export declare const CLASSIC_SLOT = "rgba(255, 255, 255, 0.3)";
+export declare const AI_FIRST_DELAY = 1;
+export declare const AI_CHAIN_DELAY = 0.8;
+export declare const LINE_TIME = 0.22;
+export declare const BOX_TIME = 0.32;
+/** The camera leans back this far from straight down, so the studs, rods and tiles read as 3D. */
+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 type Layout = TiltView & {
+    boardSize: number;
+    /** From the board's edge to the outer dots' centres. */
+    padding: number;
+    /** Between neighbouring dots. */
+    cell: number;
+    dotRadius: number;
+    lineWidth: number;
+    /** Height of the board's top face. */
+    boardTop: number;
 };
+/** The board as wide as the game area, centred between the scoreboard and the controls. */
+export declare function getLayout(width: number, height: number, offset: number): Layout;
+/** A dot's centre on the board (row 0 along the top), in world units. */
+export declare function dotPoint(l: Layout, row: number, col: number): [number, number];

package/lib/typescript/src/games/dots-and-boxes/DotsAndBoxesGame.d.ts

@@ -0,0 +1,44 @@
+import { type Camera, type Entity, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './DotsAndBoxesConstants';
+import { type Board } from './DotsAndBoxesScene';
+export type Phase = 'ready' | 'playing' | 'over';
+export type Turn = 'player' | 'opponent';
+export type GameEvent = 'line' | 'box';
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    board: Board | null;
+    phase: Phase;
+    turn: Turn;
+    /** Who drew each line (0 = nobody yet). */
+    lines: Uint8Array<ArrayBuffer>;
+    /** Who claimed each box (0 = nobody yet). */
+    boxes: Uint8Array<ArrayBuffer>;
+    sideCounts: Uint8Array<ArrayBuffer>;
+    drawn: number;
+    rods: Entity[];
+    tiles: Entity[];
+    playerScore: number;
+    opponentScore: number;
+    won: boolean;
+    onPhase: (_p: Phase) => void;
+    onScores: (_player: number, _opponent: number) => void;
+    onTurn: (_t: Turn) => void;
+    onEvent: (_e: GameEvent, _who: Turn) => 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;
+export declare function start(g: Game): void;
+/** A fresh board (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 open line nearest a view point, if the point is close enough to it. */
+export declare function lineAt(g: Game, x: number, y: number): number | null;
+/** A tap: draws the line under it on your turn. */
+export declare function tap(g: Game, x: number, y: number): void;

package/lib/typescript/src/games/dots-and-boxes/DotsAndBoxesScene.d.ts

@@ -0,0 +1,31 @@
+import { type Entity, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './DotsAndBoxesConstants';
+export type Owner = 1 | 2;
+export type LineKind = 'h' | 'v';
+export declare function boxCentre(l: Layout, row: number, col: number): [number, number];
+export type Board = {
+    backdrop: Entity;
+    panel: Entity;
+    rim: Entity | null;
+    studs: Entity[];
+    /** One per line, in the game's line order. */
+    slots: Entity[];
+};
+/** The backdrop, the board and its rim, the studs and every line's groove. `lines` lists them in the game's order. */
+export declare function buildBoard(world: World, l: Layout, theme: GameTheme, lines: readonly {
+    kind: LineKind;
+    row: number;
+    col: number;
+}[]): Board;
+export declare function removeBoard(world: World, b: Board): void;
+/** A new theme: backdrop, board, rim and grooves repainted; the studs, rods and tiles keep their colors. */
+export declare function setBoardTheme(world: World, l: Layout, b: Board, theme: GameTheme): void;
+/** A played line's rod; with `animate`, it drops in and grows out from its middle with a bright flash. */
+export declare function spawnRod(world: World, l: Layout, kind: LineKind, row: number, col: number, owner: Owner, animate: boolean): Entity;
+/** A claimed box's tile; with `animate`, it springs up out of the board and throws a little confetti. */
+export declare function spawnTile(world: World, l: Layout, row: number, col: number, owner: Owner, animate: boolean): Entity;
+/** Confetti over the board when you win. */
+export declare function celebrate(world: World, l: Layout): void;
+/** Hides a line's groove under its rod (or shows it again on a reset). */
+export declare function showSlot(world: World, b: Board, index: number, on: boolean): void;

package/lib/typescript/src/games/falling-sticks/FallingSticks.d.ts

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

package/lib/typescript/src/games/falling-sticks/FallingSticksConstants.d.ts

@@ -1,44 +1,32 @@
-export declare const SCREEN_W: number;
-export declare const SCREEN_H: number;
-export declare const STICK_LEN: number;
-export declare const STICK_W: number;
-export declare const STICK_CANVAS: number;
-export declare const STICK_HALF: number;
-export declare const HIT_RADIUS: number;
-export declare const SPAWN_MARGIN: number;
-export declare const FLOOR_Y: number;
-export declare const FALLING_STICKS_TIME_LIMIT = 120;
-export declare const FALLING_STICKS_CONFIG: {
-    readonly MAX_STICKS: 18;
-    readonly LIVES: 3;
-    readonly POINTS_PER_CATCH: 500;
-    readonly BASE_FALL_SPEED: 2.4;
-    readonly SPEED_INC_PER_POINT: 0.0015;
-    readonly MAX_FALL_SPEED: 3.8;
-    readonly BASE_SPAWN_MS: 1450;
-    readonly SPAWN_DEC_PER_POINT: 0.6;
-    readonly MIN_SPAWN_MS: 1000;
-    readonly SPIN_MAX: 2.2;
-    readonly LAND_TILT_MAX: 12;
+export declare const TIME_LIMIT = 120;
+export declare const LIVES = 3;
+export declare const POINTS_PER_CATCH = 500;
+export declare const MAX_STICKS = 18;
+export declare const BASE_FALL_SPEED = 2.4;
+export declare const SPEED_INC_PER_POINT = 0.00006;
+export declare const MAX_FALL_SPEED = 3.8;
+export declare const BASE_SPAWN_MS = 1450;
+export declare const SPAWN_DEC_PER_POINT = 0.012;
+export declare const MIN_SPAWN_MS = 1000;
+export declare const SPIN_MAX = 2.2;
+export declare const LAND_TILT_MAX = 6;
+/** The first stick of a run drops almost at once. */
+export declare const FIRST_SPAWN_TIMER: number;
+export declare const STEP_MS: number;
+export declare const MAX_PENDING_MS = 50;
+export declare const STICK_COLORS: readonly ["#E53935", "#1E88E5", "#43A047", "#FB8C00", "#8E24AA", "#00ACC1", "#F4511E", "#FDD835"];
+export type Layout = {
+    width: number;
+    height: number;
+    left: number;
+    right: number;
+    spawnY: number;
+    stickLen: number;
+    stickW: number;
+    hitRadius: number;
+    spawnMargin: number;
+    /** Sticks are missed once their centre passes this line (the grass). */
+    floorY: number;
 };
-export declare const FALLING_STICKS_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-};
-export declare const STICK_COLORS: {
-    top: string;
-    bottom: string;
-    rim: string;
-    highlight: string;
-}[];
-export declare const STICK_SHADOW = "rgba(0,0,0,0.35)";
-export declare const GROUND: {
-    readonly bodyTop: "#3C7D33";
-    readonly bodyBottom: "#123A16";
-    readonly bladeBackTop: "#4E9B40";
-    readonly bladeBackBottom: "#2C6A28";
-    readonly bladeFrontTop: "#84C468";
-    readonly bladeFrontBottom: "#4E9B40";
-    readonly surfaceHighlight: "rgba(255,255,255,0.12)";
-};
-export declare const GRASS_BLADE_H = 18;
+/** Keep catches below the HUD, above the controls and inside the centered, capped play width. */
+export declare function getLayout(width: number, height: number, offset?: number): Layout;

package/lib/typescript/src/games/falling-sticks/FallingSticksGame.d.ts

@@ -0,0 +1,42 @@
+import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './FallingSticksConstants';
+import { type Field } from './FallingSticksRules';
+import { type Scene } from './FallingSticksScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** catch: a stick caught (one per stick); miss: one landed (one per stick); win / lose: how it ended. */
+export type GameEvent = 'catch' | 'miss' | 'win' | 'lose';
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    field: Field;
+    /** Score, lives and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly lives: number;
+    readonly score: number;
+    readonly timeLeft: number;
+    won: boolean;
+    /** The finger's recent points, for its trail (only while playing). */
+    trail: number[];
+    pending: number;
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onLives: (_l: number) => void;
+    onTime: (_t: number) => void;
+    onEvent: (_e: GameEvent) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the field out for the view (first layout, header height, rotation), or the night sky for a dark theme: rebuilt where things stand. */
+export declare function setLayout(g: Game, l: Layout): void;
+/** Change the scenery in place while preserving the current run and stick colors. */
+export declare function setTheme(g: Game, theme: GameTheme): void;
+export declare function start(g: Game): void;
+/** Back to an empty field, 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;
+/** Down catches the sticks under the finger at once; moving catches every stick it passes over, leaving a trail. */
+export declare function drag(g: Game, { phase, x, y, cancelled }: DragEvent): void;

package/lib/typescript/src/games/falling-sticks/FallingSticksRules.d.ts

@@ -0,0 +1,36 @@
+import { type Layout } from './FallingSticksConstants';
+export declare const FREE = 0;
+export declare const FALLING = 1;
+/** Lying on the ground: stays visible, so its slot isn't reused. */
+export declare const LANDED = 2;
+/** One pool slot, in view points (x right, y down) and degrees (clockwise). */
+export type Stick = {
+    state: number;
+    color: number;
+    x: number;
+    y: number;
+    speed: number;
+    rot: number;
+    rotSpeed: number;
+    restY: number;
+    restRot: number;
+};
+export type Field = {
+    sticks: Stick[];
+    spawnTimer: number;
+    score: number;
+    nextColor: number;
+};
+export declare const newField: () => Field;
+/**
+ * One 60 Hz frame with `lives` left: sticks fall and spin, land (each a life), and maybe one spawns.
+ * Returns the slots that landed and spawned, and the lives left.
+ */
+export declare function step(f: Field, l: Layout, lives: number): {
+    landed: number[];
+    spawned: number;
+    lives: number;
+};
+/** Catch along the entire swipe and the stick's rotated length, so fast swipes and tip taps count. */
+export declare function catchAlong(f: Field, l: Layout, fromX: number, fromY: number, x: number, y: number): number[];
+export declare const catchAt: (f: Field, l: Layout, x: number, y: number) => number[];

package/lib/typescript/src/games/falling-sticks/FallingSticksScene.d.ts

@@ -0,0 +1,26 @@
+import { type Entity, type TransformBatch, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type View3D } from '../shared/EngineMeadow';
+import { type Layout } from './FallingSticksConstants';
+import type { Stick } from './FallingSticksRules';
+export type Scene = {
+    view: View3D;
+    scenery: Entity[];
+    sticks: Entity[];
+    trail: Entity[];
+    tumble: number[];
+};
+export declare function buildScene(world: World, l: Layout, theme: GameTheme): Scene;
+export declare function removeScene(world: World, s: Scene): void;
+export declare function placeStick(world: World, _l: Layout, s: Scene, i: number, st: Stick, spinning?: boolean, updates?: TransformBatch): void;
+/** Reuse a pooled baton, including its color and native animation state. */
+export declare function showStick(world: World, l: Layout, s: Scene, i: number, st: Stick): void;
+export declare function hideStick(world: World, s: Scene, i: number): void;
+/** A soft landing bounce followed by a tumble into the grass. */
+export declare function landStick(world: World, l: Layout, s: Scene, i: number, st: Stick): void;
+/** Flash and pop the full baton, with a ring, flying chips and sparks along its length. */
+export declare function popStick(world: World, l: Layout, s: Scene, i: number, st: Stick): void;
+/** Connected tapered segments stay continuous even when touch events are far apart. */
+export declare function drawTrail(world: World, _l: Layout, s: Scene, points: number[]): void;
+export declare function fadeTrail(world: World, s: Scene): void;
+export declare function celebrate(world: World, l: Layout, s: Scene): void;

package/lib/typescript/src/games/find-different-number/FindDifferentNumber.d.ts

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

package/lib/typescript/src/games/find-different-number/FindDifferentNumberConstants.d.ts

@@ -1,31 +1,35 @@
-export declare const GRID_SIZE = 10;
-export declare const TOTAL_CELLS: number;
-export declare const DIFFERENT_COUNT = 10;
-export declare const TILE_SIZE: number;
-export declare const BOARD_WIDTH: number;
-export declare const BOARD_HEIGHT: number;
-export declare const PLAY_WIDTH: number;
-export declare const PLAY_HEIGHT: number;
-export declare const FIND_DIFF_GAME_CONFIG: {
-    readonly TILE_GAP: 4 | 6;
-    readonly BOARD_PADDING: 0;
-    readonly MAX_BOARD_WIDTH: number;
-    readonly TILE_RADIUS: 12 | 9;
-    readonly GAME_DURATION: 60;
-    readonly POINTS_PER_ROUND: 1000;
-    readonly TIME_BONUS_PER_ROUND: 5;
+import type { TiltView } from '../shared/EngineTilt';
+export declare const GAME_DURATION = 120;
+export declare const POINTS_PER_FIND = 500;
+export declare const WRONG_PENALTY = 3;
+export declare const COLORS: {
+    readonly CLASSIC_BOARD: "rgba(255, 255, 255, 0.10)";
+    readonly CLASSIC_RIM: "rgba(255, 255, 255, 0.35)";
+    readonly LIGHT_BOARD: "#D3DBE8";
+    readonly LIGHT_RIM: "#AEBBD0";
+    readonly TILE: "#FFFFFF";
+    readonly TEXT: "#0D1757";
+    readonly FOUND: "#4FC562";
+    readonly FOUND_TEXT: "#FFFFFF";
+    readonly WRONG: "#FF5252";
 };
-export declare const FIND_DIFF_ANIMATION_CONFIG: {
-    readonly CORRECT_SCALE: 1.06;
-    readonly WRONG_SHAKE_DURATION: 300;
-    readonly LEVEL_TRANSITION: 350;
-};
-export declare const FIND_DIFF_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly TILE_BG: "rgba(255, 255, 255, 0.25)";
-    readonly TILE_BG_FOUND: "rgba(76, 175, 80, 0.55)";
-    readonly WRONG_FLASH: "#ff5252";
-    readonly CORRECT_FLASH: "#4CAF50";
-    readonly TEXT_PRIMARY: "#FFFFFF";
+/** The camera looks straight down at the board. */
+export declare const TILT = 0;
+/** Evenly lit, straight from the camera and all ambient: every face keeps its exact color, with no shading anywhere. */
+export declare const LIGHT: import("@nayan-ui/engine").Light;
+/** A tile's height, of its width. */
+export declare const TILE_HEIGHT = 0.2;
+export declare const FOUND_SCALE = 1.18;
+export type Layout = TiltView & {
+    tile: number;
+    gap: number;
+    pitch: number;
+    pad: number;
+    size: number;
 };
+/** Tiles as wide as the screen allows (as the original grid), smaller if the screen is short. */
+export declare function getLayout(width: number, height: number, offset: number, tablet: boolean): Layout;
+/** A cell's centre (row 0 along the top), in world units. */
+export declare const cellCentre: (l: Layout, i: number) => [number, number];
+/** The cell under a board point (on a tile, not the gap between), or -1. */
+export declare function cellAt(l: Layout, x: number, y: number): number;