Game: free-roam overworld with biome-themed enemy spawning

Rebuild the Game page from a fixed arena into a free-roam map: the hero roams the whole three-band overworld and enemies spawn around it as you explore — RTS humans on the Forgotten Plains, orcs in the Orc Kingdom, the Dark Brotherhood in the Necropolis — culled as you move on.

- web/*.js: rebuilt bundles (comboBattler + map/classes/enemies sandboxes) from auto-battler.
- web/tiny.js: per-biome enemy rosters wired into the Game page.
- app.py: full-screen #battle-stage; relocate Gradio footer links into the sidebar.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

app.py

@@ -122,12 +122,23 @@ THEME = ('<style>'
          # Gradio still hides it (display:none on the inactive tab's ancestor).
          '.gradio-container .tabitem{padding:0 !important;}'
          '.gradio-container .tabs{border:0 !important;}'
-         '#sprite-stage,#persona-stage,#diary-stage,#classes-stage,#enemies-stage,#worldmap-stage{position:fixed !important;top:0;bottom:0;'
+         '#sprite-stage,#persona-stage,#diary-stage,#classes-stage,#enemies-stage,#worldmap-stage,#battle-stage{position:fixed !important;top:0;bottom:0;'
          'right:0;left:var(--tac-w,240px);height:auto !important;z-index:1;}'
          'body.tac-collapsed #sprite-stage,body.tac-collapsed #persona-stage,'
          'body.tac-collapsed #diary-stage,body.tac-collapsed #classes-stage,body.tac-collapsed #enemies-stage,'
-         'body.tac-collapsed #worldmap-stage{left:0;}'
-         '@media (max-width:768px){#sprite-stage,#persona-stage,#diary-stage,#classes-stage,#enemies-stage,#worldmap-stage{left:0;}}'
+         'body.tac-collapsed #worldmap-stage,body.tac-collapsed #battle-stage{left:0;}'
+         '@media (max-width:768px){#sprite-stage,#persona-stage,#diary-stage,#classes-stage,#enemies-stage,#worldmap-stage,#battle-stage{left:0;}}'
+         # Gradio's relocated footer links (Use via API / Built with Gradio / Settings), styled to look
+         # like the sidebar nav items WITHOUT the tac-nav-item class — that class makes sidebar.js hijack
+         # the click (mark them active = white, and swallow navigation). web/tiny.js copies the reference
+         # nav item's padding onto them; here we mirror the rest (icon on the left, hover, colour).
+         '#tac-extlinks .tac-extlink{display:flex !important;align-items:center;gap:8px !important;width:100%;'
+         'min-height:0 !important;background:none !important;border:0 !important;border-radius:0 !important;'
+         'box-shadow:none !important;justify-content:flex-start !important;text-align:left !important;'
+         'color:var(--tac-ink) !important;font-family:var(--tac-font) !important;font-size:14px !important;'
+         'font-weight:500 !important;text-decoration:none !important;cursor:pointer;}'
+         '#tac-extlinks .tac-extlink:hover{background:var(--tac-bg-2) !important;}'
+         '#tac-extlinks .tac-extlink img,#tac-extlinks .tac-extlink svg{order:-1;width:18px !important;height:18px !important;flex-shrink:0;margin:0 !important;}'
          '</style>')
 # `upgrade-insecure-requests` is needed on the HTTPS Space (prevents mixed-content behind HF's
 # TLS edge) but BREAKS plain-http LAN testing: it forces every asset/manifest/frame URL to https
@@ -145,7 +156,9 @@ HEAD = (_CSP
         '<link rel="stylesheet" href="/web/shell/worldmap.css">'
         '<script type="module" src="/web/tiny.js"></script>'
         '<script src="/web/shell/sidebar.js"></script>')
-STAGE = "height:56vh;border:1px solid #20262e;border-radius:12px;overflow:hidden;background:#0b0e12"
+# The Game stage fills the whole content area (full-screen map), like the other stages — the
+# `#battle-stage` rules above lift it out of Gradio's flow; this just sets the load-time background.
+STAGE = "background:#0b0e12"
 
 
 # Shared app-shell sidebar: rendered from the SAME nav.json + sidebar.css +
@@ -176,11 +189,17 @@ def build_sidebar(nav):
         out.append('<div class="tac-section">')
         if sec.get("title"):
             out.append(f'<div class="tac-section-title">{sec["title"]}</div>')
-        for it in items:
-            cls = "tac-nav-item active" if first else "tac-nav-item"
-            first = False
-            out.append(f'<a class="{cls}" data-target="{it["space"]}" href="#">'
-                       f'<span class="tac-ico">{it.get("icon","")}</span><span>{it["label"]}</span></a>')
+        if sec.get("title") == "App":
+            # The App section is filled entirely by web/tiny.js, which relocates Gradio's footer links
+            # (Use via API, Built with Gradio, Settings) here — so all three share the same treatment
+            # instead of Settings being a special nav item routed back to the footer.
+            out.append('<div id="tac-extlinks"></div>')
+        else:
+            for it in items:
+                cls = "tac-nav-item active" if first else "tac-nav-item"
+                first = False
+                out.append(f'<a class="{cls}" data-target="{it["space"]}" href="#">'
+                           f'<span class="tac-ico">{it.get("icon","")}</span><span>{it["label"]}</span></a>')
         out.append('</div>')
     out.append('</aside>')
     out.append('<button class="tac-toggle tac-reopen" title="Open menu">›</button>')

web/classesSandbox.js

@@ -1022,11 +1022,11 @@ function makeActor(unit, team, id, slot) {
     // optional: idle until a foe is within this distance (else always engage)
   };
 }
-function makeTeamBattle({ seed = 1, players = [], enemies = [], sandbox = false, respawnDummies = 0, freeCast = false, world = null } = {}) {
+function makeTeamBattle({ seed = 1, players = [], enemies = [], sandbox = false, respawnDummies = 0, freeCast = false, world = null, field = null } = {}) {
   const actors = [];
   players.filter(Boolean).slice(0, 5).forEach((u, i) => actors.push(makeActor(u, "player", `P${i}`, i)));
   enemies.filter(Boolean).slice(0, 5).forEach((u, i) => actors.push(makeActor(u, "enemy", `E${i}`, i)));
-  return { t: 0, rng: makeRng(seed), actors, projectiles: [], log: [], over: false, winner: null, sandbox, respawnDummies, freeCast, input: {}, world };
+  return { t: 0, rng: makeRng(seed), actors, projectiles: [], log: [], over: false, winner: null, sandbox, respawnDummies, freeCast, input: {}, world, field: field || FIELD };
 }
 function setInput(b, id, cmd) {
   if (!b.input) b.input = {};
@@ -1319,9 +1319,10 @@ function applyEffect(b, src, tgt, e, delivery = "spell", s = null) {
   }
 }
 function shadowStep(b, a, tgt) {
+  const f = b.field || FIELD;
   const dx = a.x - tgt.x, dy = a.y - tgt.y, len = Math.hypot(dx, dy) || 1;
-  a.x = Math.max(0, Math.min(FIELD.w, tgt.x + dx / len * (BASIC_MELEE_GW * 0.8)));
-  a.y = Math.max(0, Math.min(FIELD.h, tgt.y + dy / len * (BASIC_MELEE_GW * 0.8)));
+  a.x = Math.max(0, Math.min(f.w, tgt.x + dx / len * (BASIC_MELEE_GW * 0.8)));
+  a.y = Math.max(0, Math.min(f.h, tgt.y + dy / len * (BASIC_MELEE_GW * 0.8)));
 }
 function fireSpellProjectiles(b, src, tgt, amt, e, n) {
   const base = dist(src, tgt) / 900;
@@ -1622,9 +1623,10 @@ function timeToHit(px, py, rvx, rvy, R) {
 }
 var clampField = (v, r, max) => Math.max(r, Math.min(max - r, v));
 function stepMove(b, a, vx, vy, dt) {
+  const f = b.field || FIELD;
   const w = b.world && b.world.walkable;
-  let nx = clampField(a.x + vx * dt, a.radius, FIELD.w);
-  let ny = clampField(a.y + vy * dt, a.radius, FIELD.h);
+  let nx = clampField(a.x + vx * dt, a.radius, f.w);
+  let ny = clampField(a.y + vy * dt, a.radius, f.h);
   if (w) {
     if (!w(nx, a.y)) nx = a.x;
     if (!w(nx, ny)) ny = a.y;
@@ -1633,6 +1635,7 @@ function stepMove(b, a, vx, vy, dt) {
   a.y = ny;
 }
 function resolveOverlaps(b) {
+  const f = b.field || FIELD;
   const live = b.actors.filter((a) => a.alive);
   for (let it = 0; it < DEOVERLAP_ITERS; it++) {
     for (let i = 0; i < live.length; i++) {
@@ -1648,10 +1651,10 @@ function resolveOverlaps(b) {
         const aShare = aFix ? 0 : oFix ? 1 : 0.5;
         const oShare = oFix ? 0 : aFix ? 1 : 0.5;
         const yPush = uy / COLLISION_Y_WEIGHT;
-        a.x = clampField(a.x - ux * push * aShare, a.radius, FIELD.w);
-        a.y = clampField(a.y - yPush * push * aShare, a.radius, FIELD.h);
-        o.x = clampField(o.x + ux * push * oShare, o.radius, FIELD.w);
-        o.y = clampField(o.y + yPush * push * oShare, o.radius, FIELD.h);
+        a.x = clampField(a.x - ux * push * aShare, a.radius, f.w);
+        a.y = clampField(a.y - yPush * push * aShare, a.radius, f.h);
+        o.x = clampField(o.x + ux * push * oShare, o.radius, f.w);
+        o.y = clampField(o.y + yPush * push * oShare, o.radius, f.h);
       }
     }
   }
@@ -2063,10 +2066,10 @@ async function createCombatRenderer({ pixi, defsById = {}, layers, coords, getBa
   const actorOf = (id) => getBattle()?.actors.find((x) => x.id === id);
   const floats = [];
   const sheetsById = {};
-  for (const [id, def] of Object.entries(defsById)) {
+  async function loadSheets(id, def) {
     if (!def?.idle) {
       sheetsById[id] = null;
-      continue;
+      return;
     }
     try {
       const load = (url) => url ? recoloredTexture(Texture, url, def.idle, def.recolor) : null;
@@ -2092,6 +2095,7 @@ async function createCombatRenderer({ pixi, defsById = {}, layers, coords, getBa
       sheetsById[id] = null;
     }
   }
+  for (const [id, def] of Object.entries(defsById)) await loadSheets(id, def);
   const skillIcons = {};
   for (const s of CB_SKILLS) {
     try {
@@ -2127,7 +2131,7 @@ async function createCombatRenderer({ pixi, defsById = {}, layers, coords, getBa
   } catch {
   }
   const skillPlay = {};
-  for (const [id, def] of Object.entries(defsById)) {
+  async function buildSkillPlay(id, def) {
     const cell = sheetsById[id]?.cell;
     const map = {};
     for (const [skillId, fxCfg] of Object.entries(def.skillFx || {})) {
@@ -2152,8 +2156,9 @@ async function createCombatRenderer({ pixi, defsById = {}, layers, coords, getBa
     }
     skillPlay[id] = map;
   }
+  for (const [id, def] of Object.entries(defsById)) await buildSkillPlay(id, def);
   const view = {};
-  for (const [id, def] of Object.entries(defsById)) {
+  function buildView(id, def) {
     const sh = sheetsById[id];
     const c = new Container();
     let sp;
@@ -2202,6 +2207,25 @@ async function createCombatRenderer({ pixi, defsById = {}, layers, coords, getBa
     units.addChild(c);
     view[id] = { def, sheets: sh, container: c, sprite: sp, overlay, overlayKey: null, bars, status, statusSprites: {}, outline, castOutline, mode: null, facing: null, flash: 0, dead: false };
   }
+  for (const [id, def] of Object.entries(defsById)) buildView(id, def);
+  async function addActor(id, def) {
+    if (view[id]) return view[id];
+    defsById[id] = def;
+    await loadSheets(id, def);
+    await buildSkillPlay(id, def);
+    buildView(id, def);
+    return view[id];
+  }
+  function removeActor(id) {
+    const v = view[id];
+    if (!v) return;
+    units.removeChild(v.container);
+    v.container.destroy({ children: true });
+    delete view[id];
+    delete sheetsById[id];
+    delete skillPlay[id];
+    delete defsById[id];
+  }
   function setLoop(v, mode, facing) {
     if (v.mode === mode && v.facing === facing) return;
     v.mode = mode;
@@ -2577,6 +2601,8 @@ async function createCombatRenderer({ pixi, defsById = {}, layers, coords, getBa
     floats,
     actorOf,
     skillPlay,
+    addActor,
+    removeActor,
     setLoop,
     playOnce,
     resume,

web/comboBattler.js

@@ -1,84 +1,9 @@
-// ../auto-battler/src/engine/rng.js
-function makeRng(seed) {
-  let a = seed >>> 0;
-  return function rng() {
-    a |= 0;
-    a = a + 1831565813 | 0;
-    let t = Math.imul(a ^ a >>> 15, 1 | a);
-    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
-    return ((t ^ t >>> 14) >>> 0) / 4294967296;
-  };
-}
-
-// ../auto-battler/src/engine/worldgen.js
-function hash2(seed, x, y) {
-  let h = Math.imul(x | 0, 374761393) + Math.imul(y | 0, 668265263) + Math.imul(seed | 0, 2654435761);
-  h = Math.imul(h ^ h >>> 13, 1274126177);
-  h ^= h >>> 16;
-  return (h >>> 0) / 4294967296;
-}
-var smooth = (t) => t * t * (3 - 2 * t);
-var lerp = (a, b, t) => a + (b - a) * t;
-function valueNoise(seed, x, y) {
-  const xi = Math.floor(x), yi = Math.floor(y);
-  const xf = x - xi, yf = y - yi;
-  const v00 = hash2(seed, xi, yi), v10 = hash2(seed, xi + 1, yi);
-  const v01 = hash2(seed, xi, yi + 1), v11 = hash2(seed, xi + 1, yi + 1);
-  const u = smooth(xf), v = smooth(yf);
-  return lerp(lerp(v00, v10, u), lerp(v01, v11, u), v);
-}
-function fbm(seed, x, y, octaves = 5, lacunarity = 2, gain = 0.5) {
-  let amp = 1, freq = 1, sum = 0, norm = 0;
-  for (let o = 0; o < octaves; o++) {
-    sum += amp * valueNoise(seed + o * 1013, x * freq, y * freq);
-    norm += amp;
-    amp *= gain;
-    freq *= lacunarity;
-  }
-  return sum / norm;
-}
-
-// ../auto-battler/src/engine/fpGen.js
-var sub = (seed, salt) => (Math.imul(seed | 0, 2654435761) ^ (salt | 0)) >>> 0;
-var DIRT_SCALE = 0.04;
-var DIRT_THRESHOLD = 0.56;
-function isDirt(seed, x, y) {
-  return fbm(sub(seed, 53543), x * DIRT_SCALE, y * DIRT_SCALE) > DIRT_THRESHOLD;
-}
-var STONE_SCALE = 0.085;
-var STONE_THRESHOLD = 0.66;
-function isStone(seed, x, y) {
-  return fbm(sub(seed, 22286), x * STONE_SCALE, y * STONE_SCALE) > STONE_THRESHOLD;
-}
-var FOREST_SCALE = 0.05;
-function forestField(seed, x, y) {
-  return fbm(sub(seed, 15740503), x * FOREST_SCALE, y * FOREST_SCALE);
-}
-var STONE_CLUMP_SCALE = 0.11;
-function stoneClumpField(seed, x, y) {
-  return fbm(sub(seed, 5702849), x * STONE_CLUMP_SCALE, y * STONE_CLUMP_SCALE);
-}
-var ELEV_SCALE = 0.025;
-var ELEV_THRESHOLD = 0.6;
-function isRaised(seed, x, y) {
-  return fbm(sub(seed, 57836), x * ELEV_SCALE, y * ELEV_SCALE) > ELEV_THRESHOLD;
-}
-var RIVER_SCALE = 0.022;
-var RIVER_WIDTH = 0.035;
-var WARP_SCALE = 0.03;
-var WARP_AMP = 22;
-function isRiver(seed, x, y) {
-  const wx = x + WARP_AMP * (fbm(sub(seed, 1297), x * WARP_SCALE, y * WARP_SCALE) - 0.5);
-  const wy = y + WARP_AMP * (fbm(sub(seed, 1298), x * WARP_SCALE, y * WARP_SCALE) - 0.5);
-  return Math.abs(fbm(sub(seed, 8654), wx * RIVER_SCALE, wy * RIVER_SCALE) - 0.5) < RIVER_WIDTH;
-}
-
 // ../auto-battler/src/render/chunkedMap.js
 function createChunkedMap(pixi, host, config) {
   const { Application, Assets, Sprite, Container, Texture, Rectangle, RenderTexture } = pixi;
-  const TILE3 = config.tile ?? 8;
-  const CHUNK2 = config.chunk ?? 32;
-  const CHUNKPX = CHUNK2 * TILE3;
+  const TILE7 = config.tile ?? 8;
+  const CHUNK5 = config.chunk ?? 32;
+  const CHUNKPX = CHUNK5 * TILE7;
   const BG = config.background ?? "#69636f";
   const Z_DEFAULT = config.zoomDefault ?? 1;
   const Z_MIN = config.zoomMin ?? 1 / 32;
@@ -91,6 +16,16 @@ function createChunkedMap(pixi, host, config) {
   const MACRO_LEVEL_MAX = config.macroLevelMax ?? 6;
   const DETAIL_BUDGET = config.detailBudget ?? 1;
   const MACRO_BUDGET = config.macroBudget ?? 8;
+  const bounds = config.bounds ? {
+    x0: config.bounds.x0 * TILE7,
+    y0: config.bounds.y0 * TILE7,
+    x1: config.bounds.x1 * TILE7,
+    y1: config.bounds.y1 * TILE7,
+    tx0: config.bounds.x0,
+    ty0: config.bounds.y0,
+    tx1: config.bounds.x1,
+    ty1: config.bounds.y1
+  } : null;
   let app = null, root = null, genRoot = null, macroRoot = null, shadowLayer = null, propLayer = null;
   let ctx = null;
   let alive = true;
@@ -98,7 +33,7 @@ function createChunkedMap(pixi, host, config) {
   let seed = config.seed ?? 1;
   let zoom = Z_DEFAULT;
   let cameraDirty = true, genPending = false, lastEmitTile = null;
-  const camera = { x: CHUNKPX / 2, y: CHUNKPX / 2 };
+  const camera = { x: config.initialCamera?.x ?? CHUNKPX / 2, y: config.initialCamera?.y ?? CHUNKPX / 2 };
   const chunks = /* @__PURE__ */ new Map();
   const macroChunks = /* @__PURE__ */ new Map();
   const fading = /* @__PURE__ */ new Set();
