@lewismoten/gamemaker-sandbox-tools 3.1.0 → 3.4.0

package/dist/kit/quantize.js

@@ -0,0 +1,72 @@
+const C = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5];
+function U(A, r = [[0, 0, 0]]) {
+  const s = new Float64Array(32768);
+  for (const t of A) for (let e = 0; e < t.length; e += 3) s[t[e] >> 3 << 10 | t[e + 1] >> 3 << 5 | t[e + 2] >> 3]++;
+  const u = [];
+  for (let t = 0; t < s.length; t++) s[t] && u.push(t);
+  const o = (t) => Math.sqrt(s[t]), n = (t, e) => t >> 10 - e * 5 & 31, i = [{ bins: u, weight: u.reduce((t, e) => t + o(e), 0) }], c = 256 - r.length;
+  for (; i.length < c; ) {
+    let t = -1, e = 0, l = 0;
+    if (i.forEach((f, p) => {
+      if (!(f.bins.length < 2))
+        for (let d = 0; d < 3; d++) {
+          let y = 31, M = 0;
+          for (const v of f.bins) {
+            const m = n(v, d);
+            m < y && (y = m), m > M && (M = m);
+          }
+          const k = (M - y) * f.weight;
+          k > e && (e = k, t = p, l = d);
+        }
+    }), t < 0) break;
+    const a = i[t];
+    a.bins.sort((f, p) => n(f, l) - n(p, l) || f - p);
+    let w = 0, b = 1;
+    for (; b < a.bins.length - 1 && (w += o(a.bins[b - 1]), !(w >= a.weight / 2)); b++)
+      ;
+    const h = a.bins.slice(0, b), E = a.bins.slice(b);
+    i.splice(t, 1, { bins: h, weight: h.reduce((f, p) => f + o(p), 0) }, { bins: E, weight: E.reduce((f, p) => f + o(p), 0) });
+  }
+  const g = new Uint8Array(768);
+  return r.forEach(([t, e, l], a) => g.set([t >> 2, e >> 2, l >> 2], a * 3)), i.forEach((t, e) => {
+    let l = 0, a = 0, w = 0;
+    for (const h of t.bins)
+      l += n(h, 0) * o(h), a += n(h, 1) * o(h), w += n(h, 2) * o(h);
+    const b = (h) => Math.min(63, Math.round((h / t.weight * 8 + 4) / 4));
+    g.set([b(l), b(a), b(w)], (r.length + e) * 3);
+  }), g;
+}
+class q {
+  constructor(r, s = 8) {
+    this.palette = r, this.amount = s;
+  }
+  palette;
+  amount;
+  lut = new Int16Array(4096 * 64).fill(-1);
+  /** The nearest palette entry to a 6-bit color. */
+  nearest(r, s, u) {
+    const o = r << 12 | s << 6 | u;
+    let n = this.lut[o];
+    if (n >= 0) return n;
+    let i = 1e9;
+    for (let c = 0; c < 256; c++) {
+      const g = this.palette[c * 3] - r, t = this.palette[c * 3 + 1] - s, e = this.palette[c * 3 + 2] - u, l = 3 * g * g + 4 * t * t + 2 * e * e;
+      l < i && (i = l, n = c);
+    }
+    return this.lut[o] = n, n;
+  }
+  /** A whole picture: `rgb` is w*h*3 bytes. */
+  apply(r, s, u) {
+    const o = new Uint8Array(s * u);
+    for (let n = 0; n < u; n++)
+      for (let i = 0; i < s; i++) {
+        const c = n * s + i, g = (C[(n & 3) * 4 + (i & 3)] / 16 - 0.47) * this.amount, t = (e) => Math.max(0, Math.min(63, Math.round((e + g) / 4.048)));
+        o[c] = this.nearest(t(r[c * 3]), t(r[c * 3 + 1]), t(r[c * 3 + 2]));
+      }
+    return o;
+  }
+}
+export {
+  q as Quantizer,
+  U as medianCutPalette
+};

package/dist/kit/raytrace.js

