1681-engine 0.0.0-stage → 0.5.9

package/dist/net/lobby/LobbyHost.js

@@ -0,0 +1,365 @@
+import { LobbyRooms as c } from "./LobbyRooms.js";
+import { Matchmaker as d } from "./Matchmaker.js";
+class p {
+  constructor(t = {}) {
+    this.options = t, this.now = t.now ?? Date.now, this.rooms = new c(t.random), this.matchmaker = new d(t.modes ?? []);
+  }
+  options;
+  rooms;
+  matchmaker;
+  sockets = /* @__PURE__ */ new Map();
+  members = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  /** Rooms whose match started, by match id, so `finish` can open them again. */
+  playing = /* @__PURE__ */ new Map();
+  nextId = 1;
+  nextMatch = 1;
+  listDirty = !1;
+  timer = null;
+  now;
+  /** A socket connected; returns the id its messages and its close are reported under. */
+  connect(t) {
+    const s = this.nextId++;
+    return this.sockets.set(s, t), s;
+  }
+  /** Socket `id` closed: out of its room, the queue and any match being accepted. */
+  disconnect(t) {
+    this.sockets.delete(t);
+    const s = this.members.get(t);
+    s && (this.leaveQueue(s, !1), this.cancelPendingFor(t, "left"), this.leaveRoom(s), this.members.delete(t), this.options.onLeave?.(t));
+  }
+  /** A message arrived from socket `id`. */
+  message(t, s) {
+    if (typeof s != "string") return;
+    let e;
+    try {
+      e = JSON.parse(s);
+    } catch {
+      return;
+    }
+    if (!e || typeof e != "object" || typeof e.t != "string") return;
+    if (e.t === "hello") return this.hello(t, e.data);
+    if (e.t === "ping") {
+      typeof e.c == "number" && Number.isFinite(e.c) && this.send(t, { t: "pong", c: e.c, st: this.now() });
+      return;
+    }
+    const o = this.members.get(t);
+    if (!o || !this.allow(o)) return;
+    this.handle(o, e) || this.options.onMessage?.(t, e);
+  }
+  /** A player's public data (what `admit` returned). */
+  dataOf(t) {
+    return this.members.get(t)?.data;
+  }
+  /** Sends one of the game's own messages to a player. */
+  send(t, s) {
+    this.sockets.get(t)?.send(JSON.stringify(s));
+  }
+  /** Searches the queue and runs the ready checks on a timer. */
+  start() {
+    this.timer || (this.timer = setInterval(() => this.update(), this.options.matchEveryMs ?? 1e3));
+  }
+  stop() {
+    this.timer && clearInterval(this.timer), this.timer = null;
+  }
+  /** One round: lapsed ready checks cancelled, the queue searched, the room list pushed if it changed. */
+  update(t = this.now()) {
+    for (const s of [...this.pending.values()]) t >= s.expiresAt && this.cancel(s, "timeout");
+    for (const s of this.matchmaker.find(t)) this.found(s, t);
+    this.listDirty && this.pushList();
+  }
+  /** A started match is over: its rooms open again, their members not ready. */
+  finish(t) {
+    const s = this.playing.get(t);
+    this.playing.delete(t);
+    for (const e of s ?? []) {
+      const o = this.rooms.get(e);
+      o && (o.playing = !1, o.ready.clear(), this.pushRoom(o));
+    }
+    this.listDirty = !0;
+  }
+  // ── messages ─────────────────────────────────────────────────────────────────────────────────────────────────
+  hello(t, s) {
+    if (this.members.has(t)) return;
+    let e;
+    try {
+      e = this.options.admit ? this.options.admit(s, t) : s;
+    } catch (o) {
+      this.sockets.get(t)?.close(4003, o instanceof Error ? o.message : "refused");
+      return;
+    }
+    this.members.set(t, { id: t, data: e, ticket: null, lockedUntil: 0, match: null, rateWindow: 0, rateCount: 0 }), this.send(t, { t: "lobby/welcome", id: t, modes: (this.options.modes ?? []).map((o) => o.id) }), this.send(t, { t: "lobby/rooms", rooms: this.rooms.listed(this.options.listLimit ?? 50) }), this.options.onJoin?.(t);
+  }
+  /** True when the lobby handled it (or refused it). */
+  handle(t, s) {
+    switch (s.t) {
+      case "lobby/list":
+        return this.send(t.id, { t: "lobby/rooms", rooms: this.rooms.listed(this.options.listLimit ?? 50) }), !0;
+      case "lobby/create":
+        return this.create(t, s), !0;
+      case "lobby/join":
+        return this.join(t, s), !0;
+      case "lobby/leave":
+        return this.rooms.of(t.id) ? (t.match && this.cancelPendingFor(t.id, "left"), this.leaveRoom(t)) : this.error(t, "not-in-room", "You are not in a room"), !0;
+      case "lobby/ready":
+        return this.ready(t, s.ready === !0), !0;
+      case "lobby/kick":
+        return this.kick(t, s.player), !0;
+      case "lobby/promote":
+        return this.promote(t, s.player), !0;
+      case "lobby/settings": {
+        const e = this.hostRoom(t);
+        return e && (e.queued || e.playing) ? this.error(t, "room-busy", "Leave the queue first") : e && (e.settings = s.settings, e.ready.clear(), this.pushRoom(e)), !0;
+      }
+      case "lobby/chat": {
+        const e = this.rooms.of(t.id);
+        if (!e || typeof s.text != "string")
+          return this.error(t, "not-in-room", "You are not in a room"), !0;
+        const o = s.text.trim().slice(0, this.options.chatMax ?? 200);
+        if (o) for (const i of e.members) this.send(i, { t: "lobby/chat", from: t.id, text: o });
+        return !0;
+      }
+      case "lobby/start":
+        return this.startRoom(t), !0;
+      case "queue/join":
+        return this.queue(t, s.mode), !0;
+      case "queue/leave":
+        return this.leaveQueue(t, !0), !0;
+      case "match/accept":
+        return this.answer(t, !0), !0;
+      case "match/decline":
+        return this.answer(t, !1), !0;
+      default:
+        return !1;
+    }
+  }
+  create(t, s) {
+    if (this.rooms.of(t.id)) return this.error(t, "in-room", "Leave your room first");
+    if (t.ticket || t.match) return this.error(t, "queued", "Leave the queue first");
+    const e = this.options.maxRoomPlayers ?? 8, o = Number.isInteger(s.maxPlayers) ? Math.max(1, Math.min(e, s.maxPlayers)) : e, i = this.options.modes ?? [], h = typeof s.mode == "string" ? s.mode.slice(0, 32) : i[0]?.id ?? "custom", n = typeof s.name == "string" && s.name.trim() ? s.name.trim().slice(0, this.options.nameMax ?? 32) : `Room ${this.rooms.count + 1}`, r = this.rooms.create(t.id, { name: n, mode: h, maxPlayers: o, private: s.private === !0, settings: s.settings ?? null });
+    this.pushRoom(r), this.listDirty = !0;
+  }
+  join(t, s) {
+    if (this.rooms.of(t.id)) return this.error(t, "in-room", "Leave your room first");
+    if (t.ticket || t.match) return this.error(t, "queued", "Leave the queue first");
+    const e = typeof s.code == "string" ? this.rooms.byInvite(s.code) : typeof s.room == "string" ? this.rooms.get(s.room) : void 0;
+    if (!e || e.private && typeof s.code != "string") return this.error(t, "no-room", "No such room");
+    if (e.queued || e.playing) return this.error(t, "room-busy", "That room is busy");
+    if (e.members.length >= e.maxPlayers) return this.error(t, "room-full", "That room is full");
+    this.rooms.join(t.id, e), this.pushRoom(e), this.listDirty = !0;
+  }
+  ready(t, s) {
+    const e = this.rooms.of(t.id);
+    if (!e) return this.error(t, "not-in-room", "You are not in a room");
+    if (e.queued || e.playing) return this.error(t, "room-busy", "Leave the queue first");
+    s ? e.ready.add(t.id) : e.ready.delete(t.id), this.pushRoom(e);
+  }
+  kick(t, s) {
+    const e = this.hostRoom(t);
+    if (!e || typeof s != "number" || s === t.id || !e.members.includes(s)) return;
+    const o = this.members.get(s);
+    o && (e.queued && this.dequeueRoom(e), this.leaveRoom(o), this.send(s, { t: "lobby/kicked" }));
+  }
+  promote(t, s) {
+    const e = this.hostRoom(t);
+    !e || typeof s != "number" || !e.members.includes(s) || s === t.id || (e.host = s, e.ready.delete(s), this.pushRoom(e));
+  }
+  /** The room `m` hosts, or an error to them. */
+  hostRoom(t) {
+    const s = this.rooms.of(t.id);
+    if (!s) this.error(t, "not-in-room", "You are not in a room");
+    else if (s.host !== t.id) this.error(t, "not-host", "Only the host can do that");
+    else return s;
+    return null;
+  }
+  startRoom(t) {
+    const s = this.hostRoom(t);
+    if (!s) return;
+    if (s.queued || s.playing) return this.error(t, "room-busy", "That room is busy");
+    if (!this.rooms.allReady(s)) return this.error(t, "not-ready", "Not everyone is ready");
+    const e = `M${this.nextMatch++}`, o = s.members.map((i) => ({ id: i, data: this.members.get(i)?.data, team: 0 }));
+    if (s.playing = !0, this.listDirty = !0, !this.begin(e, s.mode, o, [s], s)) {
+      s.playing = !1;
+      return;
+    }
+    this.pushRoom(s);
+  }
+  // ── the queue ────────────────────────────────────────────────────────────────────────────────────────────────
+  queue(t, s) {
+    const e = typeof s == "string" ? this.matchmaker.mode(s) : void 0;
+    if (!e) return this.error(t, "no-mode", "No such mode");
+    if (t.match) return this.error(t, "queued", "A match is waiting for you");
+    const o = this.rooms.of(t.id), i = o ? o.members : [t.id];
+    if (o) {
+      if (o.host !== t.id) return this.error(t, "not-host", "Only the host can queue the room");
+      if (o.queued || o.playing) return this.error(t, "room-busy", "The room is already queued");
+      if (!this.rooms.allReady(o)) return this.error(t, "not-ready", "Not everyone is ready");
+    } else if (t.ticket) return this.error(t, "queued", "You are already queued");
+    if (i.length > e.teamSize) return this.error(t, "too-many", `A team holds ${e.teamSize}`);
+    const h = this.now(), n = Math.max(...i.map((a) => this.members.get(a)?.lockedUntil ?? 0));
+    if (n > h)
+      return this.send(t.id, { t: "queue/locked", until: n }), this.error(t, "locked", "Someone in your group declined a match recently");
+    const r = { id: o ? `r:${o.id}` : `p:${t.id}`, mode: e.id, members: [...i], rating: this.ratingOf(i, e.id), since: h };
+    this.matchmaker.add(r), o && (o.queued = !0, this.pushRoom(o), this.listDirty = !0);
+    for (const a of i) {
+      const u = this.members.get(a);
+      u && (u.ticket = r.id);
+    }
+    this.pushQueue(r);
+  }
+  ratingOf(t, s) {
+    const e = this.options.ratingOf;
+    if (!e) return 1e3;
+    let o = 0;
+    for (const i of t) o += e(i, this.members.get(i).data, s);
+    return o / t.length;
+  }
+  /** Takes `m` (or its whole room) out of the queue. */
+  leaveQueue(t, s) {
+    if (!t.ticket) {
+      s && this.error(t, "queued", "You are not queued");
+      return;
+    }
+    const e = this.rooms.of(t.id);
+    if (e?.queued) return this.dequeueRoom(e);
+    this.matchmaker.remove(t.ticket), t.ticket = null, s && this.send(t.id, { t: "queue/status", mode: null, since: 0, waiting: 0 });
+  }
+  dequeueRoom(t) {
+    this.matchmaker.remove(`r:${t.id}`), t.queued = !1;
+    for (const s of t.members) {
+      const e = this.members.get(s);
+      e && (e.ticket = null), this.send(s, { t: "queue/status", mode: null, since: 0, waiting: 0 });
+    }
+    this.pushRoom(t), this.listDirty = !0;
+  }
+  pushQueue(t) {
+    const s = this.matchmaker.waiting(t.mode).length - 1;
+    for (const e of t.members) this.send(e, { t: "queue/status", mode: t.mode, since: t.since, waiting: s });
+  }
+  // ── found matches and the ready check ───────────────────────────────────────────────────────────────────────
+  found(t, s) {
+    const e = `M${this.nextMatch++}`, o = t.teams.flatMap((n, r) => n.map((a) => ({ id: a, data: this.members.get(a)?.data, team: r })));
+    for (const n of o) {
+      const r = this.members.get(n.id);
+      r && (r.ticket = null, r.match = e);
+    }
+    const i = this.options.readyCheckMs ?? 15e3;
+    if (i <= 0) {
+      this.startFound(e, t, o);
+      return;
+    }
+    const h = { id: e, found: t, players: o, accepted: /* @__PURE__ */ new Set(), declined: /* @__PURE__ */ new Set(), expiresAt: s + i };
+    this.pending.set(e, h);
+    for (const n of o) this.send(n.id, { t: "match/found", match: e, mode: t.mode, players: o, expiresAt: h.expiresAt });
+  }
+  answer(t, s) {
+    const e = t.match ? this.pending.get(t.match) : void 0;
+    if (!e) return;
+    if (!s)
+      return e.declined.add(t.id), this.cancel(e, "declined");
+    e.accepted.add(t.id);
+    const o = [...e.accepted];
+    for (const i of e.players) this.send(i.id, { t: "match/accepted", match: e.id, accepted: o });
+    e.accepted.size === e.players.length && (this.pending.delete(e.id), this.startFound(e.id, e.found, e.players));
+  }
+  startFound(t, s, e) {
+    const o = s.tickets.filter((i) => i.id.startsWith("r:")).map((i) => this.rooms.get(i.id.slice(2))).filter((i) => !!i);
+    for (const i of o)
+      i.queued = !1, i.playing = !0;
+    if (!this.begin(t, s.mode, e, o)) {
+      for (const i of o)
+        i.playing = !1, i.queued = !0;
+      for (const i of s.tickets) this.requeue(i);
+      return;
+    }
+    for (const i of o) this.pushRoom(i);
+    this.listDirty = !0;
+  }
+  /** Calls `onStart` and tells everyone where to go; false (nothing sent) when it threw. */
+  begin(t, s, e, o, i) {
+    let h = null;
+    try {
+      const n = { id: t, mode: s, players: e };
+      i && (n.room = i.id, n.settings = i.settings), h = this.options.onStart?.(n) ?? null;
+    } catch (n) {
+      for (const r of e) {
+        const a = this.members.get(r.id);
+        a && (a.match = null), this.send(r.id, { t: "match/cancelled", match: t, reason: "left", requeued: !i }), i && this.send(r.id, { t: "lobby/error", code: "bad-request", message: n instanceof Error ? n.message : "could not start" });
+      }
+      return !1;
+    }
+    o.length && this.playing.set(t, o.map((n) => n.id));
+    for (const n of e) {
+      const r = this.members.get(n.id);
+      r && (r.match = null);
+      const a = typeof h == "function" ? h(n.id) : h;
+      this.send(n.id, { t: "match/start", match: t, mode: s, players: e, data: a });
+    }
+    return !0;
+  }
+  /** A ready check failed: whoever did not accept is locked out, every group that did goes back to its place. */
+  cancel(t, s) {
+    this.pending.delete(t.id);
+    const e = this.now(), o = this.options.declineLockMs ?? 3e4, i = new Set(s === "timeout" ? t.players.map((h) => h.id).filter((h) => !t.accepted.has(h)) : t.declined);
+    for (const h of t.found.tickets) {
+      if (h.members.some((r) => i.has(r) || !this.members.has(r))) {
+        for (const r of h.members) {
+          const a = this.members.get(r);
+          a && (a.match = null, i.has(r) && (a.lockedUntil = e + o), i.has(r) && this.send(r, { t: "queue/locked", until: a.lockedUntil }), this.send(r, { t: "match/cancelled", match: t.id, reason: s, requeued: !1 }));
+        }
+        if (h.id.startsWith("r:")) {
+          const r = this.rooms.get(h.id.slice(2));
+          r && (r.queued = !1, this.pushRoom(r), this.listDirty = !0);
+        }
+        continue;
+      }
+      this.requeue(h);
+      for (const r of h.members) this.send(r, { t: "match/cancelled", match: t.id, reason: s, requeued: !0 });
+    }
+  }
+  /** Back into the queue at its old place (its old `since`). */
+  requeue(t) {
+    this.matchmaker.add(t);
+    for (const s of t.members) {
+      const e = this.members.get(s);
+      e && (e.match = null, e.ticket = t.id);
+    }
+    this.pushQueue(t);
+  }
+  cancelPendingFor(t, s) {
+    const e = this.members.get(t), o = e?.match ? this.pending.get(e.match) : void 0;
+    o && (o.declined.add(t), this.cancel(o, s));
+  }
+  // ── rooms ────────────────────────────────────────────────────────────────────────────────────────────────────
+  leaveRoom(t) {
+    const s = this.rooms.of(t.id);
+    if (!s) return;
+    s.queued && this.dequeueRoom(s);
+    const e = this.rooms.leave(t.id);
+    this.send(t.id, { t: "lobby/room", room: null }), e && !e.closed && this.pushRoom(e.room), this.listDirty = !0;
+  }
+  pushRoom(t) {
+    if (!this.rooms.get(t.id)) return;
+    const s = this.rooms.state(t, (e) => this.members.get(e)?.data);
+    for (const e of t.members) this.send(e, { t: "lobby/room", room: s });
+  }
+  /** The list, to everyone browsing (in no room). */
+  pushList() {
+    this.listDirty = !1;
+    const t = this.rooms.listed(this.options.listLimit ?? 50);
+    for (const s of this.members.keys()) this.rooms.of(s) || this.send(s, { t: "lobby/rooms", rooms: t });
+  }
+  error(t, s, e) {
+    this.send(t.id, { t: "lobby/error", code: s, message: e });
+  }
+  /** A per-second allowance; three times over closes the socket. */
+  allow(t) {
+    const s = this.now();
+    s - t.rateWindow >= 1e3 && (t.rateWindow = s, t.rateCount = 0);
+    const e = this.options.ratePerSecond ?? 20;
+    return ++t.rateCount <= e ? !0 : (t.rateCount === e + 1 && this.error(t, "rate", "Slow down"), t.rateCount > e * 3 && (this.sockets.get(t.id)?.close(4008, "too many messages"), this.disconnect(t.id)), !1);
+  }
+}
+export {
+  p as LobbyHost
+};

