1681-engine 0.0.0-stage → 0.5.9

package/dist/pixel/Evaporation.js

@@ -0,0 +1,84 @@
+import { addPixelLayer as E } from "./PixelLayer.js";
+import { engineSettings as P } from "../settings.js";
+import { ramp as I } from "./pixelTone.js";
+const A = 1e3 / 12, _ = 1400, B = 150, D = 420, R = 16, p = { budget: 500, body: 60, big: 160 };
+class G {
+  constructor(t, r) {
+    this.scene = t, this.track = r;
+  }
+  scene;
+  track;
+  clouds = [];
+  live = 0;
+  play(t, r, n) {
+    const m = P.getState(), c = m.reducedFx || m.batterySaver, f = Math.min(t.pixels.length, r ? c ? p.big : D : c ? p.body : B), e = Math.min(f, Math.max(R, (c ? p.budget : _) - this.live));
+    if (e <= 0) return;
+    const y = Math.max(1, Math.round(Math.abs(t.scaleY))), M = E(this.scene);
+    this.track(M);
+    const a = {
+      g: M,
+      x: Math.round(t.x),
+      y: Math.round(t.y),
+      born: n,
+      end: n,
+      size: y,
+      n: e,
+      frame: -1,
+      x0: new Float32Array(e),
+      y0: new Float32Array(e),
+      delay: new Float32Array(e),
+      life: new Float32Array(e),
+      vx: new Float32Array(e),
+      vy: new Float32Array(e),
+      phase: new Float32Array(e),
+      color: new Uint32Array(e)
+    };
+    let h = 0, d = -1 / 0, i = 1;
+    const o = t.pixels;
+    for (let l = 0; l < o.length; l++)
+      h = Math.min(h, o.dy[l]), d = Math.max(d, o.dy[l]), i = Math.max(i, Math.abs(o.dx[l] * t.scaleX));
+    const x = Math.max(1, d - h), u = r ? 520 : 260, F = r ? 900 : 620, g = e / o.length;
+    let s = 0;
+    for (let l = 0; l < o.length && s < e; l++) {
+      if (g < 1 && Math.random() > g && o.length - l > e - s) continue;
+      const v = o.dy[l], b = o.dx[l] * t.scaleX, k = v * Math.abs(t.scaleY), w = (v - h) / x;
+      a.x0[s] = b, a.y0[s] = k, a.delay[s] = w * u * 0.6 + Math.random() * u * 0.4, a.life[s] = F * (0.6 + Math.random() * 0.6), a.vx[s] = b / i * 5 + (Math.random() - 0.5) * 10, a.vy[s] = -(10 + Math.random() * 16) * (r ? 1.3 : 1), a.phase[s] = Math.random() * Math.PI * 2, a.color[s] = o.color[l], a.end = Math.max(a.end, n + a.delay[s] + a.life[s]), s++;
+    }
+    a.n = s, this.live += a.n, this.clouds.push(a), this.draw(a, n);
+  }
+  update(t) {
+    for (let r = this.clouds.length - 1; r >= 0; r--) {
+      const n = this.clouds[r];
+      if (!n.g.active || t >= n.end) {
+        n.g.active && n.g.destroy(), this.live -= n.n, this.clouds.splice(r, 1);
+        continue;
+      }
+      this.draw(n, t);
+    }
+  }
+  draw(t, r) {
+    const n = Math.floor((r - t.born) / A);
+    if (n === t.frame) return;
+    t.frame = n;
+    const m = n * A, c = t.g;
+    c.clear(), c.setPosition(t.x, t.y).setDepth(t.y + 2);
+    const f = t.size;
+    for (let e = 0; e < t.n; e++) {
+      const y = m - t.delay[e];
+      let M = t.x0[e], a = t.y0[e], h = t.color[e], d = 1;
+      if (y > 0) {
+        const i = y / t.life[e];
+        if (i >= 1) continue;
+        const o = y / 1e3;
+        M += t.vx[e] * o + Math.sin(t.phase[e] + o * 9) * i * 1.5, a += t.vy[e] * o - 22 * o * o;
+        const x = I(h);
+        h = i < 0.3 ? h : i < 0.6 ? x.light : x.hi, d = i < 0.55 ? 1 : i < 0.8 ? 0.66 : 0.33;
+      }
+      c.rect(Math.round(M), Math.round(a), f, f, h, d);
+    }
+    c.present();
+  }
+}
+export {
+  G as Evaporation
+};

package/dist/pixel/NightShade.js

