@nayan-ui/games 1.19.0 → 1.20.0

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

@@ -0,0 +1,23 @@
+export declare const POINTS_PER_CORRECT = 200;
+export declare const POINTS_PER_UNIT = 500;
+export declare const WIN_BONUS = 5000;
+export declare const CLUES = 36;
+export type Cell = {
+    value: number;
+    given: boolean;
+    error: boolean;
+};
+export type Puzzle = {
+    grid: Cell[][];
+    solution: number[][];
+    toFill: number;
+};
+/** A fresh puzzle: a solved board with all but 36 cells emptied, at random. */
+export declare function newPuzzle(): Puzzle;
+/** The cells of the row, column and box through (row, col) that are now all solved, each unit once, and the points for them. */
+export declare function completedUnits(p: Puzzle, row: number, col: number): {
+    cells: number[];
+    points: number;
+};
+/** How many of each digit are still to place (9 minus the right-looking ones on the board), as the original pad counted. */
+export declare function remaining(p: Puzzle): number[];

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

@@ -0,0 +1,44 @@
+import { type Entity, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './SudokuConstants';
+import type { Cell } from './SudokuRules';
+/** How a cell reads: selected, wrong, sharing the selected number, in the selected cell's row / column / box, or none. */
+export type Highlight = 'selected' | 'same' | 'peer' | 'none';
+type Key = {
+    root: Entity;
+    block: Entity;
+    digit: Entity;
+    count: Entity;
+};
+export type Scene = {
+    backdrop: Entity;
+    board: Entity[];
+    cells: Entity[];
+    /** The digit on each cell (null while empty), and what it shows. */
+    digits: (Entity | null)[];
+    shown: string[];
+    selected: number;
+    keys: Key[];
+    keyCounts: number[];
+};
+declare const cellTop: (l: Layout) => number;
+declare const keyTop: (l: Layout) => number;
+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, l: Layout, s: Scene, theme: GameTheme): void;
+/**
+ * Brings every cell up to date: its tint for the highlight, and its digit (spawned, recolored or
+ * removed only where it changed). `pop` is the cell just placed: its digit drops in.
+ */
+export declare function drawGrid(world: World, l: Layout, s: Scene, grid: Cell[][], highlight: (r: number, c: number) => Highlight, pop?: number): void;
+/** The keys' counts of digits left, greyed out at none. */
+export declare function drawKeys(world: World, l: Layout, s: Scene, counts: number[]): void;
+/** A key pressed down into the board while touched. */
+export declare function pressKey(world: World, l: Layout, s: Scene, n: number, down: boolean): void;
+/** A wrong number: the cell shakes. */
+export declare function shakeCell(world: World, l: Layout, s: Scene, i: number): void;
+/** A completed row / column / box (or the whole board): its cells hop and flash in a sweep from `origin`. */
+export declare function flash(world: World, l: Layout, s: Scene, cells: number[], origin: number): void;
+/** Solved: confetti over the board. */
+export declare function celebrate(world: World, l: Layout): void;
+export { keyTop, cellTop };

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

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

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

