1681-engine 0.0.0-stage → 0.5.9

package/dist/net/Connection.js

@@ -0,0 +1,107 @@
+import { EventBus as i } from "../events/EventBus.js";
+import { onAppResume as o } from "../platform/appResume.js";
+import { noteServerTime as r } from "./serverClock.js";
+import { decodeSnapshotFrame as n } from "./snapshotCodec.js";
+import { shouldReconnect as h, reconnectDelay as c } from "./reconnect.js";
+const l = 4408;
+class d {
+  constructor(e, t = {}) {
+    this.url = e, this.options = t;
+  }
+  url;
+  options;
+  events = new i();
+  /** The last measured round trip, ms. */
+  rtt = 0;
+  socket = null;
+  batch = null;
+  closedByUs = !1;
+  attempt = 0;
+  pingTimer = null;
+  retryTimer = null;
+  probeTimer = null;
+  stopResume = null;
+  get open() {
+    return this.socket?.readyState === 1;
+  }
+  connect() {
+    this.closedByUs = !1;
+    const e = this.options.WebSocket ?? globalThis.WebSocket;
+    if (!e) throw new Error("Connection: no WebSocket in this environment");
+    const t = new e(this.url);
+    return t.binaryType = "arraybuffer", this.socket = t, t.onopen = () => {
+      this.attempt = 0, this.send({ t: "hello", data: this.options.hello?.() }), this.ping(), this.pingTimer = setInterval(() => this.ping(), this.options.pingMs ?? 1e3), this.events.emit("open", void 0);
+    }, t.onmessage = (s) => this.receive(s.data), t.onclose = (s) => {
+      (this.socket === t || this.socket === null) && this.closed(s.code, s.reason);
+    }, (this.options.resumeProbeMs ?? 0) > 0 && !this.stopResume && (this.stopResume = (this.options.onResume ?? o)(() => this.probe())), this;
+  }
+  /** Sends a message now (dropped while closed: input is resent by the prediction's own state, not by the socket). */
+  send(e) {
+    this.socket?.readyState === 1 && this.socket.send(JSON.stringify(e));
+  }
+  /** Adds one input step to this frame's batch; `flush` sends it. Steps must come in sequence order. */
+  queueInput(e, t) {
+    this.batch || (this.batch = { seq: e, steps: [] }), this.batch.steps.push([t[0], t[1], t[2]]);
+  }
+  /** Sends this frame's input steps as one message. Call once a frame. */
+  flush() {
+    this.batch && (this.send({ t: "input", seq: this.batch.seq, steps: this.batch.steps }), this.batch = null);
+  }
+  close() {
+    this.closedByUs = !0, this.retryTimer && clearTimeout(this.retryTimer), this.pingTimer && clearInterval(this.pingTimer), this.clearProbe(), this.stopResume?.(), this.stopResume = null, this.socket?.close(), this.socket = null;
+  }
+  /** The socket is gone (closed, or given up on): report it and reconnect unless told not to. */
+  closed(e, t) {
+    this.pingTimer && clearInterval(this.pingTimer), this.pingTimer = null, this.clearProbe(), this.socket = null;
+    const s = h(e, { closedByUs: this.closedByUs, reconnect: this.options.reconnect, fatalCloseCodes: this.options.fatalCloseCodes });
+    this.events.emit("close", { code: e, reason: t, willRetry: s }), s && (this.retryTimer = setTimeout(() => this.connect(), c(this.attempt++, this.options.maxBackoffMs)));
+  }
+  /** Back from the background: a pong within `resumeProbeMs` proves the socket alive, none drops it. */
+  probe() {
+    const e = this.socket;
+    !e || e.readyState !== 1 || this.probeTimer || (this.probeTimer = setTimeout(() => {
+      if (this.probeTimer = null, this.socket === e) {
+        e.onopen = e.onmessage = e.onclose = null;
+        try {
+          e.close();
+        } catch {
+        }
+        this.closed(l, "no answer after resume");
+      }
+    }, this.options.resumeProbeMs), this.ping());
+  }
+  clearProbe() {
+    this.probeTimer && clearTimeout(this.probeTimer), this.probeTimer = null;
+  }
+  ping() {
+    this.send({ t: "ping", c: Date.now() });
+  }
+  receive(e) {
+    let t;
+    try {
+      t = typeof e == "string" ? JSON.parse(e) : n(e);
+    } catch (s) {
+      console.error("[net] could not read a message", s);
+      return;
+    }
+    switch (t.t) {
+      case "pong": {
+        const s = t;
+        this.clearProbe(), this.rtt = Date.now() - s.c, r(s.st, this.rtt);
+        return;
+      }
+      case "welcome":
+        this.events.emit("welcome", t);
+        return;
+      case "snap":
+        this.events.emit("snapshot", t);
+        return;
+      default:
+        this.events.emit("message", t);
+    }
+  }
+}
+export {
+  l as CLOSE_NO_ANSWER,
+  d as Connection
+};

