@lewismoten/gamemaker-sandbox-engine 3.1.0 → 3.3.0

package/dist/engine/machine.js

@@ -0,0 +1,192 @@
+import { Screen as d } from "../gfx/screen.js";
+import { Keyboard as m } from "../input/keyboard.js";
+import { listenDeskMouse as u, Mickeys as p } from "../input/deskMouse.js";
+import { AudioEngine as y } from "../audio/engine.js";
+import { PALETTE_SIZE as c } from "../formats/palette.js";
+const w = 6;
+class k extends Error {
+  constructor() {
+    super("Game aborted");
+  }
+}
+class E {
+  screen;
+  keyboard = new m();
+  audio;
+  files;
+  pointer = { x: 160, y: 100, clicks: 0 };
+  aborted = !1;
+  /** Observer only (the walkthrough player's item marks): a picture, cartoon, text page or slide list is about to be shown. Never changes timing. */
+  onItem;
+  frameWaiters = [];
+  raf = 0;
+  /** The ball mouse on the desk moves the pointer and clicks too. */
+  offDeskMouse;
+  /** The engine was made here (not passed in): it goes with the Machine. */
+  ownsAudio;
+  constructor(t, e, i, s = {}) {
+    if (this.screen = new d(t), this.files = e, this.ownsAudio = !i, this.audio = i ?? new y(), s.input === !1 ? (this.offDeskMouse = () => {
+    }, this.keyboard.attach = this.keyboard.detach = () => {
+    }) : this.listen(t), s.frames === "manual") return;
+    const o = () => {
+      this.presentFrame(), this.raf = requestAnimationFrame(o);
+    };
+    this.raf = requestAnimationFrame(o);
+  }
+  listen(t) {
+    t.addEventListener("pointerdown", this.onPointer), t.addEventListener("pointermove", this.onMove);
+    const e = new p();
+    let i = 0;
+    this.offDeskMouse = u((s, o, r) => {
+      const [h, a] = e.take(s, o);
+      this.pointer.x = Math.max(0, Math.min(319, this.pointer.x + h)), this.pointer.y = Math.max(0, Math.min(199, this.pointer.y + a)), r & ~i && (this.pointer.clicks++, this.audio.resume()), i = r;
+    });
+  }
+  /** The time in ms the game goes by (waits, fades, animations, the game clock). */
+  now() {
+    return performance.now();
+  }
+  /** One display frame: the screen is shown (unless `show` is false) and everything waiting for a frame goes on. */
+  presentFrame(t = !0) {
+    t && this.screen.present();
+    const e = this.frameWaiters;
+    this.frameWaiters = [], e.forEach((i) => i());
+  }
+  /** How many are waiting for the next frame (a stepped Machine's game is idle when one is). */
+  get frameWaiting() {
+    return this.frameWaiters.length;
+  }
+  toScreen(t) {
+    const e = this.screen.canvas.getBoundingClientRect();
+    this.pointer.x = Math.floor((t.clientX - e.left) / e.width * 320), this.pointer.y = Math.floor((t.clientY - e.top) / e.height * 200);
+  }
+  onPointer = (t) => {
+    this.toScreen(t), this.pointer.clicks++, this.audio.resume();
+  };
+  onMove = (t) => this.toScreen(t);
+  destroy() {
+    this.aborted = !0, this.raf && cancelAnimationFrame(this.raf), this.keyboard.detach(), this.ownsAudio ? this.audio.dispose() : this.audio.stopAll(), this.screen.canvas.removeEventListener("pointerdown", this.onPointer), this.screen.canvas.removeEventListener("pointermove", this.onMove), this.offDeskMouse();
+    const t = this.frameWaiters;
+    this.frameWaiters = [], t.forEach((e) => e());
+  }
+  /** Told when the game waits for files still on their way (true) and when they are in. */
+  onLoading;
+  /**
+   * Waits for game files still on their way from the site (a hosted game starts before
+   * all its files are in, project/streamGame.ts); a short wait shows no cue. Names the
+   * game doesn't have, or that are in already, return at once.
+   */
+  async need(...t) {
+    const e = this.files.stream?.need(t.filter((s) => !!s));
+    if (!e) return;
+    const i = setTimeout(() => this.onLoading?.(!0), 150);
+    try {
+      await e;
+    } finally {
+      clearTimeout(i), this.onLoading?.(!1);
+    }
+    this.polledAt = this.now(), this.checkAbort();
+  }
+  /** Fetches these game files next, if they are still on their way, without waiting. */
+  want(...t) {
+    this.files.stream?.want(t.filter((e) => !!e));
+  }
+  checkAbort() {
+    if (this.aborted) throw new k();
+  }
+  /** Waits for the next animation frame (the screen is presented every frame). */
+  frame() {
+    return this.checkAbort(), this.pollKeys(), new Promise((t) => this.frameWaiters.push(t)).then(() => this.checkAbort());
+  }
+  async sleep(t) {
+    const e = this.now() + t;
+    for (; this.now() < e; ) await this.frame();
+  }
+  takeClick() {
+    return this.pointer.clicks ? (this.pointer.clicks = 0, !0) : !1;
+  }
+  /**
+   * PauseTimeKey: waits up to `seconds` (forever if omitted) for a key or click.
+   * Returns the key, a pseudo key for a click (ascii 1, as the C returned 1 for a mouse
+   * button; scan 28 is Enter's), or undefined on time out (the C returned FALSE).
+   */
+  async pauseTimeKey(t = 1 / 0) {
+    const e = this.now() + t * 1e3;
+    return this.takeClick(), this.waiting(async () => {
+      for (; ; ) {
+        const i = this.keyboard.readKey();
+        if (i) return i;
+        if (this.takeClick()) return { scan: 28, ascii: 1, key: "" };
+        if (this.now() >= e) return;
+        await this.frame();
+      }
+    });
+  }
+  waitDepth = 0;
+  polledAt = 0;
+  /**
+   * Runs `fn` as PLAYGAME code that read keys through GetKey (key waits, pictures,
+   * animations, text pages): while it runs, each frame hands the demo recorder the polls
+   * the DOS PC would have made meanwhile (keyPoll). Gameplay itself stole the keyboard
+   * interrupt and never called GetKey, so it does not count.
+   */
+  async waiting(t) {
+    this.waitDepth++ === 0 && (this.polledAt = this.now());
+    try {
+      return await t();
+    } finally {
+      if (--this.waitDepth === 0 && this.keyPollEnd) for (const e of this.keyPollEnd()) this.keyboard.feed(e);
+    }
+  }
+  pollKeys() {
+    if (!this.keyPoll || this.waitDepth === 0) return;
+    const t = this.now(), e = Math.max(1, Math.round((t - this.polledAt) * w));
+    this.polledAt = t;
+    for (const i of this.keyPoll(e)) this.keyboard.feed(i);
+  }
+  /**
+   * Demo playback: called while a screen waits for a key with how many GetKey polls the
+   * DOS PC would have made meanwhile; returns recorded keys that become pending.
+   */
+  keyPoll;
+  /** Demo playback: a key-reading screen ended; returns recorded keys it must have taken. */
+  keyPollEnd;
+  /** Demo playback: one GetKey poll by a screen (tick-counted recordings); returns the recorded keys now due. */
+  keyPollOnce;
+  /** Clears keyboard input (while (GetKey(1)) GetKey(0)). */
+  flushKeys() {
+    this.keyboard.clear(), this.pointer.clicks = 0;
+  }
+  /**
+   * FadeTo: 65 retrace-synchronized steps from the current palette to `dest`. The C
+   * waited for one VGA vertical retrace (70 Hz in mode 13h) per step, hence steps/70 s;
+   * it stepped each channel Bresenham-style, which the truncated d*step/steps matches
+   * at every step.
+   */
+  async fadeTo(t, e = 65) {
+    if (e <= 0) {
+      this.screen.setPalette(t);
+      return;
+    }
+    const i = this.screen.palette.slice(), s = this.now(), o = e / 70 * 1e3;
+    for (; ; ) {
+      const r = Math.min(1, (this.now() - s) / o), h = Math.floor(r * e), a = new Uint8Array(c);
+      for (let n = 0; n < c; n++) {
+        const f = (t[n] ?? 0) - i[n];
+        a[n] = i[n] + Math.trunc(f * h / e);
+      }
+      if (this.screen.setPalette(a), r >= 1) break;
+      await this.frame();
+    }
+    this.screen.setPalette(t);
+  }
+  async fadeAllTo(t, e, i, s = 65) {
+    const o = new Uint8Array(c);
+    for (let r = 0; r < 256; r++) o.set([t, e, i], r * 3);
+    await this.fadeTo(o, s);
+  }
+}
+export {
+  k as GameAborted,
+  E as Machine
+};

