1681-engine 0.5.10 → 0.6.1

package/dist/nav/steering.js

@@ -0,0 +1,77 @@
+const M = () => ({ x: 0, y: 0 });
+function h(o, x, t, y) {
+  const n = Math.hypot(o, x);
+  return n === 0 ? { x: -y.vx, y: -y.vy } : { x: o / n * t - y.vx, y: x / n * t - y.vy };
+}
+function b(o, x, t, y) {
+  return h(x - o.x, t - o.y, y, o);
+}
+function I(o, x, t, y, n = 1 / 0) {
+  const r = o.x - x, f = o.y - t;
+  return r * r + f * f > n * n ? M() : h(r, f, y, o);
+}
+function w(o, x, t, y, n) {
+  const r = x - o.x, f = t - o.y, c = Math.hypot(r, f), v = c < n ? y * (c / n) : y;
+  return h(r, f, v, o);
+}
+function A(o, x, t, y) {
+  let n = 0, r = 0;
+  for (const f of x) {
+    if (f === o) continue;
+    let c = o.x - f.x, v = o.y - f.y, i = Math.hypot(c, v);
+    if (i >= t) continue;
+    i === 0 ? (c = o.vx - f.vx || 1, v = o.vy - f.vy, i = Math.hypot(c, v), c /= i, v /= i, i = 0) : (c /= i, v /= i);
+    const s = (1 - i / t) * y;
+    n += c * s, r += v * s;
+  }
+  return { x: n, y: r };
+}
+function k(o, x, t) {
+  let y = 0, n = 0, r = 0;
+  for (const f of x)
+    f === o || (f.x - o.x) ** 2 + (f.y - o.y) ** 2 > t * t || (y += f.vx, n += f.vy, r++);
+  return r === 0 ? M() : { x: y / r - o.vx, y: n / r - o.vy };
+}
+function E(o, x, t, y) {
+  let n = 0, r = 0, f = 0;
+  for (const c of x)
+    c === o || (c.x - o.x) ** 2 + (c.y - o.y) ** 2 > t * t || (n += c.x, r += c.y, f++);
+  return f === 0 ? M() : b(o, n / f, r / f, y);
+}
+function O(o, x, t, y) {
+  const n = Math.floor(o.x / t), r = Math.floor(o.y / t), f = x.stepAt(n, r);
+  if (f) return h(f[0], f[1], y, o);
+  if (x.costAt(n, r) === 0) return { x: -o.vx, y: -o.vy };
+  let c = 1 / 0, v = 0, i = 0;
+  for (let s = 1; s <= 2 && c === 1 / 0; s++)
+    for (let u = -s; u <= s; u++)
+      for (let l = -s; l <= s; l++) {
+        if (Math.max(Math.abs(l), Math.abs(u)) !== s) continue;
+        const p = x.costAt(n + l, r + u);
+        p < c && (c = p, v = l, i = u);
+      }
+  return c === 1 / 0 ? { x: -o.vx, y: -o.vy } : b(o, (n + v + 0.5) * t, (r + i + 0.5) * t, y);
+}
+function Z(o, ...x) {
+  let t = 0, y = 0;
+  for (const [r, f] of x)
+    t += r.x * f, y += r.y * f;
+  const n = Math.hypot(t, y);
+  return n > o && (t = t / n * o, y = y / n * o), { x: t, y };
+}
+function j(o, x, t, y) {
+  o.vx += x.x * y, o.vy += x.y * y;
+  const n = Math.hypot(o.vx, o.vy);
+  n > t && (o.vx = o.vx / n * t, o.vy = o.vy / n * t), o.x += o.vx * y, o.y += o.vy * y;
+}
+export {
+  k as alignment,
+  j as applySteering,
+  w as arrive,
+  E as cohesion,
+  Z as combineSteering,
+  I as flee,
+  O as followFlow,
+  b as seek,
+  A as separation
+};

package/dist/net/InterpolationBuffer.js