@@ -0,0 +1,33 @@
+import { tintNight as e } from "../ambient/DayClock.js";
+import { Darkness as h } from "./Darkness.js";
+class p {
+  constructor(a, t) {
+    this.options = t, this.dark = new h(a, 0, 0), this.dark.setShade(0, 0), this.lampScale = t.lampScale ?? 1.6, this.carried = t.carriedLight ?? 64, this.carriedFrom = Math.min(0.99, t.carriedFrom ?? 0.55);
+  }
+  options;
+  dark;
+  lampScale;
+  carried;
+  carriedFrom;
+  /** A light the place glows with, `glowSize` the diameter of the glow drawn for it: by night it is what is seen by. */
+  addLight(a, t, r, s, i = 0) {
+    this.dark.addLamp(a, t, r / 2 * this.lampScale, i, s);
+  }
+  /** Lamps colour the dark less (a "fewer ambient lights" setting); their holes stay as wide. */
+  setLampsDimmed(a) {
+    this.dark.setLampsDimmed(a);
+  }
+  /** `now` the frame's ms, `wallMs` the shared wall time the clock reads (`serverNow()`), `px`/`py` the player. */
+  update(a, t, r, s) {
+    const i = this.options.clock.at(t);
+    this.dark.setShade(e(i, this.options.tint, this.options.tintShare), i.alpha);
+    const d = this.carriedFrom;
+    this.dark.update(a, r, s, Math.max(0, (i.night - d) / (1 - d)) * this.carried);
+  }
+  destroy() {
+    this.dark.destroy();
+  }
+}
+export {
+  p as NightShade
+};

package/dist/pixel/PixelLayer.js

