@korial29/tiny-fps 0.0.0-stage → 0.2.0

package/dist/types/client/effects.d.ts

@@ -0,0 +1,37 @@
+import type { PlayerState, Shot } from '../shared/types';
+type Vec3 = [number, number, number];
+export interface Spark {
+    p: Vec3;
+    v: Vec3;
+    /** Seconds left. */
+    life: number;
+}
+/** What the renderer and the camera read; update and shot move it. */
+export interface Effects {
+    /** Vertical eye offset, metres. */
+    bob: number;
+    /** Radians, positive leans right (strafing right). */
+    roll: number;
+    /** Camera yaw and pitch jitter, radians. */
+    shakeYaw: number;
+    shakePitch: number;
+    /** Recoil, 1 at a shot down to 0. */
+    kick: number;
+    /** Barrel angle, radians. */
+    spin: number;
+    /** Seconds of own muzzle flash left. */
+    flash: number;
+    /** Seconds of flash left at each other shooter, by player id. */
+    flashes: Map<number, number>;
+    sparks: Spark[];
+    /** Advances dt seconds: the own player (eased, undefined before the first snapshot) and the held keys. */
+    update(me: PlayerState | undefined, keys: number, dt: number): void;
+    /**
+     * A shot, from the shooter's eye; own ones kick the camera and the gun. No sparks with
+     * `sparks` false: a shot that hit the viewer would burst them inside the camera.
+     */
+    shot(s: Shot, from: Vec3, own: boolean, sparks?: boolean): void;
+}
+/** rand in [0, 1): injectable so the tests are exact. */
+export declare const createEffects: (rand?: () => number) => Effects;
+export {};

package/dist/types/client/gun.d.ts

@@ -0,0 +1,19 @@
+type Vec3 = [number, number, number];
+/** Where the barrels end, on -z: the muzzle flash sits just past it. */
+export declare const MUZZLE = 0.55;
+/**
+ * Revolves a profile of [radius, length] points around the axis through `at` along -z: `length`
+ * runs forward from `at`. Returns triangles as x, y, z, nx, ny, nz per vertex, `sides` quads of 2
+ * triangles per profile segment. The profile goes from back to front and closes on the axis, so
+ * the normals (smooth around the ring, flat along the profile) point outward.
+ */
+export declare const lathe: (profile: [number, number][], sides: number, at?: Vec3) => number[];
+/**
+ * The chaingun, built once per level of detail: `barrels` turn around the central axis (the caller
+ * spins them), the `body` stays. Vertices as in lathe.
+ */
+export declare const chaingun: (sides: number) => {
+    barrels: number[];
+    body: number[];
+};
+export {};

package/dist/types/client/index.d.ts

@@ -0,0 +1,22 @@
+import type { PlayerInfo, SocketLike } from '../shared/types';
+export type { PlayerInfo, SocketLike } from '../shared/types';
+export interface TinyFpsOptions {
+    name: string;
+    /** WebSocket URL, e.g. ws://localhost:8787/demo (the path picks the room). */
+    url?: string;
+    /** Any WebSocket-like socket, e.g. localSocket('room') from '@korial29/tiny-fps/local'. */
+    socket?: SocketLike;
+}
+export type TinyFpsEvent = 'roster' | 'open' | 'close';
+export interface TinyFps {
+    on(ev: TinyFpsEvent, cb: () => void): void;
+    /** Everyone in the room, the own player included. */
+    players(): PlayerInfo[];
+    /** Closes the socket, stops the loop and removes the canvas. */
+    destroy(): void;
+}
+/**
+ * Mounts the game in a Shadow DOM inside container: one WebGL2 canvas filling it, a click locks the
+ * pointer, the mouse looks, WASD (ZQSD on AZERTY) moves, Space jumps.
+ */
+export declare const tinyFps: (container: HTMLElement, opts: TinyFpsOptions) => TinyFps;

package/dist/types/client/input.d.ts

