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

package/dist/formats/blocks.js

@@ -0,0 +1,103 @@
+import { W as r, R as u } from "../binary-D7wuaC5g.js";
+const c = 20, i = c * c, l = 420, a = 150, f = 100, B = 50, h = 255, S = 1, w = 2, T = 4, A = 8, m = { bbl: a, mbl: f, cbl: B };
+function L(e, t = !1) {
+  return {
+    pixels: new Uint8Array(i).fill(t ? h : 0),
+    birthMon: 0,
+    birthTime: 0,
+    xtra: new Uint8Array(2),
+    solid: 0,
+    hitpt: 0,
+    scorePts: 0,
+    chHitPt: 0,
+    nextBl: e,
+    ntime: 0,
+    touchBl: e,
+    grav: 0,
+    obj: 0,
+    effect: 0,
+    eamt: 0
+  };
+}
+function O(e) {
+  return {
+    pixels: e.bytesOf(i),
+    birthMon: e.u8(),
+    birthTime: e.i16(),
+    xtra: e.bytesOf(2),
+    solid: e.u8(),
+    hitpt: e.u8(),
+    scorePts: e.i16(),
+    chHitPt: e.i16(),
+    nextBl: e.u8(),
+    ntime: e.i16(),
+    touchBl: e.u8(),
+    grav: e.i8(),
+    obj: e.u8(),
+    effect: e.u8(),
+    eamt: e.i16()
+  };
+}
+function p(e, t) {
+  e.bytes(t.pixels, i).u8(t.birthMon).i16(t.birthTime).bytes(t.xtra, 2).u8(t.solid).u8(t.hitpt).i16(t.scorePts).i16(t.chHitPt).u8(t.nextBl).i16(t.ntime).u8(t.touchBl).i8(t.grav).u8(t.obj).u8(t.effect).i16(t.eamt);
+}
+function b(e, t) {
+  const n = new u(e), o = [];
+  for (let s = 0; s < t; s++) o.push(O(n));
+  return o;
+}
+function C(e) {
+  const t = new r(e.length * l);
+  for (const n of e) p(t, n);
+  return t.toBytes();
+}
+function R(e) {
+  const t = e !== "bbl";
+  return Array.from({ length: m[e] }, (n, o) => L(o, t));
+}
+function d(e, t, n) {
+  const o = c - 1, s = e & 255;
+  switch (s > 7 ? 7 : s) {
+    case 1:
+      return (o - t) * c + n;
+    // p[L-j][k]
+    case 2:
+      return (o - n) * c + (o - t);
+    // p[L-k][L-j]
+    case 3:
+      return t * c + (o - n);
+    // p[j][L-k]
+    case 4:
+      return n * c + (o - t);
+    // p[k][L-j]
+    case 5:
+      return t * c + n;
+    // p[j][k]
+    case 6:
+      return (o - n) * c + t;
+    // p[L-k][j]
+    case 7:
+      return (o - t) * c + (o - n);
+    // p[L-j][L-k]
+    default:
+      return n * c + t;
+  }
+}
+export {
+  a as BACKBL,
+  c as BLEN,
+  m as BLOCK_COUNTS,
+  l as BLOCK_SIZE,
+  B as CHARBL,
+  f as MONBL,
+  T as SOLBOT,
+  A as SOLLEF,
+  w as SOLRIG,
+  S as SOLTOP,
+  h as TRANSPARENT,
+  L as emptyBlock,
+  R as newBlockSet,
+  d as orientIndex,
+  b as parseBlocks,
+  C as serializeBlocks
+};

package/dist/formats/character.js

