@nayan-ui/games 1.19.0 → 1.20.0

package/lib/typescript/src/games/pac-man/PacManScene.d.ts

@@ -0,0 +1,44 @@
+import { type Entity, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Direction, GhostMode, GhostName, type Layout } from './PacManConstants';
+type GhostRig = {
+    root: Entity;
+    body: Entity;
+    eyes: [Entity, Entity];
+    pupils: [Entity, Entity];
+};
+export type Scene = {
+    backdrop: Entity;
+    board: Entity;
+    dots: Map<number, Entity>;
+    pacman: Entity;
+    mouth: Entity;
+    /** The mouth's full size (world units): it chomps between almost shut and this. */
+    mouthSize: number;
+    ghosts: Record<GhostName, GhostRig>;
+    fruit: Entity | null;
+};
+export declare function buildScene(world: World, l: Layout, theme: GameTheme): Scene;
+export declare function removeScene(world: World, s: Scene): void;
+export declare function setSceneTheme(world: World, s: Scene, theme: GameTheme): void;
+export declare function eatDot(world: World, s: Scene, x: number, y: number): void;
+export declare function clearDots(world: World, s: Scene): void;
+export declare function placeFruit(world: World, l: Layout, s: Scene, fruit: {
+    x: number;
+    y: number;
+} | null): void;
+export declare function fruitEaten(world: World, l: Layout, s: Scene, x: number, y: number): void;
+/** Moves Pac-Man to a cell: gliding over `time`, or snapping across the side tunnel. */
+export declare function movePacman(world: World, l: Layout, s: Scene, cx: number, cy: number, dir: Direction, time: number, snap: boolean): void;
+export declare function setPacman(world: World, l: Layout, s: Scene, cx: number, cy: number, dir: Direction): void;
+/** The mouth chomps open and shut while Pac-Man moves. */
+export declare function startChomp(world: World, s: Scene, chompTime: number): void;
+/** The mouth stops, half open (his look at rest). */
+export declare function stopChomp(world: World, s: Scene): void;
+/** Pac-Man caught: a flash of yellow sparks where he stood. */
+export declare function pacmanHit(world: World, l: Layout, cx: number, cy: number): void;
+export declare function moveGhost(world: World, l: Layout, s: Scene, name: GhostName, cx: number, cy: number, time: number, snap: boolean): void;
+/** A ghost's colour and body (just the eyes race home when eaten) for its mode. */
+export declare function dressGhost(world: World, l: Layout, s: Scene, name: GhostName, mode: GhostMode, flashing: boolean): void;
+export declare function ghostEaten(world: World, l: Layout, cx: number, cy: number): void;
+export {};

package/lib/typescript/src/games/paper-io/PaperIo.d.ts

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

package/lib/typescript/src/games/paper-io/PaperIoConstants.d.ts

@@ -1,47 +1,67 @@
-export declare const PAPER_CONFIG: {
-    readonly COLS: number;
-    readonly ROWS: number;
-    readonly CELL: number;
-    readonly GRID_W: number;
-    readonly GRID_H: number;
-    readonly GRID_LEFT: 0;
-    readonly STEP_MS: 92;
-    readonly BOT_COUNT: 1;
-    readonly START_TERRITORY: 2;
-    readonly GAME_DURATION_MS: 120000;
-    readonly TOTAL_CELLS: number;
-    readonly SCREEN_WIDTH: number;
-    readonly SCREEN_HEIGHT: number;
-};
-export interface PlayerColor {
+import type { TiltView } from '../shared/EngineTilt';
+export declare const STEP_MS = 92;
+export declare const PLAYER_COUNT = 2;
+export declare const START_TERRITORY = 1;
+export declare const GAME_DURATION_MS = 120000;
+export declare const LOW_TIME = 10;
+export declare const POINTS_PER_CELL = 10;
+export declare const SWIPE = 10;
+export type PlayerColor = {
     territory: string;
     trail: string;
     head: string;
     headDark: string;
-}
+};
+/** 0 = you (green), 1 = the AI (red), as the original game. */
 export declare const PLAYER_COLORS: PlayerColor[];