@@ -0,0 +1,379 @@
+const q = (n, t) => [n[0] + t[0], n[1] + t[1], n[2] + t[2]], d = (n, t) => [n[0] - t[0], n[1] - t[1], n[2] - t[2]], y = (n, t) => [n[0] * t, n[1] * t, n[2] * t], x = (n, t) => n[0] * t[0] + n[1] * t[1] + n[2] * t[2], T = (n, t) => [n[1] * t[2] - n[2] * t[1], n[2] * t[0] - n[0] * t[2], n[0] * t[1] - n[1] * t[0]], P = (n, t, s) => [n[0] + (t[0] - n[0]) * s, n[1] + (t[1] - n[1]) * s, n[2] + (t[2] - n[2]) * s], k = (n) => n < 0 ? 0 : n > 1 ? 1 : n;
+function A(n) {
+  const t = Math.hypot(n[0], n[1], n[2]) || 1;
+  return [n[0] / t, n[1] / t, n[2] / t];
+}
+const v = [1, 0, 0, 0, 1, 0, 0, 0, 1];
+function R(n) {
+  const t = Math.cos(n), s = Math.sin(n);
+  return [1, 0, 0, 0, t, -s, 0, s, t];
+}
+function X(n) {
+  const t = Math.cos(n), s = Math.sin(n);
+  return [t, 0, s, 0, 1, 0, -s, 0, t];
+}
+function F(n, t) {
+  const s = [];
+  for (let i = 0; i < 3; i++) for (let o = 0; o < 3; o++) s.push(n[i * 3] * t[o] + n[i * 3 + 1] * t[3 + o] + n[i * 3 + 2] * t[6 + o]);
+  return s;
+}
+const J = (n, t, s) => [n[0], t[0], s[0], n[1], t[1], s[1], n[2], t[2], s[2]], I = (n, t) => [
+  n[0] * t[0] + n[1] * t[1] + n[2] * t[2],
+  n[3] * t[0] + n[4] * t[1] + n[5] * t[2],
+  n[6] * t[0] + n[7] * t[1] + n[8] * t[2]
+], W = (n, t) => [n[0] * t[0] + n[3] * t[1] + n[6] * t[2], n[1] * t[0] + n[4] * t[1] + n[7] * t[2], n[2] * t[0] + n[5] * t[1] + n[8] * t[2]], D = (n = [0, 0, 0], t = v, s = 1) => ({ rot: t, pos: n, size: s }), w = 1e-4;
+class g {
+  constructor(t, s) {
+    this.at = t, this.material = s;
+  }
+  at;
+  material;
+  /** World-space bounding box, [min, max]. */
+  box = [
+    [0, 0, 0],
+    [0, 0, 0]
+  ];
+  /** Whether the shape throws a shadow. */
+  shadows = !0;
+  /** Recomputes the world box after `at` changes. */
+  update() {
+    const [t, s] = this.bounds(), i = [1e9, 1e9, 1e9], o = [-1e9, -1e9, -1e9];
+    for (const r of [t[0], s[0]])
+      for (const e of [t[1], s[1]])
+        for (const c of [t[2], s[2]]) {
+          const h = this.toWorld([r, e, c]);
+          for (let l = 0; l < 3; l++)
+            i[l] = Math.min(i[l], h[l]), o[l] = Math.max(o[l], h[l]);
+        }
+    return this.box = [i, o], this;
+  }
+  toWorld(t) {
+    return q(I(this.at.rot, y(t, this.at.size)), this.at.pos);
+  }
+  /** The world box's eight corners. */
+  corners() {
+    const [t, s] = this.box, i = [];
+    for (const o of [t[0], s[0]]) for (const r of [t[1], s[1]]) for (const e of [t[2], s[2]]) i.push([o, r, e]);
+    return i;
+  }
+  hit(t, s, i) {
+    if (!E(this.box, t, s, i)) return;
+    const o = this.at.size, r = y(W(this.at.rot, d(t, this.at.pos)), 1 / o), e = W(this.at.rot, s), c = this.local(r, e, i / o);
+    if (!c || c.t * o >= i) return;
+    let h = A(I(this.at.rot, c.n));
+    x(h, s) > 0 && (h = y(h, -1));
+    const l = c.t * o;
+    return { t: l, p: q(t, y(s, l)), local: q(r, y(e, c.t)), n: h, shape: this };
+  }
+}
+function E(n, t, s, i) {
+  const o = n[0], r = n[1];
+  let e = 0, c = i;
+  for (let h = 0; h < 3; h++) {
+    const l = s[h], p = t[h];
+    if (l > -1e-12 && l < 1e-12) {
+      if (p < o[h] || p > r[h]) return !1;
+      continue;
+    }
+    const a = 1 / l;
+    let u = (o[h] - p) * a, f = (r[h] - p) * a;
+    if (u > f) {
+      const M = u;
+      u = f, f = M;
+    }
+    if (u > e && (e = u), f < c && (c = f), e > c) return !1;
+  }
+  return !0;
+}
+class K extends g {
+  constructor(t, s, i, o) {
+    super(i, o), this.mn = t, this.mx = s, this.update();
+  }
+  mn;
+  mx;
+  bounds() {
+    return [this.mn, this.mx];
+  }
+  local(t, s, i) {
+    let o = -1e9, r = 1e9, e = 0, c = 0;
+    for (let a = 0; a < 3; a++) {
+      if (Math.abs(s[a]) < 1e-12) {
+        if (t[a] < this.mn[a] || t[a] > this.mx[a]) return;
+        continue;
+      }
+      let u = (this.mn[a] - t[a]) / s[a], f = (this.mx[a] - t[a]) / s[a];
+      u > f && ([u, f] = [f, u]), u > o && (o = u, e = a), f < r && (r = f, c = a);
+    }
+    if (o > r) return;
+    const [h, l] = o > w ? [o, e] : [r, c];
+    if (h <= w || h >= i) return;
+    const p = [0, 0, 0];
+    return p[l] = -Math.sign(s[l]) || 1, { t: h, n: p };
+  }
+}
+class O extends g {
+  constructor(t, s, i, o, r, e, c = { bottom: !0, top: !0 }) {
+    super(r, e), this.r0 = t, this.r1 = s, this.y0 = i, this.y1 = o, this.caps = c, this.update();
+  }
+  r0;
+  r1;
+  y0;
+  y1;
+  caps;
+  bounds() {
+    const t = Math.max(this.r0, this.r1);
+    return [
+      [-t, this.y0, -t],
+      [t, this.y1, t]
+    ];
+  }
+  local(t, s, i) {
+    const o = (this.r1 - this.r0) / (this.y1 - this.y0), r = this.r0 - o * this.y0, e = r + o * t[1], c = s[0] * s[0] + s[2] * s[2] - o * o * s[1] * s[1], h = 2 * (t[0] * s[0] + t[2] * s[2] - o * s[1] * e), l = t[0] * t[0] + t[2] * t[2] - e * e;
+    let p;
+    const a = (u, f) => {
+      u > w && u < i && (!p || u < p.t) && (p = { t: u, n: f() });
+    };
+    if (Math.abs(c) > 1e-12) {
+      const u = h * h - 4 * c * l;
+      if (u >= 0) {
+        const f = Math.sqrt(u);
+        for (const M of [(-h - f) / (2 * c), (-h + f) / (2 * c)]) {
+          const m = t[1] + s[1] * M;
+          m < this.y0 || m > this.y1 || a(M, () => {
+            const b = t[0] + s[0] * M, z = t[2] + s[2] * M;
+            return [b, -(r + o * m) * o, z];
+          });
+        }
+      }
+    }
+    if (Math.abs(s[1]) > 1e-12)
+      for (const [u, f, M, m] of [
+        [this.y0, this.r0, this.caps.bottom, -1],
+        [this.y1, this.r1, this.caps.top, 1]
+      ]) {
+        if (!M) continue;
+        const b = (u - t[1]) / s[1], z = t[0] + s[0] * b, C = t[2] + s[2] * b;
+        z * z + C * C <= f * f && a(b, () => [0, m, 0]);
+      }
+    return p;
+  }
+}
+class Q extends g {
+  constructor(t, s, i, o) {
+    super(i, o), this.inner = t, this.outer = s, this.update();
+  }
+  inner;
+  outer;
+  bounds() {
+    return [
+      [-this.outer, -1e-3, -this.outer],
+      [this.outer, 1e-3, this.outer]
+    ];
+  }
+  local(t, s, i) {
+    if (Math.abs(s[1]) < 1e-12) return;
+    const o = -t[1] / s[1];
+    if (o <= w || o >= i) return;
+    const r = t[0] + s[0] * o, e = t[2] + s[2] * o, c = r * r + e * e;
+    if (!(c > this.outer * this.outer || c < this.inner * this.inner))
+      return { t: o, n: [0, 1, 0] };
+  }
+}
+class U extends g {
+  constructor(t, s, i) {
+    super(s, i), this.r = t, this.update();
+  }
+  r;
+  bounds() {
+    const t = this.r;
+    return [
+      [-t, -t, -t],
+      [t, t, t]
+    ];
+  }
+  local(t, s, i) {
+    const o = x(t, s), r = x(t, t) - this.r * this.r, e = o * o - r;
+    if (e < 0) return;
+    const c = Math.sqrt(e), h = -o - c > w ? -o - c : -o + c;
+    if (!(h <= w || h >= i))
+      return { t: h, n: q(t, y(s, h)) };
+  }
+}
+class V extends g {
+  constructor(t, s, i, o, r) {
+    super(o, r), this.a = t, this.b = s, this.r = i, this.update();
+  }
+  a;
+  b;
+  r;
+  bounds() {
+    const t = this.r;
+    return [
+      [Math.min(this.a[0], this.b[0]) - t, Math.min(this.a[1], this.b[1]) - t, Math.min(this.a[2], this.b[2]) - t],
+      [Math.max(this.a[0], this.b[0]) + t, Math.max(this.a[1], this.b[1]) + t, Math.max(this.a[2], this.b[2]) + t]
+    ];
+  }
+  local(t, s, i) {
+    const o = d(this.b, this.a), r = d(t, this.a), e = x(o, o), c = x(o, s), h = x(o, r), l = x(s, r), p = x(r, r), a = this.r, u = e - c * c;
+    let f = e * l - h * c, M = e * p - h * h - a * a * e, m = f * f - u * M, b = -1;
+    if (m >= 0) {
+      b = (-f - Math.sqrt(m)) / u;
+      const B = h + b * c;
+      if (!(B > 0 && B < e)) {
+        const S = B <= 0 ? r : d(t, this.b);
+        f = x(s, S), M = x(S, S) - a * a, m = f * f - M, b = m > 0 ? -f - Math.sqrt(m) : -1;
+      }
+    }
+    if (b <= w || b >= i) return;
+    const z = q(t, y(s, b)), C = d(z, this.a), j = k(x(C, o) / e);
+    return { t: b, n: d(C, y(o, j)) };
+  }
+}
+class Z extends g {
+  constructor(t, s, i, o, r) {
+    super(o, r), this.a = t, this.b = s, this.c = i, this.update();
+  }
+  a;
+  b;
+  c;
+  bounds() {
+    const t = [this.a, this.b, this.c];
+    return [[0, 1, 2].map((s) => Math.min(...t.map((i) => i[s])) - 1e-3), [0, 1, 2].map((s) => Math.max(...t.map((i) => i[s])) + 1e-3)];
+  }
+  local(t, s, i) {
+    const o = d(this.b, this.a), r = d(this.c, this.a), e = T(s, r), c = x(o, e);
+    if (Math.abs(c) < 1e-12) return;
+    const h = d(t, this.a), l = x(h, e) / c;
+    if (l < 0 || l > 1) return;
+    const p = T(h, o), a = x(s, p) / c;
+    if (a < 0 || l + a > 1) return;
+    const u = x(r, p) / c;
+    if (!(u <= w || u >= i))
+      return { t: u, n: T(o, r) };
+  }
+}
+class _ extends g {
+  constructor(t, s, i) {
+    super(s, i), this.text = t, this.update();
+  }
+  text;
+  bounds() {
+    const t = this.text.grid;
+    return [
+      [t.x0, t.y0, -this.text.half - 0.01],
+      [t.x1, t.y1, this.text.half + 0.01]
+    ];
+  }
+  local(t, s, i) {
+    const o = this.text.trace(t[0], t[1], t[2], s[0], s[1], s[2]);
+    if (!(o <= w || o >= i))
+      return { t: o, n: this.text.normal(t[0] + s[0] * o, t[1] + s[1] * o, t[2] + s[2] * o) };
+  }
+}
+class G extends g {
+  constructor(t) {
+    super(D(), () => ({ color: [0, 0, 0], kd: 0, ks: 0, shine: 1, mirror: 0 })), this.parts = t, this.update();
+  }
+  parts;
+  bounds() {
+    return [
+      [0, 0, 0],
+      [0, 0, 0]
+    ];
+  }
+  local() {
+  }
+  update() {
+    const t = [1e9, 1e9, 1e9], s = [-1e9, -1e9, -1e9];
+    for (const i of this.parts ?? [])
+      for (let o = 0; o < 3; o++)
+        t[o] = Math.min(t[o], i.box[0][o]), s[o] = Math.max(s[o], i.box[1][o]);
+    return this.box = [t, s], this;
+  }
+  hit(t, s, i) {
+    if (E(this.box, t, s, i))
+      return H(this.parts, t, s, i);
+  }
+}
+function H(n, t, s, i = 1e9) {
+  let o;
+  for (const r of n) {
+    const e = r.hit(t, s, o ? o.t : i);
+    e && (o = e);
+  }
+  return o;
+}
+function L(n, t, s, i = 1e9) {
+  for (const o of n)
+    if (!(!o.shadows || !E(o.box, t, s, i)) && (o instanceof G ? L(o.parts, t, s, i) : o.hit(t, s, i)))
+      return !0;
+  return !1;
+}
+class $ {
+  constructor(t, s, i, o = 320, r = 200, e = 1.2) {
+    this.eye = t, this.focal = i, this.w = o, this.h = r, this.aspect = e, this.fw = A(d(s, t)), this.right = A(T([0, 1, 0], this.fw)), this.up = T(this.fw, this.right);
+  }
+  eye;
+  focal;
+  w;
+  h;
+  aspect;
+  fw;
+  right;
+  up;
+  ray(t, s) {
+    const i = (t - this.w / 2) / this.focal, o = -(s - this.h / 2) * this.aspect / this.focal;
+    return A(q(this.fw, q(y(this.right, i), y(this.up, o))));
+  }
+  project(t) {
+    const s = d(t, this.eye), i = x(s, this.fw);
+    if (!(i < 0.05))
+      return [this.w / 2 + x(s, this.right) * this.focal / i, this.h / 2 - x(s, this.up) * this.focal / i / this.aspect];
+  }
+}
+function Y(n, t, s) {
+  let i = Math.imul(n, 374761393) ^ Math.imul(t, 668265263) ^ Math.imul(s, 2147483647);
+  return i = Math.imul(i ^ i >>> 13, 1274126177), ((i ^ i >>> 16) >>> 0) / 4294967296;
+}
+function N(n, t, s) {
+  const i = Math.floor(n), o = Math.floor(t), r = Math.floor(s), e = (u) => u * u * (3 - 2 * u), c = e(n - i), h = e(t - o), l = e(s - r), p = (u, f, M) => u + (f - u) * M, a = (u, f, M) => Y(i + u, o + f, r + M);
+  return p(p(p(a(0, 0, 0), a(1, 0, 0), c), p(a(0, 1, 0), a(1, 1, 0), c), h), p(p(a(0, 0, 1), a(1, 0, 1), c), p(a(0, 1, 1), a(1, 1, 1), c), h), l) * 2 - 1;
+}
+function tt(n, t, s, i = 4) {
+  let o = 0, r = 0.5;
+  for (let e = 0; e < i; e++)
+    o += N(n, t, s) * r, n *= 2.03, t *= 2.03, s *= 2.03, r *= 0.5;
+  return o;
+}
+const st = (n, t, s, i) => Y(Math.floor(n * i), Math.floor(t * i), Math.floor(s * i));
+export {
+  K as Box,
+  $ as Camera,
+  V as Capsule,
+  O as Cone,
+  G as Group,
+  _ as Lettering,
+  Q as Ring,
+  g as Shape,
+  U as Sphere,
+  Z as Tri,
+  q as add,
+  I as apply,
+  L as blocked,
+  k as clamp01,
+  T as cross,
+  x as dot,
+  tt as fbm,
+  J as fromAxes,
+  st as grain,
+  P as mix,
+  F as mulM,
+  H as nearest,
+  N as noise,
+  A as norm,
+  D as placed,
+  R as rotX,
+  X as rotY,
+  y as scale,
+  d as sub
+};