@@ -0,0 +1,17 @@
+/** The KEY bit of a KeyboardEvent.code, 0 for a key the game ignores. */
+export declare const keyBit: (code: string) => number;
+/** Live look angles and held keys; the loop reads them once per step and per frame. */
+export interface Controls {
+    /** Radians, [0, 2π). Mouse right turns right, which lowers yaw. */
+    yaw: number;
+    /** Radians, ±MAX_PITCH. Positive looks up. */
+    pitch: number;
+    /** KEY bits held now. */
+    keys: number;
+    /** The canvas holds the pointer lock. */
+    locked(): boolean;
+    /** Removes every listener. */
+    destroy(): void;
+}
+/** Click the canvas to lock the pointer; while locked the mouse looks, the keys move, the left button fires. */
+export declare const createInput: (canvas: HTMLCanvasElement) => Controls;

package/dist/types/client/predict.d.ts

@@ -0,0 +1,29 @@
+import type { Input, Level, PlayerState, Shot, Snapshot } from '../shared/types';
+export interface Predictor {
+    /** The own player id, from the roster. Snapshots before it are only used for the others. */
+    you(id: number): void;
+    /**
+     * One local step: gives the input the next seq, rounds its yaw and pitch to the wire, moves the
+     * own player with it, keeps it for replay, and returns it for the caller to send (the very
+     * values predicted with, which the host reads back). Until the own player is known (no snapshot
+     * shows it yet) it only numbers and keeps the input: the first snapshot replays it.
+     * With `now` (ms, performance.now()) the input carries the view tick the others are drawn at.
+     */
+    step(i: Omit<Input, 'seq' | 'view'>, now?: number): Input;
+    /**
+     * The shot the last step fired, resolved with fire() against others(now) of that step; undefined
+     * when it did not fire. Replays on a snapshot never fire again.
+     */
+    shot(): Shot | undefined;
+    /** A decoded snapshot, received at `now` (ms, performance.now()). */
+    snapshot(s: Snapshot, now: number): void;
+    /**
+     * The own player, eased between the state before and after the last step by alpha in [0, 1]
+     * (the share of a step elapsed since it), so the camera moves smoothly at any frame rate.
+     * Undefined until a snapshot shows the own player.
+     */
+    me(alpha: number): PlayerState | undefined;
+    /** The other players at now - INTERP_DELAY; a player missing from the latest snapshot is gone. */
+    others(now: number): PlayerState[];
+}
+export declare const createPredictor: (lvl: Level) => Predictor;

package/dist/types/client/render.d.ts

@@ -0,0 +1,34 @@
+import type { Edge, Level, PlayerState } from '../shared/types';
+import type { Effects } from './effects';
+type Vec3 = [number, number, number];
+/**
+ * Camera axes [right, up, forward]: forward is (-sin yaw cos pitch, sin pitch, -cos yaw cos pitch),
+ * y up at roll 0. A positive roll leans the camera right: up tilts toward right.
+ */
+export declare const basis: (yaw: number, pitch: number, roll?: number) => [Vec3, Vec3, Vec3];
+/** Column-major view-projection matrix of basis(yaw, pitch, roll) at eye, 70° vertical field of view. */
+export declare const viewProj: (eye: Vec3, yaw: number, pitch: number, aspect: number, roll?: number) => Float32Array<ArrayBuffer>;
+/** A world point on screen, in [0, 1] from the top left; undefined behind the camera. */
+export declare const project: (m: Float32Array, x: number, y: number, z: number) => [number, number] | undefined;
+/**
+ * Appends the 36 vertices of a box centred on (cx, cy, cz) with half sizes (hx, hy, hz), turned
+ * by yaw about its own vertical axis (local forward, -z, ends up along forward(yaw)).
+ */
+export declare const pushBox: (out: number[], [cx, cy, cz]: Vec3, [hx, hy, hz]: Vec3, yaw: number, color: number[], layer?: number) => void;
+/** Vertical spans [y0, y1] an edge draws on its own side: the wall, or the steps of a portal. */
+export declare const spans: ({ map }: Level, { front, back }: Edge) => [number, number][];
+/** Floors and ceilings as fans, then every edge's walls as quads, in the vertex format above. */
+export declare const levelVerts: (lvl: Level) => number[];
+export interface Renderer {
+    /**
+     * Draws one frame: the map, the others and the effects as seen from eye, with the view model on
+     * top. colors maps player id to CSS.
+     */
+    frame(eye: Vec3, yaw: number, pitch: number, others: PlayerState[], colors: ReadonlyMap<number, string>, fx: Effects): void;
+    /** A world point on screen as of the last frame, in [0, 1] from the top left. */
+    project(x: number, y: number, z: number): [number, number] | undefined;
+    destroy(): void;
+}
+/** Throws when the browser has no WebGL2. */
+export declare const createRenderer: (canvas: HTMLCanvasElement, lvl: Level) => Renderer;
+export {};

