1681-engine 0.0.0-stage → 0.5.8

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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"}

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

@@ -0,0 +1,26 @@
+import type { Body } from './Body.js';
+import { SpatialHash } from './SpatialHash.js';
+/**
+ * Two spatial hashes: static bodies, rebuilt only when they change (a level's ground is thousands of tiles merged
+ * into a few hundred boxes and never moves), and everything else, rebuilt every sub-step. Pairs are found from the
+ * moving side only: two sleeping or static bodies are never tested against each other.
+ */
+export declare class BroadPhase {
+    private readonly margin;
+    readonly statics: SpatialHash;
+    readonly movers: SpatialHash;
+    private staticsDirty;
+    constructor(cellSize: number, margin: number);
+    markStaticsDirty(): void;
+    /** Re-lists every body; statics only if they changed. Bounds must be current. */
+    rebuild(bodies: readonly Body[]): void;
+    /**
+     * Calls `visit` once for every pair whose bounds (grown by the margin) overlap and in which at least one body
+     * moves. A pair sharing several cells is visited only from the cell holding the corner of their overlap, which
+     * needs no set of pairs seen.
+     */
+    pairs(bodies: readonly Body[], visit: (a: Body, b: Body) => void): void;
+    /** The pair overlaps and (cx, cy) is the cell of its overlap's top-left corner. */
+    private owns;
+}
+//# sourceMappingURL=BroadPhase.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BroadPhase.d.ts","sourceRoot":"","sources":["../../../src/physics/BroadPhase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C;;;;GAIG;AACH,qBAAa,UAAU;IAOnB,OAAO,CAAC,QAAQ,CAAC,MAAM;IANzB,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,OAAO,CAAC,YAAY,CAAQ;gBAG1B,QAAQ,EAAE,MAAM,EACC,MAAM,EAAE,MAAM;IAMjC,gBAAgB,IAAI,IAAI;IAIxB,iFAAiF;IACjF,OAAO,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,GAAG,IAAI;IAUtC;;;;OAIG;IACH,KAAK,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,KAAK,IAAI,GAAG,IAAI;IA0BvE,mFAAmF;IACnF,OAAO,CAAC,IAAI;CAMb"}

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

