lantern-engine 0.0.0-stage → 0.4.0

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

@@ -0,0 +1,43 @@
+import type { InputStep, MovementParams } from './constants.js';
+import { type CollisionGrid, type MoverState } from './movement.js';
+import { type MoverWire } from './protocol.js';
+/**
+ * Client-side prediction for the local player's body. Every input step is applied at once (the player sees their
+ * own move with no lag) and kept until the server acknowledges it. When a snapshot says where the server has the
+ * body as of step `ack`, the body is put there and every step after `ack` is replayed on top.
+ *
+ * Movement is deterministic (`stepMover`), so with the same steps, params and grid the replay lands exactly where
+ * the prediction was and nothing moves. When it does not (the server refused a step, a collision only it knew of),
+ * the difference is `correction`: draw the body at `drawX/drawY`, which ease that jump out over a few frames instead
+ * of snapping.
+ */
+export declare class PredictedMover {
+    private params;
+    private grid;
+    readonly mover: MoverState;
+    private pending;
+    private nextSeq;
+    /** The jump the last reconciliation made, still being eased out (world px). */
+    private offsetX;
+    private offsetY;
+    /** How big the last correction was (0 when the prediction was right). */
+    correction: number;
+    /** Share of a visual correction left after each 60th of a second (default 0.8). */
+    smoothing: number;
+    constructor(x: number, y: number, params: MovementParams, grid: CollisionGrid);
+    /** Applies one input step now and keeps it for replay; returns its sequence number (send it with the step). */
+    step(step: InputStep): number;
+    /** Steps sent but not yet acknowledged. */
+    get unacknowledged(): number;
+    /** The server's word: the body as of step `ack`. Rewinds there and replays the rest. */
+    reconcile(ack: number, server: MoverWire): void;
+    /** Eases the visual correction out; call once a frame with its length in seconds. */
+    smooth(dt: number): void;
+    /** Where to draw the body: the predicted place plus the correction still being eased out. */
+    get drawX(): number;
+    get drawY(): number;
+    /** New movement rules (a buff, a slow): applied to future steps and to replays. */
+    setParams(params: MovementParams): void;
+    setGrid(grid: CollisionGrid): void;
+}
+//# sourceMappingURL=PredictedMover.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PredictedMover.d.ts","sourceRoot":"","sources":["../../../src/net/PredictedMover.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7D,OAAO,EAA0B,KAAK,aAAa,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AACzF,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAE3D;;;;;;;;;GASG;AACH,qBAAa,cAAc;IAevB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,IAAI;IAfd,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,OAAO,CAAC,OAAO,CAA0C;IACzD,OAAO,CAAC,OAAO,CAAK;IACpB,+EAA+E;IAC/E,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,OAAO,CAAK;IACpB,yEAAyE;IACzE,UAAU,SAAK;IACf,mFAAmF;IACnF,SAAS,SAAO;gBAGd,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACD,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,aAAa;IAK7B,+GAA+G;IAC/G,IAAI,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM;IAO7B,2CAA2C;IAC3C,IAAI,cAAc,IAAI,MAAM,CAE3B;IAED,wFAAwF;IACxF,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI;IAoB/C,qFAAqF;IACrF,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAQxB,6FAA6F;IAC7F,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,mFAAmF;IACnF,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAIvC,OAAO,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI;CAGnC"}

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

