@nayan-ui/games 1.19.0 → 1.21.0

package/lib/typescript/src/games/bike-racing/BikeRacingConstants.d.ts

@@ -1,31 +1,40 @@
-export declare const BIKE_RACING_GAME_CONFIG: {
-    GAME_DURATION: number;
-    BIKE_WIDTH: number;
-    BIKE_HEIGHT: number;
-    OBSTACLE_WIDTH: number;
-    OBSTACLE_HEIGHT: number;
-    ROAD_LANES: number;
-    LANE_WIDTH: number;
-    ROAD_SPEED: number;
-    OBSTACLE_SPAWN_INTERVAL: number;
-    COLLISION_TOLERANCE: number;
-    POINTS_PER_OBSTACLE_PASSED: number;
-    LANE_SWITCH_DURATION: number;
-    PLAYER_BOTTOM_MARGIN: number;
+import type { Color, Model, Vec3 } from '@nayan-ui/engine';
+import { type Assets as RoadAssets } from '../car-racing/CarRacingConstants';
+export { AUTOPLAY, CAMERA_FOV, DAY_LIGHT, EDGE, FINISH_CLEAR, LANES, LATERAL_SPEED, NIGHT_LIGHT, NIGHT_SKY, ROAD_HALF, SKY, STEER_RESPONSE, STEER_WIDTH, TRACK_LENGTH, getRacingSounds } from '../car-racing/CarRacingConstants';
+export declare const LIVES = 3;
+export declare const POINTS_PER_BIKE_PASSED = 500;
+export declare const START_SPEED = 30;
+export declare const TRAFFIC_SPEED = 16;
+export declare const SPAWN_AHEAD = 170;
+export declare const CRASH_SLOWDOWN = 0.5;
+export declare const INVULNERABLE = 1.6;
+/** Passing a bike with this little between your middles (metres) counts as a near miss. */
+export declare const NEAR_MISS_GAP = 1.3;
+export declare const LEAN = 0.045;
+export declare const MAX_LEAN = 0.5;
+/** The original game's bike colors: the player's orange, traffic in blue, green and magenta (and a few more). */
+export declare const PLAYER_PAINT: Color;
+export declare const PAINTS: Color[];
+export declare const SUIT: Color;
+export declare const SUIT_TRIM: Color;
+export declare const VISOR: Color;
+/**
+ * One bike for everyone, built in code (BikeMeshes). Its paint is white so each bike tints its own
+ * color; the trim (frame, tyres, wheels, chrome, exhaust) and the smoked windscreen keep theirs. The
+ * rider is built from the engine's shapes (BikeRacingScene).
+ */
+export type BikeModel = {
+    body: Model;
+    trim: Model;
+    glass: Model;
+    size: Vec3;
 };
-export declare const BIKE_RACING_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly ROAD_DARK: "#3a3a5e";
-    readonly ROAD_LIGHT: "#2a2a2a";
-    readonly ROAD_LINE: "#ffff00";
-    readonly GRASS_GREEN: "#2d5016";
-    readonly GRASS_DARK: "#1a3009";
-    readonly SKY_BLUE: "#87ceeb";
-    readonly PLAYER_BIKE: "#ff6600";
-    readonly OBSTACLE_BIKE_1: "#0066ff";
-    readonly OBSTACLE_BIKE_2: "#00ff66";
-    readonly OBSTACLE_BIKE_3: "#ff00ff";
-    readonly UI: "#ffffff";
+export type Assets = RoadAssets & {
+    bike: BikeModel;
 };
-export declare const getLanePosition: (laneIndex: number, screenWidth: number) => number;
+export declare const getCachedAssets: () => Assets | null;
+export declare function loadAssets(): Promise<Assets>;
+/** Starts loading the game's textures and building its models (they're cached), so opening it is quick. */
+export declare function preloadBikeRacing(): void;
+/** Road assets are warmed by Car Racing first and reused here. */
+export declare function warmAssets(): Iterable<() => unknown>;

package/lib/typescript/src/games/bike-racing/BikeRacingGame.d.ts

@@ -0,0 +1,104 @@
+import { type Camera, type Entity, type Voice, World } from '@nayan-ui/engine';
+import { type Fire, Track } from '../car-racing/CarRacingScene';
+import type { HudFeedback } from '../shared/EngineHud';
+import { type Assets } from './BikeRacingConstants';
+export type Phase = 'ready' | 'playing' | 'over';
+export declare function createGame(a: Assets, night: boolean): {
+    world: World;
+    night: boolean;
+    track: Track;
+    chase: {
+        eye: [number, number, number];
+        target: [number, number, number];
+        initialized: boolean;
+    };
+    assets: Assets;
+    camera: Camera;
+    player: {
+        root: Entity;
+        lean: Entity;
+        lights: Entity[];
+    };
+    horizon: Entity;
+    segments: import("../car-racing/CarRacingScene").Segment[];
+    traffic: Bike[];
+    /** Wrecks on fire. */
+    burning: Fire[];
+    phase: Phase;
+    time: number;
+    s: number;
+    d: number;
+    target: number;
+    dragX: number;
+    speed: number;
+    lateral: number;
+    steeringGoal: number;
+    steeringPose: {
+        yaw: number;
+        roll: number;
+    };
+    spawnTimer: number;
+    invulnerable: number;
+    scrape: number;
+    orbit: number;
+    /** Seconds left of the start's wheelie, and of the wobble after a crash. */
+    wheelie: number;
+    wobble: number;
+    /** Score, lives and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    readonly lives: number;
+    /** Metres left to the finish gate. */
+    left: number;
+    shake: number;
+    engine: Voice | null;
+    audible: boolean;
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onLives: (_l: number) => void;
+    onDistance: (_metres: number) => void;
+    hudFeedback: HudFeedback;
+};
+export type Game = ReturnType<typeof createGame>;
+export declare function start(g: Game): void;
+/** Mirrors the shared screen's audible state without letting an engine loop leak to another screen. */
+export declare function setAudible(g: Game, enabled: boolean): void;
+/** Change the scene in place when the host theme changes. */
+export declare function setNight(g: Game, night: boolean): void;
+/** Steers toward the finger: `dx` is the drag's distance so far, `metresPerPoint` how far that moves the bike. */
+export declare function steer(g: Game, phase: 'start' | 'move' | 'end', dx: number, metresPerPoint: number): void;
+/** Stops the run's sounds and frees its world (the screen unmounting). */
+export declare function dispose(g: Game): void;
+export declare function tick(g: Game, dt: number): void;
+export type Bike = {
+    root: Entity;
+    lean: Entity;
+    lights: Entity[];
+    s: number;
+    d: number;
+    /** Its lane's centre, and which lane (0..2). */
+    lane: number;
+    laneIndex: number;
+    /** A gentle weave about the lane's centre. */
+    weave: number;
+    weaveSpeed: number;
+    phase: number;
+    /** How far a sideswipe has shoved it out of its line, and how fast it's still sliding. */
+    shove: number;
+    vshove: number;
+    passed: boolean;
+    crashed: boolean;
+    /** It was sideswiped (no near-miss bonus for it). */
+    bumped: boolean;
+    /** Seconds until another sideswipe makes a sound again. */
+    bumpCooldown: number;
+    /** Closest it came beside the player, for near misses. */
+    closest: number;
+    /** How far ahead of the player it was last frame, and whether it's touching (and met nose to tail). */
+    wasAhead: number;
+    touching: boolean;
+    headOn: boolean;
+};
+/** Traffic ahead, in a lane that doesn't close the road: bikes close together always leave a lane open. */
+export declare function spawnTraffic(g: Game, ahead?: number): void;
+/** Demo bot: head for the lane whose next bike is furthest away. */
+export declare function autopilot(g: Game): void;

package/lib/typescript/src/games/bike-racing/BikeRacingScene.d.ts

@@ -0,0 +1,25 @@
+import { type Color, type Entity, type Vec3, type World } from '@nayan-ui/engine';
+import { type Assets } from './BikeRacingConstants';
+/**
+ * A bike: an invisible root at its middle (the collider's centre once wrecked), a lean pivot where the
+ * tyres touch the road, and on it the body (painted), tyres, rider and helmet (in the bike's color).
+ */
+export declare function spawnBike(world: World, a: Assets, paint: Color, position: Vec3, night: boolean): {
+    root: Entity;
+    lean: Entity;
+    lights: Entity[];
+};
+/** Repaint lights without rebuilding the bike or disturbing its lean and wheelie. */
+export declare function setBikeNight(world: World, bike: {
+    root: Entity;
+    lean: Entity;
+    lights: Entity[];
+}, night: boolean): void;
+/**
+ * Leans a bike `roll` radians into a turn (positive to the right) about where its tyres touch the
+ * road, and lifts its nose `wheelie` radians about the rear tyre. `ground` is the pivot's place under
+ * the root (half the bike's height down).
+ */
+export declare function leanBike(world: World, lean: Entity, ground: number, roll: number, wheelie?: number): void;
+/** Reusable assets; the game loader advances one builder per frame. */
+export declare function warmAssets(): Iterable<() => unknown>;

package/lib/typescript/src/games/block-blast/BlockBlast.d.ts

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

package/lib/typescript/src/games/block-blast/BlockBlastConstants.d.ts

@@ -1,32 +1,50 @@
-export declare const BLOCK_BLAST_GAME_CONFIG: {
-    readonly GRID_SIZE: 9;
-    readonly CELL_SIZE: number;
-    readonly CELL_GAP: 2;
-    readonly NEXT_PIECES_COUNT: 3;
-    readonly POINTS_PER_BLOCK: 50;
-    readonly POINTS_PER_LINE: 500;
-    readonly COMBO_MULTIPLIER: 1.5;
-    readonly PREVIEW_PIECE_SCALE: 0.7;
-    readonly DRAGGING_PIECE_SCALE: 1;
-    readonly DRAG_Y_OFFSET: 50;
-    readonly GAME_DURATION: 300;
+import type { Color } from '@nayan-ui/engine';
+export { toColor } from '../shared/EngineUtils';
+export declare const GRID_SIZE = 9;
+export declare const NEXT_PIECES_COUNT = 3;
+export declare const POINTS_PER_BLOCK = 50;
+export declare const POINTS_PER_LINE = 500;
+export declare const GAME_DURATION = 300;
+export declare const BLOCK_COLORS: readonly ["#FF3B3B", "#32CD32", "#FFD700", "#4DA6FF", "#BF5AF2", "#FF9500"];
+export declare const BLOCK_SHAPES: readonly (readonly (readonly number[])[])[];
+export declare const TRAY_SCALE = 0.7;
+export declare const DRAG_LIFT = 50;
+export declare const LIFT_TIME = 0.14;
+export declare const RETURN_TIME = 0.18;
+export declare const DEAL_TIME = 0.24;
+export declare const FLASH_TIME = 0.26;
+export declare const FLASH_AMOUNT = 0.55;
+export declare const CLEAR_TIME = 0.5;
+export declare const CLEAR_RIPPLE = 0.025;
+export declare const PICKUP_SPRING: {
+    stiffness: number;
+    damping: number;
+    mass: number;
 };
-export declare const BLOCK_BLAST_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly GRID_BACKGROUND: "rgba(255, 255, 255, 0.12)";
-    readonly EMPTY_CELL: "rgba(255, 255, 255, 0.25)";
-    readonly GRID_LINE: "rgba(255, 255, 255, 0.35)";
-    readonly BLOCK_RED: "#FF3B3B";
-    readonly BLOCK_GREEN: "#32CD32";
-    readonly BLOCK_YELLOW: "#FFD700";
-    readonly BLOCK_BLUE: "#4DA6FF";
-    readonly BLOCK_PURPLE: "#BF5AF2";
-    readonly BLOCK_ORANGE: "#FF9500";
-    readonly COMBO_TEXT: "#ffd700";
-    readonly UI: "#ffffff";
-    readonly HEART: "#ffffff";
+export declare const CELL_GAP = 2;
+export type Layout = {
+    /** The GameView's size in points. */
+    width: number;
+    height: number;
+    cell: number;
+    /** Cell plus gap: the distance between neighbouring cells. */
+    step: number;
+    /** Board's outer square: top-left corner and side, in view points. */
+    boardLeft: number;
+    boardTop: number;
+    boardSize: number;
+    /** Centre of each tray slot, in view points. */
+    slots: [number, number][];
+    /** Width of each slot's touch area. */
+    slotWidth: number;
+    trayTop: number;
+    trayHeight: number;
+    /** Block thickness toward the camera. */
+    depth: number;
 };
-export declare const BLOCK_SHAPES: readonly [readonly [readonly [1]], readonly [readonly [1, 1]], readonly [readonly [1], readonly [1]], readonly [readonly [1, 1, 1]], readonly [readonly [1], readonly [1], readonly [1]], readonly [readonly [1, 1], readonly [1, 0]], readonly [readonly [1, 1], readonly [0, 1]], readonly [readonly [1, 0], readonly [1, 1]], readonly [readonly [0, 1], readonly [1, 1]], readonly [readonly [1, 1, 1, 1]], readonly [readonly [1], readonly [1], readonly [1], readonly [1]], readonly [readonly [1, 1], readonly [1, 1]], readonly [readonly [1, 1, 1], readonly [0, 1, 0]], readonly [readonly [0, 1, 0], readonly [1, 1, 1]], readonly [readonly [0, 1, 1], readonly [1, 1, 0]], readonly [readonly [1, 1, 0], readonly [0, 1, 1]], readonly [readonly [1, 1, 1], readonly [1, 0, 0]], readonly [readonly [0, 0, 1], readonly [1, 1, 1]], readonly [readonly [1, 0, 0], readonly [1, 1, 1]], readonly [readonly [1, 1, 1], readonly [0, 0, 1]]];
-export declare const getRandomBlockShape: () => readonly [readonly [1]] | readonly [readonly [1, 1]] | readonly [readonly [1], readonly [1]] | readonly [readonly [1, 1, 1]] | readonly [readonly [1], readonly [1], readonly [1]] | readonly [readonly [1, 1], readonly [1, 0]] | readonly [readonly [1, 1], readonly [0, 1]] | readonly [readonly [1, 0], readonly [1, 1]] | readonly [readonly [0, 1], readonly [1, 1]] | readonly [readonly [1, 1, 1, 1]] | readonly [readonly [1], readonly [1], readonly [1], readonly [1]] | readonly [readonly [1, 1], readonly [1, 1]] | readonly [readonly [1, 1, 1], readonly [0, 1, 0]] | readonly [readonly [0, 1, 0], readonly [1, 1, 1]] | readonly [readonly [0, 1, 1], readonly [1, 1, 0]] | readonly [readonly [1, 1, 0], readonly [0, 1, 1]] | readonly [readonly [1, 1, 1], readonly [1, 0, 0]] | readonly [readonly [0, 0, 1], readonly [1, 1, 1]] | readonly [readonly [1, 0, 0], readonly [1, 1, 1]] | readonly [readonly [1, 1, 1], readonly [0, 0, 1]] | undefined;
-export declare const getRandomBlockColor: () => "#FFD700" | "#FF3B3B" | "#32CD32" | "#4DA6FF" | "#BF5AF2" | "#FF9500" | undefined;
+export declare function getLayout(width: number, height: number, offset: number): Layout;
+export declare const LIGHT: import("@nayan-ui/engine").Light;
+/** Self-lit (flat, unshaded): the engine draws a color whose brightest channel is 2 at full brightness. */
+export declare function flat([r, g, b, a]: Color): Color;
+/** `color` blended toward white, for the placement glint. */
+export declare function tint([r, g, b]: Color, amount: number): Color;

package/lib/typescript/src/games/block-blast/BlockBlastGame.d.ts

@@ -0,0 +1,77 @@
+import { type Camera, type Color, type Entity, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './BlockBlastConstants';
+import { type Board, type BoardColors } from './BlockBlastScene';
+export type Phase = 'ready' | 'playing' | 'over';
+type Shape = readonly (readonly number[])[];
+type Piece = {
+    shape: Shape;
+    css: string;
+    color: Color;
+    root: Entity | null;
+};
+type Drag = {
+    slot: number;
+    /** Finger offset from the piece's centre at pickup, so the piece doesn't jump to the finger. */
+    offsetX: number;
+    offsetY: number;
+    x: number;
+    y: number;
+    liftedAt: number;
+    /** Drop target: top-left cell, or null when not over the board. */
+    row: number | null;
+    col: number | null;
+    valid: boolean;
+    returning: boolean;
+    drawnX?: number;
+    drawnY?: number;
+};
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    colors: BoardColors;
+    /** For the screen background (theme color and pattern, see EngineBackdrop). */
+    theme: GameTheme;
+    layout: Layout | null;
+    board: Board | null;
+    phase: Phase;
+    time: number;
+    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    readonly timeLeft: number;
+    won: boolean;
+    /** Each cell's color (css, for the line-clear sound check), or null. */
+    grid: (string | null)[];
+    gridColors: (Color | null)[];
+    blocks: (Entity | null)[];
+    pieces: Piece[];
+    drag: Drag | null;
+    /** What each preview overlay shows, so a hover only touches the cells that changed. */
+    ghostShown: (Color | null)[];
+    previewColors: Map<string, Color>;
+    highlightShown: boolean[];
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onTime: (_t: number) => void;
+    onPick: () => void;
+    onInvalid: () => void;
+    onPlace: () => void;
+    onClear: (_lines: number) => void;
+    onGameOver: () => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the scene out for the view (first layout, rotation, header height): rebuilt from the run's state. */
+export declare function setLayout(g: Game, l: Layout): void;
+/** Repaints the board and background for a new theme without touching the run. */
+export declare function setTheme(g: Game, theme: GameTheme): void;
+export declare function start(g: Game): void;
+/** A fresh board and tray (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;
+/** Finger down: picks up the tray piece under it (anywhere in its slot). */
+export declare function dragStart(g: Game, x: number, y: number): void;
+export declare function dragMove(g: Game, x: number, y: number): void;
+/** Finger up: drops the piece if it fits, otherwise it flies back to its slot. */
+export declare function dragEnd(g: Game): void;
+export {};

package/lib/typescript/src/games/block-blast/BlockBlastScene.d.ts

@@ -0,0 +1,36 @@
+import { type Color, type Entity, type Vec3, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import type { PopBurstOptions } from '../shared/EngineBlasts';
+import { type Layout } from './BlockBlastConstants';
+/** A view point (from the top-left) at depth `z`, in world space. */
+export declare const toWorld: (l: Layout, x: number, y: number, z?: number) => Vec3;
+/** Centre of a board cell, in view points. */
+export declare const cellCenter: (l: Layout, row: number, col: number) => [number, number];
+export declare const trayZ: (l: Layout) => number;
+export declare const dragZ = 80;
+export type BoardColors = GameTheme['BOARD'];
+/** The board: its panel and rim, the empty slots, and per-cell overlays for the drop preview. */
+export type Board = {
+    /** The game background (theme color and pattern), behind everything. */
+    backdrop: Entity;
+    rim: Entity;
+    panel: Entity;
+    empties: Entity[];
+    /** Lines the hovered drop would complete. */
+    highlights: Entity[];
+    /** The hovered piece's cells (its color, or the invalid color). */
+    ghosts: Entity[];
+};
+export declare function buildBoard(world: World, l: Layout, colors: BoardColors, theme: GameTheme): Board;
+/** Repaints the board for a theme (the run carries on). */
+export declare function colorBoard(world: World, b: Board, colors: BoardColors): void;
+/** Shows or hides a preview overlay (`null` hides it). */
+export declare function setOverlay(world: World, overlay: Entity, color: Color | null): void;
+/** A placed block on the board. */
+export declare function spawnBlock(world: World, l: Layout, row: number, col: number, color: Color): Entity;
+/** A piece: an invisible root at its centre with one block per cell, at `scale` of board size. */
+export declare function spawnPiece(world: World, l: Layout, shape: readonly (readonly number[])[], color: Color, at: [number, number], scale: number): Entity;
+/** A board block's scale (for popping it away). */
+export declare const blockScale: (l: Layout) => Vec3;
+/** Where a cleared block's burst flies from (just in front of it) and glows (behind it, over its cell). */
+export declare function blockBurst(l: Layout, row: number, col: number, color: Color): PopBurstOptions;

package/lib/typescript/src/games/block-breaker/BlockBreaker.d.ts

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

package/lib/typescript/src/games/block-breaker/BlockBreakerConstants.d.ts

@@ -1,41 +1,94 @@
-export declare const GRID_HEIGHT: number;
-export declare const BLOCK_BREAKER_GAME_CONFIG: {
-    readonly BRICK_COLS: 8;
-    readonly BRICK_ROWS: 5;
-    readonly BRICK_PADDING: 3;
-    readonly BRICK_WIDTH: number;
-    readonly BRICK_HEIGHT: 22 | 18;
-    readonly GRID_TOP: 5;
-    readonly PADDLE_WIDTH: 100 | 80;
-    readonly PADDLE_HEIGHT: 12 | 14;
-    readonly PADDLE_BOTTOM_OFFSET: 30 | 20;
-    readonly BALL_RADIUS: 7 | 8;
-    readonly BALL_SPEED: 4 | 5;
-    readonly POINTS_PER_BRICK: 200;
-    readonly POINTS_PER_MULTI_HIT: 150;
-    readonly LIVES: 3;
-    readonly POWER_UP_CHANCE: 0.15;
-    readonly POWER_UP_SPEED: 2;
-    readonly POWER_UP_SIZE: 14 | 18;
-};
-export declare const BRICK_COLORS: readonly ["#FF3B3B", "#FFD700", "#32CD32", "#4DA6FF", "#BF5AF2", "#FF9500"];
+export declare const BRICK_COLS = 8;
+export declare const BRICK_ROWS = 5;
+export declare const LIVES = 3;
+export declare const TIME_LIMIT = 300;
+export declare const POINTS_PER_BRICK = 200;
+export declare const POINTS_PER_COMBO = 150;
+export declare const COMBO_CALLOUT = 3;
 export declare enum PowerUpType {
     WIDE_PADDLE = "wide_paddle",
     MULTI_BALL = "multi_ball",
     EXTRA_LIFE = "extra_life"
 }
-export declare const BLOCK_BREAKER_TIME_LIMIT = 300;
-export declare const BLOCK_BREAKER_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly PADDLE: "#ffffff";
-    readonly PADDLE_GLOW: "rgba(255, 255, 255, 0.3)";
-    readonly BALL: "#ffffff";
-    readonly BALL_TRAIL: "rgba(255, 255, 255, 0.2)";
-    readonly UI: "#ffffff";
-    readonly GRID_BOX_FILL: "rgba(255, 255, 255, 0.25)";
-    readonly GRID_BOX_BORDER: "rgba(255, 255, 255, 0.5)";
-    readonly POWER_UP_WIDE: "#00FF88";
-    readonly POWER_UP_MULTI: "#FF6B9D";
-    readonly POWER_UP_LIFE: "#FFD700";
+export declare const POWER_UP_TYPES: readonly [PowerUpType.WIDE_PADDLE, PowerUpType.MULTI_BALL, PowerUpType.EXTRA_LIFE];
+export declare const POWER_UP_CHANCE = 0.15;
+export declare const MAX_BALLS = 5;
+export declare const WIDE_FACTOR = 1.3;
+export declare const WIDE_MAX = 1.5;
+export declare const WIDE_TIME = 10;
+export declare const FRAME_TIME: number;
+export declare const MAX_FRAMES = 2;
+export declare const BALL_SPEED: number;
+export declare const BALL_RADIUS: number;
+export declare const LAUNCH_SPREAD: number;
+export declare const PADDLE_BOUNCE: number;
+export declare const POWER_UP_SPEED = 2;
+export declare const POWER_UP_SIZE: number;
+export declare const RELAUNCH_DELAY = 0.5;
+export declare const PADDLE_WIDTH_TIME = 0.22;
+export declare const BUMP_TIME = 0.06;
+export declare const BUMP_SPRING: {
+    damping: number;
+    stiffness: number;
+};
+export declare const BALL_SPAWN_SPRING: {
+    damping: number;
+    stiffness: number;
+};
+export declare const BRICK_DROP = 18;
+export declare const BRICK_INTRO_SPRING: {
+    damping: number;
+    stiffness: number;
+};
+export declare const BRICK_ROW_STAGGER = 0.07;
+export declare const BRICK_COL_STAGGER = 0.018;
+export declare const PULSE_TIME = 0.52;
+export declare const TRAIL: readonly [{
+    readonly k: 1.6;
+    readonly r: 0.8;
+    readonly o: 0.32;
+}, {
+    readonly k: 3.2;
+    readonly r: 0.62;
+    readonly o: 0.18;
+}, {
+    readonly k: 4.8;
+    readonly r: 0.45;
+    readonly o: 0.08;
+}];
+export declare const LIGHT: import("@nayan-ui/engine").Light;
+export declare const BRICK_COLORS: readonly ["#FF3B3B", "#FFD700", "#32CD32", "#4DA6FF", "#BF5AF2", "#FF9500"];
+export declare const POWER_UP_COLORS: Record<PowerUpType, string>;
+export declare const PADDLE_COLOR = "#ffffff";
+export declare const BALL_COLOR = "#e0e0e0";
+export declare const TRAIL_COLOR = "#ffffff";
+export declare const CLASSIC_BOARD = "rgba(255, 255, 255, 0.25)";
+export declare const CLASSIC_BORDER = "rgba(255, 255, 255, 0.5)";
+export declare const CLASSIC_RADIUS = 16;
+export declare const THEMED_RADIUS = 8;
+export type Layout = {
+    /** The GameView's size. */
+    width: number;
+    height: number;
+    /** The board: as wide as the game area, a fixed height, centred below the header. */
+    boardLeft: number;
+    boardTop: number;
+    boardWidth: number;
+    boardHeight: number;
+    brickWidth: number;
+    brickHeight: number;
+    /** The first brick's left edge and the top row's top. */
+    bricksLeft: number;
+    bricksTop: number;
+    /** One brick to the next. */
+    brickStepX: number;
+    brickStepY: number;
+    paddleWidth: number;
+    paddleHeight: number;
+    paddleTop: number;
+    /** Where the ball's centre stays between (side walls), and where a ball counts as lost. */
+    minX: number;
+    maxX: number;
+    lostY: number;
 };
+export declare function getLayout(width: number, height: number, offset: number): Layout;

package/lib/typescript/src/games/block-breaker/BlockBreakerGame.d.ts

@@ -0,0 +1,82 @@
+import { type Camera, type Entity, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout, PowerUpType } from './BlockBreakerConstants';
+import { type BallView, type Paddle, type Scenery } from './BlockBreakerScene';
+export type Phase = 'ready' | 'playing' | 'over';
+type Brick = {
+    row: number;
+    col: number;
+    hits: number;
+    entity: Entity | null;
+};
+type Ball = {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    view: BallView | null;
+};
+type PowerUp = {
+    type: PowerUpType;
+    x: number;
+    y: number;
+    entity: Entity | null;
+};
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    colors: import("./BlockBreakerScene").PieceColors;
+    layout: Layout | null;
+    scenery: Scenery | null;
+    phase: Phase;
+    /** Score, lives and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    readonly lives: number;
+    readonly timeLeft: number;
+    won: boolean;
+    /** Game clock, seconds: drives the delayed steps (they pause with the frame loop). */
+    time: number;
+    bricks: Brick[];
+    balls: Ball[];
+    powerUps: PowerUp[];
+    /** Bricks broken since the ball last touched the paddle. */
+    combo: number;
+    paddle: Paddle | null;
+    /** Paddle centre (board points), the width it collides with, and where a drag started. */
+    paddleX: number;
+    paddleWidth: number;
+    dragFrom: number;
+    /** The next wall to appear builds in. */
+    intro: boolean;
+    /** Game seconds the current intro has been playing (-1 until its board spawns). */
+    introAge: number;
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onLives: (_n: number) => void;
+    onTime: (_t: number) => void;
+    onWall: () => void;
+    onPaddle: () => void;
+    onBrickHit: () => void;
+    onBrickBreak: () => void;
+    onCombo: () => void;
+    onPowerUp: () => void;
+    onLaunch: () => void;
+    onLoseLife: () => void;
+    onWin: () => void;
+    onLose: () => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the scene out for the view (first layout, header height, rotation): rebuilt from the run's state. */
+export declare function setLayout(g: Game, l: Layout): void;
+/** A new theme: the background and board are repainted and the ball and paddle recolored. */
+export declare function setTheme(g: Game, theme: GameTheme): void;
+export declare function start(g: Game): void;
+/** A new wall, lives and timer (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;
+export declare function dragStart(g: Game): void;
+/** Slides the paddle by the drag's distance, kept inside the board. */
+export declare function dragMove(g: Game, dx: number): void;
+export {};