@nayan-ui/games 1.19.0 → 1.21.0

package/lib/typescript/src/games/treasure-hunt/TreasureHuntControls.d.ts

@@ -0,0 +1,75 @@
+import { type Camera, type Entity, type Vec3, type Voice } from '@nayan-ui/engine';
+import { type HumanAnimation, type Point } from './TreasureHuntConstants';
+import { type NatureInput, type NatureMap } from './TreasureHuntRules';
+export interface SwipeContact {
+    identifier: number | string;
+    pageX: number;
+    pageY: number;
+}
+interface TapContact {
+    x: number;
+    y: number;
+    time: number;
+    dragged: boolean;
+}
+export interface SwipeInput {
+    x: number;
+    y: number;
+    filtered: {
+        x: number;
+        y: number;
+    };
+    filterActive: boolean;
+    touchId: SwipeContact['identifier'] | null;
+    startX: number;
+    startY: number;
+    contacts: Map<SwipeContact['identifier'], TapContact>;
+}
+export declare const createSwipeInput: () => SwipeInput;
+export declare function resetSwipe(input: SwipeInput): void;
+export declare function startSwipe(input: SwipeInput, touch: SwipeContact, time?: number): void;
+export declare function moveSwipe(input: SwipeInput, touch: SwipeContact): void;
+/** Sample once per engine frame: touch delivery frequency cannot introduce steering steps. */
+export declare function sampleSwipe(input: SwipeInput, elapsed: number): {
+    x: number;
+    y: number;
+};
+/** A swipe, long hold or cancelled gesture never becomes a punch when the finger lifts. */
+export declare function endSwipe(input: SwipeInput, touch: SwipeContact, time?: number): boolean;
+export declare const FOLLOW_OFFSET: Vec3;
+export declare function createNatureCamera(target: Entity, spawn: Point, yaw?: number, map?: NatureMap): Camera;
+/** Stay behind the facing direction, lift over rising ground and pull in under cave roofs. */
+export declare function updateNatureCamera(camera: Camera, yaw: number, map?: NatureMap, player?: Point, dt?: number): void;
+export declare function resetNatureCamera(camera: Camera, spawn: Point, yaw?: number, map?: NatureMap): void;
+export interface MovementReference {
+    active: boolean;
+    yaw: number;
+}
+/**
+ * Use the explorer's facing when a swipe gesture begins. Holding a direction keeps a steady world
+ * heading while the camera turns behind the explorer; recalculating against the rotating view every
+ * frame would turn a held sideways input into an endless spin. Ending the swipe rebases the next gesture to the explorer.
+ */
+export declare function explorerRelativeInput(input: NatureInput, explorerYaw: number, reference: MovementReference): NatureInput;
+type FootstepSound = 'footstepWalk' | 'footstepRun';
+interface FootstepPlayback {
+    play: (name: FootstepSound, options: {
+        volume: number;
+        pitch: number;
+        pan: number;
+    }) => Voice | null;
+    stop: (voice: Voice | null) => void;
+}
+interface FootstepMotion {
+    animation: HumanAnimation | null;
+    from: number;
+    to: number;
+    speed: number;
+    audible: boolean;
+}
+/** One short native voice per landing. No timers, loop gaps or delayed playback after stopping. */
+export declare function createFootsteps(playback: FootstepPlayback): {
+    stop: () => void;
+    update(motion: FootstepMotion, dt: number): void;
+};
+export {};

package/lib/typescript/src/games/treasure-hunt/TreasureHuntGame.d.ts

