@lewismoten/gamemaker-sandbox-tools 0.0.0-stage → 3.4.0

package/dist/pack/threeMfPack.js

@@ -0,0 +1,92 @@
+import { packIndices as A, unpackIndices as x } from "./meshPack.js";
+import { write3mf as M } from "../mesh/threeMf.js";
+import { readZip as b } from "../mesh/zipFile.js";
+function D(t, r) {
+  return b(M(t, r));
+}
+const y = 1295207751, w = (t) => t.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&amp;/g, "&"), E = (t) => t >= 0 ? t * 2 : -t * 2 - 1, N = (t) => t % 2 ? -(t + 1) / 2 : t / 2;
+function p(t, r) {
+  for (let e = 0; e < t.length; e++) {
+    let o = t[e];
+    for (; o >= 128; )
+      r.push(o % 128 | 128), o = Math.floor(o / 128);
+    r.push(o);
+  }
+}
+function F(t) {
+  const r = w(/<metadata name="Title">([^<]*)<\/metadata>/.exec(t)?.[1] ?? ""), e = [...t.matchAll(/<base name="[^"]*" displaycolor="#([0-9A-F]{6})"\/>/g)].map(
+    (a) => [0, 2, 4].map((l) => parseInt(a[1].slice(l, l + 2), 16))
+  ), o = [];
+  for (const a of t.matchAll(/<object id="\d+" type="model" name="([^"]*)" pid="1" pindex="(\d+)">([\s\S]*?)<\/object>/g)) {
+    const l = e[Number(a[2])];
+    if (!l) throw new Error("A 3MF part names a color it does not have");
+    const i = [];
+    for (const c of a[3].matchAll(/<vertex x="([^"]+)" y="([^"]+)" z="([^"]+)"\/>/g)) i.push(...[c[1], c[2], c[3]].map((s) => Math.round(Number(s) * 1e3)));
+    const h = [];
+    for (const c of a[3].matchAll(/<triangle v1="(\d+)" v2="(\d+)" v3="(\d+)"\/>/g)) h.push(Number(c[1]), Number(c[2]), Number(c[3]));
+    o.push({ name: w(a[1]), color: l, ints: Int32Array.from(i), indices: Uint32Array.from(h) });
+  }
+  return { title: r, parts: o };
+}
+const v = (t) => t.parts.map((r) => ({ name: r.name, color: r.color, mesh: { positions: Float32Array.from(r.ints, (e) => e / 1e3), indices: r.indices } })), I = (t, r) => t.length === r.length && t.every((e, o) => e.name === r[o].name && e.data.length === r[o].data.length && e.data.every((a, l) => a === r[o].data[l]));
+function j(t, r) {
+  const e = b(t, r), o = e.find((n) => n.name === "3D/3dmodel.model");
+  if (!o) throw new Error("No 3D/3dmodel.model in the file");
+  const a = F(new TextDecoder().decode(o.data));
+  if (!I(D(v(a), a.title), e)) throw new Error("This 3MF would not be made again the same: not one write3mf wrote");
+  const l = new TextEncoder(), i = [], h = (n) => {
+    const m = l.encode(n);
+    p([m.length], i), i.push(...m);
+  };
+  h(a.title), p([a.parts.length], i);
+  const c = [];
+  for (const n of a.parts) {
+    h(n.name), i.push(...n.color), p([n.ints.length / 3, n.indices.length / 3], i);
+    for (let f = 0; f < 3; f++) {
+      const u = [];
+      let g = 0;
+      for (let d = f; d < n.ints.length; d += 3)
+        u.push(E(n.ints[d] - g)), g = n.ints[d];
+      p(u, c);
+    }
+    const m = A(n.indices);
+    p([m.length], c);
+    for (const f of m) c.push(f);
+  }
+  const s = new Uint8Array(8 + i.length + c.length);
+  return new DataView(s.buffer).setUint32(0, y, !0), new DataView(s.buffer).setUint32(4, i.length, !0), s.set(i, 8), s.set(c, 8 + i.length), s;
+}
+function P(t) {
+  const r = new DataView(t.buffer, t.byteOffset, t.byteLength);
+  if (t.length < 8 || r.getUint32(0, !0) !== y) throw new Error("Not a packed 3MF");
+  let e = 8;
+  const o = () => {
+    let s = 0, n = 1;
+    for (; ; ) {
+      if (e >= t.length) throw new Error("Packed 3MF is cut short");
+      const m = t[e++];
+      if (s += (m & 127) * n, m < 128) return s;
+      n *= 128;
+    }
+  }, a = new TextDecoder(), l = () => {
+    const s = o(), n = a.decode(t.subarray(e, e + s));
+    return e += s, n;
+  }, i = l(), c = Array.from({ length: o() }, () => {
+    const s = l(), n = [t[e], t[e + 1], t[e + 2]];
+    return e += 3, { name: s, color: n, verts: o(), tris: o() };
+  }).map((s) => {
+    const n = new Int32Array(s.verts * 3);
+    for (let u = 0; u < 3; u++) {
+      let g = 0;
+      for (let d = u; d < n.length; d += 3) n[d] = g += N(o());
+    }
+    const m = o(), f = x(t.subarray(e, e + m), s.tris * 3);
+    return e += m, { name: s.name, color: s.color, ints: n, indices: f };
+  });
+  return { title: i, parts: v({ parts: c }) };
+}
+export {
+  j as pack3mf,
+  D as threeMfEntries,
+  P as unpack3mf
+};

