1681-engine 0.0.0-stage → 0.5.9

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

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

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

@@ -0,0 +1,23 @@
+import type { Body } from './Body.js';
+/**
+ * Broad phase: a uniform grid hashed into a map, each cell listing the bodies whose bounds touch it. A body spans
+ * as many cells as its bounds cover, so a long merged floor sits in a row of cells and is still one body.
+ *
+ * Cells are keyed by their coordinates packed into one number (16 bits each, wrapping): two cells 65,536 cells
+ * apart share a list, which only costs a few extra narrow-phase tests, never a missed pair.
+ */
+export declare class SpatialHash {
+    readonly cellSize: number;
+    private readonly inv;
+    private readonly cells;
+    /** Lists emptied by `clear`, kept for reuse so a rebuild every step allocates nothing once warm. */
+    private readonly spare;
+    constructor(cellSize: number);
+    static key(cx: number, cy: number): number;
+    cellOf(v: number): number;
+    clear(): void;
+    insert(body: Body, margin?: number): void;
+    /** The bodies listed in one cell (undefined when empty). Do not keep or edit the array. */
+    at(cx: number, cy: number): readonly Body[] | undefined;
+}
+//# sourceMappingURL=SpatialHash.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SpatialHash.d.ts","sourceRoot":"","sources":["../../../src/physics/SpatialHash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC;;;;;;GAMG;AACH,qBAAa,WAAW;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA6B;IACnD,oGAAoG;IACpG,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;gBAE1B,QAAQ,EAAE,MAAM;IAM5B,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM;IAI1C,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAIzB,KAAK,IAAI,IAAI;IAQb,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,SAAI,GAAG,IAAI;IAkBpC,2FAA2F;IAC3F,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,SAAS,IAAI,EAAE,GAAG,SAAS;CAGxD"}

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

@@ -0,0 +1,27 @@
+import type { Body } from './Body.js';
+/**
+ * The result of a narrow-phase test: the normal points from `a` to `b`, `depth` > 0 is overlap, < 0 a gap (the
+ * deepest of the points). Up to two contact points, each with its own depth and a feature id that stays the same
+ * while the same corners touch, so the solver can carry each point's impulse over from step to step.
+ */
+export interface Manifold {
+    nx: number;
+    ny: number;
+    depth: number;
+    count: number;
+    readonly px: [number, number];
+    readonly py: [number, number];
+    readonly pd: [number, number];
+    readonly id: [number, number];
+}
+export declare function emptyManifold(): Manifold;
+/**
+ * Narrow phase. Fills `out` and returns true when the two shapes overlap or lie closer than `margin`. The margin
+ * keeps a resting contact alive while the solver holds the bodies a hair apart, so a body standing on the ground is
+ * grounded on every step instead of flickering between touching and not.
+ *
+ * Two bodies that never turn and sit square (boxes at no angle, circles) take the axis-aligned tests, which know the
+ * internal faces of merged tile boxes; anything turned or turning takes the polygon tests (`collidePolygon.ts`).
+ */
+export declare function collide(a: Body, b: Body, margin: number, out: Manifold): boolean;
+//# sourceMappingURL=collide.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collide.d.ts","sourceRoot":"","sources":["../../../src/physics/collide.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAInC;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,QAAQ,CAAC,EAAE,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,QAAQ,CAAC,EAAE,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,QAAQ,CAAC,EAAE,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B;AAED,wBAAgB,aAAa,IAAI,QAAQ,CAExC;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CA+BhF"}

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

@@ -0,0 +1,14 @@
+import type { Body } from './Body.js';
+import type { Manifold } from './collide.js';
+/**
+ * Two convex shapes (boxes or polygons, turned or not) by the separating axis test, then the incident edge clipped
+ * against the reference face's sides (Box2D's manifold), giving one or two points. A normal out of a merged tile box's
+ * internal face is never used, so a turned crate slides over the seams of a tile floor like a square one does.
+ */
+export declare function polygonPolygon(a: Body, b: Body, margin: number, out: Manifold): boolean;
+/**
+ * A circle against a box or polygon that is turned (or turns): the face the centre lies furthest out of, then that
+ * face's middle or one of its corners. `circleIsA` says which way round the pair is, so the normal runs from a to b.
+ */
+export declare function circlePolygon(circle: Body, radius: number, poly: Body, margin: number, circleIsA: boolean, out: Manifold): boolean;
+//# sourceMappingURL=collidePolygon.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collidePolygon.d.ts","sourceRoot":"","sources":["../../../src/physics/collidePolygon.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAsE1C;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CA+DvF;AA6BD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CAiDlI"}

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