@@ -1,55 +1,62 @@
 class x {
-  constructor(s = 100, a = 120, t = 30) {
-    this.delayMs = s, this.maxExtrapolateMs = a, this.keep = t;
+  constructor(e = 100, a = 120, t = 30) {
+    this.delayMs = e, this.maxExtrapolateMs = a, this.keep = t;
   }
   delayMs;
   maxExtrapolateMs;
   keep;
   samples = /* @__PURE__ */ new Map();
   /** Records every body of a snapshot taken at `time`. */
-  push(s, a) {
-    for (const [t, n, o, h, m, p, c] of a) {
+  push(e, a) {
+    for (const [t, n, r, h, m, p, c] of a) {
       let i = this.samples.get(t);
       i || (i = [], this.samples.set(t, i));
       const l = i[i.length - 1];
-      l && s <= l.time || (i.push({ time: s, x: n, y: o, aim: h, anim: m, hp: p, flags: c }), i.length > this.keep && i.splice(0, i.length - this.keep));
+      l && e <= l.time || (i.push({ time: e, x: n, y: r, aim: h, anim: m, hp: p, flags: c }), i.length > this.keep && i.splice(0, i.length - this.keep));
     }
   }
+  /**
+   * The server time bodies are drawn at when it is `now` (`serverNow()`): what a shot should carry, so a server with
+   * lag compensation judges it against the picture the player aimed at.
+   */
+  viewTime(e) {
+    return e - this.delayMs;
+  }
   /** Forgets a body (it left view). */
-  remove(s) {
-    this.samples.delete(s);
+  remove(e) {
+    this.samples.delete(e);
   }
-  has(s) {
-    return this.samples.has(s);
+  has(e) {
+    return this.samples.has(e);
   }
   ids() {
     return this.samples.keys();
   }
   /** Where body `id` should be drawn at server time `now`, or null if nothing is known of it. */
-  sample(s, a) {
-    const t = this.samples.get(s);
+  sample(e, a) {
+    const t = this.samples.get(e);
     if (!t || t.length === 0) return null;
-    const n = a - this.delayMs, o = t[0];
-    if (n <= o.time || t.length === 1) return g(o);
+    const n = a - this.delayMs, r = t[0];
+    if (n <= r.time || t.length === 1) return g(r);
     for (let i = t.length - 1; i > 0; i--) {
-      const l = t[i - 1], r = t[i];
-      if (n >= l.time && n <= r.time) {
-        const u = r.time === l.time ? 1 : (n - l.time) / (r.time - l.time);
-        return f(l, r, u);
+      const l = t[i - 1], o = t[i];
+      if (n >= l.time && n <= o.time) {
+        const u = o.time === l.time ? 1 : (n - l.time) / (o.time - l.time);
+        return f(l, o, u);
       }
     }
     const h = t[t.length - 2], m = t[t.length - 1], p = Math.min(n - m.time, this.maxExtrapolateMs), c = m.time === h.time ? 1 : 1 + p / (m.time - h.time);
     return f(h, m, c);
   }
 }
-function g(e) {
-  return { x: e.x, y: e.y, aim: e.aim, anim: e.anim, hp: e.hp, flags: e.flags };
+function g(s) {
+  return { x: s.x, y: s.y, aim: s.aim, anim: s.anim, hp: s.hp, flags: s.flags };
 }
-function f(e, s, a) {
-  let t = s.aim - e.aim;
+function f(s, e, a) {
+  let t = e.aim - s.aim;
   t > Math.PI && (t -= Math.PI * 2), t < -Math.PI && (t += Math.PI * 2);
-  const n = a < 1 ? e : s;
-  return { x: e.x + (s.x - e.x) * a, y: e.y + (s.y - e.y) * a, aim: e.aim + t * a, anim: n.anim, hp: n.hp, flags: n.flags };
+  const n = a < 1 ? s : e;
+  return { x: s.x + (e.x - s.x) * a, y: s.y + (e.y - s.y) * a, aim: s.aim + t * a, anim: n.anim, hp: n.hp, flags: n.flags };
 }
 export {
   x as InterpolationBuffer

package/dist/net/LagCompensator.js

@@ -0,0 +1,100 @@
+class k {
+  /** `keepMs`: how much history is kept; at least the longest rewind allowed plus a snapshot interval. */
+  constructor(s = 1e3) {
+    this.keepMs = s;
+  }
+  keepMs;
+  frames = [];
+  /** The latest recorded time, or -Infinity before any. */
+  get newest() {
+    return this.frames.length ? this.frames[this.frames.length - 1].time : -1 / 0;
+  }
+  get oldest() {
+    return this.frames.length ? this.frames[0].time : -1 / 0;
+  }
+  /** Records every body's position at `time`. A time not after the last one recorded replaces that frame. */
+  record(s, t) {
+    const e = /* @__PURE__ */ new Map();
+    for (const r of t) e.set(r.id, [r.x, r.y]);
+    const n = this.frames[this.frames.length - 1];
+    n && s <= n.time ? n.pos = e : this.frames.push({ time: s, pos: e });
+    const o = s - this.keepMs;
+    for (; this.frames.length > 2 && this.frames[1].time <= o; ) this.frames.shift();
+  }
+  /** Forgets a body everywhere in the history (it left the game, not just the view). */
+  forget(s) {
+    for (const t of this.frames) t.pos.delete(s);
+  }
+  clear() {
+    this.frames.length = 0;
+  }
+  /**
+   * A time a client claims it saw, kept within `[now - maxRewindMs, now]`: the window a rewind is honoured in. A
+   * claim that is not a finite number is taken as `now` (no rewind).
+   */
+  static clampTime(s, t, e) {
+    return typeof s != "number" || !Number.isFinite(s) ? t : Math.min(t, Math.max(t - e, s));
+  }
+  /**
+   * Where body `id` was at `time`, blended between the frames around it as `InterpolationBuffer` blends; null when
+   * the history has no frame of it. Before the oldest frame it is where it was then; after the newest, where it is.
+   */
+  at(s, t) {
+    const e = this.around(t);
+    return e ? b(e[0], e[1], e[2], s) : null;
+  }
+  /** Every body in the history at `time`. */
+  all(s) {
+    const t = this.around(s);
+    if (!t) return [];
+    const [e, n, o] = t, r = /* @__PURE__ */ new Set([...e.pos.keys(), ...n.pos.keys()]), i = [];
+    for (const a of r) {
+      const h = b(e, n, o, a);
+      i.push({ id: a, x: h.x, y: h.y });
+    }
+    return i;
+  }
+  /** The bodies whose centre was within `radius` of (x, y) at `time`, nearest first; `except` (the shooter) left out. */
+  near(s, t, e, n, o) {
+    return this.all(s).filter((i) => i.id !== o && (i.x - t) ** 2 + (i.y - e) ** 2 <= n * n).sort((i, a) => (i.x - t) ** 2 + (i.y - e) ** 2 - ((a.x - t) ** 2 + (a.y - e) ** 2));
+  }
+  /**
+   * A hitscan at `time`: the bodies a ray from (x, y) along (dx, dy) passed within `radius` of, before `range` px, in
+   * the order it met them. `except` (the shooter) is left out. Walls are the game's to check against the first hit.
+   */
+  alongRay(s, t, e, n, o, r, i, a) {
+    const h = Math.hypot(n, o);
+    if (h === 0) return [];
+    const u = n / h, m = o / h, p = [];
+    for (const f of this.all(s)) {
+      if (f.id === a) continue;
+      const c = (f.x - t) * u + (f.y - e) * m, g = t + u * c - f.x, y = e + m * c - f.y, x = g * g + y * y;
+      if (x > i * i) continue;
+      const M = c - Math.sqrt(i * i - x);
+      c < -i || M > r || p.push({ id: f.id, x: f.x, y: f.y, along: Math.max(0, M) });
+    }
+    return p.sort((f, c) => f.along - c.along);
+  }
+  /** The two frames around `time` and how far between them it is (0 at the first, 1 at the second). */
+  around(s) {
+    const t = this.frames;
+    if (t.length === 0) return null;
+    if (s <= t[0].time) return [t[0], t[0], 0];
+    const e = t[t.length - 1];
+    if (s >= e.time) return [e, e, 0];
+    for (let n = t.length - 1; n > 0; n--) {
+      const o = t[n - 1], r = t[n];
+      if (s >= o.time && s <= r.time) return [o, r, r.time === o.time ? 1 : (s - o.time) / (r.time - o.time)];
+    }
+    return null;
+  }
+}
+function b(l, s, t, e) {
+  const n = l.pos.get(e), o = s.pos.get(e);
+  if (n && o) return { x: n[0] + (o[0] - n[0]) * t, y: n[1] + (o[1] - n[1]) * t };
+  const r = n ?? o;
+  return r ? { x: r[0], y: r[1] } : null;
+}
+export {
+  k as LagCompensator
+};

package/dist/net/Room.js

@@ -1,21 +1,38 @@
-import { createMover as l, stepMover as p } from "./movement.js";
-import { moverToWire as c } from "./protocol.js";
-class g {
+import { LagCompensator as f } from "./LagCompensator.js";
+import { createMover as m, stepMover as p } from "./movement.js";
+import { moverToWire as y } from "./protocol.js";
+import { SpatialHash as b } from "./SpatialHash.js";
+const g = 1 << 24;
+class M {
   constructor(e) {
     this.options = e, this.maxQueue = e.maxQueue ?? 30, this.maxSteps = e.maxStepsPerTick ?? 3, this.backlog = e.backlog ?? 4;
+    const i = e.interest;
+    if (i && !(i.radius > 0)) throw new Error(`Room: interest.radius must be above 0 (got ${i.radius})`);
+    this.hash = i ? new b(i.radius) : null, this.rewindMs = Math.max(0, e.rewindMs ?? 0), this.history = this.rewindMs > 0 ? new f(this.rewindMs + 200) : null;
   }
   options;
   players = /* @__PURE__ */ new Map();
+  /** The bodies the server moves (`addBody`). */
+  bodies = /* @__PURE__ */ new Map();
   tick = 0;
+  /** Past positions for judging shots against what a client saw, when the room was made with `rewindMs`. */
+  history;
+  /** How far back a client's claimed view time is honoured (`rewindMs`, 0 when off). */
+  rewindMs;
   known = /* @__PURE__ */ new Map();
+  hash;
+  nearby = [];
   maxQueue;
   maxSteps;
   backlog;
+  nextBodyId = g;
   join(e, i) {
     if (this.players.has(e)) throw new Error(`Room: player ${e} has already joined`);
-    const r = this.options.spawn(e, i), t = {
+    if (this.bodies.has(e)) throw new Error(`Room: id ${e} is a body's`);
+    const t = this.options.spawn(e, i), s = {
+      kind: "player",
       id: e,
-      mover: l(r.x, r.y),
+      mover: m(t.x, t.y),
       data: i,
       params: { ...this.options.params },
       ack: -1,
@@ -26,66 +43,128 @@ class g {
       flags: 0,
       strikes: 0
     };
-    return this.players.set(e, t), this.known.set(e, /* @__PURE__ */ new Set()), t;
+    return this.players.set(e, s), this.known.set(e, /* @__PURE__ */ new Set()), this.hash?.set(e, t.x, t.y), s;
   }
   leave(e) {
-    this.players.delete(e), this.known.delete(e);
+    this.players.delete(e), this.known.delete(e), this.hash?.delete(e), this.history?.forget(e);
+  }
+  /**
+   * Records where every body is now, at server time `time`, into `history`; `RoomHost` calls it as each round of
+   * snapshots goes out, so the history holds exactly the positions clients interpolate between.
+   */
+  record(e) {
+    if (!this.history) return;
+    const i = [...this.players.values()].map((t) => ({ id: t.id, x: t.mover.x, y: t.mover.y }));
+    for (const t of this.bodies.values()) i.push({ id: t.id, x: t.x, y: t.y });
+    this.history.record(e, i);
+  }
+  /**
+   * Adds a body the server moves, at (x, y), with the game's `data` (what players are told it looks like). Its id
+   * is `id`, or the next from `BODY_ID_BASE` up; an id a player or body has is refused.
+   */
+  addBody(e, i, t, s) {
+    let o = s;
+    if (o === void 0) {
+      for (; this.bodies.has(this.nextBodyId) || this.players.has(this.nextBodyId); ) this.nextBodyId++;
+      o = this.nextBodyId++;
+    } else if (this.bodies.has(o) || this.players.has(o)) throw new Error(`Room: id ${o} is taken`);
+    if (!Number.isInteger(o) || o < 0 || o > 2147483647) throw new Error(`Room: a body id must fit an i32 (got ${o})`);
+    const a = { kind: "body", id: o, x: i, y: t, aim: 0, anim: 0, hp: 0, flags: 0, data: e };
+    return this.bodies.set(o, a), this.hash?.set(o, i, t), a;
+  }
+  /** Takes a body out: players who saw it get it in `rm` with their next snapshot. */
+  removeBody(e) {
+    this.bodies.delete(e) && (this.hash?.delete(e), this.history?.forget(e));
   }
   /**
    * Input steps `seq`, `seq + 1`, … from a player. Steps already received are skipped (a resend), any step with
    * numbers no client sends refuses the whole message, and steps past a full queue are dropped. Returns false when
    * something was refused.
    */
-  input(e, i, r) {
-    const t = this.players.get(e);
-    if (!t) return !1;
-    if (!Number.isInteger(i) || i < 0 || !Array.isArray(r) || r.length > this.maxQueue)
-      return t.strikes++, !1;
-    for (const s of r)
-      if (!Array.isArray(s) || s.length !== 3 || !s.every((u) => Number.isFinite(u)) || Math.abs(s[0]) > 1 || Math.abs(s[1]) > 1 || !Number.isInteger(s[2]))
-        return t.strikes++, !1;
-    const n = t.ack + 1 + t.queue.length, o = i - n;
-    if (o > this.maxQueue)
-      return t.strikes++, !1;
-    for (let s = 0; s < o; s++) t.queue.push([0, 0, 0]);
-    let h = !0;
-    for (let s = 0; s < r.length; s++)
-      if (!(i + s < n)) {
-        if (t.queue.length >= this.maxQueue) {
-          h = !1, t.strikes++;
+  input(e, i, t) {
+    const s = this.players.get(e);
+    if (!s) return !1;
+    if (!Number.isInteger(i) || i < 0 || !Array.isArray(t) || t.length > this.maxQueue)
+      return s.strikes++, !1;
+    for (const r of t)
+      if (!Array.isArray(r) || r.length !== 3 || !r.every((h) => Number.isFinite(h)) || Math.abs(r[0]) > 1 || Math.abs(r[1]) > 1 || !Number.isInteger(r[2]))
+        return s.strikes++, !1;
+    const o = s.ack + 1 + s.queue.length, a = i - o;
+    if (a > this.maxQueue)
+      return s.strikes++, !1;
+    for (let r = 0; r < a; r++) s.queue.push([0, 0, 0]);
+    let u = !0;
+    for (let r = 0; r < t.length; r++)
+      if (!(i + r < o)) {
+        if (s.queue.length >= this.maxQueue) {
+          u = !1, s.strikes++;
           break;
         }
-        t.queue.push([r[s][0], r[s][1], r[s][2]]);
+        s.queue.push([t[r][0], t[r][1], t[r][2]]);
       }
-    return h;
+    return u;
   }
   /** One simulation step for everyone. */
   step() {
     this.tick++;
     for (const e of this.players.values()) {
-      const i = e.queue.length;
-      if (i === 0) continue;
-      const r = i > this.backlog ? Math.min(this.maxSteps, i - this.backlog + 1) : 1;
-      for (let t = 0; t < r; t++) {
-        const n = e.queue.shift();
-        p(e.mover, n, e.params, this.options.grid), e.ack++, this.options.onStep?.(e, n);
+      const i = e.queue.length, t = i > this.backlog ? Math.min(this.maxSteps, i - this.backlog + 1) : Math.min(1, i);
+      for (let s = 0; s < t; s++) {
+        const o = e.queue.shift();
+        p(e.mover, o, e.params, this.options.grid), e.ack++, this.options.onStep?.(e, o);
       }
+      this.hash?.set(e.id, e.mover.x, e.mover.y);
     }
+    if (this.hash) for (const e of this.bodies.values()) this.hash.set(e.id, e.x, e.y);
+  }
+  /**
+   * Moves a player by hand (a teleport, a respawn), and files it in the interest grid at once. Writing `mover.x/y`
+   * directly also works; the room then finds it at its new place from the next step.
+   */
+  place(e, i, t) {
+    const s = this.players.get(e), o = this.bodies.get(e);
+    if (s)
+      s.mover.x = i, s.mover.y = t;
+    else if (o)
+      o.x = i, o.y = t;
+    else return;
+    this.hash?.set(e, i, t);
   }
   /** The snapshot player `id` should get now. `time` is the server's wall clock (ms). */
   snapshotFor(e, i) {
-    const r = this.players.get(e), t = this.known.get(e);
-    if (!r || !t) return null;
-    const n = [], o = [], h = /* @__PURE__ */ new Set();
-    for (const a of this.players.values())
-      h.add(a.id), n.push([a.id, a.mover.x, a.mover.y, a.aim, a.anim, a.hp, a.flags]), t.has(a.id) || (t.add(a.id), o.push({ id: a.id, data: a.data }));
-    const s = [];
-    for (const a of t)
-      h.has(a) || (t.delete(a), s.push(a));
-    const u = { t: "snap", tick: this.tick, time: i, ack: r.ack, me: c(r.mover), up: n };
-    return o.length && (u.sp = o), s.length && (u.rm = s), u;
+    const t = this.players.get(e), s = this.known.get(e);
+    if (!t || !s) return null;
+    const o = [], a = [], u = /* @__PURE__ */ new Set();
+    for (const n of this.visibleTo(t, s)) {
+      u.add(n.id);
+      const c = d(n);
+      o.push([n.id, c.x, c.y, n.aim, n.anim, n.hp, n.flags]), s.has(n.id) || (s.add(n.id), a.push({ id: n.id, data: n.data }));
+    }
+    const r = [];
+    for (const n of s)
+      u.has(n) || (s.delete(n), r.push(n));
+    const h = { t: "snap", tick: this.tick, time: i, ack: t.ack, me: y(t.mover), up: o };
+    return a.length && (h.sp = a), r.length && (h.rm = r), h;
+  }
+  /** What `me` is sent: itself always; with interest, the rest in range (a known one until past the margin). */
+  visibleTo(e, i) {
+    const t = this.options.interest;
+    if (!t || !this.hash) return [...this.players.values(), ...this.bodies.values()];
+    const s = t.radius, o = s + (t.leaveMargin ?? s / 4), a = this.nearby;
+    a.length = 0, this.hash.near(e.mover.x, e.mover.y, o, a);
+    const u = [e];
+    for (const r of a) {
+      if (r === e.id) continue;
+      const h = this.players.get(r) ?? this.bodies.get(r);
+      if (!h) continue;
+      const n = d(h);
+      (n.x - e.mover.x) ** 2 + (n.y - e.mover.y) ** 2 > s * s && !i.has(r) || t.canSee && !t.canSee(e, h) || u.push(h);
+    }
+    return u.sort((r, h) => r.id - h.id);
   }
 }
+const d = (l) => l.kind === "player" ? l.mover : l;
 export {
-  g as Room
+  g as BODY_ID_BASE,
+  M as Room
 };

package/dist/net/RoomHost.js

@@ -1,5 +1,6 @@
-import { encodeSnapshotFrame as n } from "./snapshotCodec.js";
-class p {
+import { LagCompensator as n } from "./LagCompensator.js";
+import { encodeSnapshotFrame as r } from "./snapshotCodec.js";
+class c {
   constructor(t, s = {}) {
     this.room = t, this.options = s, this.stepMs = 1e3 / (s.stepRate ?? 60), this.snapEvery = Math.max(1, Math.round((s.stepRate ?? 60) / (s.snapRate ?? 20))), this.now = s.now ?? Date.now;
   }
@@ -64,7 +65,7 @@ class p {
   /** Sends one of the game's own messages to a player. */
   sendTo(t, s) {
     const e = this.sockets.get(t);
-    e && (s.t === "snap" && s.up?.length ? e.send(n(s)) : e.send(JSON.stringify(s)));
+    e && (s.t === "snap" && s.up?.length ? e.send(r(s)) : e.send(JSON.stringify(s)));
   }
   /** Starts stepping on a timer. Steps are counted by the clock, so a late timer runs the steps it owes. */
   start() {
@@ -81,11 +82,19 @@ class p {
   stepOnce() {
     if (this.room.step(), this.room.tick % this.snapEvery !== 0) return;
     const t = this.now();
+    this.room.record(t);
     for (const s of this.joined) {
       const e = this.room.snapshotFor(s, t);
       e && this.sendTo(s, e);
     }
   }
+  /**
+   * The server time a client's claimed view time (`InterpolationBuffer.viewTime`, sent with a shot) is judged at:
+   * kept within the room's `rewindMs` of now, so no claim reaches further back. `now` with no history kept.
+   */
+  rewindTime(t) {
+    return n.clampTime(t, this.now(), this.room.rewindMs);
+  }
   strike(t) {
     const s = this.room.players.get(t);
     s && (s.strikes++, this.checkStrikes(t));
@@ -96,5 +105,5 @@ class p {
   }
 }
 export {
-  p as RoomHost
+  c as RoomHost
 };

package/dist/net/SpatialHash.js

@@ -0,0 +1,66 @@
+const z = (a, t) => (a + 32768) * 65536 + (t + 32768);
+class M {
+  /** `cellSize`: world px per cell. About the radius queries ask for keeps a query to a 3×3 block. */
+  constructor(t) {
+    if (this.cellSize = t, !(t > 0)) throw new Error(`SpatialHash: cellSize must be above 0 (got ${t})`);
+  }
+  cellSize;
+  cells = /* @__PURE__ */ new Map();
+  entries = /* @__PURE__ */ new Map();
+  get size() {
+    return this.entries.size;
+  }
+  has(t) {
+    return this.entries.has(t);
+  }
+  /** Puts `id` at (x, y), or moves it there. */
+  set(t, s, e) {
+    const l = z(Math.floor(s / this.cellSize), Math.floor(e / this.cellSize)), i = this.entries.get(t);
+    if (i) {
+      if (i.x = s, i.y = e, i.cell === l) return;
+      this.unlink(t, i.cell), i.cell = l;
+    } else this.entries.set(t, { x: s, y: e, cell: l });
+    let n = this.cells.get(l);
+    n || this.cells.set(l, n = /* @__PURE__ */ new Set()), n.add(t);
+  }
+  delete(t) {
+    const s = this.entries.get(t);
+    s && (this.unlink(t, s.cell), this.entries.delete(t));
+  }
+  clear() {
+    this.cells.clear(), this.entries.clear();
+  }
+  /** The ids within `radius` of (x, y), edge included, pushed onto `out` in no set order. */
+  near(t, s, e, l = []) {
+    const i = e * e;
+    return this.visit(t - e, s - e, t + e, s + e, (n, c) => {
+      const r = c.x - t, o = c.y - s;
+      r * r + o * o <= i && l.push(n);
+    }), l;
+  }
+  /** The ids inside the box from (x0, y0) to (x1, y1), edges included. */
+  inRect(t, s, e, l, i = []) {
+    return this.visit(t, s, e, l, (n, c) => {
+      c.x >= t && c.x <= e && c.y >= s && c.y <= l && i.push(n);
+    }), i;
+  }
+  visit(t, s, e, l, i) {
+    const n = this.cellSize, c = Math.floor(t / n), r = Math.floor(s / n), o = Math.floor(e / n), S = Math.floor(l / n);
+    if ((o - c + 1) * (S - r + 1) > this.entries.size) {
+      for (const [h, f] of this.entries) i(h, f);
+      return;
+    }
+    for (let h = r; h <= S; h++)
+      for (let f = c; f <= o; f++) {
+        const g = this.cells.get(z(f, h));
+        if (g) for (const u of g) i(u, this.entries.get(u));
+      }
+  }
+  unlink(t, s) {
+    const e = this.cells.get(s);
+    e && (e.delete(t), e.size === 0 && this.cells.delete(s));
+  }
+}
+export {
+  M as SpatialHash
+};