package/dist/net/lobby/LobbyRooms.js

@@ -0,0 +1,65 @@
+const o = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+class i {
+  constructor(e = Math.random) {
+    this.random = e;
+  }
+  random;
+  rooms = /* @__PURE__ */ new Map();
+  byCode = /* @__PURE__ */ new Map();
+  roomOf = /* @__PURE__ */ new Map();
+  nextId = 1;
+  get count() {
+    return this.rooms.size;
+  }
+  get(e) {
+    return this.rooms.get(e);
+  }
+  byInvite(e) {
+    return this.byCode.get(e.toUpperCase());
+  }
+  of(e) {
+    return this.roomOf.get(e);
+  }
+  all() {
+    return this.rooms.values();
+  }
+  create(e, t) {
+    if (this.roomOf.has(e)) throw new Error("LobbyRooms: already in a room");
+    let s = "";
+    do
+      s = Array.from({ length: 6 }, () => o[Math.floor(this.random() * o.length)]).join("");
+    while (this.byCode.has(s));
+    const r = { id: `R${this.nextId++}`, code: s, ...t, host: e, members: [e], ready: /* @__PURE__ */ new Set(), queued: !1, playing: !1 };
+    return this.rooms.set(r.id, r), this.byCode.set(s, r), this.roomOf.set(e, r), r;
+  }
+  join(e, t) {
+    if (this.roomOf.has(e)) throw new Error("LobbyRooms: already in a room");
+    t.members.push(e), this.roomOf.set(e, t);
+  }
+  /** Takes a player out of their room; returns the room (closed when it emptied, `closed` true). */
+  leave(e) {
+    const t = this.roomOf.get(e);
+    if (!t) return null;
+    this.roomOf.delete(e);
+    const s = t.members.indexOf(e);
+    return s >= 0 && t.members.splice(s, 1), t.ready.delete(e), t.members.length === 0 ? (this.rooms.delete(t.id), this.byCode.delete(t.code), { room: t, closed: !0 }) : (t.host === e && (t.host = t.members[0], t.ready.delete(t.host)), { room: t, closed: !1 });
+  }
+  /** Everyone but the host has said they are ready. */
+  allReady(e) {
+    return e.members.every((t) => t === e.host || e.ready.has(t));
+  }
+  summary(e) {
+    return { id: e.id, name: e.name, mode: e.mode, players: e.members.length, maxPlayers: e.maxPlayers, private: e.private, busy: e.queued || e.playing };
+  }
+  state(e, t) {
+    const s = e.members.map((r) => ({ id: r, data: t(r), ready: r === e.host || e.ready.has(r) }));
+    return { ...this.summary(e), code: e.code, host: e.host, members: s, settings: e.settings, queued: e.queued };
+  }
+  /** The rooms anyone may browse: public, open, not full; the fullest first, so players gather. */
+  listed(e) {
+    return [...this.rooms.values()].filter((t) => !t.private && !t.queued && !t.playing && t.members.length < t.maxPlayers).sort((t, s) => s.members.length - t.members.length || (t.id < s.id ? -1 : 1)).slice(0, e).map((t) => this.summary(t));
+  }
+}
+export {
+  i as LobbyRooms
+};

