@nayan-ui/games 1.19.0 → 1.20.0

package/lib/typescript/src/games/space-fighter/SpaceFighterScene.d.ts

@@ -0,0 +1,51 @@
+import { type Entity, type MutableQuat, type Quat, type Vec3, type World } from '@nayan-ui/engine';
+import { type Layout } from './SpaceFighterConstants';
+/** A screen point on the play plane (or `depth` ahead), in world units. */
+export declare const toWorld: (l: Layout, x: number, y: number, depth?: number) => Vec3;
+/** The ship's lean and bank; pass `out` to reuse it (the result is only valid until the next call with it). */
+export declare const shipRotation: (bank: number, out?: MutableQuat) => Quat;
+export type Ship = {
+    root: Entity;
+    body: Entity;
+    flames: Entity[];
+};
+export declare function spawnShip(world: World, l: Layout, x: number): Ship;
+/** The exhausts flicker; dragging (thrusters on) burns them bigger and white-blue. */
+export declare function flicker(world: World, _l: Layout, s: Ship, boost: boolean): void;
+/** A run starts: the ship zooms up into place from below the screen. */
+export declare function launchShip(world: World, l: Layout, s: Ship): void;
+export declare function placeShip(world: World, l: Layout, s: Ship, x: number, bank: number): void;
+/** Hit: the ship barrel-rolls off the blow and blinks through its safe spell. */
+export declare function blinkShip(world: World, s: Ship): void;
+export declare function steadyShip(world: World, s: Ship): void;
+export type Belt = {
+    root: Entity;
+};
+/**
+ * A pair's two belts of tumbling asteroids, its top edge at screen y: one from the left edge to the
+ * gap's left side, one from its right side to the right edge. The rocks reach the gap's edges exactly,
+ * as the belts' hitboxes do, with smaller ones filling the corners; sizes vary along each belt.
+ */
+export declare function spawnBelts(world: World, l: Layout, top: number, gapLeft: number, seed: number): Belt;
+export declare function placeBelts(world: World, l: Layout, b: Belt, top: number): void;
+/** A hit: fire and debris where the ship struck. */
+export declare function explode(world: World, l: Layout, x: number, y: number): void;
+/** A ringed ice planet: banded in pale blues and teals, its rings tilted round it. */
+export type Space = {
+    all: Entity[];
+    /** The sun (day) or the moon (night), with its glow. */ sky: Entity[];
+    stars: {
+        e: Entity;
+        x: number;
+        y: number;
+        z: number;
+        since: number;
+    }[];
+};
+export declare const STAR_DRIFT = 5;
+/** A new theme: the sun comes out by day, the moon by night. */
+export declare function setSpaceTheme(world: World, l: Layout, space: Space, day: boolean): void;
+export declare function spawnSpace(world: World, l: Layout, clock: number, day: boolean): Space;
+/** Stars that have drifted below the view come back in above it. */
+export declare function wrapStars(world: World, s: Space, clock: number): void;
+export declare function removeAll(world: World, entities: Entity[]): void;

package/lib/typescript/src/games/spider-solitaire/SpiderSolitaire.d.ts

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

package/lib/typescript/src/games/spider-solitaire/SpiderSolitaireConstants.d.ts

