1681-engine 0.0.0-stage → 0.5.8

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

@@ -0,0 +1 @@
+{"version":3,"file":"Matchmaker.d.ts","sourceRoot":"","sources":["../../../../src/net/lobby/Matchmaker.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,iIAAiI;IACjI,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qFAAqF;AACrF,MAAM,WAAW,MAAM;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,wEAAwE;IACxE,MAAM,EAAE,MAAM,CAAC;IACf,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,mEAAmE;IACnE,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC;CACnB;AAED;;;;;;GAMG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgC;IACtD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;gBAEzC,KAAK,EAAE,SAAS,SAAS,EAAE;IAOvC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAIvC,6GAA6G;IAC7G,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAOzB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAMtC,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAInC,oDAAoD;IACpD,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE;IAI/B,oDAAoD;IACpD,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM;IAMxC,uEAAuE;IACvE,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,EAAE;IAqB/B,OAAO,CAAC,SAAS;CAWlB;AAwBD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,GAAG,IAAI,CAmBtG"}

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

@@ -0,0 +1,6 @@
+export { LobbyHost, type LobbyHostOptions, type LobbyMatch } from './LobbyHost.js';
+export { LobbyClient, type LobbyClientEvents, type LobbyLink, type PendingMatch } from './LobbyClient.js';
+export { LobbyRooms, type LobbyRoom } from './LobbyRooms.js';
+export { Matchmaker, balanceTeams, type MatchMode, type Ticket, type FoundMatch } from './Matchmaker.js';
+export type { LobbyClientMessage, LobbyServerMessage, LobbyErrorCode, RoomSummary, RoomState, RoomMember, MatchPlayer } from './lobbyProtocol.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/net/lobby/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAChF,OAAO,EAAE,WAAW,EAAE,KAAK,iBAAiB,EAAE,KAAK,SAAS,EAAE,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AACvG,OAAO,EAAE,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,KAAK,SAAS,EAAE,KAAK,MAAM,EAAE,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AACtG,YAAY,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,cAAc,EAAE,WAAW,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC"}

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

@@ -0,0 +1,143 @@
+/** A lobby room as everyone browsing sees it. */
+export interface RoomSummary {
+    id: string;
+    name: string;
+    mode: string;
+    players: number;
+    maxPlayers: number;
+    /** Joined only by its code. Private rooms are never listed; this is set on your own room's state. */
+    private: boolean;
+    /** The room is in the matchmaking queue or its game has started: nobody joins. */
+    busy: boolean;
+}
+export interface RoomMember {
+    id: number;
+    /** The game's own public data for the player (a name, a look), as `admit` returned it. */
+    data: unknown;
+    ready: boolean;
+}
+/** Your own room, whole. */
+export interface RoomState extends RoomSummary {
+    /** The code a friend joins a private room by. */
+    code: string;
+    host: number;
+    members: RoomMember[];
+    /** The game's own settings for it (a map, a difficulty); only the host changes them. */
+    settings: unknown;
+    /** In the matchmaking queue as one group. */
+    queued: boolean;
+}
+export interface MatchPlayer {
+    id: number;
+    data: unknown;
+    team: number;
+}
+/** Client → lobby. */
+export type LobbyClientMessage = {
+    t: 'lobby/list';
+} | {
+    t: 'lobby/create';
+    name?: string;
+    mode?: string;
+    maxPlayers?: number;
+    private?: boolean;
+    settings?: unknown;
+} | {
+    t: 'lobby/join';
+    room?: string;
+    code?: string;
+} | {
+    t: 'lobby/leave';
+} | {
+    t: 'lobby/ready';
+    ready: boolean;
+} | {
+    t: 'lobby/kick';
+    player: number;
+} | {
+    t: 'lobby/promote';
+    player: number;
+} | {
+    t: 'lobby/settings';
+    settings: unknown;
+} | {
+    t: 'lobby/chat';
+    text: string;
+}
+/** The host starts the room's own game (everyone ready), outside matchmaking. */
+ | {
+    t: 'lobby/start';
+}
+/** Queue alone, or the whole room when its host asks. */
+ | {
+    t: 'queue/join';
+    mode: string;
+} | {
+    t: 'queue/leave';
+} | {
+    t: 'match/accept';
+} | {
+    t: 'match/decline';
+};
+/** Why the lobby refused something. */
+export type LobbyErrorCode = 'bad-request' | 'no-room' | 'room-full' | 'room-busy' | 'not-host' | 'not-ready' | 'in-room' | 'not-in-room' | 'no-mode' | 'too-many' | 'queued' | 'locked' | 'rate';
+/** Lobby → client. */
+export type LobbyServerMessage = {
+    t: 'lobby/welcome';
+    id: number;
+    modes: string[];
+} | {
+    t: 'lobby/rooms';
+    rooms: RoomSummary[];
+}
+/** Your room changed (null: you are in none). */
+ | {
+    t: 'lobby/room';
+    room: RoomState | null;
+} | {
+    t: 'lobby/chat';
+    from: number;
+    text: string;
+} | {
+    t: 'lobby/kicked';
+} | {
+    t: 'lobby/error';
+    code: LobbyErrorCode;
+    message: string;
+}
+/** In the queue since `since` (server ms), `waiting` other groups queued for that mode; `until` set while locked out. */
+ | {
+    t: 'queue/status';
+    mode: string | null;
+    since: number;
+    waiting: number;
+} | {
+    t: 'queue/locked';
+    until: number;
+} | {
+    t: 'match/found';
+    match: string;
+    mode: string;
+    players: MatchPlayer[];
+    expiresAt: number;
+} | {
+    t: 'match/accepted';
+    match: string;
+    accepted: number[];
+}
+/** The ready check failed; `requeued` when you were put back in the queue at your old place. */
+ | {
+    t: 'match/cancelled';
+    match: string;
+    reason: 'declined' | 'timeout' | 'left';
+    requeued: boolean;
+}
+/** Everyone accepted (or the host started the room): go play. `data` is what the game's `onStart` returned for you. */
+ | {
+    t: 'match/start';
+    match: string;
+    mode: string;
+    players: MatchPlayer[];
+    data: unknown;
+};
+//# sourceMappingURL=lobbyProtocol.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lobbyProtocol.d.ts","sourceRoot":"","sources":["../../../../src/net/lobby/lobbyProtocol.ts"],"names":[],"mappings":"AAKA,iDAAiD;AACjD,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,qGAAqG;IACrG,OAAO,EAAE,OAAO,CAAC;IACjB,kFAAkF;IAClF,IAAI,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,0FAA0F;IAC1F,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,4BAA4B;AAC5B,MAAM,WAAW,SAAU,SAAQ,WAAW;IAC5C,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,wFAAwF;IACxF,QAAQ,EAAE,OAAO,CAAC;IAClB,6CAA6C;IAC7C,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd;AAED,sBAAsB;AACtB,MAAM,MAAM,kBAAkB,GAC1B;IAAE,CAAC,EAAE,YAAY,CAAA;CAAE,GACnB;IAAE,CAAC,EAAE,cAAc,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,GAC/G;IAAE,CAAC,EAAE,YAAY,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GACjD;IAAE,CAAC,EAAE,aAAa,CAAA;CAAE,GACpB;IAAE,CAAC,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GACpC;IAAE,CAAC,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACnC;IAAE,CAAC,EAAE,eAAe,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACtC;IAAE,CAAC,EAAE,gBAAgB,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,GAC1C;IAAE,CAAC,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE;AACnC,iFAAiF;GAC/E;IAAE,CAAC,EAAE,aAAa,CAAA;CAAE;AACtB,yDAAyD;GACvD;IAAE,CAAC,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACjC;IAAE,CAAC,EAAE,aAAa,CAAA;CAAE,GACpB;IAAE,CAAC,EAAE,cAAc,CAAA;CAAE,GACrB;IAAE,CAAC,EAAE,eAAe,CAAA;CAAE,CAAC;AAE3B,uCAAuC;AACvC,MAAM,MAAM,cAAc,GACtB,aAAa,GACb,SAAS,GACT,WAAW,GACX,WAAW,GACX,UAAU,GACV,WAAW,GACX,SAAS,GACT,aAAa,GACb,SAAS,GACT,UAAU,GACV,QAAQ,GACR,QAAQ,GACR,MAAM,CAAC;AAEX,sBAAsB;AACtB,MAAM,MAAM,kBAAkB,GAC1B;IAAE,CAAC,EAAE,eAAe,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GACnD;IAAE,CAAC,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,WAAW,EAAE,CAAA;CAAE;AAC5C,iDAAiD;GAC/C;IAAE,CAAC,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,SAAS,GAAG,IAAI,CAAA;CAAE,GAC3C;IAAE,CAAC,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC/C;IAAE,CAAC,EAAE,cAAc,CAAA;CAAE,GACrB;IAAE,CAAC,EAAE,aAAa,CAAC;IAAC,IAAI,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE;AAC7D,yHAAyH;GACvH;IAAE,CAAC,EAAE,cAAc,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC1E;IAAE,CAAC,EAAE,cAAc,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,CAAC,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,WAAW,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAC5F;IAAE,CAAC,EAAE,gBAAgB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE;AAC5D,gGAAgG;GAC9F;IAAE,CAAC,EAAE,iBAAiB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE;AACrG,uHAAuH;GACrH;IAAE,CAAC,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,WAAW,EAAE,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,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/parallax/Parallax.d.ts

@@ -0,0 +1,37 @@
+import { Container } from 'pixi.js';
+import { ParallaxLayer, type ParallaxCamera, type ParallaxLayerOptions } from './ParallaxLayer.js';
+export interface ParallaxOptions {
+    /**
+     * Where the whole parallax sorts among the world layer's children (its `zIndex`, default -1000): below the level,
+     * so every layer stays behind it. A foreground layer (factor above 1) belongs in a second `Parallax` with a depth
+     * above the level's.
+     */
+    depth?: number;
+}
+/**
+ * Layers of scenery behind (or before) the world, each scrolling at its own share of the camera's speed. Add `view`
+ * to the world layer — a scene's `root` — and call `update(camera, dtMs)` once a frame after the camera moved, so
+ * the layers sit where this frame's view is:
+ *
+ * ```ts
+ * const sky = new Parallax();
+ * sky.add({ texture: clouds, factorX: 0.1, repeatX: true, speedX: -6 });
+ * sky.add({ display: hills, factorX: 0.5, factorY: 1 });
+ * this.root.addChild(sky.view);
+ * // each frame
+ * sky.update(stage.cameras.main, dt * 1000);
+ * ```
+ */
+export declare class Parallax {
+    readonly view: Container<import("pixi.js").ContainerChild>;
+    private readonly list;
+    constructor(options?: ParallaxOptions);
+    get layers(): readonly ParallaxLayer[];
+    /** Adds a layer (built here from options, or one made before); later layers draw in front unless a `depth` says. */
+    add(layer: ParallaxLayer | ParallaxLayerOptions): ParallaxLayer;
+    /** Takes a layer out and destroys it. */
+    remove(layer: ParallaxLayer): void;
+    update(camera: ParallaxCamera, dtMs: number): void;
+    destroy(): void;
+}
+//# sourceMappingURL=Parallax.d.ts.map

package/dist/types/parallax/Parallax.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Parallax.d.ts","sourceRoot":"","sources":["../../../src/parallax/Parallax.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,KAAK,cAAc,EAAE,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEhG,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,QAAQ;IACnB,QAAQ,CAAC,IAAI,8CAA6C;IAC1D,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAuB;gBAEhC,OAAO,GAAE,eAAoB;IAIzC,IAAI,MAAM,IAAI,SAAS,aAAa,EAAE,CAErC;IAED,oHAAoH;IACpH,GAAG,CAAC,KAAK,EAAE,aAAa,GAAG,oBAAoB,GAAG,aAAa;IAQ/D,yCAAyC;IACzC,MAAM,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAOlC,MAAM,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAIlD,OAAO,IAAI,IAAI;CAIhB"}

package/dist/types/parallax/ParallaxLayer.d.ts

@@ -0,0 +1,80 @@
+import { Container, type Texture } from 'pixi.js';
+/** What a parallax layer reads off the camera each frame; the engine's `Camera` has all of it. */
+export interface ParallaxCamera {
+    readonly scrollX: number;
+    readonly scrollY: number;
+    readonly width: number;
+    readonly height: number;
+    readonly zoom: number;
+    /** Set on a pixel-perfect engine: a layer then lands on whole world pixels unless told otherwise. */
+    readonly roundPixels?: boolean;
+}
+export interface ParallaxLayerOptions {
+    /**
+     * A texture to draw, repeated along the axes `repeatX` / `repeatY` name (one tiling sprite, as wide as the view
+     * whatever the level's length). Give either this or `display`.
+     */
+    texture?: Texture;
+    /** Anything already drawn (a sprite, a `Graphics`, a container of them), drawn once and never repeated. */
+    display?: Container;
+    /** Share of the camera's horizontal travel the layer moves on screen: 0 fixed to the screen, 1 with the world (default 0.5). */
+    factorX?: number;
+    /** The same vertically (default: `factorX`). */
+    factorY?: number;
+    /** Repeat the texture left and right forever (a `texture` layer only). */
+    repeatX?: boolean;
+    /** Repeat the texture up and down forever (a `texture` layer only). */
+    repeatY?: boolean;
+    /** World px added to the layer's position, e.g. where on the level a row of hills stands. */
+    offsetX?: number;
+    offsetY?: number;
+    /** Drift, world px a second, on top of the parallax (clouds). */
+    speedX?: number;
+    speedY?: number;
+    /** Land on whole world pixels (default: the camera's `roundPixels`, i.e. a pixel-perfect engine). */
+    snap?: boolean;
+    /** Hide the layer while none of it is in view (default true). Repeated layers always fill the view. */
+    cull?: boolean;
+    /** Order among the parallax's layers: lower draws further back (default: the order they were added in). */
+    depth?: number;
+}
+/**
+ * One layer of a `Parallax`: a texture or a display object that scrolls at a share of the camera's speed, optionally
+ * repeated and drifting. `view` goes into the world layer (the parallax adds it), so the camera's zoom and pixel
+ * rounding apply to it like to any world object; the layer only moves it.
+ */
+export declare class ParallaxLayer {
+    readonly view: Container<import("pixi.js").ContainerChild>;
+    factorX: number;
+    factorY: number;
+    offsetX: number;
+    offsetY: number;
+    speedX: number;
+    speedY: number;
+    snap: boolean | undefined;
+    cull: boolean;
+    /** The depth it was given, if any (a `Parallax` numbers the others in the order they were added). */
+    readonly depth: number | undefined;
+    private readonly repeatX;
+    private readonly repeatY;
+    private readonly tiling;
+    private readonly tileW;
+    private readonly tileH;
+    /** The content's local bounds, measured once: reading bounds every frame walks the whole display tree. */
+    private boundsX;
+    private boundsY;
+    private boundsW;
+    private boundsH;
+    private driftX;
+    private driftY;
+    private readonly input;
+    private readonly px;
+    private readonly py;
+    constructor(options: ParallaxLayerOptions);
+    /** Measures the content again, after it was redrawn larger or smaller (culling reads the measured size). */
+    remeasure(): void;
+    /** Places the layer for this frame; `dtMs` advances the drift. */
+    update(camera: ParallaxCamera, dtMs: number): void;
+    destroy(): void;
+}
+//# sourceMappingURL=ParallaxLayer.d.ts.map

package/dist/types/parallax/ParallaxLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParallaxLayer.d.ts","sourceRoot":"","sources":["../../../src/parallax/ParallaxLayer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAwB,KAAK,OAAO,EAAE,MAAM,SAAS,CAAC;AAGxE,kGAAkG;AAClG,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,qGAAqG;IACrG,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,2GAA2G;IAC3G,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,gIAAgI;IAChI,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gDAAgD;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0EAA0E;IAC1E,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,uEAAuE;IACvE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,6FAA6F;IAC7F,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iEAAiE;IACjE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qGAAqG;IACrG,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,uGAAuG;IACvG,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,2GAA2G;IAC3G,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,qBAAa,aAAa;IACxB,QAAQ,CAAC,IAAI,8CAAmB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC;IAC1B,IAAI,EAAE,OAAO,CAAC;IACd,qGAAqG;IACrG,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;IACpD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,0GAA0G;IAC1G,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,MAAM,CAAK;IAEnB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiI;IACvJ,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAoE;IACvF,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAoE;gBAE3E,OAAO,EAAE,oBAAoB;IA0BzC,4GAA4G;IAC5G,SAAS,IAAI,IAAI;IAejB,kEAAkE;IAClE,MAAM,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IA2ClD,OAAO,IAAI,IAAI;CAGhB"}

package/dist/types/parallax/parallaxMath.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The arithmetic of parallax, apart from anything that draws so it can be tested under node. One axis at a time:
+ * the same functions serve x and y.
+ */
+/**
+ * The world position a layer is drawn at so that, on screen, it moves `factor` times as far as the camera: 0 stays
+ * fixed to the screen (a sky at infinity), 1 moves with the world, 0.5 at half speed, above 1 faster (a foreground).
+ * The layer lives in the world layer, so the camera's zoom scales it like everything else.
+ */
+export declare function parallaxOrigin(scroll: number, factor: number, offset?: number): number;
+/** `value` brought into [0, size): where a repeating pattern stands within one tile. 0 for an empty tile. */
+export declare function wrap(value: number, size: number): number;
+/** Whether a span [start, start + size) overlaps the view [viewStart, viewStart + viewSize), `margin` px wider. */
+export declare function spanVisible(start: number, size: number, viewStart: number, viewSize: number, margin?: number): boolean;
+/** Where one axis of a layer goes this frame; written into a caller's object so a frame allocates nothing. */
+export interface AxisPlacement {
+    /** The layer's world position on this axis. */
+    position: number;
+    /** For a repeated axis, how long the tiled strip is (it covers the view); otherwise the content's own size. */
+    size: number;
+    /** For a repeated axis, the pattern's offset inside the strip (a tiling sprite's tile position), in [0, tile). */
+    phase: number;
+    /** For an axis that does not repeat, whether the content reaches into the view at all. */
+    visible: boolean;
+}
+export interface AxisInput {
+    /** The camera's scroll on this axis (the world coordinate at the screen's edge). */
+    scroll: number;
+    /** How much of the world the view shows on this axis: the screen's size over the camera's zoom. */
+    view: number;
+    factor: number;
+    /** Fixed offset plus whatever auto-scroll has added. */
+    offset: number;
+    repeat: boolean;
+    /** One tile's size on this axis (repeated axes). */
+    tile: number;
+    /** Where the content's bounds begin from the layer's position, and how long they are (axes that do not repeat). */
+    contentStart: number;
+    contentSize: number;
+    /** Land on whole world pixels. */
+    snap: boolean;
+}
+/**
+ * Places one axis. A repeated axis is a strip laid over the view, starting at the view's edge (floored to a whole
+ * pixel when snapping), whose pattern is shifted so its tiles stand where the parallax puts them: the strip never
+ * grows with the level, however long it is. An axis that does not repeat sits at its parallax origin and is visible
+ * only while its content overlaps the view.
+ */
+export declare function placeAxis(out: AxisPlacement, a: AxisInput): AxisPlacement;
+//# sourceMappingURL=parallaxMath.d.ts.map

package/dist/types/parallax/parallaxMath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallaxMath.d.ts","sourceRoot":"","sources":["../../../src/parallax/parallaxMath.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,SAAI,GAAG,MAAM,CAEjF;AAED,6GAA6G;AAC7G,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAKxD;AAED,mHAAmH;AACnH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,SAAI,GAAG,OAAO,CAEjH;AAED,8GAA8G;AAC9G,MAAM,WAAW,aAAa;IAC5B,+CAA+C;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,+GAA+G;IAC/G,IAAI,EAAE,MAAM,CAAC;IACb,kHAAkH;IAClH,KAAK,EAAE,MAAM,CAAC;IACd,0FAA0F;IAC1F,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,SAAS;IACxB,oFAAoF;IACpF,MAAM,EAAE,MAAM,CAAC;IACf,mGAAmG;IACnG,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;IAChB,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,mHAAmH;IACnH,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,kCAAkC;IAClC,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,aAAa,EAAE,CAAC,EAAE,SAAS,GAAG,aAAa,CAiBzE"}