1681-engine 0.0.0-stage → 0.5.9

package/dist/net/snapshotCodec.js

@@ -0,0 +1,91 @@
+const h = 1, d = 5, b = 16, M = 8, y = 256, c = Math.PI * 2;
+function E(t, n, r) {
+  if (!Number.isFinite(t)) return Number.isNaN(t) ? 0 : t > 0 ? r : n;
+  const e = Math.round(t);
+  return e < n ? n : e > r ? r : e;
+}
+function s(t) {
+  return E(t * 8, -32768, 32767);
+}
+function T(t) {
+  return Number.isFinite(t) ? (Math.round(t * 256 / c) % 256 + 256) % 256 : 0;
+}
+function a(t) {
+  return (t >= 256 / 2 ? t - 256 : t) * c / 256;
+}
+function i(t, n, r) {
+  t.setInt32(n, E(r[0], -2147483648, 2147483647)), t.setInt16(n + 4, s(r[1])), t.setInt16(n + 6, s(r[2])), t.setUint8(n + 8, T(r[3])), t.setUint8(n + 9, E(r[4], 0, 255)), t.setInt32(n + 10, E(r[5], -2147483648, 2147483647)), t.setUint16(n + 14, E(r[6], 0, 65535));
+}
+function D(t, n) {
+  return [
+    t.getInt32(n),
+    t.getInt16(n + 4) / 8,
+    t.getInt16(n + 6) / 8,
+    a(t.getUint8(n + 8)),
+    t.getUint8(n + 9),
+    t.getInt32(n + 10),
+    t.getUint16(n + 14)
+  ];
+}
+function N(t) {
+  const n = new Uint8Array(t.length * 16), r = new DataView(n.buffer);
+  for (let e = 0; e < t.length; e++) i(r, e * 16, t[e]);
+  return n;
+}
+function u(t) {
+  if (t.byteLength % 16 !== 0) throw new Error(`update block of ${t.byteLength} bytes`);
+  const n = new DataView(t.buffer, t.byteOffset, t.byteLength), r = [];
+  for (let e = 0; e < t.byteLength; e += 16) r.push(D(n, e));
+  return r;
+}
+function I(t) {
+  const n = new Array(t.length);
+  for (let r = 0; r < t.length; r++) {
+    const e = t[r];
+    n[r] = [
+      E(e[0], -2147483648, 2147483647) + 0,
+      s(e[1]) / 8 + 0,
+      s(e[2]) / 8 + 0,
+      a(T(e[3])),
+      E(e[4], 0, 255) + 0,
+      E(e[5], -2147483648, 2147483647) + 0,
+      E(e[6], 0, 65535) + 0
+    ];
+  }
+  return n;
+}
+const P = globalThis, R = new P.TextEncoder(), g = new P.TextDecoder();
+function O(t) {
+  const { up: n, ...r } = t, e = R.encode(JSON.stringify(r)), S = n?.length ? n.length : 0, A = new Uint8Array(5 + e.byteLength + S * 16), o = new DataView(A.buffer);
+  o.setUint8(0, 1), o.setUint32(1, e.byteLength), A.set(e, 5);
+  const U = 5 + e.byteLength;
+  for (let _ = 0; _ < S; _++) i(o, U + _ * 16, n[_]);
+  return A;
+}
+function f(t) {
+  const n = t instanceof Uint8Array ? t : new Uint8Array(t);
+  if (n.byteLength < 5) throw new Error("short snapshot frame");
+  const r = new DataView(n.buffer, n.byteOffset, n.byteLength), e = r.getUint8(0);
+  if (e !== 1) throw new Error(`unknown binary frame tag ${e}`);
+  const A = 5 + r.getUint32(1);
+  if (A > n.byteLength) throw new Error("snapshot frame JSON overruns the frame");
+  const o = JSON.parse(g.decode(n.subarray(5, A)));
+  return A < n.byteLength && (o.up = u(n.subarray(A))), o;
+}
+export {
+  d as SNAP_FRAME_HEADER_BYTES,
+  h as SNAP_FRAME_TAG,
+  y as UPDATE_AIM_STEPS,
+  M as UPDATE_POS_SCALE,
+  b as UPDATE_RECORD_BYTES,
+  f as decodeSnapshotFrame,
+  u as decodeUpdates,
+  a as dequantizeAim,
+  O as encodeSnapshotFrame,
+  N as encodeUpdates,
+  T as quantizeAim,
+  s as quantizePos,
+  I as quantizeUpdates,
+  D as readUpdate,
+  i as writeUpdate
+};