@@ -0,0 +1,210 @@
+import { Sprite as R, Texture as Y, BufferImageSource as B } from "pixi.js";
+import { Graphics as C } from "../core/Graphics.js";
+import { patchPixi as D } from "../core/pixiPatches.js";
+D();
+const W = 1024, U = [16, 24, 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, 1024], G = 24, K = 24 * 1024 * 1024, j = 60, m = /* @__PURE__ */ new Map();
+let S = 0, E = 0;
+const L = (n) => {
+  for (const t of U) if (t >= n) return t;
+  return Math.ceil(n / 256) * 256;
+}, F = (n, t) => n * 4096 + t;
+function q(n, t) {
+  let i = m.get(F(n, t));
+  if (!i?.length) {
+    let o = 1 / 0;
+    for (const [c, a] of m) {
+      if (!a.length) continue;
+      const p = Math.floor(c / 4096), f = c % 4096, g = p * f;
+      p >= n && f >= t && g <= n * t * 2 && g < o && (o = g, i = a);
+    }
+  }
+  const s = i?.pop();
+  if (s)
+    return S -= s.pixels.byteLength, s;
+  E++;
+  const e = new Uint8Array(n * t * 4), l = new B({
+    resource: e,
+    width: n,
+    height: t,
+    format: "rgba8unorm",
+    alphaMode: "premultiplied-alpha",
+    scaleMode: "nearest"
+  });
+  return { pixels: e, words: new Uint32Array(e.buffer), source: l, texture: new Y({ source: l }), capW: n, capH: t };
+}
+function z(n) {
+  const t = F(n.capW, n.capH);
+  let i = m.get(t);
+  if (i || m.set(t, i = []), i.length >= G || S + n.pixels.byteLength > K) {
+    n.texture.destroy(!0);
+    return;
+  }
+  i.push(n), S += n.pixels.byteLength;
+}
+function $(n) {
+  return n.add.existing(new J());
+}
+class J extends C {
+  /** This frame's rects: x, y, w, h, colour, alpha — six numbers each. */
+  rects = [];
+  /** Staged solid runs not yet committed: x, y, w, colour — four numbers each; later ones win. */
+  staged = [];
+  ink = 16777215;
+  inkAlpha = 1;
+  sprite = new R(Y.EMPTY);
+  surface = null;
+  /** Where the buffer's first pixel sits in the layer, as of the last `present`. */
+  originX = 0;
+  originY = 0;
+  /** The last frame's size, and how many presents in a row it stayed well inside a quarter of the buffer. */
+  lastW = 0;
+  lastH = 0;
+  small = 0;
+  constructor() {
+    super(), this.sprite.visible = !1, this.addChild(this.sprite);
+  }
+  /** Textures made, spent buffers waiting in the pool and their bytes (the leak tools read it). */
+  static stats() {
+    let t = 0;
+    for (const i of m.values()) t += i.length;
+    return { made: E, pooled: t, pooledBytes: S };
+  }
+  /** Lets every pooled buffer go (the world changed map): the next map's effects start a pool of their own. */
+  static drainPool() {
+    for (const t of m.values()) for (const i of t) i.texture.destroy(!0);
+    m.clear(), S = 0;
+  }
+  fillStyle(t, i = 1) {
+    return this.ink = t, this.inkAlpha = i, super.fillStyle(t, i);
+  }
+  fillRect(t, i, s, e) {
+    const l = Math.round(t), o = Math.round(i), c = Math.round(t + s) - l, a = Math.round(i + e) - o;
+    return c > 0 && a > 0 && this.inkAlpha > 0 && this.rects.push(l, o, c, a, this.ink, this.inkAlpha), this;
+  }
+  /** `fillStyle` + `fillRect` on whole pixels in one call, leaving the fill style alone (a hot loop's way in). */
+  rect(t, i, s, e, l, o = 1) {
+    s > 0 && e > 0 && o > 0 && Number.isFinite(t) && Number.isFinite(i) && Number.isFinite(s) && Number.isFinite(e) && this.rects.push(t, i, s, e, l, o);
+  }
+  /**
+   * A solid run of `w` whole pixels at (x, y) in `color`, held until `commit` lays every staged run in the order given
+   * (the later winning where they cross), after whatever was drawn before the commit. What `pixelTone`'s batch writes
+   * instead of filing each pixel in a map and sorting it into rects.
+   */
+  stage(t, i, s, e) {
+    Number.isFinite(t) && Number.isFinite(i) && Number.isFinite(s) && this.staged.push(t, i, s, e);
+  }
+  /** Lays the staged runs, as opaque rects, after everything drawn so far. */
+  commit() {
+    const t = this.staged, i = t.length;
+    if (i === 0) return;
+    const s = this.rects;
+    for (let e = 0; e < i; e += 4) s.push(t[e], t[e + 1], t[e + 2], 1, t[e + 3], 1);
+    t.length = 0;
+  }
+  clear() {
+    return this.rects.length = 0, this.staged.length = 0, super.clear();
+  }
+  /** How far the last frame reached from the layer's origin, in world pixels (0 when nothing showed). */
+  reach() {
+    return this.sprite.visible ? Math.max(Math.abs(this.originX), Math.abs(this.originY), Math.abs(this.originX + this.lastW), Math.abs(this.originY + this.lastH)) : 0;
+  }
+  /** Writes this frame's rects into the texture and shows it; call once the frame is painted. */
+  present() {
+    this.commit();
+    const t = this.rects;
+    if (t.length === 0) {
+      this.sprite.visible = !1;
+      return;
+    }
+    let i = 1 / 0, s = 1 / 0, e = -1 / 0, l = -1 / 0;
+    for (let r = 0; r < t.length; r += 6)
+      t[r] < i && (i = t[r]), t[r + 1] < s && (s = t[r + 1]), t[r] + t[r + 2] > e && (e = t[r] + t[r + 2]), t[r + 1] + t[r + 3] > l && (l = t[r + 1] + t[r + 3]);
+    const o = e - i, c = l - s;
+    if (o > W || c > W) {
+      this.sprite.visible = !1;
+      const r = t.length;
+      for (let u = 0; u < r; u += 6)
+        super.fillStyle(t[u + 4], t[u + 5]), super.fillRect(t[u], t[u + 1], t[u + 2], t[u + 3]);
+      return;
+    }
+    const a = this.fit(o, c), { words: p, pixels: f, capW: g } = a;
+    p.fill(0);
+    for (let r = 0; r < t.length; r += 6) {
+      const u = t[r] - i, y = t[r + 1] - s, M = t[r + 2], v = t[r + 3], P = t[r + 4], x = t[r + 5], k = P >> 16 & 255, A = P >> 8 & 255, H = P & 255;
+      if (x >= 1) {
+        const d = (4278190080 | H << 16 | A << 8 | k) >>> 0;
+        if (M === 1 && v === 1) {
+          p[y * g + u] = d;
+          continue;
+        }
+        for (let h = y; h < y + v; h++) {
+          const b = h * g + u;
+          if (M < 8) for (let X = b, _ = b + M; X < _; X++) p[X] = d;
+          else p.fill(d, b, b + M);
+        }
+        continue;
+      }
+      const w = 1 - x, I = k * x, N = A * x, O = H * x, T = 255 * x;
+      for (let d = y; d < y + v; d++)
+        for (let h = (d * g + u) * 4, b = h + M * 4; h < b; h += 4)
+          f[h] = I + f[h] * w, f[h + 1] = N + f[h + 1] * w, f[h + 2] = O + f[h + 2] * w, f[h + 3] = T + f[h + 3] * w;
+    }
+    a.source.update(), this.sprite.texture = a.texture, this.sprite.position.set(i, s), this.sprite.visible = !0, this.originX = i, this.originY = s, this.lastW = o, this.lastH = c;
+  }
+  /**
+   * Shows `other`'s last frame instead of painting one: its texture, placed where it placed it. A frame shared by
+   * several bodies (the same aura on two bodies) is painted once and shown by each of their layers.
+   */
+  mirror(t) {
+    const i = t.surface;
+    if (!i || !t.sprite.visible) {
+      this.hideMirror();
+      return;
+    }
+    this.sprite.texture = i.texture, this.sprite.position.set(t.originX, t.originY), this.sprite.visible = !0, this.originX = t.originX, this.originY = t.originY, this.lastW = t.lastW, this.lastH = t.lastH;
+  }
+  /** Shows nothing and lets go of the texture a `mirror` showed. */
+  hideMirror() {
+    this.sprite.visible = !1, this.sprite.texture = this.surface?.texture ?? Y.EMPTY;
+  }
+  /** The premultiplied [r, g, b, a] last presented at layer pixel (x, y); zeros where nothing was (tests read it). */
+  pixelAt(t, i) {
+    const s = this.surface, e = s?.capW ?? 0, l = s?.capH ?? 0;
+    if (this.sprite.width !== e || this.sprite.height !== l) throw new Error("PixelLayer sprite is scaled");
+    const o = t - this.originX, c = i - this.originY;
+    if (!s || !this.sprite.visible || o < 0 || c < 0 || o >= e || c >= l) return [0, 0, 0, 0];
+    const a = (c * e + o) * 4;
+    return [s.pixels[a], s.pixels[a + 1], s.pixels[a + 2], s.pixels[a + 3]];
+  }
+  /** The buffer's size (tests read it). */
+  capacity() {
+    return { w: this.surface?.capW ?? 0, h: this.surface?.capH ?? 0 };
+  }
+  /**
+   * A buffer at least `w` × `h`: grown a size class at a time and kept while it fits, traded back to the pool for a
+   * smaller one only once the frames have stayed well inside it for `SHRINK_AFTER` presents (a long-lived layer — an
+   * aura, a status mark — that once swelled would otherwise hold and upload its largest buffer for good).
+   */
+  fit(t, i) {
+    const s = this.surface;
+    if (s && t <= s.capW && i <= s.capH) {
+      const a = s.capW * s.capH >= 16384 && t * 4 <= s.capW && i * 4 <= s.capH;
+      if (this.small = a ? this.small + 1 : 0, this.small < j) return s;
+    }
+    this.small = 0;
+    const e = !!s && (t > s.capW || i > s.capH), l = L(Math.max(1, t, e ? s.capW : 0)), o = L(Math.max(1, i, e ? s.capH : 0));
+    this.dropSurface();
+    const c = q(l, o);
+    return this.surface = c, this.sprite.texture = c.texture, c;
+  }
+  dropSurface() {
+    this.sprite.texture = Y.EMPTY, this.surface && z(this.surface), this.surface = null;
+  }
+  destroy() {
+    this.destroyed || (this.dropSurface(), super.destroy());
+  }
+}
+export {
+  J as PixelLayer,
+  $ as addPixelLayer
+};

