1681-engine 0.5.9 → 0.6.0

package/dist/input/inputTape.js

@@ -0,0 +1,68 @@
+class r {
+  constructor(t, e) {
+    this.meta = e, this.untap = t.tap((s) => this.capture(s));
+  }
+  meta;
+  order = [];
+  index = /* @__PURE__ */ new Map();
+  last = /* @__PURE__ */ new Map();
+  changes = [];
+  steps = 0;
+  untap;
+  stopped = null;
+  /** Steps recorded so far. */
+  get length() {
+    return this.steps;
+  }
+  /** Stops recording and returns the tape (the same one on every later call). */
+  stop() {
+    return this.stopped ? this.stopped : (this.untap(), this.stopped = { version: 1, actions: [...this.order], steps: this.steps, changes: this.changes.map((t) => [...t]) }, this.meta && (this.stopped.meta = structuredClone(this.meta)), this.stopped);
+  }
+  capture(t) {
+    const e = this.steps++;
+    for (const [s, i] of t) this.note(e, s, i);
+    for (const [s, i] of this.last) i !== 0 && !t.has(s) && this.note(e, s, 0);
+  }
+  note(t, e, s) {
+    if ((this.last.get(e) ?? 0) === s) return;
+    let i = this.index.get(e);
+    i === void 0 && (i = this.order.length, this.order.push(e), this.index.set(e, i)), this.last.set(e, s), this.changes.push([t, i, s]);
+  }
+}
+class h {
+  constructor(t) {
+    if (this.tape = t, !(t?.version === 1 && Array.isArray(t.actions) && Number.isInteger(t.steps) && Array.isArray(t.changes) && t.changes.every((s, i) => Array.isArray(s) && s.length === 3 && s.every(Number.isFinite) && s[1] >= 0 && s[1] < t.actions.length && (i === 0 || s[0] >= t.changes[i - 1][0])))) throw new Error("InputPlayer: not an input tape (version 1)");
+  }
+  tape;
+  step = 0;
+  next = 0;
+  values = /* @__PURE__ */ new Map();
+  /** Steps played so far. */
+  get position() {
+    return this.step;
+  }
+  get done() {
+    return this.step >= this.tape.steps;
+  }
+  /** The next step's values, or null once the tape is over. */
+  read() {
+    if (this.done) return null;
+    const t = this.tape.changes;
+    for (; this.next < t.length && t[this.next][0] === this.step; ) {
+      const [, e, s] = t[this.next++], i = this.tape.actions[e];
+      s === 0 ? this.values.delete(i) : this.values.set(i, s);
+    }
+    return this.step++, this.values;
+  }
+  /** Drives `actions` from the tape until it ends; `onEnd` is called on the poll that finds it over. */
+  playInto(t, e) {
+    t.replay(() => {
+      const s = this.read();
+      return s === null && e?.(), s;
+    });
+  }
+}
+export {
+  h as InputPlayer,
+  r as InputRecorder
+};

package/dist/mobile/backButton.js

@@ -0,0 +1,40 @@
+class r {
+  constructor(t = () => {
+  }) {
+    this.onRoot = t;
+  }
+  onRoot;
+  handlers = [];
+  /** Puts `handler` on top; the returned function takes it off (from anywhere in the stack). */
+  push(t) {
+    return this.handlers.push(t), () => {
+      const s = this.handlers.lastIndexOf(t);
+      s >= 0 && this.handlers.splice(s, 1);
+    };
+  }
+  get size() {
+    return this.handlers.length;
+  }
+  /** A back press: offered from the top down; `onRoot` when none uses it. True when a handler used it. */
+  press() {
+    for (let t = this.handlers.length - 1; t >= 0; t--)
+      if (this.handlers[t]()) return !0;
+    return this.onRoot(), !1;
+  }
+}
+function h(n) {
+  const t = n.withinMs ?? 2e3, s = n.now ?? (() => Date.now());
+  let e = -1 / 0;
+  return () => {
+    const i = s();
+    if (i - e <= t) {
+      e = -1 / 0, n.exit();
+      return;
+    }
+    e = i, n.notify();
+  };
+}
+export {
+  r as BackStack,
+  h as doubleBackToExit
+};

package/dist/mobile/capacitor.js