package/dist/net/InterpolationBuffer.js

@@ -0,0 +1,56 @@
+class x {
+  constructor(s = 100, a = 120, t = 30) {
+    this.delayMs = s, 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) {
+      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));
+    }
+  }
+  /** Forgets a body (it left view). */
+  remove(s) {
+    this.samples.delete(s);
+  }
+  has(s) {
+    return this.samples.has(s);
+  }
+  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);
+    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);
+    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 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 f(e, s, a) {
+  let t = s.aim - e.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 };
+}
+export {
+  x as InterpolationBuffer
+};

package/dist/net/PredictedMover.js

@@ -0,0 +1,60 @@
+import { createMover as c, stepMover as n } from "./movement.js";
+import { moverFromWire as m } from "./protocol.js";
+class g {
+  constructor(t, s, i, o) {
+    this.params = i, this.grid = o, this.mover = c(t, s);
+  }
+  params;
+  grid;
+  mover;
+  pending = [];
+  nextSeq = 0;
+  /** The jump the last reconciliation made, still being eased out (world px). */
+  offsetX = 0;
+  offsetY = 0;
+  /** How big the last correction was (0 when the prediction was right). */
+  correction = 0;
+  /** Share of a visual correction left after each 60th of a second (default 0.8). */
+  smoothing = 0.8;
+  /** Applies one input step now and keeps it for replay; returns its sequence number (send it with the step). */
+  step(t) {
+    const s = this.nextSeq++;
+    return this.pending.push({ seq: s, step: [t[0], t[1], t[2]] }), n(this.mover, t, this.params, this.grid), s;
+  }
+  /** Steps sent but not yet acknowledged. */
+  get unacknowledged() {
+    return this.pending.length;
+  }
+  /** The server's word: the body as of step `ack`. Rewinds there and replays the rest. */
+  reconcile(t, s) {
+    const i = this.mover.x, o = this.mover.y;
+    let e = 0;
+    for (; e < this.pending.length && this.pending[e].seq <= t; ) e++;
+    e && (this.pending = this.pending.slice(e)), m(s, this.mover);
+    for (const f of this.pending) n(this.mover, f.step, this.params, this.grid);
+    const r = i - this.mover.x, h = o - this.mover.y;
+    this.correction = Math.hypot(r, h), this.correction > 0.01 && this.correction < 64 ? (this.offsetX += r, this.offsetY += h) : this.correction >= 64 && (this.offsetX = this.offsetY = 0);
+  }
+  /** Eases the visual correction out; call once a frame with its length in seconds. */
+  smooth(t) {
+    const s = Math.pow(this.smoothing, t * 60);
+    this.offsetX *= s, this.offsetY *= s, Math.abs(this.offsetX) < 0.01 && (this.offsetX = 0), Math.abs(this.offsetY) < 0.01 && (this.offsetY = 0);
+  }
+  /** Where to draw the body: the predicted place plus the correction still being eased out. */
+  get drawX() {
+    return this.mover.x + this.offsetX;
+  }
+  get drawY() {
+    return this.mover.y + this.offsetY;
+  }
+  /** New movement rules (a buff, a slow): applied to future steps and to replays. */
+  setParams(t) {
+    this.params = t;
+  }
+  setGrid(t) {
+    this.grid = t;
+  }
+}
+export {
+  g as PredictedMover
+};

package/dist/net/Room.js