package/dist/pixel/PixelMarks.js

@@ -0,0 +1,99 @@
+import { ringPixels as d, discRuns as k, ellipsePixels as u, chevronPixels as $ } from "./aimPixels.js";
+function n(g, h, t) {
+  g.fillStyle(t, 1);
+  for (const [s, i] of h) g.fillRect(s, i, 1, 1);
+}
+class P {
+  constructor(h, t) {
+    this.stage = h, this.tones = t.tones, this.depth = t.depth ?? 0, this.headings = Math.max(4, Math.round(t.headings ?? 32)), this.spacing = Math.max(1, t.spacing ?? 10), this.creep = t.creep ?? 0.02, this.fillAlpha = t.fillAlpha ?? 0.28;
+  }
+  stage;
+  tones;
+  depth;
+  headings;
+  spacing;
+  creep;
+  fillAlpha;
+  cache = /* @__PURE__ */ new Map();
+  pool = [];
+  used = 0;
+  shown = /* @__PURE__ */ new Set();
+  next = /* @__PURE__ */ new Set();
+  begin() {
+    this.used = 0, this.next.clear();
+  }
+  /** A ring of radius `r` round (x, y): the bright line with dark pixels just inside and outside it. */
+  ring(h, t, s, i) {
+    const e = this.tones[i];
+    s = Math.max(2, Math.round(s)), this.place(`ring:${s}:${i}`, h, t, (l) => {
+      n(l, d(s + 1), e.dark), n(l, d(Math.max(1, s - 1)), e.dark), n(l, d(s), e.light);
+    });
+  }
+  /** A filled disc of radius `r` with a bright rim and a cross at its middle: where a skill aimed at a spot lands. */
+  disc(h, t, s, i) {
+    const e = this.tones[i];
+    s = Math.max(2, Math.round(s)), this.place(`disc:${s}:${i}`, h, t, (l) => {
+      l.fillStyle(e.fill, this.fillAlpha);
+      for (const [a, o, c] of k(s)) l.fillRect(o, a, c - o + 1, 1);
+      n(l, d(s + 1), e.dark), n(l, d(s), e.rim), l.fillStyle(e.light, 1).fillRect(-1, 0, 3, 1).fillRect(0, -1, 1, 3);
+    });
+  }
+  /** A ring on the ground in three-quarter view, `rx` wide and `ry` deep, centred on (x, y) — a body's feet. */
+  groundRing(h, t, s, i, e) {
+    const l = this.tones[e];
+    s = Math.max(3, Math.round(s)), i = Math.max(2, Math.round(i)), this.place(`ell:${s}:${i}:${e}`, h, t, (a) => {
+      n(a, u(s + 1, i + 1), l.dark), n(a, u(s - 1, i - 1), l.dark), n(a, u(s, i), l.rim), a.fillStyle(l.light, 1).fillRect(-s, 0, 1, 1).fillRect(s, 0, 1, 1).fillRect(-1, i, 3, 1);
+    });
+  }
+  /**
+   * An aim line from (x, y) along `angle`, from `start` to `end` px out: chevrons `size` px across every `spacing`,
+   * creeping forward with `now`, and a larger one at the end.
+   */
+  chevrons(h, t, s, i, e, l, a, o) {
+    const c = this.heading(i), f = c / this.headings * Math.PI * 2, r = Math.cos(i), x = Math.sin(i), m = h * this.creep % this.spacing, M = l - a;
+    for (let p = e + m; p < M - this.spacing * 0.5; p += this.spacing) this.chevron(t + r * p, s + x * p, c, f, a, o);
+    this.chevron(t + r * M, s + x * M, c, f, a + 2, o);
+  }
+  /**
+   * One still chevron `dist` px out from (x, y) along `angle`: the way the next blow goes. Unlike `chevrons` it does
+   * not creep, so an arrow always under the feet does not keep catching the eye.
+   */
+  pointer(h, t, s, i, e, l) {
+    const a = this.heading(s);
+    this.chevron(h + Math.cos(s) * i, t + Math.sin(s) * i, a, a / this.headings * Math.PI * 2, e, l);
+  }
+  end() {
+    for (let t = this.used; t < this.pool.length; t++) this.pool[t].g.setVisible(!1);
+    for (const t of this.shown) this.next.has(t) || t.setVisible(!1);
+    for (const t of this.next) t.setVisible(!0);
+    const h = this.shown;
+    this.shown = this.next, this.next = h;
+  }
+  destroy() {
+    for (const h of this.cache.values()) h.destroy();
+    for (const h of this.pool) h.g.destroy();
+    this.cache.clear(), this.pool.length = 0, this.shown.clear(), this.next.clear();
+  }
+  heading(h) {
+    const t = this.headings;
+    return (Math.round(h / (Math.PI * 2) * t) % t + t) % t;
+  }
+  chevron(h, t, s, i, e, l) {
+    let a = this.pool[this.used];
+    a || (a = { g: this.stage.add.graphics().setDepth(this.depth), key: "" }, this.pool.push(a)), this.used++;
+    const o = `${s}:${e}:${l}`;
+    if (a.key !== o) {
+      a.key = o;
+      const c = this.tones[l], { lit: f, rim: r } = $(i, e);
+      a.g.clear(), n(a.g, r, c.dark), n(a.g, f, c.light);
+    }
+    a.g.setPosition(Math.round(h), Math.round(t)).setVisible(!0);
+  }
+  place(h, t, s, i) {
+    let e = this.cache.get(h);
+    e || (e = this.stage.add.graphics().setDepth(this.depth), i(e), e.setVisible(!1), this.cache.set(h, e)), e.setPosition(Math.round(t), Math.round(s)), this.next.add(e);
+  }
+}
+export {
+  P as PixelMarks
+};

