@nayan-ui/games 1.18.0 → 1.20.0

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 {};

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

@@ -0,0 +1,48 @@
+import { type Color, type Entity, type Vec3, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout, type PowerUpType } from './BlockBreakerConstants';
+/** A board point at depth `z`, in world space. */
+export declare const toWorld: (l: Layout, x: number, y: number, z?: number) => Vec3;
+export declare const brickColor: (row: number) => Color;
+/** Ball, trail and paddle colors: white reads on classic and dark; light mode draws them in its text color. */
+export type PieceColors = {
+    ball: Color;
+    trail: Color;
+    paddle: Color;
+};
+export declare function pieceColors(theme: GameTheme): PieceColors;
+export type Scenery = {
+    backdrop: Entity;
+    parts: Entity[];
+};
+export declare function buildScenery(world: World, l: Layout, theme: GameTheme): Scenery;
+export declare function removeScenery(world: World, s: Scenery): void;
+export declare function setSceneryTheme(world: World, l: Layout, s: Scenery, theme: GameTheme): void;
+/** A brick by its top-left; with `intro`, it drops into place `intro` seconds in, with a bounce. */
+export declare function spawnBrick(world: World, l: Layout, x: number, y: number, row: number, intro: number | null): Entity;
+/** A broken brick: it pops (swells, flashes, settles, shrinks away) and bursts in its color, then it's gone. */
+export declare function breakBrick(world: World, l: Layout, brick: Entity, x: number, y: number, row: number): void;
+/** A brick that took a hit but stands: a quick shake. */
+export declare function hitBrick(world: World, brick: Entity): void;
+/** The paddle: a root that squashes (about its centre) carrying the body, which widens. */
+export type Paddle = {
+    root: Entity;
+    body: Entity;
+};
+export declare function spawnPaddle(world: World, l: Layout, x: number, width: number, color: Color): Paddle;
+export declare function placePaddle(world: World, l: Layout, p: Paddle, x: number): void;
+export declare function setPaddleWidth(world: World, l: Layout, p: Paddle, width: number, animate: boolean): void;
+/** Squash and stretch when the ball (strength 1) or a power-up (1.4) lands on it. */
+export declare function bumpPaddle(world: World, p: Paddle, strength: number): void;
+/** A ball and the three fading dots trailing it. */
+export type BallView = {
+    ball: Entity;
+    trail: Entity[];
+};
+export declare function spawnBall(world: World, l: Layout, x: number, y: number, colors: PieceColors): BallView;
+export declare function placeBall(world: World, l: Layout, v: BallView, x: number, y: number, vx: number, vy: number): void;
+export declare function colorBall(world: World, v: BallView, colors: PieceColors): void;
+export declare function removeBall(world: World, v: BallView): void;
+/** A falling power-up: a sphere in its color with a breathing glow behind it. */
+export declare function spawnPowerUp(world: World, l: Layout, type: PowerUpType, x: number, y: number): Entity;
+export declare function placePowerUp(world: World, l: Layout, e: Entity, x: number, y: number): void;

package/lib/typescript/src/games/bluk/Bluk.d.ts

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

package/lib/typescript/src/games/bluk/BlukConstants.d.ts

