1681-engine 0.0.0-stage → 0.5.8

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/lobby/LobbyClient.d.ts

@@ -0,0 +1,107 @@
+import { EventBus } from '../../events/EventBus.js';
+import type { LobbyClientMessage, LobbyErrorCode, MatchPlayer, RoomState, RoomSummary } from './lobbyProtocol.js';
+/** What a `LobbyClient` sends through and hears from: a `Connection` fits. */
+export interface LobbyLink {
+    send(msg: {
+        t: string;
+        [k: string]: unknown;
+    }): void;
+    readonly events: {
+        on(event: 'message', fn: (msg: {
+            t: string;
+            [k: string]: unknown;
+        }) => void): () => void;
+    };
+}
+export interface PendingMatch {
+    id: string;
+    mode: string;
+    players: MatchPlayer[];
+    expiresAt: number;
+    accepted: number[];
+    /** You answered already. */
+    answered: boolean;
+}
+export interface LobbyClientEvents {
+    /** Anything in the client's state changed: redraw the lobby screen. */
+    change: undefined;
+    chat: {
+        from: number;
+        text: string;
+    };
+    error: {
+        code: LobbyErrorCode;
+        message: string;
+    };
+    kicked: undefined;
+    found: PendingMatch;
+    cancelled: {
+        match: string;
+        reason: 'declined' | 'timeout' | 'left';
+        requeued: boolean;
+    };
+    /** Go and play: `data` is what the server's `onStart` gave you. */
+    start: {
+        match: string;
+        mode: string;
+        players: MatchPlayer[];
+        data: unknown;
+    };
+}
+/**
+ * The lobby as a client sees it: the room list, your room, your place in the queue and a match waiting for your
+ * answer, kept up to date from the server's messages, with a method for everything a lobby screen does. Hand it the
+ * game's `Connection` (or anything that sends JSON and emits the messages it does not handle):
+ *
+ * ```ts
+ * const conn = new Connection('wss://lobby.example.com', { hello: () => ({ name }) }).connect();
+ * const lobby = new LobbyClient(conn);
+ * lobby.events.on('change', () => drawLobby(lobby));
+ * lobby.events.on('start', ({ data }) => joinGame(data));
+ * lobby.queue('duel');
+ * ```
+ */
+export declare class LobbyClient {
+    private readonly link;
+    readonly events: EventBus<LobbyClientEvents>;
+    /** Your id in the lobby (-1 until welcomed). */
+    id: number;
+    modes: string[];
+    rooms: RoomSummary[];
+    room: RoomState | null;
+    /** Your queue: the mode, since when (server ms) and how many other groups wait for it. */
+    queued: {
+        mode: string;
+        since: number;
+        waiting: number;
+    } | null;
+    /** Kept out of the queue until then (server ms), after a declined match. */
+    lockedUntil: number;
+    match: PendingMatch | null;
+    private readonly off;
+    constructor(link: LobbyLink);
+    get isHost(): boolean;
+    /** Every member of your room but the host has said ready. */
+    get roomReady(): boolean;
+    list(): void;
+    create(options?: Omit<Extract<LobbyClientMessage, {
+        t: 'lobby/create';
+    }>, 't'>): void;
+    join(room: string): void;
+    joinByCode(code: string): void;
+    leave(): void;
+    setReady(ready: boolean): void;
+    kick(player: number): void;
+    promote(player: number): void;
+    setSettings(settings: unknown): void;
+    chat(text: string): void;
+    startRoom(): void;
+    queue(mode: string): void;
+    leaveQueue(): void;
+    accept(): void;
+    decline(): void;
+    destroy(): void;
+    private send;
+    private receive;
+}
+//# sourceMappingURL=LobbyClient.d.ts.map

package/dist/types/net/lobby/LobbyClient.d.ts.map

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

package/dist/types/net/lobby/LobbyHost.d.ts

