Spaces:

build-small-hackathon
/

tiny-army

Running

App Files Files Community

tiny-army / web /comboBattler.js

polats's picture

Game: hero creation + selection flow; pin the Space

3ef6bd6 about 12 hours ago

history blame contribute delete

187 kB

	// ../auto-battler/src/render/chunkedMap.js
	function createChunkedMap(pixi, host, config) {
	const { Application, Assets, Sprite, Container, Texture, Rectangle, RenderTexture } = pixi;
	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;
	const Z_MAX = config.zoomMax ?? 6;
	const Z_STEP = config.zoomStep ?? 1.15;
	const Z_DETAIL = config.zDetail ?? 0.9;
	const Z_MACRO = config.zMacro ?? 0.5;
	const MCHUNK = config.macroChunkTexels ?? 32;
	const MACRO_TEXEL_PX = config.macroTexelPx ?? 2.5;
	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;
	let enabled = true;
	let seed = config.seed ?? 1;
	let zoom = Z_DEFAULT;
	let cameraDirty = true, genPending = false, lastEmitTile = null;
	let flyAnim = null;
	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();
	const keys = /* @__PURE__ */ new Set();
	const texCache = /* @__PURE__ */ new Map();
	const listeners = /* @__PURE__ */ new Set();
	const tickHooks = /* @__PURE__ */ new Set();
	const drag = { on: false, px: 0, py: 0 };
	const pointers = /* @__PURE__ */ new Map();
	const pinch = { on: false, dist: 0 };
	const handlers = {};
	const emit = () => listeners.forEach((fn) => fn(getSnapshot()));
	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 * TILE7, r * TILE7, TILE7, TILE7) });
	texCache.set(k, t);
	}
	return t;
	}
	function texFrame(source, x, y, w, h) {
	const k = source.uid + ":f" + x + "," + y + "," + w + "," + h;
	let t = texCache.get(k);
	if (!t) {
	t = new Texture({ source, frame: new Rectangle(x, y, w, h) });
	texCache.set(k, t);
	}
	return t;
	}
	function makeChunk(cx, cy) {
	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 * TILE7;
	sp.y = ty * TILE7;
	tmp.addChild(sp);
	return sp;
	};
	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";
	app.renderer.render({ container: tmp, target: rt });
	rt.source.updateMipmaps();
	tmp.destroy({ children: true });
	const sprite = new Sprite(rt);
	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 / (TILE7 * z)))));
	}
	function makeMacroChunk(L, mcx, mcy) {
	const step2 = 1 << L, t0x = mcx * MCHUNK * step2, t0y = mcy * MCHUNK * step2;
	const cv = document.createElement("canvas");
	cv.width = MCHUNK;
	cv.height = MCHUNK;
	const g = cv.getContext("2d");
	const img = g.createImageData(MCHUNK, MCHUNK), d = img.data;
	for (let j = 0; j < MCHUNK; j++) for (let i = 0; i < MCHUNK; i++) {
	const [r, gg, b] = config.macroColor(seed, t0x + i * step2 + (step2 >> 1), t0y + j * step2 + (step2 >> 1));
	const o = (j * MCHUNK + i) * 4;
	d[o] = r;
	d[o + 1] = gg;
	d[o + 2] = b;
	d[o + 3] = 255;
	}
	g.putImageData(img, 0, 0);
	const t = Texture.from(cv);
	t.source.scaleMode = "linear";
	const sprite = new Sprite(t);
	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]) {
	L.scale.set(zoom);
	L.x = sx;
	L.y = sy;
	}
	const detailActive = zoom > Z_MACRO;
	const t = Math.max(0, Math.min(1, (zoom - Z_MACRO) / (Z_DETAIL - Z_MACRO)));
	genRoot.visible = shadowLayer.visible = propLayer.visible = detailActive;
	genRoot.alpha = shadowLayer.alpha = propLayer.alpha = t;
	macroRoot.visible = true;
	macroRoot.alpha = 1;
	let pending = false;
	if (detailActive) pending = reconcileDetail() \|\| pending;
	else clearChunks();
	pending = reconcileMacro(chooseMacroLevel(zoom)) \|\| pending;
	genPending = pending;
	}
	function evictChunk(key, ch) {
	fading.delete(ch.sprite);
	genRoot.removeChild(ch.sprite);
	ch.sprite.destroy();
	ch.rt.destroy(true);
	if (ch.live) for (const l of ch.live) {
	propLayer.removeChild(l.sprite);
	l.sprite.destroy();
	if (l.shadow) {
	shadowLayer.removeChild(l.shadow);
	l.shadow.destroy();
	}
	}
	chunks.delete(key);
	}
	function reconcileDetail() {
	const halfW = app.screen.width / 2 / zoom, halfH = app.screen.height / 2 / zoom;
	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);
	}
	const ccx = camera.x / CHUNKPX, ccy = camera.y / CHUNKPX, missing = [];
	for (let cy = r0; cy <= r1; cy++) for (let cx = c0; cx <= c1; cx++) {
	const key = cx + "," + cy;
	if (!chunks.has(key)) missing.push({ cx, cy, key, d: (cx + 0.5 - ccx) 2 + (cy + 0.5 - ccy) 2 });
	}
	missing.sort((a, b) => a.d - b.d);
	for (let i = 0; i < missing.length && i < DETAIL_BUDGET; i++) {
	const { cx, cy, key } = missing[i];
	const ch = makeChunk(cx, cy);
	chunks.set(key, ch);
	genRoot.addChild(ch.sprite);
	ch.sprite.alpha = 0;
	fading.add(ch.sprite);
	if (ch.live) for (const l of ch.live) {
	if (l.shadow) shadowLayer.addChild(l.shadow);
	propLayer.addChild(l.sprite);
	}
	}
	return missing.length > DETAIL_BUDGET;
	}
	function reconcileMacro(L) {
	const px = MCHUNK * (1 << L) * TILE7;
	const halfW = app.screen.width / 2 / zoom, halfH = app.screen.height / 2 / zoom;
	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) {
	macroRoot.removeChild(mc.sprite);
	mc.sprite.destroy();
	mc.tex.destroy(true);
	macroChunks.delete(key);
	}
	}
	const ccx = camera.x / px, ccy = camera.y / px, missing = [];
	for (let my = r0; my <= r1; my++) for (let mx = c0; mx <= c1; mx++) {
	const key = L + "," + mx + "," + my;
	if (!macroChunks.has(key)) missing.push({ mx, my, key, d: (mx + 0.5 - ccx) 2 + (my + 0.5 - ccy) 2 });
	}
	missing.sort((a, b) => a.d - b.d);
	for (let i = 0; i < missing.length && i < MACRO_BUDGET; i++) {
	const { mx, my, key } = missing[i];
	const mc = makeMacroChunk(L, mx, my);
	macroChunks.set(key, mc);
	macroRoot.addChild(mc.sprite);
	}
	return missing.length > MACRO_BUDGET;
	}
	function clearChunks() {
	for (const [key, ch] of chunks) evictChunk(key, ch);
	}
	function clearMacro() {
	for (const [, mc] of macroChunks) {
	macroRoot?.removeChild(mc.sprite);
	mc.sprite.destroy();
	mc.tex.destroy(true);
	}
	macroChunks.clear();
	}
	function zoomAt(factor, lx, ly) {
	if (!app) return;
	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;
	zoom = nz;
	camera.x = wx - (lx - sw / 2) / zoom;
	camera.y = wy - (ly - sh / 2) / zoom;
	cameraDirty = true;
	}
	function zoomBy(factor) {
	if (app) zoomAt(factor, app.screen.width / 2, app.screen.height / 2);
	}
	function flyTo(wx, wy, z, ms = 800) {
	return new Promise((resolve) => {
	if (!app) {
	resolve();
	return;
	}
	if (flyAnim) {
	const r = flyAnim.resolve;
	flyAnim = null;
	r && r();
	}
	const toZ = Math.min(Z_MAX, Math.max(bounds ? coverZoom() : Z_MIN, z));
	flyAnim = { fromX: camera.x, fromY: camera.y, fromZ: zoom, toX: wx, toY: wy, toZ, t: 0, dur: Math.max(1, ms), resolve };
	});
	}
	function bindInput() {
	const canvas = app.canvas;
	const local = (cx, cy) => {
	const r = canvas.getBoundingClientRect();
	return [cx - r.left, cy - r.top];
	};
	const two = () => {
	const it = pointers.values();
	return [it.next().value, it.next().value];
	};
	handlers.down = (e) => {
	if (!enabled \|\| flyAnim) return;
	pointers.set(e.pointerId, { x: e.clientX, y: e.clientY });
	canvas.setPointerCapture?.(e.pointerId);
	if (pointers.size === 1) {
	drag.on = true;
	drag.px = e.clientX;
	drag.py = e.clientY;
	} else if (pointers.size === 2) {
	const [a, b] = two();
	pinch.on = true;
	pinch.dist = Math.hypot(a.x - b.x, a.y - b.y);
	drag.on = false;
	}
	};
	handlers.move = (e) => {
	if (!pointers.has(e.pointerId)) return;
	pointers.set(e.pointerId, { x: e.clientX, y: e.clientY });
	if (pinch.on && pointers.size >= 2) {
	const [a, b] = two(), d = Math.hypot(a.x - b.x, a.y - b.y);
	if (pinch.dist > 0) zoomAt(d / pinch.dist, ...local((a.x + b.x) / 2, (a.y + b.y) / 2));
	pinch.dist = d;
	} else if (drag.on) {
	camera.x -= (e.clientX - drag.px) / zoom;
	camera.y -= (e.clientY - drag.py) / zoom;
	drag.px = e.clientX;
	drag.py = e.clientY;
	cameraDirty = true;
	}
	};
	handlers.up = (e) => {
	pointers.delete(e.pointerId);
	if (pointers.size < 2) pinch.on = false;
	if (pointers.size === 1) {
	const p = pointers.values().next().value;
	drag.on = true;
	drag.px = p.x;
	drag.py = p.y;
	} else if (pointers.size === 0) drag.on = false;
	};
	handlers.wheel = (e) => {
	if (!enabled \|\| flyAnim) return;
	e.preventDefault();
	zoomAt(e.deltaY < 0 ? Z_STEP : 1 / Z_STEP, ...local(e.clientX, e.clientY));
	};
	handlers.key = (down) => (e) => {
	if (!enabled) return;
	const tag = document.activeElement?.tagName;
	if (tag === "INPUT" \|\| tag === "TEXTAREA") return;
	if (["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown"].includes(e.key) \|\| "wasd".includes(e.key.toLowerCase())) {
	e.preventDefault();
	if (down) keys.add(e.key);
	else keys.delete(e.key);
	}
	};
	handlers.keydown = handlers.key(true);
	handlers.keyup = handlers.key(false);
	canvas.style.touchAction = "none";
	canvas.addEventListener("pointerdown", handlers.down);
	canvas.addEventListener("pointermove", handlers.move);
	window.addEventListener("pointerup", handlers.up);
	canvas.addEventListener("wheel", handlers.wheel, { passive: false });
	if (config.keyboardPan !== false) {
	window.addEventListener("keydown", handlers.keydown);
	window.addEventListener("keyup", handlers.keyup);
	}
	}
	function unbindInput() {
	const canvas = app?.canvas;
	canvas?.removeEventListener("pointerdown", handlers.down);
	canvas?.removeEventListener("pointermove", handlers.move);
	window.removeEventListener("pointerup", handlers.up);
	canvas?.removeEventListener("wheel", handlers.wheel);
	window.removeEventListener("keydown", handlers.keydown);
	window.removeEventListener("keyup", handlers.keyup);
	}
	const PAN_SPEED = 6;
	function tick(ticker) {
	for (const fn of tickHooks) fn(ticker);
	if (flyAnim) {
	flyAnim.t += ticker.deltaMS;
	const p = Math.min(1, flyAnim.t / flyAnim.dur);
	const e = p < 0.5 ? 2 * p * p : 1 - Math.pow(-2 * p + 2, 2) / 2;
	camera.x = flyAnim.fromX + (flyAnim.toX - flyAnim.fromX) * e;
	camera.y = flyAnim.fromY + (flyAnim.toY - flyAnim.fromY) * e;
	zoom = flyAnim.fromZ + (flyAnim.toZ - flyAnim.fromZ) * e;
	cameraDirty = true;
	if (p >= 1) {
	const r = flyAnim.resolve;
	flyAnim = null;
	r && r();
	}
	reconcile();
	cameraDirty = false;
	return;
	}
	if (!enabled) return;
	let dx = 0, dy = 0;
	for (const k of keys) {
	if (k === "ArrowLeft" \|\| k === "a" \|\| k === "A") dx -= 1;
	else if (k === "ArrowRight" \|\| k === "d" \|\| k === "D") dx += 1;
	else if (k === "ArrowUp" \|\| k === "w" \|\| k === "W") dy -= 1;
	else if (k === "ArrowDown" \|\| k === "s" \|\| k === "S") dy += 1;
	}
	if (dx \|\| dy) {
	const sp = PAN_SPEED * ticker.deltaTime / zoom;
	camera.x += dx * sp;
	camera.y += dy * sp;
	cameraDirty = true;
	}
	if (fading.size) {
	const step2 = 0.12 * ticker.deltaTime;
	for (const sp of fading) {
	sp.alpha = Math.min(1, sp.alpha + step2);
	if (sp.alpha >= 1) fading.delete(sp);
	}
	}
	if (cameraDirty \|\| genPending) {
	reconcile();
	cameraDirty = false;
	const tk = Math.round(camera.x / TILE7) + "," + Math.round(camera.y / TILE7) + "," + zoom.toFixed(3);
	if (tk !== lastEmitTile) {
	lastEmitTile = tk;
	emit();
	}
	}
	}
	const ready = (async () => {
	const a = new Application();
	await a.init({ background: BG, antialias: false, resizeTo: host });
	if (!alive) {
	a.destroy(true);
	return;
	}
	app = a;
	host.appendChild(app.canvas);
	root = new Container();
	app.stage.addChild(root);
	macroRoot = new Container();
	root.addChild(macroRoot);
	genRoot = new Container();
	root.addChild(genRoot);
	shadowLayer = new Container();
	root.addChild(shadowLayer);
	propLayer = new Container();
	propLayer.sortableChildren = true;
	root.addChild(propLayer);
	ctx = await config.load({ Assets, Texture, Rectangle });
	if (!alive) return;
	bindInput();
	app.ticker.add(tick);
	app.renderer.on("resize", () => {
	cameraDirty = true;
	});
	cameraDirty = true;
	reconcile();
	emit();
	})();
	function getCamera() {
	return { x: camera.x, y: camera.y, zoom };
	}
	function onTick(fn) {
	tickHooks.add(fn);
	return () => tickHooks.delete(fn);
	}
	function getEntityLayer() {
	return propLayer;
	}
	function getApp() {
	return app;
	}
	function screenToWorld(sx, sy) {
	if (!app) return { x: 0, y: 0 };
	return { x: camera.x + (sx - app.screen.width / 2) / zoom, y: camera.y + (sy - app.screen.height / 2) / zoom };
	}
	function worldToScreen(wx, wy) {
	if (!app) return { x: 0, y: 0 };
	return { x: app.screen.width / 2 + (wx - camera.x) * zoom, y: app.screen.height / 2 + (wy - camera.y) * zoom };
	}
	function tileIndexAt(wx, wy) {
	if (!config.tileIndexAt) return null;
	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;
	}
	function regenerate(nextSeed) {
	seed = nextSeed >>> 0;
	clearChunks();
	clearMacro();
	cameraDirty = true;
	reconcile();
	emit();
	}
	function onChange(fn) {
	listeners.add(fn);
	return () => listeners.delete(fn);
	}
	function destroy() {
	alive = false;
	try {
	unbindInput();
	} catch {
	}
	try {
	app?.ticker.remove(tick);
	} catch {
	}
	try {
	clearChunks();
	clearMacro();
	} catch {
	}
	try {
	app?.canvas?.remove();
	} catch {
	}
	try {
	app?.destroy(true, { children: true });
	} catch {
	}
	app = null;
	root = null;
	genRoot = null;
	macroRoot = null;
	shadowLayer = null;
	propLayer = null;
	ctx = null;
	texCache.clear();
	}
	return { ready, regenerate, destroy, onChange, getSnapshot, getCamera, tileIndexAt, biomeAt, getBounds, zoomBy, flyTo, 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
	var rect = (c, r, w, h) => {
	const a = [];
	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);
	h = Math.imul(h ^ (b \| 0) ^ 2246822507, 2246822519);
	h = Math.imul(h ^ (c \| 0) ^ 3266489909, 3266489917);
	h ^= h >>> 15;
	return h >>> 0;
	}
	var sparse = (base, vars, x, y, salt, rate, seed) => {
	if (!vars.length) return base;
	const h = rhash(x, y, salt, 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;
	return [c0 + cx, r0 + cy];
	}
	function centerTile([c0, r0], dNW, dNE, dSW, dSE) {
	if (!dNW && !dNE && !dSW && !dSE) return [c0 + 1, r0 + 1];
	if (dNW && dSE && !dNE && !dSW) return [c0 + 2, r0 + 3];
	if (dNE && dSW && !dNW && !dSE) return [c0 + 2, r0 + 4];
	if (dNW) return [c0, r0 + 3];
	if (dNE) return [c0 + 1, r0 + 3];
	if (dSW) return [c0, r0 + 4];
	return [c0 + 1, r0 + 4];
	}
	function bakeCliffs(cfg, { chunk, x0, y0, seed, raised, place, accept = () => true, stairAt = null, stairAtV = null }) {
	const ST = cfg.STAIR && (stairAt \|\| stairAtV) ? cfg.STAIR : null;
	const useNS = ST && stairAt, useWE = ST && stairAtV;
	const isWide = (ax, ay, room) => room && rhash(ax, ay, ST.WIDE_SALT, seed) % 2 === 0;
	const sAnchor = (x, y) => raised(x, y) && !raised(x, y + 1) && raised(x - 1, y) && raised(x + 1, y) && stairAt(x, y);
	const nAnchor = (x, y) => raised(x, y) && !raised(x, y - 1) && raised(x - 1, y) && raised(x + 1, y) && stairAt(x, y);
	const wAnchor = (x, y) => raised(x, y) && !raised(x - 1, y) && raised(x + 1, y) && raised(x, y - 1) && raised(x, y + 1) && !raised(x - 1, y + 1) && stairAtV(x, y);
	const eAnchor = (x, y) => raised(x, y) && !raised(x + 1, y) && raised(x - 1, y) && raised(x, y - 1) && raised(x, y + 1) && !raised(x + 1, y + 1) && stairAtV(x, y);
	const sRoom = (x, y) => !raised(x + 1, y + 1) && raised(x + 2, y) && !raised(x + 2, y + 1) && raised(x + 3, y);
	const nRoom = (x, y) => !raised(x + 1, y - 1) && raised(x + 2, y) && !raised(x + 2, y - 1) && raised(x + 3, y);
	const wRoom = (x, y) => raised(x, y + 2) && !raised(x - 1, y + 2);
	const eRoom = (x, y) => raised(x, y + 2) && !raised(x + 1, y + 2);
	const W_OFF = [[0, 0], [0, 1], [-1, 0], [-1, 1], [-1, 2]];
	const E_OFF = [[0, 0], [0, 1], [1, 0], [1, 1], [1, 2]];
	const sDepth = useNS ? Math.max(ST.S.NARROW.length, ST.S.WIDE.length) : 0;
	function stairTileAt(wx, wy) {
	if (useNS) {
	for (let drow = 0; drow < sDepth; drow++) for (let dcol = 0; dcol <= 2; dcol++) {
	const ax = wx - dcol, ay = wy - drow;
	if (!sAnchor(ax, ay)) continue;
	if (isWide(ax, ay, sRoom(ax, ay))) {
	if (drow < ST.S.WIDE.length) return ST.S.WIDE[drow][dcol];
	} else if (dcol === 0 && drow < ST.S.NARROW.length) return ST.S.NARROW[drow];
	}
	for (let dcol = 0; dcol <= 2; dcol++) {
	if (nAnchor(wx - dcol, wy)) {
	if (isWide(wx - dcol, wy, nRoom(wx - dcol, wy))) return ST.N.WIDE.LIP[dcol];
	if (dcol === 0) return ST.N.NARROW.LIP;
	}
	if (nAnchor(wx - dcol, wy + 1)) {
	if (isWide(wx - dcol, wy + 1, nRoom(wx - dcol, wy + 1))) return ST.N.WIDE.CAP[dcol];
	if (dcol === 0) return ST.N.NARROW.CAP;
	}
	}
	}
	if (useWE) {
	for (const [dx, dy] of W_OFF) {
	const ax = wx - dx, ay = wy - dy;
	if (!wAnchor(ax, ay)) continue;
	const e = (isWide(ax, ay, wRoom(ax, ay)) ? ST.W.WIDE : ST.W.NARROW).find((o) => o.dx === dx && o.dy === dy);
	if (e) return e.t;
	}
	for (const [dx, dy] of E_OFF) {
	const ax = wx - dx, ay = wy - dy;
	if (!eAnchor(ax, ay)) continue;
	const e = (isWide(ax, ay, eRoom(ax, ay)) ? ST.E.WIDE : ST.E.NARROW).find((o) => o.dx === dx && o.dy === dy);
	if (e) return e.t;
	}
	}
	return null;
	}
	for (let ty = 0; ty < chunk; ty++) for (let tx = 0; tx < chunk; tx++) {
	if (!accept(tx, ty)) continue;
	const wx = x0 + tx, wy = y0 + ty;
	if (ST) {
	const st = stairTileAt(wx, wy);
	if (st) {
	place(st, tx, ty);
	continue;
	}
	}
	if (raised(wx, wy)) {
	const bN = !raised(wx, wy - 1), bE = !raised(wx + 1, wy), bS = !raised(wx, wy + 1), bW = !raised(wx - 1, wy);
	if (bN && bW) place(cfg.LIP_TL, tx, ty);
	else if (bN && bE) place(cfg.LIP_TR, tx, ty);
	else if (bS && bW) place(cfg.LIP_SW, tx, ty);
	else if (bS && bE) place(cfg.LIP_SE, tx, ty);
	else if (bN) place(sparse(cfg.LIP_T, cfg.LIP_T_VAR, wx, wy, 1, cfg.RATE, seed), tx, ty);
	else if (bS) place(sparse(cfg.LIP_S, cfg.LIP_S_VAR, wx, wy, 2, cfg.RATE, seed), tx, ty);
	else if (bW) place(sparse(cfg.WALL_L, cfg.WALL_L_VAR, wx, wy, 3, cfg.RATE, seed), tx, ty);
	else if (bE) place(sparse(cfg.WALL_R, cfg.WALL_R_VAR, wx, wy, 4, cfg.RATE, seed), tx, ty);
	} else {
	for (let k = 1; k <= cfg.FACE_H; k++) {
	if (raised(wx, wy - k)) {
	const leftEnd = !raised(wx - 1, wy - k), rightEnd = !raised(wx + 1, wy - k);
	place(leftEnd ? cfg.FACE_L[k - 1] : rightEnd ? cfg.FACE_R[k - 1] : sparse(cfg.FACE[k - 1], cfg.FACE_VAR[k - 1], wx, wy, 5 + k, cfg.RATE, seed), tx, ty);
	break;
	}
	}
	}
	}
	}

	// ../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 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 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_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]];
	var WATER_BLOCK = [25, 3];
	var WATER_FILL = [26, 4];
	var WATER_VARS = [[26, 4]];
	var FILL_RATE = 6;
	var FP_CLIFF = {
	LIP_T: [25, 16],
	LIP_T_VAR: [],
	LIP_TL: [24, 16],
	LIP_TR: [26, 16],
	WALL_L: [24, 17],
	WALL_L_VAR: [],
	WALL_R: [26, 17],
	WALL_R_VAR: [],
	LIP_S: [25, 18],
	LIP_S_VAR: [],
	LIP_SW: [24, 18],
	LIP_SE: [26, 18],
	FACE_H: 2,
	FACE: [[25, 19], [25, 20]],
	FACE_VAR: [[], []],
	FACE_L: [[24, 19], [24, 20]],
	FACE_R: [[26, 19], [26, 20]],
	RATE: 4,
	// Stair exits cut into straight cliff edges. Two sheet variants, one tile wide (cross at cols 2–6)
	// and two tiles wide (cross at cols 8–14); bakeCliffs picks per-exit by hash. Every tile below is
	// a real non-empty sheet cell — the crosses have transparent corners, so placing those would bleed
	// the grass base through (the bug the NARROW arms used to hit). Layout per direction:
	// • S — NARROW: one column, [lip, step, step, step(onto ground)]. WIDE: 3 columns × those 4 rows.
	// • N — LIP on the raised back edge (grass+steps) + CAP one tile north on the ground; ×3 cols wide.
	// • W/E — a descent off the side wall. Each tile carries its {dx,dy} cell-offset from the wall
	// anchor. NARROW: 3-tile L. WIDE: 2-tall entry on the wall + a 3-tall stone descent beside it.
	STAIR: {
	WIDE_SALT: 359697,
	// hash salt deciding narrow-vs-wide at each exit (~50/50)
	S: {
	NARROW: [[4, 18], [4, 19], [4, 20], [4, 20]],
	WIDE: [
	[[10, 19], [11, 19], [12, 19]],
	[[10, 20], [11, 20], [12, 20]],
	[[10, 21], [11, 21], [12, 21]],
	[[10, 21], [11, 21], [12, 21]]
	]
	},
	N: {
	NARROW: { LIP: [4, 16], CAP: [4, 15] },
	WIDE: { LIP: [[10, 16], [11, 16], [12, 16]], CAP: [[10, 15], [11, 15], [12, 15]] }
	},
	W: {
	NARROW: [{ dx: 0, dy: 0, t: [3, 17] }, { dx: -1, dy: 0, t: [2, 17] }, { dx: -1, dy: 1, t: [2, 18] }],
	WIDE: [
	{ dx: 0, dy: 0, t: [9, 17] },
	{ dx: 0, dy: 1, t: [9, 18] },
	{ dx: -1, dy: 0, t: [8, 17] },
	{ dx: -1, dy: 1, t: [8, 18] },
	{ dx: -1, dy: 2, t: [8, 19] }
	]
	},
	E: {
	NARROW: [{ dx: 0, dy: 0, t: [5, 17] }, { dx: 1, dy: 0, t: [6, 17] }, { dx: 1, dy: 1, t: [6, 18] }],
	WIDE: [
	{ dx: 0, dy: 0, t: [13, 17] },
	{ dx: 0, dy: 1, t: [13, 18] },
	{ dx: 1, dy: 0, t: [14, 17] },
	{ dx: 1, dy: 1, t: [14, 18] },
	{ dx: 1, dy: 2, t: [14, 19] }
	]
	}
	}
	};
	var STAIR_SPACING = 14;
	var COL_CLIFF = [150, 138, 112];
	var FOLIAGE = [
	{ weight: 5, tiles: [[9, 6], [10, 6], [11, 6]] },
	// grass tufts
	{ weight: 3, tiles: [[12, 6], [13, 6]] },
	// small reeds
	{ weight: 3, tiles: [[9, 9], [10, 9], [11, 9], [12, 9], [13, 9]] },
	// flowers (red/purple/daisy) + small grass
	{ weight: 1, sprite: { c: 14, r: 6, w: 1, h: 3 } },
	// tall reed 1×3
	{ weight: 1, sprite: { c: 15, r: 6, w: 2, h: 3 } },
	// wide reed 2×3
	{ weight: 1, sprite: { c: 17, r: 6, w: 2, h: 3 } },
	// wide reed 2×3
	{ weight: 1, sprite: { c: 14, r: 9, w: 1, h: 2 } }
	// cattail 1×2
	];
	var FOLIAGE_WEIGHT = FOLIAGE.reduce((s, g) => s + g.weight, 0);
	var FOLIAGE_RATE = 11;
	var WATER_FOLIAGE = { c: 15, r: 9, w: 1, h: 2 };
	var WATER_FOLIAGE_RATE = 16;
	var TREES = [
	{ frame: [155, 3, 21, 25], ax: 0.48, ay: 0.96 },
	// tree 1 (plain)
	{ frame: [155, 35, 21, 25], ax: 0.48, ay: 0.96 },
	// tree 2 (fruited)
	{ frame: [152, 32, 24, 32], ax: 0.5, ay: 0.94 }
	// tree 3 — full 3×4 fruited (19,4)
	];
	var TREE_SCALE_BASE = 1;
	var TREE_SCALE_JITTER = 0.14;
	var TREE_FLIP_RATE = 0.5;
	var TREE_JITTER = 2;
	var FOREST_BLOCK_X = 3;
	var FOREST_BLOCK_Y = 2;
	var FOREST_THRESHOLD = 0.6;
	var FOREST_MIN_NB = 2;
	var FOREST_FILL = 0.5;
	var STONES = [
	{ c: 8, r: 3, w: 2, h: 2, weight: 3 },
	// small rock
	{ c: 10, r: 3, w: 2, h: 2, weight: 3 },
	// small rock
	{ c: 12, r: 3, w: 2, h: 2, weight: 3 },
	// small flat rock
	{ c: 14, r: 3, w: 2, h: 2, weight: 3 },
	// small rock
	{ c: 16, r: 3, w: 2, h: 2, weight: 3 },
	// small rock
	{ c: 6, r: 3, w: 2, h: 3, weight: 2 },
	// medium boulder
	{ c: 0, r: 3, w: 2, h: 4, weight: 1 },
	// big boulder
	{ c: 2, r: 3, w: 2, h: 4, weight: 1 },
	// big boulder
	{ c: 4, r: 3, w: 2, h: 4, weight: 1 }
	// big knobbly boulder
	];
	var STONE_WEIGHT = STONES.reduce((s, g) => s + g.weight, 0);
	var STONE_BLOCK_X = 2;
	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_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) {
	return new Promise((resolve, reject) => {
	const img = new Image();
	img.onload = () => resolve(img);
	img.onerror = reject;
	img.src = url;
	});
	}
	async function buildShadowMask(url) {
	const img = await loadImg(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 / 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 * TILE3, r * TILE3, TILE3, TILE3).data;
	for (let i = 3; i < d.length; i += 4) {
	if (d[i] > 8) {
	set.add(c + "," + r);
	break;
	}
	}
	}
	return set;
	}
	function chunkFields2(seed, x0, y0) {
	const WATER_BUFFER = 2;
	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);
	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 waterF = clean((x, y) => isRiver(seed, x, y));
	const raisedField = clean((x, y) => isRaised(seed, x, y));
	for (let k = 0; k < waterF.length; k++) if (raisedField[k]) waterF[k] = 0;
	const dirtRaw = clean((x, y) => isDirt(seed, x, y));
	const stoneRaw = clean((x, y) => isStone(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)] = forestField(seed, x0 + i - M, y0 + j - M) > FOREST_THRESHOLD ? 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_NB ? 1 : 0;
	}
	const sraw = new Uint8Array(SZ * SZ);
	for (let j = 0; j < SZ; j++) for (let i = 0; i < SZ; i++) sraw[idx(i, j)] = stoneClumpField(seed, x0 + i - M, y0 + j - M) > STONE_CLUMP_THRESHOLD ? 1 : 0;
	const stoneClumpRegion = new Uint8Array(SZ * SZ);
	for (let j = 1; j < SZ - 1; j++) for (let i = 1; i < SZ - 1; i++) {
	if (!sraw[idx(i, j)]) continue;
	let c = 0;
	for (let dj = -1; dj <= 1; dj++) for (let di = -1; di <= 1; di++) if ((di \|\| dj) && sraw[idx(i + di, j + dj)]) c++;
	stoneClumpRegion[idx(i, j)] = c >= STONE_CLUMP_MIN_NB ? 1 : 0;
	}
	const dirt = new Uint8Array(SZ * SZ), stone = new Uint8Array(SZ * SZ);
	for (let j = WATER_BUFFER; j < SZ - WATER_BUFFER; j++) for (let i = WATER_BUFFER; i < SZ - WATER_BUFFER; i++) {
	let nearW = 0;
	for (let dj = -WATER_BUFFER; dj <= WATER_BUFFER && !nearW; dj++) for (let di = -WATER_BUFFER; di <= WATER_BUFFER; di++) if (waterF[idx(i + di, j + dj)]) {
	nearW = 1;
	break;
	}
	const rais = raisedField[idx(i, j)];
	dirt[idx(i, j)] = dirtRaw[idx(i, j)] && !nearW && !rais ? 1 : 0;
	stone[idx(i, j)] = stoneRaw[idx(i, j)] && !dirtRaw[idx(i, j)] && !nearW && !rais ? 1 : 0;
	}
	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: 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(TILES2);
	t.source.scaleMode = "nearest";
	ctx.tiles = t.source;
	try {
	const s = await Assets.load(SHADOW);
	s.source.scaleMode = "nearest";
	ctx.shadow = s.source;
	} catch {
	}
	try {
	ctx.shadowSet = await buildShadowMask(SHADOW);
	} catch {
	ctx.shadowSet = null;
	}
	try {
	const p = await Assets.load(PROPS);
	p.source.scaleMode = "nearest";
	ctx.props = p.source;
	} catch {
	}
	try {
	const p = await Assets.load(PROP_SHADOW);
	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 = 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;
	const atD = (wx, wy) => dirt[idx(wx - x0 + M, wy - y0 + M)] === 1;
	const atS = (wx, wy) => stone[idx(wx - x0 + M, wy - y0 + M)] === 1;
	const isRaisedAt = (wx, wy) => raisedField[idx(wx - x0 + M, wy - y0 + M)] === 1;
	const place = (coord, tx, ty) => {
	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 * TILE3;
	sh.y = ty * TILE3;
	tmp.addChild(sh);
	}
	};
	const blob = (atFn, BLOCK, fillBase, fillVars, salt, wx, wy, tx, ty) => {
	const N = !atFn(wx, wy - 1), E = !atFn(wx + 1, wy), S = !atFn(wx, wy + 1), W = !atFn(wx - 1, wy);
	if (N && E && S && W) {
	place(sparse(fillBase, fillVars, wx, wy, salt, FILL_RATE, seed2), tx, ty);
	return;
	}
	let cr;
	if (!N && !E && !S && !W) {
	const dNW = !atFn(wx - 1, wy - 1), dNE = !atFn(wx + 1, wy - 1), dSW = !atFn(wx - 1, wy + 1), dSE = !atFn(wx + 1, wy + 1);
	if (!dNW && !dNE && !dSW && !dSE) {
	place(sparse(fillBase, fillVars, wx, wy, salt, FILL_RATE, seed2), tx, ty);
	return;
	}
	cr = centerTile(BLOCK, dNW, dNE, dSW, dSE);
	} else cr = blockTile(BLOCK, N, E, S, W);
	place(cr, tx, ty);
	};
	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_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 * TILE3, (spec.r - spec.h + 1) * TILE3, spec.w * TILE3, spec.h * TILE3));
	sp.anchor.set(0.5, 1);
	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 < 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)) {
	if (hashU32(seed2 ^ 24301, wx, wy) % WATER_FOLIAGE_RATE === 0) live.push({ sprite: propSprite(WATER_FOLIAGE, wx, wy), shadow: null });
	continue;
	}
	if (atD(wx, wy) \|\| atS(wx, wy)) continue;
	const h = hashU32(seed2 ^ 15733114, wx, wy);
	if (h % FOLIAGE_RATE !== 0) continue;
	let pick = (h >>> 8) % FOLIAGE_WEIGHT, g = FOLIAGE[0];
	for (const grp of FOLIAGE) {
	if (pick < grp.weight) {
	g = grp;
	break;
	}
	pick -= grp.weight;
	}
	if (g.sprite) {
	live.push({ sprite: propSprite(g.sprite, wx, wy), shadow: null });
	continue;
	}
	const [c, r] = g.tiles[(h >>> 16) % g.tiles.length];
	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) => {
	const off = hashU32(seed2 ^ 358936, Math.floor(wy / STAIR_SPACING), 0) % STAIR_SPACING;
	return ((wx - off) % STAIR_SPACING + STAIR_SPACING) % STAIR_SPACING === 0;
	};
	const stairAtV = (wx, wy) => {
	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: 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 + 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 + 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;
	if (atW(wx, wy) \|\| atS(wx, wy)) continue;
	if (!isRaisedAt(wx, wy)) {
	let onFace = false;
	for (let k = 1; k <= FP_CLIFF.FACE_H; k++) if (isRaisedAt(wx, wy - k)) {
	onFace = true;
	break;
	}
	if (onFace) continue;
	}
	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 * 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);
	tr.x = px;
	tr.y = py;
	tr.zIndex = py;
	let shadow = null;
	if (ctx.propShadow) {
	shadow = new Sprite(texFrame(ctx.propShadow, ...T.frame));
	shadow.anchor.set(T.ax, T.ay);
	shadow.scale.set(flip ? -sc : sc, sc);
	shadow.x = px;
	shadow.y = py;
	}
	live.push({ sprite: tr, shadow });
	}
	}
	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 + 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 + 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;
	if (atW(wx, wy)) continue;
	if (!isRaisedAt(wx, wy)) {
	let onFace = false;
	for (let k = 1; k <= FP_CLIFF.FACE_H; k++) if (isRaisedAt(wx, wy - k)) {
	onFace = true;
	break;
	}
	if (onFace) continue;
	}
	let pick = (h >>> 20) % STONE_WEIGHT, st = STONES[0];
	for (const s of STONES) {
	if (pick < s.weight) {
	st = s;
	break;
	}
	pick -= s.weight;
	}
	live.push({ sprite: propSprite(st, wx, wy), shadow: null });
	}
	}
	return { meta: f, live };
	},
	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_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 >= 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;
	const N = !at(wx, wy - 1), E = !at(wx + 1, wy), S = !at(wx, wy + 1), W = !at(wx - 1, wy);
	if (N && E && S && W) return fill;
	if (!N && !E && !S && !W) {
	const dNW = !at(wx - 1, wy - 1), dNE = !at(wx + 1, wy - 1), dSW = !at(wx - 1, wy + 1), dSE = !at(wx + 1, wy + 1);
	if (!dNW && !dNE && !dSW && !dSE) return fill;
	return centerTile(BLOCK, dNW, dNE, dSW, dSE);
	}
	return blockTile(BLOCK, N, E, S, W);
	};
	if (waterF[idx(wx - x0 + M, wy - y0 + M)] === 1) return pick(waterF, WATER_BLOCK, WATER_FILL);
	if (stone[idx(wx - x0 + M, wy - y0 + M)] === 1) return pick(stone, STONE_BLOCK, STONE_FILL);
	if (dirt[idx(wx - x0 + M, wy - y0 + M)] === 1) return pick(dirt, DIRT_BLOCK, DIRT_FILL);
	return GRASS_BASE;
	}
	});

	// ../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 = 720;
	var GAME_H = 480;
	var BAND_IDS = ["forgottenPlains", "orc", "necropolis"];
	var BAND_WARP_SCALE = 0.014;
	var BAND_WARP_T = 0.035;
	var BAND_EDGE_T = 0.06;
	var bandSub = (seed, salt) => (Math.imul(seed \| 0, 2654435761) ^ (salt \| 0)) >>> 0;
	function diagonalRegion(W, H) {
	const b1 = 0.8, b2 = 1.2;
	return (seed, x, y) => {
	const warp = BAND_WARP_T * (fbm(bandSub(seed, 1441), x * BAND_WARP_SCALE, y * BAND_WARP_SCALE) - 0.5) * 2;
	const t = x / W + (H - y) / H + warp;
	let i, j, d;
	if (t < b1) {
	i = 0;
	j = 1;
	d = b1 - t;
	} else if (t >= b2) {
	i = 2;
	j = 1;
	d = t - b2;
	} else {
	i = 1;
	const dl = t - b1, dr = b2 - t;
	if (dl < dr) {
	j = 0;
	d = dl;
	} else {
	j = 2;
	d = dr;
	}
	}
	const edge = Math.max(0, Math.min(1, d / BAND_EDGE_T));
	return { id: BAND_IDS[i], id2: BAND_IDS[j], edge };
	};
	}
	function createGameOverworldMap(pixi, host, opts = {}) {
	const config = overworldConfig(opts.seed ?? 1, {
	regionFn: diagonalRegion(GAME_W, GAME_H),
	bounds: { x0: 0, y0: 0, x1: GAME_W, y1: GAME_H },
	// Start the view in the bottom-left (Forgotten Plains) corner.
	initialCamera: { x: 64 * TILE5, y: (GAME_H - 64) * TILE5 }
	});
	return createChunkedMap(pixi, host, { ...config, keyboardPan: opts.keyboardPan });
	}

	// ../auto-battler/src/engine/skills.js
	var FIRST_15 = [
	// ── Warrior: adrenaline-fuelled condition → spike (Swordsmanship line) ──
	{
	id: 382,
	name: "Sever Artery",
	profession: "Warrior",
	attribute: "Swordsmanship",
	category: "melee_attack",
	target: "foe",
	cost: { adrenaline: 4 },
	cast: 0,
	recharge: 0,
	requires: ["on_hit"],
	effects: [{ op: "apply_condition", condition: "bleeding", duration: { scale: [5, 25] } }]
	},
	{
	id: 384,
	name: "Gash",
	profession: "Warrior",
	attribute: "Swordsmanship",
	category: "melee_attack",
	target: "foe",
	cost: { adrenaline: 6 },
	cast: 0,
	recharge: 0,
	// The payoff: bonus damage + Deep Wound, but only on an already-Bleeding foe.
	requires: ["on_hit", { target: "bleeding" }],
	effects: [
	{ op: "bonus_damage", amount: { scale: [5, 20] } },
	{ op: "apply_condition", condition: "deepWound", duration: { scale: [5, 20] } }
	]
	},
	{
	id: 385,
	name: "Final Thrust",
	profession: "Warrior",
	attribute: "Swordsmanship",
	category: "melee_attack",
	target: "foe",
	cost: { adrenaline: 10 },
	cast: 0,
	recharge: 0,
	requires: ["on_hit"],
	effects: [
	{ op: "lose_all_adrenaline" },
	{ op: "bonus_damage", amount: { scale: [1, 40] } },
	// "doubled if below 50%" — applying the same bonus a second time, gated.
	{ op: "bonus_damage", amount: { scale: [1, 40] }, if: { target_below_health: 0.5 } }
	]
	},
	// ── Ranger: preparations + ranged conditions/interrupt ──
	{
	id: 435,
	name: "Apply Poison",
	profession: "Ranger",
	attribute: "Wilderness Survival",
	category: "preparation",
	target: "self",
	cost: { energy: 15 },
	cast: 2,
	recharge: 12,
	// The differentiator: a self rider — future physical attacks inflict Poison.
	effects: [{
	op: "preparation",
	duration: { fixed: 24 },
	on_attack: [{ op: "apply_condition", condition: "poison", duration: { scale: [3, 15] } }]
	}]
	},
	{
	id: 391,
	name: "Hunter's Shot",
	profession: "Ranger",
	attribute: "Marksmanship",
	category: "bow_attack",
	target: "foe",
	cost: { energy: 5 },
	cast: 1,
	recharge: 10,
	requires: ["on_hit"],
	effects: [{ op: "apply_condition", condition: "bleeding", duration: { scale: [3, 25] } }]
	},
	{
	id: 426,
	name: "Savage Shot",
	profession: "Ranger",
	attribute: "Marksmanship",
	category: "bow_attack",
	target: "foe",
	cost: { energy: 10 },
	cast: 0.5,
	recharge: 5,
	requires: ["on_hit"],
	effects: [
	{ op: "interrupt" },
	// Bonus only if the interrupted action was a spell.
	{ op: "bonus_damage", amount: { scale: [13, 28] }, if: { target: "casting_spell" } }
	]
	},
	// ── Necromancer: trigger-hexes (the event bus / physway) ──
	{
	id: 121,
	name: "Spiteful Spirit",
	profession: "Necromancer",
	attribute: "Curses",
	category: "hex",
	target: "foe",
	cost: { energy: 15 },
	cast: 2,
	recharge: 10,
	elite: true,
	effects: [{
	op: "hex",
	duration: { scale: [8, 20] },
	trigger: "on_action",
	payload: [{ op: "damage", damageType: "shadow", amount: { scale: [5, 35] }, scope: "target_and_adjacent" }]
	}]
	},
	{
	id: 101,
	name: "Barbs",
	profession: "Necromancer",
	attribute: "Curses",
	category: "hex",
	target: "foe",
	cost: { energy: 10 },
	cast: 2,
	recharge: 5,
	effects: [{
	op: "hex",
	duration: { fixed: 30 },
	// Passive amplifier — no discrete trigger; the damage pipeline reads it.
	payload: [{ op: "amplify_damage", amount: { scale: [1, 15] }, vs: "physical" }]
	}]
	},
	{
	id: 150,
	name: "Mark of Pain",
	profession: "Necromancer",
	attribute: "Curses",
	category: "hex",
	target: "foe",
	cost: { energy: 10 },
	cast: 1,
	recharge: 20,
	effects: [{
	op: "hex",
	duration: { fixed: 30 },
	trigger: "on_physical_hit",
	payload: [{ op: "damage", damageType: "shadow", amount: { scale: [10, 40] }, scope: "adjacent_to_target" }]
	}]
	},
	// ── Monk: the damage-interception pipeline ──
	{
	id: 245,
	name: "Protective Spirit",
	profession: "Monk",
	attribute: "Protection Prayers",
	category: "enchantment",
	target: "ally",
	cost: { energy: 10 },
	cast: 0.25,
	recharge: 5,
	effects: [{
	op: "enchant",
	duration: { scale: [5, 23] },
	// Cap: a single hit can't remove more than 10% of max Health.
	payload: [{ op: "cap_damage", maxFraction: 0.1 }]
	}]
	},
	{
	id: 307,
	name: "Reversal of Fortune",
	profession: "Monk",
	attribute: "Protection Prayers",
	category: "enchantment",
	target: "ally",
	cost: { energy: 5 },
	cast: 0.25,
	recharge: 2,
	effects: [{
	op: "enchant",
	duration: { fixed: 8 },
	charges: 1,
	trigger: "on_incoming_damage",
	payload: [{ op: "convert_damage_to_heal", cap: { scale: [15, 80] } }]
	}]
	},
	{
	id: 1114,
	name: "Spirit Bond",
	profession: "Monk",
	attribute: "Protection Prayers",
	category: "enchantment",
	target: "ally",
	cost: { energy: 10 },
	cast: 0.25,
	recharge: 2,
	effects: [{
	op: "enchant",
	duration: { fixed: 8 },
	charges: 10,
	trigger: "on_incoming_damage",
	threshold: { perHitDamageOver: 50 },
	payload: [{ op: "heal", amount: { scale: [30, 90] }, scope: "target" }]
	}]
	},
	// ── Assassin: the combo chain (lead → off-hand → dual) ──
	{
	id: 782,
	name: "Jagged Strike",
	profession: "Assassin",
	attribute: "Dagger Mastery",
	category: "lead_attack",
	target: "foe",
	cost: { energy: 5 },
	cast: 0.5,
	recharge: 1,
	requires: ["on_hit"],
	effects: [
	{ op: "apply_condition", condition: "bleeding", duration: { scale: [5, 20] } },
	{ op: "set_combo_mark", stage: "lead" }
	]
	},
	{
	id: 780,
	name: "Fox Fangs",
	profession: "Assassin",
	attribute: "Dagger Mastery",
	category: "offhand_attack",
	target: "foe",
	cost: { energy: 5 },
	cast: 0.5,
	recharge: 3,
	requires: ["on_hit", { combo_follows: "lead" }],
	effects: [
	{ op: "bonus_damage", amount: { scale: [10, 35] }, unblockable: true },
	{ op: "set_combo_mark", stage: "offhand" }
	]
	},
	{
	id: 775,
	name: "Death Blossom",
	profession: "Assassin",
	attribute: "Dagger Mastery",
	category: "dual_attack",
	target: "foe",
	cost: { energy: 5 },
	cast: 0,
	recharge: 2,
	requires: ["on_hit", { combo_follows: "offhand" }],
	effects: [
	{ op: "bonus_damage", amount: { scale: [20, 45] } },
	{ op: "damage", amount: { scale: [20, 45] }, scope: "adjacent_to_target" }
	]
	}
	];
	var VARIANT_EXTRA = [
	// ── Warrior · Sentinel (soak / protect) ──
	{
	id: 348,
	name: '"Watch Yourself!"',
	profession: "Warrior",
	attribute: "Tactics",
	category: "shout",
	target: "party",
	cost: { adrenaline: 4 },
	cast: 0,
	recharge: 4,
	// Party armor for 10s, but the buff also ends after 10 incoming attacks.
	effects: [{ op: "armor_mod", amount: { scale: [5, 25] }, duration: { fixed: 10 }, attacksLeft: 10, scope: "party" }]
	},
	{
	id: 372,
	name: "Gladiator's Defense",
	profession: "Warrior",
	attribute: "Tactics",
	category: "stance",
	target: "self",
	cost: { energy: 5 },
	cast: 0,
	recharge: 30,
	elite: true,
	// 75% block; whoever you block in melee takes 5…35 back.
	effects: [{ op: "block", chance: 0.75, vs: "melee", reflect: { scale: [5, 35] }, duration: { scale: [5, 11] } }]
	},
	{
	id: 1,
	name: "Healing Signet",
	profession: "Warrior",
	attribute: "Tactics",
	category: "signet",
	target: "self",
	cost: {},
	cast: 2,
	recharge: 4,
	effects: [{ op: "heal", amount: { scale: [82, 172] }, scope: "self" }],
	whileActivating: [{ op: "armor_mod", amount: -40, duration: { fixed: 0 }, scope: "self" }]
	// −40 armor while using
	},
	// ── Warrior · Breaker (knockdown control) ──
	{
	id: 332,
	name: "Bull's Strike",
	profession: "Warrior",
	attribute: "Strength",
	category: "melee_attack",
	target: "foe",
	cost: { energy: 5 },
	cast: 0,
	recharge: 10,
	requires: ["on_hit", { target: "moving" }],
	effects: [
	{ op: "bonus_damage", amount: { scale: [5, 30] } },
	{ op: "knockdown", duration: { fixed: 2 } }
	]
	},
	{
	id: 331,
	name: "Hammer Bash",
	profession: "Warrior",
	attribute: "Hammer Mastery",
	category: "melee_attack",
	target: "foe",
	cost: { adrenaline: 6 },
	cast: 0,
	recharge: 0,
	requires: ["on_hit"],
	effects: [
	{ op: "knockdown", duration: { fixed: 2 } },
	{ op: "lose_all_adrenaline" }
	]
	},
	{
	id: 352,
	name: "Crushing Blow",
	profession: "Warrior",
	attribute: "Hammer Mastery",
	category: "melee_attack",
	target: "foe",
	cost: { energy: 5 },
	cast: 0,
	recharge: 10,
	requires: ["on_hit"],
	effects: [
	{ op: "bonus_damage", amount: { scale: [1, 20] } },
	{ op: "apply_condition", condition: "deepWound", duration: { scale: [5, 20] }, if: { target: "knocked_down" } }
	]
	},
	// ── Ranger · Sharpshooter (Punishing Shot completes the interrupt bar) ──
	{
	id: 409,
	name: "Punishing Shot",
	profession: "Ranger",
	attribute: "Marksmanship",
	category: "bow_attack",
	target: "foe",
	cost: { energy: 10 },
	cast: 0.5,
	recharge: 5,
	elite: true,
	requires: ["on_hit"],
	effects: [
	{ op: "bonus_damage", amount: { scale: [10, 20] } },
	{ op: "interrupt" }
	]
	},
	// ── Ranger · Toxicologist (stacked degen) ──
	{
	id: 1470,
	name: "Barbed Arrows",
	profession: "Ranger",
	attribute: "Wilderness Survival",
	category: "preparation",
	target: "self",
	cost: { energy: 10 },
	cast: 2,
	recharge: 12,
	effects: [{
	op: "preparation",
	duration: { fixed: 24 },
	on_attack: [{ op: "apply_condition", condition: "bleeding", duration: { scale: [3, 15] } }]
	}],
	whileActivating: [{ op: "armor_mod", amount: -40, duration: { fixed: 0 }, scope: "self" }]
	// −40 armor while activating
	},
	{
	id: 1466,
	name: "Burning Arrow",
	profession: "Ranger",
	attribute: "Marksmanship",
	category: "bow_attack",
	target: "foe",
	cost: { energy: 10 },
	cast: 0,
	recharge: 5,
	elite: true,
	requires: ["on_hit"],
	effects: [
	{ op: "bonus_damage", amount: { scale: [10, 30] } },
	{ op: "apply_condition", condition: "burning", duration: { scale: [1, 7] } }
	]
	},
	// ── Ranger · Survivalist (sustain / kite) ──
	{
	id: 446,
	name: "Troll Unguent",
	profession: "Ranger",
	attribute: "Wilderness Survival",
	category: "skill",
	target: "self",
	cost: { energy: 5 },
	cast: 3,
	recharge: 10,
	effects: [{ op: "regen_mod", pips: { scale: [3, 10] }, duration: { fixed: 13 }, scope: "self" }]
	},
	{
	id: 1727,
	name: "Natural Stride",
	profession: "Ranger",
	attribute: "Wilderness Survival",
	category: "stance",
	target: "self",
	cost: { energy: 5 },
	cast: 0,
	recharge: 12,
	// Move 33% faster + 50% block; the stance ends if you become hexed/enchanted.
	effects: [
	{ op: "move_speed", mult: 1.33, duration: { scale: [1, 8] }, endsOnHexEnchant: true },
	{ op: "block", chance: 0.5, vs: "all", duration: { scale: [1, 8] }, endsOnHexEnchant: true }
	]
	},
	{
	id: 393,
	name: "Crippling Shot",
	profession: "Ranger",
	attribute: "Marksmanship",
	category: "bow_attack",
	target: "foe",
	cost: { energy: 10 },
	cast: 0,
	recharge: 2,
	elite: true,
	requires: ["on_hit"],
	effects: [{ op: "apply_condition", condition: "crippled", duration: { scale: [1, 12] }, unblockable: true }]
	},
	// ── Necromancer · Vampire (life-steal sustain) ──
	{
	id: 153,
	name: "Vampiric Gaze",
	profession: "Necromancer",
	attribute: "Blood Magic",
	category: "spell",
	target: "foe",
	cost: { energy: 10 },
	cast: 1,
	recharge: 8,
	effects: [{ op: "life_steal", amount: { scale: [18, 60] } }]
	},
	{
	id: 109,
	name: "Life Siphon",
	profession: "Necromancer",
	attribute: "Blood Magic",
	category: "hex",
	target: "foe",
	cost: { energy: 10 },
	cast: 1,
	recharge: 5,
	effects: [
	{ op: "regen_mod", pips: { scale: [-1, -3] }, duration: { scale: [12, 24] }, scope: "target" },
	{ op: "regen_mod", pips: { scale: [1, 3] }, duration: { scale: [12, 24] }, scope: "self" }
	]
	},
	{
	id: 115,
	name: "Blood Renewal",
	profession: "Necromancer",
	attribute: "Blood Magic",
	category: "enchantment",
	target: "self",
	cost: { energy: 1, sacrifice: 15 },
	cast: 1,
	recharge: 7,
	// +3…6 regen for 7s, then a burst heal of 40…190 when the enchant ends.
	effects: [
	{ op: "regen_mod", pips: { scale: [3, 6] }, duration: { fixed: 7 }, scope: "self" },
	{ op: "enchant", duration: { fixed: 7 }, trigger: "on_end", payload: [{ op: "heal", amount: { scale: [40, 190] }, scope: "self" }] }
	]
	},
	// ── Necromancer · Plaguebearer (condition spread) ──
	{
	id: 118,
	name: "Enfeebling Blood",
	profession: "Necromancer",
	attribute: "Curses",
	category: "spell",
	target: "foe",
	cost: { energy: 1, sacrifice: 10 },
	cast: 1,
	recharge: 8,
	effects: [{ op: "apply_condition", condition: "weakness", duration: { scale: [5, 20] }, scope: "target_and_adjacent" }]
	},
	{
	id: 106,
	name: "Rotting Flesh",
	profession: "Necromancer",
	attribute: "Death Magic",
	category: "spell",
	target: "foe",
	cost: { energy: 15 },
	cast: 3,
	recharge: 3,
	effects: [{ op: "apply_condition", condition: "disease", duration: { scale: [10, 25] } }]
	},
	{
	id: 135,
	name: "Faintheartedness",
	profession: "Necromancer",
	attribute: "Curses",
	category: "hex",
	target: "foe",
	cost: { energy: 10 },
	cast: 1,
	recharge: 8,
	effects: [
	{ op: "regen_mod", pips: { scale: [0, -3] }, duration: { scale: [3, 16] }, scope: "target" },
	{ op: "attack_speed", mult: 2, duration: { scale: [3, 16] }, scope: "target" }
	]
	},
	// ── Monk · Healer (raw healing) ──
	{
	id: 281,
	name: "Orison of Healing",
	profession: "Monk",
	attribute: "Healing Prayers",
	category: "spell",
	target: "ally",
	cost: { energy: 5 },
	cast: 1,
	recharge: 2,
	effects: [{ op: "heal", amount: { scale: [20, 70] }, scope: "target" }]
	},
	{
	id: 283,
	name: "Dwayna's Kiss",
	profession: "Monk",
	attribute: "Healing Prayers",
	category: "spell",
	target: "other_ally",
	cost: { energy: 5 },
	cast: 1,
	recharge: 3,
	// Heal, +10…35 more for each enchantment and hex on the target ally.
	effects: [{ op: "heal", amount: { scale: [15, 60] }, scope: "target", plusPerMod: { kinds: ["enchant", "hex"], amount: { scale: [10, 35] } } }]
	},
	{
	id: 282,
	name: "Word of Healing",
	profession: "Monk",
	attribute: "Healing Prayers",
	category: "spell",
	target: "ally",
	cost: { energy: 5 },
	cast: 0.75,
	recharge: 3,
	elite: true,
	// Conditional bonus first so the "<50% Health" check reads the pre-heal HP
	// (the base heal below would otherwise lift the ally over the threshold).
	effects: [
	{ op: "heal", amount: { scale: [30, 115] }, scope: "target", if: { target_below_health: 0.5 } },
	{ op: "heal", amount: { scale: [5, 100] }, scope: "target" }
	]
	},
	// ── Monk · Smiter (holy offense) ──
	{
	id: 312,
	name: "Holy Strike",
	profession: "Monk",
	attribute: "Smiting Prayers",
	category: "spell",
	target: "foe",
	cost: { energy: 5 },
	cast: 0.75,
	recharge: 8,
	effects: [
	{ op: "damage", damageType: "holy", amount: { scale: [10, 55] }, scope: "target" },
	{ op: "damage", damageType: "holy", amount: { scale: [10, 55] }, scope: "target", if: { target: "knocked_down" } }
	]
	},
	{
	id: 240,
	name: "Smite",
	profession: "Monk",
	attribute: "Smiting Prayers",
	category: "spell",
	target: "foe",
	cost: { energy: 10 },
	cast: 1,
	recharge: 10,
	effects: [
	{ op: "damage", damageType: "holy", amount: { scale: [10, 55] }, scope: "target_and_adjacent" },
	{ op: "damage", damageType: "holy", amount: { scale: [10, 35] }, scope: "target_and_adjacent", if: { target: "attacking" } }
	]
	},
	{
	id: 252,
	name: "Banish",
	profession: "Monk",
	attribute: "Smiting Prayers",
	category: "spell",
	target: "foe",
	cost: { energy: 5 },
	cast: 1,
	recharge: 10,
	// Double vs summoned creatures — a no-op until summons exist, but recorded.
	effects: [{ op: "damage", damageType: "holy", amount: { scale: [20, 56] }, scope: "target", vsSummoned: 2 }]
	},
	// ── Assassin · Nightstalker (shadow-step burst) ──
	{
	id: 952,
	name: "Death's Charge",
	profession: "Assassin",
	attribute: "Shadow Arts",
	category: "skill",
	target: "foe",
	cost: { energy: 5 },
	cast: 0.25,
	recharge: 30,
	// Shadow-step to the foe; heal only if that foe has more Health than you.
	effects: [
	{ op: "shadow_step", to: "foe" },
	{ op: "heal", amount: { scale: [65, 200] }, scope: "self", if: { target_health_above_self: true } }
	]
	},
	{
	id: 1024,
	name: "Black Mantis Thrust",
	profession: "Assassin",
	attribute: "Deadly Arts",
	category: "lead_attack",
	target: "foe",
	cost: { energy: 5 },
	cast: 1,
	recharge: 6,
	requires: ["on_hit"],
	effects: [
	{ op: "bonus_damage", amount: { scale: [8, 20] } },
	{ op: "apply_condition", condition: "crippled", duration: { scale: [3, 15] }, if: { target: "hexed" } },
	{ op: "set_combo_mark", stage: "lead" }
	]
	},
	// ── Assassin · Saboteur (control / Deadly Arts) ──
	{
	id: 858,
	name: "Dancing Daggers",
	profession: "Assassin",
	attribute: "Deadly Arts",
	category: "spell",
	target: "foe",
	cost: { energy: 5 },
	cast: 1,
	recharge: 5,
	// Three earth projectiles, each 5…35; counts as a lead attack.
	effects: [
	{ op: "damage", damageType: "earth", amount: { scale: [5, 35] }, projectiles: 3, delivery: "projectile_spell", scope: "target" },
	{ op: "set_combo_mark", stage: "lead" }
	]
	},
	{
	id: 784,
	name: "Entangling Asp",
	profession: "Assassin",
	attribute: "Deadly Arts",
	category: "spell",
	target: "foe",
	cost: { energy: 10 },
	cast: 1,
	recharge: 20,
	requires: [{ combo_follows: "lead" }],
	effects: [
	{ op: "knockdown", duration: { fixed: 2 } },
	{ op: "apply_condition", condition: "poison", duration: { scale: [5, 20] } }
	]
	},
	{
	id: 988,
	name: "Temple Strike",
	profession: "Assassin",
	attribute: "Dagger Mastery",
	category: "offhand_attack",
	target: "foe",
	cost: { energy: 15 },
	cast: 0,
	recharge: 20,
	elite: true,
	requires: ["on_hit", { combo_follows: "lead" }],
	effects: [
	{ op: "interrupt", if: { target: "casting_spell" } },
	// interrupts a spell
	{ op: "apply_condition", condition: "dazed", duration: { scale: [1, 10] } },
	{ op: "apply_condition", condition: "blind", duration: { scale: [1, 10] } }
	]
	}
	];
	var CB_SKILLS = [...FIRST_15, ...VARIANT_EXTRA];

	// ../auto-battler/src/gw.js
	var iconUrl = (id) => `/gw/skills/${id}.jpg`;

	// ../auto-battler/src/lib/recolor.js
	var QUANT = 24;
	var SAT_MIN = 0.2;
	var L_MIN = 0.1;
	var L_MAX = 0.95;
	var SWATCH_N = 5;
	function rgbToHsl(r, g, b) {
	r /= 255;
	g /= 255;
	b /= 255;
	const max = Math.max(r, g, b), min = Math.min(r, g, b);
	const l = (max + min) / 2;
	let h = 0, s = 0;
	if (max !== min) {
	const d = max - min;
	s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
	if (max === r) h = (g - b) / d + (g < b ? 6 : 0);
	else if (max === g) h = (b - r) / d + 2;
	else h = (r - g) / d + 4;
	h *= 60;
	}
	return [h, s, l];
	}
	function hslToRgb(h, s, l) {
	h /= 360;
	if (s === 0) {
	const v = Math.round(l * 255);
	return [v, v, v];
	}
	const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
	const p = 2 * l - q;
	const hue = (t) => {
	if (t < 0) t += 1;
	if (t > 1) t -= 1;
	if (t < 1 / 6) return p + (q - p) * 6 * t;
	if (t < 1 / 2) return q;
	if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
	return p;
	};
	return [Math.round(hue(h + 1 / 3) * 255), Math.round(hue(h) * 255), Math.round(hue(h - 1 / 3) * 255)];
	}
	var hexToRgb = (hex) => {
	const n = parseInt(hex.replace("#", ""), 16);
	return [n >> 16 & 255, n >> 8 & 255, n & 255];
	};
	var rgbToHex = (r, g, b) => "#" + [r, g, b].map((v) => v.toString(16).padStart(2, "0")).join("");
	var isMaterial = (s, l) => s >= SAT_MIN && l >= L_MIN && l <= L_MAX;
	var _imgCache = /* @__PURE__ */ new Map();
	function loadImage(url) {
	if (_imgCache.has(url)) return _imgCache.get(url);
	const p = new Promise((res, rej) => {
	const img = new Image();
	img.crossOrigin = "anonymous";
	img.onload = () => res(img);
	img.onerror = rej;
	img.src = url;
	});
	_imgCache.set(url, p);
	return p;
	}
	function pixels(img) {
	const cv = document.createElement("canvas");
	cv.width = img.naturalWidth;
	cv.height = img.naturalHeight;
	const ctx = cv.getContext("2d", { willReadFrequently: true });
	ctx.drawImage(img, 0, 0);
	return { cv, ctx, data: ctx.getImageData(0, 0, cv.width, cv.height) };
	}
	var _analysis = /* @__PURE__ */ new Map();
	function analyze(idleUrl) {
	if (_analysis.has(idleUrl)) return _analysis.get(idleUrl);
	const p = (async () => {
	const { data } = pixels(await loadImage(idleUrl));
	const d = data.data;
	const counts = /* @__PURE__ */ new Map();
	for (let i = 0; i < d.length; i += 4) {
	if (d[i + 3] < 8) continue;
	const r = d[i] - d[i] % QUANT, g = d[i + 1] - d[i + 1] % QUANT, b = d[i + 2] - d[i + 2] % QUANT;
	const [h, s, l] = rgbToHsl(r, g, b);
	if (!isMaterial(s, l)) continue;
	const k = r << 16 \| g << 8 \| b;
	counts.set(k, (counts.get(k) \|\| 0) + 1);
	}
	if (!counts.size) return { anchor: null, swatches: [] };
	const entries = [...counts.entries()].map(([k, c]) => ({ k, c, hsl: rgbToHsl(k >> 16 & 255, k >> 8 & 255, k & 255) })).sort((a, b) => b.c - a.c);
	const anchor = entries[0].hsl;
	const swatches = entries.slice(0, SWATCH_N).sort((a, b) => a.hsl[0] - b.hsl[0] \|\| a.hsl[2] - b.hsl[2]).map(({ k }) => rgbToHex(k >> 16 & 255, k >> 8 & 255, k & 255));
	return { anchor, swatches };
	})();
	_analysis.set(idleUrl, p);
	return p;
	}
	function xform([h, s, l], anchor, tH, tS) {
	const nh = ((h + (tH - anchor[0])) % 360 + 360) % 360;
	const ns = Math.min(1, Math.max(0, s + (tS - anchor[1])));
	return hslToRgb(nh, ns, l);
	}
	var _canvasCache = /* @__PURE__ */ new Map();
	function recoloredCanvas(url, idleUrl, targetHex) {
	const key = `${url}#${idleUrl}#${targetHex}`;
	if (_canvasCache.has(key)) return _canvasCache.get(key);
	const p = (async () => {
	const [img, { anchor }] = await Promise.all([loadImage(url), analyze(idleUrl)]);
	const { cv, ctx, data } = pixels(img);
	if (anchor) {
	const [tH, tS] = rgbToHsl(...hexToRgb(targetHex));
	const d = data.data;
	for (let i = 0; i < d.length; i += 4) {
	if (d[i + 3] < 8) continue;
	const [h, s, l] = rgbToHsl(d[i], d[i + 1], d[i + 2]);
	if (!isMaterial(s, l)) continue;
	const [r, g, b] = xform([h, s, l], anchor, tH, tS);
	d[i] = r;
	d[i + 1] = g;
	d[i + 2] = b;
	}
	ctx.putImageData(data, 0, 0);
	}
	return cv;
	})();
	_canvasCache.set(key, p);
	return p;
	}
	async function recoloredTexture(Texture, url, idleUrl, targetHex) {
	const cv = targetHex ? await recoloredCanvas(url, idleUrl, targetHex) : await loadImage(url);
	const t = Texture.from(cv);
	t.source.scaleMode = "nearest";
	return t;
	}

	// ../auto-battler/src/render/spriteSheet.js
	var SHEET_ROWS = 4;
	var cellOf = (height) => Math.round(height / SHEET_ROWS);
	function sliceGridWith(pixi, texture, cell = cellOf(texture.source.height)) {
	const { Texture, Rectangle } = pixi;
	const src = texture.source;
	const rows = Math.max(1, Math.round(src.height / cell));
	const cols = Math.max(1, Math.round(src.width / cell));
	return Array.from({ length: rows }, (_, r) => Array.from({ length: cols }, (_2, c) => new Texture({ source: src, frame: new Rectangle(c * cell, r * cell, cell, cell) })));
	}
	var ANIM = { idle: 0.12, walk: 0.18, attack: 0.3, dmg: 0.25, die: 0.28 };
	var ROW_FOR = { "front-right": 0, "front-left": 1, "back-right": 2, "back-left": 3 };
	var rowFor = (grid, facing) => grid[ROW_FOR[facing]] ?? grid[0];
	var facingFor = (faceX, faceY) => (faceY < 0 ? "back" : "front") + "-" + (faceX < 0 ? "left" : "right");

	// ../auto-battler/src/render/combatRenderer.js
	var COND_ICON = {
	bleeding: "bleeding",
	poison: "poison",
	burning: "burning",
	deepWound: "deep-wound",
	disease: "disease",
	dazed: "dazed",
	crippled: "crippled",
	weakness: "weakness",
	blind: "blind",
	crackedArmor: "cracked-armor"
	};
	var COND_STATUS = {
	bleeding: "bleeding",
	poison: "poison",
	burning: "fire",
	disease: "sickness",
	deepWound: "petrification",
	dazed: "stun",
	crippled: "ice",
	weakness: "nature",
	blind: "fear",
	crackedArmor: "shock"
	};
	var COND_PRIORITY = ["deepWound", "burning", "poison", "bleeding", "disease", "dazed", "crippled", "blind", "crackedArmor", "weakness"];
	var OUT_OFF = [[-1, 0], [1, 0], [0, -1], [0, 1], [-1, -1], [1, -1], [-1, 1], [1, 1]];
	var MAT_RED = [0, 0, 0, 0, 0.86, 0, 0, 0, 0, 0.12, 0, 0, 0, 0, 0.12, 0, 0, 0, 1, 0];
	var MAT_YELLOW = [0, 0, 0, 0, 1, 0, 0, 0, 0, 0.84, 0, 0, 0, 0, 0.1, 0, 0, 0, 1, 0];
	var GOLD = 16767050;
	var BAR_TOP = 3;
	var GHOST_HOLD = 220;
	var GHOST_TAU = 150;
	var GHOST_FADE = 400;
	var ICON_SIZE = 18;
	var _footCache = /* @__PURE__ */ new Map();
	async function footFracOf(url) {
	if (!url) return 1;
	if (_footCache.has(url)) return _footCache.get(url);
	try {
	const img = await new Promise((ok, no) => {
	const i = new Image();
	i.onload = () => ok(i);
	i.onerror = no;
	i.src = url;
	});
	const cell = Math.round(img.naturalHeight / 4);
	const cv = document.createElement("canvas");
	cv.width = cell;
	cv.height = cell;
	const ctx = cv.getContext("2d", { willReadFrequently: true });
	ctx.drawImage(img, 0, 0, cell, cell, 0, 0, cell, cell);
	const d = ctx.getImageData(0, 0, cell, cell).data;
	let bottom = cell - 1;
	for (let y = cell - 1; y >= 0; y--) {
	let any = false;
	for (let x = 0; x < cell; x++) if (d[(y * cell + x) * 4 + 3] > 16) {
	any = true;
	break;
	}
	if (any) {
	bottom = y;
	break;
	}
	}
	const frac = Math.min(1, (bottom + 1.5) / cell);
	_footCache.set(url, frac);
	return frac;
	} catch {
	return 1;
	}
	}
	var facingOf = (a) => facingFor(a.faceX, a.faceY);
	async function createCombatRenderer({ pixi, defsById = {}, layers, coords, getBattle }) {
	const { Assets, Texture, Rectangle, AnimatedSprite, Sprite, Container, Graphics, Text, ColorMatrixFilter } = pixi;
	const sliceGrid = (texture, cell) => sliceGridWith({ Texture, Rectangle }, texture, cell);
	const rowFramesH = (texture, cell) => {
	const src = texture.source;
	const cols = Math.max(1, Math.round(src.width / cell));
	const h = Math.min(cell, src.height);
	return Array.from({ length: cols }, (_, c) => new Texture({ source: src, frame: new Rectangle(c * cell, 0, cell, h) }));
	};
	const { units, fx, projLayer } = layers;
	const { mapX, mapY, depthOf } = coords;
	const actorOf = (id) => getBattle()?.actors.find((x) => x.id === id);
	const floats = [];
	const sheetsById = {};
	async function loadSheets(id, def) {
	if (!def?.idle) {
	sheetsById[id] = null;
	return;
	}
	try {
	const load = (url) => url ? recoloredTexture(Texture, url, def.idle, def.recolor) : null;
	const [idle, walk, attack, dmg, die] = await Promise.all([
	load(def.idle),
	load(def.walk),
	load(def.attack),
	load(def.dmg),
	load(def.die)
	]);
	for (const tx of [idle, walk, attack, dmg, die]) if (tx) tx.source.scaleMode = "nearest";
	const cell = Math.round(idle.source.height / 4);
	sheetsById[id] = {
	idle: sliceGrid(idle, cell),
	walk: walk ? sliceGrid(walk, cell) : sliceGrid(idle, cell),
	attack: attack ? sliceGrid(attack, cell) : sliceGrid(idle, cell),
	dmg: dmg ? sliceGrid(dmg, cell) : null,
	die: die ? sliceGrid(die, cell) : null,
	cell,
	footFrac: await footFracOf(def.idle)
	};
	} catch {
	sheetsById[id] = null;
	}
	}
	for (const [id, def] of Object.entries(defsById)) await loadSheets(id, def);
	const skillIcons = {};
	for (const s of CB_SKILLS) {
	try {
	const t = await Assets.load(iconUrl(s.id));
	t.source.scaleMode = "linear";
	skillIcons[s.id] = t;
	} catch {
	}
	}
	const condIcons = {};
	for (const [type, file] of Object.entries(COND_ICON)) {
	try {
	const t = await Assets.load(`/gw/icons/condition-${file}.jpg`);
	t.source.scaleMode = "linear";
	condIcons[type] = t;
	} catch {
	}
	}
	const condFrames = {};
	try {
	const catalogue = await fetch("/assets/effects.json").then((r) => r.json()).then((d) => d.effects \|\| []);
	const byKey = Object.fromEntries(catalogue.filter((e) => e.category === "status").map((e) => [e.key, e]));
	for (const [type, statusKey] of Object.entries(COND_STATUS)) {
	const e = byKey[statusKey];
	if (!e) continue;
	try {
	const t = await Assets.load(e.url);
	t.source.scaleMode = "nearest";
	condFrames[type] = rowFramesH(t, e.cell \|\| t.source.height);
	} catch {
	}
	}
	} catch {
	}
	const skillPlay = {};
	async function buildSkillPlay(id, def) {
	const cell = sheetsById[id]?.cell;
	const map = {};
	for (const [skillId, fxCfg] of Object.entries(def.skillFx \|\| {})) {
	let animGrid = null;
	if (fxCfg.animUrl && cell) {
	try {
	const t = await recoloredTexture(Texture, fxCfg.animUrl, def.idle, def.recolor);
	animGrid = sliceGrid(t, cell);
	} catch {
	}
	}
	const effects = [];
	for (const ef of fxCfg.effects \|\| []) {
	try {
	const t = await Assets.load(ef.url);
	t.source.scaleMode = "nearest";
	effects.push(sliceGrid(t, ef.cell \|\| 32)[0]);
	} catch {
	}
	}
	map[skillId] = { animGrid, effects };
	}
	skillPlay[id] = map;
	}
	for (const [id, def] of Object.entries(defsById)) await buildSkillPlay(id, def);
	const view = {};
	function buildView(id, def) {
	const sh = sheetsById[id];
	const c = new Container();
	let sp;
	if (sh) {
	sp = new AnimatedSprite(rowFor(sh.idle, "front-right"));
	sp.anchor.set(0.5, sh.footFrac ?? 1);
	sp.animationSpeed = ANIM.idle;
	sp.play();
	} else {
	sp = new Container();
	const g = new Graphics();
	g.circle(0, -16, 16).fill(def?.color \|\| 8947848);
	const t = new Text({ text: (def?.name \|\| "?")[0], style: { fill: 16777215, fontSize: 15, fontWeight: "700" } });
	t.anchor.set(0.5);
	t.y = -16;
	sp.addChild(g, t);
	}
	const bars = new Graphics();
	const status = new Container();
	const overlay = new AnimatedSprite([Texture.EMPTY]);
	overlay.anchor.set(0.5, sh?.footFrac ?? 1);
	overlay.visible = false;
	overlay.loop = true;
	overlay.animationSpeed = 0.15;
	const makeOutline = (matrix) => {
	if (!sh) return null;
	const o = { container: new Container(), copies: [] };
	const filter = new ColorMatrixFilter();
	filter.matrix = matrix;
	o.container.filters = [filter];
	o.container.visible = false;
	o.container.alpha = 0.75;
	for (let i = 0; i < OUT_OFF.length; i++) {
	const s = new Sprite(Texture.EMPTY);
	s.anchor.set(0.5, sh.footFrac ?? 1);
	o.container.addChild(s);
	o.copies.push(s);
	}
	return o;
	};
	const castOutline = makeOutline(MAT_YELLOW);
	const outline = makeOutline(MAT_RED);
	if (castOutline) c.addChild(castOutline.container);
	if (outline) c.addChild(outline.container);
	c.addChild(sp, overlay, bars, status);
	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;
	v.facing = facing;
	v.sprite.textures = rowFor(v.sheets[mode], facing);
	v.sprite.loop = true;
	v.sprite.animationSpeed = ANIM[mode];
	v.sprite.play();
	}
	function playOnce(v, mode, facing, onDone, speedMul = 1) {
	v.mode = mode;
	v.facing = facing;
	v.sprite.onComplete = null;
	v.sprite.textures = rowFor(v.sheets[mode], facing);
	v.sprite.loop = false;
	v.sprite.animationSpeed = ANIM[mode] * speedMul;
	v.sprite.onComplete = () => {
	v.sprite.onComplete = null;
	onDone && onDone();
	};
	v.sprite.gotoAndPlay(0);
	}
	const resume = (v) => {
	v.mode = null;
	};
	function playAttack(id, a, onDone = null, speedMul = 1) {
	const v = view[id];
	if (!v?.sheets \|\| v.dead) return;
	playOnce(v, "attack", facingOf(a), () => {
	resume(v);
	onDone && onDone();
	}, speedMul);
	}
	function playHurt(id, a) {
	const v = view[id];
	if (!v?.sheets?.dmg \|\| v.dead \|\| v.skillAnim \|\| v.mode !== "idle") return;
	playOnce(v, "dmg", facingOf(a), () => resume(v));
	}
	function playDie(id, a) {
	const v = view[id];
	if (!v \|\| v.dead) return;
	v.dead = true;
	v.mode = "die";
	const facing = facingOf(a);
	v.facing = facing;
	if (!v.sheets) return;
	const crumple = () => {
	if (!v.sheets.die) return;
	const frames = rowFor(v.sheets.die, facing);
	v.sprite.onComplete = null;
	v.sprite.textures = frames;
	v.sprite.loop = false;
	v.sprite.animationSpeed = ANIM.die * 0.75;
	v.sprite.onComplete = () => {
	v.sprite.onComplete = null;
	v.sprite.gotoAndStop(frames.length - 1);
	};
	v.sprite.gotoAndPlay(0);
	};
	if (v.sheets.dmg) {
	const hit = rowFor(v.sheets.dmg, facing);
	v.sprite.onComplete = null;
	v.sprite.textures = hit;
	v.sprite.loop = false;
	v.sprite.animationSpeed = ANIM.dmg;
	v.sprite.onComplete = () => {
	v.sprite.onComplete = null;
	crumple();
	};
	v.sprite.gotoAndPlay(0);
	} else crumple();
	}
	function playGridOnce(v, grid, { speedMul = 1, hold = false, onDone = null } = {}) {
	if (!grid \|\| !v \|\| v.dead) return false;
	v.mode = "attack";
	v.skillAnim = true;
	v.sprite.onComplete = null;
	v.sprite.textures = grid[0];
	v.sprite.loop = false;
	v.sprite.animationSpeed = ANIM.attack * speedMul;
	v.sprite.onComplete = () => {
	v.sprite.onComplete = null;
	if (hold) v.sprite.gotoAndStop(grid[0].length - 1);
	else {
	v.skillAnim = false;
	resume(v);
	}
	onDone && onDone();
	};
	v.sprite.gotoAndPlay(0);
	return true;
	}
	function spawnEffects(casterId, framesList) {
	const a = actorOf(casterId);
	const v = view[casterId];
	if (!a \|\| !v \|\| !framesList?.length) return;
	const cell = v.sheets?.cell ?? 24, ff = v.sheets?.footFrac ?? 1, depth = depthOf(a);
	const cx = mapX(a.x), cy = mapY(a.y) - (ff - 0.5) * cell * depth;
	for (const frames of framesList) {
	if (!frames?.length) continue;
	const s = new AnimatedSprite(frames);
	s.anchor.set(0.5);
	s.loop = false;
	s.animationSpeed = 0.3;
	s.scale.set(depth);
	s.position.set(cx, cy);
	s.onComplete = () => fx.removeChild(s);
	fx.addChild(s);
	s.gotoAndPlay(0);
	}
	}
	const headY = (id, a) => {
	const v = view[id], cell = v?.sheets?.cell ?? 24, ff = v?.sheets?.footFrac ?? 1;
	return mapY(a.y) - ff * cell * depthOf(a) - 2;
	};
	function floatText(id, text, color, opts = {}) {
	const a = actorOf(id);
	if (!a) return;
	const t = new Text({ text, style: { fill: color, fontSize: opts.big ? 20 : 14, fontFamily: "monospace", fontWeight: "700", stroke: opts.big ? { color: 2760448, width: 3 } : void 0 } });
	t.anchor.set(0.5);
	t.x = mapX(a.x) + (Math.random() * 20 - 10);
	t.y = headY(id, a) - (opts.big ? 6 : 0);
	fx.addChild(t);
	floats.push({ t, life: opts.big ? 1.25 : 1, max: opts.big ? 1.25 : 1 });
	}
	function floatIcon(id, skillId) {
	const a = actorOf(id);
	const tex = skillId && skillIcons[skillId];
	if (!a \|\| !tex) return false;
	const s = new Sprite(tex);
	s.anchor.set(0.5);
	s.width = ICON_SIZE;
	s.height = ICON_SIZE;
	s.x = mapX(a.x);
	s.y = headY(id, a) - 8;
	fx.addChild(s);
	floats.push({ t: s, life: 1.2, max: 1.2, icon: true, size: ICON_SIZE, who: id });
	return true;
	}
	function flagEmpower(id) {
	for (const f of floats) if (f.icon && f.who === id) {
	f.t.tint = GOLD;
	f.empower = true;
	f.size = ICON_SIZE + 6;
	}
	floatText(id, "\u26A1", GOLD);
	}
	function spawnEcho(id) {
	const a = actorOf(id), v = view[id];
	if (!a \|\| !v?.sheets) return;
	const depth = depthOf(a);
	for (const cfg of [{ life: 0.55, scaleTo: 2.2, a0: 0.85 }, { life: 0.8, scaleTo: 3.1, a0: 0.55 }]) {
	const s = new Sprite(v.sprite.texture);
	s.anchor.set(0.5, v.sheets.footFrac ?? 1);
	s.tint = 10473727;
	s.x = mapX(a.x);
	s.y = mapY(a.y);
	fx.addChild(s);
	floats.push({ t: s, life: cfg.life, max: cfg.life, echo: true, baseScale: depth, scaleTo: cfg.scaleTo, alpha0: cfg.a0, dir: a.facing \|\| 1 });
	}
	}
	function drawBars(id, a, dt, now) {
	const v = view[id];
	const g = v.bars;
	g.clear();
	const w = 40;
	const cur = Math.max(0, a.hp / a.baseMaxHp);
	if (v.hpGhost == null \|\| cur >= v.hpGhost) {
	v.hpGhost = cur;
	v.hpLast = cur;
	v.hpGhostT = GHOST_HOLD;
	}
	if (cur < (v.hpLast ?? cur) - 8e-3) v.hpGhostT = 0;
	v.hpLast = cur;
	v.hpGhostT = (v.hpGhostT ?? GHOST_HOLD) + dt;
	if (v.hpGhost > cur && v.hpGhostT > GHOST_HOLD) {
	v.hpGhost = cur + (v.hpGhost - cur) * Math.max(0, 1 - dt / GHOST_TAU);
	if (v.hpGhost - cur < 4e-3) v.hpGhost = cur;
	}
	g.rect(-w / 2, BAR_TOP, w, 5).fill(1316897);
	if (v.hpGhost > cur + 1e-4) {
	const fade = v.hpGhostT <= GHOST_HOLD ? 1 : Math.max(0, 1 - (v.hpGhostT - GHOST_HOLD) / GHOST_FADE);
	g.rect(-w / 2 + 1 + (w - 2) * cur, BAR_TOP + 1, (w - 2) * (v.hpGhost - cur), 3).fill({ color: 16777215, alpha: 0.85 * fade });
	}
	g.rect(-w / 2 + 1, BAR_TOP + 1, (w - 2) * cur, 3).fill(cur > 0.4 ? 12113482 : 14165786);
	const res = a.profession === "Warrior" ? a.adrenaline / 25 : a.energy / a.maxEnergy;
	g.rect(-w / 2, BAR_TOP + 6, w, 3).fill(1316897);
	g.rect(-w / 2 + 1, BAR_TOP + 7, (w - 2) * Math.max(0, Math.min(1, res)), 1.5).fill(a.profession === "Warrior" ? 15247146 : 3832997);
	const mark = Object.values(a.marks \|\| {}).find((m) => m && m.until > now);
	if (mark) for (let i = 0; i < (mark.stage === "offhand" ? 2 : 1); i++) g.circle(w / 2 - 2 - i * 3, BAR_TOP - 2, 1.3).fill(16767050);
	const headRel = -((v.sheets?.footFrac ?? 1) * (v.sheets?.cell ?? 24) * depthOf(a)) - 4;
	if (a.kd > now) {
	const cy = headRel + 2;
	for (let i = 0; i < 3; i++) {
	const ang = now * 6 + i * 2 * Math.PI / 3;
	g.circle(Math.cos(ang) * 6, cy + Math.sin(ang) * 2.2, 1.5).fill(16110658);
	}
	}
	if (a.casting && a.casting.skill) {
	const total = a.casting.skill.cast \|\| 1;
	const prog = Math.max(0, Math.min(1, 1 - (a.casting.left ?? 0) / total));
	g.rect(-11, headRel, 22, 3).fill(1316897);
	g.rect(-10, headRel + 0.75, 20 * prog, 1.5).fill(7325664);
	}
	}
	function drawStatus(id, a, t, depth) {
	const v = view[id];
	const active = a.conds.filter((c) => c.until > t && condIcons[c.type]);
	const sz = 11, gap = 2, totalW = active.length * sz + Math.max(0, active.length - 1) * gap;
	active.forEach((c, i) => {
	let s = v.statusSprites[c.type];
	if (!s) {
	s = new Sprite(condIcons[c.type]);
	s.anchor.set(0.5);
	s.width = sz;
	s.height = sz;
	v.status.addChild(s);
	v.statusSprites[c.type] = s;
	}
	s.x = -totalW / 2 + sz / 2 + i * (sz + gap);
	s.y = BAR_TOP + 15;
	const left = c.until - t;
	s.visible = left >= 1.2 \|\| Math.floor(t * 6) % 2 === 0;
	});
	for (const type in v.statusSprites) if (!active.find((c) => c.type === type)) v.statusSprites[type].visible = false;
	let key = null;
	if (!v.dead) {
	for (const type of COND_PRIORITY) if (condFrames[type] && active.some((c) => c.type === type)) {
	key = type;
	break;
	}
	}
	if (key !== v.overlayKey) {
	v.overlayKey = key;
	if (key) {
	v.overlay.textures = condFrames[key];
	v.overlay.visible = true;
	v.overlay.gotoAndPlay(0);
	} else {
	v.overlay.visible = false;
	}
	}
	if (key) v.overlay.scale.set(depth);
	}
	function resetForNewBattle() {
	for (const id in view) {
	const v = view[id];
	v.dead = false;
	v.mode = null;
	v.facing = null;
	v.flash = 0;
	v.skillAnim = false;
	for (const k in v.statusSprites) v.statusSprites[k].visible = false;
	v.overlay.visible = false;
	v.overlayKey = null;
	if (v.sheets) {
	v.sprite.onComplete = null;
	v.sprite.tint = 16777215;
	v.sprite.alpha = 1;
	}
	}
	}
	function syncActors(b, dtMS, now, { cine = null, cineDim = 0, cineCfg = {} } = {}) {
	for (const a of b.actors) {
	const v = view[a.id];
	if (!v) continue;
	v.container.x = mapX(a.x);
	v.container.y = mapY(a.y);
	if (cine?.hit && a.id === cine.targetId && !v.dead) {
	v.container.x += (Math.random() * 2 - 1) * 2.5;
	v.container.y += (Math.random() * 2 - 1) * 2.5;
	}
	v.container.zIndex = a.y;
	const depth = depthOf(a);
	const dimmed = cine && cine.freeze && cineCfg.dim !== false && a.id !== cine.casterId && a.id !== cine.targetId;
	const dimTint = () => {
	const g = Math.round(255 * (1 - cineDim * 0.5));
	return g << 16 \| g << 8 \| g;
	};
	if (v.sheets) {
	v.sprite.scale.set(depth);
	if (v.dead) {
	v.sprite.tint = dimmed ? dimTint() : 16777215;
	v.sprite.alpha = 0.9;
	} else {
	if (v.mode !== "attack" && v.mode !== "dmg") {
	setLoop(v, a.moving ? "walk" : "idle", facingOf(a));
	}
	v.flash = Math.max(0, v.flash - dtMS);
	v.sprite.tint = dimmed ? dimTint() : v.flash > 0 && !v.skillAnim ? 16738922 : 16777215;
	v.sprite.alpha = 1;
	}
	} else {
	v.sprite.scale.set(1);
	v.sprite.alpha = a.alive ? 1 : 0.32;
	}
	drawBars(a.id, a, dtMS, b.t);
	drawStatus(a.id, a, b.t, depth);
	}
	}
	function updateFloats(dtMS) {
	for (let i = floats.length - 1; i >= 0; i--) {
	const f = floats[i];
	f.life -= dtMS / 1e3;
	const age = f.max - f.life;
	if (f.echo) {
	const p = Math.min(1, age / f.max);
	const sc = f.baseScale * (1 + (f.scaleTo - 1) * p);
	f.t.scale.set(sc * (f.dir < 0 ? -1 : 1), sc);
	f.t.alpha = f.alpha0 * (1 - p);
	} else {
	f.t.y -= dtMS * 0.022;
	const fin = Math.min(1, age / 0.18), fout = Math.min(1, f.life / 0.35);
	f.t.alpha = Math.max(0, Math.min(fin, fout));
	if (f.icon) {
	const sz = f.size * (0.6 + 0.4 * fin);
	f.t.width = sz;
	f.t.height = sz;
	}
	}
	if (f.life <= 0) {
	fx.removeChild(f.t);
	floats.splice(i, 1);
	}
	}
	}
	function drawProjectiles(b) {
	projLayer.clear();
	for (const p of b.projectiles) {
	const frac = Math.max(0, Math.min(1, (b.t - p.bornT) / (p.hitT - p.bornT)));
	const px = mapX(p.fromX + (p.aimX - p.fromX) * frac);
	const py = mapY(p.fromY + (p.aimY - p.fromY) * frac) - 26;
	projLayer.circle(px, py, 4).fill(15786176).stroke({ width: 1, color: 2764602 });
	}
	}
	function processLog(b, r, hooks = {}) {
	const log2 = b.log;
	for (; r.logIdx < log2.length; r.logIdx++) {
	const e = log2[r.logIdx];
	if (e.kind === "cast") {
	const h = hooks.onCast?.(e) \|\| {};
	if (h.break) {
	r.logIdx++;
	return;
	}
	const v = view[e.who], a = actorOf(e.who), play = skillPlay[e.who]?.[e.skillId];
	if (!h.skipInline) {
	if (v && a) {
	if (!playGridOnce(v, play?.animGrid)) playAttack(e.who, a);
	spawnEffects(e.who, play?.effects);
	}
	if (!floatIcon(e.who, e.skillId)) floatText(e.who, e.name + (e.elite ? " \u2605" : ""), 15787730);
	if (e.combo === "dual") floatText(e.who, "\u2726", GOLD);
	}
	} else if (e.kind === "swing") {
	if (!e.skillId) playAttack(e.who, actorOf(e.who));
	} else if (e.kind === "shoot") {
	if (!e.skillId) playAttack(e.who, actorOf(e.who));
	} else if (e.kind === "hit" && e.amount > 0) {
	const v = view[e.who];
	if (v) v.flash = 130;
	playHurt(e.who, actorOf(e.who));
	e.empowered ? floatText(e.who, "-" + e.amount + "!", GOLD, { big: true }) : floatText(e.who, "-" + e.amount, 16743018);
	} else if (e.kind === "heal" && e.amount > 0) e.empowered ? floatText(e.who, "+" + e.amount + "!", GOLD, { big: true }) : floatText(e.who, "+" + e.amount, 9429896);
	else if (e.kind === "cond" && e.empowered) floatText(e.who, (e.cond === "interrupted" ? "INTERRUPT" : String(e.cond).toUpperCase()) + "!", GOLD, { big: true });
	else if (e.kind === "empower") flagEmpower(e.who);
	else if (e.kind === "miss") floatText(e.who, "dodge", 10405352);
	else if (e.kind === "death") playDie(e.who, actorOf(e.who));
	}
	}
	return {
	view,
	floats,
	actorOf,
	skillPlay,
	addActor,
	removeActor: removeActor2,
	setLoop,
	playOnce,
	resume,
	playAttack,
	playHurt,
	playDie,
	playGridOnce,
	spawnEffects,
	floatText,
	floatIcon,
	flagEmpower,
	spawnEcho,
	drawBars,
	drawStatus,
	resetForNewBattle,
	syncActors,
	updateFloats,
	drawProjectiles,
	processLog
	};
	}

	// ../auto-battler/src/engine/range.js
	var MELEE_GW = 144;
	var BASIC_MELEE_GW = MELEE_GW / 2;
	var BOW_GW = 1e3;

	// ../auto-battler/src/engine/teamBattle.js
	var byId = Object.fromEntries(CB_SKILLS.map((s) => [s.id, s]));
	var skillById = (id) => byId[id] \|\| null;
	var FIELD = { w: 1e3, h: 600 };
	var FORMATION = [
	{ x: 0.31, y: 0.66 },
	{ x: 0.47, y: 0.74 },
	{ x: 0.13, y: 0.73 },
	{ x: 0.28, y: 0.82 },
	{ x: 0.44, y: 0.91 }
	];
	var HIT_TOLERANCE = 130;
	function val(v, rank = 12) {
	if (typeof v === "number") return v;
	if (v == null) return 0;
	if (v.fixed != null) return v.fixed;
	if (v.scale) {
	const [a, b] = v.scale;
	return Math.round(a + (b - a) * rank / 15);
	}
	return 0;
	}
	var DEGEN = { bleeding: 4, poison: 4, burning: 8, disease: 4 };
	var ATTACK_CATEGORIES = ["melee_attack", "bow_attack", "lead_attack", "offhand_attack", "dual_attack", "scythe_attack", "spear_attack"];
	var isAttack = (s) => ATTACK_CATEGORIES.includes(s.category);
	var CLASS_TEMPLATES = {
	Warrior: { maxHp: 520, role: "melee", weapon: { min: 15, max: 22, interval: 1.5, range: BASIC_MELEE_GW }, moveSpeed: 130, maxEnergy: 25, energyRegen: 0.5, armor: 80 },
	Assassin: { maxHp: 480, role: "melee", weapon: { min: 7, max: 17, interval: 1.33, range: BASIC_MELEE_GW }, moveSpeed: 175, maxEnergy: 30, energyRegen: 1.2, armor: 55 },
	Ranger: { maxHp: 430, role: "ranged", weapon: { min: 12, max: 28, interval: 1.9, range: BOW_GW, projSpeed: 850 }, moveSpeed: 155, preferredRange: 620, maxEnergy: 35, energyRegen: 1, armor: 45 },
	Monk: { maxHp: 470, role: "melee", weapon: { min: 8, max: 14, interval: 1.6, range: BASIC_MELEE_GW }, moveSpeed: 140, maxEnergy: 40, energyRegen: 1.4, armor: 60 },
	Necromancer: { maxHp: 450, role: "ranged", weapon: { min: 10, max: 20, interval: 1.8, range: BOW_GW, projSpeed: 720 }, moveSpeed: 140, preferredRange: 520, maxEnergy: 35, energyRegen: 1, armor: 45 }
	};
	var DEFAULT_TEMPLATE = { maxHp: 300, role: "melee", weapon: { min: 10, max: 16, interval: 1.5, range: BASIC_MELEE_GW }, moveSpeed: 150, maxEnergy: 30, energyRegen: 1, armor: 50 };
	function templateFor(unit) {
	if (unit.template) return unit.template;
	if (unit.profession && CLASS_TEMPLATES[unit.profession]) return CLASS_TEMPLATES[unit.profession];
	if (unit.stats) {
	const s = unit.stats;
	const basic = s.basicDamage ?? 12;
	const ranged = unit.attackType === "ranged";
	return {
	maxHp: s.hp ?? 100,
	role: ranged ? "ranged" : "melee",
	armor: s.armor ?? 40,
	moveSpeed: 150,
	maxEnergy: 30,
	energyRegen: 1,
	preferredRange: ranged ? 600 : void 0,
	weapon: {
	min: Math.max(1, Math.round(basic * 0.8)),
	max: Math.round(basic * 1.3),
	interval: 1.4,
	range: ranged ? BOW_GW : BASIC_MELEE_GW,
	...ranged ? { projSpeed: 800 } : {}
	}
	};
	}
	return DEFAULT_TEMPLATE;
	}
	function makeActor(unit, team, id, slot) {
	const tpl = templateFor(unit);
	const p = FORMATION[slot % FORMATION.length];
	const pt = team === "player" ? { x: p.x, y: p.y } : { x: 1 - p.x, y: 1 - p.y };
	const bar = (unit.skills \|\| []).map(skillById).filter(Boolean);
	return {
	id,
	team,
	name: unit.name \|\| id,
	profession: unit.profession \|\| null,
	// control: 'ai' (autonomous), 'player' (driven by b.input via setInput) or
	// 'dummy' (passive target — takes damage, never acts). Sandboxes use the
	// latter two so the Classes/Enemies hero fights real engine dummies.
	control: unit.control \|\| "ai",
	role: tpl.role,
	rank: unit.rank ?? 12,
	armor: tpl.armor ?? 0,
	weapon: { ...tpl.weapon },
	moveSpeed: tpl.moveSpeed,
	preferredRange: tpl.preferredRange,
	radius: radiusOf(unit, tpl),
	maxEnergy: tpl.maxEnergy,
	energyRegen: tpl.energyRegen,
	baseMaxHp: tpl.maxHp,
	maxHp: tpl.maxHp,
	hp: tpl.maxHp,
	energy: tpl.maxEnergy,
	adrenaline: 0,
	bar,
	x: pt.x * FIELD.w,
	y: pt.y * FIELD.h,
	facing: team === "player" ? 1 : -1,
	faceX: team === "player" ? 1 : -1,
	faceY: team === "player" ? -1 : 1,
	// players look up-right, enemies down-left
	attackTimer: tpl.weapon.interval,
	casting: null,
	recharge: {},
	conds: [],
	marks: {},
	prep: null,
	alive: true,
	mods: [],
	kd: 0,
	aggroRadius: unit.aggroRadius ?? null
	// 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, 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, 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 = {};
	b.input[id] = { ...b.input[id] \|\| {}, ...cmd };
	}
	var ADJACENT_GW = 140;
	var BODY_RADIUS = { melee: 35, ranged: 32 };
	var DEFAULT_RADIUS = 32;
	var DEOVERLAP_ITERS = 3;
	var DEOVERLAP_FRACTION = 0.5;
	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) => 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 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) => {
	a.adrenaline = Math.min(25, a.adrenaline + n);
	};
	var livingFoes = (b, a) => b.actors.filter((x) => x.alive && x.team !== a.team);
	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 = dist2(a, x);
	if (d < bd) {
	bd = d;
	best = x;
	}
	}
	return best;
	}
	function mostWoundedAlly(b, a, includeSelf = true) {
	let best = null, bf = Infinity;
	for (const x of alliesOf(b, a)) {
	if (!includeSelf && x === a) continue;
	const f = x.hp / x.maxHp;
	if (f < bf) {
	bf = f;
	best = x;
	}
	}
	return best;
	}
	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);
	var sumRegenPips = (b, a) => activeMods(b, a, "regen").reduce((n, m) => n + m.pips, 0);
	var bonusArmor = (b, a) => activeMods(b, a, "armor").reduce((n, m) => n + m.amount, 0);
	var attackSpeedMult = (b, a) => activeMods(b, a, "attackSpeed").reduce((n, m) => n * m.mult, 1);
	var moveSpeedMult = (b, a) => (hasCond(a, "crippled") ? 0.5 : 1) * activeMods(b, a, "moveSpeed").reduce((n, m) => n * m.mult, 1);
	var hasHex = (b, a) => hasModKind(b, a, "hex");
	var countCat = (b, a, kinds) => a.mods.filter((m) => m.until > b.t && kinds.includes(m.cat)).length;
	var mitigate = (dmg, armor) => dmg * (100 / (100 + (armor \|\| 0)));
	function log(b, kind, who, extra = {}) {
	b.log.push({ t: Math.round(b.t * 100) / 100, kind, who: who?.id, ...extra });
	}
	function applyCondition(b, tgt, type, dur, empowered) {
	if (!tgt.alive) return;
	const ex = tgt.conds.find((c) => c.type === type);
	if (ex) {
	ex.until = Math.max(ex.until, b.t + dur);
	return;
	}
	tgt.conds.push({ type, until: b.t + dur });
	if (type === "deepWound") {
	tgt.maxHp = Math.round(tgt.baseMaxHp * 0.8);
	if (tgt.hp > tgt.maxHp) tgt.hp = tgt.maxHp;
	}
	log(b, "cond", tgt, { cond: type, amount: Math.round(dur), ...empowered ? { empowered: true } : {} });
	}
	function expireConds(b, a) {
	for (const c of a.conds) if (c.until <= b.t && c.type === "deepWound") a.maxHp = a.baseMaxHp;
	a.conds = a.conds.filter((c) => c.until > b.t);
	for (const m of a.mods) if (m.kind === "onEnd" && m.until <= b.t && !m.fired) {
	m.fired = true;
	const src = b.actors.find((x) => x.id === m.srcId) \|\| a;
	for (const e of m.payload \|\| []) applyEffect(b, src, a, e, "spell");
	}
	a.mods = a.mods.filter((m) => m.until > b.t);
	}
	function healActor(b, a, amount, empowered) {
	if (!a.alive \|\| amount <= 0) return;
	a.hp = Math.min(a.maxHp, a.hp + Math.round(amount));
	log(b, "heal", a, { amount: Math.round(amount), ...empowered ? { empowered: true } : {} });
	}
	function dealDamage(b, src, tgt, amount, label, opts = {}) {
	if (!tgt.alive) return 0;
	const { damageType = "physical", delivery = "spell", armorIgnoring = false, empowered = false } = opts;
	const physical = delivery === "melee" \|\| delivery === "projectile";
	if (physical) {
	const blk = blockRoll(b, tgt, delivery);
	if (blk) {
	if (blk.reflect && delivery === "melee") dealDamage(b, tgt, src, blk.reflect, "reflect", { delivery: "spell", armorIgnoring: true });
	log(b, "miss", tgt, { name: label });
	return 0;
	}
	}
	let dmg = amount;
	if (physical) {
	for (const m of activeMods(b, tgt, "amplify")) if (m.vs === "physical") dmg += m.amount;
	}
	if (!(armorIgnoring \|\| ARMOR_IGNORING.has(damageType))) dmg = mitigate(dmg, tgt.armor + bonusArmor(b, tgt));
	const cap = activeMods(b, tgt, "cap")[0];
	if (cap) dmg = Math.min(dmg, cap.fraction * tgt.maxHp);
	const conv = activeMods(b, tgt, "convert").find((m) => m.charges > 0);
	if (conv) {
	healActor(b, tgt, Math.min(dmg, conv.cap));
	conv.charges--;
	dmg = 0;
	}
	for (const m of activeMods(b, tgt, "onIncomingHeal")) {
	if (m.charges > 0 && dmg > m.threshold) {
	healActor(b, tgt, m.amount);
	m.charges--;
	}
	}
	dmg = Math.max(0, Math.round(dmg));
	tgt.hp -= dmg;
	log(b, "hit", tgt, { src: src.id, amount: dmg, name: label, ...empowered ? { empowered: true } : {} });
	gainAdr(tgt, 1);
	if (physical) {
	for (const m of activeMods(b, tgt, "armor")) if (m.attacksLeft != null && --m.attacksLeft <= 0) m.until = b.t;
	fireTrigger(b, tgt, "onPhysicalHit");
	}
	if (tgt.hp <= 0) kill(b, tgt);
	return dmg;
	}
	function blockRoll(b, tgt, delivery) {
	for (const m of activeMods(b, tgt, "block")) {
	if (m.vs === "all" \|\| m.vs === delivery) {
	if (b.rng() < m.chance) return m;
	}
	}
	return null;
	}
	function kill(b, a) {
	if (!a.alive) return;
	a.alive = false;
	a.hp = 0;
	a.deadAt = b.t;
	log(b, "death", a);
	if (hasCond(a, "disease")) for (const x of adjacentTo(b, a)) applyCondition(b, x, "disease", 10);
	}
	function applyContainer(b, src, tgt, e) {
	const dur = val(e.duration, src.rank);
	const cat = e.op;
	const p = e.payload?.[0] \|\| {};
	if (e.op === "hex") addMod(b, tgt, { kind: "hex", cat, dur });
	for (const m of tgt.mods) if (m.endsOnHexEnchant && m.until > b.t) m.until = b.t;
	if (p.op === "amplify_damage") {
	addMod(b, tgt, { kind: "amplify", cat, vs: p.vs \|\| "physical", amount: val(p.amount, src.rank), dur });
	return;
	}
	if (p.op === "cap_damage") {
	addMod(b, tgt, { kind: "cap", cat, fraction: p.maxFraction, dur });
	return;
	}
	if (p.op === "convert_damage_to_heal") {
	addMod(b, tgt, { kind: "convert", cat, cap: val(p.cap, src.rank), charges: e.charges ?? 1, dur });
	return;
	}
	if (e.trigger === "on_end") {
	addMod(b, tgt, { kind: "onEnd", cat, payload: e.payload, srcId: src.id, srcRank: src.rank, dur });
	return;
	}
	if (e.trigger === "on_incoming_damage" && p.op === "heal") {
	addMod(b, tgt, { kind: "onIncomingHeal", cat, amount: val(p.amount, src.rank), threshold: e.threshold?.perHitDamageOver ?? 0, charges: e.charges ?? 1, dur });
	return;
	}
	if (e.trigger === "on_action") {
	addMod(b, tgt, { kind: "onAction", cat, payload: e.payload, srcId: src.id, srcRank: src.rank, dur });
	return;
	}
	if (e.trigger === "on_physical_hit") {
	addMod(b, tgt, { kind: "onPhysicalHit", cat, payload: e.payload, srcId: src.id, srcRank: src.rank, dur });
	return;
	}
	addMod(b, tgt, { kind: "enchant", cat, dur });
	}
	function fireTrigger(b, a, kind) {
	for (const m of activeMods(b, a, kind)) {
	const fakeSrc = b.actors.find((x) => x.id === m.srcId) \|\| { id: m.srcId, rank: m.srcRank };
	for (const e of m.payload \|\| []) applyEffect(b, fakeSrc, a, e, "spell");
	}
	}
	function resolveScope(b, src, tgt, scope) {
	switch (scope) {
	case "self":
	return [src];
	case "party":
	return alliesOf(b, src);
	case "target_and_adjacent":
	return [tgt, ...adjacentTo(b, tgt)];
	case "adjacent_to_target":
	return adjacentTo(b, tgt);
	case "nearby":
	case "area":
	return [tgt, ...adjacentTo(b, tgt)];
	default:
	return [tgt];
	}
	}
	function applyEffect(b, src, tgt, e, delivery = "spell", s = null) {
	if (e.if && !branchOk(b, e.if, src, tgt)) return;
	if (e.if && s) logEmpower(b, src, tgt, s, empowerLabel(e, src.rank), reasonOf(e.if));
	const emp = !!e.if;
	const targets = resolveScope(b, src, tgt, e.scope);
	for (const t of targets) {
	if (!t \|\| !t.alive) continue;
	const dur = e.duration != null ? val(e.duration, src.rank) : 0;
	switch (e.op) {
	case "damage": {
	const amt = val(e.amount, src.rank);
	const n = e.projectiles \|\| 0;
	if (n > 1 \|\| e.delivery === "projectile_spell") fireSpellProjectiles(b, src, t, amt, e, n \|\| 1);
	else dealDamage(b, src, t, amt, src.name \|\| "spell", { damageType: e.damageType, delivery, empowered: emp });
	break;
	}
	case "life_steal": {
	const dealt = dealDamage(b, src, t, val(e.amount, src.rank), src.name \|\| "steal", { delivery, armorIgnoring: true });
	healActor(b, src, dealt);
	break;
	}
	case "heal": {
	let amt = val(e.amount, src.rank);
	let scaled = 0;
	if (e.plusPerMod) {
	scaled = countCat(b, t, e.plusPerMod.kinds) * val(e.plusPerMod.amount, src.rank);
	amt += scaled;
	}
	if (s && scaled > 0) logEmpower(b, src, t, s, `+${scaled} heal`, `${countCat(b, t, e.plusPerMod.kinds)} effects`);
	healActor(b, t, amt, emp \|\| scaled > 0);
	break;
	}
	case "apply_condition":
	applyCondition(b, t, e.condition, dur, emp);
	break;
	case "knockdown":
	t.kd = Math.max(t.kd, b.t + dur);
	t.casting = null;
	break;
	case "interrupt":
	if (t.casting) {
	t.casting = null;
	log(b, "cond", t, { cond: "interrupted", amount: 0, ...emp ? { empowered: true } : {} });
	}
	break;
	case "regen_mod":
	addMod(b, t, { kind: "regen", pips: val(e.pips, src.rank), dur });
	break;
	case "attack_speed":
	addMod(b, t, { kind: "attackSpeed", mult: e.mult, dur });
	break;
	case "armor_mod":
	addMod(b, t, { kind: "armor", amount: val(e.amount, src.rank), attacksLeft: e.attacksLeft, dur });
	break;
	case "move_speed":
	addMod(b, src, { kind: "moveSpeed", mult: e.mult, endsOnHexEnchant: e.endsOnHexEnchant, dur });
	break;
	case "block":
	addMod(b, src, { kind: "block", chance: e.chance, vs: e.vs \|\| "all", reflect: e.reflect ? val(e.reflect, src.rank) : 0, endsOnHexEnchant: e.endsOnHexEnchant, dur });
	break;
	case "shadow_step":
	shadowStep(b, src, t);
	break;
	case "set_combo_mark":
	src.marks[t.id] = { stage: e.stage, until: b.t + 20 };
	break;
	case "lose_all_adrenaline":
	src.adrenaline = 0;
	break;
	case "preparation":
	src.prep = { on_attack: e.on_attack, until: b.t + dur };
	break;
	case "hex":
	case "enchant":
	applyContainer(b, src, t, e);
	break;
	default:
	break;
	}
	}
	}
	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(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 = dist2(src, tgt) / 900;
	for (let i = 0; i < n; i++) {
	b.projectiles.push({
	srcId: src.id,
	tgtId: tgt.id,
	aimX: tgt.x,
	aimY: tgt.y,
	bornT: b.t,
	hitT: b.t + base + i * 0.1,
	spell: true,
	amount: amt,
	damageType: e.damageType,
	label: src.name \|\| "spell"
	});
	}
	log(b, "shoot", src, { name: src.name });
	}
	function branchOk(b, req, a, tgt) {
	if (req.target_below_health != null) return tgt.hp / tgt.maxHp < req.target_below_health;
	if (req.target_health_above_self) return tgt.hp > a.hp;
	if (req.target === "bleeding") return hasCond(tgt, "bleeding");
	if (req.target === "casting_spell") return !!tgt.casting;
	if (req.target === "moving") return !!tgt.moving;
	if (req.target === "knocked_down") return isKd(b, tgt);
	if (req.target === "hexed") return hasHex(b, tgt);
	if (req.target === "attacking") return tgt.attackedAt != null && b.t - tgt.attackedAt < 1.2;
	if (req.self === "enchanted") return hasModKind(b, a, "cap") \|\| hasModKind(b, a, "convert");
	return true;
	}
	function reasonOf(req) {
	if (!req) return "";
	if (req.target_below_health != null) return `foe <${req.target_below_health * 100}%`;
	if (req.target_health_above_self) return "foe has more HP";
	if (req.target === "bleeding") return "foe Bleeding";
	if (req.target === "casting_spell") return "foe casting";
	if (req.target === "moving") return "foe moving";
	if (req.target === "knocked_down") return "knocked down";
	if (req.target === "hexed") return "foe hexed";
	if (req.target === "attacking") return "foe attacking";
	return "";
	}
	function empowerLabel(e, rank) {
	switch (e.op) {
	case "bonus_damage":
	case "damage":
	return `+${val(e.amount, rank)} dmg`;
	case "apply_condition":
	return `+${e.condition}`;
	case "heal":
	return `+${val(e.amount, rank)} heal`;
	case "interrupt":
	return "INTERRUPT";
	default:
	return "bonus";
	}
	}
	function logEmpower(b, src, tgt, s, label, reason) {
	log(b, "empower", src, { tgt: tgt?.id, skillId: s?.id, name: s?.name, label, reason });
	}
	function strike(b, a, enemy, s) {
	a.attackTimer = a.weapon.interval * attackSpeedMult(b, a);
	a.attackedAt = b.t;
	if (hasCond(a, "blind") && b.rng() < 0.9) {
	if (a.role !== "ranged") log(b, "swing", a, { name: s ? s.name : "attack" });
	log(b, "miss", enemy, { name: s ? s.name : "attack" });
	return;
	}
	let weaponDmg = a.weapon.min + b.rng() * (a.weapon.max - a.weapon.min);
	if (hasCond(a, "weakness")) weaponDmg *= 0.75;
	let bonus = 0, empEffect = null;
	if (s) {
	for (const e of s.effects) if (e.op === "bonus_damage" && (!e.if \|\| branchOk(b, e.if, a, enemy))) {
	bonus += val(e.amount, a.rank);
	if (e.if) empEffect = e;
	}
	}
	if (a.role === "ranged") {
	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 {
	log(b, "swing", a, { name: s ? s.name : "attack" });
	applyHit(b, a, enemy, s, weaponDmg, bonus, empEffect);
	}
	}
	function applyHit(b, a, enemy, s, weaponDmg, bonus, empEffect = null) {
	if (!enemy.alive) return;
	const delivery = a.role === "ranged" ? "projectile" : "melee";
	if (empEffect) logEmpower(b, a, enemy, s, empowerLabel(empEffect, a.rank), reasonOf(empEffect.if));
	dealDamage(b, a, enemy, weaponDmg + bonus, s ? s.name : "attack", { delivery, empowered: !!empEffect });
	if (s) {
	for (const e of s.effects) {
	if (e.op === "bonus_damage") continue;
	if (e.if && !branchOk(b, e.if, a, enemy)) continue;
	const emp = !!e.if;
	if (emp && e.op !== "damage") logEmpower(b, a, enemy, s, empowerLabel(e, a.rank), reasonOf(e.if));
	switch (e.op) {
	case "apply_condition":
	for (const t of resolveScope(b, a, enemy, e.scope)) applyCondition(b, t, e.condition, val(e.duration, a.rank), emp);
	break;
	case "set_combo_mark":
	a.marks[enemy.id] = { stage: e.stage, until: b.t + 20 };
	break;
	case "lose_all_adrenaline":
	a.adrenaline = 0;
	break;
	case "knockdown":
	enemy.kd = Math.max(enemy.kd, b.t + val(e.duration, a.rank));
	enemy.casting = null;
	break;
	case "interrupt":
	if (enemy.casting) {
	enemy.casting = null;
	log(b, "cond", enemy, { cond: "interrupted", amount: 0, ...emp ? { empowered: true } : {} });
	}
	break;
	case "damage":
	applyEffect(b, a, enemy, e, "melee", s);
	break;
	default:
	break;
	}
	}
	if (s.category === "dual_attack") delete a.marks[enemy.id];
	}
	if (a.prep && a.prep.until > b.t) for (const e of a.prep.on_attack) {
	if (e.op === "apply_condition") applyCondition(b, enemy, e.condition, val(e.duration, a.rank));
	}
	gainAdr(a, 1);
	}
	function advanceProjectiles(b) {
	const live = [];
	for (const p of b.projectiles) {
	if (b.t < p.hitT) {
	live.push(p);
	continue;
	}
	const src = b.actors.find((x) => x.id === p.srcId);
	const tgt = b.actors.find((x) => x.id === p.tgtId);
	if (!src \|\| !tgt \|\| !tgt.alive) continue;
	if (Math.hypot(tgt.x - p.aimX, tgt.y - p.aimY) > HIT_TOLERANCE) {
	log(b, "miss", tgt, { name: p.label \|\| p.s?.name \|\| "shot" });
	continue;
	}
	if (p.spell) dealDamage(b, src, tgt, p.amount, p.label, { damageType: p.damageType, delivery: "spell" });
	else applyHit(b, src, tgt, p.s, p.weaponDmg, p.bonus, p.empEffect);
	}
	b.projectiles = live;
	}
	var fireOnAction = (b, a) => fireTrigger(b, a, "onAction");
	function applyActivationPenalty(b, a, s, cast) {
	for (const e of s.whileActivating \|\| []) {
	if (e.op === "armor_mod") addMod(b, a, { kind: "armor", amount: val(e.amount, a.rank), dur: cast });
	}
	}
	var COMBO_STAGE = { lead_attack: "lead", offhand_attack: "offhand", dual_attack: "dual" };
	function performSkill(b, a, tgt, s) {
	if (s.cost?.energy) a.energy -= s.cost.energy;
	if (s.cost?.adrenaline) a.adrenaline -= s.cost.adrenaline;
	if (s.cost?.sacrifice) a.hp = Math.max(1, a.hp - Math.round(a.maxHp * s.cost.sacrifice / 100));
	log(b, "cast", a, { name: s.name, elite: !!s.elite, skillId: s.id, tgt: tgt.id, ...COMBO_STAGE[s.category] ? { combo: COMBO_STAGE[s.category] } : {} });
	a.recharge[s.name] = b.t + (s.recharge \|\| 0);
	fireOnAction(b, a);
	if (isAttack(s)) {
	strike(b, a, tgt, s);
	return;
	}
	for (const e of s.effects) applyEffect(b, a, tgt, e, "spell", s);
	}
	var isSupport = (s) => !!s && ["self", "ally", "other_ally", "party"].includes(s.target);
	var enchantModKind = (e) => {
	const p = e.payload?.[0] \|\| {};
	if (p.op === "cap_damage") return "cap";
	if (p.op === "convert_damage_to_heal") return "convert";
	if (e.trigger === "on_incoming_damage") return "onIncomingHeal";
	return null;
	};
	function skillTarget(b, a, s, foe) {
	if (s.target === "self" \|\| s.target === "party") return a;
	if (s.target === "ally") return mostWoundedAlly(b, a, true);
	if (s.target === "other_ally") return mostWoundedAlly(b, a, false);
	return foe;
	}
	function usable(b, a, s, tgt, foe, free = false) {
	if (!tgt) return false;
	if (free) return true;
	if (b.t < (a.recharge[s.name] \|\| 0)) return 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) && 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;
	if (r.target === "bleeding" && !hasCond(foe, "bleeding")) return false;
	if (r.target === "casting_spell" && !foe.casting) return false;
	if (r.target === "moving" && !foe.moving) return false;
	if (r.target === "knocked_down" && !isKd(b, foe)) return false;
	}
	if (s.effects.some((e) => e.op === "preparation") && a.prep && a.prep.until > b.t) return false;
	if (isSupport(s)) {
	if (s.effects.some((e) => e.op === "heal") && tgt.hp / tgt.maxHp >= 0.7 && s.effects.every((e) => e.op === "heal" \|\| e.op === "shadow_step")) return false;
	for (const e of s.effects) {
	if (e.op === "enchant") {
	const k = enchantModKind(e);
	if (k && hasModKind(b, tgt, k)) return false;
	}
	const selfBuffKind = { block: "block", armor_mod: "armor", regen_mod: "regen", attack_speed: "attackSpeed", move_speed: "moveSpeed" }[e.op];
	if (selfBuffKind && hasModKind(b, a, selfBuffKind)) return false;
	}
	} else {
	const meaningful = s.effects.filter((e) => e.op !== "set_combo_mark" && e.op !== "preparation");
	if (meaningful.length && meaningful.every((e) => e.op === "apply_condition" && hasCond(foe, e.condition))) return false;
	}
	return true;
	}
	function chooseAction(b, a, foe) {
	for (const s of a.bar) {
	const tgt = skillTarget(b, a, s, foe);
	if (usable(b, a, s, tgt, foe)) return { skill: s, target: tgt };
	}
	return null;
	}
	function moveActor(b, a, enemy, dt) {
	const d = dist2(a, enemy);
	let toward = 0;
	if (a.role === "ranged") {
	if (d < (a.preferredRange ?? a.weapon.range * 0.7)) toward = -1;
	else if (d > a.weapon.range) toward = 1;
	} else if (edgeGap(a, enemy) > reachOf(a)) {
	toward = 1;
	}
	if (!toward) {
	a.vx = 0;
	a.vy = 0;
	return;
	}
	const speed = a.moveSpeed * moveSpeedMult(b, a);
	const dx = enemy.x - a.x, dy = enemy.y - a.y, len = Math.hypot(dx, dy) \|\| 1;
	const desVx = dx / len * speed * toward, desVy = dy / len * speed * toward;
	const [vx, vy] = avoidVelocity(b, a, enemy, desVx, desVy, speed);
	const px = a.x, py = a.y;
	stepMove(b, a, vx, vy, dt);
	a.vx = vx;
	a.vy = vy;
	a.moving = b.world ? a.x !== px \|\| a.y !== py : true;
	}
	var RVO_TAU = 1.6;
	var RVO_RANGE = 280;
	var RVO_W = 240;
	var RVO_ANGLES = [0, 0.3, -0.3, 0.62, -0.62, 0.98, -0.98, 1.4, -1.4];
	var RVO_SPEEDS = [1, 0.6];
	function avoidVelocity(b, a, enemy, desVx, desVy, speed) {
	const KY = COLLISION_Y_WEIGHT;
	const obs = [];
	for (const o of b.actors) {
	if (o === a \|\| !o.alive \|\| o === enemy) continue;
	const rpx = o.x - a.x, rpy = (o.y - a.y) * KY;
	if (rpx * rpx + rpy * rpy > RVO_RANGE * RVO_RANGE) continue;
	obs.push({ rpx, rpy, ovx: o.vx \|\| 0, ovy: (o.vy \|\| 0) * KY, R: a.radius + o.radius });
	}
	if (!obs.length) return [desVx, desVy];
	const baseAng = Math.atan2(desVy, desVx);
	let best = [desVx, desVy], bestPen = Infinity;
	for (const da of RVO_ANGLES) {
	const ang = baseAng + da, cs = Math.cos(ang), sn = Math.sin(ang);
	for (const sf of RVO_SPEEDS) {
	const cvx = cs * speed * sf, cvy = sn * speed * sf;
	const cvxw = cvx, cvyw = cvy * KY;
	let minTtc = Infinity;
	for (const o of obs) {
	const t = timeToHit(o.rpx, o.rpy, o.ovx - cvxw, o.ovy - cvyw, o.R);
	if (t < minTtc) minTtc = t;
	}
	const collPen = minTtc <= RVO_TAU ? RVO_W / Math.max(minTtc, 0.05) : 0;
	const dev = Math.hypot(cvx - desVx, cvy - desVy);
	const pen = collPen + dev;
	if (pen < bestPen) {
	bestPen = pen;
	best = [cvx, cvy];
	}
	}
	}
	return best;
	}
	function timeToHit(px, py, rvx, rvy, R) {
	const c = px * px + py * py - R * R;
	if (c <= 0) return 0;
	const a2 = rvx * rvx + rvy * rvy;
	if (a2 < 1e-6) return Infinity;
	const b2 = px * rvx + py * rvy;
	if (b2 >= 0) return Infinity;
	const disc = b2 * b2 - a2 * c;
	if (disc <= 0) return Infinity;
	return (-b2 - Math.sqrt(disc)) / a2;
	}
	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, 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;
	}
	a.x = nx;
	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++) {
	for (let j = i + 1; j < live.length; j++) {
	const a = live[i], o = live[j];
	const dx = o.x - a.x, dy = (o.y - a.y) * COLLISION_Y_WEIGHT;
	const d = Math.hypot(dx, dy) \|\| 0.01;
	const overlap = a.radius + o.radius - d;
	if (overlap <= CONTACT_SLOP) continue;
	const ux = dx / d, uy = dy / d;
	const aFix = isImmovable(b, a), oFix = isImmovable(b, o);
	const push = overlap * DEOVERLAP_FRACTION;
	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, 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);
	}
	}
	}
	}
	var isImmovable = (b, a) => !!a.casting \|\| isKd(b, a);
	function stepPlayer(b, a, foe, dt) {
	const cmd = b.input && b.input[a.id] \|\| {};
	const mx = cmd.moveX \|\| 0, my = cmd.moveY \|\| 0;
	if (mx \|\| my) {
	const len = Math.hypot(mx, my) \|\| 1;
	const speed = a.moveSpeed * moveSpeedMult(b, a);
	const px = a.x, py = a.y;
	stepMove(b, a, mx / len * speed, my / len * speed, dt);
	a.moving = b.world ? a.x !== px \|\| a.y !== py : true;
	a.faceX = mx < 0 ? -1 : mx > 0 ? 1 : a.faceX;
	a.faceY = my < 0 ? -1 : my > 0 ? 1 : a.faceY;
	a.facing = a.faceX;
	}
	if (a.casting) {
	a.casting.left -= dt;
	if (a.casting.left <= 0) {
	const { skill, target } = a.casting;
	a.casting = null;
	performSkill(b, a, target?.alive ? target : foe, skill);
	}
	return;
	}
	const action = cmd.action;
	if (!action) return;
	const free = !!b.freeCast;
	if (free) {
	a.energy = a.maxEnergy;
	a.adrenaline = 25;
	}
	const clear = () => {
	if (b.input) b.input[a.id] = { ...cmd, action: null };
	};
	if (action === "basic") {
	if (!free && a.role !== "ranged" && edgeGap(a, foe) > reachOf(a)) {
	clear();
	return;
	}
	if (!free && a.attackTimer > 0) return;
	fireOnAction(b, a);
	strike(b, a, foe, null);
	clear();
	return;
	}
	const s = a.bar.find((x) => x.id === action);
	if (!s) {
	clear();
	return;
	}
	const tgt = skillTarget(b, a, s, foe);
	if (!usable(b, a, s, tgt, foe, free)) return;
	const cast = (s.cast \|\| 0) * (hasCond(a, "dazed") ? 2 : 1);
	if (cast <= 0) performSkill(b, a, tgt, s);
	else {
	applyActivationPenalty(b, a, s, cast);
	a.casting = { skill: s, target: tgt, left: cast };
	}
	clear();
	}
	function reviveDummy(b, a) {
	a.alive = true;
	a.hp = a.maxHp = a.baseMaxHp;
	a.energy = a.maxEnergy;
	a.adrenaline = 0;
	a.conds = [];
	a.marks = {};
	a.mods = [];
	a.casting = null;
	a.kd = 0;
	a.deadAt = null;
	}
	function step(b, dt) {
	if (b.over) return;
	b.t += dt;
	if (b.sandbox && b.respawnDummies) {
	for (const a of b.actors) if (!a.alive && a.control === "dummy" && a.deadAt != null && b.t - a.deadAt >= b.respawnDummies) reviveDummy(b, a);
	}
	for (const a of b.actors) {
	if (!a.alive) continue;
	a.energy = Math.min(a.maxEnergy, a.energy + a.energyRegen * dt);
	let degen = 0;
	for (const c of a.conds) if (c.until > b.t) degen += DEGEN[c.type] \|\| 0;
	const rate = degen - sumRegenPips(b, a) * 2;
	if (rate) {
	a.hp = Math.min(a.maxHp, a.hp - rate * dt);
	if (a.hp <= 0) kill(b, a);
	}
	expireConds(b, a);
	a.attackTimer -= dt;
	for (const id of Object.keys(a.marks)) if (a.marks[id]?.until <= b.t) delete a.marks[id];
	}
	advanceProjectiles(b);
	for (const a of b.actors) {
	if (!a.alive \|\| b.over) continue;
	const enemy = nearestFoe(b, a);
	if (!enemy && a.control !== "player") continue;
	if (a.aggroRadius != null && a.control !== "player" && dist2(a, enemy) > a.aggroRadius) {
	a.moving = false;
	continue;
	}
	if (enemy) {
	a.facing = enemy.x < a.x ? -1 : 1;
	a.faceX = a.facing;
	a.faceY = enemy.y < a.y ? -1 : 1;
	}
	a.moving = false;
	if (isKd(b, a)) {
	a.casting = null;
	continue;
	}
	if (a.control === "dummy") continue;
	if (a.control === "player") {
	stepPlayer(b, a, enemy, dt);
	continue;
	}
	if (a.casting) {
	a.casting.left -= dt;
	if (a.casting.left <= 0) {
	const { skill, target } = a.casting;
	a.casting = null;
	performSkill(b, a, target?.alive ? target : enemy, skill);
	}
	continue;
	}
	const action = chooseAction(b, a, enemy);
	if (action) {
	const cast = (action.skill.cast \|\| 0) * (hasCond(a, "dazed") ? 2 : 1);
	if (cast <= 0) performSkill(b, a, action.target, action.skill);
	else {
	applyActivationPenalty(b, a, action.skill, cast);
	a.casting = { skill: action.skill, target: action.target, left: cast };
	}
	} else if (edgeGap(a, enemy) <= reachOf(a) && a.attackTimer <= 0) {
	fireOnAction(b, a);
	strike(b, a, enemy, null);
	} else {
	moveActor(b, a, enemy, dt);
	}
	}
	resolveOverlaps(b);
	if (b.sandbox) return;
	const playerAlive = b.actors.some((a) => a.alive && a.team === "player");
	const enemyAlive = b.actors.some((a) => a.alive && a.team === "enemy");
	if (!playerAlive \|\| !enemyAlive) {
	b.over = true;
	b.winner = playerAlive ? "player" : enemyAlive ? "enemy" : null;
	} else if (b.t >= MAX_BATTLE_T) {
	const hp = (team) => b.actors.filter((a) => a.alive && a.team === team).reduce((n, a) => n + a.hp, 0);
	const ph = hp("player"), eh = hp("enemy");
	b.over = true;
	b.winner = ph === eh ? null : ph > eh ? "player" : "enemy";
	}
	}

	// ../auto-battler/src/sim/walkable.js
	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 TILE6 = 8;
	var SPRITE_TILES = 0.95;
	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) => {
	const i = new Image();
	i.onload = () => res(i);
	i.onerror = rej;
	i.src = url;
	});
	const cell = Math.round(img.naturalHeight / 4);
	const cv = document.createElement("canvas");
	cv.width = cell;
	cv.height = cell;
	const ctx = cv.getContext("2d", { willReadFrequently: true });
	ctx.drawImage(img, 0, 0, cell, cell, 0, 0, cell, cell);
	const d = ctx.getImageData(0, 0, cell, cell).data;
	let minY = cell, maxY = -1;
	for (let y = 0; y < cell; y++) for (let x = 0; x < cell; x++) if (d[(y * cell + x) * 4 + 3] > 40) {
	if (y < minY) minY = y;
	if (y > maxY) maxY = y;
	}
	return maxY < 0 ? cell : maxY + 1 - minY;
	} catch {
	return 16;
	}
	}
	function mountComboBattler(pixi, host, opts = {}) {
	const { Graphics, Container } = pixi;
	const seed = (opts.seed ?? 1) >>> 0;
	const G = opts.groundScale ?? 0.3;
	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 };
	const req = { attack: false, skill: 0 };
	let moveTarget = null;
	const acc = { t: 0 };
	const cursor = { logIdx: 0 };
	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, ...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] };
	const held = {};
	const applyKeys = () => {
	let x = 0, y = 0;
	for (const k in held) if (held[k]) {
	x += KEYMAP[k][0];
	y += KEYMAP[k][1];
	}
	keys.x = Math.sign(x);
	keys.y = Math.sign(y);
	};
	function bindKeys() {
	const onDown = (e) => {
	const tag = e.target?.tagName;
	if (tag === "INPUT" \|\| tag === "SELECT" \|\| tag === "TEXTAREA") return;
	if (e.code === "Space" \|\| e.key === " ") {
	req.attack = true;
	e.preventDefault();
	return;
	}
	if (e.key >= "1" && e.key <= "9") {
	req.skill = +e.key;
	e.preventDefault();
	return;
	}
	const k = e.key.toLowerCase();
	if (KEYMAP[k]) {
	held[k] = true;
	applyKeys();
	e.preventDefault();
	}
	};
	const onUp = (e) => {
	const k = e.key.toLowerCase();
	if (KEYMAP[k]) {
	held[k] = false;
	applyKeys();
	}
	};
	window.addEventListener("keydown", onDown);
	window.addEventListener("keyup", onUp);
	keyHandlers = () => {
	window.removeEventListener("keydown", onDown);
	window.removeEventListener("keyup", onUp);
	};
	}
	function bindTap() {
	const canvas = map.getApp().canvas;
	let downAt = null;
	const onDown = (e) => {
	downAt = { x: e.clientX, y: e.clientY, t: performance.now() };
	};
	const onUp = (e) => {
	if (!downAt) return;
	const moved = Math.hypot(e.clientX - downAt.x, e.clientY - downAt.y), elapsed = performance.now() - downAt.t;
	downAt = null;
	if (moved > 8 \|\| elapsed > 500) return;
	const r = canvas.getBoundingClientRect(), w = map.screenToWorld(e.clientX - r.left, e.clientY - r.top);
	moveTarget = worldToField(w.x, w.y);
	};
	canvas.addEventListener("pointerdown", onDown);
	window.addEventListener("pointerup", onUp);
	tapHandlers = () => {
	canvas.removeEventListener("pointerdown", onDown);
	window.removeEventListener("pointerup", onUp);
	};
	}
	function buildControls() {
	const bar = document.createElement("div");
	bar.style.cssText = "position:absolute;left:0;right:0;bottom:10px;display:flex;gap:8px;justify-content:center;align-items:flex-end;pointer-events:none;z-index:5;font-family:monospace";
	const mk = (label, on) => {
	const b = document.createElement("button");
	b.textContent = label;
	b.style.cssText = "pointer-events:auto;touch-action:manipulation;min-width:46px;height:46px;border-radius:10px;border:1px solid #20262e;background:rgba(20,24,33,.78);color:#e8e8e8;font:600 13px monospace;cursor:pointer";
	const fire = (ev) => {
	ev.preventDefault();
	on();
	};
	b.addEventListener("pointerdown", fire);
	return b;
	};
	bar.appendChild(mk("\u2694", () => {
	req.attack = true;
	}));
	const names = (pa()?.bar \|\| []).map((s) => s.name);
	names.forEach((nm, i) => bar.appendChild(mk(String(i + 1), () => {
	req.skill = i + 1;
	})).setAttribute("title", nm \|\| ""));
	host.appendChild(bar);
	controlsEl = bar;
	}
	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, dist3(p, e));
	return m;
	};
	function tick(ticker) {
	if (!battle \|\| !R) return;
	const dtMS = ticker.deltaMS, dt = dtMS / 1e3;
	const p = pa();
	if (keys.x \|\| keys.y) {
	moveTarget = null;
	setInput(battle, "P0", { moveX: keys.x, moveY: keys.y });
	} else if (moveTarget && p) {
	const dx = moveTarget.x - p.x, dy = moveTarget.y - p.y, d = Math.hypot(dx, dy);
	if (d < Math.max(10, p.radius * 0.5)) {
	moveTarget = null;
	setInput(battle, "P0", { moveX: 0, moveY: 0 });
	} else setInput(battle, "P0", { moveX: dx / d, moveY: dy / d });
	} else setInput(battle, "P0", { moveX: 0, moveY: 0 });
	if (req.attack) {
	req.attack = false;
	if (p && nearestFoeDist() <= p.weapon.range + p.radius) setInput(battle, "P0", { action: "basic" });
	}
	if (req.skill) {
	const s = p?.bar?.[req.skill - 1];
	req.skill = 0;
	if (s) setInput(battle, "P0", { action: s.id });
	}
	acc.t += Math.min(dt, 0.1);
	while (acc.t >= STEP) {
	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() {
	const p = pa();
	rings.clear();
	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 sd = (o) => ({ idle: o?.idle, walk: o?.walk, attack: o?.attack, dmg: o?.dmg, die: o?.die });
	function teardownCombat() {
	try {
	offTick?.();
	} catch {
	}
	offTick = null;
	try {
	keyHandlers?.();
	} catch {
	}
	keyHandlers = null;
	try {
	tapHandlers?.();
	} catch {
	}
	tapHandlers = null;
	try {
	controlsEl?.remove();
	} catch {
	}
	controlsEl = null;
	try {
	markers?.destroy();
	} catch {
	}
	markers = null;
	try {
	combatRoot?.destroy({ children: true });
	} catch {
	}
	combatRoot = null;
	R = null;
	rings = null;
	battle = null;
	spawnFn = null;
	dead = false;
	acc.t = 0;
	cursor.logIdx = 0;
	moveTarget = null;
	}
	async function spawnHero(player) {
	if (!alive \|\| !player) return;
	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 pProf = player?.unit?.profession;
	const pSkills = player?.unit?.skills?.length ? player.unit.skills : CB_SKILLS.filter((s) => s.profession === pProf).slice(0, 3).map((s) => s.id);
	const players = [{ ...player?.unit \|\| {}, name: player?.name \|\| "Hero", control: "player", skills: pSkills }];
	battle = makeTeamBattle({ seed, players, enemies: [], sandbox: true, freeCast: true, world, field });
	const start = worldToField(bnds.x0 + 64 * TILE6, bnds.y1 - 64 * TILE6);
	const p0 = snapField(start.x, start.y);
	const P = pa();
	if (P) {
	P.x = p0.x;
	P.y = p0.y;
	}
	const defsById = {};
	defsById.P0 = { name: players[0].name, profession: players[0].profession, ...sd(player?.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();
	units.sortableChildren = true;
	const fx = new Container();
	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(player?.sheets?.idle \|\| player?.sheets?.walk);
	if (!alive) return;
	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, fy2) => {
	const w = fieldToWorld(fx2, fy2);
	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();
	offTick = map.onTick(tick);
	emit();
	}
	async function selectHero(player) {
	if (!alive \|\| !player) return;
	if (battle \|\| combatRoot) teardownCombat();
	await spawnHero(player);
	}
	const ready = (async () => {
	await map.ready;
	if (!alive) return;
	if (opts.player) await spawnHero(opts.player);
	})();
	function getSnapshot() {
	return snap();
	}
	function resize() {
	try {
	map.getApp()?.resize();
	} catch {
	}
	}
	function onChange(fn) {
	listeners.add(fn);
	return () => listeners.delete(fn);
	}
	function destroy() {
	alive = false;
	try {
	offTick?.();
	} catch {
	}
	try {
	keyHandlers?.();
	} catch {
	}
	try {
	tapHandlers?.();
	} catch {
	}
	try {
	controlsEl?.remove();
	} catch {
	}
	try {
	markers?.destroy();
	} catch {
	}
	try {
	map.destroy();
	} catch {
	}
	battle = null;
	R = null;
	combatRoot = null;
	listeners.clear();
	}
	function getSpawnWorld() {
	const b = map.getBounds();
	return b ? { x: b.x0 + 64 * TILE6, y: b.y1 - 64 * TILE6 } : { x: 0, y: 0 };
	}
	const ctrl = { ready, selectHero, getSpawnWorld, getSnapshot, resize, onChange, destroy, map, walkable: (wx, wy) => roamWalkable(wx, wy) };
	if (typeof window !== "undefined") {
	window.__comboSnap = () => ctrl.getSnapshot();
	window.__combo = ctrl;
	}
	return ctrl;
	}
	export {
	mountComboBattler
	};