package/dist/engine/menus.js

@@ -0,0 +1,135 @@
+import { STOCK_LOOK as m } from "./playerLook.js";
+import { placeFor as p, insertHighScore as b, serializeHighScores as M, parseHighScores as K } from "../formats/highscore.js";
+import { PALETTE_SIZE as F } from "../formats/palette.js";
+async function P(t, e, n, i, a, c, u = 1 / 0, r = 1, o = !0, f = 5) {
+  const s = (l) => n - 8 + l * i;
+  let w = t.screen.getCol(e, s(r));
+  o ? t.flushKeys() : t.takeClick();
+  let g = t.now();
+  for (; ; ) {
+    t.screen.boxFill(e, s(r), e + f, s(r) + 4, c);
+    const l = t.keyboard.readKey();
+    let h = 0;
+    if (t.takeClick()) {
+      const d = Math.floor((t.pointer.y - (n - 8) + i / 2) / i);
+      if (d >= 1 && d <= a)
+        return t.screen.boxFill(e, s(r), e + f, s(r) + 4, w), d;
+    }
+    if (l) {
+      if (g = t.now(), l.ascii === 13) return r;
+      if (l.ascii === 27) return 0;
+      l.scan === 72 && (h = -1), l.scan === 80 && (h = 1);
+    } else if (t.now() - g > u * 1e3) return a + 1;
+    h && (t.screen.boxFill(e, s(r), e + f, s(r) + 4, w), r += h, r < 1 && (r = a), r > a && (r = 1), w = t.screen.getCol(e, s(r))), await t.frame();
+  }
+}
+async function C(t, e, n, i, a, c, u) {
+  let r = c.slice(0, u);
+  t.screen.write(e, n, i, r), t.flushKeys();
+  const o = (f) => {
+    const s = r.length;
+    s < u ? t.screen.box(e + s * 8, n, e + (s + 1) * 8 - 2, n + 7, f) : t.screen.line(e + s * 8 - 1, n, e + s * 8 - 1, n + 7, f);
+  };
+  for (; ; ) {
+    const f = Math.floor(t.now() / 450) % 2 === 0;
+    o(f ? i : a);
+    const s = t.keyboard.readKey();
+    if (!s) {
+      await t.frame();
+      continue;
+    }
+    if (o(a), s.ascii === 27) return null;
+    if (s.ascii === 13) return r;
+    s.ascii === 8 || s.scan === 75 ? r.length && (r = r.slice(0, -1), t.screen.boxFill(e + r.length * 8, n, e + (r.length + 1) * 8 - 1, n + 7, a)) : s.ascii >= 32 && s.ascii < 256 && r.length < u && (r += String.fromCharCode(s.ascii), t.screen.write(e, n, i, r));
+  }
+}
+function H(t = Math.random) {
+  const e = new Uint8Array(F), n = 2;
+  let [i, a, c] = [0, 0, 0], [u, r, o] = [0, 0, 0];
+  const f = () => Math.floor(t() * 2);
+  for (let s = 0; s < 256; s++) {
+    if (s % (64 / n) === 0)
+      do
+        o === 0 && (o = f()), r === 0 && (r = f()), u === 0 && (u = f());
+      while (o === 0 && r === 0 && u === 0);
+    u === 1 && (i += n), r === 1 && (a += n), o === 1 && (c += n), u === 2 && (i -= n), r === 2 && (a -= n), o === 2 && (c -= n), i >= 63 && ([u, i] = [2, 63]), c >= 63 && ([o, c] = [2, 63]), a >= 63 && ([r, a] = [2, 63]), i < 0 && ([i, u] = [0, 0]), a < 0 && ([a, r] = [0, 0]), c < 0 && ([c, o] = [0, 0]), e.set([i, a, c], s * 3);
+  }
+  return e;
+}
+function Y(t, e, n = Math.random) {
+  t.screen.clear(), e.set(H(n)), t.screen.setPalette(e);
+  for (let i = 0; i <= 100; i++) t.screen.box(40 - Math.trunc(i * 4 / 10), 100 - i, 280 + Math.trunc(i * 4 / 10), 180 + Math.trunc(i * 2 / 10), i);
+}
+function y(t) {
+  return `${t}.his`;
+}
+function S(t, e) {
+  const n = t.files.get(y(e));
+  return n ? K(n) : Array.from({ length: 10 }, () => ({ score: 0, name: "" }));
+}
+function A(t, e, n, i) {
+  const a = e.color(n, "color.select.menu");
+  t.write(e.num("layout.menu.titleX"), e.num("layout.menu.titleY"), a, i);
+  for (const c of N) t.write(e.num(`layout.menu.${c}.x`), e.num(`layout.menu.${c}.y`), a, e.text(`str.menu.${c}`));
+  return a;
+}
+const N = ["play", "instructions", "storyline", "credits", "highScores", "quit"];
+function R(t) {
+  return {
+    x: t.num("layout.menu.markerX"),
+    y: t.num("layout.menu.firstY"),
+    dy: t.num("layout.menu.spacing"),
+    idle: t.seconds("timing.menu.idleSeconds"),
+    width: t.num("border.marker.width")
+  };
+}
+function _(t, e, n, i) {
+  t.write(
+    e.num("layout.menu.noFile.x"),
+    e.num("layout.menu.noFile.y"),
+    e.color(n, "color.select.menuMessages"),
+    e.text(`str.menu.${i}`)
+  );
+}
+function $(t, e, n, i, a) {
+  const c = e.color(n, "color.select.hsTitle"), u = e.color(n, "color.select.hsRows");
+  t.write(e.num("layout.hiscore.title.x"), e.num("layout.hiscore.title.y"), c, e.text("str.hiscore.title"));
+  let r = e.num("layout.hiscore.rowSpacing"), o = e.num("layout.hiscore.firstRowY");
+  const f = e.num("layout.hiscore.rows");
+  for (let s = 0; s < f; s++)
+    i[s].score !== 0 && t.write(20, o, u, `${String(i[s].score).padStart(10)} ${i[s].name}`), o += r, s % 2 === 0 && r--, r--;
+  a > 0 && t.write(20, o, u, e.format("str.hiscore.latest", a)), t.write(e.num("layout.hiscore.anyKey.x"), e.num("layout.hiscore.anyKey.y"), c, e.text("str.hiscore.anyKey"));
+}
+async function v(t, e, n, i = -1, a = m) {
+  await t.need(y(e));
+  const c = S(t, e);
+  t.screen.setPalette(n), $(t.screen, a, n, c, i), await t.pauseTimeKey(a.seconds("timing.highScores"));
+}
+function x(t, e, n, i) {
+  const a = e.color(n, "color.select.hsPrompt"), c = e.color(n, "color.select.hsName");
+  return t.write(e.num("layout.hiscore.congrats.x"), e.num("layout.hiscore.congrats.y"), a, e.text("str.hiscore.congrats")), t.write(0, 100, c, e.format("str.hiscore.place", i)), t.write(e.num("layout.hiscore.enterName.x"), e.num("layout.hiscore.enterName.y"), a, e.text("str.hiscore.enterName")), c;
+}
+async function D(t, e, n, i, a = m) {
+  await t.need(y(e));
+  const c = S(t, e), u = p(c, i);
+  let r = 0, o = c;
+  if (u >= 0) {
+    const f = x(t.screen, a, n, u + 1), s = await C(t, 136, 120, f, 0, "", 22) ?? "";
+    o = b(c, u, { score: i, name: s }), r = u + 1;
+  }
+  return t.files.set(y(e), M(o)), r;
+}
+export {
+  D as checkHighScores,
+  Y as drawDefaultScreen,
+  $ as drawHighScores,
+  A as drawMenu,
+  x as drawNewHighScore,
+  _ as drawNoFile,
+  C as gGet,
+  P as gVertMenu,
+  y as highScoreFile,
+  R as menuMarker,
+  S as readHighScores,
+  v as showHighScores
+};

