@lewismoten/gamemaker-sandbox-engine 0.0.0-stage → 3.3.0

package/dist/formats/monster.js

@@ -0,0 +1,69 @@
+import { Writer as g, Reader as L } from "./binary.js";
+const e = 64, p = 20, l = 10, R = 300, C = 0, V = 1;
+function a(t) {
+  return { x: t.i16(), y: t.i16(), pic: t.i16(), orient: t.i16() };
+}
+function f(t, o) {
+  t.i16(o.x).i16(o.y).i16(o.pic).i16(o.orient);
+}
+function j(t) {
+  const o = t.i16(), n = t.i16(), c = t.i16(), M = t.i16(), h = t.u8(), y = t.i8(), s = [];
+  for (let i = 0; i <= p; i++) s.push([t.i16(), t.i16()]);
+  const d = t.u32(), w = t.i8(), A = t.i16(), x = t.bytesOf(21), T = t.i16(), E = t.i16(), O = t.i16(), S = [t.i16(), t.i16()], r = [[], []];
+  for (let i = 0; i < 2; i++) for (let u = 0; u < l; u++) r[i].push(a(t));
+  const N = a(t);
+  return { used: o, fly: n, jump: c, stick: M, power: h, thru: y, pic: s, lasttime: d, newmon: w, upscore: A, xtra: x, activate: T, end: E, towards: O, close: S, march: r, cur: N };
+}
+function k(t, o) {
+  t.i16(o.used).i16(o.fly).i16(o.jump).i16(o.stick).u8(o.power).i8(o.thru);
+  for (const [n, c] of o.pic) t.i16(n).i16(c);
+  t.u32(o.lasttime).i8(o.newmon).i16(o.upscore).bytes(o.xtra, 21).i16(o.activate).i16(o.end).i16(o.towards).i16(o.close[0]).i16(o.close[1]);
+  for (const n of o.march) for (const c of n) f(t, c);
+  f(t, o.cur);
+}
+function z(t) {
+  const o = new L(t);
+  return Array.from({ length: e }, () => j(o));
+}
+function B(t) {
+  const o = new g(e * R);
+  for (const n of t) k(o, n);
+  return o.toBytes();
+}
+function v() {
+  const t = Array.from({ length: p + 1 }, () => [100, 1]), o = () => Array.from({ length: l }, () => ({ x: 0, y: 0, pic: 0, orient: 0 }));
+  return {
+    used: 0,
+    fly: 0,
+    jump: 0,
+    stick: 0,
+    power: 1,
+    thru: 1,
+    pic: t,
+    lasttime: 0,
+    newmon: e,
+    upscore: 0,
+    xtra: new Uint8Array(21),
+    activate: 0,
+    end: 0,
+    towards: 0,
+    close: [0, 0],
+    march: [o(), o()],
+    cur: { x: 0, y: 0, pic: 0, orient: 0 }
+  };
+}
+function H() {
+  return Array.from({ length: e }, () => v());
+}
+export {
+  V as ATTACKMOVEMENT,
+  e as LASTMON,
+  p as LASTSL,
+  l as MAXMARCH,
+  R as MONSTER_SIZE,
+  C as NORMALMOVEMENT,
+  v as emptyMonster,
+  H as newMonsterSet,
+  z as parseMonsters,
+  B as serializeMonsters
+};

package/dist/formats/palette.js

@@ -0,0 +1,58 @@
+const T = 768;
+function h(t) {
+  const r = new Uint8Array(768);
+  return r.set(t.subarray(0, 768)), r;
+}
+function A(t) {
+  return t.slice(0, 768);
+}
+function P(t) {
+  const r = new Uint32Array(256);
+  for (let n = 0; n < 256; n++)
+    r[n] = 255 << 24 | u(t[n * 3 + 2]) << 16 | u(t[n * 3 + 1]) << 8 | u(t[n * 3]);
+  return r;
+}
+function u(t) {
+  const r = t & 63;
+  return r << 2 | r >> 4;
+}
+function b(t, r) {
+  return `rgb(${u(t[r * 3])},${u(t[r * 3 + 1])},${u(t[r * 3 + 2])})`;
+}
+function d(t, r, n, e) {
+  let o = 0, s = 1 / 0;
+  for (let c = 0; c < 256; c++) {
+    const i = (t[c * 3] & 63) - r, f = (t[c * 3 + 1] & 63) - n, a = (t[c * 3 + 2] & 63) - e, E = i * i + f * f + a * a;
+    E < s && (s = E, o = c);
+  }
+  return o;
+}
+function I() {
+  const t = new Uint8Array(768);
+  for (let n = 0; n < 16; n++) t.set([n * 4 + 3, n * 4 + 3, n * 4 + 3], n * 3);
+  let r = 16;
+  for (let n = 0; n < 6; n++)
+    for (let e = 0; e < 6; e++) for (let o = 0; o < 6; o++) t.set([Math.round(n * 63 / 5), Math.round(e * 63 / 5), Math.round(o * 63 / 5)], r++ * 3);
+  for (; r < 255; r++) {
+    const n = (r - 232) / 23 * 6, [e, o, s] = l(n, 1, 1);
+    t.set([e, o, s], r * 3);
+  }
+  return t.set([63, 0, 63], 765), t;
+}
+function l(t, r, n) {
+  const e = (o) => {
+    const s = (o + t) % 6;
+    return Math.round(63 * (n - n * r * Math.max(0, Math.min(s, 4 - s, 1))));
+  };
+  return [e(5), e(3), e(1)];
+}
+export {
+  T as PALETTE_SIZE,
+  I as defaultPalette,
+  d as matchColor,
+  b as paletteCss,
+  P as paletteToRGBA,
+  h as parsePalette,
+  A as serializePalette,
+  u as vga8
+};

