1681-engine 0.0.0-stage → 0.5.9

package/dist/types/net/snapshotCodec.d.ts

@@ -0,0 +1,55 @@
+import type { EntityUpdate } from './constants.js';
+/** Any snapshot whose `up` block travels as binary records; the rest is JSON. */
+export interface SnapshotLike {
+    up?: EntityUpdate[];
+}
+/**
+ * Binary wire form of a snapshot's `up` block. A server in another language must write the same bytes.
+ *
+ * A snapshot that carries no updates is still one text frame of JSON. A snapshot that does is one **binary** WebSocket
+ * frame, big-endian throughout:
+ *
+ * ```
+ *   u8   SNAP_FRAME_TAG
+ *   u32  L, the byte length of the JSON that follows
+ *   L    UTF-8 JSON of the snapshot with `up` left out
+ *   n × UPDATE_RECORD_BYTES, one record per EntityUpdate, n = (frame length - 5 - L) / 16
+ * ```
+ *
+ * One record (16 bytes), the `[id, x, y, aim, anim, hp, flags]` tuple:
+ *
+ * | off | type  | field                                                                              |
+ * |-----|-------|------------------------------------------------------------------------------------|
+ * | 0   | i32   | id                                                                                 |
+ * | 4   | i16   | x in 1/UPDATE_POS_SCALE px, clamped to [-32768, 32767] (−4096 … 4095.875 px)          |
+ * | 6   | i16   | y, the same                                                                        |
+ * | 8   | u8    | aim in 1/UPDATE_AIM_STEPS of a turn, wrapped; read back in [-π, π)                     |
+ * | 9   | u8    | anim (ANIM), clamped to 0..255                                                     |
+ * | 10  | i32   | hp (big bodies go past 65535)                                                      |
+ * | 14  | u16   | flags (ENTITY_FLAG, nine bits used today), clamped to 0..65535                      |
+ *
+ * Quantisation error: position ≤ 1/16 px, aim ≤ π/256 rad. The position range holds maps up to 4096 px a side.
+ * Each record is written once per actor state version on the server and shared by every viewer.
+ */
+export declare const SNAP_FRAME_TAG = 1;
+/** Tag byte + the u32 JSON length. */
+export declare const SNAP_FRAME_HEADER_BYTES = 5;
+export declare const UPDATE_RECORD_BYTES = 16;
+export declare const UPDATE_POS_SCALE = 8;
+export declare const UPDATE_AIM_STEPS = 256;
+/** World px → the i16 on the wire. */
+export declare function quantizePos(v: number): number;
+/** Radians → the u8 on the wire (wrapped, so any angle is accepted). */
+export declare function quantizeAim(a: number): number;
+export declare function dequantizeAim(b: number): number;
+export declare function writeUpdate(view: DataView, off: number, u: EntityUpdate): void;
+export declare function readUpdate(view: DataView, off: number): EntityUpdate;
+export declare function encodeUpdates(ups: readonly EntityUpdate[]): Uint8Array;
+export declare function decodeUpdates(bytes: Uint8Array): EntityUpdate[];
+/** The updates exactly as a client reads them off the wire: what a local simulation sends, so it quantises like the server. */
+export declare function quantizeUpdates(ups: readonly EntityUpdate[]): EntityUpdate[];
+/** A snapshot as the server frames it: binary when it carries updates (see the layout above). */
+export declare function encodeSnapshotFrame<S extends SnapshotLike>(snap: S): Uint8Array;
+/** Reads a binary snapshot frame back into the same object a text frame parses to. */
+export declare function decodeSnapshotFrame<S extends SnapshotLike>(frame: ArrayBuffer | Uint8Array): S;
+//# sourceMappingURL=snapshotCodec.d.ts.map

package/dist/types/net/snapshotCodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshotCodec.d.ts","sourceRoot":"","sources":["../../../src/net/snapshotCodec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,iFAAiF;AACjF,MAAM,WAAW,YAAY;IAC3B,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,cAAc,IAAI,CAAC;AAChC,sCAAsC;AACtC,eAAO,MAAM,uBAAuB,IAAI,CAAC;AACzC,eAAO,MAAM,mBAAmB,KAAK,CAAC;AACtC,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAClC,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAUpC,sCAAsC;AACtC,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED,wEAAwE;AACxE,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAI7C;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,YAAY,GAAG,IAAI,CAQ9E;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,YAAY,CAUpE;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,SAAS,YAAY,EAAE,GAAG,UAAU,CAKtE;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,YAAY,EAAE,CAM/D;AAED,+HAA+H;AAC/H,wBAAgB,eAAe,CAAC,GAAG,EAAE,SAAS,YAAY,EAAE,GAAG,YAAY,EAAE,CAgB5E;AAWD,iGAAiG;AACjG,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,YAAY,EAAE,IAAI,EAAE,CAAC,GAAG,UAAU,CAY/E;AAED,sFAAsF;AACtF,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,YAAY,EAAE,KAAK,EAAE,WAAW,GAAG,UAAU,GAAG,CAAC,CAY9F"}