package/dist/kit/recordedDemo.js

@@ -0,0 +1,10 @@
+import { serializeRecording as l } from "@lewismoten/gamemaker-sandbox-engine/formats/recording";
+function k(e, r = 30, n = 4) {
+  if (e.length % 2) throw new RangeError("Demo keys must be delta/key pairs");
+  const o = [];
+  for (let t = 0; t < e.length; t += 2) o.push({ delta: e[t], key: e[t + 1] });
+  return o.push({ delta: r, key: 1 }, { delta: n, key: 129 }), l(o);
+}
+export {
+  k as recordedDemo
+};

package/dist/kit/reel.js

@@ -0,0 +1,77 @@
+import { encodeFli as k } from "@lewismoten/gamemaker-sandbox-engine/formats/fli";
+import { Pixels as w } from "./pixels.js";
+function x(o, t) {
+  return o.map((s) => Math.round(s * Math.max(0, Math.min(1, t))));
+}
+class U {
+  constructor(t, s = 320, h = 200) {
+    this.pal = t, this.w = s, this.h = h, this.frames.push(new Uint8Array(s * h)), this.palettes.push(new Uint8Array(768));
+  }
+  pal;
+  w;
+  h;
+  frames = [];
+  palettes = [];
+  last;
+  /** Adds a picture for `hold` frames, its palette faded to `light`. */
+  add(t, s = 1, h = 1, r = this.pal) {
+    const a = Uint8Array.from(t.px), e = h >= 1 ? r : x(r, h);
+    for (let l = 0; l < s; l++)
+      this.frames.push(a), this.palettes.push(e);
+    return this.last = { px: a, pal: r }, this;
+  }
+  /** A picture drawn over a copy of `bg` (the actors over the scenery), for `hold` frames. */
+  frame(t, s, h = 1, r = 1, a = this.pal) {
+    const e = new w(t.w, t.h);
+    return e.px.set(t.px), s(e), this.add(e, h, r, a);
+  }
+  /** The picture fading in from black over `n` frames (the last at full light). */
+  fadeIn(t, s, h = this.pal) {
+    for (let r = 1; r <= s; r++) this.add(t, 1, r / s, h);
+    return this;
+  }
+  /** The last picture fading out to black over `n` frames. */
+  fadeOut(t) {
+    const s = this.last;
+    if (!s) return this;
+    for (let h = t - 1; h >= 0; h--)
+      this.frames.push(s.px), this.palettes.push(x(s.pal, h / t));
+    return this;
+  }
+  /**
+   * A cartoon's closing iris: black closes in on (cx, cy) over `n` frames from the last picture
+   * down to a circle `end` pixels across (round on a 4:3 screen: VGA's pixels are taller than
+   * wide), and holds there `hold` frames. Follow it with fadeOut. Gives an intro whose pictures
+   * are the title's art a last view that isn't the title.
+   */
+  irisOut(t, s, h, r = 64, a = 6) {
+    const e = this.last;
+    if (!e) return this;
+    let l = 0;
+    const f = (i) => e.pal[i * 3] + e.pal[i * 3 + 1] + e.pal[i * 3 + 2];
+    for (let i = 1; i < e.pal.length / 3; i++) f(i) < f(l) && (l = i);
+    const u = Math.hypot(Math.max(t, this.w - t), Math.max(s, this.h - s) * 1.2), m = new w(this.w, this.h);
+    for (let i = 1; i <= h; i++) {
+      const d = i / h, M = u + (r / 2 - u) * (1 - (1 - d) * (1 - d));
+      for (let p = 0; p < this.h; p++)
+        for (let n = 0; n < this.w; n++) {
+          const c = p * this.w + n;
+          m.px[c] = Math.hypot(n - t, (p - s) * 1.2) <= M ? e.px[c] : l;
+        }
+      this.add(m, i === h ? a : 1, 1, e.pal);
+    }
+    return this;
+  }
+  /** The .FLI: `speed` is the wait after each frame in 1/70 s (5 = 14 frames a second). */
+  fli(t) {
+    return k(this.frames, this.pal, { width: this.w, height: this.h, speed: t, palettes: this.palettes, runs: !0 });
+  }
+  /** How long it plays, in seconds. */
+  seconds(t) {
+    return this.frames.length * t / 70;
+  }
+}
+export {
+  U as Reel,
+  x as dimmed
+};

