Dejvino
6a2af2e45f
One album must not render the same dungeon twice. dungeonTheme() scores the measured summary per theme — pace terms gate on tempoConfidence so doubled detectors never read fast, crypt is penalised for blazing masters — plus small seeded jitter so ambiguous songs vary across seeds while decided races stay decided. The plan carries the theme name; dressing mix, planting/timber/puddle densities follow it, and the facade builds all materials (stone/floor multipliers, torch + light color, wood, fog tint) from the same record. Calibrated bank spread is 4/4/4/4/1 (windswept holds runner); corners stable across seeds; plan reshaping, facade wiring, and murk-vs-clear gates covered by tests.
577 lines
30 KiB
JavaScript
577 lines
30 KiB
JavaScript
import { test } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
|
|
import { Rng } from '../src/engine/rng.js';
|
|
import { genDungeon, dungeonCharacter, dungeonTheme, THEMES, THEME_NAMES, pathAt, roomAt, zoneAt, odometer, entityPose, CELL } from '../src/venues/dungeon/map.js';
|
|
import { PROP_BUILDERS } from '../src/venues/dungeon/props.js';
|
|
import { HAZARD_BUILDERS, avoidanceOffset } from '../src/venues/dungeon/hazards.js';
|
|
import { generateVenue } from '../src/venues/VenueGenerator.js';
|
|
import { generatePersonality } from '../src/look/Personality.js';
|
|
|
|
test('dungeon map is deterministic with rooms, zones and a closed route', () => {
|
|
const a = genDungeon({ seed: 7, rng: new Rng(7) });
|
|
const b = genDungeon({ seed: 7, rng: new Rng(7) });
|
|
assert.deepEqual(a, b, 'same seed must generate the same dungeon');
|
|
assert.ok(a.rooms.length >= 3, `only ${a.rooms.length} rooms`);
|
|
const zones = new Set(a.rooms.map((r) => r.zone));
|
|
assert.ok(zones.size >= 3, `zone coverage thin: ${[...zones].join(',')}`);
|
|
assert.ok(a.route.totalLen > 80, `route too short: ${a.route.totalLen}`);
|
|
// pathAt wraps and is pure.
|
|
const s1 = pathAt(a, 3.7), s2 = pathAt(a, 3.7 + a.route.totalLen);
|
|
assert.deepEqual(s1, s2, 'pathAt must wrap seamlessly');
|
|
assert.ok(Number.isFinite(s1.yaw), 'heading must be finite');
|
|
});
|
|
|
|
test('every room is reachable: BFS over open cells hits all rooms', () => {
|
|
for (const seed of [5, 7, 4242]) {
|
|
const m = genDungeon({ seed, rng: new Rng(seed) });
|
|
const seen = new Set([0]);
|
|
const r0 = m.rooms[0];
|
|
const qx = [r0.x + Math.floor(r0.w / 2)], qy = [r0.y + Math.floor(r0.h / 2)];
|
|
const seenCells = new Set([qy[0] * m.w + qx[0]]);
|
|
const roomOf = new Int16Array(m.w * m.h).fill(-1);
|
|
for (const rm of m.rooms) {
|
|
for (let y = rm.y; y < rm.y + rm.h; y++) {
|
|
for (let x = rm.x; x < rm.x + rm.w; x++) roomOf[y * m.w + x] = rm.id;
|
|
}
|
|
}
|
|
let head = 0;
|
|
while (head < qx.length) {
|
|
const cx = qx[head], cy = qy[head];
|
|
head++;
|
|
if (roomOf[cy * m.w + cx] >= 0) seen.add(roomOf[cy * m.w + cx]);
|
|
for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {
|
|
const nx = cx + dx, ny = cy + dy;
|
|
if (nx < 0 || ny < 0 || nx >= m.w || ny >= m.h) continue;
|
|
if (!m.grid[ny * m.w + nx] || seenCells.has(ny * m.w + nx)) continue;
|
|
seenCells.add(ny * m.w + nx);
|
|
qx.push(nx); qy.push(ny);
|
|
}
|
|
}
|
|
assert.equal(seen.size, m.rooms.length,
|
|
`seed ${seed}: reachable ${seen.size}/${m.rooms.length} rooms`);
|
|
}
|
|
});
|
|
|
|
test('the route only walks open cells and visits every room', () => {
|
|
const m = genDungeon({ seed: 7, rng: new Rng(7) });
|
|
// Route samples sit on open cells (checked at cell granularity).
|
|
for (let s = 0; s < m.route.totalLen; s += 2) {
|
|
const p = pathAt(m, s);
|
|
const cx = Math.floor(p.x / CELL + m.w / 2);
|
|
const cy = Math.floor(p.z / CELL + m.h / 2);
|
|
assert.ok(cx >= 0 && cy >= 0 && cx < m.w && cy < m.h, `route off the grid at s=${s}`);
|
|
assert.ok(m.grid[cy * m.w + cx], `route crosses a solid cell at s=${s.toFixed(1)}`);
|
|
}
|
|
const visited = new Set(m.route.roomIds.filter((id) => id >= 0));
|
|
assert.equal(visited.size, m.rooms.length, 'the tour must enter every room');
|
|
});
|
|
|
|
test('no holes indoors, green edges outdoors: every open edge is walled or planted', () => {
|
|
const m = genDungeon({ seed: 7, rng: new Rng(7) });
|
|
const hRuns = m.wallRuns.filter((r) => r.z0 === r.z1);
|
|
const vRuns = m.wallRuns.filter((r) => r.x0 === r.x1);
|
|
const coveredH = (x, z) => hRuns.some((r) =>
|
|
Math.abs(r.z0 - z) < 1e-6 && x + 1e-6 >= r.x0 && x - 1e-6 <= r.x1);
|
|
const coveredV = (x, z) => vRuns.some((r) =>
|
|
Math.abs(r.x0 - x) < 1e-6 && z + 1e-6 >= r.z0 && z - 1e-6 <= r.z1);
|
|
const plantedNear = (x, z) => m.items.vegetation.some((v) =>
|
|
Math.hypot(v.x - x, v.z - z) < 1.6);
|
|
const w0 = (cx) => (cx - m.w / 2) * CELL; // west edge of cell cx
|
|
const z0 = (cy) => (cy - m.h / 2) * CELL;
|
|
// Indoor-ness is the map's own flag (rooms by rect, corridors by the
|
|
// rooms they join) — the test reads it, never re-derives it, so a
|
|
// corridor the tour never walks still judges correctly.
|
|
const cellIndoor = (x, y) => m.indoor[y * m.w + x] === 1;
|
|
let walled = 0, planted = 0;
|
|
for (let y = 0; y < m.h; y++) {
|
|
for (let x = 0; x < m.w; x++) {
|
|
if (!m.grid[y * m.w + x]) continue;
|
|
const openN = (nx, ny) => nx >= 0 && ny >= 0 && nx < m.w && ny < m.h && m.grid[ny * m.w + nx];
|
|
const edges = [];
|
|
if (!openN(x - 1, y)) edges.push(['v', w0(x), z0(y) + CELL / 2]);
|
|
if (!openN(x + 1, y)) edges.push(['v', w0(x) + CELL, z0(y) + CELL / 2]);
|
|
if (!openN(x, y - 1)) edges.push(['h', w0(x) + CELL / 2, z0(y)]);
|
|
if (!openN(x, y + 1)) edges.push(['h', w0(x) + CELL / 2, z0(y) + CELL]);
|
|
for (const [kind, ex, ez] of edges) {
|
|
const covered = kind === 'h' ? coveredH(ex, ez) : coveredV(ex, ez);
|
|
if (cellIndoor(x, y)) {
|
|
assert.ok(covered, `hole on ${kind === 'h' ? 'horizontal' : 'vertical'} edge of (${x},${y})`);
|
|
walled++;
|
|
} else {
|
|
assert.ok(plantedNear(ex, ez) || covered,
|
|
`outdoor edge of (${x},${y}) neither walled nor planted`);
|
|
planted++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
assert.ok(walled > 100, `only ${walled} wall edges checked — map too open?`);
|
|
assert.ok(planted > 20, `only ${planted} planted edges — outdoor bare?`);
|
|
for (const v of m.items.vegetation) {
|
|
assert.ok(['tree', 'bush', 'boulder'].includes(v.kind), `unknown planting ${v.kind}`);
|
|
const cx = Math.floor(v.x / CELL + m.w / 2);
|
|
const cy = Math.floor(v.z / CELL + m.h / 2);
|
|
assert.ok(cx >= 0 && cy >= 0 && cx < m.w && cy < m.h, 'planting off the grid');
|
|
assert.ok(!m.grid[cy * m.w + cx], 'planting on an open cell — it would block the walk');
|
|
}
|
|
});
|
|
|
|
test('watch cells stand on open ground with line-of-sight to the route', () => {
|
|
const m = genDungeon({ seed: 7, rng: new Rng(7) });
|
|
assert.ok(Object.keys(m.watch).length >= m.rooms.length - 1,
|
|
'nearly every room needs a camera chair');
|
|
for (const [id, w] of Object.entries(m.watch)) {
|
|
const cx = Math.floor(w.x / CELL + m.w / 2);
|
|
const cy = Math.floor(w.z / CELL + m.h / 2);
|
|
assert.ok(m.grid[cy * m.w + cx], `watch cell of room ${id} is solid`);
|
|
const rm = m.rooms.find((r) => r.id === Number(id));
|
|
assert.ok(cx >= rm.x && cx < rm.x + rm.w && cy >= rm.y && cy < rm.y + rm.h,
|
|
`watch cell of room ${id} is outside its room`);
|
|
}
|
|
});
|
|
|
|
test('portal sits off-route in a room, facing the walk', () => {
|
|
const m = genDungeon({ seed: 7, rng: new Rng(7) });
|
|
assert.ok(m.portal, 'no portal planned');
|
|
const cx = Math.floor(m.portal.x / CELL + m.w / 2);
|
|
const cy = Math.floor(m.portal.z / CELL + m.h / 2);
|
|
assert.ok(m.grid[cy * m.w + cx], 'portal cell is solid');
|
|
const rm = m.rooms.find((r) => r.id === m.portal.roomId);
|
|
assert.ok(rm && rm.indoor, 'portal belongs in an indoor room');
|
|
assert.ok(Number.isFinite(m.portal.yaw), 'portal yaw must be finite');
|
|
});
|
|
|
|
test('items sit on open cells, off the walked line', () => {
|
|
const m = genDungeon({ seed: 7, rng: new Rng(7) });
|
|
const onOpen = (x, z, what) => {
|
|
const cx = Math.floor(x / CELL + m.w / 2);
|
|
const cy = Math.floor(z / CELL + m.h / 2);
|
|
assert.ok(cx >= 0 && cy >= 0 && cx < m.w && cy < m.h, `${what} off the grid`);
|
|
assert.ok(m.grid[cy * m.w + cx], `${what} on a solid cell`);
|
|
};
|
|
for (const p of m.items.props) {
|
|
assert.ok(PROP_BUILDERS[p.type], `unknown prop ${p.type}`);
|
|
onOpen(p.x, p.z, `prop ${p.type}`);
|
|
}
|
|
assert.ok(m.items.torches.length >= 2, `only ${m.items.torches.length} torches`);
|
|
assert.ok(m.items.torches.length <= 18, 'torch cap blown — clutter');
|
|
for (const tc of m.items.torches) {
|
|
// Sconces hang on indoor stone: an indoor open cell within a step,
|
|
// with a solid neighbour in reach of the bracket — never floating,
|
|
// never buried deep.
|
|
const cx = Math.floor(tc.x / CELL + m.w / 2);
|
|
const cy = Math.floor(tc.z / CELL + m.h / 2);
|
|
let indoorNear = false, solidNear = false, openNear = false;
|
|
for (let dy = -1; dy <= 1; dy++) {
|
|
for (let dx = -1; dx <= 1; dx++) {
|
|
const nx = cx + dx, ny = cy + dy;
|
|
if (nx < 0 || ny < 0 || nx >= m.w || ny >= m.h) continue;
|
|
if (m.grid[ny * m.w + nx]) {
|
|
openNear = true;
|
|
if (m.indoor[ny * m.w + nx]) indoorNear = true;
|
|
} else solidNear = true;
|
|
}
|
|
}
|
|
assert.ok(openNear, 'torch buried in stone');
|
|
assert.ok(indoorNear, 'torch burning outdoors');
|
|
assert.ok(solidNear, 'torch with no wall in reach — floating');
|
|
}
|
|
assert.ok(m.items.patrols.length >= 1, 'no patrol lanterns for the open ground');
|
|
assert.ok(m.items.windows.length >= 4, `only ${m.items.windows.length} windows`);
|
|
assert.ok(m.items.puddles.length === Math.max(2, Math.round(4 * THEMES[m.theme].puddleMul)),
|
|
`puddle count ${m.items.puddles.length} ignores theme ${m.theme}`);
|
|
for (const g of [...m.items.gates, ...m.items.gaps, ...m.items.patrols]) {
|
|
onOpen(g.x, g.z, 'hazard');
|
|
}
|
|
for (const g of m.items.gates) {
|
|
assert.ok(HAZARD_BUILDERS.gate, 'gate builder missing');
|
|
assert.ok(typeof g.s === 'number', 'gate needs route arclength for the lift');
|
|
}
|
|
// Avoidance stays bounded on the real gate list.
|
|
for (let i = 0; i < 50; i++) {
|
|
const off = avoidanceOffset(i * 1.7, m.items.gates, i * 0.63);
|
|
assert.ok(Number.isFinite(off) && Math.abs(off) <= 1.0, `avoidance out of bounds: ${off}`);
|
|
}
|
|
});
|
|
|
|
test('portcullis stays up for the whole procession, not just the hero', async () => {
|
|
const T = await import('three');
|
|
const { updateHazards, HAZARD_BUILDERS } = await import('../src/venues/dungeon/hazards.js');
|
|
const gate = HAZARD_BUILDERS.gate(T, new Rng(3), [0.45, 0.45, 0.48]);
|
|
gate.userData.home = { x: 0, z: 0, yaw: 0 };
|
|
gate.userData.hazardS = 100;
|
|
const liftOf = (partyS) => {
|
|
updateHazards({ hazards: { items: [gate] }, t: 10, heroS: partyS[0], partyS });
|
|
return gate.userData.liftBars.position.y;
|
|
};
|
|
// Hero under the gate: fully raised.
|
|
assert.ok(liftOf([100]) > 2.3, 'gate not raised for the hero');
|
|
// Hero through, one trailer still under it: must stay fully raised.
|
|
assert.ok(liftOf([104, 100.5, 108]) > 2.3, 'gate dropped on the trailer');
|
|
// Whole party clear: back down.
|
|
assert.ok(liftOf([112, 116, 120]) < 0.1, 'gate stays up with nobody near');
|
|
// Hero-only fallback still behaves (no partyS passed).
|
|
updateHazards({ hazards: { items: [gate] }, t: 10, heroS: 100 });
|
|
assert.ok(gate.userData.liftBars.position.y > 2.3, 'hero-only lift broken');
|
|
});
|
|
|
|
test('roomAt/zoneAt follow the route through rooms and corridors', () => {
|
|
const m = genDungeon({ seed: 7, rng: new Rng(7) });
|
|
const seenRooms = new Set(), seenZones = new Set();
|
|
let corridor = false;
|
|
for (let s = 0; s < m.route.totalLen; s += 1) {
|
|
const r = roomAt(m, s);
|
|
const z = zoneAt(m, s);
|
|
assert.ok(Number.isInteger(r) && r >= -1 && r < m.rooms.length, `bad room ${r}`);
|
|
assert.ok(typeof z === 'string' && z.length > 0, `bad zone ${z}`);
|
|
if (r >= 0) seenRooms.add(r);
|
|
else corridor = true;
|
|
seenZones.add(z);
|
|
}
|
|
assert.equal(seenRooms.size, m.rooms.length, 'route samples must cover every room');
|
|
assert.ok(corridor, 'route never leaves rooms — corridors unused?');
|
|
assert.ok(seenZones.size >= 2, 'route crosses a single zone only');
|
|
});
|
|
|
|
test('the cast assembles: enemies, critters and a wisp on open cells', () => {
|
|
const m = genDungeon({ seed: 7, rng: new Rng(7) });
|
|
const kinds = m.items.entities.map((e) => e.kind);
|
|
assert.ok(kinds.filter((k) => k === 'lurker').length >= 2, `lurkers: ${kinds.join(',')}`);
|
|
assert.ok(kinds.includes('critter'), 'no critters');
|
|
assert.ok(kinds.includes('wisp'), 'no wisp');
|
|
assert.equal(m.items.entities.length, 6, `cast size ${m.items.entities.length}`);
|
|
for (const e of m.items.entities) {
|
|
assert.ok(['lurker', 'sentry', 'critter', 'wisp'].includes(e.kind), `unknown entity ${e.kind}`);
|
|
const cx = Math.floor(e.x / CELL + m.w / 2);
|
|
const cy = Math.floor(e.z / CELL + m.h / 2);
|
|
assert.ok(m.grid[cy * m.w + cx] === 1, `${e.kind} on a solid cell`);
|
|
assert.ok(Number.isFinite(e.s) && Number.isFinite(e.yaw), `${e.kind} missing s/yaw`);
|
|
assert.ok(e.range >= 0 && Number.isFinite(e.speed) && Number.isFinite(e.phase),
|
|
`${e.kind} missing gait params`);
|
|
}
|
|
});
|
|
|
|
test('loot sits a step off the walk, each cache earning its halt', () => {
|
|
const m = genDungeon({ seed: 7, rng: new Rng(7) });
|
|
assert.ok(m.items.loot.length >= 2, `only ${m.items.loot.length} loot spots`);
|
|
assert.ok(m.items.loot.length <= 3, 'loot glut');
|
|
for (const l of m.items.loot) {
|
|
assert.ok(['cache', 'relic', 'hoard'].includes(l.kind), `unknown loot ${l.kind}`);
|
|
const cx = Math.floor(l.x / CELL + m.w / 2);
|
|
const cy = Math.floor(l.z / CELL + m.h / 2);
|
|
assert.ok(m.grid[cy * m.w + cx] === 1, `loot ${l.kind} on a solid cell`);
|
|
}
|
|
assert.equal(m.items.halts.length, m.items.loot.length, 'every cache earns a halt');
|
|
for (let i = 0; i < m.items.halts.length; i++) {
|
|
const h = m.items.halts[i];
|
|
assert.ok(h.dur > 0 && h.dur <= 3, `halt dur ${h.dur}`);
|
|
assert.equal(h.s, m.items.loot[i].s, 'halt must sit on its loot');
|
|
for (let j = i + 1; j < m.items.halts.length; j++) {
|
|
const L = m.route.totalLen;
|
|
const d = Math.abs(h.s - m.items.halts[j].s) % L;
|
|
assert.ok(Math.min(d, L - d) >= 15, 'halts overlap — the odometer could retreat');
|
|
}
|
|
}
|
|
});
|
|
|
|
test('odometer holds at halts and never retreats', () => {
|
|
const cruise = 1.4, L = 200;
|
|
const halts = [{ s: 50, dur: 2.2 }, { s: 150, dur: 2.2 }];
|
|
// Deterministic.
|
|
assert.equal(odometer(cruise, halts, L, 10), odometer(cruise, halts, L, 10));
|
|
// Unpaused stretch advances at gait.
|
|
assert.ok(Math.abs(odometer(cruise, halts, L, 10) - cruise * 10) < 1e-9, 'gait wrong');
|
|
// Arrival holds: from t_a to t_a+dur the reading stays on the loot.
|
|
const ta = 50 / cruise;
|
|
assert.ok(Math.abs(odometer(cruise, halts, L, ta + 1.1) - 50) < 1e-9, 'halt does not hold');
|
|
assert.ok(Math.abs(odometer(cruise, halts, L, ta + 2.2) - 50) < 1e-9, 'halt releases early');
|
|
// Monotonic everywhere, both gaits, both halt sets.
|
|
for (const c of [0.4, 1.4, 2.6]) {
|
|
let prev = odometer(c, halts, L, 0);
|
|
for (let t = 0.05; t < 300; t += 0.05) {
|
|
const s = odometer(c, halts, L, t);
|
|
const d = (s - prev + L) % L;
|
|
assert.ok(d < c * 0.06 + 1e-9, `retreat at t=${t.toFixed(2)} (cruise ${c})`);
|
|
prev = s;
|
|
}
|
|
}
|
|
});
|
|
|
|
test('entity poses are deterministic, bounded and hero-aware', () => {
|
|
const m = genDungeon({ seed: 7, rng: new Rng(7) });
|
|
const L = m.route.totalLen;
|
|
for (const e of m.items.entities) {
|
|
const p1 = entityPose(e, 10, 5, 0, 0, L);
|
|
const p2 = entityPose(e, 10, 5, 0, 0, L);
|
|
assert.deepEqual(p1, p2, `${e.kind} pose unstable`);
|
|
assert.ok(Math.hypot(p1.x - e.x, p1.z - e.z) <= e.range + 1.6,
|
|
`${e.kind} wanders ${Math.hypot(p1.x - e.x, p1.z - e.z).toFixed(2)} from home`);
|
|
assert.ok(p1.alert >= 0 && p1.alert <= 1, `${e.kind} alert out of range`);
|
|
// Near the hero it notices; far away it doesn't.
|
|
const near = entityPose(e, 10, e.s, e.x, e.z, L);
|
|
const far = entityPose(e, 10, (e.s + L / 2) % L, e.x, e.z, L);
|
|
assert.ok(near.alert >= far.alert, `${e.kind} ignores the hero`);
|
|
assert.ok(near.alert > 0.5, `${e.kind} cold at point blank`);
|
|
}
|
|
});
|
|
|
|
const SLOW_DARK = {
|
|
meanCentroid: 0.3, meanFlatness: 0.1, bpm: 68,
|
|
dynamicRange: 0.7, meanLoudness: 0.3,
|
|
};
|
|
|
|
// Summaries that pin the character mapping at its corners: a sealed crypt
|
|
// (dark + slow) and an airy ruin (bright + fast).
|
|
const SEALED = { bpm: 70, meanCentroid: 0.05, meanFlatness: 0.3, meanLoudness: 0.008, dynamicRange: 0.4 };
|
|
const AIRY = { bpm: 140, meanCentroid: 0.9, meanFlatness: 0.7, meanLoudness: 0.0014, dynamicRange: 0.89 };
|
|
|
|
test('dungeonCharacter maps song to dungeon in documented ranges', () => {
|
|
for (const summary of [{}, SEALED, AIRY, SLOW_DARK, { bpm: 200, meanCentroid: 5, meanLoudness: -1 }]) {
|
|
const c = dungeonCharacter(summary);
|
|
for (const k of ['indoorBias', 'murk', 'sizeMul', 'dark', 'slow']) {
|
|
assert.ok(Number.isFinite(c[k]), `${k} not finite for ${JSON.stringify(summary)}`);
|
|
}
|
|
assert.ok(c.indoorBias >= 0 && c.indoorBias <= 1, 'indoorBias out of range');
|
|
assert.ok(c.murk >= 0 && c.murk <= 1, 'murk out of range');
|
|
assert.ok(c.sizeMul >= 1 && c.sizeMul <= 1.45, 'sizeMul out of range');
|
|
}
|
|
// Defaults are the neutral middle, not an extreme.
|
|
const d0 = dungeonCharacter({});
|
|
assert.ok(d0.indoorBias > 0.3 && d0.indoorBias < 0.9, 'default bias extreme');
|
|
assert.ok(d0.murk > 0.1 && d0.murk < 0.8, 'default murk extreme');
|
|
// Monotonic in darkness: darker songs seal and murk harder.
|
|
const brighter = dungeonCharacter({ ...SEALED, meanCentroid: 0.5 });
|
|
const sealed = dungeonCharacter(SEALED);
|
|
assert.ok(sealed.indoorBias >= brighter.indoorBias, 'darker song less sealed');
|
|
assert.ok(sealed.murk >= brighter.murk, 'darker song less murky');
|
|
// Monotonic in tempo: slower songs seal harder and build bigger.
|
|
// (bpm 140 stays unfolded — above 150 the detector doubles, so the
|
|
// comparison stays in honest tempo territory.)
|
|
const faster = dungeonCharacter({ ...SEALED, bpm: 140 });
|
|
assert.ok(sealed.indoorBias >= faster.indoorBias, 'slower song less sealed');
|
|
assert.ok(sealed.sizeMul >= faster.sizeMul, 'slower song builds smaller');
|
|
});
|
|
|
|
test('dark slow songs seal the dungeon: no outside views', () => {
|
|
const m = genDungeon({ seed: 7, rng: new Rng(7), summary: SEALED });
|
|
assert.equal(m.character.indoorBias, 1, 'sealed summary must pin bias');
|
|
assert.ok(m.rooms.length >= 3, 'sealed map needs rooms too');
|
|
for (const rm of m.rooms) {
|
|
assert.ok(rm.indoor, `sealed room ${rm.id} left open (${rm.zone})`);
|
|
}
|
|
for (let s = 0; s < m.route.totalLen; s += 2) {
|
|
const z = zoneAt(m, s);
|
|
assert.ok(z === 'hall' || z === 'room', `sealed route sees outside: ${z}`);
|
|
}
|
|
});
|
|
|
|
test('bright fast songs open the dungeon: some outside views', () => {
|
|
const m = genDungeon({ seed: 7, rng: new Rng(7), summary: AIRY });
|
|
assert.ok(m.character.indoorBias < 0.5, 'airy summary must drop bias');
|
|
assert.ok(m.rooms.some((rm) => !rm.indoor), 'airy map sealed shut');
|
|
assert.ok(m.rooms.some((rm) => rm.indoor), 'airy map has no interior at all');
|
|
});
|
|
|
|
test('heavy songs build bigger rooms than light ones, same seed', () => {
|
|
const heavy = genDungeon({ seed: 7, rng: new Rng(7), summary: { bpm: 70, meanCentroid: 0.3, meanLoudness: 0.01 } });
|
|
const light = genDungeon({ seed: 7, rng: new Rng(7), summary: { bpm: 140, meanCentroid: 0.6, meanLoudness: 0.001 } });
|
|
assert.ok(heavy.character.sizeMul > light.character.sizeMul + 0.2, 'heft must move sizeMul');
|
|
const mean = (p) => p.rooms.reduce((a, r) => a + r.w * r.h, 0) / p.rooms.length;
|
|
assert.ok(mean(heavy) > mean(light) * 1.2,
|
|
`heavy mean area ${mean(heavy).toFixed(1)} vs light ${mean(light).toFixed(1)}`);
|
|
assert.ok(heavy.rooms.length >= 3 && light.rooms.length >= 3, 'both maps need rooms');
|
|
});
|
|
|
|
test('timber frames every gate and beams some walls, bounded', () => {
|
|
const m = genDungeon({ seed: 7, rng: new Rng(7) });
|
|
assert.ok(m.items.gates.length > 0, 'seed 7 needs gates for this test');
|
|
assert.ok(m.items.timbers.length > 0, 'no timber at all');
|
|
assert.ok(m.items.timbers.length <= 140, `timber blowout: ${m.items.timbers.length}`);
|
|
for (const tb of m.items.timbers) {
|
|
for (const k of ['x', 'y', 'z', 'sx', 'sy', 'sz', 'yaw']) {
|
|
assert.ok(Number.isFinite(tb[k]), `timber ${k} not finite`);
|
|
}
|
|
assert.ok(tb.sx > 0 && tb.sy > 0 && tb.sz > 0, 'timber with dead dimension');
|
|
}
|
|
// Every gate gets a door frame: two posts flanking it plus a lintel over.
|
|
for (const g of m.items.gates) {
|
|
const rx = Math.cos(g.yaw), rz = -Math.sin(g.yaw);
|
|
const near = m.items.timbers.filter((tb) =>
|
|
Math.hypot(tb.x - g.x, tb.z - g.z) < 1.6);
|
|
assert.ok(near.length >= 3, `gate at ${g.x.toFixed(1)},${g.z.toFixed(1)} has ${near.length} timbers`);
|
|
const posts = near.filter((tb) => Math.abs(tb.sy - 2.7) < 1e-9);
|
|
assert.equal(posts.length, 2, `gate frame wants 2 posts, has ${posts.length}`);
|
|
for (const side of [-1.15, 1.15]) {
|
|
assert.ok(posts.some((tb) =>
|
|
Math.abs((tb.x - g.x) * rx + (tb.z - g.z) * rz - side) < 0.35),
|
|
`gate frame missing post at lateral ${side}`);
|
|
}
|
|
assert.ok(near.some((tb) => Math.abs(tb.sx - 2.75) < 1e-9 && tb.y > -1.15 + 2.4),
|
|
'gate frame missing its lintel');
|
|
}
|
|
// Wall beams sit on wall runs (plate centres), never floating.
|
|
const beams = m.items.timbers.filter((tb) => Math.abs(tb.sx - 0.3) > 1e-9 || Math.abs(tb.sz - 0.3) > 1e-9);
|
|
assert.ok(beams.length > 0, 'no wall beams sampled');
|
|
const onRun = (tb) => m.wallRuns.some((r) => {
|
|
const len = Math.max(r.x1 - r.x0, r.z1 - r.z0);
|
|
const d = len > 0
|
|
? Math.abs((tb.x - r.x0) * (r.z1 - r.z0) - (tb.z - r.z0) * (r.x1 - r.x0)) / len
|
|
: Math.hypot(tb.x - r.x0, tb.z - r.z0);
|
|
const within = tb.x >= Math.min(r.x0, r.x1) - 0.4 && tb.x <= Math.max(r.x0, r.x1) + 0.4
|
|
&& tb.z >= Math.min(r.z0, r.z1) - 0.4 && tb.z <= Math.max(r.z0, r.z1) + 0.4;
|
|
return within && d < 0.35;
|
|
});
|
|
for (const tb of beams) {
|
|
// Door-frame pieces live at gates, not on runs — skip those.
|
|
const atGate = m.items.gates.some((g) => Math.hypot(tb.x - g.x, tb.z - g.z) < 1.6);
|
|
if (atGate) continue;
|
|
assert.ok(onRun(tb), `beam at ${tb.x.toFixed(1)},${tb.z.toFixed(1)} floats off its wall`);
|
|
}
|
|
});
|
|
|
|
function slowPersonalityAt(seed) {
|
|
const rng = new Rng(seed);
|
|
return generatePersonality(SLOW_DARK, rng.fork('personality'), () => 10, 4);
|
|
}
|
|
|
|
test('VenueGenerator plans the dungeon map when the dungeon is picked', () => {
|
|
const rng = new Rng(5);
|
|
const story = {
|
|
sections: [{ act: 'setup' }, { act: 'development' }, { act: 'climax' }, { act: 'resolution' }],
|
|
};
|
|
const vs = generateVenue({
|
|
summary: SLOW_DARK, rng: rng.fork('venue'), personality: slowPersonalityAt(5),
|
|
director: null, story, sections: [{}, {}, {}, {}],
|
|
});
|
|
assert.equal(vs.archetype, 'dungeon');
|
|
assert.ok(vs.dungeon && vs.dungeon.map, 'dungeon venue must carry the map');
|
|
assert.ok(vs.dungeon.map.rooms.length >= 3, 'map has no rooms');
|
|
assert.ok(vs.dungeon.map.route.totalLen > 80, 'route too short');
|
|
assert.equal(vs.population.kind, 'party', 'dungeon walks a party, not a crowd');
|
|
assert.equal(vs.projection.kind, 'portal', 'dungeon projects on the portal');
|
|
// Deterministic across regenerations.
|
|
const again = generateVenue({
|
|
summary: SLOW_DARK, rng: new Rng(5).fork('venue'), personality: slowPersonalityAt(5),
|
|
director: null, story, sections: [{}, {}, {}, {}],
|
|
});
|
|
assert.deepEqual(again.dungeon, vs.dungeon);
|
|
// Non-dungeon venues carry no dungeon plan.
|
|
const fast = generateVenue({
|
|
summary: { ...SLOW_DARK, bpm: 140 }, rng: new Rng(5).fork('venue'),
|
|
personality: slowPersonalityAt(5), director: null, story, sections: [{}, {}, {}, {}],
|
|
});
|
|
if (fast.archetype !== 'dungeon') assert.equal(fast.dungeon, null);
|
|
});
|
|
|
|
const THEME_CORNERS = {
|
|
crypt: { bpm: 62, meanCentroid: 0.02, meanFlatness: 0.3, meanLoudness: 0.008, dynamicRange: 0.9 },
|
|
overgrown: { bpm: 100, meanCentroid: 0.45, meanFlatness: 0.85, meanLoudness: 0.0005, dynamicRange: 0.5 },
|
|
ember: { bpm: 150, meanCentroid: 0.5, meanFlatness: 0.3, meanLoudness: 0.0022, dynamicRange: 0.4 },
|
|
flooded: { bpm: 120, meanCentroid: 0.9, meanFlatness: 0.2, meanLoudness: 0.001, dynamicRange: 0.9 },
|
|
windswept: { bpm: 170, meanCentroid: 0.85, meanFlatness: 0.2, meanLoudness: 0.001, dynamicRange: 0.4 },
|
|
};
|
|
|
|
test('dungeonTheme is deterministic and names a known theme', () => {
|
|
for (const s of [{}, ...Object.values(THEME_CORNERS)]) {
|
|
assert.equal(dungeonTheme(s, 7), dungeonTheme(s, 7), 'theme unstable across calls');
|
|
assert.ok(THEME_NAMES.includes(dungeonTheme(s, 7)), `unknown theme for ${JSON.stringify(s)}`);
|
|
assert.ok(THEMES[dungeonTheme(s, 7)], 'theme record missing');
|
|
}
|
|
// Same song, different seeds may vary (jitter), but the pick stays valid.
|
|
for (const seed of [1, 2, 3, 99, 12345]) {
|
|
assert.ok(THEME_NAMES.includes(dungeonTheme(THEME_CORNERS.ember, seed)));
|
|
}
|
|
});
|
|
|
|
test('each theme wins its home corner', () => {
|
|
for (const [want, s] of Object.entries(THEME_CORNERS)) {
|
|
assert.equal(dungeonTheme(s, 7), want, `${want} corner picked ${dungeonTheme(s, 7)}`);
|
|
assert.equal(dungeonTheme(s, 99), want, `${want} corner unstable across seeds`);
|
|
}
|
|
});
|
|
|
|
test('theme sweep reaches every theme', () => {
|
|
const seen = new Set();
|
|
for (let bpm = 60; bpm <= 180; bpm += 20) {
|
|
for (const cent of [0.1, 0.4, 0.7, 0.95]) {
|
|
for (const flat of [0.1, 0.6, 0.9]) {
|
|
for (const loud of [0.0005, 0.002]) {
|
|
seen.add(dungeonTheme({ bpm, meanCentroid: cent, meanFlatness: flat, meanLoudness: loud, dynamicRange: 0.5 }, 7));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
assert.deepEqual([...seen].sort(), [...THEME_NAMES].sort(),
|
|
`sweep reaches only ${[...seen].join(',')}`);
|
|
});
|
|
|
|
test('theme records are well-formed', () => {
|
|
for (const [name, th] of Object.entries(THEMES)) {
|
|
for (const k of ['stoneMul', 'floorMul', 'torch', 'fogTint', 'wood']) {
|
|
assert.ok(Array.isArray(th[k]) && th[k].length === 3, `${name}.${k} not an RGB triple`);
|
|
assert.ok(th[k].every((v) => Number.isFinite(v) && v >= 0 && v <= 1.2), `${name}.${k} out of range`);
|
|
}
|
|
for (const k of ['propIndoor', 'propOutdoor']) {
|
|
assert.ok(Array.isArray(th[k]) && th[k].length > 0, `${name}.${k} empty`);
|
|
assert.ok(th[k].every((t) => PROP_BUILDERS[t]), `${name}.${k} names an unbuildable prop`);
|
|
}
|
|
for (const k of ['vegMul', 'timberMul', 'puddleMul']) {
|
|
assert.ok(Number.isFinite(th[k]) && th[k] > 0, `${name}.${k} not a positive density`);
|
|
}
|
|
}
|
|
});
|
|
|
|
test('theme reshapes the plan: dressing, planting, timber, puddles', () => {
|
|
// Ember-forcing vs crypt-forcing summaries, same seed: only the theme differs.
|
|
const ember = genDungeon({ seed: 7, rng: new Rng(7), summary: THEME_CORNERS.ember });
|
|
const crypt = genDungeon({ seed: 7, rng: new Rng(7), summary: THEME_CORNERS.crypt });
|
|
assert.equal(ember.theme, 'ember');
|
|
assert.equal(crypt.theme, 'crypt');
|
|
const stal = (m) => m.items.props.filter((p) => p.type === 'stalagmite').length;
|
|
assert.ok(stal(ember) >= stal(crypt), `ember ${stal(ember)} vs crypt ${stal(crypt)} stalagmites`);
|
|
assert.ok(ember.items.puddles.length <= crypt.items.puddles.length,
|
|
`ember ${ember.items.puddles.length} vs crypt ${crypt.items.puddles.length} puddles`);
|
|
assert.ok(ember.items.timbers.length < crypt.items.timbers.length,
|
|
`ember ${ember.items.timbers.length} vs crypt ${crypt.items.timbers.length} timbers`);
|
|
});
|
|
|
|
test('facade builds themed materials and lights', async () => {
|
|
const T = await import('three');
|
|
const { dungeon } = await import('../src/venues/dungeon.js');
|
|
const summary = THEME_CORNERS.ember;
|
|
const map = genDungeon({ seed: 7, rng: new Rng(7), summary });
|
|
const theme = THEMES[map.theme];
|
|
const scene = new T.Scene();
|
|
const instance = dungeon.build({
|
|
scene, seed: 7, params: {},
|
|
actorSpec: null,
|
|
venueSpec: { seed: 5, dungeon: { map }, population: { count: 2 }, paletteMap: [0, 1, 2, 3], perSection: [] },
|
|
THREE: T,
|
|
});
|
|
assert.ok(instance, 'build returned nothing');
|
|
const flame = instance.flameMat.emissive;
|
|
assert.ok(Math.abs(flame.r - theme.torch[0]) < 1e-6
|
|
&& Math.abs(flame.g - theme.torch[1]) < 1e-6
|
|
&& Math.abs(flame.b - theme.torch[2]) < 1e-6,
|
|
`flame ${flame.r.toFixed(2)},${flame.g.toFixed(2)},${flame.b.toFixed(2)} != theme ${theme.torch}`);
|
|
const tl = instance.torch.color;
|
|
assert.ok(Math.abs(tl.r - theme.torch[0]) < 1e-6
|
|
&& Math.abs(tl.g - theme.torch[1]) < 1e-6
|
|
&& Math.abs(tl.b - theme.torch[2]) < 1e-6,
|
|
'torch light ignores theme');
|
|
// Per-frame palette tint carries the theme multipliers.
|
|
dungeon.update({
|
|
instance, scene, camera: new T.PerspectiveCamera(),
|
|
timeline: { time: 1, frame: 60, progress: 0.01 },
|
|
features: {}, params: {}, palette: [[1, 1, 1]],
|
|
personality: null, framing: null, opacity: 1,
|
|
actorSpec: null, venueSpec: instance.venueSpec, venueState: null,
|
|
THREE: T,
|
|
});
|
|
const st = instance.stoneMat.color;
|
|
const fx = theme.stoneMul[0];
|
|
assert.ok(Math.abs(st.r / fx - (0.42 * (0.45 + 0.7 * 0.75) + 0.07)) < 0.05,
|
|
'stone tint does not carry the theme multiplier');
|
|
});
|