@@ -0,0 +1,8 @@
+import type { Body } from './Body.js';
+import type { Contact } from './Contact.js';
+import type { ContactInfo } from './types.js';
+/** Marks `body` as standing on `ground` through contact `c`; the first ground found in a step wins. */
+export declare function setGround(body: Body, ground: Body, c: Contact): void;
+/** A copy for an event: the contact itself changes on the next step. */
+export declare function info(c: Contact): ContactInfo;
+//# sourceMappingURL=contactReport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contactReport.d.ts","sourceRoot":"","sources":["../../../src/physics/contactReport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,uGAAuG;AACvG,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,GAAG,IAAI,CAOpE;AAED,wEAAwE;AACxE,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,GAAG,WAAW,CAE5C"}

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

@@ -0,0 +1,43 @@
+import type { Body } from './Body.js';
+import type { PhysicsWorld } from './PhysicsWorld.js';
+/** Colours `drawColliders` gives each kind of body. */
+export interface ColliderColors {
+    static: number;
+    kinematic: number;
+    /** A dynamic body standing on something. */
+    grounded: number;
+    /** A dynamic body in the air. */
+    airborne: number;
+    /** A dynamic body asleep (only with `allowSleep`). */
+    sleeping: number;
+    sensor: number;
+}
+export declare const COLLIDER_COLORS: Readonly<ColliderColors>;
+/**
+ * Draws one box in world coordinates. The same shape as `DebugOverlay`'s `BoxDrawer`, written out here so the physics
+ * module stays free of anything that draws.
+ */
+export type ColliderBoxDrawer = (x: number, y: number, width: number, height: number, color?: number) => void;
+/** Draws one line in world coordinates (`DebugOverlay`'s `LineDrawer`). */
+export type ColliderLineDrawer = (x0: number, y0: number, x1: number, y1: number, color?: number) => void;
+/**
+ * Draws every body's bounding box, coloured by what it is: the usual body of a `DebugOverlay`'s `colliders` callback,
+ * which otherwise made every game keep a list of its own bodies just to show them.
+ *
+ * ```ts
+ * new DebugOverlay(engine, { colliders: (draw) => drawColliders(physics, draw) });
+ * ```
+ *
+ * `colorOf` picks a game's own colour for a body (a one-way plank, a hazard), or returns undefined for the default.
+ * A circle is drawn as its bounding box: the overlay draws boxes, and a box round a circle still shows where it is.
+ * Given `line` (the overlay hands it over as its second argument), a turned box or a polygon is drawn as its own
+ * outline, and a circle that rotates gets a spoke showing its angle.
+ *
+ * ```ts
+ * new DebugOverlay(engine, { colliders: (draw, line) => drawColliders(physics, draw, {}, undefined, line) });
+ * ```
+ */
+export declare function drawColliders(world: PhysicsWorld, draw: ColliderBoxDrawer, colors?: Partial<ColliderColors>, colorOf?: (body: Body) => number | undefined, line?: ColliderLineDrawer): void;
+/** The default colour of one body. */
+export declare function colliderColor(b: Body, c?: ColliderColors): number;
+//# sourceMappingURL=drawColliders.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drawColliders.d.ts","sourceRoot":"","sources":["../../../src/physics/drawColliders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,uDAAuD;AACvD,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,4CAA4C;IAC5C,QAAQ,EAAE,MAAM,CAAC;IACjB,iCAAiC;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,sDAAsD;IACtD,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,cAAc,CAOpD,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;AAE9G,2EAA2E;AAC3E,MAAM,MAAM,kBAAkB,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;AAE1G;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,YAAY,EACnB,IAAI,EAAE,iBAAiB,EACvB,MAAM,GAAE,OAAO,CAAC,cAAc,CAAM,EACpC,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,MAAM,GAAG,SAAS,EAC5C,IAAI,CAAC,EAAE,kBAAkB,GACxB,IAAI,CAcN;AAED,sCAAsC;AACtC,wBAAgB,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAE,cAAgC,GAAG,MAAM,CAMlF"}

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