@@ -0,0 +1,41 @@
+import { type Camera, type Entity, World } from '@nayan-ui/engine';
+import { type GameAssets } from './TreasureHuntConstants';
+import { createFootsteps, type MovementReference, type SwipeInput } from './TreasureHuntControls';
+import { type Human } from './TreasureHuntModel';
+import { type NatureInput, type NatureState } from './TreasureHuntRules';
+import { type NatureVisual, type RobotVisual } from './TreasureHuntScene';
+export interface NatureGame {
+    readonly phase: 'ready' | 'playing' | 'over';
+    readonly score: number;
+    readonly won: boolean;
+    onPhase: (phase: 'ready' | 'playing' | 'over') => void;
+    world: World;
+    assets: GameAssets;
+    camera: Camera;
+    movementReference: MovementReference;
+    nature: NatureVisual;
+    state: NatureState;
+    human: Human;
+    footsteps: ReturnType<typeof createFootsteps>;
+    swipe: SwipeInput;
+    attackBuffer: number;
+    enemies: Map<number, RobotVisual>;
+    gems: Map<number, Entity>;
+    animationTime: number;
+    combatTime: number;
+    hudTime: number;
+    nextRun: Iterator<() => void> | null;
+    preparing: boolean;
+    prepareDelay: number;
+    onChange: () => void;
+}
+export declare function createGame(assets: GameAssets): NatureGame;
+export declare function start(game: NatureGame): void;
+export declare function reset(game: NatureGame): void;
+export declare function clearInput(game: NatureGame): void;
+export declare function punch(game: NatureGame): void;
+/** Shared screen frame callback: sample gestures and consume at most one buffered punch. */
+export declare function update(game: NatureGame, dt: number): void;
+/** Called exclusively by GameView, which also suspends frames on AppState changes. */
+export declare function tick(game: NatureGame, input: NatureInput, elapsed: number): void;
+export declare function dispose(game: NatureGame): void;

package/lib/typescript/src/games/treasure-hunt/TreasureHuntMeshes.d.ts

@@ -0,0 +1,26 @@
+import { type Geometry, type Vec3 } from '@nayan-ui/engine';
+import { type Landscape } from './TreasureHuntRules';
+export type HumanSoles = readonly [Vec3, Vec3];
+/** Keep the support foot planted; retain airborne height only for running. */
+export declare function humanSupportHeight(feet: HumanSoles, ground: readonly [number, number], airborne?: boolean): number;
+/** A shared horizontal disc; layered at low alpha for a soft contact shadow. */
+export declare function contactShadowGeometry(): Geometry;
+/** A brilliant cut: table, star/bezel crown, thin girdle and pointed pavilion.
+ * Each facet owns flat normals and a cool reflected-light tint, so cuts stay crisp while spinning. */
+export declare function diamondGeometry(): Geometry;
+export interface TerrainGeometry {
+    meadow: Geometry;
+    stone: Geometry;
+    shore: Geometry;
+}
+export declare function terrainGeometry(profile: number): TerrainGeometry;
+/** The same vertices and contours, yielded in row batches so preparation cannot monopolize JS. */
+export declare function terrainGeometrySteps(profile: number): Generator<void, TerrainGeometry>;
+export declare function riverGeometry(land: Landscape): Geometry;
+/** Hollow stone tunnel: both exterior and interior faces, open portals at either end. */
+export declare function caveGeometry(): Geometry;
+/** Irregular stratified boulders, with smooth normals and repeatable UVs rather than scaled cubes. */
+export declare function boulderGeometry(style: number): Geometry;
+export declare function foliageGeometry(pine: boolean, style: number): Geometry;
+/** Tiny bent blades, distributed in shared clumps; actual grass rather than an entirely flat field. */
+export declare function grassGeometry(style: number): Geometry;

package/lib/typescript/src/games/treasure-hunt/TreasureHuntModel.d.ts