@@ -0,0 +1,91 @@
+import { createMover as l, stepMover as p } from "./movement.js";
+import { moverToWire as c } from "./protocol.js";
+class g {
+  constructor(e) {
+    this.options = e, this.maxQueue = e.maxQueue ?? 30, this.maxSteps = e.maxStepsPerTick ?? 3, this.backlog = e.backlog ?? 4;
+  }
+  options;
+  players = /* @__PURE__ */ new Map();
+  tick = 0;
+  known = /* @__PURE__ */ new Map();
+  maxQueue;
+  maxSteps;
+  backlog;
+  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 = {
+      id: e,
+      mover: l(r.x, r.y),
+      data: i,
+      params: { ...this.options.params },
+      ack: -1,
+      queue: [],
+      aim: 0,
+      anim: 0,
+      hp: 0,
+      flags: 0,
+      strikes: 0
+    };
+    return this.players.set(e, t), this.known.set(e, /* @__PURE__ */ new Set()), t;
+  }
+  leave(e) {
+    this.players.delete(e), this.known.delete(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++;
+          break;
+        }
+        t.queue.push([r[s][0], r[s][1], r[s][2]]);
+      }
+    return h;
+  }
+  /** 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);
+      }
+    }
+  }
+  /** 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;
+  }
+}
+export {
+  g as Room
+};

package/dist/net/RoomHost.js

@@ -0,0 +1,100 @@
+import { encodeSnapshotFrame as n } from "./snapshotCodec.js";
+class p {
+  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;
+  }
+  room;
+  options;
+  sockets = /* @__PURE__ */ new Map();
+  joined = /* @__PURE__ */ new Set();
+  nextId = 1;
+  stepTimer = null;
+  lastStepAt = 0;
+  stepsDue = 0;
+  stepMs;
+  snapEvery;
+  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;
+  }
+  /** A message arrived from socket `id` (text as a string, binary as bytes). */
+  message(t, s) {
+    if (typeof s != "string") return;
+    let e;
+    try {
+      e = JSON.parse(s);
+    } catch {
+      return this.strike(t);
+    }
+    if (!e || typeof e != "object" || typeof e.t != "string") return this.strike(t);
+    switch (e.t) {
+      case "hello": {
+        if (this.joined.has(t)) return;
+        let i;
+        try {
+          i = this.options.admit ? this.options.admit(e.data, t) : e.data;
+        } catch (o) {
+          this.sockets.get(t)?.close(4003, o instanceof Error ? o.message : "refused");
+          return;
+        }
+        this.room.join(t, i), this.joined.add(t), this.sendTo(t, { t: "welcome", id: t, tick: this.room.tick, stepRate: 1e3 / this.stepMs, snapRate: 1e3 / this.stepMs / this.snapEvery }), this.options.onJoin?.(t);
+        return;
+      }
+      case "input": {
+        const i = e;
+        if (!this.joined.has(t)) return;
+        this.room.input(t, i.seq, i.steps) || this.checkStrikes(t);
+        return;
+      }
+      case "ping": {
+        const i = e.c;
+        typeof i == "number" && Number.isFinite(i) && this.sendTo(t, { t: "pong", c: i, st: this.now() });
+        return;
+      }
+      default:
+        this.joined.has(t) && this.options.onMessage?.(t, e);
+    }
+  }
+  /** Socket `id` closed. */
+  disconnect(t) {
+    this.sockets.delete(t), this.joined.delete(t) && (this.room.leave(t), this.options.onLeave?.(t));
+  }
+  /** 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)));
+  }
+  /** Starts stepping on a timer. Steps are counted by the clock, so a late timer runs the steps it owes. */
+  start() {
+    this.stepTimer || (this.lastStepAt = this.now(), this.stepTimer = setInterval(() => {
+      const t = this.now();
+      for (this.stepsDue += (t - this.lastStepAt) / this.stepMs, this.lastStepAt = t, this.stepsDue = Math.min(this.stepsDue, 60); this.stepsDue >= 1; )
+        this.stepsDue--, this.stepOnce();
+    }, this.stepMs / 2));
+  }
+  stop() {
+    this.stepTimer && clearInterval(this.stepTimer), this.stepTimer = null;
+  }
+  /** One step, and the snapshots when they are due. Exposed for tests and for servers that drive their own loop. */
+  stepOnce() {
+    if (this.room.step(), this.room.tick % this.snapEvery !== 0) return;
+    const t = this.now();
+    for (const s of this.joined) {
+      const e = this.room.snapshotFor(s, t);
+      e && this.sendTo(s, e);
+    }
+  }
+  strike(t) {
+    const s = this.room.players.get(t);
+    s && (s.strikes++, this.checkStrikes(t));
+  }
+  checkStrikes(t) {
+    const s = this.room.players.get(t);
+    s && s.strikes >= (this.options.maxStrikes ?? 20) && (this.sockets.get(t)?.close(4008, "too much invalid input"), this.disconnect(t));
+  }
+}
+export {
+  p as RoomHost
+};

package/dist/net/cadence.js

@@ -0,0 +1,21 @@
+const n = {
+  /** A basic attack may arrive this share of its interval early. */
+  attackEarlyShare: 0.2,
+  /** The cast lock and the attack lock a cast leaves may be cut this short. */
+  lockSlackMs: 60,
+  /** A skill may be cast this long before its cooldown ends. */
+  cooldownSlackMs: 40,
+  /** A potion may be drunk this long before its kind's cooldown ends. */
+  potionSlackMs: 150
+};
+function o(c, a, t) {
+  return a !== void 0 && c < a - t;
+}
+function e(c, a, t) {
+  return Math.max(c, a ?? c) + t;
+}
+export {
+  n as CADENCE,
+  o as cadenceEarly,
+  e as cadenceNext
+};