package/dist/parallax/Parallax.js

@@ -0,0 +1,31 @@
+import { Container as r } from "pixi.js";
+import { ParallaxLayer as s } from "./ParallaxLayer.js";
+class d {
+  view = new r({ sortableChildren: !0 });
+  list = [];
+  constructor(t = {}) {
+    this.view.zIndex = t.depth ?? -1e3;
+  }
+  get layers() {
+    return this.list;
+  }
+  /** Adds a layer (built here from options, or one made before); later layers draw in front unless a `depth` says. */
+  add(t) {
+    const i = t instanceof s ? t : new s(t);
+    return i.depth === void 0 && (i.view.zIndex = this.list.length), this.list.push(i), this.view.addChild(i.view), i;
+  }
+  /** Takes a layer out and destroys it. */
+  remove(t) {
+    const i = this.list.indexOf(t);
+    i < 0 || (this.list.splice(i, 1), t.destroy());
+  }
+  update(t, i) {
+    for (let e = 0; e < this.list.length; e++) this.list[e].update(t, i);
+  }
+  destroy() {
+    this.list.length = 0, this.view.destroy({ children: !0 });
+  }
+}
+export {
+  d as Parallax
+};

package/dist/parallax/ParallaxLayer.js

@@ -0,0 +1,69 @@
+import { Container as u, TilingSprite as X, Sprite as Y } from "pixi.js";
+import { wrap as f, placeAxis as a } from "./parallaxMath.js";
+class g {
+  view = new u();
+  factorX;
+  factorY;
+  offsetX;
+  offsetY;
+  speedX;
+  speedY;
+  snap;
+  cull;
+  /** The depth it was given, if any (a `Parallax` numbers the others in the order they were added). */
+  depth;
+  repeatX;
+  repeatY;
+  tiling = null;
+  tileW = 0;
+  tileH = 0;
+  /** The content's local bounds, measured once: reading bounds every frame walks the whole display tree. */
+  boundsX = 0;
+  boundsY = 0;
+  boundsW = 0;
+  boundsH = 0;
+  driftX = 0;
+  driftY = 0;
+  // scratch, so a frame allocates nothing
+  input = { scroll: 0, view: 0, factor: 0, offset: 0, repeat: !1, tile: 0, contentStart: 0, contentSize: 0, snap: !1 };
+  px = { position: 0, size: 0, phase: 0, visible: !0 };
+  py = { position: 0, size: 0, phase: 0, visible: !0 };
+  constructor(t) {
+    const { texture: e, display: s } = t;
+    if (!e == !s) throw new Error("ParallaxLayer: give exactly one of `texture` and `display`");
+    this.factorX = t.factorX ?? 0.5, this.factorY = t.factorY ?? this.factorX, this.offsetX = t.offsetX ?? 0, this.offsetY = t.offsetY ?? 0, this.speedX = t.speedX ?? 0, this.speedY = t.speedY ?? 0, this.snap = t.snap, this.cull = t.cull ?? !0, this.repeatX = e !== void 0 && t.repeatX === !0, this.repeatY = e !== void 0 && t.repeatY === !0, this.depth = t.depth, t.depth !== void 0 && (this.view.zIndex = t.depth), e ? (this.tileW = e.width, this.tileH = e.height, this.repeatX || this.repeatY ? (this.tiling = new X({ texture: e, width: e.width, height: e.height }), this.view.addChild(this.tiling)) : this.view.addChild(new Y(e))) : s && this.view.addChild(s), this.remeasure();
+  }
+  /** Measures the content again, after it was redrawn larger or smaller (culling reads the measured size). */
+  remeasure() {
+    if (this.tiling) {
+      this.boundsX = 0, this.boundsY = 0, this.boundsW = this.tileW, this.boundsH = this.tileH;
+      return;
+    }
+    const t = this.view.getLocalBounds();
+    this.boundsX = t.x, this.boundsY = t.y, this.boundsW = t.width, this.boundsH = t.height;
+  }
+  /** Places the layer for this frame; `dtMs` advances the drift. */
+  update(t, e) {
+    const s = e / 1e3;
+    this.driftX += this.speedX * s, this.driftY += this.speedY * s, this.repeatX && (this.driftX = f(this.driftX, this.tileW)), this.repeatY && (this.driftY = f(this.driftY, this.tileH));
+    const p = this.snap ?? t.roundPixels === !0, d = t.zoom > 0 ? t.zoom : 1, i = this.input;
+    i.snap = p, i.scroll = t.scrollX, i.view = t.width / d, i.factor = this.factorX, i.offset = this.offsetX + this.driftX, i.repeat = this.repeatX, i.tile = this.tileW, i.contentStart = this.boundsX, i.contentSize = this.boundsW;
+    const r = a(this.px, i);
+    i.scroll = t.scrollY, i.view = t.height / d, i.factor = this.factorY, i.offset = this.offsetY + this.driftY, i.repeat = this.repeatY, i.tile = this.tileH, i.contentStart = this.boundsY, i.contentSize = this.boundsH;
+    const o = a(this.py, i);
+    this.view.position.set(r.position, o.position);
+    const h = this.tiling;
+    if (h) {
+      const l = this.repeatX ? r.size : this.tileW, n = this.repeatY ? o.size : this.tileH;
+      (h.width !== l || h.height !== n) && h.setSize(l, n), h.tilePosition.set(r.phase, o.phase);
+    }
+    const c = t.width > 0 && t.height > 0;
+    this.view.visible = !this.cull || !c || r.visible && o.visible;
+  }
+  destroy() {
+    this.view.destroy({ children: !0 });
+  }
+}
+export {
+  g as ParallaxLayer
+};