package/dist/engine/monsters.js

@@ -0,0 +1,259 @@
+import { BACKBL as tr, BLEN as i, MONBL as k, TRANSPARENT as p, CHARBL as Y, SOLRIG as C, SOLLEF as R, SOLBOT as F, SOLTOP as D } from "../formats/blocks.js";
+import { LASTMON as N, LASTSL as O, ATTACKMOVEMENT as A, MAXMARCH as X, NORMALMOVEMENT as S } from "../formats/monster.js";
+import { chrFrame as cr } from "./keys.js";
+import { onscrn as or, doBlockTouchChar as nr, doSound as H, KILLSOUND as V } from "./touch.js";
+import { SCRNBLEN as _, SCRNBWID as j, mapBlock as v, MONMOVESPEED as q, random as E, mapMonAt as J, setMapMon as Q, OFFSCRN as T, CHARPOWER as er, sign as m, shownBlock as fr } from "./world.js";
+import { LASTMM as b, MWID as h, MLEN as d } from "../formats/map.js";
+const sr = { x: 0, y: 0, pic: 0, orient: 0 };
+function P(r, o, n) {
+  return n >= 0 ? r.march[o]?.[n] ?? sr : o === 1 ? r.march[0][X - 1] : { x: r.end, y: r.towards, pic: r.close[0], orient: r.close[1] };
+}
+function w(r) {
+  r.delta = { x: 0, y: 0 }, r.scrPos = { x: T, y: T }, r.oldPos = { ...r.scrPos }, r.picDrawn = !1, r.curx[1] = 0, r.cury[1] = 0, r.curPic = -1, r.offl = -1, r.offs = 0, r.curMarch = S, r.orient = 0, r.dest = 0;
+}
+function W(r, o) {
+  const n = r.mi[o];
+  if (n.curPic >= 0 && n.curPic < O) {
+    const f = r.mon[r.mm[o].monnum]?.pic[n.curPic][0] ?? k;
+    return f < k && f >= 0 ? f : k;
+  }
+  return k;
+}
+function ir(r, o) {
+  const n = or(r, o.curx[0], o.cury[0], o.scrPos);
+  return n && (o.scrPos.x += o.curx[1], o.scrPos.y += o.cury[1]), n;
+}
+function I(r, o, n) {
+  let c = o - r.curx[0], f = n - r.cury[0];
+  c > d / 2 && (c -= d), c < -d / 2 && (c += d), f > h / 2 && (f -= h), f < -h / 2 && (f += h), r.delta = { x: c * i, y: f * i };
+}
+function B(r, o) {
+  const n = { x: 0, y: 0 }, c = Math.abs(r.delta.x), f = Math.abs(r.delta.y);
+  if (c >= f)
+    for (let e = 0; e < o; e++) {
+      if (r.offl >= c) {
+        r.offl = -1;
+        break;
+      }
+      r.offl++, n.x += m(r.delta.x), r.offs += f, r.offs >= c && (r.offs -= c, n.y += m(r.delta.y));
+    }
+  else
+    for (let e = 0; e < o; e++) {
+      if (r.offl >= f) {
+        r.offl = -1;
+        break;
+      }
+      r.offl++, r.offs += c, n.y += m(r.delta.y), r.offs >= f && (r.offs -= f, n.x += m(r.delta.x));
+    }
+  return n;
+}
+function z(r) {
+  r.y < 0 ? r.y += h : r.y >= h && (r.y -= h), r.x < 0 ? r.x += d : r.x >= d && (r.x -= d);
+}
+const L = (r, o, n) => fr(r, v(r, o, n)).solid;
+function Z(r, o, n, c) {
+  let f, e;
+  o.curx[1] + n.x < 0 ? (c.x--, f = C, e = 1) : (c.x++, f = R, e = 3), z(c);
+  let t = L(r, c.x, c.y);
+  return o.cury[1] + n.y > i / 4 && (t |= L(r, c.x, (c.y + 1) % h)), o.cury[1] + n.y < -i / 4 && (t |= L(r, c.x, (c.y - 1 + h) % h)), t & f ? (n.x = -o.curx[1], c.x += e === 1 ? 1 : -1, !0) : !1;
+}
+function $(r, o, n, c) {
+  let f, e;
+  o.cury[1] + n.y < 0 ? (c.y--, f = F, e = 1) : (c.y++, f = D, e = 3), z(c);
+  let t = L(r, c.x, c.y);
+  return o.curx[1] + n.x > i / 4 && (t |= L(r, (c.x + 1) % d, c.y)), o.curx[1] + n.x < -i / 4 && (t |= L(r, (c.x - 1 + d) % d, c.y)), t & f ? (n.y = -o.cury[1], c.y += e === 1 ? 1 : -1, !0) : !1;
+}
+function ur(r, o, n) {
+  const c = { x: o.curx[0], y: o.cury[0] };
+  let f = !1;
+  return Math.abs(n.x) > Math.abs(n.y) ? (f = Z(r, o, n, c) || f, n.y && (f = $(r, o, n, c) || f)) : (n.y && (f = $(r, o, n, c) || f), n.x && (f = Z(r, o, n, c) || f)), f;
+}
+function lr(r, o) {
+  const n = r.mi[o];
+  return Math.abs(n.curx[0] - r.chr.x[0]) < r.tune.attackX && Math.abs(n.cury[0] - r.chr.y[0]) < r.tune.attackY;
+}
+function G(r, o, n, c, f) {
+  if (o >= b) {
+    let e = r.firstEmptyMM;
+    for (let t = 0; t <= b; t++) {
+      if (e >= 0 && e < b && r.mm[e].monnum === N) {
+        o = e;
+        break;
+      }
+      e++, e >= b && (e = 0);
+    }
+    r.firstEmptyMM = Math.max(0, e);
+  }
+  if (o < b && o >= 0) {
+    r.mm[o].monnum = n & 255;
+    const e = r.mi[o];
+    return e.birthTime = r.clock, e.nextAni = r.clock, e.nextMove = r.clock, e.curx[0] = c, e.cury[0] = f, e.target = { x: c, y: f }, o;
+  }
+  return b;
+}
+function g(r, o) {
+  const n = r.mon[r.mm[o].monnum];
+  if (!n || n.end === -2) return !1;
+  if (n.newmon === N || n.newmon < 0)
+    return r.mm[o].monnum = N, o < r.firstEmptyMM && (r.firstEmptyMM = Math.max(0, o - 1)), !0;
+  const c = r.mi[o];
+  return G(r, o, n.newmon, c.curx[0], c.cury[0]), c.offl = -1, c.curMarch = S, c.dest = 0, c.curPic = 0, c.fromchar > 0 && c.fromchar++, !1;
+}
+function gr(r) {
+  r.birthFlag.fill(0);
+  for (const o of r.blkMon)
+    o.nexttime <= r.clock && (o.nexttime += r.bg[o.blnum].birthTime, r.birthFlag[o.blnum] = 1);
+  for (let o = r.mx - _ / 2; o < r.mx + _ * 3 / 2; o++)
+    for (let n = r.my - j / 2; n < r.my + j * 3 / 2; n++) {
+      const c = (o + d) % d, f = (n + h) % h, e = r.blkmap[v(r, c, f)] ?? tr;
+      if (!r.birthFlag[e]) continue;
+      const t = G(r, b, r.bg[e].birthMon, c, f);
+      t < b && (r.mi[t].fromchar = 0, w(r.mi[t]));
+    }
+}
+function Pr(r, o, n, c) {
+  const f = G(r, b, c, o, n);
+  if (f >= b) return;
+  const e = r.mi[f];
+  w(e), e.fromchar = 1, e.curx[1] = r.chr.x[1], e.cury[1] = r.chr.y[1], e.offl = -1;
+  const t = r.mon[c & 255];
+  if (t && t.towards < 64) {
+    const { netx: u, nety: x } = r.ci;
+    e.delta = { x: u * i, y: x * i }, Math.abs(u) - Math.abs(x) > 0 ? e.orient = u < 0 ? 4 : 0 : e.orient = x < 0 ? 3 : 1;
+  }
+}
+function ar(r, o, n) {
+  const c = r.mi[o], f = r.mon[n];
+  if (c.dest === X || P(f, c.curMarch, c.dest).pic === 0) {
+    if (f.end === -1 && c.curMarch === S && g(r, o)) return !0;
+    c.dest = 0, c.curMarch = S;
+  }
+  const e = P(f, c.curMarch, c.dest), t = { x: e.x + c.curx[0], y: e.y + c.cury[0] };
+  if (c.dest !== 0) {
+    const u = P(f, c.curMarch, c.dest - 1);
+    t.x -= u.x, t.y -= u.y;
+  }
+  return c.orient = e.orient, z(t), c.target = t, I(c, t.x, t.y), c.offl = 0, c.offs = 0, c.dest++, !1;
+}
+function K(r, o, n, c, f, e) {
+  const t = Math.abs(c - r), u = Math.abs(f - o);
+  if (c -= t, r -= t, f -= u, o -= u, t > i || u > i) return !1;
+  const x = (l) => l >= 0 && l < n.length ? n[l] : p, M = (l) => l >= 0 && l < e.length ? e[l] : p;
+  let s, a;
+  if (c >= r && f >= o) {
+    s = i * u, a = 0;
+    for (let l = 0; l < o + i - f; l++) {
+      s += t;
+      for (let y = 0; y < r + i - c; y++, s++, a++) if (x(s) !== p && M(a) !== p) return !0;
+      a += t;
+    }
+    return !1;
+  }
+  if (c >= r && f <= o) {
+    s = 0, a = u * i;
+    for (let l = 0; l < f + i - o; l++) {
+      s += t;
+      for (let y = 0; y < r + i - c; y++, s++, a++) if (x(s) !== p && M(a) !== p) return !0;
+      a += t;
+    }
+    return !1;
+  }
+  if (c <= r && f >= o) {
+    a = 0, s = u * i;
+    for (let l = 0; l < o + i - f; l++) {
+      a += t;
+      for (let y = 0; y < c + i - r; y++, s++, a++) if (x(s) !== p && M(a) !== p) return !0;
+      s += t;
+    }
+    return !1;
+  }
+  a = i * u, s = 0;
+  for (let l = 0; l < f + i - o; l++) {
+    a += t;
+    for (let y = 0; y < c + i - r; y++, s++, a++) if (x(s) !== p && M(a) !== p) return !0;
+    s += t;
+  }
+  return !1;
+}
+function xr(r, o) {
+  const n = r.mi[o], { ci: c } = r;
+  if (n.scrPos.x === T) return !1;
+  const f = Math.min(n.scrPos.x, c.scrx), e = Math.min(n.scrPos.y, c.scry), t = { x: c.scrx - f, y: c.scry - e }, u = { x: n.scrPos.x - f, y: n.scrPos.y - e }, x = { x: Math.max(t.x, u.x), y: Math.max(t.y, u.y) };
+  let M = !1;
+  if (u.x <= t.x + i && u.x + i >= t.x && u.y <= t.y + i && u.y + i * 2 >= t.y) {
+    let s = W(r, o);
+    if (s >= k) return !1;
+    const a = cr(r), l = r.mblk[s].pixels;
+    a.pic2 < Y && (M = K(t.x, t.y, r.cblk[a.pic2].pixels, u.x, u.y, l)), a.pic1 < Y && (M = K(t.x, t.y, r.cblk[a.pic1].pixels, u.x, u.y + i, l) || M), M && (s = r.mblk[s].solid, s > 0 && (x.x >= x.y ? r.monsolid |= t.x === 0 ? C & s : R & s : r.monsolid |= t.y === 0 ? F & s : D & s, r.mmSolid = o)), r.monsolid & C && r.monsolid & R && (r.monsolid |= t.y === 0 ? F & s : D & s), r.monsolid & F && r.monsolid & D && (r.monsolid |= t.x === 0 ? C & s : R & s);
+  }
+  return M;
+}
+function yr(r, o, n, c) {
+  const f = r.mm[o].monnum, e = r.mm[n].monnum;
+  if (f >= N || e >= N) return n;
+  const t = r.mon[f], u = r.mon[e];
+  if (t.power === u.power) return n;
+  const x = c & 1 ? i : 0, M = c & 2 ? i : 0, s = W(r, o);
+  if (s >= k) return n;
+  const a = W(r, n);
+  if (a >= k) return o;
+  const l = r.mi[o], y = r.mi[n];
+  return K(l.curx[1] + x, l.cury[1] + M, r.mblk[s].pixels, y.curx[1], y.cury[1], r.mblk[a].pixels) ? t.power < u.power ? (g(r, o), y.fromchar > 0 ? (r.ci.score += t.upscore, H(r, V), g(r, n), b) : n) : (g(r, n), l.fromchar > 0 ? (r.ci.score += u.upscore, H(r, V), g(r, o), b) : o) : n;
+}
+function Ar(r) {
+  const { clock: o, chr: n } = r;
+  for (let c = 0; c < b; c++) {
+    const f = r.mm[c].monnum;
+    if (f >= N) continue;
+    const e = r.mon[f], t = r.mi[c];
+    if (!e || (o >= t.nextAni && (t.curPic++, (t.curPic >= O || e.pic[t.curPic][0] >= k) && (t.curPic = e.pic[0][0] < k ? 0 : O), t.nextAni = t.curPic < O ? o + e.pic[t.curPic][1] : o + 1e5), o < t.nextMove)) continue;
+    const u = Math.trunc((o - t.nextMove + 1) / q);
+    t.nextMove = o + q, e.activate !== 0 && t.curMarch !== A && lr(r, c) && (t.curMarch = A, t.dest = 1);
+    let x;
+    if (t.curMarch === A && e.activate === 2) {
+      const l = P(e, A, t.dest);
+      t.target = { x: (l.x + n.x[0] + d) % d, y: (l.y + n.y[0] + h) % h }, I(t, t.target.x, t.target.y), t.offl = 0, x = B(t, l.pic * u), t.offl === -1 && (t.dest++, t.offs = 0, t.dest === X || P(e, A, t.dest).pic === 0 ? (t.curMarch = S, t.dest = 0) : t.orient = P(e, A, t.dest).orient);
+    } else if (e.towards === 0) {
+      if (t.offl === -1 && ar(r, c, f)) continue;
+      x = B(t, P(e, t.curMarch, t.dest - 1).pic * u);
+    } else e.towards < 64 ? (t.fromchar || (I(t, n.x[0], n.y[0]), t.delta.x += n.x[1] - t.curx[1], t.delta.y += n.y[1] - t.cury[1], e.towards < 0 && (t.delta = { x: -t.delta.x, y: -t.delta.y }), t.delta.x < 0 ? t.orient |= 4 : t.orient = 0), x = B(t, Math.abs(e.towards) * u)) : (t.curx[0] === t.target.x && t.cury[0] === t.target.y && (E(r, 2) ? t.target.x = (t.target.x + E(r, 7) + 5) % d : (t.target.x -= E(r, 7) + 5, t.target.x < 0 && (t.target.x += d)), E(r, 2) ? t.target.y = (t.target.y + E(r, 7) + 5) % h : (t.target.y -= E(r, 7) + 5, t.target.y < 0 && (t.target.y += h)), I(t, t.target.x, t.target.y), t.offl = 0, t.offs = 0), x = B(t, (e.towards >> 6) * u));
+    if (e.thru && ur(r, t, x) && t.fromchar > 0 && g(r, c)) continue;
+    for (x.x === 0 && x.y === 0 ? t.target = { x: t.curx[0], y: t.cury[0] } : (t.curx[1] += x.x, t.cury[1] += x.y), J(r, t.curx[0], t.cury[0]) === c && Q(r, t.curx[0], t.cury[0], b); t.curx[1] >= i; )
+      t.curx[1] -= i, t.curx[0]++;
+    for (; t.curx[1] < 0; )
+      t.curx[1] += i, t.curx[0]--;
+    for (; t.cury[1] >= i; )
+      t.cury[1] -= i, t.cury[0]++;
+    for (; t.cury[1] < 0; )
+      t.cury[1] += i, t.cury[0]--;
+    if (t.curx[0] < 0 && (t.curx[0] += d), t.cury[0] < 0 && (t.cury[0] += h), t.curx[0] >= d && (t.curx[0] -= d), t.cury[0] >= h && (t.cury[0] -= h), ir(r, t) || (t.scrPos = { x: T, y: T }), t.curPic >= 0 && t.curPic < O && xr(r, c) && t.fromchar !== 1) {
+      const l = W(r, c), y = nr(r, r.mblk[l]) - 1;
+      if (r.mon[r.mm[c].monnum]?.power < er && g(r, c)) {
+        y || H(r, V);
+        continue;
+      }
+    }
+    let M = c;
+    const s = t.curx[0], a = t.cury[0];
+    for (const [l, y, rr] of [
+      [0, 0, 0],
+      [1, 0, 1],
+      [1, 1, 3],
+      [0, 1, 2]
+    ]) {
+      const U = J(r, s + l, a + y);
+      U < b && (M = yr(r, U, c, rr));
+    }
+    M < b && Q(r, r.mi[M].curx[0], r.mi[M].cury[0], M), e.end > 0 && t.birthTime + e.end <= o && g(r, c);
+  }
+}
+export {
+  G as birthMon,
+  gr as blockBirthMonsters,
+  ir as calcDraw,
+  Pr as charBirthMon,
+  W as monPicNum,
+  Ar as moveAllMonsters,
+  K as picChkTouch,
+  w as resetMonInfo
+};