package/dist/types/client/textures.d.ts

@@ -0,0 +1,4 @@
+export declare const SIZE = 128;
+export declare const LAYERS: number;
+/** All layers, RGBA, layer after layer, rows top to bottom: the upload of a texture array. */
+export declare const textures: () => Uint8ClampedArray;

package/dist/types/local/index.d.ts

@@ -0,0 +1,14 @@
+import type { Rules, SocketLike } from '../shared/types';
+/**
+ * Same-browser multiplayer: tabs of one origin play together over a
+ * BroadcastChannel. One tab hosts the Room (elected with navigator.locks);
+ * when it closes, another tab takes over with a fresh Room (score back to 0-0)
+ * and every socket replays its join, so the client only sees a new roster.
+ *
+ * Without navigator.locks (old browsers, or a non-secure context such as plain
+ * http on a LAN address) every tab hosts its own Room and plays alone.
+ *
+ * `rules` are the match rules of the Room this tab creates when it hosts (missing ones fall
+ * back to RULES). Only the host's count: pass the same ones from every tab.
+ */
+export declare const localSocket: (room: string, rules?: Partial<Rules>) => SocketLike;

package/dist/types/server/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/types/server/index.d.ts

@@ -0,0 +1,16 @@
+import type { Server } from 'node:http';
+import type { Rules } from '../shared/types';
+export interface ServeOptions {
+    /** Listen on this port (ignored when server is given). */
+    port?: number;
+    /** Attach to an existing HTTP server instead. */
+    server?: Server;
+    /** Match rules for every room; missing ones fall back to RULES. */
+    rules?: Partial<Rules>;
+}
+/**
+ * Starts the WebSocket server: one Room per URL path. Returns an idempotent stop
+ * function that closes every socket, room, the WebSocketServer, and the HTTP
+ * server only when serve created it (`{ port }`).
+ */
+export declare const serve: (opts: ServeOptions) => (() => Promise<void>);

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