@@ -0,0 +1,83 @@
+import { R as d, W as A } from "../binary-D7wuaC5g.js";
+const r = 20, u = 10, a = 10, c = r + 10, S = 32767, s = 3784, b = 0, q = 1, v = 2, C = 3, I = 4, Q = ["Idle", "Die", "Hurt", "Pick up", "Drop"];
+function k(t) {
+  return { x: t.i16(), y: t.i16(), orient: t.u16(), pic1: t.u16(), pic2: t.u16(), pause: t.u16(), extra: t.bytesOf(5) };
+}
+function w(t, e) {
+  t.i16(e.x).i16(e.y).u16(e.orient).u16(e.pic1).u16(e.pic2).u16(e.pause).bytes(e.extra, 5);
+}
+function R(t) {
+  const e = [];
+  for (let n = 0; n < u; n++) e.push(k(t));
+  return {
+    frames: e,
+    key: t.u16(),
+    sound: t.i8(),
+    on: t.i8(),
+    bloc: t.u8(),
+    ground: t.i8(),
+    jstkBut: t.i8(),
+    jstkMov: t.i8(),
+    norepeat: t.i8(),
+    momentum: t.i8(),
+    xtra: t.bytesOf(5)
+  };
+}
+function M(t, e) {
+  for (const n of e.frames) w(t, n);
+  t.u16(e.key).i8(e.sound).i8(e.on).u8(e.bloc).i8(e.ground).i8(e.jstkBut).i8(e.jstkMov).i8(e.norepeat).i8(e.momentum).bytes(e.xtra, 5);
+}
+function U(t) {
+  const e = new d(t), n = [];
+  for (let o = 0; o < r; o++) n.push(R(e));
+  const i = [e.i16(), e.i16(), e.i16()], p = [e.i16(), e.i16(), e.i16()], y = e.i8(), E = e.i8(), l = e.bytesOf(a), f = [];
+  for (let o = 0; o < c; o++) f.push(e.i16());
+  const x = e.bytesOf(s);
+  return { sequences: n, x: i, y: p, cframe: y, cseq: E, inv: l, meter: f, rest: x };
+}
+function j(t) {
+  const e = new A(s * 2);
+  for (const n of t.sequences) M(e, n);
+  for (const n of t.x) e.i16(n);
+  for (const n of t.y) e.i16(n);
+  e.i8(t.cframe).i8(t.cseq).bytes(t.inv, a);
+  for (const n of t.meter) e.i16(n);
+  return e.bytes(t.rest, s), e.toBytes();
+}
+function m(t = !1) {
+  return { x: 0, y: 0, orient: 0, pic1: 50, pic2: t ? 51 : 50, pause: 1, extra: new Uint8Array(5) };
+}
+function D() {
+  const t = [];
+  for (let n = 0; n < r; n++) {
+    const i = Array.from({ length: u }, () => m(!0));
+    n === b && (i[0] = { ...m(), pic1: 0, pic2: 1, pause: 2 }), t.push({ frames: i, key: 0, sound: 30, on: 0, bloc: 150, ground: 0, jstkBut: 0, jstkMov: 0, norepeat: 0, momentum: 0, xtra: new Uint8Array(5) });
+  }
+  const e = new Array(c).fill(S);
+  e[0] = 100, e[1] = 3;
+  for (let n = r; n < c; n++) e[n] = 1;
+  return { sequences: t, x: [0, 0, 0], y: [0, 0, 0], cframe: 0, cseq: 0, inv: new Uint8Array(a).fill(150), meter: e, rest: new Uint8Array(s) };
+}
+function O(t) {
+  const e = t.frames.findIndex((n) => n.pic2 === 51);
+  return e < 0 ? u : e;
+}
+export {
+  s as CHR_RECORD_SIZE,
+  q as DIESEQ,
+  I as DROPSEQ,
+  v as HURTSEQ,
+  b as IDLESEQ,
+  S as INF_REPEAT,
+  u as MAXFRAME,
+  a as MAXINV,
+  r as MAXSEQ,
+  c as METERS,
+  C as PICKUPSEQ,
+  Q as SEQUENCE_NAMES,
+  m as emptyFrame,
+  O as frameCount,
+  D as newCharacter,
+  U as parseCharacter,
+  j as serializeCharacter
+};

package/dist/formats/cmf.js

