@lewismoten/gamemaker-sandbox-tools 3.1.0 → 3.4.0

package/dist/kit/fliClips.js

@@ -0,0 +1,133 @@
+import { encodeFli as b, parseFli as w, newFliCanvas as L, applyFliFrame as k } from "@lewismoten/gamemaker-sandbox-engine/formats/fli";
+import { shrinkFrames as A, decodeFli as j, encodeFrames as v } from "./fliShrink.js";
+import { parseSlideList as M, serializeSlideList as x } from "@lewismoten/gamemaker-sandbox-engine/formats/graphicScripts";
+function I(t) {
+  const n = w(t);
+  return n.frameCount * n.speed / 70;
+}
+function O(t) {
+  const n = w(t);
+  if (n.frames.length <= n.frameCount) return t;
+  const e = t.slice(0, n.frames[n.frameCount]);
+  return new DataView(e.buffer).setUint32(0, e.length, !0), e;
+}
+function U(t) {
+  const n = w(t), e = L(n), c = [], o = [];
+  for (let r = 0; r < n.frameCount; r++)
+    k(n, r, e), c.push(Uint8Array.from(e.pixels)), o.push(Uint8Array.from(e.palette));
+  return { frames: c, palettes: o, w: n.width, h: n.height, speed: n.speed };
+}
+function d(t, n) {
+  if (t.length !== n.length) return !1;
+  for (let e = 0; e < t.length; e++) if (t[e] !== n[e]) return !1;
+  return !0;
+}
+function S(t, n, e) {
+  let c = d(n[e - 1], n[e]) ? 0 : 1e9;
+  const o = t[e - 1], r = t[e];
+  for (let f = 0; f < o.length; f++) o[f] !== r[f] && c++;
+  return c;
+}
+function W(t, n, e, c, o) {
+  const r = w(t), f = (s) => (s + 1 < r.frames.length ? r.frames[s + 1] : t.length) - r.frames[s], l = [], u = (s) => (l[s] === void 0 && (l[s] = s > 0 && d(n[s - 1], n[s]) && d(e[s - 1], e[s]) ? u(s - 1) : b([n[s]], e[s], { width: c, height: o, runs: !0, noLoopFrame: !0 }).length - 128), l[s]);
+  return (s) => d(e[s - 1], e[s]) ? u(s) - f(s) : 1e9;
+}
+function $(t, n, e) {
+  const c = t.length, o = [];
+  let r = 0;
+  for (; c - r > e; ) {
+    const f = Math.ceil((c - r) / e), l = r + Math.round((c - r) / f), u = Math.max(r + 1, l - Math.floor(e / 4), c - (f - 1) * e), s = Math.min(r + e, c - 1);
+    let i = s, a = 1 / 0;
+    for (let h = u; h <= s; h++) {
+      const m = S(t, n, h);
+      m < a && ([i, a] = [h, m]);
+    }
+    o.push(i), r = i;
+  }
+  return o;
+}
+function z(t, n, e, c) {
+  const o = [new Array(t + 1).fill(1 / 0)], r = [new Array(t + 1).fill(-1)];
+  o[0][0] = 0;
+  const f = /* @__PURE__ */ new Map(), l = (i) => f.get(i) ?? (f.set(i, c(i)), f.get(i));
+  let u;
+  for (let i = 0; i < e; i++) {
+    for (let a = 0; a < t; a++) o[i][a] < 1 / 0 && t - a <= n && (!u || o[i][a] < o[u[0]][u[1]]) && (u = [i, a]);
+    if (i + 1 === e) break;
+    o.push(new Array(t + 1).fill(1 / 0)), r.push(new Array(t + 1).fill(-1));
+    for (let a = 0; a < t; a++)
+      if (o[i][a] !== 1 / 0)
+        for (let h = a + 1; h <= Math.min(a + n, t - 1); h++) {
+          const m = o[i][a] + l(h);
+          m < o[i + 1][h] && ([o[i + 1][h], r[i + 1][h]] = [m, a]);
+        }
+  }
+  const s = [];
+  for (let [i, a] = u; i > 0; a = r[i][a], i--) s.unshift(a);
+  return s;
+}
+function E(t, n) {
+  if (n === 0) return t;
+  const e = t.lastIndexOf(".");
+  return `${t.slice(0, e).slice(0, 7)}${n + 1}${t.slice(e)}`;
+}
+function P(t, n, e = 4, c = {}) {
+  let o = n, r;
+  const f = c.shrink?.length ? A(j(n), c.shrink) : [];
+  if (f.length) {
+    const p = f[f.length - 1];
+    f.some((y) => !y.lossless) && (o = v(p.frames)), r = p.encode.sparsePalettes;
+  }
+  if (I(o) <= e * 1.25) return { [t]: c.noLoopFrame ? O(o) : o };
+  const { frames: l, palettes: u, w: s, h: i, speed: a } = U(o), h = Math.max(1, Math.floor(e * 70 / Math.max(1, a))), m = $(l, u, h), g = [0, ...c.cheapCuts ? z(l.length, h, m.length + 1, W(o, l, u, s, i)) : m, l.length], C = {};
+  for (let p = 0; p + 1 < g.length; p++) {
+    const y = l.slice(g[p], g[p + 1]), F = u.slice(g[p], g[p + 1]);
+    C[E(t, p)] = b(y, F[0], {
+      width: s,
+      height: i,
+      speed: a,
+      palettes: F,
+      runs: !0,
+      noLoopFrame: c.noLoopFrame,
+      sparsePalettes: r
+    });
+  }
+  return C;
+}
+function D(t, n) {
+  const e = Object.keys(t);
+  return e.map((c, o) => o < e.length - 1 ? { name: c, pause: 0 } : { name: c, pause: n });
+}
+function N(t, n, e = 4, c = {}) {
+  const o = /* @__PURE__ */ new Map();
+  for (const r of n)
+    for (const f of M(t.get(r) ?? new Uint8Array())) {
+      const l = f.name.toLowerCase(), u = t.get(l);
+      if (!l.endsWith(".fli") || !u || o.has(l)) continue;
+      const s = P(l, u, e, c);
+      Object.keys(s).length > 1 && o.set(l, s);
+    }
+  if (o.size) {
+    for (const r of o.values()) for (const [f, l] of Object.entries(r)) t.set(f, l);
+    for (const [r, f] of t) {
+      if (!r.endsWith(".lst")) continue;
+      const l = M(f), u = (s) => o.get(s.name.toLowerCase());
+      l.some(u) && t.set(r, x(l.flatMap((s) => u(s) ? D(u(s), s.pause) : [s])));
+    }
+  }
+}
+function H(t, n = 4, e = {}) {
+  N(
+    t,
+    [...t.keys()].filter((c) => c.endsWith(".lst")),
+    n,
+    e
+  );
+}
+export {
+  D as clipEntries,
+  H as clipEveryList,
+  N as clipLists,
+  P as fliClips,
+  I as fliSeconds
+};