@@ -0,0 +1,46 @@
+import type { Rules } from './types';
+/** Physics steps per second: one client input per step, the host steps a player per input. */
+export declare const TICK_HZ = 60;
+/** A snapshot goes out every SNAP_EVERY host ticks: 60 / 2 = 30 Hz. */
+export declare const SNAP_EVERY = 2;
+/**
+ * Render delay of the other players, interpolated between snapshots, in ms: about three snapshot
+ * intervals, so one lost or late snapshot does not freeze them. The own player is predicted.
+ */
+export declare const INTERP_DELAY = 100;
+/** Player cylinder. */
+export declare const PLAYER_R = 0.4;
+export declare const PLAYER_H = 1.8;
+/** Camera height above the feet. */
+export declare const EYE = 1.6;
+/** Metres per second. */
+export declare const RUN_SPEED = 6;
+export declare const JUMP_SPEED = 7;
+/** Metres per second squared. */
+export declare const GRAVITY = 20;
+/** Pitch is clamped to ±MAX_PITCH radians, just short of straight up or down. */
+export declare const MAX_PITCH = 1.55;
+/** A floor at most this much higher is walked onto; a higher one needs a jump. */
+export declare const STEP_H = 0.5;
+/** Steps between two chaingun shots while the trigger is held: 60 / 5 = 12 shots per second. */
+export declare const FIRE_EVERY = 5;
+/** Speed factor while the trigger is held. */
+export declare const FIRE_SLOW = 0.5;
+/** Metres a shot reaches. */
+export declare const RANGE = 100;
+/** Largest angle, in radians, between a shot and the view direction. */
+export declare const SPREAD = 0.02;
+/**
+ * Host ticks a shot may look back (0.5 s): the host rewinds the targets to the view tick of the
+ * input that fired, clamped to this.
+ */
+export declare const MAX_REWIND = 30;
+/**
+ * Host-side speed-hack guard: each player earns one input per host tick and may bank up to
+ * INPUT_BURST of them; inputs beyond the bank are dropped (and not acked).
+ */
+export declare const INPUT_BURST = 10;
+export declare const MAX_PLAYERS = 16;
+/** Longest player name, in characters (code points). */
+export declare const MAX_NAME = 16;
+export declare const RULES: Rules;

package/dist/types/shared/level.d.ts

@@ -0,0 +1,13 @@
+import type { Level, MapDef, Sector } from './types';
+/** Joins every edge a→b with the sector that has b→a, if any: that edge is a portal. */
+export declare const compile: (map: MapDef) => Level;
+/** Whether (x, z) is inside the sector, its edges included. */
+export declare const inside: ({ pts }: Sector, x: number, z: number) => boolean;
+/** Index of the first sector holding (x, z), -1 outside the map. */
+export declare const sectorAt: ({ map }: Level, x: number, z: number) => number;
+/**
+ * Whether a wall, a step or a ceiling hides b from a (both inside the map). Between two edge
+ * crossings the segment stays in one sector, and each crossing is checked against the opening of
+ * its portal, so floors and ceilings need no test of their own.
+ */
+export declare const blocked: ({ map, edges }: Level, [ax, ay, az]: [number, number, number], [bx, by, bz]: [number, number, number]) => boolean;

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

@@ -0,0 +1,6 @@
+import type { MapDef } from './types';
+/**
+ * The first sector map, a test bed for heights: a start room, a low corridor, a tall hall around a
+ * lava pit, stairs up to a balcony. Each spot is reachable on foot; the pit is a 1 m drop.
+ */
+export declare const HALL: MapDef;

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

@@ -0,0 +1,20 @@
+import type { Input, Level, PlayerState } from './types';
+export declare const TAU: number;
+/** An angle in [0, 2π). */
+export declare const norm: (a: number) => number;
+/** Unit vector the player faces at yaw, on the floor plane: yaw 0 looks toward -z. */
+export declare const forward: (yaw: number) => [x: number, z: number];
+/**
+ * Applies one input for 1 / TICK_HZ s, in place: yaw and pitch from the input (pitch clamped to
+ * MAX_PITCH), RUN_SPEED along the held keys (diagonals not faster), a jump from the ground,
+ * GRAVITY, then collisions of the cylinder (PLAYER_R, PLAYER_H) with the sectors of the level:
+ * it slides along shut edges (see shut and push), stands on the highest floor under the circle
+ * (a step up to STEP_H is climbed at once, a higher one needs a jump, a ledge is a fall), and
+ * bumps its head on the lowest ceiling.
+ * The chaingun: `cool` counts down one per step, RUN_SPEED is scaled by FIRE_SLOW while KEY.FIRE
+ * is held, and the step that finds it held with `cool` at 0 re-arms it to FIRE_EVERY and returns
+ * true: the caller resolves a shot (one every FIRE_EVERY steps, the first at once).
+ */
+export declare const move: (p: PlayerState, i: Input, lvl: Level) => boolean;
+/** A player standing on the floor at spawn point n of the map (modulo the count). */
+export declare const spawn: (id: number, lvl: Level, n: number) => PlayerState;

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