-export declare const PAPER_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly GRID_LINE: "rgba(255,255,255,0.05)";
-    readonly BOARD: "rgba(0,0,0,0.18)";
+export declare const COLORS: {
+    readonly CLASSIC_BOARD: "rgba(0, 0, 0, 0.18)";
+    readonly FLASH: "#FFFFFF";
+    readonly EYE: "#FFFFFF";
+    readonly PUPIL: "#2C2C44";
+};
+/** A slightly lower tabletop view shows the people and their flags while keeping the grid readable. */
+export declare const TILT = 0.48;
+/** Render in compact world units so a full-screen board and tall people fit the camera's depth range. */
+export declare const WORLD_SCALE = 0.25;
+/** 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;
+/** Heights of land and trails, in cells. */
+export declare const LAND = 0.32;
+export declare const TRAIL = 0.22;
+export declare const PERSON: {
+    readonly SCALE: 3.2;
+    readonly STRIDE: 0.38;
+    readonly HEIGHT: 3.06;
+    readonly CELEBRATION_SCALE: 1.5;
+};
+export declare const PERSON_COLORS: {
+    readonly SKIN: readonly ["#DFAC87", "#A57355"];
+    readonly HAIR: "#352A24";
+    readonly PANTS: "#2F3D50";
+    readonly SHOE: "#38414A";
+    readonly SOLE: "#EEE9DF";
+    readonly POLE: "#CCD4D8";
+    readonly BADGE: "#E8D4A3";
+};
+export type Grid = {
+    cols: number;
+    rows: number;
+    cell: number;
 };