package/dist/kit/fliShrink.js

@@ -0,0 +1,277 @@
+import { parseFli as W, newFliCanvas as at, applyFliFrame as ot, encodeFli as rt } from "@lewismoten/gamemaker-sandbox-engine/formats/fli";
+function ct(t) {
+  const s = W(t), f = at(s), e = [], n = [];
+  for (let o = 0; o < s.frameCount; o++)
+    ot(s, o, f), e.push(Uint8Array.from(f.pixels)), n.push(Uint8Array.from(f.palette));
+  return { frames: e, palettes: n, width: s.width, height: s.height, speed: s.speed };
+}
+function Q(t, s = {}) {
+  return rt(t.frames, t.palettes[0], {
+    width: t.width,
+    height: t.height,
+    speed: t.speed,
+    palettes: t.palettes,
+    runs: !0,
+    noLoopFrame: !0,
+    sparsePalettes: s.sparsePalettes
+  });
+}
+const lt = { 4: "COLOR256", 7: "SS2", 11: "COLOR64", 12: "LC", 13: "BLACK", 15: "BRUN", 16: "COPY", 18: "PSTAMP" };
+function wt(t) {
+  const s = W(t), f = ct(t), e = new DataView(t.buffer, t.byteOffset, t.byteLength), n = [], o = {};
+  for (let i = 0; i < s.frameCount; i++) {
+    const p = s.frames[i], u = { header: 16 };
+    let d = p + 16;
+    for (let x = 0, M = e.getUint16(p + 6, !0); x < M; x++) {
+      const P = e.getUint32(d, !0), S = lt[e.getUint16(d + 4, !0)] ?? String(e.getUint16(d + 4, !0));
+      u[S] = (u[S] ?? 0) + P, d += P;
+    }
+    let y = 0;
+    const b = f.frames[i - 1];
+    if (!b) y = f.frames[i].length;
+    else for (let x = 0; x < b.length; x++) b[x] !== f.frames[i][x] && y++;
+    for (const [x, M] of Object.entries(u)) o[x] = (o[x] ?? 0) + M;
+    n.push({ frame: i, bytes: e.getUint32(p, !0), chunks: u, changedPixels: y });
+  }
+  const c = [], h = t.length, r = [...n].sort((i, p) => p.bytes - i.bytes)[0];
+  r && r.bytes > h * 0.25 && c.push(
+    `Frame ${r.frame + 1} is ${Math.round(r.bytes / h * 100)}% of the file: a whole new picture. Dithered or speckled art costs the most there; flatter shading costs less.`
+  );
+  const l = o.COLOR64 ?? 0;
+  l > h * 0.04 && c.push(
+    `Palette changes take ${Math.round(l / h * 100)}%: fades resend colors a frame does not draw (sparse palettes, a smaller palette).`
+  );
+  const a = n.filter((i) => i.frame > 0 && i.changedPixels > 0 && i.bytes / i.changedPixels > 1.5 && i.changedPixels > 400);
+  a.length > n.length * 0.2 && c.push(
+    `${a.length} frames change many pixels by a little (noise or dither that moves): holding still areas still, or snapping near colors, cuts them.`
+  );
+  const m = n.filter((i) => i.frame > 0 && i.changedPixels === 0).length;
+  return m > n.length * 0.3 && c.push(`${m} frames repeat the one before: they cost their header only, but dropping frames and lengthening delays would save more.`), { totalBytes: h, frames: n, byChunk: o, findings: c };
+}
+const F = (t, s, f) => Math.round((t[s * 3 + f] & 63) * 255 / 63);
+function Z(t, s, f = (e) => e) {
+  let e = 0, n = 0, o = 0, c = 0;
+  for (let h = 0; h < t.frames.length; h++) {
+    const r = t.frames[h], l = t.palettes[h], a = Math.min(s.frames.length - 1, f(h)), m = s.frames[a], i = s.palettes[a];
+    for (let p = 0; p < r.length; p++) {
+      if (c++, r[p] === m[p] && l === i) continue;
+      let u = 0;
+      for (let d = 0; d < 3; d++) u = Math.max(u, Math.abs(F(l, r[p], d) - F(i, m[p], d)));
+      u && o++, e += u, n = Math.max(n, u);
+    }
+  }
+  return { mean: c ? e / c : 0, worst: n, changedShare: c ? o / c : 0 };
+}
+function C(t, s, f, e, n, o, c) {
+  const h = Q(f, o).length, r = Q(e, { ...o, ...n }).length;
+  return {
+    name: t,
+    lossless: s,
+    frames: e,
+    encode: { ...o, ...n },
+    bytesBefore: h,
+    bytesAfter: r,
+    savedBytes: h - r,
+    visibility: s ? { mean: 0, worst: 0, changedShare: 0 } : Z(f, e, c)
+  };
+}
+const N = (t, s, f) => Math.max(...[0, 1, 2].map((e) => Math.abs(F(t, s, e) - F(t, f, e))));
+function X(t) {
+  const s = (f) => f.reduce((e, n) => e + n, 0);
+  return t.palettes.reduce((f, e) => s(e) > s(f) ? e : f);
+}
+function ft(t, s, f = {}) {
+  const { width: e, height: n } = t, o = X(t), c = t.frames.map((h) => {
+    const r = Uint8Array.from(h), l = (a, m, i) => {
+      r[m] === r[i] && r[a] !== r[m] && N(o, r[a], r[m]) <= s.tolerance && (r[a] = r[m]);
+    };
+    for (let a = 0; a < n; a++) for (let m = 1; m < e - 1; m++) l(a * e + m, a * e + m - 1, a * e + m + 1);
+    for (let a = 1; a < n - 1; a++) for (let m = 0; m < e; m++) l(a * e + m, (a - 1) * e + m, (a + 1) * e + m);
+    return r;
+  });
+  return C("flatten dithering", !1, t, { ...t, frames: c }, {}, f);
+}
+function ht(t, s = {}) {
+  return C("sparse palettes", !0, t, t, { sparsePalettes: !0 }, s);
+}
+function it(t, s, f = {}) {
+  const e = t.frames.map((n) => Uint8Array.from(n));
+  for (let n = 1; n < e.length; n++) {
+    if (t.palettes[n] !== t.palettes[n - 1] && t.palettes[n].some((r, l) => r !== t.palettes[n - 1][l])) continue;
+    const o = t.palettes[n], c = e[n - 1], h = e[n];
+    for (let r = 0; r < h.length; r++) h[r] !== c[r] && N(o, h[r], c[r]) <= s.tolerance && (h[r] = c[r]);
+  }
+  return C("hold still areas still", !1, t, { ...t, frames: e }, {}, f);
+}
+function pt(t, s, f) {
+  let e = f[0], n = 1 / 0;
+  for (const o of f) {
+    const c = [0, 1, 2].reduce((h, r) => h + (F(t, s, r) - F(t, o, r)) ** 2, 0);
+    c < n && ([e, n] = [o, c]);
+  }
+  return e;
+}
+function mt(t, s, f = {}) {
+  const e = X(t), n = new Array(256).fill(0);
+  for (const l of t.frames) for (let a = 0; a < l.length; a += 7) n[l[a]]++;
+  const o = n.map((l, a) => a).sort((l, a) => n[a] - n[l]), c = Array.from({ length: 256 }, (l, a) => a), h = [];
+  for (const l of o) {
+    if (!n[l]) continue;
+    const a = h.find((m) => N(e, l, m) <= s.tolerance);
+    a === void 0 ? h.push(l) : c[l] = a;
+  }
+  const r = t.frames.map((l) => l.map((a) => c[a]));
+  return C("snap near colors", !1, t, { ...t, frames: r }, {}, f);
+}
+function ut(t, s, f = {}) {
+  const e = X(t), n = new Array(256).fill(0);
+  for (const l of t.frames) for (let a = 0; a < l.length; a++) n[l[a]]++;
+  const o = n.map((l, a) => a).filter((l) => n[l]).sort((l, a) => n[a] - n[l]), c = o.slice(0, Math.max(1, s.colors)), h = Array.from({ length: 256 }, (l, a) => a);
+  for (const l of o.slice(c.length)) h[l] = pt(e, l, c);
+  const r = t.frames.map((l) => l.map((a) => h[a]));
+  return C("fewer colors", !1, t, { ...t, frames: r }, {}, f);
+}
+function dt(t, s = {}) {
+  const f = (o) => o % 2 === 0 || o === t.frames.length - 1, e = t.frames.map((o, c) => c).filter(f), n = { ...t, frames: e.map((o) => t.frames[o]), palettes: e.map((o) => t.palettes[o]), speed: Math.min(255, t.speed * 2) };
+  return C("drop every other frame", !1, t, n, {}, s, (o) => o >= t.frames.length - 1 ? e.length - 1 : o >> 1);
+}
+function At(t, s) {
+  const f = [];
+  let e = t, n = {};
+  for (const o of s) {
+    const c = o.step === "sparsePalettes" ? ht(e, n) : o.step === "holdStill" ? it(e, o, n) : o.step === "snapColors" ? mt(e, o, n) : o.step === "flattenDither" ? ft(e, o, n) : o.step === "maxColors" ? ut(e, o, n) : o.step === "onePalette" ? xt(e, o, n) : o.step === "frame" ? bt(e, o, n) : dt(e, n);
+    f.push(c), e = c.frames, n = c.encode;
+  }
+  return f;
+}
+function Ct(t, s) {
+  const f = t.frames.length, e = s.frames.length;
+  return Z(t, s, e === f ? (n) => n : (n) => n >= f - 1 ? e - 1 : n >> 1);
+}
+const K = (t, s) => (t[s * 3] & 63) << 12 | (t[s * 3 + 1] & 63) << 6 | t[s * 3 + 2] & 63;
+function yt(t, s, f) {
+  const e = (c, h) => c >> 12 - 6 * h & 63, n = [t], o = (c) => {
+    let h = 0, r = 0;
+    for (let l = 0; l < 3; l++) {
+      const a = c.map((i) => e(i, l)), m = Math.max(...a) - Math.min(...a);
+      m > h && ([h, r] = [m, l]);
+    }
+    return { best: h, at: r };
+  };
+  for (; n.length < f; ) {
+    let c = -1, h = 0;
+    if (n.forEach((p, u) => {
+      if (p.length < 2) return;
+      const d = o(p).best * p.reduce((y, b) => y + s.get(b), 0);
+      d > h && ([c, h] = [u, d]);
+    }), c < 0) break;
+    const r = n[c], { at: l } = o(r);
+    r.sort((p, u) => e(p, l) - e(u, l));
+    const a = r.reduce((p, u) => p + s.get(u), 0) / 2;
+    let m = 0, i = 1;
+    for (let p = 0; p < r.length - 1 && (m += s.get(r[p]), i = p + 1, !(m >= a)); p++)
+      ;
+    n.splice(c, 1, r.slice(0, i), r.slice(i));
+  }
+  return n.map((c) => {
+    const h = c.reduce((l, a) => l + s.get(a), 0) || 1, r = [0, 1, 2].map((l) => Math.round(c.reduce((a, m) => a + e(m, l) * s.get(m), 0) / h));
+    return r[0] << 12 | r[1] << 6 | r[2];
+  });
+}
+function xt(t, s, f = {}) {
+  const e = Math.max(1, Math.min(256, Math.round(s.colors))), n = /* @__PURE__ */ new Map();
+  t.frames.forEach((i, p) => {
+    const u = t.palettes[p], d = new Uint32Array(256);
+    for (let y = 0; y < i.length; y++) d[i[y]]++;
+    for (let y = 0; y < 256; y++) d[y] && n.set(K(u, y), (n.get(K(u, y)) ?? 0) + d[y]);
+  });
+  const o = [...n.keys()], c = o.length <= e ? o : yt(o, n, e), h = new Uint8Array(768);
+  c.forEach((i, p) => {
+    h[p * 3] = i >> 12, h[p * 3 + 1] = i >> 6 & 63, h[p * 3 + 2] = i & 63;
+  });
+  const r = /* @__PURE__ */ new Map(), l = (i) => {
+    let p = r.get(i);
+    if (p !== void 0) return p;
+    let u = 1 / 0;
+    return p = 0, c.forEach((d, y) => {
+      const b = [12, 6, 0].reduce((x, M) => x + ((i >> M & 63) - (d >> M & 63)) ** 2, 0);
+      b < u && ([p, u] = [y, b]);
+    }), r.set(i, p), p;
+  }, a = t.frames.map((i, p) => {
+    const u = t.palettes[p], d = Uint8Array.from({ length: 256 }, (y, b) => l(K(u, b)));
+    return i.map((y) => d[y]);
+  }), m = { ...t, frames: a, palettes: a.map(() => h) };
+  return C("one palette", o.length <= e, t, m, {}, f);
+}
+function Mt(t) {
+  let s = 0, f = 1 / 0;
+  for (let e = 0; e < 256; e++) {
+    const n = (t[e * 3] & 63) + (t[e * 3 + 1] & 63) + (t[e * 3 + 2] & 63);
+    if (n < f && ([s, f] = [e, n]), e === 0 && n === 0) return 0;
+  }
+  return s;
+}
+function bt(t, s, f = {}) {
+  const { width: e, height: n } = t, o = (M, P) => Math.max(0, Math.min(P, Math.round(M) || 0)), c = o(s.left, e - 1), h = o(s.right, e - 1 - c), r = o(s.top, n - 1), l = o(s.bottom, n - 1 - r), a = Math.max(0.05, Math.min(8, s.zoom || 1));
+  if (!c && !h && !r && !l && a === 1 && !s.panX && !s.panY) return C("frame it", !0, t, t, {}, f);
+  const i = Mt(t.palettes[0]), p = e - c - h, u = n - r - l, d = a === 1 && !s.panX && !s.panY, y = d ? e / 2 : c + p / 2, b = d ? n / 2 : r + u / 2, x = t.frames.map((M, P) => {
+    const S = new Uint8Array(e * n).fill(i), tt = t.palettes[P], R = new Uint8Array(256);
+    for (let w = 0; w < M.length; w++) R[M[w]] = 1;
+    const et = [...R.keys()].filter((w) => R[w]), V = /* @__PURE__ */ new Map(), U = (w, k) => tt[w * 3 + k] & 63;
+    for (let w = 0; w < u; w++) {
+      const k = r + w, _ = n / 2 + s.panY + (k - b) / a, nt = _ + 1 / a;
+      for (let $ = 0; $ < p; $++) {
+        const B = c + $, D = e / 2 + s.panX + (B - y) / a, st = D + 1 / a;
+        if (a >= 1) {
+          const A = Math.floor(D + 0.5 / a), g = Math.floor(_ + 0.5 / a);
+          A >= 0 && A < e && g >= 0 && g < n && (S[k * e + B] = M[g * e + A]);
+          continue;
+        }
+        const I = Math.max(0, Math.floor(D)), q = Math.min(e - 1, Math.ceil(st) - 1), Y = Math.max(0, Math.floor(_)), H = Math.min(n - 1, Math.ceil(nt) - 1);
+        if (I > q || Y > H) continue;
+        const z = M[Y * e + I];
+        let T = !0, j = 0, G = 0, J = 0, E = 0;
+        for (let A = Y; A <= H; A++)
+          for (let g = I; g <= q; g++) {
+            const v = M[A * e + g];
+            v !== z && (T = !1), j += U(v, 0), G += U(v, 1), J += U(v, 2), E++;
+          }
+        if (T) {
+          S[k * e + B] = z;
+          continue;
+        }
+        const O = Math.round(j / E) << 12 | Math.round(G / E) << 6 | Math.round(J / E);
+        let L = V.get(O);
+        if (L === void 0) {
+          let A = 1 / 0;
+          L = z;
+          for (const g of et) {
+            const v = (U(g, 0) - (O >> 12)) ** 2 + (U(g, 1) - (O >> 6 & 63)) ** 2 + (U(g, 2) - (O & 63)) ** 2;
+            v < A && ([L, A] = [g, v]);
+          }
+          V.set(O, L);
+        }
+        S[k * e + B] = L;
+      }
+    }
+    return S;
+  });
+  return C("frame it", !1, t, { ...t, frames: x }, {}, f);
+}
+export {
+  Mt as bandColor,
+  Ct as chainVisibility,
+  ct as decodeFli,
+  dt as dropFramesStep,
+  Q as encodeFrames,
+  ft as flattenDitherStep,
+  wt as fliReport,
+  bt as frameStep,
+  it as holdStillStep,
+  ut as maxColorsStep,
+  xt as onePaletteStep,
+  At as shrinkFrames,
+  mt as snapColorsStep,
+  ht as sparsePalettesStep,
+  Z as visibilityOf
+};

