@nayan-ui/games 1.18.0 → 1.20.0

package/lib/typescript/src/games/tangram/TangramRules.d.ts

@@ -0,0 +1,61 @@
+export type PieceType = 'large' | 'medium' | 'small' | 'square' | 'para';
+export type Pt = {
+    x: number;
+    y: number;
+};
+export type TanTarget = {
+    id: number;
+    type: PieceType;
+    color: string;
+    /** The tan's shape, centred on its centroid (board points at full size, unrotated). */
+    localPoints: Pt[];
+    /** Where it goes when solved, and at what turn (degrees, clockwise on screen). */
+    targetCx: number;
+    targetCy: number;
+    targetRot: number;
+    /** Its rotational symmetry (degrees). */
+    symmetry: number;
+    /** Its solved outline, in board points. */
+    silPoints: Pt[];
+    /** Where it starts, in the tray. */
+    initialRot: number;
+    scatterCx: number;
+    scatterCy: number;
+};
+export type TangramLevel = {
+    pieces: TanTarget[];
+    mirror: boolean;
+    silhouetteRect: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+};
+/** The board, in tan units: the 4 x 4 square silhouette with the tray in the strip under it. */
+export declare const TOTAL_BOARD_UNITS = 6;
+export declare const TRAY_SCALE = 0.4;
+export declare const RIM_RADIUS = 0.024;
+export declare const ROT_TOL = 30;
+export declare const SNAP_UNITS = 1.8;
+export declare const TOTAL_PIECES = 7;
+export declare const rotatePt: (x: number, y: number, deg: number, ox: number, oy: number) => Pt;
+export declare function canonicalShapes(mirror: boolean): Record<PieceType, Pt[]>;
+/** A level: its silhouette (centred across the board, near its top) and its tray, for a board `unit` points to the tan unit. */
+export declare function generateLevel(levelIndex: number, unit: number, boardW: number, boardH: number): TangramLevel;
+/** Whether a turn matches a target within tolerance, allowing for the tan's symmetry. */
+export declare const isRotationMatched: (cur: number, target: number, sym: number) => boolean;
+/** The turn nearest `cur` that equals the target (modulo symmetry), to snap smoothly to. */
+export declare const snappedRotation: (cur: number, target: number, sym: number) => number;
+/**
+ * Where a tan dropped at (x, y) at turn `rot` goes: the nearest free slot of its type within reach at
+ * a matching turn (claimed), 'nudge' if it's over one at the wrong turn, or null. As the original board.
+ */
+export declare function claimSlot(level: TangramLevel, occupied: boolean[], unit: number, type: PieceType, x: number, y: number, rot: number): {
+    slot: number;
+    cx: number;
+    cy: number;
+    rot: number;
+} | 'nudge' | null;
+/** Whether a board point lies inside a tan drawn at (cx, cy), turned `rot`, at `scale`, give or take `margin`. */
+export declare function insidePiece(local: Pt[], cx: number, cy: number, rot: number, scale: number, px: number, py: number, margin?: number): boolean;

package/lib/typescript/src/games/tangram/TangramScene.d.ts