@@ -0,0 +1,5 @@
+import { type System } from '../ecs/World.js';
+import type { PhysicsWorld } from './PhysicsWorld.js';
+/** A `fixed` system that steps `physics` once per simulation step, by the loop's own dt. */
+export declare function physicsSystem(physics: PhysicsWorld, name?: string): System;
+//# sourceMappingURL=physicsSystem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"physicsSystem.d.ts","sourceRoot":"","sources":["../../../src/physics/physicsSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,MAAM,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,4FAA4F;AAC5F,wBAAgB,aAAa,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,SAAY,GAAG,MAAM,CAE7E"}

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

@@ -0,0 +1,28 @@
+import type { BoxShape, PolygonShape, Vec2 } from './types.js';
+/** The most corners a polygon shape may have. */
+export declare const MAX_POLYGON_VERTICES = 16;
+/** The centroid of the convex hull of `points`: where to put the body so a `polygonShape(points)` lands on them. */
+export declare function polygonCentroid(points: readonly Vec2[]): Vec2;
+/**
+ * A convex polygon shape from any points: their convex hull, in the order the solver keeps, moved so its centroid is
+ * the body's position. Give points round the origin, or anywhere and place the body at `polygonCentroid(points)`.
+ */
+export declare function polygonShape(points: readonly Vec2[]): PolygonShape;
+/** A regular polygon of `sides` corners on a circle of `radius`, its first corner straight up. */
+export declare function regularPolygon(sides: number, radius: number): PolygonShape;
+/** Local outward normals and the solver's mass terms of a polygon, worked out once per shape object. */
+export interface PolygonData {
+    readonly vertices: readonly Vec2[];
+    readonly normals: readonly Vec2[];
+    /** Second moment of area about the centroid per unit of area-mass: inertia = mass × this. */
+    readonly inertiaPerMass: number;
+    /** The furthest corner from the centre. */
+    readonly radius: number;
+    /** The nearest face to the centre: how far the body may move in one sub-step without passing through anything. */
+    readonly inradius: number;
+}
+/** The data of a polygon shape, checked (convex, in order) the first time it is asked for. */
+export declare function polygonData(shape: PolygonShape): PolygonData;
+/** A box as the four corners the polygon tests use: top-left first, clockwise on screen, so face i is top, right, bottom, left. */
+export declare function boxCorners(s: BoxShape): Vec2[];
+//# sourceMappingURL=polygon.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"polygon.d.ts","sourceRoot":"","sources":["../../../src/physics/polygon.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAE5D,iDAAiD;AACjD,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAavC,oHAAoH;AACpH,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,GAAG,IAAI,CAe7D;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,GAAG,YAAY,CAMlE;AAED,kGAAkG;AAClG,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY,CAQ1E;AAsBD,wGAAwG;AACxG,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,SAAS,IAAI,EAAE,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,SAAS,IAAI,EAAE,CAAC;IAClC,6FAA6F;IAC7F,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,2CAA2C;IAC3C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,kHAAkH;IAClH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAID,8FAA8F;AAC9F,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,WAAW,CA+B5D;AAED,mIAAmI;AACnI,wBAAgB,UAAU,CAAC,CAAC,EAAE,QAAQ,GAAG,IAAI,EAAE,CAO9C"}

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

@@ -0,0 +1,19 @@
+import type { Body } from './Body.js';
+import type { SpatialHash } from './SpatialHash.js';
+import type { RayHit, RaycastOptions } from './types.js';
+/** Where a ray from (ox, oy) along (dx, dy) — not normalised, t = 1 at its end — first enters a body. */
+interface ShapeHit {
+    t: number;
+    nx: number;
+    ny: number;
+}
+/** A ray starting inside the shape misses it, so a body can cast from its own centre without hitting itself. */
+export declare function rayShape(body: Body, ox: number, oy: number, dx: number, dy: number, maxT: number, out: ShapeHit): boolean;
+/**
+ * The first body a segment from (x0, y0) to (x1, y1) meets, walking the broad phase's cells in the ray's order
+ * (Amanatides–Woo) and stopping once the next cell lies beyond the best hit so far; a long ray over a large map
+ * looks only at the cells it crosses.
+ */
+export declare function castRay(hashes: readonly SpatialHash[], x0: number, y0: number, x1: number, y1: number, options?: RaycastOptions): RayHit | null;
+export {};
+//# sourceMappingURL=raycast.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raycast.d.ts","sourceRoot":"","sources":["../../../src/physics/raycast.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEtD,yGAAyG;AACzG,UAAU,QAAQ;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ;AAID,gHAAgH;AAChH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CAmDzH;AAqCD;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE,cAAmB,GAAG,MAAM,GAAG,IAAI,CAuDnJ"}

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