package/dist/kit/gameSim.js

@@ -0,0 +1,235 @@
+import { readdirSync as A, readFileSync as M } from "node:fs";
+import { join as b } from "node:path";
+import { fileURLToPath as v } from "node:url";
+import { moveChars as B } from "@lewismoten/gamemaker-sandbox-engine/engine/character";
+import { simKeyPress as C } from "@lewismoten/gamemaker-sandbox-engine/engine/keys";
+import { blockBirthMonsters as K, moveAllMonsters as L } from "@lewismoten/gamemaker-sandbox-engine/engine/monsters";
+import { updateCharDrawState as x } from "@lewismoten/gamemaker-sandbox-engine/engine/render";
+import { initScroll as N, drawScroll as E, changeScroll as j } from "@lewismoten/gamemaker-sandbox-engine/engine/scroll";
+import { startSceneInits as I, changeBlocks as O } from "@lewismoten/gamemaker-sandbox-engine/engine/scene";
+import { getTouchBlocks as R } from "@lewismoten/gamemaker-sandbox-engine/engine/touch";
+import { BACKBL as D, newCharInfo as P, createWorld as W, padBlocks as f, LASTMM as q, MLEN as F, bgBlock as G } from "@lewismoten/gamemaker-sandbox-engine/engine/world";
+import { parseBlocks as k, BACKBL as y, MONBL as w, CHARBL as S } from "@lewismoten/gamemaker-sandbox-engine/formats/blocks";
+import { parseCharacter as H } from "@lewismoten/gamemaker-sandbox-engine/formats/character";
+import { parseMonsters as U } from "@lewismoten/gamemaker-sandbox-engine/formats/monster";
+import { parseMap as _ } from "@lewismoten/gamemaker-sandbox-engine/formats/map";
+import { parseGame as $, MAXSCENELINKS as m, NOSCENE as V } from "@lewismoten/gamemaker-sandbox-engine/formats/game";
+import { parseSoundSet as X, LASTSND as z } from "@lewismoten/gamemaker-sandbox-engine/formats/sound";
+import { vocMs as J } from "./clips.js";
+const Q = 18.2;
+function Y(n) {
+  const t = /* @__PURE__ */ new Map();
+  for (const e of A(n)) t.set(e.toLowerCase(), new Uint8Array(M(b(n, e))));
+  return t;
+}
+class p {
+  constructor(t) {
+    this.a = t;
+  }
+  a;
+  next = () => {
+    this.a = this.a + 1831565813 >>> 0;
+    let t = this.a;
+    return t = Math.imul(t ^ t >>> 15, t | 1), t ^= t + Math.imul(t ^ t >>> 7, t | 61), ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+class Z {
+  constructor(t, e = 1) {
+    this.files = t, this.seed = e, this.game = $(t.get([...t.keys()].find((o) => o.endsWith(".gam")))), this.ci.hitpts = -1, this.ci.lives = -1, this.ci.score = 0, this.ci.inv.fill(D + 1), this.ci.meter.fill(-1), this.enter(this.game.scenes[0].links[0].toScene, 0, 0);
+  }
+  files;
+  seed;
+  game;
+  ci = P();
+  w;
+  scene = 0;
+  prev = 0;
+  link = 0;
+  /** Scenes entered, in order (a death enters the same scene again). */
+  trail = [];
+  /** Game ticks since play entered the current scene (a segment's clock). */
+  ticks = 0;
+  /** Keys per scene entered (a scene entered again after a death keeps counting on). */
+  segments = [];
+  /** Ticks each finished segment ran. */
+  segmentTicks = [];
+  lastKeyTick = 0;
+  held = /* @__PURE__ */ new Set();
+  pending = [];
+  doScroll = !1;
+  /** TimerCounter: it runs on across scenes. */
+  clock = 1;
+  rand = new p(0);
+  ended;
+  deaths = 0;
+  /** The inventory slot the drop picker answers with once (set it before pressing the drop key; -1, the default, is Esc). */
+  dropSlot = -1;
+  /**
+   * The .VOC clip the Sound Blaster is playing (PlaySbVocFile: a new one cuts it off), with
+   * the game clock tick it ends on; a scene's exit or intro picture cuts it too (ShowGraphic).
+   */
+  clip;
+  file(t, e) {
+    const o = this.game.scenes[t].files[e];
+    return o ? this.files.get(o) : void 0;
+  }
+  /** loadscene + StartSceneInits, as playScene does them. */
+  enter(t, e, o, a = !1) {
+    this.scene = t, this.prev = e, this.link = o, this.trail.push(t), a || (this.segments.length && this.segmentTicks.push(this.ticks), this.segments.push({ scene: t, keys: [] }), this.ticks = 0, this.lastKeyTick = 0);
+    const r = (c) => this.file(t, c);
+    this.rand = new p(this.seed), (this.game.scenes[e]?.files[10] || this.game.scenes[t].files[9]) && (this.clip = void 0);
+    const l = r(7) && X(r(7)), h = (c) => {
+      if (!l || c < 0 || c >= z) return !1;
+      const d = l.digital[c], g = d && d[0] !== " " ? this.files.get(`${d.toLowerCase()}.voc`) : void 0;
+      return g && (this.clip = { name: d, until: this.clock + Math.ceil(J(g) / 1e3 * Q) }), !0;
+    }, i = this.w, s = W(_(r(1)), { play: h }, this.rand.next);
+    s.bg = f(k(r(2), y), y), s.mblk = f(r(4) ? k(r(4), w) : void 0, w), s.cblk = r(6) || !i ? f(k(r(6), S), S) : i.cblk, s.mon = r(3) ? U(r(3)) : [], s.noMons = !r(3) || !r(4), s.chr = r(5) || !i ? H(r(5)) : i.chr, s.ci = this.ci, s.clock = this.clock, this.w = s, I(s, this.game.scenes[e].links[o].to), s.gclk = s.clock, s.joyOldTime = s.clock, N(s, this.game.scenes[t].scroll), this.doScroll = !1, this.held.clear(), this.pending = [];
+  }
+  press(t) {
+    this.held.has(t) || (this.held.add(t), this.event(t));
+  }
+  release(t) {
+    this.held.has(t) && (this.held.delete(t), this.event(t | 128));
+  }
+  releaseAll() {
+    for (const t of [...this.held]) this.release(t);
+  }
+  isHeld(t) {
+    return this.held.has(t);
+  }
+  event(t) {
+    this.ended || (this.pending.push(t), this.record(t));
+  }
+  /** Writes key `k` into the segment (without playing it in this sim): the drop picker's own keys, which the real engine reads. */
+  record(t) {
+    if (this.ended) return;
+    const e = this.ticks + 1;
+    this.segments[this.segments.length - 1].keys.push({ delta: e - this.lastKeyTick, key: t }), this.lastKeyTick = e;
+  }
+  /** One game tick; returns 'link' (into another scene), 'dead' or 'end'. */
+  async tick() {
+    if (this.ended) return "end";
+    const t = this.w;
+    this.ticks++, this.clock++;
+    for (let i = 0; i < 8; i++) this.doScroll && E(t);
+    t.clock = this.clock, t.noMons || (K(t), L(t));
+    const e = t.chr;
+    if (this.pending.length && (!e.sequences[e.cseq].ground || e.cframe === 0)) for (const i of this.pending.splice(0)) C(t, i);
+    let o = !1, a = 0;
+    do
+      await B(t, async () => {
+        const i = this.dropSlot;
+        if (this.dropSlot = -1, i >= 0) {
+          const s = [...new Array(i % 5).fill(77), ...i >= 5 ? [80] : [], 28];
+          for (const c of s)
+            this.record(c), this.record(c | 128);
+        }
+        return i;
+      }) && (o = !0);
+    while (t.chr.cframe === -1 && !o && a++ < 50);
+    O(t), x(t), this.doScroll = j(t) !== 0, t.monsolid = 0, t.mmSolid = q;
+    const r = R(t), l = this.game.scenes[this.scene].links;
+    let h = m;
+    for (let i = 0; i < m && h === m; i++) {
+      const s = l[i];
+      if (!(!s || s.toScene === V))
+        for (let c = 0; c < 6; c++) s.from.x === r.blks[c][0] && s.from.y === r.blks[c][1] && (h = i);
+    }
+    if (o)
+      return this.deaths++, this.ci.lives > 0 ? (this.ci.lives--, this.ci.hitpts = -1, this.enter(this.scene, this.prev, this.link, !0)) : this.ended = "lost", "dead";
+    if (h !== m) {
+      const i = l[h].toScene;
+      return i === 1 ? (this.ended = "won", "end") : (this.enter(i, this.scene, h), "link");
+    }
+  }
+  /** Game ticks until the clip playing now ends (0 when none is). */
+  get clipTicksLeft() {
+    return this.clip ? Math.max(0, this.clip.until - this.clock) : 0;
+  }
+  /**
+   * Stands still until the clip playing now has played to the end, so the bot's next sound
+   * (a jump, a pickup) doesn't cut it off: a level's start clip, say. Returns what a tick
+   * returned if play left the scene meanwhile.
+   */
+  async waitForClip() {
+    for (this.releaseAll(); this.clipTicksLeft > 0; ) {
+      const t = await this.tick();
+      if (t) return t;
+    }
+  }
+  /** The character's block and the pixels past it. */
+  get pos() {
+    const t = this.w.chr;
+    return { x: t.x[0], y: t.y[0], sx: t.x[1], sy: t.y[1] };
+  }
+  meter(t) {
+    return this.ci.meter[t];
+  }
+  /** Money: Game-Maker's counter 3, which shows meter - 1. */
+  get money() {
+    return this.ci.meter[3] - 1;
+  }
+  /** The block number at (x, y) as it is now (a block taken or pushed is a new block number). */
+  blockAt(t, e) {
+    return this.w.map[e * F + t];
+  }
+  /** The block's attributes as shown now (timed blocks change by themselves). */
+  shown(t, e) {
+    return G(this.w, this.w.blkmap[this.blockAt(t, e)] ?? 0);
+  }
+  solidAt(t, e) {
+    return this.shown(t, e).solid !== 0;
+  }
+  snapshot() {
+    return {
+      w: T(this.w),
+      rand: this.rand.a,
+      scene: this.scene,
+      prev: this.prev,
+      link: this.link,
+      ticks: this.ticks,
+      clock: this.clock,
+      lastKeyTick: this.lastKeyTick,
+      held: [...this.held],
+      pending: [...this.pending],
+      doScroll: this.doScroll,
+      ended: this.ended,
+      deaths: this.deaths,
+      trail: [...this.trail],
+      segments: this.segments.map((t) => ({ scene: t.scene, keys: t.keys.slice() })),
+      segmentTicks: [...this.segmentTicks],
+      clip: this.clip && { ...this.clip }
+    };
+  }
+  restore(t) {
+    this.rand = new p(t.rand);
+    const e = T(t.w);
+    e.rand = this.rand.next, this.w = e, this.ci = e.ci, this.scene = t.scene, this.prev = t.prev, this.link = t.link, this.ticks = t.ticks, this.clock = t.clock, this.lastKeyTick = t.lastKeyTick, this.held = new Set(t.held), this.pending = [...t.pending], this.doScroll = t.doScroll, this.ended = t.ended, this.deaths = t.deaths, this.trail = [...t.trail], this.segments = t.segments.map((o) => ({ scene: o.scene, keys: o.keys.slice() })), this.segmentTicks = [...t.segmentTicks], this.clip = t.clip && { ...t.clip };
+  }
+}
+function T(n) {
+  const { sound: t, rand: e, joystick: o, bg: a, mblk: r, cblk: l, mon: h, palette: i, chr: s, ...c } = n;
+  return { ...u(c), sound: t, rand: e, joystick: o, bg: a, mblk: r, cblk: l, mon: h, palette: i, chr: { ...s, x: [...s.x], y: [...s.y] } };
+}
+function u(n) {
+  if (n === null || typeof n != "object") return n;
+  if (ArrayBuffer.isView(n)) return n.slice();
+  if (Array.isArray(n)) return n.map(u);
+  const t = {};
+  for (const e in n) t[e] = u(n[e]);
+  return t;
+}
+function yt(n) {
+  const t = v(n);
+  return class extends Z {
+    constructor(e = Y(t), o = 1) {
+      super(e, o);
+    }
+  };
+}
+export {
+  Z as GameSim,
+  Q as TICKS_PER_SECOND,
+  yt as diskSim,
+  Y as readDisk
+};