@@ -0,0 +1,69 @@
+import type { InputStep, MovementParams } from './constants.js';
+import { type CollisionGrid, type MoverState } from './movement.js';
+import { type Snapshot } from './protocol.js';
+export interface RoomPlayer<D = unknown> {
+    readonly id: number;
+    readonly mover: MoverState;
+    /** The game's own data for this player (sent to others in `sp` when they first see it). */
+    data: D;
+    params: MovementParams;
+    /** The last input step applied (-1 before any): what snapshots acknowledge. */
+    ack: number;
+    /** Steps received and not yet applied. */
+    readonly queue: InputStep[];
+    /** What the snapshot's update record carries beside the position; the game sets them. */
+    aim: number;
+    anim: number;
+    hp: number;
+    flags: number;
+    /** Refused inputs (nonsense numbers, a flood): a game may kick past some count. */
+    strikes: number;
+}
+export interface RoomOptions<D> {
+    grid: CollisionGrid;
+    /** Movement rules a new player starts with. */
+    params: MovementParams;
+    /** Where a player who joins stands. */
+    spawn: (id: number, data: D) => {
+        x: number;
+        y: number;
+    };
+    /** Steps a player may have waiting before more are refused (default 30: half a second at 60). */
+    maxQueue?: number;
+    /** A player with more than `backlog` waiting catches up by running up to `maxStepsPerTick` a tick (default 3, 4). */
+    maxStepsPerTick?: number;
+    backlog?: number;
+    /** Called after each step a player takes (set aim, anim, flags from it). */
+    onStep?: (player: RoomPlayer<D>, step: InputStep) => void;
+}
+/**
+ * An authoritative room for a server: players send input steps, the room applies them with the same `stepMover` the
+ * clients predict with, and builds each player a snapshot of everyone (with their own body whole, so their
+ * prediction can rewind to it). Transport-free: wire `input`, `step` and `snapshotFor` to any socket library.
+ *
+ * Every step a player sends is applied once, in order; a client cannot move faster by sending more (the queue is
+ * capped and drained at most `maxStepsPerTick` a tick), and nonsense input is refused and counted.
+ */
+export declare class Room<D = unknown> {
+    private readonly options;
+    readonly players: Map<number, RoomPlayer<D>>;
+    tick: number;
+    private readonly known;
+    private readonly maxQueue;
+    private readonly maxSteps;
+    private readonly backlog;
+    constructor(options: RoomOptions<D>);
+    join(id: number, data: D): RoomPlayer<D>;
+    leave(id: number): void;
+    /**
+     * Input steps `seq`, `seq + 1`, … from a player. Steps already received are skipped (a resend), any step with
+     * numbers no client sends refuses the whole message, and steps past a full queue are dropped. Returns false when
+     * something was refused.
+     */
+    input(id: number, seq: number, steps: readonly InputStep[]): boolean;
+    /** One simulation step for everyone. */
+    step(): void;
+    /** The snapshot player `id` should get now. `time` is the server's wall clock (ms). */
+    snapshotFor(id: number, time: number): Snapshot | null;
+}
+//# sourceMappingURL=Room.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Room.d.ts","sourceRoot":"","sources":["../../../src/net/Room.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,SAAS,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC3E,OAAO,EAA0B,KAAK,aAAa,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AACzF,OAAO,EAAe,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAExD,MAAM,WAAW,UAAU,CAAC,CAAC,GAAG,OAAO;IACrC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,2FAA2F;IAC3F,IAAI,EAAE,CAAC,CAAC;IACR,MAAM,EAAE,cAAc,CAAC;IACvB,+EAA+E;IAC/E,GAAG,EAAE,MAAM,CAAC;IACZ,0CAA0C;IAC1C,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC;IAC5B,yFAAyF;IACzF,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,mFAAmF;IACnF,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,WAAW,CAAC,CAAC;IAC5B,IAAI,EAAE,aAAa,CAAC;IACpB,+CAA+C;IAC/C,MAAM,EAAE,cAAc,CAAC;IACvB,uCAAuC;IACvC,KAAK,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,KAAK;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACzD,iGAAiG;IACjG,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qHAAqH;IACrH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4EAA4E;IAC5E,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,KAAK,IAAI,CAAC;CAC3D;AAED;;;;;;;GAOG;AACH,qBAAa,IAAI,CAAC,CAAC,GAAG,OAAO;IAQf,OAAO,CAAC,QAAQ,CAAC,OAAO;IAPpC,QAAQ,CAAC,OAAO,6BAAoC;IACpD,IAAI,SAAK;IACT,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAkC;IACxD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAEJ,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC;IAMpD,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;IAqBxC,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAKvB;;;;OAIG;IACH,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO;IAkCpE,wCAAwC;IACxC,IAAI,IAAI,IAAI;IAeZ,uFAAuF;IACvF,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI;CA2BvD"}

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

