@korial29/tiny-fps 0.0.0-stage → 0.2.0

package/dist/server.js

@@ -0,0 +1,814 @@
+import { WebSocketServer } from "ws";
+// src/shared/constants.ts
+/** Player cylinder. */
+var PLAYER_R = .4;
+var PLAYER_H = 1.8;
+/** Camera height above the feet. */
+var EYE = 1.6;
+/** Pitch is clamped to ±MAX_PITCH radians, just short of straight up or down. */
+var MAX_PITCH = 1.55;
+/** Speed factor while the trigger is held. */
+var FIRE_SLOW = .5;
+/** Largest angle, in radians, between a shot and the view direction. */
+var SPREAD = .02;
+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,
+	/** Left mouse button: the chaingun fires every FIRE_EVERY steps while held. */
+	FIRE: 32
+};
+/** 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.
+* 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).
+*/
+var move = (p, i, lvl) => {
+	const fire = (i.keys & KEY.FIRE) !== 0;
+	p.cool = Math.max(0, p.cool - 1);
+	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 * (fire ? FIRE_SLOW : 1) / (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);
+	if (fire && !p.cool) {
+		p.cool = 5;
+		return true;
+	}
+	return false;
+};
+/** 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,
+		cool: 0
+	};
+};
+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 !== 11) 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)),
+		view: (v.getUint16(8) * 256 + v.getUint8(10)) / 256
+	};
+};
+var encodeSnapshot = (s) => {
+	const shots = 4 + 24 * s.players.length;
+	const v = new DataView(new ArrayBuffer(shots + 1 + 14 * s.shots.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 | p.cool << 1);
+	});
+	v.setUint8(shots, s.shots.length);
+	s.shots.forEach((h, i) => {
+		const o = shots + 1 + i * 14;
+		v.setUint8(o, h.id);
+		v.setFloat32(o + 1, h.x);
+		v.setFloat32(o + 5, h.y);
+		v.setFloat32(o + 9, h.z);
+		v.setUint8(o + 13, h.hit & 255);
+	});
+	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/shoot.ts
+/** 32-bit integer hash (a xorshift-multiply round, twice). */
+var hash = (n) => {
+	for (let k = 0; k < 2; k++) n = Math.imul(n ^ n >>> 16, 73244475);
+	return (n ^ n >>> 16) >>> 0;
+};
+/**
+* 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.
+*/
+var aim = (yaw, pitch, seq) => {
+	const [sy, cy, sp, cp] = [
+		Math.sin(yaw),
+		Math.cos(yaw),
+		Math.sin(pitch),
+		Math.cos(pitch)
+	];
+	const h = hash(seq + 1);
+	const a = (h & 65535) / 65536 * TAU;
+	const r = (h >>> 16) / 65535;
+	const [x, y] = [Math.cos(a) * r * SPREAD, Math.sin(a) * r * SPREAD];
+	const d = [
+		-sy * cp + cy * x + sy * sp * y,
+		sp + cp * y,
+		-cy * cp - sy * x + cy * sp * y
+	];
+	const n = Math.hypot(...d);
+	return [
+		d[0] / n,
+		d[1] / n,
+		d[2] / n
+	];
+};
+/**
+* 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.
+*/
+var trace = (lvl, o, d, max) => {
+	const { map, edges } = lvl;
+	let s = Math.max(sectorAt(lvl, o[0], o[2]), 0);
+	let t = 0;
+	for (let hop = 0; hop <= map.sectors.length; hop++) {
+		const { floor, ceil } = map.sectors[s];
+		let exit = Infinity;
+		let through;
+		for (const e of edges) {
+			if (e.front !== s) continue;
+			const [ex, ez] = [e.bx - e.ax, e.bz - e.az];
+			const out = d[2] * ex - d[0] * ez;
+			if (out >= 0) continue;
+			const x = Math.max(((o[2] - e.az) * ex - (o[0] - e.ax) * ez) / -out, t);
+			const u = ((o[0] + x * d[0] - e.ax) * ex + (o[2] + x * d[2] - e.az) * ez) / (ex * ex + ez * ez);
+			if (u > -1e-9 && u < 1 + 1e-9 && (x < exit - 1e-9 || x < exit + 1e-9 && e.back < 0)) [exit, through] = [x, e];
+		}
+		const flat = d[1] < 0 ? (floor - o[1]) / d[1] : d[1] > 0 ? (ceil - o[1]) / d[1] : Infinity;
+		if (flat <= exit || !through) return Math.min(Math.max(flat, t), max);
+		if (exit >= max) return max;
+		const y = o[1] + exit * d[1];
+		const k = through.back < 0 ? void 0 : map.sectors[through.back];
+		if (!k || y < Math.max(floor, k.floor) || y > Math.min(ceil, k.ceil)) return exit;
+		[s, t] = [through.back, exit];
+	}
+	return t;
+};
+/**
+* Distance at which the ray enters the upright cylinder of t (sides and caps), Infinity on a miss:
+* the span of the ray inside the infinite cylinder, cut to the span between the cap planes.
+*/
+var hit = (o, d, t) => {
+	const [px, pz] = [o[0] - t.x, o[2] - t.z];
+	const a = d[0] * d[0] + d[2] * d[2];
+	const b = px * d[0] + pz * d[2];
+	const c = px * px + pz * pz - PLAYER_R * PLAYER_R;
+	let [lo, hi] = [0, Infinity];
+	if (a > 1e-12) {
+		const q = b * b - a * c;
+		if (q < 0) return Infinity;
+		[lo, hi] = [Math.max(0, (-b - Math.sqrt(q)) / a), (-b + Math.sqrt(q)) / a];
+	} else if (c > 0) return Infinity;
+	const [y0, y1] = [t.y - o[1], t.y + PLAYER_H - o[1]];
+	if (d[1]) {
+		const [u, v] = [y0 / d[1], y1 / d[1]];
+		lo = Math.max(lo, Math.min(u, v));
+		hi = Math.min(hi, Math.max(u, v));
+	} else if (y0 > 0 || y1 < 0) return Infinity;
+	return lo <= hi ? lo : Infinity;
+};
+/**
+* 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.
+*/
+var fire = (lvl, shooter, seq, targets) => {
+	const o = [
+		shooter.x,
+		shooter.y + EYE,
+		shooter.z
+	];
+	const d = aim(shooter.yaw, shooter.pitch, seq);
+	let t = trace(lvl, o, d, 100);
+	let id = -1;
+	for (const p of targets) {
+		const u = p.id === shooter.id ? Infinity : hit(o, d, p);
+		if (u < t) [t, id] = [u, p.id];
+	}
+	return {
+		id: shooter.id,
+		x: o[0] + d[0] * t,
+		y: o[1] + d[1] * t,
+		z: o[2] + d[2] * t,
+		hit: id
+	};
+};
+// 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.
+*   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.
+*/
+var Room = class {
+	/** Every connected peer; null until it joins. */
+	peers = /* @__PURE__ */ new Map();
+	ticks = 0;
+	/** The players as each snapshot of the last MAX_REWIND ticks sent them. */
+	history = [];
+	/** Shots resolved since the last snapshot. */
+	shots = [];
+	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--;
+			if (move(p.state, input, LEVEL)) this.shots.push(fire(LEVEL, p.state, input.seq, this.rewind(p, input.view)));
+			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) {
+			this.history.push({
+				tick: this.ticks,
+				players: players.map((p) => ({ ...p.state }))
+			});
+			while (this.history[0].tick < this.ticks - 30) this.history.shift();
+			const snap = encodeSnapshot({
+				tick: this.ticks,
+				players: players.map((p) => ({
+					...p.state,
+					ack: p.ack
+				})),
+				shots: this.shots
+			});
+			this.shots = [];
+			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;
+	}
+	/**
+	* 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.
+	*/
+	rewind(shooter, view = 0) {
+		const now = this.players().filter((p) => p !== shooter).map((p) => p.state);
+		const [first, last] = [this.history[0], this.history.at(-1)];
+		if (!first || !last) return now;
+		const back = ((this.ticks - view + 32768) % 65536 + 65536) % 65536 - 32768;
+		const t = Math.min(Math.max(this.ticks - back, first.tick), last.tick);
+		let k = 0;
+		while (k + 1 < this.history.length && this.history[k + 1].tick <= t) k++;
+		const [a, b] = [this.history[k], this.history[k + 1] ?? this.history[k]];
+		const u = b.tick > a.tick ? (t - a.tick) / (b.tick - a.tick) : 0;
+		return now.map((p) => {
+			const pa = a.players.find((q) => q.id === p.id);
+			const pb = b.players.find((q) => q.id === p.id);
+			const l = (m, n) => m + (n - m) * u;
+			return pa && pb ? {
+				...pb,
+				x: l(pa.x, pb.x),
+				y: l(pa.y, pb.y),
+				z: l(pa.z, pb.z)
+			} : pb ?? pa ?? p;
+		});
+	}
+	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 };