package/dist/palette-reserve.js

@@ -0,0 +1,116 @@
+import { labOf as C, FLAG_MEAN as V, FLAG_WORST as X } from "./color-reduce.js";
+const Y = 16, Z = 254, tt = 48;
+function ot(p, r) {
+  const u = [], w = /* @__PURE__ */ new Set(), A = p.filter((s) => s.distinct > 0).sort((s, g) => g.distinct - s.distinct);
+  for (const s of A) {
+    const g = Math.min(s.distinct, tt);
+    let l;
+    for (let n = Y; n + g - 1 <= Z; n++) {
+      let d = 0, h = !1;
+      for (let i = n; i < n + g; i++) {
+        if (w.has(i)) {
+          h = !0;
+          break;
+        }
+        d += (r[i] ?? 0) + A.reduce((k, M) => M === s ? k : k + (M.usage[i] ?? 0), 0) - (s.usage[i] ?? 0) * 0.5;
+      }
+      !h && (!l || d < l.cost) && (l = { start: n, cost: d });
+    }
+    if (!l) continue;
+    let m = 0;
+    for (let n = l.start; n < l.start + g; n++)
+      w.add(n), m += (r[n] ?? 0) + A.reduce((d, h) => h === s ? d : d + (h.usage[n] ?? 0), 0);
+    u.push({ first: l.start, last: l.start + g - 1, role: s.role, conflicts: m });
+  }
+  return u.sort((s, g) => s.first - g.first);
+}
+const J = (p, r) => p[r * 3] << 12 | p[r * 3 + 1] << 6 | p[r * 3 + 2];
+function st(p, r, u, w, A) {
+  const s = w - u + 1, g = new Set(p.flatMap((t) => t.palettes));
+  for (const t of g) {
+    if (!r.has(t)) return { ok: !1, why: `palette ${t} is missing` };
+    const e = A.get(t);
+    if (e) {
+      for (let a = u; a <= w; a++) if (e.has(a)) return { ok: !1, why: `${t} has other blocks drawing with color ${a}; reduce those colors first` };
+    }
+  }
+  const l = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
+  p.forEach((t) => {
+    const e = r.get(t.palettes[0]);
+    for (const a of t.shown)
+      for (const c of t.blocks[a]?.pixels ?? []) {
+        if (c === 0 || c === 255) continue;
+        const f = J(e, c);
+        l.set(f, (l.get(f) ?? 0) + 1), m.has(f) || m.set(f, { pal: e, index: c }), c >= u && c <= w && !n.has(f) && n.set(f, c);
+      }
+  });
+  const d = [...l.entries()].sort((t, e) => e[1] - t[1] || t[0] - e[0]), h = d.slice(0, s).map(([t]) => t), i = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ new Set();
+  for (const t of h) {
+    const e = n.get(t);
+    e !== void 0 && !k.has(e) && (i.set(t, e), k.add(e));
+  }
+  let M = u;
+  for (const t of h)
+    if (!i.has(t)) {
+      for (; k.has(M); ) M++;
+      i.set(t, M), k.add(M);
+    }
+  const K = (t) => C(m.get(t).pal, m.get(t).index), U = new Map(i);
+  for (const [t] of d.slice(s)) {
+    const e = K(t);
+    let a = h[0], c = 1 / 0;
+    for (const f of h) {
+      const o = K(f), b = Math.hypot(e[0] - o[0], e[1] - o[1], e[2] - o[2]);
+      b < c && (c = b, a = f);
+    }
+    U.set(t, i.get(a));
+  }
+  const Q = r.get(p[0].palettes[0]), R = new Uint8Array(s * 3);
+  R.set(Q.subarray(u * 3, (w + 1) * 3));
+  for (const t of h) R.set([t >> 12 & 63, t >> 6 & 63, t & 63], (i.get(t) - u) * 3);
+  const $ = /* @__PURE__ */ new Map();
+  for (const t of g) {
+    const e = r.get(t);
+    if (e.subarray(u * 3, (w + 1) * 3).every((c, f) => c === R[f])) continue;
+    const a = e.slice();
+    a.set(R, u * 3), $.set(t, a);
+  }
+  const W = /* @__PURE__ */ new Map(), I = [], j = [];
+  let z = 0, N = 0, O = 0;
+  return p.forEach((t, e) => {
+    const a = r.get(t.palettes[0]), c = /* @__PURE__ */ new Map(), f = (o) => o === 0 || o === 255 ? o : U.get(J(a, o)) ?? o;
+    for (let o = 0; o < t.blocks.length; o++) {
+      const b = t.blocks[o].pixels, B = t.shown.has(o), P = B ? b.map(f) : b;
+      if (!B) continue;
+      const D = P.some((_, x) => _ !== b[x]);
+      D && c.set(o, P);
+      let S = 0, y = 0, F = 0;
+      for (const _ of t.palettes) {
+        const x = r.get(_), G = $.get(_) ?? x;
+        for (let L = 0; L < b.length; L++) {
+          const [E, T] = [b[L], P[L]];
+          if (E === 255 || E === 0 || x[E * 3] === G[T * 3] && x[E * 3 + 1] === G[T * 3 + 1] && x[E * 3 + 2] === G[T * 3 + 2]) continue;
+          const [q, v] = [C(x, E), C(G, T)], H = Math.hypot(q[0] - v[0], q[1] - v[1], q[2] - v[2]);
+          S += H, y++, F = Math.max(F, H);
+        }
+      }
+      !D && !y || (I.push({ file: e, n: o, mean: y ? S / y : 0 }), y && (S / y > V || F > X) && j.push(o), z += S, N += y, O = Math.max(O, F));
+    }
+    W.set(e, c);
+  }), I.sort((t, e) => e.mean - t.mean), {
+    ok: !0,
+    pixels: W,
+    palettes: $,
+    score: { mean: N ? z / N : 0, worst: O, flagged: j },
+    changed: I,
+    used: h.length,
+    reduced: Math.max(0, d.length - s)
+  };
+}
+export {
+  Y as FIRST_FREE,
+  Z as LAST_FREE,
+  tt as RANGE_CAP,
+  ot as planRanges,
+  st as syncRange
+};

