@nayan-ui/games 1.19.0 → 1.20.0

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

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

@@ -0,0 +1,54 @@
+import { type Camera, type Entity, type Vec3, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Config, type Sky } from './BlukConstants';
+import type { Pillar } from './BlukRules';
+/** The theme's sky: the built-in one, its base following the theme's background (as the original scene). */
+export declare function skyFor(theme: GameTheme): Sky;
+type PillarView = {
+    root: Entity;
+};
+type Decor = {
+    entity: Entity;
+    x: number;
+    y: number;
+    z: number;
+};
+export type Scene = {
+    sky: Entity;
+    towers: Decor[];
+    frameX?: number;
+    frameWidth?: number;
+    frameHeight?: number;
+    pillars: Map<string, PillarView>;
+    block: Entity;
+    figure: Entity;
+    body: Entity;
+    dots: Entity[];
+    ring: Entity;
+};
+/** World point for a course point (x along the world, y down in the view). */
+export declare const toWorld: (x: number, y: number, z?: number) => Vec3;
+export declare function buildScene(world: World, c: Config, theme: GameTheme, pillars: Pillar[], block: [number, number], colorIndex: number): Scene;
+export declare function removeScene(world: World, s: Scene): void;
+/** Keeps the pillars in step with the course: new ones appear, dropped ones go. */
+export declare function syncPillars(world: World, c: Config, s: Scene, pillars: Pillar[]): void;
+/** Points the camera at the course scrolled `camX` along, the sky and towers following. */
+export declare function frame(world: World, c: Config, s: Scene, camera: Camera, camX: number): void;
+/** The block at its centre (course point), tilted `tilt` (radians, clockwise on screen). */
+export declare function placeBlock(world: World, s: Scene, x: number, y: number, tilt: number): void;
+/** The character's squash (above 0 stretches it tall, below squashes it flat), set at once. */
+export declare function squash(world: World, c: Config, s: Scene, q: number): void;
+/** Springing out of the crouch into a quick stretch, for a launch. */
+export declare function stretch(world: World, c: Config, s: Scene): void;
+/** Relaxing a crouch that didn't jump. */
+export declare function relax(world: World, c: Config, s: Scene): void;
+/** A landing: the tilt eases out, the character squashes and springs back, dust puffs up, and on a perfect one a gold ring spreads. */
+export declare function land(world: World, c: Config, s: Scene, x: number, topY: number, perfect: boolean, colorIndex: number): void;
+/** Off the edge: the block tumbles forward and fades as it drops into the void. */
+export declare function fall(world: World, s: Scene, tilt: number, colorIndex: number): void;
+/** The block whole again, at rest and in a color (a new board). */
+export declare function resetBlock(world: World, c: Config, s: Scene, colorIndex: number): void;
+/** The preview arc: a dot at each point (course coordinates), shrinking along it; the rest hidden. */
+export declare function showArc(world: World, c: Config, s: Scene, pts: number[]): void;
+export declare const hideArc: (world: World, c: Config, s: Scene) => void;
+export {};

package/lib/typescript/src/games/bubble-shooter/BubbleShooter.d.ts

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

package/lib/typescript/src/games/bubble-shooter/BubbleShooterConstants.d.ts

@@ -1,26 +1,58 @@
-export declare const GRID_HEIGHT: number;
-export declare const BUBBLE_SHOOTER_GAME_CONFIG: {
-    readonly BUBBLE_RADIUS: number;
-    readonly BUBBLE_SPACING: 2;
-    readonly SHOOTER_SIZE: 50;
-    readonly BUBBLE_SPEED: 20;
-    readonly POINTS_PER_BUBBLE: 200;
-    readonly POINTS_PER_DROP: 100;
-    readonly MIN_MATCH_COUNT: 3;
-    readonly COLS_PER_ROW: 9;
-    readonly ROW_OFFSET: 0.5;
-};
+export declare const ROW_COUNT = 5;
+export declare const COLS_PER_ROW = 9;
+export declare const COLOR_COUNT = 4;
+export declare const MIN_MATCH = 3;
+export declare const POINTS_PER_BUBBLE = 200;
+export declare const TIME_LIMIT = 300;
 export declare const BUBBLE_COLORS: readonly ["#FF3B3B", "#32CD32", "#FFD700", "#4DA6FF", "#BF5AF2"];
