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

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
+};

package/dist/kit/hopBot.js

@@ -0,0 +1,142 @@
+class d {
+  constructor(s, t) {
+    this.sim = s, this.scan = t.scan, this.origin = t.origin, this.meterShown = t.meter, this.traced = t.traced ?? [72, 75, 77, 80, 16, 18];
+  }
+  sim;
+  log = [];
+  scan;
+  origin;
+  meterShown;
+  traced;
+  snapshot() {
+    return { sim: this.sim.snapshot(), log: this.log.length };
+  }
+  restore(s) {
+    this.sim.restore(s.sim), this.log.length = s.log;
+  }
+  /** The hero's position in level pixels (left/top of its bottom block). */
+  get px() {
+    const s = this.sim.pos;
+    return { x: (s.x - this.origin) * 20 + s.sx, y: (s.y - this.origin) * 20 + s.sy };
+  }
+  /** Its block (level coordinates), rounded to the nearest. */
+  get at() {
+    const s = this.px;
+    return { x: Math.round(s.x / 20), y: Math.round(s.y / 20) };
+  }
+  say(s) {
+    const t = this.px;
+    this.log.push(`[${this.sim.scene}] ${s} @${(t.x / 20).toFixed(2)},${(t.y / 20).toFixed(2)} t${this.sim.ticks} hp ${this.sim.ci.hitpts}`);
+  }
+  async tick() {
+    const s = this.sim.ci.hitpts, t = await this.sim.tick() ?? void 0;
+    if (process.env.BOT_HURT && this.sim.ci.hitpts < s) {
+      const e = this.sim.w, h = e.mi.map((r, o) => ({ mi: r, n: e.mm[o].monnum })).filter(({ mi: r, n: o }) => o < 64 && Math.abs(r.curx[0] - this.sim.pos.x) <= 1 && Math.abs(r.cury[0] - this.sim.pos.y) <= 1), i = this.meterShown;
+      this.say(
+        `  hurt ${s - this.sim.ci.hitpts}: monsters ${h.map((r) => r.n).join(",")} block ${this.sim.blockAt(this.sim.pos.x + 1, this.sim.pos.y)} ${i.name} ${this.sim.meter(i.n) - 1}`
+      );
+    }
+    return process.env.BOT_TRACE && this.say(`  keys ${this.traced.filter((e) => this.sim.isHeld(e)).join(",")} gy ${this.sim.ci.gravy}${t ? " " + t : ""}`), t;
+  }
+  async wait(s) {
+    for (let t = 0; t < s; t++) {
+      const e = await this.tick();
+      if (e) return e;
+    }
+  }
+  /** Waits until the hero stops moving up or down (standing, or holding on to something). */
+  async land(s = 80) {
+    let t = this.px.y, e = 0;
+    for (let h = 0; h < s; h++) {
+      const i = await this.tick();
+      if (i) return i;
+      const r = this.px.y;
+      if (e = r === t ? e + 1 : 0, t = r, e >= 3) return;
+    }
+    return "never landed";
+  }
+  /** Before each step of a walk: a game's chance to stop for something (keys still held). */
+  async beforeStep(s) {
+  }
+  /** Before a hop (and before a walk hops what blocks it, `dir` still held): a game's chance to wait. */
+  async beforeHop(s) {
+  }
+  /** Walks to level column `bx` (its left edge at bx * 20 px), hopping over whatever stops it. */
+  async walk(s, t = "", e = 900) {
+    const h = this.scan, i = s * 20, r = i > this.px.x ? "right" : "left", o = () => r === "right" ? this.px.x >= i : this.px.x <= i;
+    this.sim.press(h[r]);
+    let n = 0, a = this.px.x;
+    for (let l = 0; l < e && !o(); l++) {
+      const p = await this.beforeStep(r);
+      if (p) return this.sim.releaseAll(), p;
+      const m = await this.tick();
+      if (m) return this.sim.releaseAll(), m;
+      if (n = this.px.x === a ? n + 1 : 0, a = this.px.x, n >= 3) {
+        const x = await this.beforeHop(r);
+        if (x) return this.sim.releaseAll(), x;
+        this.sim.press(h.up);
+        const f = await this.wait(10);
+        if (this.sim.release(h.up), f) return this.sim.releaseAll(), f;
+        n = -12;
+      }
+    }
+    this.sim.release(h[r]);
+    const c = await this.land();
+    if (c) return c;
+    if (Math.abs(this.px.x - i) > 3) {
+      const l = this.px.x > i ? "left" : "right";
+      this.sim.press(h[l]);
+      for (let p = 0; p < 10 && Math.abs(this.px.x - i) > 2; p++) {
+        const m = await this.tick();
+        if (m) return this.sim.releaseAll(), m;
+      }
+      this.sim.release(h[l]);
+    }
+    return Math.abs(this.px.x - i) > 6 ? `walk to ${s} ${t} stopped at ${(this.px.x / 20).toFixed(2)}` : (t && this.say(`at ${t}`), this.land());
+  }
+  /**
+   * A hop: Up (or Q/E sideways) held `hold` ticks; then `steer` held while it falls, until it
+   * lands or has gone `steerTo` columns (level block x).
+   */
+  async hop(s, t = 12, e, h) {
+    const i = this.scan, r = s === "up" ? i.up : s === "left" ? i.q : i.e, o = await this.beforeHop();
+    if (o) return o;
+    this.sim.press(r);
+    let n = await this.wait(t);
+    if (this.sim.release(r), n) return this.sim.releaseAll(), n;
+    if (e) {
+      this.sim.press(i[e]);
+      const a = h !== void 0 ? h * 20 : void 0;
+      for (let c = 0; c < 60 && !(a !== void 0 && (e === "right" ? this.px.x >= a : this.px.x <= a)); c++)
+        if (n = await this.tick(), n) return this.sim.releaseAll(), n;
+      this.sim.release(i[e]);
+    }
+    return n = await this.land(), this.say(`hopped ${s}${e ? " then " + e : ""}`), n;
+  }
+  /** Holds a key for `ticks` (Down to climb down, Up to climb up, Space for the game's action). */
+  async hold(s, t) {
+    const e = this.scan[s];
+    this.sim.press(e);
+    const h = await this.wait(t);
+    return this.sim.release(e), h;
+  }
+  /** Climbs (or walks) along one axis until the hero reaches level column/row `to`. */
+  async dig(s, t, e = "", h = 400) {
+    const i = t * 20, r = () => s === "left" ? this.px.x <= i : s === "right" ? this.px.x >= i : s === "up" ? this.px.y <= i : this.px.y >= i;
+    return this.until(s, r, e || `dug ${s} to ${t}`, h);
+  }
+  /** Holds `key` until `check` says so (or `max` ticks: then it fails). */
+  async until(s, t, e, h = 300) {
+    const i = s === void 0 ? void 0 : this.scan[s];
+    i !== void 0 && this.sim.press(i);
+    for (let r = 0; r < h && !t(); r++) {
+      const o = await this.tick();
+      if (o) return this.sim.releaseAll(), o;
+    }
+    if (i !== void 0 && this.sim.release(i), !t()) return `never ${e}`;
+    this.say(e);
+  }
+}
+export {
+  d as HopBot
+};