@@ -0,0 +1,32 @@
+import type { Input, PlayerInfo, Snapshot } from './types';
+export type ClientText = {
+    t: 'join';
+    name: string;
+};
+export type ServerText = {
+    t: 'roster';
+    you: number;
+    players: PlayerInfo[];
+} | {
+    t: 'full';
+};
+export declare const MSG_INPUT = 1;
+export declare const MSG_SNAPSHOT = 2;
+export declare const INPUT_BYTES = 11;
+export declare const SNAP_HEAD = 4;
+export declare const SNAP_PLAYER = 24;
+export declare const SNAP_SHOT = 14;
+/**
+ * The input as the host will read it after encodeInput and decodeInput: yaw, pitch and view
+ * rounded to the wire (an absent view stays absent here, and reads 0 on the host). The client
+ * predicts with this, so both sides move with the same values.
+ */
+export declare const onWire: (i: Input) => Input;
+export declare const encodeInput: (i: Input) => ArrayBuffer;
+/** Null on anything that is not a well-formed input frame. */
+export declare const decodeInput: (buf: ArrayBuffer) => Input | null;
+export declare const encodeSnapshot: (s: Snapshot) => ArrayBuffer;
+/** Null on anything that is not a well-formed snapshot frame. */
+export declare const decodeSnapshot: (buf: ArrayBuffer) => Snapshot | null;
+/** Returns null on anything that is not a known text message. */
+export declare const parseText: <T extends ClientText | ServerText>(raw: string) => T | null;

package/dist/types/shared/room.d.ts

@@ -0,0 +1,59 @@
+import type { Conn, Every, Rules } from './types';
+/**
+ * One game, transport-agnostic. The Node server and the local host tab both drive a Room: they
+ * feed it connections and frames, the room answers through Conn.send.
+ *
+ * - A peer joins with { t: 'join', name }: unique name (`Bob 2`), unique colour, a spawn point not
+ *   taken by another player; 'full' beyond rules.maxPlayers. Everyone gets a fresh 'roster' on
+ *   every join and leave.
+ * - Each input frame moves its player at once with move(); the INPUT_BURST bank drops the excess.
+ *   A step that fires resolves its shot at once with fire(), the other players rewound to the
+ *   view tick of the input (lag compensation, at most MAX_REWIND ticks back).
+ * - Every SNAP_EVERY ticks of TICK_HZ, one snapshot with every player and the shots resolved
+ *   since the last one goes to every peer.
+ */
+export declare class Room {
+    /** Every connected peer; null until it joins. */
+    private peers;
+    private ticks;
+    /** The players as each snapshot of the last MAX_REWIND ticks sent them. */
+    private history;
+    /** Shots resolved since the last snapshot. */
+    private shots;
+    private halt;
+    private rules;
+    /** Round-robin cursor over the spawn points, used once they are all taken. */
+    private rr;
+    /** Missing rules fall back to RULES. */
+    constructor(rules?: Partial<Rules>);
+    /** Number of joined players. */
+    get size(): number;
+    /** A peer opened. Nothing is sent until it joins. */
+    connect(conn: Conn): void;
+    /** A text (JSON) or binary frame from a peer. */
+    receive(conn: Conn, data: string | ArrayBuffer): void;
+    /** A peer left: its player goes, the roster goes out again. */
+    disconnect(conn: Conn): void;
+    /** One host tick. Public so tests can drive the room without a timer. */
+    tick(): void;
+    /**
+     * Drives tick() with a timer. An accumulator on performance.now() keeps the
+     * simulation at TICK_HZ whatever the timer jitter; after a stall at most
+     * MAX_CATCH_UP ticks are replayed and the rest of the backlog is dropped.
+     * `every` replaces setInterval, e.g. with a Worker-backed timer that
+     * background tabs do not throttle.
+     */
+    start(every?: Every): void;
+    stop(): void;
+    /**
+     * The players other than `shooter` as the shooter drew them at `view` (a u16 tick, fractional,
+     * read against the current tick and clamped to the kept history): x, y, z interpolated between
+     * the two snapshots around it like the client does. A player the history does not hold stands
+     * where it is.
+     */
+    private rewind;
+    private players;
+    private join;
+    /** Each joined peer gets the full roster with its own id. */
+    private roster;
+}