package/dist/engine/playGain.js

@@ -0,0 +1,10 @@
+const t = () => ({ banked: 0, base: 0 });
+function b(a, n, e) {
+  a.banked += Math.max(0, n - a.base), a.base = e;
+}
+const s = (a, n) => a.banked + Math.max(0, n - a.base);
+export {
+  s as gainAtEnd,
+  b as gainAtLoad,
+  t as newPlayGain
+};

package/dist/engine/playerLook.js

@@ -0,0 +1,48 @@
+import { matchColor as p } from "../formats/palette.js";
+import { PATCHES as i } from "../player/patchTable.js";
+import { cleanPatches as l } from "../player/patchRules.js";
+import { STOCK_TUNING as d } from "./world.js";
+const m = new Map(i.map((o) => [o.id, o]));
+function k(o, e) {
+  let c = 0;
+  return o.replace(/%([-0]*)(\d*)l?([ds])/g, (n, s, t, r) => {
+    const f = e[c++], a = String(r === "d" ? Math.trunc(Number(f)) : f), u = Number(t || 0);
+    return s.includes("-") ? a.padEnd(u) : s.includes("0") && r === "d" ? a.padStart(u, "0") : a.padStart(u);
+  });
+}
+function y(o, e) {
+  const c = l(o), n = (t) => {
+    const r = m.get(t);
+    if (!r) throw new Error(`No player patch ${t}`);
+    return c[t] ?? (r.kind === "fkey" ? "on" : r.stock);
+  }, s = (t) => n(t);
+  return {
+    text: (t) => n(t),
+    format: (t, ...r) => k(n(t), r),
+    color: (t, r) => {
+      const [f, a, u] = s(`color.rgb.${n(r)}`);
+      return p(t, f, a, u);
+    },
+    rgb: s,
+    frame: (t) => n(t),
+    num: (t) => n(t),
+    seconds: (t) => {
+      const r = n(t);
+      return r < 0 ? r & 65535 : r;
+    },
+    fkeyOn: (t) => !m.has(`table.fkeys.F${t}`) || n(`table.fkeys.F${t}`) !== "off",
+    ...e ? { about: e } : {}
+  };
+}
+function O(o) {
+  const e = {};
+  for (const c of Object.keys(d)) e[c] = o.num(`play.${c}`);
+  return e;
+}
+const N = y();
+export {
+  N as STOCK_LOOK,
+  O as playTuning,
+  y as playerLook,
+  k as sprintf
+};