package/dist/net/lobby/Matchmaker.js

@@ -0,0 +1,105 @@
+class l {
+  modes = /* @__PURE__ */ new Map();
+  tickets = /* @__PURE__ */ new Map();
+  constructor(e) {
+    for (const t of e) {
+      if (!(t.teams >= 1 && t.teamSize >= 1)) throw new Error(`Matchmaker: mode ${t.id} needs at least one team of one`);
+      this.modes.set(t.id, t);
+    }
+  }
+  get size() {
+    return this.tickets.size;
+  }
+  mode(e) {
+    return this.modes.get(e);
+  }
+  /** Adds a ticket (replacing one of the same id); throws on an unknown mode or a group too big for a team. */
+  add(e) {
+    const t = this.modes.get(e.mode);
+    if (!t) throw new Error(`Matchmaker: no mode ${e.mode}`);
+    if (e.members.length < 1 || e.members.length > t.teamSize) throw new Error(`Matchmaker: a group of ${e.members.length} does not fit a team of ${t.teamSize}`);
+    this.tickets.set(e.id, e);
+  }
+  remove(e) {
+    const t = this.tickets.get(e);
+    return this.tickets.delete(e), t;
+  }
+  get(e) {
+    return this.tickets.get(e);
+  }
+  /** The tickets waiting for a mode, oldest first. */
+  waiting(e) {
+    return [...this.tickets.values()].filter((t) => t.mode === e).sort((t, s) => t.since - s.since);
+  }
+  /** How far a ticket's rating window reaches now. */
+  windowOf(e, t) {
+    const s = this.modes.get(e.mode), i = Math.max(0, t - e.since) / 1e3;
+    return Math.min(s.maxWindow ?? 600, (s.window ?? 100) + (s.widenPerSecond ?? 10) * i);
+  }
+  /** Every match that can be made now; their tickets leave the queue. */
+  find(e) {
+    const t = [];
+    for (const s of this.modes.values()) {
+      const i = s.teams * s.teamSize;
+      let h = !0;
+      for (; h; ) {
+        h = !1;
+        const o = this.waiting(s.id);
+        for (const r of o) {
+          const m = this.tryAnchor(r, o, s, i, e);
+          if (m) {
+            for (const a of m.tickets) this.tickets.delete(a.id);
+            t.push(m), h = !0;
+            break;
+          }
+        }
+      }
+    }
+    return t;
+  }
+  tryAnchor(e, t, s, i, h) {
+    const o = this.windowOf(e, h), r = t.filter((n) => n !== e && Math.abs(n.rating - e.rating) <= Math.min(o, this.windowOf(n, h))).sort((n, u) => Math.abs(n.rating - e.rating) - Math.abs(u.rating - e.rating) || n.since - u.since), m = g([e], r, i);
+    if (!m) return null;
+    const a = d(m, s.teams, s.teamSize);
+    return a ? { mode: s.id, tickets: m, teams: a } : null;
+  }
+}
+function g(c, e, t) {
+  const s = c.reduce((r, m) => r + m.members.length, 0);
+  if (s === t) return c;
+  if (s > t) return null;
+  const i = [];
+  let h = 2e3;
+  const o = (r, m) => {
+    if (m === 0) return !0;
+    if (--h < 0) return !1;
+    for (let a = r; a < e.length; a++) {
+      const n = e[a];
+      if (!(n.members.length > m)) {
+        if (i.push(n), o(a + 1, m - n.members.length)) return !0;
+        i.pop();
+      }
+    }
+    return !1;
+  };
+  return o(0, t - s) ? [...c, ...i] : null;
+}
+function d(c, e, t) {
+  const s = [...c].sort((o, r) => r.members.length - o.members.length || r.rating - o.rating), i = Array.from({ length: e }, () => ({ ids: [], weight: 0 })), h = (o) => {
+    if (o === s.length) return !0;
+    const r = s[o], m = [...i.keys()].sort((a, n) => i[a].weight - i[n].weight || i[a].ids.length - i[n].ids.length);
+    for (const a of m) {
+      const n = i[a];
+      if (!(n.ids.length + r.members.length > t)) {
+        if (n.ids.push(...r.members), n.weight += r.rating * r.members.length, h(o + 1)) return !0;
+        n.ids.length -= r.members.length, n.weight -= r.rating * r.members.length;
+      }
+    }
+    return !1;
+  };
+  return h(0) ? i.map((o) => o.ids) : null;
+}
+export {
+  l as Matchmaker,
+  d as balanceTeams
+};