@@ -0,0 +1,147 @@
+import type { HostSocket } from '../RoomHost.js';
+import { LobbyRooms } from './LobbyRooms.js';
+import type { LobbyServerMessage, MatchPlayer } from './lobbyProtocol.js';
+import { Matchmaker, type MatchMode } from './Matchmaker.js';
+/** A match the lobby made (from the queue or a room's start), as `onStart` is given it. */
+export interface LobbyMatch<D> {
+    id: string;
+    mode: string;
+    players: (MatchPlayer & {
+        data: D;
+    })[];
+    /** The lobby room it was started from, for a room's own game. */
+    room?: string;
+    /** That room's settings. */
+    settings?: unknown;
+}
+export interface LobbyHostOptions<D> {
+    /** Modes the queue fills (none: rooms only). */
+    modes?: readonly MatchMode[];
+    /** Turns a hello's data into the player's public data (validate it here); throw to refuse the player. */
+    admit?: (data: unknown, id: number) => D;
+    /** A player's rating in a mode (default 1000 for everyone). A party queues at its members' mean. */
+    ratingOf?: (id: number, data: D, mode: string) => number;
+    /**
+     * Called when a match starts (everyone accepted, or a room's host started). Return what each player is told to go
+     * to — a game server's address and a ticket, a room id on this server — as one value for all, or a function of
+     * the player's id. Throw to cancel the start (everyone is told it was cancelled and requeued).
+     */
+    onStart?: (match: LobbyMatch<D>) => unknown;
+    /** Time to accept a found match (default 15 s); 0 starts it at once. */
+    readyCheckMs?: number;
+    /** How long one who declined or let the check lapse is kept out of the queue (default 30 s). */
+    declineLockMs?: number;
+    /** Most players a room may hold (default 8), and rooms listed at once (default 50). */
+    maxRoomPlayers?: number;
+    listLimit?: number;
+    /** Characters of a chat line (default 200) and of a room name (default 32). */
+    chatMax?: number;
+    nameMax?: number;
+    /** Messages a player may send a second before they are refused (default 20); three times it closes the socket. */
+    ratePerSecond?: number;
+    /** How often the queue is searched (default 1000 ms). */
+    matchEveryMs?: number;
+    /** The game's own messages (anything the lobby does not handle). */
+    onMessage?: (id: number, msg: {
+        t: string;
+        [k: string]: unknown;
+    }) => void;
+    onJoin?: (id: number) => void;
+    onLeave?: (id: number) => void;
+    /** Clock and dice, for tests. */
+    now?: () => number;
+    random?: () => number;
+}
+/**
+ * The front room of an online game, transport-free like `RoomHost`: players say hello and browse rooms; a room has a
+ * host, a code to share, ready flags, chat and the game's own settings; a player alone or a whole room queues for a
+ * mode, the `Matchmaker` finds matches by rating, and each match goes through a ready check before `onStart` turns it
+ * into a game. Someone who declines (or lets the check lapse) is locked out of the queue for a while; everyone else
+ * goes back to their old place in it.
+ *
+ * ```ts
+ * const lobby = new LobbyHost({
+ *   modes: [{ id: 'duel', teams: 2, teamSize: 1 }, { id: '2v2', teams: 2, teamSize: 2 }],
+ *   admit: (d) => ({ name: String((d as { name?: unknown })?.name ?? 'player').slice(0, 16) }),
+ *   ratingOf: (id) => ratings.get(id) ?? 1000,
+ *   onStart: (match) => ({ server: 'wss://eu1.example.com', ticket: issueTicket(match) }),
+ * });
+ * wss.on('connection', (ws) => {
+ *   const id = lobby.connect(ws);
+ *   ws.on('message', (data, binary) => lobby.message(id, binary ? '' : data.toString()));
+ *   ws.on('close', () => lobby.disconnect(id));
+ * });
+ * lobby.start();
+ * ```
+ */
+export declare class LobbyHost<D = unknown> {
+    private readonly options;
+    readonly rooms: LobbyRooms;
+    readonly matchmaker: Matchmaker;
+    private readonly sockets;
+    private readonly members;
+    private readonly pending;
+    /** Rooms whose match started, by match id, so `finish` can open them again. */
+    private readonly playing;
+    private nextId;
+    private nextMatch;
+    private listDirty;
+    private timer;
+    private readonly now;
+    constructor(options?: LobbyHostOptions<D>);
+    /** A socket connected; returns the id its messages and its close are reported under. */
+    connect(socket: HostSocket): number;
+    /** Socket `id` closed: out of its room, the queue and any match being accepted. */
+    disconnect(id: number): void;
+    /** A message arrived from socket `id`. */
+    message(id: number, data: string | ArrayBuffer | Uint8Array): void;
+    /** A player's public data (what `admit` returned). */
+    dataOf(id: number): D | undefined;
+    /** Sends one of the game's own messages to a player. */
+    send(id: number, msg: LobbyServerMessage | {
+        t: string;
+        [k: string]: unknown;
+    }): void;
+    /** Searches the queue and runs the ready checks on a timer. */
+    start(): void;
+    stop(): void;
+    /** One round: lapsed ready checks cancelled, the queue searched, the room list pushed if it changed. */
+    update(now?: number): void;
+    /** A started match is over: its rooms open again, their members not ready. */
+    finish(matchId: string): void;
+    private hello;
+    /** True when the lobby handled it (or refused it). */
+    private handle;
+    private create;
+    private join;
+    private ready;
+    private kick;
+    private promote;
+    /** The room `m` hosts, or an error to them. */
+    private hostRoom;
+    private startRoom;
+    private queue;
+    private ratingOf;
+    /** Takes `m` (or its whole room) out of the queue. */
+    private leaveQueue;
+    private dequeueRoom;
+    private pushQueue;
+    private found;
+    private answer;
+    private startFound;
+    /** Calls `onStart` and tells everyone where to go; false (nothing sent) when it threw. */
+    private begin;
+    /** A ready check failed: whoever did not accept is locked out, every group that did goes back to its place. */
+    private cancel;
+    /** Back into the queue at its old place (its old `since`). */
+    private requeue;
+    private cancelPendingFor;
+    private leaveRoom;
+    private pushRoom;
+    /** The list, to everyone browsing (in no room). */
+    private pushList;
+    private error;
+    /** A per-second allowance; three times over closes the socket. */
+    private allow;
+}
+//# sourceMappingURL=LobbyHost.d.ts.map