@@ -0,0 +1,74 @@
+import type { Room } from './Room.js';
+import type { ServerMessage } from './protocol.js';
+/** The least a server socket must do; a `ws` WebSocket, a uWebSockets one or a test double all fit. */
+export interface HostSocket {
+    send(data: string | Uint8Array): void;
+    close(code?: number, reason?: string): void;
+}
+export interface RoomHostOptions<D> {
+    /** Simulation steps a second (default 60) and snapshots a second (default 20). */
+    stepRate?: number;
+    snapRate?: number;
+    /** Turns a hello's data into the player's data (validate it here); throw to refuse the player. */
+    admit?: (data: unknown, id: number) => D;
+    /** Refused inputs before the player is disconnected (default 20). */
+    maxStrikes?: number;
+    /** The game's own messages (anything the engine does not handle). */
+    onMessage?: (id: number, msg: {
+        t: string;
+        [k: string]: unknown;
+    }) => void;
+    /** Called when a player joins or leaves. */
+    onJoin?: (id: number) => void;
+    onLeave?: (id: number) => void;
+    /** Wall clock, for tests (default Date.now). */
+    now?: () => number;
+}
+/**
+ * Runs a `Room` for connected sockets: a socket says hello and joins, its input goes to the room, the room steps at
+ * `stepRate`, and every player gets its own snapshot at `snapRate` (binary when it carries bodies). Pings are
+ * answered with the server's time. A player who keeps sending nonsense is disconnected.
+ *
+ * ```ts
+ * const host = new RoomHost(room);
+ * wss.on('connection', (ws) => {
+ *   const id = host.connect(ws);
+ *   ws.on('message', (data, binary) => host.message(id, binary ? data : data.toString()));
+ *   ws.on('close', () => host.disconnect(id));
+ * });
+ * host.start();
+ * ```
+ */
+export declare class RoomHost<D = unknown> {
+    readonly room: Room<D>;
+    private readonly options;
+    private readonly sockets;
+    private readonly joined;
+    private nextId;
+    private stepTimer;
+    private lastStepAt;
+    private stepsDue;
+    private readonly stepMs;
+    private readonly snapEvery;
+    private readonly now;
+    constructor(room: Room<D>, options?: RoomHostOptions<D>);
+    /** A socket connected; returns the id its messages and its close are reported under. */
+    connect(socket: HostSocket): number;
+    /** A message arrived from socket `id` (text as a string, binary as bytes). */
+    message(id: number, data: string | ArrayBuffer | Uint8Array): void;
+    /** Socket `id` closed. */
+    disconnect(id: number): void;
+    /** Sends one of the game's own messages to a player. */
+    sendTo(id: number, msg: ServerMessage | {
+        t: string;
+        [k: string]: unknown;
+    }): void;
+    /** Starts stepping on a timer. Steps are counted by the clock, so a late timer runs the steps it owes. */
+    start(): void;
+    stop(): void;
+    /** One step, and the snapshots when they are due. Exposed for tests and for servers that drive their own loop. */
+    stepOnce(): void;
+    private strike;
+    private checkStrikes;
+}
+//# sourceMappingURL=RoomHost.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RoomHost.d.ts","sourceRoot":"","sources":["../../../src/net/RoomHost.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAiB,aAAa,EAAY,MAAM,YAAY,CAAC;AAEzE,uGAAuG;AACvG,MAAM,WAAW,UAAU;IACzB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAAC;IACtC,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7C;AAED,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC,kFAAkF;IAClF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kGAAkG;IAClG,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,KAAK,CAAC,CAAC;IACzC,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,qEAAqE;IACrE,SAAS,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;IAC3E,4CAA4C;IAC5C,MAAM,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9B,OAAO,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,gDAAgD;IAChD,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,QAAQ,CAAC,CAAC,GAAG,OAAO;IAY7B,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAZ1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiC;IACzD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAC5C,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,SAAS,CAA+C;IAChE,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;gBAGxB,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EACL,OAAO,GAAE,eAAe,CAAC,CAAC,CAAM;IAOnD,wFAAwF;IACxF,OAAO,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM;IAMnC,8EAA8E;IAC9E,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,UAAU,GAAG,IAAI;IAyClE,0BAA0B;IAC1B,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAQ5B,wDAAwD;IACxD,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa,GAAG;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,GAAG,IAAI;IAOlF,0GAA0G;IAC1G,KAAK,IAAI,IAAI;IAgBb,IAAI,IAAI,IAAI;IAKZ,kHAAkH;IAClH,QAAQ,IAAI,IAAI;IAUhB,OAAO,CAAC,MAAM;IAQd,OAAO,CAAC,YAAY;CAOrB"}

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

