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

package/dist/formats/voc.js

@@ -0,0 +1,303 @@
+const A = "Creative Voice File";
+function C(e) {
+  for (let t = 0; t < A.length; t++) if (e[t] !== A.charCodeAt(t)) return !1;
+  return !0;
+}
+function j(e) {
+  if (!C(e)) throw new Error("Not a VOC file");
+  let t = e[20] | e[21] << 8, n = 0;
+  const s = [];
+  let f = -1, h = 0, l = 0, u = 0, i;
+  const p = (a) => {
+    if (u === 0) return k(a);
+    const c = x[u];
+    return c ? (i || (i = { reference: a[0] ?? 128, scale: 0 }, a = a.subarray(1)), F(a, c, i)) : new Float32Array(0);
+  };
+  for (; t < e.length && l++ < 1e4; ) {
+    const a = e[t];
+    if (a === 0) break;
+    const c = e[t + 1] | e[t + 2] << 8 | e[t + 3] << 16, r = t + 4, M = Math.min(e.length, r + c);
+    switch (a) {
+      case 1: {
+        const m = Math.round(1e6 / (256 - e[r]));
+        n ||= m, u = e[r + 1], i = void 0, s.push(p(e.subarray(r + 2, M)));
+        break;
+      }
+      case 2:
+        s.push(p(e.subarray(r, M)));
+        break;
+      case 3: {
+        const m = (e[r] | e[r + 1] << 8) + 1;
+        n ||= Math.round(1e6 / (256 - e[r + 2])), s.push(new Float32Array(m));
+        break;
+      }
+      case 6:
+        f = t + 4 + c, h = e[r] | e[r + 1] << 8;
+        break;
+      case 7:
+        if (f >= 0 && h > 0 && h < 65535) {
+          h--, t = f;
+          continue;
+        }
+        break;
+      case 8: {
+        const m = e[r] | e[r + 1] << 8, w = e[r + 3] === 1;
+        n = Math.round(256e6 / ((w ? 2 : 1) * (65536 - m)));
+        break;
+      }
+      case 9: {
+        n = e[r] | e[r + 1] << 8 | e[r + 2] << 16 | e[r + 3] << 24;
+        const m = e[r + 4], w = e.subarray(r + 12, M);
+        s.push(m === 16 ? V(w) : k(w));
+        break;
+      }
+    }
+    t = r + c;
+  }
+  const g = s.reduce((a, c) => a + c.length, 0), o = new Float32Array(g);
+  let d = 0;
+  for (const a of s)
+    o.set(a, d), d += a.length;
+  return { sampleRate: n || 8e3, samples: o };
+}
+function k(e) {
+  const t = new Float32Array(e.length);
+  for (let n = 0; n < e.length; n++) t[n] = (e[n] - 128) / 128;
+  return t;
+}
+const x = {
+  1: {
+    bits: [4, 4],
+    scaleMap: [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      0,
+      -1,
+      -2,
+      -3,
+      -4,
+      -5,
+      -6,
+      -7,
+      1,
+      3,
+      5,
+      7,
+      9,
+      11,
+      13,
+      15,
+      -1,
+      -3,
+      -5,
+      -7,
+      -9,
+      -11,
+      -13,
+      -15,
+      2,
+      6,
+      10,
+      14,
+      18,
+      22,
+      26,
+      30,
+      -2,
+      -6,
+      -10,
+      -14,
+      -18,
+      -22,
+      -26,
+      -30,
+      4,
+      12,
+      20,
+      28,
+      36,
+      44,
+      52,
+      60,
+      -4,
+      -12,
+      -20,
+      -28,
+      -36,
+      -44,
+      -52,
+      -60
+    ],
+    adjustMap: [
+      0,
+      0,
+      0,
+      0,
+      0,
+      16,
+      16,
+      16,
+      0,
+      0,
+      0,
+      0,
+      0,
+      16,
+      16,
+      16,
+      240,
+      0,
+      0,
+      0,
+      0,
+      16,
+      16,
+      16,
+      240,
+      0,
+      0,
+      0,
+      0,
+      16,
+      16,
+      16,
+      240,
+      0,
+      0,
+      0,
+      0,
+      16,
+      16,
+      16,
+      240,
+      0,
+      0,
+      0,
+      0,
+      16,
+      16,
+      16,
+      240,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      240,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0
+    ]
+  },
+  2: {
+    bits: [3, 3, 2],
+    scaleMap: [
+      0,
+      1,
+      2,
+      3,
+      0,
+      -1,
+      -2,
+      -3,
+      1,
+      3,
+      5,
+      7,
+      -1,
+      -3,
+      -5,
+      -7,
+      2,
+      6,
+      10,
+      14,
+      -2,
+      -6,
+      -10,
+      -14,
+      4,
+      12,
+      20,
+      28,
+      -4,
+      -12,
+      -20,
+      -28,
+      5,
+      15,
+      25,
+      35,
+      -5,
+      -15,
+      -25,
+      -35
+    ],
+    adjustMap: [0, 0, 0, 8, 0, 0, 0, 8, 248, 0, 0, 8, 248, 0, 0, 8, 248, 0, 0, 8, 248, 0, 0, 8, 248, 0, 0, 8, 248, 0, 0, 8, 248, 0, 0, 0, 248, 0, 0, 0]
+  },
+  3: {
+    bits: [2, 2, 2, 2],
+    scaleMap: [0, 1, 0, -1, 1, 3, -1, -3, 2, 6, -2, -6, 4, 12, -4, -12, 8, 24, -8, -24, 6, 48, -16, -48],
+    adjustMap: [0, 4, 0, 4, 252, 4, 252, 4, 252, 4, 252, 4, 252, 4, 252, 4, 252, 4, 252, 4, 252, 0, 252, 0]
+  }
+};
+function F(e, t, n) {
+  const s = new Float32Array(e.length * t.bits.length), f = t.scaleMap.length - 1;
+  let h = 0;
+  for (const l of e) {
+    let u = 8;
+    for (const i of t.bits) {
+      u -= i;
+      let p = l >> u & (1 << i) - 1;
+      t.bits.length === 3 && i === 2 && (p <<= 1);
+      const g = Math.max(0, Math.min(f, p + n.scale));
+      n.reference = Math.max(0, Math.min(255, n.reference + t.scaleMap[g])), n.scale = n.scale + t.adjustMap[g] & 255, s[h++] = (n.reference - 128) / 128;
+    }
+  }
+  return s;
+}
+function V(e) {
+  const t = new Float32Array(e.length >> 1);
+  for (let n = 0; n < t.length; n++) t[n] = ((e[n * 2] | e[n * 2 + 1] << 8) << 16 >> 16) / 32768;
+  return t;
+}
+function U(e, t = 11025) {
+  const n = Math.max(0, Math.min(255, Math.round(256 - 1e6 / t))), s = 16777200, f = [];
+  let h = 0;
+  do {
+    const o = e.subarray(h, Math.min(e.length, h + s)), d = h === 0, a = d ? 6 : 4, c = new Uint8Array(a + o.length), r = o.length + (d ? 2 : 0);
+    c[0] = d ? 1 : 2, c[1] = r & 255, c[2] = r >> 8 & 255, c[3] = r >> 16 & 255, d && (c[4] = n, c[5] = 0);
+    for (let M = 0; M < o.length; M++) c[a + M] = Math.max(0, Math.min(255, Math.round(o[M] * 127 + 128)));
+    f.push(c), h += s;
+  } while (h < e.length);
+  const l = new Uint8Array(26);
+  for (let o = 0; o < A.length; o++) l[o] = A.charCodeAt(o);
+  l[20] = 26;
+  const u = 266;
+  l[22] = u & 255, l[23] = u >> 8;
+  const i = ~u + 4660 & 65535;
+  l[24] = i & 255, l[25] = i >> 8;
+  const p = new Uint8Array(l.length + f.reduce((o, d) => o + d.length, 0) + 1);
+  p.set(l);
+  let g = l.length;
+  for (const o of f)
+    p.set(o, g), g += o.length;
+  return p;
+}
+export {
+  j as decodeVoc,
+  U as encodeVoc,
+  C as isVoc
+};