-export declare const BUBBLE_SHOOTER_ROW_COUNT = 5;
-export declare const BUBBLE_SHOOTER_COLOR_COUNT = 4;
-export declare const BUBBLE_SHOOTER_TIME_LIMIT = 300;
-export declare const BUBBLE_SHOOTER_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly SHOOTER: "#ffffff";
-    readonly SHOOTER_ARROW: "#ff6b9d";
-    readonly CEILING: "#e0e0e0";
-    readonly UI: "#ffffff";
-    readonly GRID_BOX_FILL: "rgba(255, 255, 255, 0.30)";
-    readonly GRID_BOX_BORDER: "rgba(255, 255, 255, 0.35)";
+export declare const SHOT_SPEED = 20;
+export declare const FRAME_TIME: number;
+export declare const MAX_AIM_ANGLE: number;
+export declare const TOP_BOUNDARY = 10;
+export declare const SNAP_FROM = 0.55;
+export declare const POP_SPRING: {
+    damping: number;
+    stiffness: number;
+};
+export declare const INTRO_SPRING: {
+    damping: number;
+    stiffness: number;
+};
+export declare const INTRO_ROW_STAGGER = 0.055;
+export declare const INTRO_SWEEP = 0.0006;
+export declare const LOAD_FROM = 0.4;
+export declare const NEXT_DELAY = 0.08;
+export declare const BURST_TIME = 0.45;
+export declare const AIM_DOT_COUNT = 40;
+export declare const AIM_DOT_SPACING = 18;
+export declare const AIM_DOT_RADIUS_START = 3;
+export declare const AIM_DOT_RADIUS_END = 1.5;
+export declare const AIM_ALPHA_NEAR = 0.6;
+export declare const AIM_ALPHA_FAR = 0.3;
+export declare const LIGHT: import("@nayan-ui/engine").Light;
+export declare const BUBBLE_SHINE = 0.4;
+export declare const CLASSIC_BOARD = "rgba(255, 255, 255, 0.30)";
+export declare const CLASSIC_BORDER = "rgba(255, 255, 255, 0.35)";
+export declare const CLASSIC_AIM = "#ffffff";
+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 fits between the shared HUD and controls, independently of its full-width background. */
+    boardLeft: number;
+    boardTop: number;
+    boardWidth: number;
+    boardHeight: number;
+    radius: number;
+    /** From one bubble's centre to its neighbour's. */
+    diameter: number;
+    /** Where shots leave from and aim is measured. All positions are board points, from its top-left. */
+    shooterX: number;
+    shooterY: number;
+    /** Where a shot's centre stays between (it bounces off the side walls). */
+    minX: number;
+    maxX: number;
 };
+export declare function getLayout(width: number, height: number, offset: number): Layout;

package/lib/typescript/src/games/bubble-shooter/BubbleShooterGame.d.ts