@@ -0,0 +1,62 @@
+import type { Body } from './Body.js';
+import type { ContactInfo, Vec2 } from './types.js';
+/** One point of a contact and the solver's terms for it. */
+export declare class ContactPoint {
+    /** World position when measured, and the depth there (px, < 0 a gap). */
+    x: number;
+    y: number;
+    depth: number;
+    /** Which corners or faces made it: matched from step to step to carry the impulses over. */
+    id: number;
+    /** Accumulated normal and friction impulses. */
+    jn: number;
+    jt: number;
+    /** Per sub-step solver terms. */
+    massN: number;
+    massT: number;
+    target: number;
+    /** Offsets from each body's centre, refreshed every sub-step. */
+    rax: number;
+    ray: number;
+    rbx: number;
+    rby: number;
+    /** The point in each body's own frame when measured, so position correction can track its depth as they move and turn. */
+    lax: number;
+    lay: number;
+    lbx: number;
+    lby: number;
+}
+/**
+ * One touching pair, kept from step to step while they touch: the impulses it ended the last step with start the
+ * next one (warm starting), which is what lets a stack settle in a few solver iterations instead of shivering.
+ */
+export declare class Contact implements ContactInfo {
+    readonly a: Body;
+    readonly b: Body;
+    readonly key: number;
+    nx: number;
+    ny: number;
+    depth: number;
+    /** One or two points; only the first `count` are in use. */
+    readonly pts: [ContactPoint, ContactPoint];
+    count: number;
+    mu: number;
+    /** Solved this sub-step (false when the pre-solve hook turned it off). */
+    enabled: boolean;
+    /** The world step and sub-step that last found it. */
+    seenStep: number;
+    seenSub: number;
+    /** Reported as touching (a `begin` went out and no `end` yet). */
+    reported: boolean;
+    constructor(a: Body, b: Body, key: number);
+    get sensor(): boolean;
+    /** Where the two touch, world px. */
+    get points(): Vec2[];
+    /** Accumulated normal impulse over the points: how hard the pair pressed together on the last sub-step. */
+    get normalImpulse(): number;
+    /** The other body of the pair. */
+    other(body: Body): Body;
+    /** A stable number for the pair, whichever order it is asked in. */
+    static keyOf(a: Body, b: Body): number;
+}
+//# sourceMappingURL=Contact.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Contact.d.ts","sourceRoot":"","sources":["../../../src/physics/Contact.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAEjD,4DAA4D;AAC5D,qBAAa,YAAY;IACvB,yEAAyE;IACzE,CAAC,SAAK;IACN,CAAC,SAAK;IACN,KAAK,SAAK;IACV,4FAA4F;IAC5F,EAAE,SAAK;IACP,gDAAgD;IAChD,EAAE,SAAK;IACP,EAAE,SAAK;IACP,iCAAiC;IACjC,KAAK,SAAK;IACV,KAAK,SAAK;IACV,MAAM,SAAK;IACX,iEAAiE;IACjE,GAAG,SAAK;IACR,GAAG,SAAK;IACR,GAAG,SAAK;IACR,GAAG,SAAK;IACR,0HAA0H;IAC1H,GAAG,SAAK;IACR,GAAG,SAAK;IACR,GAAG,SAAK;IACR,GAAG,SAAK;CACT;AAED;;;GAGG;AACH,qBAAa,OAAQ,YAAW,WAAW;IAiBvC,QAAQ,CAAC,CAAC,EAAE,IAAI;IAChB,QAAQ,CAAC,CAAC,EAAE,IAAI;IAChB,QAAQ,CAAC,GAAG,EAAE,MAAM;IAlBtB,EAAE,SAAK;IACP,EAAE,SAAK;IACP,KAAK,SAAK;IACV,4DAA4D;IAC5D,QAAQ,CAAC,GAAG,EAAE,CAAC,YAAY,EAAE,YAAY,CAAC,CAA4C;IACtF,KAAK,SAAK;IACV,EAAE,SAAK;IACP,0EAA0E;IAC1E,OAAO,UAAQ;IACf,sDAAsD;IACtD,QAAQ,SAAM;IACd,OAAO,SAAM;IACb,kEAAkE;IAClE,QAAQ,UAAS;gBAGN,CAAC,EAAE,IAAI,EACP,CAAC,EAAE,IAAI,EACP,GAAG,EAAE,MAAM;IAGtB,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,qCAAqC;IACrC,IAAI,MAAM,IAAI,IAAI,EAAE,CAInB;IAED,2GAA2G;IAC3G,IAAI,aAAa,IAAI,MAAM,CAI1B;IAED,kCAAkC;IAClC,KAAK,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAIvB,oEAAoE;IACpE,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM;CAKvC"}

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

@@ -0,0 +1,29 @@
+import type { Contact } from './Contact.js';
+/** Tuning the solver reads; `PhysicsWorld` owns the values. */
+export interface SolverSettings {
+    /** Approach speed (px/s) below which nothing bounces, so a resting body does not hop on gravity's own step. */
+    restitutionThreshold: number;
+    /** Overlap (px) left alone by position correction: a little keeps resting contacts alive and steady. */
+    slop: number;
+    /** Share of the remaining overlap removed per position iteration. */
+    correction: number;
+    /** The most one position iteration moves a pair apart (px), so a deep overlap is undone over a few steps, not flung. */
+    maxCorrection: number;
+}
+/**
+ * Sequential impulses: each contact point is a normal constraint (no approach, plus bounce) and a friction constraint
+ * clamped by its normal impulse (Coulomb), applied at the point so a body that rotates is turned by it. Penetration
+ * is not fed back into the velocities (no Baumgarte energy): it is removed afterwards by moving positions and angles
+ * only, tracked as the bodies move (a "split impulse" in its simplest form), so resting bodies do not bounce off their
+ * own correction. Bodies that do not rotate have no inverse inertia, and every angular term drops out.
+ */
+export declare class ContactSolver {
+    private readonly settings;
+    constructor(settings: SolverSettings);
+    /** Mass, friction and the velocity target of every enabled contact point; then the impulses carried over from the last sub-step are applied (warm start). */
+    prepare(contacts: readonly Contact[], dt: number): void;
+    solveVelocities(contacts: readonly Contact[]): void;
+    /** Pushes overlapping pairs apart along their normals, by position (and angle) only. */
+    solvePositions(contacts: readonly Contact[]): void;
+}
+//# sourceMappingURL=ContactSolver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ContactSolver.d.ts","sourceRoot":"","sources":["../../../src/physics/ContactSolver.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAgB,MAAM,WAAW,CAAC;AAEvD,+DAA+D;AAC/D,MAAM,WAAW,cAAc;IAC7B,+GAA+G;IAC/G,oBAAoB,EAAE,MAAM,CAAC;IAC7B,wGAAwG;IACxG,IAAI,EAAE,MAAM,CAAC;IACb,qEAAqE;IACrE,UAAU,EAAE,MAAM,CAAC;IACnB,wHAAwH;IACxH,aAAa,EAAE,MAAM,CAAC;CACvB;AAOD;;;;;;GAMG;AACH,qBAAa,aAAa;IACZ,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,cAAc;IAErD,6JAA6J;IAC7J,OAAO,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IA0CvD,eAAe,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,GAAG,IAAI;IAiCnD,wFAAwF;IACxF,cAAc,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,GAAG,IAAI;CA0CnD"}

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