@@ -0,0 +1,37 @@
+import { R as k } from "../binary-D7wuaC5g.js";
+const h = 146;
+function U(t) {
+  return t[0] === 67 && t[1] === 84 && t[2] === 77 && t[3] === 70;
+}
+function w(t) {
+  if (!U(t)) throw new Error("Not a CMF file");
+  const s = new k(t, 4), i = s.u16(), l = s.u16(), o = s.u16(), u = s.u16(), a = s.u16();
+  s.skip(6);
+  const f = s.bytesOf(16), r = s.u16(), e = s.u16(), c = [];
+  for (let n = 0; n < r; n++) c.push(new k(t, l + n * 16).bytesOf(16));
+  return { version: i, ticksPerBeat: u, clockTicks: a, channelUsed: f, instruments: c, basicTempo: e, music: t.subarray(o) };
+}
+function p(t) {
+  const s = [t & 127];
+  for (t >>>= 7; t > 0; t >>>= 7) s.unshift(t & 127 | 128);
+  return s;
+}
+function E(t) {
+  const i = t.instruments.slice(0, 128), l = new Uint8Array(16), o = [];
+  let u = 0;
+  for (const c of [...t.events].sort((n, m) => n.tick - m.tick)) {
+    const n = Math.max(u, Math.round(c.tick));
+    o.push(...p(n - u), ...c.data), u = n;
+    const m = c.data[0];
+    m >= 128 && m < 240 && (l[m & 15] = 1);
+  }
+  o.push(0, 255, 47, 0);
+  const a = 40, f = a + i.length * 16, r = new Uint8Array(f + o.length), e = new DataView(r.buffer);
+  return r.set([67, 84, 77, 70]), e.setUint16(4, 257, !0), e.setUint16(6, a, !0), e.setUint16(8, f, !0), e.setUint16(10, t.ticksPerBeat ?? 48, !0), e.setUint16(12, h, !0), r.set(l, 20), e.setUint16(36, i.length, !0), e.setUint16(38, t.basicTempo ?? 488, !0), i.forEach((c, n) => r.set(c.subarray(0, 16), a + n * 16)), r.set(o, f), r;
+}
+export {
+  h as CMF_GAMEMAKER_CLOCK,
+  E as encodeCmf,
+  U as isCmf,
+  w as parseCmf
+};

package/dist/formats/fli.js