package/dist/types/net/lobby/LobbyHost.d.ts.map

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

package/dist/types/net/lobby/LobbyRooms.d.ts

@@ -0,0 +1,56 @@
+import type { RoomState, RoomSummary } from './lobbyProtocol.js';
+/** A lobby room on the server. */
+export interface LobbyRoom {
+    readonly id: string;
+    readonly code: string;
+    name: string;
+    mode: string;
+    maxPlayers: number;
+    private: boolean;
+    host: number;
+    /** In the order they came: the next host is the first left. */
+    readonly members: number[];
+    readonly ready: Set<number>;
+    settings: unknown;
+    /** In the matchmaking queue as one group. */
+    queued: boolean;
+    /** Its game is being played (or its match is being accepted): nobody joins until `LobbyHost.finish`. */
+    playing: boolean;
+}
+/**
+ * The rooms of a lobby and who is in which, with no sockets: create, join by id or code, leave (the host's place
+ * passing to the next member, an empty room closing), kick, ready. `LobbyHost` speaks for it.
+ */
+export declare class LobbyRooms {
+    private readonly random;
+    private readonly rooms;
+    private readonly byCode;
+    private readonly roomOf;
+    private nextId;
+    constructor(random?: () => number);
+    get count(): number;
+    get(id: string): LobbyRoom | undefined;
+    byInvite(code: string): LobbyRoom | undefined;
+    of(player: number): LobbyRoom | undefined;
+    all(): IterableIterator<LobbyRoom>;
+    create(host: number, o: {
+        name: string;
+        mode: string;
+        maxPlayers: number;
+        private: boolean;
+        settings: unknown;
+    }): LobbyRoom;
+    join(player: number, room: LobbyRoom): void;
+    /** Takes a player out of their room; returns the room (closed when it emptied, `closed` true). */
+    leave(player: number): {
+        room: LobbyRoom;
+        closed: boolean;
+    } | null;
+    /** Everyone but the host has said they are ready. */
+    allReady(room: LobbyRoom): boolean;
+    summary(room: LobbyRoom): RoomSummary;
+    state(room: LobbyRoom, dataOf: (id: number) => unknown): RoomState;
+    /** The rooms anyone may browse: public, open, not full; the fullest first, so players gather. */
+    listed(limit: number): RoomSummary[];
+}
+//# sourceMappingURL=LobbyRooms.d.ts.map