@@ -0,0 +1,57 @@
+import { type Entity, type LoadedModel, type Quat, type Texture, type TransformBatch, type Vec3, type World } from '@nayan-ui/engine';
+import { type HumanAnimation, type Point } from './TreasureHuntConstants';
+import { type NatureMap } from './TreasureHuntRules';
+export interface HumanAssets {
+    model: LoadedModel;
+    atlas: Texture;
+    soleIndices: Uint32Array;
+    supportIndices: Uint32Array;
+    leftCount: number;
+}
+/** Native GLB skinning shares one mesh and clips across every explorer instance. */
+export declare function loadHumanAssets(): Promise<HumanAssets>;
+export interface Human {
+    root: Entity;
+    body: Entity;
+    animation: HumanAnimation | null;
+    rate: number;
+    strikes: number;
+    phase: number;
+    indices: Uint32Array;
+    supportIndices: Uint32Array;
+    samples: Float32Array;
+    leftCount: number;
+    soles: [[number, number, number], [number, number, number]];
+    shadows: [Entity[], Entity[]];
+}
+export declare function spawnHuman(world: World, position: Vec3, assets: HumanAssets): Human;
+/** Query only boot vertices; full-body skinning and clip blending stay on the native GPU path. */
+export declare function placeHuman(world: World, human: Human, map: NatureMap, point: Point, yaw: number, dt?: number, updates?: TransformBatch): void;
+export declare function playHuman(world: World, human: Human, animation: HumanAnimation, speed?: number): void;
+export declare function resetHuman(world: World, human: Human): void;
+export declare function advanceHuman(human: Human, dt: number): void;
+export interface RobotVisual {
+    root: Entity;
+    warning: Entity;
+    chassis: Entity;
+    head: Entity;
+    armL: Entity;
+    armR: Entity;
+    elbowL: Entity;
+    elbowR: Entity;
+    legL: Entity;
+    legR: Entity;
+    kneeL: Entity;
+    kneeR: Entity;
+    motion: 'idle' | 'walk' | 'attack' | 'stagger' | null;
+    colorState: number | null;
+    warningVisible: boolean;
+    pose: [number, number, number, number];
+}
+export declare function spawnRobot(world: World, x: number, y: number, z: number): RobotVisual;
+export declare function placeRobot(world: World, visual: RobotVisual, x: number, z: number, y: number, yaw: number, windup: number, stagger: number, moving: boolean, _time: number, updates?: TransformBatch): void;
+/** One cached mesh for all foot and trunk contact shadows, owned by their actor/scenery root. */
+export declare function spawnContactShadow(world: World, parent: Entity): Entity[];
+export declare function placeContactShadow(world: World, layers: Entity[], position: Vec3, rotation: Quat, width: number, depth: number, opacity: number, updates?: TransformBatch): void;
+/** The explorer loader and robot caches are shared with the actual game. */
+export declare function warmAssets(): Iterable<() => unknown>;

package/lib/typescript/src/games/treasure-hunt/TreasureHuntRules.d.ts