@@ -0,0 +1,42 @@
+import { type Entity, type Quat, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './TangramConstants';
+import { type TangramLevel } from './TangramRules';
+/** Where a tan is drawn: its centre (board points), turn (degrees, clockwise on screen), size and height (tan units). */
+export type Pose = {
+    x: number;
+    y: number;
+    rot: number;
+    scale: number;
+    lift: number;
+};
+type TanView = {
+    root: Entity;
+    slab: Entity;
+    rim: Entity;
+};
+export type Scene = {
+    backdrop: Entity;
+    slots: Entity[];
+    tans: TanView[];
+};
+/** A turn clockwise on screen (y down) is a turn the other way in the world (y up). */
+export declare const turn: (deg: number) => Quat;
+export declare function buildScene(world: World, l: Layout, theme: GameTheme, level: TangramLevel, poses: Pose[]): Scene;
+export declare function removeScene(world: World, s: Scene): void;
+export declare function setSceneTheme(world: World, s: Scene, theme: GameTheme): void;
+/** Puts a tan at a pose at once (following the finger). */
+export declare function setPose(world: World, l: Layout, s: Scene, id: number, p: Pose): void;
+/** Glides a tan to a pose. */
+export declare function moveTo(world: World, l: Layout, s: Scene, id: number, p: Pose, duration: number, easing?: 'easeOut' | 'back'): void;
+/** A new level: every tan grows in on its tray spot, one after another. */
+export declare function enter(world: World, l: Layout, s: Scene, poses: Pose[], stagger: number): void;
+/** A tan snapped into its slot: a small pop as it lands. */
+export declare function pop(world: World, l: Layout, s: Scene, id: number, delay: number): void;
+/** Over a matching slot at the wrong turn: a wiggle. */
+export declare function wiggle(world: World, s: Scene, id: number, rot: number): void;
+/** Solved: a wave of pops round the shape, and confetti over it. */
+export declare function celebrate(world: World, l: Layout, s: Scene, level: TangramLevel, delay: number, stagger: number): void;
+/** Out of time: the tans still in the tray dim. */
+export declare function dim(world: World, s: Scene, ids: number[], colors: string[]): void;
+export {};

package/lib/typescript/src/games/tank-1990/Tank1990.d.ts

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

package/lib/typescript/src/games/tank-1990/Tank1990Constants.d.ts

@@ -1,129 +1,46 @@
+import type { TiltView } from '../shared/EngineTilt';
 export type Direction = 'up' | 'down' | 'left' | 'right';
-export type TileType = 'empty' | 'brick' | 'steel' | 'water' | 'grass' | 'base';
-export declare const TANK_1990_COLORS: {
-    BACKGROUND: string;
-    GRID_LINE: string;
-    PLAYER_BODY_TOP: string;
-    PLAYER_BODY_FACE: string;
-    PLAYER_BODY_BOTTOM: string;
-    PLAYER_BODY_SHADOW: string;
-    PLAYER_TRACK: string;
-    PLAYER_TRACK_HIGHLIGHT: string;
-    PLAYER_TURRET: string;
-    PLAYER_TURRET_SHADOW: string;
-    PLAYER_BARREL: string;
-    PLAYER_BARREL_HIGHLIGHT: string;
-    ENEMY_BODY_TOP: string;
-    ENEMY_BODY_FACE: string;
-    ENEMY_BODY_BOTTOM: string;
-    ENEMY_BODY_SHADOW: string;
-    ENEMY_TRACK: string;
-    ENEMY_TRACK_HIGHLIGHT: string;
-    ENEMY_TURRET: string;
-    ENEMY_TURRET_SHADOW: string;
-    ENEMY_BARREL: string;
-    ENEMY_BARREL_HIGHLIGHT: string;
-    BULLET_CORE: string;
-    BULLET_GLOW: string;
-    BULLET_TRAIL: string;
-    BRICK_FACE: string;
-    BRICK_FACE_ALT: string;
-    BRICK_TOP: string;
-    BRICK_HIGHLIGHT: string;
-    BRICK_BOTTOM: string;
-    BRICK_RIGHT_EDGE: string;
-    BRICK_MORTAR: string;
-    BRICK_MORTAR_SHADOW: string;
-    BRICK_SPECKLE_LIGHT: string;
-    BRICK_SPECKLE_DARK: string;
-    BRICK_DAMAGED_FACE: string;
-    BRICK_DAMAGED_FACE_ALT: string;
-    BRICK_DAMAGED_TOP: string;
-    BRICK_DAMAGED_HIGHLIGHT: string;
-    BRICK_DAMAGED_BOTTOM: string;
-    BRICK_DAMAGED_RIGHT_EDGE: string;
-    STEEL_FACE: string;
-    STEEL_TOP: string;
-    STEEL_BOTTOM: string;
-    STEEL_RIVET: string;
-    STEEL_SHADOW: string;
-    WATER_DEEP: string;
-    WATER_MID: string;
-    WATER_SURFACE: string;
-    WATER_HIGHLIGHT: string;
-    WATER_FOAM: string;
-    GRASS_BASE: string;
-    GRASS_MID: string;
-    GRASS_TIP: string;
-    GRASS_HIGHLIGHT: string;
-    BASE_OUTER: string;
-    BASE_FACE: string;
-    BASE_INNER: string;
-    BASE_EMBLEM: string;
-    BASE_SHADOW: string;
-    EXPLOSION_CORE: string;
-    EXPLOSION_INNER: string;
-    EXPLOSION_MID: string;
-    EXPLOSION_OUTER: string;
-    EXPLOSION_SMOKE: string;
-    EXPLOSION_SHRAPNEL: string;
-    MUZZLE_CORE: string;
-    MUZZLE_INNER: string;
-    MUZZLE_OUTER: string;
-    SPAWN_SHIELD: string;
-    SPAWN_SHIELD_EDGE: string;
-    CONTROL_BG: string;
-    CONTROL_ACTIVE: string;
-    CONTROL_BORDER: string;
-    SCORE_TEXT: string;
-};
-export declare const TANK_1990_GAME_CONFIG: {
-    GRID_WIDTH: number;
-    GRID_HEIGHT: number;
-    CELL_SIZE: number;
-    PLAYER_SPEED: number;
-    ENEMY_SPEED: number;
-    TANK_SIZE: number;
-    BULLET_SPEED: number;
-    BULLET_SIZE: number;
-    PLAYER_FIRE_COOLDOWN: number;
-    ENEMY_FIRE_COOLDOWN: number;
-    INITIAL_LIVES: number;
-    ENEMY_SPAWN_INTERVAL: number;
-    MAX_ENEMIES: number;
-    ENEMIES_PER_LEVEL: number;
-    POINTS_PER_ENEMY: number;
-    POINTS_PER_LEVEL: number;
-    EXPLOSION_DURATION: number;
-    SPAWN_PROTECTION_TIME: number;
-};
-export declare const TANK_1990_DIFFICULTY_CONFIG: {
-    readonly easy: {
-        readonly enemySpeed: 0.6;
-        readonly enemyFireCooldown: 2000;
-        readonly maxEnemies: 3;
-        readonly enemiesPerLevel: 10;
-        readonly enemySpawnInterval: 6000;
-    };
-    readonly medium: {
-        readonly enemySpeed: 1;
-        readonly enemyFireCooldown: 1500;
-        readonly maxEnemies: 4;
-        readonly enemiesPerLevel: 15;
-        readonly enemySpawnInterval: 5000;
-    };
-    readonly hard: {
-        readonly enemySpeed: 1.4;
-        readonly enemyFireCooldown: 1000;
-        readonly maxEnemies: 5;
-        readonly enemiesPerLevel: 20;
-        readonly enemySpawnInterval: 4000;
-    };
-};
-export declare const getGameConfig: () => {
-    readonly enemySpeed: 1;
-    readonly enemyFireCooldown: 1500;
-    readonly maxEnemies: 4;
-    readonly enemiesPerLevel: 15;
-    readonly enemySpawnInterval: 5000;
+export type TileType = 'empty' | 'brick' | 'steel' | 'base';
+export declare const GRID_WIDTH = 13;
+export declare const GRID_HEIGHT = 17;
+export declare const LIVES = 3;
+export declare const POINTS_PER_ENEMY = 1000;
+export declare const POINTS_PER_LEVEL = 2000;
+export declare const ENEMIES_PER_LEVEL = 15;
+export declare const MAX_ENEMIES = 4;
+export declare const STEP_MS: number;
+export declare const STEP_TOLERANCE_MS = 2;
+export declare const MAX_PENDING_MS = 50;
+export declare const REFERENCE_CELL = 24;
+export declare const PLAYER_SPEED = 2;
+export declare const ENEMY_SPEED = 1;
+export declare const TANK_RATIO = 0.8;
+export declare const HIT_TANK_SIZE = 20;
+export declare const BULLET_SPEED = 6;
+export declare const BULLET_SIZE = 4;
+export declare const PLAYER_FIRE_COOLDOWN = 300;
+export declare const ENEMY_FIRE_COOLDOWN = 1500;
+export declare const SPAWN_PROTECTION = 2000;
+export declare const ENEMY_TURN_INTERVAL = 800;
+export declare const ENEMY_AIM_TOLERANCE: number;
+export declare const FIRST_ENEMY = 1000;
+export declare const ENEMY_SPAWN_INTERVAL = 5000;
+export declare const SWIPE_THRESHOLD = 5;
+export declare const TURN_TIME = 0.08;
+export declare const EXPLOSION_TIME = 0.5;
+/** The camera leans back from straight down, so the walls, tanks and turrets stand up off the field. */
+export declare const TILT = 0.42;
+/** Lit from the upper left; surfaces facing up off the field (+z) keep their exact color. */
+export declare const LIGHT: import("@nayan-ui/engine").Light;
+export declare const CLASSIC_FIELD = "rgba(255, 255, 255, 0.30)";
+export declare const GRID_LINE = "rgba(0, 0, 0, 0.10)";
+/** The steel frame round the field (at most this wide, half a cell on tiny boards): it counts toward the max width. */
+export declare const FRAME = 10;
+export type Layout = TiltView & {
+    /** Whole points, as the original board used. */
+    cell: number;
+    boardWidth: number;
+    boardHeight: number;
 };
+/** A whole-point cell as wide as the game area allows with the frame round it, smaller if the screen is short. */
+export declare function getLayout(width: number, height: number, offset: number): Layout;

package/lib/typescript/src/games/tank-1990/Tank1990Game.d.ts

@@ -0,0 +1,50 @@
+import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Direction, type Layout } from './Tank1990Constants';
+import { type Bullet, type Tank, type Tile } from './Tank1990Rules';
+import { type Scene } from './Tank1990Scene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** fire: a shot of yours; kill: an enemy destroyed; hit: you were hit. */
+export type GameEvent = 'fire' | 'kill' | 'hit';
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    tiles: Tile[][];
+    player: Tank | null;
+    enemies: Tank[];
+    bullets: Bullet[];
+    /** Score and lives live in the engine (Rust). */
+    readonly lives: number;
+    readonly score: number;
+    /** Enemies still to roll in this level. */
+    enemiesRemaining: number;
+    won: boolean;
+    /** Where the held swipe is steering, if anywhere. */
+    direction: Direction | null;
+    /** The game clock (ms), the fixed-step remainder, and the enemy roll-ins: a first one, then a steady interval from the start. */
+    now: number;
+    pending: number;
+    firstSpawn: number | null;
+    nextSpawn: number;
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onLives: (_n: number) => void;
+    onEnemies: (_n: number) => void;
+    onEvent: (_e: GameEvent) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the battle out for the view (first layout, header height, rotation); a new cell size rescales the tanks and shells. */
+export declare function setLayout(g: Game, l: Layout): void;
+export declare function setTheme(g: Game, theme: GameTheme): void;
+/** Plays the map that's showing, your tank freshly shielded. */
+export declare function start(g: Game): void;
+/** A new map, 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;
+/** Hold a swipe to drive: the way it's moved furthest from where it started; let go to stop. */
+export declare function drag(g: Game, { phase, dx, dy }: DragEvent): void;

package/lib/typescript/src/games/tank-1990/Tank1990Rules.d.ts

@@ -0,0 +1,67 @@
+import { type Direction, type TileType } from './Tank1990Constants';
+export type Tank = {
+    id: number;
+    x: number;
+    y: number;
+    direction: Direction;
+    isPlayer: boolean;
+    isAlive: boolean;
+    lastFireTime: number;
+    spawnProtectionEndTime: number;
+    lastDirectionChangeTime: number;
+};
+export type Bullet = {
+    id: number;
+    x: number;
+    y: number;
+    direction: Direction;
+    isPlayerBullet: boolean;
+};
+export type Tile = {
+    type: TileType;
+    health: number;
+};
+export type Board = {
+    tiles: Tile[][];
+    cell: number;
+    width: number;
+    height: number;
+};
+export declare const BASE_X: number;
+export declare const BASE_Y: number;
+/** A fresh map: one of the arenas (sometimes mirrored), the base walled in steel, the spawns and the player's start kept clear. */
+export declare function createMap(): Tile[][];
+/** The player's tank, bottom left (away from the base), shielded for a moment. */
+export declare function createPlayer(cell: number, now: number): Tank;
+/** An enemy at the first free spawn point along the top (left, middle, right), or null if they're all taken. */
+export declare function createEnemy(cell: number, enemies: Tank[], now: number): Tank | null;
+/** A tank turned to `direction` and, if the way is clear, moved one tick along it. */
+export declare function moveTank(tank: Tank, direction: Direction, speed: number, b: Board, tanks: Tank[]): Tank;
+/** A bullet from the tank's muzzle, if its gun has cooled down. */
+export declare function fire(tank: Tank, now: number): Bullet | null;
+export declare function moveBullet(bullet: Bullet): void;
+export type BulletHit = {
+    hit: boolean;
+    tile?: [number, number];
+    base?: boolean;
+    tank?: Tank;
+};
+/** What a bullet has hit: the edge, a wall (bricks and the base take damage), or an unshielded tank on the other side. */
+export declare function bulletHit(bullet: Bullet, b: Board, tanks: Tank[], now: number): BulletHit;
+/** A hit on a tile: a brick loses a layer (two and it's gone); the base is destroyed. Returns its new state. */
+export declare function damageTile(tiles: Tile[][], x: number, y: number): Tile | null;
+/** Opposing bullets that meet cancel out; returns the survivors and where each pair met. */
+export declare function bulletClashes(bullets: Bullet[]): {
+    remaining: Bullet[];
+    points: [number, number][];
+};
+/**
+ * An enemy's heading: when blocked, a clear way (toward the player if that's one), or straight back;
+ * otherwise, every 800 ms, toward the player (40%), on as it was (35%) or anywhere (25%).
+ */
+export declare function enemyHeading(enemy: Tank, player: Tank, b: Board, tanks: Tank[], blocked: boolean, now: number): {
+    direction: Direction;
+    turned: boolean;
+};
+/** Whether an enemy pulls the trigger: always with the player ahead and nearly in line, otherwise 30% of the time. */
+export declare function enemyWantsToFire(enemy: Tank, player: Tank): boolean;

package/lib/typescript/src/games/tank-1990/Tank1990Scene.d.ts

@@ -0,0 +1,38 @@
+import { type Entity, type Vec3, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Direction, type Layout } from './Tank1990Constants';
+import type { Bullet, Tank, Tile } from './Tank1990Rules';
+export declare const heading: (d: Direction) => import("@nayan-ui/engine").MutableQuat;
+/** Board points to the world, at height z. */
+export declare const toWorld: (l: Layout, x: number, y: number, z?: number) => Vec3;
+export type TankView = {
+    body: Entity;
+    shield: Entity;
+    direction: Direction;
+    shielded: boolean;
+    x: number;
+    y: number;
+};
+export type Scene = {
+    backdrop: Entity;
+    field: Entity;
+    frame: Entity;
+    grid: Entity;
+    /** Each tile's wall, row by row (null where it's open ground). */
+    walls: (Entity | null)[][];
+    tanks: Map<number, TankView>;
+    bullets: Map<number, Entity>;
+};
+export declare function buildScene(world: World, l: Layout, theme: GameTheme, tiles: Tile[][]): Scene;
+export declare function removeScene(world: World, s: Scene): void;
+export declare function setSceneTheme(world: World, l: Layout, s: Scene, theme: GameTheme): void;
+/** A tile's wall after a hit: a layer down, or gone in a shower of rubble. */
+export declare function updateWall(world: World, l: Layout, s: Scene, x: number, y: number, t: Tile, was: Tile['type']): void;
+/** Builds a fresh map's walls (a new board). */
+export declare function rebuildWalls(world: World, l: Layout, s: Scene, tiles: Tile[][]): void;
+/** Puts every live tank and shell where the battle has them (spawning newcomers, clearing the gone). */
+export declare function syncUnits(world: World, l: Layout, s: Scene, tanks: Tank[], bullets: Bullet[], now: number): void;
+/** A muzzle flash at the end of a tank's barrel. */
+export declare function muzzleFlash(world: World, l: Layout, t: Tank): void;
+/** An explosion at a board point: a fireball and smoke, bigger for a tank. */
+export declare function explode(world: World, l: Layout, x: number, y: number, big: boolean): void;

package/lib/typescript/src/games/tic-tac-toe/TicTacToe.d.ts

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

package/lib/typescript/src/games/tic-tac-toe/TicTacToeConstants.d.ts

@@ -1,72 +1,35 @@
-export declare const TIC_TAC_TOE_COLORS: {
-    BACKGROUND: string;
-    PRIMARY: string;
-    X_COLOR: string;
-    O_COLOR: string;
-    WIN_LINE: string;
-    GRID_LINE: string;
-    CELL_BACKGROUND: string;
-    CELL_HOVER: string;
-    BACKGROUND_COLORS: string[];
-};
-export declare const TIC_TAC_TOE_GAME_CONFIG: {
-    SCREEN_WIDTH: number;
-    SCREEN_HEIGHT: number;
-    BOARD_SIZE: number;
-    CELL_SIZE: number;
-    LINE_WIDTH: number;
-    SYMBOL_SIZE: number;
-    SYMBOL_STROKE_WIDTH: number;
-};
-export declare const TIC_TAC_TOE_CONSTANTS: {
-    maxTime: number;
-    winScore: number;
-    drawScore: number;
-    loseScore: number;
-};
-export type Player = 'X' | 'O' | null;
-export type CellValue = Player;
-export type Board = CellValue[];
-export declare const WINNING_COMBINATIONS: number[][];
-export declare const BOARD_3D: {
-    readonly DEPTH: 10 | 8;
-    readonly PADDING: 10 | 8;
-    readonly RADIUS: 16 | 12;
-    readonly BOARD_TOP: "#5c4033";
-    readonly BOARD_FRONT: "#4a3228";
-    readonly BOARD_INNER: "#3a2518";
-    readonly BOARD_HIGHLIGHT: "#7a5a45";
-};
-export declare const GRID_3D: {
-    readonly line: "#7a5a45";
-    readonly lineLight: "#8d6e5a";
-    readonly shadow: "rgba(0,0,0,0.35)";
-    readonly highlight: "#9e8070";
-    readonly depth: 3;
-};
-export declare const X_3D: {
-    readonly stroke: string[];
-    readonly shadow: string;
-    readonly highlight: string;
-    readonly outerGlow: "rgba(229,57,53,0.35)";
-    readonly glow: string[];
-    readonly winStroke: string[];
-};
-export declare const O_3D: {
-    readonly stroke: string[];
-    readonly shadow: string;
-    readonly highlight: string;
-    readonly outerGlow: "rgba(46,125,50,0.35)";
-    readonly glow: string[];
-    readonly winStroke: string[];
-};
-export declare const WIN_3D: {
-    readonly stroke: string[];
-    readonly glow: string[];
-    readonly shadow: "rgba(255,152,0,0.4)";
-};
-export declare const CELL_3D: {
-    readonly face: "rgba(122,90,69,0.08)";
-    readonly faceAlt: "rgba(122,90,69,0.04)";
-    readonly hover: "rgba(122,90,69,0.10)";
-};
+import type { TiltView } from '../shared/EngineTilt';
+export declare const TIME_LIMIT = 120;
+export declare const WIN_SCORE = 10000;
+export declare const DRAW_SCORE = 5000;
+export declare const LOSE_SCORE = 0;
+/** Points for every second still on the clock when a game is won (half this for a draw). */
+export declare const TIME_BONUS = 50;
+export declare const ROBOT_DELAY = 0.5;
+export declare const COLORS: {
+    readonly X: "#E53935";
+    readonly O: "#2E7D32";
+    readonly WIN: "#FFC107";
+    readonly FRAME: "#5c4033";
+    readonly WELL: "#3a2518";
+    readonly SURFACE: "#6b4c3b";
+    readonly SURFACE_ALT: "#735342";
+    readonly GRID: "#8d6e5a";
+    readonly X_BADGE: "#F44336";
+    readonly O_BADGE: "#4CAF50";
+};
+/** The camera leans back from straight down, so the board's depth and the pieces stand up. */
+export declare const TILT = 0.42;
+/** 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 & {
+    cell: number;
+    size: number;
+    pad: number;
+};
+/** The board as big as the original board (85% of the width, at most 350 points, 420 on a tablet), smaller if the screen is short. */
+export declare function getLayout(width: number, height: number, offset: number, tablet: boolean): Layout;
+/** A cell's centre (0 top left, row by row), in world units. */
+export declare function cellCentre(l: Layout, i: number): [number, number];
+/** The cell under a board point, or -1. */
+export declare function cellAt(l: Layout, x: number, y: number): number;

package/lib/typescript/src/games/tic-tac-toe/TicTacToeGame.d.ts

@@ -0,0 +1,54 @@
+import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './TicTacToeConstants';
+import { type Board, type Player } from './TicTacToeRules';
+import { type Scene } from './TicTacToeScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** How a game ended. */
+export type Result = 'win' | 'lose' | 'draw' | 'timeout';
+/** place / robot: a piece down; win / lose / draw: how a move ended it (a timeout is silent, as in the original game). */
+export type GameEvent = 'place' | 'robot' | 'win' | 'lose' | 'draw';
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    board: Board;
+    turn: Player;
+    result: Result | null;
+    finalScore: number;
+    line: readonly [number, number, number] | null;
+    /** The countdown lives in the engine (Rust), advanced by world.update. */
+    readonly timeLeft: number;
+    /** A finger down on a cell (shown as a ghost O until it lifts). */
+    press: number;
+    onPhase: (_p: Phase) => void;
+    onTurn: (_p: Player) => void;
+    onTime: (_t: number) => void;
+    onEvent: (_e: GameEvent) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** A finished game's score: the result's points, plus a bonus for the time left (a win's full, a draw's half). */
+export declare const scoreFor: (r: Result | null, timeLeft: number) => number;
+/** The game-over card's score. */
+export declare const shownScore: (g: {
+    result: Result | null;
+    finalScore: number;
+}) => number;
+/** 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;
+/** A fresh board, your move first. */
+export declare function start(g: Game): void;
+/** An empty board, 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;
+/** Your move on a cell, if it's your turn and the cell is empty; the robot answers after its think. */
+export declare function play(g: Game, i: number): void;
+/** The cell under a view point (on the board's surface), or -1. */
+export declare function cellUnder(g: Game, x: number, y: number): number;
+/** A finger down on an empty cell shows a ghost O there; lifting on the same cell plays it. */
+export declare function drag(g: Game, { phase, x, y }: DragEvent): void;

package/lib/typescript/src/games/tic-tac-toe/TicTacToeRules.d.ts

@@ -0,0 +1,10 @@
+export type Player = 'X' | 'O';
+export type Cell = Player | null;
+export type Board = Cell[];
+export declare const LINES: readonly [readonly [0, 1, 2], readonly [3, 4, 5], readonly [6, 7, 8], readonly [0, 3, 6], readonly [1, 4, 7], readonly [2, 5, 8], readonly [0, 4, 8], readonly [2, 4, 6]];
+export declare const emptyBoard: () => Board;
+/** The line three in a row, if there is one. */
+export declare function winningLine(b: Board): readonly [number, number, number] | null;
+export declare const winnerOf: (b: Board) => Player | null;
+/** A forgiving opponent that takes wins, sometimes misses blocks, and occasionally looks ahead. */
+export declare function robotMove(b: Board): number;

package/lib/typescript/src/games/tic-tac-toe/TicTacToeScene.d.ts

@@ -0,0 +1,26 @@
+import { type Entity, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './TicTacToeConstants';
+import type { Player } from './TicTacToeRules';
+export type Scene = {
+    backdrop: Entity;
+    /** The board's frame, well and surface, its cells and grid bars (rebuilt on a theme change). */
+    board: Entity[];
+    pieces: (Entity | null)[];
+    ghost: Entity;
+    line: Entity | null;
+};
+export declare function buildScene(world: World, l: Layout, theme: GameTheme, board: (Player | null)[]): Scene;
+export declare function removeScene(world: World, s: Scene): void;
+export declare function setSceneTheme(world: World, l: Layout, s: Scene, theme: GameTheme): void;
+/** A piece on a cell: it grows out of the cell with a little turn and settles (or is just there). */
+export declare function place(world: World, l: Layout, s: Scene, i: number, p: Player, animate?: boolean): void;
+/** A faint O over an empty cell while a finger rests on it. */
+export declare function showGhost(world: World, l: Layout, s: Scene, i: number): void;
+export declare function hideGhost(world: World, s: Scene): void;
+/** Three in a row: they turn gold and hop, and a gold bar is laid across them, glowing softly. */
+export declare function markWin(world: World, l: Layout, s: Scene, line: readonly [number, number, number]): void;
+/** A draw: every piece gives a little shrug. */
+export declare function shrug(world: World, l: Layout, s: Scene): void;
+/** A fresh board: the pieces lift off and fade, and the win bar goes. */
+export declare function clearPieces(world: World, s: Scene): void;

package/lib/typescript/src/games/tile-home/TileHome.d.ts

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