package/dist/palettes.js

@@ -0,0 +1,138 @@
+import { colorRamp as s } from "./colors.js";
+const l = `
+000000 404040 6c6c6c 909090 b0b0b0 c8c8c8 dcdcdc ececec
+444400 646410 848424 a0a034 b8b840 d0d050 e8e85c fcfc68
+702800 844414 985c28 ac783c bc8c4c cca05c dcb468 e8cc7c
+841800 983418 ac5030 c06848 d0805c e09470 eca880 fcbc94
+880000 9c2020 b03c3c c05858 d07070 e08888 eca0a0 fcb4b4
+78005c 8c2074 a03c88 b0589c c070b0 d084c0 dc9cd0 ecb0e0
+480078 602090 783ca4 8c58b8 a070cc b484dc c49cec d4b0fc
+140084 302098 4c3cac 6858c0 7c70d0 9488e0 a8a0ec bcb4fc
+000088 1c209c 3840b0 505cc0 6874d0 7c8ce0 90a4ec a4b8fc
+00187c 1c3890 3854a8 5070bc 6888cc 7c9cdc 90b4ec a4c8fc
+002c5c 1c4c78 386890 5084ac 689cc0 7cb4d4 90cce8 a4e0fc
+00402c 1c5c48 387c64 509c80 68b494 7cd0ac 90e4c0 a4fcd4
+003c00 205c20 407c40 5c9c5c 74b474 8cd08c a4e4a4 b8fcb8
+143800 345c1c 507c38 6c9850 84b468 9ccc7c b4e490 c8fca4
+2c3000 4c501c 687034 848c4c 9ca864 b4c078 ccd488 e0ec9c
+442800 644818 846830 a08444 b89c58 d0b46c e8cc7c fce08c
+`, w = `
+000000 404040 6c6c6c 909090 b0b0b0 c8c8c8 dcdcdc ececec
+805800 947020 a8843c bc9c58 ccac70 dcc084 ecd09c fce0b0
+445c00 5c7820 74903c 8cac58 a0c070 b0d484 c0e89c d4fcb0
+703400 885020 a0683c b48458 c89870 dcac84 ecc09c fcd4b0
+006414 208034 3c9850 58b06c 70c484 84d89c 9ce8b4 b0fcc8
+700014 882034 a03c50 b4586c c87084 dc849c ec9cb4 fcb0c8
+005c5c 207474 3c8c8c 58a4a4 70b8b8 84c8c8 9cdcdc b0ecec
+70005c 842074 943c88 a8589c b470b0 c484c0 d09cd0 e0b0e0
+003c70 1c5888 3874a0 508cb4 68a4c8 7cb8dc 90ccec a4e0fc
+580070 6c2088 803ca0 9458b4 a470c8 b484dc c49cec d4b0fc
+002070 1c3c88 3858a0 5074b4 6888c8 7ca0dc 90b4ec a4c8fc
+3c0080 542094 6c3ca8 8058bc 9470cc a884dc b89cec c8b0fc
+000088 20209c 3c3cb0 5858c0 7070d0 8484e0 9c9cec b0b0fc
+`, m = `
+575757 000c8e 0800a6 340096 550061 630015 5a0000 3c0e00
+112800 003b00 004200 003a05 002652 000000 a5a5a5 0041d9
+2f1eff 6704f2 9400b4 aa0057 a31800 803900 4b5b00 137600
+008100 007923 006288 ffffff 4a9fff 797eff af63ff dd55ff
+f757c2 f76a63 dc8810 aea900 78c400 4ad211 2fcf64 2fbdc4
+414141 b9ddff cad1ff dec6ff f0c0ff fcc0ee fdc6ca f5d0aa
+e4dd95 d0e892 bdeea2 b2eec0 b0e8e3 b3b3b3
+`, i = `
+000000 ffffff fa3200 1de0ff a84bcc 68ba51 004ad0 ffe94d
+ff5b00 c13e00 ff723e 605e62 8c937f b2ff90 458aff c3b8d7
+`, t = (c) => c.trim().split(/\s+/).map((A) => [0, 2, 4].map((a) => parseInt(A.slice(a, a + 2), 16))), d = (c) => s(c, [0, 0, 0], [255, 255, 255]), r = () => Array.from({ length: 16 }, (c, A) => A === 6 ? [170, 85, 0] : [4, 2, 1].map((a) => (A & a ? 170 : 0) + (A & 8 ? 85 : 0))), e = (c, A, a, b, f, o) => ({
+  id: c,
+  name: A,
+  stem: a,
+  entries: b,
+  description: f,
+  colors: o
+}), B = () => [
+  e("amber", "Monochrome amber", "monoamb", 32, "32 shades from black to warm amber.", () => s(32, [0, 0, 0], [255, 184, 48])),
+  e("green", "Monochrome green", "monogrn", 32, "32 shades from black to phosphor green.", () => s(32, [0, 0, 0], [64, 255, 96])),
+  e("white", "Monochrome white", "monowht", 32, "32 shades from black to white.", () => d(32)),
+  e(
+    "atari-ntsc",
+    "Atari 2600 NTSC",
+    "atntsc",
+    128,
+    "128 TIA color slots, using Ricardo Cancho Niemietz’s RGB reference approximation.",
+    () => t(l)
+  ),
+  e("atari-pal", "Atari 2600 PAL", "atpal", 104, "104 colors after removing repeated gray columns from the PAL reference.", () => t(w)),
+  e("nes", "NES · 54 colors", "nes54", 54, "Persune’s unemphasized 2C02G US reference, adapted to VGA.", () => t(m)),
+  e("cga-cyan", "CGA cyan / magenta", "cga0", 4, "Black, bright cyan, bright magenta and white.", () => [r()[0], r()[11], r()[13], r()[15]]),
+  e("cga-green", "CGA green / red / brown", "cga1", 4, "Black, green, red and orange-brown, with the RGBI brown correction.", () => [
+    r()[0],
+    r()[2],
+    r()[4],
+    r()[6]
+  ]),
+  e("ega", "EGA · 16 colors", "ega16", 16, "The standard 16 RGBI colors, with brown corrected.", r),
+  e("ega-skin", "EGA + skin tones & hair", "egaskin", 28, "The 16 EGA colors plus three project-designed four-color skin and hair ramps.", () => [
+    ...r(),
+    ...s(4, [92, 48, 28], [255, 226, 194]),
+    ...s(4, [46, 26, 22], [163, 107, 74]),
+    ...s(4, [20, 15, 15], [158, 123, 60])
+  ]),
+  e(
+    "gameboy",
+    "Game Boy greens",
+    "gbgreen",
+    5,
+    "Four project-designed LCD greens, plus black at index 0 for menus.",
+    () => s(4, [20, 52, 20], [188, 212, 96])
+  ),
+  e(
+    "sega",
+    "Sega Master System · 64 colors",
+    "sms64",
+    64,
+    "SMS2 RGB colors: two bits per channel.",
+    () => Array.from({ length: 64 }, (c, A) => [(A & 3) * 85, (A >> 2 & 3) * 85, (A >> 4 & 3) * 85])
+  ),
+  e("c64", "Commodore 64 · 16 colors", "c64ntsc", 16, "Groepaz’s NTSC CXA2025 reference, with menu black normalized.", () => t(i)),
+  e(
+    "websafe",
+    "Web-safe · 216 colors",
+    "websafe",
+    216,
+    "The six-level RGB cube, rounded to VGA’s channel levels.",
+    () => Array.from({ length: 216 }, (c, A) => [Math.floor(A / 36) * 51, Math.floor(A / 6) % 6 * 51, A % 6 * 51])
+  ),
+  ...[4, 8, 16, 32, 64, 128].map(
+    (c) => e(
+      `gray-${c}`,
+      `Grayscale · ${c} steps`,
+      `gray${c}`,
+      c,
+      c === 128 ? "128 steps; VGA can represent 64 distinct gray shades, so adjacent steps repeat." : `${c} evenly spaced gray shades.`,
+      () => d(c)
+    )
+  )
+];
+let p;
+const g = () => p ??= B(), P = () => Object.freeze(g().map(({ colors: c, ...A }) => Object.freeze(A))), C = /* @__PURE__ */ P();
+function G(c) {
+  const A = g().find((o) => o.id === c);
+  if (!A) throw new RangeError(`Unknown palette preset: ${c}`);
+  const a = [...A.colors()], b = a.findIndex((o) => o.every((n) => n === 0));
+  b >= 0 && a.splice(b, 1), a.unshift([0, 0, 0]);
+  const f = new Uint8Array(768);
+  return a.slice(0, 255).forEach(
+    (o, n) => f.set(
+      o.map((h) => Math.round(h * 63 / 255)),
+      n * 3
+    )
+  ), f;
+}
+const D = "AAAAAAAHAAAKAAANAAASAAAXAAAcAAAhAAAmAAArAAAwAAA1AAA5AAA8AAA/Pz8hAAgAAA0AABIAABcAABwAACEAACYAACsAADAAADUAADoAAD8AAAkFAAwGABAIABgMACAQACgUADAYADgcAD8gGT8hID8mKz8rMD8wMj8yDBAAEBYAFBsAGCAAHCQAICkAJDAACBIABRMGAAwJABIOABgSAB4XACQbACofADEoADgqAD8wAAgIAAwMABISABcXABwcACEhACYmACsrADAwADU1ADo6AD8/GT8/Iz8/LT8/CAoQDhEcDhUcDhgcDhwcAAgLAAwQABEWABUcABskCAAADQAAEgAAFwAAHAAAIQAAJgAAKwAAMAAANQAAOgAAPwAADAMAEAUAGAgAIAkAKAsAMAwANw4APxAAFAADHAAGKgQJOQsPPA4SPxEVEAgAFgsAGg0AIBAAJBIALBYAMhkAOBwAPyAAPy0EDgcEEgkFFgsGGg0HHg8IIhEJJhMKKhULLhcMMhkNNhsOOSERPCUXPyobPy4jCAgADQ0AEhIAFxcAHBwBISEAJiYAKysAMDAANTUAOjoAPz8APz8QPz8YPz8gPz8oPz8wDg4IFhYMHBwOIiIRLCwWNjYbCQEADAMAEAQAFAUAGAYACgcEEAwIFBAMGBQQHBgUEAAQGAAYIQAhJgAmKwArMAAwNQA1OgA6PwA/DQAREQAVFQAcGgAhHwAmJAAsJwAyKgA4Lgg/LBUmDw8WFhYeGxsmICAsIyMxJiY1KSk4LCw8MDA/NTU/CAgIDQ0NEhISFxcXHBwcISEhJiYmKysrMDAwNTU1Ojo6Pz8/MhgbOBwgPyEhPyYmPysrPzIyEAAIGQANIQATKAAWLgAZNAAcOgAfPwAhPwokPxQnPxgsPxwwPx81PyY7Pyw/LT82Nj8qMDA/Mz8TPzotLTY/LT8/AAA/AAA/AAA/AAA/AAA/AAA/AAA/AAA/AAA/AAA/AAA/AAA/AAA/AAA/AAA/AAA/AAA/BgsX";
+function I() {
+  return Uint8Array.from(atob(D), (c) => c.charCodeAt(0));
+}
+export {
+  C as PALETTE_PRESETS,
+  G as createPalettePreset,
+  I as libraryDefaultPalette
+};