@@ -0,0 +1,296 @@
+import { PALETTE_SIZE as R } from "./palette.js";
+const P = 44817, L = 44818, $ = 61946;
+function Y(e) {
+  const t = e[4] | e[5] << 8;
+  return t === P || t === L;
+}
+function b(e) {
+  const t = new DataView(e.buffer, e.byteOffset, e.byteLength), i = t.getUint16(4, !0);
+  if (i !== P && i !== L) throw new Error("Not an FLI file");
+  const c = t.getUint16(6, !0), r = t.getUint16(8, !0) || 320, s = t.getUint16(10, !0) || 200;
+  let h = t.getUint16(16, !0);
+  i === L && (h = Math.round(t.getUint32(16, !0) * 70 / 1e3));
+  let u = i === L && t.getUint32(80, !0) || 128;
+  const n = [];
+  for (; u + 16 <= e.length && n.length <= c; ) {
+    const l = t.getUint32(u, !0), o = t.getUint16(u + 4, !0);
+    if (l < 16) break;
+    o === $ && n.push(u), u += l;
+  }
+  return { width: r, height: s, frameCount: c, speed: h, frames: n, bytes: e };
+}
+function x(e) {
+  return { pixels: new Uint8Array(e.width * e.height), palette: new Uint8Array(R) };
+}
+function p(e, t, i) {
+  const c = e.frames[t];
+  if (c === void 0) return !1;
+  const r = e.bytes, s = new DataView(r.buffer, r.byteOffset, r.byteLength), h = s.getUint32(c, !0), u = s.getUint16(c + 6, !0), n = Math.min(r.length, c + h);
+  let l = c + 16, o = !1;
+  for (let d = 0; d < u && l + 6 <= n; d++) {
+    const f = s.getUint32(l, !0), a = s.getUint16(l + 4, !0), g = l + 6, w = Math.min(n, l + Math.max(f, 6));
+    switch (a) {
+      case 11:
+      // FLI_COLOR (0..63)
+      case 4:
+        B(r, g, i.palette, a === 4), o = !0;
+        break;
+      case 12:
+        Z(r, g, w, e.width, i.pixels);
+        break;
+      case 7:
+        q(r, g, w, e.width, e.height, i.pixels);
+        break;
+      case 13:
+        i.pixels.fill(0);
+        break;
+      case 15:
+        X(r, g, w, e.width, e.height, i.pixels);
+        break;
+      case 16:
+        i.pixels.set(r.subarray(g, Math.min(w, g + i.pixels.length)));
+        break;
+    }
+    if (f < 6) break;
+    l += f;
+  }
+  return o;
+}
+function B(e, t, i, c) {
+  const r = e[t] | e[t + 1] << 8;
+  t += 2;
+  let s = 0;
+  for (let h = 0; h < r; h++) {
+    s += e[t++];
+    let u = e[t++];
+    u === 0 && (u = 256);
+    for (let n = 0; n < u && s < 256; n++, s++)
+      for (let l = 0; l < 3; l++) {
+        const o = e[t++] ?? 0;
+        i[s * 3 + l] = c ? o >> 2 : o & 63;
+      }
+  }
+}
+function X(e, t, i, c, r, s) {
+  for (let h = 0; h < r && t < i; h++) {
+    t++;
+    let u = 0;
+    const n = h * c;
+    for (; u < c && t < i; ) {
+      const l = e[t++] << 24 >> 24;
+      if (l >= 0) {
+        const o = e[t++];
+        for (let d = 0; d < l && u < c; d++) s[n + u++] = o;
+      } else
+        for (let o = 0; o < -l && u < c; o++) s[n + u++] = e[t++];
+    }
+  }
+}
+function Z(e, t, i, c, r) {
+  let s = e[t] | e[t + 1] << 8;
+  const h = e[t + 2] | e[t + 3] << 8;
+  t += 4;
+  for (let u = 0; u < h && t < i; u++, s++) {
+    const n = e[t++];
+    let l = 0;
+    for (let o = 0; o < n && t < i; o++) {
+      l += e[t++];
+      const d = e[t++] << 24 >> 24, f = s * c;
+      if (d >= 0)
+        for (let a = 0; a < d; a++) r[f + l++] = e[t++];
+      else {
+        const a = e[t++];
+        for (let g = 0; g < -d; g++) r[f + l++] = a;
+      }
+    }
+  }
+}
+function q(e, t, i, c, r, s) {
+  let h = e[t] | e[t + 1] << 8;
+  t += 2;
+  let u = 0;
+  for (; h > 0 && t < i && u < r; ) {
+    let n = (e[t] | e[t + 1] << 8) << 16 >> 16;
+    if (t += 2, (n & 49152) === 49152) {
+      u -= n;
+      continue;
+    }
+    (n & 49152) === 32768 && (s[u * c + c - 1] = n & 255, n = (e[t] | e[t + 1] << 8) << 16 >> 16, t += 2);
+    let l = 0;
+    const o = u * c;
+    for (let d = 0; d < n && t < i; d++) {
+      l += e[t++];
+      const f = e[t++] << 24 >> 24;
+      if (f >= 0)
+        for (let a = 0; a < f; a++)
+          s[o + l++] = e[t++], s[o + l++] = e[t++];
+      else {
+        const a = e[t++], g = e[t++];
+        for (let w = 0; w < -f; w++)
+          s[o + l++] = a, s[o + l++] = g;
+      }
+    }
+    u++, h--;
+  }
+}
+function G(e, t, i) {
+  const c = [];
+  for (let r = 0; r < i; r++) {
+    const s = e.subarray(r * t, r * t + t), h = [];
+    let u = 0, n = 0;
+    for (; n < t; ) {
+      let l = 1;
+      for (; n + l < t && l < 127 && s[n + l] === s[n]; ) l++;
+      if (l >= 3 || n + l >= t)
+        h.push(l, s[n]), n += l;
+      else {
+        let o = 0;
+        for (; n + o < t && o < 128 && !(n + o + 2 < t && s[n + o] === s[n + o + 1] && s[n + o] === s[n + o + 2]); ) o++;
+        h.push(256 - o & 255, ...s.subarray(n, n + o)), n += o;
+      }
+      u++;
+    }
+    c.push(Math.min(255, u), ...h);
+  }
+  return c;
+}
+const I = 16e3, T = 127;
+function M(e, t, i, c, r) {
+  const s = i * c, h = [];
+  let u = 0, n = 0, l = 0;
+  for (; n < c; ) {
+    if (e[s + n] === t[s + n]) {
+      n++;
+      continue;
+    }
+    let o = n;
+    for (; o < c && o - n < 127 && (e[s + o] !== t[s + o] || o + 1 < c && e[s + o + 1] !== t[s + o + 1]); ) o++;
+    let d = n - l;
+    for (; d > 255; )
+      h.push(255, 0), u++, d -= 255;
+    const f = o - n, a = t.subarray(s + n, s + o).every((g) => g === t[s + n]);
+    r && !a ? u += Q(t, s + n, s + o, d, h) : (a && f > 2 ? h.push(d, 256 - f & 255, t[s + n]) : h.push(d, f, ...t.subarray(s + n, s + o)), u++), l = o, n = o;
+  }
+  return u > T ? r ? M(e, t, i, c, !1) : void 0 : [u, ...h];
+}
+function V(e, t, i, c) {
+  let r = 0;
+  for (; r < c && _(e, t, r, i); ) r++;
+  if (r === c) return;
+  let s = c - 1;
+  for (; s > r && _(e, t, s, i); ) s--;
+  return [r, s];
+}
+const H = (e, t) => [e & 255, e >> 8, t & 255, t >> 8];
+function J(e, t, i, c, r = !1) {
+  const s = V(e, t, i, c);
+  if (!s) return [0, 0, 0, 0];
+  const [h, u] = s, n = H(h, u - h + 1);
+  for (let l = h; l <= u; l++) {
+    const o = M(e, t, l, i, r);
+    if (!o) return;
+    n.push(...o);
+  }
+  return n;
+}
+function N(e, t, i, c, r) {
+  const s = V(e, t, i, c);
+  if (!s) return [m(12, [0, 0, 0, 0])];
+  const h = r - 6 - 1 - 4, u = [];
+  let n = [], l = 0, o = 0;
+  const d = () => {
+    for (; n.length && n[n.length - 1].length === 1 && n[n.length - 1][0] === 0; ) n.pop();
+    n.length && u.push(m(12, [...H(o, n.length), ...n.flat()])), n = [], l = 0;
+  };
+  for (let f = s[0]; f <= s[1]; f++) {
+    const a = _(e, t, f, i), g = a ? [0] : M(e, t, f, i, !1), w = a ? void 0 : M(e, t, f, i, !0), U = w && (!g || w.length < g.length) ? w : g;
+    if (!U) throw new Error(`FLI line ${f} needs more than ${T} packets`);
+    if (l + U.length > h && d(), !n.length) {
+      if (a) continue;
+      o = f;
+    }
+    n.push(U), l += U.length;
+  }
+  return d(), u;
+}
+function Q(e, t, i, c, r) {
+  let s = 0, h = t;
+  const u = (l) => {
+    l > h && (r.push(s ? 0 : c, l - h, ...e.subarray(h, l)), s++);
+  };
+  let n = t;
+  for (; n < i; ) {
+    let l = 1;
+    for (; n + l < i && l < 127 && e[n + l] === e[n]; ) l++;
+    if (l >= 3)
+      u(n), r.push(s ? 0 : c, 256 - l & 255, e[n]), s++, n += l, h = n;
+    else
+      for (n += l; n - h > 127; )
+        u(h + 127), h += 127;
+  }
+  return u(i), s;
+}
+function _(e, t, i, c) {
+  for (let r = i * c, s = r + c; r < s; r++) if (e[r] !== t[r]) return !1;
+  return !0;
+}
+function m(e, t) {
+  let i = t.length + 6;
+  const c = i & 1;
+  return i += c, [i & 255, i >> 8 & 255, i >> 16 & 255, i >>> 24, e & 255, e >> 8, ...t, ...c ? [0] : []];
+}
+function tt(e, t, i = {}) {
+  const c = i.width ?? 320, r = i.height ?? 200, s = [...e, e[0]], h = i.palettes ? [...e.map((f, a) => i.palettes[a] ?? t), i.palettes[0] ?? t] : void 0, u = s.map((f, a) => {
+    const g = [], w = h?.[a] ?? t;
+    if (a === 0 || h && h[a - 1].some((y, k) => k < 768 && (y & 63) !== (w[k] & 63))) {
+      const y = [1, 0, 0, 0];
+      for (let k = 0; k < 768; k++) y.push(w[k] & 63);
+      g.push(m(11, y));
+    }
+    const U = a > 0 ? s[a - 1] : void 0, v = U ? J(U, f, c, r, i.runs) : void 0, A = v && v.length < 64e3 ? void 0 : G(f, c, r), z = v && (!A || v.length < A.length) ? m(12, v) : m(15, A ?? G(f, c, r));
+    if (z.length <= I) g.push(z);
+    else {
+      const y = N(
+        f.map((C) => C ^ 1),
+        f,
+        c,
+        r,
+        I
+      ), k = U ? N(U, f, c, r, I) : void 0, S = (C) => C.reduce((E, O) => E + O.length, 0), D = k && S(k) <= S(y) ? k : y, K = a === 0 || h && h[a - 1].every((C, E) => E >= 768 || (C & 63) === 0);
+      g.length && K ? g.splice(0, 0, ...D) : g.push(...D);
+    }
+    const j = g.flat(), F = j.length + 16;
+    return [
+      F & 255,
+      F >> 8 & 255,
+      F >> 16 & 255,
+      F >>> 24,
+      250,
+      241,
+      g.length & 255,
+      g.length >> 8,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      ...j
+    ];
+  }), n = 128 + u.reduce((f, a) => f + a.length, 0), l = new Uint8Array(n), o = new DataView(l.buffer);
+  o.setUint32(0, n, !0), o.setUint16(4, 44817, !0), o.setUint16(6, e.length, !0), o.setUint16(8, c, !0), o.setUint16(10, r, !0), o.setUint16(12, 8, !0), o.setUint16(16, i.speed ?? 5, !0);
+  let d = 128;
+  for (const f of u)
+    l.set(f, d), d += f.length;
+  return l;
+}
+export {
+  I as FLI_CHUNK_MAX,
+  p as applyFliFrame,
+  tt as encodeFli,
+  Y as isFli,
+  x as newFliCanvas,
+  b as parseFli
+};