package/dist/parallax/parallaxMath.js

@@ -0,0 +1,26 @@
+function l(n, e, i = 0) {
+  return n * (1 - e) + i;
+}
+function s(n, e) {
+  if (!(e > 0)) return 0;
+  const i = n % e;
+  return i < 0 ? i + e : i + 0;
+}
+function c(n, e, i, r, t = 0) {
+  return n < i + r + t && n + e > i - t;
+}
+function o(n, e) {
+  let i = l(e.scroll, e.factor, e.offset);
+  if (e.snap && (i = Math.round(i)), e.repeat && e.tile > 0) {
+    const r = e.snap ? Math.floor(e.scroll) : e.scroll;
+    n.position = r, n.size = Math.ceil(e.view) + 1, n.phase = s(i - r, e.tile), n.visible = !0;
+  } else
+    n.position = i, n.size = e.contentSize, n.phase = 0, n.visible = c(i + e.contentStart, e.contentSize, e.scroll, e.view);
+  return n;
+}
+export {
+  l as parallaxOrigin,
+  o as placeAxis,
+  c as spanVisible,
+  s as wrap
+};

package/dist/particles/Emitter.js

@@ -0,0 +1,107 @@
+import { ParticleContainer as M, Particle as b } from "pixi.js";
+import { engineSettings as P } from "../settings.js";
+import { inView as v } from "../fx/viewCull.js";
+import { particleBudget as C } from "./ParticleBudget.js";
+import { ParticleSim as I } from "./ParticleSim.js";
+import { sampleCurve as w, sampleColor as S } from "./particleCurves.js";
+import { scaleCount as z, dueParticles as F, spreadAngle as X, sampleRange as y } from "./particleSampling.js";
+class R {
+  view;
+  x = 0;
+  y = 0;
+  /** Continuous emission on or off (bursts work either way). */
+  emitting = !1;
+  sim;
+  pool = [];
+  budget;
+  random;
+  opts;
+  carry = 0;
+  destroyed = !1;
+  /** Set by the last `update`: whether the emitter's point was near the screen. */
+  near = !0;
+  constructor(t) {
+    this.opts = t, this.sim = new I(t.capacity ?? 256), this.budget = t.budget ?? C, this.random = t.random ?? Math.random, this.view = new M({
+      texture: t.texture,
+      dynamicProperties: { position: !0, rotation: !0, vertex: !0, color: !0, uvs: !1 }
+    }), this.view.blendMode = t.blend === "add" ? "add" : "normal";
+  }
+  /** Particles alive now. */
+  get live() {
+    return this.sim.count;
+  }
+  setPosition(t, n) {
+    return this.x = t, this.y = n, this;
+  }
+  start() {
+    return this.emitting = !0, this;
+  }
+  /** Stops emitting; the particles in the air live out their lives. */
+  stop() {
+    return this.emitting = !1, this.carry = 0, this;
+  }
+  /** `count` particles at once, at the emitter or at (x, y). Thinned under reduced effects; skipped off screen. */
+  burst(t, n = this.x, s = this.y) {
+    this.destroyed || !this.near || this.emit(z(t, this.thin(), this.random()), n, s);
+  }
+  /** Advances by `dt` seconds. Pass the camera to skip spawning and drawing while everything is off screen. */
+  update(t, n) {
+    if (this.destroyed) return;
+    const s = this.opts.cullMargin ?? 64;
+    this.near = n ? v(n, this.x, this.y, s) : !0;
+    const e = this.opts.rate ?? 0;
+    if (this.emitting && e > 0 && this.near) {
+      const i = F(e * this.thin(), t, this.carry), d = Math.floor(i);
+      this.carry = i - d, d > 0 && this.emit(d, this.x, this.y);
+    } else this.carry = 0;
+    const a = this.opts, r = this.sim.step(t, a.gravityX ?? 0, a.gravityY ?? 0, a.drag ?? 0);
+    r > 0 && this.budget.give(r), this.draw(n, s);
+  }
+  /** Every particle gone at once (a scene change, a cancelled effect). */
+  clear() {
+    this.budget.give(this.sim.clear()), this.draw(void 0, 0);
+  }
+  destroy() {
+    this.destroyed || (this.clear(), this.destroyed = !0, this.pool.length = 0, this.view.destroy());
+  }
+  thin() {
+    const t = P.getState();
+    return t.reducedFx || t.batterySaver ? this.opts.thinFactor ?? 0.35 : 1;
+  }
+  emit(t, n, s) {
+    const e = this.sim, a = this.budget.take(Math.min(t, e.capacity - e.count)), r = this.opts, i = this.random, d = r.angle ?? -Math.PI / 2, f = r.spread ?? Math.PI;
+    for (let l = 0; l < a; l++) {
+      let o = n, h = s;
+      const c = r.area;
+      if (c && "radius" in c) {
+        const g = Math.sqrt(i()) * c.radius, u = i() * Math.PI * 2;
+        o += Math.cos(u) * g, h += Math.sin(u) * g;
+      } else c && (o += (i() - 0.5) * c.width, h += (i() - 0.5) * c.height);
+      const p = X(d, f, i()), m = y(r.speed ?? [40, 80], i());
+      e.spawn(o, h, Math.cos(p) * m, Math.sin(p) * m, y(r.lifetime ?? 1, i()), y(r.rotation ?? 0, i()), y(r.spin ?? 0, i()), i());
+    }
+  }
+  draw(t, n) {
+    const s = this.sim, e = this.view.particleChildren;
+    if (e.length !== s.count) {
+      for (; e.length < s.count; ) e.push(this.pool.pop() ?? new b({ texture: this.opts.texture, anchorX: 0.5, anchorY: 0.5 }));
+      for (; e.length > s.count; ) this.pool.push(e.pop());
+      this.view.update();
+    }
+    const a = this.opts, r = a.size ?? 1, i = a.alpha ?? Y, d = a.tint ?? 16777215, f = a.sizeVariance ?? 0;
+    let l = s.count === 0;
+    for (let o = 0; o < s.count; o++) {
+      const h = e[o], c = s.progress(o), p = s.x[o], m = s.y[o];
+      h.x = p, h.y = m, h.rotation = s.rot[o];
+      const g = w(r, c) * (1 + (s.seed[o] * 2 - 1) * f);
+      h.scaleX = g, h.scaleY = g;
+      const u = S(d, c), x = Math.min(1, Math.max(0, w(i, c)));
+      h.color = ((u & 255) << 16 | u & 65280 | u >> 16 & 255) + ((x * 255 | 0) << 24), !l && (!t || v(t, p, m, n)) && (l = !0);
+    }
+    this.view.visible = l && s.count > 0;
+  }
+}
+const Y = { start: 1, end: 0 };
+export {
+  R as Emitter
+};