package/dist/release-notes.js

@@ -0,0 +1,40 @@
+const s = [
+  ["gam", "game file", "game files"],
+  ["map", "map", "maps"],
+  ["bbl", "background block set", "background block sets"],
+  ["mbl", "monster block set", "monster block sets"],
+  ["cbl", "character block set", "character block sets"],
+  ["chr", "character", "characters"],
+  ["mon", "monster set", "monster sets"],
+  ["pal", "palette", "palettes"],
+  ["gif", "picture", "pictures"],
+  ["fli", "animation", "animations"],
+  ["voc", "sound", "sounds"],
+  ["text", "text file", "text files"]
+], h = ["other file", "other files"];
+const d = (e) => e.toUpperCase(), a = (e) => {
+  const t = s.findIndex(([n]) => n === e);
+  return t < 0 ? s.length : t;
+};
+function m(e) {
+  const t = e.slice(0, 4).map(d).join(", ");
+  return e.length > 4 ? `${t} and ${e.length - 4} more` : t;
+}
+function c(e) {
+  const t = /* @__PURE__ */ new Map();
+  for (const n of e) {
+    const o = s.some(([r]) => r === n.kind) ? n.kind : "other";
+    t.set(o, [...t.get(o) ?? [], n.name]);
+  }
+  return [...t.entries()].sort((n, o) => a(n[0]) - a(o[0])).map(([n, o]) => {
+    const [r, i] = s.find(([l]) => l === n)?.slice(1) ?? h;
+    return `${o.length} ${o.length === 1 ? r : i} (${m(o)})`;
+  }).join(", ");
+}
+function p(e) {
+  const t = [];
+  return e.changed.length && t.push(`Changed ${c(e.changed)}.`), e.added.length && t.push(`Added ${c(e.added)}.`), e.removed.length && t.push(`Removed ${c(e.removed)}.`), t.join(" ");
+}
+export {
+  p as releaseNotes
+};