@@ -0,0 +1,48 @@
+async function i(e, n) {
+  const t = await e.addListener("backButton", () => {
+    n.press();
+  });
+  return () => {
+    t.remove();
+  };
+}
+async function s(e) {
+  if (!e?.getInfo) return 1 / 0;
+  try {
+    const n = parseInt((await e.getInfo()).build, 10);
+    return Number.isFinite(n) ? n : 0;
+  } catch {
+    return 1 / 0;
+  }
+}
+function u(e) {
+  if (!/^[a-zA-Z][\w]*(\.[a-zA-Z][\w]*)+$/.test(e.appId))
+    throw new Error(`capacitorConfig: appId must be reverse-domain, like com.example.game (got '${e.appId}')`);
+  const n = e.backgroundColor ?? "#000000", t = e.debug ?? !1, a = {
+    appId: e.appId,
+    appName: e.appName,
+    webDir: e.webDir ?? "dist",
+    backgroundColor: n,
+    server: { androidScheme: "https", cleartext: !1 },
+    android: { backgroundColor: n, allowMixedContent: !1, captureInput: !0, webContentsDebuggingEnabled: t },
+    ios: { backgroundColor: n, contentInset: "never", scrollEnabled: !1, webContentsDebuggingEnabled: t },
+    plugins: {
+      SplashScreen: { launchAutoHide: !1, backgroundColor: n, showSpinner: !1 },
+      CapacitorUpdater: { autoUpdate: !1 }
+    }
+  };
+  return c(a, e.extra ?? {});
+}
+function c(e, n) {
+  const t = { ...e };
+  for (const [a, r] of Object.entries(n)) {
+    const o = t[a];
+    t[a] = r && typeof r == "object" && !Array.isArray(r) && o && typeof o == "object" && !Array.isArray(o) ? c(o, r) : r;
+  }
+  return t;
+}
+export {
+  u as capacitorConfig,
+  i as installBackButton,
+  s as nativeBuildOf
+};

package/dist/mobile/screen.js

@@ -0,0 +1,31 @@
+function r(n = globalThis.document) {
+  if (!n?.body) return { top: 0, right: 0, bottom: 0, left: 0 };
+  const t = n.createElement("div");
+  t.style.cssText = "position:fixed;visibility:hidden;pointer-events:none;padding-top:env(safe-area-inset-top,0px);padding-right:env(safe-area-inset-right,0px);padding-bottom:env(safe-area-inset-bottom,0px);padding-left:env(safe-area-inset-left,0px)", n.body.appendChild(t);
+  const e = getComputedStyle(t), i = (o) => parseFloat(o) || 0, a = { top: i(e.paddingTop), right: i(e.paddingRight), bottom: i(e.paddingBottom), left: i(e.paddingLeft) };
+  return t.remove(), a;
+}
+async function l(n = globalThis.navigator?.wakeLock, t = globalThis.document) {
+  if (!n) return () => {
+  };
+  let e = null, i = !1;
+  const a = async () => {
+    try {
+      const s = await n.request("screen");
+      if (i) return void s.release();
+      e = s, s.addEventListener?.("release", () => {
+        e === s && (e = null);
+      });
+    } catch {
+    }
+  }, o = () => {
+    t?.visibilityState === "visible" && !e && a();
+  };
+  return await a(), t?.addEventListener("visibilitychange", o), () => {
+    i = !0, t?.removeEventListener("visibilitychange", o), e?.release(), e = null;
+  };
+}
+export {
+  l as keepScreenOn,
+  r as safeAreaInsets
+};

package/dist/mobile.js

@@ -0,0 +1,12 @@
+import { BackStack as t, doubleBackToExit as a } from "./mobile/backButton.js";
+import { capacitorConfig as c, installBackButton as n, nativeBuildOf as f } from "./mobile/capacitor.js";
+import { keepScreenOn as k, safeAreaInsets as p } from "./mobile/screen.js";
+export {
+  t as BackStack,
+  c as capacitorConfig,
+  a as doubleBackToExit,
+  n as installBackButton,
+  k as keepScreenOn,
+  f as nativeBuildOf,
+  p as safeAreaInsets
+};

package/dist/nav/flowField.js

@@ -0,0 +1,58 @@
+import { MinHeap as C } from "./MinHeap.js";
+import { isOpen as g, NAV_STEPS as S, canStep as E } from "./navGrid.js";
+function M(o, s, w = {}) {
+  const { cost: r, endOnly: l, maxCost: h = 1 / 0 } = w, i = o.width, e = i * o.height, u = new Float32Array(e).fill(1 / 0), x = new Int8Array(e).fill(-1), A = new Uint8Array(e), y = new C(), d = new Uint8Array(e);
+  for (const n of s) {
+    if (!g(o, n.x, n.y)) continue;
+    const t = n.y * i + n.x;
+    d[t] = 1, u[t] = 0, y.push(t, 0);
+  }
+  const k = (n, t) => d[t * i + n] === 1;
+  for (; y.size > 0; ) {
+    const n = y.pop();
+    if (A[n]) continue;
+    A[n] = 1;
+    const t = n % i, f = n / i | 0;
+    if (!(!d[n] && l?.(t, f)))
+      for (let c = 0; c < S.length; c++) {
+        const [T, U, z] = S[c], I = t - T, F = f - U;
+        if (!g(o, I, F) || !E(o, I, F, T, U, l, k)) continue;
+        const p = F * i + I;
+        if (A[p]) continue;
+        const a = u[n] + z + (r ? r(t, f) : 0);
+        a >= u[p] || a > h || (u[p] = a, x[p] = c, y.push(p, a));
+      }
+  }
+  const O = (n, t) => n >= 0 && t >= 0 && n < i && t < o.height;
+  return {
+    width: i,
+    height: o.height,
+    costs: u,
+    steps: x,
+    stepAt(n, t) {
+      if (!O(n, t)) return null;
+      const f = x[t * i + n];
+      if (f < 0) return null;
+      const c = S[f];
+      return [c[0], c[1]];
+    },
+    costAt(n, t) {
+      return O(n, t) ? u[t * i + n] : 1 / 0;
+    }
+  };
+}
+function N(o, s, w = o.width * o.height) {
+  if (o.costAt(s.x, s.y) === 1 / 0) return null;
+  const r = [{ x: s.x, y: s.y }];
+  let l = s.x, h = s.y;
+  for (let i = 0; i < w; i++) {
+    const e = o.stepAt(l, h);
+    if (!e) return r;
+    l += e[0], h += e[1], r.push({ x: l, y: h });
+  }
+  return r;
+}
+export {
+  M as flowField,
+  N as followField
+};

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/ApiClient.js