@@ -0,0 +1,22 @@
+/**
+ * Every repeated player action with a timer — the basic attack, a skill's cooldown, the cast and attack locks, a
+ * potion — runs on a **schedule**, not on "the last time plus some slack". An action may arrive up to its slack
+ * early (network jitter bunches packets), but the next one is then due a whole interval after the later of the
+ * arrival and the time this one was due, so the slack never adds up: a client sending every 0.8 of an interval
+ * lands at most one per interval (67 in 100), not 100. A server must run the same arithmetic.
+ */
+export declare const CADENCE: {
+    /** A basic attack may arrive this share of its interval early. */
+    readonly attackEarlyShare: 0.2;
+    /** The cast lock and the attack lock a cast leaves may be cut this short. */
+    readonly lockSlackMs: 60;
+    /** A skill may be cast this long before its cooldown ends. */
+    readonly cooldownSlackMs: 40;
+    /** A potion may be drunk this long before its kind's cooldown ends. */
+    readonly potionSlackMs: 150;
+};
+/** Whether an action arriving at `now` is earlier than its slack allows; `due` undefined = never taken, due at once. */
+export declare function cadenceEarly(now: number, due: number | undefined, slack: number): boolean;
+/** When the action after one accepted at `now` is due: a whole interval after the later of `now` and `due`. */
+export declare function cadenceNext(now: number, due: number | undefined, interval: number): number;
+//# sourceMappingURL=cadence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cadence.d.ts","sourceRoot":"","sources":["../../../src/net/cadence.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,OAAO;IAClB,kEAAkE;;IAElE,6EAA6E;;IAE7E,8DAA8D;;IAE9D,uEAAuE;;CAE/D,CAAC;AAEX,wHAAwH;AACxH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAEzF;AAED,+GAA+G;AAC/G,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE1F"}

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

@@ -0,0 +1,24 @@
+/** World and movement constants. A game that needs other numbers forks these; client and server must agree. */
+export declare const TILE_SIZE = 16;
+/** Fixed input steps a second; movement is simulated per step on both sides. */
+export declare const INPUT_STEP_RATE = 60;
+export declare const INPUT_STEP_DT: number;
+/** Bit of an input step's flags that asks for a dodge roll. */
+export declare const INPUT_FLAG_DASH = 1;
+/** The body's collision box, half extents (px). */
+export declare const BODY_HALF_WIDTH = 5;
+export declare const BODY_HALF_HEIGHT = 3;
+export declare const COLLISION_EPSILON = 0.01;
+/** One fixed input step: [axisX, axisY, flags]. */
+export type InputStep = [number, number, number];
+export interface MovementParams {
+    speed: number;
+    dashSpeed: number;
+    dashSteps: number;
+    dashCooldownSteps: number;
+    canMove: boolean;
+    canDash: boolean;
+}
+/** One body's state in a snapshot: [id, x, y, aim, anim, hp, flags]. */
+export type EntityUpdate = [number, number, number, number, number, number, number];
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/net/constants.ts"],"names":[],"mappings":"AAAA,+GAA+G;AAE/G,eAAO,MAAM,SAAS,KAAK,CAAC;AAE5B,gFAAgF;AAChF,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,eAAO,MAAM,aAAa,QAAsB,CAAC;AAEjD,+DAA+D;AAC/D,eAAO,MAAM,eAAe,IAAI,CAAC;AAEjC,mDAAmD;AACnD,eAAO,MAAM,eAAe,IAAI,CAAC;AACjC,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAClC,eAAO,MAAM,iBAAiB,OAAO,CAAC;AAEtC,mDAAmD;AACnD,MAAM,MAAM,SAAS,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAEjD,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,wEAAwE;AACxE,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC"}

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

