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

package/dist/engine/slowPc.js

@@ -0,0 +1,98 @@
+const i = {
+  tickMs: 15,
+  monsterMs: 1.2,
+  scrollPassMs: 2.5,
+  stripMs: 1.5
+};
+class c {
+  constructor(t) {
+    this.interruptMs = t;
+  }
+  interruptMs;
+  /** Milliseconds of work still running. */
+  owed = 0;
+  /**
+   * Called once per NewTimer interrupt: true when the PC is still busy with earlier work
+   * and this interrupt's pass of the main loop (scroll step, game tick) is lost.
+   */
+  busy() {
+    return this.owed >= this.interruptMs ? (this.owed -= this.interruptMs, !0) : (this.owed = 0, !1);
+  }
+  spend(t) {
+    this.owed += t;
+  }
+  reset() {
+    this.owed = 0;
+  }
+}
+function l(s, t, e = 0) {
+  return s.tickMs + s.monsterMs * t + (s.cellMs ?? 0) * Math.min(e, 170);
+}
+function u(s, t) {
+  return s.scrollPassMs + s.stripMs * t;
+}
+const v = ["today", "486", "386", "286", "ps1"], n = {
+  // 286 at 12 MHz, IDE disk about 400 KB/s, 30 ms to open a file; 20 monsters fill a tick
+  // (sourced range for a 286-era MFM or early IDE drive: about 220-550 KB/s, 30-75 ms an open)
+  286: { tickMs: 20, monsterMs: 1.8, scrollPassMs: 3.3, stripMs: 2, cellMs: 0.25, vocOpenMs: 30, vocBytesPerMs: 400, ...o(0.035, 0.033) },
+  // 386DX-33, disk about 800 KB/s, 18 ms to open
+  386: { tickMs: 9, monsterMs: 0.8, scrollPassMs: 1.5, stripMs: 0.8, cellMs: 0.12, vocOpenMs: 18, vocBytesPerMs: 800, ...o(0.016, 0.015) },
+  // 486DX2-66, disk about 1.5 MB/s, 12 ms to open
+  486: { tickMs: 4, monsterMs: 0.35, scrollPassMs: 0.7, stripMs: 0.4, cellMs: 0.05, vocOpenMs: 12, vocBytesPerMs: 1500, ...o(7e-3, 6e-3) },
+  // IBM PS/1 Model 2011: a 286 at 10 MHz (the 286-12's CPU costs times 1.2), 1 MB, a small slow hard disk
+  // (about 80 ms to find a file and about 150 KB/s after that), no disk cache, no EMS. PLAYGAME reads a
+  // .voc whole from the disk every time it plays one and keeps nothing between plays, so the cache a
+  // roomier PC might have added never helps here; the extra 384 KB above 640 KB is out of PLAYGAME's reach.
+  // The disk is the 2011's 30 MB WDL-330P (IBM PS/1 Technical Reference 57F1970, p. 8-26): 19 ms average
+  // access, 3600 rpm, 33 sectors a track at a 4:1 interleave, so at most about 247 KB/s; 80 ms and 150 KB/s
+  // are the slow end of what that gives with an uncached directory and fragmented files (range 30-90 ms,
+  // 145-245 KB/s). Estimates, not timed on a real PS/1 or in an emulator.
+  // DOS 4 lives in the PS/1's ROM, so only its data takes conventional memory (about 45 KB more for the
+  // game than a DOS loaded from disk): about 145 KB of the far heap is left once DOS's data, drivers and
+  // the game's own data have their share.
+  ps1: {
+    tickMs: 24,
+    monsterMs: 2.2,
+    scrollPassMs: 4,
+    stripMs: 2.4,
+    cellMs: 0.3,
+    vocOpenMs: 80,
+    vocBytesPerMs: 150,
+    vocHeapBytes: 145e3,
+    ...o(0.042, 0.04)
+  }
+};
+function o(s, t) {
+  return { readHoldsMusic: !1, isrMs: s, fmEventMs: t, fmWriteMs: 0.03 };
+}
+function a(s) {
+  return s === "today" ? void 0 : n[s];
+}
+function d(s, t) {
+  return M(s, t) ? s.vocOpenMs ?? 0 : !s || s.vocOpenMs === void 0 || !s.vocBytesPerMs ? 0 : s.vocOpenMs + t / s.vocBytesPerMs;
+}
+function f(s, t) {
+  return s?.readHoldsMusic ? t : 0;
+}
+function M(s, t) {
+  return !!s && s.vocHeapBytes !== void 0 && t > s.vocHeapBytes;
+}
+function P(s, t) {
+  if (!s || s.vocOpenMs === void 0 || !s.vocBytesPerMs) return 0;
+  let e = 0;
+  for (const r of t) e += s.vocOpenMs + r / s.vocBytesPerMs;
+  return e;
+}
+export {
+  v as SPEED_CHOICES,
+  n as SPEED_PRESETS,
+  c as SlowCpu,
+  i as TURBO_OFF,
+  a as costsFor,
+  f as musicHoldMs,
+  P as sceneLoadMs,
+  u as scrollCost,
+  l as tickCost,
+  d as vocStallMs,
+  M as vocWontFit
+};