package/dist/simulation.js

@@ -0,0 +1,18 @@
+import { Sim as r } from "./kit/sceneSim.js";
+import { GameSim as m, TICKS_PER_SECOND as t, diskSim as n, readDisk as S } from "./kit/gameSim.js";
+import { newCharInfo as f } from "@lewismoten/gamemaker-sandbox-engine/engine/world";
+import { initializeScene as x, legacySceneInits as a } from "./kit/sceneInit.js";
+import { expectScene as k } from "./kit/routeChecks.js";
+import { changeBlocks as C } from "@lewismoten/gamemaker-sandbox-engine/engine/scene";
+export {
+  m as GameSim,
+  r as Sim,
+  t as TICKS_PER_SECOND,
+  C as changeBlocks,
+  n as diskSim,
+  k as expectScene,
+  x as initializeScene,
+  a as legacySceneInits,
+  f as newCharInfo,
+  S as readDisk
+};

package/dist/text.js

@@ -0,0 +1,74 @@
+import { FONT_CP437 as T } from "@lewismoten/gamemaker-sandbox-engine/gfx/cp437Glyphs";
+import { FONT_CP437 as z } from "@lewismoten/gamemaker-sandbox-engine/gfx/cp437Glyphs";
+import { toCp437 as M, fromCp437 as P } from "@lewismoten/gamemaker-sandbox-engine/text/cp437";
+import { fromCp437 as D, toCp437 as J } from "@lewismoten/gamemaker-sandbox-engine/text/cp437";
+import { Pixels as N } from "./kit/pixels.js";
+import { MICRO_SQUARE_GLYPHS as Y, MICRO_GLYPHS as k } from "./microFont.js";
+function G(e) {
+  for (const t of e)
+    if (t.charCodeAt(0) >= 128 && M(t) === t && P(t) !== t) throw new RangeError(`No CP437 glyph for ${t}`);
+  const i = M(e), n = new Uint8Array(i.length);
+  for (let t = 0; t < i.length; t++) {
+    const o = i.charCodeAt(t);
+    if (o > 255) throw new RangeError(`No CP437 glyph for ${i[t]}`);
+    n[t] = o;
+  }
+  return n;
+}
+function H(e, i = "cp437") {
+  if (!Number.isInteger(e) || e < 0 || e > 255) throw new RangeError("Glyph code must be 0..255");
+  if (i === "cp437") return T.slice(e * 8, e * 8 + 8);
+  const n = i === "micro-square" ? Y : k, t = P(String.fromCharCode(e)), o = n[t] ?? n[t.toUpperCase()] ?? n["?"];
+  return Uint8Array.from({ length: 5 }, (f, r) => {
+    let a = 0;
+    for (let s = 0; s < 3; s++) o[r * 3 + s] === "1" && (a |= 1 << s);
+    return a;
+  });
+}
+function F(e, i, n = 1, t = 2) {
+  if (x(i), !Number.isInteger(n) || !Number.isInteger(t)) throw new RangeError("Shadow offsets must be integers");
+  const o = new N(e.w, e.h, 255);
+  for (let f = 0; f < e.h; f++) for (let r = 0; r < e.w; r++) e.get(r, f) !== 255 && o.set(r + n, f + t, i);
+  return o.blit(e, 0, 0, 255);
+}
+function x(e) {
+  if (!Number.isInteger(e) || e < 0 || e > 254) throw new RangeError("Ink must be a palette index 0..254");
+}
+function Q(e, i = {}) {
+  const { font: n = "cp437", color: t = 0, scale: o = 1, outline: f, shadow: r } = i;
+  if (x(t), f !== void 0 && x(f), r && x(r.color), !Number.isSafeInteger(o) || o < 1) throw new RangeError("Scale must be a positive integer");
+  const a = r?.dx ?? 1, s = r?.dy ?? 2;
+  if (!Number.isSafeInteger(a) || !Number.isSafeInteger(s)) throw new RangeError("Shadow offsets must be integers");
+  const y = typeof e == "string" ? e.replaceAll(`\r
+`, `
+`).split(`
+`).map(G) : [e], R = Math.max(...y.map((h) => h.length));
+  if (!R) return { width: 0, height: 0, pixels: new Uint8Array(), originX: 0, originY: 0 };
+  const S = n === "cp437" ? 8 : 3, C = n === "cp437" ? 8 : 5, A = n === "cp437" ? 8 : 4, p = f === void 0 ? 0 : 1, E = Math.min(-p, r ? a : 0), I = Math.min(-p, r ? s : 0), _ = Math.max(p, r ? a : 0), v = Math.max(p, r ? s : 0), m = ((R - 1) * A + S) * o + _ - E, w = ((y.length - 1) * (C + 1) + C) * o + v - I, u = new N(m, w, 255);
+  y.forEach(
+    (h, c) => h.forEach((l, g) => {
+      H(l, n).forEach((U, O) => {
+        for (let b = 0; b < S; b++)
+          U & 1 << b && u.rect((g * A + b) * o - E, (c * (C + 1) + O) * o - I, o, o, t);
+      });
+    })
+  );
+  const d = new N(m, w, 255);
+  if (r && d.blit(F(u, r.color, a, s), 0, 0, 255), f !== void 0) {
+    for (let h = 0; h < w; h++)
+      for (let c = 0; c < m; c++)
+        if (u.get(c, h) !== 255) for (let l = -1; l <= 1; l++) for (let g = -1; g <= 1; g++) d.set(c + g, h + l, f);
+  }
+  return d.blit(u, 0, 0, 255), { width: m, height: w, pixels: d.px, originX: -E, originY: -I };
+}
+export {
+  z as FONT_CP437,
+  k as MICRO_GLYPHS,
+  Y as MICRO_SQUARE_GLYPHS,
+  F as dropShadow,
+  G as encodeText,
+  D as fromCp437,
+  H as glyphRows,
+  Q as renderText,
+  J as toCp437
+};