package/dist/types/parallax/Parallax.d.ts

@@ -0,0 +1,37 @@
+import { Container } from 'pixi.js';
+import { ParallaxLayer, type ParallaxCamera, type ParallaxLayerOptions } from './ParallaxLayer.js';
+export interface ParallaxOptions {
+    /**
+     * Where the whole parallax sorts among the world layer's children (its `zIndex`, default -1000): below the level,
+     * so every layer stays behind it. A foreground layer (factor above 1) belongs in a second `Parallax` with a depth
+     * above the level's.
+     */
+    depth?: number;
+}
+/**
+ * Layers of scenery behind (or before) the world, each scrolling at its own share of the camera's speed. Add `view`
+ * to the world layer — a scene's `root` — and call `update(camera, dtMs)` once a frame after the camera moved, so
+ * the layers sit where this frame's view is:
+ *
+ * ```ts
+ * const sky = new Parallax();
+ * sky.add({ texture: clouds, factorX: 0.1, repeatX: true, speedX: -6 });
+ * sky.add({ display: hills, factorX: 0.5, factorY: 1 });
+ * this.root.addChild(sky.view);
+ * // each frame
+ * sky.update(stage.cameras.main, dt * 1000);
+ * ```
+ */
+export declare class Parallax {
+    readonly view: Container<import("pixi.js").ContainerChild>;
+    private readonly list;
+    constructor(options?: ParallaxOptions);
+    get layers(): readonly ParallaxLayer[];
+    /** Adds a layer (built here from options, or one made before); later layers draw in front unless a `depth` says. */
+    add(layer: ParallaxLayer | ParallaxLayerOptions): ParallaxLayer;
+    /** Takes a layer out and destroys it. */
+    remove(layer: ParallaxLayer): void;
+    update(camera: ParallaxCamera, dtMs: number): void;
+    destroy(): void;
+}
+//# sourceMappingURL=Parallax.d.ts.map

package/dist/types/parallax/Parallax.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Parallax.d.ts","sourceRoot":"","sources":["../../../src/parallax/Parallax.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,KAAK,cAAc,EAAE,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEhG,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,QAAQ;IACnB,QAAQ,CAAC,IAAI,8CAA6C;IAC1D,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAuB;gBAEhC,OAAO,GAAE,eAAoB;IAIzC,IAAI,MAAM,IAAI,SAAS,aAAa,EAAE,CAErC;IAED,oHAAoH;IACpH,GAAG,CAAC,KAAK,EAAE,aAAa,GAAG,oBAAoB,GAAG,aAAa;IAQ/D,yCAAyC;IACzC,MAAM,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAOlC,MAAM,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAIlD,OAAO,IAAI,IAAI;CAIhB"}

package/dist/types/parallax/ParallaxLayer.d.ts

