@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/world/forge.js

@@ -0,0 +1,542 @@
+import { createHash } from 'node:crypto';
+import { rng } from "../studio/widen.js";
+import { ROLES, SOLID_ROLES, stringify, WORLD_FORMAT, WORLD_VERSION, TILE, } from "./format.js";
+export const SHAPES_2D = ['hall', 'pillars', 'cave', 'cross', 'split', 'ring'];
+export const SHAPES_3D = ['rolling', 'terraced', 'basin', 'ridge', 'plateau', 'dunes'];
+export const BUDGETS = { '2d': { instances: 60, draw_calls: 24 }, '3d': { instances: 160, draw_calls: 32, lod_far: 40 } };
+export const MAX_ROOMS = 64;
+export const SPLIT_CELLS = 6000;
+const between = (r, lo, hi) => lo + r() * (hi - lo);
+const int = (r, lo, hi) => Math.floor(between(r, lo, hi + 1 - 1e-9));
+const pick = (r, xs) => xs[Math.floor(r() * xs.length)];
+const round = (n, d = 2) => { const v = Number(n.toFixed(d)); return Object.is(v, -0) ? 0 : v; };
+const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+function grammarOf(r, kind, brief) {
+    const all = kind === '2d' ? SHAPES_2D : SHAPES_3D;
+    const liked = brief.shapes.filter((s) => all.includes(s));
+    const weights = all.map((s) => round(r() ** 2 * (liked.includes(s) ? 3 : liked.length ? 0.3 : 1), 3));
+    const base = kind === '2d' ? [int(r, 10, 16), int(r, 8, 12)] : [int(r, 14, 20), int(r, 14, 20)];
+    return {
+        shapes: [...all], weights,
+        min_size: base, max_size: [base[0] + int(r, 2, 12), base[1] + int(r, 2, 8)],
+        density: round(between(r, 0.04, 0.3)), hazard: kind === '2d' ? round(between(r, 0, 0.1)) : 0,
+        pickups: int(r, 1, 4), branching: round(between(r, 0.1, 0.45)), loops: int(r, 0, 2), secret: r() < 0.6 ? 1 : 0,
+        dress: round(between(r, 0.03, 0.14)), cluster: round(r()), hue: int(r, 0, 359), chapter_turn: int(r, 20, 75),
+        amplitude: kind === '3d' ? round(between(r, 1, 6)) : 0, frequency: kind === '3d' ? round(between(r, 0.08, 0.25)) : 0, octaves: kind === '3d' ? int(r, 1, 3) : 0,
+    };
+}
+function weighted(r, names, w) {
+    const total = w.reduce((a, b) => a + b, 0) || 1;
+    let x = r() * total;
+    for (let i = 0; i < names.length; i++) {
+        x -= w[i];
+        if (x <= 0)
+            return names[i];
+    }
+    return names[names.length - 1];
+}
+function graphOf(r, g, n, brief) {
+    const side = n >= 4 ? Math.round((n - 2) * g.branching) : 0;
+    const main = n - side;
+    const named = brief.chapters.slice(0, main);
+    const count = named.length || clamp(Math.round(main / between(r, 2, 3.2)), 1, main);
+    const nodes = [];
+    for (let i = 0; i < main; i++) {
+        nodes.push({ id: `r${i + 1}`, chapter: Math.min(count - 1, Math.floor((i * count) / main)), role: i === 0 ? 'arrival' : i === main - 1 ? 'goal' : 'path', map: [i, 0] });
+    }
+    const edges = [];
+    const edge = (from, to, kind) => edges.push({ id: `e${edges.length + 1}`, from, to, kind });
+    for (let i = 1; i < main; i++)
+        edge(nodes[i - 1].id, nodes[i].id, 'door');
+    const taken = new Set(nodes.map((x) => x.map.join(',')));
+    for (let s = 0; s < side; s++) {
+        const parent = int(r, 0, Math.max(0, main - 1 - (main > 2 ? 1 : 0)));
+        const dy = [1, -1, 2, -2, 3, -3].find((d) => !taken.has(`${parent},${d}`)) ?? side + s;
+        const secret = s === 0 && g.secret === 1;
+        const node = { id: `r${main + s + 1}`, chapter: nodes[parent].chapter, role: secret ? 'secret' : 'side', map: [parent, dy], parent };
+        taken.add(node.map.join(','));
+        nodes.push(node);
+        edge(nodes[parent].id, node.id, secret ? 'secret' : 'door');
+    }
+    for (let k = 0; k < g.loops && main >= 3; k++) {
+        const i = int(r, 0, main - 3);
+        if (!edges.some((e) => e.from === nodes[i].id && e.to === nodes[i + 2].id))
+            edge(nodes[i].id, nodes[i + 2].id, 'loop');
+    }
+    const chapters = Array.from({ length: count }, (_, c) => ({
+        id: `c${c + 1}`, name: named[c]?.name ?? `Chapter ${c + 1}`,
+        rooms: nodes.filter((x) => x.chapter === c).map((x) => x.id), ...(named[c]?.landmark ? { landmark: named[c].landmark } : {}),
+    }));
+    return { nodes, edges, chapters, critical: nodes.slice(0, main).map((x) => x.id) };
+}
+function doorSides(node, nodes, edges) {
+    const at = new Map(nodes.map((x) => [x.id, x]));
+    return edges.filter((e) => e.from === node.id || e.to === node.id).map((e) => {
+        const other = at.get(e.from === node.id ? e.to : e.from);
+        const dx = other.map[0] - node.map[0], dy = other.map[1] - node.map[1];
+        const side = e.kind === 'loop' ? (node.map[1] <= 0 ? 'N' : 'S') : dy === 0 ? (dx < 0 ? 'W' : 'E') : dx === 0 ? (dy > 0 ? 'S' : 'N') : dy > 0 ? 'S' : 'N';
+        return { edge: e, to: other.id, side };
+    });
+}
+function doorCells(sides, cols, rows) {
+    const out = [];
+    for (const s of ['N', 'S', 'E', 'W']) {
+        const on = sides.filter((d) => d.side === s);
+        on.forEach((d, j) => {
+            const len = s === 'N' || s === 'S' ? cols : rows;
+            const off = clamp(Math.round(((j + 1) * (len - 1)) / (on.length + 1)), 1, len - 2);
+            const at = s === 'N' ? [off, 0] : s === 'S' ? [off, rows - 1] : s === 'W' ? [0, off] : [cols - 1, off];
+            const inward = s === 'N' ? [off, 1] : s === 'S' ? [off, rows - 2] : s === 'W' ? [1, off] : [cols - 2, off];
+            out.push({ id: d.edge.id, to: d.to, kind: d.edge.kind, at, inward, side: s });
+        });
+    }
+    return out.sort((a, b) => a.id.localeCompare(b.id, 'en', { numeric: true }));
+}
+function lPath(r, a, b) {
+    const out = [[a[0], a[1]]];
+    let [x, y] = a;
+    const horizontalFirst = r() < 0.5;
+    const stepX = () => { while (x !== b[0]) {
+        x += Math.sign(b[0] - x);
+        out.push([x, y]);
+    } };
+    const stepY = () => { while (y !== b[1]) {
+        y += Math.sign(b[1] - y);
+        out.push([x, y]);
+    } };
+    if (horizontalFirst) {
+        stepX();
+        stepY();
+    }
+    else {
+        stepY();
+        stepX();
+    }
+    return out;
+}
+const interior = (r, cols, rows, xs = [1, cols - 2]) => [int(r, xs[0], xs[1]), int(r, 1, rows - 2)];
+const far = (r, from, cols, rows, tries = 14) => {
+    let best = [from[0] === 1 ? 2 : 1, from[1]], d = 0;
+    for (let i = 0; i < tries; i++) {
+        const c = interior(r, cols, rows);
+        const dd = Math.abs(c[0] - from[0]) + Math.abs(c[1] - from[1]);
+        if (dd > d) {
+            d = dd;
+            best = c;
+        }
+    }
+    return best;
+};
+function kindsFor(r, props, role, maxKinds) {
+    const own = props.filter((p) => p.role === role).map((p) => p.kind);
+    if (!props.length)
+        return [role];
+    if (!own.length)
+        return role === 'dressing' ? props.filter((p) => !SOLID_ROLES.includes(p.role) && p.role !== 'light').map((p) => p.kind).slice(0, 1) : [];
+    const shuffled = [...own];
+    for (let i = shuffled.length - 1; i > 0; i--) {
+        const j = Math.floor(r() * (i + 1));
+        [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+    }
+    return shuffled.slice(0, Math.max(1, Math.min(own.length, maxKinds)));
+}
+export function estimate(instances, kind, arrival, lodFar) {
+    const kinds = new Set(instances.map((i) => i.kind)).size;
+    const lights = instances.filter((i) => i.role === 'light').length;
+    const e = { instances: instances.length, kinds, lights, draw_calls: 1 + kinds + lights };
+    if (kind === '3d' && lodFar) {
+        const farOnes = instances.filter((i) => Math.hypot(i.pos[0] - arrival[0], i.pos[2] - arrival[2]) > lodFar).length;
+        e.lod = { near: instances.length - farOnes, far: farOnes };
+    }
+    return e;
+}
+const hex = (h, s, l) => {
+    const k = (n) => (n + h / 30) % 12, a = s * Math.min(l, 1 - l);
+    const f = (n) => Math.round(255 * (l - a * Math.max(-1, Math.min(k(n) - 3, 9 - k(n), 1))));
+    return `#${[f(0), f(8), f(4)].map((v) => v.toString(16).padStart(2, '0')).join('')}`;
+};
+export function hueOf(c) {
+    const [r, g, b] = [1, 3, 5].map((i) => parseInt(c.slice(i, i + 2), 16) / 255);
+    const mx = Math.max(r, g, b), mn = Math.min(r, g, b), d = mx - mn;
+    if (!d)
+        return 0;
+    const h = mx === r ? ((g - b) / d) % 6 : mx === g ? (b - r) / d + 2 : (r - g) / d + 4;
+    return Math.round(((h * 60) + 360) % 360);
+}
+const darken = (c, f) => `#${[1, 3, 5].map((i) => Math.round(parseInt(c.slice(i, i + 2), 16) * f).toString(16).padStart(2, '0')).join('')}`;
+function atmosphereOf(r, g, kind, palette) {
+    const hue = palette[0] ? hueOf(palette[0]) : g.hue;
+    const sky = palette[1] ?? hex(hue, 0.45, 0.62);
+    const unit = kind === '3d' ? 1 : 0.25;
+    return {
+        sky, fog: { color: darken(palette[0] ?? sky, 0.55), near: round(between(r, 8, 20) * unit, 1), far: round(between(r, 50, 120) * unit, 1) },
+        light: { color: hex((hue + 35) % 360, 0.6, 0.86), intensity: round(between(r, 0.9, 1.3)) },
+        ambient: round(between(r, 0.35, 0.55)),
+    };
+}
+function roomAtmosphere(r, g, base, chapter, role) {
+    const out = {};
+    if (chapter > 0) {
+        const hue = (hueOf(base.sky) + chapter * g.chapter_turn) % 360;
+        out.sky = hex(hue, 0.45, 0.6 - 0.04 * (chapter % 3));
+        out.fog = { ...base.fog, color: darken(out.sky, 0.55) };
+    }
+    if (role === 'secret') {
+        out.fog = { ...(out.fog ?? base.fog), near: round(base.fog.near * 0.5, 1), far: round(base.fog.far * 0.6, 1) };
+        out.light = { ...base.light, intensity: round(base.light.intensity * 0.7) };
+        out.ambient = Math.max(0.35, round(base.ambient - 0.08));
+    }
+    else if (role === 'goal') {
+        out.light = { color: hex(int(r, 25, 45), 0.75, 0.82), intensity: round(base.light.intensity * 1.15) };
+    }
+    else if (role === 'side') {
+        out.light = { ...base.light, color: hex((hueOf(base.light.color) + int(r, -25, 25) + 360) % 360, 0.55, 0.86) };
+    }
+    return out;
+}
+class Cells {
+    list;
+    at = new Map();
+    constructor(cells) { this.list = [...cells]; this.list.forEach((c, i) => this.at.set(c.join(','), i)); }
+    get size() { return this.list.length; }
+    has(c) { return this.at.has(c.join(',')); }
+    take(c) {
+        const i = this.at.get(c.join(','));
+        if (i === undefined)
+            return;
+        const last = this.list.pop();
+        this.at.delete(c.join(','));
+        if (i < this.list.length) {
+            this.list[i] = last;
+            this.at.set(last.join(','), i);
+        }
+    }
+}
+function scatter(r, g, pool, count) {
+    if (!pool.size || count <= 0)
+        return [];
+    const centres = Array.from({ length: Math.max(1, Math.round(count / 6)) }, () => pick(r, pool.list));
+    const out = [];
+    for (let i = 0; i < count * 3 && out.length < count && pool.size; i++) {
+        let c;
+        if (r() < g.cluster) {
+            const o = pick(r, centres);
+            c = [o[0] + int(r, -3, 3), o[1] + int(r, -3, 3)];
+        }
+        else
+            c = pick(r, pool.list);
+        if (!pool.has(c))
+            continue;
+        pool.take(c);
+        out.push(c);
+    }
+    return out;
+}
+function room2d(r, g, node, sides, props, budget, landmark) {
+    const cols = int(r, g.min_size[0], g.max_size[0]), rows = int(r, g.min_size[1], g.max_size[1]);
+    const shape = weighted(r, g.shapes, g.weights);
+    const grid = Array.from({ length: rows }, (_, y) => Array.from({ length: cols }, (_, x) => (x === 0 || y === 0 || x === cols - 1 || y === rows - 1 ? TILE.solid : TILE.floor)));
+    const inside = (x, y) => x > 0 && y > 0 && x < cols - 1 && y < rows - 1;
+    const set = (x, y, c) => { if (inside(x, y))
+        grid[y][x] = c; };
+    const area = (cols - 2) * (rows - 2);
+    if (shape === 'hall') {
+        for (let i = 0; i < Math.round((area * g.density) / 3); i++) {
+            const [x, y] = interior(r, cols, rows);
+            const s = r() < 0.4 ? 2 : 1;
+            for (let dy = 0; dy < s; dy++)
+                for (let dx = 0; dx < s; dx++)
+                    set(x + dx, y + dy, TILE.solid);
+        }
+    }
+    else if (shape === 'pillars') {
+        const sx = int(r, 3, 5), sy = int(r, 3, 5), ox = int(r, 0, sx - 1), oy = int(r, 0, sy - 1);
+        for (let y = 2 + oy; y < rows - 2; y += sy)
+            for (let x = 2 + ox; x < cols - 2; x += sx)
+                set(x, y, TILE.solid);
+    }
+    else if (shape === 'cave') {
+        for (let y = 1; y < rows - 1; y++)
+            for (let x = 1; x < cols - 1; x++)
+                grid[y][x] = r() < 0.38 + g.density * 0.3 ? TILE.solid : TILE.floor;
+        for (let pass = 0; pass < 4; pass++) {
+            const next = grid.map((row) => [...row]);
+            for (let y = 1; y < rows - 1; y++)
+                for (let x = 1; x < cols - 1; x++) {
+                    let walls = 0;
+                    for (let dy = -1; dy <= 1; dy++)
+                        for (let dx = -1; dx <= 1; dx++)
+                            if (grid[y + dy][x + dx] === TILE.solid)
+                                walls++;
+                    next[y][x] = walls >= 5 ? TILE.solid : TILE.floor;
+                }
+            grid.splice(0, rows, ...next);
+        }
+    }
+    else if (shape === 'cross') {
+        const w = Math.max(1, Math.floor((cols - 2) * between(r, 0.2, 0.34))), h = Math.max(1, Math.floor((rows - 2) * between(r, 0.2, 0.34)));
+        for (let y = 1; y < rows - 1; y++)
+            for (let x = 1; x < cols - 1; x++)
+                if ((x <= w || x >= cols - 1 - w) && (y <= h || y >= rows - 1 - h))
+                    set(x, y, TILE.solid);
+    }
+    else if (shape === 'split') {
+        const x0 = int(r, Math.floor(cols * 0.35), Math.floor(cols * 0.65)), gap = int(r, 1, rows - 3);
+        for (let y = 1; y < rows - 1; y++)
+            if (y !== gap)
+                set(x0, y, TILE.solid);
+        if (r() < 0.5) {
+            const y0 = int(r, Math.floor(rows * 0.35), Math.floor(rows * 0.65)), gx = int(r, 1, cols - 3);
+            for (let x = 1; x < cols - 1; x++)
+                if (x !== gx && x !== x0)
+                    set(x, y0, TILE.solid);
+        }
+    }
+    else {
+        for (let y = Math.floor(rows * 0.32); y < Math.ceil(rows * 0.68); y++)
+            for (let x = Math.floor(cols * 0.3); x < Math.ceil(cols * 0.7); x++)
+                set(x, y, TILE.solid);
+    }
+    const doors = doorCells(sides, cols, rows);
+    const entry = doors.find((d) => node.parent !== undefined ? d.to === `r${node.parent + 1}` : d.side === 'W' && d.kind === 'door');
+    const arrival = entry ? [clamp(entry.inward[0] + Math.sign(entry.inward[0] - entry.at[0]), 1, cols - 2), clamp(entry.inward[1] + Math.sign(entry.inward[1] - entry.at[1]), 1, rows - 2)] : interior(r, cols, rows, [1, Math.max(1, Math.floor(cols / 3))]);
+    const targets = doors.map((d) => d.inward);
+    const goal = node.role === 'goal' || (node.role === 'arrival' && !doors.some((d) => d.kind === 'door' && d.side === 'E')) ? far(r, arrival, cols, rows) : null;
+    const pickups = Array.from({ length: node.role === 'side' || node.role === 'secret' ? g.pickups + 2 : int(r, 0, g.pickups) }, () => interior(r, cols, rows))
+        .filter((p) => p.join(',') !== arrival.join(',') && p.join(',') !== goal?.join(',') && !doors.some((d) => d.inward.join(',') === p.join(',')));
+    if (goal)
+        targets.push(goal);
+    targets.push(...pickups);
+    const reserved = new Set([arrival.join(',')]);
+    for (const t of targets)
+        for (const [x, y] of lPath(r, arrival, t)) {
+            if (grid[y][x] === TILE.solid || grid[y][x] === TILE.hazard)
+                grid[y][x] = TILE.floor;
+            reserved.add(`${x},${y}`);
+        }
+    for (const d of doors)
+        grid[d.at[1]][d.at[0]] = TILE.door;
+    for (const p of pickups)
+        grid[p[1]][p[0]] = TILE.pickup;
+    if (goal)
+        grid[goal[1]][goal[0]] = TILE.goal;
+    grid[arrival[1]][arrival[0]] = TILE.spawn;
+    for (let y = 1; y < rows - 1; y++)
+        for (let x = 1; x < cols - 1; x++)
+            if (grid[y][x] === TILE.floor && !reserved.has(`${x},${y}`) && r() < g.hazard)
+                grid[y][x] = TILE.hazard;
+    const seen = new Set([arrival.join(',')]);
+    const stack = [arrival];
+    while (stack.length) {
+        const [x, y] = stack.pop();
+        for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {
+            const nx = x + dx, ny = y + dy, k = `${nx},${ny}`;
+            if (inside(nx, ny) && !seen.has(k) && grid[ny][nx] !== TILE.solid && grid[ny][nx] !== TILE.hazard) {
+                seen.add(k);
+                stack.push([nx, ny]);
+            }
+        }
+    }
+    for (let y = 1; y < rows - 1; y++)
+        for (let x = 1; x < cols - 1; x++)
+            if (grid[y][x] === TILE.floor && !seen.has(`${x},${y}`))
+                grid[y][x] = TILE.solid;
+    const free = [];
+    for (let y = 1; y < rows - 1; y++)
+        for (let x = 1; x < cols - 1; x++)
+            if (grid[y][x] === TILE.floor && !reserved.has(`${x},${y}`))
+                free.push([x, y]);
+    const places = [{ name: 'arrival', at: arrival }];
+    if (goal)
+        places.push({ name: 'goal', at: goal });
+    if ((node.role === 'side' || node.role === 'secret') && pickups.length)
+        places.push({ name: 'reward', at: pickups.reduce((a, b) => (Math.abs(b[0] - arrival[0]) + Math.abs(b[1] - arrival[1]) > Math.abs(a[0] - arrival[0]) + Math.abs(a[1] - arrival[1]) ? b : a)) });
+    const instances = dress(r, g, free, props, budget, '2d', 1, () => 0, landmark, places, cols * rows);
+    return { tiles: grid.map((row) => row.join('')), doors: doors.map(({ id, to, at, kind }) => ({ id, to, at, kind })), places, instances, shape, size: [cols, rows] };
+}
+function dress(r, g, free, props, budget, kind, cell, heightAt, landmark, places, area) {
+    const out = [];
+    const pool = new Cells(free);
+    const put = (c, k, role, scale) => {
+        const jx = kind === '3d' ? between(r, -0.3, 0.3) : 0, jy = kind === '3d' ? between(r, -0.3, 0.3) : 0;
+        const pos = kind === '3d' ? [round((c[0] + 0.5 + jx) * cell), heightAt(c[0], c[1]), round((c[1] + 0.5 + jy) * cell)] : [c[0] + 0.5, c[1] + 0.5];
+        out.push({ id: `i${out.length + 1}`, kind: k, role, pos, rot: kind === '3d' ? round(r() * Math.PI * 2, 3) : 0, scale, solid: kind === '3d' && SOLID_ROLES.includes(role) });
+        pool.take(c);
+    };
+    const lights = kindsFor(r, props, 'light', 2);
+    const maxKinds = Math.max(2, budget.draw_calls - 8);
+    if (landmark !== undefined && pool.size) {
+        const lk = kindsFor(r, props, 'landmark', 1)[0] ?? (props.length ? undefined : 'landmark');
+        if (lk) {
+            const c = kind === '3d' ? pool.list.reduce((a, b) => (heightAt(b[0], b[1]) > heightAt(a[0], a[1]) ? b : a)) : pick(r, pool.list);
+            put(c, lk, 'landmark', round(between(r, 2, 3)));
+            places.push({ name: 'landmark', at: out[out.length - 1].pos, ...(landmark ? { label: landmark } : {}) });
+        }
+    }
+    if (lights.length)
+        for (let i = 0, n = int(r, 1, kind === '3d' ? 4 : 3); i < n && pool.size && out.length < budget.instances; i++)
+            put(pick(r, pool.list), pick(r, lights), 'light', 1);
+    const cover = kindsFor(r, props, 'cover', Math.ceil(maxKinds / 2));
+    const dressing = kindsFor(r, props, 'dressing', int(r, 2, Math.max(2, maxKinds - cover.length)));
+    const count = Math.min(budget.instances - out.length, Math.round(area * g.dress * (kind === '3d' ? 0.5 : 1)));
+    for (const c of scatter(r, g, pool, count)) {
+        const useCover = cover.length && (r() < 0.3 || !dressing.length);
+        if (!useCover && !dressing.length)
+            break;
+        put(c, useCover ? pick(r, cover) : pick(r, dressing), useCover ? 'cover' : 'dressing', round(between(r, 0.8, 1.25)));
+    }
+    return out;
+}
+function noise(r, cols, rows, freq, octaves) {
+    const out = Array.from({ length: rows }, () => new Array(cols).fill(0));
+    let amp = 1, total = 0;
+    for (let o = 0; o < octaves; o++, amp /= 2, freq *= 2) {
+        const step = Math.max(2, Math.round(1 / freq));
+        const lw = Math.ceil(cols / step) + 2, lh = Math.ceil(rows / step) + 2;
+        const lattice = Array.from({ length: lh }, () => Array.from({ length: lw }, () => r()));
+        const s = (t) => t * t * (3 - 2 * t);
+        for (let y = 0; y < rows; y++)
+            for (let x = 0; x < cols; x++) {
+                const gx = x / step, gy = y / step, x0 = Math.floor(gx), y0 = Math.floor(gy), tx = s(gx - x0), ty = s(gy - y0);
+                const a = lattice[y0][x0] + (lattice[y0][x0 + 1] - lattice[y0][x0]) * tx;
+                const b = lattice[y0 + 1][x0] + (lattice[y0 + 1][x0 + 1] - lattice[y0 + 1][x0]) * tx;
+                out[y][x] += amp * (a + (b - a) * ty);
+            }
+        total += amp;
+    }
+    return out.map((row) => row.map((v) => v / total));
+}
+function room3d(r, g, node, sides, props, budget, cell, step, landmark) {
+    const cols = int(r, g.min_size[0], g.max_size[0]), rows = int(r, g.min_size[1], g.max_size[1]);
+    const shape = weighted(r, g.shapes, g.weights);
+    const n = noise(r, cols, rows, g.frequency, g.octaves);
+    const A = g.amplitude, levels = int(r, 2, 4), phase = r() * 6.28;
+    const h = n.map((row, y) => row.map((v, x) => round((() => {
+        const d = Math.hypot((x - cols / 2) / (cols / 2), (y - rows / 2) / (rows / 2));
+        switch (shape) {
+            case 'terraced': return Math.round((v * A) / (A / levels)) * (A / levels);
+            case 'basin': return v * A * 0.5 + A * 0.8 * d * d;
+            case 'ridge': return A * (1 - Math.abs(2 * v - 1));
+            case 'plateau': return Math.min(v * A * 1.4, A * 0.6);
+            case 'dunes': return A * 0.3 * (1 + Math.sin(x * g.frequency * 3 + phase)) + v * A * 0.4;
+            default: return v * A;
+        }
+    })())));
+    const doors = doorCells(sides, cols, rows);
+    const entry = doors.find((d) => node.parent !== undefined ? d.to === `r${node.parent + 1}` : d.side === 'W' && d.kind === 'door');
+    const arrival = entry ? [...entry.inward] : interior(r, cols, rows, [1, Math.max(1, Math.floor(cols / 3))]);
+    const goal = node.role === 'goal' || (node.role === 'arrival' && !doors.some((d) => d.kind === 'door' && d.side === 'E')) ? far(r, arrival, cols, rows) : null;
+    const reward = node.role === 'side' || node.role === 'secret' ? far(r, arrival, cols, rows) : null;
+    const ways = doors.map((d) => [...lPath(r, arrival, d.inward), d.at]);
+    if (goal)
+        ways.push(lPath(r, arrival, goal));
+    if (reward)
+        ways.push(lPath(r, arrival, reward));
+    const reserved = new Set([arrival.join(',')]);
+    const s = round(step * 0.9);
+    for (const way of ways)
+        for (let i = 1; i < way.length; i++) {
+            const [x, y] = way[i], [px, py] = way[i - 1], k = `${x},${y}`;
+            if (!reserved.has(k))
+                h[y][x] = round(clamp(h[y][x], h[py][px] - s, h[py][px] + s));
+            reserved.add(k);
+        }
+    const heights = h;
+    const free = [];
+    for (let y = 0; y < rows; y++)
+        for (let x = 0; x < cols; x++)
+            if (!reserved.has(`${x},${y}`))
+                free.push([x, y]);
+    const at = (c) => [round((c[0] + 0.5) * cell), heights[c[1]][c[0]], round((c[1] + 0.5) * cell)];
+    const places = [{ name: 'arrival', at: at(arrival) }];
+    if (goal)
+        places.push({ name: 'goal', at: at(goal) });
+    if (reward)
+        places.push({ name: 'reward', at: at(reward) });
+    const instances = dress(r, g, free, props, budget, '3d', cell, (x, y) => heights[y][x], landmark, places, cols * rows);
+    const blocked = new Set(instances.filter((i) => i.solid).map((i) => `${Math.floor(i.pos[0] / cell)},${Math.floor(i.pos[2] / cell)}`));
+    const reach = flood3d(heights, arrival, step, blocked);
+    let vista = arrival;
+    for (const k of reach) {
+        const [x, y] = k.split(',').map(Number);
+        if (heights[y][x] > heights[vista[1]][vista[0]])
+            vista = [x, y];
+    }
+    places.push({ name: 'vista', at: at(vista) });
+    return { heights: { cols, rows, cell, heights }, doors: doors.map(({ id, to, at: a, kind }) => ({ id, to, at: a, kind })), places, instances, shape, size: [cols, rows] };
+}
+export function flood3d(h, from, step, blocked) {
+    const rows = h.length, cols = h[0]?.length ?? 0;
+    const seen = new Set();
+    if (blocked.has(from.join(',')))
+        return seen;
+    seen.add(from.join(','));
+    const stack = [from];
+    while (stack.length) {
+        const [x, y] = stack.pop();
+        for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {
+            const nx = x + dx, ny = y + dy, k = `${nx},${ny}`;
+            if (nx < 0 || ny < 0 || nx >= cols || ny >= rows || seen.has(k) || blocked.has(k))
+                continue;
+            if (Math.abs(h[ny][nx] - h[y][x]) > step + 1e-9)
+                continue;
+            seen.add(k);
+            stack.push([nx, ny]);
+        }
+    }
+    return seen;
+}
+export function fingerprintOf(world) {
+    return createHash('sha256').update(stringify({ ...world, fingerprint: '' })).digest('hex');
+}
+export function forge(opts) {
+    const r = rng(opts.seed);
+    const { kind, brief } = opts;
+    const g = grammarOf(r, kind, brief);
+    const n = clamp(opts.rooms ?? brief.rooms ?? (brief.chapters.length ? Math.max(brief.chapters.length * 2, 4) : int(r, 5, 9)), 1, MAX_ROOMS);
+    const { nodes, edges, chapters, critical } = graphOf(r, g, n, brief);
+    const budgets = { ...BUDGETS[kind] };
+    const cell = kind === '3d' ? 2 : 1;
+    const step = brief.step ?? 0.6;
+    const base = atmosphereOf(r, g, kind, brief.palette);
+    const heights = {};
+    const firstOfChapter = new Set(chapters.map((c) => c.rooms[0]));
+    const rooms = nodes.map((node) => {
+        const sides = doorSides(node, nodes, edges);
+        const ch = chapters[node.chapter];
+        const landmark = firstOfChapter.has(node.id) ? (ch.landmark ?? '') : undefined;
+        const b = kind === '3d' ? room3d(r, g, node, sides, brief.props, BUDGETS['3d'], cell, step, landmark) : room2d(r, g, node, sides, brief.props, BUDGETS['2d'], landmark);
+        const arrival = b.places.find((p) => p.name === 'arrival').at;
+        const room = {
+            id: node.id, chapter: ch.id, role: node.role, map: node.map, shape: b.shape, size: b.size,
+            ...(kind === '2d' ? { view: 'top', tiles: b.tiles } : { heights: `rooms/${node.id}.heights.json` }),
+            doors: b.doors, places: b.places, instances: b.instances,
+            atmosphere: roomAtmosphere(r, g, base, node.chapter, node.role),
+            estimate: estimate(b.instances, kind, arrival, kind === '3d' ? BUDGETS['3d'].lod_far : undefined),
+        };
+        if (b.heights)
+            heights[node.id] = b.heights;
+        return room;
+    });
+    const files = {};
+    if (kind === '2d' && rooms.reduce((a, x) => a + x.size[0] * x.size[1], 0) > SPLIT_CELLS) {
+        for (const room of rooms) {
+            files[`rooms/${room.id}.json`] = stringify({ id: room.id, tiles: room.tiles }) + '\n';
+            room.file = `rooms/${room.id}.json`;
+            delete room.tiles;
+        }
+    }
+    for (const [id, hf] of Object.entries(heights))
+        files[`rooms/${id}.heights.json`] = stringify(hf) + '\n';
+    const world = {
+        format: WORLD_FORMAT, version: WORLD_VERSION, kind, seed: opts.seed, fingerprint: '',
+        brief: { from: brief.from, title: brief.title }, grammar: g, cell,
+        ...(kind === '3d' ? { movement: { step } } : {}),
+        props: brief.props.length ? brief.props : ROLES.map((role) => ({ kind: role, role })),
+        ...(kind === '2d' ? { legend: { '#': 'solid', '.': 'floor', '^': 'hazard', S: 'arrival', G: 'goal', '*': 'pickup', D: 'door' } } : {}),
+        atmosphere: base, budgets, chapters, rooms, edges, critical_path: critical,
+    };
+    world.fingerprint = fingerprintOf(world);
+    files['world.json'] = stringify(world) + '\n';
+    return { world, heights, files };
+}

package/dist/world/format.js

@@ -0,0 +1,40 @@
+export const WORLD_DIR = 'design/world';
+export const WORLD_FILE = `${WORLD_DIR}/world.json`;
+export const WORLD_FORMAT = 'funpixel-world';
+export const WORLD_VERSION = 1;
+export const TILE = { solid: '#', floor: '.', hazard: '^', spawn: 'S', goal: 'G', pickup: '*', door: 'D' };
+export const LEGEND = {
+    '#': 'solid', '.': 'empty', '^': 'hazard', S: 'spawn', G: 'exit', '*': 'pickup', D: 'exit',
+};
+export const ROLES = ['cover', 'landmark', 'light', 'dressing', 'marker'];
+export const SOLID_ROLES = ['cover', 'landmark'];
+export function stringify(v, indent = '') {
+    const inner = indent + '  ';
+    if (v === null || typeof v !== 'object')
+        return JSON.stringify(v);
+    if (Array.isArray(v)) {
+        if (!v.length)
+            return '[]';
+        if (v.every(small)) {
+            const one = `[${v.map((x) => (x !== null && typeof x === 'object' ? stringify(x) : JSON.stringify(x))).join(', ')}]`;
+            const flat = v.every((x) => x === null || typeof x !== 'object');
+            if (flat ? v.every((x) => typeof x === 'number') || one.length <= 72 : one.length <= 100)
+                return one;
+        }
+        return `[\n${v.map((x) => inner + stringify(x, inner)).join(',\n')}\n${indent}]`;
+    }
+    const entries = Object.entries(v).filter(([, x]) => x !== undefined);
+    if (!entries.length)
+        return '{}';
+    if (small(v)) {
+        const one = `{ ${entries.map(([k, x]) => `${JSON.stringify(k)}: ${stringify(x)}`).join(', ')} }`;
+        if (one.length <= 140)
+            return one;
+    }
+    return `{\n${entries.map(([k, x]) => `${inner}${JSON.stringify(k)}: ${stringify(x, inner)}`).join(',\n')}\n${indent}}`;
+}
+function small(v) {
+    if (v === null || typeof v !== 'object')
+        return true;
+    return Object.values(v).every((x) => x === null || typeof x !== 'object' || (Array.isArray(x) && x.every((n) => typeof n === 'number')));
+}

package/dist/world/variety.js

@@ -0,0 +1,59 @@
+import { forge, hueOf } from "./forge.js";
+export const TWIN_BELOW = 0.12;
+const GRID = 6;
+export const PARTS = ['shapes', 'layout', 'grammar', 'light', 'graph'];
+function picture(f, id) {
+    const room = f.world.rooms.find((r) => r.id === id);
+    const cells = room.tiles ? room.tiles.map((t) => [...t].map((c) => (c === '#' ? 1 : 0))) : f.heights[id].heights;
+    const rows = cells.length, cols = cells[0].length;
+    const flat = cells.flat(), lo = Math.min(...flat), span = Math.max(...flat) - lo || 1;
+    const out = [];
+    for (let gy = 0; gy < GRID; gy++)
+        for (let gx = 0; gx < GRID; gx++) {
+            let sum = 0, n = 0;
+            for (let y = Math.floor((gy * rows) / GRID); y < Math.max(Math.floor(((gy + 1) * rows) / GRID), Math.floor((gy * rows) / GRID) + 1); y++)
+                for (let x = Math.floor((gx * cols) / GRID); x < Math.max(Math.floor(((gx + 1) * cols) / GRID), Math.floor((gx * cols) / GRID) + 1); x++) {
+                    sum += (cells[y][x] - lo) / span;
+                    n++;
+                }
+            out.push(n ? sum / n : 0);
+        }
+    return out;
+}
+export function signature(f) {
+    const w = f.world, g = w.grammar;
+    const shapes = new Map();
+    for (const r of w.rooms)
+        shapes.set(r.shape, (shapes.get(r.shape) ?? 0) + 1 / w.rooms.length);
+    const side = w.rooms.filter((r) => r.role === 'side' || r.role === 'secret').length / w.rooms.length;
+    return {
+        seed: w.seed, shapes, layouts: w.rooms.map((r) => picture(f, r.id)),
+        grammar: [g.density / 0.3, g.hazard / 0.1, g.branching / 0.45, g.dress / 0.14, g.cluster, g.amplitude / 6, g.frequency / 0.25].map((v) => Math.min(1, v || 0)),
+        hue: hueOf(w.atmosphere.sky ?? '#000000'),
+        graph: [side, w.edges.filter((e) => e.kind === 'loop').length / 2, w.edges.some((e) => e.kind === 'secret') ? 1 : 0],
+    };
+}
+const meanAbs = (a, b) => (a.length ? a.reduce((s, v, i) => s + Math.abs(v - (b[i] ?? 0)), 0) / a.length : 0);
+export function distance(a, b) {
+    const keys = new Set([...a.shapes.keys(), ...b.shapes.keys()]);
+    const shapes = [...keys].reduce((s, k) => s + Math.abs((a.shapes.get(k) ?? 0) - (b.shapes.get(k) ?? 0)), 0) / 2;
+    const n = Math.min(a.layouts.length, b.layouts.length);
+    const layout = n ? Array.from({ length: n }, (_, i) => meanAbs(a.layouts[i], b.layouts[i])).reduce((x, y) => x + y, 0) / n : 1;
+    const hd = Math.abs(a.hue - b.hue) % 360;
+    const parts = { shapes, layout, grammar: meanAbs(a.grammar, b.grammar), light: Math.min(hd, 360 - hd) / 180, graph: meanAbs(a.graph, b.graph) };
+    const r3 = (v) => Math.round(v * 1000) / 1000;
+    return { ...Object.fromEntries(Object.entries(parts).map(([k, v]) => [k, r3(v)])), overall: r3(PARTS.reduce((s, k) => s + parts[k], 0) / PARTS.length) };
+}
+export function varietyOf(seed, count, kind, brief, rooms) {
+    const seeds = Array.from({ length: count }, (_, i) => (seed + i) >>> 0);
+    const sigs = seeds.map((s) => signature(forge({ seed: s, kind, brief, rooms })));
+    const rows = [];
+    for (let i = 0; i < sigs.length; i++)
+        for (let j = i + 1; j < sigs.length; j++)
+            rows.push({ a: sigs[i].seed, b: sigs[j].seed, d: distance(sigs[i], sigs[j]) });
+    const avg = (k) => (rows.length ? Math.round((rows.reduce((s, r) => s + r.d[k], 0) / rows.length) * 1000) / 1000 : 0);
+    const mean = Object.fromEntries([...PARTS, 'overall'].map((k) => [k, avg(k)]));
+    const sorted = [...rows].sort((x, y) => x.d.overall - y.d.overall);
+    const twins = sorted.filter((r) => r.d.overall < TWIN_BELOW).map((r) => ({ a: r.a, b: r.b, overall: r.d.overall }));
+    return { kind, seeds, pairs: rows.length, mean, closest: sorted[0] ? { a: sorted[0].a, b: sorted[0].b, overall: sorted[0].d.overall } : null, twins, verdict: twins.length ? 'warn' : 'pass' };
+}