package/dist/net/movement.js

@@ -0,0 +1,84 @@
+import { BODY_HALF_WIDTH as b, BODY_HALF_HEIGHT as D, COLLISION_EPSILON as i, INPUT_FLAG_DASH as M, INPUT_STEP_DT as x } from "./constants.js";
+const H = 0.7071067811865476;
+function W(t, e, o, h, a = {}) {
+  if (h.length !== t * e)
+    throw new Error(`collision string length ${h.length} != ${t}x${e}`);
+  const n = new Uint8Array(t * e);
+  for (let c = 0; c < n.length; c++) n[c] = h.charCodeAt(c) === 49 ? 1 : 0;
+  const { ground: s } = a, r = new Set(a.shotOverTiles ?? []);
+  let f;
+  if (s && s.length === n.length && r.size) {
+    f = new Uint8Array(n.length);
+    for (let c = 0; c < n.length; c++) f[c] = n[c] && r.has(s[c]) ? 1 : 0;
+  }
+  const l = a.bodyHalfWidth ?? b, y = a.bodyHalfHeight ?? D;
+  return f ? { width: t, height: e, tileSize: o, solid: n, shotOver: f, bodyHalfWidth: l, bodyHalfHeight: y } : { width: t, height: e, tileSize: o, solid: n, bodyHalfWidth: l, bodyHalfHeight: y };
+}
+function A(t, e, o) {
+  return d(t, e, o) ? t.shotOver?.[o * t.width + e] !== 1 : !1;
+}
+function C(t, e) {
+  return { x: t, y: e, lastDx: 1, lastDy: 0, dashLeft: 0, dashCd: 0, dashDx: 1, dashDy: 0 };
+}
+function d(t, e, o) {
+  return e < 0 || o < 0 || e >= t.width || o >= t.height ? !0 : t.solid[o * t.width + e] === 1;
+}
+function O(t, e, o) {
+  const h = t.tileSize, a = Math.floor((e - t.bodyHalfWidth) / h), n = Math.floor((e + t.bodyHalfWidth) / h), s = Math.floor((o - t.bodyHalfHeight) / h), r = Math.floor((o + t.bodyHalfHeight) / h);
+  for (let f = s; f <= r; f++)
+    for (let l = a; l <= n; l++)
+      if (d(t, l, f)) return !0;
+  return !1;
+}
+function L(t, e, o, h) {
+  if (h === 0) return e;
+  const a = t.tileSize, n = e + h, s = Math.floor((o - t.bodyHalfHeight) / a), r = Math.floor((o + t.bodyHalfHeight) / a);
+  if (h > 0) {
+    const f = Math.floor((n + t.bodyHalfWidth) / a);
+    for (let l = s; l <= r; l++)
+      if (d(t, f, l)) return f * a - t.bodyHalfWidth - i;
+  } else {
+    const f = Math.floor((n - t.bodyHalfWidth) / a);
+    for (let l = s; l <= r; l++)
+      if (d(t, f, l)) return (f + 1) * a + t.bodyHalfWidth + i;
+  }
+  return n;
+}
+function S(t, e, o, h) {
+  if (h === 0) return o;
+  const a = t.tileSize, n = o + h, s = Math.floor((e - t.bodyHalfWidth) / a), r = Math.floor((e + t.bodyHalfWidth) / a);
+  if (h > 0) {
+    const f = Math.floor((n + t.bodyHalfHeight) / a);
+    for (let l = s; l <= r; l++)
+      if (d(t, l, f)) return f * a - t.bodyHalfHeight - i;
+  } else {
+    const f = Math.floor((n - t.bodyHalfHeight) / a);
+    for (let l = s; l <= r; l++)
+      if (d(t, l, f)) return (f + 1) * a + t.bodyHalfHeight + i;
+  }
+  return n;
+}
+function u(t) {
+  return t > 0 ? 1 : t < 0 ? -1 : 0;
+}
+function _(t, e, o, h) {
+  t.dashCd > 0 && t.dashCd--;
+  const a = t.dashLeft > 0;
+  let n = o.canMove && !a ? u(e[0]) : 0, s = o.canMove && !a ? u(e[1]) : 0;
+  n !== 0 && s !== 0 && (n = n * H, s = s * H), (n !== 0 || s !== 0) && (t.lastDx = n, t.lastDy = s), (e[2] & (o.dashFlag ?? M)) !== 0 && o.canDash && o.canMove && t.dashLeft === 0 && t.dashCd === 0 && (t.dashLeft = o.dashSteps, t.dashCd = o.dashCooldownSteps, t.dashDx = t.lastDx, t.dashDy = t.lastDy);
+  let r, f;
+  t.dashLeft > 0 ? (r = t.dashDx * o.dashSpeed, f = t.dashDy * o.dashSpeed, t.dashLeft--) : (r = n * o.speed, f = s * o.speed);
+  const l = o.stepDt ?? x;
+  t.x = L(h, t.x, t.y, r * l), t.y = S(h, t.x, t.y, f * l);
+}
+export {
+  H as DIAGONAL,
+  A as blocksShot,
+  O as bodyCollides,
+  W as createCollisionGrid,
+  C as createMover,
+  d as isSolidTile,
+  L as moveX,
+  S as moveY,
+  _ as stepMover
+};