@@ -0,0 +1,80 @@
+import { Container, type Texture } from 'pixi.js';
+/** What a parallax layer reads off the camera each frame; the engine's `Camera` has all of it. */
+export interface ParallaxCamera {
+    readonly scrollX: number;
+    readonly scrollY: number;
+    readonly width: number;
+    readonly height: number;
+    readonly zoom: number;
+    /** Set on a pixel-perfect engine: a layer then lands on whole world pixels unless told otherwise. */
+    readonly roundPixels?: boolean;
+}
+export interface ParallaxLayerOptions {
+    /**
+     * A texture to draw, repeated along the axes `repeatX` / `repeatY` name (one tiling sprite, as wide as the view
+     * whatever the level's length). Give either this or `display`.
+     */
+    texture?: Texture;
+    /** Anything already drawn (a sprite, a `Graphics`, a container of them), drawn once and never repeated. */
+    display?: Container;
+    /** Share of the camera's horizontal travel the layer moves on screen: 0 fixed to the screen, 1 with the world (default 0.5). */
+    factorX?: number;
+    /** The same vertically (default: `factorX`). */
+    factorY?: number;
+    /** Repeat the texture left and right forever (a `texture` layer only). */
+    repeatX?: boolean;
+    /** Repeat the texture up and down forever (a `texture` layer only). */
+    repeatY?: boolean;
+    /** World px added to the layer's position, e.g. where on the level a row of hills stands. */
+    offsetX?: number;
+    offsetY?: number;
+    /** Drift, world px a second, on top of the parallax (clouds). */
+    speedX?: number;
+    speedY?: number;
+    /** Land on whole world pixels (default: the camera's `roundPixels`, i.e. a pixel-perfect engine). */
+    snap?: boolean;
+    /** Hide the layer while none of it is in view (default true). Repeated layers always fill the view. */
+    cull?: boolean;
+    /** Order among the parallax's layers: lower draws further back (default: the order they were added in). */
+    depth?: number;
+}
+/**
+ * One layer of a `Parallax`: a texture or a display object that scrolls at a share of the camera's speed, optionally
+ * repeated and drifting. `view` goes into the world layer (the parallax adds it), so the camera's zoom and pixel
+ * rounding apply to it like to any world object; the layer only moves it.
+ */
+export declare class ParallaxLayer {
+    readonly view: Container<import("pixi.js").ContainerChild>;
+    factorX: number;
+    factorY: number;
+    offsetX: number;
+    offsetY: number;
+    speedX: number;
+    speedY: number;
+    snap: boolean | undefined;
+    cull: boolean;
+    /** The depth it was given, if any (a `Parallax` numbers the others in the order they were added). */
+    readonly depth: number | undefined;
+    private readonly repeatX;
+    private readonly repeatY;
+    private readonly tiling;
+    private readonly tileW;
+    private readonly tileH;
+    /** The content's local bounds, measured once: reading bounds every frame walks the whole display tree. */
+    private boundsX;
+    private boundsY;
+    private boundsW;
+    private boundsH;
+    private driftX;
+    private driftY;
+    private readonly input;
+    private readonly px;
+    private readonly py;
+    constructor(options: ParallaxLayerOptions);
+    /** Measures the content again, after it was redrawn larger or smaller (culling reads the measured size). */
+    remeasure(): void;
+    /** Places the layer for this frame; `dtMs` advances the drift. */
+    update(camera: ParallaxCamera, dtMs: number): void;
+    destroy(): void;
+}
+//# sourceMappingURL=ParallaxLayer.d.ts.map

package/dist/types/parallax/ParallaxLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParallaxLayer.d.ts","sourceRoot":"","sources":["../../../src/parallax/ParallaxLayer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAwB,KAAK,OAAO,EAAE,MAAM,SAAS,CAAC;AAGxE,kGAAkG;AAClG,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,qGAAqG;IACrG,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,2GAA2G;IAC3G,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,gIAAgI;IAChI,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gDAAgD;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0EAA0E;IAC1E,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,uEAAuE;IACvE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,6FAA6F;IAC7F,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iEAAiE;IACjE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qGAAqG;IACrG,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,uGAAuG;IACvG,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,2GAA2G;IAC3G,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,qBAAa,aAAa;IACxB,QAAQ,CAAC,IAAI,8CAAmB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC;IAC1B,IAAI,EAAE,OAAO,CAAC;IACd,qGAAqG;IACrG,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;IACpD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,0GAA0G;IAC1G,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,MAAM,CAAK;IAEnB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiI;IACvJ,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAoE;IACvF,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAoE;gBAE3E,OAAO,EAAE,oBAAoB;IA0BzC,4GAA4G;IAC5G,SAAS,IAAI,IAAI;IAejB,kEAAkE;IAClE,MAAM,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IA2ClD,OAAO,IAAI,IAAI;CAGhB"}