package/dist/types/net/lobby/LobbyRooms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LobbyRooms.d.ts","sourceRoot":"","sources":["../../../../src/net/lobby/LobbyRooms.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,SAAS,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE1E,kCAAkC;AAClC,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5B,QAAQ,EAAE,OAAO,CAAC;IAClB,6CAA6C;IAC7C,MAAM,EAAE,OAAO,CAAC;IAChB,wGAAwG;IACxG,OAAO,EAAE,OAAO,CAAC;CAClB;AAID;;;GAGG;AACH,qBAAa,UAAU;IAMT,OAAO,CAAC,QAAQ,CAAC,MAAM;IALnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgC;IACtD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgC;IACvD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgC;IACvD,OAAO,CAAC,MAAM,CAAK;gBAEU,MAAM,GAAE,MAAM,MAAoB;IAE/D,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAItC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAI7C,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAIzC,GAAG,IAAI,gBAAgB,CAAC,SAAS,CAAC;IAIlC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS;IAY3H,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,IAAI;IAM3C,kGAAkG;IAClG,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG;QAAE,IAAI,EAAE,SAAS,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI;IAoBlE,qDAAqD;IACrD,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO;IAIlC,OAAO,CAAC,IAAI,EAAE,SAAS,GAAG,WAAW;IAIrC,KAAK,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,GAAG,SAAS;IAKlE,iGAAiG;IACjG,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,EAAE;CAOrC"}

package/dist/types/net/lobby/Matchmaker.d.ts

@@ -0,0 +1,57 @@
+/** A mode the matchmaker fills: `teams` sides of `teamSize` players. */
+export interface MatchMode {
+    id: string;
+    teams: number;
+    teamSize: number;
+    /** Rating difference allowed at once (default 100), widened by `widenPerSecond` (default 10) up to `maxWindow` (default 600). */
+    window?: number;
+    widenPerSecond?: number;
+    maxWindow?: number;
+}
+/** One group waiting together: a player alone, or a party that must not be split. */
+export interface Ticket {
+    id: string;
+    mode: string;
+    members: readonly number[];
+    /** The group's rating (the game's own: Elo, a level, a power score). */
+    rating: number;
+    /** When it joined the queue (ms): the oldest waits least. */
+    since: number;
+}
+export interface FoundMatch {
+    mode: string;
+    tickets: Ticket[];
+    /** Each team's player ids, in the order the teams are numbered. */
+    teams: number[][];
+}
+/**
+ * The matchmaking queue, pure: tickets in, matches out, no clock of its own and no sockets. Each `find(now)` takes
+ * the oldest ticket of a mode as the anchor, gathers the groups within its rating window (and each within theirs,
+ * so a newcomer is not thrown in with veterans because a veteran waited), and fills the teams from the closest
+ * ratings first, never splitting a party; the teams are then balanced by rating. A window grows with the wait, so
+ * anyone is matched in the end; a ticket nothing fits waits for the next call.
+ */
+export declare class Matchmaker {
+    private readonly modes;
+    private readonly tickets;
+    constructor(modes: readonly MatchMode[]);
+    get size(): number;
+    mode(id: string): MatchMode | undefined;
+    /** Adds a ticket (replacing one of the same id); throws on an unknown mode or a group too big for a team. */
+    add(ticket: Ticket): void;
+    remove(id: string): Ticket | undefined;
+    get(id: string): Ticket | undefined;
+    /** The tickets waiting for a mode, oldest first. */
+    waiting(mode: string): Ticket[];
+    /** How far a ticket's rating window reaches now. */
+    windowOf(t: Ticket, now: number): number;
+    /** Every match that can be made now; their tickets leave the queue. */
+    find(now: number): FoundMatch[];
+    private tryAnchor;
+}
+/**
+ * Splits groups into `teams` of exactly `size` players, parties whole, ratings as even as it can: the largest groups
+ * first, each into the team with room whose rating total is lowest. Returns null when the sizes cannot be packed.
+ */
+export declare function balanceTeams(groups: readonly Ticket[], teams: number, size: number): number[][] | null;
+//# sourceMappingURL=Matchmaker.d.ts.map