${scenes.filter(Boolean).length} scenes, ${game.actors.filter(a => a.folder?.id === folders.Actor.id).length} actors and a journal, all in the folder ${esc(title)}.
@UUID[${journal.uuid}]{Open the adventure}
${seams ? '' : '
⚠ Forge seams missing — update the VANITY system to 0.10.5 for quiet output.
'}
`,
});
return { delve: d, journal, scenes, folders, dungeonId };
}
/* ---------------------------------------------------------------- journal */
/**
* The journal's foe section, driven by classifyFoes so it cannot disagree with the chat card.
* The roster's tactical notes name particular monsters, so they print only where the plan is
* itself the encounter.
*/
function foeSection(c) {
const table = rows => `
Foe
atk
def
Grit
Nerve
${rows}
`;
if (c.kind === 'forged') return `
${esc(cap(c.heat))} — in the world. These are the actors the Forge created; run the fight off these.
${table(c.foes.map(f => `
@UUID[${f.uuid}]{${esc(f.name)}}
${f.atk ?? '?'}
${f.def ?? '?'}
${f.grit ?? '?'}
${f.nerve ?? '?'}
${esc(f.trick)}
`).join(''))}
${c.planned ? `
DELVE planned ${esc(c.planned.line)}. The Forge rolls its own cast, so the plan's foes are not these — its tactical notes describe monsters that were not created.
` : ''}`;
if (c.kind === 'planned') return `
${esc(cap(c.heat))} — not cast. Nothing was forged for this area, so the plan is the encounter. Cast it by hand:
${table(c.roster.foes.map(f => `
${f.n}× ${esc(f.name)}
${f.atk}
${f.def}
${f.grit}
${f.nerve}
${esc(f.note)}
`).join(''))}
Harmed by ${esc(c.roster.harmedBy)}. ${esc(c.roster.avoid)}.
`;
if (c.kind === 'unavailable') return `
${esc(cap(c.heat))} — nothing to run. No actors were created and this theme has no roster at this heat. Improvise the fight or skip it; the area's decision and fallback still stand.
`;
return '';
}
function buildPages(d, scenes) {
const sk = d.skeleton, ap = sk.appeasement;
const pages = [];
const GM_ONLY = { default: CONST.DOCUMENT_OWNERSHIP_LEVELS.NONE };
pages.push({
name: '① The truth', type: 'text', ownership: GM_ONLY,
text: { content: `
${esc(sk.placeName)}
${esc(sk.motif.dangerLine)}.
What was done. ${esc(sk.knot.transgression)}
What is left. ${esc(sk.bottomProblem.label)} ${esc(sk.bottomProblem.failureState)}. It wants ${esc(sk.bottomProblem.wantNow)}, and it opens by asking ${esc(d.ending.question)}
The prize. ${esc(sk.prize.label)} — ${esc(sk.prize.function)}.
The danger. ${esc(sk.motif.danger)}: ${esc(sk.motif.dangerLine)}.
The way through
Anyone may ${esc(ap.move)}[${esc(ap.attribute)} ${ap.successes}].
On success ${esc(ap.why)}, and ${esc(sk.factions[0]?.name ?? 'the dead')} will not open hostilities.
It costs +${ap.gain.vanity} Vanity now and +${ap.cost.bane} Bane later. Repeatable in every area —
say the Bane aloud when it banks, so the table can see the route is open.
Pressure
Clock. Roll 1d6 on any attention trigger, or every 3 Turns. 1 — something comes. Telegraph one Turn ahead.
The tab. Aim for ${d.pressure.target} Banes by the ending. Banes come from named beats, not from hoping for Stumbles.
Factions
${sk.factions.map(f => `
${esc(f.name)} (${esc(f.kind)}) — ${esc(f.essence)}. Handled by ${esc(f.handledBy)}.
${esc(a.cueFragments.join('. '))}.
${a.situation ? `${esc(cap(a.situation.occupant))} — ${esc(a.situation.doing)}. When you walk in, ${esc(a.situation.onArrival)}.` : ''}
Read that aloud, or rewrite it in your own words — it is a prompt, not a script.
${a.situation ? `
Why. ${esc(cap(a.situation.because))}. They can: ${esc(a.situation.offer)}.
This is the authored slot. DELVE stages the approach and stops here on purpose — the climax is yours to write.
' : ''}
${esc(sk.bottomProblem.label)} — ${esc(sk.bottomProblem.failureState)}. It opens by asking ${esc(e.question)}
What they did
The audience
Appeased it, even once
It listens, and will trade ${esc(sk.prize.label)} for the real thing, said to its face.
Never appeased, tab under 4
It offers a Vice — the shine now, the bill later. Refusing starts the fight.
Carrying the prize
It wants that more than it wants them.
Fighting
Winnable by two engaged heroes. Name what harms it before initiative.
The Reckoning. If the tab reads six mid-audience, stop and roll it. A delve about vanity billing them in front of this thing is the best ending it has — do not soften it.
` },
});
return pages;
}
/* ----------------------------------------------------------------- remove */
/** Every dungeon DELVE has built in this world. */
export function listDungeons() {
const byId = new Map();
for (const f of game.folders) {
const id = f.getFlag(MOD, 'dungeonId');
if (!id) continue;
if (!byId.has(id)) byId.set(id, { id, name: f.getFlag(MOD, 'dungeonName') ?? f.name, folders: [] });
byId.get(id).folders.push(f);
}
for (const d of byId.values()) {
d.scenes = game.scenes.filter(s => s.getFlag(MOD, 'dungeonId') === d.id);
d.actors = game.actors.filter(a => a.getFlag(MOD, 'dungeonId') === d.id);
d.journals = game.journal.filter(j => j.getFlag(MOD, 'dungeonId') === d.id);
}
return [...byId.values()];
}
/** Delete one generated dungeon and everything it made. Confirms with exact counts first. */
export async function removeDungeon(dungeonId, { confirm = true } = {}) {
const d = listDungeons().find(x => x.id === dungeonId);
if (!d) return ui.notifications.warn('DELVE: no such dungeon.');
if (confirm) {
const ok = await foundry.applications.api.DialogV2.confirm({
window: { title: `Remove ${d.name}?` },
content: `
This deletes ${d.scenes.length} scenes, ${d.actors.length} actors,
${d.journals.length} journal(s) and ${d.folders.length} folders.
Nothing else in the world is touched, and this cannot be undone.
`,
rejectClose: false, modal: true,
});
if (!ok) return false;
}
// Never delete the scene the GM is standing in.
if (d.scenes.some(s => s.active)) {
const other = game.scenes.find(s => !d.scenes.includes(s));
if (other) await other.activate();
}
if (d.scenes.length) await Scene.deleteDocuments(d.scenes.map(s => s.id));
if (d.actors.length) await Actor.deleteDocuments(d.actors.map(a => a.id));
if (d.journals.length) await JournalEntry.deleteDocuments(d.journals.map(j => j.id));
if (d.folders.length) await Folder.deleteDocuments(d.folders.map(f => f.id));
ui.notifications.info(`DELVE: removed ${d.name}.`);
return true;
}
/** Pick one to remove. */
export async function removeDungeonDialog() {
const all = listDungeons();
if (!all.length) return ui.notifications.info('DELVE: no generated dungeons in this world.');
const options = all.map(d => ``).join('');
const id = await foundry.applications.api.DialogV2.prompt({
window: { title: 'DELVE — remove a dungeon' },
content: `