@@ -1,54 +1,35 @@
-export declare const UNIT: number;
-export declare const BOARD_W: number;
-export declare const BOARD_H: number;
-export declare const SNAP_DIST: number;
-export declare const ROT_TOL = 30;
-export declare const TRAY_SCALE = 0.55;
-export declare const TANGRAM_GAME_CONFIG: {
-    readonly GAME_DURATION: 120;
-    readonly POINTS_PER_PIECE: 1000;
-    readonly TIME_BONUS_PER_SECOND: 10;
-    readonly TOTAL_PIECES: 7;
+import type { TiltView } from '../shared/EngineTilt';
+export declare const GAME_DURATION = 120;
+export declare const POINTS_PER_PIECE = 1000;
+export { TRAY_SCALE, RIM_RADIUS } from './TangramRules';
+export declare const TAP_MAX = 0.25;
+export declare const TAP_SLOP = 10;
+export declare const ROTATE_STEP = 45;
+export declare const ROTATE_TIME = 0.18;
+export declare const SNAP_TIME = 0.16;
+export declare const ENTRY_STAGGER = 0.045;
+export declare const WIN_DELAY = 0.22;
+export declare const WIN_STAGGER = 0.09;
+export declare const COLORS: {
+    readonly CLASSIC_SLOT: "rgba(255, 255, 255, 0.12)";
+    readonly CLASSIC_SLOT_EDGE: "rgba(255, 255, 255, 0.30)";
 };
-export type PieceType = 'large' | 'medium' | 'small' | 'square' | 'para';
-export interface Pt {
-    x: number;
-    y: number;
-}
-export interface TanTarget {
-    id: number;
-    type: PieceType;
-    color: string;
-    stroke: string;
-    localPoints: Pt[];
-    canvasSize: number;
-    targetCx: number;
-    targetCy: number;
-    targetRot: number;
-    symmetry: number;
-    silPath: string;
-    initialRot: number;
-    scatterCx: number;
-    scatterCy: number;
-}
-export interface TangramLevel {
-    pieces: TanTarget[];
-    silhouetteRect: {
-        x: number;
-        y: number;
-        w: number;
-        h: number;
-    };
-}
-export declare const TANGRAM_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly SILHOUETTE_FILL: "rgba(255, 255, 255, 0.12)";
-    readonly SILHOUETTE_STROKE: "rgba(255, 255, 255, 0.30)";
-    readonly TRAY_HINT: "rgba(255, 255, 255, 0.10)";
-    readonly TEXT_PRIMARY: "#FFFFFF";
+/** A directly overhead camera and light keep shapes and finger positions aligned. */
+export declare const TILT = 0;
+export declare const LIGHT: import("@nayan-ui/engine").Light;
+/** A tan's thickness, and the gap between stacked tans in the tray, in tan units. */
+export declare const PIECE_DEPTH = 0.2;
+export declare const STACK_STEP = 0.14;
+/** How high a tan rises off the board while held. */
+export declare const HELD_HEIGHT = 1.2;
+export type Layout = TiltView & {
+    unit: number;
+    boardW: number;
+    boardH: number;
 };
-export declare const generateLevel: (levelIndex: number) => TangramLevel;
-export declare const isRotationMatched: (cur: number, target: number, sym: number) => boolean;
-export declare const snappedRotation: (cur: number, target: number, sym: number) => number;
-export declare const localPath: (points: Pt[], cx: number, cy: number) => string;
+/** Fit the entire grid, including its outline, inside the game width. */
+export declare function getLayout(width: number, height: number, offset: number): Layout;
+/** A board point (x right, y down from the board's top-left) in the world (the board centred on the origin, y up). */
+export declare const toWorld: (l: Layout, x: number, y: number) => [number, number];
+/** And back. */
+export declare const toBoard: (l: Layout, wx: number, wy: number) => [number, number];

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

@@ -0,0 +1,68 @@
+import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './TangramConstants';
+import { type TangramLevel } from './TangramRules';
+import { type Scene } from './TangramScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** rotate: a tan turned; place: one snapped in; wrong: dropped over its slot at the wrong turn; win / lose: how it ended. */
+export type GameEvent = 'rotate' | 'place' | 'wrong' | 'win' | 'lose';
+/** A tan's state: its centre (board points), its turn (degrees, clockwise), and whether it's in a slot. */
+type Tan = {
+    x: number;
+    y: number;
+    rot: number;
+    placed: boolean;
+};
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    level: number;
+    data: TangramLevel | null;
+    tans: Tan[];
+    occupied: boolean[];
+    /** The tan last picked up (shown full size, on top), or -1. */
+    active: number;
+    /** A finger on a tan: where it went down (view and board points), when, and whether it's dragging. */
+    held: {
+        id: number;
+        sx: number;
+        sy: number;
+        bx: number;
+        by: number;
+        ox: number;
+        oy: number;
+        at: number;
+        moved: boolean;
+    } | null;
+    placed: number;
+    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    readonly timeLeft: number;
+    won: boolean;
+    /** Seconds since the game was made, for telling taps from holds. */
+    clock: number;
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onPlaced: (_n: 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): the level is rebuilt for its size. */
+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;
+/** Stop: back to the first silhouette, set out afresh (as the original game). */
+export declare function stop(g: Game): void;
+/** Play Again: the next silhouette after a win, the same one again after running out of time. */
+export declare function playAgain(g: Game): void;
+export declare function dispose(g: Game): void;
+export declare function tick(g: Game, dt: number): void;
+/** The tan under a board point: the active one first, then the higher ids (drawn above), never a placed one. */
+export declare function tanAt(g: Game, bx: number, by: number): number;
+export declare function drag(g: Game, e: DragEvent): void;
+export {};

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;