1681-engine 0.0.0-stage → 0.5.9

package/dist/pixel/paintLayer.js

@@ -0,0 +1,35 @@
+import { inView as C } from "../fx/viewCull.js";
+import { addPixelLayer as w } from "./PixelLayer.js";
+import { setCoverage as M, beginBatch as R, endBatch as U } from "./pixelTone.js";
+const _ = 64, b = 192;
+function O(o, a) {
+  const { at: v, duration: n, paint: x, alive: f } = a, s = a.depth ?? ((t) => t + 45), h = 1e3 / (a.fps ?? 12), l = a.every ?? 1, c = Math.min(a.fadeMs ?? 260, n * 0.3), e = w(o);
+  a.onCreate?.(e);
+  const y = { elapsed: 0 };
+  let i = -1, p = b;
+  const d = o.cameras.main, u = () => {
+    if (f && !f()) {
+      e.destroy();
+      return;
+    }
+    const t = v();
+    e.setPosition(d.snap(t.x), d.snap(t.y)).setDepth(typeof s == "number" ? s : s(t.y));
+    let r = Math.floor(y.elapsed / h);
+    if (l > 1 && (r -= r % l), r === i || i >= 0 && !C(d, t.x, t.y, _ + Math.max(p, e.reach()))) return;
+    i = r, e.clear();
+    const m = Math.min(n, r * h);
+    M(c > 0 && m > n - c ? Math.max(0, (n - m) / c) * 0.85 + 0.15 : 1), R(e);
+    try {
+      x(e, m);
+    } finally {
+      U(), M(1);
+    }
+    e.present(), p = Math.max(p, e.reach());
+  };
+  if (u(), !e.active) return e;
+  const L = o.tweens.add({ targets: y, elapsed: n, duration: n, onUpdate: u, onComplete: () => e.destroy() });
+  return e.once("destroyed", () => L.remove()), e;
+}
+export {
+  O as paintLayer
+};

package/dist/pixel/palette.js

@@ -0,0 +1,56 @@
+import { hex as a } from "./pixel.js";
+const r = {
+  outline: a("#1a1220"),
+  outlineSoft: a("#2e2233"),
+  black: a("#0e0b12"),
+  white: a("#f4f0e8"),
+  offWhite: a("#e2dccf"),
+  skin: a("#f2c59a"),
+  skinShade: a("#d99d74"),
+  skinTan: a("#cf9468"),
+  skinTanShade: a("#a86c48"),
+  blush: a("#e88c80"),
+  hairBlack: a("#2a2230"),
+  hairBrown: a("#5b3a29"),
+  hairAuburn: a("#7a3b2a"),
+  hairWhite: a("#e8e4dc"),
+  hairGrey: a("#9a96a0"),
+  red: a("#c8373a"),
+  redDark: a("#8e2331"),
+  crimson: a("#a3243b"),
+  orange: a("#e07a36"),
+  gold: a("#f2c84b"),
+  goldDark: a("#b88a2a"),
+  yellow: a("#f5e06a"),
+  green: a("#5aa04a"),
+  greenDark: a("#2f6b3a"),
+  jade: a("#4fbf8f"),
+  jadeDark: a("#2d8466"),
+  teal: a("#3aa6a0"),
+  sky: a("#7ec4f0"),
+  azure: a("#4a8ad4"),
+  blue: a("#3560b0"),
+  navy: a("#27335e"),
+  indigo: a("#3b2f6e"),
+  purple: a("#7a4bb0"),
+  pink: a("#e89aaa"),
+  brown: a("#7a5234"),
+  brownDark: a("#4e3222"),
+  brownLight: a("#a6784a"),
+  tan: a("#c9a26e"),
+  cream: a("#efe2c0"),
+  grey: a("#8a8690"),
+  greyDark: a("#57535e"),
+  greyLight: a("#bdb9c2"),
+  steel: a("#c8d2dc"),
+  steelDark: a("#7f8a98"),
+  iron: a("#9aa0a8"),
+  wood: a("#9a6a3c"),
+  woodDark: a("#6a4426"),
+  woodLight: a("#bd8c56"),
+  straw: a("#d8b060"),
+  strawDark: a("#a8823e")
+};
+export {
+  r as P
+};