-export declare const DIRECTIONS: {
-    readonly UP: {
-        readonly dx: 0;
-        readonly dy: -1;
-    };
-    readonly DOWN: {
-        readonly dx: 0;
-        readonly dy: 1;
-    };
-    readonly LEFT: {
-        readonly dx: -1;
-        readonly dy: 0;
-    };
-    readonly RIGHT: {
-        readonly dx: 1;
-        readonly dy: 0;
-    };
+export type Layout = TiltView & Grid & {
+    gridW: number;
+    gridH: number;
+    columnWidth: number;
+    rowDepth: number;
+    eyeDistance: number;
 };
-export type DirCode = 'UP' | 'DOWN' | 'LEFT' | 'RIGHT';
+/**
+ * The original grid: square cells a 32nd of the width (a 44th on a tablet) covering the whole view edge to
+ * edge. The grid is fixed by the first layout (as the original game fixed it at load); later layouts only
+ * remap those same cells and the camera to fill the view.
+ */
+export declare function gridFor(width: number, height: number, tablet: boolean): Grid;
+export declare function getLayout(width: number, height: number, grid: Grid): Layout;
+/** A cell's centre on the board, in world units (row 0 along the top). */
+export declare const cellCentre: (l: Layout, col: number, row: number) => [number, number];

package/lib/typescript/src/games/paper-io/PaperIoGame.d.ts

@@ -0,0 +1,49 @@
+import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Grid, type Layout } from './PaperIoConstants';
+import { type Board, type DirCode, type Stats } from './PaperIoRules';
+import { type Scene } from './PaperIoScene';
+export type Phase = 'ready' | 'playing' | 'over';
+/** turn: your swipe took; capture: you banked land; over: the round ended. */
+export type GameEvent = 'turn' | 'capture' | 'over';
+export declare function createGame(theme: GameTheme): {
+    world: World | null;
+    camera: Camera;
+    theme: GameTheme;
+    grid: Grid | null;
+    layout: Layout | null;
+    scene: Scene | null;
+    phase: Phase;
+    board: Board | null;
+    stats: Stats | null;
+    won: boolean;
+    sinceStep: number;
+    /** The first frame after starting credits no time (as the original loop's first frame). */
+    fresh: boolean;
+    /** The swipe in progress: where it went down, and the last turn it asked for. */
+    swipe: {
+        x: number;
+        y: number;
+        last: DirCode | null;
+    } | null;
+    onPhase: (_p: Phase) => void;
+    onStats: (_s: Stats) => void;
+    onTime: (_t: number) => void;
+    onEvent: (_e: GameEvent) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/**
+ * Lays the board out for the view. The first layout fixes the grid (as the original game fixed it at load)
+ * and makes the world, sized for every cell's land and trail; later ones (header, rotation) keep the
+ * board and only rebuild the scene round it.
+ */
+export declare function setLayout(g: Game, l: Layout): void;
+export declare function setTheme(g: Game, theme: GameTheme): void;
+/** Starts a round on a fresh board, as the original Start did. */
+export declare function start(g: Game): void;
+/** A fresh board, not started (Stop, Play Again). */
+export declare function reset(g: Game): void;
+export declare function dispose(g: Game): void;
+export declare function tick(g: Game, dt: number): void;
+/** Swipes steer: once a drag has gone 10 points from where it went down, its main way is a turn. */
+export declare function drag(g: Game, { phase, x, y }: DragEvent): void;

package/lib/typescript/src/games/paper-io/PaperIoMeshes.d.ts

@@ -0,0 +1,13 @@
+import { type Model } from '@nayan-ui/engine';
+export interface PersonMeshes {
+    shirt: Model;
+    skin: Model;
+    details: Model;
+    sleeve: Model;
+    hand: Model;
+    leg: Model;
+    flags: readonly [Model, Model, Model];
+}
+export declare function personMeshes(): PersonMeshes;
+/** Reusable assets; the game loader advances one builder per frame. */
+export declare function warmAssets(): Iterable<() => unknown>;

package/lib/typescript/src/games/paper-io/PaperIoRules.d.ts

@@ -0,0 +1,71 @@
+import { type Grid } from './PaperIoConstants';
+export type Vec = {
+    dx: number;
+    dy: number;
+};
+export declare const DIRECTIONS: {
+    readonly UP: {
+        readonly dx: 0;
+        readonly dy: -1;
+    };
+    readonly DOWN: {
+        readonly dx: 0;
+        readonly dy: 1;
+    };
+    readonly LEFT: {
+        readonly dx: -1;
+        readonly dy: 0;
+    };
+    readonly RIGHT: {
+        readonly dx: 1;
+        readonly dy: 0;
+    };
+};
+export type DirCode = keyof typeof DIRECTIONS;
+export type Player = {
+    id: number;
+    index: number;
+    isBot: boolean;
+    alive: boolean;
+    col: number;
+    row: number;
+    dir: Vec;
+    pendingDir: Vec;
+    trail: number[];
+    homeCol: number;
+    homeRow: number;
+    botState: 'expand' | 'return';
+    botStepsOut: number;
+    botTurned: boolean;
+};
+export type Board = Grid & {
+    total: number;
+    owners: number[];
+    trails: number[];
+    players: Player[];
+    counts: number[];
+};
+export type Stats = {
+    score: number;
+    territoryPct: number;
+    aiPct: number;
+    rank: number;
+    alivePlayers: number;
+};
+export declare const countTerritory: (b: Board, id: number) => number;
+/** A fresh board: you near the bottom middle, the AI near the top middle, each on a 3 x 3 patch. */
+export declare function newBoard(g: Grid): Board;
+export declare function stats(b: Board): Stats;
+/** A swipe's turn for you: queued for the next step (no turning straight back). Whether it changed. */
+export declare function turn(b: Board, code: DirCode): boolean;
+/** What one step changed: land (and who captured), trails, and whether the board is full. */
+export type StepResult = {
+    trailCells: number[];
+    territory: boolean;
+    trails: boolean;
+    captured: boolean[];
+    full: boolean;
+    won: boolean;
+};
+/** One grid step: the AI decides, head-on moves are blocked, everyone moves a cell. */
+export declare function step(b: Board): StepResult;

package/lib/typescript/src/games/paper-io/PaperIoScene.d.ts

@@ -0,0 +1,39 @@
+import { type Entity, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './PaperIoConstants';
+import type { Board } from './PaperIoRules';
+interface PersonRig {
+    root: Entity;
+    visual: Entity;
+    legs: readonly [Entity, Entity];
+    arm: Entity;
+    flag: Entity;
+    stride: number;
+    col: number;
+    row: number;
+    walking: boolean;
+}
+export type Scene = {
+    root: Entity;
+    backdrop: Entity;
+    board: Entity;
+    /** Land and trail cells, by cell index (spawned when first needed), and who each shows. */
+    land: (Entity | null)[];
+    landOwner: Int8Array;
+    landCorners: Uint8Array;
+    trail: (Entity | null)[];
+    trailOwner: Int8Array;
+    heads: PersonRig[];
+};
+export declare function buildScene(world: World, l: Layout, theme: GameTheme, b: Board): Scene;
+export declare function removeScene(world: World, s: Scene): void;
+export declare function setSceneTheme(world: World, l: Layout, s: Scene, theme: GameTheme): void;
+/** Shows each cell's land and trail as the board has them; newly captured land flashes in if `flash`. */
+export declare function syncBoard(world: World, l: Layout, s: Scene, b: Board, flash: boolean, dirty?: readonly number[]): void;
+/** People glide between cells, turn with their feet, and carry their flags through each step. */
+export declare function placeHeads(world: World, l: Layout, s: Scene, b: Board, glide: boolean, popped?: boolean[]): void;
+/** The round's over: walking stops; the winner and their flag lift in celebration. */
+export declare function finish(world: World, l: Layout, s: Scene, won: boolean): void;
+/** Reusable assets; the game loader advances one builder per frame. */
+export declare function warmAssets(): Iterable<() => unknown>;
+export {};

package/lib/typescript/src/games/penguin-run/PenguinMeshes.d.ts

@@ -0,0 +1,9 @@
+import { type Model } from '@nayan-ui/engine';
+/** The one-piece body: torso, head and every face detail in a single mesh. */
+export declare function bodyMesh(): Model;
+/** A paddle flipper hanging from its shoulder (origin): glossy navy outside, cream inside; `side` -1 is the left. */
+export declare function flipperMesh(side: -1 | 1): Model;
+/** A chunky orange foot from its heel (origin) forward: a rounded pad and three plump toes. */
+export declare function footMesh(): Model;
+/** Reusable assets; the game loader advances one builder per frame. */
+export declare function warmAssets(): Iterable<() => unknown>;

package/lib/typescript/src/games/penguin-run/PenguinModel.d.ts

@@ -0,0 +1,42 @@
+import { type Color, type Entity, type Vec3, type World } from '@nayan-ui/engine';
+export type PenguinAnim = 'idle' | 'walk' | 'run' | 'punch' | 'jab' | 'jump' | 'slide' | 'hit' | 'dance' | 'dead';
+/** Clips that loop until another one starts. */
+export declare const LOOPING: ReadonlySet<PenguinAnim>;
+/** How long each one-shot clip runs, in seconds. */
+export declare const CLIP_TIME: Record<PenguinAnim, number>;
+export type Penguin = {
+    root: Entity;
+    pelvis: Entity;
+    body: Entity;
+    flipperL: Entity;
+    flipperR: Entity;
+    footL: Entity;
+    footR: Entity;
+    /** Where the root stands (ground x), kept in step with root moves. */
+    x: number;
+    /** The yaw the root faces, radians (0 looks at the camera). */
+    yaw: number;
+    anim: PenguinAnim | null;
+};
+/** Builds the meshes ahead of time (each is made once per app). */
+export declare function preparePenguin(): void;
+/** Spawns a penguin standing at `position` (feet on the ground), `size` units tall, facing the camera. */
+export declare function spawnPenguin(world: World, position: Vec3, size?: number, tint?: Color): Penguin;
+/** Turns the whole bird to `yaw` (0 faces the camera, π/2 faces +x). */
+export declare function facePenguin(world: World, p: Penguin, yaw: number, duration?: number): void;
+/** Walks, runs or slides the root to ground x over `duration` (the limbs play whatever clip is on). */
+export declare function movePenguin(world: World, p: Penguin, x: number, duration: number, easing?: 'linear' | 'easeOut' | 'easeInOut'): Promise<void>;
+/** Snaps the bird to ground x, upright and facing `yaw`, every limb at rest (a new run). */
+export declare function placePenguin(world: World, p: Penguin, x: number, yaw?: number): void;
+/**
+ * Plays a clip. Looping clips (idle, walk, run, dance) run until the next call and resolve at once;
+ * one-shots resolve when they end. `speed` scales the clip's pace.
+ *
+ * Every clip is keyed for weight and timing rather than evenly: a beat of anticipation before each
+ * action, a fast action, overshoot and a settle after it; feet planted while the body shifts its
+ * weight over them; flippers trailing the body's moves (overlapping action); squash on landings and
+ * stretch on take-offs. Curves run through the keys smoothly.
+ */
+export declare function playPenguin(world: World, p: Penguin, anim: PenguinAnim, speed?: number): Promise<void>;
+/** Hand position for effects: where a strike lands, in world space, for a bird of `size` at its x and yaw. */
+export declare function strikePoint(p: Penguin, size: number): Vec3;

package/lib/typescript/src/games/penguin-run/PenguinRun.d.ts

@@ -0,0 +1 @@
+export declare const PenguinRun: import("react").FC<import("../..").GameProps>;

package/lib/typescript/src/games/penguin-run/PenguinRunConstants.d.ts

@@ -0,0 +1,58 @@
+export declare const PENGUIN_SIZE = 1.2;
+/** Lane centres across the temple causeway. */
+export declare const LANE_X: readonly [-1.7, 0, 1.7];
+/** Lane changes follow a critically damped spring (higher = snappier), leaning into the move. */
+export declare const LANE_STIFFNESS = 14;
+export declare const LEAN_ROLL = 0.045;
+export declare const LEAN_YAW = 0.035;
+export declare const MAX_LEAN = 0.32;
+/** How quickly the camera drifts after the penguin's lane. */
+export declare const CAMERA_FOLLOW = 6;
+/** Run speed, held for the whole track. */
+export declare const SPEED_START = 7;
+/** The track is this long; crossing the finish line wins. */
+export declare const TRACK_LENGTH = 1000;
+/** Clear running at the start and before the finish. */
+export declare const START_CLEAR = 14;
+export declare const FINISH_CLEAR = 6;
+/** Paving rows are this long; a gap is one missing slab. */
+export declare const SLAB = 2;
+/** After a crash or a win, the scene plays (fall, dance) for this long before the results card. */
+export declare const RESULTS_DELAY_LOSE = 1700;
+export declare const RESULTS_DELAY_WIN = 2600;
+/** The causeway is built from tiles this long; this many stay ahead of the penguin. */
+export declare const TILE_LENGTH = 12;
+export declare const TILES_AHEAD = 9;
+export declare const TILES_BEHIND = 2;
+/** Causeway laid behind the start line (ending at a temple), so the start screen has scenery all round. */
+export declare const TILES_BEFORE_START = 3;
+/** Causeway past the finish line before the far temple. */
+export declare const TILES_PAST_FINISH = 3;
+/**
+ * Jumps and slides cover a set distance rather than a set time: the clips play faster as the run
+ * speeds up, so a jump timed the same way always clears a gap. Metres spent airborne / ducked, and
+ * the clip-length limits that keep them from feeling floaty when slow or frantic when fast.
+ */
+export declare const JUMP_AIR_METRES = 5.5;
+export declare const SLIDE_LOW_METRES = 7;
+export declare const JUMP_TIME: [number, number];
+export declare const SLIDE_TIME: [number, number];
+/**
+ * Fractions of each clip during which the penguin counts as off the ground (clears a gap) or low
+ * enough to pass under a gateway: generous, from just after it springs or drops to just before it lands
+ * or rises.
+ */
+export declare const GAP_WINDOW: [number, number];
+export declare const LOW_WINDOW: [number, number];
+/** How far from a gap's centre the penguin falls in (the slab is SLAB long; the broken edges forgive). */
+export declare const GAP_HALF = 0.45;
+/** Hits the penguin can take; after one it stumbles on and can't be hurt again for a moment. */
+export declare const MAX_LIVES = 3;
+export declare const HURT_INVULNERABLE = 2.2;
+/** How deep (along z) an obstacle is for collisions, and how close in x counts as the same lane. */
+export declare const HIT_DEPTH = 0.3;
+export declare const LANE_TOLERANCE = 0.7;
+export declare const COIN_RADIUS = 1.1;
+export declare const POINTS_PER_METRE = 2;
+export declare const POINTS_COIN = 20;
+export declare const POINTS_GEM = 200;

package/lib/typescript/src/games/penguin-run/PenguinRunGame.d.ts

@@ -0,0 +1,64 @@
+import { type Camera, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Tile, type TrackPlan } from './PenguinRunScene';
+export type Phase = 'ready' | 'playing' | 'over';
+type Action = 'jump' | 'slide' | 'hit' | null;
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    theme: GameTheme;
+    penguin: import("./PenguinModel").Penguin;
+    camera: Camera;
+    phase: Phase;
+    won: boolean;
+    plan: TrackPlan;
+    tiles: Tile[];
+    nextTile: number;
+    lane: number;
+    x: number;
+    vx: number;
+    camX: number;
+    z: number;
+    speed: number;
+    distance: number;
+    lastDistance: number;
+    coins: number;
+    gems: number;
+    score: number;
+    lives: number;
+    invulnerable: number;
+    action: Action;
+    /** A jump / slide swiped while the same one was still playing: it goes as soon as that one ends, if within QUEUE_TIME. */
+    queued: "jump" | "slide" | null;
+    queuedT: number;
+    actionT: number;
+    actionDur: number;
+    orbit: number;
+    onPhase: (phase: Phase) => void;
+    onScore: (score: number) => void;
+    onCoins: (coins: number) => void;
+    onLives: (lives: number) => void;
+    onHurt: () => void;
+    onDistance: (metres: number) => void;
+    onCoin: (gem: boolean) => void;
+    onJump: () => void;
+    onSlide: () => void;
+    onLane: () => void;
+    onCrash: () => void;
+    onWin: () => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** A fresh attempt: a newly generated track, the penguin waiting at the start. */
+export declare function reset(g: Game): void;
+export declare function start(g: Game): void;
+export declare function swipe(g: Game, direction: 'left' | 'right' | 'up' | 'down'): void;
+/**
+ * Drag controls, as in the other engine games: a move fires mid-stroke as soon as the finger has
+ * travelled DRAG_THRESHOLD points (no waiting for release), one move per stroke.
+ */
+export declare function steer(g: Game, phase: 'start' | 'move' | 'end', x: number, y: number): void;
+export declare function tick(g: Game, dt: number): void;
+export declare function setLayout(g: Game, width: number, height: number): void;
+/** Day or night: rebuilds the tiles in view with the new lighting tint (the run carries on). */
+export declare function setTheme(g: Game, theme: GameTheme): void;
+export declare function dispose(g: Game): void;
+export {};

package/lib/typescript/src/games/penguin-run/PenguinRunScene.d.ts

@@ -0,0 +1,65 @@
+import { type Entity, type Light, type Vec3, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+/** The last tile of the causeway: a few past the finish, ending at the far temple. */
+export declare const LAST_TILE: number;
+export declare const lightFor: (theme: GameTheme) => Light;
+/** Hazy jungle air by day, deep blue by night; also the fog's color. */
+export declare const backgroundFor: (theme: GameTheme) => readonly [number, number, number];
+export declare const FOG = 0.02;
+/** Builds every mesh ahead of time (each is made once per app). */
+export declare function prepareRunMeshes(): void;
+/** Each cached scenery mesh can be warmed independently without constructing a track. */
+export declare function warmAssets(): Iterable<() => unknown>;
+export type ObstacleKind = 'gap' | 'beam';
+/** `wide`: part of a row spanning all three lanes (drawn once, as one piece, on the middle lane). */
+export type PlanObstacle = {
+    kind: ObstacleKind;
+    lane: number;
+    z: number;
+    wide?: boolean;
+};
+export type PlanPickup = {
+    lane: number;
+    z: number;
+    gem: boolean;
+};
+export type TrackPlan = {
+    seed: number;
+    obstacles: PlanObstacle[];
+    pickups: PlanPickup[];
+};
+/**
+ * Lays out the TRACK_LENGTH metres in rows of obstacles. Some rows span the whole causeway (a crack
+ * you must jump, or a gateway you must slide under: gateways always span it); the rest break one or
+ * two lanes with gaps, never all three. Rows come closer and harder the further along the track, always
+ * leaving room to land and react. A trail of coins hops between lanes, steering clear of obstacles.
+ * A new seed gives a new layout every attempt.
+ */
+export declare function generateTrack(seed: number): TrackPlan;
+export type Obstacle = PlanObstacle & {
+    e: Entity | null;
+};
+export type Pickup = {
+    gem: boolean;
+    lane: number;
+    y: number;
+    z: number;
+    e: Entity;
+    taken: boolean;
+};
+export type Tile = {
+    index: number;
+    z: number;
+    entities: Entity[];
+    obstacles: Obstacle[];
+    pickups: Pickup[];
+};
+/**
+ * Builds tile `index` (its near end at z = -index * TILE_LENGTH) from the run's plan: the causeway
+ * slab by slab (broken out where there is a gap), its scenery, and the plan's obstacles, coins and
+ * finish line that fall in it.
+ */
+export declare function spawnTile(world: World, index: number, theme: GameTheme, plan: TrackPlan): Tile;
+export declare function despawnTile(world: World, tile: Tile): void;
+export declare function coinSparkle(world: World, position: Vec3, gem: boolean): void;
+export declare function crashDust(world: World, position: Vec3): void;

package/lib/typescript/src/games/perfect-circle/PerfectCircle.d.ts

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

package/lib/typescript/src/games/perfect-circle/PerfectCircleConstants.d.ts

@@ -1,51 +1,29 @@
-export declare const PERFECT_CIRCLE_MIN_ACCURACY = 70;
-export declare const PERFECT_CIRCLE_GAME_CONFIG: {
-    readonly MIN_POINTS: 20;
-    readonly SAMPLE_POINTS: 100;
-    readonly STROKE_WIDTH: 4;
-    readonly GUIDE_CIRCLE_OPACITY: 0.15;
-    readonly GUIDE_CIRCLE_RADIUS_OFFSET: 20;
-};
-export declare const PERFECT_CIRCLE_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly CANVAS: "#16213e";
+import type { TiltView } from '../shared/EngineTilt';
+export declare const MIN_POINT_DISTANCE = 4;
+export declare const STROKE_RADIUS = 2.5;
+export declare const FIT_TRACE_TIME = 0.65;
+export declare const TINT_TIME = 0.38;
+export declare const COLORS: {
     readonly STROKE: "#00d4ff";
-    readonly GUIDE: "#ffffff";
     readonly SUCCESS: "#4ecca3";
     readonly FAIL: "#ff6b6b";
+    readonly GUIDE: "#ffffff";
     readonly UI: "#00d4ff";
-    readonly TEXT: "#ffffff";
 };
-export declare const ACCURACY_LEVELS: {
-    readonly PERFECT: {
-        readonly min: 95;
-        readonly label: "PERFECT!";
-        readonly emoji: "🎯";
-    };
-    readonly EXCELLENT: {
-        readonly min: 90;
-        readonly label: "EXCELLENT!";
-        readonly emoji: "⭐";
-    };
-    readonly GREAT: {
-        readonly min: 85;
-        readonly label: "GREAT!";
-        readonly emoji: "✨";
-    };
-    readonly GOOD: {
-        readonly min: 80;
-        readonly label: "GOOD!";
-        readonly emoji: "👍";
-    };
-    readonly NICE: {
-        readonly min: 70;
-        readonly label: "NICE TRY!";
-        readonly emoji: "👌";
-    };
-    readonly POOR: {
-        readonly min: 0;
-        readonly label: "KEEP TRYING!";
-        readonly emoji: "💪";
-    };
+/**
+ * The camera looks straight down: the guide must be a true circle on screen, since the drawing is
+ * scored in view points. The depth shows in the plate's bevel, the raised guide ring and the round tube.
+ */
+export declare const TILT = 0;
+export declare const LIGHT: import("@nayan-ui/engine").Light;
+export type Layout = TiltView & {
+    cx: number;
+    cy: number;
+    radius: number;
 };
+/**
+ * The guide circle: half the game width (the view less 30 points, at most 500) across, centred 55
+ * points below the middle of the screen, as the original canvas put it. On a screen too short for that, it
+ * shrinks and moves to fit between the scoreboard and the controls.
+ */
+export declare function getLayout(width: number, height: number, offset: number): Layout;