@@ -0,0 +1,50 @@
+import { type InputStep, type MovementParams } from './constants.js';
+/** 1/sqrt(2), written as a literal so every port uses the exact same double. */
+export declare const DIAGONAL = 0.7071067811865476;
+export interface CollisionGrid {
+    readonly width: number;
+    readonly height: number;
+    readonly tileSize: number;
+    /** 1 = solid, row-major. */
+    readonly solid: Uint8Array;
+    /** 1 = a solid tile a shot flies over (`shotOverTiles`), row-major; absent when the ground was not given. */
+    readonly shotOver?: Uint8Array;
+    /** Half the moving body's collision box, px. */
+    readonly bodyHalfWidth: number;
+    readonly bodyHalfHeight: number;
+}
+export interface CollisionGridOptions {
+    /** The tile id of every cell, row-major; needed only for `shotOverTiles`. */
+    ground?: readonly number[];
+    /** Tile ids nothing walks but a shot flies over (water, lava…): solid for bodies, open for shots. */
+    shotOverTiles?: Iterable<number>;
+    /** Half the moving body's collision box, px (default `BODY_HALF_WIDTH` × `BODY_HALF_HEIGHT`, a 10×6 foot box). */
+    bodyHalfWidth?: number;
+    bodyHalfHeight?: number;
+}
+export interface MoverState {
+    x: number;
+    y: number;
+    /** Last non-zero movement direction (normalized), used for dashing while idle. */
+    lastDx: number;
+    lastDy: number;
+    dashLeft: number;
+    dashCd: number;
+    dashDx: number;
+    dashDy: number;
+}
+/** A grid from a string of '0'/'1' per cell (row-major, '1' solid). */
+export declare function createCollisionGrid(width: number, height: number, tileSize: number, solid: string, options?: CollisionGridOptions): CollisionGrid;
+/** Whether a shot in flight stops on this tile: solid, and not ground a shot flies over (`shotOverTiles`). */
+export declare function blocksShot(grid: CollisionGrid, tx: number, ty: number): boolean;
+export declare function createMover(x: number, y: number): MoverState;
+export declare function isSolidTile(grid: CollisionGrid, tx: number, ty: number): boolean;
+/** True if the body box centered at (x, y) overlaps a solid tile. */
+export declare function bodyCollides(grid: CollisionGrid, x: number, y: number): boolean;
+/** Moves along X by dx, stopping flush against the first solid tile column. */
+export declare function moveX(grid: CollisionGrid, x: number, y: number, dx: number): number;
+/** Moves along Y by dy, stopping flush against the first solid tile row. */
+export declare function moveY(grid: CollisionGrid, x: number, y: number, dy: number): number;
+/** Advances the mover by one fixed input step. Mutates `s`. */
+export declare function stepMover(s: MoverState, step: InputStep, p: MovementParams, grid: CollisionGrid): void;
+//# sourceMappingURL=movement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"movement.d.ts","sourceRoot":"","sources":["../../../src/net/movement.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,SAAS,EACd,KAAK,cAAc,EACpB,MAAM,aAAa,CAAC;AAUrB,gFAAgF;AAChF,eAAO,MAAM,QAAQ,qBAAqB,CAAC;AAE3C,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,4BAA4B;IAC5B,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,6GAA6G;IAC7G,QAAQ,CAAC,QAAQ,CAAC,EAAE,UAAU,CAAC;IAC/B,gDAAgD;IAChD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,oBAAoB;IACnC,6EAA6E;IAC7E,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,qGAAqG;IACrG,aAAa,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IACjC,kHAAkH;IAClH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,UAAU;IACzB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,kFAAkF;IAClF,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,uEAAuE;AACvE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,oBAAyB,GAAG,aAAa,CAgBrJ;AAED,8GAA8G;AAC9G,wBAAgB,UAAU,CAAC,IAAI,EAAE,aAAa,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAG/E;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,CAE5D;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,aAAa,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAGhF;AAED,qEAAqE;AACrE,wBAAgB,YAAY,CAAC,IAAI,EAAE,aAAa,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAY/E;AAED,+EAA+E;AAC/E,wBAAgB,KAAK,CAAC,IAAI,EAAE,aAAa,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAkBnF;AAED,4EAA4E;AAC5E,wBAAgB,KAAK,CAAC,IAAI,EAAE,aAAa,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAkBnF;AAMD,+DAA+D;AAC/D,wBAAgB,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,EAAE,cAAc,EAAE,IAAI,EAAE,aAAa,GAAG,IAAI,CAoCtG"}

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