package/dist/particles/ParticleBudget.js

@@ -0,0 +1,31 @@
+import { engineSettings as i } from "../settings.js";
+class s {
+  constructor(t = 4e3, e = 0.35) {
+    this.limit = t, this.thinFactor = e;
+  }
+  limit;
+  thinFactor;
+  used = 0;
+  /** The limit as the settings stand now. */
+  get effectiveLimit() {
+    const t = i.getState();
+    return t.reducedFx || t.batterySaver ? Math.floor(this.limit * this.thinFactor) : this.limit;
+  }
+  get live() {
+    return this.used;
+  }
+  /** Reserves up to `n` particles and returns how many were granted (0 when the budget is spent). */
+  take(t) {
+    const e = Math.max(0, Math.min(t, this.effectiveLimit - this.used));
+    return this.used += e, e;
+  }
+  /** Returns `n` particles that died or were cleared. */
+  give(t) {
+    this.used = Math.max(0, this.used - t);
+  }
+}
+const a = new s();
+export {
+  s as ParticleBudget,
+  a as particleBudget
+};

package/dist/particles/ParticleSim.js

@@ -0,0 +1,59 @@
+class y {
+  constructor(t) {
+    this.capacity = t, this.x = new Float32Array(t), this.y = new Float32Array(t), this.vx = new Float32Array(t), this.vy = new Float32Array(t), this.age = new Float32Array(t), this.life = new Float32Array(t), this.rot = new Float32Array(t), this.spin = new Float32Array(t), this.seed = new Float32Array(t);
+  }
+  capacity;
+  x;
+  y;
+  vx;
+  vy;
+  age;
+  life;
+  rot;
+  spin;
+  /** A random draw per particle (0–1), fixed for its life: size variance, flicker phase. */
+  seed;
+  count = 0;
+  /** Adds a particle; returns its index, or -1 when the sim is full. `life` is in seconds. */
+  spawn(t, i, l, r, e, n, s, o) {
+    if (this.count >= this.capacity) return -1;
+    const h = this.count++;
+    return this.x[h] = t, this.y[h] = i, this.vx[h] = l, this.vy[h] = r, this.age[h] = 0, this.life[h] = e > 0 ? e : 1e-3, this.rot[h] = n, this.spin[h] = s, this.seed[h] = o, h;
+  }
+  /**
+   * Advances every particle by `dt` seconds: gravity (px/s²) added to velocity, then drag, then position. Drag is
+   * the share of speed lost per second, applied as `exp(-drag × dt)` so it is the same at any frame rate. Returns how
+   * many particles died this step.
+   */
+  step(t, i, l, r) {
+    const e = r > 0 ? Math.exp(-r * t) : 1;
+    let n = 0, s = 0;
+    for (; s < this.count; ) {
+      const o = this.age[s] + t;
+      if (o >= this.life[s]) {
+        this.removeAt(s), n++;
+        continue;
+      }
+      this.age[s] = o;
+      const h = (this.vx[s] + i * t) * e, a = (this.vy[s] + l * t) * e;
+      this.vx[s] = h, this.vy[s] = a, this.x[s] = this.x[s] + h * t, this.y[s] = this.y[s] + a * t, this.rot[s] = this.rot[s] + this.spin[s] * t, s++;
+    }
+    return n;
+  }
+  /** The share of its life particle `i` has lived (0–1). */
+  progress(t) {
+    return this.age[t] / this.life[t];
+  }
+  /** Every particle gone; returns how many there were. */
+  clear() {
+    const t = this.count;
+    return this.count = 0, t;
+  }
+  removeAt(t) {
+    const i = --this.count;
+    t !== i && (this.x[t] = this.x[i], this.y[t] = this.y[i], this.vx[t] = this.vx[i], this.vy[t] = this.vy[i], this.age[t] = this.age[i], this.life[t] = this.life[i], this.rot[t] = this.rot[i], this.spin[t] = this.spin[i], this.seed[t] = this.seed[i]);
+  }
+}
+export {
+  y as ParticleSim
+};

