1681-engine 0.0.0-stage → 0.5.8

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

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

@@ -0,0 +1,116 @@
+import type { Body } from './Body.js';
+/**
+ * The shapes a body may have, each centred on the body's position. A body turns only when it is made with
+ * `rotates: true`; a platformer's bodies need no rotation, and a body that never turns keeps the cheap axis-aligned
+ * tests and the steadiest stacks.
+ */
+export type Shape = CircleShape | BoxShape | PolygonShape;
+export interface CircleShape {
+    readonly kind: 'circle';
+    radius: number;
+}
+export interface BoxShape {
+    readonly kind: 'box';
+    halfWidth: number;
+    halfHeight: number;
+}
+/** A point or a vector in world or body pixels, y down. */
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+/**
+ * A convex polygon, its vertices relative to the body's position, which must be the polygon's centroid (make one with
+ * `polygonShape`, which orders the points and moves them there). Up to `MAX_POLYGON_VERTICES` corners.
+ */
+export interface PolygonShape {
+    readonly kind: 'polygon';
+    readonly vertices: readonly Vec2[];
+}
+/**
+ * - `dynamic`: moved by gravity, forces and contacts;
+ * - `static`: never moves (ground, walls); cheapest, kept in a broad phase of its own;
+ * - `kinematic`: moved only by its velocity (a moving platform), pushes dynamic bodies and is never pushed.
+ */
+export type BodyType = 'dynamic' | 'static' | 'kinematic';
+export interface BodyOptions {
+    type?: BodyType;
+    shape: Shape;
+    x?: number;
+    y?: number;
+    vx?: number;
+    vy?: number;
+    /**
+     * Whether contacts and torques turn the body (default false). A body that does not rotate may still be placed at an
+     * `angle`, and keeps it.
+     */
+    rotates?: boolean;
+    /** Radians, clockwise on screen (y grows downwards). */
+    angle?: number;
+    /** Radians per second. */
+    angularVelocity?: number;
+    /** Turning lost per second, as a share (default 0.05): a rolling ball slows down without rolling friction. */
+    angularDamping?: number;
+    /** Mass of a dynamic body (default 1). Ignored for static and kinematic bodies, whose mass is infinite. */
+    mass?: number;
+    /** Bounce, 0–1 (default 0). A pair bounces by the larger of its two. */
+    restitution?: number;
+    /** Coulomb friction coefficient (default 0.5). A pair uses the geometric mean of its two. */
+    friction?: number;
+    /** Velocity lost per second, as a share (default 0): air drag. */
+    linearDamping?: number;
+    /** Multiplies the world's gravity for this body (default 1; 0 floats). */
+    gravityScale?: number;
+    /** A sensor reports overlaps (contact events) but is never pushed and pushes nothing. */
+    sensor?: boolean;
+    /** Category bits this body is in (default 1). */
+    layer?: number;
+    /** Category bits this body collides with (default all). A pair collides when each one's layer is in the other's mask. */
+    mask?: number;
+    /** Anything the game wants to find again from a contact or a ray hit (an entity id, an object). */
+    userData?: unknown;
+}
+/** Faces of a box that lie against more solid ground (bits), never used as a contact normal. */
+export declare const FACE_LEFT = 1;
+export declare const FACE_RIGHT = 2;
+export declare const FACE_TOP = 4;
+export declare const FACE_BOTTOM = 8;
+/** A contact as events and queries report it. The normal points from `a` towards `b`; y grows downwards. */
+export interface ContactInfo {
+    readonly a: Body;
+    readonly b: Body;
+    readonly nx: number;
+    readonly ny: number;
+    /** Overlap along the normal, px (slightly negative while resting just apart). */
+    readonly depth: number;
+    /** Either body is a sensor: reported, never resolved. */
+    readonly sensor: boolean;
+    /** Where the two touch, world px: one or two points (two where an edge lies along an edge). */
+    readonly points: readonly Vec2[];
+}
+export interface PhysicsEvents {
+    /** Two bodies started touching (or a sensor started overlapping). Emitted after the step. */
+    begin: ContactInfo;
+    /** Two bodies stopped touching, or one of them was removed. Emitted after the step. */
+    end: ContactInfo;
+}
+export interface RayHit {
+    body: Body;
+    /** Where the ray met the body. */
+    x: number;
+    y: number;
+    /** Surface normal there, pointing back towards the ray's start. */
+    nx: number;
+    ny: number;
+    /** Share of the ray's length at the hit, 0–1. */
+    fraction: number;
+}
+export interface RaycastOptions {
+    /** Only bodies whose layer shares a bit with this (default all). */
+    mask?: number;
+    /** Sensors are skipped unless this is true. */
+    includeSensors?: boolean;
+    /** Skip bodies this returns false for (the caster itself, say). */
+    filter?: (body: Body) => boolean;
+}
+//# sourceMappingURL=types.d.ts.map

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

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