@@ -0,0 +1,198 @@
+import { type Quat } from '@nayan-ui/engine';
+import { type Point } from './TreasureHuntConstants';
+export declare const SOLID_CELL = 8;
+export declare const ROCK_RINGS = 12;
+export declare const ROCK_SIDES = 18;
+export declare const CAVE_INNER_WIDTH = 3.5;
+export declare const CAVE_INNER_HEIGHT = 4.8;
+export declare const BRIDGE_RAIL_INSET = 0.15;
+export declare const BRIDGE_RAIL_DEPTH = 0.09;
+export declare const BRIDGE_POST_WIDTH = 0.3;
+export declare const BRIDGE_POST_HEIGHT = 1.12;
+export type SolidTag = 'tree' | 'rock' | 'bridge-rail' | 'bridge-post';
+interface SolidBounds extends Point {
+    tag: SolidTag;
+    bottom: number;
+    top: number;
+    minX: number;
+    maxX: number;
+    minZ: number;
+    maxZ: number;
+}
+export type Solid = SolidBounds & ({
+    shape: 'circle';
+    radius: number;
+} | {
+    shape: 'polygon';
+    points: Point[];
+});
+export type SolidCells = Map<string, Solid[]>;
+/** Shared surface samples keep rendered boulders and their collision hulls in agreement. */
+export declare function rockSurface(style: number, a: number, b: number): {
+    position: [number, number, number];
+    normal: [number, number, number];
+};
+export declare function circleSolid(tag: SolidTag, x: number, z: number, radius: number, bottom: number, top: number): Solid;
+export declare function boxSolid(tag: SolidTag, x: number, z: number, halfX: number, halfZ: number, yaw: number, bottom: number, top: number): Solid;
+export declare function rockSolid(x: number, y: number, z: number, scale: readonly [number, number, number], yaw: number, style: number): Solid;
+/** Signed distance to the full visible footprint, including rounded corners around an actor. */
+export declare function solidDistance(solid: Solid, x: number, z: number): number;
+export declare function indexSolid(cells: SolidCells, solid: Solid): void;
+export declare function solidClearance(cells: SolidCells, x: number, z: number, radius: number, bottom: number, top: number): number;
+export interface BridgeBarrier extends Point {
+    kind: 'rail' | 'post';
+    halfX: number;
+    halfZ: number;
+}
+/** The renderer and collision system share every railing and post position. */
+export declare function bridgeBarriers(bridge: {
+    halfLength: number;
+    halfWidth: number;
+}): BridgeBarrier[];
+export interface Hill extends Point {
+    height: number;
+    width: number;
+    depth: number;
+    yaw: number;
+}
+export interface Cave extends Point {
+    y: number;
+    length: number;
+}
+export interface Bridge extends Point {
+    halfLength: number;
+    halfWidth: number;
+    y: number;
+}
+export type TerrainSurface = 'grass' | 'hill' | 'river' | 'shore' | 'cave' | 'bridge';
+export declare const TERRAIN_STEP = 1.6;
+export declare const TERRAIN_EDGE: number;
+export declare const TERRAIN_GRID: Float32Array<ArrayBuffer>;
+export interface NatureProp extends Point {
+    kind: 'pine' | 'birch' | 'rock';
+    scale: number;
+    yaw: number;
+    style: number;
+}
+export interface NatureDecoration extends Point {
+    kind: 'rock' | 'pine';
+    area: 'horizon' | 'cave-roof' | 'cave-entrance';
+    y: number;
+    scale: [number, number, number];
+    yaw: number;
+    style: number;
+}
+export interface Landscape {
+    profile: number;
+    phase: number;
+    hills: Hill[];
+    caves: Cave[];
+    bridges: Bridge[];
+}
+export interface NatureMap {
+    seed: number;
+    edge: number;
+    rotation: number;
+    landscape: Landscape;
+    spawn: Point;
+    props: NatureProp[];
+    decorations: NatureDecoration[];
+    obstacleCells: SolidCells;
+    reachable: Point[];
+    gems: Point[];
+    enemies: Point[];
+}
+export declare function random(seed: number): () => number;
+/** Bounded geometry library: native mesh IDs live for the app's lifetime. Seeds also rotate the
+ * landscape and independently scatter vegetation, formations, enemies and treasure each run. */
+export declare function landscapeFor(profile: number): Landscape;
+export declare function riverX(landscape: Landscape, z: number): number;
+export declare function riverWidth(landscape: Landscape, z: number): number;
+export declare function waterLevel(_landscape: Landscape, z: number): number;
+/** Compact rocky hills leave broad, gently rolling grassland between their distinct foothills. */
+export declare function hillRise(landscape: Landscape, x: number, z: number): number;
+export declare function terrainHeight(landscape: Landscape, x: number, z: number): number;
+/** Sample the same triangle planes the renderer draws, including clipped material boundaries. */
+export declare function terrainMeshHeight(landscape: Landscape, x: number, z: number): number;
+/** Rounded cave surrounds avoid rectangular terrain cutouts at the entrances. */
+export declare function caveDistance(cave: Cave, x: number, z: number): number;
+export declare function caveClearance(landscape: Landscape, x: number, z: number): number;
+/** Continuous contours are shared by visible terrain, movement and contact normals. */
+export declare function terrainSurface(landscape: Landscape, x: number, z: number): Exclude<TerrainSurface, 'bridge'>;
+export declare function toWorld(map: Pick<NatureMap, 'rotation'>, x: number, z: number): Point;
+export declare function toLocal(map: Pick<NatureMap, 'rotation'>, x: number, z: number): Point;
+export declare function groundHeight(map: NatureMap, x: number, z: number): number;
+/** Surface tilt in a parent's yaw basis, for contact shadows that lie against the ground. */
+export declare function groundTilt(map: NatureMap, x: number, z: number, yaw?: number): Quat;
+export declare function bridgeAt(map: NatureMap, x: number, z: number): Bridge | undefined;
+export declare function surfaceAt(map: NatureMap, x: number, z: number): TerrainSurface;
+/** Immutable terrain samples; the screen owns colours, paths and live objective markers. */
+export declare function mapOverview(map: NatureMap, size: number): readonly (TerrainSurface | null)[];
+export declare function waterDepth(map: NatureMap, x: number, z: number): number;
+export declare function caveAt(map: NatureMap, x: number, z: number): Cave | undefined;
+/** Passage width accounts for the explorer's height beneath the actual curved arch. */
+export declare function cavePassageClearance(landscape: Landscape, x: number, z: number): number;
+/** Terrain and visible solids supply the same contact normals used by swept movement. */
+export declare function navigationClearance(map: NatureMap, x: number, z: number, radius?: number): number;
+/** Grass, bridge decks and cave passages are walkable; complete body footprints stay outside solids. */
+export declare function isWalkable(map: NatureMap, x: number, z: number, radius?: number): boolean;
+export declare function generateNature(seed?: number): NatureMap;
+/** Prepare one fresh layout in bounded batches, without creating a world, actors or game state. */
+export declare function warmNextMap(): Iterable<() => void>;
+export declare const peekNextMap: () => NatureMap | undefined;
+export type Phase = 'ready' | 'playing' | 'won' | 'lost';
+export interface Enemy extends Point {
+    id: number;
+    home: Point;
+    health: number;
+    yaw: number;
+    windup: number;
+    recovery: number;
+    stagger: number;
+    moving: boolean;
+}
+export interface Gem extends Point {
+    id: number;
+    taken: boolean;
+}
+export interface NatureState {
+    map: NatureMap;
+    phase: Phase;
+    player: Point;
+    yaw: number;
+    health: number;
+    gems: number;
+    defeated: number;
+    score: number;
+    time: number;
+    attackCooldown: number;
+    attackPending: number;
+    invulnerable: number;
+    moving: boolean;
+    speed: number;
+    velocity: Point;
+    yawVelocity: number;
+    enemies: Enemy[];
+    pickups: Gem[];
+}
+export interface NatureInput {
+    x: number;
+    y: number;
+    attack: boolean;
+}
+export interface NatureEvent {
+    kind: 'attack' | 'hit' | 'defeated' | 'gem' | 'hurt' | 'won' | 'lost';
+    x: number;
+    z: number;
+    id?: number;
+}
+export declare const distance: (a: Point, b: Point) => number;
+export declare function createState(seed?: number): NatureState;
+/** Sweep the full direction, settle just before contact, then slide along its continuous normal. */
+export interface ActorBody extends Point {
+    radius: number;
+}
+export declare function moveActor(map: NatureMap, point: Point, dx: number, dz: number, radius?: number, bodies?: readonly ActorBody[]): void;
+/** No React or native calls: rules emit events for the engine's effects and HUD. */
+export declare function step(state: NatureState, input: NatureInput, elapsed: number): NatureEvent[];
+export {};