package/dist/formats/recording.js

@@ -0,0 +1,17 @@
+import { Reader as i, Writer as u } from "./binary.js";
+const r = 1e3;
+function l(t) {
+  const e = new i(t), o = [], c = Math.min(r, Math.floor(t.length / 3));
+  for (let n = 0; n < c; n++) o.push({ delta: e.u16(), key: e.u8() });
+  return o;
+}
+function a(t) {
+  const e = new u(t.length * 3);
+  for (const o of t.slice(0, r)) e.u16(o.delta).u8(o.key);
+  return e.toBytes();
+}
+export {
+  r as RECLEN,
+  l as parseRecording,
+  a as serializeRecording
+};

package/dist/formats/sound.js

@@ -0,0 +1,44 @@
+import { Reader as f, Writer as u } from "./binary.js";
+const e = 30, c = 36, d = e * c * 2 + e * 9, w = [
+  "Help (hit points up)",
+  "Kill monster",
+  "Add money",
+  "Subtract money",
+  "Add life",
+  "Add score",
+  "Subtract score",
+  "Add other counter",
+  "Subtract other counter"
+];
+function A(i) {
+  const n = new f(i), o = [];
+  for (let r = 0; r < e; r++) {
+    const a = new Uint16Array(c);
+    for (let s = 0; s < c; s++) a[s] = n.u16();
+    o.push(a);
+  }
+  const t = [];
+  for (let r = 0; r < e; r++) t.push(n.bytesOf(9));
+  const l = t.map((r) => new f(r).cstr(9));
+  return { freqs: o, digital: l, digitalRaw: t };
+}
+function y(i) {
+  const n = new u(d);
+  for (const o of i.freqs) for (let t = 0; t < c; t++) n.u16(o[t] ?? 0);
+  return i.digital.forEach((o, t) => n.cstrOver(o, i.digitalRaw[t], 9)), n.toBytes();
+}
+function p() {
+  return {
+    freqs: Array.from({ length: e }, () => new Uint16Array(c)),
+    digital: new Array(e).fill(""),
+    digitalRaw: Array.from({ length: e }, () => new Uint8Array(9))
+  };
+}
+export {
+  e as LASTSND,
+  c as NUMFREQ,
+  w as SOUND_NAMES,
+  p as newSoundSet,
+  A as parseSoundSet,
+  y as serializeSoundSet
+};

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/gfx/colorVision.js

@@ -0,0 +1,45 @@
+const f = {
+  protan: [0.152286, 1.052583, -0.204868, 0.114503, 0.786281, 0.099216, -3882e-6, -0.048116, 1.051998],
+  deutan: [0.367322, 0.860646, -0.227968, 0.280085, 0.672501, 0.047413, -0.01182, 0.04294, 0.968881],
+  tritan: [1.255528, -0.076749, -0.178779, -0.078411, 0.930809, 0.147602, 4733e-6, 0.691367, 0.3039]
+}, l = (t) => t <= 0.04045 ? t / 12.92 : ((t + 0.055) / 1.055) ** 2.4;
+function m(t) {
+  const n = Math.max(0, Math.min(1, t));
+  return n <= 31308e-7 ? n * 12.92 : 1.055 * n ** (1 / 2.4) - 0.055;
+}
+function y(t, n) {
+  return [0, 1, 2].map((o) => Math.max(0, Math.min(1, n[o * 3] * t[0] + n[o * 3 + 1] * t[1] + n[o * 3 + 2] * t[2])));
+}
+function h([t, n, o]) {
+  const e = (0.4124 * t + 0.3576 * n + 0.1805 * o) / 0.95047, c = 0.2126 * t + 0.7152 * n + 0.0722 * o, r = (0.0193 * t + 0.1192 * n + 0.9505 * o) / 1.08883, s = (a) => a > 216 / 24389 ? Math.cbrt(a) : (24389 / 27 * a + 16) / 116;
+  return [116 * s(c) - 16, 500 * (s(e) - s(c)), 200 * (s(c) - s(r))];
+}
+function p([t, n, o]) {
+  const e = (t + 16) / 116, c = (u) => u ** 3 > 216 / 24389 ? u ** 3 : (116 * u - 16) / (24389 / 27), r = c(e + n / 500) * 0.95047, s = c(e), a = c(e - o / 200) * 1.08883;
+  return [3.2406 * r - 1.5372 * s - 0.4986 * a, -0.9689 * r + 1.8758 * s + 0.0415 * a, 0.0557 * r - 0.204 * s + 1.057 * a];
+}
+const M = (t, n) => Math.hypot(t[0] - n[0], t[1] - n[1], t[2] - n[2]), i = (t) => t.map((n) => l(n / 255));
+function d(t, n) {
+  return y(i(t), f[n]).map((o) => Math.round(255 * m(o)));
+}
+const L = (t, n) => M(h(i(t)), h(i(n)));
+function x(t, n) {
+  const o = new Uint8Array(t.length);
+  for (let e = 0; e < t.length; e += 3) {
+    const [c, r, s] = d([0, 1, 2].map((a) => t[e + a] << 2 | t[e + a] >> 4), n);
+    o.set([c >> 2, r >> 2, s >> 2], e);
+  }
+  return o;
+}
+export {
+  f as MACHADO,
+  L as deltaEBytes,
+  M as deltaELab,
+  h as lab,
+  m as linearToSrgb,
+  d as simulateBytes,
+  y as simulateLinear,
+  x as simulatePalette,
+  l as srgbToLinear,
+  p as unlab
+};