package/dist/types/audio.d.ts

@@ -0,0 +1,4 @@
+export * from './music/compose.js';
+export * from './kit/tune.js';
+export * from './kit/sound.js';
+export * from './kit/synthParts.js';

package/dist/types/audioFiles.d.ts

@@ -0,0 +1,22 @@
+export interface AudioFileOptions {
+    /** Output mono sample rate. Defaults to Game-Maker's usual 11025 Hz. */
+    sampleRate?: number;
+    /** Executable name or path; FFmpeg is installed separately, never bundled. */
+    ffmpegPath?: string;
+    /** Maximum decoded mono samples (default 16 MiB). Exceeding it fails, never truncates. */
+    maxSamples?: number;
+    /** Maximum conversion time, in milliseconds (default 30000). */
+    timeoutMs?: number;
+}
+export interface VocFileOptions extends Omit<AudioFileOptions, 'maxSamples'> {
+    /** Maximum total VOC bytes, including headers (default 65535, the DOS size limit). */
+    maxBytes?: number;
+}
+/**
+ * Decode FLAC, Ogg, WAV or another FFmpeg-supported file to mono samples for encodeVoc.
+ * The unsigned-byte mapping deliberately inverts encodeVoc, retaining all original PCM
+ * values when lossless sources are decoded at their own sample rate. Other rates resample.
+ */
+export declare function decodeAudioFile(file: string | URL, options?: AudioFileOptions): Float32Array;
+/** Convert source audio to a native mono, unsigned 8-bit VOC, enforcing DOS's size limit. */
+export declare function audioFileToVoc(file: string | URL, options?: VocFileOptions): Uint8Array;