package/lib/typescript/src/games/treasure-hunt/TreasureHuntScene.d.ts

@@ -0,0 +1,40 @@
+import { type Entity, type Model, type World } from '@nayan-ui/engine';
+import type { EngineHud } from '../shared/EngineHud';
+import { type NatureAssets } from './TreasureHuntConstants';
+import { type Bridge, type NatureMap, type NatureState } from './TreasureHuntRules';
+/** Decks, supports and guardrails use the exact span and height sampled by movement. */
+export declare function spawnBridge(world: World, owner: Entity, map: NatureMap, bridge: Bridge, assets: NatureAssets): void;
+export { spawnRobot, placeRobot } from './TreasureHuntModel';
+export type { RobotVisual } from './TreasureHuntModel';
+interface NatureMeshes {
+    gem: Model;
+    trunks: Model[];
+    pine: Model[];
+    birch: Model[];
+    rocks: Model[];
+    grass: Model[];
+    cave: Model;
+}
+type TerrainModels = {
+    meadow: Model;
+    stone: Model;
+    shore: Model;
+    water: Model;
+};
+export declare function prepareNature(): NatureMeshes;
+/** Reusable scenery only: terrain profiles and seeded maps are built for the chosen run. */
+export declare function warmAssets(): Iterable<() => unknown>;
+export declare function terrainModels(profile: number): TerrainModels;
+export interface NatureVisual {
+    root: Entity;
+    water: Entity;
+    flow: number;
+}
+/** No second world or native entities: prepare only the next run's immutable scenery data. */
+export declare function warmMapScenery(map: NatureMap): Iterable<() => void>;
+/** A single owner root makes replay cleanup include every tree, grass blade and bridge. */
+export declare function spawnNature(world: World, map: NatureMap, assets: NatureAssets): NatureVisual;
+/** River motion shares the engine's existing frame tick. */
+export declare function animateNature(world: World, nature: NatureVisual, dt: number): void;
+export declare function spawnGem(world: World, x: number, y: number, z: number): Entity;
+export declare function drawMiniMap(hud: EngineHud, state: NatureState): void;