package/dist/engine/slowPcMusic.js

@@ -0,0 +1,46 @@
+import { loadSong as v } from "../audio/cmfLoad.js";
+import { TICK_RATE as p } from "../audio/cmfPlayer.js";
+const o = { on: 4, off: 1, program: 11 };
+function E(s) {
+  const e = v(s)?.music;
+  if (!e) return;
+  let n = 0;
+  const a = () => {
+    let t = 0, r;
+    do
+      r = e[n++] ?? 0, t = t * 128 + (r & 127);
+    while (r & 128 && n < e.length);
+    return t;
+  };
+  a();
+  const i = { interrupts: 0, events: 0, writes: 0, peakEvents: 0, peakWrites: 0 };
+  let l = 128, f = 0, u = 0;
+  const m = () => {
+    i.peakEvents = Math.max(i.peakEvents, f), i.peakWrites = Math.max(i.peakWrites, u), f = u = 0;
+  };
+  for (; n < e.length; ) {
+    e[n] & 128 && (l = e[n++]);
+    const t = l & 240;
+    let r = 0;
+    if (t === 144 ? r = e[n + 1] ? o.on : o.off : t === 128 ? r = o.off : t === 192 && (r = o.program), t === 128 || t === 144 || t === 160 || t === 176 || t === 224) n += 2;
+    else if (t === 192 || t === 208) n += 1;
+    else break;
+    r && (f++, u += r, i.events++, i.writes += r);
+    const M = a();
+    M && m(), i.interrupts += M;
+  }
+  return m(), i;
+}
+function g(s, e) {
+  return s?.isrMs ? !e || !e.interrupts ? s.isrMs : s.isrMs + (e.events * (s.fmEventMs ?? 0) + e.writes * (s.fmWriteMs ?? 0)) / e.interrupts : 0;
+}
+function h(s, e) {
+  return (s.isrMs ?? 0) + e.peakEvents * (s.fmEventMs ?? 0) + e.peakWrites * (s.fmWriteMs ?? 0);
+}
+const w = 1e3 / p;
+export {
+  w as INTERRUPT_MS,
+  g as songIsrMs,
+  E as songLoad,
+  h as songPeakIsrMs
+};

package/dist/engine/touch.js