package/dist/types/audioWav.d.ts

@@ -0,0 +1,4 @@
+export declare function pcm8Wav(bytes: Uint8Array): {
+    samples: Uint8Array;
+    sampleRate: number;
+} | undefined;

package/dist/types/blockMerge.d.ts

@@ -0,0 +1,24 @@
+import { type Block } from '@lewismoten/gamemaker-sandbox-engine/formats/blocks';
+import type { GameMap } from '@lewismoten/gamemaker-sandbox-engine/formats/map';
+export interface BblMergeInput {
+    keep: Block[];
+    drop: Block[];
+    /** The dropped set's maps (every map its scenes open); each is renumbered. */
+    dropMaps: GameMap[];
+    /** Block numbers of the dropped set its maps draw, with everything those turn into. */
+    dropUsed: ReadonlySet<number>;
+    /** Numbers that must keep their number in the dropped set (pickups, required and starting inventory, 0). */
+    dropPinned: ReadonlySet<number>;
+    /** Slots of the kept set that are in use (drawn, linked to, or pinned): never given away even if they look blank. */
+    keepUsed: ReadonlySet<number>;
+}
+export interface BblMerge {
+    blocks: Block[];
+    maps: GameMap[];
+    /** Where each of the dropped set's drawn blocks is now. */
+    at: Map<number, number>;
+    /** The dropped blocks that moved into a slot of their own (the others reuse a twin). */
+    fresh: number[];
+}
+/** The merge, or why the two sets can't share one file. */
+export declare function mergeBackgroundSets(input: BblMergeInput): BblMerge | string;