package/dist/formats/fliLimits.js

@@ -0,0 +1,54 @@
+import { FLI_CHUNK_MAX as g, isFli as p, parseFli as k } from "./fli.js";
+const $ = /* @__PURE__ */ new Set([11, 12, 13, 15, 16]);
+function M(e) {
+  if (e.length < 128 || !p(e)) return [];
+  const t = k(e), i = new DataView(e.buffer, e.byteOffset, e.byteLength), h = [];
+  return t.frames.forEach((n, o) => {
+    const l = /* @__PURE__ */ new Set(), r = (c, s) => {
+      l.has(c) || (l.add(c), h.push({ kind: c, frame: o, value: s }));
+    }, u = Math.min(e.length, n + i.getUint32(n, !0));
+    let a = n + 16;
+    for (let c = 0; c < i.getUint16(n + 6, !0) && a + 6 <= u; c++) {
+      const s = i.getUint32(a, !0), f = i.getUint16(a + 4, !0);
+      if (s < 6) break;
+      if (s > g && r("big", s), f === 13) r("black", f);
+      else if (!$.has(f)) r("type", f);
+      else if (f === 12) {
+        const m = d(e, a + 6, Math.min(u, a + s));
+        m >= 128 && r("packets", m);
+      }
+      a += s;
+    }
+  }), h;
+}
+function d(e, t, i) {
+  if (t + 4 > i) return 0;
+  const h = e[t + 2] | e[t + 3] << 8;
+  let n = t + 4, o = 0;
+  for (let l = 0; l < h && n < i; l++) {
+    const r = e[n++];
+    o = Math.max(o, r);
+    for (let u = 0; u < r && n + 1 < i; u++) {
+      const a = e[n + 1] << 24 >> 24;
+      n += 2 + (a >= 0 ? a : 1);
+    }
+  }
+  return o;
+}
+function U(e) {
+  const t = e.frame === 0 ? "its first frame" : `frame ${e.frame + 1}`;
+  switch (e.kind) {
+    case "big":
+      return `a ${e.value.toLocaleString("en-US")}-byte chunk in ${t} (DOS reads ${g.toLocaleString("en-US")} safely)`;
+    case "packets":
+      return `a line of ${e.value} changes in ${t} (DOS reads 127 at most)`;
+    case "black":
+      return `an all-black chunk in ${t} (PLAYGAME crashes on it)`;
+    default:
+      return `a chunk of type ${e.value} in ${t} (PLAYGAME stops at it)`;
+  }
+}
+export {
+  U as describeFliFault,
+  M as fliFaults
+};