package/dist/types/parallax/parallaxMath.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The arithmetic of parallax, apart from anything that draws so it can be tested under node. One axis at a time:
+ * the same functions serve x and y.
+ */
+/**
+ * The world position a layer is drawn at so that, on screen, it moves `factor` times as far as the camera: 0 stays
+ * fixed to the screen (a sky at infinity), 1 moves with the world, 0.5 at half speed, above 1 faster (a foreground).
+ * The layer lives in the world layer, so the camera's zoom scales it like everything else.
+ */
+export declare function parallaxOrigin(scroll: number, factor: number, offset?: number): number;
+/** `value` brought into [0, size): where a repeating pattern stands within one tile. 0 for an empty tile. */
+export declare function wrap(value: number, size: number): number;
+/** Whether a span [start, start + size) overlaps the view [viewStart, viewStart + viewSize), `margin` px wider. */
+export declare function spanVisible(start: number, size: number, viewStart: number, viewSize: number, margin?: number): boolean;
+/** Where one axis of a layer goes this frame; written into a caller's object so a frame allocates nothing. */
+export interface AxisPlacement {
+    /** The layer's world position on this axis. */
+    position: number;
+    /** For a repeated axis, how long the tiled strip is (it covers the view); otherwise the content's own size. */
+    size: number;
+    /** For a repeated axis, the pattern's offset inside the strip (a tiling sprite's tile position), in [0, tile). */
+    phase: number;
+    /** For an axis that does not repeat, whether the content reaches into the view at all. */
+    visible: boolean;
+}
+export interface AxisInput {
+    /** The camera's scroll on this axis (the world coordinate at the screen's edge). */
+    scroll: number;
+    /** How much of the world the view shows on this axis: the screen's size over the camera's zoom. */
+    view: number;
+    factor: number;
+    /** Fixed offset plus whatever auto-scroll has added. */
+    offset: number;
+    repeat: boolean;
+    /** One tile's size on this axis (repeated axes). */
+    tile: number;
+    /** Where the content's bounds begin from the layer's position, and how long they are (axes that do not repeat). */
+    contentStart: number;
+    contentSize: number;
+    /** Land on whole world pixels. */
+    snap: boolean;
+}
+/**
+ * Places one axis. A repeated axis is a strip laid over the view, starting at the view's edge (floored to a whole
+ * pixel when snapping), whose pattern is shifted so its tiles stand where the parallax puts them: the strip never
+ * grows with the level, however long it is. An axis that does not repeat sits at its parallax origin and is visible
+ * only while its content overlaps the view.
+ */
+export declare function placeAxis(out: AxisPlacement, a: AxisInput): AxisPlacement;
+//# sourceMappingURL=parallaxMath.d.ts.map

package/dist/types/parallax/parallaxMath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallaxMath.d.ts","sourceRoot":"","sources":["../../../src/parallax/parallaxMath.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,SAAI,GAAG,MAAM,CAEjF;AAED,6GAA6G;AAC7G,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAKxD;AAED,mHAAmH;AACnH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,SAAI,GAAG,OAAO,CAEjH;AAED,8GAA8G;AAC9G,MAAM,WAAW,aAAa;IAC5B,+CAA+C;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,+GAA+G;IAC/G,IAAI,EAAE,MAAM,CAAC;IACb,kHAAkH;IAClH,KAAK,EAAE,MAAM,CAAC;IACd,0FAA0F;IAC1F,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,SAAS;IACxB,oFAAoF;IACpF,MAAM,EAAE,MAAM,CAAC;IACf,mGAAmG;IACnG,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;IAChB,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,mHAAmH;IACnH,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,kCAAkC;IAClC,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,aAAa,EAAE,CAAC,EAAE,SAAS,GAAG,aAAa,CAiBzE"}

package/dist/types/particles/Emitter.d.ts