@@ -0,0 +1,16 @@
+import type { Body } from './Body.js';
+/** Anything with a settable position: a Pixi container, a sprite, a plain object. */
+export interface Positioned {
+    x: number;
+    y: number;
+    /** Set to the body's angle when the body rotates or stands at an angle; left alone otherwise. */
+    rotation?: number;
+}
+/**
+ * Places `view` where `body` is drawn this frame: between its last two step positions by the loop's `alpha`
+ * (`SystemContext.alpha` in a `frame` system), so motion is smooth at any refresh rate even though physics steps
+ * at a fixed rate. Pass `round` for pixel art, so the view lands on whole pixels. A body that rotates (or was placed
+ * at an angle) turns the view too, by the shorter way between its last two angles; the offset is turned with it.
+ */
+export declare function syncToBody(view: Positioned, body: Body, alpha: number, offsetX?: number, offsetY?: number, round?: boolean): void;
+//# sourceMappingURL=syncToBody.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"syncToBody.d.ts","sourceRoot":"","sources":["../../../src/physics/syncToBody.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,qFAAqF;AACrF,MAAM,WAAW,UAAU;IACzB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,iGAAiG;IACjG,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,SAAI,EAAE,OAAO,SAAI,EAAE,KAAK,UAAQ,GAAG,IAAI,CAoBrH"}

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

@@ -0,0 +1,36 @@
+import type { CollisionGrid } from '../net/movement.js';
+import { Body } from './Body.js';
+export interface TileBodiesOptions {
+    /** World position of tile (0, 0)'s top-left corner (default 0, 0). */
+    originX?: number;
+    originY?: number;
+    friction?: number;
+    restitution?: number;
+    layer?: number;
+    mask?: number;
+    userData?: unknown;
+}
+/** A rectangle of solid tiles, in tiles, both ends inclusive. */
+export interface TileRect {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}
+/**
+ * Covers the solid cells of a tile grid with as few rectangles as a cheap greedy pass finds: runs along each row,
+ * then a run is grown downwards while the row below has exactly the same run. A floor becomes one box and a wall
+ * one tall box, so a body sliding along either crosses no seam to snag on.
+ */
+export declare function mergeTileRects(width: number, height: number, solid: (tx: number, ty: number) => boolean): TileRect[];
+/**
+ * Static boxes for the solid tiles of a grid, ready for `PhysicsWorld.add`. Each box marks the faces that lie
+ * wholly against more solid tiles as internal, so a body is never pushed out through a face that is inside the
+ * ground (the seam between a floor and the wall standing on it).
+ *
+ * Outside the grid counts as open, so the edges of the map collide like any other face.
+ */
+export declare function tileBodies(width: number, height: number, tileSize: number, solid: (tx: number, ty: number) => boolean, options?: TileBodiesOptions): Body[];
+/** `tileBodies` for the engine's `CollisionGrid` (from `createCollisionGrid` or a Tiled map's `collisionFromTiled`). */
+export declare function tileBodiesFromGrid(grid: CollisionGrid, options?: TileBodiesOptions): Body[];
+//# sourceMappingURL=tileBodies.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tileBodies.d.ts","sourceRoot":"","sources":["../../../src/physics/tileBodies.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAG9B,MAAM,WAAW,iBAAiB;IAChC,sEAAsE;IACtE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,iEAAiE;AACjE,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,GAAG,QAAQ,EAAE,CA4BpH;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,EAAE,OAAO,GAAE,iBAAsB,GAAG,IAAI,EAAE,CA0B/J;AAED,wHAAwH;AACxH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,GAAE,iBAAsB,GAAG,IAAI,EAAE,CAE/F"}