@@ -0,0 +1,61 @@
+import { MAXSEQ as x, DIESEQ as E, INF_REPEAT as r, HURTSEQ as h } from "../formats/character.js";
+import { pushKey as B } from "./keys.js";
+import { i16 as S, u16 as N, mapBlock as U } from "./world.js";
+import { BACKBL as l, BLEN as p } from "../formats/blocks.js";
+import { LASTSND as O } from "../formats/sound.js";
+import { MLEN as m, MWID as a } from "../formats/map.js";
+const A = 0, X = 1, d = 2, P = 3, T = 4, q = 5, H = 6, L = 7, g = 8;
+function i(t, e) {
+  return e >= 0 && e < O ? t.sound.play(e) : !1;
+}
+function R(t) {
+  return t.x >= 1 && t.y >= 1 && t.x <= 320 - p && t.y <= 200 - p;
+}
+function C(t, e, c, f) {
+  return f.x = e - t.mx, t.mx > e && (f.x += m), f.x = f.x * p - t.scroll.nx, f.y = c - t.my, t.my > c && (f.y += a), f.y = f.y * p - t.scroll.ny, R(f);
+}
+function I(t) {
+  const { chr: e, ci: c } = t, f = { blks: Array.from({ length: 6 }, () => [m, a]), blknum: new Array(6).fill(l) }, o = (u, D, y) => {
+    f.blks[u] = [D, y], f.blknum[u] = t.blkmap[U(t, D, y)] ?? l;
+  }, s = e.x[0], n = e.y[0];
+  if (c.topthere) {
+    const u = n - 1 < 0 ? n - 1 + a : n - 1;
+    o(0, s, u), e.x[1] > 0 && o(1, (s + 1) % m, u);
+  }
+  return o(2, s, n), e.x[1] > 0 && o(3, (s + 1) % m, n), e.y[1] > 0 && o(4, s, (n + 1) % a), e.x[1] > 0 && e.y[1] > 0 && o(5, (s + 1) % m, (n + 1) % a), f;
+}
+function _(t, e, c) {
+  for (let f = 0; f < x; f++) t.chr.sequences[f].bloc === e && (t.ci.seqon[f] = c);
+}
+function M(t, e) {
+  const { ci: c, chr: f } = t;
+  let o = !1;
+  if ((e.effect >= 20 || e.effect === 3) && c.meter[e.effect] + e.eamt <= 0) return 0;
+  if (f.cseq !== E && (e.chHitPt <= 0 ? c.hitpts = S(c.hitpts + e.chHitPt) : N(c.hitpts + e.chHitPt) < r ? c.hitpts = S(c.hitpts + e.chHitPt) : c.hitpts = r - 1, e.chHitPt > 0 ? o = i(t, A) : e.chHitPt < 0 && f.cseq !== h && (B(t), c.nextAni = t.clock, f.cseq = h, f.cframe = -1, t.curkey = 255, f.sequences[h].sound < O && f.sequences[h].sound >= 0 && (o = i(t, f.sequences[h].sound))), c.hitpts <= 0 && (c.nextAni = t.clock, f.cseq = E, f.cframe = -1, t.curkey = 0)), e.effect === 1 && (e.eamt > 0 && (o = i(t, T)), c.lives = S(c.lives + e.eamt)), e.effect > 2 && c.meter[e.effect] !== r && e.effect < c.meter.length) {
+    o || (e.effect === 3 ? e.eamt > 0 ? o = i(t, d) : e.eamt < 0 && (o = i(t, P)) : e.eamt > 0 ? o = i(t, L) : e.eamt < 0 && (o = i(t, g)));
+    const s = c.meter[e.effect];
+    N(s + e.eamt) < r ? s + e.eamt < -1 * (r - 128) ? c.meter[e.effect] = -1 * (r - 128) : c.meter[e.effect] = S(s + e.eamt) : c.meter[e.effect] = r - 1;
+  }
+  return c.score += e.scorePts, o || (e.scorePts > 0 ? o = i(t, q) : e.scorePts < 0 && (o = i(t, H))), o ? 2 : 1;
+}
+function F(t, e, c, f) {
+  if (e === m) return 1;
+  const o = t.bg[f] ?? t.bg[l];
+  return M(t, o) ? ((f !== o.touchBl || o.obj) && t.onTouched?.(e, c, f), f !== o.touchBl && C(t, e, c, { x: 0, y: 0 }) && (t.map[c * m + e] = o.touchBl), 1) : 2;
+}
+function z(t) {
+  const e = I(t);
+  for (let c = 0; c < 6; c++)
+    (t.bg[e.blknum[c]] ?? t.bg[l]).obj || F(t, e.blks[c][0], e.blks[c][1], e.blknum[c]);
+}
+export {
+  X as KILLSOUND,
+  _ as checkSeqForTie,
+  z as checkTouch,
+  M as doBlockTouchChar,
+  i as doSound,
+  I as getTouchBlocks,
+  R as inScreenBounds,
+  C as onscrn,
+  F as reallyCheckTouch
+};

