@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/gdd/levelmap.js

@@ -0,0 +1,428 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { END, roomFiles, specRooms, uniqueRooms } from "../spec/rooms.js";
+export const LEVEL_FILES = ['design/level.json', 'design/levels'];
+export const isLevelSpec = (raw) => !!raw && typeof raw === 'object' && !('tiles' in raw) && !('levels' in raw)
+    && (Array.isArray(raw.areas) || Array.isArray(raw.platforms)) && Array.isArray(raw.markers);
+const sections = (text) => text.split(/^##\s+/m).slice(1).map((chunk) => ({ level: 2, title: chunk.split('\n')[0].trim(), body: chunk.split('\n').slice(1).join('\n') }));
+const readJson = (p) => { try {
+    return JSON.parse(readFileSync(p, 'utf8'));
+}
+catch {
+    return null;
+} };
+const esc = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+const num = (v, d = 0) => (typeof v === 'number' && Number.isFinite(v) ? v : d);
+const str = (v) => (typeof v === 'string' && v.trim() ? v.trim() : undefined);
+const cut = (s, n) => (s.length > n ? `${s.slice(0, n - 1).trimEnd()}…` : s);
+const key = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
+export function placeLandmarks(text) {
+    const out = new Map();
+    for (const s of sections(text)) {
+        if (s.level !== 2 || !/^(places|the places|where it happens|locations)\b/i.test(s.title))
+            continue;
+        const rows = s.body.split('\n').filter((l) => /^\s*\|.*\|\s*$/.test(l)).map((l) => l.trim().replace(/^\||\|$/g, '').split('|').map((c) => c.trim()));
+        if (rows.length < 3)
+            continue;
+        const at = rows[0].findIndex((h) => /^landmark/i.test(h));
+        if (at < 0)
+            continue;
+        for (const r of rows.slice(2)) {
+            const place = r[0]?.replace(/[*`]/g, '').trim(), mark = r[at]?.replace(/[*`]/g, '').trim();
+            if (place && mark && !/[<>]/.test(place + mark) && mark !== '—' && mark !== '-')
+                out.set(key(place), mark);
+        }
+    }
+    return out;
+}
+export function roomsMap(game, landmarks = new Map()) {
+    const { rooms: all, files } = specRooms(game);
+    const rooms = uniqueRooms(all);
+    if (!rooms.length)
+        return null;
+    const raw = new Map();
+    const chapterNames = new Map();
+    for (const f of roomFiles(game)) {
+        const data = readJson(join(game, f));
+        const chapters = Array.isArray(data?.chapters) ? data.chapters : Array.isArray(data?.rooms) ? [{ id: 'rooms', rooms: data.rooms }] : [];
+        for (const c of chapters) {
+            if (typeof c?.id === 'string' && str(c.name))
+                chapterNames.set(c.id, str(c.name));
+            for (const r of Array.isArray(c?.rooms) ? c.rooms : [])
+                if (typeof r?.id === 'string')
+                    raw.set(r.id, r);
+        }
+    }
+    const ids = new Set(rooms.map((r) => r.id));
+    const out = rooms.map((r, i) => {
+        const extra = raw.get(r.id) ?? {};
+        const named = (Array.isArray(extra.exits) ? extra.exits : [])
+            .map((e) => (typeof e === 'string' ? e : str(e?.to) ?? str(e?.room) ?? str(e?.leads)))
+            .filter((t) => typeof t === 'string' && (ids.has(t) || t === END));
+        const own = r.exit && (ids.has(r.exit) || r.exit === END) ? r.exit : null;
+        const next = own ?? (rooms[i + 1]?.id ?? END);
+        const look = str(extra.look) ?? str(extra.landmark) ?? landmarks.get(key(r.name)) ?? landmarks.get(key(r.id));
+        return {
+            id: r.id, name: r.name, chapter: r.chapter, to: [...new Set([next, ...named])], byOrder: !own, onPath: false, slice: r.slice,
+            ...(r.teaches ? { teaches: r.teaches } : {}), ...(look ? { look } : {}),
+        };
+    });
+    const byId = new Map(out.map((r) => [r.id, r]));
+    const path = [];
+    let at = out[0];
+    while (at && !path.includes(at.id)) {
+        path.push(at.id);
+        at.onPath = true;
+        at = byId.get(at.to[0]);
+    }
+    const last = byId.get(path[path.length - 1]);
+    const chapters = [...new Set(out.map((r) => r.chapter))].map((id) => ({ id, name: chapterNames.get(id) ?? (id === 'rooms' ? '' : id) }));
+    return { files, chapters, rooms: out, path, reachesEnd: last?.to[0] === END };
+}
+const PALETTE = { floor: '#b08a62', wall: '#e8dcc4', trim: '#5a4332', ground: '#6f9a4a', path: '#c9b48a', water: '#3f8fc4', prop: '#8a5a3b', foliage: '#3f7d3a', accent: '#d9563a', ink: '#1b1622' };
+const HEX = /^#[0-9a-f]{6}$/i;
+const STEP_Y = 0.5;
+const REACH_GAP = 1.0;
+const LOOK_NAME = /look|landmark|vista|view|focus/i;
+const contains = (r, x, z, pad = 0) => x >= r.x - pad && x <= r.x + r.w + pad && z >= r.z - pad && z <= r.z + r.d + pad;
+const centre = (r) => [r.x + r.w / 2, r.z + r.d / 2];
+const heightsMeet = (a, b) => a.y[0] - STEP_Y <= b.y[1] && b.y[0] - STEP_Y <= a.y[1];
+export function specFiles(game) {
+    const out = [];
+    for (const entry of LEVEL_FILES) {
+        const p = join(game, entry);
+        if (!existsSync(p))
+            continue;
+        const files = statSync(p).isDirectory() ? readdirSync(p).filter((f) => f.endsWith('.json')).sort().map((f) => join(p, f)) : [p];
+        for (const f of files) {
+            const raw = readJson(f);
+            const list = Array.isArray(raw?.levels) ? raw.levels : [raw];
+            list.forEach((one, i) => { if (isLevelSpec(one))
+                out.push({ file: `${relative(game, f).split('\\').join('/')}${list.length > 1 ? `#${i + 1}` : ''}`, spec: one }); });
+        }
+    }
+    return out;
+}
+export function planMap(spec, file, landmarks = new Map()) {
+    const palette = { ...PALETTE };
+    for (const [k, v] of Object.entries(spec?.style?.palette ?? {}))
+        if (typeof v === 'string' && HEX.test(v) && k in palette)
+            palette[k] = v;
+    const nodes = [];
+    const rect = (r) => ({ x: num(r.x), z: num(r.z), w: Math.max(0.25, num(r.w, 1)), d: Math.max(0.25, num(r.d, 1)) });
+    for (const a of Array.isArray(spec.areas) ? spec.areas : []) {
+        const kind = (['room', 'yard', 'path', 'water'].includes(a?.kind) ? a.kind : 'room');
+        const name = String(a?.name ?? 'area');
+        const lm = landmarks.get(key(name));
+        nodes.push({ ...rect(a), name, kind, walled: kind === 'room' && a.walls !== false, y: [num(a.floor_y), num(a.floor_y)], ...(lm ? { landmark: lm } : {}) });
+    }
+    for (const p of Array.isArray(spec.platforms) ? spec.platforms : [])
+        nodes.push({ ...rect(p), name: String(p?.name ?? 'platform'), kind: 'platform', walled: false, y: [num(p.y), num(p.y)] });
+    for (const r of Array.isArray(spec.ramps) ? spec.ramps : []) {
+        const lo = Math.min(num(r.from_y), num(r.to_y)), hi = Math.max(num(r.from_y), num(r.to_y));
+        nodes.push({ ...rect(r), name: String(r?.name ?? 'ramp'), kind: 'ramp', walled: false, y: [lo, hi], dir: typeof r.dir === 'string' ? r.dir : undefined });
+    }
+    const markers = (Array.isArray(spec.markers) ? spec.markers : [])
+        .filter((m) => Array.isArray(m?.at) && m.at.length >= 3)
+        .map((m) => ({ name: String(m.name ?? ''), kind: String(m.kind ?? ''), x: num(m.at[0]), y: num(m.at[1]), z: num(m.at[2]), rot: num(m.rot) }));
+    const walls = (Array.isArray(spec.walls) ? spec.walls : []).filter((w) => Array.isArray(w?.from) && Array.isArray(w?.to)).map((w) => {
+        const from = [num(w.from[0]), num(w.from[1])], to = [num(w.to[0]), num(w.to[1])];
+        const len = Math.hypot(to[0] - from[0], to[1] - from[1]) || 1;
+        const gaps = (Array.isArray(w.openings) ? w.openings : []).map((o) => [num(o.at) / len, (num(o.at) + num(o.width, 1)) / len]);
+        return { name: String(w.name ?? 'wall'), from, to, gaps };
+    });
+    const walkable = nodes.map((n, i) => ({ n, i })).filter(({ n }) => n.kind !== 'water');
+    const links = new Map();
+    const link = (a, b, via) => {
+        if (a === b)
+            return;
+        for (const [p, q] of [[a, b], [b, a]]) {
+            const l = links.get(p) ?? [];
+            if (!l.some((e) => e.to === q))
+                l.push({ to: q, via });
+            links.set(p, l);
+        }
+    };
+    const doors = [];
+    for (const { n, i } of walkable) {
+        if (n.kind !== 'room')
+            continue;
+        const area = (Array.isArray(spec.areas) ? spec.areas : []).find((a) => String(a?.name) === n.name) ?? {};
+        for (const o of Array.isArray(area.openings) ? area.openings : []) {
+            const at = num(o.at), width = num(o.width, 1), mid = at + width / 2;
+            const side = o.side;
+            const pt = side === 'n' ? [n.x + mid, n.z] : side === 's' ? [n.x + mid, n.z + n.d] : side === 'w' ? [n.x, n.z + mid] : side === 'e' ? [n.x + n.w, n.z + mid] : null;
+            if (!pt)
+                continue;
+            const seg = side === 'n' || side === 's' ? [n.x + at, pt[1], n.x + at + width, pt[1]] : [pt[0], n.z + at, pt[0], n.z + at + width];
+            doors.push(seg);
+            if (num(o.sill) > STEP_Y || width < 0.6)
+                continue;
+            const out = side === 'n' ? [0, -1] : side === 's' ? [0, 1] : side === 'w' ? [-1, 0] : [1, 0];
+            for (const reach of [0.3, 0.6, REACH_GAP]) {
+                const x = pt[0] + out[0] * reach, z = pt[1] + out[1] * reach;
+                const other = walkable.find(({ n: m, i: j }) => j !== i && contains(m, x, z) && heightsMeet(n, m));
+                if (other) {
+                    link(i, other.i, pt);
+                    break;
+                }
+            }
+        }
+    }
+    for (const { n: a, i } of walkable)
+        for (const { n: b, i: j } of walkable) {
+            if (j <= i || !heightsMeet(a, b))
+                continue;
+            const ox = Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x), oz = Math.min(a.z + a.d, b.z + b.d) - Math.max(a.z, b.z);
+            if (ox > 0.01 && oz > 0.01) {
+                const inside = (p, q) => p.x >= q.x - 0.01 && p.z >= q.z - 0.01 && p.x + p.w <= q.x + q.w + 0.01 && p.z + p.d <= q.z + q.d + 0.01;
+                if ((!a.walled && !b.walled) || inside(a, b) || inside(b, a))
+                    link(i, j, [Math.max(a.x, b.x) + ox / 2, Math.max(a.z, b.z) + oz / 2]);
+                continue;
+            }
+            if (a.walled || b.walled)
+                continue;
+            const gx = Math.max(0, -ox), gz = Math.max(0, -oz);
+            if (Math.hypot(gx, gz) > REACH_GAP)
+                continue;
+            const mx = ox > 0 ? Math.max(a.x, b.x) + ox / 2 : (Math.min(a.x + a.w, b.x + b.w) + Math.max(a.x, b.x)) / 2;
+            const mz = oz > 0 ? Math.max(a.z, b.z) + oz / 2 : (Math.min(a.z + a.d, b.z + b.d) + Math.max(a.z, b.z)) / 2;
+            link(i, j, [mx, mz]);
+        }
+    const placeOf = (m) => {
+        let best = null, dy = Infinity;
+        for (const { n, i } of walkable) {
+            if (!contains(n, m.x, m.z, 0.05))
+                continue;
+            const d = Math.min(Math.abs(m.y - n.y[0]), Math.abs(m.y - n.y[1]));
+            if (d < dy) {
+                dy = d;
+                best = i;
+            }
+        }
+        return best;
+    };
+    const route = (from, to) => {
+        if (from === to)
+            return [];
+        const prev = new Map([[from, { from, via: [0, 0] }]]);
+        const queue = [from];
+        while (queue.length) {
+            const at = queue.shift();
+            if (at === to)
+                break;
+            for (const e of links.get(at) ?? [])
+                if (!prev.has(e.to)) {
+                    prev.set(e.to, { from: at, via: e.via });
+                    queue.push(e.to);
+                }
+        }
+        if (!prev.has(to))
+            return null;
+        const vias = [];
+        for (let at = to; at !== from; at = prev.get(at).from)
+            vias.unshift(prev.get(at).via);
+        return vias;
+    };
+    const spawn = markers.find((m) => m.kind === 'spawn'), exit = markers.find((m) => m.kind === 'exit');
+    const stops = spawn && exit ? [spawn, ...markers.filter((m) => m.kind === 'checkpoint'), exit] : [];
+    const path = [], gaps = [];
+    for (let k = 0; k + 1 < stops.length; k++) {
+        const a = stops[k], b = stops[k + 1];
+        const pa = placeOf(a), pb = placeOf(b);
+        const vias = pa !== null && pb !== null ? route(pa, pb) : null;
+        if (!vias) {
+            gaps.push(`${a.kind} ${a.name} to ${b.kind} ${b.name}`);
+            continue;
+        }
+        if (!path.length || path[path.length - 1][0] !== a.x || path[path.length - 1][1] !== a.z)
+            path.push([a.x, a.z]);
+        path.push(...vias, [b.x, b.z]);
+    }
+    const looks = markers.filter((m) => m.kind === 'camera' || m.kind === 'spawn' || LOOK_NAME.test(m.name));
+    return { file, name: typeof spec.name === 'string' ? spec.name : file, nodes, walls, doors, markers, palette, path, gaps, looks };
+}
+export function readLevelMaps(game, gddText = '') {
+    const landmarks = placeLandmarks(gddText);
+    let rooms = null;
+    try {
+        rooms = roomsMap(game, landmarks);
+    }
+    catch { }
+    const plans = [];
+    try {
+        for (const { file, spec } of specFiles(game).slice(0, 8))
+            plans.push(planMap(spec, file, landmarks));
+    }
+    catch { }
+    return { rooms, plans };
+}
+export const hasLevelMap = (m) => !!m.rooms || m.plans.length > 0;
+const BW = 172, BH = 78, GX = 46, GY = 46, LABEL = 24, PAD = 14, PER_ROW = 4;
+function roomsSvg(m) {
+    const pos = new Map();
+    let y = PAD, cols = 1;
+    const labels = [];
+    const endAfter = m.reachesEnd ? m.path[m.path.length - 1] : null;
+    for (const c of m.chapters) {
+        const ids = m.rooms.filter((r) => r.chapter === c.id).map((r) => r.id);
+        const slots = [...ids, ...(endAfter && ids.includes(endAfter) && ids[ids.length - 1] === endAfter ? [END] : [])];
+        if (c.name) {
+            labels.push(`<text class="ch" x="${PAD}" y="${y + 15}">${esc(cut(c.name, 60))}</text>`);
+            y += LABEL;
+        }
+        for (let k = 0; k < slots.length; k++) {
+            const col = k % PER_ROW;
+            if (k && !col)
+                y += BH + GY;
+            pos.set(slots[k], { x: PAD + col * (BW + GX), y });
+            cols = Math.max(cols, col + 1);
+        }
+        y += BH + GY;
+    }
+    if (endAfter && !pos.has(END)) {
+        pos.set(END, { x: PAD, y });
+        y += BH + GY;
+    }
+    const width = PAD * 2 + cols * BW + (cols - 1) * GX, height = y - GY + PAD;
+    const onPath = new Set(m.path.map((id, i) => `${id}>${m.path[i + 1] ?? (m.reachesEnd ? END : '')}`));
+    const edges = [];
+    for (const r of m.rooms)
+        for (const to of r.to) {
+            const a = pos.get(r.id), b = pos.get(to);
+            if (!a || !b)
+                continue;
+            const crit = onPath.has(`${r.id}>${to}`);
+            const cls = `rt${crit ? ' crit' : ''}${r.byOrder && to === r.to[0] ? ' order' : ''}`;
+            let d;
+            if (b.y === a.y && b.x > a.x) {
+                const x1 = a.x + BW, y1 = a.y + BH / 2, x2 = b.x - 4;
+                d = b.x - a.x === BW + GX ? `M${x1} ${y1}H${x2}` : `M${a.x + BW / 2} ${a.y}C${a.x + BW / 2} ${a.y - GY} ${b.x + BW / 2} ${b.y - GY} ${b.x + BW / 2} ${b.y - 4}`;
+            }
+            else if (b.y > a.y) {
+                d = `M${a.x + BW / 2} ${a.y + BH}C${a.x + BW / 2} ${a.y + BH + GY * 0.9} ${b.x + BW / 2} ${b.y - GY * 0.9} ${b.x + BW / 2} ${b.y - 4}`;
+            }
+            else {
+                d = `M${a.x} ${a.y + BH / 2}C${a.x - GX} ${a.y + BH / 2} ${b.x - GX} ${b.y + BH / 2} ${b.x - 4} ${b.y + BH / 2}`;
+            }
+            edges.push(`<path class="${cls}" d="${d}" marker-end="url(#${crit ? 'lm-ah-crit' : 'lm-ah'})"/>`);
+        }
+    const boxes = m.rooms.map((r) => {
+        const p = pos.get(r.id);
+        const lines = [r.teaches ? cut(r.teaches, 24) : '', r.look ? `◉ ${cut(r.look, 21)}` : ''].filter(Boolean);
+        const tip = [r.name, r.teaches && `teaches: ${r.teaches}`, r.look && `look: ${r.look}`, r.slice && 'the slice: built first'].filter(Boolean).join(' · ');
+        return `<g class="rm${r.onPath ? ' on' : ' off'}${r.slice ? ' slice' : ''}" data-room="${esc(r.id)}"><title>${esc(tip)}</title><rect x="${p.x}" y="${p.y}" width="${BW}" height="${BH}" rx="12"/>`
+            + `<text class="nm" x="${p.x + 12}" y="${p.y + 24}">${esc(cut(r.name, r.slice ? 13 : 18))}</text>${r.slice ? `<text class="tag" x="${p.x + BW - 12}" y="${p.y + 24}" text-anchor="end">slice</text>` : ''}`
+            + lines.map((l, i) => `<text class="${l.startsWith('◉') ? 'lk' : 'sm'}" x="${p.x + 12}" y="${p.y + 45 + i * 17}">${esc(l)}</text>`).join('') + '</g>';
+    });
+    const end = pos.get(END);
+    const endBox = end ? `<g class="end"><rect x="${end.x}" y="${end.y + BH / 2 - 18}" width="92" height="36" rx="18"/><text x="${end.x + 46}" y="${end.y + BH / 2 + 5}" text-anchor="middle">The end</text></g>` : '';
+    return `<svg class="lm-svg rooms" viewBox="0 0 ${width} ${height}" width="${width}" role="img" aria-label="The campaign: ${m.rooms.length} rooms, the critical path ${esc(m.path.join(' to '))}">`
+        + `<defs><marker id="lm-ah" viewBox="0 0 10 10" refX="8" refY="5" markerUnits="userSpaceOnUse" markerWidth="9" markerHeight="9" orient="auto-start-reverse"><path class="ah" d="M0 0L10 5L0 10z"/></marker><marker id="lm-ah-crit" viewBox="0 0 10 10" refX="8" refY="5" markerUnits="userSpaceOnUse" markerWidth="12" markerHeight="12" orient="auto-start-reverse"><path class="ah crit" d="M0 0L10 5L0 10z"/></marker></defs>`
+        + edges.join('') + labels.join('') + boxes.join('') + endBox + '</svg>';
+}
+const dark = (hex) => { const n = parseInt(hex.slice(1), 16); return (0.2126 * ((n >> 16) & 255) + 0.7152 * ((n >> 8) & 255) + 0.0722 * (n & 255)) / 255 < 0.42; };
+const KIND_FILL = { room: 'floor', yard: 'ground', path: 'path', water: 'water', platform: 'trim', ramp: 'path' };
+const GLYPH = { spawn: 'S', exit: 'E', checkpoint: 'C', pickup: '★', enemy: '!', trigger: '◆', light: '✦', camera: '◉' };
+function planSvg(p) {
+    const xs = [], zs = [];
+    for (const n of p.nodes) {
+        xs.push(n.x, n.x + n.w);
+        zs.push(n.z, n.z + n.d);
+    }
+    for (const w of p.walls) {
+        xs.push(w.from[0], w.to[0]);
+        zs.push(w.from[1], w.to[1]);
+    }
+    for (const m of p.markers) {
+        xs.push(m.x);
+        zs.push(m.z);
+    }
+    if (!xs.length)
+        return '';
+    const minX = Math.min(...xs) - 1, minZ = Math.min(...zs) - 1, W = Math.max(...xs) + 1 - minX, D = Math.max(...zs) + 1 - minZ;
+    const s = Math.max(4, Math.min(48, 680 / W, 460 / D));
+    const X = (x) => +((x - minX) * s).toFixed(1), Z = (z) => +((z - minZ) * s).toFixed(1);
+    const pal = p.palette;
+    const order = ['yard', 'path', 'water', 'room', 'ramp', 'platform'];
+    const nodes = [...p.nodes].sort((a, b) => order.indexOf(a.kind) - order.indexOf(b.kind)).map((n) => {
+        const fill = pal[KIND_FILL[n.kind]] ?? pal.floor;
+        const r = `<rect class="ar ${n.kind}${n.walled ? ' walled' : ''}" x="${X(n.x)}" y="${Z(n.z)}" width="${(n.w * s).toFixed(1)}" height="${(n.d * s).toFixed(1)}" fill="${fill}" stroke="${n.walled ? pal.ink : pal.trim}"/>`;
+        const arrow = n.kind === 'ramp' && n.dir ? (() => {
+            const [cx, cz] = centre(n), L = Math.min(n.w, n.d) * 0.35;
+            const v = n.dir === 'n' ? [0, -1] : n.dir === 's' ? [0, 1] : n.dir === 'e' ? [1, 0] : [-1, 0];
+            return `<path class="up" d="M${X(cx - v[0] * L)} ${Z(cz - v[1] * L)}L${X(cx + v[0] * L)} ${Z(cz + v[1] * L)}" stroke="${pal.ink}" marker-end="url(#lm-up)"/>`;
+        })() : '';
+        const label = n.w * s > 44 && n.d * s > 18 && n.kind !== 'ramp' ? `<text class="an" x="${X(n.x) + 5}" y="${Z(n.z) + 14}" fill="${dark(fill) ? '#fff' : pal.ink}">${esc(cut(n.name, Math.max(4, Math.floor((n.w * s) / 7.5))))}</text>` : '';
+        return `<g><title>${esc(`${n.name} (${n.kind}${n.y[0] || n.y[1] ? `, ${n.y[0] === n.y[1] ? n.y[0] : `${n.y[0]}–${n.y[1]}`} m up` : ''})${n.landmark ? ` · landmark: ${n.landmark}` : ''}`)}</title>${r}${arrow}${label}</g>`;
+    });
+    const doors = p.doors.map(([x1, z1, x2, z2]) => `<path class="door" d="M${X(x1)} ${Z(z1)}L${X(x2)} ${Z(z2)}" stroke="${pal.accent}"/>`);
+    const walls = p.walls.map((w) => {
+        const seg = [];
+        const cuts = [...w.gaps].sort((a, b) => a[0] - b[0]);
+        let t = 0;
+        const at = (u) => [w.from[0] + (w.to[0] - w.from[0]) * u, w.from[1] + (w.to[1] - w.from[1]) * u];
+        for (const [g0, g1] of [...cuts, [1, 1]]) {
+            if (g0 > t) {
+                const [a, b] = at(t), [c, d] = at(Math.min(1, g0));
+                seg.push(`M${X(a)} ${Z(b)}L${X(c)} ${Z(d)}`);
+            }
+            t = Math.max(t, g1);
+        }
+        return `<path class="wr" d="${seg.join('')}" stroke="${pal.trim}"><title>${esc(w.name)}</title></path>`;
+    });
+    const route = p.path.length > 1 ? `<path class="crit" d="${p.path.map(([x, z], i) => `${i ? 'L' : 'M'}${X(x)} ${Z(z)}`).join('')}"/>` : '';
+    const looks = p.looks.map((m) => {
+        const a = (m.rot * Math.PI) / 180, vx = -Math.sin(a), vz = -Math.cos(a), L = 2.6;
+        const px = -vz, pz = vx, half = 0.9;
+        return `<path class="cone" d="M${X(m.x)} ${Z(m.z)}L${X(m.x + vx * L + px * half)} ${Z(m.z + vz * L + pz * half)}L${X(m.x + vx * L - px * half)} ${Z(m.z + vz * L - pz * half)}z"><title>${esc(`${m.kind === 'spawn' ? 'the player faces this way at the start' : `${m.kind} ${m.name}: look here`}`)}</title></path>`;
+    });
+    const pins = p.markers.map((m) => `<g class="pin ${esc(m.kind)}"><title>${esc(`${m.kind} ${m.name}`)}</title><circle cx="${X(m.x)}" cy="${Z(m.z)}" r="9"/><text x="${X(m.x)}" y="${Z(m.z) + 4}" text-anchor="middle">${GLYPH[m.kind] ?? '·'}</text></g>`);
+    const w = Math.ceil(W * s), h = Math.ceil(D * s);
+    return `<svg class="lm-svg plan" viewBox="0 0 ${w} ${h}" width="${w}" role="img" aria-label="${esc(`The plan of ${p.name} from above, north up${p.path.length > 1 ? ', the route from the spawn to the exit drawn' : ''}`)}">`
+        + `<defs><marker id="lm-up" viewBox="0 0 10 10" refX="6" refY="5" markerWidth="5" markerHeight="5" orient="auto"><path d="M0 0L10 5L0 10z" fill="${pal.ink}"/></marker></defs>`
+        + `<rect class="ground" x="0" y="0" width="${w}" height="${h}"/>` + nodes.join('') + walls.join('') + doors.join('') + looks.join('') + route + pins.join('') + '</svg>';
+}
+export const LEVEL_MAP_CSS = `.lm{margin:18px 0 8px}.lm h3{margin:0 0 6px}.lm .lmw{overflow-x:auto;background:var(--card);border:1px solid var(--rule);border-radius:14px;padding:8px;margin:8px 0}
+.lm-svg{display:block;height:auto;margin:0 auto;font-family:system-ui,sans-serif}.lm-svg.rooms{max-width:none}.lm-svg.plan{max-width:100%}
+.lm .rm rect{fill:var(--bg2);stroke:var(--rule);stroke-width:1.5}.lm .rm.on rect{fill:var(--card);stroke:var(--accent);stroke-width:2.5}.lm .rm.slice rect{stroke-dasharray:0}.lm .rm.off{opacity:.62}
+.lm .nm{font-weight:800;font-size:14.5px;fill:var(--ink)}.lm .sm{font-size:12px;fill:var(--ink2)}.lm .lk{font-size:12px;fill:var(--accent2);font-weight:600}.lm .tag{font-size:10.5px;font-weight:800;letter-spacing:.08em;text-transform:uppercase;fill:var(--accent)}
+.lm .ch{font-size:12px;font-weight:800;letter-spacing:.12em;text-transform:uppercase;fill:var(--ink2);paint-order:stroke;stroke:var(--card);stroke-width:6px;stroke-linejoin:round}
+.lm .rt{fill:none;stroke:var(--ink2);stroke-width:1.6;stroke-dasharray:5 5}.lm .rt.order{stroke-dasharray:2 5}.lm .rt.crit{stroke:var(--accent);stroke-width:3.2;stroke-dasharray:0}
+.lm .ah{fill:var(--ink2)}.lm .ah.crit{fill:var(--accent)}.lm .end rect{fill:var(--accent)}.lm .end text{fill:#fff;font-weight:800;font-size:13px}
+.lm .ground{fill:var(--bg2)}.lm .ar{stroke-width:1.2}.lm .ar.walled{stroke-width:3}.lm .ar.platform{stroke-dasharray:4 3}.lm .an{font-size:11.5px;font-weight:700;opacity:.85}
+.lm .door{stroke-width:4;stroke-linecap:round}.lm .wr{fill:none;stroke-width:3;stroke-linecap:round}.lm .up{stroke-width:1.6}
+.lm path.crit{fill:none;stroke:var(--accent);stroke-width:4;stroke-linejoin:round;stroke-linecap:round;stroke-dasharray:9 6}
+.lm .cone{fill:var(--accent2);opacity:.35}.lm .pin circle{fill:var(--card);stroke:var(--ink);stroke-width:1.5}.lm .pin text{font-size:11px;font-weight:800;fill:var(--ink)}
+.lm .pin.spawn circle{fill:var(--go);stroke:var(--go)}.lm .pin.exit circle{fill:var(--accent);stroke:var(--accent)}.lm .pin.spawn text,.lm .pin.exit text{fill:#fff}
+.lm .key{display:flex;flex-wrap:wrap;gap:6px 14px;font-size:13px;color:var(--ink2);margin:4px 0 0;padding:0;list-style:none}.lm .key li{margin:0}
+.lm .key i{display:inline-block;width:18px;height:0;border-top:3px solid var(--accent);vertical-align:middle;margin-right:5px}.lm .key i.side{border-top:2px dashed var(--ink2)}
+.lm .looks{font-size:14px}.lm .looks li{margin-bottom:3px}`;
+export function levelMapHtml(m) {
+    if (!hasLevelMap(m))
+        return '';
+    const parts = [];
+    if (m.rooms) {
+        const r = m.rooms;
+        const names = new Map(r.rooms.map((x) => [x.id, x.name]));
+        const looks = r.rooms.filter((x) => x.look);
+        const side = r.rooms.filter((x) => !x.onPath);
+        parts.push(`<div class="lm-c"><h3>The campaign</h3><p>${r.rooms.length} room${r.rooms.length === 1 ? '' : 's'} from ${esc(r.files.join(', '))}. The critical path: ${esc(r.path.map((id) => names.get(id) ?? id).join(' → '))}${r.reachesEnd ? ' → the end' : ` (it stops at ${esc(names.get(r.path[r.path.length - 1]) ?? '')}: no way on to the end)`}.${side.length ? ` Off the path: ${esc(side.map((x) => x.name).join(', '))}.` : ''}</p>`
+            + `<div class="lmw">${roomsSvg(r)}</div><ul class="key"><li><i></i>the critical path</li><li><i class="side"></i>another way out</li>${r.rooms.some((x) => x.byOrder) ? '<li>dotted: the next room in order (the room names no exit)</li>' : ''}${looks.length ? '<li>◉ where the player should look</li>' : ''}</ul>`
+            + (looks.length ? `<ul class="looks">${looks.map((x) => `<li><b>${esc(x.name)}</b>: ${esc(x.look)}</li>`).join('')}</ul>` : '') + '</div>');
+    }
+    for (const p of m.plans) {
+        const looks = p.looks.filter((x) => x.kind !== 'spawn');
+        const marks = p.nodes.filter((n) => n.landmark);
+        const spawn = p.looks.find((x) => x.kind === 'spawn');
+        const said = p.path.length > 1 ? 'The route from the spawn to the exit, through the doors and open ground as the data lays them out, is drawn dashed.' : p.markers.some((x) => x.kind === 'spawn') && p.markers.some((x) => x.kind === 'exit') ? '' : 'The data has no spawn and exit to route between.';
+        parts.push(`<div class="lm-p"><h3>${esc(p.name)} from above</h3><p>${esc(p.file)}: ${p.nodes.length} place${p.nodes.length === 1 ? '' : 's'}, ${p.markers.length} marker${p.markers.length === 1 ? '' : 's'}; north up. ${said}${p.gaps.length ? ` No way found from ${esc(p.gaps.join('; from '))} without a jump: <code>npx @funpixel/tools reach</code> measures it with the game's own jump.` : ''}</p>`
+            + `<div class="lmw">${planSvg(p)}</div><ul class="key"><li><b>S</b> spawn</li><li><b>E</b> exit</li>${p.markers.some((x) => x.kind === 'checkpoint') ? '<li><b>C</b> checkpoint</li>' : ''}${p.markers.some((x) => x.kind === 'pickup') ? '<li><b>★</b> pickup</li>' : ''}${p.markers.some((x) => x.kind === 'enemy') ? '<li><b>!</b> enemy</li>' : ''}${p.looks.length ? '<li>shaded wedge: where the player looks</li>' : ''}<li>accent strokes: doors</li></ul>`
+            + (looks.length || marks.length || spawn ? `<ul class="looks">${spawn ? `<li>At the start the player faces ${esc(compass(spawn.rot))}.</li>` : ''}${looks.map((x) => `<li><b>${esc(x.name)}</b> (${esc(x.kind)}): looks ${esc(compass(x.rot))}</li>`).join('')}${marks.map((n) => `<li><b>${esc(n.name)}</b>: ${esc(n.landmark)}</li>`).join('')}</ul>` : '') + '</div>');
+    }
+    return `<div class="lm" id="level-map">${parts.join('')}</div>`;
+}
+function compass(rot) {
+    const a = ((-rot % 360) + 360) % 360;
+    return ['north', 'north-east', 'east', 'south-east', 'south', 'south-west', 'west', 'north-west'][Math.round(a / 45) % 8];
+}