@myvillage/cli 2.7.0 → 2.8.0

package/vendor/realtime/myvillage-realtime-client.js

@@ -0,0 +1,634 @@
+// myvillage-realtime client v0.2.0 — generated by myvillage-realtime (npm run build:client).
+// Do not edit: regenerate from https://github.com/myvillageproject/myvillage-realtime
+//#region src/shared/protocol.ts
+/** Server simulation/snapshot rate. */
+var TICK_HZ = 20;
+/** Fixed client input rate; every input advances that player's sim by INPUT_DT. */
+var INPUT_HZ = 30;
+var INPUT_DT = 1 / 30;
+var PROTOCOL_VERSION = 1;
+/** WebSocket close codes the room uses (4000-4999 is app-defined). */
+var CloseCode = {
+	Replaced: 4001,
+	MatchOver: 4002,
+	Full: 4003,
+	BadTicket: 4004
+};
+//#endregion
+//#region src/shared/sim.ts
+function clamp(v, min, max) {
+	return v < min ? min : v > max ? max : v;
+}
+/** Unit vector a player at `yaw` faces (yaw 0 → -Z, matching three.js cameras). */
+function forwardOf(yaw) {
+	return {
+		x: -Math.sin(yaw),
+		z: -Math.cos(yaw)
+	};
+}
+/** Sanitise raw stick input to a vector of length <= 1. */
+function normalizeMove(mx, mz) {
+	const x = Number.isFinite(mx) ? clamp(mx, -1, 1) : 0;
+	const z = Number.isFinite(mz) ? clamp(mz, -1, 1) : 0;
+	const len = Math.hypot(x, z);
+	return len > 1 ? {
+		x: x / len,
+		z: z / len
+	} : {
+		x,
+		z
+	};
+}
+/** Push a circle out of the arena bounds and every wall. Mutates `p`. */
+function resolveCollisions(p, radius, map) {
+	for (let pass = 0; pass < 2; pass++) {
+		for (const b of map.walls) pushOutOfBox(p, radius, b);
+		const hx = map.width / 2 - radius;
+		const hz = map.depth / 2 - radius;
+		p.x = clamp(p.x, -hx, hx);
+		p.z = clamp(p.z, -hz, hz);
+	}
+}
+function pushOutOfBox(p, r, b) {
+	const cx = clamp(p.x, b.minX, b.maxX);
+	const cz = clamp(p.z, b.minZ, b.maxZ);
+	const dx = p.x - cx;
+	const dz = p.z - cz;
+	const d2 = dx * dx + dz * dz;
+	if (d2 >= r * r) return;
+	if (d2 > 1e-12) {
+		const d = Math.sqrt(d2);
+		p.x = cx + dx / d * r;
+		p.z = cz + dz / d * r;
+		return;
+	}
+	const left = p.x - b.minX;
+	const right = b.maxX - p.x;
+	const back = p.z - b.minZ;
+	const front = b.maxZ - p.z;
+	const m = Math.min(left, right, back, front);
+	if (m === left) p.x = b.minX - r;
+	else if (m === right) p.x = b.maxX + r;
+	else if (m === back) p.z = b.minZ - r;
+	else p.z = b.maxZ + r;
+}
+/** Advance a position by one input step. Mutates `p`. */
+function stepMove(p, input, speed, radius, map, dt) {
+	const m = normalizeMove(input.mx, input.mz);
+	const f = forwardOf(Number.isFinite(input.yaw) ? input.yaw : 0);
+	const rx = -f.z;
+	const rz = f.x;
+	p.x += (rx * m.x + f.x * m.z) * speed * dt;
+	p.z += (rz * m.x + f.z * m.z) * speed * dt;
+	resolveCollisions(p, radius, map);
+}
+/** Distance along a ray to an AABB, or null if missed (slab method). */
+function rayBox(o, d, b) {
+	let tmin = 0;
+	let tmax = Infinity;
+	for (const [oa, da, lo, hi] of [[
+		o.x,
+		d.x,
+		b.minX,
+		b.maxX
+	], [
+		o.z,
+		d.z,
+		b.minZ,
+		b.maxZ
+	]]) {
+		if (Math.abs(da) < 1e-12) {
+			if (oa < lo || oa > hi) return null;
+			continue;
+		}
+		let t1 = (lo - oa) / da;
+		let t2 = (hi - oa) / da;
+		if (t1 > t2) [t1, t2] = [t2, t1];
+		tmin = Math.max(tmin, t1);
+		tmax = Math.min(tmax, t2);
+		if (tmin > tmax) return null;
+	}
+	return tmin;
+}
+/** Distance along a (unit) ray to a circle, or null if missed. */
+function rayCircle(o, d, c, r) {
+	const ox = o.x - c.x;
+	const oz = o.z - c.z;
+	const b = ox * d.x + oz * d.z;
+	const cc = ox * ox + oz * oz - r * r;
+	const disc = b * b - cc;
+	if (disc < 0) return null;
+	const s = Math.sqrt(disc);
+	const t = -b - s;
+	if (t >= 0) return t;
+	return -b + s >= 0 ? 0 : null;
+}
+/** Distance to the first wall along the ray, capped at `range`. */
+function wallDistance(o, d, map, range) {
+	let best = range;
+	for (const b of map.walls) {
+		const t = rayBox(o, d, b);
+		if (t !== null && t < best) best = t;
+	}
+	return best;
+}
+/**
+* Hitscan from `origin` along `yaw`. Returns the nearest target hit before any
+* wall and within `range`, plus how far the shot travelled.
+*/
+function castShot(origin, yaw, range, map, targets, radius) {
+	const d = forwardOf(yaw);
+	const wall = wallDistance(origin, d, map, range);
+	let hit = null;
+	let dist = wall;
+	for (const t of targets) {
+		const td = rayCircle(origin, d, t, radius);
+		if (td !== null && td < dist) {
+			dist = td;
+			hit = t.id;
+		}
+	}
+	return {
+		hit,
+		dist
+	};
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.152.0/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.152.0/helpers/esm/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.152.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.152.0/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+//#region client/arena-client.ts
+var MAX_STEPS_PER_UPDATE = 4;
+var MAX_PENDING = 120;
+var SNAPSHOT_BUFFER = 20;
+var SNAP_CORRECTION = 2;
+var SMOOTH_HALF_LIFE = .05;
+var PING_EVERY_MS = 2e3;
+function lerpAngle(a, b, t) {
+	let d = (b - a) % (Math.PI * 2);
+	if (d > Math.PI) d -= Math.PI * 2;
+	if (d < -Math.PI) d += Math.PI * 2;
+	return a + d * t;
+}
+var ArenaClient = class {
+	constructor(opts) {
+		_defineProperty(this, "opts", void 0);
+		_defineProperty(this, "cfg", null);
+		_defineProperty(this, "you", null);
+		_defineProperty(this, "phase", "waiting");
+		_defineProperty(this, "timeLeft", 0);
+		_defineProperty(this, "rttMs", 0);
+		_defineProperty(this, "controls", {
+			mx: 0,
+			mz: 0,
+			yaw: 0,
+			pitch: 0,
+			fire: false
+		});
+		_defineProperty(this, "self", {
+			x: 0,
+			z: 0,
+			yaw: 0,
+			pitch: 0,
+			hp: 0,
+			alive: true,
+			it: false,
+			score: 0
+		});
+		_defineProperty(this, "ws", null);
+		_defineProperty(this, "seq", 0);
+		_defineProperty(this, "pending", []);
+		_defineProperty(this, "acc", 0);
+		_defineProperty(this, "snaps", []);
+		_defineProperty(this, "clockOffsetMs", null);
+		_defineProperty(this, "smooth", {
+			x: 0,
+			z: 0
+		});
+		_defineProperty(this, "pingTimer", null);
+		_defineProperty(this, "listeners", {
+			snapshot: /* @__PURE__ */ new Set(),
+			event: /* @__PURE__ */ new Set(),
+			end: /* @__PURE__ */ new Set(),
+			error: /* @__PURE__ */ new Set(),
+			close: /* @__PURE__ */ new Set()
+		});
+		this.opts = opts;
+	}
+	on(type, fn) {
+		this.listeners[type].add(fn);
+		return () => this.listeners[type].delete(fn);
+	}
+	connect() {
+		return new Promise((resolve, reject) => {
+			const url = `${this.opts.wsUrl}?ticket=${encodeURIComponent(this.opts.ticket)}`;
+			const ws = new WebSocket(url);
+			this.ws = ws;
+			let welcomed = false;
+			ws.onmessage = (e) => {
+				const msg = JSON.parse(String(e.data));
+				if (msg.t === "welcome") {
+					welcomed = true;
+					this.onWelcome(msg);
+					resolve(msg);
+				} else if (msg.t === "error") {
+					this.emit("error", msg);
+					if (!welcomed) reject(new Error(msg.message));
+				} else this.onMessage(msg);
+			};
+			ws.onclose = (e) => {
+				this.stopPing();
+				if (!welcomed) reject(new Error(e.reason || `Connection closed (${e.code})`));
+				this.emit("close", {
+					code: e.code,
+					reason: e.reason
+				});
+			};
+		});
+	}
+	close() {
+		this.stopPing();
+		this.ws?.close(1e3, "leaving");
+	}
+	/** Call once per rendered frame. Sends fixed-rate inputs and runs prediction. */
+	update(dtSec) {
+		if (!this.ws || this.ws.readyState !== WebSocket.OPEN || !this.cfg) return;
+		this.self.yaw = this.controls.yaw;
+		this.self.pitch = this.controls.pitch;
+		this.acc += dtSec;
+		let steps = 0;
+		while (this.acc >= .03333333333333333 && steps < MAX_STEPS_PER_UPDATE) {
+			this.acc -= INPUT_DT;
+			steps++;
+			this.sendInput();
+		}
+		if (steps === MAX_STEPS_PER_UPDATE) this.acc = 0;
+		const decay = Math.pow(.5, dtSec / SMOOTH_HALF_LIFE);
+		this.smooth.x *= decay;
+		this.smooth.z *= decay;
+	}
+	/** Where to draw yourself this frame (prediction + smoothed corrections). */
+	get view() {
+		return {
+			...this.self,
+			x: this.self.x + this.smooth.x,
+			z: this.self.z + this.smooth.z
+		};
+	}
+	/** Other players, interpolated at the current render time. */
+	others(nowMs = performance.now()) {
+		const rt = this.renderTick(nowMs);
+		if (!this.snaps.length) return [];
+		let a = this.snaps[0];
+		let b = this.snaps[0];
+		for (let i = 0; i < this.snaps.length; i++) {
+			if (this.snaps[i].tick <= rt) a = this.snaps[i];
+			if (this.snaps[i].tick >= rt) {
+				b = this.snaps[i];
+				break;
+			}
+			b = this.snaps[i];
+		}
+		const t = b.tick === a.tick ? 0 : Math.min(1, Math.max(0, (rt - a.tick) / (b.tick - a.tick)));
+		const out = [];
+		for (const [id, pb] of b.players) {
+			if (id === this.you) continue;
+			const pa = a.players.get(id);
+			if (!pa || !pa.a || !pb.a || Math.hypot(pb.x - pa.x, pb.z - pa.z) > 4) {
+				out.push(pb);
+				continue;
+			}
+			out.push({
+				...pb,
+				x: pa.x + (pb.x - pa.x) * t,
+				z: pa.z + (pb.z - pa.z) * t,
+				y: lerpAngle(pa.y, pb.y, t),
+				p: pa.p + (pb.p - pa.p) * t
+			});
+		}
+		return out;
+	}
+	/** Latest authoritative snapshot of every player (scores, names, hp). */
+	get roster() {
+		const last = this.snaps[this.snaps.length - 1];
+		return last ? [...last.players.values()] : [];
+	}
+	onWelcome(msg) {
+		this.cfg = msg.cfg;
+		this.you = msg.you;
+		this.syncClock(msg.tick);
+		this.stopPing();
+		this.pingTimer = setInterval(() => this.ws?.send(JSON.stringify({
+			t: "ping",
+			c: performance.now()
+		})), PING_EVERY_MS);
+	}
+	onMessage(msg) {
+		if (msg.t === "s") this.onSnapshot(msg);
+		else if (msg.t === "pong") this.rttMs = performance.now() - msg.c;
+		else if (msg.t === "end") {
+			this.phase = "ended";
+			this.emit("end", msg);
+		}
+	}
+	onSnapshot(msg) {
+		this.syncClock(msg.k);
+		this.phase = msg.ph;
+		this.timeLeft = msg.tl;
+		this.snaps.push({
+			tick: msg.k,
+			players: new Map(msg.p.map((p) => [p.id, p]))
+		});
+		if (this.snaps.length > SNAPSHOT_BUFFER) this.snaps.shift();
+		const me = msg.p.find((p) => p.id === this.you);
+		if (me && this.cfg) {
+			const before = {
+				x: this.self.x + this.smooth.x,
+				z: this.self.z + this.smooth.z
+			};
+			this.self.x = me.x;
+			this.self.z = me.z;
+			this.self.hp = me.hp;
+			this.self.alive = me.a;
+			this.self.it = !!me.it;
+			this.self.score = me.s;
+			this.pending = this.pending.filter((i) => i.seq > msg.ack);
+			for (const inp of this.pending) this.predict(inp);
+			const ex = before.x - this.self.x;
+			const ez = before.z - this.self.z;
+			if (Math.hypot(ex, ez) > SNAP_CORRECTION) this.smooth = {
+				x: 0,
+				z: 0
+			};
+			else this.smooth = {
+				x: ex,
+				z: ez
+			};
+		}
+		this.emit("snapshot", msg);
+		for (const e of msg.ev ?? []) this.emit("event", e);
+	}
+	sendInput() {
+		const c = this.controls;
+		const inp = {
+			t: "i",
+			seq: ++this.seq,
+			mx: c.mx,
+			mz: c.mz,
+			yaw: c.yaw,
+			pitch: c.pitch,
+			fire: c.fire,
+			vt: Math.round(this.renderTick() * 100) / 100
+		};
+		this.predict(inp);
+		this.pending.push(inp);
+		if (this.pending.length > MAX_PENDING) this.pending.shift();
+		this.ws.send(JSON.stringify(inp));
+	}
+	/** Mirror of the server's applyInput movement rules. */
+	predict(inp) {
+		const cfg = this.cfg;
+		if (!this.self.alive || this.phase === "countdown" || this.phase === "ended") return;
+		const speed = cfg.moveSpeed * (this.self.it ? cfg.itSpeedMultiplier : 1);
+		stepMove(this.self, inp, speed, cfg.playerRadius, cfg.map, INPUT_DT);
+	}
+	/** Smoothed estimate of the server tick "now", minus the interpolation delay. */
+	renderTick(nowMs = performance.now()) {
+		if (this.clockOffsetMs === null) return 0;
+		return (nowMs + this.clockOffsetMs) * 20 / 1e3 - (this.opts.interpDelayTicks ?? 2);
+	}
+	syncClock(tick) {
+		const sample = tick * 1e3 / 20 - performance.now();
+		if (this.clockOffsetMs === null || Math.abs(sample - this.clockOffsetMs) > 1e3) this.clockOffsetMs = sample;
+		else this.clockOffsetMs += (sample - this.clockOffsetMs) * .1;
+	}
+	stopPing() {
+		if (this.pingTimer) clearInterval(this.pingTimer);
+		this.pingTimer = null;
+	}
+	emit(type, arg) {
+		for (const fn of this.listeners[type]) fn(arg);
+	}
+};
+var DEFAULT_ARENA_CONFIG = {
+	mode: "elimination",
+	minPlayers: 2,
+	maxPlayers: 8,
+	durationSec: 180,
+	countdownSec: 3,
+	moveSpeed: 6,
+	playerRadius: .4,
+	maxHp: 100,
+	damage: 25,
+	fireCooldownMs: 300,
+	weaponRange: 40,
+	respawnSec: 3,
+	tagRange: 2,
+	tagCooldownSec: 2,
+	itSpeedMultiplier: 1.1,
+	map: {
+		width: 40,
+		depth: 40,
+		walls: [
+			{
+				minX: -2,
+				minZ: -2,
+				maxX: 2,
+				maxZ: 2,
+				height: 3
+			},
+			{
+				minX: -12,
+				minZ: -12,
+				maxX: -8,
+				maxZ: -10,
+				height: 2
+			},
+			{
+				minX: 8,
+				minZ: 10,
+				maxX: 12,
+				maxZ: 12,
+				height: 2
+			},
+			{
+				minX: -12,
+				minZ: 8,
+				maxX: -10,
+				maxZ: 14,
+				height: 2
+			},
+			{
+				minX: 10,
+				minZ: -14,
+				maxX: 12,
+				maxZ: -8,
+				height: 2
+			},
+			{
+				minX: -1,
+				minZ: -16,
+				maxX: 1,
+				maxZ: -9,
+				height: 2.5
+			},
+			{
+				minX: -1,
+				minZ: 9,
+				maxX: 1,
+				maxZ: 16,
+				height: 2.5
+			}
+		],
+		spawns: [
+			{
+				x: -16,
+				z: -16,
+				yaw: -3 * Math.PI / 4
+			},
+			{
+				x: 16,
+				z: 16,
+				yaw: Math.PI / 4
+			},
+			{
+				x: -16,
+				z: 16,
+				yaw: -Math.PI / 4
+			},
+			{
+				x: 16,
+				z: -16,
+				yaw: 3 * Math.PI / 4
+			},
+			{
+				x: 0,
+				z: -18,
+				yaw: Math.PI
+			},
+			{
+				x: 0,
+				z: 18,
+				yaw: 0
+			},
+			{
+				x: -18,
+				z: 0,
+				yaw: -Math.PI / 2
+			},
+			{
+				x: 18,
+				z: 0,
+				yaw: Math.PI / 2
+			}
+		]
+	}
+};
+var MAX_WALLS = 200;
+var MAX_SPAWNS = 32;
+function num(v, fallback, min, max) {
+	return typeof v === "number" && Number.isFinite(v) ? Math.min(max, Math.max(min, v)) : fallback;
+}
+function resolveMap(input) {
+	if (!input || typeof input !== "object") return DEFAULT_ARENA_CONFIG.map;
+	const m = input;
+	const width = num(m.width, 40, 10, 400);
+	const depth = num(m.depth, 40, 10, 400);
+	const walls = Array.isArray(m.walls) ? m.walls.slice(0, MAX_WALLS).flatMap((w) => {
+		if (!w || typeof w !== "object") return [];
+		if (![
+			w.minX,
+			w.minZ,
+			w.maxX,
+			w.maxZ
+		].every((v) => typeof v === "number" && Number.isFinite(v))) return [];
+		if (w.maxX <= w.minX || w.maxZ <= w.minZ) return [];
+		return [{
+			minX: w.minX,
+			minZ: w.minZ,
+			maxX: w.maxX,
+			maxZ: w.maxZ,
+			height: num(w.height, 2, .1, 50)
+		}];
+	}) : [];
+	const spawns = Array.isArray(m.spawns) ? m.spawns.slice(0, MAX_SPAWNS).flatMap((s) => {
+		if (!s || typeof s !== "object") return [];
+		if (![s.x, s.z].every((v) => typeof v === "number" && Number.isFinite(v))) return [];
+		return [{
+			x: num(s.x, 0, -width / 2, width / 2),
+			z: num(s.z, 0, -depth / 2, depth / 2),
+			yaw: num(s.yaw, 0, -10, 10)
+		}];
+	}) : [];
+	return {
+		width,
+		depth,
+		walls,
+		spawns: spawns.length ? spawns : [{
+			x: 0,
+			z: 0,
+			yaw: 0
+		}]
+	};
+}
+/** Merge untrusted overrides over the defaults, clamping everything. */
+function resolveArenaConfig(overrides) {
+	const o = overrides && typeof overrides === "object" ? overrides : {};
+	const d = DEFAULT_ARENA_CONFIG;
+	const maxPlayers = Math.round(num(o.maxPlayers, d.maxPlayers, 2, 16));
+	return {
+		mode: o.mode === "tag" || o.mode === "elimination" ? o.mode : d.mode,
+		minPlayers: Math.round(num(o.minPlayers, d.minPlayers, 1, maxPlayers)),
+		maxPlayers,
+		durationSec: num(o.durationSec, d.durationSec, 15, 1800),
+		countdownSec: num(o.countdownSec, d.countdownSec, 0, 10),
+		moveSpeed: num(o.moveSpeed, d.moveSpeed, 1, 20),
+		playerRadius: num(o.playerRadius, d.playerRadius, .2, 2),
+		maxHp: num(o.maxHp, d.maxHp, 1, 1e3),
+		damage: num(o.damage, d.damage, 1, 1e3),
+		fireCooldownMs: num(o.fireCooldownMs, d.fireCooldownMs, 50, 5e3),
+		weaponRange: num(o.weaponRange, d.weaponRange, 1, 200),
+		respawnSec: num(o.respawnSec, d.respawnSec, 0, 30),
+		tagRange: num(o.tagRange, d.tagRange, .5, 10),
+		tagCooldownSec: num(o.tagCooldownSec, d.tagCooldownSec, 0, 10),
+		itSpeedMultiplier: num(o.itSpeedMultiplier, d.itSpeedMultiplier, .5, 2),
+		map: o.map === void 0 ? d.map : resolveMap(o.map)
+	};
+}
+//#endregion
+export { ArenaClient, CloseCode, DEFAULT_ARENA_CONFIG, INPUT_DT, INPUT_HZ, PROTOCOL_VERSION, TICK_HZ, castShot, forwardOf, resolveArenaConfig, stepMove };