@lewismoten/gamemaker-sandbox-tools 3.1.0 → 3.4.0

package/dist/images.js

@@ -1,50 +1,88 @@
-import { vga8 as g } from "./formats/palette.js";
-const m = (() => {
-  const e = new Uint32Array(256);
-  for (let n = 0; n < 256; n++) {
-    let t = n;
-    for (let o = 0; o < 8; o++) t = t & 1 ? 3988292384 ^ t >>> 1 : t >>> 1;
-    e[n] = t >>> 0;
-  }
-  return e;
-})();
-function p(e) {
-  let n = 4294967295;
-  for (let t = 0; t < e.length; t++) n = m[(n ^ e[t]) & 255] ^ n >>> 8;
-  return (n ^ 4294967295) >>> 0;
+import { encodePng as k } from "./image/png.js";
+import { crc32 as q } from "@lewismoten/gamemaker-sandbox-archives/zip";
+import { Pixels as w } from "./kit/pixels.js";
+import { flipX as F, flipY as G, turn180 as U, turn90 as X } from "./kit/transforms.js";
+function N(n, e, h, r, i) {
+  const u = [[n, e]];
+  return (i === "h" || i === "both") && u.push([h - 1 - n, e]), (i === "v" || i === "both") && u.push([n, r - 1 - e]), i === "both" && u.push([h - 1 - n, r - 1 - e]), u.filter(([c, g], t) => u.findIndex(([o, a]) => o === c && a === g) === t);
+}
+function E(n, e, h) {
+  const r = Math.max(Math.abs(e.x - n.x), Math.abs(e.y - n.y), 1);
+  for (let i = 0; i <= r; i++) h(Math.round(n.x + (e.x - n.x) * i / r), Math.round(n.y + (e.y - n.y) * i / r));
 }
-async function D(e) {
-  const n = new Blob([e]).stream().pipeThrough(new CompressionStream("deflate"));
-  return new Uint8Array(await new Response(n).arrayBuffer());
+function R(n, e, h) {
+  for (let r = Math.min(n.x, e.x); r <= Math.max(n.x, e.x); r++)
+    h(r, n.y), h(r, e.y);
+  for (let r = Math.min(n.y, e.y); r <= Math.max(n.y, e.y); r++)
+    h(n.x, r), h(e.x, r);
+}
+function y(n, e, h, r, i, u, c = () => !0, g = (t, o, a) => {
+  n[o * e + t] = a;
+}) {
+  if (!Number.isSafeInteger(e) || !Number.isSafeInteger(h) || e < 1 || h < 1 || n.length !== e * h)
+    throw new RangeError("Expected width × height indexed pixels");
+  if (!Number.isInteger(r) || !Number.isInteger(i) || r < 0 || i < 0 || r >= e || i >= h || !c(r, i)) return;
+  const t = n.slice(), o = t[i * e + r];
+  if (o === u) return;
+  const a = new Uint8Array(n.length), l = [r, i];
+  for (; l.length; ) {
+    const f = l.pop(), s = l.pop();
+    s < 0 || f < 0 || s >= e || f >= h || a[f * e + s] || t[f * e + s] !== o || !c(s, f) || (a[f * e + s] = 1, g(s, f, u), l.push(s + 1, f, s - 1, f, s, f + 1, s, f - 1));
+  }
 }
-function i(e, n) {
-  const t = new Uint8Array(12 + n.length), o = new DataView(t.buffer);
-  o.setUint32(0, n.length);
-  for (let s = 0; s < 4; s++) t[4 + s] = e.charCodeAt(s);
-  return t.set(n, 8), o.setUint32(8 + n.length, p(t.subarray(4, 8 + n.length)) >>> 0), t;
+function S(n, e, h) {
+  if (!Number.isInteger(e) || !Number.isInteger(h)) throw new RangeError("Pixel shifts must use whole numbers");
+  const r = (i, u) => (i % u + u) % u;
+  return new w(n.w, n.h).map((i, u) => n.get(r(i - e, n.w), r(u - h, n.h)));
 }
-async function x(e, n = 1) {
-  const t = Math.max(1, Math.floor(n)), o = e.width * t, s = e.height * t, f = new Uint8Array((o + 1) * s);
-  for (let r = 0; r < s; r++) {
-    const l = r * (o + 1) | 0, A = Math.floor(r / t) * e.width;
-    for (let a = 0; a < o; a++) f[l + 1 + a] = e.pixels[A + Math.floor(a / t)];
+function P(n, e = 256) {
+  if (!Number.isInteger(e) || e < 1 || e > 256) throw new RangeError("Color count must be 1..256");
+  if (n.some(
+    (t) => !Number.isSafeInteger(t.width) || !Number.isSafeInteger(t.height) || t.width < 0 || t.height < 0 || t.data.length !== t.width * t.height * 4
+  ))
+    throw new RangeError("Expected width × height RGBA pixels");
+  if (!n.some((t) => t.data.length)) return [];
+  const h = n.reduce((t, o) => t + o.width * o.height, 0), r = Math.max(1, Math.floor(h / 12e4)), i = [];
+  for (const t of n) for (let o = 0; o < t.data.length; o += 4 * r) i.push(t.data[o] << 16 | t.data[o + 1] << 8 | t.data[o + 2]);
+  const u = [...new Set(i)];
+  if (u.length <= e) return u.map((t) => [t >> 16 & 255, t >> 8 & 255, t & 255]);
+  const c = [i], g = (t, o) => t >> 16 - o * 8 & 255;
+  for (; c.length < e; ) {
+    let t = -1, o = -1, a = 0;
+    if (c.forEach((s, b) => {
+      if (!(s.length < 2))
+        for (let d = 0; d < 3; d++) {
+          let p = 255, x = 0;
+          for (const M of s) {
+            const m = g(M, d);
+            m < p && (p = m), m > x && (x = m);
+          }
+          x - p > o && (o = x - p, t = b, a = d);
+        }
+    }), t < 0 || o === 0) break;
+    const l = c[t].sort((s, b) => g(s, a) - g(b, a)), f = l.length >> 1;
+    c.splice(t, 1, l.slice(0, f), l.slice(f));
   }
-  const c = new Uint8Array(13), w = new DataView(c.buffer);
-  w.setUint32(0, o), w.setUint32(4, s), c.set([8, 3, 0, 0, 0], 8);
-  const h = new Uint8Array(768);
-  for (let r = 0; r < 768; r++) h[r] = g(e.palette[r] ?? 0);
-  const u = [
-    new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]),
-    i("IHDR", c),
-    i("PLTE", h),
-    i("IDAT", await D(f)),
-    i("IEND", new Uint8Array(0))
-  ], y = new Uint8Array(u.reduce((r, l) => r + l.length, 0));
-  let U = 0;
-  for (const r of u) y.set(r, U), U += r.length;
-  return y;
+  return c.map((t) => {
+    let o = 0, a = 0, l = 0;
+    for (const s of t)
+      o += s >> 16 & 255, a += s >> 8 & 255, l += s & 255;
+    const f = Math.max(1, t.length);
+    return [Math.round(o / f), Math.round(a / f), Math.round(l / f)];
+  });
 }
 export {
-  p as crc32,
-  x as encodePng
+  w as Pixels,
+  R as box,
+  q as crc32,
+  k as encodePng,
+  F as flipX,
+  G as flipY,
+  y as floodFill,
+  E as line,
+  P as medianCutRgba,
+  N as mirrorAll,
+  S as shiftPixels,
+  U as turn180,
+  X as turn90
 };

package/dist/kit/actors.js

@@ -0,0 +1,19 @@
+import { emptyFrame as a } from "@lewismoten/gamemaker-sandbox-engine/formats/character";
+import { emptyMonster as f } from "@lewismoten/gamemaker-sandbox-engine/formats/monster";
+function h(r, o, n = {}) {
+  if (o.length > 10) throw new Error("Too many frames");
+  o.forEach((t, e) => r.frames[e] = t);
+  for (let t = o.length; t < r.frames.length; t++) r.frames[t] = a(!0);
+  Object.assign(r, { sound: 255, jstkBut: 4, jstkMov: 0, ...n });
+}
+function u(r, o, n = []) {
+  const t = f();
+  return t.used = 1, r.forEach((e, c) => t.pic[c] = e), Object.assign(t, o), n.forEach((e, c) => t.march[0][c] = e), t;
+}
+const m = (r, o, n, t = 0) => ({ x: r, y: o, pic: n, orient: t }), p = (r, o, n = 0) => [m(0, 0, o), m(r, n, o, 0), m(0, 0, o, 4)];
+export {
+  m as corner,
+  u as mon,
+  p as pace,
+  h as set
+};

package/dist/kit/align.js

@@ -0,0 +1,204 @@
+import { readdirSync as P, readFileSync as A } from "node:fs";
+import { join as L } from "node:path";
+import { parseGame as N, ADVTYPE as C, ADV_EXTS as v } from "@lewismoten/gamemaker-sandbox-engine/formats/game";
+import { MLEN as g, MWID as x, parseMap as O } from "@lewismoten/gamemaker-sandbox-engine/formats/map";
+import { parseBlocks as B, BACKBL as D } from "@lewismoten/gamemaker-sandbox-engine/formats/blocks";
+import { parsePalette as J } from "@lewismoten/gamemaker-sandbox-engine/formats/palette";
+import { Pixels as j } from "./pixels.js";
+import { writePng as E } from "./png.js";
+const T = (p, c) => typeof p == "string" ? c === p : p.test(c);
+function V(p, c, r = g, a = x, e) {
+  const f = [];
+  for (let o = 0; o < a; o++)
+    for (let n = 0; n < r; n++) {
+      const t = p(n, o);
+      if (t)
+        for (const s of c) {
+          const l = typeof s.part == "string" ? t === s.part ? /^.*$/.exec(t) : null : s.part instanceof RegExp ? s.part.exec(t) : s.part.test(t) ? /^.*$/.exec(t) : null;
+          if (!l) continue;
+          const u = typeof s.need == "function" ? [s.need(l)] : Array.isArray(s.need[0]?.[0]) ? s.need : [s.need];
+          let i;
+          for (const m of u) {
+            const h = [], b = [];
+            for (const [d, w, y] of m) {
+              const M = n + d, S = o + w, $ = M < 0 || S < 0 || M >= r || S >= a ? "off the map" : p(M, S) ?? "?";
+              T(y, $) ? s.joins !== !1 && Math.abs(d) + Math.abs(w) === 1 && b.push(JSON.stringify(d + w > 0 ? [t, $, d ? "h" : "v"] : [$, t, d ? "h" : "v"])) : h.push(`${s.what ?? t} at ${n},${o}: wanted ${String(y)} at ${d},${w}, found ${$}`);
+            }
+            if (!h.length) {
+              i = [];
+              for (const d of b) e?.add(d);
+              break;
+            }
+            (!i || h.length < i.length) && (i = h);
+          }
+          f.push(...i ?? []);
+        }
+    }
+  return f;
+}
+function q(p, c, r, a = (e) => e) {
+  return {
+    part: p,
+    need: (e) => {
+      const f = e[1], [o, n] = [Number(e[2]), Number(e[3])], [t, s] = c.get(f) ?? [1, 1], l = [];
+      for (let u = 0; u < s; u++)
+        for (let i = 0; i < t; i++) {
+          const m = r(f, i, u);
+          (i !== o || u !== n) && l.push([i - o, u - n, { test: (h) => a(h) === m, toString: () => m }]);
+        }
+      return l;
+    }
+  };
+}
+function W(p, c) {
+  const r = [];
+  c.forEach((e, f) => e.forEach((o, n) => o !== null && r.push([n, f, o])));
+  const a = /* @__PURE__ */ new Map();
+  for (const e of r) a.set(String(e[2]), [...a.get(String(e[2])) ?? [], e]);
+  return [...a.values()].map((e) => {
+    const f = e[0][2];
+    return {
+      what: `${p} (${String(f)})`,
+      part: typeof f == "string" ? f : { test: (o) => f.test(o) },
+      need: e.map(([o, n]) => r.filter((t) => t[0] !== o || t[1] !== n).map(([t, s, l]) => [t - o, s - n, l]))
+    };
+  });
+}
+const X = (p, c, r, a, e) => W(p, e === 0 ? a === 1 ? [[c, r]] : [[r, c]] : e === 1 ? [[c], [r]] : [[r], [c]]);
+function tt(p, c, r = /$^/, a = 0.75) {
+  const e = new Set(c), f = /* @__PURE__ */ new Map();
+  for (const n of p)
+    for (let t = 0; t < x; t++)
+      for (let s = 0; s < g; s++) {
+        const l = /^(.*?)(\d)$/.exec(n(s, t) ?? "");
+        if (!l || r.test(l[1])) continue;
+        const u = `${l[1]}${Number(l[2]) + 1}`;
+        if (!e.has(u)) continue;
+        const i = f.get(l[0]) ?? { n: 0, h: 0, v: 0 };
+        i.n++, s + 1 < g && n(s + 1, t) === u && i.h++, t + 1 < x && n(s, t + 1) === u && i.v++, f.set(l[0], i);
+      }
+  const o = /* @__PURE__ */ new Map();
+  for (const [n, t] of f)
+    t.h >= a * t.n ? o.set(n, [1, 0]) : t.v >= a * t.n && o.set(n, [0, 1]);
+  return [...o].flatMap(
+    ([n, [t, s]]) => X(
+      `${n.replace(/\d$/, "")} (found on the maps)`,
+      n,
+      n.replace(/\d$/, (l) => String(Number(l) + 1)),
+      t,
+      s
+    )
+  );
+}
+function nt(p) {
+  const c = [];
+  for (const [r, a] of p) c[a] = r;
+  return c;
+}
+function et(p, c) {
+  const r = /* @__PURE__ */ new Map();
+  for (const a of p) {
+    const e = c.exec(a);
+    if (!e) continue;
+    const f = r.get(e[1]) ?? [0, 0];
+    r.set(e[1], [Math.max(f[0], Number(e[2]) + 1), Math.max(f[1], Number(e[3]) + 1)]);
+  }
+  return r;
+}
+const k = (p, c, r) => {
+  if (c === r) return 0;
+  if (c === 255 || r === 255) return 63;
+  let a = 0;
+  for (let e = 0; e < 3; e++) a += Math.abs(p[c * 3 + e] - p[r * 3 + e]);
+  return a / 3;
+};
+function Y(p, c, r) {
+  return r.map(([a, e, f]) => {
+    const o = p(a), n = p(e);
+    let t = 0, s = 0, l = 0;
+    for (let u = 0; u < 20; u++) {
+      const [i, m, h, b] = f === "h" ? [o(18, u), o(19, u), n(0, u), n(1, u)] : [o(u, 18), o(u, 19), n(u, 0), n(u, 1)];
+      t += k(c, m, h), s += k(c, i, m), l += k(c, h, b);
+    }
+    return { a, b: e, dir: f, across: t / 20, within: Math.max(s, l) / 20 };
+  });
+}
+function z(p, c = 2.5, r = 6) {
+  return p.filter((a) => a.across > r && a.across > c * a.within);
+}
+function F(p) {
+  const c = new Map(P(p).map((o) => [o.toLowerCase(), o])), r = (o) => new Uint8Array(A(L(p, c.get(o.toLowerCase()) ?? o))), a = [...c.keys()].find((o) => o.endsWith(".gam"));
+  if (!a) throw new Error(`no .gam in ${p}`);
+  const e = N(r(a)), f = [];
+  for (const o of e.scenes) {
+    if (o.gametype !== C) continue;
+    const n = (t) => o.files[v.indexOf(t)];
+    !n("map") || !n("bbl") || !n("pal") || f.push({
+      desc: o.desc,
+      map: n("map"),
+      pal: J(r(n("pal"))),
+      blocks: O(r(n("map"))).blocks,
+      bbl: B(r(n("bbl")), D)
+    });
+  }
+  return f;
+}
+function ot(p, c, r, a, e, f, o = 4, n = c.bbl) {
+  const t = new j(e * 20, f * 20);
+  for (let s = 0; s < f; s++)
+    for (let l = 0; l < e; l++) {
+      const u = n[c.blocks[(a + s + x) % x * g + (r + l + g) % g]];
+      for (let i = 0; i < 20; i++) for (let m = 0; m < 20; m++) t.px[(s * 20 + i) * t.w + l * 20 + m] = u.pixels[i * 20 + m];
+    }
+  E(p, t, c.pal, o);
+}
+function G(p, c, r, a, e = 4, f = 0) {
+  const o = Math.max(...a.map((t) => t.length)), n = new j(o * (20 + f), a.length * (20 + f), 255);
+  a.forEach(
+    (t, s) => t.forEach((l, u) => {
+      if (!l) return;
+      const i = c(l);
+      for (let m = 0; m < 20; m++) for (let h = 0; h < 20; h++) n.set(u * (20 + f) + h, s * (20 + f) + m, i(h, m));
+    })
+  ), E(p, n, r, e);
+}
+function st(p, c, r, a = {}) {
+  const e = [], f = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Set();
+  for (const t of F(p)) {
+    const s = c(t.map.toLowerCase());
+    if (!s || o.has(t.map.toLowerCase())) continue;
+    o.add(t.map.toLowerCase());
+    const l = /* @__PURE__ */ new Set();
+    e.push([
+      t.map.toLowerCase(),
+      V((i, m) => s[t.blocks[m * g + i]], typeof r == "function" ? r(t.map.toLowerCase()) : r, g, x, l)
+    ]);
+    const u = /* @__PURE__ */ new Map();
+    s.forEach((i, m) => i !== void 0 && u.set(i, m));
+    for (const i of l) f.has(i) || f.set(i, { sc: t, ids: u });
+  }
+  const n = [];
+  for (const [t, { sc: s, ids: l }] of f) {
+    const [u, i, m] = JSON.parse(t), h = (b) => {
+      const d = s.bbl[l.get(b)].pixels;
+      return (w, y) => d[y * 20 + w];
+    };
+    for (const b of Y(h, s.pal, [[u, i, m]]))
+      n.push({ ...b, draw: (d, w = 8) => G(d, h, s.pal, m === "h" ? [[u, i]] : [[u], [i]], w) });
+  }
+  return { maps: e, seams: n, broken: z(n, a.factor, a.floor) };
+}
+export {
+  st as auditDisk,
+  tt as autoParts,
+  z as brokenSeams,
+  V as checkParts,
+  F as diskScenes,
+  q as gridParts,
+  nt as namesOf,
+  X as pair,
+  Y as seams,
+  W as shape,
+  et as sizesOf,
+  ot as writeArea
+};

package/dist/kit/blit.js

@@ -0,0 +1,45 @@
+import { Pixels as x } from "./pixels.js";
+const p = 255;
+function w(t, n, e = 0, l = 0) {
+  return t.blit(n, e, l, p);
+}
+function m(t, n) {
+  const e = new x(t.w, t.h);
+  return e.px.set(t.px.map(n)), e;
+}
+function c(t, n, e, l, o, i = !1, a = p) {
+  for (let r = 0; r < n.h; r++)
+    for (let f = 0; f < n.w; f++) {
+      const u = n.get(i ? n.w - 1 - f : f, r);
+      u !== a && u >= 0 && t.rect(e + f * o, l + r * o, o, o, u);
+    }
+}
+function g(t, n, e = {}) {
+  const l = e.transparent ?? p, o = new x(t.w, t.h, p);
+  o.px.set(t.px);
+  for (let i = 0; i < t.h; i++)
+    for (let a = 0; a < t.w; a++) {
+      if (t.get(a, i) !== l) continue;
+      [t.get(a - 1, i), t.get(a + 1, i), t.get(a, i - 1), t.get(a, i + 1)].some((f) => f !== l && f !== -1 && (!e.ignoreInk || f !== n)) && o.set(a, i, n);
+    }
+  return o;
+}
+function s(t, n, e, l, o = 20, i = 20) {
+  const a = new x(o, i, p), r = Math.max(...t.map((f) => f.length));
+  return a.draw(e ?? Math.floor((o - r) / 2), l ?? i - t.length, t, n), a;
+}
+const d = (t, n, e, l, o) => t.draw(n, e, l, o), y = (t, n, e, l, o, i = p) => c(t, n, e, l, o, !1, i);
+function A(t, n, e = p) {
+  return t.px.set(g(t, n, { transparent: e }).px), t;
+}
+export {
+  p as CLEAR,
+  d as asciiArt,
+  s as asciiSprite,
+  g as outline,
+  A as outlineInPlace,
+  w as over,
+  m as recolor,
+  c as scaleBlit,
+  y as scaleBlitTransparent
+};

package/dist/kit/blockRoles.js

@@ -0,0 +1,97 @@
+import { SOLTOP as f, SOLRIG as k, SOLBOT as S, SOLLEF as y } from "@lewismoten/gamemaker-sandbox-engine/formats/blocks";
+const A = [
+  { id: "floor", label: "Floor", group: "Ground", hint: "Something to walk on" },
+  { id: "wall", label: "Wall", group: "Ground", hint: "Solid on every side" },
+  { id: "wall-top", label: "Wall top", group: "Ground", hint: "The top edge of a wall" },
+  { id: "wall-edge", label: "Wall edge or corner", group: "Ground", hint: "An edge or corner piece of a wall set" },
+  { id: "path", label: "Path or road", group: "Ground", hint: "A path, road or trail" },
+  { id: "water", label: "Water", group: "Ground", hint: "Water to cross or swim" },
+  { id: "shore", label: "Shore", group: "Ground", hint: "Where land meets water" },
+  { id: "tree", label: "Tree", group: "Ground", hint: "A tree" },
+  { id: "rock", label: "Rock", group: "Ground", hint: "A rock or boulder" },
+  { id: "sky", label: "Sky", group: "Ground", hint: "Open air behind a platform level" },
+  { id: "decoration", label: "Decoration", group: "Ground", hint: "Looks nice, does nothing" },
+  { id: "hazard", label: "Hazard", group: "Ground", hint: "Hurts the hero" },
+  { id: "platform", label: "Platform", group: "Doors", hint: "Solid on top only: stand on it from above" },
+  { id: "ladder", label: "Ladder", group: "Doors", hint: "Pulls the hero up or down" },
+  { id: "door", label: "Door", group: "Doors", hint: "Open; turns into another block when touched" },
+  { id: "locked-door", label: "Locked door", group: "Doors", hint: "Needs a key (same lock number)" },
+  { id: "exit", label: "Exit", group: "Doors", hint: "Leads out of the level" },
+  { id: "entry", label: "Entry", group: "Doors", hint: "Where the hero comes in" },
+  { id: "stairs-up", label: "Stairs up", group: "Doors", hint: "Stairs going up" },
+  { id: "stairs-down", label: "Stairs down", group: "Doors", hint: "Stairs going down" },
+  { id: "chest", label: "Chest", group: "Loot", hint: "A chest that holds something" },
+  { id: "treasure", label: "Treasure", group: "Loot", hint: "Money or score when picked up" },
+  { id: "key", label: "Key", group: "Loot", hint: "Opens a locked door with the same lock number" },
+  { id: "life", label: "Heart or life", group: "Loot", hint: "Adds a life" },
+  { id: "powerup", label: "Power-up", group: "Loot", hint: "Picked up to help the hero" },
+  { id: "chair", label: "Chair", group: "Furniture", hint: "Faces one way" },
+  { id: "table", label: "Table", group: "Furniture", hint: "A table or desk" },
+  { id: "bed", label: "Bed", group: "Furniture", hint: "A bed" },
+  { id: "counter", label: "Counter", group: "Furniture", hint: "A shop counter or bar" },
+  { id: "shelf", label: "Shelf", group: "Furniture", hint: "A shelf or bookcase" },
+  { id: "rug", label: "Rug", group: "Furniture", hint: "A rug on the floor" },
+  { id: "lamp", label: "Lamp", group: "Furniture", hint: "A lamp or torch" },
+  { id: "stove", label: "Stove", group: "Furniture", hint: "A stove or fireplace" },
+  { id: "plant", label: "Plant", group: "Furniture", hint: "A pot plant or flower" },
+  { id: "monster-spawn", label: "Monster spawn", group: "Spawn", hint: "Gives birth to monsters" },
+  { id: "hero-start", label: "Hero start", group: "Spawn", hint: "Where the hero begins" }
+], L = A.map((e) => e.id), W = ["Ground", "Doors", "Loot", "Furniture", "Spawn"], O = ["N", "E", "S", "W"], $ = { N: "north (up)", E: "east (right)", S: "south (down)", W: "west (left)" }, G = /* @__PURE__ */ new Set(["chair", "bed", "counter", "shelf", "stove", "table", "lamp", "entry", "exit"]), v = /* @__PURE__ */ new Set(["locked-door", "key"]), F = 10, P = (e) => e.some((n) => G.has(n)), R = (e) => e.some((n) => v.has(n)), D = (e) => typeof e == "string" && L.includes(e);
+function I(e, n) {
+  const t = {};
+  if (!e || typeof e != "object" || Array.isArray(e)) return t;
+  for (const [i, o] of Object.entries(e)) {
+    const l = Number(i);
+    if (!Number.isInteger(l) || l < 0 || l >= n || !o || typeof o != "object") continue;
+    const r = o, s = [...new Set((Array.isArray(r.roles) ? r.roles : []).filter(D))];
+    if (!s.length) continue;
+    const a = { roles: s };
+    P(s) && O.includes(r.facing) && (a.facing = r.facing);
+    const u = Math.round(Number(r.pair));
+    R(s) && u >= 1 && u <= F && (a.pair = u), t[l] = a;
+  }
+  return t;
+}
+function T(e) {
+  const n = Object.keys(e).map(Number).filter((t) => e[t]?.roles.length).sort((t, i) => t - i);
+  if (n.length)
+    return Object.fromEntries(n.map((t) => [String(t), e[t]]));
+}
+function C(e, n, t) {
+  return Object.keys(e).map(Number).filter((i) => e[i].roles.includes(n) && (t === void 0 || e[i].pair === t)).sort((i, o) => i - o);
+}
+const c = f | k | S | y;
+function E(e, n) {
+  let t = 0, i = 0, o = 0;
+  for (const l of e) {
+    if (l === 255) continue;
+    const r = n[l * 3] ?? 0, s = n[l * 3 + 1] ?? 0, a = n[l * 3 + 2] ?? 0;
+    t++, o += (r + s + a) / 189, a > 20 && a > r * 1.4 && a > s * 1.1 && i++;
+  }
+  return t ? { blue: i / t, light: o / t } : void 0;
+}
+function M(e, n, t = {}) {
+  const i = [], o = (p, b, m) => {
+    i.some((w) => w.role === p) || i.push({ role: p, why: b, pair: m });
+  }, l = e.solid & c, r = e.effect >= 20 && e.effect <= 29 ? e.effect - 19 : void 0, s = e.touchBl !== n, a = e.grav & 15, u = t.palette ? E(e.pixels, t.palette) : void 0, h = !!u && u.blue >= 0.6, g = e.obj !== 0 || s && !l && (e.scorePts > 0 || e.eamt > 0 && e.effect !== 0), d = e.obj ? "picked up" : "touched";
+  return g ? (e.effect === 3 && e.eamt > 0 ? o("treasure", `${d}, adds money`) : e.scorePts > 0 && !(r && e.eamt > 0) && o("treasure", `${d}, adds score`), r && e.eamt > 0 && o("key", `${d}, adds to special counter ${r}`, r), e.effect === 1 && e.eamt > 0 && o("life", `${d}, adds a life`), i.length || o("powerup", e.obj ? "can be picked up" : `${d}, changes the hero`)) : (l === c ? s || r && e.eamt < 0 ? o("locked-door", r ? `solid, and costs special counter ${r}` : "solid, and turns into another block when touched", r) : o("wall", "solid on every side") : l === f && o("platform", "solid on top only"), l !== c && (r && e.eamt < 0 ? o("locked-door", `costs special counter ${r} when touched`, r) : s && o("door", "turns into another block when touched"))), e.chHitPt < 0 && !e.obj && o("hazard", "hurts when touched"), a & 1 && l !== c && o("ladder", (a & 5) === 5 ? "up and down pulls cancel" : "pulls up"), e.birthTime > 0 && e.birthMon > 0 && o("monster-spawn", `gives birth to monster ${e.birthMon}`), t.inTerrain && o("wall-edge", "part of a terrain (edge set) in this block set"), h && !l && !e.obj && (u.light > 0.55 && o("sky", "a light blue picture, nothing solid"), o("water", "a mostly blue picture, nothing solid")), !l && !e.obj && !s && !e.chHitPt && !e.scorePts && !(a & 1) && !r && !h && !i.length && o("floor", "walkable and does nothing"), i;
+}
+function H(e, n) {
+  return n.filter((t) => !e.includes(t.role));
+}
+export {
+  O as FACINGS,
+  $ as FACING_NAMES,
+  F as MAX_PAIR,
+  A as ROLES,
+  W as ROLE_GROUPS,
+  L as ROLE_IDS,
+  C as blocksWithRole,
+  I as cleanRoles,
+  P as hasFacing,
+  R as hasPair,
+  T as packRoles,
+  H as pendingSuggestions,
+  E as pictureBlue,
+  M as suggestRoles
+};

package/dist/kit/clips.js

@@ -0,0 +1,40 @@
+import { decodeVoc as k } from "@lewismoten/gamemaker-sandbox-engine/formats/voc";
+const v = 1e3, M = 1e3, S = 30;
+function g(t) {
+  const n = k(t);
+  return n.sampleRate ? n.samples.length / n.sampleRate * 1e3 : 0;
+}
+function _(t) {
+  const { events: n, scenes: f, starts: b, names: p } = t, y = (e) => {
+    let i = -1;
+    for (const o of f) o.t <= e && (i = o.n);
+    return i;
+  }, l = [];
+  return n.forEach((e, i) => {
+    if (e.kind !== "voc" || !e.bytes) return;
+    const o = g(e.bytes);
+    let r = 1 / 0, a = "picture";
+    for (const s of n.slice(i + 1)) {
+      if (s.kind === "voc") {
+        r = s.t, a = (s.bytes && p.get(s.bytes)) ?? "a clip";
+        break;
+      }
+      if (s.kind === "stopVoc") {
+        r = s.t;
+        break;
+      }
+    }
+    const u = r - e.t;
+    if (u + S >= o) return;
+    const d = y(e.t), m = p.get(e.bytes) ?? "?", h = a === "picture" || y(r) !== d, c = [...b].reverse().find((s) => s.t <= e.t), $ = c && c.n === d && e.t - c.t <= v && !f.some((s) => s.t > c.t && s.t <= e.t) && !n.slice(0, i).some((s) => s.kind === "voc" && s.t >= c.t) && o >= M;
+    h ? l.push({ kind: "end", scene: d, clip: m, ms: o, played: u, by: a, at: e.t }) : $ && l.push({ kind: "start", scene: d, clip: m, ms: o, played: u, by: a, at: e.t, since: e.t - c.t });
+  }), l;
+}
+function w(t) {
+  return `${t.kind === "end" ? `scene ${t.scene} ends during ${t.clip}` : `scene ${t.scene} starts with ${t.clip}`}: ${Math.round(t.played)} of ${Math.round(t.ms)} ms played, cut by ${t.by} (at ${(t.at / 1e3).toFixed(1)} s${t.since === void 0 ? "" : `, ${Math.round(t.since)} ms into the level`})`;
+}
+export {
+  _ as clipCuts,
+  w as describeCut,
+  g as vocMs
+};

package/dist/kit/coverPaint.js

@@ -0,0 +1,18 @@
+import { rng as e } from "./pixels.js";
+const x = (t, n, c) => [t[0] + (n[0] - t[0]) * c, t[1] + (n[1] - t[1]) * c, t[2] + (n[2] - t[2]) * c], l = (t) => Math.max(0, Math.min(255, t)), g = (t, n, c) => {
+  const o = Math.max(0, Math.min(1, (c - t) / (n - t)));
+  return o * o * (3 - 2 * o);
+};
+function p(t) {
+  const n = e(t), c = Array.from({ length: 4096 }, () => n()), o = (m, h) => c[(h % 64 + 64) % 64 * 64 + (m % 64 + 64) % 64];
+  return (m, h) => {
+    const r = Math.floor(m), s = Math.floor(h), a = m - r, i = h - s, f = o(r, s) + (o(r + 1, s) - o(r, s)) * a, M = o(r, s + 1) + (o(r + 1, s + 1) - o(r, s + 1)) * a;
+    return f + (M - f) * i;
+  };
+}
+export {
+  l as clamp,
+  x as mixc,
+  p as noise2,
+  g as smooth
+};

package/dist/kit/disk.js

@@ -0,0 +1,76 @@
+import { mkdirSync as d, writeFileSync as h, renameSync as u, readdirSync as g, rmSync as y } from "node:fs";
+import { join as c } from "node:path";
+import { parseGame as l, ADVTYPE as p, serializeGame as w } from "@lewismoten/gamemaker-sandbox-engine/formats/game";
+import { normalize as m } from "@lewismoten/gamemaker-sandbox-engine/core/gameFiles";
+const S = (r) => Buffer.from(r).toString("latin1");
+function k(r) {
+  const e = [], o = /* @__PURE__ */ new Set();
+  for (const [t, f] of r)
+    if (t.endsWith(".gam"))
+      for (const a of l(f).scenes) {
+        const i = a.gametype === p ? m(a.files[0] ?? "") : "";
+        i.endsWith(".pal") && r.has(i) && !o.has(i) && (o.add(i), e.push(i));
+      }
+  const s = [...r.keys()].filter((t) => t.endsWith(".pal") && !o.has(t)).sort(), n = /* @__PURE__ */ new Map();
+  for (const t of [...e, ...s]) {
+    const f = S(r.get(t));
+    n.set(f, [...n.get(f) ?? [], t]);
+  }
+  return [...n.values()].filter((t) => t.length > 1);
+}
+function v(r) {
+  const e = /* @__PURE__ */ new Map();
+  let o = 0;
+  for (const [s, ...n] of k(r))
+    for (const t of n)
+      e.set(t, s), o += r.get(t).length;
+  if (!e.size) return { merged: e, saved: o };
+  for (const [s, n] of [...r])
+    if (s.endsWith(".gam")) {
+      const t = l(n);
+      let f = !1;
+      for (const a of t.scenes) {
+        const i = a.gametype === p ? e.get(m(a.files[0] ?? "")) : void 0;
+        i && (a.files[0] = i, f = !0);
+      }
+      f && r.set(s, w(t));
+    }
+  for (const s of e.keys()) r.delete(s);
+  return { merged: e, saved: o };
+}
+class D {
+  constructor(e) {
+    this.dir = e;
+  }
+  dir;
+  files = /* @__PURE__ */ new Map();
+  /** Adds a file (8.3 name, lower case on disk). */
+  put(e, o) {
+    if (!/^[a-z0-9_$~!#%&-]{1,8}\.[a-z0-9]{1,3}$/i.test(e)) throw new Error(`${e} is not a DOS 8.3 file name`);
+    this.files.set(e.toLowerCase(), typeof o == "string" ? z(o) : o);
+  }
+  /**
+   * Replace the selected output directory's contents with the collected native files. Each file
+   * is written beside its place and renamed over it, and leftovers go last, so a server reading
+   * the folder during a rebuild never finds a file missing or half written.
+   */
+  write(e = this.dir) {
+    v(this.files), d(e, { recursive: !0 });
+    let o = 0;
+    for (const [s, n] of this.files) {
+      const t = c(e, `.${s}.${process.pid}.part`);
+      h(t, n), u(t, c(e, s)), o += n.length;
+    }
+    for (const s of g(e)) this.files.has(s) || y(c(e, s), { recursive: !0, force: !0 });
+    return o;
+  }
+}
+function z(r) {
+  const e = r.replace(/\r?\n/g, `\r
+`);
+  return Uint8Array.from([...e].map((o) => o.charCodeAt(0) < 256 ? o.charCodeAt(0) : 63));
+}
+export {
+  D as Disk,
+  z as dosText
+};

package/dist/kit/fadeOut.js

@@ -0,0 +1,13 @@
+import { encodeFli as s } from "@lewismoten/gamemaker-sandbox-engine/formats/fli";
+import { dimmed as u } from "./reel.js";
+function p(t, n = 0.5) {
+  return Math.max(4, Math.round(n * 70 / Math.max(1, t)));
+}
+function x(t, n, e = {}) {
+  const { fade: l, ...d } = e, o = l ?? p(e.speed ?? 5), a = t.map((h, r) => e.palettes?.[r] ?? n), i = t[t.length - 1], m = a[a.length - 1], c = Array.from({ length: o }, (h, r) => u(m, (o - 1 - r) / o));
+  return s([...t, ...c.map(() => i)], n, { ...d, palettes: [...a, ...c] });
+}
+export {
+  x as encodeFliFadeOut,
+  p as fadeOutLength
+};