@nayan-ui/games 1.19.0 → 1.21.0

package/lib/typescript/src/games/memory-match/MemoryMatchRules.d.ts

@@ -0,0 +1,14 @@
+export declare const ROWS = 5;
+export declare const COLS = 4;
+export type FruitSymbol = 'apple' | 'orange' | 'banana' | 'grapes' | 'kiwi' | 'strawberry' | 'mango' | 'peach' | 'cherries' | 'pineapple' | 'watermelon' | 'pomegranate';
+export declare const FRUIT_SYMBOLS: FruitSymbol[];
+export type CardState = 'down' | 'up' | 'matched';
+export type Card = {
+    symbol: number;
+    state: CardState;
+};
+/** A fresh deck: a pair of each of the first ten fruits, Fisher-Yates shuffled (the same draws as the original store). */
+export declare function buildDeck(): {
+    cards: Card[];
+    totalPairs: number;
+};

package/lib/typescript/src/games/memory-match/MemoryMatchScene.d.ts

@@ -0,0 +1,35 @@
+import { type Entity, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './MemoryMatchConstants';
+import { type Card } from './MemoryMatchRules';
+/** A shared transform keeps the stock, printed faces, match seal and fruit together during a flip. */
+type CardView = {
+    root: Entity;
+    body: Entity;
+    backBody: Entity;
+    back: Entity;
+    front: Entity;
+    seal: Entity;
+    fruit: Entity;
+    fruitScale: number;
+};
+export type Scene = {
+    backdrop: Entity;
+    cards: CardView[];
+};
+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;
+/** A new deal: every card face down with its new fruit, popping in one after another. */
+export declare function deal(world: World, l: Layout, s: Scene, cards: Card[]): void;
+/** A card turns over (face up or face down), lifting off the table as it turns; its fruit shows only face up. */
+export declare function flip(world: World, l: Layout, s: Scene, i: number, up: boolean): void;
+/** A pair found: both cards turn green and pulse. */
+export declare function matched(world: World, l: Layout, s: Scene, i: number): void;
+/** A miss: both cards shake. */
+export declare function mismatch(world: World, l: Layout, s: Scene, i: number): void;
+/** Every pair found: a pulse wave across the board, and confetti. */
+export declare function celebrate(world: World, l: Layout, s: Scene): void;
+/** Out of time: the cards not matched dim. */
+export declare function timeUp(world: World, s: Scene, cards: Card[]): void;
+export {};

package/lib/typescript/src/games/mine-sweeper/MineSweeper.d.ts

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

package/lib/typescript/src/games/mine-sweeper/MineSweeperConstants.d.ts

@@ -1,85 +1,46 @@
-export declare const GRID_PIXEL_WIDTH: number;
-export declare const GRID_PIXEL_HEIGHT: number;
-export declare const GRID_TOTAL_WIDTH: number;
-export declare const GRID_TOTAL_HEIGHT: number;
-export declare const GRID_HEIGHT: number;
-export declare const BOARD_3D: {
-    readonly DEPTH: 10 | 8;
-    readonly PADDING: 0;
-    readonly RADIUS: 16 | 12;
+import type { TiltView } from '../shared/EngineTilt';
+export type Board = {
+    rows: number;
+    cols: number;
+    mines: number;
 };
-export declare const BOARD_FRAME_COLORS: {
-    readonly BOARD_TOP: "rgba(255, 255, 255, 0.30)";
-    readonly BOARD_FRONT: "rgba(255, 255, 255, 0.20)";
-    readonly BOARD_INNER: "rgba(255, 255, 255, 0.15)";
-    readonly BOARD_HIGHLIGHT: "rgba(255, 255, 255, 0.40)";
+/** 9 x 10 on a phone, 12 x 14 on a tablet (as the original game sized it), with 5 mines on either. */
+export declare const boardFor: (tablet: boolean) => Board;
+export declare const TIME_LIMIT = 180;
+export declare const POINTS_PER_REVEAL = 100;
+export declare const POINTS_PER_FLAG = 50;
+export declare const WIN_BONUS = 5000;
+export declare const FLAG_HOLD = 0.3;
+export declare const TAP_SLOP = 10;
+export declare const TAP_MAX = 0.5;
+export declare const GAME_OVER_DELAY = 0.4;
+export declare const REVEAL_STEP = 0.025;
+export declare const NUMBER_COLORS: string[];
+export declare const COLORS: {
+    readonly HIDDEN: "#3D7A4E";
+    readonly HIDDEN_ALT: "#5DA86E";
+    readonly REVEALED: "#F0E6D0";
+    readonly REVEALED_ALT: "#E5DABE";
+    readonly MINE: "#E74C3C";
+    readonly CLASSIC_BOARD: "rgba(255, 255, 255, 0.30)";
+    readonly CLASSIC_GRID: "rgba(255, 255, 255, 0.10)";
 };
-export declare const MINE_SWEEPER_GAME_CONFIG: {
-    readonly ROWS: 14 | 10;
-    readonly COLS: 12 | 9;
-    readonly CELL_SIZE: number;
-    readonly CELL_SPACING: 3;
-    readonly MINE_COUNT: 12 | 10;
-    readonly POINTS_PER_REVEAL: 100;
-    readonly POINTS_PER_FLAG: 50;
-    readonly WIN_BONUS: 5000;
-};
-export declare const MINE_SWEEPER_TIME_LIMIT = 180;
-export declare const NUMBER_COLORS: Record<number, string>;
-export declare const MINE_SWEEPER_COLORS: {
-    readonly BACKGROUND: "#1a3320";
-    readonly PRIMARY: "#ffffff";
-    readonly CELL_HIDDEN: "#3D7A4E";
-    readonly CELL_HIDDEN_ALT: "#5DA86E";
-    readonly CELL_REVEALED: "#F0E6D0";
-    readonly CELL_REVEALED_ALT: "#E5DABE";
-    readonly GRID_LINE: "#2A5438";
-    readonly CELL_MINE: "#E74C3C";
-    readonly CELL_FLAG: "#FFD700";
-    readonly CELL_BORDER: "rgba(0, 0, 0, 0.15)";
-    readonly UI: "#ffffff";
-    readonly GRID_BOX_FILL: "rgba(255, 255, 255, 0.10)";
-    readonly GRID_BOX_BORDER: "rgba(255, 255, 255, 0.25)";
-};
-export declare const CELL_BEVEL: number;
-export declare const CELL_3D: {
-    readonly hidden: {
-        readonly top: string;
-        readonly face: "#3D7A4E";
-        readonly faceBottom: string;
-        readonly right: string;
-        readonly bottom: string;
-        readonly highlight: "rgba(255, 255, 255, 0.30)";
-    };
-    readonly hiddenAlt: {
-        readonly top: string;
-        readonly face: "#5DA86E";
-        readonly faceBottom: string;
-        readonly right: string;
-        readonly bottom: string;
-        readonly highlight: "rgba(255, 255, 255, 0.30)";
-    };
-    readonly revealed: {
-        readonly face: "#F0E6D0";
-        readonly faceBottom: string;
-        readonly insetShadow: "rgba(0, 0, 0, 0.12)";
-        readonly insetLight: "rgba(255, 255, 255, 0.4)";
-    };
-    readonly revealedAlt: {
-        readonly face: "#E5DABE";
-        readonly faceBottom: string;
-        readonly insetShadow: "rgba(0, 0, 0, 0.12)";
-        readonly insetLight: "rgba(255, 255, 255, 0.4)";
-    };
-    readonly mine: {
-        readonly face: "#E74C3C";
-        readonly faceBottom: string;
-        readonly glow: "rgba(231, 76, 60, 0.5)";
-    };
-    readonly flag: {
-        readonly pole: "#8B4513";
-        readonly cloth: "#E74C3C";
-        readonly clothShadow: string;
-        readonly base: "#555555";
-    };
+/** The camera leans back from straight down, so the raised tiles, flags and mines stand up. */
+export declare const TILT = 0.34;
+/** Lit from the upper left; surfaces facing up off the board (+z) keep their exact color. */
+export declare const LIGHT: import("@nayan-ui/engine").Light;
+export declare const SPACING = 3;
+export type Layout = TiltView & Board & {
+    cell: number;
+    pitch: number;
+    gridWidth: number;
+    gridHeight: number;
+    boardWidth: number;
+    boardHeight: number;
 };
+/** Whole-point cells as wide as the game area allows (as the original board), smaller if the screen is short. */
+export declare function getLayout(width: number, height: number, offset: number, b: Board): Layout;
+/** A cell's centre on the board (row 0 along the top), in world units. */
+export declare function cellCentre(l: Layout, row: number, col: number): [number, number];
+/** The cell a board point is on (not in the gaps between cells), or null. */
+export declare function cellAt(l: Layout, x: number, y: number): [number, number] | null;

package/lib/typescript/src/games/mine-sweeper/MineSweeperGame.d.ts

@@ -0,0 +1,59 @@
+import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Board, type Layout } from './MineSweeperConstants';
+import { type Cell } from './MineSweeperRules';
+import { type Scene } from './MineSweeperScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** reveal: cells opened; flag: a flag planted; mine: one went off. */
+export type GameEvent = 'reveal' | 'flag' | 'mine';
+export declare function createGame(theme: GameTheme, board: Board): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    board: Board;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    grid: Cell[][];
+    firstReveal: boolean;
+    /** Set the moment a mine goes off: nothing more counts in the beat before the round ends. */
+    mineHit: boolean;
+    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    readonly timeRemaining: number;
+    minesRemaining: number;
+    revealed: number;
+    won: boolean;
+    /** A finger down on the board: where, when, and whether it's already flagged (so the lift isn't a tap). */
+    press: {
+        x: number;
+        y: number;
+        at: number;
+        cell: [number, number] | null;
+        flagged: boolean;
+    } | null;
+    /** Seconds on the game's clock, for telling taps from presses. */
+    clock: number;
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onTime: (_t: number) => void;
+    onMines: (_n: 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 from the grid'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, hidden 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;
+/** The cell under a view point (on the raised tiles' tops), or null between cells or off the board. */
+export declare function cellUnder(g: Game, x: number, y: number): [number, number] | null;
+/** Down on a cell starts a press; resting there flags it (in `tick`); a quick lift without wandering reveals it. */
+export declare function drag(g: Game, { phase, x, y }: DragEvent): void;
+/** Reveals a cell: a mine ends the round; otherwise it (and any empty run) opens, 100 points a cell. */
+export declare function revealAt(g: Game, row: number, col: number): void;
+/** Flags a hidden cell (50 points, one fewer mine to find) or takes its flag back off. */
+export declare function toggleFlag(g: Game, row: number, col: number): void;

package/lib/typescript/src/games/mine-sweeper/MineSweeperRules.d.ts

@@ -0,0 +1,18 @@
+import type { Board } from './MineSweeperConstants';
+export declare enum CellState {
+    HIDDEN = "hidden",
+    REVEALED = "revealed",
+    FLAGGED = "flagged"
+}
+export type Cell = {
+    row: number;
+    col: number;
+    isMine: boolean;
+    state: CellState;
+    adjacentMines: number;
+};
+export declare function emptyGrid(b: Board): Cell[][];
+/** Lays the mines anywhere but the 3 x 3 round the first reveal, then counts each cell's neighbours. */
+export declare function placeMines(grid: Cell[][], b: Board, safeRow: number, safeCol: number): void;
+/** The cells a reveal opens, breadth first from the tapped one: past every empty cell to its neighbours, stopping at flags and mines. */
+export declare function floodReveal(grid: Cell[][], b: Board, startRow: number, startCol: number): Cell[];

package/lib/typescript/src/games/mine-sweeper/MineSweeperScene.d.ts

@@ -0,0 +1,23 @@
+import { type Camera, type Entity, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './MineSweeperConstants';
+import { type Cell } from './MineSweeperRules';
+export type Scene = {
+    backdrop: Entity;
+    panel: Entity;
+    grid: Entity | null;
+    tiles: Entity[];
+    /** What sits on each cell: its count, a flag or a mine (null when nothing does). */
+    marks: (Entity | null)[];
+};
+export declare function buildScene(world: World, l: Layout, theme: GameTheme, grid: Cell[][]): Scene;
+export declare function removeScene(world: World, s: Scene): void;
+export declare function setSceneTheme(world: World, l: Layout, s: Scene, theme: GameTheme): void;
+/** Revealed cells sink to sand one after another, rippling out from the first, and show what they hold. */
+export declare function reveal(world: World, l: Layout, s: Scene, cells: Cell[], origin: Cell): void;
+/** A flag goes up, or comes down. */
+export declare function flag(world: World, l: Layout, s: Scene, cell: Cell): void;
+/** A mine goes off: a fireball, a jolt, and every mine shows. */
+export declare function explode(world: World, l: Layout, s: Scene, camera: Camera, hit: Cell, mines: Cell[]): void;
+/** Every safe cell cleared: confetti over the board. */
+export declare function celebrate(world: World, l: Layout): void;

package/lib/typescript/src/games/mob-control/MobControl.d.ts

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

package/lib/typescript/src/games/mob-control/MobControlConstants.d.ts

@@ -1,89 +1,103 @@
-export declare const LANE_INNER = 0.86;
-export declare const GATE_REF_Y: number;
+import type { Light } from '@nayan-ui/engine';
 export declare const MOB_CONFIG: {
-    readonly SCREEN_WIDTH: number;
-    readonly SCREEN_HEIGHT: number;
-    readonly FIELD_TOP: number;
-    readonly FIELD_BOTTOM: number;
-    readonly ENEMY_LINE: number;
-    readonly PLAYER_LINE: number;
-    readonly ROAD_TOP_Y: number;
-    readonly ROAD_BOTTOM_Y: number;
-    readonly ROAD_HALF_TOP: number;
-    readonly ROAD_HALF_BOTTOM: number;
-    readonly DEPTH_FAR_SCALE: 0.78;
-    readonly DEPTH_NEAR_SCALE: 1.25;
-    readonly ENEMY_SCALE: 1.28;
-    readonly CANNON_Y: number;
-    readonly CANNON_WIDTH: 90 | 68;
-    readonly BLOB_MIN_RADIUS: 16 | 13;
-    readonly BLOB_MAX_RADIUS: 28 | 34;
-    readonly PLAYER_BLOB_SPEED: 7 | 5.6;
-    readonly ENEMY_BLOB_SPEED: 1.1 | 0.85;
-    readonly MAX_COUNT: 80;
-    readonly MAX_BLOBS: 28;
-    readonly ENEMY_COUNT_CAP: 40;
-    readonly FIRE_INTERVAL_MS: 480;
-    readonly FIRE_COUNT: 2;
-    readonly GATE_HEIGHT: 46 | 38;
-    readonly GATE_SPEED: 1.1 | 1.4;
-    readonly GATE_SPAWN_INTERVAL_MS: 3200;
-    readonly MAX_GATES: 2;
-    readonly ENEMY_BASE_HP: 40;
-    readonly ENEMY_HP_PER_LEVEL: 20;
-    readonly PLAYER_HP: 30;
-    readonly ENEMY_SPAWN_INTERVAL_MS: 3600;
-    readonly ENEMY_SPAWN_MIN_MS: 2200;
-    readonly ENEMY_LEVEL_CAP: 10;
-    readonly SCORE_PER_KILL: 100;
-    readonly SCORE_PER_LEVEL: 1000;
-    readonly GAME_DURATION_MS: 120000;
+    readonly HALF_WIDTH: 5.2;
+    readonly TRACK_NEAR_Z: 30;
+    readonly TRACK_FAR_Z: -150;
+    readonly CANNON_LIMIT: 4.25;
+    readonly CANNON_Z: 1.2;
+    readonly SPAWN_Z: -0.9;
+    readonly BASE_Z: -32;
+    readonly TARGET_LINE: -29.5;
+    readonly BREACH_Z: 0.15;
+    readonly PLAYER_HP: 1200;
+    readonly PLAYER_SLOTS: 640;
+    readonly ENEMY_SLOTS: 384;
+    readonly CAPACITY: 1024;
+    readonly BASE_HP: 1000;
+    readonly CORE_HP: 1400;
+    readonly ENEMY_WAVE_SIZE: 14;
+    readonly ENEMY_WAVE_INTERVAL: 1.35;
+    readonly ENEMY_SURGE_INTERVAL: 15;
+    readonly ENEMY_MAX_SURGE: 8;
+    readonly MAX_STRENGTH: 4096;
+    readonly PLAYER_SPEED: 4.8;
+    readonly ENEMY_SPEED: 2.65;
+    readonly FIRE_INTERVAL: 0.105;
+    readonly CHAMPION_CHARGE: 100;
+    readonly CHAMPION_PER_SHOT: 1.6;
+    readonly CHAMPION_STRENGTH: 42;
+    readonly CHAMPION_SPEED: 6.2;
+    readonly BOSS_STRENGTH: 170;
+    readonly BOSS_SPEED: 1.55;
+    readonly BOOST_SPEED: 1.65;
+    readonly BOOST_DURATION: 1.4;
+    readonly FLIGHT_DURATION: 0.38;
+    readonly COLLISION_RADIUS: 0.34;
+    readonly GRID_SIZE: 0.8;
+    readonly GRID_COLUMNS: 14;
+    readonly GRID_ROWS: 46;
+    readonly MAX_COLLISION_VISITS: 48;
+    readonly MAX_SEPARATION_VISITS: 12;
+    readonly STEP: number;
+    readonly MAX_FRAME: 0.05;
+    readonly HUD_INTERVAL: 0.12;
+    readonly EFFECT_INTERVAL: 0.075;
+    readonly MAX_EFFECTS: 6;
+    readonly WORLD_CAPACITY: 640;
+    readonly KILL_POINTS: 5;
+    readonly BASE_POINTS: 350;
+    readonly LEVEL_POINTS: 500;
 };
-export type GateOp = {
-    kind: 'mul';
-    value: number;
-} | {
-    kind: 'add';
-    value: number;
-};
-export declare const GATE_OPS: GateOp[];
-export declare const gateLabel: (op: GateOp) => string;
-export declare const radiusForCount: (count: number) => number;
+export interface Gate {
+    id: number;
+    x: number;
+    originX: number;
+    z: number;
+    halfWidth: number;
+    factor: number;
+    operation: 'multiply' | 'add' | 'divide';
+    moving: boolean;
+    hits: number;
+    remainder: number;
+}
+export interface Barrier {
+    x: number;
+    z: number;
+    halfWidth: number;
+    hp: number;
+    maxHp: number;
+}
+export interface BoostPad {
+    x: number;
+    z: number;
+    halfWidth: number;
+    halfLength: number;
+}
+export interface Base {
+    x: number;
+    z: number;
+    hp: number;
+    maxHp: number;
+    spawnClock: number;
+}
 export declare const MOB_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly PLAYER: "#4D96FF";
-    readonly PLAYER_LIGHT: "#B9D6FF";
-    readonly PLAYER_DARK: "#1E52A8";
-    readonly ENEMY: "#FF5C5C";
-    readonly ENEMY_LIGHT: "#FFC2C2";
-    readonly ENEMY_DARK: "#B32B2B";
-    readonly BLOB_SHADOW: "rgba(0,0,0,0.22)";
-    readonly GRASS_TOP: "#82C24A";
-    readonly GRASS_BOTTOM: "#5FA336";
-    readonly GRASS_DARK: "#3F7A28";
-    readonly SAND_FAR: "#A8916A";
-    readonly SAND_NEAR: "#C4AF86";
-    readonly SAND_EDGE: "rgba(70,50,24,0.30)";
-    readonly FLOWER_1: "#FFFFFF";
-    readonly FLOWER_2: "#FFD34A";
-    readonly FLOWER_3: "#FF7BAC";
-    readonly GATE_GOOD: "#6BCB77";
-    readonly GATE_GOOD_DARK: "#3C8F4C";
-    readonly GATE_ADD: "#FFB443";
-    readonly GATE_ADD_DARK: "#D9861E";
-    readonly GATE_FRAME: "#2B3A2E";
-    readonly ENEMY_BASE: "#C24350";
-    readonly ENEMY_BASE_DARK: "#7A2732";
-    readonly ENEMY_BASE_TOP: "#E36572";
-    readonly ENEMY_BASE_SIDE: "#94303C";
-    readonly CANNON: "#4E8FD6";
-    readonly CANNON_LIGHT: "#8FC0F5";
-    readonly CANNON_DARK: "#234E7D";
-    readonly CANNON_METAL: "#3A4A5E";
-    readonly CANNON_METAL_DARK: "#232E3D";
-    readonly HP_BAR_BG: "rgba(0,0,0,0.35)";
-    readonly HP_BAR_ENEMY: "#FF5C5C";
-    readonly HP_BAR_PLAYER: "#6BCB77";
-    readonly TEXT: "#ffffff";
+    readonly PLAYER: "#3998FF";
+    readonly ENEMY: "#F25467";
+    readonly PLAYER_DARK: "#1D568F";
+    readonly ENEMY_DARK: "#8D2D42";
+    readonly GATE: "#29BFFF";
+    readonly GATE_HIGH: "#A14CF5";
+    readonly GATE_DANGER: "#F16B68";
+    readonly FRAME: "#1763A8";
+    readonly ROAD: "#CDD0D2";
+    readonly ROAD_EDGE: "#E6BA78";
+    readonly GROUND: "#D7AB72";
+    readonly CHAMPION: "#FFC83E";
+    readonly BOOST: "#7DECF1";
+    readonly HP_PLAYER: "#54CDA2";
+    readonly HP_ENEMY: "#F25467";
 };
+export declare const SKY_DAY: readonly [0.67, 0.81, 0.88];
+export declare const SKY_NIGHT: readonly [0.035, 0.07, 0.13];
+export declare const DAY_LIGHT: Light;
+export declare const NIGHT_LIGHT: Light;

package/lib/typescript/src/games/mob-control/MobControlGame.d.ts

@@ -0,0 +1,45 @@
+import { type Camera, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { MobControlRenderer } from './MobControlRenderer';
+import { type Scene, type View } from './MobControlScene';
+export type Phase = 'ready' | 'playing' | 'over';
+export type GameEvent = 'shoot' | 'gate' | 'hit' | 'clash' | 'boss' | 'damage' | 'champion' | 'win' | 'lose';
+export interface Hud {
+    score: number;
+    hp: number;
+    army: number;
+    level: number;
+}
+export declare const INITIAL_HUD: Hud;
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    renderer: MobControlRenderer;
+    sim: import("./MobControlRules").Sim;
+    camera: Camera;
+    night: boolean;
+    view: View | null;
+    scene: Scene | null;
+    phase: Phase;
+    won: boolean;
+    active: boolean;
+    pending: number;
+    clock: number;
+    lastHud: number;
+    lastEffect: number;
+    hudKey: string;
+    feedback: Partial<Record<GameEvent, number>>;
+    readonly score: number;
+    onPhase: (_phase: Phase) => void;
+    onHud: (_hud: Hud) => void;
+    onEvent: (_event: GameEvent) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+export declare function setLayout(g: Game, width: number, height: number): void;
+export declare function setTheme(g: Game, theme: GameTheme): void;
+export declare function reset(g: Game): void;
+export declare function replay(g: Game): void;
+export declare function start(g: Game): void;
+export declare function aim(g: Game, x: number): void;
+export declare function setActive(g: Game, active: boolean): void;
+export declare function dispose(g: Game): void;
+export declare function tick(g: Game, dt: number): void;

package/lib/typescript/src/games/mob-control/MobControlMeshes.d.ts

@@ -0,0 +1,2 @@
+import { type Model } from '@nayan-ui/engine';
+export declare function unitMeshes(): readonly [Model, Model];

package/lib/typescript/src/games/mob-control/MobControlRenderer.d.ts

@@ -0,0 +1,20 @@
+import { type Model, type RenderSource, type World } from '@nayan-ui/engine';
+import type { Sim } from './MobControlRules';
+export declare class MobControlRenderer implements RenderSource {
+    private readonly world;
+    private readonly poses;
+    readonly capacity: number;
+    readonly matrices: Float32Array;
+    readonly colors: Float32Array;
+    readonly regions: Float32Array;
+    readonly ranges: Uint32Array;
+    count: number;
+    private disposed;
+    private readonly sizeStrength;
+    private readonly sizeKind;
+    private readonly sizes;
+    constructor(world: World, poses: readonly [Model, Model]);
+    sync(s: Sim, alpha: number, clock: number): void;
+    setView(matrix: Float32Array, width: number, height: number): void;
+    dispose(): void;
+}

package/lib/typescript/src/games/mob-control/MobControlRules.d.ts

@@ -0,0 +1,68 @@
+import { type Barrier, type Base, type BoostPad, type Gate } from './MobControlConstants';
+export interface Events {
+    shots: number;
+    gates: number;
+    clashes: number;
+    hits: number;
+    breaches: number;
+    captured: number;
+    champion: boolean;
+    barrierBroken: number;
+    bossDefeated: boolean;
+    won: boolean;
+    lost: boolean;
+    effectCount: number;
+    effectX: Float32Array;
+    effectZ: Float32Array;
+    effectTeam: Uint8Array;
+}
+export interface Sim {
+    alive: Uint8Array;
+    x: Float32Array;
+    z: Float32Array;
+    previousX: Float32Array;
+    previousZ: Float32Array;
+    strength: Uint16Array;
+    gatesPassed: Uint8Array;
+    ticket: Uint32Array;
+    kind: Uint8Array;
+    boost: Float32Array;
+    flight: Float32Array;
+    next: Int16Array;
+    playerGrid: Int16Array;
+    enemyGrid: Int16Array;
+    freePlayer: Uint16Array;
+    freeEnemy: Uint16Array;
+    freePlayerCount: number;
+    freeEnemyCount: number;
+    playerCount: number;
+    enemyCount: number;
+    playerStrength: number;
+    enemyStrength: number;
+    championCount: number;
+    bossCount: number;
+    charge: number;
+    serial: number;
+    seed: number;
+    level: number;
+    elapsed: number;
+    battleClock: number;
+    fireClock: number;
+    cannonX: number;
+    targetX: number;
+    hp: number;
+    score: number;
+    finished: boolean;
+    won: boolean;
+    gates: Gate[];
+    bases: Base[];
+    barriers: Barrier[];
+    boostPad: BoostPad | null;
+    events: Events;
+    collisionVisits: number;
+}
+export declare const isPlayer: (i: number) => boolean;
+export declare function createSim(seed?: number, level?: number): Sim;
+/** Pool pressure packs strength into an existing slot; it never silently deletes a multiplied army. */
+export declare function spawn(s: Sim, player: boolean, x: number, z: number, strength?: number, passed?: number, kind?: number, airborne?: boolean): number;
+export declare function step(s: Sim, dt: number): Events;