package/dist/engine/world.js

@@ -0,0 +1,205 @@
+import { BACKBL as c, CHARBL as i, emptyBlock as u, MONBL as p } from "../formats/blocks.js";
+import { BLEN as $ } from "../formats/blocks.js";
+import { MAXSEQ as y, METERS as S, MAXINV as x } from "../formats/character.js";
+import { INF_REPEAT as ot } from "../formats/character.js";
+import { LASTMON as rt } from "../formats/monster.js";
+import { LASTMM as a, MLEN as M } from "../formats/map.js";
+import { MWID as ct } from "../formats/map.js";
+import { LASTSND as st } from "../formats/sound.js";
+const X = 320, I = 200, d = 20, f = 11, L = 16, w = 10, A = 1, P = 1, Y = 1, h = 8, g = 5, e = -100, k = 40, E = 40, b = 6, D = 50, K = 100, V = 4294967295, N = Object.freeze({
+  maxSpeed: f,
+  gravityCap: f * 4,
+  gravityTicks: A,
+  attackX: h,
+  attackY: g,
+  scrollSpeedX: k,
+  scrollSpeedY: E,
+  scrollSteps: b,
+  fadeSteps: 65
+});
+function C() {
+  return {
+    score: 0,
+    update: !1,
+    topthere: !1,
+    bottomthere: !1,
+    curtop: i,
+    curbottom: i,
+    nextx: e,
+    nexty: e,
+    scrx: e,
+    scry: e,
+    oldx: e,
+    oldy: e,
+    netx: 5,
+    nety: 0,
+    gravx: 0,
+    gravy: 0,
+    hitpts: -1,
+    lives: -1,
+    nextAni: 0,
+    inv: new Array(x).fill(c + 1),
+    meter: new Array(S).fill(-1),
+    seqon: new Array(y).fill(!1)
+  };
+}
+function O() {
+  return {
+    fromchar: 0,
+    delta: { x: 0, y: 0 },
+    curx: [0, 0],
+    cury: [0, 0],
+    target: { x: 0, y: 0 },
+    offl: -1,
+    offs: 0,
+    curMarch: 0,
+    curPic: -1,
+    orient: 0,
+    picDrawn: !1,
+    scrPos: { x: e, y: e },
+    oldPos: { x: e, y: e },
+    dest: 0,
+    nextAni: 0,
+    nextMove: 0,
+    birthTime: 0
+  };
+}
+function R() {
+  return {
+    nx: 0,
+    ny: 0,
+    totalx: 0,
+    totaly: 0,
+    distx: 0,
+    disty: 0,
+    inMotion: 0,
+    maxX: 0,
+    maxY: 0,
+    minX: 0,
+    minY: 0,
+    leftStop: 0,
+    rightStop: 0,
+    upStop: 0,
+    downStop: 0,
+    movx: 0,
+    movy: 0,
+    littleShiftx: 0,
+    littleShifty: 0,
+    up: 0,
+    down: 0,
+    left: 0,
+    right: 0,
+    bx: { dscroll: 0, ctr: 0, iters: 0 },
+    by: { dscroll: 0, ctr: 0, iters: 0 }
+  };
+}
+function s(t, o) {
+  const n = (t ?? []).slice(0, o);
+  for (; n.length < o + 1; ) n.push(u(n.length, !0));
+  return n;
+}
+function m(t, o) {
+  return o * M + t;
+}
+function U(t, o, n) {
+  return t.map[m(o, n)] ?? 0;
+}
+function W(t, o, n) {
+  const r = m(o, n);
+  return r >= 0 && r < t.mapMon.length ? t.mapMon[r] : a;
+}
+function j(t, o, n, r) {
+  const l = m(o, n);
+  l >= 0 && l < t.mapMon.length && (t.mapMon[l] = r);
+}
+function F(t, o) {
+  return t.bg[t.blkmap[o] ?? o] ?? t.bg[c];
+}
+function G(t, o) {
+  return t.bg[o] ?? t.bg[c];
+}
+function H(t, o, n = Math.random) {
+  return {
+    // 256 VGA colors x 3 (r, g, b), each 0..63.
+    palette: new Uint8Array(768),
+    map: t.blocks.slice(),
+    mapMon: t.mons.slice(),
+    bg: s(void 0, c),
+    mblk: s(void 0, p),
+    cblk: s(void 0, i),
+    mon: [],
+    chr: void 0,
+    noMons: !1,
+    ci: C(),
+    mi: Array.from({ length: a }, O),
+    mm: t.monsters.map((r) => ({ monnum: r.monnum, curx: r.curx, cury: r.cury })),
+    firstEmptyMM: 0,
+    monsolid: 0,
+    mmSolid: a,
+    blkMon: [],
+    birthFlag: new Uint8Array(c + 1),
+    nxtchg: new Array(c).fill(0),
+    blkmap: Uint8Array.from({ length: c }, (r, l) => l),
+    mx: 0,
+    my: 0,
+    scroll: R(),
+    clock: 1,
+    keydn: new Uint8Array(128),
+    keystack: Array.from({ length: d + 1 }, () => ({ key: 255, seq: 0, frame: 0 })),
+    keystkptr: 0,
+    curkey: 0,
+    gclk: 1,
+    joyOldTime: 1,
+    joyOldBut: 0,
+    sound: o,
+    rand: n,
+    jstickOn: !0,
+    tune: N
+  };
+}
+const _ = (t, o) => Math.floor(t.rand() * o), q = (t) => t > 0 ? 1 : t < 0 ? -1 : 0, Z = (t) => t << 16 >> 16, z = (t) => t & 65535;
+export {
+  h as ATTACKX,
+  g as ATTACKY,
+  c as BACKBL,
+  $ as BLEN,
+  i as CHARBL,
+  K as CHARPOWER,
+  A as GRAVSPEED,
+  ot as INF_REPEAT,
+  Y as JSTICKKEY,
+  a as LASTMM,
+  rt as LASTMON,
+  st as LASTSND,
+  f as MAXGRAV,
+  x as MAXINV,
+  d as MAXKEYS,
+  D as MAXMONSSHOWN,
+  y as MAXSEQ,
+  M as MLEN,
+  p as MONBL,
+  P as MONMOVESPEED,
+  ct as MWID,
+  V as NEVER,
+  e as OFFSCRN,
+  L as SCRNBLEN,
+  w as SCRNBWID,
+  b as SCROLLPERMOVE,
+  k as SCRSPDX,
+  E as SCRSPDY,
+  X as SIZEX,
+  I as SIZEY,
+  N as STOCK_TUNING,
+  G as bgBlock,
+  H as createWorld,
+  Z as i16,
+  U as mapBlock,
+  W as mapMonAt,
+  C as newCharInfo,
+  s as padBlocks,
+  _ as random,
+  j as setMapMon,
+  F as shownBlock,
+  q as sign,
+  z as u16
+};