package/dist/pixel/pixel.js

@@ -0,0 +1,277 @@
+const D = 0;
+function b(r, t, n, h = 255) {
+  const s = Math.max(0, Math.min(255, Math.round(r))), o = Math.max(0, Math.min(255, Math.round(t))), i = Math.max(0, Math.min(255, Math.round(n)));
+  return (Math.max(0, Math.min(255, Math.round(h))) << 24 | i << 16 | o << 8 | s) >>> 0;
+}
+function U(r) {
+  let t = r.startsWith("#") ? r.slice(1) : r;
+  t.length === 3 && (t = [...t].map((i) => i + i).join(""));
+  const n = parseInt(t.slice(0, 2), 16), h = parseInt(t.slice(2, 4), 16), s = parseInt(t.slice(4, 6), 16), o = t.length >= 8 ? parseInt(t.slice(6, 8), 16) : 255;
+  return b(n, h, s, o);
+}
+function m(r) {
+  return [r & 255, r >>> 8 & 255, r >>> 16 & 255, r >>> 24 & 255];
+}
+function B(r, t) {
+  const [n, h, s, o] = m(r);
+  if (t >= 1) {
+    const i = Math.min(1, t - 1);
+    return b(n + (255 - n) * i, h + (255 - h) * i, s + (255 - s) * i, o);
+  }
+  return b(n * t, h * t, s * t, o);
+}
+function L(r, t, n) {
+  const h = m(r), s = m(t);
+  return b(h[0] + (s[0] - h[0]) * n, h[1] + (s[1] - h[1]) * n, h[2] + (s[2] - h[2]) * n, h[3] + (s[3] - h[3]) * n);
+}
+function R(r, t) {
+  const [n, h, s] = m(r);
+  return b(n, h, s, t);
+}
+function $(r) {
+  const [t, n, h, s] = m(r);
+  return `rgba(${t},${n},${h},${(s / 255).toFixed(3)})`;
+}
+function C(r, t, n = 0) {
+  let h = r * 374761393 + t * 668265263 + n * 2147483647 | 0;
+  return h = Math.imul(h ^ h >>> 13, 1274126177), ((h ^ h >>> 16) >>> 0) / 4294967296;
+}
+function v(r) {
+  let t = r >>> 0;
+  return () => {
+    t = t + 1831565813 >>> 0;
+    let n = t;
+    return n = Math.imul(n ^ n >>> 15, n | 1), n ^= n + Math.imul(n ^ n >>> 7, n | 61), ((n ^ n >>> 14) >>> 0) / 4294967296;
+  };
+}
+function S(r, t, n, h) {
+  const s = r / n, o = t / n, i = Math.floor(s), e = Math.floor(o), l = s - i, c = o - e, M = l * l * (3 - 2 * l), d = c * c * (3 - 2 * c), w = C(i, e, h), a = C(i + 1, e, h), u = C(i, e + 1, h), f = C(i + 1, e + 1, h);
+  return w + (a - w) * M + (u - w) * d + (w - a - u + f) * M * d;
+}
+class A {
+  constructor(t, n) {
+    this.w = t, this.h = n, this.data = new Uint32Array(t * n);
+  }
+  w;
+  h;
+  data;
+  inBounds(t, n) {
+    return t >= 0 && n >= 0 && t < this.w && n < this.h;
+  }
+  px(t, n, h) {
+    t = Math.floor(t), n = Math.floor(n), t >= 0 && n >= 0 && t < this.w && n < this.h && (this.data[n * this.w + t] = h);
+  }
+  get(t, n) {
+    return t < 0 || n < 0 || t >= this.w || n >= this.h ? 0 : this.data[n * this.w + t] ?? 0;
+  }
+  alphaAt(t, n) {
+    return this.get(t, n) >>> 24;
+  }
+  rect(t, n, h, s, o) {
+    for (let i = Math.floor(n); i < n + s; i++) for (let e = Math.floor(t); e < t + h; e++) this.px(e, i, o);
+  }
+  hline(t, n, h, s) {
+    for (let o = Math.min(t, n); o <= Math.max(t, n); o++) this.px(o, h, s);
+  }
+  vline(t, n, h, s) {
+    for (let o = Math.min(n, h); o <= Math.max(n, h); o++) this.px(t, o, s);
+  }
+  /** Filled ellipse; a pixel is inside when its center lies inside the ellipse. */
+  ellipse(t, n, h, s, o) {
+    if (!(h <= 0 || s <= 0))
+      for (let i = Math.floor(n - s); i <= Math.ceil(n + s); i++)
+        for (let e = Math.floor(t - h); e <= Math.ceil(t + h); e++) {
+          const l = (e + 0.5 - t) / h, c = (i + 0.5 - n) / s;
+          l * l + c * c <= 1 && this.px(e, i, o);
+        }
+  }
+  circle(t, n, h, s) {
+    this.ellipse(t, n, h, h, s);
+  }
+  ring(t, n, h, s, o) {
+    for (let i = Math.floor(n - h - 1); i <= Math.ceil(n + h + 1); i++)
+      for (let e = Math.floor(t - h - 1); e <= Math.ceil(t + h + 1); e++) {
+        const l = Math.hypot(e + 0.5 - t, i + 0.5 - n);
+        l <= h && l >= h - s && this.px(e, i, o);
+      }
+  }
+  line(t, n, h, s, o, i = 1) {
+    t = Math.round(t), n = Math.round(n), h = Math.round(h), s = Math.round(s);
+    const e = Math.abs(h - t), l = -Math.abs(s - n), c = t < h ? 1 : -1, M = n < s ? 1 : -1;
+    let d = e + l;
+    for (; i <= 1 ? this.px(t, n, o) : this.rect(t - Math.floor((i - 1) / 2), n - Math.floor((i - 1) / 2), i, i, o), !(t === h && n === s); ) {
+      const w = 2 * d;
+      w >= l && (d += l, t += c), w <= e && (d += e, n += M);
+    }
+  }
+  /** Filled polygon (even-odd scanline on pixel centers). */
+  poly(t, n) {
+    if (t.length < 3) return;
+    const h = Math.floor(Math.min(...t.map((o) => o[1]))), s = Math.ceil(Math.max(...t.map((o) => o[1])));
+    for (let o = h; o <= s; o++) {
+      const i = o + 0.5, e = [];
+      for (let l = 0; l < t.length; l++) {
+        const c = t[l], M = t[(l + 1) % t.length];
+        (c[1] <= i && M[1] > i || M[1] <= i && c[1] > i) && e.push(c[0] + (i - c[1]) / (M[1] - c[1]) * (M[0] - c[0]));
+      }
+      e.sort((l, c) => l - c);
+      for (let l = 0; l + 1 < e.length; l += 2)
+        for (let c = Math.ceil(e[l] - 0.5); c <= Math.floor(e[l + 1] - 0.5); c++) this.px(c, o, n);
+    }
+  }
+  /**
+   * Adds `width` pixels of outline around all opaque pixels, one ring at a time — the same result as calling it
+   * `width` times, but each ring only visits the neighbours of the ring before it instead of the whole grid again.
+   * (A pixel next to ring `k` is always filled by ring `k+1`, so nothing further back can still be waiting.)
+   */
+  outline(t, n = !1, h = 1) {
+    const s = this.w, o = this.h, i = new Uint8Array(this.data.length);
+    let e = s, l = o, c = -1, M = -1;
+    for (let a = 0; a < o; a++)
+      for (let u = 0; u < s; u++) {
+        const f = a * s + u;
+        this.data[f] >>> 24 && (i[f] = 1, u < e && (e = u), u > c && (c = u), a < l && (l = a), M = a);
+      }
+    if (c < 0) return;
+    const d = (a, u, f) => a >= 0 && u >= 0 && a < s && u < o && i[f] === 1;
+    let w = [];
+    for (let a = Math.max(0, l - 1); a <= Math.min(o - 1, M + 1); a++)
+      for (let u = Math.max(0, e - 1); u <= Math.min(s - 1, c + 1); u++) {
+        const f = a * s + u;
+        if (i[f]) continue;
+        let g = d(u - 1, a, f - 1) || d(u + 1, a, f + 1) || d(u, a - 1, f - s) || d(u, a + 1, f + s);
+        !g && n && (g = d(u - 1, a - 1, f - s - 1) || d(u + 1, a - 1, f - s + 1) || d(u - 1, a + 1, f + s - 1) || d(u + 1, a + 1, f + s + 1)), g && (this.data[f] = t, w.push(f));
+      }
+    for (const a of w) i[a] = 1;
+    for (let a = 1; a < h && w.length; a++) {
+      const u = [];
+      for (const f of w) {
+        const g = f % s, p = f / s | 0, x = (E, I, y) => {
+          E < 0 || I < 0 || E >= s || I >= o || i[y] || (i[y] = 1, this.data[y] = t, u.push(y));
+        };
+        x(g - 1, p, f - 1), x(g + 1, p, f + 1), x(g, p - 1, f - s), x(g, p + 1, f + s), n && (x(g - 1, p - 1, f - s - 1), x(g + 1, p - 1, f - s + 1), x(g - 1, p + 1, f + s - 1), x(g + 1, p + 1, f + s + 1));
+      }
+      w = u;
+    }
+  }
+  /** Replaces every pixel whose color matches `from`. */
+  recolor(t, n) {
+    for (let h = 0; h < this.data.length; h++) this.data[h] === t && (this.data[h] = n);
+  }
+  /** Multiplies brightness of opaque pixels matching `pred`. */
+  tint(t, n) {
+    for (let h = 0; h < this.h; h++)
+      for (let s = 0; s < this.w; s++) {
+        const o = h * this.w + s, i = this.data[o] ?? 0;
+        i >>> 24 && n(s, h) && (this.data[o] = B(i, t));
+      }
+  }
+  blit(t, n, h, s = !1) {
+    for (let o = 0; o < t.h; o++)
+      for (let i = 0; i < t.w; i++) {
+        const e = t.data[o * t.w + i] ?? 0;
+        e >>> 24 && this.px(n + (s ? t.w - 1 - i : i), h + o, e);
+      }
+  }
+  /** Alpha-blends a color onto an existing pixel. */
+  blend(t, n, h) {
+    if (!this.inBounds(t, n)) return;
+    const s = n * this.w + t, o = this.data[s] ?? 0, [i, e, l, c] = m(h), M = c / 255, d = m(o);
+    this.data[s] = b(d[0] + (i - d[0]) * M, d[1] + (e - d[1]) * M, d[2] + (l - d[2]) * M, Math.max(d[3], c));
+  }
+  /** Reads a canvas back into a grid (a PNG layer of the paper doll joining the painted ones). */
+  static from(t) {
+    const n = new A(t.width, t.height), h = t.getContext("2d").getImageData(0, 0, t.width, t.height);
+    return n.data.set(new Uint32Array(h.data.buffer, h.data.byteOffset, t.width * t.height)), n;
+  }
+  /** The same picture on a grid `factor` times as fine, each pixel becoming a square block. */
+  upscaled(t) {
+    if (t === 1) return this;
+    const n = new A(this.w * t, this.h * t);
+    for (let h = 0; h < this.h; h++)
+      for (let s = 0; s < this.w; s++) {
+        const o = this.data[h * this.w + s] ?? 0;
+        o >>> 24 && n.rect(s * t, h * t, t, t, o);
+      }
+    return n;
+  }
+  /** Same size and same pixels. */
+  equals(t) {
+    if (t.w !== this.w || t.h !== this.h) return !1;
+    for (let n = 0; n < this.data.length; n++) if (this.data[n] !== t.data[n]) return !1;
+    return !0;
+  }
+  /** Cheap hash of the pixels, for grouping identical frames before comparing them. */
+  key() {
+    let t = 2166136261;
+    for (let n = 0; n < this.data.length; n++)
+      t ^= this.data[n], t = Math.imul(t, 16777619) >>> 0;
+    return t >>> 0;
+  }
+  clone() {
+    const t = new A(this.w, this.h);
+    return t.data.set(this.data), t;
+  }
+  toCanvas() {
+    const t = document.createElement("canvas");
+    t.width = this.w, t.height = this.h;
+    const n = t.getContext("2d");
+    if (!n) throw new Error("2D canvas not supported");
+    const h = new Uint8ClampedArray(this.w * this.h * 4);
+    h.set(new Uint8Array(this.data.buffer, this.data.byteOffset, this.data.byteLength));
+    const s = new ImageData(h, this.w, this.h);
+    return n.putImageData(s, 0, 0), t;
+  }
+}
+class O extends A {
+  constructor(t, n, h, s) {
+    super(h, s), this.x0 = t, this.y0 = n;
+  }
+  x0;
+  y0;
+  inBounds(t, n) {
+    return super.inBounds(t - this.x0, n - this.y0);
+  }
+  px(t, n, h) {
+    super.px(Math.floor(t) - this.x0, Math.floor(n) - this.y0, h);
+  }
+  get(t, n) {
+    return super.get(t - this.x0, n - this.y0);
+  }
+  blend(t, n, h) {
+    const s = t - this.x0, o = n - this.y0;
+    if (!super.inBounds(s, o)) return;
+    const i = o * this.w + s, e = this.data[i] ?? 0, [l, c, M, d] = m(h), w = d / 255, a = m(e);
+    this.data[i] = b(a[0] + (l - a[0]) * w, a[1] + (c - a[1]) * w, a[2] + (M - a[2]) * w, Math.max(a[3], d));
+  }
+}
+function W(r, t = 16384) {
+  const n = r[0];
+  if (!n) throw new Error("makeSheet: no frames");
+  const h = Math.max(1, Math.min(r.length, Math.floor(t / n.w))), s = Math.ceil(r.length / h), o = new A(n.w * h, n.h * s);
+  return r.forEach((i, e) => o.blit(i, e % h * n.w, Math.floor(e / h) * n.h)), o.toCanvas();
+}
+function Y(r, t) {
+  const n = document.createElement("canvas");
+  n.width = r.width * t, n.height = r.height * t;
+  const h = n.getContext("2d");
+  if (!h) throw new Error("2D canvas not supported");
+  return h.imageSmoothingEnabled = !1, h.drawImage(r, 0, 0, n.width, n.height), n;
+}
+export {
+  D as CLEAR,
+  A as PixelGrid,
+  O as PixelWindow,
+  m as channels,
+  C as hash2,
+  U as hex,
+  W as makeSheet,
+  L as mix,
+  v as mulberry32,
+  b as rgba,
+  B as shade,
+  $ as toCss,
+  Y as upscale,
+  S as valueNoise,
+  R as withAlpha
+};