package/dist/kit/road3d.js

@@ -0,0 +1,67 @@
+import { Pixels as u } from "./pixels.js";
+function l(t, r, i) {
+  const o = (e) => Math.max(0, (e - t) * i);
+  return {
+    halfWidth: o,
+    laneX: (e, s) => r + e * 2 * o(s) / 3,
+    dividerX: (e, s) => r + e * o(s) / 3
+  };
+}
+function m(t, r, i = "spawn") {
+  return r.map((o) => {
+    const e = t.filter(([, n]) => n === o).sort((n, a) => n[0] - a[0]), s = `${i}${o}_end`, h = [];
+    let f = 0;
+    return e.forEach(([n, , a], c) => {
+      if (n < f || n < 2) throw new Error(`road lane ${o}: entry at ${n} is out of order`);
+      h.push({
+        name: `${i}${o}_${c}`,
+        kind: a,
+        birthTime: n,
+        next: c + 1 < e.length ? `${i}${o}_${c + 1}` : s,
+        ntime: n + 1 - f
+      }), f = n + 1;
+    }), { lane: o, first: h[0]?.name ?? s, blocks: h, end: s };
+  });
+}
+function w(t, r) {
+  let i = 0, o = 0;
+  return t.map(([e, s, h]) => (i += e, o += s, [i, o, h, r]));
+}
+const M = (t) => [
+  [t, 1, 1],
+  [t, 1, 2],
+  [3 * t, 4, 4],
+  [2 * t, 3, 5]
+], $ = 240, p = (t, r) => [r[0] - t[0], r[1] - t[1], $], b = (t) => [
+  [`${t}0`, 12],
+  [`${t}1`, 8],
+  [`${t}2`, 5],
+  [`${t}3`, 200]
+], x = [
+  { scale: 0.25, bottom: 6 },
+  { scale: 0.45, bottom: 11 },
+  { scale: 0.72, bottom: 16 },
+  { scale: 1, bottom: 19 }
+];
+function _(t, r, i, o) {
+  const e = new u(20, 20, o);
+  if (r >= 1) return e.blit(t, 0, i - 19, o);
+  const s = Math.max(1, Math.round(20 * r)), h = Math.round(10 - s / 2), f = i + 1 - s;
+  for (let n = 0; n < s; n++)
+    for (let a = 0; a < s; a++) {
+      const c = t.get(Math.min(19, Math.floor((a + 0.5) / r)), Math.min(19, Math.floor((n + 0.5) / r)));
+      c !== o && e.set(h + a, f + n, c);
+    }
+  return e;
+}
+export {
+  $ as ROAD_LEAP,
+  x as ROAD_SIZES,
+  b as growPics,
+  M as laneSlide,
+  p as leapTo,
+  w as roadCorners,
+  l as roadView,
+  _ as shrinkSprite,
+  m as spawnChains
+};