@@ -0,0 +1,78 @@
+import { EventBus } from '../events/EventBus.js';
+import { Body } from './Body.js';
+import { Contact } from './Contact.js';
+import type { PhysicsWorldOptions } from './PhysicsWorldOptions.js';
+import type { BodyOptions, ContactInfo, PhysicsEvents, RayHit, RaycastOptions } from './types.js';
+/**
+ * A rigid-body world for platformers and physics toys: dynamic, static and kinematic circles, boxes and convex
+ * polygons, turned by contacts when made with `rotates: true`, stepped at a fixed dt (`physicsSystem` runs it as a
+ * `fixed` system). Each step: forces and gravity (semi-implicit Euler), broad phase, narrow phase, sequential impulses
+ * with warm starting, then positions, then overlap removed by moving positions. Fast bodies are handled by
+ * sub-stepping, not swept tests.
+ *
+ * Not deterministic across machines: the solver's results depend on body order and floating point, which is fine for
+ * a single player's world but not for one a server must replay (use `net/movement` for that).
+ */
+export declare class PhysicsWorld {
+    gravityX: number;
+    gravityY: number;
+    readonly events: EventBus<PhysicsEvents>;
+    /** Called for each touching solid pair every sub-step; returning false skips its response this sub-step (one-way platforms). */
+    preSolve: ((contact: Contact) => boolean) | null;
+    private readonly list;
+    private readonly broad;
+    private readonly solver;
+    private readonly contacts;
+    private readonly active;
+    private readonly manifold;
+    private readonly removals;
+    private readonly settings;
+    private readonly velocityIterations;
+    private readonly positionIterations;
+    private readonly maxSubsteps;
+    private readonly maxSpeed;
+    private readonly margin;
+    private readonly groundNormal;
+    private readonly allowSleep;
+    private readonly sleepSpeed;
+    private readonly sleepTime;
+    private stepCount;
+    private subCount;
+    private stepping;
+    constructor(options?: PhysicsWorldOptions);
+    /** Adds a body (or makes one from options) and returns it. */
+    add(body: Body | BodyOptions): Body;
+    addAll(bodies: Iterable<Body>): void;
+    /** Takes a body out; its contacts end (with `end` events). During a step it waits until the step is over. */
+    remove(body: Body): void;
+    /** Call after moving, resizing or retyping a static body by hand. */
+    staticsChanged(): void;
+    get bodyCount(): number;
+    /**
+     * Every body in the world, in the order added: for tools (a debug drawing, an inspector) that would otherwise keep
+     * a second list beside the world's. Read it, never hold it across a step: adding and removing change it in place.
+     */
+    get bodies(): readonly Body[];
+    /** Advances the world by `dt` seconds; call it with the fixed step (`FixedLoop.stepSeconds`). */
+    step(dt: number): void;
+    /** The first body on the segment from (x0, y0) to (x1, y1). Bodies the ray starts inside are skipped. */
+    raycast(x0: number, y0: number, x1: number, y1: number, options?: RaycastOptions): RayHit | null;
+    /** The pairs touching `body` after the last step (sensors' overlaps included). */
+    contactsOf(body: Body, out?: ContactInfo[]): ContactInfo[];
+    /** Whether `body` stood on something at the end of the last step (also `body.grounded`). */
+    isGrounded(body: Body): boolean;
+    private substepsFor;
+    private substep;
+    private readonly visitPair;
+    /**
+     * Copies the narrow phase's points into the contact, carrying each point's impulses over from the last sub-step
+     * when the same feature touches again (`warm`: the pair touched on the last sub-step).
+     */
+    private takeManifold;
+    /** A sleeping body wakes when something meets it faster than the sleep speed (a kinematic platform always does). */
+    private wakeOnImpact;
+    private updateSleep;
+    /** Ends pairs no longer touching, starts new ones, refreshes `grounded`, then emits the events. */
+    private finishContacts;
+}
+//# sourceMappingURL=PhysicsWorld.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsWorld.d.ts","sourceRoot":"","sources":["../../../src/physics/PhysicsWorld.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAG9B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE/F;;;;;;;;;GASG;AACH,qBAAa,YAAY;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,MAAM,0BAAiC;IAChD,gIAAgI;IAChI,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,GAAG,IAAI,CAAQ;IACxD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAc;IACnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8B;IACvD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmB;IAC5C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAc;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiB;IAC1C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAC5C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAC5C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAU;IACrC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,QAAQ,CAAS;gBAEb,OAAO,GAAE,mBAAwB;IAsB7C,8DAA8D;IAC9D,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,WAAW,GAAG,IAAI;IAWnC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,IAAI;IAIpC,6GAA6G;IAC7G,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAsBxB,qEAAqE;IACrE,cAAc,IAAI,IAAI;IAItB,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED;;;OAGG;IACH,IAAI,MAAM,IAAI,SAAS,IAAI,EAAE,CAE5B;IAED,iGAAiG;IACjG,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAyBtB,yGAAyG;IACzG,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,GAAG,IAAI;IAMhG,kFAAkF;IAClF,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,GAAE,WAAW,EAAO,GAAG,WAAW,EAAE;IAM9D,4FAA4F;IAC5F,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO;IAI/B,OAAO,CAAC,WAAW;IAcnB,OAAO,CAAC,OAAO;IAyCf,OAAO,CAAC,QAAQ,CAAC,SAAS,CA0BxB;IAEF;;;OAGG;IACH,OAAO,CAAC,YAAY;IA6CpB,oHAAoH;IACpH,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,WAAW;IAmBnB,mGAAmG;IACnG,OAAO,CAAC,cAAc;CA2BvB"}

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