@@ -0,0 +1,97 @@
+import { ParticleContainer, type Texture } from 'pixi.js';
+import { type CameraLike } from '../fx/viewCull.js';
+import { ParticleBudget } from './ParticleBudget.js';
+import { type ColorCurve, type Curve } from './particleCurves.js';
+import { type Range } from './particleSampling.js';
+/** Where a new particle appears round the emitter: a disc, or a box centred on it. */
+export type SpawnArea = {
+    readonly radius: number;
+} | {
+    readonly width: number;
+    readonly height: number;
+};
+export interface EmitterOptions {
+    /** Every particle's texture. One emitter draws one texture (a frame of an atlas works: they share a source). */
+    texture: Texture;
+    /** Particles this emitter may hold at once (default 256). */
+    capacity?: number;
+    /** Particles a second while emitting (default 0: bursts only). */
+    rate?: number;
+    /** Seconds a particle lives (default 1). */
+    lifetime?: Range;
+    /** Starting speed, px/s (default [40, 80]). */
+    speed?: Range;
+    /** Direction of travel in radians (default -π/2, up the screen) and how far either way it may turn (default π). */
+    angle?: number;
+    spread?: number;
+    /** Px/s² added to velocity (default none). */
+    gravityX?: number;
+    gravityY?: number;
+    /** Share of speed lost per second (default 0). */
+    drag?: number;
+    /** Scale of the texture over life (default 1), and how much each particle's size may differ (0–1, default 0). */
+    size?: Curve;
+    sizeVariance?: number;
+    /** Opacity over life (default fading from 1 to 0). */
+    alpha?: Curve;
+    /** Tint over life, `0xrrggbb` (default white). */
+    tint?: ColorCurve;
+    /** Starting rotation and spin, radians and radians/s (default 0). */
+    rotation?: Range;
+    spin?: Range;
+    /** 'add' for glows, sparks and fire; 'normal' for smoke and debris (default 'normal'). */
+    blend?: 'normal' | 'add';
+    /** Where particles appear round the emitter (default its exact point). */
+    area?: SpawnArea;
+    /** World px beyond the screen within which the emitter still spawns and draws (default 64). */
+    cullMargin?: number;
+    /** Share of particles kept under reduced effects or the battery saver (default 0.35). */
+    thinFactor?: number;
+    /** The budget shared with other emitters (default the engine-wide `particleBudget`). */
+    budget?: ParticleBudget;
+    /** Random source (default `Math.random`); a seeded one makes an emitter replayable. */
+    random?: () => number;
+}
+/**
+ * A source of smooth sprite particles for any art style: sparks, smoke, dust, magic. Particles live in world
+ * coordinates, so moving the emitter (`x`, `y`) trails new ones behind it instead of dragging the old ones along.
+ *
+ * Drawn by one Pixi `ParticleContainer` (`view`): add it to a scene's `root`, and call `update(dt, camera)` once a
+ * frame. Particle objects are pooled and their colour is written straight into Pixi's packed field, so a steady
+ * emitter allocates nothing per frame. Spawning asks the shared `ParticleBudget` first, and off-screen emitters
+ * neither spawn nor draw.
+ */
+export declare class Emitter {
+    readonly view: ParticleContainer;
+    x: number;
+    y: number;
+    /** Continuous emission on or off (bursts work either way). */
+    emitting: boolean;
+    private readonly sim;
+    private readonly pool;
+    private readonly budget;
+    private readonly random;
+    private readonly opts;
+    private carry;
+    private destroyed;
+    /** Set by the last `update`: whether the emitter's point was near the screen. */
+    private near;
+    constructor(options: EmitterOptions);
+    /** Particles alive now. */
+    get live(): number;
+    setPosition(x: number, y: number): this;
+    start(): this;
+    /** Stops emitting; the particles in the air live out their lives. */
+    stop(): this;
+    /** `count` particles at once, at the emitter or at (x, y). Thinned under reduced effects; skipped off screen. */
+    burst(count: number, x?: number, y?: number): void;
+    /** Advances by `dt` seconds. Pass the camera to skip spawning and drawing while everything is off screen. */
+    update(dt: number, camera?: CameraLike): void;
+    /** Every particle gone at once (a scene change, a cancelled effect). */
+    clear(): void;
+    destroy(): void;
+    private thin;
+    private emit;
+    private draw;
+}
+//# sourceMappingURL=Emitter.d.ts.map

package/dist/types/particles/Emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Emitter.d.ts","sourceRoot":"","sources":["../../../src/particles/Emitter.ts"],"names":[],"mappings":"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"}

package/dist/types/particles/ParticleBudget.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Particles alive across every emitter that shares this budget. An emitter asks before it spawns and gives back as
+ * its particles die, so a crowd of emitters at once costs no more than `limit`: ten explosions in one frame share the
+ * budget instead of adding up to a frame the GPU cannot finish. Under reduced effects or the battery saver the limit
+ * shrinks by `thinFactor`.
+ */
+export declare class ParticleBudget {
+    /** Particles alive at once, for every emitter together. */
+    limit: number;
+    /** The share of `limit` left under reduced effects or the battery saver. */
+    thinFactor: number;
+    private used;
+    constructor(
+    /** Particles alive at once, for every emitter together. */
+    limit?: number, 
+    /** The share of `limit` left under reduced effects or the battery saver. */
+    thinFactor?: number);
+    /** The limit as the settings stand now. */
+    get effectiveLimit(): number;
+    get live(): number;
+    /** Reserves up to `n` particles and returns how many were granted (0 when the budget is spent). */
+    take(n: number): number;
+    /** Returns `n` particles that died or were cleared. */
+    give(n: number): void;
+}
+/** The budget every emitter shares unless it is handed its own. */
+export declare const particleBudget: ParticleBudget;
+//# sourceMappingURL=ParticleBudget.d.ts.map