package/dist/images.js

@@ -0,0 +1,50 @@
+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;
+}
+async function D(e) {
+  const n = new Blob([e]).stream().pipeThrough(new CompressionStream("deflate"));
+  return new Uint8Array(await new Response(n).arrayBuffer());
+}
+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;
+}
+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)];
+  }
+  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;
+}
+export {
+  p as crc32,
+  x as encodePng
+};

package/dist/pixels-DzfIIUOl.js

@@ -0,0 +1,76 @@
+class a {
+  constructor(s, t, h = 0) {
+    this.w = s, this.h = t, this.px = new Uint8Array(s * t).fill(h);
+  }
+  get(s, t) {
+    return s < 0 || t < 0 || s >= this.w || t >= this.h ? -1 : this.px[t * this.w + s];
+  }
+  set(s, t, h) {
+    return s = Math.round(s), t = Math.round(t), s >= 0 && t >= 0 && s < this.w && t < this.h && (this.px[t * this.w + s] = h), this;
+  }
+  rect(s, t, h, e, i) {
+    for (let r = t; r < t + e; r++) for (let n = s; n < s + h; n++) this.set(n, r, i);
+    return this;
+  }
+  frame(s, t, h, e, i) {
+    return this.rect(s, t, h, 1, i).rect(s, t + e - 1, h, 1, i), this.rect(s, t, 1, e, i).rect(s + h - 1, t, 1, e, i);
+  }
+  line(s, t, h, e, i) {
+    const r = Math.max(Math.abs(h - s), Math.abs(e - t), 1);
+    for (let n = 0; n <= r; n++) this.set(s + (h - s) * n / r, t + (e - t) * n / r, i);
+    return this;
+  }
+  disc(s, t, h, e) {
+    for (let i = Math.floor(t - h); i <= t + h; i++)
+      for (let r = Math.floor(s - h); r <= s + h; r++) (r - s) ** 2 + (i - t) ** 2 <= h * h && this.set(r, i, e);
+    return this;
+  }
+  ring(s, t, h, e) {
+    for (let i = 0; i < Math.PI * 2; i += 0.5 / Math.max(1, h)) this.set(s + Math.cos(i) * h, t + Math.sin(i) * h, e);
+    return this;
+  }
+  /** Every pixel through fn(x, y, current) → new color (or the same). */
+  map(s) {
+    for (let t = 0; t < this.h; t++) for (let h = 0; h < this.w; h++) this.px[t * this.w + h] = s(h, t, this.px[t * this.w + h]);
+    return this;
+  }
+  /** Copies another picture in, skipping `transparent` pixels. */
+  blit(s, t, h, e = -1) {
+    for (let i = 0; i < s.h; i++)
+      for (let r = 0; r < s.w; r++) {
+        const n = s.px[i * s.w + r];
+        n !== e && this.set(t + r, h + i, n);
+      }
+    return this;
+  }
+  /** A sub-rectangle as a new picture (cutting a 20x20 block out of a big drawing). */
+  crop(s, t, h, e) {
+    const i = new a(h, e);
+    for (let r = 0; r < e; r++) for (let n = 0; n < h; n++) i.px[r * h + n] = this.get(s + n, t + r) & 255;
+    return i;
+  }
+  flipX() {
+    return new a(this.w, this.h).map((t, h) => this.get(this.w - 1 - t, h));
+  }
+  /** ASCII art: each character maps to a color through `key`; others are skipped. */
+  draw(s, t, h, e) {
+    return h.forEach((i, r) => [...i].forEach((n, f) => n in e && this.set(s + f, t + r, e[n]))), this;
+  }
+}
+function l(o) {
+  let s = o >>> 0;
+  return () => {
+    s = s + 1831565813 >>> 0;
+    let t = s;
+    return t = Math.imul(t ^ t >>> 15, t | 1), t ^= t + Math.imul(t ^ t >>> 7, t | 61), ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function u(o, s, t) {
+  const h = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5];
+  return t * 16 > h[(s & 3) * 4 + (o & 3)];
+}
+export {
+  a as P,
+  u as d,
+  l as r
+};