package/lib/typescript/src/games/whack-a-mole/WhackAMole.d.ts

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

package/lib/typescript/src/games/whack-a-mole/WhackAMoleConstants.d.ts

@@ -1,46 +1,36 @@
-export declare const WHACK_A_MOLE_CONSTANTS: {
-    readonly moleSpawnInterval: 1500;
-    readonly moleAppearDuration: 2000;
-    readonly moleVisibleDuration: 2000;
-    readonly gridSize: 3;
-    readonly pointsPerMole: 500;
-    readonly gameDuration: 120;
-};
-export declare const WHACK_A_MOLE_GAME_CONFIG: {
-    readonly GRID_SIZE: 3;
-    readonly HOLE_SIZE: number;
-    readonly MOLE_APPEAR_DURATION: 1500;
-    readonly MOLE_DISAPPEAR_DURATION: 500;
-    readonly GAME_DURATION: 120;
-    readonly INITIAL_SPAWN_DELAY: 1000;
-    readonly MAX_SPAWN_INTERVAL: 2000;
-};
-export declare const WHACK_A_MOLE_ANIMATION_CONFIG: {
-    readonly MOLE_SPRING: {
-        readonly damping: 15;
-        readonly stiffness: 200;
-    };
-    readonly HOLE_SPRING: {
-        readonly damping: 20;
-        readonly stiffness: 300;
-    };
-    readonly HIT_TIMING: {
-        readonly duration: 300;
-    };
-};
-export declare const WHACK_A_MOLE_COLORS: {
-    readonly BACKGROUND: "#3a3a5e";
-    readonly PRIMARY: "#ffffff";
-    readonly SCORE_BOARD: "#1B5E20";
-    readonly HOLE: "#3E2723";
-    readonly HOLE_BORDER: "#5D4037";
-    readonly HOLE_SHADOW: "#2E2E2E";
-    readonly MOLE_SHADOW: "rgba(0,0,0,0.3)";
-    readonly TIMER_TEXT: "#FF5722";
-    readonly UI: "#ffffff";
-    readonly TEXT_PRIMARY: "#FFFFFF";
-    readonly TEXT_SECONDARY: "#E8F5E8";
-    readonly WHITE: "#FFFFFF";
-    readonly HIT_EFFECT_OUTER: "#FFD700";
-    readonly HIT_EFFECT_INNER: "#FFA500";
+import { type MeadowOptions, type View3D } from '../shared/EngineMeadow';
+export declare const GRID = 3;
+export declare const HOLES: number;
+export declare const TIME_LIMIT = 120;
+export declare const POINTS_PER_MOLE = 500;
+export declare const TIME_WARNING = 10;
+export declare const FIRST_SPAWN = 1;
+export declare const SPAWN_MAX = 1.5;
+export declare const SPAWN_MIN = 1.05;
+export declare const MOLE_UP_TIME = 2;
+export declare const EYE_HEIGHT = 1.6;
+/** Rows are further apart in depth than columns across, so the perspective doesn't squash them together. */
+export declare const ROW_SPACING = 1.6;
+export declare const HOLE_RADIUS = 0.36;
+export declare const MOLE_HEIGHT = 0.62;
+export type Layout = {
+    width: number;
+    height: number;
+    view: View3D;
+    /** Metres between neighbouring holes across; rows are `ROW_SPACING` times that apart. */
+    spacing: number;
+    /** Metres from the eye to the near row. */
+    nearZ: number;
+    /** Each hole's centre on the ground, row 0 (furthest) first, left to right. */
+    holes: [number, number, number][];
 };
+/**
+ * The camera at eye height looking across a lawn: the horizon a little under the scoreboard (sky,
+ * hills and the treeline above it), the near row's rims just above the controls, the grid as wide as
+ * fits the screen.
+ */
+export declare function getLayout(width: number, height: number, offset: number): Layout;
+/** Where a world point appears in the view (screen points). */
+export declare function toScreen(v: View3D, p: readonly [number, number, number]): [number, number];
+/** The meadow around the lawn: the sun and clouds in the strip of sky above the horizon. */
+export declare function meadowFor(l: Layout): MeadowOptions;

package/lib/typescript/src/games/whack-a-mole/WhackAMoleGame.d.ts

@@ -0,0 +1,51 @@
+import { type Camera, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './WhackAMoleConstants';
+import { type Scene } from './WhackAMoleScene';
+export type Phase = 'ready' | 'playing' | 'over';
+export type GameEvent = 'spawn' | 'hit' | 'miss' | 'empty' | 'warning';
+export declare function createGame(theme: GameTheme): {
+    world: World;
+    camera: Camera;
+    theme: GameTheme;
+    layout: Layout | null;
+    hitLayout: Layout | null;
+    hitZones: {
+        rim: [number, number];
+        up: [number, number];
+        down: [number, number];
+        reach: number;
+    }[];
+    scene: Scene | null;
+    phase: Phase;
+    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
+    readonly score: number;
+    readonly timeLeft: number;
+    /** Which holes have a mole up, and when each one ducks back (game clock). */
+    up: boolean[];
+    hideAt: number[];
+    nextSpawn: number;
+    /** Seconds on the game's clock, for spawns and each mole's time up. */
+    clock: number;
+    onPhase: (_p: Phase) => void;
+    onScore: (_s: number) => void;
+    onTime: (_t: number) => void;
+    onEvent: (_e: GameEvent) => void;
+};
+export type Game = ReturnType<typeof createGame>;
+/** Lays the world out for the view (first layout, header height, rotation): rebuilt from the game's state. */
+export declare function setLayout(g: Game, l: Layout): void;
+/** A new theme: day or night (the screen swaps the light); the game carries on. */
+export declare function setTheme(g: Game, theme: GameTheme): void;
+export declare function start(g: Game): void;
+/** Back to a fresh, unstarted game (Stop, Play Again). The world, and the GPU view drawing it, are kept. */
+export declare function reset(g: Game): void;
+export declare function dispose(g: Game): void;
+export declare function tick(g: Game, dt: number): void;
+/**
+ * The hole a view point is over: its rim, or the mole standing in it. Each hole's zone reaches half way
+ * to its neighbours in its row (the far row's are smaller, as it looks), and the nearest one wins.
+ */
+export declare function holeAt(g: Game, x: number, y: number): number | null;
+/** A tap: a hit lands on the hole under it at once, whacking the mole if one's up. */
+export declare function tap(g: Game, x: number, y: number): void;

package/lib/typescript/src/games/whack-a-mole/WhackAMoleScene.d.ts

@@ -0,0 +1,31 @@
+import { type Entity, type Vec3, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { type Layout } from './WhackAMoleConstants';
+export type Scene = {
+    scenery: Entity[];
+    mounds: Entity[];
+    moles: Entity[];
+};
+/** A mole's place: up out of its hole, or hidden below the ground. */
+export declare const molePosition: (l: Layout, hole: number, up: boolean) => Vec3;
+/** The top of a mole that's up, for hit-testing and the hit's burst. */
+export declare const moleTop: (l: Layout) => number;
+export declare function buildScene(world: World, l: Layout, theme: GameTheme): Scene;
+export declare function removeScene(world: World, s: Scene): void;
+/** A mole springs up out of its hole and looks about. */
+export declare function popUp(world: World, l: Layout, s: Scene, hole: number): void;
+/** A mole that wasn't hit ducks back down. */
+export declare function duck(world: World, l: Layout, s: Scene, hole: number): void;
+/** A whacked mole squashes flat, sees stars and sinks away. */
+export declare function bonk(world: World, l: Layout, s: Scene, hole: number): void;
+/** Dirt kicked up where a tap hits an empty hole. */
+export declare function thud(world: World, l: Layout, hole: number): void;
+/**
+ * A whack: a hot flash flares behind the mole's head, eight impact streaks shoot out from it, comic
+ * style, and dust puffs out round the hole (the mole squashes and sees stars in `bonk`).
+ */
+export declare function hitEffect(world: World, l: Layout, hole: number): void;
+/** A miss: a smaller puff of dust with the dirt. */
+export declare function missEffect(world: World, l: Layout, hole: number): void;
+/** Every mole back underground (a reset or the end of a game). */
+export declare function hideAll(world: World, l: Layout, s: Scene): void;

package/lib/typescript/src/games/word-search/WordSearch.d.ts

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

package/lib/typescript/src/games/word-search/WordSearchWords.d.ts

@@ -0,0 +1 @@
+export declare const WORDS: readonly string[];