package/dist/types/shared/shoot.d.ts

@@ -0,0 +1,24 @@
+import type { Level, PlayerState, Shot } from './types';
+type Vec3 = [number, number, number];
+/**
+ * Unit direction of a shot: the view direction at yaw and pitch (yaw 0, pitch 0 is -z; pitch > 0
+ * looks up), turned by at most SPREAD in a direction hashed from seq, so the host and the
+ * shooter's client agree on it.
+ */
+export declare const aim: (yaw: number, pitch: number, seq: number) => Vec3;
+/**
+ * Distance along the ray from o (inside the map) in the unit direction d to the first wall, step
+ * face, floor or ceiling, at most max.
+ *
+ * Walks the sectors: in the current convex one the ray leaves through the edge with the least
+ * crossing distance among the edges it goes outward through, or ends earlier on the floor or the
+ * ceiling. A solid edge, or a portal whose opening does not hold the crossing height, ends it.
+ */
+export declare const trace: (lvl: Level, o: Vec3, d: Vec3, max: number) => number;
+/**
+ * Resolves one shot of `shooter` (state after the step that fired) from its eye (feet + EYE)
+ * along aim(yaw, pitch, seq): the nearest of the level (trace) and the upright cylinders
+ * (PLAYER_R, PLAYER_H, from the feet) of `targets` other than the shooter, within RANGE.
+ */
+export declare const fire: (lvl: Level, shooter: PlayerState, seq: number, targets: PlayerState[]) => Shot;
+export {};

package/dist/types/shared/types.d.ts