package/dist/pixel/SwayProp.js

@@ -0,0 +1,74 @@
+import { Sprite as b, Texture as m, Rectangle as I } from "pixi.js";
+import { buildRig as M, gustAt as R, swayOffset as S } from "./swayRig.js";
+const g = /* @__PURE__ */ new WeakMap();
+function v(r, t) {
+  let s = g.get(r.source);
+  s || g.set(r.source, s = /* @__PURE__ */ new Map());
+  const h = r.frame, o = `${h.x + t.x},${h.y + t.y},${t.w},${t.h}`;
+  let i = s.get(o);
+  return i || s.set(o, i = new m({ source: r.source, frame: new I(h.x + t.x, h.y + t.y, t.w, t.h) })), i;
+}
+function $(r) {
+  const s = r.source.resource?.getContext?.("2d");
+  if (!s) return;
+  const { x: h, y: o, width: i, height: c } = r.frame, e = s.getImageData(h, o, i, c).data, n = [];
+  for (let u = 0; u < c; u++) {
+    let p = -1, d = -1;
+    for (let f = 0; f < i; f++)
+      e[(u * i + f) * 4 + 3] > 0 && (p < 0 && (p = f), d = f);
+    n.push(p < 0 ? 0 : d - p + 1);
+  }
+  return n;
+}
+class k {
+  constructor(t, s, h = {}) {
+    this.img = t, this.def = s, this.phase = h.phase ?? 0, this.speed = s.speed * (h.pace ?? 1), this.shown = t.visible, this.alpha = t.alpha;
+    const o = t.texture, i = o.frame.width, c = o.frame.height, e = t.parent, n = h.rig ?? (i >= 2 && c >= 2 ? M(s, i, c, s.mode === "crown" ? h.rowWidths ?? $(o) : void 0, h.variant ?? 0) : null);
+    if (this.active = !!n && !!e && n.pieces.length > 0 && n.strips.length > 0, !this.active || !n || !e) return;
+    const u = t.anchor.x * i, p = t.anchor.y * c, d = Math.round(t.x - u), f = Math.round(t.y - p), [w, ...y] = n.pieces;
+    t.texture = v(o, w), t.anchor.set((u - w.x) / w.w, (p - w.y) / w.h);
+    const x = (a) => {
+      const l = new b(v(o, a));
+      return l.position.set(d + a.x, f + a.y), l.zIndex = t.zIndex, l.visible = t.visible, l.alpha = t.alpha, e.addChild(l), this.parts.push(l), l;
+    };
+    for (const a of y) x(a);
+    for (const a of n.strips) this.strips.push({ sprite: x(a.rect), homeX: d + a.rect.x, weight: a.weight, lag: a.lag, offset: 0 });
+  }
+  img;
+  def;
+  parts = [];
+  strips = [];
+  phase;
+  speed;
+  shown;
+  alpha;
+  /** False when the frame is too small or the rig has nothing to move: `update` then does nothing. */
+  active;
+  /** `tSec` seconds of any steady clock; `enabled` false stands everything still (an ambient-effects setting). */
+  update(t, s, h = !0) {
+    if (!this.active) return;
+    const o = this.img.visible;
+    if (o !== this.shown) {
+      this.shown = o;
+      for (const e of this.parts) e.visible = o;
+    }
+    if (!o) return;
+    if (this.img.alpha !== this.alpha) {
+      this.alpha = this.img.alpha;
+      for (const e of this.parts) e.alpha = this.alpha;
+    }
+    const i = !h || s.wind <= 0, c = i ? 0 : R(t, this.img.x, s.gustSeconds, s.gustPx);
+    for (const e of this.strips) {
+      const n = i ? 0 : S(t, this.speed, this.phase, e.lag, this.def.amp, s.wind, c, e.weight, s.minReach ?? 0);
+      n !== e.offset && (e.offset = n, e.sprite.x = e.homeX + n);
+    }
+  }
+  destroy() {
+    for (const t of this.parts) t.destroy();
+    this.parts.length = 0, this.strips.length = 0;
+  }
+}
+export {
+  k as SwayProp,
+  $ as opaqueRowWidths
+};