@@ -0,0 +1,24 @@
+import type { SolverSettings } from './ContactSolver.js';
+/** Tuning for a `PhysicsWorld`; every field has a default fit for a platformer in pixels. */
+export interface PhysicsWorldOptions extends Partial<SolverSettings> {
+    /** Px/s² (default 0, 980: y grows downwards, so positive y falls). */
+    gravityX?: number;
+    gravityY?: number;
+    /** Broad-phase cell size, px (default 64): about the size of a typical body or a few tiles. */
+    cellSize?: number;
+    velocityIterations?: number;
+    positionIterations?: number;
+    /** A step is split so no body moves more than its own smallest half size per sub-step, up to this many (default 16). */
+    maxSubsteps?: number;
+    /** No body moves faster than this, px/s (default 4000): the bound that makes the sub-steps above enough. */
+    maxSpeed?: number;
+    /** Gap (px) at which a pair already counts as touching (default 0.5). */
+    contactMargin?: number;
+    /** A contact normal with an upward share above this grounds a body (default 0.7, ground up to ~45°). */
+    groundNormal?: number;
+    /** Let bodies at rest stop being simulated until something touches them (default false). */
+    allowSleep?: boolean;
+    sleepSpeed?: number;
+    sleepTime?: number;
+}
+//# sourceMappingURL=PhysicsWorldOptions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsWorldOptions.d.ts","sourceRoot":"","sources":["../../../src/physics/PhysicsWorldOptions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD,6FAA6F;AAC7F,MAAM,WAAW,mBAAoB,SAAQ,OAAO,CAAC,cAAc,CAAC;IAClE,sEAAsE;IACtE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,+FAA+F;IAC/F,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,wHAAwH;IACxH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4GAA4G;IAC5G,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,yEAAyE;IACzE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,wGAAwG;IACxG,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,4FAA4F;IAC5F,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB"}