@@ -0,0 +1,96 @@
+import { timeoutSignal as p } from "../platform/timeoutSignal.js";
+class g extends Error {
+  constructor(t, e, r, n, u) {
+    super(r), this.status = t, this.code = e, this.details = n, this.body = u, this.name = "ApiError";
+  }
+  status;
+  code;
+  details;
+  body;
+}
+function y(i) {
+  if (!i || typeof i != "object") return {};
+  const t = i;
+  return {
+    code: typeof t.code == "string" ? t.code : void 0,
+    message: typeof t.message == "string" ? t.message : void 0,
+    details: t.details && typeof t.details == "object" ? t.details : void 0
+  };
+}
+function v(i) {
+  const t = AbortSignal.any;
+  if (typeof t == "function") return t.call(AbortSignal, [...i]);
+  const e = new AbortController();
+  for (const r of i) {
+    if (r.aborted) {
+      e.abort(r.reason);
+      break;
+    }
+    r.addEventListener("abort", () => e.abort(r.reason), { once: !0 });
+  }
+  return e.signal;
+}
+class E {
+  constructor(t) {
+    this.options = t;
+  }
+  options;
+  token = null;
+  /** A new access token for a 401 (`RefreshResult`); unset, a 401 is simply thrown. */
+  refresher = null;
+  /** Called when a 401 ends the session: no refresher, a refused refresh, or a retry refused again. */
+  onUnauthorized = null;
+  get accessToken() {
+    return this.token;
+  }
+  setToken(t) {
+    this.token = t;
+  }
+  /** Sends a request and returns its parsed JSON body (undefined for an empty or unreadable one). */
+  async request(t, e, r, n = {}, u = !1) {
+    const o = this.options, l = { Accept: "application/json", ...o.headers?.(), ...n.headers };
+    r !== void 0 && (l["Content-Type"] = "application/json");
+    const f = this.token;
+    f && (l.Authorization = `Bearer ${f}`);
+    const w = p(n.timeoutMs ?? o.timeoutMs ?? 1e4), b = n.signal ? v([w, n.signal]) : w;
+    let s, h;
+    try {
+      const a = typeof o.baseUrl == "function" ? o.baseUrl(e) : o.baseUrl;
+      s = await (o.fetch ?? fetch)(a + e, {
+        method: t,
+        headers: l,
+        body: r !== void 0 ? JSON.stringify(r) : void 0,
+        signal: b
+      }), h = s.status === 204 ? "" : await s.text();
+    } catch (a) {
+      throw n.signal?.aborted ? new g(0, "ABORTED", "Aborted.") : (console.warn("[api] network error", t, e, a), this.networkError());
+    }
+    let c;
+    if (h)
+      try {
+        c = JSON.parse(h);
+      } catch {
+        c = void 0;
+      }
+    if (s.ok) return c;
+    const d = (o.describe ?? y)(c, s.status), k = new g(s.status, d.code ?? `HTTP_${s.status}`, d.message ?? `HTTP ${s.status}`, d.details, c);
+    if (o.onError?.(k), o.onStatus?.[s.status]?.(k), s.status === 401 && this.token && !u && !o.noRefresh?.(e)) {
+      if (f !== this.token) return this.request(t, e, r, n, !0);
+      if (this.refresher) {
+        const a = await this.refresher().catch(() => null);
+        if (a !== null && a !== "refused")
+          return this.token = a, this.request(t, e, r, n, !0);
+        if (a === null) throw this.networkError();
+      }
+    }
+    throw s.status === 401 && this.token && this.onUnauthorized?.(), k;
+  }
+  networkError() {
+    const t = this.options.networkMessage;
+    return new g(0, "NETWORK", typeof t == "function" ? t() : t ?? "Cannot reach the server.");
+  }
+}
+export {
+  E as ApiClient,
+  g as ApiError
+};

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
+};