package/dist/net/constants.js

@@ -0,0 +1,10 @@
+const _ = 16, T = 60, I = 0.016666666666666666, E = 1, o = 5, t = 3, P = 0.01;
+export {
+  t as BODY_HALF_HEIGHT,
+  o as BODY_HALF_WIDTH,
+  P as COLLISION_EPSILON,
+  E as INPUT_FLAG_DASH,
+  I as INPUT_STEP_DT,
+  T as INPUT_STEP_RATE,
+  _ as TILE_SIZE
+};

package/dist/net/lobby/LobbyClient.js

@@ -0,0 +1,123 @@
+import { EventBus as s } from "../../events/EventBus.js";
+class o {
+  constructor(e) {
+    this.link = e, this.off = e.events.on("message", (t) => this.receive(t));
+  }
+  link;
+  events = new s();
+  /** Your id in the lobby (-1 until welcomed). */
+  id = -1;
+  modes = [];
+  rooms = [];
+  room = null;
+  /** Your queue: the mode, since when (server ms) and how many other groups wait for it. */
+  queued = null;
+  /** Kept out of the queue until then (server ms), after a declined match. */
+  lockedUntil = 0;
+  match = null;
+  off;
+  get isHost() {
+    return this.room !== null && this.room.host === this.id;
+  }
+  /** Every member of your room but the host has said ready. */
+  get roomReady() {
+    return this.room !== null && this.room.members.every((e) => e.ready);
+  }
+  list() {
+    this.send({ t: "lobby/list" });
+  }
+  create(e = {}) {
+    this.send({ t: "lobby/create", ...e });
+  }
+  join(e) {
+    this.send({ t: "lobby/join", room: e });
+  }
+  joinByCode(e) {
+    this.send({ t: "lobby/join", code: e.trim().toUpperCase() });
+  }
+  leave() {
+    this.send({ t: "lobby/leave" });
+  }
+  setReady(e) {
+    this.send({ t: "lobby/ready", ready: e });
+  }
+  kick(e) {
+    this.send({ t: "lobby/kick", player: e });
+  }
+  promote(e) {
+    this.send({ t: "lobby/promote", player: e });
+  }
+  setSettings(e) {
+    this.send({ t: "lobby/settings", settings: e });
+  }
+  chat(e) {
+    this.send({ t: "lobby/chat", text: e });
+  }
+  startRoom() {
+    this.send({ t: "lobby/start" });
+  }
+  queue(e) {
+    this.send({ t: "queue/join", mode: e });
+  }
+  leaveQueue() {
+    this.send({ t: "queue/leave" });
+  }
+  accept() {
+    this.match && (this.match.answered = !0), this.send({ t: "match/accept" }), this.events.emit("change", void 0);
+  }
+  decline() {
+    this.match && (this.match.answered = !0), this.send({ t: "match/decline" });
+  }
+  destroy() {
+    this.off(), this.events.clear();
+  }
+  send(e) {
+    this.link.send(e);
+  }
+  receive(e) {
+    switch (e.t) {
+      case "lobby/welcome":
+        this.id = e.id, this.modes = e.modes;
+        break;
+      case "lobby/rooms":
+        this.rooms = e.rooms;
+        break;
+      case "lobby/room":
+        this.room = e.room;
+        break;
+      case "lobby/chat":
+        this.events.emit("chat", { from: e.from, text: e.text });
+        return;
+      case "lobby/kicked":
+        this.room = null, this.events.emit("kicked", void 0);
+        break;
+      case "lobby/error":
+        this.events.emit("error", { code: e.code, message: e.message });
+        return;
+      case "queue/status":
+        this.queued = e.mode ? { mode: e.mode, since: e.since, waiting: e.waiting } : null;
+        break;
+      case "queue/locked":
+        this.lockedUntil = e.until;
+        break;
+      case "match/found":
+        this.queued = null, this.match = { id: e.match, mode: e.mode, players: e.players, expiresAt: e.expiresAt, accepted: [], answered: !1 }, this.events.emit("found", this.match);
+        break;
+      case "match/accepted":
+        this.match?.id === e.match && (this.match.accepted = e.accepted);
+        break;
+      case "match/cancelled":
+        this.match?.id === e.match && (this.match = null), this.events.emit("cancelled", { match: e.match, reason: e.reason, requeued: e.requeued });
+        break;
+      case "match/start":
+        this.match = null, this.queued = null, this.events.emit("start", { match: e.match, mode: e.mode, players: e.players, data: e.data });
+        break;
+      default:
+        return;
+    }
+    this.events.emit("change", void 0);
+  }
+}
+export {
+  o as LobbyClient
+};