package/dist/pixel/pixelPaint.js

@@ -0,0 +1,197 @@
+import { ramp as P, dithered as I, grade as S, capturing as B, stageRun as v, endOutline as E, pixelKey as F, fillRuns as H, batchFor as T, record as K, beginOutline as L, flushBatch as j, currentCoverage as D } from "./pixelTone.js";
+import { PixelLayer as G } from "./PixelLayer.js";
+import { pixelOn as ft, spark as at, tail as lt } from "./pixelParticles.js";
+const J = 16774358, d = (f) => Math.round(f);
+function y(f, e, o, n, c = 1) {
+  const s = d(e), t = d(o);
+  if (I(s, t)) return;
+  const i = S(n);
+  if (B()) {
+    for (let a = 0; a < c; a++) for (let h = 0; h < c; h++) K(s + h, t + a, i);
+    return;
+  }
+  const l = T(f);
+  if (l) {
+    for (let a = 0; a < c; a++) v(l, s, t + a, c, i);
+    return;
+  }
+  f.fillStyle(i, 1).fillRect(s, t, c, c);
+}
+class C {
+  at = /* @__PURE__ */ new Map();
+  set(e, o, n) {
+    this.at.set(F(d(e), d(o)), n);
+  }
+  lay(e) {
+    if (B()) {
+      for (const [c, s] of this.at) y(e, (c >>> 16) - 32768, (c & 65535) - 32768, s);
+      return;
+    }
+    const o = T(e);
+    if (o instanceof G) {
+      for (const [c, s] of this.at) {
+        const t = (c >>> 16) - 32768, i = (c & 65535) - 32768;
+        I(t, i) || o.stage(t, i, 1, S(s));
+      }
+      return;
+    }
+    const n = /* @__PURE__ */ new Map();
+    for (const [c, s] of this.at) I((c >>> 16) - 32768, (c & 65535) - 32768) || n.set(c, S(s));
+    H(e, n);
+  }
+}
+function R(f, e, o, n, c) {
+  const s = d(e), t = d(n);
+  if (!(t <= 0)) {
+    if (!B() && !I(s, o) && !I(s + 1, o) && !I(s + 2, o + 1) && !I(s + 3, o + 1)) {
+      const i = T(f);
+      if (i) {
+        v(i, s, d(o), t, S(c));
+        return;
+      }
+      f.fillStyle(S(c), 1).fillRect(s, d(o), t, 1);
+      return;
+    }
+    for (let i = 0; i < t; i++) y(f, s + i, o, c);
+  }
+}
+function Y(f, e, o) {
+  L();
+  try {
+    o();
+  } finally {
+    E(f, e);
+  }
+}
+function q(f, e, o, n, c = 2) {
+  const s = Math.hypot(o.x - e.x, o.y - e.y), t = Math.max(1, Math.ceil(s)), i = s ? -(o.y - e.y) / s : 0, l = s ? (o.x - e.x) / s : 1, a = P(n), h = Math.max(1, Math.round(c));
+  for (let r = 0; r <= t; r++) {
+    const u = t >= 10 && (r <= 1 || r >= t - 1), x = t >= 16 && Math.abs(r - Math.round(t / 3)) <= 1, m = e.x + (o.x - e.x) * r / t, p = e.y + (o.y - e.y) * r / t;
+    for (let M = 0; M < h; M++) {
+      const w = M - (h - 1) / 2, g = h >= 2 ? M === 0 ? a.light : M === h - 1 ? a.deep : n : n;
+      y(f, m + i * w, p + l * w, u ? a.deep : x && M === 0 ? a.hi : g);
+    }
+  }
+}
+function Z(f, e, o, n = 0, c = 0) {
+  const s = P(o), t = Math.max(32, Math.ceil(e * 5)), i = new C();
+  for (let l = 0; l < t; l++) {
+    const a = ((l * 64 / t + n) % 16 + 16) % 16;
+    if (a < 3) continue;
+    const h = l * Math.PI * 2 / t, r = Math.sin(h), u = a < 4 ? s.hi : r > 0.35 ? s.light : r < -0.35 ? s.deep : o, x = Math.cos(h) * e, m = c + r * e * 0.5;
+    i.set(x, m, u), r > 0.5 && i.set(x, m + 1, s.deep);
+  }
+  i.lay(f);
+}
+function _(f, e, o, n, c) {
+  const s = P(c);
+  for (let t = -n; t <= n; t++) {
+    const i = Math.max(1, d(n - Math.abs(t))), l = d(e - i / 2);
+    if (t > n * 0.45) {
+      R(f, l, o + t, i, s.deep);
+      continue;
+    }
+    const a = Math.floor(i / 2);
+    n < 3 || a < 1 ? R(f, l, o + t, i, c) : (R(f, l, o + t, a, s.light), R(f, l + a, o + t, i - a, c));
+  }
+  n >= 5 && y(f, e - 1, o - n + 2, s.hi);
+}
+function $(f, e, o, n, c = !1) {
+  for (let s = 0; s < 12; s++) {
+    const t = s * Math.PI / 6 + (c ? e * 1.8 : 0), i = o * (c ? 1 - e : e);
+    y(f, Math.cos(t) * i, -8 + Math.sin(t) * i * 0.6 - (c ? 0 : Math.sin(e * Math.PI) * 8), s % 3 ? n : J, s % 3 ? 1 : 2);
+  }
+}
+function N(f, e, o, n, c, s = !1) {
+  const t = Math.max(1, Math.round(s ? n * 0.5 : n)), i = P(c);
+  for (let l = -t; l <= t; l++) {
+    const a = d(n * Math.sqrt(Math.max(0, 1 - (l / t) ** 2)));
+    if (a <= 0) continue;
+    const h = (l + t) / (2 * t || 1);
+    R(f, e - a, o + l, a * 2, h > 0.7 && n >= 3 ? i.deep : c), n >= 3 && h < 0.35 && a >= 2 && R(f, e - a + 1, o + l, d(a * 0.6), i.light);
+  }
+  n >= 4 && y(f, e - n * 0.4, o - t * 0.55, i.hi);
+}
+function Q(f, e, o, n, c, s = e + 8) {
+  const t = c / 1e3, i = e + n * t + 260 * t * t;
+  return i > s && n * t + 260 * t * t > 0 ? null : { x: f + o * t, y: i };
+}
+function z(f, e, o, n, c) {
+  q(f, { x: e - n, y: o - n }, { x: e + n, y: o + n }, c), q(f, { x: e - n, y: o + n }, { x: e + n, y: o - n }, c);
+}
+function tt(f, e, o, n, c, s) {
+  const t = { x: e.x + (o.x - e.x) * n, y: e.y + (o.y - e.y) * n };
+  q(f, t, o, c, 4), q(f, t, o, s, 2);
+}
+function nt(f, e, o, n, c, s, t = 0, i = 0.7) {
+  if (n = Math.round(n), n < 2) return;
+  const l = P(c), a = Math.max(2, Math.round(n * 0.85)), h = i * D();
+  j();
+  const r = d(e);
+  for (let u = -a; u <= a; u++) {
+    const x = n * Math.sqrt(Math.max(0, 1 - (u / (a + 0.5)) ** 2));
+    let m = 0, p = 0, M = -1, w = 0;
+    const g = Math.ceil(x);
+    for (let k = -g; k <= g; k++) {
+      let O = -1, A = 0;
+      if (k < g) {
+        const W = x - Math.abs(k + 0.5), b = (k * 73856093 ^ u * 19349663 ^ t * 83492791) >>> 0;
+        W < 1 && b % 2 === 0 || (O = u < -a * 0.3 && k < x * 0.2 ? s : u > a * 0.4 ? l.deep : b % 9 === 0 ? l.light : c, A = W < 1 ? h * 0.6 : h);
+      }
+      if (O === M && A === w && O !== -1) {
+        p++;
+        continue;
+      }
+      M !== -1 && f.fillStyle(S(M), w).fillRect(r + m, d(o + u), p, 1), m = k, p = 1, M = O, w = A;
+    }
+  }
+}
+function ot(f, e, o, n, c, s, t, i = !0, l = 1) {
+  const a = Math.max(2, Math.ceil(Math.abs(s - c) * n)), h = P(t);
+  l *= 2;
+  const r = new C();
+  for (let u = 0; u < l; u++) {
+    const x = n - u, m = u === 0 ? h.light : u === l - 1 ? h.deep : t;
+    for (let p = 0; p <= a; p++) {
+      const M = c + (s - c) * p / a, w = p >= a - 1 ? h.hi : l <= 2 && a >= 12 && p < a * 0.2 ? h.deep : m;
+      r.set(e + Math.cos(M) * x, o + Math.sin(M) * x * (i ? 0.5 : 1), w);
+    }
+  }
+  r.lay(f);
+}
+function et(f, e, o, n, c = 10, s = 13154458) {
+  for (let t = 0; t < 4; t++) {
+    const i = t * 1.7 + 0.3, l = Math.round(4 * (1 - n));
+    l >= 1 && N(f, e + Math.cos(i) * c * n, o - 2 + Math.sin(i) * c * 0.4 * n - n * 4, l, t % 2 ? s : 14734524);
+  }
+}
+function st(f, e, o, n, c, s, t) {
+  for (let i = 0; i < n; i++) {
+    const l = i / n * Math.PI * 2 + 0.3, a = c * (0.6 + i * 7 % 5 * 0.1), h = Q(e, o, Math.cos(l) * a, -70 - i * 17 % 40, s, o + 6);
+    if (!h) continue;
+    const r = t[i % t.length], u = h.y + Math.sin(l) * a * 0.3 * s / 1e3;
+    i % 3 ? y(f, h.x, u, r) : (y(f, h.x, u, r, 2), y(f, h.x, u + 2, P(r).deep, 2), y(f, h.x, u, P(r).hi));
+  }
+}
+export {
+  J as WHITE,
+  ot as arc,
+  N as blob,
+  tt as dashStreak,
+  st as debris,
+  _ as diamond,
+  y as dot,
+  Q as drop,
+  et as dust,
+  R as hline,
+  Y as outlined,
+  ft as pixelOn,
+  nt as puffBlob,
+  Z as ring,
+  $ as shards,
+  d as snap,
+  at as spark,
+  q as stroke,
+  lt as tail,
+  z as xMark
+};