package/dist/types/particles/ParticleBudget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParticleBudget.d.ts","sourceRoot":"","sources":["../../../src/particles/ParticleBudget.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,qBAAa,cAAc;IAIvB,2DAA2D;IACpD,KAAK;IACZ,4EAA4E;IACrE,UAAU;IANnB,OAAO,CAAC,IAAI,CAAK;;IAGf,2DAA2D;IACpD,KAAK,SAAO;IACnB,4EAA4E;IACrE,UAAU,SAAO;IAG1B,2CAA2C;IAC3C,IAAI,cAAc,IAAI,MAAM,CAG3B;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,mGAAmG;IACnG,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAMvB,uDAAuD;IACvD,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;CAGtB;AAED,mEAAmE;AACnE,eAAO,MAAM,cAAc,gBAAuB,CAAC"}

package/dist/types/particles/ParticleSim.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The particles of one emitter as flat typed arrays (structure of arrays): position, velocity, age and lifetime,
+ * rotation and spin, and a per-particle random draw the curves can use. Pure, no Pixi: the emitter draws what this
+ * holds, and tests step it under node.
+ *
+ * Live particles are packed at indices `0 … count - 1`. A particle that dies is replaced by the last live one, so a
+ * step never leaves holes and never allocates; the order of particles is therefore not stable, which drawing does
+ * not need (every live index is written again each frame).
+ */
+export declare class ParticleSim {
+    readonly capacity: number;
+    readonly x: Float32Array;
+    readonly y: Float32Array;
+    readonly vx: Float32Array;
+    readonly vy: Float32Array;
+    readonly age: Float32Array;
+    readonly life: Float32Array;
+    readonly rot: Float32Array;
+    readonly spin: Float32Array;
+    /** A random draw per particle (0–1), fixed for its life: size variance, flicker phase. */
+    readonly seed: Float32Array;
+    count: number;
+    constructor(capacity: number);
+    /** Adds a particle; returns its index, or -1 when the sim is full. `life` is in seconds. */
+    spawn(x: number, y: number, vx: number, vy: number, life: number, rot: number, spin: number, seed: number): number;
+    /**
+     * Advances every particle by `dt` seconds: gravity (px/s²) added to velocity, then drag, then position. Drag is
+     * the share of speed lost per second, applied as `exp(-drag × dt)` so it is the same at any frame rate. Returns how
+     * many particles died this step.
+     */
+    step(dt: number, gravityX: number, gravityY: number, drag: number): number;
+    /** The share of its life particle `i` has lived (0–1). */
+    progress(i: number): number;
+    /** Every particle gone; returns how many there were. */
+    clear(): number;
+    private removeAt;
+}
+//# sourceMappingURL=ParticleSim.d.ts.map

package/dist/types/particles/ParticleSim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParticleSim.d.ts","sourceRoot":"","sources":["../../../src/particles/ParticleSim.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,qBAAa,WAAW;IAaV,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAZrC,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAC;IACzB,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAC;IACzB,QAAQ,CAAC,EAAE,EAAE,YAAY,CAAC;IAC1B,QAAQ,CAAC,EAAE,EAAE,YAAY,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,0FAA0F;IAC1F,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,KAAK,SAAK;gBAEW,QAAQ,EAAE,MAAM;IAYrC,4FAA4F;IAC5F,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM;IAelH;;;;OAIG;IACH,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM;IAwB1E,0DAA0D;IAC1D,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAI3B,wDAAwD;IACxD,KAAK,IAAI,MAAM;IAMf,OAAO,CAAC,QAAQ;CAajB"}