package/dist/particles/particleCurves.js

@@ -0,0 +1,47 @@
+function u(n, t) {
+  if (typeof n == "number") return n;
+  if (!p(n)) return n.start + (n.end - n.start) * l(t);
+  const f = n.length;
+  if (f === 0) return 0;
+  const i = n[0];
+  if (t <= i[0]) return i[1];
+  for (let r = 1; r < f; r++) {
+    const o = n[r];
+    if (t <= o[0]) {
+      const s = n[r - 1], e = o[0] - s[0];
+      return e <= 0 ? o[1] : s[1] + (o[1] - s[1]) * ((t - s[0]) / e);
+    }
+  }
+  return n[f - 1][1];
+}
+function d(n, t) {
+  if (typeof n == "number") return n;
+  if (!p(n)) return a(n.start, n.end, l(t));
+  const f = n.length;
+  if (f === 0) return 16777215;
+  const i = n[0];
+  if (t <= i[0]) return i[1];
+  for (let r = 1; r < f; r++) {
+    const o = n[r];
+    if (t <= o[0]) {
+      const s = n[r - 1], e = o[0] - s[0];
+      return e <= 0 ? o[1] : a(s[1], o[1], (t - s[0]) / e);
+    }
+  }
+  return n[f - 1][1];
+}
+function a(n, t, f) {
+  const i = l(f), r = Math.round((n >> 16 & 255) + ((t >> 16 & 255) - (n >> 16 & 255)) * i), o = Math.round((n >> 8 & 255) + ((t >> 8 & 255) - (n >> 8 & 255)) * i), s = Math.round((n & 255) + ((t & 255) - (n & 255)) * i);
+  return r << 16 | o << 8 | s;
+}
+function p(n) {
+  return Array.isArray(n);
+}
+function l(n) {
+  return n < 0 ? 0 : n > 1 ? 1 : n;
+}
+export {
+  a as lerpColor,
+  d as sampleColor,
+  u as sampleCurve
+};

package/dist/particles/particleSampling.js

@@ -0,0 +1,29 @@
+function o(n, e) {
+  return typeof n == "number" ? n : n[0] + (n[1] - n[0]) * e;
+}
+function i(n, e, t) {
+  return n + (t * 2 - 1) * e;
+}
+function l(n, e, t) {
+  return !(n > 0) || !(e > 0) ? t : t + n * e;
+}
+function f(n, e, t) {
+  if (e >= 1) return n;
+  const u = n * Math.max(0, e), r = Math.floor(u);
+  return r + (t < u - r ? 1 : 0);
+}
+function s(n) {
+  let e = n >>> 0;
+  return () => {
+    e = e + 1831565813 >>> 0;
+    let t = e;
+    return t = Math.imul(t ^ t >>> 15, t | 1), t ^= t + Math.imul(t ^ t >>> 7, t | 61), ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+export {
+  l as dueParticles,
+  o as sampleRange,
+  f as scaleCount,
+  s as seededRandom,
+  i as spreadAngle
+};