package/dist/pixel/aimPixels.js

@@ -0,0 +1,67 @@
+function w(n) {
+  n = Math.max(1, Math.round(n));
+  const o = /* @__PURE__ */ new Set(), h = [], l = (e, c) => {
+    const r = `${e},${c}`;
+    o.has(r) || (o.add(r), h.push([e, c]));
+  };
+  let u = n, t = 0, s = 1 - n;
+  for (; u >= t; ) {
+    for (const [e, c] of [[u, t], [t, u], [-t, u], [-u, t], [-u, -t], [-t, -u], [t, -u], [u, -t]]) l(e, c);
+    t++, s < 0 ? s += 2 * t + 1 : (u--, s += 2 * (t - u) + 1);
+  }
+  return h;
+}
+function x(n) {
+  n = Math.max(1, Math.round(n));
+  const o = [];
+  for (let h = -n; h <= n; h++) {
+    const l = Math.floor(Math.sqrt(n * n - h * h) + 0.5);
+    o.push([h, -l, l]);
+  }
+  return o;
+}
+function S(n, o) {
+  n = Math.max(1, Math.round(n)), o = Math.max(1, Math.round(o));
+  const h = /* @__PURE__ */ new Set(), l = [], u = (f, d) => {
+    for (const [m, p] of [[f, d], [-f, d], [f, -d], [-f, -d]]) {
+      const $ = `${m},${p}`;
+      h.has($) || (h.add($), l.push([m, p]));
+    }
+  }, t = n * n, s = o * o;
+  let e = 0, c = o, r = s - t * o + 0.25 * t, M = 2 * s * e, a = 2 * t * c;
+  for (; M < a; )
+    u(e, c), e++, M += 2 * s, r < 0 ? r += M + s : (c--, a -= 2 * t, r += M - a + s);
+  let i = s * (e + 0.5) * (e + 0.5) + t * (c - 1) * (c - 1) - t * s;
+  for (; c >= 0; )
+    u(e, c), c--, a -= 2 * t, i > 0 ? i += t - a : (e++, M += 2 * s, i += M - a + t);
+  return l;
+}
+function b(n, o) {
+  const h = Math.cos(n), l = Math.sin(n), u = { u: o * 0.5, v: 0 }, t = [
+    { u: -o * 0.5, v: -o },
+    { u: -o * 0.5, v: o }
+  ], s = o + 2, e = /* @__PURE__ */ new Set(), c = [];
+  for (let a = -s; a <= s; a++)
+    for (let i = -s; i <= s; i++) {
+      const f = i * h + a * l, d = -i * l + a * h;
+      Math.min(...t.map((m) => v(f, d, m.u, m.v, u.u, u.v))) <= 0.72 && (e.add(`${i},${a}`), c.push([i, a]));
+    }
+  const r = [], M = /* @__PURE__ */ new Set();
+  for (const [a, i] of c)
+    for (let f = -1; f <= 1; f++)
+      for (let d = -1; d <= 1; d++) {
+        const m = `${a + d},${i + f}`;
+        e.has(m) || M.has(m) || (M.add(m), r.push([a + d, i + f]));
+      }
+  return { lit: c, rim: r };
+}
+function v(n, o, h, l, u, t) {
+  const s = u - h, e = t - l, c = Math.max(0, Math.min(1, ((n - h) * s + (o - l) * e) / (s * s + e * e)));
+  return Math.hypot(n - (h + s * c), o - (l + e * c));
+}
+export {
+  b as chevronPixels,
+  x as discRuns,
+  S as ellipsePixels,
+  w as ringPixels
+};