package/dist/types/colorReduce.d.ts

@@ -0,0 +1,23 @@
+import type { Block } from '@lewismoten/gamemaker-sandbox-engine/formats/blocks';
+export declare const FLAG_MEAN = 6;
+export declare const FLAG_WORST = 20;
+type Lab = [number, number, number];
+/** CIELAB of palette color `i` (palette bytes are 6-bit VGA values). */
+export declare function labOf(palette: Uint8Array, i: number): Lab;
+export interface ReduceScore {
+    /** Mean delta E over the pixels that changed color, and over every pixel of the changed blocks. */
+    mean: number;
+    worst: number;
+    /** Blocks that passed a threshold. */
+    flagged: number[];
+}
+export interface ReduceResult {
+    /** Block number to its new pixels, only for blocks that changed. */
+    changed: Map<number, Uint8Array>;
+    /** Each color index that moved and where it went. */
+    moves: Map<number, number>;
+    score: ReduceScore;
+}
+/** The blocks `which` with every pixel outside `allowed` (and not 0 or 255) moved to the nearest allowed color in `palettes[0]`; scored under every palette. */
+export declare function reduceBlocks(blocks: Block[], which: Iterable<number>, palettes: Uint8Array[], allowed: ReadonlySet<number>): ReduceResult;
+export {};

package/dist/types/colors.d.ts

@@ -0,0 +1,26 @@
+export type RGB = readonly [number, number, number];
+/** Hue in degrees, saturation and value in 0..1. */
+export type HSV = readonly [number, number, number];
+/** Convert eight-bit RGB to hue, saturation and value without changing the input. */
+export declare function rgbToHsv(color: RGB): [number, number, number];
+/** Convert HSV to rounded eight-bit RGB; hue wraps around at 360 degrees. */
+export declare function hsvToRgb(color: HSV): [number, number, number];
+export type TimeOfDay = 'morning' | 'noon' | 'afternoon' | 'sunset' | 'night' | 'show';
+export interface Lighting {
+    readonly mul: RGB;
+    readonly add: RGB;
+}
+/** Eight-bit RGB lighting presets; show is warm stage lighting. */
+export declare const TIME_OF_DAY_LIGHT: Readonly<Record<TimeOfDay, Lighting>>;
+/** Eight-bit sky ramp endpoints and optional middle stop, dark to light. */
+export declare const TIME_OF_DAY_SKY: Readonly<Record<TimeOfDay, readonly [RGB, RGB, RGB?]>>;
+/** Light one eight-bit RGB color, rounding and clamping each component. */
+export declare function lightColor(color: RGB, lighting: TimeOfDay | Lighting): [number, number, number];
+/** A pure eight-bit RGB ramp, including both endpoints; a middle stop falls at t=0.5. */
+export declare function colorRamp(count: number, from: RGB, to: RGB, mid?: RGB): [number, number, number][];
+/**
+ * Light a native 768-byte, six-bit VGA palette, without changing pixel indexes or the input.
+ * Indexes 0 (engine clear color) and 255 (transparent) are preserved by default. Supply
+ * your own list to protect glowing ramps, designer colors, or to adjust every entry ([]).
+ */
+export declare function adjustPalette(palette: Uint8Array, lighting: TimeOfDay | Lighting, preserve?: readonly number[]): Uint8Array;

package/dist/types/delta.d.ts

@@ -0,0 +1,32 @@
+export type FileState = Uint8Array;
+/** A file in a delta: new whole, changed by patches, or gone. */
+export type FileDelta = {
+    kind: 'new';
+    bytes: Uint8Array;
+} | {
+    kind: 'bytes';
+    length: number;
+    patches: {
+        at: number;
+        bytes: Uint8Array;
+    }[];
+} | {
+    kind: 'lines';
+    start: number;
+    remove: number;
+    add: string[];
+} | {
+    kind: 'gone';
+};
+/** What changed between two versions of a game: only the files that differ. */
+export type Delta = Record<string, FileDelta>;
+/** The difference that turns `from` (undefined: no such file) into `to` (undefined: removed); undefined when they are the same. */
+export declare function diffFile(name: string, from: FileState | undefined, to: FileState | undefined): FileDelta | undefined;
+/** The file after a delta; undefined when it is gone. */
+export declare function patchFile(from: FileState | undefined, d: FileDelta): FileState | undefined;
+/** The delta between two whole versions (file name to bytes). */
+export declare function diffVersions(from: ReadonlyMap<string, FileState>, to: ReadonlyMap<string, FileState>): Delta;
+/** A version with a delta applied. */
+export declare function applyDelta(from: ReadonlyMap<string, FileState>, delta: Delta): Map<string, FileState>;
+/** Bytes a delta takes to store (patch bytes, new files, added lines), to show what a version costs. */
+export declare function deltaSize(delta: Delta): number;