package/dist/types/pixel/Darkness.d.ts

@@ -0,0 +1,78 @@
+import type { Stage } from '../core/Stage.js';
+/** A plain light's colour (a lamp nobody named one for, the light a body carries): warm, as flame is. */
+export declare const WARM_LIGHT = 16761466;
+export declare class Darkness {
+    private readonly stage;
+    private color;
+    private alpha;
+    private readonly scratch;
+    private readonly sheet;
+    /** Every hole is erased before any colour is laid, or a later hole would wipe an earlier light's colour away. */
+    private readonly holes;
+    private readonly washes;
+    private readonly lamps;
+    /** The transient lights (`lights.ts`), reused frame to frame. */
+    private readonly flashes;
+    private rt;
+    /**
+     * On the screen layer, laid over the world with its exact transform by the camera (`Camera.follow`), shake included:
+     * the night is drawn in world pixels round the unshaken camera and only this layer moves with a shake, so a shaking
+     * screen does not redraw the night every frame.
+     */
+    private readonly layer;
+    private readonly view;
+    /** The light the player carries: the only one that follows them, and the last one they lose. */
+    private readonly carried;
+    private readonly unsubscribeResize;
+    /** Lamps that flicker: while one does (or the player carries a light) every frame differs. */
+    private flickering;
+    /** Something other than the camera changed what the night looks like (a lamp added, dimmed, the window resized). */
+    private dirty;
+    /** What the last drawn frame was drawn from: the texture, the camera's texel and the shade. */
+    private drawn;
+    /** The carried light's place at the last redraw (it follows the body). */
+    private carriedAt;
+    /** When the sheet was last redrawn. */
+    private drawnAt;
+    /** The world pixel the night's top-left texel stands on. */
+    private ox;
+    private oy;
+    /** The night texture's size in world pixels, and the zoom it was made for. */
+    private rtKey;
+    /** The lamps' colour turned down (`setLampsDimmed`). */
+    private dimLamps;
+    /** A phone redraws the night at most `PHONE_MS` apart, whatever moves (`isTouchUi`). */
+    private readonly phone;
+    constructor(stage: Stage, color: number, alpha: number);
+    /** A hole and its colour, added to the night's layers. */
+    private light;
+    /** A lamp fixed in the world: a torch on a wall, the seep in its chamber, a crystal in a seam, in its own colour. */
+    addLamp(x: number, y: number, radius: number, flicker?: number, color?: number): void;
+    /**
+     * Changes how dark and what colour the sheet is (the outdoor night, `NightShade`, deepens and lifts with the
+     * world clock). A sheet with no alpha left is neither drawn nor redrawn, so a map at noon pays nothing for its night.
+     */
+    setShade(color: number, alpha: number): void;
+    /**
+     * Dimmed lamps lay only `LAMP_DIM` of their colour on the dark (a "fewer ambient lights" setting). The holes they
+     * cut stay as wide, so a dark place is still seen by them.
+     */
+    setLampsDimmed(dim: boolean): void;
+    /**
+     * The night's own texture, one texel a world pixel and `MARGIN` to spare on each side (a shake, or a camera that
+     * moved while a phone waits for its next redraw, never shows its edge), remade when the window or the zoom changes:
+     * at zoom 2 or 3 it is a quarter or a ninth of the screen's pixels. True when it was remade.
+     */
+    private fit;
+    /** Redraws the night with this frame's holes in it, when anything in it changed. `px`/`py` is where the player stands. */
+    update(now: number, px: number, py: number, carriedRadius: number): void;
+    private hide;
+    /** Lays light `l` at world (wx, wy), `r` px across its radius, in the night's world-pixel grid. */
+    private place;
+    destroy(): void;
+}
+/** What is left of a lamp's glow and colour while lamps are dimmed (`setLampsDimmed`). */
+export declare const LAMP_DIM = 0.35;
+/** World units of light the player carries underground — about five tiles of certainty in any direction. */
+export declare const CARRIED_LIGHT: number;
+//# sourceMappingURL=Darkness.d.ts.map