package/dist/pixel/lights.js

@@ -0,0 +1,43 @@
+import { engineSettings as l } from "../settings.js";
+const s = 16773320, i = [], c = 48;
+function g(n, o, t, e, f = s, r = performance.now()) {
+  i.length >= c && i.shift(), i.push({ x: n, y: o, r: t, born: r, until: r + e, fades: !0, color: f });
+}
+const u = 2e4;
+function p(n, o, t = s, e = performance.now()) {
+  const f = n(), r = { x: f.x, y: f.y, r: o, born: e, until: e + u, follow: n, fades: !1, color: t };
+  return i.length >= c && i.shift(), i.push(r), { end: () => r.until = 0 };
+}
+const h = [];
+function d(n) {
+  for (let t = i.length - 1; t >= 0; t--) i[t].until <= n && i.splice(t, 1);
+  const o = l.getState();
+  if (o.combatLights === !1 || o.batterySaver) return h;
+  for (const t of i) {
+    if (!t.follow) continue;
+    let e;
+    try {
+      e = t.follow();
+    } catch {
+      t.until = 0, t.follow = void 0;
+      continue;
+    }
+    t.x = e.x, t.y = e.y;
+  }
+  return i;
+}
+function m(n, o) {
+  if (!n.fades) return n.r;
+  const t = Math.min(1, (o - n.born) / Math.max(1, n.until - n.born));
+  return n.r * Math.sqrt(1 - t);
+}
+function L() {
+  i.length = 0;
+}
+export {
+  p as carriedLight,
+  L as clearLights,
+  g as flashLight,
+  m as lightRadius,
+  d as liveLights
+};