@@ -0,0 +1,156 @@
+export interface PlayerInfo {
+    id: number;
+    name: string;
+    /** CSS colour, unique within the room. */
+    color: string;
+}
+/** Bits of Input.keys. Keys are read by KeyboardEvent.code, so WASD is ZQSD on AZERTY. */
+export declare const KEY: {
+    readonly FORWARD: 1;
+    readonly BACK: 2;
+    readonly LEFT: 4;
+    readonly RIGHT: 8;
+    readonly JUMP: 16;
+    /** Left mouse button: the chaingun fires every FIRE_EVERY steps while held. */
+    readonly FIRE: 32;
+};
+/** One client step: what the player held during 1 / TICK_HZ s, and where they looked. */
+export interface Input {
+    /** Client step counter, u16, wraps. The host acks the last one it applied. */
+    seq: number;
+    /** KEY bits. */
+    keys: number;
+    /** Radians, [0, 2π). */
+    yaw: number;
+    /** Radians, [-MAX_PITCH, MAX_PITCH]. */
+    pitch: number;
+    /**
+     * Host tick the client drew the others at when it sent this input, fractional (interpolation
+     * between two snapshots), in [0, 65536): the host rewinds the targets of a shot to it (lag
+     * compensation). The wire keeps 1/256 tick. Absent (no snapshot seen yet) goes out as 0: the host
+     * clamps it to the oldest tick it keeps.
+     */
+    view?: number;
+}
+export interface PlayerState {
+    id: number;
+    /** Feet position. */
+    x: number;
+    y: number;
+    z: number;
+    /** Vertical speed, m/s. */
+    vy: number;
+    yaw: number;
+    pitch: number;
+    /** Standing on a floor: a jump is allowed. */
+    ground: boolean;
+    /** Steps until the chaingun may fire again, 0 to FIRE_EVERY. */
+    cool: number;
+}
+/** One shot, as the host resolved it. */
+export interface Shot {
+    /** The shooter. */
+    id: number;
+    /** Where the shot stopped: a wall, a floor, a ceiling, a target, or RANGE away. */
+    x: number;
+    y: number;
+    z: number;
+    /** Id of the player hit, -1 for the level or nothing. */
+    hit: number;
+}
+/** Procedural textures, generated by the client. A sector names one per surface. */
+export declare const TEX: {
+    readonly BRICK: 0;
+    readonly TILE: 1;
+    readonly LAVA: 2;
+    readonly STONE: 3;
+};
+/**
+ * A room, Doom style: a convex polygon on the floor plane with a flat floor and a flat ceiling.
+ * Two sectors are joined where one has the edge a→b and the other b→a with the very same
+ * coordinates (a portal); every other edge is a solid wall. Split an edge with collinear points
+ * when several sectors meet it (no T-junctions).
+ */
+export interface Sector {
+    /**
+     * Corners as (x, z), counter-clockwise: the signed area Σ (x_i z_{i+1} - x_{i+1} z_i) is positive.
+     * Collinear points are allowed.
+     */
+    pts: [x: number, z: number][];
+    /** Heights in metres, ceil > floor. */
+    floor: number;
+    ceil: number;
+    /** TEX ids of the floor, the walls (and steps) on its edges, and the ceiling. */
+    ft: number;
+    wt: number;
+    ct: number;
+    /** Light level multiplied into the shading, 0 to 1. Absent: 1. */
+    light?: number;
+}
+export interface MapDef {
+    sectors: Sector[];
+    /** Spawn points: feet x, z (inside a sector, standing on its floor) and the yaw to face. */
+    spawns: [x: number, z: number, yaw: number][];
+}
+/** One directed edge of a sector, see compile in level.ts. */
+export interface Edge {
+    ax: number;
+    az: number;
+    bx: number;
+    bz: number;
+    /** Index of the sector the edge belongs to (the side it faces into). */
+    front: number;
+    /** Index of the sector across a portal, -1 for a solid wall. */
+    back: number;
+}
+/** A map ready for physics and drawing. */
+export interface Level {
+    map: MapDef;
+    /** Every edge of every sector, in sector then point order. */
+    edges: Edge[];
+}
+/** One player in a snapshot. */
+export interface SnapPlayer {
+    id: number;
+    x: number;
+    y: number;
+    z: number;
+    vy: number;
+    yaw: number;
+    pitch: number;
+    ground: boolean;
+    cool: number;
+    /** Seq of the last input of this player the host applied: the client replays the ones after. */
+    ack: number;
+}
+export interface Snapshot {
+    /** Host tick, u16, wraps. */
+    tick: number;
+    players: SnapPlayer[];
+    /** Shots fired since the previous snapshot, in order. */
+    shots: Shot[];
+}
+/** Room rules, set by the host. Defaults in constants.ts (RULES). */
+export interface Rules {
+    maxPlayers: number;
+}
+/**
+ * The subset of WebSocket the client relies on. A real WebSocket (with
+ * binaryType 'arraybuffer') and the local BroadcastChannel socket both fit.
+ */
+export interface SocketLike {
+    binaryType: string;
+    onopen: (() => void) | null;
+    onclose: (() => void) | null;
+    onmessage: ((ev: {
+        data: string | ArrayBuffer;
+    }) => void) | null;
+    send(data: string | ArrayBuffer): void;
+    close(): void;
+}
+/** Calls cb every ms milliseconds until the returned function is called. */
+export type Every = (cb: () => void, ms: number) => () => void;
+/** One connected peer, as the room sees it. Transport-agnostic. */
+export interface Conn {
+    send(data: string | ArrayBuffer): void;
+}