@lewismoten/gamemaker-sandbox-tools 3.1.0 → 3.4.0

package/dist/kit/levelGen.js

@@ -0,0 +1,1423 @@
+import { blocksWithRole as X, ROLES as ue, MAX_PAIR as Zt, FACINGS as de } from "./blockRoles.js";
+import { CHARBL as pe, BLEN as j } from "@lewismoten/gamemaker-sandbox-engine/formats/blocks";
+import { GRAVSPEED as ye, MAXGRAV as gt } from "@lewismoten/gamemaker-sandbox-engine/engine/world";
+import { MAXSEQ as xe } from "@lewismoten/gamemaker-sandbox-engine/formats/character";
+const ke = [
+  {
+    id: "platform",
+    label: "Platform",
+    blurb: "A side view, left to right: ground with pits, steps, ladders, spikes and stepping stones, sized to what the hero can really jump.",
+    min: { w: 40, h: 20 },
+    must: ["wall", "sky"],
+    want: [
+      {
+        role: "platform",
+        use: "Ledges to jump up to, and stepping stones across wide pits (solid on top only).",
+        without: "stones are made of wall blocks and there are no ledges"
+      },
+      { role: "ladder", use: "Beside tall towers the hero cannot jump up (he needs an up key that climbs).", without: "no towers" },
+      { role: "hazard", use: "Spikes to jump over, and in the bottom of pits.", without: "pits are floored with wall and there are no spikes" },
+      { role: "wall-top", use: "The top row of the ground.", without: "the ground top uses the wall block" },
+      { role: "treasure", use: "Coins along the path and over pits, where a jump reaches them.", without: "no coins" },
+      { role: "life", use: "One heart on the highest place he can stand.", without: "no heart" },
+      { role: "locked-door", use: "A tall door late in the level (needs a key block with the same lock number).", without: "no locked door" },
+      { role: "key", use: "On an earlier stretch, picked up on the way.", without: "no locked door" },
+      { role: "decoration", use: "Bushes and flowers on the ground.", without: "no decoration" }
+    ]
+  },
+  {
+    id: "dungeon",
+    min: { w: 12, h: 12 },
+    label: "Dungeon",
+    blurb: "Rooms joined by corridors, with the walls drawn round them.",
+    must: ["wall", "floor"],
+    want: [
+      { role: "decoration", use: "Scattered inside the bigger rooms.", without: "the rooms are left bare" },
+      {
+        role: "locked-door",
+        use: "Shut in a narrow passage on the way to the exit (needs a key block with the same lock number).",
+        without: "no locked doors"
+      },
+      { role: "key", use: "Placed where it can be reached before its locked door.", without: "no locked doors" },
+      { role: "treasure", use: "In corners and dead ends, more of it far from the entry.", without: "no treasure" },
+      { role: "life", use: "One heart in a far corner.", without: "no heart" }
+    ]
+  },
+  {
+    id: "forest",
+    min: { w: 12, h: 12 },
+    label: "Forest",
+    blurb: "Trees with clearings and a winding path through them.",
+    must: ["floor", "tree"],
+    want: [
+      { role: "path", use: "A winding trail from one side to the other.", without: "no trail" },
+      { role: "rock", use: "A few rocks in the open.", without: "no rocks" },
+      { role: "decoration", use: "Flowers and bushes in the open.", without: "no flowers" },
+      { role: "treasure", use: "In dead ends and nooks among the trees.", without: "no treasure" },
+      { role: "life", use: "One heart in a far nook.", without: "no heart" }
+    ]
+  },
+  {
+    id: "home",
+    label: "Home",
+    blurb: "One to three rooms with a front door; furniture against the walls and chairs facing the table.",
+    min: { w: 12, h: 10 },
+    must: ["wall", "floor"],
+    want: [
+      { role: "door", use: "The front door in the south wall (the entry and exit).", without: "the front door is plain floor" },
+      { role: "table", use: "A table in the living room.", without: "no table" },
+      { role: "chair", use: "Next to the table, facing it (a chair block must say which way it faces).", without: "no chairs" },
+      { role: "bed", use: "Against a wall, front to the room.", without: "no beds" },
+      { role: "shelf", use: "Against walls.", without: "no shelves" },
+      { role: "stove", use: "Against a wall of the living room.", without: "no stove" },
+      { role: "rug", use: "Under and around the table.", without: "no rugs" },
+      { role: "lamp", use: "Against walls.", without: "no lamps" },
+      { role: "plant", use: "In a corner.", without: "no plants" }
+    ]
+  },
+  {
+    id: "shop",
+    label: "Shop",
+    blurb: "One room: shelves on the back wall, a counter across it, and room for customers by the door.",
+    min: { w: 12, h: 10 },
+    must: ["wall", "floor"],
+    want: [
+      { role: "door", use: "The front door in the south wall (the entry and exit).", without: "the front door is plain floor" },
+      { role: "counter", use: "Across the room, facing the door (the block must face south), with an open end to the shopkeeper.", without: "no counter" },
+      { role: "shelf", use: "Along the back wall and the side walls.", without: "no shelves" },
+      { role: "table", use: "A display table for customers.", without: "no display table" },
+      { role: "rug", use: "Inside the door.", without: "no rug" },
+      { role: "lamp", use: "Against the side walls.", without: "no lamps" },
+      { role: "plant", use: "In a corner.", without: "no plants" }
+    ]
+  },
+  {
+    id: "castle",
+    label: "Castle",
+    blurb: "An outer wall with corner towers and a gate, a courtyard, and a keep of rooms.",
+    min: { w: 30, h: 24 },
+    must: ["wall", "floor"],
+    want: [
+      { role: "door", use: "In the gate and the keep door.", without: "the gate and keep door are plain floor" },
+      { role: "path", use: "A road from the gate to the keep door.", without: "no road" },
+      { role: "decoration", use: "Scattered in the courtyard and the keep rooms.", without: "the courtyard is bare" },
+      { role: "locked-door", use: "Shut in a narrow passage of the keep (needs a key block with the same lock number).", without: "no locked doors" },
+      { role: "key", use: "Placed where it can be reached before its locked door.", without: "no locked doors" },
+      { role: "treasure", use: "In tower rooms, corners and dead ends of the keep.", without: "no treasure" },
+      { role: "life", use: "One heart in a far corner.", without: "no heart" }
+    ]
+  },
+  {
+    id: "town",
+    label: "Town",
+    blurb: "A winding main street between two gates, cross streets, a plaza and houses with their doors on the street.",
+    min: { w: 40, h: 28 },
+    must: ["wall", "floor"],
+    want: [
+      { role: "door", use: "On each house front and in the two gates (proposed links to interiors and the overworld).", without: "the doors are plain floor" },
+      { role: "wall-top", use: "The two top rows of each house (its roof).", without: "roofs use the wall block" },
+      { role: "path", use: "The streets and the plaza.", without: "streets are plain floor" },
+      { role: "tree", use: "A ring round the town and a few in the open.", without: "no trees" },
+      { role: "decoration", use: "In the plaza and scattered in the open.", without: "no decoration" }
+    ]
+  },
+  {
+    id: "overworld",
+    label: "Overworld",
+    blurb: "Land and sea with forests and mountains, shores drawn with the water brush, and a road joining towns, dungeon entrances and a castle.",
+    min: { w: 40, h: 40 },
+    must: ["floor", "water"],
+    want: [
+      { role: "tree", use: "Forest where the land is wet.", without: "no forests" },
+      { role: "rock", use: "Mountains on the highest ground.", without: "no mountains" },
+      { role: "path", use: "A road joining the sites.", without: "roads are plain floor" },
+      { role: "door", use: "The mark of each site (a town, dungeon entrance or castle).", without: "sites are marked by a clearing only" },
+      { role: "decoration", use: "Scattered on the grass.", without: "no flowers" }
+    ]
+  }
+], se = (t) => ke.find((e) => e.id === t), qt = (t) => ue.find((e) => e.id === t).label;
+function ge(t, e) {
+  const o = se(t), s = (h) => X(e, h).length, n = [
+    ...o.must.map((h) => ({ role: h, label: qt(h), must: !0, count: s(h) })),
+    ...o.want.map((h) => ({ role: h.role, label: qt(h.role), must: !1, count: s(h.role), use: h.use, without: h.without }))
+  ], c = n.filter((h) => h.must && !h.count).map((h) => h.label.toLowerCase()), a = c.length ? `Needs ${c.map((h) => `a ${h} block`).join(" and ")}. Mark ${c.length > 1 ? "them" : "one"} in the block editor's Uses tab.` : "", x = n.filter((h) => !h.must && !h.count), y = [...new Set(x.map((h) => h.without))].map(
+    (h) => `No ${x.filter((l) => l.without === h).map((l) => l.label.toLowerCase()).join(" or ")} block: ${h}.`
+  );
+  return { kind: t, items: n, ok: !c.length, message: a, skipped: y };
+}
+function zt(t) {
+  let e = t >>> 0;
+  const o = () => {
+    e = e + 1831565813 >>> 0;
+    let s = e;
+    return s = Math.imul(s ^ s >>> 15, s | 1), s ^= s + Math.imul(s ^ s >>> 7, s | 61), ((s ^ s >>> 14) >>> 0) / 4294967296;
+  };
+  return {
+    next: o,
+    /** An integer from lo to hi, both included. */
+    int: (s, n) => s + Math.floor(o() * (n - s + 1)),
+    chance: (s) => o() < s,
+    pick: (s) => s[Math.floor(o() * s.length)]
+  };
+}
+const Q = 0, Z = 1, ct = 2, J = 3, Et = 4, ut = 5, Ot = 6, Kt = 7, Bt = 8, Gt = 9, le = 10, dt = 11, it = 12, bt = 13, yt = 14, ft = 15, ht = 16, xt = 17, tt = (t) => t === Q || t === J || t === Et || t === le || t === it || t === bt, pt = (t, e, o) => ({ w: t, h: e, cells: new Uint8Array(t * e).fill(o) }), me = [
+  [1, 0],
+  [-1, 0],
+  [0, 1],
+  [0, -1]
+];
+function st(t, e) {
+  const o = new Int32Array(t.cells.length).fill(-1);
+  if (tt(t.cells[e])) return o;
+  o[e] = 0;
+  const s = [e];
+  for (let n = 0; n < s.length; n++) {
+    const c = s[n], a = c % t.w, x = c / t.w | 0;
+    for (const [y, h] of me) {
+      const l = a + y, i = x + h;
+      if (l < 0 || i < 0 || l >= t.w || i >= t.h) continue;
+      const r = i * t.w + l;
+      o[r] < 0 && !tt(t.cells[r]) && (o[r] = o[c] + 1, s.push(r));
+    }
+  }
+  return o;
+}
+function Yt(t, e, o) {
+  for (let s = -1; s <= 1; s++)
+    for (let n = -1; n <= 1; n++) {
+      const c = e + n, a = o + s;
+      if (c < 0 || a < 0 || c >= t.w || a >= t.h || tt(t.cells[a * t.w + c])) return !1;
+    }
+  return !0;
+}
+function ce(t, e) {
+  const o = st(t, e);
+  let s = e;
+  for (let n = 0; n < o.length; n++) o[n] > o[s] && (s = n);
+  return s;
+}
+const re = [
+  [1, 0],
+  [-1, 0],
+  [0, 1],
+  [0, -1]
+];
+function Rt(t, e) {
+  const o = e % t.w, s = e / t.w | 0;
+  let n = 0;
+  for (let c = -1; c <= 1; c++)
+    for (let a = -1; a <= 1; a++) {
+      if (!a && !c) continue;
+      const x = o + a, y = s + c;
+      (x < 0 || y < 0 || x >= t.w || y >= t.h || tt(t.cells[y * t.w + x])) && n++;
+    }
+  return n;
+}
+function Wt(t, e) {
+  const o = { w: t.w, h: t.h, cells: t.cells.slice() };
+  for (const s of e) o.cells[s] = 0;
+  return o;
+}
+function we(t, e, o) {
+  const s = st(t, o);
+  if (s[e] < 0) return [];
+  const n = [e];
+  for (; n[n.length - 1] !== o; ) {
+    const c = n[n.length - 1], a = c % t.w, x = c / t.w | 0;
+    let y = -1;
+    for (const [h, l] of re) {
+      const i = a + h, r = x + l;
+      if (i < 0 || r < 0 || i >= t.w || r >= t.h) continue;
+      const M = r * t.w + i;
+      s[M] >= 0 && s[M] < s[c] && y < 0 && (y = M);
+    }
+    n.push(y);
+  }
+  return n;
+}
+function Me(t, e) {
+  const o = e % t.w, s = e / t.w | 0, n = (c, a) => {
+    const x = o + c, y = s + a;
+    return x >= 0 && y >= 0 && x < t.w && y < t.h && !tt(t.cells[y * t.w + x]);
+  };
+  return n(1, 0) && n(-1, 0) && !n(0, 1) && !n(0, -1) || n(0, 1) && n(0, -1) && !n(1, 0) && !n(-1, 0);
+}
+function be(t, e, o, s, n) {
+  const c = /* @__PURE__ */ new Set([e, o]), a = [], x = [], y = [], h = (M, T, k) => M.every((b) => Math.max(Math.abs(b % t.w - T % t.w), Math.abs((b / t.w | 0) - (T / t.w | 0))) >= k);
+  if (n.pairs.length) {
+    const M = we(t, e, o), T = M.filter(
+      (p, f) => f >= 4 && f < M.length - 3 && t.cells[p] === Z && Me(t, p) && st(Wt(t, [p]), e)[o] < 0
+    ), k = Math.min(n.pairs.length, 3, T.length), b = [];
+    for (let p = 0; p < k; p++) b.push(T[Math.min(T.length - 1, Math.floor((p + 1) * T.length / (k + 1)))]);
+    const C = [...new Set(b)];
+    C.forEach((p, f) => {
+      const w = C.slice(f), L = st(Wt(t, w), e);
+      let P = -1, z = -1;
+      for (let E = 0; E < L.length; E++) {
+        if (L[E] < 3 || c.has(E) || w.includes(E)) continue;
+        const U = Rt(t, E) * 4 + Math.min(L[E], 40) + s.next() * 3;
+        U > z && (z = U, P = E);
+      }
+      P < 0 || (c.add(p), c.add(P), a.push({ cell: p, key: P, pair: n.pairs[f % n.pairs.length], order: f }));
+    });
+    for (const p of a)
+      t.cells[p.cell] = Ot, t.cells[p.key] = Kt;
+  }
+  const l = st(t, e), i = [];
+  for (let M = 0; M < l.length; M++) l[M] >= 0 && !c.has(M) && t.cells[M] !== Ot && i.push(M);
+  if (n.treasure) {
+    const M = Math.max(3, Math.min(12, Math.round(i.length / 150))), T = i.filter((k) => l[k] >= 3 && Rt(t, k) >= 5).map((k) => ({ i: k, s: Rt(t, k) * 3 + Math.min(l[k], 60) / 2 + s.next() * 4 })).sort((k, b) => b.s - k.s || k.i - b.i);
+    for (const { i: k } of T) {
+      if (x.length >= M) break;
+      h(x, k, 4) && (x.push(k), c.add(k));
+    }
+  }
+  let r;
+  n.life && x.length > 2 && (r = x.pop(), t.cells[r] = Gt);
+  for (const M of x) t.cells[M] = Bt;
+  if (n.monsters.length) {
+    const M = Math.max(2, Math.min(10, Math.round(i.length / 130))), T = i.filter((b) => l[b] >= 5 && !c.has(b) && Rt(t, b) <= 2), k = [];
+    for (let b = 0; b < T.length * 2 && y.length < M && T.length; b++) {
+      const C = T[Math.floor(s.next() * T.length)];
+      h(k, C, 5) && (k.push(C), y.push({ cell: C, monnum: s.pick(n.monsters) }));
+    }
+    y.sort((b, C) => b.cell - C.cell);
+  }
+  return { locks: a, treasure: x, life: r, monsters: y };
+}
+function ve(t, e, o, s, n) {
+  const c = /* @__PURE__ */ new Set(), a = new Map(s.map((i) => [i.cell, i])), x = new Map(s.map((i) => [i.key, i.pair]));
+  let y = new Uint8Array(t.cells.length);
+  for (let i = !0; i; ) {
+    i = !1, y = new Uint8Array(t.cells.length);
+    const r = [e];
+    for (y[e] = 1; r.length; ) {
+      const M = r.pop(), T = x.get(M);
+      T !== void 0 && !c.has(T) && (c.add(T), i = !0);
+      const k = M % t.w, b = M / t.w | 0;
+      for (const [C, p] of re) {
+        const f = k + C, w = b + p;
+        if (f < 0 || w < 0 || f >= t.w || w >= t.h) continue;
+        const L = w * t.w + f, P = a.get(L);
+        y[L] || tt(t.cells[L]) || P && !c.has(P.pair) || (y[L] = 1, r.push(L));
+      }
+    }
+  }
+  const h = y[o] === 1 && s.every((i) => y[i.cell] && y[i.key]) && n.every((i) => y[i]), l = s.every((i) => {
+    const r = s.filter((M) => M.order >= i.order).map((M) => M.cell);
+    return st(Wt(t, r), e)[i.key] >= 0;
+  });
+  return { ok: h, strict: l };
+}
+const Dt = 9;
+function _t(t, e, o) {
+  const s = t.w < t.h ? !0 : t.h < t.w ? !1 : e.chance(0.5), n = s ? t.h : t.w;
+  if (o > 6 || n < Dt * 2 || o > 1 && e.chance(0.15)) return;
+  const c = e.int(Dt, n - Dt);
+  t.a = s ? { x: t.x, y: t.y, w: t.w, h: c } : { x: t.x, y: t.y, w: c, h: t.h }, t.b = s ? { x: t.x, y: t.y + c, w: t.w, h: t.h - c } : { x: t.x + c, y: t.y, w: t.w - c, h: t.h }, _t(t.a, e, o + 1), _t(t.b, e, o + 1);
+}
+const Lt = (t) => t.a && t.b ? [...Lt(t.a), ...Lt(t.b)] : [t], St = (t) => ({ x: t.room.x + (t.room.w >> 1), y: t.room.y + (t.room.h >> 1) });
+function At(t, e, o, s, n) {
+  for (let c = Math.min(o, n); c <= Math.max(o, n); c++) for (let a = Math.min(e, s); a <= Math.max(e, s); a++) t.cells[c * t.w + a] = Z;
+}
+function ie(t, e, o, s) {
+  s.chance(0.5) ? (At(t, e.x, e.y, o.x, e.y), At(t, o.x, e.y, o.x, o.y)) : (At(t, e.x, e.y, e.x, o.y), At(t, e.x, o.y, o.x, o.y));
+}
+const Jt = (t, e) => e.pick(Lt(t));
+function Ut(t, e, o) {
+  !t.a || !t.b || (Ut(t.a, e, o), Ut(t.b, e, o), ie(e, St(Jt(t.a, o)), St(Jt(t.b, o)), o));
+}
+function ae(t, e, o, s) {
+  const n = pt(t, e, Q), c = { x: 1, y: 1, w: t - 2, h: e - 2 };
+  _t(c, o, 0);
+  const a = Lt(c);
+  for (const i of a) {
+    const r = o.int(Math.min(4, i.w - 3), i.w - 3), M = o.int(Math.min(4, i.h - 3), i.h - 3);
+    i.room = { x: i.x + 1 + o.int(0, i.w - 2 - r), y: i.y + 1 + o.int(0, i.h - 2 - M), w: r, h: M }, At(n, i.room.x, i.room.y, i.room.x + r - 1, i.room.y + M - 1);
+  }
+  Ut(c, n, o);
+  for (let i = 0; i < a.length >> 2; i++) ie(n, St(o.pick(a)), St(o.pick(a)), o);
+  const x = St(a[0]), y = x.y * t + x.x, h = ce(n, y);
+  let l = !1;
+  if (s)
+    for (const i of a) {
+      const r = i.room;
+      if (!(r.w * r.h < 20))
+        for (let M = o.int(1, 3); M > 0; M--) {
+          const T = r.x + o.int(0, r.w - 1), k = r.y + o.int(0, r.h - 1), b = k * t + T;
+          b === y || b === h || !Yt(n, T, k) || (n.cells[b] = ut, l = !0);
+        }
+    }
+  return { area: n, entry: y, exit: h, rooms: a.length, decorated: l };
+}
+function Ae(t) {
+  const { w: e, h: o, cells: s } = t, n = s.slice();
+  for (let c = 0; c < o; c++) {
+    const a = c > 0 && c < o - 1;
+    for (let x = 0; x < e; x++) {
+      let y = 0;
+      if (a && x > 0 && x < e - 1) {
+        const h = c * e + x;
+        y = +(s[h - e - 1] === J) + +(s[h - e] === J) + +(s[h - e + 1] === J) + +(s[h - 1] === J) + +(s[h + 1] === J) + +(s[h + e - 1] === J) + +(s[h + e] === J) + +(s[h + e + 1] === J);
+      } else
+        for (let h = -1; h <= 1; h++)
+          for (let l = -1; l <= 1; l++) {
+            if (!l && !h) continue;
+            const i = x + l, r = c + h;
+            (i < 0 || r < 0 || i >= e || r >= o || s[r * e + i] === J) && y++;
+          }
+      n[c * e + x] = y >= 4 ? J : Z;
+    }
+  }
+  s.set(n);
+}
+function Se(t) {
+  const { w: e, h: o, cells: s } = t, n = new Int32Array(s.length).fill(-1), c = new Int32Array(s.length);
+  let a = -1, x = 0, y = 0;
+  for (let h = 0; h < s.length; h++) {
+    if (tt(s[h]) || n[h] >= 0) continue;
+    let l = 0, i = 0;
+    for (c[i++] = h, n[h] = y; l < i; ) {
+      const r = c[l++], M = r % e, T = r / e | 0;
+      M + 1 < e && n[r + 1] < 0 && !tt(s[r + 1]) && (n[r + 1] = y, c[i++] = r + 1), M > 0 && n[r - 1] < 0 && !tt(s[r - 1]) && (n[r - 1] = y, c[i++] = r - 1), T + 1 < o && n[r + e] < 0 && !tt(s[r + e]) && (n[r + e] = y, c[i++] = r + e), T > 0 && n[r - e] < 0 && !tt(s[r - e]) && (n[r - e] = y, c[i++] = r - e);
+    }
+    i > x && (a = y, x = i), y++;
+  }
+  for (let h = 0; h < s.length; h++) !tt(s[h]) && n[h] !== a && (s[h] = J);
+  return x;
+}
+function fe(t, e, o, s) {
+  const n = new Float64Array(t.cells.length).fill(1 / 0), c = new Int32Array(t.cells.length).fill(-1), a = [[0, e]];
+  n[e] = 0;
+  const x = (l) => {
+    a.push(l);
+    let i = a.length - 1;
+    for (; i > 0; ) {
+      const r = i - 1 >> 1;
+      if (a[r][0] <= a[i][0]) break;
+      [a[r], a[i]] = [a[i], a[r]], i = r;
+    }
+  }, y = () => {
+    const l = a[0], i = a.pop();
+    if (a.length) {
+      a[0] = i;
+      let r = 0;
+      for (; ; ) {
+        const M = 2 * r + 1, T = M + 1;
+        let k = r;
+        if (M < a.length && a[M][0] < a[k][0] && (k = M), T < a.length && a[T][0] < a[k][0] && (k = T), k === r) break;
+        [a[k], a[r]] = [a[r], a[k]], r = k;
+      }
+    }
+    return l;
+  };
+  for (; a.length; ) {
+    const [l, i] = y();
+    if (l > n[i]) continue;
+    if (i === o) break;
+    const r = i % t.w, M = i / t.w | 0;
+    for (const [T, k] of [
+      [1, 0],
+      [-1, 0],
+      [0, 1],
+      [0, -1]
+    ]) {
+      const b = r + T, C = M + k;
+      if (b < 0 || C < 0 || b >= t.w || C >= t.h) continue;
+      const p = C * t.w + b;
+      if (tt(t.cells[p])) continue;
+      const f = l + s[p];
+      f < n[p] && (n[p] = f, c[p] = i, x([f, p]));
+    }
+  }
+  const h = [];
+  for (let l = o; l >= 0; l = c[l]) h.push(l);
+  return h.reverse();
+}
+function Ee(t, e, o, s) {
+  const n = pt(t, e, J);
+  let c = 0;
+  for (let h = 0; h < 6 && c < t * e * 0.22; h++) {
+    const l = 0.5 - h * 0.03;
+    for (let i = 0; i < n.cells.length; i++) n.cells[i] = o.chance(l) ? J : Z;
+    for (let i = 0; i < 4; i++) Ae(n);
+    for (let i = o.int(2, 4); i > 0; i--) {
+      const r = o.int(3, 5), M = o.int(r, Math.max(r, t - 1 - r)), T = o.int(r, Math.max(r, e - 1 - r));
+      for (let k = T - r; k <= T + r; k++)
+        for (let b = M - r; b <= M + r; b++)
+          b >= 0 && k >= 0 && b < t && k < e && (b - M) ** 2 + (k - T) ** 2 <= r * r && (n.cells[k * t + b] = Z);
+    }
+    c = Se(n);
+  }
+  let a = n.cells.findIndex((h) => !tt(h));
+  for (let h = 0; h < n.cells.length; h++) !tt(n.cells[h]) && h % t < a % t && (a = h);
+  const x = ce(n, a);
+  let y = !1;
+  if (s.path && a !== x) {
+    const h = new Float32Array(n.cells.length);
+    for (let l = 0; l < h.length; l++) h[l] = 1 + o.next() * 4;
+    for (const l of fe(n, a, x, h)) n.cells[l] = ct;
+    y = !0;
+  }
+  for (let h = 0; h < e; h++)
+    for (let l = 0; l < t; l++) {
+      const i = h * t + l;
+      n.cells[i] !== Z || i === a || i === x || !Yt(n, l, h) || (s.rock && o.chance(0.02) ? n.cells[i] = Et : s.decor && o.chance(0.05) && (n.cells[i] = ut));
+    }
+  return { area: n, entry: a, exit: x, open: c, trail: y };
+}
+const Ct = { N: [0, -1], E: [1, 0], S: [0, 1], W: [-1, 0] }, Tt = { N: "S", E: "W", S: "N", W: "E" };
+function Oe(t, e, o, s, n) {
+  const c = [], a = /* @__PURE__ */ new Set(), x = (p, f) => f * t.w + p, y = (p) => t.cells[p] === Z && !n.has(p), h = (p) => p.map((f) => [s.next(), f]).sort((f, w) => f[0] - w[0]).map((f) => f[1]), l = (p, f, w) => f >= p.x && f < p.x + p.w && w >= p.y && w < p.y + p.h;
+  function i(p) {
+    const f = st(t, e);
+    for (let w = 0; w < f.length; w++) if (!tt(t.cells[w]) && f[w] < 0) return !1;
+    return [...c, ...p].every((w) => {
+      if (w.open) return !0;
+      const L = w.cell % t.w, P = w.cell / t.w | 0;
+      return Object.values(Ct).some(([z, E]) => {
+        const U = L + z, N = P + E;
+        return U >= 0 && N >= 0 && U < t.w && N < t.h && f[x(U, N)] >= 0;
+      });
+    });
+  }
+  function r(p) {
+    if (new Set(p.map((f) => f.cell)).size !== p.length || !p.every((f) => y(f.cell))) return !1;
+    for (const f of p) t.cells[f.cell] = le;
+    if (i(p))
+      return c.push(...p), !0;
+    for (const f of p) t.cells[f.cell] = Z;
+    return !1;
+  }
+  const M = (p, f) => !!o[p]?.includes(f);
+  function T(p, f, w, L = ["N", "E", "S", "W"]) {
+    if (!o[f]?.length) return !1;
+    const P = h(L).filter((z) => M(f, Tt[z]) || !["bed", "counter", "shelf", "stove", "chair"].includes(f));
+    P.length || a.add(f);
+    for (let z = 0; z < 14 && P.length; z++) {
+      const E = P[z % P.length], U = E === "N" || E === "S", N = U ? p.w : p.h, m = s.int(0, Math.max(0, N - w)), R = [];
+      for (let F = 0; F < w; F++) {
+        const B = m + F, v = U ? p.x + B : E === "W" ? p.x : p.x + p.w - 1, u = U ? E === "N" ? p.y : p.y + p.h - 1 : p.y + B;
+        if (!l(p, v, u)) break;
+        R.push({ cell: x(v, u), role: f, facing: Tt[E] });
+      }
+      if (R.length === w && r(R)) return !0;
+    }
+    return !1;
+  }
+  function k(p, f, w) {
+    if (o.table?.length)
+      for (let L = 0; L < 30; L++) {
+        const P = s.chance(0.6), z = P ? w : 1, E = P ? 1 : w;
+        if (p.w < z + 2 || p.h < E + 2) continue;
+        const U = s.int(p.x + 1, p.x + p.w - z - 1), N = s.int(p.y + 1, p.y + p.h - E - 1), m = [];
+        let R = !0;
+        for (let F = N - 1; F <= N + E; F++)
+          for (let B = U - 1; B <= U + z; B++) {
+            const v = x(B, F);
+            B >= U && B < U + z && F >= N && F < N + E ? m.push(v) : (!l(p, B, F) || t.cells[v] !== Z || n.has(v)) && (R = !1);
+          }
+        if (!(!R || !m.every(y)) && r(m.map((F) => ({ cell: F, role: "table" })))) {
+          if (f)
+            if (o.chair?.length) {
+              const F = [];
+              for (const v of m) {
+                const u = v % t.w, d = v / t.w | 0;
+                for (const g of ["N", "E", "S", "W"]) {
+                  const [A, $] = Ct[g], I = x(u + A, d + $);
+                  !m.includes(I) && M("chair", Tt[g]) && F.push({ cell: I, role: "chair", facing: Tt[g] });
+                }
+              }
+              let B = s.int(1, Math.min(4, Math.max(1, F.length)));
+              for (const v of h(F)) B > 0 && r([v]) && B--;
+            } else o.chair && a.add("chair");
+          return m;
+        }
+      }
+  }
+  function b(p, f) {
+    return o[f]?.length ? h([x(p.x, p.y), x(p.x + p.w - 1, p.y), x(p.x, p.y + p.h - 1), x(p.x + p.w - 1, p.y + p.h - 1)]).some((L) => r([{ cell: L, role: f, facing: "S" }])) : !1;
+  }
+  function C(p) {
+    if (o.rug?.length)
+      for (const f of p) t.cells[f] === Z && !c.some((w) => w.cell === f) && c.push({ cell: f, role: "rug", open: !0 });
+  }
+  return { items: c, skipped: a, commit: r, against: T, table: k, corner: b, rug: C, free: y, at: x, shuffle: h };
+}
+function Re(t, e, o, s, n) {
+  const c = pt(t, e, Q), a = Math.min(t, s === "home" ? 24 : 26), x = Math.min(e, s === "home" ? 16 : 14), y = t - a >> 1, h = e - x >> 1, l = { x: y + 1, y: h + 1, w: a - 2, h: x - 2 }, i = (w, L) => L * t + w;
+  for (let w = l.y; w < l.y + l.h; w++) for (let L = l.x; L < l.x + l.w; L++) c.cells[i(L, w)] = Z;
+  const r = Math.max(l.x + 1, Math.min(l.x + l.w - 3, l.x + (l.w >> 1) + o.int(-2, 2))), M = h + x - 1;
+  c.cells[i(r, M)] = dt;
+  const T = i(r, M - 1), k = /* @__PURE__ */ new Set(), b = (w) => {
+    for (let L = 1; L <= w; L++) for (const P of [r, r + 1]) k.add(i(P, M - L));
+  }, C = Oe(c, T, n, o, k), p = [l];
+  let f;
+  if (s === "home") {
+    if (b(4), l.w >= 13 && o.chance(0.75)) {
+      const E = o.int(l.x + 5, l.x + l.w - 6);
+      if (Math.abs(E - r - 0.5) > 3) {
+        const U = o.int(l.y + 1, l.y + l.h - 4);
+        for (let N = l.y; N < l.y + l.h; N++) c.cells[i(E, N)] = N === U || N === U + 1 ? Z : Q;
+        for (const N of [U, U + 1]) for (const m of [E - 1, E, E + 1]) k.add(i(m, N));
+        p.splice(0, 1, { x: l.x, y: l.y, w: E - l.x, h: l.h }, { x: E + 1, y: l.y, w: l.x + l.w - E - 1, h: l.h });
+      }
+    }
+    const w = p.find((E) => !(r >= E.x && r < E.x + E.w));
+    if (w && w.w >= 6 && w.h >= 10 && o.chance(0.5)) {
+      const E = o.int(w.y + 4, w.y + w.h - 5), U = o.int(w.x + 1, w.x + w.w - 3);
+      for (let N = w.x; N < w.x + w.w; N++) c.cells[i(N, E)] = N === U || N === U + 1 ? Z : Q;
+      for (const N of [U, U + 1]) for (const m of [E - 1, E, E + 1]) k.add(i(N, m));
+      p.splice(p.indexOf(w), 1, { ...w, h: E - w.y }, { x: w.x, y: E + 1, w: w.w, h: w.y + w.h - E - 1 });
+    }
+    const L = p.find((E) => r >= E.x && r < E.x + E.w), P = C.table(L, !0, o.int(2, 3)) ?? [];
+    C.against(L, "stove", 1), C.against(L, "shelf", o.int(1, 2)), C.corner(L, "plant"), C.against(L, "lamp", 1), p.length === 1 && C.against(L, "bed", 2);
+    const z = [];
+    for (const E of P) for (let U = -1; U <= 1; U++) for (let N = -1; N <= 1; N++) z.push(E + U * t + N);
+    C.rug(z.filter((E) => E >= 0 && E < c.cells.length));
+    for (const E of p)
+      if (E !== L) {
+        for (let U = o.int(1, 2); U > 0; U--) C.against(E, "bed", 2);
+        o.chance(0.6) && C.against(E, "shelf", o.int(1, 2)), C.against(E, "lamp", 1), C.corner(E, "plant");
+      }
+  } else {
+    const w = l.y + Math.max(3, Math.floor(l.h * 0.4));
+    for (let N = w + 1; N < M; N++) for (const m of [r, r + 1]) k.add(i(m, N));
+    const P = r - l.x > l.x + l.w - r - 2 ? [l.x, l.x + 1] : [l.x + l.w - 2, l.x + l.w - 1], z = !!n.counter?.includes("S");
+    if (n.counter?.length && !z && C.skipped.add("counter"), z) {
+      const N = [];
+      for (let R = l.x; R < l.x + l.w; R++) P.includes(R) || N.push({ cell: i(R, w), role: "counter", facing: "S" });
+      const m = l.x + (l.w >> 1);
+      f = i(m, w - 1), k.add(f), C.commit(N);
+    }
+    const E = l.y;
+    for (let N = l.x; N < l.x + l.w; N++)
+      o.chance(0.25) || C.against({ x: N, y: E, w: 1, h: 1 }, "shelf", 1, ["N"]);
+    const U = { x: l.x, y: w + 1, w: l.w, h: M - w - 1 };
+    C.against(U, "shelf", o.int(1, 2), ["W", "E"]), C.table(U, !1, o.int(1, 2)), C.corner(U, "plant"), C.against(U, "lamp", 1, ["W", "E"]), C.rug([r, r + 1].flatMap((N) => [i(N, M - 1), i(N, M - 2)]));
+  }
+  return { area: c, entry: T, exit: i(r, M), items: C.items, shopkeeper: f, skipped: [...C.skipped] };
+}
+const mt = 5;
+function Te(t, e, o, s) {
+  const n = pt(t, e, Q), c = (f, w) => w * t + f;
+  for (let f = 2; f < e - 2; f++) for (let w = 2; w < t - 2; w++) n.cells[c(w, f)] = Z;
+  for (const [f, w] of [
+    [0, 0],
+    [t - mt, 0],
+    [0, e - mt],
+    [t - mt, e - mt]
+  ]) {
+    for (let P = w; P < w + mt; P++) for (let z = f; z < f + mt; z++) n.cells[c(z, P)] = Q;
+    for (let P = w + 1; P <= w + 3; P++) for (let z = f + 1; z <= f + 3; z++) n.cells[c(z, P)] = Z;
+    const L = f === 0;
+    n.cells[c(L ? f + 4 : f, w + 2)] = Z, n.cells[c(L ? f + 5 : f - 1, w + 2)] = Z;
+  }
+  const a = (t >> 1) - 1;
+  for (const f of [a, a + 1])
+    n.cells[c(f, e - 1)] = dt, n.cells[c(f, e - 2)] = Z;
+  const x = c(a, e - 3), y = t - 4, h = e - 4, l = Math.min(Math.max(12, Math.round(y * 0.6)), y - 6), i = Math.min(Math.max(12, Math.round(h * 0.62)), h - 6), r = 2 + (y - l >> 1), M = 3, T = ae(l, i, o, s.decorate);
+  for (let f = 0; f < i; f++) for (let w = 0; w < l; w++) n.cells[c(r + w, M + f)] = T.area.cells[f * l + w];
+  const k = r + (l >> 1) + o.int(-2, 2), b = M + i - 1;
+  n.cells[c(k, b)] = dt;
+  for (let f = b - 1; f > M && n.cells[c(k, f)] === Q; f--) n.cells[c(k, f)] = Z;
+  if (s.path) {
+    for (let f = e - 3; f >= b + 1; f--) n.cells[c(a, f)] = ct;
+    for (let f = Math.min(a, k); f <= Math.max(a, k); f++) n.cells[c(f, b + 1)] = ct;
+  }
+  if (s.decorate)
+    for (let f = o.int(4, 8); f > 0; f--) {
+      const w = o.int(3, t - 4), L = o.int(b + 2, e - 5), P = c(w, L);
+      n.cells[P] === Z && Yt(n, w, L) && Math.abs(w - a) > 2 && (n.cells[P] = ut);
+    }
+  const C = st(n, x);
+  let p = c(k, b);
+  for (let f = M; f < M + i; f++) for (let w = r; w < r + l; w++) C[c(w, f)] > C[p] && (p = c(w, f));
+  return { area: n, entry: x, exit: p };
+}
+function Ie(t, e, o, s) {
+  const n = pt(t, e, Z), c = (m, R) => R * t + m, a = (m, R, F) => m >= 0 && R >= 0 && m < t && R < e && (n.cells[c(m, R)] = F), x = e >> 1, y = Math.max(5, x - (e >> 3)), h = Math.min(e - 6, x + (e >> 3)), l = [];
+  let i = x;
+  for (let m = 0; m < t; m++)
+    m % 4 === 3 && (i = Math.min(h, Math.max(y, i + o.int(-1, 1)))), l.push(i);
+  const r = new Uint8Array(t * e), M = (m, R, F) => {
+    for (let B = -F; B <= F; B++)
+      for (let v = -F; v <= F; v++) m + v >= 0 && R + B >= 0 && m + v < t && R + B < e && (r[c(m + v, R + B)] = 1);
+  };
+  if (s.tree)
+    for (let m = 0; m < t * e; m++) (m % t < 1 || m % t >= t - 1 || m < t || m >= t * (e - 1)) && (n.cells[m] = J);
+  const T = [], k = t >> 1;
+  T.push(k - 1);
+  for (let m = k - o.int(17, 21); m > 8; m -= o.int(20, 26)) T.push(m);
+  for (let m = k + o.int(17, 21); m < t - 9; m += o.int(20, 26)) T.push(m);
+  T.forEach((m, R) => {
+    const F = R % 2 === 0, B = o.int(0, 1) ? 0.4 : 0.6, v = o.chance(0.5) ? 1 : -1, u = o.int(3, 5);
+    for (let d = 0; d <= 1; d++) {
+      const g = l[Math.min(t - 1, m + d)], A = F ? [u, g] : [g, e - 1 - u];
+      for (let $ = A[0]; $ <= A[1]; $++) {
+        const I = m + d + (Math.abs($ - g) > B * (A[1] - A[0]) ? v : 0);
+        a(I, $, ct), M(I, $, 1);
+      }
+    }
+  });
+  for (let m = 0; m < t; m++)
+    for (let R = -1; R <= 1; R++)
+      a(m, l[m] + R, ct), M(m, l[m] + R, 1);
+  const b = [];
+  a(0, l[0], dt), a(t - 1, l[t - 1], dt), b.push({ cell: c(0, l[0]), kind: "overworld", label: "West gate" }, { cell: c(t - 1, l[t - 1]), kind: "overworld", label: "East gate" });
+  const C = k - 1, p = l[k];
+  for (let m = p - 3; m <= p + 3; m++)
+    for (let R = C - 4; R <= C + 5; R++)
+      a(R, m, ct), M(R, m, 1);
+  s.decor && (a(C + 0, p, ut), a(C + 1, p, ut));
+  const f = [];
+  for (const m of [!0, !1])
+    for (let R = 2; R < t - 8; ) {
+      const F = o.int(5, 7), B = o.int(4, 5);
+      let v = m ? e : 0;
+      for (let I = 0; I < F; I++) v = m ? Math.min(v, l[R + I] - 2) : Math.max(v, l[R + I] + 2);
+      const u = m ? v - 2 : v + 2, d = m ? u - B + 1 : u;
+      let g = d >= 2 && d + B <= e - 2;
+      for (let I = d - 1; g && I <= d + B; I++)
+        for (let W = R - 1; W <= R + F; W++) (W < 1 || W >= t - 1 || r[c(W, I)] || n.cells[c(W, I)] !== Z) && (g = !1);
+      if (!g) {
+        R += 1;
+        continue;
+      }
+      for (let I = d; I < d + B; I++) for (let W = R; W < R + F; W++) a(W, I, I < d + 2 ? bt : Q);
+      const A = R + (F >> 1), $ = m ? d + B - 1 : d;
+      if (a(A, $, dt), m) for (let I = $ + 1; I <= l[A] - 1; I++) a(A, I, ct);
+      else for (let I = $ - 1; I >= l[A] + 1; I--) a(A, I, ct);
+      M(R, d, 0);
+      for (let I = d; I < d + B; I++) for (let W = R; W < R + F; W++) r[c(W, I)] = 1;
+      f.push({ cell: c(A, $), d: Math.abs(A - C) }), R += F + o.int(1, 2);
+    }
+  const w = f.slice().sort((m, R) => m.d - R.d || m.cell - R.cell), L = new Set(w.slice(0, Math.min(3, Math.floor(f.length / 3))).map((m) => m.cell));
+  let P = 0, z = 0;
+  for (const m of f.slice().sort((R, F) => R.cell - F.cell))
+    b.push(L.has(m.cell) ? { cell: m.cell, kind: "shop", label: `Shop ${++z}` } : { cell: m.cell, kind: "home", label: `Home ${++P}` });
+  for (let m = 2; m < e - 2; m++)
+    for (let R = 2; R < t - 2; R++) {
+      const F = c(R, m);
+      n.cells[F] !== Z || r[F] || (s.tree && o.chance(0.03) ? n.cells[F] = J : s.decor && o.chance(0.05) && (n.cells[F] = ut));
+    }
+  const E = c(1, l[1]), U = c(t - 2, l[t - 2]), N = st(n, E);
+  for (let m = 0; m < N.length; m++) !tt(n.cells[m]) && N[m] < 0 && (n.cells[m] = s.tree ? J : Q);
+  return { area: n, entry: E, exit: U, links: b };
+}
+const Qt = (t) => t * t * (3 - 2 * t);
+function It(t, e, o, s, n) {
+  const c = n ? Math.max(2, Math.round(t / s)) : Math.ceil(t / s) + 1, a = n ? Math.max(2, Math.round(e / s)) : Math.ceil(e / s) + 1, x = Array.from({ length: c * a }, () => o.next()), y = new Float32Array(t * e), h = n ? c / t : 1 / s, l = n ? a / e : 1 / s;
+  for (let i = 0; i < e; i++)
+    for (let r = 0; r < t; r++) {
+      const M = r * h, T = i * l, k = Math.floor(M), b = Math.floor(T), C = Qt(M - k), p = Qt(T - b), f = (P, z) => x[z % a * c + P % c], w = f(k, b) + (f(k + 1, b) - f(k, b)) * C, L = f(k, b + 1) + (f(k + 1, b + 1) - f(k, b + 1)) * C;
+      y[i * t + r] = w + (L - w) * p;
+    }
+  return y;
+}
+const Ft = (t, e) => [...t].sort((o, s) => o - s)[Math.floor(t.length * e)];
+function Le(t, e, o, s) {
+  const n = pt(t, e, Z), c = (v, u) => u * t + v, a = It(t, e, o, 16, s.wrap), x = It(t, e, o, 8, s.wrap), y = It(t, e, o, 4, s.wrap), h = a.map((v, u) => v * 0.6 + x[u] * 0.3 + y[u] * 0.1), l = It(t, e, o, 12, s.wrap), i = Ft(h, 0.24), r = Ft(h, 0.93), M = Ft(l, 0.66);
+  for (let v = 0; v < t * e; v++)
+    h[v] < i ? n.cells[v] = it : s.rock && h[v] > r ? n.cells[v] = Et : s.tree && l[v] > M ? n.cells[v] = J : s.decor && o.chance(0.04) && (n.cells[v] = ut);
+  const T = (v) => v !== it, k = new Int32Array(t * e).fill(-1);
+  let b = -1, C = 0, p = 0;
+  for (let v = 0; v < t * e; v++) {
+    if (!T(n.cells[v]) || k[v] >= 0) continue;
+    const u = [v];
+    k[v] = p;
+    let d = 0;
+    for (; u.length; ) {
+      const g = u.pop();
+      d++;
+      const A = g % t, $ = g / t | 0;
+      for (const [I, W] of [
+        [1, 0],
+        [-1, 0],
+        [0, 1],
+        [0, -1]
+      ]) {
+        const q = A + I, O = $ + W;
+        if (q < 0 || O < 0 || q >= t || O >= e) continue;
+        const _ = c(q, O);
+        k[_] < 0 && T(n.cells[_]) && (k[_] = p, u.push(_));
+      }
+    }
+    d > C && (b = p, C = d), p++;
+  }
+  for (let v = 0; v < t * e; v++) T(n.cells[v]) && k[v] !== b && (n.cells[v] = it);
+  const f = ["town", "dungeon", "castle", "town", "dungeon"], w = t * e >= 3600 ? 5 : 4, L = [], P = Math.max(10, Math.floor(Math.min(t, e) / 4));
+  for (let v = 0; v < 4e3 && L.length < w; v++) {
+    const u = o.int(3, t - 4), d = o.int(3, e - 4);
+    let g = !0;
+    for (let A = -2; A <= 2 && g; A++) for (let $ = -2; $ <= 2; $++) n.cells[c(u + $, d + A)] === it && (g = !1);
+    g && L.every((A) => Math.abs(A % t - u) + Math.abs((A / t | 0) - d) >= P) && L.push(c(u, d));
+  }
+  L.sort((v, u) => v % t - u % t);
+  for (const v of L) {
+    const u = v % t, d = v / t | 0;
+    for (let g = -1; g <= 1; g++) for (let A = -1; A <= 1; A++) n.cells[c(u + A, d + g)] = Z;
+  }
+  const z = { w: t, h: e, cells: n.cells.map((v) => v === it ? it : Z) }, E = new Float32Array(t * e);
+  for (let v = 0; v < E.length; v++) E[v] = n.cells[v] === Et ? 14 : n.cells[v] === J ? 4 : 1 + o.next() * 0.6;
+  const U = L.length ? [L[0]] : [];
+  for (const v of L.slice(1)) {
+    const u = U.reduce(
+      (d, g) => Math.abs(d % t - v % t) + Math.abs((d / t | 0) - (v / t | 0)) <= Math.abs(g % t - v % t) + Math.abs((g / t | 0) - (v / t | 0)) ? d : g
+    );
+    for (const d of fe(z, u, v, E))
+      n.cells[d] = ct, E[d] = 0.2;
+    U.push(v);
+  }
+  const N = [], m = {};
+  L.forEach((v, u) => {
+    n.cells[v] = dt;
+    const d = f[u % f.length];
+    m[d] = (m[d] ?? 0) + 1, N.push({ cell: v, kind: d, label: `${d[0].toUpperCase()}${d.slice(1)} ${m[d]}` });
+  });
+  const R = L.length ? L[0] + t : c(t >> 1, e >> 1), F = st(n, R);
+  for (let v = 0; v < F.length; v++) !tt(n.cells[v]) && F[v] < 0 && (n.cells[v] = it);
+  const B = L.length > 1 ? L[L.length - 1] : R;
+  return { area: n, entry: R, exit: B, links: N };
+}
+const te = (t) => Math.max(1, t);
+function Ce(t) {
+  let e, o, s = !1, n, c, a;
+  const x = (i) => i >> 8;
+  for (let i = 5; i < xe; i++) {
+    const r = t.sequences[i];
+    if (!r.key && !r.jstkMov) continue;
+    const M = r.frames.findIndex((p) => p.pic2 === pe + 1), T = r.frames.slice(0, M < 0 ? r.frames.length : M);
+    if (!T.length) continue;
+    const k = T.reduce((p, f) => p + f.x, 0), b = T.reduce((p, f) => p + f.y, 0), C = T.reduce((p, f) => p + te(f.pause), 0);
+    if (r.momentum && b < 0 && !o) {
+      const p = [];
+      let f = 0;
+      for (const w of T)
+        p[f] = (p[f] ?? 0) + w.y, f += te(w.pause);
+      o = { push: p, ground: !!r.ground, key: x(r.key) };
+    } else !r.momentum && k > 0 && b === 0 && !e ? e = { dx: k, ticks: C, key: x(r.key) } : !r.momentum && k < 0 && b === 0 && n === void 0 ? n = r.key ? x(r.key) : void 0 : !r.momentum && b < 0 && k === 0 ? (s = !0, c ??= r.key ? x(r.key) : void 0) : !r.momentum && b > 0 && k === 0 && (a ??= r.key ? x(r.key) : void 0);
+  }
+  if (!e) return { ok: !1, message: "The hero has no walking sequence to the right, so there is nothing to measure a side view by." };
+  if (!o) return { ok: !1, message: "The hero has no jump (a sequence that pushes him up as momentum), so a side view cannot be checked." };
+  const y = {
+    vx: e.dx / e.ticks,
+    push: o.push,
+    steer: !o.ground,
+    climb: s,
+    rise: 0,
+    keys: { right: e.key, left: n, jump: o.key, up: c, down: a }
+  }, h = je(y, "jump", 0, 0);
+  let l = 0;
+  for (const i of h.dy) y.rise = Math.max(y.rise, l -= i);
+  return y.rise < 10 ? { ok: !1, message: "The hero’s jump is too small to cross anything." } : { ok: !0, physics: y };
+}
+function Ve(t, e, o) {
+  return { ...t, vx: t.vx * e, push: t.push.map((s) => Math.round(s * o)), rise: t.rise * o * o };
+}
+const jt = 90;
+class he {
+  constructor(e, o, s, n) {
+    this.p = e, this.kind = o, this.dir = s, this.steerTicks = n;
+  }
+  p;
+  kind;
+  dir;
+  steerTicks;
+  vy = 0;
+  t = 0;
+  step() {
+    const { p: e, t: o } = this;
+    return this.kind === "jump" && (this.vy += e.push[o] ?? 0), o % ye === 0 && (this.vy += 1), this.vy = Math.max(-gt * 4, Math.min(gt * 4, this.vy)), this.t++, {
+      dy: Math.max(-gt, Math.min(gt, this.vy)),
+      dx: this.dir && o >= 1 && o <= this.steerTicks && (e.steer || this.kind === "fall") ? Math.round(this.dir * e.vx) : 0
+    };
+  }
+  /**
+   * A block with no gravity holds him (engine/character.ts onGround): the tick he reaches it his speed fades to 5/6 once; after
+   * that `slide` moves him by his speed and fades it twice a tick (the ground check runs after the sideways move and again
+   * after the vertical one), while the walk key goes on steering him for its ticks.
+   */
+  fade() {
+    this.vy = Math.trunc(this.vy * 5 / 6);
+  }
+  slide() {
+    const { p: e, t: o } = this, s = Math.max(-gt, Math.min(gt, this.vy)), n = this.dir && o >= 1 && o <= this.steerTicks && (e.steer || this.kind === "fall") ? Math.round(this.dir * e.vx) : 0;
+    return this.vy = Math.trunc(Math.trunc(this.vy * 5 / 6) * 5 / 6), this.t++, { dx: n, dy: s, done: this.vy === 0 && s === 0 && this.t > this.steerTicks };
+  }
+  /** He has landed (the ground check stopped his fall): his speed is gone, and the gravity clock runs on. */
+  land() {
+    this.vy = 0;
+  }
+  bump() {
+    this.vy < 0 && (this.vy = 0);
+  }
+}
+function je(t, e, o, s) {
+  const n = new he(t, e, o, s), c = [], a = [];
+  for (let x = 0; x < jt; x++) {
+    const y = n.step();
+    c.push(y.dx), a.push(y.dy);
+  }
+  return { dx: c, dy: a };
+}
+function Ne() {
+  const t = [], e = [3, 6, 9, 12, 15, 18, 22, jt];
+  for (const o of ["jump", "fall"])
+    for (const s of [-1, 0, 1]) for (const n of s ? e : [0]) t.push({ kind: o, dir: s, steerTicks: n });
+  return t;
+}
+const nt = 0, Pt = 1, wt = 2, vt = 3;
+function Ht(t, e, o, s, n = {}) {
+  const { goal: c } = n, { w: a, h: x } = t, y = new Uint8Array(a * x), h = new Uint8Array(a * x), l = (u, d) => u < 0 || u >= a || d >= x ? Q : d < 0 ? 255 : t.cells[d * a + u], i = (u) => u === Q || u === bt || u === Ot && !s, r = (u, d) => {
+    const g = Math.floor((d - j) / j), A = Math.floor((d + j - 1) / j);
+    let $ = nt;
+    for (let I = g; I <= A; I++)
+      for (let W = Math.floor(u / j); W <= Math.floor((u + j - 1) / j); W++) {
+        const q = l(W, I);
+        if (q === ht) return wt;
+        if (q === 255) return vt;
+        i(q) && ($ = Pt);
+      }
+    return $;
+  }, M = (u, d) => {
+    const g = Math.floor((d - j) / j), A = Math.floor((d + j - 1) / j);
+    for (let $ = g; $ <= A; $++) for (let I = Math.floor(u / j); I <= Math.floor((u + j - 1) / j); I++) if (l(I, $) === xt) return !0;
+    return !1;
+  }, T = (u, d) => {
+    const g = Math.floor((d - j) / j), A = Math.floor((d + j - 1) / j);
+    for (let $ = Math.max(0, g); $ <= Math.min(x - 1, A); $++)
+      for (let I = Math.floor(u / j); I <= Math.floor((u + j - 1) / j); I++) I >= 0 && I < a && (y[$ * a + I] = 1);
+  }, k = (u) => i(u) || u === xt, b = (u, d) => {
+    const g = Math.floor(u / j), A = u - g * j, $ = l(g, d + 1), I = A > 0 ? l(g + 1, d + 1) : nt, W = k($), q = k(I), O = $ === ht || I === ht;
+    return !W && !q ? { held: !1, x: u, spiked: O } : W && !q && A > j / 2 ? { held: !1, x: (g + 1) * j, spiked: O } : q && !W && A < j / 2 ? { held: !1, x: g * j, spiked: O } : { held: !0, x: u, spiked: O };
+  }, C = (u, d) => {
+    const g = Math.floor((u + j / 2) / j);
+    return l(g, d) === ft || l(g, d - 1) === ft;
+  }, p = (u, d) => {
+    const g = b(u, d);
+    return C(u, d) || g.held && !g.spiked;
+  }, f = Math.max(1, Math.round(e.vx)), w = (u, d) => {
+    const g = Math.floor((u + j / 2) / j);
+    if (g < 6 || g > a - 7 || d < 5 || d + 1 >= x) return !1;
+    for (let A = g - 5; A <= g + 5; A++) {
+      const $ = l(A, d + 1);
+      if (!(i($) || $ === xt)) return !1;
+      for (let I = d - 5; I <= d; I++) {
+        const W = l(A, I);
+        if (i(W) || W === ht || W === ft || W === xt) return !1;
+      }
+    }
+    return !0;
+  }, L = a * j * x, P = new Uint8Array(L), z = (u, d) => d * a * j + u, E = [];
+  let U = !1;
+  const N = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map(), R = (u, d, g) => {
+    if (d < 0 || d >= x || u < 0 || u >= a * j) return;
+    const A = z(u, d);
+    if (P[A]) return;
+    P[A] = 1, E.push(u, d);
+    const $ = d * a + Math.min(a - 1, Math.floor((u + j / 2) / j));
+    n.route && (g && N.set(A, { ...g, to: { X: u, row: d } }), m.has($) || m.set($, A)), h[$] = 1, c !== void 0 && h[c] && (U = !0);
+  }, F = Ne(), B = (u, d, g, A, $, I) => {
+    const W = I ?? { X: u, row: Math.round(d / j) }, q = new he(e, g, A, $);
+    let O = u, _ = d;
+    for (let Y = 0; Y < jt; Y++) {
+      const K = q.step();
+      if (K.dx) {
+        const G = r(O + K.dx, _);
+        if (G === wt || G === vt || G === nt && M(O + K.dx, _)) return;
+        G === nt && (O += K.dx);
+      }
+      const H = _ + K.dy;
+      if (K.dy > 0) {
+        const G = Math.floor((H + j - 1) / j);
+        if (G >= x) return;
+        const V = Math.floor((O + j / 2) / j);
+        if (G > Math.floor((_ + j - 1) / j)) {
+          const lt = b(O, G - 1);
+          if (lt.held || lt.x !== O) {
+            if (r(O, H) === wt) return;
+            const rt = G - 1;
+            if (r(O, rt * j) !== nt) return;
+            if (lt.held) {
+              if (lt.spiked && !C(O, rt)) return;
+              T(O, rt * j), R(O, rt, { kind: g, dir: A, steerTicks: $, from: W, startX: u });
+              return;
+            }
+            if (r(lt.x, rt * j) !== nt) return;
+            O = lt.x, _ = rt * j, q.land(), T(O, _);
+            continue;
+          }
+        }
+        const et = r(O, H);
+        if (et === wt || et === vt || et === Pt && [Math.floor((H - j) / j), Math.floor((H + j - 1) / j)].some((lt) => i(l(V, lt)))) return;
+        _ = H;
+      } else if (K.dy < 0) {
+        const G = r(O, H);
+        if (G === vt) return;
+        if (G === Pt) {
+          q.bump();
+          let V = _;
+          for (; r(O, V - 1) === nt; ) V--;
+          _ = V;
+        } else {
+          if (G === wt) return;
+          _ = H;
+        }
+      }
+      T(O, _);
+      const S = () => Math.floor((O + j / 2) / j), D = () => Math.floor((_ + j / 2) / j);
+      if (l(S(), D()) === ft) {
+        q.fade();
+        for (let G = 0; G < jt; G++) {
+          const V = q.slide();
+          if (V.dx) {
+            const et = r(O + V.dx, _);
+            if (et === wt || et === vt) return;
+            et === nt && (O += V.dx);
+          }
+          if (V.dy) {
+            if (r(O, _ + V.dy) !== nt) return;
+            _ += V.dy;
+          }
+          if (T(O, _), l(S(), D()) !== ft) return;
+          if (V.done) break;
+        }
+        r(O, D() * j) === nt && R(O, D(), { kind: g, dir: A, steerTicks: $, from: W, startX: u });
+        return;
+      }
+    }
+  };
+  R(o % a * j, Math.floor(o / a));
+  for (let u = 0; u < E.length && !U; u += 2) {
+    const d = E[u], g = E[u + 1], A = g * j;
+    if (r(d, A) !== nt) continue;
+    T(d, A);
+    const $ = l(Math.floor((d + j / 2) / j), g) === ft;
+    for (const I of [-1, 1]) {
+      const W = d + I * f;
+      if (!(W < 0 || W > a * j - j || r(W, A) !== nt) && !(b(W, g).spiked && !C(W, g)))
+        if (T(W, A), p(W, g)) R(W, g, { kind: "walk", dir: I, steerTicks: 0, from: { X: d, row: g }, startX: d });
+        else {
+          const q = b(W, g).x;
+          if (r(q, A) === nt)
+            for (const O of F) O.kind === "fall" && O.dir !== 0 && B(q, A, "fall", O.dir, O.steerTicks, { X: d, row: g });
+        }
+    }
+    if (!$ && !w(d, g))
+      for (const I of F) I.kind === "jump" && B(d, A, "jump", I.dir, I.steerTicks);
+    if (!p(d, g))
+      for (const I of F) I.kind === "fall" && B(d, A, "fall", I.dir, I.steerTicks, { X: d, row: g });
+    if ($ && e.climb) {
+      const I = Math.floor((d + j / 2) / j);
+      for (const W of [-1, 1])
+        l(I, g + W) === ft && r(d, (g + W) * j) === nt && R(d, g + W, { kind: "climb", dir: 0, steerTicks: 0, from: { X: d, row: g }, startX: d });
+    }
+  }
+  return { touched: y, stood: h, routeTo: (u) => {
+    const d = m.get(u);
+    if (d === void 0) return;
+    const g = [];
+    for (let A = N.get(d); A; A = N.get(z(A.from.X, A.from.row))) g.unshift(A);
+    return g;
+  } };
+}
+const ee = 26, Mt = 18;
+function $t(t, e, o, s = !1) {
+  const n = 10 + e + 8, c = pt(n, ee, yt), a = (y, h) => {
+    for (let l = h; l < ee; l++) c.cells[l * n + y] = Q;
+  };
+  for (let y = 0; y < 10; y++) a(y, Mt);
+  for (let y = 10 + e; y < n; y++) a(y, Mt - o);
+  if (s)
+    for (let y = 10; y < 10 + e; y++) a(y, Mt), c.cells[(Mt - 1) * n + y] = ht;
+  const x = 10 + e + 4 + (Mt - o - 1) * n;
+  return Ht(c, t, 5 + (Mt - 1) * n, !0, { goal: x }).stood[x] === 1;
+}
+const oe = /* @__PURE__ */ new Map();
+function ze(t) {
+  const e = JSON.stringify([t.vx, t.push.map((x) => x ?? 0), t.steer, t.climb]), o = oe.get(e);
+  if (o) return o;
+  let s = 0;
+  for (; s < 10 && $t(t, 0, s + 1); ) s++;
+  const n = [];
+  for (let x = 0; x <= s; x++) {
+    let y = 0;
+    for (; y < 14 && $t(t, y + 1, x); ) y++;
+    n.push(y);
+  }
+  let c = 0;
+  for (; c < 10 && $t(t, c + 1, 0, !0); ) c++;
+  const a = { maxRise: s, maxGap: n[0], gapAt: n, maxSpikes: c };
+  return oe.set(e, a), a;
+}
+const ne = 2;
+function De(t, e, o, s, n) {
+  const c = pt(t, e, yt), a = ze(s.physics), x = [], y = Math.max(1, Math.floor(a.maxRise * n)), h = (O) => Math.max(1, Math.floor((a.gapAt[Math.max(0, Math.min(O, a.gapAt.length - 1))] ?? a.maxGap) * n)), l = Math.ceil((s.physics.rise + j) / j), i = Math.max(l + 1, Math.ceil(s.physics.rise / j) + 3), r = e - 4, M = (O, _, Y) => c.cells[_ * t + O] = Y, T = (O, _) => {
+    for (let Y = _; Y < e; Y++) M(O, Y, Y === _ && s.cap ? bt : Q);
+  };
+  for (let O = 0; O < e; O++) M(0, O, Q), M(t - 1, O, Q);
+  let k = 1, b = Math.max(i, Math.min(r, e - 6));
+  const C = [], p = [], f = [], w = [], L = [], P = (O) => {
+    const _ = k;
+    for (let Y = 0; Y < O && k < t - 1; Y++) T(k++, b);
+    C.push({ x0: _, len: k - _, s: b });
+  }, z = { rise: 0, gap: 0 };
+  P(6);
+  const E = (b - 1) * t + 3, U = Math.min(2, y);
+  for (; k < t - 12; ) {
+    const O = ["flat", "flat", "gap", "gap", "gap", "step", "step", "step"];
+    s.hazard && O.push("spikes", "spikes");
+    const _ = (r - b) / Math.max(1, r - i);
+    s.ladder && s.physics.climb && b - (y + 1) >= i && _ < 0.6 && O.push("tower"), s.ledge && y >= 2 && b - l - 1 >= 2 && O.push("ledge", "ledge"), t - 1 - k > 24 && O.push("stones", "stones");
+    const Y = o.pick(O);
+    if (Y === "flat") P(o.int(3, 8));
+    else if (Y === "gap") {
+      const K = o.int(1, h(0)), H = Math.min(e - 2, b + U);
+      for (let S = 0; S < K; S++) {
+        s.hazard && M(k + S, H, ht);
+        for (let D = H + (s.hazard ? 1 : 0); D < e; D++) M(k + S, D, Q);
+      }
+      z.gap = Math.max(z.gap, K), p.push({ x: k, g: K, s: b }), k += K, P(o.int(2, 4));
+    } else if (Y === "step") {
+      const K = o.chance(0.7 - 0.6 * _), H = o.int(1, y), S = K ? b - H : b + H;
+      S >= i && S <= r && (z.rise = Math.max(z.rise, H), b = S), P(o.int(2, 5));
+    } else if (Y === "spikes") {
+      const K = o.int(1, Math.max(1, Math.min(2, Math.floor(a.maxSpikes * n * 0.5)))), H = 8 + K, S = k;
+      P(H);
+      const D = S + 3 + o.int(0, 1);
+      for (let G = 0; G < K; G++) M(D + G, b - 1, ht);
+      w.push(D);
+    } else if (Y === "tower") {
+      const K = o.int(y + 1, y + 4), H = b - K;
+      if (H < i) continue;
+      T(k, b);
+      for (let S = H - 1; S <= b - 1; S++) M(k, S, ft);
+      k++, b = H, P(o.int(3, 5));
+    } else if (Y === "ledge") {
+      const K = o.int(2, Math.min(y, b - l - 1)), H = 9, S = k;
+      P(H);
+      const D = o.int(3, 4), G = S + 3;
+      for (let V = 0; V < D; V++) M(G + V, b - K, xt);
+      L.push({ x: G, len: D, t: b - K });
+    } else {
+      const K = o.int(2, 4), H = [];
+      let S = k, D = b;
+      for (let ot = 0; ot < K; ot++) {
+        const at = o.int(-y, y);
+        let kt = Math.max(i, Math.min(r - 1, D - at));
+        ot === 0 && (kt = Math.min(kt, b));
+        const Nt = o.int(1, h(Math.max(0, D - kt)));
+        z.gap = Math.max(z.gap, Nt), z.rise = Math.max(z.rise, Math.abs(D - kt));
+        const Xt = o.int(2, 3);
+        H.push({ x: S + Nt, len: Xt, t: kt }), S += Nt + Xt, D = kt;
+      }
+      const G = Math.max(...H.map((ot) => ot.t)), V = H[H.length - 1], et = o.int(1, h(0));
+      z.gap = Math.max(z.gap, et);
+      const lt = S + et;
+      if (lt + 8 >= t - 1) continue;
+      const rt = Math.min(e - 2, G + 1), Vt = Math.max(V.t, rt - y);
+      if (Vt > r) continue;
+      for (let ot = k; ot < lt; ot++) {
+        s.hazard && M(ot, rt, ht);
+        for (let at = rt + (s.hazard ? 1 : 0); at < e; at++) M(ot, at, Q);
+      }
+      for (const ot of H) {
+        for (let at = ot.x; at < ot.x + ot.len; at++) M(at, ot.t, s.ledge ? xt : Q);
+        f.push(ot);
+      }
+      k = lt, b = Vt, P(o.int(3, 5));
+    }
+  }
+  P(t - 1 - k);
+  const N = t - 4, m = (b - 1) * t + N, R = { exit: !1, collectable: !0, lockHolds: !0 }, F = Ht(c, s.physics, E, !0);
+  R.exit = F.stood[m] === 1;
+  const B = /* @__PURE__ */ new Set([E, m]), v = [];
+  let u;
+  const d = [], g = [], A = (O) => c.cells[O] === yt && !B.has(O), $ = (O, _, Y) => _.some((K) => Math.abs(K % t - O % t) < Y && Math.abs((K / t | 0) - (O / t | 0)) < 3), I = s.pairs[0];
+  if (I !== void 0 && R.exit) {
+    const O = C.filter((K) => K.len >= 7 && K.x0 > t * 0.4 && K.x0 + K.len < t - 10), _ = (K) => C.filter((H) => H.len >= 4 && H.x0 + H.len < K.x0 - 4 && H.x0 > 6), Y = O.find((K) => _(K).length > 0);
+    if (Y) {
+      const K = Y.x0 + (Y.len >> 1), H = Math.min(Y.s, Math.ceil(s.physics.rise / j) + 3), S = [];
+      for (let V = Y.s - H; V < Y.s; V++) S.push(V * t + K);
+      const D = o.pick(_(Y)), G = (D.s - 1) * t + D.x0 + (D.len >> 1);
+      if (S.every((V) => c.cells[V] === yt) && c.cells[G] === yt) {
+        for (const et of S) c.cells[et] = Ot;
+        const V = Ht(c, s.physics, E, !1);
+        if (V.stood[m] === 0 && V.touched[G] === 1) {
+          c.cells[G] = Kt, B.add(G);
+          for (const et of S) B.add(et);
+          g.push(...S), d.push({ cell: S[S.length - 1], key: G, pair: I, order: 0 });
+        } else {
+          for (const et of S) c.cells[et] = yt;
+          x.push(
+            V.stood[m] ? "A locked door could be jumped over, so none was drawn." : "The key could not be reached before its door, so no door was drawn."
+          );
+        }
+      }
+    }
+  }
+  const W = F;
+  if (s.treasure && R.exit) {
+    const O = [], _ = (S, D) => {
+      if (S < 1 || S >= t - 1 || D < 1 || D >= e) return;
+      const G = D * t + S;
+      A(G) && W.touched[G] && O.push(G);
+    };
+    for (const S of C) for (let D = S.x0 + 1; D < S.x0 + S.len - 1; D += 3) Math.abs(D - 3) > 3 && Math.abs(D - N) > 3 && _(D, S.s - 1);
+    for (const S of p) {
+      const D = S.x + (S.g >> 1);
+      for (const G of [3, 2]) {
+        const V = (S.s - G) * t + D;
+        if (A(V) && W.touched[V]) {
+          O.push(V);
+          break;
+        }
+      }
+    }
+    for (const S of f) _(S.x + (S.len >> 1), S.t - 1);
+    for (const S of L) _(S.x + 1, S.t - 1);
+    const Y = Math.max(4, Math.min(30, Math.floor(t / 5))), K = [...new Set(O)].sort((S, D) => S % t - D % t), H = Math.max(1, K.length / Y);
+    for (let S = 0; S < K.length && v.length < Y; S += H) {
+      const D = K[Math.floor(S)];
+      $(D, v, 2) || v.push(D);
+    }
+    if (s.life && v.length > 2) {
+      let S = -1;
+      for (let D = 0; D < t * e; D++) {
+        if (!W.stood[D] || D % t < 8 || D % t > t - 9 || !A(D)) continue;
+        const G = D / t | 0;
+        (S < 0 || G < (S / t | 0) || G === (S / t | 0) && o.chance(0.3)) && (S = D);
+      }
+      if (S >= 0) {
+        u = S;
+        const D = v.findIndex((G) => Math.abs(G % t - S % t) < 3);
+        D >= 0 && v.splice(D, 1);
+      }
+    }
+    for (const S of v) c.cells[S] = Bt, B.add(S);
+    u !== void 0 && (c.cells[u] = Gt, B.add(u));
+  }
+  R.collectable = [...v, ...u === void 0 ? [] : [u], ...d.map((O) => O.key)].every((O) => W.touched[O] === 1);
+  const q = [];
+  if (s.monsters.length && R.exit) {
+    const O = g.length ? g[0] % t : -99, _ = [];
+    for (const H of C)
+      if (H.len >= 6) {
+        for (let S = H.x0 + ne + 1; S < H.x0 + H.len - ne - 1; S++)
+          if (S > 12 && S < t - 8 && Math.abs(S - O) > 2) {
+            const D = (H.s - 1) * t + S;
+            A(D) && W.stood[D] && _.push(D);
+          }
+      }
+    const Y = Math.max(1, Math.min(6, Math.floor(t / 18))), K = [];
+    for (let H = 0; H < _.length * 2 && q.length < Y && _.length; H++) {
+      const S = _[Math.floor(o.next() * _.length)];
+      K.some((D) => Math.abs(D % t - S % t) < 8) || (K.push(S), B.add(S), q.push({ cell: S, monnum: o.pick(s.monsters) }));
+    }
+    q.sort((H, S) => H.cell - S.cell);
+  }
+  if (s.decorate) {
+    for (const O of C)
+      if (O.len >= 5 && o.chance(0.6)) {
+        const _ = (O.s - 1) * t + O.x0 + O.len - 2;
+        A(_) && _ % t < t - 6 && !w.includes(_ % t) && (c.cells[_] = ut);
+      }
+  }
+  return !w.length && s.hazard && x.push("No spikes fit this layout."), { area: c, entry: E, exit: m, locks: d, doorCells: g, treasure: v, life: u, monsters: q, notes: x, proof: R, difficulty: n, can: { rise: a.maxRise, gap: a.maxGap }, asked: z };
+}
+function Fe(t, e, o, s) {
+  let n;
+  for (let c = 0; c < 8; c++) {
+    const a = Math.max(0.2, s.difficulty - (c >= 3 ? 0.1 * (c - 2) : 0)), x = De(t, e, o, s, a);
+    if (x.proof.exit && x.proof.collectable && x.proof.lockHolds)
+      return a < s.difficulty && x.notes.push(`Drawn a little easier than asked (${Math.round(a * 100)}%): the first layouts could not be proven.`), x;
+    n ??= x;
+  }
+  return n.notes.push("No layout could be proven reachable by jump math."), n;
+}
+const Pe = {
+  home: { w: 24, h: 16 },
+  shop: { w: 26, h: 14 },
+  castle: { w: 56, h: 40 },
+  town: { w: 80, h: 56 },
+  platform: { w: 120, h: 24 }
+}, Xe = 10, Ze = (t, e) => t + Math.imul(e, 2654435761) >>> 0, $e = (t, e) => X(t, e)[0];
+function We(t, e) {
+  const o = ge(e.kind, t);
+  if (!o.ok) return { ok: !1, message: o.message };
+  const s = se(e.kind).min;
+  if (e.rect.w < s.w || e.rect.h < s.h)
+    return { ok: !1, message: `That area is small: a ${e.kind} needs at least ${s.w} by ${s.h} blocks.` };
+  const n = Pe[e.kind], c = Math.min(e.rect.w, n?.w ?? 1 / 0), a = Math.min(e.rect.h, n?.h ?? 1 / 0), x = { x: e.rect.x + (e.rect.w - c >> 1), y: e.rect.y + (e.rect.h - a >> 1), w: c, h: a }, y = zt(e.seed), h = [...o.skipped], l = (u) => X(t, u).length > 0;
+  let i, r, M;
+  const T = {};
+  let k, b, C = [], p, f = [];
+  const w = (u, d) => {
+    const g = X(t, u);
+    return g.find((A) => t[A].facing === d) ?? g.find((A) => !t[A].facing) ?? g[0];
+  };
+  if (e.kind === "platform") {
+    if (!e.hero) return { ok: !1, message: "A side view needs the hero’s character file, to measure how he jumps." };
+    const u = Ce(e.hero);
+    if (!u.ok) return { ok: !1, message: u.message };
+    const d = Array.from({ length: Zt }, (A, $) => $ + 1).filter(
+      (A) => X(t, "locked-door", A).length && X(t, "key", A).length
+    ), g = Fe(c, a, y, {
+      physics: u.physics,
+      difficulty: Math.max(0.1, Math.min(1, (e.difficulty ?? 80) / 100)),
+      ladder: l("ladder"),
+      hazard: l("hazard"),
+      ledge: l("platform"),
+      cap: l("wall-top"),
+      pairs: d,
+      treasure: l("treasure"),
+      life: l("life"),
+      monsters: e.monsters ?? [],
+      decorate: l("decoration")
+    });
+    ({ area: i, entry: r, exit: M } = g), h.push(...g.notes), l("locked-door") && !d.length && h.push("The locked door blocks and key blocks share no lock number, so no doors were locked."), k = { proof: g.proof, difficulty: g.difficulty, can: g.can, asked: g.asked }, b = { locks: g.locks, treasure: g.treasure, life: g.life, monsters: g.monsters, doorCells: g.doorCells };
+  } else if (e.kind === "dungeon")
+    ({ area: i, entry: r, exit: M } = ae(c, a, y, l("decoration")));
+  else if (e.kind === "castle")
+    ({ area: i, entry: r, exit: M } = Te(c, a, y, { path: l("path"), decorate: l("decoration") }));
+  else if (e.kind === "town")
+    ({ area: i, entry: r, exit: M, links: f } = Ie(c, a, y, { tree: l("tree"), decor: l("decoration") }));
+  else if (e.kind === "overworld")
+    ({ area: i, entry: r, exit: M, links: f } = Le(c, a, y, { tree: l("tree"), rock: l("rock"), decor: l("decoration"), wrap: !!e.wrap }));
+  else if (e.kind === "home" || e.kind === "shop") {
+    const u = {};
+    for (const g of ["table", "chair", "bed", "counter", "shelf", "stove", "rug", "lamp", "plant"]) {
+      const A = X(t, g);
+      A.length && (u[g] = A.some(($) => !t[$].facing) ? de : [...new Set(A.map(($) => t[$].facing))]);
+    }
+    const d = Re(c, a, y, e.kind, u);
+    ({ area: i, entry: r, exit: M } = d), p = d.shopkeeper, C = d.items.map((g) => ({ ...g, block: w(g.role, g.facing) }));
+    for (const g of d.skipped)
+      h.push(
+        g === "chair" ? "Chairs skipped: no chair block faces the way a chair beside a table must." : `Some ${g}s skipped: no ${g} block faces the way it must stand against a wall.`
+      );
+  } else
+    ({ area: i, entry: r, exit: M } = Ee(c, a, y, { path: l("path"), rock: l("rock"), decor: l("decoration") }));
+  const L = e.kind === "dungeon" || e.kind === "castle" ? Array.from({ length: Zt }, (u, d) => d + 1).filter(
+    (u) => X(t, "locked-door", u).length && X(t, "key", u).length
+  ) : [], P = e.kind === "home" || e.kind === "shop" || e.kind === "town" || e.kind === "overworld", z = b || (P ? { locks: [], treasure: [], life: void 0, monsters: [] } : be(i, r, M, zt(e.seed ^ 2654435769), {
+    pairs: L,
+    treasure: l("treasure"),
+    life: l("life"),
+    monsters: e.monsters ?? []
+  })), E = e.kind === "dungeon" || e.kind === "castle";
+  E && l("locked-door") && !L.length && h.push("The locked door blocks and key blocks share no lock number, so no doors were locked."), E && L.length && !z.locks.length && h.push("No narrow passage fit a locked door in this layout.");
+  const U = {
+    [Q]: X(t, "wall").slice(0, 1),
+    [Z]: X(t, "floor"),
+    [ct]: X(t, "path").slice(0, 1),
+    [J]: X(t, "tree").slice(0, 1),
+    [Et]: X(t, "rock").slice(0, 1),
+    [ut]: X(t, "decoration"),
+    [dt]: X(t, "door").slice(0, 1),
+    [it]: X(t, "water").slice(0, 1),
+    [yt]: X(t, "sky").slice(0, 1),
+    [ft]: X(t, "ladder").slice(0, 1),
+    [ht]: X(t, "hazard").slice(0, 1),
+    [xt]: X(t, "platform").slice(0, 1),
+    [bt]: X(t, "wall-top").length ? X(t, "wall-top").slice(0, 1) : X(t, "wall").slice(0, 1)
+  }, N = $e(t, "floor"), m = new Uint8Array(i.cells.length), R = zt(e.seed ^ 1540483477);
+  for (let u = 0; u < m.length; u++) {
+    const d = U[i.cells[u]] ?? [N];
+    m[u] = i.cells[u] === Z && d.length > 1 && R.chance(0.1) ? d[R.int(1, d.length - 1)] : d[0] ?? N;
+  }
+  const F = (u) => {
+    const d = [];
+    return i.cells.forEach((g, A) => g === u && d.push(A)), d;
+  }, B = (u, d) => u.forEach((g, A) => m[g] = d[A % d.length]);
+  for (const u of z.locks)
+    m[u.cell] = X(t, "locked-door", u.pair)[0], m[u.key] = X(t, "key", u.pair)[0];
+  if (b) for (const u of b.doorCells) m[u] = X(t, "locked-door", b.locks[0].pair)[0];
+  B(z.treasure, X(t, "treasure").length ? X(t, "treasure") : [N]), z.life !== void 0 && (m[z.life] = X(t, "life")[0]);
+  for (const u of C) m[u.cell] = u.block;
+  const v = e.kind === "town" && !l("wall-top");
+  return T.wall = e.kind !== "forest" && e.kind !== "overworld" ? [...F(Q), ...v ? F(bt) : []] : void 0, T.tree = e.kind === "forest" || e.kind === "town" || e.kind === "overworld" ? F(J) : void 0, T.water = e.kind === "overworld" ? F(it) : void 0, T.path = F(ct).length ? F(ct) : void 0, {
+    ok: !0,
+    result: {
+      rect: x,
+      blocks: m,
+      kinds: i.cells,
+      terrainCells: T,
+      entry: r,
+      exit: M,
+      locks: z.locks,
+      treasure: z.treasure,
+      life: z.life,
+      monsters: z.monsters,
+      furniture: C,
+      shopkeeper: p,
+      links: f,
+      platform: k,
+      notes: h
+    }
+  };
+}
+function _e(t) {
+  const e = { w: t.rect.w, h: t.rect.h, cells: t.kinds }, o = st(e, t.entry);
+  let s = 0, n = 0;
+  for (let c = 0; c < o.length; c++)
+    tt(e.cells[c]) || (s++, o[c] >= 0 && n++);
+  return { ok: s === n && s > 0, open: s, reached: n };
+}
+function Ue(t) {
+  if (!t.furniture.length) return !0;
+  const e = { w: t.rect.w, h: t.rect.h, cells: t.kinds }, o = st(e, t.entry), s = new Set(t.furniture.filter((n) => n.role === "table").map((n) => n.cell));
+  return t.furniture.every((n) => {
+    const c = n.cell % e.w, a = n.cell / e.w | 0;
+    if (n.open) return o[n.cell] >= 0;
+    if (n.role === "chair") {
+      const [x, y] = Ct[n.facing];
+      if (!s.has((a + y) * e.w + c + x)) return !1;
+    }
+    return Object.values(Ct).some(([x, y]) => {
+      const h = c + x, l = a + y;
+      return h >= 0 && l >= 0 && h < e.w && l < e.h && o[l * e.w + h] >= 0;
+    });
+  });
+}
+function He(t) {
+  if (!t.links.length) return !0;
+  const e = { w: t.rect.w, h: t.rect.h, cells: t.kinds }, o = st(e, t.entry);
+  return t.links.every((s) => o[s.cell] >= 0);
+}
+function qe(t) {
+  const e = { w: t.rect.w, h: t.rect.h, cells: t.kinds }, o = [...t.treasure, ...t.life === void 0 ? [] : [t.life]];
+  if (t.platform) {
+    const c = t.platform.proof;
+    return { reach: c.exit, keysFirst: c.lockHolds, collectable: c.collectable, furnished: !0, linked: !0 };
+  }
+  const s = ve(e, t.entry, t.exit, t.locks, o);
+  return { reach: _e(t).ok, keysFirst: s.strict, collectable: s.ok, furnished: Ue(t), linked: He(t) };
+}
+const Je = { LOCK: Ot, KEY: Kt, TREASURE: Bt, LIFE: Gt };
+function Qe(t) {
+  return We(t.roles, { kind: "platform", seed: t.seed, rect: t.rect, hero: t.hero, difficulty: t.difficulty, monsters: t.monsters });
+}
+export {
+  dt as DOOR_CELL,
+  Z as FLOOR_CELL,
+  ke as KINDS,
+  ft as LADDER_CELL,
+  Ot as LOCK_CELL,
+  Xe as MIN_SIDE,
+  ct as PATH_CELL,
+  Je as PROP_KINDS,
+  ze as capability,
+  ge as checkNeeds,
+  tt as closedCell,
+  We as generate,
+  Qe as generatePlatform,
+  Ce as heroPhysics,
+  se as kindInfo,
+  Ze as offerSeed,
+  qe as proveResult,
+  Ht as reachFrom,
+  _e as verifyReach,
+  Ve as weaker
+};