package/dist/pixel/pixelParticles.js

@@ -0,0 +1,35 @@
+import { dot as i } from "./pixelPaint.js";
+import { ramp as w } from "./pixelTone.js";
+function C(n, s, h, e, a, f = 0) {
+  const o = w(e);
+  if (a === 1) return i(n, s, h, f % 3 === 0 ? o.light : e);
+  i(n, s, h, o.hi);
+  const c = a === 3 ? 2 + f % 2 : 1;
+  for (let t = 1; t <= c; t++) {
+    const r = t === c && c > 1 ? o.deep : t === 1 ? o.light : e;
+    i(n, s + t, h, r), i(n, s - t, h, r), i(n, s, h + t, r), i(n, s, h - t, r);
+  }
+}
+function D(n, s, h, e, a, f, o, c = 1) {
+  const t = Math.hypot(e, a);
+  if (t === 0) return i(n, s, h, o);
+  const r = w(o), p = [r.hi, r.light, o, o, r.deep, r.shade], j = Math.max(1, Math.floor(f));
+  let u = -a / t, m = e / t;
+  (m < -0.1 || Math.abs(m) <= 0.1 && u < 0) && (u = -u, m = -m);
+  const l = Math.round(u), q = Math.round(m) || (l === 0 ? 1 : 0);
+  for (let M = j; M >= 0; M--) {
+    const d = M / j;
+    if (d > 0.5 && M % 2) continue;
+    const b = s - e / t * M, k = h - a / t * M, O = Math.min(p.length - 1, Math.floor(d * p.length));
+    c >= 2 && d < 0.8 && i(n, b + l, k + q, p[Math.min(p.length - 1, O + 1)]), c >= 3 && d < 0.45 && i(n, b - l, k - q, p[Math.max(0, O - 1)]), i(n, b, k, p[O]);
+  }
+}
+function E(n, s, h, e) {
+  const a = Math.cos(e), f = Math.sin(e);
+  return (o, c, t) => i(n, s + a * o - f * c, h + f * o + a * c, t);
+}
+export {
+  E as pixelOn,
+  C as spark,
+  D as tail
+};