@@ -1,37 +1,54 @@
-export declare const SMALL_CARD_WIDTH: number;
-export declare const SMALL_CARD_HEIGHT: number;
-export declare const CARD_WIDTH: number;
-export declare const CARD_HEIGHT: number;
-export declare const CARD_OVERLAP: number;
-export declare const CARD_FACE_DOWN_OVERLAP: number;
-export declare const SPIDER_SOLITAIRE_COLORS: {
-    BACKGROUND: string;
-    PRIMARY: string;
-    CARD_BACK: string;
-    CARD_FRONT: string;
-    CARD_RED: string;
-    CARD_BLACK: string;
-    EMPTY_PILE: string;
-    SELECTED_BORDER: string;
-    CARD_SHADOW: string;
+import { type TiltView } from '../shared/EngineTilt';
+import type { Suit } from './SpiderSolitaireRules';
+/** A win scores by its time against ten minutes, as the original game did. */
+export declare const EXPECTED_TIME = 600;
+export declare const BASE_SCORE = 100;
+export declare const TAP_SLOP = 10;
+export declare const MOVE_TIME = 0.24;
+export declare const DEAL_STAGGER = 0.05;
+export declare const RUN_STAGGER = 0.045;
+export declare const WIN_DELAY = 1.1;
+export declare const COLORS: {
+    readonly FACE: "#FFFFFF";
+    readonly BACK: "#1565C0";
+    readonly BACK_LIGHT: "#3B82D6";
+    readonly BACK_FRAME: "#E3F2FD";
+    readonly RED: "#DC2626";
+    readonly BLACK: "#1F2937";
+    readonly SELECTED: "#FFE082";
+    readonly CLASSIC_SLOT: "rgba(255, 255, 255, 0.35)";
 };
-export declare const SPIDER_SOLITAIRE_GAME_CONFIG: {
-    SCREEN_WIDTH: number;
-    SCREEN_HEIGHT: number;
-    CARD_WIDTH: number;
-    CARD_HEIGHT: number;
-    CARD_OVERLAP: number;
-    CARD_FACE_DOWN_OVERLAP: number;
-    PILE_SPACING: number;
-    FOUNDATION_TOP: number;
-    TABLEAU_TOP: number;
-};
-export declare const SPIDER_SOLITAIRE_CONSTANTS: {
-    maxTime: number;
-};
-export declare const SUITS: readonly ["hearts", "diamonds", "clubs", "spades"];
-export declare const VALUES: readonly ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"];
-export type Suit = (typeof SUITS)[number];
-export type Value = (typeof VALUES)[number];
-export declare const SUIT_SYMBOLS: Record<Suit, string>;
 export declare const SUIT_COLORS: Record<Suit, string>;
+/** The camera leans back a little from straight down, so the cards' thickness and the stacks read as 3D. */
+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 is 1.4 times as tall as it is wide, and this thin (of its width). */
+export declare const CARD_RATIO = 1.4;
+export declare const THICKNESS = 0.024;
+/** How far down a pile each card shows below the one under it (of a card's height), as the original piles. */
+export declare const FACE_DOWN_STEP = 0.15;
+export declare const FACE_UP_STEP = 0.25;
+/** The deck and the finished runs along the bottom are drawn at this size. */
+export declare const SMALL = 0.74;
+export type Layout = TiltView & {
+    /** A tableau card's width and height. */
+    card: number;
+    cardH: number;
+    /** Each pile's centre (world x). */
+    columns: number[];
+    pitch: number;
+    /** The top edge of a pile's first card, and the lowest a pile may reach (world y). */
+    pileTop: number;
+    pileBottom: number;
+    /** The bottom row: its centre (world y), the deck's right edge and the first finished run's centre (world x). */
+    rowY: number;
+    stockRight: number;
+    foundationX: number;
+    /** Heights between stacked cards (world z). */
+    dz: number;
+};
+/** All ten piles side by side across the game area (the original piles scrolled sideways), the deck and runs below. */
+export declare function getLayout(width: number, height: number, offset: number, tablet: boolean): Layout;
+/** Where a table point at height z shows in the view. */
+export declare const onScreen: (l: Layout, x: number, y: number, z: number) => [number, number];

package/lib/typescript/src/games/spider-solitaire/SpiderSolitaireGame.d.ts

@@ -0,0 +1,67 @@
+import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './SpiderSolitaireConstants';
+import { type Board } from './SpiderSolitaireRules';
+import { type Held, type Scene } from './SpiderSolitaireScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** select / deselect: a run picked up or put back; invalid: a move or deal not allowed; place: a run moved; deal: a row dealt; complete: a run lifted off; win: the eighth. */
+export type GameEvent = 'select' | 'deselect' | 'invalid' | 'place' | 'deal' | 'complete' | 'win';
+/** What a finger is on: a pile's card, a pile (its empty place or below its cards), or the deck. */
+type Hit = {
+    kind: 'card';
+    pile: number;
+    index: number;
+} | {
+    kind: 'pile';
+    pile: number;
+} | {
+    kind: 'stock';
+} | null;
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    board: Board;
+    /** The run picked up (tapped), or being dragged. */
+    held: Held;
+    /** A finger down: where, on what, and (once it's moved off) where it grabbed the dragged run. */
+    press: {
+        x: number;
+        y: number;
+        hit: Hit;
+        grab: [number, number] | null;
+        dragging: boolean;
+    } | null;
+    /** Seconds since the start (the original game's elapsed clock), and the score a win reports: both in the engine (Rust). */
+    readonly time: number;
+    readonly score: number;
+    won: boolean;
+    onPhase: (_p: Phase) => void;
+    onDeals: (_n: number) => void;
+    onCompleted: (_n: number) => void;
+    onEvent: (_e: GameEvent) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the table out for the view (first layout, header height, rotation); the first deal glides out of the deck. */
+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 shuffle dealt out, 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;
+/** What's under a view point: the top-most card there, a pile's column, or the deck. */
+export declare function hitAt(g: Game, sx: number, sy: number): Hit;
+/** A quick tap does what it did in the original game; a finger that moves off a face-up run drags it. */
+export declare function drag(g: Game, e: DragEvent): void;
+/** A card tapped: put back the run if it's the one picked up, move the picked-up run here, or pick up from here. */
+export declare function select(g: Game, pile: number, index: number): void;
+/** Puts the picked-up run on a pile, if it may go there. */
+export declare function moveTo(g: Game, to: number): void;
+/** One card onto every pile from the deck (not while a pile is empty). */
+export declare function deal(g: Game): void;
+export {};

package/lib/typescript/src/games/spider-solitaire/SpiderSolitaireRules.d.ts

@@ -0,0 +1,39 @@
+export declare const SUITS: readonly ["hearts", "diamonds", "clubs", "spades"];
+export declare const VALUES: readonly ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"];
+export type Suit = (typeof SUITS)[number];
+export type Value = (typeof VALUES)[number];
+export type Card = {
+    id: string;
+    suit: Suit;
+    value: Value;
+    faceUp: boolean;
+};
+/** The 10 piles, the stock (dealt from its end) and the runs lifted out so far (each K first). */
+export type Board = {
+    tableau: Card[][];
+    stock: Card[];
+    completed: Card[][];
+};
+export declare const PILES = 10;
+export declare const RUNS_TO_WIN = 8;
+/** As the original game: always two suits. */
+export declare const SUIT_COUNT = 2;
+export declare const rank: (v: Value) => number;
+/** A fresh deal: six cards in each of the first four piles, five in the rest, only the top ones face up; 50 left to deal. */
+export declare function newBoard(): Board;
+/** Descending by one all the way down (any suit), so it can be picked up together. */
+export declare function isValidSequence(cards: Card[]): boolean;
+/** Whether a run can go on a pile: anything on an empty one, else one rank below its face-up top card. */
+export declare function canMove(b: Board, cards: Card[], to: number): boolean;
+/** The run from `index` down, if it may be picked up (a single face-up card always may). */
+export declare function pickable(b: Board, pile: number, index: number): Card[] | null;
+/** Moves the run from `from` at `index` onto `to` (already checked), turning up the card it uncovers. */
+export declare function moveRun(b: Board, from: number, index: number, to: number): void;
+/** Why a row can't be dealt (an empty pile, or nothing left), or null if it can. */
+export declare const dealBlocked: (b: Board) => "empty-pile" | "no-stock" | null;
+/** One card face up onto every pile, from the stock's end. */
+export declare function dealRow(b: Board): void;
+/** Lifts a finished King-to-Ace run of one suit off the end of a pile, if there is one; returns it. */
+export declare function takeCompletedRun(b: Board, pile: number): Card[] | null;
+/** Deals left (each a row of 10). */
+export declare const dealsLeft: (b: Board) => number;

package/lib/typescript/src/games/spider-solitaire/SpiderSolitaireScene.d.ts

@@ -0,0 +1,60 @@
+import { type Entity, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './SpiderSolitaireConstants';
+import { type Board, type Card } from './SpiderSolitaireRules';
+/** Where a card should be: its centre on the table, its height, face up or down, its size, picked up or not. */
+export type Spot = {
+    x: number;
+    y: number;
+    z: number;
+    faceUp: boolean;
+    small: boolean;
+    selected: boolean;
+};
+type CardView = {
+    body: Entity;
+    spot: Spot | null;
+};
+type Slot = {
+    ring: Entity;
+    fill: Entity | null;
+};
+export type Scene = {
+    backdrop: Entity;
+    piles: Slot[];
+    stock: Slot;
+    foundation: Slot;
+    cards: Map<string, CardView>;
+};
+/** The table: the backdrop, an outline for each pile, the deck's place and the first run's, and all 104 cards. */
+export declare function buildScene(world: World, l: Layout, theme: GameTheme, cards: Card[]): Scene;
+export declare function removeScene(world: World, s: Scene): void;
+export declare function setSceneTheme(world: World, s: Scene, theme: GameTheme): void;
+/** How far down from the pile's top edge each card's top edge is: the original steps, squeezed if the pile would run too long. */
+export declare function pileOffsets(l: Layout, pile: Card[]): number[];
+/** A pile card's place: its centre and height (each card a little above the one under it). */
+export declare function pileSpot(l: Layout, column: number, offset: number, index: number): [number, number, number];
+/** What the player holds: a picked-up run (lifted), or a dragged one (following the finger, its top card's centre at x, y). */
+export type Held = {
+    pile: number;
+    index: number;
+    drag: {
+        x: number;
+        y: number;
+    } | null;
+} | null;
+/** Every card's place on the table, from the board and what's held. */
+export declare function layoutCards(l: Layout, b: Board, held: Held, onlyHeld?: boolean): Map<string, Spot>;
+/**
+ * Moves every card that's changed place to its new one: it glides (rising over the cards between and
+ * turning over on the way if it flips), after `delay(id)` seconds. `instant` puts them there at once
+ * (a dragged run following the finger).
+ */
+export declare function placeCards(world: World, l: Layout, s: Scene, spots: Map<string, Spot>, delay?: (id: string) => number, instant?: boolean): void;
+/** A move that isn't allowed: the cards shake where they are. */
+export declare function shakeCards(world: World, s: Scene, ids: string[]): void;
+/** A finished run lifted off: a sparkle where it was. */
+export declare function sparkle(world: World, l: Layout, x: number, y: number): void;
+/** All eight runs home: confetti over the table. */
+export declare function celebrate(world: World, l: Layout): void;
+export {};

package/lib/typescript/src/games/stack-tower/StackTower.d.ts

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

package/lib/typescript/src/games/stack-tower/StackTowerConstants.d.ts

@@ -1,25 +1,33 @@
-export declare const GRID_HEIGHT: number;
-export declare const STACK_TOWER_GAME_CONFIG: {
-    readonly BLOCK_HEIGHT: 28 | 22;
-    readonly BLOCK_DEPTH: 10 | 8;
-    readonly INITIAL_BLOCK_WIDTH: 200 | 160;
-    readonly BLOCK_SPEED: 3.5 | 4.5;
-    readonly BLOCK_SPEED_INCREMENT: 0;
-    readonly MAX_BLOCK_SPEED: 3.5 | 4.5;
-    readonly BASE_Y: number;
-    readonly VISIBLE_STACK_COUNT: number;
-    readonly GAME_WIDTH: number;
-    readonly POINTS_PER_BLOCK: 500;
-    readonly PERFECT_BONUS: 250;
-    readonly PERFECT_THRESHOLD: 3;
-};
+import type { TiltView } from '../shared/EngineTilt';
+export declare const TIME_LIMIT = 120;
+export declare const POINTS_PER_BLOCK = 500;
+export declare const PERFECT_BONUS = 250;
+export declare const PERFECT_THRESHOLD = 3;
+export declare const MIN_OVERLAP_RATIO = 0.4;
+/** Cycled up the tower. */
 export declare const BLOCK_COLORS: readonly ["#FF4757", "#FFA502", "#2ED573", "#1E90FF", "#FF6BD6", "#A55EEA", "#00D2D3", "#FF6348"];
-export declare const STACK_TOWER_TIME_LIMIT = 120;
-export declare const STACK_TOWER_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly UI: "#ffffff";
-    readonly GRID_BOX_FILL: "rgba(255, 255, 255, 0.15)";
-    readonly GRID_BOX_BORDER: "rgba(255, 255, 255, 0.5)";
-    readonly PERFECT_TEXT: "#FFD700";
+export declare const FRAME_MS = 16.67;
+export declare const MAX_FRAMES = 2;
+export declare const NEXT_BLOCK_DELAY = 0.2;
+export declare const MISS_TIME = 0.45;
+export declare const GAME_OVER_DELAY = 0.3;
+export declare const SPAWN_FADE = 0.2;
+export declare const PERFECT_SHOW = 0.6;
+export declare const CAMERA_TIME = 0.35;
+/** The camera looks down a little from in front, so the tower's top and its depth show. */
+export declare const TILT = -0.24;
+/** Lit from the upper left; faces toward the camera (+z) keep their exact color. */
+export declare const LIGHT: import("@nayan-ui/engine").Light;
+export type Layout = TiltView & {
+    /** The slide's bounds: the game area, 30 narrower than the screen and at most 500 across. */
+    left: number;
+    gameWidth: number;
+    blockWidth: number;
+    blockHeight: number;
+    /** Front to back. */
+    blockDepth: number;
+    speed: number;
+    /** The base block's top. */
+    baseY: number;
 };
+export declare function getLayout(width: number, height: number): Layout;

package/lib/typescript/src/games/stack-tower/StackTowerGame.d.ts

@@ -0,0 +1,58 @@
+import { type Camera, type Entity, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import type { HudFeedback } from '../shared/EngineHud';
+import { type Layout } from './StackTowerConstants';
+import { type Scene } from './StackTowerScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** place / perfect: a block set down; miss: it missed the tower. */
+export type GameEvent = 'place' | 'perfect' | 'miss';
+type Placed = {
+    x: number;
+    y: number;
+    level: number;
+    entity: Entity | null;
+};
+type Moving = {
+    x: number;
+    y: number;
+    direction: number;
+    level: number;
+    entity: Entity | null;
+};
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    tower: Placed[];
+    moving: Moving | null;
+    falling: Entity | null;
+    level: number;
+    perfectCount: number;
+    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    readonly timeRemaining: number;
+    won: boolean;
+    /** How far the view has scrolled down to follow the tower, and where it's heading. */
+    offset: number;
+    offsetTarget: number;
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onTime: (_t: number) => void;
+    hudFeedback: HudFeedback;
+    onEvent: (_e: GameEvent) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the tower out for the view (first layout, 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;
+/** Back to the base block alone (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 tap anywhere drops the sliding block where it is. */
+export declare function tap(g: Game): void;
+export {};

package/lib/typescript/src/games/stack-tower/StackTowerScene.d.ts

@@ -0,0 +1,27 @@
+import { type Color, type Entity, type Vec3, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { aimTilted, type TiltView } from '../shared/EngineTilt';
+import { type Layout } from './StackTowerConstants';
+export type Scene = {
+    frameOffset?: number;
+    backdrop: Entity;
+    plinth: Entity;
+    blocks: Entity[];
+    moving: Entity | null;
+};
+/** The view the camera frames, scrolled down by `offset` points as the tower grows. */
+export declare const viewFor: (l: Layout, offset: number) => TiltView;
+/** A block's face centre in the world, from its top-left in tower points. */
+export declare function blockAt(l: Layout, x: number, y: number): Vec3;
+export declare const blockColor: (level: number) => Color;
+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;
+/** Frames the tower: the camera scrolled `offset` down, the backdrop kept fixed behind it. */
+export declare function frame(world: World, l: Layout, s: Scene, camera: Parameters<typeof aimTilted>[0], offset: number): void;
+export declare function spawnBlock(world: World, l: Layout, x: number, y: number, level: number, fadeIn?: boolean): Entity;
+export declare function slideBlock(world: World, l: Layout, e: Entity, x: number, y: number): void;
+/** A block set down: it flashes bright and puffs dust from under its ends; a perfect one also rings gold. */
+export declare function land(world: World, l: Layout, e: Entity, x: number, y: number, level: number, perfect: boolean): void;
+/** A missed block tumbles off the way it was sliding, fading as it goes. */
+export declare function tumble(world: World, l: Layout, e: Entity, x: number, y: number, direction: number, level: number): void;

package/lib/typescript/src/games/sudoku/Sudoku.d.ts

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

package/lib/typescript/src/games/sudoku/SudokuConstants.d.ts

@@ -1,59 +1,54 @@
-export declare const INNER_GRID_SIZE: number;
-export declare const GRID_TOTAL_SIZE: number;
-export declare const GRID_HEIGHT: number;
-export declare const SUDOKU_GAME_CONFIG: {
-    readonly GRID_SIZE: 9;
-    readonly CELL_SIZE: number;
-    readonly CELL_SPACING: 1;
-    readonly BOX_BORDER: 2;
-    readonly POINTS_PER_CORRECT: 200;
-    readonly POINTS_PER_COMPLETE_ROW: 500;
-    readonly POINTS_PER_COMPLETE_COL: 500;
-    readonly POINTS_PER_COMPLETE_BOX: 500;
-    readonly WIN_BONUS: 5000;
-    readonly CLUES_COUNT: 36;
-};
-export declare const SUDOKU_TIME_LIMIT = 600;
-export declare const BOARD_3D: {
-    readonly DEPTH: 10 | 8;
-    readonly PADDING: 10 | 8;
-    readonly RADIUS: 16 | 12;
-};
-export declare const SUDOKU_COLORS: {
-    readonly BACKGROUND: "#1a237e";
-    readonly PRIMARY: "#ffffff";
-    readonly CELL_BG: "#ffffff";
-    readonly CELL_GIVEN: "#E8EAF6";
-    readonly CELL_SELECTED: "#BBDEFB";
-    readonly CELL_SAME_NUMBER: "#E3F2FD";
-    readonly CELL_SAME_ROW_COL: "#F3E5F5";
-    readonly CELL_ERROR: "#FFCDD2";
+import type { TiltView } from '../shared/EngineTilt';
+export declare const TIME_LIMIT: number;
+export declare const LOW_TIME = 60;
+export declare const FLASH_STEP = 0.028;
+export declare const TAP_SLOP = 12;
+export declare const COLORS: {
+    readonly CELL: "#ffffff";
+    readonly GIVEN: "#E8EAF6";
+    readonly SELECTED: "#BBDEFB";
+    readonly SAME_NUMBER: "#E3F2FD";
+    readonly PEER: "#F3E5F5";
+    readonly ERROR: "#FFCDD2";
     readonly TEXT_GIVEN: "#1a237e";
     readonly TEXT_PLACED: "#1565C0";
     readonly TEXT_ERROR: "#D32F2F";
-    readonly GRID_LINE: "#90A4AE";
-    readonly BOX_LINE: "#1a237e";
-    readonly NUMBER_PAD_BG: "rgba(255, 255, 255, 0.2)";
-    readonly NUMBER_PAD_TEXT: "#ffffff";
-    readonly NUMBER_PAD_ACTIVE: "rgba(255, 255, 255, 0.4)";
-    readonly NUMBER_PAD_DISABLED: "rgba(255, 255, 255, 0.08)";
-    readonly UI: "#ffffff";
-    readonly GRID_BOX_FILL: "rgba(255, 255, 255, 0.15)";
-    readonly GRID_BOX_BORDER: "rgba(255, 255, 255, 0.5)";
-    readonly BOARD_TOP: "#5c4033";
-    readonly BOARD_FRONT: "#4a3228";
-    readonly BOARD_INNER: "#3a2518";
-    readonly BOARD_HIGHLIGHT: "#7a5a45";
-    readonly NUM_BTN_TOP: "#e8ddd0";
-    readonly NUM_BTN_FRONT: string;
-    readonly NUM_BTN_HIGHLIGHT: string;
-    readonly NUM_BTN_TEXT: "#3e2723";
-    readonly NUM_BTN_REMAINING: "#8d6e63";
-    readonly NUM_BTN_DISABLED_TOP: "#bdb5ad";
-    readonly NUM_BTN_DISABLED_FRONT: string;
-    readonly NUM_BTN_DISABLED_TEXT: "#9e9e9e";
-    readonly CELL_DEPTH: "#d0d0d0";
-    readonly CELL_GIVEN_DEPTH: string;
-    readonly CELL_SELECTED_DEPTH: string;
-    readonly CELL_ERROR_DEPTH: string;
+    readonly LINES: "#1a237e";
+    readonly FRAME: "#5c4033";
+    readonly WELL: "#3a2518";
+    readonly KEY: "#e8ddd0";
+    readonly KEY_TEXT: "#3e2723";
+    readonly KEY_REMAINING: "#8d6e63";
+    readonly KEY_DISABLED: "#bdb5ad";
+    readonly KEY_DISABLED_TEXT: "#9e9e9e";
+};
+/** 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;
+export declare const CELL_HEIGHT = 0.12;
+export declare const KEY_HEIGHT = 0.3;
+export declare const SPACING = 1.5;
+export declare const BORDER = 3.5;
+export type Layout = TiltView & {
+    cell: number;
+    /** The grid's side (cells, lines and borders), the board's (with its rim), where the board's centre is (world y). */
+    grid: number;
+    board: number;
+    boardY: number;
+    /** The number keys: their width, height, pitch and the row's centre (world y). */
+    key: number;
+    keyH: number;
+    keyPitch: number;
+    keysY: number;
 };
+/** Cells as big as the width allows (as the original grid), smaller if the screen is short; the keys spread under the board. */
+export declare function getLayout(width: number, height: number, offset: number): Layout;
+/** A cell's centre, in world units. */
+export declare function cellCentre(l: Layout, row: number, col: number): [number, number];
+/** A number key's centre (n = 1..9), in world units. */
+export declare const keyCentre: (l: Layout, n: number) => [number, number];
+/** The cell a board point is on (a line between counts as the nearer cell), or null off the grid. */
+export declare function cellAt(l: Layout, x: number, y: number): [number, number] | null;
+/** The number key a point is on, or 0. */
+export declare function keyAt(l: Layout, x: number, y: number): number;

package/lib/typescript/src/games/sudoku/SudokuGame.d.ts

@@ -0,0 +1,56 @@
+import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './SudokuConstants';
+import { type Puzzle } from './SudokuRules';
+import { type Scene } from './SudokuScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** place: a right number; wrong: a wrong one; win / lose: how it ended. */
+export type GameEvent = 'place' | 'wrong' | 'win' | 'lose';
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    puzzle: Puzzle;
+    filled: number;
+    selRow: number;
+    selCol: number;
+    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    readonly timeLeft: number;
+    won: boolean;
+    /** A finger down: where, and on which key (0 on the board). */
+    press: {
+        x: number;
+        y: number;
+        key: number;
+    } | null;
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => 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 puzzle already shown, nothing selected. */
+export declare function start(g: Game): void;
+/** A fresh puzzle, not started (Stop, Play Again, as the original game). */
+export declare function reset(g: Game): void;
+export declare function dispose(g: Game): void;
+export declare function tick(g: Game, dt: number): void;
+/** Selects a cell (any cell, given or not). */
+export declare function select(g: Game, row: number, col: number): void;
+/** Places a number in the selected cell (not a given one): checked against the solution and scored. */
+export declare function enter(g: Game, n: number): void;
+/** What's under a view point: a number key (1..9), a cell, or nothing. */
+export declare function hitAt(g: Game, x: number, y: number): {
+    key: number;
+} | {
+    cell: [number, number];
+} | null;
+/** A finger down presses a key in; a tap (lifting without wandering) selects a cell or enters a number. */
+export declare function drag(g: Game, { phase, x, y }: DragEvent): void;