@korial29/tiny-fps 0.0.0-stage → 0.1.0

package/dist/server.js

@@ -0,0 +1,624 @@
+import { WebSocketServer } from "ws";
+// src/shared/constants.ts
+/** Player cylinder. */
+var PLAYER_R = .4;
+var PLAYER_H = 1.8;
+/** Pitch is clamped to ±MAX_PITCH radians, just short of straight up or down. */
+var MAX_PITCH = 1.55;
+var RULES = { maxPlayers: 16 };
+// src/shared/level.ts
+/** Joins every edge a→b with the sector that has b→a, if any: that edge is a portal. */
+var compile = (map) => {
+	const key = (ax, az, bx, bz) => `${ax},${az},${bx},${bz}`;
+	const owner = /* @__PURE__ */ new Map();
+	map.sectors.forEach(({ pts }, s) => pts.forEach(([ax, az], i) => owner.set(key(ax, az, ...pts[(i + 1) % pts.length]), s)));
+	return {
+		map,
+		edges: map.sectors.flatMap(({ pts }, front) => pts.map(([ax, az], i) => {
+			const [bx, bz] = pts[(i + 1) % pts.length];
+			return {
+				ax,
+				az,
+				bx,
+				bz,
+				front,
+				back: owner.get(key(bx, bz, ax, az)) ?? -1
+			};
+		}))
+	};
+};
+/** Whether (x, z) is inside the sector, its edges included. */
+var inside = ({ pts }, x, z) => pts.every(([ax, az], i) => {
+	const [bx, bz] = pts[(i + 1) % pts.length];
+	return (bx - ax) * (z - az) - (bz - az) * (x - ax) >= 0;
+});
+/** Index of the first sector holding (x, z), -1 outside the map. */
+var sectorAt = ({ map }, x, z) => map.sectors.findIndex((s) => inside(s, x, z));
+// src/shared/types.ts
+/** Bits of Input.keys. Keys are read by KeyboardEvent.code, so WASD is ZQSD on AZERTY. */
+var KEY = {
+	FORWARD: 1,
+	BACK: 2,
+	LEFT: 4,
+	RIGHT: 8,
+	JUMP: 16
+};
+/** Procedural textures, generated by the client. A sector names one per surface. */
+var TEX = {
+	BRICK: 0,
+	TILE: 1,
+	LAVA: 2,
+	STONE: 3
+};
+// src/shared/map.ts
+var sector = (pts, floor, ceil, ft, light) => ({
+	pts,
+	floor,
+	ceil,
+	ft,
+	wt: TEX.BRICK,
+	ct: TEX.STONE,
+	light
+});
+/**
+* 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.
+*/
+var HALL = {
+	sectors: [
+		sector([
+			[0, 0],
+			[16, 0],
+			[16, 6],
+			[16, 10],
+			[16, 16],
+			[0, 16]
+		], 1, 5, TEX.TILE),
+		sector([
+			[16, 6],
+			[20, 6],
+			[20, 10],
+			[16, 10]
+		], 1, 3.5, TEX.TILE, .6),
+		sector([
+			[20, 0],
+			[36, 0],
+			[36, 6],
+			[30, 6],
+			[26, 6],
+			[20, 6]
+		], 1, 7, TEX.TILE),
+		sector([
+			[20, 6],
+			[26, 6],
+			[26, 10],
+			[20, 10]
+		], 1, 7, TEX.TILE),
+		sector([
+			[30, 6],
+			[36, 6],
+			[36, 10],
+			[30, 10]
+		], 1, 7, TEX.TILE),
+		sector([
+			[20, 10],
+			[26, 10],
+			[30, 10],
+			[36, 10],
+			[36, 16],
+			[32, 16],
+			[28, 16],
+			[20, 16]
+		], 1, 7, TEX.TILE),
+		sector([
+			[26, 6],
+			[30, 6],
+			[30, 10],
+			[26, 10]
+		], 0, 7, TEX.LAVA),
+		sector([
+			[28, 16],
+			[32, 16],
+			[32, 17],
+			[28, 17]
+		], 1.4, 7, TEX.STONE),
+		sector([
+			[28, 17],
+			[32, 17],
+			[32, 18],
+			[28, 18]
+		], 1.8, 7, TEX.STONE),
+		sector([
+			[28, 18],
+			[32, 18],
+			[32, 19],
+			[28, 19]
+		], 2.2, 7, TEX.STONE),
+		sector([
+			[24, 19],
+			[28, 19],
+			[32, 19],
+			[36, 19],
+			[36, 26],
+			[24, 26]
+		], 2.6, 7, TEX.TILE, .8)
+	],
+	spawns: [
+		[
+			4,
+			4,
+			Math.PI * 1.5
+		],
+		[
+			4,
+			12,
+			Math.PI * 1.5
+		],
+		[
+			8,
+			8,
+			Math.PI * 1.5
+		],
+		[
+			12,
+			4,
+			Math.PI * 1.5
+		],
+		[
+			12,
+			12,
+			Math.PI * 1.5
+		],
+		[
+			2,
+			8,
+			Math.PI * 1.5
+		],
+		[
+			8,
+			2,
+			Math.PI * 1.5
+		],
+		[
+			8,
+			14,
+			Math.PI * 1.5
+		]
+	]
+};
+// src/shared/physics.ts
+var DT = 1 / 60;
+var TAU = Math.PI * 2;
+/** Overlaps smaller than this are rounding noise, not contact. */
+var EPS = 1e-6;
+/**
+* Feet this close below a floor still stand on it (rounding of y must not sink a player into
+* the floor or flip a step test), and a fall that ends this close above a floor
+* lands on it.
+*/
+var SKIN = .01;
+/** An angle in [0, 2π). */
+var norm = (a) => (a % TAU + TAU) % TAU;
+/** Unit vector the player faces at yaw, on the floor plane: yaw 0 looks toward -z. */
+var forward = (yaw) => [-Math.sin(yaw), -Math.cos(yaw)];
+var f32 = Math.fround;
+var clamp = (v, lo, hi) => Math.min(Math.max(v, lo), hi);
+/**
+* Whether the edge stops a player whose feet are at y: a solid wall, a floor on the far side more
+* than STEP_H above the feet, or an opening (the lower ceiling minus the higher floor) too short
+* for the body or under the head. SKIN keeps rounding from flipping the answer
+* for a player resting on a step or against a ceiling.
+*/
+var shut = ({ map }, e, y) => {
+	if (e.back < 0) return true;
+	const f = map.sectors[e.front];
+	const k = map.sectors[e.back];
+	const top = Math.min(f.ceil, k.ceil);
+	return k.floor > y + .5 + SKIN || top - Math.max(f.floor, k.floor) < 1.8 - SKIN || top < y + 1.8 - SKIN;
+};
+/**
+* Pushes the player out of every shut edge it overlaps, deepest first (up to 4 passes: two walls
+* in a corner settle in two). The push is along the vector from the closest point of the edge, so
+* against a wall it is the normal (the other axis keeps moving: the slide) and at an endpoint it
+* is radial: a player running at a corner slides round it. Deepest first matters on a straight
+* wall split by a collinear point: the endpoint of the next piece is always shallower than the
+* normal push of the piece the player is on, so it never pulls him back along the wall.
+* An edge only counts from its front side (the inside of its sector); across it, the twin edge of
+* the neighbour decides.
+* Tunnelling is impossible: a step is RUN_SPEED / TICK_HZ = 0.1 m and the axis ends each step at
+* least PLAYER_R = 0.4 m from every shut edge it started beside, so it cannot cross one in 0.1 m.
+*/
+var push = (p, lvl) => {
+	const reach = (PLAYER_R - EPS) ** 2;
+	for (let pass = 0; pass < 4; pass++) {
+		let best = 0;
+		let px = 0;
+		let pz = 0;
+		for (const e of lvl.edges) {
+			const ex = e.bx - e.ax;
+			const ez = e.bz - e.az;
+			const rx = p.x - e.ax;
+			const rz = p.z - e.az;
+			if (ex * rz - ez * rx < 0) continue;
+			const t = clamp((rx * ex + rz * ez) / (ex * ex + ez * ez), 0, 1);
+			const dx = rx - t * ex;
+			const dz = rz - t * ez;
+			const d2 = dx * dx + dz * dz;
+			if (d2 >= reach) continue;
+			const d = Math.sqrt(d2);
+			if (.4 - d <= best || !shut(lvl, e, p.y)) continue;
+			best = PLAYER_R - d;
+			const n = d || Math.hypot(ex, ez);
+			px = (d ? dx : -ez) / n * best;
+			pz = (d ? dz : ex) / n * best;
+		}
+		if (!best) return;
+		p.x += px;
+		p.z += pz;
+	}
+};
+/**
+* The floor and the ceiling under the player: the highest floor and the lowest ceiling of the
+* sector holding the axis and of every sector across a portal the circle overlaps and could walk
+* through (a shut edge is a wall: the circle never counts what lies behind it).
+*/
+var span = (lvl, x, z, y) => {
+	const { map, edges } = lvl;
+	const s = Math.max(sectorAt(lvl, x, z), 0);
+	let { floor, ceil } = map.sectors[s];
+	const reach = (PLAYER_R - EPS) ** 2;
+	for (const e of edges) {
+		if (e.front !== s || e.back < 0) continue;
+		const ex = e.bx - e.ax;
+		const ez = e.bz - e.az;
+		const rx = x - e.ax;
+		const rz = z - e.az;
+		const t = clamp((rx * ex + rz * ez) / (ex * ex + ez * ez), 0, 1);
+		if ((rx - t * ex) ** 2 + (rz - t * ez) ** 2 < reach && !shut(lvl, e, y)) {
+			const k = map.sectors[e.back];
+			floor = Math.max(floor, k.floor);
+			ceil = Math.min(ceil, k.ceil);
+		}
+	}
+	return [floor, ceil];
+};
+/**
+* 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.
+*/
+var move = (p, i, lvl) => {
+	p.yaw = norm(i.yaw);
+	p.pitch = Math.max(-MAX_PITCH, Math.min(MAX_PITCH, i.pitch));
+	const f = (i.keys & KEY.FORWARD ? 1 : 0) - (i.keys & KEY.BACK ? 1 : 0);
+	const s = (i.keys & KEY.RIGHT ? 1 : 0) - (i.keys & KEY.LEFT ? 1 : 0);
+	const d = 6 * DT / (Math.hypot(f, s) || 1);
+	const [fx, fz] = forward(p.yaw);
+	p.x += (fx * f - fz * s) * d;
+	p.z += (fz * f + fx * s) * d;
+	push(p, lvl);
+	const [floor, ceil] = span(lvl, p.x, p.z, p.y);
+	if (p.ground && i.keys & KEY.JUMP) p.vy = 7;
+	const vy = p.vy - 20 * DT;
+	p.y += (p.vy + vy) / 2 * DT;
+	p.vy = vy;
+	p.ground = false;
+	if (p.y + 1.8 > ceil) {
+		p.y = ceil - PLAYER_H;
+		p.vy = Math.min(p.vy, 0);
+	}
+	if (p.vy <= 0 ? p.y <= floor + SKIN : p.y < floor) {
+		p.y = floor;
+		if (p.vy <= 0) {
+			p.vy = 0;
+			p.ground = true;
+		}
+	}
+	p.x = f32(p.x);
+	p.y = f32(p.y);
+	p.z = f32(p.z);
+	p.vy = f32(p.vy);
+};
+/** A player standing on the floor at spawn point n of the map (modulo the count). */
+var spawn = (id, lvl, n) => {
+	const { spawns, sectors } = lvl.map;
+	const [x, z, yaw] = spawns[(n % spawns.length + spawns.length) % spawns.length];
+	const y = sectors[Math.max(sectorAt(lvl, x, z), 0)].floor;
+	return {
+		id,
+		x: f32(x),
+		y: f32(y),
+		z: f32(z),
+		vy: 0,
+		yaw: norm(yaw),
+		pitch: 0,
+		ground: true
+	};
+};
+var TURN = 65536 / (2 * Math.PI);
+/** Radians to 65536ths of a turn; the mask also folds negative and ≥ 2π angles into one turn. */
+var toTurn = (yaw) => Math.round(yaw * TURN) & 65535;
+var clamp16 = (v) => Math.max(-32768, Math.min(32767, Math.round(v)));
+/** Pitch in 1/10000 rad, and back. */
+var toPitch = (pitch) => clamp16(pitch * 1e4);
+var fromPitch = (w) => w / 1e4;
+var fromTurn = (w) => w / TURN;
+/** Null on anything that is not a well-formed input frame. */
+var decodeInput = (buf) => {
+	if (buf.byteLength !== 8) return null;
+	const v = new DataView(buf);
+	if (v.getUint8(0) !== 1) return null;
+	return {
+		seq: v.getUint16(1),
+		keys: v.getUint8(3),
+		yaw: fromTurn(v.getUint16(4)),
+		pitch: fromPitch(v.getInt16(6))
+	};
+};
+var encodeSnapshot = (s) => {
+	const v = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(4 + 24 * s.players.length));
+	v.setUint8(0, 2);
+	v.setUint16(1, s.tick & 65535);
+	v.setUint8(3, s.players.length);
+	s.players.forEach((p, i) => {
+		const o = 4 + i * 24;
+		v.setUint8(o, p.id);
+		v.setFloat32(o + 1, p.x);
+		v.setFloat32(o + 5, p.y);
+		v.setFloat32(o + 9, p.z);
+		v.setFloat32(o + 13, p.vy);
+		v.setUint16(o + 17, toTurn(p.yaw));
+		v.setInt16(o + 19, toPitch(p.pitch));
+		v.setUint16(o + 21, p.ack & 65535);
+		v.setUint8(o + 23, +p.ground);
+	});
+	return v.buffer;
+};
+/** Returns null on anything that is not a known text message. */
+var parseText = (raw) => {
+	try {
+		const msg = JSON.parse(raw);
+		return msg && typeof msg.t === "string" ? msg : null;
+	} catch {
+		return null;
+	}
+};
+// src/shared/room.ts
+/** Ticks run at most this many times per timer callback, so a stalled host does not spiral. */
+var MAX_CATCH_UP = 20;
+/** The map every room plays, compiled once. */
+var LEVEL = compile(HALL);
+/** A new player does not spawn within this many metres of another one. */
+var SPAWN_CLEAR = 2;
+var COLORS = [
+	"#e6194b",
+	"#3cb44b",
+	"#ffe119",
+	"#4363d8",
+	"#f58231",
+	"#911eb4",
+	"#42d4f4",
+	"#f032e6",
+	"#bfef45",
+	"#fabed4",
+	"#469990",
+	"#dcbeff",
+	"#9a6324",
+	"#800000",
+	"#aaffc3",
+	"#808000"
+];
+/** First n characters (code points) of s, trimmed. */
+var cut = (s, n) => Array.from(s).slice(0, n).join("").trim();
+var cleanName = (raw) => cut((typeof raw === "string" ? raw : "").replace(/\s+/g, " ").replace(/\p{Cc}/gu, "").trim(), 16);
+/** name, or name 2, name 3… (base cut to stay within MAX_NAME) when it is taken. */
+var unique = (name, taken) => {
+	let out = name;
+	for (let n = 2; taken.includes(out); n++) out = `${cut(name, 15 - `${n}`.length)} ${n}`;
+	return out;
+};
+var setEvery = (cb, ms) => {
+	const id = setInterval(cb, ms);
+	return () => clearInterval(id);
+};
+/**
+* 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.
+* - Every SNAP_EVERY ticks of TICK_HZ, one snapshot with every player goes to every peer.
+*/
+var Room = class {
+	/** Every connected peer; null until it joins. */
+	peers = /* @__PURE__ */ new Map();
+	ticks = 0;
+	halt;
+	rules;
+	/** Round-robin cursor over the spawn points, used once they are all taken. */
+	rr = 0;
+	/** Missing rules fall back to RULES. */
+	constructor(rules = {}) {
+		this.rules = {
+			...RULES,
+			...rules
+		};
+	}
+	/** Number of joined players. */
+	get size() {
+		return this.players().length;
+	}
+	/** A peer opened. Nothing is sent until it joins. */
+	connect(conn) {
+		this.peers.set(conn, null);
+	}
+	/** A text (JSON) or binary frame from a peer. */
+	receive(conn, data) {
+		const p = this.peers.get(conn);
+		if (typeof data === "string") {
+			const msg = parseText(data);
+			if (p === null && msg?.t === "join") this.join(conn, msg.name);
+			return;
+		}
+		const input = p && decodeInput(data);
+		if (input && p.bank > 0) {
+			p.bank--;
+			move(p.state, input, LEVEL);
+			p.ack = input.seq;
+		}
+	}
+	/** A peer left: its player goes, the roster goes out again. */
+	disconnect(conn) {
+		const p = this.peers.get(conn);
+		this.peers.delete(conn);
+		if (p) this.roster();
+	}
+	/** One host tick. Public so tests can drive the room without a timer. */
+	tick() {
+		const players = this.players();
+		if (!players.length) return;
+		players.forEach((p) => p.bank = Math.min(10, p.bank + 1));
+		if (++this.ticks % 2 === 0) {
+			const snap = encodeSnapshot({
+				tick: this.ticks,
+				players: players.map((p) => ({
+					...p.state,
+					ack: p.ack
+				}))
+			});
+			players.forEach((p) => p.conn.send(snap));
+		}
+	}
+	/**
+	* 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 = setEvery) {
+		if (this.halt) return;
+		const dt = 1e3 / 60;
+		let last = performance.now();
+		let acc = 0;
+		this.halt = every(() => {
+			const now = performance.now();
+			acc += now - last;
+			last = now;
+			for (let n = 0; acc >= dt && n < MAX_CATCH_UP; n++) {
+				this.tick();
+				acc -= dt;
+			}
+			acc %= dt;
+		}, dt);
+	}
+	stop() {
+		this.halt?.();
+		this.halt = void 0;
+	}
+	players() {
+		return [...this.peers.values()].filter((p) => p !== null);
+	}
+	join(conn, name) {
+		const players = this.players();
+		if (players.length >= this.rules.maxPlayers) {
+			conn.send(JSON.stringify({ t: "full" }));
+			return;
+		}
+		let id = 0;
+		while (players.some((p) => p.info.id === id)) id++;
+		const color = COLORS.find((c) => !players.some((p) => p.info.color === c)) ?? COLORS[id % COLORS.length];
+		const near = (n) => {
+			const { x, z } = spawn(id, LEVEL, n);
+			return players.some((p) => Math.hypot(p.state.x - x, p.state.z - z) < SPAWN_CLEAR);
+		};
+		let n = 0;
+		while (n < HALL.spawns.length && near(n)) n++;
+		const player = {
+			conn,
+			info: {
+				id,
+				name: unique(cleanName(name) || `Player ${id}`, players.map((p) => p.info.name)),
+				color
+			},
+			state: spawn(id, LEVEL, n < HALL.spawns.length ? n : this.rr++),
+			bank: 10,
+			ack: 65535
+		};
+		this.peers.set(conn, player);
+		this.roster();
+	}
+	/** Each joined peer gets the full roster with its own id. */
+	roster() {
+		const players = this.players();
+		const list = players.map((p) => p.info).sort((a, b) => a.id - b.id);
+		players.forEach((p) => p.conn.send(JSON.stringify({
+			t: "roster",
+			you: p.info.id,
+			players: list
+		})));
+	}
+};
+// src/server/index.ts
+/** `/demo` → "demo", `/` → "default". Undecodable paths are kept as is. */
+var roomName = (url = "/") => {
+	const path = new URL(url, "http://x").pathname.slice(1);
+	let name = path;
+	try {
+		name = decodeURIComponent(path);
+	} catch {}
+	return name.slice(0, 64) || "default";
+};
+/**
+* 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 }`).
+*/
+var serve = (opts) => {
+	const wss = new WebSocketServer({
+		...opts.server ? { server: opts.server } : { port: opts.port },
+		maxPayload: 256
+	});
+	const rooms = /* @__PURE__ */ new Map();
+	wss.on("connection", (ws, req) => {
+		const name = roomName(req.url);
+		const entry = rooms.get(name) ?? {
+			room: new Room(opts.rules),
+			conns: 0
+		};
+		const { room } = entry;
+		if (!entry.conns++) {
+			rooms.set(name, entry);
+			room.start();
+		}
+		const conn = { send: (data) => {
+			if (ws.readyState === ws.OPEN) ws.send(data);
+		} };
+		room.connect(conn);
+		ws.on("message", (data, isBinary) => {
+			const buf = data;
+			room.receive(conn, isBinary ? new Uint8Array(buf).buffer : buf.toString());
+		});
+		ws.on("error", () => {});
+		ws.on("close", () => {
+			room.disconnect(conn);
+			if (!--entry.conns && rooms.get(name) === entry) {
+				room.stop();
+				rooms.delete(name);
+			}
+		});
+	});
+	let stopping;
+	return () => stopping ??= new Promise((resolve, reject) => {
+		wss.clients.forEach((ws) => ws.terminate());
+		rooms.forEach(({ room }) => room.stop());
+		rooms.clear();
+		wss.close((err) => err ? reject(err) : resolve());
+	});
+};
+export { serve };

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 and the keys move. */
+export declare const createInput: (canvas: HTMLCanvasElement) => Controls;

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

@@ -0,0 +1,23 @@
+import type { Input, Level, PlayerState, 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.
+     */
+    step(i: Omit<Input, 'seq'>): Input;
+    /** 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;