package/dist/formats/binary.js

@@ -0,0 +1,120 @@
+const n = new TextDecoder("latin1");
+class h {
+  bytes;
+  offset;
+  constructor(t, s = 0) {
+    this.bytes = t, this.offset = s;
+  }
+  get length() {
+    return this.bytes.length;
+  }
+  get eof() {
+    return this.offset >= this.bytes.length;
+  }
+  skip(t) {
+    return this.offset += t, this;
+  }
+  u8() {
+    const t = this.offset < this.bytes.length ? this.bytes[this.offset] : 0;
+    return this.offset++, t;
+  }
+  i8() {
+    const t = this.u8();
+    return t > 127 ? t - 256 : t;
+  }
+  u16() {
+    return this.u8() | this.u8() << 8;
+  }
+  i16() {
+    const t = this.u16();
+    return t > 32767 ? t - 65536 : t;
+  }
+  u32() {
+    return (this.u16() | this.u16() << 16) >>> 0;
+  }
+  i32() {
+    return this.u16() | this.u16() << 16;
+  }
+  /** Copies n bytes (zero padded when the source is short). */
+  bytesOf(t) {
+    const s = new Uint8Array(t), e = Math.max(0, Math.min(t, this.bytes.length - this.offset));
+    return e > 0 && s.set(this.bytes.subarray(this.offset, this.offset + e)), this.offset += t, s;
+  }
+  /** Reads a fixed size, NUL terminated string field. */
+  cstr(t) {
+    return u(this.bytesOf(t));
+  }
+}
+class f {
+  buf;
+  offset = 0;
+  constructor(t = 1024) {
+    this.buf = new Uint8Array(t);
+  }
+  ensure(t) {
+    if (this.offset + t <= this.buf.length) return;
+    let s = this.buf.length * 2;
+    for (; s < this.offset + t; ) s *= 2;
+    const e = new Uint8Array(s);
+    e.set(this.buf), this.buf = e;
+  }
+  u8(t) {
+    return this.ensure(1), this.buf[this.offset++] = t & 255, this;
+  }
+  // Signed writes store the same two's complement bytes as the unsigned ones.
+  i8(t) {
+    return this.u8(t);
+  }
+  u16(t) {
+    return this.u8(t).u8(t >> 8);
+  }
+  i16(t) {
+    return this.u16(t);
+  }
+  u32(t) {
+    return this.u16(t & 65535).u16(t >>> 16 & 65535);
+  }
+  i32(t) {
+    return this.u32(t >>> 0);
+  }
+  bytes(t, s = t.length) {
+    this.ensure(s);
+    for (let e = 0; e < s; e++) this.buf[this.offset++] = e < t.length ? t[e] & 255 : 0;
+    return this;
+  }
+  /** Writes a string into a fixed size NUL padded field (truncated to leave room for the NUL). */
+  cstr(t, s) {
+    const e = new Uint8Array(s);
+    for (let i = 0; i < Math.min(t.length, s - 1); i++) e[i] = t.charCodeAt(i) & 255;
+    return this.bytes(e);
+  }
+  /**
+   * Writes a fixed size string field. When the text is unchanged the original raw
+   * bytes (including any garbage after the NUL) are kept so files round-trip exactly.
+   */
+  cstrOver(t, s, e) {
+    return s && s.length === e && u(s) === t ? this.bytes(s) : this.cstr(t, e);
+  }
+  toBytes() {
+    return this.buf.slice(0, this.offset);
+  }
+}
+function u(r) {
+  const t = r.indexOf(0);
+  return n.decode(t < 0 ? r : r.subarray(0, t));
+}
+function o(r) {
+  return n.decode(r);
+}
+function c(r) {
+  const t = new Uint8Array(r.length);
+  for (let s = 0; s < r.length; s++) t[s] = r.charCodeAt(s) & 255;
+  return t;
+}
+export {
+  h as Reader,
+  f as Writer,
+  u as cString,
+  o as latin1Text,
+  c as textBytes
+};

package/dist/formats/blocks.js

@@ -0,0 +1,103 @@
+import { Writer as r, Reader as u } from "./binary.js";
+const c = 20, s = 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(s).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(s),
+    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, s).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 i = 0; i < t; i++) 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 d(e) {
+  const t = e !== "bbl";
+  return Array.from({ length: m[e] }, (n, o) => L(o, t));
+}
+function g(e, t, n) {
+  const o = c - 1, i = e & 255;
+  switch (i > 7 ? 7 : i) {
+    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,
+  d as newBlockSet,
+  g as orientIndex,
+  b as parseBlocks,
+  C as serializeBlocks
+};