@@ -1,59 +1,70 @@
-export declare const BLUK_GAME_CONFIG: {
-    readonly BLOCK_SIZE: 56 | 44;
-    readonly PILLAR_MIN_WIDTH: 50 | 68;
-    readonly PILLAR_MAX_WIDTH: 96 | 68;
-    readonly PILLAR_TOP_MIN: number;
-    readonly PILLAR_TOP_MAX: number;
-    readonly PILLAR_DEPTH: 16 | 12;
-    readonly BLOCK_DEPTH: 10 | 7;
-    readonly GAP_MIN: number;
-    readonly GAP_MAX: number;
-    readonly GAP_GROWTH_PER_SCORE: 1 | 0.8;
-    readonly GAP_GROWTH_MAX: 60 | 36;
-    readonly WIDTH_SHRINK_PER_SCORE: 0.7 | 0.5;
-    readonly WIDTH_SHRINK_MAX: 28 | 18;
-    readonly VIEWPORT_MARGIN: 16 | 12;
-    readonly ANCHOR_X: number;
-    readonly GRAVITY: 0.62;
-    readonly POWER_MULTIPLIER: 0.16;
-    readonly MIN_LAUNCH_SPEED: 6;
-    readonly MAX_LAUNCH_SPEED: 22 | 26;
-    readonly SWEET_SPOT_WIDTH: 56 | 44;
-    readonly POINTS_PER_LAND: 1000;
-    readonly PERFECT_BONUS: 500;
-    readonly FALL_THRESHOLD_Y: number;
-    readonly TRAJECTORY_DOTS: 16;
-    readonly TRAJECTORY_STEP: 3;
-    readonly SCREEN_HEIGHT: number;
-    readonly SCREEN_WIDTH: number;
+export declare const GAME_DURATION = 120;
+export declare const POINTS_PER_LAND = 1000;
+export declare const PERFECT_BONUS = 500;
+export declare const LOOKAHEAD = 4;
+export declare const PERFECT_SHOW = 0.6;
+export declare const FALL_DELAY = 0.25;
+export declare const GRAVITY = 0.62;
+export declare const POWER_MULTIPLIER = 0.16;
+export declare const MIN_LAUNCH_SPEED = 6;
+export declare const STEP_MS: number;
+export declare const STEP_TOLERANCE_MS = 2;
+export declare const MAX_PENDING_MS = 34;
+export declare const TRAJECTORY_DOTS = 16;
+export declare const TRAJECTORY_STEP = 3;
+/** Everything sized from the view (the original game sized it from the screen). */
+export type Config = {
+    width: number;
+    height: number;
+    blockSize: number;
+    pillarMinWidth: number;
+    pillarMaxWidth: number;
+    pillarTopMin: number;
+    pillarTopMax: number;
+    pillarDepth: number;
+    gapMin: number;
+    gapMax: number;
+    gapGrowthPerScore: number;
+    gapGrowthMax: number;
+    widthShrinkPerScore: number;
+    widthShrinkMax: number;
+    viewportMargin: number;
+    anchorX: number;
+    maxLaunchSpeed: number;
+    sweetSpotWidth: number;
+    fallThresholdY: number;
 };
+export declare function getConfig(width: number, height: number, tablet: boolean): Config;
+/** The block's colors, cycling as you go. */
 export declare const BLOCK_COLORS: readonly ["#FF6B6B", "#4ECDC4", "#FFD93D", "#6BCB77", "#4D96FF", "#FF6FB5", "#A66CFF", "#FF9F45"];
-export interface Block3DColors {
-    frontTop: string;
-    front: string;
-    frontBottom: string;
-    topLight: string;
-    top: string;
-    right: string;
-}
-export declare const BLOCK_3D_CACHE: Block3DColors[];
-export declare const BLUK_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly UI: "#ffffff";
+export declare const START_COLOR = 2;
+export declare const COLORS: {
+    readonly PILLAR: "#537A8D";
     readonly PILLAR_TOP: "#84AFC0";
-    readonly PILLAR_TOP_HIGHLIGHT: "#CDEBF5";
-    readonly PILLAR_FRONT: "#537A8D";
-    readonly PILLAR_FRONT_MID: "#365463";
-    readonly PILLAR_FRONT_DARK: "#16242D";
-    readonly PILLAR_SIDE: "#264552";
-    readonly PILLAR_SIDE_DARK: "#0D181E";
-    readonly PILLAR_EDGE_LIGHT: "rgba(198, 240, 255, 0.55)";
-    readonly PILLAR_BAND: "rgba(0, 0, 0, 0.22)";
-    readonly SWEET_SPOT_RECESS: "rgba(8, 18, 24, 0.72)";
+    readonly PILLAR_EDGE: "#CDEBF5";
+    readonly PILLAR_BAND: "#365463";
+    readonly ROCK: "#7C8A93";
+    readonly GRASS: "#5DAE4A";
+    readonly GRASS_DARK: "#3E8A35";
+    readonly MOSS: "#4A7A3A";
+    readonly SWEET_RECESS: "#0C1B22";
     readonly SWEET_SPOT: "#FFDD22";
-    readonly SWEET_SPOT_GLOW: "rgba(255, 210, 30, 0.6)";
-    readonly SWEET_SPOT_OUTER_GLOW: "rgba(255, 200, 0, 0.22)";
-    readonly TRAJECTORY_DOT: "rgba(100, 210, 255, 0.92)";
-    readonly PERFECT_TEXT: "#FFD700";
+    readonly TRAJECTORY: "#64D2FF";
+    readonly SKIN: "#F5C99A";
+    readonly PUPIL: "#2C2C2C";
+    readonly SMILE: "#C0785A";
+    readonly PERFECT: "#FFD700";
 };
+/** Each theme's sky (top to bottom), whether it has stars, and its far towers' tint. */
+export type Sky = {
+    stops: string[];
+    stars: boolean;
+    tower: string;
+};
+export declare const SKIES: Record<'classic' | 'light' | 'dark', Sky>;
+export declare const SKY_POSITIONS: number[];
+/** The camera looks down from above and round from the right, so the pillars' tops, sides and depth all show. */
+export declare const PITCH = 0.3;
+export declare const YAW = 0.42;
+/** Lit from the upper left front. */
+export declare const LIGHT: import("@nayan-ui/engine").Light;

package/lib/typescript/src/games/bluk/BlukGame.d.ts

@@ -0,0 +1,65 @@
+import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import type { HudFeedback } from '../shared/EngineHud';
+import { type Config } from './BlukConstants';
+import { type Course, type Flight, type Pillar } from './BlukRules';
+import { type Scene } from './BlukScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** jump / land / perfect: the block's moves; fall: it went over the edge; gameOver: the run's lost a beat later. */
+export type GameEvent = 'jump' | 'land' | 'perfect' | 'fall' | 'gameOver';
+type Block = 'resting' | 'flying' | 'dead';
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    config: Config | null;
+    scene: Scene | null;
+    phase: Phase;
+    course: Course | null;
+    block: Block;
+    flight: Flight;
+    /** The pillars this jump can land on (fixed at launch, as the original flight's were). */
+    targets: Pillar[];
+    tilt: number;
+    /** Whether the board on screen has been played on (Start deals a fresh one if so). */
+    dirty: boolean;
+    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    combo: number;
+    colorIndex: number;
+    won: boolean;
+    readonly timeLeft: number;
+    /** The camera: where it is, and where it's sliding to (from, to, when it started). */
+    camX: number;
+    camMove: {
+        from: number;
+        to: number;
+        at: number;
+    } | null;
+    /** Whether the finger has moved far enough to be aiming (the original pan only began after it moved). */
+    aiming: boolean;
+    pending: number;
+    /** Seconds on the game's clock, for the camera's slide. */
+    clock: number;
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onCombo: (_c: number) => void;
+    onTime: (_t: number) => void;
+    hudFeedback: HudFeedback;
+    onEvent: (_e: GameEvent) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Sizes the course for the view: a fresh board if none was played on yet, else the board rebuilt where it stands. */
+export declare function setLayout(g: Game, c: Config): void;
+export declare function setTheme(g: Game, theme: GameTheme): void;
+/** Starts play: on the board shown if it's fresh, on a fresh one if not (as the original game). */
+export declare function start(g: Game): void;
+/** A fresh 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;
+/** Dragging aims (the arc and a crouch follow the drag); letting go launches, if the drag was enough. */
+export declare function drag(g: Game, { phase, dx, dy, cancelled }: DragEvent): void;
+/** The block leaves the pillar. */
+export declare function launch(g: Game, vx: number, vy: number): void;
+export {};

package/lib/typescript/src/games/bluk/BlukRules.d.ts

@@ -0,0 +1,51 @@
+import { type Config } from './BlukConstants';
+export type Pillar = {
+    id: string;
+    worldX: number;
+    topY: number;
+    width: number;
+    colorIndex: number;
+};
+export type Velocity = {
+    vx: number;
+    vy: number;
+};
+/** The launch for a drag (it always goes forward and up), or null for a drag too small to count. */
+export declare function launchVelocity(c: Config, dx: number, dy: number): Velocity | null;
+/** The pillar a descending block (centre x, from prevY to y) lands on, if any: it must cross the top with enough overlap. */
+export declare function landingOn(c: Config, targets: Pillar[], x: number, prevY: number, y: number): number;
+/** The block's flight: centre and velocity. */
+export type Flight = {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+};
+/** One 60 Hz step: falls, moves; says which target it landed on (the block snapped onto it), or that it fell, or neither. */
+export declare function stepFlight(c: Config, f: Flight, targets: Pillar[]): {
+    landed: number;
+    fell: boolean;
+};
+/** The tilt in flight: leaning forward going up, back coming down. */
+export declare const tiltFor: (vy: number) => number;
+/** The preview arc's points [x0, y0, x1, y1, ...] (world x, view y), ending where it would land. */
+export declare function trajectory(c: Config, v: Velocity, startX: number, startY: number, targets: Pillar[]): number[];
+/** The run of pillars: where you stand, how many you've landed on (it gets harder), and the ids handed out. */
+export type Course = {
+    pillars: Pillar[];
+    current: number;
+    landed: number;
+    seq: number;
+};
+/** A fresh run: the first pillar (at its widest) under the view's anchor, and four ahead. */
+export declare function newCourse(c: Config): Course;
+/** The pillars a jump can land on: everything ahead of the current one. */
+export declare const targetsAhead: (k: Course) => Pillar[];
+/** Landed on a pillar: it's the current one now; more are made ahead and old ones behind dropped (one kept). */
+export declare function landOn(c: Config, k: Course, index: number): void;
+/** A landing's points: perfect (within the sweet spot) adds the bonus and grows the combo. */
+export declare function landingPoints(c: Config, p: Pillar, x: number, combo: number): {
+    perfect: boolean;
+    points: number;
+    combo: number;
+};