package/dist/pixel/nineSlice.js

@@ -0,0 +1,61 @@
+import { CLEAR as $, channels as m, PixelGrid as p, hex as d } from "./pixel.js";
+const v = {
+  /** A window: ink, a two-step brass rim, a gap, a lit bevel, a rivet in the corner. */
+  panel: ["..KKKKKK", ".KHHHHHH", "KHHMMMMM", "KHMKGGGG", "KHMGRSSS", "KHMGSFFF", "KHMGSFFF", "KHMGSFFF"],
+  /** A raised button: a two-step bevel, notched. Give it shadow [0, 1]; pressed, offset [0, 1] with the bevel's colours swapped. */
+  button: [".KKKK", "KHHHH", "KHMMM", "KHMFF", "KHMFF"],
+  /** A small raised button. */
+  smallButton: [".KKK", "KHHH", "KHMM", "KHMF"],
+  /** A text field: a hole in the stone, its lip in shadow top-left (D, G) and lit bottom-right (d, g). */
+  field: [".KKKK", "KDDDD", "KDGGG", "KDGFF", "KDGFF"],
+  /** A sunk well (slots, bars' tracks). */
+  well: [".KK", "KDD", "KDF"],
+  /** A list row: a flat slab lit on the top and left. */
+  row: [".KK", "KSS", "KSF"],
+  /** A thin frame: one pixel of rim (toasts, a cast bar). */
+  thin: [".KK", "KHH", "KHF"]
+}, u = { H: "L", S: "s", M: "m", D: "d", G: "g" }, G = (t) => typeof t == "string" ? d(t) : t;
+function x(t, K, l, s, H) {
+  const o = t.length, e = o * 2 + 1, i = s > o, r = H > o, M = i ? e - 1 - s : s, F = r ? e - 1 - H : H, w = t[Math.min(F, o - 1)][Math.min(M, o - 1)] ?? ".", h = M >= F, S = i && !h || r && h || i && r, n = l[w];
+  return S && n && K[n] !== void 0 ? n : w;
+}
+function y(t) {
+  const { corner: K, palette: l } = t, s = K.length;
+  if (!s || K.some((n) => n.length !== s)) throw new Error("nineSlice: the corner must be square");
+  const H = t.twins ?? u, o = s * 2 + 1, [e, i] = t.shadow ?? [0, 0], [r, M] = t.offset ?? [0, 0], [F, w] = t.pad ?? [e, i], h = new p(o + F, o + w), S = t.shadowColor ?? l.Z ?? 2348810240;
+  if (e || i) {
+    const n = G(S);
+    for (let c = 0; c < o; c++) for (let f = 0; f < o; f++) x(K, l, H, f, c) !== "." && h.px(f + e, c + i, n);
+  }
+  for (let n = 0; n < o; n++)
+    for (let c = 0; c < o; c++) {
+      const f = t.overlay?.[n]?.[c], a = f && f !== "." ? f : x(K, l, H, c, n), g = l[a];
+      a !== "." && g !== void 0 && h.px(c + r, n + M, G(g));
+    }
+  return { grid: h, insets: { top: s, left: s, right: s + F, bottom: s + w } };
+}
+function E(t, K = 2) {
+  const l = [];
+  for (let o = 0; o < t.h; o++) {
+    let e = 0;
+    for (; e < t.w; ) {
+      const i = t.get(e, o);
+      let r = e + 1;
+      for (; r < t.w && t.get(r, o) === i; ) r++;
+      if (i !== $ && i >>> 24 > 0) {
+        const [M, F, w, h] = m(i), S = `#${(M << 16 | F << 8 | w).toString(16).padStart(6, "0")}`, n = h < 255 ? ` fill-opacity="${+(h / 255).toFixed(3)}"` : "";
+        l.push(`<rect x="${e * K}" y="${o * K}" width="${(r - e) * K}" height="${K}" fill="${S}"${n}/>`);
+      }
+      e = r;
+    }
+  }
+  const s = t.w * K, H = t.h * K;
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${s}" height="${H}" viewBox="0 0 ${s} ${H}" shape-rendering="crispEdges">${l.join("")}</svg>
+`;
+}
+export {
+  v as FRAME_CORNERS,
+  u as FRAME_TWINS,
+  E as frameSvg,
+  y as nineSlice
+};