@@ -111,12 +46,12 @@ function createChunkedMap(pixi, host, config) {
   const pinch = { on: false, dist: 0 };
   const handlers = {};
   const emit = () => listeners.forEach((fn) => fn(getSnapshot()));
-  const getSnapshot = () => ({ seed, zoom, cx: Math.round(camera.x / TILE3), cy: Math.round(camera.y / TILE3), chunks: chunks.size });
+  const getSnapshot = () => ({ seed, zoom, cx: Math.round(camera.x / TILE7), cy: Math.round(camera.y / TILE7), chunks: chunks.size });
   function tex(source, c, r) {
     const k = source.uid + ":" + c + "," + r;
     let t = texCache.get(k);
     if (!t) {
-      t = new Texture({ source, frame: new Rectangle(c * TILE3, r * TILE3, TILE3, TILE3) });
+      t = new Texture({ source, frame: new Rectangle(c * TILE7, r * TILE7, TILE7, TILE7) });
       texCache.set(k, t);
     }
     return t;
@@ -131,16 +66,16 @@ function createChunkedMap(pixi, host, config) {
     return t;
   }
   function makeChunk(cx, cy) {
-    const x0 = cx * CHUNK2, y0 = cy * CHUNK2;
+    const x0 = cx * CHUNK5, y0 = cy * CHUNK5;
     const tmp = new Container();
     const add = (source, c, r, tx, ty) => {
       const sp = new Sprite(tex(source, c, r));
-      sp.x = tx * TILE3;
-      sp.y = ty * TILE3;
+      sp.x = tx * TILE7;
+      sp.y = ty * TILE7;
       tmp.addChild(sp);
       return sp;
     };
-    const res = config.bake({ cx, cy, x0, y0, seed, chunk: CHUNK2, tile: TILE3, ctx, tmp, app, Sprite, Texture, Rectangle, tex, texFrame, add }) || {};
+    const res = config.bake({ cx, cy, x0, y0, seed, chunk: CHUNK5, tile: TILE7, ctx, tmp, app, Sprite, Texture, Rectangle, tex, texFrame, add }) || {};
     const rt = RenderTexture.create({ width: CHUNKPX, height: CHUNKPX, autoGenerateMipmaps: true, scaleMode: "nearest" });
     rt.source.minFilter = "linear";
     rt.source.mipmapFilter = "linear";
@@ -148,12 +83,12 @@ function createChunkedMap(pixi, host, config) {
     rt.source.updateMipmaps();
     tmp.destroy({ children: true });
     const sprite = new Sprite(rt);
-    sprite.x = x0 * TILE3;
-    sprite.y = y0 * TILE3;
+    sprite.x = x0 * TILE7;
+    sprite.y = y0 * TILE7;
     return { sprite, rt, meta: res.meta ?? null, live: res.live ?? null };
   }
   function chooseMacroLevel(z) {
-    return Math.max(0, Math.min(MACRO_LEVEL_MAX, Math.round(Math.log2(MACRO_TEXEL_PX / (TILE3 * z)))));
+    return Math.max(0, Math.min(MACRO_LEVEL_MAX, Math.round(Math.log2(MACRO_TEXEL_PX / (TILE7 * z)))));
   }
   function makeMacroChunk(L, mcx, mcy) {
     const step2 = 1 << L, t0x = mcx * MCHUNK * step2, t0y = mcy * MCHUNK * step2;
@@ -174,13 +109,26 @@ function createChunkedMap(pixi, host, config) {
     const t = Texture.from(cv);
     t.source.scaleMode = "linear";
     const sprite = new Sprite(t);
-    sprite.x = t0x * TILE3;
-    sprite.y = t0y * TILE3;
-    sprite.width = sprite.height = MCHUNK * step2 * TILE3;
+    sprite.x = t0x * TILE7;
+    sprite.y = t0y * TILE7;
+    sprite.width = sprite.height = MCHUNK * step2 * TILE7;
     return { sprite, tex: t };
   }
+  function coverZoom() {
+    if (!bounds || !app) return Z_MIN;
+    return Math.max(app.screen.width / (bounds.x1 - bounds.x0), app.screen.height / (bounds.y1 - bounds.y0));
+  }
+  function clampCamera() {
+    if (!bounds || !app) return;
+    const hw = app.screen.width / 2 / zoom, hh = app.screen.height / 2 / zoom;
+    const loX = bounds.x0 + hw, hiX = bounds.x1 - hw, loY = bounds.y0 + hh, hiY = bounds.y1 - hh;
+    camera.x = loX <= hiX ? Math.min(hiX, Math.max(loX, camera.x)) : (bounds.x0 + bounds.x1) / 2;
+    camera.y = loY <= hiY ? Math.min(hiY, Math.max(loY, camera.y)) : (bounds.y0 + bounds.y1) / 2;
+  }
   function reconcile() {
     if (!genRoot || !ctx || !app) return;
+    if (bounds) zoom = Math.max(zoom, coverZoom());
+    clampCamera();
     const sx = Math.round(app.screen.width / 2 - camera.x * zoom);
     const sy = Math.round(app.screen.height / 2 - camera.y * zoom);
     for (const L of [macroRoot, genRoot, shadowLayer, propLayer]) {
@@ -217,8 +165,14 @@ function createChunkedMap(pixi, host, config) {
   }
   function reconcileDetail() {
     const halfW = app.screen.width / 2 / zoom, halfH = app.screen.height / 2 / zoom;
-    const c0 = Math.floor((camera.x - halfW) / CHUNKPX) - 1, c1 = Math.floor((camera.x + halfW) / CHUNKPX) + 1;
-    const r0 = Math.floor((camera.y - halfH) / CHUNKPX) - 1, r1 = Math.floor((camera.y + halfH) / CHUNKPX) + 1;
+    let c0 = Math.floor((camera.x - halfW) / CHUNKPX) - 1, c1 = Math.floor((camera.x + halfW) / CHUNKPX) + 1;
+    let r0 = Math.floor((camera.y - halfH) / CHUNKPX) - 1, r1 = Math.floor((camera.y + halfH) / CHUNKPX) + 1;
+    if (bounds) {
+      c0 = Math.max(c0, Math.floor(bounds.tx0 / CHUNK5));
+      c1 = Math.min(c1, Math.floor((bounds.tx1 - 1) / CHUNK5));
+      r0 = Math.max(r0, Math.floor(bounds.ty0 / CHUNK5));
+      r1 = Math.min(r1, Math.floor((bounds.ty1 - 1) / CHUNK5));
+    }
     for (const [key, ch] of chunks) {
       const [cx, cy] = key.split(",").map(Number);
       if (cx < c0 - 1 || cx > c1 + 1 || cy < r0 - 1 || cy > r1 + 1) evictChunk(key, ch);
@@ -244,10 +198,17 @@ function createChunkedMap(pixi, host, config) {
     return missing.length > DETAIL_BUDGET;
   }
   function reconcileMacro(L) {
-    const px = MCHUNK * (1 << L) * TILE3;
+    const px = MCHUNK * (1 << L) * TILE7;
     const halfW = app.screen.width / 2 / zoom, halfH = app.screen.height / 2 / zoom;
-    const c0 = Math.floor((camera.x - halfW) / px) - 1, c1 = Math.floor((camera.x + halfW) / px) + 1;
-    const r0 = Math.floor((camera.y - halfH) / px) - 1, r1 = Math.floor((camera.y + halfH) / px) + 1;
+    let c0 = Math.floor((camera.x - halfW) / px) - 1, c1 = Math.floor((camera.x + halfW) / px) + 1;
+    let r0 = Math.floor((camera.y - halfH) / px) - 1, r1 = Math.floor((camera.y + halfH) / px) + 1;
+    if (bounds) {
+      const mt = MCHUNK * (1 << L);
+      c0 = Math.max(c0, Math.floor(bounds.tx0 / mt));
+      c1 = Math.min(c1, Math.floor((bounds.tx1 - 1) / mt));
+      r0 = Math.max(r0, Math.floor(bounds.ty0 / mt));
+      r1 = Math.min(r1, Math.floor((bounds.ty1 - 1) / mt));
+    }
     for (const [key, mc] of macroChunks) {
       const [ml, mx, my] = key.split(",").map(Number);
       if (ml !== L || mx < c0 - 1 || mx > c1 + 1 || my < r0 - 1 || my > r1 + 1) {
@@ -284,7 +245,7 @@ function createChunkedMap(pixi, host, config) {
   }
   function zoomAt(factor, lx, ly) {
     if (!app) return;
-    const nz = Math.min(Z_MAX, Math.max(Z_MIN, zoom * factor));
+    const nz = Math.min(Z_MAX, Math.max(bounds ? coverZoom() : Z_MIN, zoom * factor));
     if (nz === zoom) return;
     const sw = app.screen.width, sh = app.screen.height;
     const wx = camera.x + (lx - sw / 2) / zoom, wy = camera.y + (ly - sh / 2) / zoom;
@@ -409,7 +370,7 @@ function createChunkedMap(pixi, host, config) {
     if (cameraDirty || genPending) {
       reconcile();
       cameraDirty = false;
-      const tk = Math.round(camera.x / TILE3) + "," + Math.round(camera.y / TILE3) + "," + zoom.toFixed(3);
+      const tk = Math.round(camera.x / TILE7) + "," + Math.round(camera.y / TILE7) + "," + zoom.toFixed(3);
       if (tk !== lastEmitTile) {
         lastEmitTile = tk;
         emit();
@@ -470,11 +431,17 @@ function createChunkedMap(pixi, host, config) {
   }
   function tileIndexAt(wx, wy) {
     if (!config.tileIndexAt) return null;
-    const cx = Math.floor(wx / CHUNK2), cy = Math.floor(wy / CHUNK2);
+    const cx = Math.floor(wx / CHUNK5), cy = Math.floor(wy / CHUNK5);
     const ch = chunks.get(cx + "," + cy);
     if (!ch) return null;
     return config.tileIndexAt(wx, wy, ch.meta);
   }
+  function biomeAt(wx, wy) {
+    return config.biomeAt ? config.biomeAt(seed, wx, wy) : null;
+  }
+  function getBounds() {
+    return bounds ? { x0: bounds.x0, y0: bounds.y0, x1: bounds.x1, y1: bounds.y1 } : null;
+  }
   function setEnabled(v) {
     enabled = v;
     if (v) cameraDirty = true;
@@ -523,7 +490,207 @@ function createChunkedMap(pixi, host, config) {
     ctx = null;
     texCache.clear();
   }
-  return { ready, regenerate, destroy, onChange, getSnapshot, getCamera, tileIndexAt, zoomBy, setEnabled, onTick, getEntityLayer, getApp, screenToWorld, worldToScreen, tile: TILE3 };
+  return { ready, regenerate, destroy, onChange, getSnapshot, getCamera, tileIndexAt, biomeAt, getBounds, zoomBy, setEnabled, onTick, getEntityLayer, getApp, screenToWorld, worldToScreen, tile: TILE7 };
+}
+
+// ../auto-battler/src/engine/rng.js
+function makeRng(seed) {
+  let a = seed >>> 0;
+  return function rng() {
+    a |= 0;
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+
+// ../auto-battler/src/engine/worldgen.js
+function hash2(seed, x, y) {
+  let h = Math.imul(x | 0, 374761393) + Math.imul(y | 0, 668265263) + Math.imul(seed | 0, 2654435761);
+  h = Math.imul(h ^ h >>> 13, 1274126177);
+  h ^= h >>> 16;
+  return (h >>> 0) / 4294967296;
+}
+var smooth = (t) => t * t * (3 - 2 * t);
+var lerp = (a, b, t) => a + (b - a) * t;
+function valueNoise(seed, x, y) {
+  const xi = Math.floor(x), yi = Math.floor(y);
+  const xf = x - xi, yf = y - yi;
+  const v00 = hash2(seed, xi, yi), v10 = hash2(seed, xi + 1, yi);
+  const v01 = hash2(seed, xi, yi + 1), v11 = hash2(seed, xi + 1, yi + 1);
+  const u = smooth(xf), v = smooth(yf);
+  return lerp(lerp(v00, v10, u), lerp(v01, v11, u), v);
+}
+function fbm(seed, x, y, octaves = 5, lacunarity = 2, gain = 0.5) {
+  let amp = 1, freq = 1, sum = 0, norm = 0;
+  for (let o = 0; o < octaves; o++) {
+    sum += amp * valueNoise(seed + o * 1013, x * freq, y * freq);
+    norm += amp;
+    amp *= gain;
+    freq *= lacunarity;
+  }
+  return sum / norm;
+}
+
+// ../auto-battler/src/engine/biomeMap.js
+var sub = (seed, salt) => (Math.imul(seed | 0, 2654435761) ^ (salt | 0)) >>> 0;
+var SCALE = 5e-3;
+var REGION_OCTAVES = 3;
+var WARP_SCALE = 0.012;
+var WARP_AMP = 40;
+var BIOMES = [
+  { id: "forgottenPlains", salt: 985505 },
+  // green meadow
+  { id: "orc", salt: 11281 },
+  // dirt / grass plains
+  { id: "necropolis", salt: 966869 }
+  // corrupted swamp
+];
+var OVERWORLD_BIOMES = BIOMES.map((b) => b.id);
+function weights(seed, x, y, out) {
+  const wx = x + WARP_AMP * (fbm(sub(seed, 1441), x * WARP_SCALE, y * WARP_SCALE) - 0.5);
+  const wy = y + WARP_AMP * (fbm(sub(seed, 1442), x * WARP_SCALE, y * WARP_SCALE) - 0.5);
+  for (let i = 0; i < BIOMES.length; i++) out[i] = fbm(sub(seed, BIOMES[i].salt), wx * SCALE, wy * SCALE, REGION_OCTAVES);
+  return out;
+}
+var _w = new Array(BIOMES.length);
+function biomeRegion(seed, x, y) {
+  const w = weights(seed, x, y, _w);
+  let i1 = 0;
+  for (let i = 1; i < w.length; i++) if (w[i] > w[i1]) i1 = i;
+  let i2 = -1;
+  for (let i = 0; i < w.length; i++) {
+    if (i === i1) continue;
+    if (i2 < 0 || w[i] > w[i2]) i2 = i;
+  }
+  return { id: BIOMES[i1].id, id2: BIOMES[i2]?.id ?? BIOMES[i1].id, edge: w[i1] - w[i2] };
+}
+
+// ../auto-battler/src/engine/transitionStencils.js
+var TILE = 8;
+var MID = 3.5;
+var BAND = 2.6;
+var WAVE_AMP = 1.35;
+var WAVE_FREQ = 0.45;
+var R_OUTER = 4.6;
+var R_CONCAVE = 2.3;
+var R_TIP = 2.6;
+var BAYER4 = [
+  0.5 / 16,
+  8.5 / 16,
+  2.5 / 16,
+  10.5 / 16,
+  12.5 / 16,
+  4.5 / 16,
+  14.5 / 16,
+  6.5 / 16,
+  3.5 / 16,
+  11.5 / 16,
+  1.5 / 16,
+  9.5 / 16,
+  15.5 / 16,
+  7.5 / 16,
+  13.5 / 16,
+  5.5 / 16
+];
+var bayer = (x, y) => BAYER4[(y & 3) * 4 + (x & 3)];
+function wave1d(t, salt) {
+  const i = Math.floor(t * WAVE_FREQ), f = t * WAVE_FREQ - i;
+  const a = hash2(salt, i, 0), b = hash2(salt, i + 1, 0);
+  const u = f * f * (3 - 2 * f);
+  return (a + (b - a) * u) * 2 - 1;
+}
+var CASES = {
+  // cardinal edges — wavy line; fg on the side away from the foreign neighbour.
+  N: (x, y, s) => y - (MID + WAVE_AMP * wave1d(x, s)),
+  S: (x, y, s) => MID + WAVE_AMP * wave1d(x, s) - y,
+  E: (x, y, s) => MID + WAVE_AMP * wave1d(y, s) - x,
+  W: (x, y, s) => x - (MID + WAVE_AMP * wave1d(y, s)),
+  // outer corners — bg is a quarter-disc in the corner (2 adjacent foreign cardinals).
+  oNE: (x, y, s) => dist(x, y, 7, 0) - (R_OUTER + WAVE_AMP * wave1d(x + y, s)),
+  oNW: (x, y, s) => dist(x, y, 0, 0) - (R_OUTER + WAVE_AMP * wave1d(x + y, s)),
+  oSE: (x, y, s) => dist(x, y, 7, 7) - (R_OUTER + WAVE_AMP * wave1d(x + y, s)),
+  oSW: (x, y, s) => dist(x, y, 0, 7) - (R_OUTER + WAVE_AMP * wave1d(x + y, s)),
+  // concave corners — small bg notch in the corner (1 foreign diagonal only).
+  cNE: (x, y, s) => dist(x, y, 7, 0) - (R_CONCAVE + 0.6 * wave1d(x + y, s)),
+  cNW: (x, y, s) => dist(x, y, 0, 0) - (R_CONCAVE + 0.6 * wave1d(x + y, s)),
+  cSE: (x, y, s) => dist(x, y, 7, 7) - (R_CONCAVE + 0.6 * wave1d(x + y, s)),
+  cSW: (x, y, s) => dist(x, y, 0, 7) - (R_CONCAVE + 0.6 * wave1d(x + y, s)),
+  // peninsula — fg is a small blob on the one open side (3 foreign cardinals).
+  tipN: (x, y, s) => R_TIP + 0.6 * wave1d(x, s) - dist(x, y, 3.5, 0),
+  tipS: (x, y, s) => R_TIP + 0.6 * wave1d(x, s) - dist(x, y, 3.5, 7),
+  tipE: (x, y, s) => R_TIP + 0.6 * wave1d(y, s) - dist(x, y, 7, 3.5),
+  tipW: (x, y, s) => R_TIP + 0.6 * wave1d(y, s) - dist(x, y, 0, 3.5),
+  // island — fg is a small blob in the centre (foreign on all 4 cardinals).
+  island: (x, y, s) => R_TIP + 0.6 * wave1d(x - y, s) - dist(x, y, 3.5, 3.5)
+};
+function dist(x, y, cx, cy) {
+  const dx = x - cx, dy = y - cy;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+var STENCIL_CASES = Object.keys(CASES);
+function boundaryCase(N, E, S, W, NW, NE, SW, SE) {
+  const card = N + E + S + W;
+  if (card === 0) {
+    const diag = NW + NE + SW + SE;
+    if (diag === 0) return null;
+    if (NW) return "cNW";
+    if (NE) return "cNE";
+    if (SW) return "cSW";
+    return "cSE";
+  }
+  if (card === 1) return N ? "N" : E ? "E" : S ? "S" : "W";
+  if (card === 2) {
+    if (N && E) return "oNE";
+    if (N && W) return "oNW";
+    if (S && E) return "oSE";
+    if (S && W) return "oSW";
+    return N ? "N" : "E";
+  }
+  if (card === 3) return !N ? "tipN" : !E ? "tipE" : !S ? "tipS" : "tipW";
+  return "island";
+}
+function makeStencil(caseKey, variant = 0) {
+  const sd = CASES[caseKey];
+  if (!sd) throw new Error(`unknown stencil case "${caseKey}"`);
+  const salt = (hashStr(caseKey) ^ variant * 40503) >>> 0;
+  const mask = new Uint8Array(TILE * TILE);
+  for (let y = 0; y < TILE; y++) for (let x = 0; x < TILE; x++) {
+    const d = sd(x, y, salt);
+    let fg;
+    if (d > BAND / 2) fg = 1;
+    else if (d < -BAND / 2) fg = 0;
+    else fg = (d + BAND / 2) / BAND > bayer(x, y) ? 1 : 0;
+    mask[y * TILE + x] = fg;
+  }
+  return mask;
+}
+function hashStr(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+
+// ../auto-battler/src/engine/orcGen.js
+var sub2 = (seed, salt) => (Math.imul(seed | 0, 2654435761) ^ (salt | 0)) >>> 0;
+var DDIRT_SCALE = 0.045;
+var DDIRT_THRESHOLD = 0.55;
+function isDarkerDirt(seed, x, y) {
+  return fbm(sub2(seed, 56599), x * DDIRT_SCALE, y * DDIRT_SCALE) > DDIRT_THRESHOLD;
+}
+var GRASS_SCALE = 0.04;
+var GRASS_THRESHOLD = 0.58;
+function isGrass(seed, x, y) {
+  return fbm(sub2(seed, 27221), x * GRASS_SCALE, y * GRASS_SCALE) > GRASS_THRESHOLD;
+}
+var ROCK_SCALE = 0.12;
+var ROCK_THRESHOLD = 0.64;
+function isRock(seed, x, y) {
+  return fbm(sub2(seed, 16588), x * ROCK_SCALE, y * ROCK_SCALE) > ROCK_THRESHOLD;
 }
 
 // ../auto-battler/src/render/tileAutotile.js
@@ -532,6 +699,7 @@ var rect = (c, r, w, h) => {
   for (let j = 0; j < h; j++) for (let i = 0; i < w; i++) a.push([c + i, r + j]);
   return a;
 };
+var offset = (t, col) => [t[0] + col, t[1]];
 var rhash = (x, y, salt, seed) => Math.imul(x * 73856093 ^ y * 19349663 ^ seed + (salt | 0), 2654435761) >>> 0;
 function hashU32(a, b, c) {
   let h = Math.imul((a | 0) ^ 2654435769, 2654435761);
@@ -546,6 +714,45 @@ var sparse = (base, vars, x, y, salt, rate, seed) => {
   return h % rate === 0 ? vars[(h >>> 5) % vars.length] : base;
 };
 var lerp3 = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];
+function autotile(set, N, E, S, W, NW, NE, SW, SE) {
+  const card = N + E + S + W;
+  if (card === 1) return N ? set.N : S ? set.S : E ? set.E : set.W;
+  if (card === 2) {
+    if (N && W) return set.vNW;
+    if (N && E) return set.vNE;
+    if (S && W) return set.vSW;
+    if (S && E) return set.vSE;
+    return N ? set.N : set.E;
+  }
+  if (card >= 3) return N ? set.N : S ? set.S : E ? set.E : set.W;
+  const diag = NW + NE + SW + SE;
+  if (diag === 0) return null;
+  if (diag === 1) return NW ? set.cNW : NE ? set.cNE : SW ? set.cSW : set.cSE;
+  if (NW && SE && !NE && !SW) return set.dNWSE;
+  if (NE && SW && !NW && !SE) return set.dSWNE;
+  return null;
+}
+function cleanField(raw, M, SZ) {
+  const idx = (i, j) => j * SZ + i;
+  let cur = new Uint8Array(SZ * SZ);
+  for (let j = 0; j < SZ; j++) for (let i = 0; i < SZ; i++) cur[idx(i, j)] = raw(i - M, j - M) ? 1 : 0;
+  let nxt = new Uint8Array(SZ * SZ);
+  for (let j = 1; j < SZ - 1; j++) for (let i = 1; i < SZ - 1; i++) {
+    let c = 0;
+    for (let dj = -1; dj <= 1; dj++) for (let di = -1; di <= 1; di++) c += cur[idx(i + di, j + dj)];
+    nxt[idx(i, j)] = c >= 5 ? 1 : 0;
+  }
+  cur = nxt;
+  for (let p = 0; p < 2; p++) {
+    nxt = new Uint8Array(SZ * SZ);
+    for (let j = 1; j < SZ - 1; j++) for (let i = 1; i < SZ - 1; i++) {
+      const card = cur[idx(i, j - 1)] + cur[idx(i + 1, j)] + cur[idx(i, j + 1)] + cur[idx(i - 1, j)];
+      nxt[idx(i, j)] = cur[idx(i, j)] ? card >= 2 ? 1 : 0 : card >= 3 ? 1 : 0;
+    }
+    cur = nxt;
+  }
+  return cur;
+}
 function blockTile([c0, r0], N, E, S, W) {
   const cx = W && !E ? 0 : E && !W ? 2 : 1;
   const cy = N && !S ? 0 : S && !N ? 2 : 1;
@@ -643,21 +850,215 @@ function bakeCliffs(cfg, { chunk, x0, y0, seed, raised, place, accept = () => tr
   }
 }
 
+// ../auto-battler/src/render/orcKingdom.js
+var ORC = "/assets/minifantasy/Minifantasy_Orc_Kingdom_v1.0/Minifantasy_Orc_Kingdom_Assets";
+var TILES = `${ORC}/Tileset/Tiles.png`;
+var TILE2 = 8;
+var CHUNK = 32;
+var DIRT_BASE = [7, 51];
+var DIRT_VARS = rect(13, 51, 2, 6);
+var DIRT_RATE = 4;
+var GRASS = {
+  fill: [3, 51],
+  vars: [],
+  N: [3, 54],
+  S: [3, 52],
+  E: [2, 53],
+  W: [4, 53],
+  cNW: [4, 54],
+  cNE: [2, 54],
+  cSW: [4, 52],
+  cSE: [2, 52],
+  vNW: [3, 56],
+  vNE: [2, 56],
+  vSW: [3, 55],
+  vSE: [2, 55],
+  dNWSE: [4, 55],
+  dSWNE: [4, 56]
+};
+var DDIRT = {
+  fill: [7, 53],
+  vars: rect(10, 51, 2, 6),
+  N: [7, 52],
+  S: [7, 54],
+  E: [8, 53],
+  W: [6, 53],
+  vNW: [6, 52],
+  vNE: [8, 52],
+  vSW: [6, 54],
+  vSE: [8, 54],
+  cNW: [6, 55],
+  cNE: [7, 55],
+  cSW: [6, 56],
+  cSE: [7, 56],
+  dNWSE: [8, 55],
+  dSWNE: [8, 56]
+};
+var OVERLAY_RATE = 5;
+var ROCK_COLOR_OFF = [0, 6, 12];
+var STONE_SIZES = [[16, 51], [16, 52], [16, 53], [16, 54], [16, 55], [16, 56]];
+var ROCK_FOLIAGE = [[17, 51], [18, 51], [19, 51], [20, 51]];
+var ROCK_DENSE = [[18, 53], [19, 53], [18, 54], [19, 54], [18, 55], [19, 55]];
+var ROCK_SPARSE = [
+  [17, 52],
+  [18, 52],
+  [19, 52],
+  [20, 52],
+  [17, 53],
+  [20, 53],
+  [17, 54],
+  [20, 54],
+  [17, 55],
+  [20, 55],
+  [17, 56],
+  [18, 56],
+  [19, 56],
+  [20, 56]
+];
+var ROCK_STONE_RATE = 28;
+var ROCK_FOLIAGE_RATE = 12;
+var COL_DIRT = [150, 128, 95];
+var COL_DDIRT = [106, 90, 79];
+var COL_GRASS = [96, 132, 58];
+function chunkFields(seed, x0, y0) {
+  const M = 6, SZ = CHUNK + 2 * M;
+  const dd = cleanField((lx, ly) => isDarkerDirt(seed, x0 + lx, y0 + ly), M, SZ);
+  const grRaw = cleanField((lx, ly) => isGrass(seed, x0 + lx, y0 + ly), M, SZ);
+  const gr = new Uint8Array(grRaw.length);
+  for (let k = 0; k < gr.length; k++) gr[k] = grRaw[k] && !dd[k] ? 1 : 0;
+  const rockRaw = cleanField((lx, ly) => isRock(seed, x0 + lx, y0 + ly), M, SZ);
+  const rock = new Uint8Array(rockRaw.length);
+  for (let k = 0; k < rock.length; k++) rock[k] = rockRaw[k] && !dd[k] && !gr[k] ? 1 : 0;
+  return { dd, gr, rock, M, SZ, x0, y0 };
+}
+var ORC_GROUND_FILLS = [
+  { key: "dirt", url: TILES, tile: DIRT_BASE },
+  { key: "ddirt", url: TILES, tile: DDIRT.fill },
+  { key: "grass", url: TILES, tile: GRASS.fill }
+];
+function orcGroundFillKey(seed, x, y) {
+  if (isDarkerDirt(seed, x, y)) return "ddirt";
+  if (isGrass(seed, x, y)) return "grass";
+  return "dirt";
+}
+var orcConfig = (seed) => ({
+  seed,
+  tile: TILE2,
+  chunk: CHUNK,
+  background: "#69636f",
+  async load({ Assets }) {
+    const t = await Assets.load(TILES);
+    t.source.scaleMode = "nearest";
+    return { tiles: t.source };
+  },
+  // `accept(tx,ty)` (chunk-local) gates which tiles this biome paints — defaults to all, so the
+  // standalone map is unchanged; the multi-biome overworld passes a per-biome dither mask.
+  bake({ x0, y0, seed: seed2, ctx, add, accept = () => true }) {
+    const f = chunkFields(seed2, x0, y0);
+    const { dd, gr, rock, M, SZ } = f;
+    const idx = (i, j) => j * SZ + i;
+    const at = (fld, lx, ly) => fld[idx(lx + M, ly + M)] === 1;
+    const atRock = (lx, ly) => rock[idx(lx + M, ly + M)] === 1;
+    const place = (coord, tx, ty) => add(ctx.tiles, coord[0], coord[1], tx, ty);
+    const drawLayer = (field, set, tx, ty) => {
+      if (!at(field, tx, ty)) return;
+      const N = !at(field, tx, ty - 1), E = !at(field, tx + 1, ty), S = !at(field, tx, ty + 1), W = !at(field, tx - 1, ty);
+      const NW = !at(field, tx - 1, ty - 1), NE = !at(field, tx + 1, ty - 1), SW = !at(field, tx - 1, ty + 1), SE = !at(field, tx + 1, ty + 1);
+      const t = autotile(set, N, E, S, W, NW, NE, SW, SE);
+      place(t || sparse(set.fill, set.vars, x0 + tx, y0 + ty, set === GRASS ? 1 : 2, OVERLAY_RATE, seed2), tx, ty);
+    };
+    for (let ty = 0; ty < CHUNK; ty++) {
+      for (let tx = 0; tx < CHUNK; tx++) {
+        if (!accept(tx, ty)) continue;
+        place(sparse(DIRT_BASE, DIRT_VARS, x0 + tx, y0 + ty, 0, DIRT_RATE, seed2), tx, ty);
+        drawLayer(dd, DDIRT, tx, ty);
+        drawLayer(gr, GRASS, tx, ty);
+        if (atRock(tx, ty)) {
+          const h = rhash(x0 + tx, y0 + ty, 3, seed2);
+          const interior = atRock(tx, ty - 1) && atRock(tx + 1, ty) && atRock(tx, ty + 1) && atRock(tx - 1, ty);
+          const pool = interior ? ROCK_DENSE : ROCK_SPARSE;
+          place(offset(pool[(h >>> 2) % pool.length], ROCK_COLOR_OFF[h % 3]), tx, ty);
+        } else if (!at(dd, tx, ty) && !at(gr, tx, ty)) {
+          const h = rhash(x0 + tx, y0 + ty, 7, seed2);
+          if (h % ROCK_STONE_RATE === 0) place(offset(STONE_SIZES[(h >>> 3) % STONE_SIZES.length], ROCK_COLOR_OFF[(h >>> 6) % 3]), tx, ty);
+          else if ((h >>> 8) % ROCK_FOLIAGE_RATE === 0) place(offset(ROCK_FOLIAGE[(h >>> 11) % ROCK_FOLIAGE.length], ROCK_COLOR_OFF[(h >>> 14) % 3]), tx, ty);
+        }
+      }
+    }
+    return { meta: f };
+  },
+  macroColor(seed2, tx, ty) {
+    if (isDarkerDirt(seed2, tx, ty)) return COL_DDIRT;
+    if (isGrass(seed2, tx, ty)) return COL_GRASS;
+    return COL_DIRT;
+  },
+  // Top-most ground tile [c,r] at world (wx,wy) for the grid overlay (rocks omitted).
+  tileIndexAt(wx, wy, meta) {
+    if (!meta) return null;
+    const { dd, gr, M, SZ, x0, y0 } = meta;
+    const lx = wx - x0, ly = wy - y0;
+    if (lx < 0 || ly < 0 || lx >= CHUNK || ly >= CHUNK) return null;
+    const at = (f, x, y) => f[(y + M) * SZ + (x + M)] === 1;
+    for (const [field, set] of [[gr, GRASS], [dd, DDIRT]]) {
+      if (!at(field, lx, ly)) continue;
+      const N = !at(field, lx, ly - 1), E = !at(field, lx + 1, ly), S = !at(field, lx, ly + 1), W = !at(field, lx - 1, ly);
+      const NW = !at(field, lx - 1, ly - 1), NE = !at(field, lx + 1, ly - 1), SW = !at(field, lx - 1, ly + 1), SE = !at(field, lx + 1, ly + 1);
+      return autotile(set, N, E, S, W, NW, NE, SW, SE) || set.fill;
+    }
+    return DIRT_BASE;
+  }
+});
+
+// ../auto-battler/src/engine/fpGen.js
+var sub3 = (seed, salt) => (Math.imul(seed | 0, 2654435761) ^ (salt | 0)) >>> 0;
+var DIRT_SCALE = 0.04;
+var DIRT_THRESHOLD = 0.56;
+function isDirt(seed, x, y) {
+  return fbm(sub3(seed, 53543), x * DIRT_SCALE, y * DIRT_SCALE) > DIRT_THRESHOLD;
+}
+var STONE_SCALE = 0.085;
+var STONE_THRESHOLD = 0.66;
+function isStone(seed, x, y) {
+  return fbm(sub3(seed, 22286), x * STONE_SCALE, y * STONE_SCALE) > STONE_THRESHOLD;
+}
+var FOREST_SCALE = 0.05;
+function forestField(seed, x, y) {
+  return fbm(sub3(seed, 15740503), x * FOREST_SCALE, y * FOREST_SCALE);
+}
+var STONE_CLUMP_SCALE = 0.11;
+function stoneClumpField(seed, x, y) {
+  return fbm(sub3(seed, 5702849), x * STONE_CLUMP_SCALE, y * STONE_CLUMP_SCALE);
+}
+var ELEV_SCALE = 0.025;
+var ELEV_THRESHOLD = 0.6;
+function isRaised(seed, x, y) {
+  return fbm(sub3(seed, 57836), x * ELEV_SCALE, y * ELEV_SCALE) > ELEV_THRESHOLD;
+}
+var RIVER_SCALE = 0.022;
+var RIVER_WIDTH = 0.035;
+var WARP_SCALE2 = 0.03;
+var WARP_AMP2 = 22;
+function isRiver(seed, x, y) {
+  const wx = x + WARP_AMP2 * (fbm(sub3(seed, 1297), x * WARP_SCALE2, y * WARP_SCALE2) - 0.5);
+  const wy = y + WARP_AMP2 * (fbm(sub3(seed, 1298), x * WARP_SCALE2, y * WARP_SCALE2) - 0.5);
+  return Math.abs(fbm(sub3(seed, 8654), wx * RIVER_SCALE, wy * RIVER_SCALE) - 0.5) < RIVER_WIDTH;
+}
+
 // ../auto-battler/src/render/forgottenPlains.js
 var FP = "/assets/minifantasy/Minifantasy_ForgottenPlains_v3.6_Commercial_Version/Minifantasy_ForgottenPlains_Assets";
-var TILES = `${FP}/Tileset/Minifantasy_ForgottenPlainsTiles.png`;
+var TILES2 = `${FP}/Tileset/Minifantasy_ForgottenPlainsTiles.png`;
 var SHADOW = `${FP}/Tileset/Minifantasy_ForgottenPlainsTilesShadows.png`;
 var PROPS = `${FP}/props/Minifantasy_ForgottenPlainsProps.png`;
 var PROP_SHADOW = `${FP}/props/Minifantasy_ForgottenPlainsPropsShadows.png`;
 var FP_MOCKUP_URL = `${FP}/Minifantasy_ForgottenPlainsMockup.png`;
-var TILE = 8;
-var CHUNK = 32;
+var TILE3 = 8;
+var CHUNK2 = 32;
 var GRASS_BASE = [37, 11];
 var GRASS_VARS = [...rect(1, 1, 4, 1), ...rect(2, 3, 3, 5)];
 var GRASS_RATE = 9;
 var DIRT_BLOCK = [7, 3];
 var DIRT_FILL = [8, 4];
-var DIRT_VARS = [[7, 1], [8, 1], [9, 1]];
+var DIRT_VARS2 = [[7, 1], [8, 1], [9, 1]];
 var STONE_BLOCK = [12, 3];
 var STONE_FILL = [13, 4];
 var STONE_VARS = [[12, 1], [13, 1], [14, 1]];
@@ -795,8 +1196,8 @@ var STONE_BLOCK_Y = 2;
 var STONE_CLUMP_THRESHOLD = 0.7;
 var STONE_CLUMP_MIN_NB = 3;
 var STONE_CLUMP_FILL = 0.7;
-var COL_GRASS = [97, 150, 55];
-var COL_DIRT = [118, 80, 38];
+var COL_GRASS2 = [97, 150, 55];
+var COL_DIRT2 = [118, 80, 38];
 var COL_STONE = [120, 120, 122];
 var COL_WATER = [74, 116, 196];
 function loadImg(url) {
@@ -814,9 +1215,9 @@ async function buildShadowMask(url) {
   cv.height = img.naturalHeight;
   const g = cv.getContext("2d", { willReadFrequently: true });
   g.drawImage(img, 0, 0);
-  const cols = img.naturalWidth / TILE | 0, rows = img.naturalHeight / TILE | 0, set = /* @__PURE__ */ new Set();
+  const cols = img.naturalWidth / TILE3 | 0, rows = img.naturalHeight / TILE3 | 0, set = /* @__PURE__ */ new Set();
   for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) {
-    const d = g.getImageData(c * TILE, r * TILE, TILE, TILE).data;
+    const d = g.getImageData(c * TILE3, r * TILE3, TILE3, TILE3).data;
     for (let i = 3; i < d.length; i += 4) {
       if (d[i] > 8) {
         set.add(c + "," + r);
@@ -826,9 +1227,9 @@ async function buildShadowMask(url) {
   }
   return set;
 }
-function chunkFields(seed, x0, y0) {
+function chunkFields2(seed, x0, y0) {
   const WATER_BUFFER = 2;
-  const M = WATER_BUFFER + 4, SZ = CHUNK + 2 * M;
+  const M = WATER_BUFFER + 4, SZ = CHUNK2 + 2 * M;
   const idx = (i, j) => j * SZ + i;
   const clean = (pred) => {
     let cur = new Uint8Array(SZ * SZ);
@@ -886,14 +1287,24 @@ function chunkFields(seed, x0, y0) {
   }
   return { waterF, dirt, stone, raisedField, forestRegion, stoneClumpRegion, M, SZ, x0, y0 };
 }
+var FP_GROUND_FILLS = [
+  { key: "grass", url: TILES2, tile: GRASS_BASE },
+  { key: "dirt", url: TILES2, tile: DIRT_FILL },
+  { key: "stone", url: TILES2, tile: STONE_FILL }
+];
+function fpGroundFillKey(seed, x, y) {
+  if (isStone(seed, x, y) && !isDirt(seed, x, y)) return "stone";
+  if (isDirt(seed, x, y)) return "dirt";
+  return "grass";
+}
 var fpConfig = (seed) => ({
   seed,
-  tile: TILE,
-  chunk: CHUNK,
+  tile: TILE3,
+  chunk: CHUNK2,
   background: "#5a7b3a",
   async load({ Assets }) {
     const ctx = { tiles: null, shadow: null, shadowSet: null, props: null, propShadow: null };
-    const t = await Assets.load(TILES);
+    const t = await Assets.load(TILES2);
     t.source.scaleMode = "nearest";
     ctx.tiles = t.source;
     try {
@@ -924,7 +1335,7 @@ var fpConfig = (seed) => ({
   // `accept(tx,ty)` (chunk-local) gates which tiles this biome paints — defaults to all, so the
   // standalone map is unchanged; the multi-biome overworld passes a per-biome dither mask.
   bake({ x0, y0, seed: seed2, ctx, tmp, Sprite, tex, texFrame, add, accept = () => true }) {
-    const f = chunkFields(seed2, x0, y0);
+    const f = chunkFields2(seed2, x0, y0);
     const { waterF, dirt, stone, raisedField, forestRegion, stoneClumpRegion, M, SZ } = f;
     const idx = (i, j) => j * SZ + i;
     const atW = (wx, wy) => waterF[idx(wx - x0 + M, wy - y0 + M)] === 1;
@@ -935,8 +1346,8 @@ var fpConfig = (seed) => ({
       add(ctx.tiles, coord[0], coord[1], tx, ty);
       if (ctx.shadow && (!ctx.shadowSet || ctx.shadowSet.has(coord[0] + "," + coord[1]))) {
         const sh = new Sprite(tex(ctx.shadow, coord[0], coord[1]));
-        sh.x = tx * TILE;
-        sh.y = ty * TILE;
+        sh.x = tx * TILE3;
+        sh.y = ty * TILE3;
         tmp.addChild(sh);
       }
     };
@@ -957,24 +1368,24 @@ var fpConfig = (seed) => ({
       } else cr = blockTile(BLOCK, N, E, S, W);
       place(cr, tx, ty);
     };
-    for (let ty = 0; ty < CHUNK; ty++) for (let tx = 0; tx < CHUNK; tx++) {
+    for (let ty = 0; ty < CHUNK2; ty++) for (let tx = 0; tx < CHUNK2; tx++) {
       if (!accept(tx, ty)) continue;
       const wx = x0 + tx, wy = y0 + ty;
       place(sparse(GRASS_BASE, GRASS_VARS, wx, wy, 0, GRASS_RATE, seed2), tx, ty);
-      if (atD(wx, wy)) blob(atD, DIRT_BLOCK, DIRT_FILL, DIRT_VARS, 1, wx, wy, tx, ty);
+      if (atD(wx, wy)) blob(atD, DIRT_BLOCK, DIRT_FILL, DIRT_VARS2, 1, wx, wy, tx, ty);
       if (atS(wx, wy)) blob(atS, STONE_BLOCK, STONE_FILL, STONE_VARS, 2, wx, wy, tx, ty);
       if (atW(wx, wy)) blob(atW, WATER_BLOCK, WATER_FILL, WATER_VARS, 3, wx, wy, tx, ty);
     }
     const live = [];
     const propSprite = (spec, wx, wy) => {
-      const sp = new Sprite(texFrame(ctx.props, spec.c * TILE, (spec.r - spec.h + 1) * TILE, spec.w * TILE, spec.h * TILE));
+      const sp = new Sprite(texFrame(ctx.props, spec.c * TILE3, (spec.r - spec.h + 1) * TILE3, spec.w * TILE3, spec.h * TILE3));
       sp.anchor.set(0.5, 1);
-      sp.x = wx * TILE + TILE / 2;
-      sp.y = (wy + 1) * TILE;
-      sp.zIndex = (wy + 1) * TILE;
+      sp.x = wx * TILE3 + TILE3 / 2;
+      sp.y = (wy + 1) * TILE3;
+      sp.zIndex = (wy + 1) * TILE3;
       return sp;
     };
-    if (ctx.props) for (let ty = 0; ty < CHUNK; ty++) for (let tx = 0; tx < CHUNK; tx++) {
+    if (ctx.props) for (let ty = 0; ty < CHUNK2; ty++) for (let tx = 0; tx < CHUNK2; tx++) {
       if (!accept(tx, ty)) continue;
       const wx = x0 + tx, wy = y0 + ty;
       if (atW(wx, wy)) {
@@ -997,9 +1408,9 @@ var fpConfig = (seed) => ({
         continue;
       }
       const [c, r] = g.tiles[(h >>> 16) % g.tiles.length];
-      const sp = new Sprite(texFrame(ctx.props, c * TILE, r * TILE, TILE, TILE));
-      sp.x = tx * TILE;
-      sp.y = ty * TILE;
+      const sp = new Sprite(texFrame(ctx.props, c * TILE3, r * TILE3, TILE3, TILE3));
+      sp.x = tx * TILE3;
+      sp.y = ty * TILE3;
       tmp.addChild(sp);
     }
     const stairAt = (wx, wy) => {
@@ -1010,15 +1421,15 @@ var fpConfig = (seed) => ({
       const off = hashU32(seed2 ^ 358940, Math.floor(wx / STAIR_SPACING), 0) % STAIR_SPACING;
       return ((wy - off) % STAIR_SPACING + STAIR_SPACING) % STAIR_SPACING === 0;
     };
-    bakeCliffs(FP_CLIFF, { chunk: CHUNK, x0, y0, seed: seed2, raised: isRaisedAt, place, accept, stairAt, stairAtV });
+    bakeCliffs(FP_CLIFF, { chunk: CHUNK2, x0, y0, seed: seed2, raised: isRaisedAt, place, accept, stairAt, stairAtV });
     if (ctx.props) {
       const inGrove = (wx, wy) => forestRegion[idx(wx - x0 + M, wy - y0 + M)] === 1;
-      const bx0 = Math.floor(x0 / FOREST_BLOCK_X), bx1 = Math.floor((x0 + CHUNK - 1) / FOREST_BLOCK_X);
-      const by0 = Math.floor(y0 / FOREST_BLOCK_Y), by1 = Math.floor((y0 + CHUNK - 1) / FOREST_BLOCK_Y);
+      const bx0 = Math.floor(x0 / FOREST_BLOCK_X), bx1 = Math.floor((x0 + CHUNK2 - 1) / FOREST_BLOCK_X);
+      const by0 = Math.floor(y0 / FOREST_BLOCK_Y), by1 = Math.floor((y0 + CHUNK2 - 1) / FOREST_BLOCK_Y);
       for (let by = by0; by <= by1; by++) for (let bx = bx0; bx <= bx1; bx++) {
         const h = hashU32(seed2 ^ 15748695, bx, by);
         const wx = bx * FOREST_BLOCK_X + h % FOREST_BLOCK_X, wy = by * FOREST_BLOCK_Y + (h >>> 4) % FOREST_BLOCK_Y;
-        if (wx < x0 || wx >= x0 + CHUNK || wy < y0 || wy >= y0 + CHUNK) continue;
+        if (wx < x0 || wx >= x0 + CHUNK2 || wy < y0 || wy >= y0 + CHUNK2) continue;
         if (!accept(wx - x0, wy - y0)) continue;
         if (!inGrove(wx, wy)) continue;
         if ((h >>> 8 & 65535) / 65536 >= FOREST_FILL) continue;
@@ -1034,8 +1445,8 @@ var fpConfig = (seed) => ({
         const T = TREES[(h >>> 24) % TREES.length];
         const flip = (h >>> 20 & 255) / 256 < TREE_FLIP_RATE;
         const sc = TREE_SCALE_BASE * (1 + ((h >>> 12 & 255) / 256 - 0.5) * 2 * TREE_SCALE_JITTER);
-        const px = wx * TILE + TILE / 2 + ((h >>> 16 & 15) / 16 - 0.5) * 2 * TREE_JITTER;
-        const py = wy * TILE + TILE / 2 + ((h >>> 28 & 15) / 16 - 0.5) * 2 * TREE_JITTER;
+        const px = wx * TILE3 + TILE3 / 2 + ((h >>> 16 & 15) / 16 - 0.5) * 2 * TREE_JITTER;
+        const py = wy * TILE3 + TILE3 / 2 + ((h >>> 28 & 15) / 16 - 0.5) * 2 * TREE_JITTER;
         const tr = new Sprite(texFrame(ctx.props, ...T.frame));
         tr.anchor.set(T.ax, T.ay);
         tr.scale.set(flip ? -sc : sc, sc);
@@ -1055,12 +1466,12 @@ var fpConfig = (seed) => ({
     }
     if (ctx.props) {
       const inClump = (wx, wy) => stoneClumpRegion[idx(wx - x0 + M, wy - y0 + M)] === 1;
-      const sbx0 = Math.floor(x0 / STONE_BLOCK_X), sbx1 = Math.floor((x0 + CHUNK - 1) / STONE_BLOCK_X);
-      const sby0 = Math.floor(y0 / STONE_BLOCK_Y), sby1 = Math.floor((y0 + CHUNK - 1) / STONE_BLOCK_Y);
+      const sbx0 = Math.floor(x0 / STONE_BLOCK_X), sbx1 = Math.floor((x0 + CHUNK2 - 1) / STONE_BLOCK_X);
+      const sby0 = Math.floor(y0 / STONE_BLOCK_Y), sby1 = Math.floor((y0 + CHUNK2 - 1) / STONE_BLOCK_Y);
       for (let by = sby0; by <= sby1; by++) for (let bx = sbx0; bx <= sbx1; bx++) {
         const h = hashU32(seed2 ^ 5702885, bx, by);
         const wx = bx * STONE_BLOCK_X + h % STONE_BLOCK_X, wy = by * STONE_BLOCK_Y + (h >>> 4) % STONE_BLOCK_Y;
-        if (wx < x0 || wx >= x0 + CHUNK || wy < y0 || wy >= y0 + CHUNK) continue;
+        if (wx < x0 || wx >= x0 + CHUNK2 || wy < y0 || wy >= y0 + CHUNK2) continue;
         if (!accept(wx - x0, wy - y0)) continue;
         if (!inClump(wx, wy)) continue;
         if ((h >>> 8 & 65535) / 65536 >= STONE_CLUMP_FILL) continue;
@@ -1089,14 +1500,14 @@ var fpConfig = (seed) => ({
   macroColor(seed2, tx, ty) {
     const raised = isRaised(seed2, tx, ty);
     if (!raised && isRiver(seed2, tx, ty)) return COL_WATER;
-    let c = isStone(seed2, tx, ty) && !isDirt(seed2, tx, ty) ? COL_STONE : isDirt(seed2, tx, ty) ? COL_DIRT : COL_GRASS;
+    let c = isStone(seed2, tx, ty) && !isDirt(seed2, tx, ty) ? COL_STONE : isDirt(seed2, tx, ty) ? COL_DIRT2 : COL_GRASS2;
     if (raised) c = lerp3(c, COL_CLIFF, 0.25);
     return c;
   },
   tileIndexAt(wx, wy, meta) {
     if (!meta) return null;
     const { waterF, dirt, stone, M, SZ, x0, y0 } = meta;
-    if (wx - x0 < 0 || wy - y0 < 0 || wx - x0 >= CHUNK || wy - y0 >= CHUNK) return null;
+    if (wx - x0 < 0 || wy - y0 < 0 || wx - x0 >= CHUNK2 || wy - y0 >= CHUNK2) return null;
     const idx = (i, j) => j * SZ + i;
     const pick = (fld, BLOCK, fill) => {
       const at = (x, y) => fld[idx(x - x0 + M, y - y0 + M)] === 1;
@@ -1115,8 +1526,752 @@ var fpConfig = (seed) => ({
     return GRASS_BASE;
   }
 });
-function createForgottenPlainsMap(pixi, host, opts = {}) {
-  return createChunkedMap(pixi, host, { ...fpConfig(opts.seed ?? 1), keyboardPan: opts.keyboardPan });
+
+// ../auto-battler/src/engine/necropolisGen.js
+var sub4 = (seed, salt) => (Math.imul(seed | 0, 2654435761) ^ (salt | 0)) >>> 0;
+var RIVER_SCALE2 = 0.045;
+var RIVER_WIDTH2 = 0.05;
+var WARP_SCALE3 = 0.03;
+var WARP_AMP3 = 16;
+var DARK_SCALE = 0.06;
+var DARK_THRESHOLD = 0.6;
+function isDark(seed, x, y) {
+  return fbm(sub4(seed, 55852), x * DARK_SCALE, y * DARK_SCALE) > DARK_THRESHOLD;
+}
+var ELEV_SCALE2 = 0.025;
+var ELEV_THRESHOLD2 = 0.6;
+function isRaised2(seed, x, y) {
+  return fbm(sub4(seed, 57836), x * ELEV_SCALE2, y * ELEV_SCALE2) > ELEV_THRESHOLD2;
+}
+var BONE_SCALE = 0.055;
+var BONE_THRESHOLD = 0.62;
+function isBone(seed, x, y) {
+  return fbm(sub4(seed, 45134), x * BONE_SCALE, y * BONE_SCALE) > BONE_THRESHOLD;
+}
+var FOREST_SCALE2 = 0.05;
+function forestField2(seed, x, y) {
+  return fbm(sub4(seed, 15740503), x * FOREST_SCALE2, y * FOREST_SCALE2);
+}
+function isRiver2(seed, x, y) {
+  const wx = x + WARP_AMP3 * (fbm(sub4(seed, 1297), x * WARP_SCALE3, y * WARP_SCALE3) - 0.5);
+  const wy = y + WARP_AMP3 * (fbm(sub4(seed, 1298), x * WARP_SCALE3, y * WARP_SCALE3) - 0.5);
+  return Math.abs(fbm(sub4(seed, 8654), wx * RIVER_SCALE2, wy * RIVER_SCALE2) - 0.5) < RIVER_WIDTH2;
+}
+
+// ../auto-battler/src/render/necropolis.js
+var NECRO = "/assets/minifantasy/Minifantasy_Necropolis_v1.0/Minifantasy_Necropolis_Assets";
+var EXT_DIR = `${NECRO}/PremadeScenes/Exterior/SeparateLayers`;
+var BIOME = `${NECRO}/Tileset/Biome/CorruptedBiome.png`;
+var SHADOW2 = `${NECRO}/Tileset/Biome/CorruptedBiomeShadows.png`;
+var PROPS2 = `${NECRO}/Props/Props.png`;
+var PROP_SHADOW2 = `${NECRO}/Props/PropShadows.png`;
+var TILE4 = 8;
+var CHUNK3 = 32;
+var TREES2 = [
+  { frame: [9, 15, 14, 14], shadow: [8, 24, 3, 5], ax: 0.04, ay: 0.82 },
+  // 1,1 (2×3)
+  { frame: [28, 11, 17, 19], shadow: [25, 24, 6, 6], ax: 0, ay: 0.84 },
+  // 3,1 (3×3)
+  { frame: [51, 13, 18, 16], shadow: [55, 24, 7, 5], ax: 0.42, ay: 0.84 },
+  // 6,1 (3×3)
+  { frame: [75, 14, 10, 15], shadow: [72, 25, 7, 4], ax: 0.05, ay: 0.87 }
+  // 9,1 (2×3)
+];
+var TREE_SCALE_BASE2 = 1;
+var TREE_SCALE_JITTER2 = 0.15;
+var TREE_FLIP_RATE2 = 0.5;
+var TREE_JITTER2 = 2;
+var FOREST_BLOCK_X2 = 2;
+var FOREST_BLOCK_Y2 = 1;
+var FOREST_THRESHOLD2 = 0.62;
+var FOREST_MIN_NB2 = 2;
+var FOREST_FILL2 = 0.55;
+var TREE_WATER_BUFFER = 1;
+var FOLIAGE2 = [
+  { tiles: [[1, 5], [2, 5], [1, 6], [2, 6]], shadow: false, weight: 3 },
+  // grass tufts (most common)
+  { tiles: [[6, 5], [7, 5], [6, 6], [7, 6]], shadow: true, weight: 1 },
+  // species A
+  { tiles: [[9, 5], [10, 5], [9, 6], [10, 6]], shadow: true, weight: 1 }
+  // species B
+];
+var FOLIAGE_WEIGHT2 = FOLIAGE2.reduce((s, g) => s + g.weight, 0);
+var FOLIAGE_RATE2 = 12;
+var LIP_T = [2, 10];
+var LIP_T_VAR = [[3, 10], [4, 10], [5, 10]];
+var LIP_TL = [1, 10];
+var LIP_TR = [6, 10];
+var WALL_L = [1, 14];
+var WALL_L_VAR = [[1, 11], [1, 12], [1, 13]];
+var WALL_R = [6, 14];
+var WALL_R_VAR = [[6, 11], [6, 12], [6, 13]];
+var LIP_S = [2, 15];
+var LIP_S_VAR = [[3, 15], [4, 15], [5, 15]];
+var LIP_SW = [1, 15];
+var LIP_SE = [6, 15];
+var FACE_H = 2;
+var FACE = [[3, 16], [3, 17]];
+var FACE_VAR = [[[2, 16], [4, 16], [5, 16]], [[2, 17], [4, 17], [5, 17]]];
+var FACE_L = [[1, 16], [1, 17]];
+var FACE_R = [[6, 16], [6, 17]];
+var CLIFF_SPARSE_RATE = 2;
+var NECRO_CLIFF = {
+  LIP_T,
+  LIP_T_VAR,
+  LIP_TL,
+  LIP_TR,
+  WALL_L,
+  WALL_L_VAR,
+  WALL_R,
+  WALL_R_VAR,
+  LIP_S,
+  LIP_S_VAR,
+  LIP_SW,
+  LIP_SE,
+  FACE_H,
+  FACE,
+  FACE_VAR,
+  FACE_L,
+  FACE_R,
+  RATE: CLIFF_SPARSE_RATE
+};
+var CORRUPT_LIGHT = [1, 1];
+var CORRUPT_DARK = [2, 1];
+var NECRO_GROUND_FILLS = [
+  { key: "light", url: BIOME, tile: CORRUPT_LIGHT },
+  { key: "dark", url: BIOME, tile: CORRUPT_DARK }
+];
+function necroGroundFillKey(seed, x, y) {
+  return isDark(seed, x, y) ? "dark" : "light";
+}
+var LIGHT_VARIANTS = [[1, 2], [2, 2], [1, 3], [2, 3], [1, 4], [2, 4], [1, 5], [2, 5]];
+var LIGHT_SPARSE_RATE = 10;
+var WATER_BLOCK2 = [4, 2];
+var BONE_BLOCK = [13, 2];
+var BONE_FILL = [[12, 1], [13, 1], [14, 1], [15, 1]];
+var EDGE_N = [18, 4];
+var EDGE_S = [18, 2];
+var EDGE_E = [17, 3];
+var EDGE_W = [19, 3];
+var CONV_NW = [18, 6];
+var CONV_NE = [17, 6];
+var CONV_SW = [18, 5];
+var CONV_SE = [17, 5];
+var CONC_NW = [19, 4];
+var CONC_NE = [17, 4];
+var CONC_SW = [19, 2];
+var CONC_SE = [17, 2];
+var CONC_NWSE = [19, 6];
+var CONC_NESW = [19, 5];
+var COL_LIGHT = [130, 119, 136];
+var COL_DARK = [105, 99, 113];
+var COL_WATER2 = [74, 142, 48];
+var COL_BONE = [180, 156, 126];
+var COL_CLIFF2 = [175, 146, 109];
+var COL_FOREST = [96, 101, 70];
+function corruptTile(N, E, S, W, NW, NE, SW, SE) {
+  const card = (N ? 1 : 0) + (E ? 1 : 0) + (S ? 1 : 0) + (W ? 1 : 0);
+  if (card === 1) return N ? EDGE_N : S ? EDGE_S : E ? EDGE_E : EDGE_W;
+  if (card === 2) {
+    if (N && W) return CONV_NW;
+    if (N && E) return CONV_NE;
+    if (S && W) return CONV_SW;
+    if (S && E) return CONV_SE;
+    return N ? EDGE_N : EDGE_E;
+  }
+  if (card >= 3) return N ? EDGE_N : S ? EDGE_S : E ? EDGE_E : EDGE_W;
+  const diag = (NW ? 1 : 0) + (NE ? 1 : 0) + (SW ? 1 : 0) + (SE ? 1 : 0);
+  if (diag === 0) return null;
+  if (diag === 1) return NW ? CONC_NW : NE ? CONC_NE : SW ? CONC_SW : CONC_SE;
+  if (NW && SE && !NE && !SW) return CONC_NWSE;
+  if (NE && SW && !NW && !SE) return CONC_NESW;
+  return null;
+}
+function boneCenterTile([c0, r0], dNW, dNE, dSW, dSE) {
+  const n = dNW + dNE + dSW + dSE;
+  if (n === 1) {
+    if (dNW) return [c0, r0 + 3];
+    if (dNE) return [c0 + 1, r0 + 3];
+    if (dSW) return [c0, r0 + 4];
+    return [c0 + 1, r0 + 4];
+  }
+  if (dNE && dSW && !dNW && !dSE) return [c0 + 2, r0 + 4];
+  if (dNW && dSE && !dNE && !dSW) return [c0 + 2, r0 + 3];
+  return [c0 + 1, r0 + 1];
+}
+function biomeColor(seed, tx, ty) {
+  const raised = isRaised2(seed, tx, ty);
+  if (!raised && isRiver2(seed, tx, ty)) return COL_WATER2;
+  if (isBone(seed, tx, ty)) return COL_BONE;
+  let c = isDark(seed, tx, ty) ? COL_DARK : COL_LIGHT;
+  if (forestField2(seed, tx, ty) > FOREST_THRESHOLD2) c = lerp3(c, COL_FOREST, 0.5);
+  if (raised) c = lerp3(c, COL_CLIFF2, 0.22);
+  return c;
+}
+function loadImg2(url) {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.onload = () => resolve(img);
+    img.onerror = reject;
+    img.src = url;
+  });
+}
+async function buildShadowMask2(url) {
+  const img = await loadImg2(url);
+  const cv = document.createElement("canvas");
+  cv.width = img.naturalWidth;
+  cv.height = img.naturalHeight;
+  const g = cv.getContext("2d", { willReadFrequently: true });
+  g.drawImage(img, 0, 0);
+  const cols = img.naturalWidth / TILE4 | 0, rows = img.naturalHeight / TILE4 | 0, set = /* @__PURE__ */ new Set();
+  for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) {
+    const d = g.getImageData(c * TILE4, r * TILE4, TILE4, TILE4).data;
+    for (let i = 3; i < d.length; i += 4) {
+      if (d[i] > 8) {
+        set.add(c + "," + r);
+        break;
+      }
+    }
+  }
+  return set;
+}
+function chunkFields3(seed, x0, y0) {
+  const WATER_BUFFER = 2;
+  const ELEV_BUFFER = 3;
+  const M = Math.max(WATER_BUFFER, ELEV_BUFFER) + 4, SZ = CHUNK3 + 2 * M;
+  const idx = (i, j) => j * SZ + i;
+  const clean = (pred) => {
+    let cur = new Uint8Array(SZ * SZ);
+    for (let j = 0; j < SZ; j++) for (let i = 0; i < SZ; i++) cur[idx(i, j)] = pred(x0 + i - M, y0 + j - M) ? 1 : 0;
+    let nxt = new Uint8Array(SZ * SZ);
+    for (let j = 1; j < SZ - 1; j++) for (let i = 1; i < SZ - 1; i++) {
+      let c = 0;
+      for (let dj = -1; dj <= 1; dj++) for (let di = -1; di <= 1; di++) c += cur[idx(i + di, j + dj)];
+      nxt[idx(i, j)] = c >= 5 ? 1 : 0;
+    }
+    cur = nxt;
+    for (let p = 0; p < 2; p++) {
+      nxt = new Uint8Array(SZ * SZ);
+      for (let j = 1; j < SZ - 1; j++) for (let i = 1; i < SZ - 1; i++) {
+        const card = cur[idx(i, j - 1)] + cur[idx(i + 1, j)] + cur[idx(i, j + 1)] + cur[idx(i - 1, j)];
+        nxt[idx(i, j)] = cur[idx(i, j)] ? card >= 2 ? 1 : 0 : card >= 3 ? 1 : 0;
+      }
+      cur = nxt;
+    }
+    return cur;
+  };
+  const darkRaw = clean((x, y) => isDark(seed, x, y));
+  const waterField = clean((x, y) => isRiver2(seed, x, y));
+  const raisedField = clean((x, y) => isRaised2(seed, x, y));
+  const boneField = clean((x, y) => isBone(seed, x, y));
+  const fraw = new Uint8Array(SZ * SZ);
+  for (let j = 0; j < SZ; j++) for (let i = 0; i < SZ; i++) fraw[idx(i, j)] = forestField2(seed, x0 + i - M, y0 + j - M) > FOREST_THRESHOLD2 ? 1 : 0;
+  const forestRegion = new Uint8Array(SZ * SZ);
+  for (let j = 1; j < SZ - 1; j++) for (let i = 1; i < SZ - 1; i++) {
+    if (!fraw[idx(i, j)]) continue;
+    let c = 0;
+    for (let dj = -1; dj <= 1; dj++) for (let di = -1; di <= 1; di++) if ((di || dj) && fraw[idx(i + di, j + dj)]) c++;
+    forestRegion[idx(i, j)] = c >= FOREST_MIN_NB2 ? 1 : 0;
+  }
+  const field = new Uint8Array(SZ * SZ);
+  const boneMask = new Uint8Array(SZ * SZ);
+  const B = Math.max(WATER_BUFFER, ELEV_BUFFER);
+  for (let j = B; j < SZ - B; j++) for (let i = B; i < SZ - B; i++) {
+    let nearW = 0;
+    for (let dj = -WATER_BUFFER; dj <= WATER_BUFFER && !nearW; dj++) for (let di = -WATER_BUFFER; di <= WATER_BUFFER; di++) if (waterField[idx(i + di, j + dj)]) {
+      nearW = 1;
+      break;
+    }
+    let nearCliff = 0;
+    {
+      const me = raisedField[idx(i, j)];
+      for (let dj = -ELEV_BUFFER; dj <= ELEV_BUFFER && !nearCliff; dj++) for (let di = -ELEV_BUFFER; di <= ELEV_BUFFER; di++) if (raisedField[idx(i + di, j + dj)] !== me) {
+        nearCliff = 1;
+        break;
+      }
+    }
+    const water = waterField[idx(i, j)];
+    field[idx(i, j)] = darkRaw[idx(i, j)] && !nearW && !water && !nearCliff ? 0 : 1;
+    boneMask[idx(i, j)] = boneField[idx(i, j)] && !water && !nearW && !nearCliff ? 1 : 0;
+  }
+  for (let pass = 0; pass < 3; pass++) {
+    const prev = boneMask.slice();
+    let changed = false;
+    for (let j = B + 1; j < SZ - B - 1; j++) for (let i = B + 1; i < SZ - B - 1; i++) {
+      if (!prev[idx(i, j)]) continue;
+      const up = prev[idx(i, j - 1)], down = prev[idx(i, j + 1)], left = prev[idx(i - 1, j)], right = prev[idx(i + 1, j)];
+      if (!up && !down || !left && !right) {
+        boneMask[idx(i, j)] = 0;
+        changed = true;
+      }
+    }
+    if (!changed) break;
+  }
+  return { field, boneMask, waterField, raisedField, forestRegion, M, SZ, x0, y0 };
+}
+var necropolisConfig = (seed) => ({
+  seed,
+  tile: TILE4,
+  chunk: CHUNK3,
+  background: "#69636f",
+  async load({ Assets }) {
+    const ctx = { biome: null, shadow: null, shadowSet: null, props: null, propShadow: null };
+    const b = await Assets.load(BIOME);
+    b.source.scaleMode = "nearest";
+    ctx.biome = b.source;
+    try {
+      const s = await Assets.load(SHADOW2);
+      s.source.scaleMode = "nearest";
+      ctx.shadow = s.source;
+    } catch {
+    }
+    try {
+      ctx.shadowSet = await buildShadowMask2(SHADOW2);
+    } catch {
+      ctx.shadowSet = null;
+    }
+    try {
+      const p = await Assets.load(PROPS2);
+      p.source.scaleMode = "nearest";
+      ctx.props = p.source;
+    } catch {
+    }
+    try {
+      const p = await Assets.load(PROP_SHADOW2);
+      p.source.scaleMode = "nearest";
+      ctx.propShadow = p.source;
+    } catch {
+    }
+    return ctx;
+  },
+  // `accept(tx,ty)` (chunk-local) gates which tiles this biome paints — defaults to all, so the
+  // standalone map is unchanged; the multi-biome overworld passes a per-biome dither mask.
+  bake({ x0, y0, seed: seed2, ctx, tmp, Sprite, tex, texFrame, add, accept = () => true }) {
+    const f = chunkFields3(seed2, x0, y0);
+    const { field, boneMask, waterField, raisedField, forestRegion, M, SZ } = f;
+    const idx = (i, j) => j * SZ + i;
+    const isLight = (wx, wy) => field[idx(wx - x0 + M, wy - y0 + M)] === 1;
+    const isRaisedAt = (wx, wy) => raisedField[idx(wx - x0 + M, wy - y0 + M)] === 1;
+    const isWater = (wx, wy) => waterField[idx(wx - x0 + M, wy - y0 + M)] === 1 && !isRaisedAt(wx, wy);
+    const boneAt = (wx, wy) => boneMask[idx(wx - x0 + M, wy - y0 + M)] === 1;
+    const place = (coord, tx, ty) => {
+      add(ctx.biome, coord[0], coord[1], tx, ty);
+      if (ctx.shadow && (!ctx.shadowSet || ctx.shadowSet.has(coord[0] + "," + coord[1]))) {
+        const sh = new Sprite(tex(ctx.shadow, coord[0], coord[1]));
+        sh.x = tx * TILE4;
+        sh.y = ty * TILE4;
+        tmp.addChild(sh);
+      }
+    };
+    for (let ty = 0; ty < CHUNK3; ty++) for (let tx = 0; tx < CHUNK3; tx++) {
+      if (!accept(tx, ty)) continue;
+      const wx = x0 + tx, wy = y0 + ty;
+      if (!isLight(wx, wy)) {
+        place(CORRUPT_DARK, tx, ty);
+        continue;
+      }
+      const N = !isLight(wx, wy - 1), E = !isLight(wx + 1, wy), S = !isLight(wx, wy + 1), Wf = !isLight(wx - 1, wy);
+      const NW = !isLight(wx - 1, wy - 1), NE = !isLight(wx + 1, wy - 1), SW = !isLight(wx - 1, wy + 1), SE = !isLight(wx + 1, wy + 1);
+      const t = corruptTile(N, E, S, Wf, NW, NE, SW, SE);
+      if (!t) {
+        place(sparse(CORRUPT_LIGHT, LIGHT_VARIANTS, wx, wy, 0, LIGHT_SPARSE_RATE, seed2), tx, ty);
+        continue;
+      }
+      place(CORRUPT_DARK, tx, ty);
+      place(t, tx, ty);
+    }
+    for (let ty = 0; ty < CHUNK3; ty++) for (let tx = 0; tx < CHUNK3; tx++) {
+      if (!accept(tx, ty)) continue;
+      const wx = x0 + tx, wy = y0 + ty;
+      if (!isWater(wx, wy)) continue;
+      const N = !isWater(wx, wy - 1), E = !isWater(wx + 1, wy), S = !isWater(wx, wy + 1), Wf = !isWater(wx - 1, wy);
+      if (N && E && S && Wf) continue;
+      let cr;
+      if (!N && !E && !S && !Wf) cr = centerTile(WATER_BLOCK2, !isWater(wx - 1, wy - 1), !isWater(wx + 1, wy - 1), !isWater(wx - 1, wy + 1), !isWater(wx + 1, wy + 1));
+      else cr = blockTile(WATER_BLOCK2, N, E, S, Wf);
+      place(cr, tx, ty);
+    }
+    for (let ty = 0; ty < CHUNK3; ty++) for (let tx = 0; tx < CHUNK3; tx++) {
+      if (!accept(tx, ty)) continue;
+      const wx = x0 + tx, wy = y0 + ty;
+      if (!boneAt(wx, wy)) continue;
+      const N = !boneAt(wx, wy - 1), E = !boneAt(wx + 1, wy), S = !boneAt(wx, wy + 1), Wf = !boneAt(wx - 1, wy);
+      if (N && E && S && Wf) {
+        place(sparse(BONE_FILL[0], BONE_FILL, wx, wy, 11, 1, seed2), tx, ty);
+        continue;
+      }
+      let cr;
+      if (!N && !E && !S && !Wf) {
+        const dNW = !boneAt(wx - 1, wy - 1), dNE = !boneAt(wx + 1, wy - 1), dSW = !boneAt(wx - 1, wy + 1), dSE = !boneAt(wx + 1, wy + 1);
+        if (dNW || dNE || dSW || dSE) cr = boneCenterTile(BONE_BLOCK, dNW, dNE, dSW, dSE);
+        else {
+          place(sparse(BONE_FILL[0], BONE_FILL, wx, wy, 11, 1, seed2), tx, ty);
+          continue;
+        }
+      } else cr = blockTile(BONE_BLOCK, N, E, S, Wf);
+      place(cr, tx, ty);
+    }
+    if (ctx.props) for (let ty = 0; ty < CHUNK3; ty++) for (let tx = 0; tx < CHUNK3; tx++) {
+      if (!accept(tx, ty)) continue;
+      const wx = x0 + tx, wy = y0 + ty;
+      if (isWater(wx, wy) || boneAt(wx, wy)) continue;
+      const h = hashU32(seed2 ^ 15733114, wx, wy);
+      if (h % FOLIAGE_RATE2 !== 0) continue;
+      let pick = (h >>> 8) % FOLIAGE_WEIGHT2, g = FOLIAGE2[0];
+      for (const grp of FOLIAGE2) {
+        if (pick < grp.weight) {
+          g = grp;
+          break;
+        }
+        pick -= grp.weight;
+      }
+      const [c, r] = g.tiles[(h >>> 16) % g.tiles.length];
+      if (g.shadow && ctx.propShadow) {
+        const sh = new Sprite(texFrame(ctx.propShadow, c * TILE4, r * TILE4, TILE4, TILE4));
+        sh.x = tx * TILE4;
+        sh.y = ty * TILE4;
+        tmp.addChild(sh);
+      }
+      const sp = new Sprite(texFrame(ctx.props, c * TILE4, r * TILE4, TILE4, TILE4));
+      sp.x = tx * TILE4;
+      sp.y = ty * TILE4;
+      tmp.addChild(sp);
+    }
+    bakeCliffs(NECRO_CLIFF, { chunk: CHUNK3, x0, y0, seed: seed2, raised: isRaisedAt, place, accept });
+    const live = [];
+    if (ctx.props) {
+      const nearWater = (wx, wy) => {
+        for (let dj = -TREE_WATER_BUFFER; dj <= TREE_WATER_BUFFER; dj++) for (let di = -TREE_WATER_BUFFER; di <= TREE_WATER_BUFFER; di++) if (waterField[idx(wx + di - x0 + M, wy + dj - y0 + M)]) return true;
+        return false;
+      };
+      const nearCliff = (wx, wy) => {
+        const me = isRaisedAt(wx, wy);
+        for (let dj = -3; dj <= 3; dj++) for (let di = -3; di <= 3; di++) if (isRaisedAt(wx + di, wy + dj) !== me) return true;
+        return false;
+      };
+      const bx0 = Math.floor(x0 / FOREST_BLOCK_X2), bx1 = Math.floor((x0 + CHUNK3 - 1) / FOREST_BLOCK_X2);
+      const by0 = Math.floor(y0 / FOREST_BLOCK_Y2), by1 = Math.floor((y0 + CHUNK3 - 1) / FOREST_BLOCK_Y2);
+      for (let by = by0; by <= by1; by++) for (let bx = bx0; bx <= bx1; bx++) {
+        const h = hashU32(seed2 ^ 15748695, bx, by);
+        const wx = bx * FOREST_BLOCK_X2 + h % FOREST_BLOCK_X2, wy = by * FOREST_BLOCK_Y2 + (h >>> 4) % FOREST_BLOCK_Y2;
+        if (wx < x0 || wx >= x0 + CHUNK3 || wy < y0 || wy >= y0 + CHUNK3) continue;
+        if (!accept(wx - x0, wy - y0)) continue;
+        if (forestRegion[idx(wx - x0 + M, wy - y0 + M)] !== 1) continue;
+        if ((h >>> 8 & 65535) / 65536 >= FOREST_FILL2) continue;
+        if (nearWater(wx, wy) || boneAt(wx, wy) || nearCliff(wx, wy)) continue;
+        const T = TREES2[(h >>> 24) % TREES2.length];
+        const flip = (h >>> 20 & 255) / 256 < TREE_FLIP_RATE2;
+        const sc = TREE_SCALE_BASE2 * (1 + ((h >>> 12 & 255) / 256 - 0.5) * 2 * TREE_SCALE_JITTER2);
+        const px = wx * TILE4 + TILE4 / 2 + ((h >>> 16 & 15) / 16 - 0.5) * 2 * TREE_JITTER2;
+        const py = wy * TILE4 + TILE4 / 2 + ((h >>> 28 & 15) / 16 - 0.5) * 2 * TREE_JITTER2;
+        const tr = new Sprite(texFrame(ctx.props, ...T.frame));
+        tr.anchor.set(T.ax, T.ay);
+        tr.scale.set(flip ? -sc : sc, sc);
+        tr.x = px;
+        tr.y = py;
+        tr.zIndex = py;
+        let shadow = null;
+        if (ctx.propShadow) {
+          shadow = new Sprite(texFrame(ctx.propShadow, ...T.shadow));
+          shadow.anchor.set(0.5, 0.5);
+          shadow.scale.set(sc, sc);
+          shadow.x = px;
+          shadow.y = py;
+        }
+        live.push({ sprite: tr, shadow });
+      }
+    }
+    return { meta: f, live };
+  },
+  macroColor: biomeColor,
+  // The ground tile [c,r] the renderer placed at world (wx,wy) — for the debug grid overlay.
+  tileIndexAt(wx, wy, meta) {
+    if (!meta) return null;
+    const { field, M, SZ, x0, y0 } = meta;
+    const fl = (x, y) => field[(y - y0 + M) * SZ + (x - x0 + M)] === 1;
+    if (wx - x0 < 0 || wy - y0 < 0 || wx - x0 >= CHUNK3 || wy - y0 >= CHUNK3) return null;
+    if (!fl(wx, wy)) return CORRUPT_DARK;
+    const t = corruptTile(
+      !fl(wx, wy - 1),
+      !fl(wx + 1, wy),
+      !fl(wx, wy + 1),
+      !fl(wx - 1, wy),
+      !fl(wx - 1, wy - 1),
+      !fl(wx + 1, wy - 1),
+      !fl(wx - 1, wy + 1),
+      !fl(wx + 1, wy + 1)
+    );
+    return t || CORRUPT_LIGHT;
+  }
+});
+
+// ../auto-battler/src/render/biomeRegistry.js
+var BIOME_FACTORIES = {
+  forgottenPlains: fpConfig,
+  orc: orcConfig,
+  necropolis: necropolisConfig
+};
+var BIOME_GROUNDS = {
+  forgottenPlains: { fills: FP_GROUND_FILLS, fillKey: fpGroundFillKey },
+  orc: { fills: ORC_GROUND_FILLS, fillKey: orcGroundFillKey },
+  necropolis: { fills: NECRO_GROUND_FILLS, fillKey: necroGroundFillKey }
+};
+
+// ../auto-battler/src/render/transitionAtlas.js
+var VARIANTS = 3;
+function loadImg3(url) {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.onload = () => resolve(img);
+    img.onerror = reject;
+    img.src = url;
+  });
+}
+function tilePixels(img, c, r) {
+  const cv = document.createElement("canvas");
+  cv.width = TILE;
+  cv.height = TILE;
+  const g = cv.getContext("2d", { willReadFrequently: true });
+  g.imageSmoothingEnabled = false;
+  g.drawImage(img, c * TILE, r * TILE, TILE, TILE, 0, 0, TILE, TILE);
+  return g.getImageData(0, 0, TILE, TILE).data;
+}
+async function buildTransitionAtlas({ grounds, ids }) {
+  const imgCache = /* @__PURE__ */ new Map(), pxCache = /* @__PURE__ */ new Map();
+  const getPx = async (url, tile) => {
+    const k = url + "|" + tile[0] + "," + tile[1];
+    if (pxCache.has(k)) return pxCache.get(k);
+    let img = imgCache.get(url);
+    if (!img) {
+      img = await loadImg3(url);
+      imgCache.set(url, img);
+    }
+    const p = tilePixels(img, tile[0], tile[1]);
+    pxCache.set(k, p);
+    return p;
+  };
+  const combos = [];
+  for (const A of ids) for (const B of ids) {
+    if (A === B) continue;
+    for (const fa of grounds[A].fills) for (const fb of grounds[B].fills) combos.push({ A, B, fa, fb });
+  }
+  for (const c of combos) {
+    c.fp = await getPx(c.fa.url, c.fa.tile);
+    c.bp = await getPx(c.fb.url, c.fb.tile);
+  }
+  const rowOf = /* @__PURE__ */ new Map();
+  combos.forEach((c, i) => rowOf.set(c.A + "|" + c.fa.key + "|" + c.B + "|" + c.fb.key, i));
+  const caseCol = /* @__PURE__ */ new Map();
+  STENCIL_CASES.forEach((k, i) => caseCol.set(k, i));
+  const canvas = document.createElement("canvas");
+  canvas.width = STENCIL_CASES.length * VARIANTS * TILE;
+  canvas.height = combos.length * TILE;
+  const ctx = canvas.getContext("2d");
+  ctx.imageSmoothingEnabled = false;
+  for (let r = 0; r < combos.length; r++) {
+    const { fp, bp } = combos[r];
+    for (let ci = 0; ci < STENCIL_CASES.length; ci++) {
+      for (let v = 0; v < VARIANTS; v++) {
+        const mask = makeStencil(STENCIL_CASES[ci], v);
+        const img = ctx.createImageData(TILE, TILE);
+        for (let p = 0; p < TILE * TILE; p++) {
+          const src = mask[p] ? fp : bp, o = p * 4;
+          img.data[o] = src[o];
+          img.data[o + 1] = src[o + 1];
+          img.data[o + 2] = src[o + 2];
+          img.data[o + 3] = src[o + 3];
+        }
+        ctx.putImageData(img, (ci * VARIANTS + v) * TILE, r * TILE);
+      }
+    }
+  }
+  const tileAt = (fgId, fgKey, bgId, bgKey, caseKey, variant) => {
+    const row = rowOf.get(fgId + "|" + fgKey + "|" + bgId + "|" + bgKey);
+    const ci = caseCol.get(caseKey);
+    if (row === void 0 || ci === void 0) return null;
+    return [ci * VARIANTS + (variant % VARIANTS + VARIANTS) % VARIANTS, row];
+  };
+  return { canvas, tileAt, variants: VARIANTS };
+}
+
+// ../auto-battler/src/render/overworld.js
+var TILE5 = 8;
+var CHUNK4 = 32;
+var MACRO_BLEND = 0.06;
+var REGION_TINT = {
+  forgottenPlains: [97, 150, 55],
+  // meadow green
+  orc: [150, 128, 95],
+  // dirt tan
+  necropolis: [120, 110, 128]
+  // corrupted grey-purple
+};
+var TINT_MIX = 0.4;
+var RANK = {};
+OVERWORLD_BIOMES.forEach((id, i) => {
+  RANK[id] = i;
+});
+var overworldConfig = (seed, opts = {}) => {
+  const region = opts.regionFn ?? biomeRegion;
+  const biomes = {};
+  for (const id of OVERWORLD_BIOMES) {
+    const factory = BIOME_FACTORIES[id];
+    if (!factory) throw new Error(`overworld: no biome config registered for "${id}"`);
+    biomes[id] = factory(seed);
+  }
+  return {
+    seed,
+    tile: TILE5,
+    chunk: CHUNK4,
+    background: "#2b2f3a",
+    bounds: opts.bounds,
+    initialCamera: opts.initialCamera,
+    // Each biome loads its own sheets into its own ctx; then build the cross-biome transition atlas
+    // from their base grounds. Key everything for bake to route to.
+    async load(api) {
+      const ctxById = {};
+      for (const id of OVERWORLD_BIOMES) ctxById[id] = await biomes[id].load(api);
+      const atlas = await buildTransitionAtlas({ grounds: BIOME_GROUNDS, ids: OVERWORLD_BIOMES });
+      const texture = api.Texture.from(atlas.canvas);
+      texture.source.scaleMode = "nearest";
+      return { ctxById, trans: { source: texture.source, tileAt: atlas.tileAt, variants: atlas.variants } };
+    },
+    // Bake a chunk: assign each tile to its (crisp) region winner, let each present biome paint its
+    // region, then overpaint the 1-tile border ring with generated transition tiles so neighbouring
+    // biomes blend cleanly. Fast path: a single-biome chunk = one bake call, no mask, no seams.
+    bake(api) {
+      const { x0, y0, seed: seed2, ctx, add } = api;
+      const GW = CHUNK4 + 2;
+      const winner = new Array(GW * GW);
+      const widx = (lx, ly) => (ly + 1) * GW + (lx + 1);
+      for (let ly = -1; ly <= CHUNK4; ly++) for (let lx = -1; lx <= CHUNK4; lx++) {
+        winner[widx(lx, ly)] = region(seed2, x0 + lx, y0 + ly).id;
+      }
+      const at = (lx, ly) => winner[widx(lx, ly)];
+      const present = /* @__PURE__ */ new Set();
+      for (let ty = 0; ty < CHUNK4; ty++) for (let tx = 0; tx < CHUNK4; tx++) present.add(at(tx, ty));
+      const single = present.size === 1;
+      const live = [];
+      const metaById = {};
+      for (const id of OVERWORLD_BIOMES) {
+        if (!present.has(id)) continue;
+        const accept = single ? void 0 : (tx, ty) => at(tx, ty) === id;
+        const res = biomes[id].bake({ ...api, ctx: ctx.ctxById[id], accept }) || {};
+        if (res.live) for (const l of res.live) live.push(l);
+        if (res.meta) metaById[id] = res.meta;
+      }
+      const trans = ctx.trans;
+      if (trans && !single) {
+        for (let ty = 0; ty < CHUNK4; ty++) for (let tx = 0; tx < CHUNK4; tx++) {
+          const A = at(tx, ty), rankA = RANK[A];
+          const below = (lx, ly) => {
+            const b = at(lx, ly);
+            return b !== A && RANK[b] < rankA;
+          };
+          const key = boundaryCase(
+            below(tx, ty - 1),
+            below(tx + 1, ty),
+            below(tx, ty + 1),
+            below(tx - 1, ty),
+            below(tx - 1, ty - 1),
+            below(tx + 1, ty - 1),
+            below(tx - 1, ty + 1),
+            below(tx + 1, ty + 1)
+          );
+          if (!key) continue;
+          const B = dominantForeign(at, tx, ty, A, rankA);
+          if (!B) continue;
+          const wx = x0 + tx, wy = y0 + ty;
+          const fgKey = BIOME_GROUNDS[A].fillKey(seed2, wx, wy);
+          const bgKey = BIOME_GROUNDS[B].fillKey(seed2, wx, wy);
+          const variant = hashU32(seed2 ^ 1957, wx, wy) % trans.variants;
+          const cr = trans.tileAt(A, fgKey, B, bgKey, key, variant);
+          if (cr) add(trans.source, cr[0], cr[1], tx, ty);
+        }
+      }
+      return { live, meta: { winner, GW, metaById } };
+    },
+    // Zoomed-out world map: a flat region tint (so lands stay legible at any zoom) modulated by a
+    // little of the biome's internal terrain colour, cross-fading into the runner-up region across
+    // a thin border band so regions read as soft-edged lands, not hard cells.
+    macroColor(seed2, tx, ty) {
+      const { id, id2, edge } = region(seed2, tx, ty);
+      let tint = REGION_TINT[id];
+      if (edge < MACRO_BLEND && id !== id2) tint = lerp3(tint, REGION_TINT[id2], 0.5 * (1 - edge / MACRO_BLEND));
+      return lerp3(tint, biomes[id].macroColor(seed2, tx, ty), TINT_MIX);
+    },
+    // Which biome owns a world tile (no chunk meta needed) — for callers that key behaviour to the
+    // land the player is on (free-roam enemy rosters, per-biome walkability).
+    biomeAt(seed2, wx, wy) {
+      return region(seed2, wx, wy).id;
+    },
+    // Debug grid overlay: dispatch to whichever biome owns the tile, with that biome's chunk meta.
+    tileIndexAt(wx, wy, meta) {
+      if (!meta) return null;
+      const tx = (wx % CHUNK4 + CHUNK4) % CHUNK4, ty = (wy % CHUNK4 + CHUNK4) % CHUNK4;
+      const id = meta.winner[(ty + 1) * meta.GW + (tx + 1)];
+      const bm = meta.metaById[id];
+      return bm ? biomes[id].tileIndexAt(wx, wy, bm) : null;
+    }
+  };
+};
+function dominantForeign(at, tx, ty, A, rankA) {
+  const tally = /* @__PURE__ */ new Map();
+  for (let dy = -1; dy <= 1; dy++) for (let dx = -1; dx <= 1; dx++) {
+    if (!dx && !dy) continue;
+    const b = at(tx + dx, ty + dy);
+    if (b !== A && RANK[b] < rankA) tally.set(b, (tally.get(b) || 0) + 1);
+  }
+  let best = null, bestN = 0;
+  for (const [b, n] of tally) if (n > bestN) {
+    bestN = n;
+    best = b;
+  }
+  return best;
+}
+var GAME_W = 510;
+var GAME_H = 340;
+var BAND_IDS = ["forgottenPlains", "orc", "necropolis"];
+var BAND_WARP_SCALE = 0.014;
+var BAND_WARP_AMP = 26;
+var BAND_EDGE_TILES = 50;
+var bandSub = (seed, salt) => (Math.imul(seed | 0, 2654435761) ^ (salt | 0)) >>> 0;
+function bandedRegion(W) {
+  const b1 = W / 3, b2 = 2 * W / 3;
+  return (seed, x, y) => {
+    const wx = x + BAND_WARP_AMP * (fbm(bandSub(seed, 1441), x * BAND_WARP_SCALE, y * BAND_WARP_SCALE) - 0.5);
+    let i, j, d;
+    if (wx < b1) {
+      i = 0;
+      j = 1;
+      d = b1 - wx;
+    } else if (wx >= b2) {
+      i = 2;
+      j = 1;
+      d = wx - b2;
+    } else {
+      i = 1;
+      const dl = wx - b1, dr = b2 - wx;
+      if (dl < dr) {
+        j = 0;
+        d = dl;
+      } else {
+        j = 2;
+        d = dr;
+      }
+    }
+    const edge = Math.max(0, Math.min(1, d / BAND_EDGE_TILES));
+    return { id: BAND_IDS[i], id2: BAND_IDS[j], edge };
+  };
+}
+function createGameOverworldMap(pixi, host, opts = {}) {
+  const config = overworldConfig(opts.seed ?? 1, {
+    regionFn: bandedRegion(GAME_W),
+    bounds: { x0: 0, y0: 0, x1: GAME_W, y1: GAME_H },
+    // Start the view near the left (Forgotten Plains) edge, vertically centred.
+    initialCamera: { x: 64 * TILE5, y: GAME_H / 2 * TILE5 }
+  });
+  return createChunkedMap(pixi, host, { ...config, keyboardPan: opts.keyboardPan });
 }
 
 // ../auto-battler/src/engine/skills.js
@@ -2061,10 +3216,10 @@ async function createCombatRenderer({ pixi, defsById = {}, layers, coords, getBa
   const actorOf = (id) => getBattle()?.actors.find((x) => x.id === id);
   const floats = [];
   const sheetsById = {};
-  for (const [id, def] of Object.entries(defsById)) {
+  async function loadSheets(id, def) {
     if (!def?.idle) {
       sheetsById[id] = null;
-      continue;
+      return;
     }
     try {
       const load = (url) => url ? recoloredTexture(Texture, url, def.idle, def.recolor) : null;
@@ -2090,6 +3245,7 @@ async function createCombatRenderer({ pixi, defsById = {}, layers, coords, getBa
       sheetsById[id] = null;
     }
   }
+  for (const [id, def] of Object.entries(defsById)) await loadSheets(id, def);
   const skillIcons = {};
   for (const s of CB_SKILLS) {
     try {
@@ -2125,7 +3281,7 @@ async function createCombatRenderer({ pixi, defsById = {}, layers, coords, getBa
   } catch {
   }
   const skillPlay = {};
-  for (const [id, def] of Object.entries(defsById)) {
+  async function buildSkillPlay(id, def) {
     const cell = sheetsById[id]?.cell;
     const map = {};
     for (const [skillId, fxCfg] of Object.entries(def.skillFx || {})) {
@@ -2150,8 +3306,9 @@ async function createCombatRenderer({ pixi, defsById = {}, layers, coords, getBa
     }
     skillPlay[id] = map;
   }
+  for (const [id, def] of Object.entries(defsById)) await buildSkillPlay(id, def);
   const view = {};
-  for (const [id, def] of Object.entries(defsById)) {
+  function buildView(id, def) {
     const sh = sheetsById[id];
     const c = new Container();
     let sp;
@@ -2200,6 +3357,25 @@ async function createCombatRenderer({ pixi, defsById = {}, layers, coords, getBa
     units.addChild(c);
     view[id] = { def, sheets: sh, container: c, sprite: sp, overlay, overlayKey: null, bars, status, statusSprites: {}, outline, castOutline, mode: null, facing: null, flash: 0, dead: false };
   }
+  for (const [id, def] of Object.entries(defsById)) buildView(id, def);
+  async function addActor(id, def) {
+    if (view[id]) return view[id];
+    defsById[id] = def;
+    await loadSheets(id, def);
+    await buildSkillPlay(id, def);
+    buildView(id, def);
+    return view[id];
+  }
+  function removeActor2(id) {
+    const v = view[id];
+    if (!v) return;
+    units.removeChild(v.container);
+    v.container.destroy({ children: true });
+    delete view[id];
+    delete sheetsById[id];
+    delete skillPlay[id];
+    delete defsById[id];
+  }
   function setLoop(v, mode, facing) {
     if (v.mode === mode && v.facing === facing) return;
     v.mode = mode;
@@ -2575,6 +3751,8 @@ async function createCombatRenderer({ pixi, defsById = {}, layers, coords, getBa
     floats,
     actorOf,
     skillPlay,
+    addActor,
+    removeActor: removeActor2,
     setLoop,
     playOnce,
     resume,
@@ -2709,11 +3887,21 @@ function makeActor(unit, team, id, slot) {
     // optional: idle until a foe is within this distance (else always engage)
   };
 }
-function makeTeamBattle({ seed = 1, players = [], enemies = [], sandbox = false, respawnDummies = 0, freeCast = false, world = null } = {}) {
+function makeTeamBattle({ seed = 1, players = [], enemies = [], sandbox = false, respawnDummies = 0, freeCast = false, world = null, field = null } = {}) {
   const actors = [];
   players.filter(Boolean).slice(0, 5).forEach((u, i) => actors.push(makeActor(u, "player", `P${i}`, i)));
   enemies.filter(Boolean).slice(0, 5).forEach((u, i) => actors.push(makeActor(u, "enemy", `E${i}`, i)));
-  return { t: 0, rng: makeRng(seed), actors, projectiles: [], log: [], over: false, winner: null, sandbox, respawnDummies, freeCast, input: {}, world };
+  return { t: 0, rng: makeRng(seed), actors, projectiles: [], log: [], over: false, winner: null, sandbox, respawnDummies, freeCast, input: {}, world, field: field || FIELD };
+}
+function spawnActor(b, unit, team, id) {
+  const a = makeActor(unit, team, id, 0);
+  a.attackTimer = a.weapon.interval;
+  b.actors.push(a);
+  return a;
+}
+function removeActor(b, id) {
+  const i = b.actors.findIndex((a) => a.id === id);
+  if (i >= 0) b.actors.splice(i, 1);
 }
 function setInput(b, id, cmd) {
   if (!b.input) b.input = {};
@@ -2728,12 +3916,12 @@ var CONTACT_SLOP = 2;
 var MAX_BATTLE_T = 90;
 var COLLISION_Y_WEIGHT = 3.2;
 var radiusOf = (unit, tpl) => unit.template?.radius ?? unit.stats?.radius ?? tpl.radius ?? BODY_RADIUS[tpl.role] ?? DEFAULT_RADIUS;
-var edgeGap = (a, t) => dist(a, t) - (a.radius || 0) - (t.radius || 0);
+var edgeGap = (a, t) => dist2(a, t) - (a.radius || 0) - (t.radius || 0);
 var MELEE_REACH = 2;
 var reachOf = (a) => a.role === "ranged" ? a.weapon.range : MELEE_REACH;
 var SPELL_RANGE = 900;
 var ARMOR_IGNORING = /* @__PURE__ */ new Set(["shadow", "holy", "dark", "chaos"]);
-var dist = (a, e) => Math.hypot(a.x - e.x, a.y - e.y);
+var dist2 = (a, e) => Math.hypot(a.x - e.x, a.y - e.y);
 var hasCond = (a, type) => a.conds.some((c) => c.type === type);
 var isKd = (b, a) => a.kd > b.t;
 var gainAdr = (a, n) => {
@@ -2744,7 +3932,7 @@ var alliesOf = (b, a) => b.actors.filter((x) => x.alive && x.team === a.team);
 function nearestFoe(b, a) {
   let best = null, bd = Infinity;
   for (const x of livingFoes(b, a)) {
-    const d = dist(a, x);
+    const d = dist2(a, x);
     if (d < bd) {
       bd = d;
       best = x;
@@ -2764,7 +3952,7 @@ function mostWoundedAlly(b, a, includeSelf = true) {
   }
   return best;
 }
-var adjacentTo = (b, tgt) => b.actors.filter((x) => x.alive && x.team === tgt.team && x !== tgt && dist(x, tgt) <= ADJACENT_GW);
+var adjacentTo = (b, tgt) => b.actors.filter((x) => x.alive && x.team === tgt.team && x !== tgt && dist2(x, tgt) <= ADJACENT_GW);
 var addMod = (b, a, m) => a.mods.push({ until: b.t + (m.dur ?? 0), ...m });
 var activeMods = (b, a, kind) => a.mods.filter((m) => m.kind === kind && m.until > b.t);
 var hasModKind = (b, a, kind) => a.mods.some((m) => m.kind === kind && m.until > b.t);
@@ -3006,12 +4194,13 @@ function applyEffect(b, src, tgt, e, delivery = "spell", s = null) {
   }
 }
 function shadowStep(b, a, tgt) {
+  const f = b.field || FIELD;
   const dx = a.x - tgt.x, dy = a.y - tgt.y, len = Math.hypot(dx, dy) || 1;
-  a.x = Math.max(0, Math.min(FIELD.w, tgt.x + dx / len * (BASIC_MELEE_GW * 0.8)));
-  a.y = Math.max(0, Math.min(FIELD.h, tgt.y + dy / len * (BASIC_MELEE_GW * 0.8)));
+  a.x = Math.max(0, Math.min(f.w, tgt.x + dx / len * (BASIC_MELEE_GW * 0.8)));
+  a.y = Math.max(0, Math.min(f.h, tgt.y + dy / len * (BASIC_MELEE_GW * 0.8)));
 }
 function fireSpellProjectiles(b, src, tgt, amt, e, n) {
-  const base = dist(src, tgt) / 900;
+  const base = dist2(src, tgt) / 900;
   for (let i = 0; i < n; i++) {
     b.projectiles.push({
       srcId: src.id,
@@ -3088,7 +4277,7 @@ function strike(b, a, enemy, s) {
     }
   }
   if (a.role === "ranged") {
-    const flight = dist(a, enemy) / (a.weapon.projSpeed || 800);
+    const flight = dist2(a, enemy) / (a.weapon.projSpeed || 800);
     b.projectiles.push({ srcId: a.id, tgtId: enemy.id, fromX: a.x, fromY: a.y, aimX: enemy.x, aimY: enemy.y, bornT: b.t, hitT: b.t + flight, weaponDmg, bonus, s, empEffect });
     log(b, "shoot", a, { name: s ? s.name : "shot", skillId: s?.id });
   } else {
@@ -3201,7 +4390,7 @@ function usable(b, a, s, tgt, foe, free = false) {
   if (s.cost?.energy && a.energy < s.cost.energy) return false;
   if (s.cost?.adrenaline && a.adrenaline < s.cost.adrenaline) return false;
   if (isAttack(s) && edgeGap(a, foe) > reachOf(a)) return false;
-  if (!isAttack(s) && !isSupport(s) && dist(a, foe) > SPELL_RANGE) return false;
+  if (!isAttack(s) && !isSupport(s) && dist2(a, foe) > SPELL_RANGE) return false;
   for (const r of s.requires || []) {
     if (r === "on_hit") continue;
     if (r.combo_follows && a.marks[foe.id]?.stage !== r.combo_follows) return false;
@@ -3235,7 +4424,7 @@ function chooseAction(b, a, foe) {
   return null;
 }
 function moveActor(b, a, enemy, dt) {
-  const d = dist(a, enemy);
+  const d = dist2(a, enemy);
   let toward = 0;
   if (a.role === "ranged") {
     if (d < (a.preferredRange ?? a.weapon.range * 0.7)) toward = -1;
@@ -3309,9 +4498,10 @@ function timeToHit(px, py, rvx, rvy, R) {
 }
 var clampField = (v, r, max) => Math.max(r, Math.min(max - r, v));
 function stepMove(b, a, vx, vy, dt) {
+  const f = b.field || FIELD;
   const w = b.world && b.world.walkable;
-  let nx = clampField(a.x + vx * dt, a.radius, FIELD.w);
-  let ny = clampField(a.y + vy * dt, a.radius, FIELD.h);
+  let nx = clampField(a.x + vx * dt, a.radius, f.w);
+  let ny = clampField(a.y + vy * dt, a.radius, f.h);
   if (w) {
     if (!w(nx, a.y)) nx = a.x;
     if (!w(nx, ny)) ny = a.y;
@@ -3320,6 +4510,7 @@ function stepMove(b, a, vx, vy, dt) {
   a.y = ny;
 }
 function resolveOverlaps(b) {
+  const f = b.field || FIELD;
   const live = b.actors.filter((a) => a.alive);
   for (let it = 0; it < DEOVERLAP_ITERS; it++) {
     for (let i = 0; i < live.length; i++) {
@@ -3335,10 +4526,10 @@ function resolveOverlaps(b) {
         const aShare = aFix ? 0 : oFix ? 1 : 0.5;
         const oShare = oFix ? 0 : aFix ? 1 : 0.5;
         const yPush = uy / COLLISION_Y_WEIGHT;
-        a.x = clampField(a.x - ux * push * aShare, a.radius, FIELD.w);
-        a.y = clampField(a.y - yPush * push * aShare, a.radius, FIELD.h);
-        o.x = clampField(o.x + ux * push * oShare, o.radius, FIELD.w);
-        o.y = clampField(o.y + yPush * push * oShare, o.radius, FIELD.h);
+        a.x = clampField(a.x - ux * push * aShare, a.radius, f.w);
+        a.y = clampField(a.y - yPush * push * aShare, a.radius, f.h);
+        o.x = clampField(o.x + ux * push * oShare, o.radius, f.w);
+        o.y = clampField(o.y + yPush * push * oShare, o.radius, f.h);
       }
     }
   }
@@ -3439,7 +4630,7 @@ function step(b, dt) {
     if (!a.alive || b.over) continue;
     const enemy = nearestFoe(b, a);
     if (!enemy && a.control !== "player") continue;
-    if (a.aggroRadius != null && a.control !== "player" && dist(a, enemy) > a.aggroRadius) {
+    if (a.aggroRadius != null && a.control !== "player" && dist2(a, enemy) > a.aggroRadius) {
       a.moving = false;
       continue;
     }
@@ -3498,14 +4689,26 @@ function step(b, dt) {
 }
 
 // ../auto-battler/src/sim/walkable.js
-function makeWalkable(seed) {
-  return (wx, wy) => !isRiver(seed, wx, wy) && !isRaised(seed, wx, wy);
+function makeRoamWalkable(seed, biomeAt) {
+  return (wx, wy) => {
+    const b = biomeAt ? biomeAt(wx, wy) : "forgottenPlains";
+    if (b === "necropolis") return !isRiver2(seed, wx, wy) && !isRaised2(seed, wx, wy);
+    if (b === "orc") return true;
+    return !isRiver(seed, wx, wy) && !isRaised(seed, wx, wy);
+  };
 }
 
 // ../auto-battler/src/render/comboBattler.js
-var TILE2 = 8;
+var TILE6 = 8;
 var SPRITE_TILES = 1.9;
 var STEP = 0.05;
+var SPAWN_TILES = 22;
+var SPAWN_JITTER = 6;
+var DESPAWN_TILES = 52;
+var TARGET_FOES = 8;
+var MAX_FOES = 16;
+var SPAWN_INTERVAL = 0.4;
+var DEATH_LINGER = 1.6;
 async function contentHeight(url) {
   try {
     const img = await new Promise((res, rej) => {
@@ -3535,10 +4738,20 @@ function mountComboBattler(pixi, host, opts = {}) {
   const { Graphics, Container } = pixi;
   const seed = (opts.seed ?? 1) >>> 0;
   const G = opts.groundScale ?? 0.3;
-  const mw = makeWalkable(seed);
-  const world = { walkable: (fx, fy) => mw(Math.round(fx * G / TILE2), Math.round(fy * G / TILE2)) };
-  const map = createForgottenPlainsMap(pixi, host, { seed, keyboardPan: false });
-  let battle = null, R = null, combatRoot = null, rings = null;
+  const ARENA = { ox: 0, oy: 0 };
+  const fieldToWorld = (fx, fy) => ({ x: ARENA.ox + fx * G, y: ARENA.oy + fy * G });
+  const worldToField = (wx, wy) => ({ x: (wx - ARENA.ox) / G, y: (wy - ARENA.oy) / G });
+  const map = createGameOverworldMap(pixi, host, { seed, keyboardPan: false });
+  const roamWalkable = makeRoamWalkable(seed, (wx, wy) => map.biomeAt(wx, wy));
+  const world = { walkable: (fx, fy) => {
+    const w = fieldToWorld(fx, fy);
+    return roamWalkable(Math.round(w.x / TILE6), Math.round(w.y / TILE6));
+  } };
+  const rosters = opts.rosters || (() => {
+    const e = opts.enemies || [];
+    return { forgottenPlains: e, orc: e, necropolis: e };
+  })();
+  let battle = null, R = null, combatRoot = null, rings = null, markers = null, spawnFn = null, dead = false;
   const depthScale = { v: 2 };
   let offTick = null, keyHandlers = null, tapHandlers = null, controlsEl = null, alive = true;
   const keys = { x: 0, y: 0 };
@@ -3549,10 +4762,14 @@ function mountComboBattler(pixi, host, opts = {}) {
   const listeners = /* @__PURE__ */ new Set();
   const pa = () => battle?.actors.find((a) => a.id === "P0") || null;
   const ea = () => battle?.actors.filter((a) => a.team === "enemy") || [];
+  const wtile = (fx, fy) => {
+    const w = fieldToWorld(fx, fy);
+    return { wx: Math.round(w.x / TILE6), wy: Math.round(w.y / TILE6) };
+  };
   const snap = () => ({
-    player: pa() ? { x: pa().x, y: pa().y, hp: pa().hp, wx: Math.round(pa().x * G / TILE2), wy: Math.round(pa().y * G / TILE2) } : null,
-    enemies: ea().map((a) => ({ x: a.x, y: a.y, hp: Math.round(a.hp), alive: a.alive, wx: Math.round(a.x * G / TILE2), wy: Math.round(a.y * G / TILE2) })),
-    over: !!battle?.over
+    player: pa() ? { x: pa().x, y: pa().y, hp: pa().hp, ...wtile(pa().x, pa().y) } : null,
+    enemies: ea().map((a) => ({ x: a.x, y: a.y, hp: Math.round(a.hp), alive: a.alive, ...wtile(a.x, a.y) })),
+    over: dead || !!battle?.over
   });
   const emit = () => listeners.forEach((fn) => fn(snap()));
   const KEYMAP = { w: [0, -1], s: [0, 1], a: [-1, 0], d: [1, 0], arrowup: [0, -1], arrowdown: [0, 1], arrowleft: [-1, 0], arrowright: [1, 0] };
@@ -3613,7 +4830,7 @@ function mountComboBattler(pixi, host, opts = {}) {
       downAt = null;
       if (moved > 8 || elapsed > 500) return;
       const r = canvas.getBoundingClientRect(), w = map.screenToWorld(e.clientX - r.left, e.clientY - r.top);
-      moveTarget = { x: w.x / G, y: w.y / G };
+      moveTarget = worldToField(w.x, w.y);
     };
     canvas.addEventListener("pointerdown", onDown);
     window.addEventListener("pointerup", onUp);
@@ -3646,12 +4863,12 @@ function mountComboBattler(pixi, host, opts = {}) {
     host.appendChild(bar);
     controlsEl = bar;
   }
-  const dist2 = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+  const dist3 = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
   const nearestFoeDist = () => {
     const p = pa();
     if (!p) return Infinity;
     let m = Infinity;
-    for (const e of ea()) if (e.alive) m = Math.min(m, dist2(p, e));
+    for (const e of ea()) if (e.alive) m = Math.min(m, dist3(p, e));
     return m;
   };
   function tick(ticker) {
@@ -3682,11 +4899,16 @@ function mountComboBattler(pixi, host, opts = {}) {
       step(battle, STEP);
       acc.t -= STEP;
     }
+    if (!dead && p && !p.alive) {
+      dead = true;
+    }
+    spawnFn && spawnFn(dt);
     R.syncActors(battle, dtMS, battle.t);
     R.updateFloats(dtMS);
     R.drawProjectiles(battle);
     R.processLog(battle, cursor);
     drawRings();
+    drawMarkers();
     emit();
   }
   function drawRings() {
@@ -3695,42 +4917,53 @@ function mountComboBattler(pixi, host, opts = {}) {
     if (!p) return;
     rings.ellipse(p.x, p.y, p.weapon.range, p.weapon.range * 0.6).stroke({ width: 1.5 / G, color: 16777215, alpha: 0.25 });
   }
+  function drawMarkers() {
+    if (!markers) return;
+    markers.clear();
+    const a = 1 - Math.max(0, Math.min(1, (map.getCamera().zoom - 0.5) / (0.9 - 0.5)));
+    if (a <= 0) return;
+    const dot = (fx, fy, color) => {
+      const w = fieldToWorld(fx, fy), s = map.worldToScreen(w.x, w.y);
+      markers.circle(s.x, s.y, 4.5).fill({ color, alpha: a }).stroke({ width: 1.5, color: 1053723, alpha: a });
+    };
+    for (const e of ea()) if (e.alive) dot(e.x, e.y, 16726832);
+    const p = pa();
+    if (p) dot(p.x, p.y, 16766474);
+  }
   const ready = (async () => {
     await map.ready;
     if (!alive) return;
     const cam = map.getCamera();
-    const snapTile = (wx, wy) => {
-      for (let r = 0; r <= 20; r++) for (let dy = -r; dy <= r; dy++) for (let dx = -r; dx <= r; dx++) if (Math.max(Math.abs(dx), Math.abs(dy)) === r && mw(wx + dx, wy + dy)) return { x: wx + dx, y: wy + dy };
-      return { x: wx, y: wy };
+    const bnds = map.getBounds();
+    ARENA.ox = bnds.x0;
+    ARENA.oy = bnds.y0;
+    const field = { w: (bnds.x1 - bnds.x0) / G, h: (bnds.y1 - bnds.y0) / G };
+    const FSTEP = TILE6 / G;
+    const snapField = (fx2, fy) => {
+      for (let r = 0; r <= 24; r++) for (let dy = -r; dy <= r; dy++) for (let dx = -r; dx <= r; dx++) {
+        if (Math.max(Math.abs(dx), Math.abs(dy)) !== r) continue;
+        const x = fx2 + dx * FSTEP, y = fy + dy * FSTEP;
+        if (x >= 0 && x <= field.w && y >= 0 && y <= field.h && world.walkable(x, y)) return { x, y };
+      }
+      return { x: Math.max(0, Math.min(field.w, fx2)), y: Math.max(0, Math.min(field.h, fy)) };
     };
-    const p0 = snapTile(Math.floor(cam.x / TILE2), Math.floor(cam.y / TILE2));
-    const toField = (tile) => ({ x: (tile.x + 0.5) * TILE2 / G, y: (tile.y + 1) * TILE2 / G });
     const pProf = opts.player?.unit?.profession;
     const pSkills = opts.player?.unit?.skills?.length ? opts.player.unit.skills : CB_SKILLS.filter((s) => s.profession === pProf).slice(0, 3).map((s) => s.id);
     const players = [{ ...opts.player?.unit || {}, name: opts.player?.name || "Hero", control: "player", skills: pSkills }];
-    const enemyUnits = (opts.enemies || []).map((e) => ({ ...e.unit || {}, name: e.name }));
-    battle = makeTeamBattle({ seed, players, enemies: enemyUnits, sandbox: true, freeCast: true, world });
-    const pf = toField(p0);
+    battle = makeTeamBattle({ seed, players, enemies: [], sandbox: true, freeCast: true, world, field });
+    const start = worldToField(cam.x, cam.y);
+    const p0 = snapField(start.x, start.y);
     const P = pa();
     if (P) {
-      P.x = pf.x;
-      P.y = pf.y;
-    }
-    ea().forEach((a, i) => {
-      const ring = 7 + i % 3 * 3, ang = i / Math.max(1, ea().length) * Math.PI * 2;
-      const t = snapTile(p0.x + Math.round(Math.cos(ang) * ring), p0.y + Math.round(Math.sin(ang) * ring));
-      const f = toField(t);
-      a.x = f.x;
-      a.y = f.y;
-    });
+      P.x = p0.x;
+      P.y = p0.y;
+    }
     const defsById = {};
     const sd = (o) => ({ idle: o?.idle, walk: o?.walk, attack: o?.attack, dmg: o?.dmg, die: o?.die });
     defsById.P0 = { name: players[0].name, profession: players[0].profession, ...sd(opts.player?.sheets) };
-    ea().forEach((a, i) => {
-      defsById[a.id] = { name: a.name, ...sd((opts.enemies || [])[i]?.sheets) };
-    });
     combatRoot = new Container();
     combatRoot.scale.set(G);
+    combatRoot.position.set(ARENA.ox, ARENA.oy);
     rings = new Graphics();
     combatRoot.addChild(rings);
     const units = new Container();
@@ -3739,11 +4972,59 @@ function mountComboBattler(pixi, host, opts = {}) {
     const proj = new Graphics();
     combatRoot.addChild(units, proj, fx);
     map.getEntityLayer().addChild(combatRoot);
+    markers = new Graphics();
+    map.getApp().stage.addChild(markers);
     const ch = await contentHeight(opts.player?.sheets?.idle || opts.player?.sheets?.walk);
-    depthScale.v = SPRITE_TILES * TILE2 / (ch * G);
+    depthScale.v = SPRITE_TILES * TILE6 / (ch * G);
     R = await createCombatRenderer({ pixi, defsById, layers: { units, fx, projLayer: proj }, coords: { mapX: (x) => x, mapY: (y) => y, depthOf: () => depthScale.v }, getBattle: () => battle });
     if (!alive) return;
     for (const a of battle.actors) a.attackTimer = 0;
+    let foeN = 0;
+    const deadAt = /* @__PURE__ */ new Map();
+    const spawnAcc = { t: SPAWN_INTERVAL };
+    const rosterAt = (fx2, fy) => {
+      const w = fieldToWorld(fx2, fy);
+      const b = map.biomeAt(Math.round(w.x / TILE6), Math.round(w.y / TILE6)) || "forgottenPlains";
+      const r = rosters[b];
+      return r && r.length ? r : rosters.forgottenPlains || [];
+    };
+    const addFoe = async (entry, pos) => {
+      const id = "R" + foeN++;
+      const a = spawnActor(battle, { ...entry.unit || {}, name: entry.name }, "enemy", id);
+      a.x = pos.x;
+      a.y = pos.y;
+      if (alive) await R.addActor(id, { name: entry.name, ...sd(entry.sheets) });
+    };
+    spawnFn = (dt) => {
+      if (dead || !battle) return;
+      const p = pa();
+      if (!p) return;
+      for (const a of ea()) {
+        if (!a.alive) {
+          if (!deadAt.has(a.id)) deadAt.set(a.id, battle.t);
+          else if (battle.t - deadAt.get(a.id) > DEATH_LINGER) {
+            R.removeActor(a.id);
+            removeActor(battle, a.id);
+            deadAt.delete(a.id);
+          }
+        } else if (dist3(a, p) > DESPAWN_TILES * FSTEP) {
+          R.removeActor(a.id);
+          removeActor(battle, a.id);
+        }
+      }
+      spawnAcc.t += dt;
+      if (spawnAcc.t < SPAWN_INTERVAL) return;
+      spawnAcc.t = 0;
+      const need = Math.min(TARGET_FOES, MAX_FOES) - ea().filter((a) => a.alive).length;
+      for (let i = 0; i < need; i++) {
+        const ang = Math.random() * Math.PI * 2;
+        const rr = (SPAWN_TILES + (Math.random() * 2 - 1) * SPAWN_JITTER) * FSTEP;
+        const pos = snapField(p.x + Math.cos(ang) * rr, p.y + Math.sin(ang) * rr);
+        const roster = rosterAt(pos.x, pos.y);
+        if (!roster.length) continue;
+        addFoe(roster[Math.random() * roster.length | 0], pos);
+      }
+    };
     bindKeys();
     bindTap();
     buildControls();
@@ -3781,6 +5062,10 @@ function mountComboBattler(pixi, host, opts = {}) {
       controlsEl?.remove();
     } catch {
     }
+    try {
+      markers?.destroy();
+    } catch {
+    }
     try {
       map.destroy();
     } catch {
@@ -3790,7 +5075,7 @@ function mountComboBattler(pixi, host, opts = {}) {
     combatRoot = null;
     listeners.clear();
   }
-  const ctrl = { ready, getSnapshot, resize, onChange, destroy, map, walkable: (wx, wy) => mw(wx, wy) };
+  const ctrl = { ready, getSnapshot, resize, onChange, destroy, map, walkable: (wx, wy) => roamWalkable(wx, wy) };
   if (typeof window !== "undefined") {
     window.__comboSnap = () => ctrl.getSnapshot();
     window.__combo = ctrl;

web/enemiesSandbox.js

@@ -855,11 +855,11 @@ function makeActor(unit, team, id, slot) {
     // optional: idle until a foe is within this distance (else always engage)
   };
 }
-function makeTeamBattle({ seed = 1, players = [], enemies = [], sandbox = false, respawnDummies = 0, freeCast = false, world = null } = {}) {
+function makeTeamBattle({ seed = 1, players = [], enemies = [], sandbox = false, respawnDummies = 0, freeCast = false, world = null, field = null } = {}) {
   const actors = [];
   players.filter(Boolean).slice(0, 5).forEach((u, i) => actors.push(makeActor(u, "player", `P${i}`, i)));
   enemies.filter(Boolean).slice(0, 5).forEach((u, i) => actors.push(makeActor(u, "enemy", `E${i}`, i)));
-  return { t: 0, rng: makeRng(seed), actors, projectiles: [], log: [], over: false, winner: null, sandbox, respawnDummies, freeCast, input: {}, world };
+  return { t: 0, rng: makeRng(seed), actors, projectiles: [], log: [], over: false, winner: null, sandbox, respawnDummies, freeCast, input: {}, world, field: field || FIELD };
 }
 function setInput(b, id, cmd) {
   if (!b.input) b.input = {};
@@ -1152,9 +1152,10 @@ function applyEffect(b, src, tgt, e, delivery = "spell", s = null) {
   }
 }
 function shadowStep(b, a, tgt) {
+  const f = b.field || FIELD;
   const dx = a.x - tgt.x, dy = a.y - tgt.y, len = Math.hypot(dx, dy) || 1;
-  a.x = Math.max(0, Math.min(FIELD.w, tgt.x + dx / len * (BASIC_MELEE_GW * 0.8)));
-  a.y = Math.max(0, Math.min(FIELD.h, tgt.y + dy / len * (BASIC_MELEE_GW * 0.8)));
+  a.x = Math.max(0, Math.min(f.w, tgt.x + dx / len * (BASIC_MELEE_GW * 0.8)));
+  a.y = Math.max(0, Math.min(f.h, tgt.y + dy / len * (BASIC_MELEE_GW * 0.8)));
 }
 function fireSpellProjectiles(b, src, tgt, amt, e, n) {
   const base = dist(src, tgt) / 900;
@@ -1455,9 +1456,10 @@ function timeToHit(px, py, rvx, rvy, R) {
 }
 var clampField = (v, r, max) => Math.max(r, Math.min(max - r, v));
 function stepMove(b, a, vx, vy, dt) {
+  const f = b.field || FIELD;
   const w = b.world && b.world.walkable;
-  let nx = clampField(a.x + vx * dt, a.radius, FIELD.w);
-  let ny = clampField(a.y + vy * dt, a.radius, FIELD.h);
+  let nx = clampField(a.x + vx * dt, a.radius, f.w);
+  let ny = clampField(a.y + vy * dt, a.radius, f.h);
   if (w) {
     if (!w(nx, a.y)) nx = a.x;
     if (!w(nx, ny)) ny = a.y;
@@ -1466,6 +1468,7 @@ function stepMove(b, a, vx, vy, dt) {
   a.y = ny;
 }
 function resolveOverlaps(b) {
+  const f = b.field || FIELD;
   const live = b.actors.filter((a) => a.alive);
   for (let it = 0; it < DEOVERLAP_ITERS; it++) {
     for (let i = 0; i < live.length; i++) {
@@ -1481,10 +1484,10 @@ function resolveOverlaps(b) {
         const aShare = aFix ? 0 : oFix ? 1 : 0.5;
         const oShare = oFix ? 0 : aFix ? 1 : 0.5;
         const yPush = uy / COLLISION_Y_WEIGHT;
-        a.x = clampField(a.x - ux * push * aShare, a.radius, FIELD.w);
-        a.y = clampField(a.y - yPush * push * aShare, a.radius, FIELD.h);
-        o.x = clampField(o.x + ux * push * oShare, o.radius, FIELD.w);
-        o.y = clampField(o.y + yPush * push * oShare, o.radius, FIELD.h);
+        a.x = clampField(a.x - ux * push * aShare, a.radius, f.w);
+        a.y = clampField(a.y - yPush * push * aShare, a.radius, f.h);
+        o.x = clampField(o.x + ux * push * oShare, o.radius, f.w);
+        o.y = clampField(o.y + yPush * push * oShare, o.radius, f.h);
       }
     }
   }
@@ -2026,10 +2029,10 @@ async function createCombatRenderer({ pixi, defsById = {}, layers, coords, getBa
   const actorOf = (id) => getBattle()?.actors.find((x) => x.id === id);
   const floats = [];
   const sheetsById = {};
-  for (const [id, def] of Object.entries(defsById)) {
+  async function loadSheets(id, def) {
     if (!def?.idle) {
       sheetsById[id] = null;
-      continue;
+      return;
     }
     try {
       const load = (url) => url ? recoloredTexture(Texture, url, def.idle, def.recolor) : null;
@@ -2055,6 +2058,7 @@ async function createCombatRenderer({ pixi, defsById = {}, layers, coords, getBa
       sheetsById[id] = null;
     }
   }
+  for (const [id, def] of Object.entries(defsById)) await loadSheets(id, def);
   const skillIcons = {};
   for (const s of CB_SKILLS) {
     try {
@@ -2090,7 +2094,7 @@ async function createCombatRenderer({ pixi, defsById = {}, layers, coords, getBa
   } catch {
   }
   const skillPlay = {};
-  for (const [id, def] of Object.entries(defsById)) {
+  async function buildSkillPlay(id, def) {
     const cell = sheetsById[id]?.cell;
     const map = {};
     for (const [skillId, fxCfg] of Object.entries(def.skillFx || {})) {
@@ -2115,8 +2119,9 @@ async function createCombatRenderer({ pixi, defsById = {}, layers, coords, getBa
     }
     skillPlay[id] = map;
   }
+  for (const [id, def] of Object.entries(defsById)) await buildSkillPlay(id, def);
   const view = {};
-  for (const [id, def] of Object.entries(defsById)) {
+  function buildView(id, def) {
     const sh = sheetsById[id];
     const c = new Container();
     let sp;
@@ -2165,6 +2170,25 @@ async function createCombatRenderer({ pixi, defsById = {}, layers, coords, getBa
     units.addChild(c);
     view[id] = { def, sheets: sh, container: c, sprite: sp, overlay, overlayKey: null, bars, status, statusSprites: {}, outline, castOutline, mode: null, facing: null, flash: 0, dead: false };
   }
+  for (const [id, def] of Object.entries(defsById)) buildView(id, def);
+  async function addActor(id, def) {
+    if (view[id]) return view[id];
+    defsById[id] = def;
+    await loadSheets(id, def);
+    await buildSkillPlay(id, def);
+    buildView(id, def);
+    return view[id];
+  }
+  function removeActor(id) {
+    const v = view[id];
+    if (!v) return;
+    units.removeChild(v.container);
+    v.container.destroy({ children: true });
+    delete view[id];
+    delete sheetsById[id];
+    delete skillPlay[id];
+    delete defsById[id];
+  }
   function setLoop(v, mode, facing) {
     if (v.mode === mode && v.facing === facing) return;
     v.mode = mode;
@@ -2540,6 +2564,8 @@ async function createCombatRenderer({ pixi, defsById = {}, layers, coords, getBa
     floats,
     actorOf,
     skillPlay,
+    addActor,
+    removeActor,
     setLoop,
     playOnce,
     resume,

web/mapSandbox.js

@@ -16,6 +16,16 @@ function createChunkedMap(pixi, host, config) {
   const MACRO_LEVEL_MAX = config.macroLevelMax ?? 6;
   const DETAIL_BUDGET = config.detailBudget ?? 1;
   const MACRO_BUDGET = config.macroBudget ?? 8;
+  const bounds = config.bounds ? {
+    x0: config.bounds.x0 * TILE6,
+    y0: config.bounds.y0 * TILE6,
+    x1: config.bounds.x1 * TILE6,
+    y1: config.bounds.y1 * TILE6,
+    tx0: config.bounds.x0,
+    ty0: config.bounds.y0,
+    tx1: config.bounds.x1,
+    ty1: config.bounds.y1
+  } : null;
   let app = null, root = null, genRoot = null, macroRoot = null, shadowLayer = null, propLayer = null;
   let ctx = null;
   let alive = true;
@@ -23,7 +33,7 @@ function createChunkedMap(pixi, host, config) {
   let seed = config.seed ?? 1;
   let zoom = Z_DEFAULT;
   let cameraDirty = true, genPending = false, lastEmitTile = null;
-  const camera = { x: CHUNKPX / 2, y: CHUNKPX / 2 };
+  const camera = { x: config.initialCamera?.x ?? CHUNKPX / 2, y: config.initialCamera?.y ?? CHUNKPX / 2 };
   const chunks = /* @__PURE__ */ new Map();
   const macroChunks = /* @__PURE__ */ new Map();
   const fading = /* @__PURE__ */ new Set();
@@ -104,8 +114,21 @@ function createChunkedMap(pixi, host, config) {
     sprite.width = sprite.height = MCHUNK * step * TILE6;
     return { sprite, tex: t };
   }
+  function coverZoom() {
+    if (!bounds || !app) return Z_MIN;
+    return Math.max(app.screen.width / (bounds.x1 - bounds.x0), app.screen.height / (bounds.y1 - bounds.y0));
+  }
+  function clampCamera() {
+    if (!bounds || !app) return;
+    const hw = app.screen.width / 2 / zoom, hh = app.screen.height / 2 / zoom;
+    const loX = bounds.x0 + hw, hiX = bounds.x1 - hw, loY = bounds.y0 + hh, hiY = bounds.y1 - hh;
+    camera.x = loX <= hiX ? Math.min(hiX, Math.max(loX, camera.x)) : (bounds.x0 + bounds.x1) / 2;
+    camera.y = loY <= hiY ? Math.min(hiY, Math.max(loY, camera.y)) : (bounds.y0 + bounds.y1) / 2;
+  }
   function reconcile() {
     if (!genRoot || !ctx || !app) return;
+    if (bounds) zoom = Math.max(zoom, coverZoom());
+    clampCamera();
     const sx = Math.round(app.screen.width / 2 - camera.x * zoom);
     const sy = Math.round(app.screen.height / 2 - camera.y * zoom);
     for (const L of [macroRoot, genRoot, shadowLayer, propLayer]) {
@@ -142,8 +165,14 @@ function createChunkedMap(pixi, host, config) {
   }
   function reconcileDetail() {
     const halfW = app.screen.width / 2 / zoom, halfH = app.screen.height / 2 / zoom;
-    const c0 = Math.floor((camera.x - halfW) / CHUNKPX) - 1, c1 = Math.floor((camera.x + halfW) / CHUNKPX) + 1;
-    const r0 = Math.floor((camera.y - halfH) / CHUNKPX) - 1, r1 = Math.floor((camera.y + halfH) / CHUNKPX) + 1;
+    let c0 = Math.floor((camera.x - halfW) / CHUNKPX) - 1, c1 = Math.floor((camera.x + halfW) / CHUNKPX) + 1;
+    let r0 = Math.floor((camera.y - halfH) / CHUNKPX) - 1, r1 = Math.floor((camera.y + halfH) / CHUNKPX) + 1;
+    if (bounds) {
+      c0 = Math.max(c0, Math.floor(bounds.tx0 / CHUNK5));
+      c1 = Math.min(c1, Math.floor((bounds.tx1 - 1) / CHUNK5));
+      r0 = Math.max(r0, Math.floor(bounds.ty0 / CHUNK5));
+      r1 = Math.min(r1, Math.floor((bounds.ty1 - 1) / CHUNK5));
+    }
     for (const [key, ch] of chunks) {
       const [cx, cy] = key.split(",").map(Number);
       if (cx < c0 - 1 || cx > c1 + 1 || cy < r0 - 1 || cy > r1 + 1) evictChunk(key, ch);
@@ -171,8 +200,15 @@ function createChunkedMap(pixi, host, config) {
   function reconcileMacro(L) {
     const px = MCHUNK * (1 << L) * TILE6;
     const halfW = app.screen.width / 2 / zoom, halfH = app.screen.height / 2 / zoom;
-    const c0 = Math.floor((camera.x - halfW) / px) - 1, c1 = Math.floor((camera.x + halfW) / px) + 1;
-    const r0 = Math.floor((camera.y - halfH) / px) - 1, r1 = Math.floor((camera.y + halfH) / px) + 1;
+    let c0 = Math.floor((camera.x - halfW) / px) - 1, c1 = Math.floor((camera.x + halfW) / px) + 1;
+    let r0 = Math.floor((camera.y - halfH) / px) - 1, r1 = Math.floor((camera.y + halfH) / px) + 1;
+    if (bounds) {
+      const mt = MCHUNK * (1 << L);
+      c0 = Math.max(c0, Math.floor(bounds.tx0 / mt));
+      c1 = Math.min(c1, Math.floor((bounds.tx1 - 1) / mt));
+      r0 = Math.max(r0, Math.floor(bounds.ty0 / mt));
+      r1 = Math.min(r1, Math.floor((bounds.ty1 - 1) / mt));
+    }
     for (const [key, mc] of macroChunks) {
       const [ml, mx, my] = key.split(",").map(Number);
       if (ml !== L || mx < c0 - 1 || mx > c1 + 1 || my < r0 - 1 || my > r1 + 1) {
@@ -209,7 +245,7 @@ function createChunkedMap(pixi, host, config) {
   }
   function zoomAt(factor, lx, ly) {
     if (!app) return;
-    const nz = Math.min(Z_MAX, Math.max(Z_MIN, zoom * factor));
+    const nz = Math.min(Z_MAX, Math.max(bounds ? coverZoom() : Z_MIN, zoom * factor));
     if (nz === zoom) return;
     const sw = app.screen.width, sh = app.screen.height;
     const wx = camera.x + (lx - sw / 2) / zoom, wy = camera.y + (ly - sh / 2) / zoom;
@@ -400,6 +436,12 @@ function createChunkedMap(pixi, host, config) {
     if (!ch) return null;
     return config.tileIndexAt(wx, wy, ch.meta);
   }
+  function biomeAt(wx, wy) {
+    return config.biomeAt ? config.biomeAt(seed, wx, wy) : null;
+  }
+  function getBounds() {
+    return bounds ? { x0: bounds.x0, y0: bounds.y0, x1: bounds.x1, y1: bounds.y1 } : null;
+  }
   function setEnabled(v) {
     enabled = v;
     if (v) cameraDirty = true;
@@ -448,7 +490,7 @@ function createChunkedMap(pixi, host, config) {
     ctx = null;
     texCache.clear();
   }
-  return { ready, regenerate, destroy, onChange, getSnapshot, getCamera, tileIndexAt, zoomBy, setEnabled, onTick, getEntityLayer, getApp, screenToWorld, worldToScreen, tile: TILE6 };
+  return { ready, regenerate, destroy, onChange, getSnapshot, getCamera, tileIndexAt, biomeAt, getBounds, zoomBy, setEnabled, onTick, getEntityLayer, getApp, screenToWorld, worldToScreen, tile: TILE6 };
 }
 
 // ../auto-battler/src/engine/rng.js
@@ -2107,7 +2149,8 @@ var RANK = {};
 OVERWORLD_BIOMES.forEach((id, i) => {
   RANK[id] = i;
 });
-var overworldConfig = (seed) => {
+var overworldConfig = (seed, opts = {}) => {
+  const region = opts.regionFn ?? biomeRegion;
   const biomes = {};
   for (const id of OVERWORLD_BIOMES) {
     const factory = BIOME_FACTORIES[id];
@@ -2119,6 +2162,8 @@ var overworldConfig = (seed) => {
     tile: TILE5,
     chunk: CHUNK4,
     background: "#2b2f3a",
+    bounds: opts.bounds,
+    initialCamera: opts.initialCamera,
     // Each biome loads its own sheets into its own ctx; then build the cross-biome transition atlas
     // from their base grounds. Key everything for bake to route to.
     async load(api) {
@@ -2138,7 +2183,7 @@ var overworldConfig = (seed) => {
       const winner = new Array(GW * GW);
       const widx = (lx, ly) => (ly + 1) * GW + (lx + 1);
       for (let ly = -1; ly <= CHUNK4; ly++) for (let lx = -1; lx <= CHUNK4; lx++) {
-        winner[widx(lx, ly)] = biomeRegion(seed2, x0 + lx, y0 + ly).id;
+        winner[widx(lx, ly)] = region(seed2, x0 + lx, y0 + ly).id;
       }
       const at = (lx, ly) => winner[widx(lx, ly)];
       const present = /* @__PURE__ */ new Set();
@@ -2188,11 +2233,16 @@ var overworldConfig = (seed) => {
     // little of the biome's internal terrain colour, cross-fading into the runner-up region across
     // a thin border band so regions read as soft-edged lands, not hard cells.
     macroColor(seed2, tx, ty) {
-      const { id, id2, edge } = biomeRegion(seed2, tx, ty);
+      const { id, id2, edge } = region(seed2, tx, ty);
       let tint = REGION_TINT[id];
       if (edge < MACRO_BLEND && id !== id2) tint = lerp3(tint, REGION_TINT[id2], 0.5 * (1 - edge / MACRO_BLEND));
       return lerp3(tint, biomes[id].macroColor(seed2, tx, ty), TINT_MIX);
     },
+    // Which biome owns a world tile (no chunk meta needed) — for callers that key behaviour to the
+    // land the player is on (free-roam enemy rosters, per-biome walkability).
+    biomeAt(seed2, wx, wy) {
+      return region(seed2, wx, wy).id;
+    },
     // Debug grid overlay: dispatch to whichever biome owns the tile, with that biome's chunk meta.
     tileIndexAt(wx, wy, meta) {
       if (!meta) return null;

web/tiny.js

@@ -135,6 +135,30 @@ whenEl('skillforge-stage', (el) => { mountSkillForgePanel(el) })
 // link / sidebar ⚙), shared across pages via the runtime.js + tts.js singletons.
 mountSettingsPanel()
 
+// Relocate Gradio's footer links — Use via API, Built with Gradio, Settings — into the sidebar's App
+// slot (#tac-extlinks), then hide the footer. We move the LIVE elements, so each keeps its native
+// behaviour (API panel / open gradio.app / open Settings). They are styled via .tac-extlink only —
+// NOT .tac-nav-item, which would make sidebar.js hijack the click (mark active=white, swallow nav).
+function relocateFooterLinks() {
+  const wanted = (t) => /^(use via api|built with gradio|settings)$/i.test((t || '').trim())
+  const move = () => {
+    const footer = document.querySelector('footer')
+    const host = document.getElementById('tac-extlinks')
+    if (!footer || !host) return false
+    const links = Array.prototype.filter.call(footer.querySelectorAll('a, button'), (e) => wanted(e.textContent))
+    if (links.length < 3) return false // wait until all three exist
+    const ref = document.querySelector('.tac-sidebar .tac-nav-item') // a real nav item, to copy its padding
+    const pad = ref ? getComputedStyle(ref).padding : ''
+    for (const e of links) { e.classList.add('tac-extlink'); if (pad) e.style.padding = pad; host.appendChild(e) }
+    footer.style.display = 'none'
+    return true
+  }
+  if (move()) return
+  const o = new MutationObserver(() => { if (move()) o.disconnect() })
+  o.observe(document.body, { childList: true, subtree: true })
+}
+relocateFooterLinks()
+
 // Sidebar "⚙ Settings" item opens the SAME Gradio settings page as the footer link.
 // Wrap sidebar.js's tacNavigate (already set, since that's a non-module script): the
 // "Settings" nav target clicks Gradio's footer Settings button; everything else routes
@@ -156,15 +180,33 @@ window.tacNavigate = function (target) {
 // on proximity in real-time on the map. The old hardcoded 4v4 demo lived here; this is the shared
 // comboBattler surface (auto-battler source, bundled to /web/comboBattler.js).
 const sheetsOf = (c) => ({ idle: spriteUrl(c.idle), walk: spriteUrl(c.walk), attack: spriteUrl(c.attack), dmg: spriteUrl(c.dmg), die: spriteUrl(c.die) })
-// An enemy band (character slug + combat stats), resolved against characters.json.
-const GAME_ENEMIES = [
-  { name: 'Orc Blade', slug: 'dark-orc-army-orc-blade', stats: { hp: 130, armor: 25, basicDamage: 13 }, attackType: 'melee' },
-  { name: 'Orc Raider', slug: 'dark-orc-army-orc-raider', stats: { hp: 120, armor: 20, basicDamage: 12 }, attackType: 'melee' },
-  { name: 'Orc Scout', slug: 'dark-orc-army-orc-scout', stats: { hp: 90, armor: 12, basicDamage: 10 }, attackType: 'melee' },
-  { name: 'Reaver', slug: 'dark-brotherhood-devoted-blade', stats: { hp: 120, armor: 20, basicDamage: 12 }, attackType: 'melee' },
-  { name: 'Acolyte', slug: 'dark-brotherhood-acolyte', stats: { hp: 100, armor: 15, basicDamage: 10 }, attackType: 'melee' },
-  { name: 'Berserker', slug: 'dark-orc-army-feral-berserker', stats: { hp: 160, armor: 30, basicDamage: 16 }, attackType: 'melee' },
-]
+// Free-roam enemy rosters, one per biome band — the spawner draws from the roster of whichever land
+// the spawn point lands on. Forgotten Plains = human patrols, Orc Kingdom = orcs, Necropolis = the
+// Dark Brotherhood. (slug + combat stats, resolved against characters.json.)
+const GAME_ROSTERS = {
+  forgottenPlains: [
+    { name: 'Swordsman', slug: 'rts-humans-swordsman', stats: { hp: 110, armor: 20, basicDamage: 12 }, attackType: 'melee' },
+    { name: 'Spearman', slug: 'rts-humans-spearman', stats: { hp: 100, armor: 18, basicDamage: 11 }, attackType: 'melee' },
+    { name: 'Knight', slug: 'rts-humans-knight', stats: { hp: 150, armor: 35, basicDamage: 14 }, attackType: 'melee' },
+    { name: 'Archer', slug: 'rts-humans-archer', stats: { hp: 80, armor: 10, basicDamage: 12 }, attackType: 'ranged' },
+  ],
+  orc: [
+    { name: 'Orc Blade', slug: 'dark-orc-army-orc-blade', stats: { hp: 130, armor: 25, basicDamage: 13 }, attackType: 'melee' },
+    { name: 'Orc Raider', slug: 'dark-orc-army-orc-raider', stats: { hp: 120, armor: 20, basicDamage: 12 }, attackType: 'melee' },
+    { name: 'Orc Scout', slug: 'dark-orc-army-orc-scout', stats: { hp: 90, armor: 12, basicDamage: 10 }, attackType: 'melee' },
+    { name: 'Feral Berserker', slug: 'dark-orc-army-feral-berserker', stats: { hp: 160, armor: 30, basicDamage: 16 }, attackType: 'melee' },
+    { name: 'Feral Arbalist', slug: 'dark-orc-army-feral-arbalist', stats: { hp: 95, armor: 14, basicDamage: 13 }, attackType: 'ranged' },
+    { name: 'Cave Troll', slug: 'dark-orc-army-cave-troll', stats: { hp: 220, armor: 40, basicDamage: 20 }, attackType: 'melee' },
+  ],
+  necropolis: [
+    { name: 'Acolyte', slug: 'dark-brotherhood-acolyte', stats: { hp: 100, armor: 15, basicDamage: 10 }, attackType: 'melee' },
+    { name: 'Dark Cultist', slug: 'dark-brotherhood-dark-cultist', stats: { hp: 95, armor: 12, basicDamage: 12 }, attackType: 'ranged' },
+    { name: 'Devoted Blade', slug: 'dark-brotherhood-devoted-blade', stats: { hp: 120, armor: 20, basicDamage: 12 }, attackType: 'melee' },
+    { name: 'Dark Hound', slug: 'dark-brotherhood-dark-hound', stats: { hp: 85, armor: 10, basicDamage: 13 }, attackType: 'melee' },
+    { name: 'Zealot', slug: 'dark-brotherhood-zealot', stats: { hp: 110, armor: 18, basicDamage: 13 }, attackType: 'melee' },
+    { name: 'Dark Abomination', slug: 'dark-brotherhood-dark-abomination', stats: { hp: 200, armor: 35, basicDamage: 18 }, attackType: 'melee' },
+  ],
+}
 // Persona class → engine profession (the engine has templates + skills for these five).
 const PERSONA_PROF = { Warrior: 'Warrior', Ranger: 'Ranger', Monk: 'Monk', Assassin: 'Assassin', Mage: 'Necromancer', Paladin: 'Monk', Cleric: 'Monk', Knight: 'Warrior' }
 const ENEMY_AGGRO = 220 // FIELD units (~8 tiles): enemy idles until the player is this near
@@ -179,10 +221,11 @@ whenEl('battle-stage', async (el) => {
     sheets: sheetsOf(pc),
     unit: { profession: PERSONA_PROF[p?.unitClass] || 'Warrior', name: p?.name || 'Hero' }, // skills filled from profession
   }
-  const enemies = GAME_ENEMIES.map((e) => {
+  const buildRoster = (list) => list.map((e) => {
     const c = chars[e.slug]; if (!c) return null
     return { name: e.name, sheets: sheetsOf(c), unit: { name: e.name, stats: e.stats, attackType: e.attackType, skills: [], aggroRadius: ENEMY_AGGRO } }
   }).filter(Boolean)
-  comboCtrl = mountComboBattler(PIXI, el, { seed: 1, player, enemies })
+  const rosters = Object.fromEntries(Object.entries(GAME_ROSTERS).map(([k, v]) => [k, buildRoster(v)]))
+  comboCtrl = mountComboBattler(PIXI, el, { seed: 1, player, rosters })
   await comboCtrl.ready
 })