package/dist/kit/routeChecks.js

@@ -0,0 +1,8 @@
+function i(e, n, c) {
+  if (e.sim.scene !== n) throw new Error(`Expected ${c} (scene ${n}), in scene ${e.sim.scene}
+${e.log.slice(-8).join(`
+`)}`);
+}
+export {
+  i as expectScene
+};

package/dist/kit/saveSlots.js

@@ -0,0 +1,11 @@
+const t = { x: 54, w: 196, h: 14, y: (o) => 37 + o * 14 }, x = { x: 34, y: 181, w: 246, h: 15 };
+function n(o, e, h, c) {
+  for (let r = 0; r < 10; r++)
+    o.rect(t.x, t.y(r), t.w, t.h, e), c !== void 0 && o.frame(t.x, t.y(r), t.w, t.h, c);
+  return o.rect(x.x, x.y, x.w, x.h, h), o;
+}
+export {
+  t as SLOT,
+  x as STATUS,
+  n as saveSlots
+};

package/dist/kit/sceneInit.js

@@ -0,0 +1,13 @@
+import { startSceneInits as o } from "@lewismoten/gamemaker-sandbox-engine/engine/scene";
+import { changeBlocks as a } from "@lewismoten/gamemaker-sandbox-engine/engine/scene";
+import { BACKBL as r } from "@lewismoten/gamemaker-sandbox-engine/engine/world";
+function c(e, i, n = !1) {
+  if (o(e, i), n && e.noMons)
+    for (let t = 0; t < r; t++) e.bg[t].birthTime > 0 && e.blkMon.push({ blnum: t, nexttime: e.clock + e.bg[t].birthTime });
+}
+const f = (e, i) => c(e, i, !0);
+export {
+  a as changeBlocks,
+  c as initializeScene,
+  f as legacySceneInits
+};