package/dist/types/particles/particleCurves.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Values that change over a particle's life, sampled at `t` from 0 (born) to 1 (gone). A curve is one of:
+ *
+ * - a number: the same the whole life;
+ * - `{ start, end }`: a straight line between the two;
+ * - keyframes `[[t, value], …]` sorted by `t`: straight lines between them, held flat before the first and after
+ *   the last (a puff that swells fast then fades slowly is three keys, not a custom function).
+ *
+ * Pure and allocation-free: an emitter samples three curves per particle per frame.
+ */
+export type Curve = number | {
+    readonly start: number;
+    readonly end: number;
+} | readonly (readonly [t: number, value: number])[];
+/** The same three shapes for colours (`0xrrggbb`), blended channel by channel. */
+export type ColorCurve = Curve;
+export declare function sampleCurve(curve: Curve, t: number): number;
+export declare function sampleColor(curve: ColorCurve, t: number): number;
+/** Two `0xrrggbb` colours mixed per channel, each channel rounded to a whole value. */
+export declare function lerpColor(a: number, b: number, t: number): number;
+//# sourceMappingURL=particleCurves.d.ts.map

package/dist/types/particles/particleCurves.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particleCurves.d.ts","sourceRoot":"","sources":["../../../src/particles/particleCurves.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,MAAM,KAAK,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC;AAEjI,kFAAkF;AAClF,MAAM,MAAM,UAAU,GAAG,KAAK,CAAC;AAE/B,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAgB3D;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAgBhE;AAED,uFAAuF;AACvF,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAMjE"}

package/dist/types/particles/particleSampling.d.ts

@@ -0,0 +1,20 @@
+/** A number picked at random between two (inclusive of the first), or a fixed one. */
+export type Range = number | readonly [min: number, max: number];
+/** A value of `range` for one random draw `r` in [0, 1). */
+export declare function sampleRange(range: Range, r: number): number;
+/** `base` turned by up to `spread` either way: `r` 0 gives `base - spread`, 0.5 gives `base`. */
+export declare function spreadAngle(base: number, spread: number, r: number): number;
+/**
+ * Whole particles due after `dt` seconds at `rate` a second, given the fraction `carry` left over from before. Kept
+ * as a fraction rather than rounded each frame, or 30 a second at 144 fps (0.21 a frame) would emit none at all.
+ * Returns the count in the integer part and the new carry in the fraction: `n = Math.floor(v)`, `carry = v - n`.
+ */
+export declare function dueParticles(rate: number, dt: number, carry: number): number;
+/**
+ * `n` scaled by `factor` (reduced effects), rounded at random so a burst of 3 at 0.35 still gives one particle about
+ * every time rather than never: the expected count stays `n × factor`.
+ */
+export declare function scaleCount(n: number, factor: number, r: number): number;
+/** A small seedable generator (mulberry32) for tests and replays; the emitter takes any `() => number`. */
+export declare function seededRandom(seed: number): () => number;
+//# sourceMappingURL=particleSampling.d.ts.map

package/dist/types/particles/particleSampling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particleSampling.d.ts","sourceRoot":"","sources":["../../../src/particles/particleSampling.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,MAAM,MAAM,KAAK,GAAG,MAAM,GAAG,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC;AAEjE,4DAA4D;AAC5D,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAG3D;AAED,iGAAiG;AACjG,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAE3E;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAG5E;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAKvE;AAED,2GAA2G;AAC3G,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,MAAM,CASvD"}

package/dist/types/physics/Body.d.ts