package/dist/net/protocol.js

@@ -0,0 +1,10 @@
+function d(a) {
+  return [a.x, a.y, a.lastDx, a.lastDy, a.dashLeft, a.dashCd, a.dashDx, a.dashDy];
+}
+function r(a, s) {
+  return [s.x, s.y, s.lastDx, s.lastDy, s.dashLeft, s.dashCd, s.dashDx, s.dashDy] = a, s;
+}
+export {
+  r as moverFromWire,
+  d as moverToWire
+};

package/dist/net/reconnect.js

@@ -0,0 +1,10 @@
+function c(n, e = 1e4, t = 250) {
+  return Math.min(e, t * 2 ** Math.max(0, n));
+}
+function r(n, e) {
+  return e.closedByUs || e.reconnect === !1 ? !1 : !e.fatalCloseCodes?.includes(n);
+}
+export {
+  c as reconnectDelay,
+  r as shouldReconnect
+};

package/dist/net/serverClock.js

@@ -0,0 +1,21 @@
+const u = 2e3;
+let n = 0, i = 1 / 0, f = 0, r = !1;
+function S() {
+  return Date.now() + n;
+}
+function _() {
+  return n;
+}
+function c(o, e, t = Date.now()) {
+  !Number.isFinite(o) || !Number.isFinite(e) || e < 0 || e > 2e3 || r && e > i && t - f < 6e4 || (n = o + e / 2 - t, i = e, f = t, r = !0);
+}
+function l() {
+  n = 0, i = 1 / 0, f = 0, r = !1;
+}
+export {
+  u as MAX_SAMPLE_RTT_MS,
+  c as noteServerTime,
+  l as resetServerClock,
+  S as serverNow,
+  _ as serverOffset
+};