@@ -0,0 +1,59 @@
+import type { EntityUpdate, InputStep } from './constants.js';
+import type { MoverState } from './movement.js';
+/** Client → server. */
+export type ClientMessage = 
+/** Asks to join; `data` is the game's own (a name, a character). */
+{
+    t: 'hello';
+    data?: unknown;
+}
+/** Input steps `seq`, `seq + 1`, … taken since the last send. */
+ | {
+    t: 'input';
+    seq: number;
+    steps: InputStep[];
+}
+/** A ping carrying the client's own clock, answered by a pong. */
+ | {
+    t: 'ping';
+    c: number;
+};
+/** Server → client. */
+export type ServerMessage = {
+    t: 'welcome';
+    id: number;
+    tick: number;
+    stepRate: number;
+    snapRate: number;
+} | {
+    t: 'pong';
+    c: number;
+    st: number;
+} | Snapshot;
+/** A body's whole mover, so a client can rewind to it exactly: x, y, lastDx, lastDy, dashLeft, dashCd, dashDx, dashDy. */
+export type MoverWire = [number, number, number, number, number, number, number, number];
+/** A body coming into view: its id and the game's own description of it (what it looks like). */
+export interface SpawnInfo {
+    id: number;
+    data?: unknown;
+}
+export interface Snapshot {
+    t: 'snap';
+    /** The server's step count when it was taken. */
+    tick: number;
+    /** The server's wall time when it was taken (ms since the epoch), for interpolation. */
+    time: number;
+    /** The last input step of this client the server has applied (-1 before any). */
+    ack: number;
+    /** This client's own body, whole, as of `ack`. */
+    me?: MoverWire;
+    /** Bodies that came into view. */
+    sp?: SpawnInfo[];
+    /** Bodies that left view. */
+    rm?: number[];
+    /** Every body in view: [id, x, y, aim, anim, hp, flags]. */
+    up?: EntityUpdate[];
+}
+export declare function moverToWire(m: MoverState): MoverWire;
+export declare function moverFromWire(w: MoverWire, into: MoverState): MoverState;
+//# sourceMappingURL=protocol.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../../src/net/protocol.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAQ7C,uBAAuB;AACvB,MAAM,MAAM,aAAa;AACvB,oEAAoE;AAClE;IAAE,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE;AAChC,iEAAiE;GAC/D;IAAE,CAAC,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,EAAE,CAAA;CAAE;AACjD,kEAAkE;GAChE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7B,uBAAuB;AACvB,MAAM,MAAM,aAAa,GACrB;IAAE,CAAC,EAAE,SAAS,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC9E;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GACpC,QAAQ,CAAC;AAEb,0HAA0H;AAC1H,MAAM,MAAM,SAAS,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAEzF,iGAAiG;AACjG,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,QAAQ;IACvB,CAAC,EAAE,MAAM,CAAC;IACV,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,wFAAwF;IACxF,IAAI,EAAE,MAAM,CAAC;IACb,iFAAiF;IACjF,GAAG,EAAE,MAAM,CAAC;IACZ,kDAAkD;IAClD,EAAE,CAAC,EAAE,SAAS,CAAC;IACf,kCAAkC;IAClC,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC;IACjB,6BAA6B;IAC7B,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC;IACd,4DAA4D;IAC5D,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC;CACrB;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,UAAU,GAAG,SAAS,CAEpD;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,GAAG,UAAU,CAGxE"}

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

@@ -0,0 +1,14 @@
+/** A sample whose round trip took longer than this says too little about when the server answered: it is passed over. */
+export declare const MAX_SAMPLE_RTT_MS = 2000;
+/** Server wall time now, in ms since the epoch. */
+export declare function serverNow(): number;
+/** The current estimate of server time minus this device's time, in ms. */
+export declare function serverOffset(): number;
+/**
+ * A server timestamp `serverMs` taken halfway through an exchange that took `rttMs` to come back: the server's clock
+ * then stood at `serverMs + rttMs / 2` of this device's now.
+ */
+export declare function noteServerTime(serverMs: number, rttMs: number, now?: number): void;
+/** Back to this device's own clock (offline, or leaving a server). */
+export declare function resetServerClock(): void;
+//# sourceMappingURL=serverClock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serverClock.d.ts","sourceRoot":"","sources":["../../../src/net/serverClock.ts"],"names":[],"mappings":"AAcA,yHAAyH;AACzH,eAAO,MAAM,iBAAiB,OAAO,CAAC;AAOtC,mDAAmD;AACnD,wBAAgB,SAAS,IAAI,MAAM,CAElC;AAED,2EAA2E;AAC3E,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,SAAa,GAAG,IAAI,CAOtF;AAED,sEAAsE;AACtE,wBAAgB,gBAAgB,IAAI,IAAI,CAKvC"}

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

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

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

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

package/dist/types/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/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"}