package/dist/types/pixel/Darkness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Darkness.d.ts","sourceRoot":"","sources":["../../../src/pixel/Darkness.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AA2C3C,yGAAyG;AACzG,eAAO,MAAM,UAAU,WAAW,CAAC;AAsEnC,qBAAa,QAAQ;IAyCjB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,KAAK;IA1Cf,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,iHAAiH;IACjH,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmB;IACzC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmB;IAC1C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqF;IAC3G,iEAAiE;IACjE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAC9C,OAAO,CAAC,EAAE,CAAgB;IAC1B;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmB;IACzC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,gGAAgG;IAChG,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IACvC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAa;IAC/C,8FAA8F;IAC9F,OAAO,CAAC,UAAU,CAAK;IACvB,oHAAoH;IACpH,OAAO,CAAC,KAAK,CAAQ;IACrB,+FAA+F;IAC/F,OAAO,CAAC,KAAK,CAAM;IACnB,0EAA0E;IAC1E,OAAO,CAAC,SAAS,CAAM;IACvB,uCAAuC;IACvC,OAAO,CAAC,OAAO,CAAa;IAC5B,4DAA4D;IAC5D,OAAO,CAAC,EAAE,CAAK;IACf,OAAO,CAAC,EAAE,CAAK;IACf,8EAA8E;IAC9E,OAAO,CAAC,KAAK,CAAM;IACnB,wDAAwD;IACxD,OAAO,CAAC,QAAQ,CAAS;IACzB,wFAAwF;IACxF,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;gBAGlB,KAAK,EAAE,KAAK,EACrB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM;IAgBvB,0DAA0D;IAC1D,OAAO,CAAC,KAAK;IAUb,qHAAqH;IACrH,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,SAAI,EAAE,KAAK,SAAa,GAAG,IAAI;IAMpF;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAM5C;;;OAGG;IACH,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAMlC;;;;OAIG;IACH,OAAO,CAAC,GAAG;IAaX,0HAA0H;IAC1H,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI;IAiExE,OAAO,CAAC,IAAI;IAKZ,mGAAmG;IACnG,OAAO,CAAC,KAAK;IAmBb,OAAO,IAAI,IAAI;CAOhB;AAED,0FAA0F;AAC1F,eAAO,MAAM,QAAQ,OAAO,CAAC;AAE7B,4GAA4G;AAC5G,eAAO,MAAM,aAAa,QAAgB,CAAC"}

package/dist/types/pixel/DitherVignette.d.ts

@@ -0,0 +1,35 @@
+import { Texture } from 'pixi.js';
+import type { Stage } from '../core/Stage.js';
+/**
+ * A white dithered edge for a screen of `w`×`h` world pixels, one texel a world pixel and scaled up `'nearest'`;
+ * the sprite that draws it tints it. Made once per size and strength. Returns `Texture.EMPTY` when the browser has
+ * no canvas memory to spare (iOS), so the caller asks again later.
+ */
+export declare function ditherVignette(w: number, h: number, strength?: number, from?: number): Texture;
+export interface DitherVignetteOptions {
+    /** The edge's colour (default black). */
+    color?: number;
+    /** How far from the centre toward a corner the edge begins, 0..1 (default 0.55). */
+    from?: number;
+}
+/**
+ * A dithered pixel edge round the screen, on the screen layer: a darkened border, or tinted red and beaten with
+ * `heartbeat` while a player is low on health. The texture is made at full strength, off the frame that first needs
+ * it (a full-screen dither is a few ms on a phone), and remade only when the window or the zoom changes; `show`
+ * changes how much of it shows.
+ */
+export declare class DitherVignette {
+    private readonly stage;
+    private readonly edge;
+    private madeFor;
+    private making;
+    private readonly from;
+    constructor(stage: Stage, options?: DitherVignetteOptions);
+    setColor(color: number): void;
+    private make;
+    /** Shows the edge at `alpha` (0..1); call each frame it shows. */
+    show(alpha: number): void;
+    hide(): void;
+    destroy(): void;
+}
+//# sourceMappingURL=DitherVignette.d.ts.map

package/dist/types/pixel/DitherVignette.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DitherVignette.d.ts","sourceRoot":"","sources":["../../../src/pixel/DitherVignette.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,OAAO,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAO3C;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,SAAI,EAAE,IAAI,SAAO,GAAG,OAAO,CAuBvF;AAED,MAAM,WAAW,qBAAqB;IACpC,yCAAyC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,oFAAoF;IACpF,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,qBAAa,cAAc;IAOvB,OAAO,CAAC,QAAQ,CAAC,KAAK;IANxB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgB;IACrC,OAAO,CAAC,OAAO,CAAM;IACrB,OAAO,CAAC,MAAM,CAA8C;IAC5D,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;gBAGX,KAAK,EAAE,KAAK,EAC7B,OAAO,GAAE,qBAA0B;IAYrC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAI7B,OAAO,CAAC,IAAI;IAaZ,kEAAkE;IAClE,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IASzB,IAAI,IAAI,IAAI;IAIZ,OAAO,IAAI,IAAI;CAIhB"}

package/dist/types/pixel/Evaporation.d.ts