@@ -0,0 +1,70 @@
+import { type Camera, type Entity, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './BubbleShooterConstants';
+import { type Scenery } from './BubbleShooterScene';
+export type Phase = 'ready' | 'playing' | 'over';
+type Bubble = {
+    x: number;
+    y: number;
+    color: number;
+    row: number;
+    entity: Entity | null;
+};
+type Shot = {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    color: number;
+    entity: Entity;
+};
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    scenery: Scenery | null;
+    phase: Phase;
+    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    readonly timeLeft: number;
+    won: boolean;
+    /** Built for the first layout (positions depend on the bubble size). */
+    bubbles: Bubble[] | null;
+    /** The shooter's loaded color and the one after it. */
+    current: number;
+    next: number;
+    currentEntity: Entity | null;
+    nextEntity: Entity | null;
+    aimDots: Entity[];
+    /** Aim, radians from straight up (right is positive). */
+    angle: number;
+    shot: Shot | null;
+    /** The next board to appear fills 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;
+    onTime: (_t: number) => void;
+    onBubbles: (_n: number) => void;
+    onShoot: () => void;
+    onPop: () => 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, board and aim dots are repainted; the run carries on. */
+export declare function setTheme(g: Game, theme: GameTheme): void;
+export declare function start(g: Game): void;
+/** A new board 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;
+/** Aims at a view point (a finger), clamped to ±72° from straight up. */
+export declare function aimAt(g: Game, x: number, y: number): void;
+/** Fires the loaded bubble along the aim; the next one loads, from the colors on the board. */
+export declare function fire(g: Game): void;
+export {};

package/lib/typescript/src/games/bubble-shooter/BubbleShooterScene.d.ts

@@ -0,0 +1,26 @@
+import { type Color, type Entity, type Vec3, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './BubbleShooterConstants';
+/** 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 bubblePosition: (l: Layout, x: number, y: number) => Vec3;
+/** A grid bubble's size (the sphere mesh is one across). */
+export declare const bubbleSize: (l: Layout) => number;
+export declare const bubbleColor: (color: number) => Color;
+/** White aim dots on classic; light / dark draw them in the theme's text color. */
+export declare const aimColor: (theme: GameTheme) => Color;
+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 bubble at (x, y), `scale` of its full size. */
+export declare function spawnBubble(world: World, l: Layout, color: number, x: number, y: number, scale?: number): Entity;
+/** A popped bubble: it pops (swells, flashes, settles, shrinks away) and bursts in its color, then it's gone. */
+export declare function popBubble(world: World, l: Layout, e: Entity, color: number, x: number, y: number): void;
+/** The aim dots, hidden until placed. */
+export declare function spawnAimDots(world: World): Entity[];
+/** Shows dots at `points` (x, y, radius triples, nearest first); the rest hide. */
+export declare function placeAimDots(world: World, l: Layout, dots: Entity[], points: number[], color: Color): void;

package/lib/typescript/src/games/candy-crush/CandyCrush.d.ts

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

package/lib/typescript/src/games/candy-crush/CandyCrushConstants.d.ts

@@ -1,35 +1,66 @@
-export declare const CANDY_CRUSH_GAME_CONFIG: {
-    readonly GRID_SIZE: 7;
-    readonly CELL_SIZE: number;
-    readonly CELL_GAP: 3;
-    readonly CANDY_TYPES: 5;
-    readonly MIN_MATCH: 3;
-    readonly ANIMATION_DURATION: 300;
-    readonly FALL_DURATION: 400;
-    readonly SWAP_DURATION: 200;
-    readonly POINTS_PER_CANDY: 50;
-    readonly COMBO_MULTIPLIER: 1.25;
-    readonly SPECIAL_CANDY_THRESHOLD: 4;
-};
+export declare const GRID_SIZE = 7;
+export declare const CANDY_TYPES = 4;
+export declare const MIN_MATCH = 3;
+/** A run this long leaves a color bomb: swap it with any candy to clear every candy of that color (two bombs clear the board). */
+export declare const BOMB_MATCH = 5;
+/** A color bomb's type: it has no color, so it never matches. */
+export declare const BOMB = -1;
+export declare const BOMB_MULTIPLIER = 2;
+export declare const ZAP_TIME = 0.25;
+export declare const POINTS_PER_CANDY = 50;
+export declare const COMBO_MULTIPLIER = 1.25;
+export declare const TIME_LIMIT = 300;
+export declare const WARNING_TIMES: readonly [30, 10];
 export declare const CANDY_COLORS: readonly ["#EF2D36", "#2DC84E", "#3B9FFF", "#FFD020", "#B44CFF", "#FF8820"];
-export declare const CANDY_TYPES: {
-    readonly NORMAL: "normal";
-    readonly STRIPED_HORIZONTAL: "striped_h";
-    readonly STRIPED_VERTICAL: "striped_v";
-    readonly WRAPPED: "wrapped";
-    readonly COLOR_BOMB: "color_bomb";
+export declare const SWAP_TIME = 0.2;
+export declare const MATCH_TIME = 0.42;
+export declare const CLEAR_RIPPLE = 0.025;
+export declare const FALL_TIME = 0.4;
+export declare const FALL_SPRING: {
+    damping: number;
+    stiffness: number;
+    mass: number;
+};
+export declare const LIFT_SPRING: {
+    damping: number;
+    stiffness: number;
+};
+export declare const RETURN_SPRING: {
+    damping: number;
+    stiffness: number;
+};
+export declare const LIFT_SCALE = 1.1;
+export declare const NUDGE_TIME = 0.09;
+export declare const NUDGE_SPRING: {
+    damping: number;
+    stiffness: number;
 };
-export declare const CANDY_CRUSH_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly GRID_BACKGROUND: "rgba(255, 255, 255, 0.15)";
-    readonly GRID_BORDER: "rgba(255, 255, 255, 0.25)";
-    readonly EMPTY_CELL: "rgba(255, 255, 255, 0.10)";
-    readonly SELECTED: "rgba(255, 255, 255, 0.7)";
-    readonly TIME_GOOD: "#ffffff";
-    readonly TIME_WARNING: "#ffffff";
-    readonly TIME_CRITICAL: "#ffffff";
-    readonly COMBO_TEXT: "#ffd700";
+export declare const NUDGE_DISTANCE = 0.28;
+export declare const INTRO_COL_STAGGER = 0.028;
+export declare const INTRO_ROW_STAGGER = 0.022;
+export declare const LIGHT: import("@nayan-ui/engine").Light;
+export declare const CANDY_SHINE = 0.55;
+export declare const CLASSIC_BOARD = "rgba(255, 255, 255, 0.13)";
+export declare const CLASSIC_BORDER = "rgba(255, 255, 255, 0.25)";
+export declare const CLASSIC_CELL = "rgba(255, 255, 255, 0.10)";
+export declare const CLASSIC_RADIUS = 16;
+export declare const THEMED_RADIUS = 8;
+export declare const CELL_GAP = 3;
+export type Layout = {
+    /** The GameView's size. */
+    width: number;
+    height: number;
+    boardLeft: number;
+    boardTop: number;
+    /** The board's side, padding included. */
+    boardSize: number;
+    cell: number;
+    /** From one cell's top-left to the next. */
+    step: number;
+    /** A drag this far starts a swap. */
+    swipeThreshold: number;
 };
-export declare const CANDY_CRUSH_DURATION = 300;
-export declare const CANDY_CRUSH_CANDY_TYPES = 4;
+/** The board as wide as the game area (360 phones / 500 tablets), centred in the space below the header. */
+export declare function getLayout(width: number, height: number, offset: number): Layout;
+/** Centre of cell (row, col), in view points. `row` may be negative: above the board. */
+export declare const cellCenter: (l: Layout, row: number, col: number) => [number, number];