@@ -0,0 +1,130 @@
+import type { BodyOptions, BodyType, Shape } from './types.js';
+/**
+ * A rigid body: plain data and a few helpers, no drawing. Positions are the shape's centre in world pixels, y down;
+ * velocities are px per second. Create bodies with `PhysicsWorld.add`, which also wakes them and puts them in the
+ * broad phase.
+ */
+export declare class Body {
+    readonly id: number;
+    readonly type: BodyType;
+    shape: Shape;
+    x: number;
+    y: number;
+    /** Position at the start of the last world step: draw at `prev + (current - prev) × alpha`. */
+    prevX: number;
+    prevY: number;
+    vx: number;
+    vy: number;
+    /** Radians, clockwise on screen. */
+    angle: number;
+    /** Angle at the start of the last world step, for drawing between steps like `prevX`. */
+    prevAngle: number;
+    /** Radians per second. */
+    angularVelocity: number;
+    /** Contacts and torques turn it (`BodyOptions.rotates`). */
+    readonly rotates: boolean;
+    /** Turning lost per second, as a share. */
+    angularDamping: number;
+    /** Torque gathered for the next step, cleared after it. */
+    torque: number;
+    /** Moment of inertia about the centre (mass × px²); infinite for a body that does not rotate. */
+    readonly inertia: number;
+    readonly invInertia: number;
+    /** Force gathered for the next step (px·mass/s²), cleared after it. */
+    fx: number;
+    fy: number;
+    readonly mass: number;
+    readonly invMass: number;
+    restitution: number;
+    friction: number;
+    linearDamping: number;
+    gravityScale: number;
+    readonly sensor: boolean;
+    layer: number;
+    mask: number;
+    userData: unknown;
+    /** Box faces lying against more solid ground (`FACE_*` bits): never a contact normal, so seams do not snag. */
+    internalFaces: number;
+    /** A sleeping body is not integrated and is treated as immovable until something wakes it. */
+    awake: boolean;
+    /** Seconds spent below the world's sleep speed. */
+    restTime: number;
+    /** Standing on something: a solid contact whose normal points up at this body (refreshed every step). */
+    grounded: boolean;
+    /** What it stands on, while grounded. */
+    ground: Body | null;
+    groundNx: number;
+    groundNy: number;
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    /** @internal cosine and sine of `angle`, refreshed by `updateBounds`. */
+    cos: number;
+    sin: number;
+    /** @internal corners and outward face normals in world space (boxes and polygons), refreshed by `updateBounds`. */
+    readonly wx: Float64Array<ArrayBuffer>;
+    readonly wy: Float64Array<ArrayBuffer>;
+    readonly wnx: Float64Array<ArrayBuffer>;
+    readonly wny: Float64Array<ArrayBuffer>;
+    /** @internal how many of the above are in use (0 for a circle). */
+    corners: number;
+    /** @internal set by the world that holds it. */
+    inWorld: boolean;
+    /** @internal last ray that tested this body, so a ray crossing many cells tests it once. */
+    rayStamp: number;
+    constructor(options: BodyOptions);
+    get isDynamic(): boolean;
+    get isStatic(): boolean;
+    /** Moves by itself this step: an awake dynamic body or any kinematic one. */
+    get moving(): boolean;
+    /** Inverse mass as the solver sees it: a sleeping body holds still like ground. */
+    get solverInvMass(): number;
+    /** The smallest half size of the shape: how far it may move in one sub-step without passing through anything. */
+    get minHalfExtent(): number;
+    /** The furthest the shape reaches from the centre: how far a corner sweeps as the body turns. */
+    get maxExtent(): number;
+    /** A box at no angle: the cheap axis-aligned tests apply to it. */
+    get axisAligned(): boolean;
+    updateBounds(): void;
+    /** Box corners in local space (top, right, bottom, left faces), or in world space when the box sits at no angle. */
+    private setBoxCorners;
+    wake(): void;
+    setVelocity(vx: number, vy: number): void;
+    /**
+     * An instant change of momentum (a jump, a hit): velocity changes by `impulse / mass`. Given a world point
+     * (`px`, `py`) off the centre, a body that rotates is also set turning.
+     */
+    applyImpulse(ix: number, iy: number, px?: number, py?: number): void;
+    /** A force held for the next step (thrust, wind); it is cleared once the step has used it. At a world point, it also turns the body. */
+    applyForce(fx: number, fy: number, px?: number, py?: number): void;
+    /** A turning force held for the next step (mass × px² / s², clockwise on screen when positive). */
+    applyTorque(torque: number): void;
+    /** An instant change of spin: angular velocity changes by `impulse / inertia`. */
+    applyAngularImpulse(impulse: number): void;
+    /** Sets the spin (a kinematic body turns at it; a dynamic one that rotates starts at it). */
+    setAngularVelocity(w: number): void;
+    /** Velocity of the body's material at a world point: its own plus what its spin adds there. */
+    velocityAt(px: number, py: number): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Puts the body somewhere without sweeping it there; the drawn position jumps too (no interpolation across it).
+     * A static body moved this way must be followed by `PhysicsWorld.staticsChanged()`.
+     */
+    setPosition(x: number, y: number, angle?: number): void;
+    /** Turns the body to `angle` without sweeping it there (like `setPosition`). */
+    setAngle(angle: number): void;
+    /** A world point in the body's own frame (before its turn). */
+    toLocal(px: number, py: number): {
+        x: number;
+        y: number;
+    };
+    /** A point of the body's own frame in the world. */
+    toWorld(lx: number, ly: number): {
+        x: number;
+        y: number;
+    };
+}
+//# sourceMappingURL=Body.d.ts.map

package/dist/types/physics/Body.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Body.d.ts","sourceRoot":"","sources":["../../../src/physics/Body.ts"],"names":[],"mappings":"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"}