@@ -0,0 +1,30 @@
+import type { Stage } from '../core/Stage.js';
+import type { WorldObject } from '../core/types.js';
+import type { PackedPixels } from './spritePixels.js';
+/** What a dying body hands over: its feet in the world, how it was drawn, and the pixels of its last frame. */
+export interface DeathPixels {
+    x: number;
+    y: number;
+    /** World pixels per sprite pixel (the body's `scale`), negative when the body faced left. */
+    scaleX: number;
+    scaleY: number;
+    pixels: PackedPixels;
+}
+/**
+ * A dead body evaporating: it breaks into its own pixels, which let go top rows first, rise, scatter a little and
+ * give out, while the body itself is hidden by the caller. Every particle is one whole world pixel in a colour read
+ * off the body's last frame, painted at 12 fps like every other effect; it pales up its own ramp as it rises and
+ * steps its alpha down instead of melting, so it stays pixel art the whole way. A cloud is one `PixelLayer` (a pooled
+ * texture) rather than a Graphics of up to 1,400 rects.
+ */
+export declare class Evaporation {
+    private readonly scene;
+    private readonly track;
+    private readonly clouds;
+    private live;
+    constructor(scene: Stage, track: (object: WorldObject) => void);
+    play(d: DeathPixels, big: boolean, now: number): void;
+    update(now: number): void;
+    private draw;
+}
+//# sourceMappingURL=Evaporation.d.ts.map

package/dist/types/pixel/Evaporation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Evaporation.d.ts","sourceRoot":"","sources":["../../../src/pixel/Evaporation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,+GAA+G;AAC/G,MAAM,WAAW,WAAW;IAC1B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,6FAA6F;IAC7F,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,YAAY,CAAC;CACtB;AAgCD;;;;;;GAMG;AACH,qBAAa,WAAW;IAKpB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK;IALxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,IAAI,CAAK;gBAGE,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI;IAGvD,IAAI,CAAC,CAAC,EAAE,WAAW,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IAqDrD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAazB,OAAO,CAAC,IAAI;CA8Bb"}

package/dist/types/pixel/NightShade.d.ts

@@ -0,0 +1,38 @@
+import type { Stage } from '../core/Stage.js';
+import { type DayClock } from '../ambient/DayClock.js';
+export interface NightShadeOptions {
+    /** The day the night follows. */
+    clock: DayClock;
+    /** This place's own night colour, pulled in as the night deepens (`tintNight`); none keeps the clock's. */
+    tint?: number;
+    /** How far the tint takes over at full night (default 0.6). */
+    tintShare?: number;
+    /** A lamp's hole in the night against the glow it is drawn with (default 1.6: the light reaches past the glow). */
+    lampScale?: number;
+    /** The radius (world px) of the light a body carries at full night; 0 for none (default 64). */
+    carriedLight?: number;
+    /** The night share below which nothing is carried (default 0.55): at dusk a hole round the feet reads as a spotlight. */
+    carriedFrom?: number;
+}
+/**
+ * The outdoor night: a `DayClock`'s grade laid over the world as a dithered `Darkness`, deepening at dusk and lifting
+ * at dawn, with every lamp, window and fire burning a hole in it — the same erase trick an underground is lit by,
+ * only with a sheet whose colour and depth follow the clock. A place under no sky (a cave) builds a `Darkness` of its
+ * own instead; at noon the sheet has no alpha and costs nothing.
+ */
+export declare class NightShade {
+    private readonly options;
+    private readonly dark;
+    private readonly lampScale;
+    private readonly carried;
+    private readonly carriedFrom;
+    constructor(stage: Stage, options: NightShadeOptions);
+    /** A light the place glows with, `glowSize` the diameter of the glow drawn for it: by night it is what is seen by. */
+    addLight(x: number, y: number, glowSize: number, color?: number, flicker?: number): void;
+    /** Lamps colour the dark less (a "fewer ambient lights" setting); their holes stay as wide. */
+    setLampsDimmed(dim: boolean): void;
+    /** `now` the frame's ms, `wallMs` the shared wall time the clock reads (`serverNow()`), `px`/`py` the player. */
+    update(now: number, wallMs: number, px: number, py: number): void;
+    destroy(): void;
+}
+//# sourceMappingURL=NightShade.d.ts.map

package/dist/types/pixel/NightShade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NightShade.d.ts","sourceRoot":"","sources":["../../../src/pixel/NightShade.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAa,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAG/D,MAAM,WAAW,iBAAiB;IAChC,iCAAiC;IACjC,KAAK,EAAE,QAAQ,CAAC;IAChB,2GAA2G;IAC3G,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,+DAA+D;IAC/D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mHAAmH;IACnH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gGAAgG;IAChG,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yHAAyH;IACzH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;GAKG;AACH,qBAAa,UAAU;IAQnB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAP1B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAW;IAChC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;gBAGnC,KAAK,EAAE,KAAK,EACK,OAAO,EAAE,iBAAiB;IAS7C,sHAAsH;IACtH,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,SAAI,GAAG,IAAI;IAInF,+FAA+F;IAC/F,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAIlC,iHAAiH;IACjH,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IAOjE,OAAO,IAAI,IAAI;CAGhB"}