tevansandClaude Fable 5
9410c04381
The complete VANITY system: d6 Stumble engine, the two Bane tables (d66 Twist the Knife + 2d6 Reckoning) with red dice, character/NPC sheets, 17 conditions as token markers, illustrated spell cast cards, the Forge tools (hero/monster/NPC/hoard/encounter/stage/carouse/commission/Vain Crown), and 11 compendia. Manifest install ready. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2875 lines
140 KiB
JavaScript
2875 lines
140 KiB
JavaScript
/**
|
||
* VANITY — the Vanity Role-Playing Game, for Foundry VTT (v13/v14).
|
||
*
|
||
* Pool = Attribute + Knack + situation. 5–6 = a Success; fail with two or more 1s
|
||
* and you Stumble, banking a Bane of Karma (Draft 12).
|
||
* One Success succeeds; extras buy damage or Special Attacks. Push once (+1 Bane).
|
||
* No hit points — Grit. Vanity / Karma / Glory drive play.
|
||
*/
|
||
|
||
/* -------------------------------------------- */
|
||
/* Constants */
|
||
/* -------------------------------------------- */
|
||
|
||
import { VANITY_CONDITIONS } from "./conditions.mjs";
|
||
|
||
const ATTRIBUTES = {
|
||
brawn: { label: "Brawn", desc: "power · toughness · melee" },
|
||
flair: { label: "Flair", desc: "agility · aim · stealth · style" },
|
||
wits: { label: "Wits", desc: "mind · senses · arcane magic" },
|
||
poise: { label: "Poise", desc: "nerve · charm · divine magic" }
|
||
};
|
||
|
||
const KNACKS = {
|
||
fight: { label: "Fight", attr: "brawn" },
|
||
shoot: { label: "Shoot", attr: "flair" },
|
||
athletics: { label: "Athletics", attr: "brawn" },
|
||
stealth: { label: "Stealth", attr: "flair" },
|
||
notice: { label: "Notice", attr: "wits" },
|
||
lore: { label: "Lore", attr: "wits" },
|
||
survive: { label: "Survive", attr: "wits" },
|
||
charm: { label: "Charm", attr: "poise" },
|
||
command: { label: "Command", attr: "poise" }
|
||
};
|
||
|
||
const RANKS = ["—", "Trained", "Expert", "Master"];
|
||
|
||
const LOCKED_KNACKS = {
|
||
"Martial Prowess": "brawn",
|
||
"Larceny": "flair",
|
||
"Arcana": "wits",
|
||
"Faith": "poise",
|
||
"Wildcraft": "wits"
|
||
};
|
||
|
||
/** Class walls never lift — each class sees only its own Locked Knack. */
|
||
const CLASS_LOCKED = {
|
||
warrior: "Martial Prowess",
|
||
rogue: "Larceny",
|
||
ranger: "Wildcraft",
|
||
mage: "Arcana",
|
||
cleric: "Faith"
|
||
};
|
||
|
||
/** Everyone is born armed. */
|
||
const UNARMED_STRIKE = {
|
||
name: "Unarmed strike",
|
||
type: "weapon",
|
||
img: "icons/skills/melee/unarmed-punch-fist.webp",
|
||
system: {
|
||
dice: 0,
|
||
hands: 0,
|
||
group: "fight",
|
||
properties: "Always with you · perfect for Subdue",
|
||
cost: "—",
|
||
description: "<p>Fists, knees, forehead, the nearest piece of furniture. +0 dice — the pool is Brawn + Fight, and pride does the rest. Declare <b>Subdue</b> to knock them cold instead of killing.</p>"
|
||
}
|
||
};
|
||
|
||
/** The §11 maneuver menu — costs in net Successes beyond the first. */
|
||
const MANEUVERS = [
|
||
{ key: "disarm", label: "Disarm", cost: 1, hint: "Target drops a weapon or item.",
|
||
desc: "The target <b>drops a weapon or held item</b> of the attacker's choice. Picking it up again costs them their Move — if nobody kicks it away first." },
|
||
{ key: "knockdown", label: "Knock Down", cost: 1, hint: "Prone: −1 die; rising costs their move.",
|
||
desc: "The target is knocked <b>prone</b>: they take <b>−1 die on everything</b>, and rising costs them their Move. <i>Plate negates Knock Down; a Nemesis may spend 1 Resolve to shrug it off.</i>" },
|
||
{ key: "driveback", label: "Drive Back", cost: 1, hint: "Shove a pace; break away or reposition.",
|
||
desc: "Shove the target <b>a pace</b> — off the bridge's midpoint, out of the doorway, away from the lever. Also how you break away or reposition without giving ground for free. <i>Reach weapons pay 1 less.</i>" },
|
||
{ key: "wound", label: "Wound", cost: 1, hint: "Lingering injury: −1 die to a fitting action until treated.",
|
||
desc: "A <b>lingering injury</b>: −1 die to a fitting kind of action <b>until treated</b> (a slashed sword-arm, a gashed leg, a split brow into their eyes). <i>Mail and plate negate the Wound maneuver.</i>" },
|
||
{ key: "feint", label: "Feint", cost: 1, hint: "Your next attack on this foe gets +1 die.",
|
||
desc: "You sell the lie; they buy it. Your <b>next attack against this foe gets +1 die</b>." },
|
||
{ key: "gap", label: "Find the Gap", cost: 1, hint: "Your next strike on this foe ignores 2 armour dice.",
|
||
desc: "You've read their guard. Your <b>next strike on this foe ignores 2 armour dice</b> (they always keep their Attribute dice — §11a). Set up the killing blow, or the Sunder." },
|
||
{ key: "grapple", label: "Grapple", cost: 1, hint: "Held; they must win a Brawn contest to break free.",
|
||
desc: "The target is <b>held</b> — no moving, no clean swings — until they <b>win a Brawn contest</b> to break free. <i>A Nemesis may spend 1 Resolve to shrug it off.</i>" },
|
||
{ key: "called", label: "Called Shot", cost: 1, hint: "Trade damage for a targeted effect — GM adjudicates.",
|
||
desc: "Trade damage for a <b>targeted effect</b>: blind an eye, cripple a leg (halve their move), pin the sleeve to the mast. The GM adjudicates the exact price and result." },
|
||
{ key: "environment", label: "Environment", cost: 1, hint: "Spend on the scene — kick the brazier, cut the bridge. GM prices it 1–2.",
|
||
desc: "Spend Successes on <b>the scene itself</b>: kick the brazier into the oil, cut the rope bridge, topple the bookcase, slam the portcullis. The GM sets a fair price (usually 1–2) and narrates the chaos." },
|
||
{ key: "sunder", label: "Sunder", cost: 2, hint: "Permanently strip 1 armour die or a shield; the first Sunder dents plate (+2→+1).",
|
||
desc: "<b>Permanently strip 1 armour die or destroy a shield</b> for the rest of the fight. The first Sunder against plate <b>dents it (+2 → +1)</b>. Patience dismantles fortresses." },
|
||
{ key: "cleave", label: "Cleave", cost: 2, hint: "Deal your remaining damage to a second adjacent foe.",
|
||
desc: "The blow carries through: deal your <b>remaining damage to a second adjacent foe</b>. Best served from a two-hander in a doorway." },
|
||
{ key: "offbalance", label: "Off-Balance", cost: 2, hint: "They reel: −2 dice on their next roll.",
|
||
desc: "The target is reeling: <b>−2 dice on their next roll</b>, attack or defence. They still act — they just act badly. <i>It never skips a turn, which is exactly why it replaced Stagger.</i>" },
|
||
{ key: "press", label: "Press", cost: 2, hint: "One extra attack now (at most one extra attack per round).",
|
||
desc: "<b>Make one extra attack immediately.</b> Remember the cap: at most <b>one extra attack per round</b>, however it's paid for (Press or Rapid Shot, not both — §11a)." }
|
||
];
|
||
|
||
/**
|
||
* The interactive spend panel for attack cards: click maneuvers to buy them
|
||
* with Successes, dial in the defender's Successes, read off the damage.
|
||
*/
|
||
function renderSpendPanel({ successes, spend, sublabel }) {
|
||
const s = { defence: 0, damage: 0, maneuvers: [], ...(spend ?? {}) };
|
||
const net = successes - s.defence;
|
||
|
||
const hints = [];
|
||
if (/brutal/i.test(sublabel ?? "")) hints.push("<b>Brutal:</b> a free Wound on this hit.");
|
||
if (/armour-piercing/i.test(sublabel ?? "")) hints.push("<b>Armour-Piercing:</b> 2 of their armour dice never counted.");
|
||
if (/reach/i.test(sublabel ?? "")) hints.push("<b>Reach:</b> Drive Back costs 1 less.");
|
||
|
||
const defRow = `
|
||
<div class="spend-def">
|
||
<span class="lbl">Defender's Successes</span>
|
||
<button type="button" class="def-btn" data-def="-1" ${s.defence < 1 ? "disabled" : ""}>−</button>
|
||
<b class="def-n">${s.defence}</b>
|
||
<button type="button" class="def-btn" data-def="1">+</button>
|
||
</div>`;
|
||
|
||
if (net <= 0) {
|
||
return `<div class="vanity-spend">
|
||
${defRow}
|
||
<div class="turned">Turned aside — net ${net}, no harm done.</div>
|
||
</div>`;
|
||
}
|
||
|
||
const budget = net - 1;
|
||
const spentOnMans = s.maneuvers.reduce((n, k) => n + (MANEUVERS.find(m => m.key === k)?.cost ?? 0), 0);
|
||
const remaining = budget - s.damage - spentOnMans;
|
||
const totalDamage = 1 + s.damage;
|
||
|
||
const manBtns = MANEUVERS.map(m => {
|
||
const sel = s.maneuvers.includes(m.key);
|
||
const disabled = !sel && remaining < m.cost;
|
||
return `<button type="button" class="spend-btn ${sel ? "sel" : ""}" data-man="${m.key}"
|
||
title="${m.hint}" ${disabled ? "disabled" : ""}>${m.label}<i>${m.cost}</i></button>`;
|
||
}).join("");
|
||
|
||
const chosen = s.maneuvers.map(k => MANEUVERS.find(m => m.key === k)).filter(Boolean);
|
||
const descs = chosen.map(m => `<div class="man-desc">
|
||
<span class="man-name">${m.label}</span><span class="man-cost">${m.cost} Success${m.cost > 1 ? "es" : ""}</span>
|
||
<p>${m.desc}</p>
|
||
</div>`).join("");
|
||
|
||
return `<div class="vanity-spend">
|
||
${defRow}
|
||
<div class="dmg-line">
|
||
<span class="dmg">Damage: <b>${totalDamage} Grit</b></span>
|
||
<span class="left">${remaining > 0 ? `${remaining} Success${remaining === 1 ? "" : "es"} to spend` : "all spent"}</span>
|
||
</div>
|
||
<div class="spend-buttons dmg-row">
|
||
<button type="button" class="spend-btn dmg-btn" data-dmg="1" title="Spend a Success on +1 Grit of damage" ${remaining < 1 ? "disabled" : ""}>+1 damage</button>
|
||
<button type="button" class="spend-btn dmg-btn" data-dmg="-1" title="Take back a point of bought damage" ${s.damage < 1 ? "disabled" : ""}>−1 damage</button>
|
||
</div>
|
||
<div class="spend-buttons man-grid">
|
||
${manBtns}
|
||
</div>
|
||
${hints.length ? `<div class="prop-hints">${hints.join(" ")}</div>` : ""}
|
||
${descs}
|
||
</div>`;
|
||
}
|
||
|
||
const SPELL_LISTS = {
|
||
arcane: { label: "Arcane", attr: "wits", knack: "Arcana" },
|
||
divine: { label: "Divine", attr: "poise", knack: "Faith" },
|
||
trick: { label: "Nature Trick", attr: "wits", knack: "Wildcraft" }
|
||
};
|
||
|
||
const MISCAST_TABLE = [
|
||
"<b>Backlash</b> — the spell turns on you or your nearest ally at full force.",
|
||
"<b>Wild Surge</b> — all within reach are knocked prone; you are absurdly marked for the scene.",
|
||
"<b>Unwanted Guest</b> — a confused, hostile minor creature appears beside you and acts on the GM's turn.",
|
||
"<b>Aetheric Feedback</b> — lose half your remaining Grit (round up), you are Rattled, Spellcraft −2 dice until you rest.",
|
||
"<b>Smoke & Thunder</b> — a soot-black thunderclap blinds & deafens everyone adjacent (−2 dice) for a round.",
|
||
"<b>Catastrophic Unravelling</b> — a burst strikes friend and foe (area attack at your Successes), +2 Banes, ALL your magic is dead until a full ritual."
|
||
];
|
||
|
||
const NPC_CATEGORIES = {
|
||
mook: "Mook",
|
||
standard: "Standard foe",
|
||
threat: "Threat",
|
||
nemesis: "Nemesis (boss)"
|
||
};
|
||
|
||
/* -------------------------------------------- */
|
||
/* Documents */
|
||
/* -------------------------------------------- */
|
||
|
||
class VanityActor extends Actor {
|
||
prepareDerivedData() {
|
||
super.prepareDerivedData();
|
||
const sys = this.system;
|
||
|
||
if (this.type === "character") {
|
||
const grit = sys.grit;
|
||
grit.value = Math.clamp(grit.value ?? 0, 0, grit.max ?? 10);
|
||
sys.vanity = Math.clamp(sys.vanity ?? 0, 0, 6); // an ego can only hold so much (§3)
|
||
// Rattled at half Grit lost (round up): remaining <= floor(max / 2)
|
||
sys.rattled = grit.value > 0 && grit.value <= Math.floor((grit.max ?? 0) / 2);
|
||
sys.takenOut = grit.value <= 0;
|
||
sys.reckoning = (sys.karma ?? 0) >= 6;
|
||
|
||
// Defence pools: Attribute + equipped armour + shield
|
||
let armourDice = 0, shieldDice = 0;
|
||
for (const it of this.items) {
|
||
if (it.type !== "armour" || !it.system.equipped) continue;
|
||
if (it.system.kind === "shield") shieldDice += Number(it.system.defence) || 0;
|
||
else armourDice += Number(it.system.defence) || 0;
|
||
}
|
||
sys.armourDice = armourDice;
|
||
sys.shieldDice = shieldDice;
|
||
sys.dodgePool = (sys.attributes.flair.value || 0) + armourDice + shieldDice;
|
||
sys.blockPool = (sys.attributes.brawn.value || 0) + armourDice + shieldDice;
|
||
sys.load = 6 + (sys.attributes.brawn.value || 0);
|
||
}
|
||
|
||
if (this.type === "npc") {
|
||
sys.grit.value = Math.clamp(sys.grit.value ?? 0, 0, sys.grit.max ?? 1);
|
||
}
|
||
}
|
||
|
||
/** Keep the Locked Knack in step with the class — walls never lift. */
|
||
async _preUpdate(changed, options, user) {
|
||
await super._preUpdate(changed, options, user);
|
||
if (this.type !== "character") return;
|
||
const newClass = foundry.utils.getProperty(changed, "system.details.class");
|
||
if (newClass !== undefined) {
|
||
const lockedName = CLASS_LOCKED[String(newClass).trim().toLowerCase()];
|
||
if (lockedName) {
|
||
foundry.utils.setProperty(changed, "system.locked.name", lockedName);
|
||
foundry.utils.setProperty(changed, "system.locked.attribute", LOCKED_KNACKS[lockedName]);
|
||
}
|
||
}
|
||
const newLocked = foundry.utils.getProperty(changed, "system.locked.name");
|
||
if (newLocked && LOCKED_KNACKS[newLocked]) {
|
||
foundry.utils.setProperty(changed, "system.locked.attribute", LOCKED_KNACKS[newLocked]);
|
||
}
|
||
}
|
||
|
||
/** Add banes to the Karma tab (capped at 6, where the Reckoning falls due) and herald it. */
|
||
async addBanes(n, reason = "") {
|
||
if (!n || this.type !== "character") return;
|
||
const karma = Math.min(6, (this.system.karma ?? 0) + n);
|
||
await this.update({ "system.karma": karma });
|
||
if (karma >= 6) {
|
||
ui.notifications?.warn(`${this.name}: ${game.i18n.localize("VANITY.Reckoning")}`);
|
||
}
|
||
await ChatMessage.create({
|
||
speaker: { alias: "The Tab" },
|
||
content: `<div class="vanity-roll vanity-tab-note bane-bank">
|
||
<header><span class="vanity-roll-label">☠ The tab grows</span>
|
||
<span class="vanity-roll-sub">${this.name}${reason ? ` — ${reason}` : ""}</span></header>
|
||
<p><b>+${n} Bane${n > 1 ? "s" : ""}</b> banked · ${this.name} now carries <b>${karma}</b> of 6.${karma >= 6 ? " <b class=\"reck\">THE RECKONING IS DUE.</b>" : ""}</p>
|
||
<div class="vanity-buttons">
|
||
${karma >= 6
|
||
? `<button type="button" class="vanity-reckon" data-actor-uuid="${this.uuid}"><i class="fa-solid fa-skull"></i> GM: THE RECKONING — roll 2d6, wipe the tab</button>`
|
||
: `<button type="button" class="vanity-twist" data-actor-uuid="${this.uuid}"><i class="fa-solid fa-dice"></i> GM: Twist the Knife — roll the d66</button>`}
|
||
</div>
|
||
</div>`
|
||
});
|
||
}
|
||
}
|
||
|
||
class VanityItem extends Item {}
|
||
|
||
/* -------------------------------------------- */
|
||
/* The dice engine */
|
||
/* -------------------------------------------- */
|
||
|
||
const DIE_FACES = ["", "⚀", "⚁", "⚂", "⚃", "⚄", "⚅"];
|
||
|
||
function faceClass(r) {
|
||
if (r >= 5) return "success";
|
||
if (r === 1) return "bane";
|
||
return "blank";
|
||
}
|
||
|
||
function renderDice(results) {
|
||
return results.map(r => `<span class="vanity-die ${faceClass(r)}" title="${r}">${DIE_FACES[r]}</span>`).join("");
|
||
}
|
||
|
||
/**
|
||
* Build the chat-card HTML for a pool roll.
|
||
*/
|
||
function renderRollCard({ label, sublabel, results, threshold, pushed, context, extra, spend, banked = 0, twistUsed = false, spell = null }) {
|
||
const successes = results.filter(r => r >= 5).length;
|
||
const ones = results.filter(r => r === 1).length;
|
||
const stumble = successes === 0 && ones >= 2;
|
||
const met = threshold ? successes >= threshold : successes >= 1;
|
||
|
||
let outcome;
|
||
if (threshold) {
|
||
outcome = met
|
||
? `<span class="good">The Weave answers — Threshold ${threshold} met</span>`
|
||
: `<span class="bad">Short of Threshold ${threshold}</span>`;
|
||
} else {
|
||
outcome = met
|
||
? `<span class="good">${successes} ${successes === 1 ? "Success" : "Successes"}</span>`
|
||
: `<span class="bad">Failure</span>`;
|
||
}
|
||
|
||
let buttons = "";
|
||
if (!pushed) {
|
||
buttons += `<button type="button" class="vanity-push"><i class="fa-solid fa-fire"></i> Push (+1 Bane)</button>`;
|
||
if (context === "spell" && !met) {
|
||
buttons += `<button type="button" class="vanity-fizzle"><i class="fa-solid fa-wind"></i> Fizzle (spell spent)</button>`;
|
||
}
|
||
}
|
||
|
||
const specials = context === "attack" && successes >= 1
|
||
? renderSpendPanel({ successes, spend, sublabel })
|
||
: "";
|
||
|
||
const spellBanner = spell ? `
|
||
<div class="vanity-spellcard ${spell.school ?? ""}">
|
||
<img src="${spell.img}" alt="">
|
||
<div class="sc-meta">
|
||
<span class="sc-line">${spell.list} · Threshold ${threshold}${spell.flavor ? ` · <i>${spell.flavor}</i>` : ""}</span>
|
||
<div class="sc-effect">${spell.effect}</div>
|
||
</div>
|
||
</div>` : "";
|
||
|
||
const spellScaling = spell && met && successes > (threshold || 1)
|
||
? `<div class="sc-scaling">✦ <b>${successes - threshold} extra Success${successes - threshold > 1 ? "es" : ""}</b> to spend on the scaling: <i>${spell.scaling}</i></div>`
|
||
: "";
|
||
|
||
return `
|
||
<div class="vanity-roll">
|
||
<header>
|
||
<span class="vanity-roll-label">${label}</span>
|
||
${sublabel ? `<span class="vanity-roll-sub">${sublabel}</span>` : ""}
|
||
</header>
|
||
${spellBanner}
|
||
<div class="vanity-dice">${renderDice(results)}</div>
|
||
<div class="vanity-outcome">
|
||
${outcome}
|
||
${stumble
|
||
? `<span class="banes">· a STUMBLE${banked ? " — 1 Bane banked" : ""}</span>`
|
||
: ones ? `<span class="banes soft">· ${ones === 1 ? "a lone 1" : `${ones} ones`} — the GM may twist the knife now</span>` : ""}
|
||
${pushed ? `<span class="pushed">· Pushed</span>` : ""}
|
||
</div>
|
||
${!stumble && ones && !twistUsed
|
||
? `<div class="vanity-buttons twist-row"><button type="button" class="vanity-twist free" data-free="true"><i class="fa-solid fa-dice"></i> GM: Twist the Knife — free d66</button></div>`
|
||
: twistUsed ? `<div class="twist-spent">The knife has been twisted.</div>` : ""}
|
||
${spellScaling}
|
||
${extra ? `<div class="vanity-extra">${extra}</div>` : ""}
|
||
${specials}
|
||
${buttons ? `<div class="vanity-buttons">${buttons}</div>` : ""}
|
||
</div>`;
|
||
}
|
||
|
||
/**
|
||
* Roll a VANITY pool and post the chat card.
|
||
* options: { threshold, context ("spell"|"attack"|...), spellUuid, sublabel }
|
||
*/
|
||
async function rollPool(actor, pool, label, options = {}) {
|
||
pool = Math.max(1, Math.floor(pool));
|
||
const roll = new Roll(`${pool}d6`);
|
||
await roll.evaluate();
|
||
const results = roll.dice[0].results.map(r => r.result);
|
||
|
||
// The Stumble (Draft 11): bank 1 Bane only on a failed roll with two or more 1s.
|
||
const ones = results.filter(r => r === 1).length;
|
||
const successes = results.filter(r => r >= 5).length;
|
||
const stumble = successes === 0 && ones >= 2;
|
||
const banked = stumble && actor?.type === "character" ? 1 : 0;
|
||
|
||
const flags = {
|
||
vanity: {
|
||
results,
|
||
pool,
|
||
label,
|
||
sublabel: options.sublabel ?? "",
|
||
threshold: options.threshold ?? 0,
|
||
context: options.context ?? "",
|
||
spellUuid: options.spellUuid ?? "",
|
||
actorUuid: actor?.uuid ?? "",
|
||
pushed: false,
|
||
extra: "",
|
||
banked,
|
||
spell: options.spell ?? null,
|
||
spend: { defence: 0, damage: 0, maneuvers: [] }
|
||
}
|
||
};
|
||
|
||
await ChatMessage.create({
|
||
speaker: ChatMessage.getSpeaker({ actor }),
|
||
rolls: [roll],
|
||
sound: CONFIG.sounds.dice,
|
||
content: renderRollCard({ label, sublabel: options.sublabel, results, threshold: options.threshold, pushed: false, context: options.context, banked, spell: options.spell ?? null }),
|
||
flags
|
||
});
|
||
if (banked) await actor.addBanes(1, `a Stumble on “${label}”`);
|
||
}
|
||
|
||
/**
|
||
* The pool-builder dialog: situational dice, Vanity spend, Rattled penalty.
|
||
*/
|
||
async function promptAndRoll(actor, { title, base, baseLabel, options = {} }) {
|
||
const rattled = actor?.system?.rattled ? 1 : 0;
|
||
const vanity = actor?.type === "character" ? (actor.system.vanity ?? 0) : 0;
|
||
|
||
const content = `
|
||
<form class="vanity-roll-dialog">
|
||
<p class="pool-line"><b>${baseLabel}</b> — base pool <b>${base}</b>${rattled ? ` · <span class="rattled">Rattled −1</span>` : ""}</p>
|
||
<div class="form-group">
|
||
<label>Situational dice (gear, position, help)</label>
|
||
<input type="number" name="bonus" value="0" step="1">
|
||
</div>
|
||
${vanity > 0 ? `<div class="form-group">
|
||
<label>Spend 1 Vanity for +1 die <em>(${vanity} left)</em></label>
|
||
<input type="checkbox" name="vanity">
|
||
</div>` : ""}
|
||
${options.threshold ? `<p class="hint">Spell Threshold ${options.threshold} — meet it and the spell works (and is never spent).</p>` : ""}
|
||
</form>`;
|
||
|
||
return new Promise(resolve => {
|
||
new Dialog({
|
||
title,
|
||
content,
|
||
buttons: {
|
||
roll: {
|
||
icon: '<i class="fa-solid fa-dice"></i>',
|
||
label: "Roll",
|
||
callback: async html => {
|
||
const form = html[0].querySelector("form");
|
||
const bonus = parseInt(form.elements.bonus?.value) || 0;
|
||
const spendVanity = form.elements.vanity?.checked ?? false;
|
||
let pool = base + bonus - rattled;
|
||
let sub = [];
|
||
if (bonus) sub.push(`${bonus > 0 ? "+" : ""}${bonus} situation`);
|
||
if (rattled) sub.push("−1 Rattled");
|
||
if (spendVanity) {
|
||
pool += 1;
|
||
sub.push("+1 Vanity");
|
||
await actor.update({ "system.vanity": Math.max(0, vanity - 1) });
|
||
}
|
||
options.sublabel = [options.sublabel, sub.join(" · ")].filter(Boolean).join(" · ");
|
||
await rollPool(actor, pool, title, options);
|
||
resolve(true);
|
||
}
|
||
},
|
||
cancel: { icon: '<i class="fa-solid fa-xmark"></i>', label: "Cancel", callback: () => resolve(false) }
|
||
},
|
||
default: "roll"
|
||
}).render(true);
|
||
});
|
||
}
|
||
|
||
/* ------------ chat-card buttons (Push / Fizzle) ------------ */
|
||
|
||
async function handlePush(message) {
|
||
const f = message.flags?.vanity;
|
||
if (!f || f.pushed) return;
|
||
|
||
const actor = f.actorUuid ? await fromUuid(f.actorUuid) : null;
|
||
const results = [...f.results];
|
||
const keep = results.filter(r => r >= 5);
|
||
const rerollCount = results.length - keep.length;
|
||
|
||
let newResults = keep;
|
||
let roll = null;
|
||
if (rerollCount > 0) {
|
||
roll = new Roll(`${rerollCount}d6`);
|
||
await roll.evaluate();
|
||
newResults = keep.concat(roll.dice[0].results.map(r => r.result));
|
||
if (game.dice3d) await game.dice3d.showForRoll(roll, game.user, true);
|
||
}
|
||
|
||
// Push costs 1 Bane; a pushed roll that STILL fails with two or more 1s Stumbles for another.
|
||
const successes = newResults.filter(r => r >= 5).length;
|
||
const ones = newResults.filter(r => r === 1).length;
|
||
const pushedStumble = successes === 0 && ones >= 2;
|
||
const isCharacter = actor?.type === "character";
|
||
const paid = 1 + (pushedStumble ? 1 : 0);
|
||
const banked = pushedStumble && isCharacter ? 1 : 0;
|
||
|
||
let extra = pushedStumble
|
||
? `<span class="pushed-note">${game.i18n.localize("VANITY.Pushed")} — and pushed straight into a Stumble (+${paid} Banes).</span>`
|
||
: `<span class="pushed-note">${game.i18n.localize("VANITY.Pushed")} (+1 Bane).</span>`;
|
||
|
||
// A failed Push on a spell is a CATASTROPHE.
|
||
if (f.context === "spell" && f.threshold && successes < f.threshold) {
|
||
const d = new Roll("1d6");
|
||
await d.evaluate();
|
||
const n = d.total;
|
||
extra += `<div class="vanity-miscast"><b>CATASTROPHE! Miscast (${n}):</b> ${MISCAST_TABLE[n - 1]}</div>`;
|
||
if (f.spellUuid) {
|
||
const spell = await fromUuid(f.spellUuid);
|
||
if (spell) await spell.update({ "system.spent": true });
|
||
extra += `<div class="spent-note">The spell is spent until recovered.</div>`;
|
||
}
|
||
}
|
||
|
||
const spend = { defence: f.spend?.defence ?? 0, damage: 0, maneuvers: [] };
|
||
await message.update({
|
||
content: renderRollCard({
|
||
label: f.label, sublabel: f.sublabel, results: newResults,
|
||
threshold: f.threshold, pushed: true, context: f.context, extra, spend, banked, twistUsed: f.twistUsed ?? false, spell: f.spell ?? null
|
||
}),
|
||
"flags.vanity.results": newResults,
|
||
"flags.vanity.pushed": true,
|
||
"flags.vanity.extra": extra,
|
||
"flags.vanity.banked": banked,
|
||
"flags.vanity.spend": spend
|
||
});
|
||
if (isCharacter) {
|
||
await actor.addBanes(paid, pushedStumble ? `Pushed “${f.label}” straight into a Stumble` : `Pushed “${f.label}”`);
|
||
}
|
||
}
|
||
|
||
/** A click on the attack card's spend panel: buy damage or maneuvers, set defence. */
|
||
async function handleSpend(message, dataset) {
|
||
const f = message.flags?.vanity;
|
||
if (!f) return;
|
||
const successes = f.results.filter(r => r >= 5).length;
|
||
const spend = { defence: 0, damage: 0, maneuvers: [], ...(f.spend ?? {}) };
|
||
|
||
if (dataset.def !== undefined) {
|
||
spend.defence = Math.max(0, spend.defence + Number(dataset.def));
|
||
} else if (dataset.dmg !== undefined) {
|
||
spend.damage = Math.max(0, spend.damage + Number(dataset.dmg));
|
||
} else if (dataset.man) {
|
||
if (spend.maneuvers.includes(dataset.man)) spend.maneuvers = spend.maneuvers.filter(k => k !== dataset.man);
|
||
else spend.maneuvers.push(dataset.man);
|
||
}
|
||
|
||
// Never overspend: if the budget shrank (defence went up), drop purchases.
|
||
const budget = Math.max(0, successes - spend.defence - 1);
|
||
const cost = spend.damage + spend.maneuvers.reduce((n, k) => n + (MANEUVERS.find(m => m.key === k)?.cost ?? 0), 0);
|
||
if (cost > budget) {
|
||
if (dataset.def !== undefined) { spend.damage = 0; spend.maneuvers = []; }
|
||
else return; // an illegal purchase — ignore the click
|
||
}
|
||
|
||
await message.update({
|
||
content: renderRollCard({
|
||
label: f.label, sublabel: f.sublabel, results: f.results,
|
||
threshold: f.threshold, pushed: f.pushed, context: f.context, extra: f.extra, spend, banked: f.banked ?? 0, twistUsed: f.twistUsed ?? false, spell: f.spell ?? null
|
||
}),
|
||
"flags.vanity.spend": spend
|
||
});
|
||
}
|
||
|
||
async function handleFizzle(message) {
|
||
const f = message.flags?.vanity;
|
||
if (!f || f.pushed) return;
|
||
let extra = `<div class="spent-note">The spell fizzles and is <b>spent</b> until recovered (rest or ritual).</div>`;
|
||
if (f.spellUuid) {
|
||
const spell = await fromUuid(f.spellUuid);
|
||
if (spell) await spell.update({ "system.spent": true });
|
||
}
|
||
await message.update({
|
||
content: renderRollCard({
|
||
label: f.label, sublabel: f.sublabel, results: f.results,
|
||
threshold: f.threshold, pushed: true, context: f.context, extra, banked: f.banked ?? 0, twistUsed: f.twistUsed ?? false, spell: f.spell ?? null
|
||
}),
|
||
"flags.vanity.pushed": true,
|
||
"flags.vanity.extra": extra
|
||
});
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
/* Actor sheets */
|
||
/* -------------------------------------------- */
|
||
|
||
class VanityActorSheet extends foundry.appv1.sheets.ActorSheet {
|
||
static get defaultOptions() {
|
||
return foundry.utils.mergeObject(super.defaultOptions, {
|
||
classes: ["vanity", "sheet", "actor"],
|
||
template: "systems/vanity/templates/character-sheet.hbs",
|
||
width: 780,
|
||
height: 900,
|
||
tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "main" }]
|
||
});
|
||
}
|
||
|
||
async getData(options) {
|
||
const ctx = await super.getData(options);
|
||
const sys = this.actor.system;
|
||
ctx.sys = sys;
|
||
ctx.attributes = Object.entries(ATTRIBUTES).map(([key, a]) => ({
|
||
key, label: a.label, desc: a.desc, value: sys.attributes[key].value
|
||
}));
|
||
ctx.knacks = Object.entries(KNACKS).map(([key, k]) => ({
|
||
key, label: k.label, attr: k.attr, attrLabel: ATTRIBUTES[k.attr].label,
|
||
rank: sys.knacks[key].rank, rankLabel: RANKS[sys.knacks[key].rank],
|
||
pool: (sys.attributes[k.attr].value || 0) + (sys.knacks[key].rank || 0)
|
||
}));
|
||
ctx.lockedAttrs = Object.keys(ATTRIBUTES);
|
||
// A recognised class sees only its own Locked Knack; walls never lift.
|
||
const classLocked = CLASS_LOCKED[(sys.details.class || "").trim().toLowerCase()];
|
||
ctx.lockedNames = classLocked
|
||
? [...new Set([classLocked, sys.locked.name].filter(Boolean))]
|
||
: Object.keys(LOCKED_KNACKS);
|
||
ctx.lockedPool = (sys.attributes[sys.locked.attribute]?.value || 0) + (Number(sys.locked.rank) || 0);
|
||
ctx.rankOptions = RANKS;
|
||
|
||
ctx.gritCells = Array.fromRange(sys.grit.max ?? 10, 1).map(i => ({
|
||
i, filled: i <= sys.grit.value, half: i === Math.floor((sys.grit.max ?? 10) / 2)
|
||
}));
|
||
ctx.vanityPips = Array.fromRange(6, 1).map(i => ({ i, filled: i <= (sys.vanity ?? 0) }));
|
||
ctx.karmaPips = Array.fromRange(6, 1).map(i => ({ i, filled: i <= (sys.karma ?? 0) }));
|
||
|
||
const items = this.actor.items;
|
||
ctx.weapons = items.filter(i => i.type === "weapon");
|
||
ctx.armour = items.filter(i => i.type === "armour");
|
||
ctx.gear = items.filter(i => i.type === "gear");
|
||
ctx.spells = items.filter(i => i.type === "spell").map(s => ({
|
||
item: s, listLabel: SPELL_LISTS[s.system.list]?.label ?? s.system.list
|
||
}));
|
||
ctx.edges = items.filter(i => i.type === "edge");
|
||
ctx.vices = items.filter(i => i.type === "vice");
|
||
ctx.hasSpells = ctx.spells.length > 0;
|
||
ctx.slotsUsed = ctx.gear.reduce((n, g) => n + (Number(g.system.slots) || 0) * (Number(g.system.quantity) || 1), 0)
|
||
+ ctx.weapons.length + ctx.armour.filter(a => a.system.kind !== "shield" || a.system.equipped).length;
|
||
|
||
const active = this.actor.statuses ?? new Set();
|
||
const withImg = c => ({ ...c, img: `systems/vanity/assets/conditions/${c.id}.png` });
|
||
const groups = { combat: "In the fray", spell: "Sorcery", state: "The big states" };
|
||
ctx.conditions = VANITY_CONDITIONS.map(c => ({ ...withImg(c), active: active.has(c.id) }));
|
||
ctx.conditionGroups = Object.entries(groups).map(([g, label]) => ({
|
||
group: g, label,
|
||
items: ctx.conditions.filter(c => c.group === g)
|
||
}));
|
||
ctx.activeConditions = ctx.conditions.filter(c => c.active);
|
||
ctx.focusCond = this._focusCond
|
||
? ctx.conditions.find(c => c.id === this._focusCond) ?? null
|
||
: null;
|
||
|
||
ctx.notesHTML = await foundry.applications.ux.TextEditor.implementation.enrichHTML(sys.notes ?? "", { async: true });
|
||
ctx.bioHTML = await foundry.applications.ux.TextEditor.implementation.enrichHTML(sys.biography ?? "", { async: true });
|
||
ctx.editable = this.isEditable;
|
||
return ctx;
|
||
}
|
||
|
||
activateListeners(html) {
|
||
super.activateListeners(html);
|
||
if (!this.isEditable) return;
|
||
const actor = this.actor;
|
||
|
||
// Attribute roll
|
||
html.find(".attr .num, .attr .nm").click(ev => {
|
||
const key = ev.currentTarget.closest("[data-attr]").dataset.attr;
|
||
const a = ATTRIBUTES[key];
|
||
promptAndRoll(actor, {
|
||
title: `${a.label} check`,
|
||
base: actor.system.attributes[key].value || 0,
|
||
baseLabel: a.label
|
||
});
|
||
});
|
||
|
||
// Saving throw (right-click an attribute)
|
||
html.find(".attr").contextmenu(ev => {
|
||
ev.preventDefault();
|
||
const key = ev.currentTarget.dataset.attr;
|
||
const a = ATTRIBUTES[key];
|
||
promptAndRoll(actor, {
|
||
title: `Saving Throw — ${a.label}`,
|
||
base: actor.system.attributes[key].value || 0,
|
||
baseLabel: `${a.label} save (1 Success = you save)`
|
||
});
|
||
});
|
||
|
||
// Knack roll
|
||
html.find(".knack-row .kn").click(ev => {
|
||
const key = ev.currentTarget.closest("[data-knack]").dataset.knack;
|
||
const k = KNACKS[key];
|
||
const pool = (actor.system.attributes[k.attr].value || 0) + (actor.system.knacks[key].rank || 0);
|
||
promptAndRoll(actor, {
|
||
title: `${k.label}`,
|
||
base: pool,
|
||
baseLabel: `${ATTRIBUTES[k.attr].label} + ${k.label} (${RANKS[actor.system.knacks[key].rank]})`
|
||
});
|
||
});
|
||
|
||
// Locked knack roll
|
||
html.find(".locked-roll").click(() => {
|
||
const l = actor.system.locked;
|
||
if (!l.name) return ui.notifications.warn("Set the Locked Knack name first.");
|
||
const rank = Number(l.rank) || 0;
|
||
const pool = (actor.system.attributes[l.attribute]?.value || 0) + rank;
|
||
promptAndRoll(actor, {
|
||
title: l.name,
|
||
base: pool,
|
||
baseLabel: `${ATTRIBUTES[l.attribute].label} + ${l.name} (${RANKS[rank]})`
|
||
});
|
||
});
|
||
|
||
// Knack rank stepper (click cycles 0→1→2, right-click reverses)
|
||
html.find(".knack-row .rank").click(async ev => {
|
||
const key = ev.currentTarget.closest("[data-knack]").dataset.knack;
|
||
const r = actor.system.knacks[key].rank;
|
||
await actor.update({ [`system.knacks.${key}.rank`]: (r + 1) % 3 });
|
||
}).contextmenu(async ev => {
|
||
ev.preventDefault();
|
||
const key = ev.currentTarget.closest("[data-knack]").dataset.knack;
|
||
const r = actor.system.knacks[key].rank;
|
||
await actor.update({ [`system.knacks.${key}.rank`]: (r + 2) % 3 });
|
||
});
|
||
|
||
// Grit track
|
||
html.find(".grit-cell").click(async ev => {
|
||
const i = Number(ev.currentTarget.dataset.i);
|
||
const cur = actor.system.grit.value;
|
||
await actor.update({ "system.grit.value": i === cur ? i - 1 : i });
|
||
});
|
||
|
||
// Vanity / Karma pips
|
||
html.find(".pip-btn").click(async ev => {
|
||
const { res, i } = ev.currentTarget.dataset;
|
||
const cur = actor.system[res] ?? 0;
|
||
const n = Number(i);
|
||
await actor.update({ [`system.${res}`]: n === cur ? n - 1 : n });
|
||
});
|
||
|
||
// Defence quick rolls
|
||
html.find(".roll-dodge").click(() => promptAndRoll(actor, {
|
||
title: "Dodge", base: actor.system.dodgePool,
|
||
baseLabel: `Flair ${actor.system.attributes.flair.value} + armour ${actor.system.armourDice} + shield ${actor.system.shieldDice}`
|
||
}));
|
||
html.find(".roll-block").click(() => promptAndRoll(actor, {
|
||
title: "Block", base: actor.system.blockPool,
|
||
baseLabel: `Brawn ${actor.system.attributes.brawn.value} + armour ${actor.system.armourDice} + shield ${actor.system.shieldDice}`
|
||
}));
|
||
|
||
// Initiative
|
||
html.find(".roll-draw").click(async () => {
|
||
if (actor.inCombat) {
|
||
const c = game.combat?.combatants.find(c => c.actorId === actor.id);
|
||
if (c) return game.combat.rollInitiative([c.id]);
|
||
}
|
||
await rollPool(actor, 1, "The Draw (initiative)", { sublabel: "act highest to lowest — reroll each round" });
|
||
});
|
||
|
||
// Weapon attack
|
||
html.find(".item-attack").click(ev => {
|
||
const item = actor.items.get(ev.currentTarget.closest("[data-item-id]").dataset.itemId);
|
||
if (!item) return;
|
||
const group = item.system.group === "shoot" ? "shoot" : "fight";
|
||
const attrKey = KNACKS[group].attr;
|
||
const attr = actor.system.attributes[attrKey].value || 0;
|
||
let knackDice = actor.system.knacks[group].rank || 0;
|
||
let knackName = KNACKS[group].label;
|
||
// Martial Prowess is the Warrior's fighting knack when set
|
||
const locked = actor.system.locked;
|
||
if (group === "fight" && locked.name === "Martial Prowess") {
|
||
knackDice = Math.max(knackDice, Number(locked.rank) || 0);
|
||
knackName = "Martial Prowess";
|
||
}
|
||
promptAndRoll(actor, {
|
||
title: `${item.name} — attack`,
|
||
base: attr + knackDice + (Number(item.system.dice) || 0),
|
||
baseLabel: `${ATTRIBUTES[attrKey].label} ${attr} + ${knackName} ${knackDice} + weapon ${item.system.dice}`,
|
||
options: { context: "attack", sublabel: item.system.properties }
|
||
});
|
||
});
|
||
|
||
// Spell cast
|
||
html.find(".item-cast").click(ev => {
|
||
const item = actor.items.get(ev.currentTarget.closest("[data-item-id]").dataset.itemId);
|
||
if (!item) return;
|
||
if (item.system.spent) return ui.notifications.warn(`${item.name} is spent — recover it with a rest or ritual.`);
|
||
const listDef = SPELL_LISTS[item.system.list] ?? SPELL_LISTS.arcane;
|
||
const attr = actor.system.attributes[listDef.attr].value || 0;
|
||
const locked = actor.system.locked;
|
||
const knackDice = Number(locked.rank) || 0;
|
||
const flavor = (item.system.description ?? "").match(/<i>(.*?)<\/i>/)?.[1] ?? "";
|
||
promptAndRoll(actor, {
|
||
title: `Cast ${item.name}`,
|
||
base: attr + knackDice,
|
||
baseLabel: `${ATTRIBUTES[listDef.attr].label} ${attr} + ${locked.name || listDef.knack} ${knackDice} · Threshold ${item.system.threshold}`,
|
||
options: {
|
||
context: "spell",
|
||
threshold: Number(item.system.threshold) || 1,
|
||
spellUuid: item.uuid,
|
||
spell: {
|
||
img: item.img,
|
||
list: listDef.label,
|
||
school: item.system.list,
|
||
effect: item.system.effect,
|
||
scaling: item.system.scaling,
|
||
flavor
|
||
}
|
||
}
|
||
});
|
||
});
|
||
|
||
// Spell recover / spend toggle
|
||
html.find(".item-spent").click(async ev => {
|
||
const item = actor.items.get(ev.currentTarget.closest("[data-item-id]").dataset.itemId);
|
||
if (item) await item.update({ "system.spent": !item.system.spent });
|
||
});
|
||
|
||
// Armour equip toggle
|
||
html.find(".item-equip").click(async ev => {
|
||
const item = actor.items.get(ev.currentTarget.closest("[data-item-id]").dataset.itemId);
|
||
if (item) await item.update({ "system.equipped": !item.system.equipped });
|
||
});
|
||
|
||
// Item management
|
||
html.find(".item-edit").click(ev => {
|
||
const item = actor.items.get(ev.currentTarget.closest("[data-item-id]").dataset.itemId);
|
||
item?.sheet.render(true);
|
||
});
|
||
html.find(".item-delete").click(async ev => {
|
||
const item = actor.items.get(ev.currentTarget.closest("[data-item-id]").dataset.itemId);
|
||
if (item) await item.delete();
|
||
});
|
||
html.find(".item-create").click(async ev => {
|
||
const type = ev.currentTarget.dataset.type;
|
||
await actor.createEmbeddedDocuments("Item", [{ name: `New ${type}`, type }]);
|
||
});
|
||
|
||
// Breather: catch your breath in a quiet scene → +2 Grit (§5)
|
||
html.find(".rest-breather").click(async () => {
|
||
const g = actor.system.grit;
|
||
if (g.value >= g.max) return ui.notifications.info(`${actor.name} is already at full Grit.`);
|
||
await actor.update({ "system.grit.value": Math.min(g.max, g.value + 2) });
|
||
await ChatMessage.create({
|
||
speaker: ChatMessage.getSpeaker({ actor }),
|
||
content: `<div class="vanity-roll vanity-forge-card"><p><b>${actor.name}</b> catches their breath — <b>+2 Grit</b> (${actor.system.grit.value}/${g.max}).</p></div>`
|
||
});
|
||
});
|
||
|
||
// Proper rest: all Grit, clear 1 Bane, recover spent spells (§5, §17)
|
||
html.find(".rest-full").click(async () => {
|
||
const g = actor.system.grit;
|
||
const karma = Math.max(0, (actor.system.karma ?? 0) - 1);
|
||
await actor.update({ "system.grit.value": g.max, "system.karma": karma });
|
||
const spent = actor.items.filter(i => i.type === "spell" && i.system.spent);
|
||
if (spent.length) await actor.updateEmbeddedDocuments("Item", spent.map(i => ({ _id: i.id, "system.spent": false })));
|
||
await ChatMessage.create({
|
||
speaker: ChatMessage.getSpeaker({ actor }),
|
||
content: `<div class="vanity-roll vanity-forge-card"><p><b>${actor.name}</b> takes a proper rest: <b>Grit restored</b> (${g.max}/${g.max}), <b>1 Bane cleared</b> (tab ${karma})${spent.length ? `, <b>${spent.length} spell${spent.length > 1 ? "s" : ""} recovered</b>` : ""}.</p></div>`
|
||
});
|
||
});
|
||
|
||
// Refuse to Fall: 1 Vanity → stop at 1 Grit, +2 Banes (§5)
|
||
html.find(".refuse-fall").click(async () => {
|
||
if ((actor.system.vanity ?? 0) < 1) return ui.notifications.warn("Refusing to Fall costs 1 Vanity — the purse is empty.");
|
||
await actor.update({ "system.vanity": actor.system.vanity - 1, "system.grit.value": 1 });
|
||
await ChatMessage.create({
|
||
speaker: ChatMessage.getSpeaker({ actor }),
|
||
content: `<div class="vanity-roll vanity-forge-card"><p><b>${actor.name} REFUSES TO FALL</b> — still standing at <b>1 Grit</b>, one more beat. Fate notices.</p></div>`
|
||
});
|
||
await actor.addBanes(2, "Refused to Fall — cheating fate");
|
||
});
|
||
|
||
// Play the Vice: +1 Vanity now, the GM banks a Bane for later (§8a)
|
||
html.find(".vice-play").click(async ev => {
|
||
const item = actor.items.get(ev.currentTarget.closest("[data-item-id]").dataset.itemId);
|
||
if (!item) return;
|
||
await actor.update({ "system.vanity": Math.min(6, (actor.system.vanity ?? 0) + 1) });
|
||
await ChatMessage.create({
|
||
speaker: ChatMessage.getSpeaker({ actor }),
|
||
content: `<div class="vanity-roll vanity-forge-card"><p><b>${actor.name}</b> plays their Vice — <b>${item.name}</b> <i>(${item.system.trigger})</i>. <b>+1 Vanity</b> now (${actor.system.vanity}); the bill arrives later.</p></div>`
|
||
});
|
||
await actor.addBanes(1, `played their Vice — ${item.name}`);
|
||
});
|
||
|
||
// Conditions: click a badge to toggle the status (actor + tokens) and read it below
|
||
html.find(".cond-badge").click(async ev => {
|
||
const id = ev.currentTarget.dataset.cond;
|
||
this._focusCond = id;
|
||
await actor.toggleStatusEffect(id);
|
||
this.render(false);
|
||
});
|
||
// Click a name in the details panel to read it without toggling
|
||
html.find(".cond-read").click(ev => {
|
||
this._focusCond = ev.currentTarget.dataset.cond;
|
||
this.render(false);
|
||
});
|
||
|
||
// Companion roll
|
||
html.find(".companion-roll").click(() => {
|
||
const c = actor.system.companion;
|
||
if (!c?.name) return;
|
||
promptAndRoll(actor, { title: `${c.name} (companion)`, base: c.pool || 3, baseLabel: `Companion pool ${c.pool || 3}` });
|
||
});
|
||
}
|
||
}
|
||
|
||
class VanityNpcSheet extends foundry.appv1.sheets.ActorSheet {
|
||
static get defaultOptions() {
|
||
return foundry.utils.mergeObject(super.defaultOptions, {
|
||
classes: ["vanity", "sheet", "actor", "npc"],
|
||
template: "systems/vanity/templates/npc-sheet.hbs",
|
||
width: 520,
|
||
height: 560
|
||
});
|
||
}
|
||
|
||
async getData(options) {
|
||
const ctx = await super.getData(options);
|
||
ctx.sys = this.actor.system;
|
||
ctx.categories = NPC_CATEGORIES;
|
||
ctx.isNemesis = this.actor.system.category === "nemesis";
|
||
ctx.notesHTML = await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.actor.system.notes ?? "", { async: true });
|
||
ctx.editable = this.isEditable;
|
||
return ctx;
|
||
}
|
||
|
||
activateListeners(html) {
|
||
super.activateListeners(html);
|
||
if (!this.isEditable) return;
|
||
const actor = this.actor;
|
||
const sys = actor.system;
|
||
|
||
html.find(".npc-roll").click(ev => {
|
||
const which = ev.currentTarget.dataset.roll;
|
||
if (which === "attack1") return promptAndRoll(actor, { title: `${actor.name} — ${sys.attack1.name || "Attack"}`, base: sys.attack1.pool || 1, baseLabel: sys.attack1.note || "attack pool", options: { context: "attack", sublabel: sys.attack1.note } });
|
||
if (which === "attack2") return promptAndRoll(actor, { title: `${actor.name} — ${sys.attack2.name || "Attack"}`, base: sys.attack2.pool || 1, baseLabel: sys.attack2.note || "attack pool", options: { context: "attack", sublabel: sys.attack2.note } });
|
||
if (which === "defence") return promptAndRoll(actor, { title: `${actor.name} — defends`, base: sys.defence.pool || 1, baseLabel: sys.defence.note || "defence pool" });
|
||
if (which === "morale") return promptAndRoll(actor, { title: `${actor.name} — Morale`, base: sys.nerve || 2, baseLabel: "Nerve pool · 1 Success = they hold, 0 = they break" });
|
||
if (which === "reaction") return promptAndRoll(actor, { title: `${actor.name} — Reaction (§24)`, base: 2, baseLabel: "2 dice ± approach (add a PC's Charm Successes) · 0 Hostile · 1 Wary · 2 Neutral · 3+ Friendly" });
|
||
});
|
||
}
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
/* Item sheet */
|
||
/* -------------------------------------------- */
|
||
|
||
class VanityItemSheet extends foundry.appv1.sheets.ItemSheet {
|
||
static get defaultOptions() {
|
||
return foundry.utils.mergeObject(super.defaultOptions, {
|
||
classes: ["vanity", "sheet", "item"],
|
||
template: "systems/vanity/templates/item-sheet.hbs",
|
||
width: 480,
|
||
height: 420
|
||
});
|
||
}
|
||
|
||
async getData(options) {
|
||
const ctx = await super.getData(options);
|
||
ctx.sys = this.item.system;
|
||
ctx.spellLists = SPELL_LISTS;
|
||
ctx.descriptionHTML = await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.item.system.description ?? "", { async: true });
|
||
ctx.editable = this.isEditable;
|
||
return ctx;
|
||
}
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
/* Dice So Nice — the peacock dice, enforced */
|
||
/* -------------------------------------------- */
|
||
|
||
Hooks.once("diceSoNiceReady", dice3d => {
|
||
dice3d.addSystem({ id: "vanity", name: "VANITY — Peacock & Gold" }, "preferred");
|
||
|
||
dice3d.addColorset({
|
||
name: "vanity",
|
||
description: "VANITY — Peacock & Gold",
|
||
category: "VANITY",
|
||
foreground: "#e0c98a",
|
||
background: "#14544e",
|
||
outline: "#0e3f3a",
|
||
edge: "#b0872f",
|
||
material: "metal",
|
||
font: "Cinzel",
|
||
visibility: "visible"
|
||
}, "preferred");
|
||
|
||
// 5–6 wear the plume and the crown (Successes); 1 wears the Bane diamond.
|
||
dice3d.addDicePreset({
|
||
type: "d6",
|
||
labels: [
|
||
"systems/vanity/assets/dice/face1-bane.png",
|
||
"2", "3", "4",
|
||
"systems/vanity/assets/dice/face5-plume.png",
|
||
"systems/vanity/assets/dice/face6-crown.png"
|
||
],
|
||
system: "vanity",
|
||
colorset: "vanity"
|
||
});
|
||
|
||
// The Bane dice — blood-red, rolled only when the GM twists the knife.
|
||
dice3d.addColorset({
|
||
name: "vanity-bane",
|
||
description: "VANITY — The Tab (Bane dice)",
|
||
category: "VANITY",
|
||
foreground: "#f2e2b3",
|
||
background: "#8a1f1f",
|
||
outline: "#3d0d0d",
|
||
edge: "#e0c98a",
|
||
material: "metal",
|
||
font: "Cinzel",
|
||
visibility: "visible"
|
||
}, "default");
|
||
});
|
||
|
||
/* -------------------------------------------- */
|
||
/* Twist the Knife — the GM spends the tab */
|
||
/* -------------------------------------------- */
|
||
|
||
const TWIST_TABLE_NAME = "Twist the Knife — spending Banes (d66)";
|
||
const RECKONING_TABLE_NAME = "THE RECKONING — the tab reads six (2d6)";
|
||
|
||
async function getVanityTable(name) {
|
||
let table = game.tables.getName(name);
|
||
if (!table) {
|
||
const pack = game.packs.get("vanity.tables");
|
||
if (pack) table = (await pack.getDocuments()).find(d => d.name === name);
|
||
}
|
||
return table;
|
||
}
|
||
|
||
/** Roll dice on the playing surface in the blood-red Bane set, without ever blocking. */
|
||
async function showBaneDice(roll) {
|
||
for (const d of roll.dice) d.options.appearance = { colorset: "vanity-bane" };
|
||
if (game.dice3d && !game.settings.get("dice-so-nice", "animateRollTable")) {
|
||
await Promise.race([
|
||
game.dice3d.showForRoll(roll, game.user, true).catch(() => {}),
|
||
new Promise(res => setTimeout(res, 3500))
|
||
]);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* GM-only: the tab reads six — cash it. Rolls 2d6 on THE RECKONING with the
|
||
* red Bane dice, posts the result, and wipes the character's track to 0.
|
||
*/
|
||
async function reckoningNow({ actorUuid = "" } = {}) {
|
||
if (!game.user.isGM) return ui.notifications.warn("Only the GM may call the Reckoning.");
|
||
const table = await getVanityTable(RECKONING_TABLE_NAME);
|
||
if (!table) return ui.notifications.error(`"${RECKONING_TABLE_NAME}" not found in world or compendium.`);
|
||
|
||
const roll = new Roll("2d6");
|
||
await roll.evaluate();
|
||
await showBaneDice(roll);
|
||
// Foundry's table.draw({roll}) re-rolls internally — map our roll to its result so
|
||
// the red dice on the table and the posted card always agree.
|
||
const results = table.getResultsForRoll(roll.total);
|
||
await table.toMessage(results, { roll });
|
||
const draw = { roll, results };
|
||
|
||
if (actorUuid) {
|
||
const actor = await fromUuid(actorUuid);
|
||
if (actor?.type === "character") {
|
||
await actor.update({ "system.karma": 0 });
|
||
await ChatMessage.create({
|
||
speaker: { alias: "The Tab" },
|
||
content: `<div class="vanity-roll vanity-tab-note"><p><b>The tab is cashed in full.</b> ${actor.name}'s track is wiped to <b>0</b>. The universe starts a fresh page.</p></div>`
|
||
});
|
||
}
|
||
}
|
||
return draw;
|
||
}
|
||
|
||
/**
|
||
* GM-only: roll the d66 on Twist the Knife with the blood-red Bane dice.
|
||
* A paid twist (actorUuid set) deducts the row's Bane cost from the tab.
|
||
* A free twist (lone unbanked 1) burns the button on its source card.
|
||
*/
|
||
async function twistTheKnife({ actorUuid = "", free = false, sourceMessage = null } = {}) {
|
||
if (!game.user.isGM) return ui.notifications.warn("Only the GM may twist the knife.");
|
||
const table = await getVanityTable(TWIST_TABLE_NAME);
|
||
if (!table) return ui.notifications.error(`"${TWIST_TABLE_NAME}" not found in world or compendium.`);
|
||
|
||
const roll = new Roll("1d6*10 + 1d6");
|
||
await roll.evaluate();
|
||
await showBaneDice(roll);
|
||
// table.draw({roll}) re-rolls internally — map our roll to its result so the red dice
|
||
// and the posted card agree.
|
||
const results = table.getResultsForRoll(roll.total);
|
||
await table.toMessage(results, { roll });
|
||
const draw = { roll, results };
|
||
|
||
if (!free && actorUuid) {
|
||
const actor = await fromUuid(actorUuid);
|
||
if (actor?.type === "character") {
|
||
const cost = draw.roll.total >= 61 ? 2 : 1;
|
||
const karma = Math.max(0, (actor.system.karma ?? 0) - cost);
|
||
await actor.update({ "system.karma": karma });
|
||
await ChatMessage.create({
|
||
speaker: { alias: "The Tab" },
|
||
content: `<div class="vanity-roll vanity-tab-note"><p><b>${cost} Bane${cost > 1 ? "s" : ""} spent</b> against ${actor.name} — the tab now reads <b>${karma}</b> of 6.</p></div>`
|
||
});
|
||
}
|
||
}
|
||
|
||
if (free && sourceMessage?.flags?.vanity) {
|
||
const f = sourceMessage.flags.vanity;
|
||
await sourceMessage.update({
|
||
"flags.vanity.twistUsed": true,
|
||
content: renderRollCard({
|
||
label: f.label, sublabel: f.sublabel, results: f.results, threshold: f.threshold,
|
||
pushed: f.pushed, context: f.context, extra: f.extra, spend: f.spend,
|
||
banked: f.banked ?? 0, twistUsed: true, spell: f.spell ?? null
|
||
})
|
||
});
|
||
}
|
||
return draw;
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
/* THE FORGE — generators */
|
||
/* -------------------------------------------- */
|
||
|
||
const rnd = arr => arr[Math.floor(Math.random() * arr.length)];
|
||
const rollDice = (n, sides) => Array.from({ length: n }, () => Math.ceil(Math.random() * sides));
|
||
const sum = a => a.reduce((x, y) => x + y, 0);
|
||
|
||
const FORGE_NAMES = {
|
||
given: ["Aldous", "Brannoc", "Caswen", "Darrow", "Elsbeth", "Fenna", "Garrick", "Hesper", "Isolde", "Jorun",
|
||
"Kestrel", "Lirael", "Maera", "Nolwen", "Osric", "Petra", "Quill", "Rosamund", "Sable", "Tamsin",
|
||
"Ulric", "Vesna", "Wren", "Yorick", "Zinnia", "Bram", "Corvin", "Yrsa", "Pinch", "Lark"],
|
||
epithets: ["the Magnificent", "the Unbowed", "of the Gilded Hand", "the Peacock", "Thrice-Crowned",
|
||
"the Modest (a lie)", "of Nine Sorrows", "the Radiant", "Silver-Tongue", "the Immaculate",
|
||
"of the Long Shadow", "the Splendid", "Half-Famous", "the Well-Dressed", "of No Small Talent"],
|
||
surnames: ["Ashveil", "Blackbriar", "Copperfield", "Duskwither", "Emberly", "Fairweather", "Goldhollow",
|
||
"Harrowgate", "Ironquill", "Larkspur", "Mistvale", "Nightingale", "Oakmantle", "Pridewell",
|
||
"Quicksilver", "Ravencourt", "Silverstitch", "Thornbury", "Vainglory", "Winterbourne"]
|
||
};
|
||
|
||
/* ------------ class definitions for the hero forge ------------ */
|
||
|
||
const FORGE_CLASSES = {
|
||
Warrior: {
|
||
key: "brawn", base: 8, locked: { name: "Martial Prowess", attribute: "brawn" },
|
||
spread: { brawn: 3, flair: 2, wits: 2, poise: 2 },
|
||
knacks: { fight: 2, athletics: 1, command: 1 },
|
||
style: "Sword & Shield",
|
||
gear: ["Long sword", "Mail", "Shield", "Healer's kit"],
|
||
edges: ["Second Wind", "Press the Attack", "Weapon Master", "Measure the Foe / Presence of a Killer / Sunder the Way"],
|
||
concepts: ["The one who steps into the doorway", "A disgraced knight with excellent posture", "Sell-sword between better wars", "Shield-bearer of a broken oath"]
|
||
},
|
||
Rogue: {
|
||
key: "flair", base: 5, locked: { name: "Larceny", attribute: "flair" },
|
||
spread: { brawn: 2, flair: 4, wits: 2, poise: 1 },
|
||
knacks: { stealth: 2, notice: 1, shoot: 1, charm: 1 },
|
||
style: "Two-Weapon",
|
||
gear: ["Short sword", "Short sword", "Padded / Leather", "Thieves' tools", "Blade poison", "Smoke bomb"],
|
||
edges: ["Ambush", "Deadly Precision (Backstab)", "Evasion (Uncanny Dodge)", "Cunning Action", "Poisoner", "Slip Away", "Audacity"],
|
||
concepts: ["Guttersnipe with a professional's contempt for doors", "Retired cat-burglar (twice)", "A spy between employers", "Tomb-robber with impeccable manners"]
|
||
},
|
||
Ranger: {
|
||
key: "flair", base: 6, locked: { name: "Wildcraft", attribute: "wits" },
|
||
spread: { brawn: 2, flair: 3, wits: 2, poise: 2 },
|
||
knacks: { shoot: 2, survive: 1, notice: 1 },
|
||
style: "Ranged",
|
||
gear: ["Long bow", "Dagger", "Dagger", "Padded / Leather", "Hunter's kit"],
|
||
edges: ["Favoured Quarry", "Favoured Enemy", "Rapid Shot", "Animal Companion", "Skirmisher's Step", "Trackless Pathfinder"],
|
||
tricks: 3,
|
||
companions: [["Ash", "hawk"], ["Bracken", "hound"], ["Sorrel", "wolf"], ["Moth", "lynx"], ["Tatters", "raven"]],
|
||
concepts: ["Borderer who guards where the map goes blank", "Beast-friend, people-sceptic", "A vengeful hunter with one name left", "Warden of a forest that remembers"]
|
||
},
|
||
Mage: {
|
||
key: "wits", base: 2, locked: { name: "Arcana", attribute: "wits" },
|
||
spread: { brawn: 1, flair: 2, wits: 4, poise: 2 },
|
||
knacks: { lore: 1, notice: 1 },
|
||
style: "—",
|
||
gear: ["Quarterstaff", "Arcane focus / spellbook"],
|
||
edges: ["Arcane Might", "Free-flowing Power", "Reflexive Ward"],
|
||
spells: { list: "arcane", always: ["Firebolt"], t1: 2, t2: 1, t3: 1 },
|
||
concepts: ["The most dangerous thing in the room, briefly", "Scholar of what could be made so", "Expelled for being right", "Tower-trained, world-curious"]
|
||
},
|
||
Cleric: {
|
||
key: "poise", base: 6, locked: { name: "Faith", attribute: "poise" },
|
||
spread: { brawn: 2, flair: 2, wits: 1, poise: 4 },
|
||
knacks: { command: 1, fight: 1 },
|
||
style: "Sword & Shield",
|
||
gear: ["Mace", "Mail", "Shield", "Holy symbol"],
|
||
edges: ["Aegis of Faith", "Sacred Wrath", "The Creed"],
|
||
spells: { list: "divine", always: ["Mend", "Bless"], t1: 2, t2: 1, t3: 1 },
|
||
creeds: ["protect the helpless", "speak only truth", "leave no debt unpaid", "bury the dead properly", "never refuse hospitality", "humble the proud"],
|
||
concepts: ["The reason the hand still lives to strike again", "Conviction wearing mail", "A creed with legs", "Doubt's least favourite argument"]
|
||
}
|
||
};
|
||
|
||
async function packDocs(packName) {
|
||
const pack = game.packs.get(`vanity.${packName}`);
|
||
return pack ? await pack.getDocuments() : [];
|
||
}
|
||
|
||
function pickN(arr, n) {
|
||
const pool = [...arr];
|
||
const out = [];
|
||
while (n-- > 0 && pool.length) out.push(pool.splice(Math.floor(Math.random() * pool.length), 1)[0]);
|
||
return out;
|
||
}
|
||
|
||
/* ------------ Forge a Hero ------------ */
|
||
|
||
async function forgeHero({ name = "", className = "", wild = false } = {}) {
|
||
const cls = FORGE_CLASSES[className] ? className : rnd(Object.keys(FORGE_CLASSES));
|
||
const def = FORGE_CLASSES[cls];
|
||
name ||= `${rnd(FORGE_NAMES.given)} ${Math.random() < 0.5 ? rnd(FORGE_NAMES.surnames) : rnd(FORGE_NAMES.epithets)}`;
|
||
|
||
// Attributes — 9 points, each 1–4, key stat 3+
|
||
let attrs;
|
||
if (wild) {
|
||
attrs = { brawn: 1, flair: 1, wits: 1, poise: 1 };
|
||
attrs[def.key] = 3;
|
||
let left = 9 - 6;
|
||
while (left > 0) {
|
||
const k = rnd(Object.keys(attrs));
|
||
if (attrs[k] < 4) { attrs[k] += 1; left -= 1; }
|
||
}
|
||
} else {
|
||
attrs = { ...def.spread };
|
||
}
|
||
|
||
// Grit roll: 2d6, +1 per 5–6, cap 10
|
||
const gritDice = rollDice(2, 6);
|
||
const gritBonus = gritDice.filter(d => d >= 5).length;
|
||
const grit = Math.min(10, def.base + gritBonus);
|
||
|
||
// Knacks: class list + one free Common at Trained
|
||
const knacks = Object.fromEntries(Object.keys(KNACKS).map(k => [k, { rank: def.knacks[k] ?? 0 }]));
|
||
const untrained = Object.keys(KNACKS).filter(k => !knacks[k].rank);
|
||
const freeKnack = rnd(untrained);
|
||
knacks[freeKnack].rank = 1;
|
||
|
||
// Items from the compendia
|
||
const [weapons, armour, gear, spells, edges, vices] = await Promise.all(
|
||
["weapons", "armour", "gear", "spells", "edges", "vices"].map(packDocs));
|
||
const byName = new Map([...weapons, ...armour, ...gear, ...spells, ...edges, ...vices].map(d => [d.name, d]));
|
||
|
||
const items = [];
|
||
for (const n of def.gear) { const d = byName.get(n); if (d) items.push(d.toObject()); }
|
||
for (const n of def.edges) { const d = byName.get(n); if (d) items.push(d.toObject()); }
|
||
|
||
let spellNames = [];
|
||
if (def.spells) {
|
||
const list = spells.filter(s => s.system.list === def.spells.list && !def.spells.always.includes(s.name));
|
||
spellNames = [...def.spells.always,
|
||
...pickN(list.filter(s => s.system.threshold === 1), def.spells.t1).map(s => s.name),
|
||
...pickN(list.filter(s => s.system.threshold === 2), def.spells.t2).map(s => s.name),
|
||
...pickN(list.filter(s => s.system.threshold === 3), def.spells.t3).map(s => s.name)];
|
||
}
|
||
if (def.tricks) {
|
||
const tricks = spells.filter(s => s.system.list === "trick");
|
||
spellNames = ["Nature's Balm", ...pickN(tricks.filter(t => t.name !== "Nature's Balm"), def.tricks - 1).map(t => t.name)];
|
||
}
|
||
for (const n of spellNames) { const d = byName.get(n); if (d) items.push(d.toObject()); }
|
||
|
||
const vice = rnd(vices);
|
||
items.push(vice.toObject());
|
||
|
||
const companion = def.companions ? rnd(def.companions) : null;
|
||
const creed = def.creeds ? rnd(def.creeds) : null;
|
||
|
||
const actor = await Actor.create({
|
||
name, type: "character", img: "icons/svg/mystery-man.svg",
|
||
system: {
|
||
attributes: Object.fromEntries(Object.entries(attrs).map(([k, v]) => [k, { value: v }])),
|
||
grit: { value: grit, max: grit },
|
||
vanity: 3, karma: 0, glory: 0,
|
||
knacks,
|
||
locked: { ...def.locked, rank: 1 },
|
||
details: {
|
||
class: cls, concept: rnd(def.concepts), fightingStyle: def.style,
|
||
coin: { gp: Math.floor(Math.random() * 4), sp: Math.floor(Math.random() * 10), cp: 0 }
|
||
},
|
||
companion: companion
|
||
? { name: `${companion[0]} (${companion[1]})`, grit: { value: 3, max: 3 }, pool: 3, notes: "Help +1 die · Harry −1 die/flank · Guard (reaction)" }
|
||
: { name: "", grit: { value: 3, max: 3 }, pool: 3, notes: "" },
|
||
notes: creed ? `Creed: ${creed}.` : ""
|
||
},
|
||
items
|
||
});
|
||
|
||
await ChatMessage.create({
|
||
speaker: { alias: "The Forge" },
|
||
whisper: ChatMessage.getWhisperRecipients("GM"),
|
||
content: `<div class="vanity-roll vanity-forge-card">
|
||
<header><span class="vanity-roll-label">⚒ A hero steps forward</span>
|
||
<span class="vanity-roll-sub">${cls} · grit roll ${gritDice.join(", ")} → Grit ${grit}</span></header>
|
||
<p><b>@UUID[${actor.uuid}]{${name}}</b> — ${actor.system.details.concept}.</p>
|
||
<p>Brawn ${attrs.brawn} · Flair ${attrs.flair} · Wits ${attrs.wits} · Poise ${attrs.poise}
|
||
· free Knack: <b>${KNACKS[freeKnack].label}</b> · Vice: <b>${vice.name}</b>${companion ? ` · companion <b>${companion[0]} the ${companion[1]}</b>` : ""}${creed ? ` · creed: <i>${creed}</i>` : ""}</p>
|
||
</div>`
|
||
});
|
||
return actor;
|
||
}
|
||
|
||
/* ------------ Forge a Monster ------------ */
|
||
|
||
const FORGE_MONSTERS = {
|
||
beast: {
|
||
syll: ["Gnar", "Fang", "Rav", "Ur", "Skoll", "Bray", "Mor", "Hulk"],
|
||
tail: ["claw", "maw", "hide", "howl", "tusk", "pelt"],
|
||
icons: ["icons/creatures/mammals/wolf-shadow-black.webp", "icons/creatures/mammals/beast-horned-scaled-glowing-orange.webp", "icons/creatures/abilities/mouth-teeth-rows-red.webp"],
|
||
nerve: 3,
|
||
tricks: ["Knock Down for free on a hit.", "Pounce: +2 dice against anyone who moved this round.", "Savage: +1 die while Rattled.", "Gore: a hit can Drive Back + Knock Down.", "Scent: cannot be ambushed."]
|
||
},
|
||
humanoid: {
|
||
syll: ["Karg", "Vex", "Brann", "Skarn", "Mol", "Dreg", "Hark", "Tuss"],
|
||
tail: ["the Knife", "One-Eye", "the Lesser", "Ironjaw", "the Bought", "Halfhand"],
|
||
icons: ["icons/skills/melee/hand-grip-sword-red.webp", "icons/equipment/head/helm-barbute-brown-tan.webp", "icons/creatures/mammals/humanoid-fox-cat-archer.webp", "icons/creatures/mammals/humanoid-cat-skulking-teal.webp"],
|
||
nerve: 2,
|
||
tricks: ["Pack tactics: +1 die when flanking.", "Disciplined: shares Guard with an adjacent ally.", "Flees when the leader falls.", "Shield-wall: +1 defence die while adjacent to an ally.", "Dirty fighter: a hit can Disarm for free."]
|
||
},
|
||
undead: {
|
||
syll: ["Mort", "Grave", "Dur", "Vess", "Carn", "Hollow", "Pall", "Wight"],
|
||
tail: ["born", "bound", "risen", "of the Barrow", "the Unfed", "of Nine Sorrows"],
|
||
icons: ["icons/magic/death/undead-skeleton-fire-green.webp", "icons/magic/death/undead-ghost-strike-white.webp", "icons/magic/death/skull-energy-light-purple.webp", "icons/magic/death/hand-undead-skeleton-fire-pink.webp"],
|
||
nerve: 5,
|
||
tricks: ["Fearless; fights to destruction.", "Paralysing touch: on a hit, a free Called Shot freezes the victim a round.", "Drains 1 max Grit on a hit.", "Half harm from arrows (bones).", "Rises again next round unless the blow was declared final."]
|
||
},
|
||
fiend: {
|
||
syll: ["Baal", "Zar", "Malg", "Xul", "Vor", "Asha", "Krezz", "Nix"],
|
||
tail: ["of the Pit", "the Tempter", "Oathbreaker", "the Bargain", "Smoke-born"],
|
||
icons: ["icons/magic/unholy/hand-claw-fire-blue.webp", "icons/magic/death/skull-horned-goat-pentagram-red.webp", "icons/magic/unholy/hand-claw-fog-green.webp"],
|
||
nerve: 4,
|
||
tricks: ["Attacks ignore 1 armour die (hellfire claws).", "Offers a bargain mid-fight — accepting is a Vice trigger.", "Immune to fire; doused by holy water.", "Terror: first sight forces a Poise save or −1 die this scene."]
|
||
},
|
||
giant: {
|
||
syll: ["Gor", "Thrum", "Bolg", "Hrun", "Mag", "Ymir", "Krag"],
|
||
tail: ["the Mountain", "Stonefist", "the Hungry", "Skullkeeper"],
|
||
icons: ["icons/creatures/magical/humanoid-giant-forest-blue.webp"],
|
||
nerve: 3,
|
||
tricks: ["A hit can Drive Back + Knock Down.", "Sweep: Cleave costs 1 less Success.", "Hurls boulders: Shoot-range attack at full pool.", "Regenerates 2 Grit a round unless the wound was fire or acid."]
|
||
},
|
||
dragonkin: {
|
||
syll: ["Vyr", "Ssath", "Drak", "Kessa", "Ryx", "Onyx", "Cindra"],
|
||
tail: ["the Gilded", "Ember-Tongue", "of the High Ledge", "Scale-Proud"],
|
||
icons: ["icons/creatures/abilities/dragon-fire-breath-orange.webp", "icons/creatures/abilities/dragon-ice-breath-blue.webp", "icons/creatures/abilities/dragon-breath-purple.webp"],
|
||
nerve: 5,
|
||
tricks: ["Breath: area attack, ignores armour, once every other round.", "Plate-like scales: block +1 die.", "Vain as any king — flattery buys a round of talk (and a Vice trigger).", "Takes wing at half Grit."]
|
||
},
|
||
vermin: {
|
||
syll: ["Skit", "Chit", "Gnash", "Squirm", "Blight", "Scur"],
|
||
tail: ["swarm", "brood", "tide", "nest-mother"],
|
||
icons: ["icons/creatures/mammals/rodent-rat-green.webp", "icons/creatures/mammals/bat-giant-tattered-purple.webp", "icons/creatures/mammals/rodent-rat-diseaed-gray.webp"],
|
||
nerve: 2,
|
||
tricks: ["Swarms; hard to hit with single blows.", "Venomous: a hit adds a free Wound.", "Skitters through any gap; ignores difficult ground.", "Gnaws gear: on a Bane spent, ruins one mundane item."]
|
||
},
|
||
aberration: {
|
||
syll: ["Xoth", "Ylg", "Quor", "Nhal", "Vhu", "Zsske"],
|
||
tail: ["the Unshaped", "of the Deep Dark", "Which Watches", "the Wrong Angle"],
|
||
icons: ["icons/creatures/eyes/eye-ringed-glow-angry-large-teal.webp", "icons/magic/perception/eye-ringed-glow-angry-large-red.webp"],
|
||
nerve: 5,
|
||
tricks: ["Wits save on first sight or lose your action gazing.", "Incorporeal: only magic or blessed weapons bite.", "Reads intentions: cannot be Feinted; ambushes cost +1 Success.", "Its wounds whisper — each hit on it gives the striker 1 Bane."]
|
||
}
|
||
};
|
||
|
||
const MENACE = {
|
||
mook: { label: "Mook", atk: [2, 3], def: [2, 2], grit: [1, 2], resolve: 0 },
|
||
standard: { label: "Standard", atk: [4, 5], def: [3, 5], grit: [4, 6], resolve: 0 },
|
||
threat: { label: "Threat", atk: [5, 6], def: [3, 4], grit: [10, 12], resolve: 0 },
|
||
nemesis: { label: "Nemesis", atk: [6, 7], def: [4, 6], grit: [12, 16], resolve: 3 }
|
||
};
|
||
|
||
const between = ([a, b]) => a + Math.floor(Math.random() * (b - a + 1));
|
||
|
||
async function forgeMonster({ type = "", menace = "", name = "", silent = false, folderId = null } = {}) {
|
||
const t = FORGE_MONSTERS[type] ? type : rnd(Object.keys(FORGE_MONSTERS));
|
||
const m = MENACE[menace] ? menace : rnd(["mook", "standard", "standard", "threat", "nemesis"]);
|
||
const def = FORGE_MONSTERS[t];
|
||
const tier = MENACE[m];
|
||
|
||
if (!name) {
|
||
const base = `${rnd(def.syll)}${rnd(def.syll).toLowerCase()}`;
|
||
const tail = rnd(def.tail);
|
||
// suffix-style tails glue on ("Morthollow-born"); title-style tails stand apart
|
||
name = /^(the |of |[A-Z])/.test(tail) ? `${base} ${tail}` : `${base} ${tail.charAt(0).toUpperCase()}${tail.slice(1)}`;
|
||
}
|
||
const trick = rnd(def.tricks);
|
||
const grit = between(tier.grit);
|
||
|
||
const actor = await Actor.create({
|
||
name: name.charAt(0).toUpperCase() + name.slice(1),
|
||
type: "npc",
|
||
folder: folderId,
|
||
img: rnd(def.icons),
|
||
system: {
|
||
category: m,
|
||
attack1: { name: "Attack", pool: between(tier.atk), note: "" },
|
||
attack2: m === "nemesis" ? { name: "Second act", pool: between(tier.atk), note: "second action each round" } : { name: "", pool: 0, note: "" },
|
||
defence: { pool: between(tier.def), note: "" },
|
||
grit: { value: grit, max: grit },
|
||
resolve: { value: tier.resolve, max: tier.resolve },
|
||
nerve: def.nerve,
|
||
trick,
|
||
notes: m === "nemesis" ? `${tier.label} ${t}. Two actions/round · cap single hits at 4 · PHASE at half Grit (${Math.floor(grit / 2)}): change tactics, telegraphed a round ahead.` : `${tier.label} ${t}.`
|
||
}
|
||
});
|
||
|
||
if (!silent) await ChatMessage.create({
|
||
speaker: { alias: "The Forge" },
|
||
whisper: ChatMessage.getWhisperRecipients("GM"),
|
||
content: `<div class="vanity-roll vanity-forge-card">
|
||
<header><span class="vanity-roll-label">⚒ Something stirs</span>
|
||
<span class="vanity-roll-sub">${tier.label} ${t}</span></header>
|
||
<p><b>@UUID[${actor.uuid}]{${actor.name}}</b> — attack ${actor.system.attack1.pool}d · defence ${actor.system.defence.pool}d · Grit ${grit}${tier.resolve ? ` · Resolve ${tier.resolve}` : ""} · Nerve ${def.nerve}</p>
|
||
<p><i>${trick}</i></p>
|
||
</div>`
|
||
});
|
||
return actor;
|
||
}
|
||
|
||
/* ------------ Forge a Face (NPC) ------------ */
|
||
|
||
const FORGE_FACES = {
|
||
occupations: ["innkeeper", "grave-digger", "town watch sergeant", "moneylender", "chandler", "midwife", "rat-catcher",
|
||
"wandering friar", "silk merchant", "blacksmith", "herbalist", "ferryman", "scribe", "fence", "minstrel",
|
||
"beggar-king", "tax collector", "horse trader", "washerwoman who knows everything", "retired sell-sword",
|
||
"apprentice mage (expelled)", "priest of a very small god", "gong farmer", "portrait painter"],
|
||
quirks: ["never says a name twice", "collects buttons from the dead", "laughs at the wrong moments", "immaculately dressed, always",
|
||
"keeps a peacock on a leash", "speaks of themselves in the third person", "quotes their late mother constantly",
|
||
"wildly superstitious about crows", "owes everyone a small favour", "smells faintly of church incense",
|
||
"writes everything down in a little book", "chews fennel seeds", "won't cross running water", "flinches at bells",
|
||
"is missing the same finger on both hands", "claims to have met a king once", "always eating an apple", "hums when lying"],
|
||
wants: ["coin, quickly and quietly", "a letter delivered unopened", "revenge dressed as justice", "to be admired by the right people",
|
||
"out of a bad bargain", "a missing sibling found", "protection from someone dangerous", "a secret kept buried",
|
||
"to leave this town forever", "an heirloom recovered", "someone else blamed", "a rival humiliated in public",
|
||
"a debt forgiven", "one night of real importance"],
|
||
secrets: ["informs for the town watch", "is not who the gravestone says they are", "hides a fugitive in the cellar",
|
||
"owes the moneylender ruinously", "saw what came out of the barrow", "is gently, hopelessly cursed",
|
||
"sells to both sides", "was beautiful once and never recovered", "keeps a stolen holy relic under the floor",
|
||
"poisoned a spouse (allegedly)", "is the by-blow of minor nobility", "belongs to a very quiet cult"],
|
||
icons: ["icons/skills/social/diplomacy-handshake-yellow.webp", "icons/skills/social/diplomacy-handshake-blue.webp",
|
||
"icons/sundries/documents/document-sealed-brown-red.webp", "icons/tools/hand/hammer-and-nail.webp"]
|
||
};
|
||
|
||
async function forgeFace({ name = "", silent = false, folderId = null } = {}) {
|
||
name ||= `${rnd(FORGE_NAMES.given)} ${rnd(FORGE_NAMES.surnames)}`;
|
||
const occupation = rnd(FORGE_FACES.occupations);
|
||
const quirk = rnd(FORGE_FACES.quirks);
|
||
const want = rnd(FORGE_FACES.wants);
|
||
const secret = rnd(FORGE_FACES.secrets);
|
||
|
||
// Reaction roll — 2 dice, 5–6 = Success (§24)
|
||
const reactionDice = rollDice(2, 6);
|
||
const rs = reactionDice.filter(d => d >= 5).length;
|
||
const mood = ["Hostile", "Wary", "Neutral", "Friendly"][Math.min(rs, 3)];
|
||
|
||
const grit = 1 + Math.floor(Math.random() * 2);
|
||
const actor = await Actor.create({
|
||
name, type: "npc", folder: folderId, img: rnd(FORGE_FACES.icons),
|
||
system: {
|
||
category: "mook",
|
||
attack1: { name: "Scuffle", pool: 2, note: "civilian" },
|
||
attack2: { name: "", pool: 0, note: "" },
|
||
defence: { pool: 2, note: "dodge" },
|
||
grit: { value: grit, max: grit },
|
||
resolve: { value: 0, max: 0 },
|
||
nerve: 2,
|
||
trick: `Quirk: ${quirk}.`,
|
||
notes: `${occupation.charAt(0).toUpperCase() + occupation.slice(1)}. First reaction: ${mood}.\nWants: ${want}.\nSecret: ${secret}.`
|
||
}
|
||
});
|
||
|
||
if (!silent) await ChatMessage.create({
|
||
speaker: { alias: "The Forge" },
|
||
whisper: ChatMessage.getWhisperRecipients("GM"),
|
||
content: `<div class="vanity-roll vanity-forge-card">
|
||
<header><span class="vanity-roll-label">⚒ A face in the crowd</span>
|
||
<span class="vanity-roll-sub">reaction ${reactionDice.join(", ")} → <b>${mood}</b></span></header>
|
||
<p><b>@UUID[${actor.uuid}]{${name}}</b>, ${occupation} — ${quirk}.</p>
|
||
<p>Wants <i>${want}</i>. Secret: <i>${secret}</i></p>
|
||
</div>`
|
||
});
|
||
return actor;
|
||
}
|
||
|
||
/* ------------ Forge a Hoard (treasure) ------------ */
|
||
|
||
const FORGE_TRINKETS = [
|
||
["A silver hand-mirror that always flatters", 8],
|
||
["A peacock-plume brooch, eye still watching", 5],
|
||
["A gilded death mask of a forgotten magistrate", 12],
|
||
["Opera gloves embroidered with someone else's initials", 3],
|
||
["A ring of braided hair under glass", 4],
|
||
["A tiny portrait locket — the face has been scratched out", 6],
|
||
["A crystal decanter that rings a perfect A when struck", 9],
|
||
["Ivory dice, subtly loaded toward sixes", 7],
|
||
["A signet ring for a house that no longer exists", 10],
|
||
["A vial of perfume that smells like rain on stone", 5],
|
||
["A silk banner from a tournament nobody admits losing", 6],
|
||
["A jewelled shoe buckle (just the one)", 4],
|
||
["A love letter, sealed, addressed only to 'You'", 2],
|
||
["An enamelled snuffbox with a hidden second lid", 8],
|
||
["A saint's fingerbone in a gold reliquary (provenance dubious)", 15],
|
||
["A courtier's fan painted with a scandalous scene", 7],
|
||
["A chess queen carved from jet, warm to the touch", 9],
|
||
["Spectacles that make everything look slightly grander", 11]
|
||
];
|
||
|
||
const FORGE_CENTERPIECES = [
|
||
["A life-size gilt statue of its previous owner, mid-flourish", 60],
|
||
["A peacock throne in miniature — a chair for a cat, solid silver", 45],
|
||
["A chandelier of stag horn and rock crystal", 50],
|
||
["A full-length mirror in a frame of golden laurels", 40],
|
||
["A tapestry of a battle that never happened, victors clearly labelled", 35],
|
||
["A jewelled crown sized for a child king", 80]
|
||
];
|
||
|
||
const FORGE_HOOKS = [
|
||
"Someone knows exactly what was in here, and will notice.",
|
||
"One coin in the pile is minted with next year's date.",
|
||
"The previous owner's rival would pay double to hear of this.",
|
||
"It is all subtly monogrammed. Fencing it will take a professional.",
|
||
"A beggar watched them carry it in, years ago. He remembers.",
|
||
"The centerpiece is famous. Displaying it is a Vice trigger.",
|
||
"A tithe is owed on it to a temple that keeps excellent records.",
|
||
"It's cursed, mildly: the owner dreams of its old master weekly."
|
||
];
|
||
|
||
const HOARDS = {
|
||
pocket: { label: "Pocket", coin: () => `${sum(rollDice(2, 6))} sp`, draws: 0, consum: 0.3, trinkets: [0, 1], hook: 0.15 },
|
||
cache: { label: "Cache", coin: () => `${sum(rollDice(1, 6))} gp, ${sum(rollDice(2, 6))} sp`, draws: 1, consum: 0.8, trinkets: [0, 1], hook: 0.3 },
|
||
chest: { label: "Chest", coin: () => `${sum(rollDice(4, 6))} gp`, draws: 2, consum: 1, trinkets: [1, 1], hook: 0.5 },
|
||
vault: { label: "Vault", coin: () => `${sum(rollDice(2, 6)) * 10} gp`, draws: 3, consum: 1, trinkets: [1, 2], hook: 1 },
|
||
kingly: { label: "Kingly", coin: () => `${sum(rollDice(6, 6)) * 10} gp`, draws: 5, consum: 1, trinkets: [2, 2], hook: 1, centerpiece: true }
|
||
};
|
||
|
||
async function forgeHoard({ size = "chest" } = {}) {
|
||
const tier = HOARDS[size] ?? HOARDS.chest;
|
||
const [weapons, armour, gear] = await Promise.all(["weapons", "armour", "gear"].map(packDocs));
|
||
const consumables = gear.filter(g => g.system.consumable);
|
||
const mundane = [...weapons, ...armour, ...gear.filter(g => !g.system.consumable)];
|
||
|
||
const lines = [];
|
||
lines.push(`<b>Coin:</b> ${tier.coin()}`);
|
||
|
||
const found = [];
|
||
if (Math.random() < tier.consum) found.push(rnd(consumables));
|
||
for (let i = 0; i < tier.draws; i++) found.push(rnd(mundane));
|
||
if (found.length) lines.push(`<b>Goods:</b> ${found.map(d => `@UUID[${d.uuid}]{${d.name}}`).join(" · ")}`);
|
||
|
||
const nTr = between(tier.trinkets);
|
||
if (nTr) lines.push(`<b>Vanities:</b> ${pickN(FORGE_TRINKETS, nTr).map(([t, v]) => `${t} <i>(${v} gp)</i>`).join(" · ")}`);
|
||
|
||
if (tier.centerpiece) {
|
||
const [c, v] = rnd(FORGE_CENTERPIECES);
|
||
lines.push(`<b>Centerpiece:</b> ${c} <i>(${v} gp — displayed during a carouse, it counts double toward Glory)</i>`);
|
||
}
|
||
if (Math.random() < tier.hook) lines.push(`<b>The catch:</b> <i>${rnd(FORGE_HOOKS)}</i>`);
|
||
|
||
await ChatMessage.create({
|
||
speaker: { alias: "The Forge" },
|
||
whisper: ChatMessage.getWhisperRecipients("GM"),
|
||
content: `<div class="vanity-roll vanity-forge-card">
|
||
<header><span class="vanity-roll-label">⚒ ${tier.label} hoard</span>
|
||
<span class="vanity-roll-sub">gold you cling to buys nothing — gold you squander buys legend (§27)</span></header>
|
||
${lines.map(l => `<p>${l}</p>`).join("")}
|
||
</div>`
|
||
});
|
||
}
|
||
|
||
/* ------------ Forge dialogs & directory buttons ------------ */
|
||
|
||
function forgeHeroDialog() {
|
||
new Dialog({
|
||
title: "The Forge — a Hero",
|
||
content: `<form class="vanity-roll-dialog">
|
||
<div class="form-group"><label>Name (blank = fate decides)</label><input type="text" name="name"></div>
|
||
<div class="form-group"><label>Class</label><select name="cls">
|
||
<option value="">Random</option>
|
||
${Object.keys(FORGE_CLASSES).map(c => `<option value="${c}">${c}</option>`).join("")}
|
||
</select></div>
|
||
<div class="form-group"><label>Wild attribute spread (random, key stat 3+)</label><input type="checkbox" name="wild"></div>
|
||
</form>`,
|
||
buttons: {
|
||
forge: {
|
||
icon: '<i class="fa-solid fa-hammer"></i>', label: "Forge",
|
||
callback: html => {
|
||
const f = html[0].querySelector("form");
|
||
forgeHero({ name: f.elements.name.value.trim(), className: f.elements.cls.value, wild: f.elements.wild.checked });
|
||
}
|
||
}
|
||
},
|
||
default: "forge"
|
||
}).render(true);
|
||
}
|
||
|
||
function forgeMonsterDialog() {
|
||
new Dialog({
|
||
title: "The Forge — a Monster",
|
||
content: `<form class="vanity-roll-dialog">
|
||
<div class="form-group"><label>Name (blank = fate decides)</label><input type="text" name="name"></div>
|
||
<div class="form-group"><label>Kind</label><select name="type">
|
||
<option value="">Random</option>
|
||
${Object.keys(FORGE_MONSTERS).map(t => `<option value="${t}">${t}</option>`).join("")}
|
||
</select></div>
|
||
<div class="form-group"><label>Menace</label><select name="menace">
|
||
<option value="">Random</option>
|
||
${Object.entries(MENACE).map(([k, v]) => `<option value="${k}">${v.label}</option>`).join("")}
|
||
</select></div>
|
||
</form>`,
|
||
buttons: {
|
||
forge: {
|
||
icon: '<i class="fa-solid fa-hammer"></i>', label: "Forge",
|
||
callback: html => {
|
||
const f = html[0].querySelector("form");
|
||
forgeMonster({ name: f.elements.name.value.trim(), type: f.elements.type.value, menace: f.elements.menace.value });
|
||
}
|
||
}
|
||
},
|
||
default: "forge"
|
||
}).render(true);
|
||
}
|
||
|
||
function forgeHoardDialog() {
|
||
new Dialog({
|
||
title: "The Forge — a Hoard",
|
||
content: `<form class="vanity-roll-dialog">
|
||
<div class="form-group"><label>How big?</label><select name="size">
|
||
${Object.entries(HOARDS).map(([k, v]) => `<option value="${k}" ${k === "chest" ? "selected" : ""}>${v.label}</option>`).join("")}
|
||
</select></div>
|
||
</form>`,
|
||
buttons: {
|
||
forge: {
|
||
icon: '<i class="fa-solid fa-coins"></i>', label: "Pour it out",
|
||
callback: html => forgeHoard({ size: html[0].querySelector("form").elements.size.value })
|
||
}
|
||
},
|
||
default: "forge"
|
||
}).render(true);
|
||
}
|
||
|
||
Hooks.on("renderActorDirectory", (app, html) => {
|
||
if (!game.user.isGM) return;
|
||
const el = html instanceof HTMLElement ? html : html[0];
|
||
if (el.querySelector(".vanity-forge")) return;
|
||
const bar = document.createElement("div");
|
||
bar.className = "vanity-forge";
|
||
bar.innerHTML = `
|
||
<span class="forge-title">The Forge</span>
|
||
<button type="button" data-forge="hero" title="Generate a ready-to-play character"><i class="fa-solid fa-user-plus"></i> Hero</button>
|
||
<button type="button" data-forge="monster" title="Generate a monster (§20)"><i class="fa-solid fa-dragon"></i> Monster</button>
|
||
<button type="button" data-forge="face" title="Generate a townsfolk NPC with wants and secrets"><i class="fa-solid fa-masks-theater"></i> NPC</button>
|
||
<button type="button" data-forge="hoard" title="Generate treasure worth carousing away"><i class="fa-solid fa-coins"></i> Hoard</button>
|
||
<button type="button" data-forge="encounter" title="Foes, situation, terrain, complication and loot"><i class="fa-solid fa-swords"></i> Encounter</button>
|
||
<button type="button" data-forge="stage" title="Raise a generated battlemap with walls, doors and lights"><i class="fa-solid fa-map"></i> Stage</button>
|
||
<button type="button" data-forge="carouse" title="Burn gold for Glory, then face the Morning After"><i class="fa-solid fa-wine-glass"></i> Carouse</button>
|
||
<button type="button" data-forge="adventure" title="A complete one-shot: patron, job, villain, map, twist and loot"><i class="fa-solid fa-scroll"></i> Adventure</button>
|
||
<button type="button" data-forge="vaincrown" title="Stage the whole Vain Crown: village, fight, forest, barrow — maps, NPCs, foes, treasure"><i class="fa-solid fa-crown"></i> Vain Crown</button>`;
|
||
bar.addEventListener("click", ev => {
|
||
const which = ev.target.closest("[data-forge]")?.dataset.forge;
|
||
if (which === "hero") forgeHeroDialog();
|
||
else if (which === "monster") forgeMonsterDialog();
|
||
else if (which === "face") forgeFace();
|
||
else if (which === "hoard") forgeHoardDialog();
|
||
else if (which === "encounter") forgeEncounterDialog();
|
||
else if (which === "stage") forgeStageDialog();
|
||
else if (which === "carouse") carouseDialog();
|
||
else if (which === "adventure") forgeAdventureDialog();
|
||
else if (which === "vaincrown") {
|
||
Dialog.confirm({ title: "Stage The Vain Crown?",
|
||
content: "<p>This builds <b>four scenes</b> (village, the green, the wood, the barrow), places <b>every NPC, beast and foe</b> as tokens, rolls the finale hoard, and writes the full adventure journal. It takes a minute and creates a lot of content.</p>",
|
||
yes: () => stageVainCrown() });
|
||
}
|
||
});
|
||
(el.querySelector(".directory-footer") ?? el).appendChild(bar);
|
||
});
|
||
|
||
/* -------------------------------------------- */
|
||
/* Content import (first launch of a world) */
|
||
/* -------------------------------------------- */
|
||
|
||
async function offerContentImport() {
|
||
if (!game.user.isGM) return;
|
||
if (game.settings.get("vanity", "contentImported")) return;
|
||
if (game.journal.size > 0 || game.actors.size > 0) return; // not a fresh world
|
||
|
||
new Dialog({
|
||
title: "VANITY — set the stage?",
|
||
content: `<p style="font-size:1.05em">Import everything into this world? You'll get the <b>Draft 10 rulebook</b>,
|
||
the <b>GM screen</b>, the adventure <b>The Vain Crown</b>, the <b>bestiary</b>, the <b>five ready-to-play heroes</b>,
|
||
and all <b>gear, spells and roll tables</b>, filed into tidy folders.</p>
|
||
<p><em>You can always import later from the Compendium tab.</em></p>`,
|
||
buttons: {
|
||
yes: {
|
||
icon: '<i class="fa-solid fa-crown"></i>',
|
||
label: "Import it all",
|
||
callback: async () => {
|
||
for (const pack of game.packs.filter(p => p.metadata.packageName === "vanity")) {
|
||
await pack.importAll({ folderName: pack.metadata.label.replace("VANITY · ", "") });
|
||
}
|
||
await game.settings.set("vanity", "contentImported", true);
|
||
ui.notifications.info("VANITY: all content imported. Break a leg — gloriously.");
|
||
}
|
||
},
|
||
later: { icon: '<i class="fa-solid fa-clock"></i>', label: "Not now" },
|
||
never: {
|
||
icon: '<i class="fa-solid fa-xmark"></i>',
|
||
label: "Don't ask again",
|
||
callback: () => game.settings.set("vanity", "contentImported", true)
|
||
}
|
||
},
|
||
default: "yes"
|
||
}).render(true);
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
/* Init */
|
||
/* -------------------------------------------- */
|
||
|
||
Hooks.once("init", () => {
|
||
console.log("VANITY | Be vain and you shine — but the brighter you burn, the bigger the bill.");
|
||
|
||
// Conditions become one-click token markers (§11b/§32).
|
||
CONFIG.statusEffects = VANITY_CONDITIONS.map(c => ({
|
||
id: c.id,
|
||
name: c.name,
|
||
img: `systems/vanity/assets/conditions/${c.id}.png`,
|
||
_vanity: { short: c.short, ends: c.ends, group: c.group }
|
||
}));
|
||
CONFIG.specialStatusEffects.DEFEATED = "taken-out";
|
||
|
||
CONFIG.Actor.documentClass = VanityActor;
|
||
CONFIG.Item.documentClass = VanityItem;
|
||
CONFIG.Combat.initiative = { formula: "1d6", decimals: 0 };
|
||
|
||
game.vanity = {
|
||
rollPool, promptAndRoll, ATTRIBUTES, KNACKS, MANEUVERS,
|
||
spend: handleSpend, push: handlePush, twist: twistTheKnife, reckoning: reckoningNow, vainCrown: stageVainCrown,
|
||
forge: { hero: forgeHero, monster: forgeMonster, face: forgeFace, hoard: forgeHoard, encounter: forgeEncounter, stage: forgeStage, adventure: forgeAdventure },
|
||
carouse
|
||
};
|
||
|
||
foundry.documents.collections.Actors.unregisterSheet("core", foundry.appv1.sheets.ActorSheet);
|
||
foundry.documents.collections.Actors.registerSheet("vanity", VanityActorSheet, {
|
||
types: ["character"], makeDefault: true, label: "VANITY Character Sheet"
|
||
});
|
||
foundry.documents.collections.Actors.registerSheet("vanity", VanityNpcSheet, {
|
||
types: ["npc"], makeDefault: true, label: "VANITY NPC Statblock"
|
||
});
|
||
foundry.documents.collections.Items.unregisterSheet("core", foundry.appv1.sheets.ItemSheet);
|
||
foundry.documents.collections.Items.registerSheet("vanity", VanityItemSheet, { makeDefault: true, label: "VANITY Item Sheet" });
|
||
|
||
game.settings.register("vanity", "contentImported", {
|
||
name: "Starter content imported", scope: "world", config: false, type: Boolean, default: false
|
||
});
|
||
game.settings.register("vanity", "rerollInitiative", {
|
||
name: "Reroll The Draw every round",
|
||
hint: "Initiative is 1d6, rerolled at the top of every round, as the rules intend.",
|
||
scope: "world", config: true, type: Boolean, default: true
|
||
});
|
||
|
||
// Fonts available to journals & drawings
|
||
CONFIG.fontDefinitions["Cinzel"] = {
|
||
editor: true,
|
||
fonts: [
|
||
{ urls: ["systems/vanity/fonts/Cinzel-SemiBold.woff2"], weight: 600 },
|
||
{ urls: ["systems/vanity/fonts/Cinzel-Bold.woff2"], weight: 700 }
|
||
]
|
||
};
|
||
CONFIG.fontDefinitions["EB Garamond"] = {
|
||
editor: true,
|
||
fonts: [
|
||
{ urls: ["systems/vanity/fonts/EBGaramond-Regular.woff2"], weight: 400 },
|
||
{ urls: ["systems/vanity/fonts/EBGaramond-Italic.woff2"], weight: 400, style: "italic" },
|
||
{ urls: ["systems/vanity/fonts/EBGaramond-Medium.woff2"], weight: 500 }
|
||
]
|
||
};
|
||
|
||
// Handlebars helpers
|
||
Handlebars.registerHelper("eq", (a, b) => a === b);
|
||
Handlebars.registerHelper("gt", (a, b) => Number(a) > Number(b));
|
||
Handlebars.registerHelper("add", (a, b) => (Number(a) || 0) + (Number(b) || 0));
|
||
Handlebars.registerHelper("checkedIf", v => (v ? "checked" : ""));
|
||
Handlebars.registerHelper("concat", (...args) => args.slice(0, -1).join(""));
|
||
});
|
||
|
||
Hooks.once("ready", () => {
|
||
offerContentImport();
|
||
});
|
||
|
||
/* Reroll The Draw at the top of each round. */
|
||
Hooks.on("combatRound", async (combat, updateData, updateOptions) => {
|
||
if (!game.user.isGM) return;
|
||
if (!game.settings.get("vanity", "rerollInitiative")) return;
|
||
if ((updateOptions?.direction ?? 1) < 0) return;
|
||
await combat.resetAll();
|
||
await combat.rollAll();
|
||
});
|
||
|
||
/* Chat card buttons. */
|
||
Hooks.on("renderChatMessageHTML", (message, html) => {
|
||
html.querySelectorAll(".vanity-push").forEach(btn => {
|
||
btn.addEventListener("click", () => {
|
||
if (!game.user.isGM && message.author?.id !== game.user.id) {
|
||
return ui.notifications.warn("Only the roller (or the GM) may Push.");
|
||
}
|
||
handlePush(message);
|
||
});
|
||
});
|
||
html.querySelectorAll(".vanity-fizzle").forEach(btn => {
|
||
btn.addEventListener("click", () => {
|
||
if (!game.user.isGM && message.author?.id !== game.user.id) return;
|
||
handleFizzle(message);
|
||
});
|
||
});
|
||
html.querySelectorAll(".vanity-spend button").forEach(btn => {
|
||
btn.addEventListener("click", () => {
|
||
if (!game.user.isGM && message.author?.id !== game.user.id) {
|
||
return ui.notifications.warn("Only the roller (or the GM) may spend Successes.");
|
||
}
|
||
handleSpend(message, btn.dataset);
|
||
});
|
||
});
|
||
html.querySelectorAll(".vanity-twist").forEach(btn => {
|
||
btn.addEventListener("click", () => {
|
||
if (!game.user.isGM) return ui.notifications.warn("Only the GM may twist the knife.");
|
||
twistTheKnife({
|
||
actorUuid: btn.dataset.actorUuid ?? "",
|
||
free: btn.dataset.free === "true",
|
||
sourceMessage: btn.dataset.free === "true" ? message : null
|
||
});
|
||
});
|
||
});
|
||
html.querySelectorAll(".vanity-reckon").forEach(btn => {
|
||
btn.addEventListener("click", () => {
|
||
if (!game.user.isGM) return ui.notifications.warn("Only the GM may call the Reckoning.");
|
||
reckoningNow({ actorUuid: btn.dataset.actorUuid ?? "" });
|
||
});
|
||
});
|
||
});
|
||
|
||
/* Token defaults — and nobody goes unarmed. */
|
||
Hooks.on("preCreateActor", (actor, data) => {
|
||
const bar = { displayBars: CONST.TOKEN_DISPLAY_MODES.OWNER_HOVER, bar1: { attribute: "grit" } };
|
||
if (actor.type === "character") {
|
||
actor.updateSource({ prototypeToken: { ...bar, actorLink: true, displayName: CONST.TOKEN_DISPLAY_MODES.HOVER } });
|
||
const hasUnarmed = actor._source.items?.some(i => i.type === "weapon" && i.name === UNARMED_STRIKE.name);
|
||
if (!hasUnarmed) {
|
||
actor.updateSource({ items: [...(actor._source.items ?? []), foundry.utils.deepClone(UNARMED_STRIKE)] });
|
||
}
|
||
} else {
|
||
actor.updateSource({ prototypeToken: { ...bar, displayName: CONST.TOKEN_DISPLAY_MODES.HOVER } });
|
||
}
|
||
});
|
||
|
||
/* -------------------------------------------- */
|
||
/* THE STAGE — battlemap & scene generator */
|
||
/* (v14 Levels-safe; recipe shared w/ mapwright)*/
|
||
/* -------------------------------------------- */
|
||
|
||
const STAGE_GS = 100;
|
||
const STAGE_SIZES = { small: [24, 16], medium: [30, 20], large: [38, 26] };
|
||
|
||
const STAGE_NAMES = {
|
||
barrow: [["The Barrow of the", "The Tomb of the", "The Vault of the", "The Halls of the"],
|
||
["Hollow King", "Vain Queen", "Gilded Court", "Silent Host", "Forgotten Name", "Peacock Prince"]],
|
||
cave: [["The Gullet", "The Weeping", "The Howling", "The Black", "The Salt", "The Candle"],
|
||
["Caves", "Deep", "Warren", "Throat", "Galleries"]],
|
||
fen: [["The Weeping", "The Drowned", "The Mirror", "The Pale", "The Whispering"],
|
||
["Fen", "Marsh", "Mire", "Flats"]],
|
||
village: [["Nettlebrook", "Marrowdown", "Gallowsmoor", "Peddler's Rest", "Thistlewick", "Mudholt", "Crowbeck"],
|
||
["", "", ""]],
|
||
forest: [["The Whispering", "The Tanglewood", "The Elder", "The Hollow", "The Thornmarch"],
|
||
["Wood", "Forest", "Wilds", "Greenway", "Thicket"]]
|
||
};
|
||
function stageName(type) { const [a, b] = STAGE_NAMES[type]; const t = `${rnd(a)} ${rnd(b)}`.trim(); return t; }
|
||
|
||
const d = n => 1 + Math.floor(Math.random() * n);
|
||
|
||
/* ---------- layouts ---------- */
|
||
|
||
function genBarrow(cols, rows) {
|
||
const g = Array.from({ length: rows }, () => new Array(cols).fill(0));
|
||
const rooms = [];
|
||
const target = Math.max(4, Math.floor((cols * rows) / 60));
|
||
for (let i = 0; i < 90 && rooms.length < target; i++) {
|
||
const w = 3 + Math.floor(Math.random() * 5), h = 3 + Math.floor(Math.random() * 4);
|
||
const x = 1 + Math.floor(Math.random() * (cols - w - 2));
|
||
const y = 1 + Math.floor(Math.random() * (rows - h - 2));
|
||
let ok = true;
|
||
for (let yy = y - 1; yy <= y + h && ok; yy++) for (let xx = x - 1; xx <= x + w; xx++) {
|
||
if (g[yy]?.[xx]) { ok = false; break; }
|
||
}
|
||
if (!ok) continue;
|
||
for (let yy = y; yy < y + h; yy++) for (let xx = x; xx < x + w; xx++) g[yy][xx] = 1;
|
||
rooms.push({ x, y, w, h, cx: x + Math.floor(w / 2), cy: y + Math.floor(h / 2) });
|
||
}
|
||
rooms.sort((a, b) => a.cx - b.cx);
|
||
const doors = [];
|
||
const seen = new Set();
|
||
for (let i = 1; i < rooms.length; i++) {
|
||
const a = rooms[i - 1], b = rooms[i];
|
||
let x = a.cx, y = a.cy, prev = null;
|
||
const step = (nx, ny) => {
|
||
const was = g[ny][nx];
|
||
const t = was === 1 ? 1 : 2;
|
||
if (!was) g[ny][nx] = 2;
|
||
if (prev && prev.t !== t) {
|
||
const key = [prev.x, prev.y, nx, ny].join(",");
|
||
if (!seen.has(key)) { seen.add(key); doors.push({ ax: prev.x, ay: prev.y, bx: nx, by: ny }); }
|
||
}
|
||
prev = { x: nx, y: ny, t };
|
||
};
|
||
step(x, y);
|
||
while (x !== b.cx) { x += Math.sign(b.cx - x); step(x, y); }
|
||
while (y !== b.cy) { y += Math.sign(b.cy - y); step(x, y); }
|
||
}
|
||
return { g, rooms, doors };
|
||
}
|
||
|
||
function genCave(cols, rows) {
|
||
let g = Array.from({ length: rows }, (_, y) => new Array(cols).fill(0).map((_, x) =>
|
||
(x === 0 || y === 0 || x === cols - 1 || y === rows - 1) ? 0 : (Math.random() < 0.55 ? 1 : 0)));
|
||
for (let it = 0; it < 4; it++) {
|
||
const nx = g.map(r => [...r]);
|
||
for (let y = 1; y < rows - 1; y++) for (let x = 1; x < cols - 1; x++) {
|
||
let n = 0;
|
||
for (let dy = -1; dy <= 1; dy++) for (let dx = -1; dx <= 1; dx++) {
|
||
if (dx || dy) n += g[y + dy][x + dx];
|
||
}
|
||
nx[y][x] = (g[y][x] ? n >= 4 : n >= 5) ? 1 : 0;
|
||
}
|
||
g = nx;
|
||
}
|
||
// keep the largest connected floor region
|
||
const label = Array.from({ length: rows }, () => new Array(cols).fill(0));
|
||
let best = 0, bestId = 0, id = 0;
|
||
for (let y = 0; y < rows; y++) for (let x = 0; x < cols; x++) {
|
||
if (!g[y][x] || label[y][x]) continue;
|
||
id += 1; let count = 0;
|
||
const stack = [[x, y]];
|
||
label[y][x] = id;
|
||
while (stack.length) {
|
||
const [cx, cy] = stack.pop(); count++;
|
||
for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {
|
||
const px = cx + dx, py = cy + dy;
|
||
if (g[py]?.[px] && !label[py][px]) { label[py][px] = id; stack.push([px, py]); }
|
||
}
|
||
}
|
||
if (count > best) { best = count; bestId = id; }
|
||
}
|
||
for (let y = 0; y < rows; y++) for (let x = 0; x < cols; x++) g[y][x] = label[y][x] === bestId ? 1 : 0;
|
||
return { g, rooms: [], doors: [] };
|
||
}
|
||
|
||
function genFen(cols, rows) {
|
||
const g = Array.from({ length: rows }, () => new Array(cols).fill(1));
|
||
const pools = [], clumps = [];
|
||
const blob = (cx, cy, r) => {
|
||
const cells = [];
|
||
for (let y = Math.max(1, cy - r); y <= Math.min(rows - 2, cy + r); y++) {
|
||
for (let x = Math.max(1, cx - r); x <= Math.min(cols - 2, cx + r); x++) {
|
||
if ((x - cx) ** 2 + (y - cy) ** 2 <= r * r + Math.random() * 2) cells.push([x, y]);
|
||
}
|
||
}
|
||
return cells;
|
||
};
|
||
for (let i = 0; i < 3 + d(3); i++) pools.push(blob(d(cols - 4) + 1, d(rows - 4) + 1, 1 + d(2)));
|
||
for (let i = 0; i < 4 + d(4); i++) clumps.push(blob(d(cols - 4) + 1, d(rows - 4) + 1, 1));
|
||
return { g, rooms: [], doors: [], pools, clumps };
|
||
}
|
||
|
||
function genVillage(cols, rows) {
|
||
const g = Array.from({ length: rows }, () => new Array(cols).fill(1));
|
||
const buildings = [];
|
||
const cxg = cols / 2, cyg = rows / 2;
|
||
const clash = (x, y, w, h) => buildings.some(b => x < b.x + b.w + 1 && x + w + 1 > b.x && y < b.y + b.h + 1 && y + h + 1 > b.y);
|
||
const target = Math.max(5, Math.floor((cols * rows) / 70));
|
||
for (let i = 0; i < 140 && buildings.length < target; i++) {
|
||
const w = 3 + Math.floor(Math.random() * 3), h = 3 + Math.floor(Math.random() * 2);
|
||
const x = 2 + Math.floor(Math.random() * (cols - w - 4));
|
||
const y = 2 + Math.floor(Math.random() * (rows - h - 4));
|
||
if (Math.abs(x + w / 2 - cxg) < 3.5 && Math.abs(y + h / 2 - cyg) < 3.5) continue; // keep the green clear
|
||
if (clash(x, y, w, h)) continue;
|
||
const edges = ["top", "bottom", "left", "right"];
|
||
buildings.push({ x, y, w, h, doorEdge: rnd(edges), roof: rnd(["#7a2f2f", "#6a4a2a", "#5a3d24", "#734a30"]) });
|
||
}
|
||
const segs = [];
|
||
for (const b of buildings) {
|
||
const { x, y, w, h, doorEdge } = b;
|
||
const run = (x1, y1, x2, y2, edge) => {
|
||
if (edge === doorEdge) {
|
||
// punch a 1-cell door in the middle of the edge
|
||
if (y1 === y2) { const dx = x1 + Math.floor((x2 - x1) / 2);
|
||
if (dx > x1) segs.push({ x1, y1, x2: dx, y2, kind: "wall" });
|
||
segs.push({ x1: dx, y1, x2: dx + 1, y2, kind: "door" });
|
||
if (dx + 1 < x2) segs.push({ x1: dx + 1, y1, x2, y2, kind: "wall" });
|
||
} else { const dy = y1 + Math.floor((y2 - y1) / 2);
|
||
if (dy > y1) segs.push({ x1, y1, x2, y2: dy, kind: "wall" });
|
||
segs.push({ x1, y1: dy, x2, y2: dy + 1, kind: "door" });
|
||
if (dy + 1 < y2) segs.push({ x1, y1: dy + 1, x2, y2, kind: "wall" });
|
||
}
|
||
} else segs.push({ x1, y1, x2, y2, kind: "wall" });
|
||
};
|
||
run(x, y, x + w, y, "top");
|
||
run(x, y + h, x + w, y + h, "bottom");
|
||
run(x, y, x, y + h, "left");
|
||
run(x + w, y, x + w, y + h, "right");
|
||
}
|
||
const well = { x: Math.floor(cxg), y: Math.floor(cyg) };
|
||
const rooms = buildings.map(b => ({ cx: b.x + Math.floor(b.w / 2), cy: b.y + Math.floor(b.h / 2), ...b }));
|
||
return { g, buildings, well, segments: segs, rooms };
|
||
}
|
||
|
||
function genForest(cols, rows) {
|
||
const g = Array.from({ length: rows }, () => new Array(cols).fill(1));
|
||
const trees = [];
|
||
const clearing = { x: cols - 5, y: Math.floor(rows / 2), r: 3.2 };
|
||
const nearClear = (x, y) => (x - clearing.x) ** 2 + (y - clearing.y) ** 2 < (clearing.r + 1.5) ** 2;
|
||
// a winding path from the west edge to the clearing
|
||
const path = [];
|
||
let py = Math.floor(rows / 2);
|
||
for (let x = 1; x <= clearing.x; x++) {
|
||
py = Math.max(2, Math.min(rows - 3, py + (Math.random() < 0.5 ? -1 : 1) * (Math.random() < 0.4 ? 1 : 0)));
|
||
path.push([x, py]);
|
||
}
|
||
const onPath = (x, y) => path.some(([px, py2]) => Math.abs(px - x) <= 1 && Math.abs(py2 - y) <= 1);
|
||
const segs = [];
|
||
const count = Math.floor(cols * rows / 12);
|
||
for (let i = 0; i < count; i++) {
|
||
const x = 1 + Math.random() * (cols - 2), y = 1 + Math.random() * (rows - 2);
|
||
if (nearClear(x, y) || onPath(Math.round(x), Math.round(y))) continue;
|
||
const r = 0.5 + Math.random() * 0.6;
|
||
trees.push({ x, y, r });
|
||
if (Math.random() < 0.4) { // some trees block line of sight & movement (a thicket)
|
||
const gx = Math.round(x), gy = Math.round(y);
|
||
segs.push({ x1: gx, y1: gy, x2: gx + 1, y2: gy, kind: "wall" });
|
||
segs.push({ x1: gx, y1: gy, x2: gx, y2: gy + 1, kind: "wall" });
|
||
}
|
||
}
|
||
return { g, trees, path, clearing, segments: segs, rooms: [] };
|
||
}
|
||
|
||
/* ---------- walls from a cell grid ---------- */
|
||
|
||
function stageWalls(g, cols, rows, doors) {
|
||
const floor = (x, y) => (g[y]?.[x] ?? 0) > 0;
|
||
const segs = [];
|
||
// vertical boundaries (between column x-1 and x)
|
||
for (let x = 0; x <= cols; x++) {
|
||
let run = null;
|
||
for (let y = 0; y <= rows; y++) {
|
||
const boundary = y < rows && (floor(x - 1, y) !== floor(x, y));
|
||
if (boundary && !run) run = y;
|
||
if (!boundary && run !== null) { segs.push({ x1: x, y1: run, x2: x, y2: y, kind: "wall" }); run = null; }
|
||
}
|
||
}
|
||
// horizontal boundaries
|
||
for (let y = 0; y <= rows; y++) {
|
||
let run = null;
|
||
for (let x = 0; x <= cols; x++) {
|
||
const boundary = x < cols && (floor(x, y - 1) !== floor(x, y));
|
||
if (boundary && run === null) run = x;
|
||
if (!boundary && run !== null) { segs.push({ x1: run, y1: y, x2: x, y2: y, kind: "wall" }); run = null; }
|
||
}
|
||
}
|
||
for (const dd of doors ?? []) {
|
||
if (dd.ay === dd.by) { // horizontal neighbours → vertical door edge
|
||
const x = Math.max(dd.ax, dd.bx);
|
||
segs.push({ x1: x, y1: dd.ay, x2: x, y2: dd.ay + 1, kind: "door" });
|
||
} else {
|
||
const y = Math.max(dd.ay, dd.by);
|
||
segs.push({ x1: dd.ax, y1: y, x2: dd.ax + 1, y2: y, kind: "door" });
|
||
}
|
||
}
|
||
return segs;
|
||
}
|
||
|
||
/* ---------- rendering ---------- */
|
||
|
||
function stageSVG(type, model, cols, rows) {
|
||
const gs = STAGE_GS, W = cols * gs, H = rows * gs;
|
||
const g = model.g;
|
||
const floor = (x, y) => (g[y]?.[x] ?? 0) > 0;
|
||
const jitter = (x, y, spread) => ((Math.sin(x * 127.1 + y * 311.7) * 43758.5453) % 1 + 1) % 1 * spread;
|
||
let s = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${W} ${H}" width="${W}" height="${H}">`;
|
||
|
||
if (type === "village") {
|
||
s += `<rect width="${W}" height="${H}" fill="#28401f"/>`;
|
||
// mottled grass
|
||
for (let i = 0; i < cols * rows * 2; i++) {
|
||
const x = Math.random() * W, y = Math.random() * H;
|
||
s += `<circle cx="${x}" cy="${y}" r="${6 + Math.random() * 14}" fill="${Math.random() < 0.5 ? "#2e4a24" : "#233a1c"}" opacity="0.5"/>`;
|
||
}
|
||
// dirt roads radiating from the green
|
||
const wx = model.well.x * gs + gs / 2, wy = model.well.y * gs + gs / 2;
|
||
for (const b of model.buildings) {
|
||
const bx = (b.x + b.w / 2) * gs, by = (b.y + b.h / 2) * gs;
|
||
s += `<line x1="${wx}" y1="${wy}" x2="${bx}" y2="${by}" stroke="#6b5636" stroke-width="26" stroke-linecap="round" opacity="0.65"/>`;
|
||
}
|
||
// the green + well
|
||
s += `<circle cx="${wx}" cy="${wy}" r="${gs * 2.6}" fill="#33521f" opacity="0.55"/>`;
|
||
s += `<circle cx="${wx}" cy="${wy}" r="${gs * 0.42}" fill="#5c5342" stroke="#2a2317" stroke-width="6"/><circle cx="${wx}" cy="${wy}" r="${gs * 0.24}" fill="#0d1a1f"/>`;
|
||
// building footprints (roofs)
|
||
for (const b of model.buildings) {
|
||
const x = b.x * gs, y = b.y * gs, w = b.w * gs, h = b.h * gs;
|
||
s += `<rect x="${x}" y="${y}" width="${w}" height="${h}" fill="#2a2016" opacity="0.5"/>`;
|
||
s += `<rect x="${x + 4}" y="${y + 4}" width="${w - 8}" height="${h - 8}" fill="${b.roof}" stroke="#2a1a12" stroke-width="4"/>`;
|
||
s += `<line x1="${x + 8}" y1="${y + h / 2}" x2="${x + w - 8}" y2="${y + h / 2}" stroke="#2a1a12" stroke-width="3" opacity="0.6"/>`;
|
||
}
|
||
// a few trees at the edges
|
||
for (let i = 0; i < 10; i++) {
|
||
const x = Math.random() * W, y = Math.random() * H;
|
||
s += `<circle cx="${x}" cy="${y}" r="${gs * 0.5}" fill="#16260f"/><circle cx="${x - 6}" cy="${y - 8}" r="${gs * 0.38}" fill="#28401c"/>`;
|
||
}
|
||
drawWalls();
|
||
} else if (type === "forest") {
|
||
s += `<rect width="${W}" height="${H}" fill="#1c2f14"/>`;
|
||
for (let i = 0; i < cols * rows * 2.4; i++) {
|
||
const x = Math.random() * W, y = Math.random() * H;
|
||
s += `<path d="M${x} ${y} q3 -12 ${5 - Math.random() * 10} -16" stroke="${Math.random() < 0.5 ? "#243d18" : "#2f4d1f"}" stroke-width="3" fill="none" opacity="0.6"/>`;
|
||
}
|
||
// the path
|
||
if (model.path?.length) {
|
||
const pts = model.path.map(([x, y]) => `${x * gs + gs / 2},${y * gs + gs / 2}`).join(" ");
|
||
s += `<polyline points="${pts}" fill="none" stroke="#6b5636" stroke-width="30" stroke-linecap="round" stroke-linejoin="round" opacity="0.7"/>`;
|
||
}
|
||
// clearing
|
||
const cx = model.clearing.x * gs + gs / 2, cy = model.clearing.y * gs + gs / 2;
|
||
s += `<circle cx="${cx}" cy="${cy}" r="${model.clearing.r * gs}" fill="#33511d" opacity="0.6"/>`;
|
||
// the barrow mouth in the clearing
|
||
s += `<ellipse cx="${cx}" cy="${cy}" rx="${gs * 0.9}" ry="${gs * 0.6}" fill="#0c1410"/><path d="M${cx - gs * 0.9} ${cy} a${gs * 0.9} ${gs * 0.9} 0 0 1 ${gs * 1.8} 0" fill="#3a2f1e" stroke="#1a140c" stroke-width="5"/>`;
|
||
// tree canopies
|
||
for (const t of model.trees) {
|
||
const x = t.x * gs, y = t.y * gs, r = t.r * gs;
|
||
s += `<circle cx="${x}" cy="${y}" r="${r * 1.15}" fill="#0f1f0a"/><circle cx="${x - r * 0.3}" cy="${y - r * 0.35}" r="${r * 0.85}" fill="#24401a"/><circle cx="${x + r * 0.25}" cy="${y + r * 0.1}" r="${r * 0.6}" fill="#1a3312"/>`;
|
||
}
|
||
} else if (type === "fen") {
|
||
s += `<rect width="${W}" height="${H}" fill="#1a352e"/>`;
|
||
for (let i = 0; i < cols * rows * 1.5; i++) {
|
||
const x = Math.random() * W, y = Math.random() * H;
|
||
s += `<path d="M${x} ${y} q3 -14 ${6 - Math.random() * 12} -20" stroke="${Math.random() < 0.5 ? "#264a3e" : "#31584a"}" stroke-width="3" fill="none" opacity="0.7"/>`;
|
||
}
|
||
for (const pool of model.pools) {
|
||
for (const [x, y] of pool) s += `<rect x="${x * gs - 8}" y="${y * gs - 8}" width="${gs + 16}" height="${gs + 16}" rx="34" fill="#123c38" opacity="0.92"/>`;
|
||
}
|
||
for (const pool of model.pools) {
|
||
for (const [x, y] of pool) s += `<rect x="${x * gs + 8}" y="${y * gs + 8}" width="${gs - 16}" height="${gs - 16}" rx="30" fill="#14544e" opacity="0.9"/>`;
|
||
}
|
||
for (const clump of model.clumps) {
|
||
for (const [x, y] of clump) {
|
||
const cx = (x + 0.5) * gs + jitter(x, y, 30) - 15, cy = (y + 0.5) * gs + jitter(y, x, 30) - 15;
|
||
s += `<circle cx="${cx}" cy="${cy}" r="${gs * 0.52}" fill="#0f231f"/><circle cx="${cx - 10}" cy="${cy - 12}" r="${gs * 0.4}" fill="#1e3b33"/>`;
|
||
}
|
||
}
|
||
for (let i = 0; i < 40; i++) {
|
||
const x = Math.random() * W, y = Math.random() * H;
|
||
s += `<path d="M${x} ${y} l2 -22 M${x} ${y} l8 -18" stroke="#8a6a20" stroke-width="2.5" fill="none" opacity="0.6"/>`;
|
||
}
|
||
} else {
|
||
s += `<rect width="${W}" height="${H}" fill="${type === "cave" ? "#0d1614" : "#111c1a"}"/>`;
|
||
const base = type === "cave" ? [201, 185, 152] : [222, 208, 176];
|
||
for (let y = 0; y < rows; y++) for (let x = 0; x < cols; x++) {
|
||
if (!floor(x, y)) continue;
|
||
const t = jitter(x, y, 22) - 11;
|
||
const fill = `rgb(${base[0] + t},${base[1] + t},${base[2] + t * 1.2})`;
|
||
if (type === "cave") {
|
||
s += `<rect x="${x * gs - 7}" y="${y * gs - 7}" width="${gs + 14}" height="${gs + 14}" rx="26" fill="${fill}"/>`;
|
||
} else {
|
||
s += `<rect x="${x * gs}" y="${y * gs}" width="${gs}" height="${gs}" fill="${fill}"/>`;
|
||
}
|
||
}
|
||
// faint grid on floor + speckle
|
||
for (let y = 0; y < rows; y++) for (let x = 0; x < cols; x++) {
|
||
if (!floor(x, y)) continue;
|
||
if (type === "barrow") s += `<rect x="${x * gs}" y="${y * gs}" width="${gs}" height="${gs}" fill="none" stroke="#2a2317" stroke-opacity="0.10"/>`;
|
||
if (Math.random() < 0.12) s += `<circle cx="${x * gs + 10 + Math.random() * 80}" cy="${y * gs + 10 + Math.random() * 80}" r="${2 + Math.random() * 4}" fill="#2a2317" opacity="0.18"/>`;
|
||
}
|
||
drawWalls();
|
||
}
|
||
function drawWalls() {
|
||
for (const seg of model.segments) {
|
||
const x1 = seg.x1 * gs, y1 = seg.y1 * gs, x2 = seg.x2 * gs, y2 = seg.y2 * gs;
|
||
if (seg.kind === "door") {
|
||
s += `<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" stroke="#b0872f" stroke-width="16" stroke-linecap="butt"/>`;
|
||
s += `<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" stroke="#e0c98a" stroke-width="6" stroke-dasharray="10 8"/>`;
|
||
} else {
|
||
s += `<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" stroke="#1a1108" stroke-width="12" stroke-linecap="square"/>`;
|
||
}
|
||
}
|
||
}
|
||
s += "</svg>";
|
||
return s;
|
||
}
|
||
|
||
/* ---------- scene assembly ---------- */
|
||
|
||
async function stageRasterUpload(svg, W, H, name) {
|
||
const blob = new Blob([svg], { type: "image/svg+xml;charset=utf-8" });
|
||
const url = URL.createObjectURL(blob);
|
||
try {
|
||
const img = new Image();
|
||
await new Promise((res, rej) => { img.onload = res; img.onerror = () => rej(new Error("SVG raster failed")); img.src = url; });
|
||
const canvas = document.createElement("canvas");
|
||
canvas.width = W; canvas.height = H;
|
||
canvas.getContext("2d").drawImage(img, 0, 0, W, H);
|
||
const png = await new Promise(res => canvas.toBlob(res, "image/png"));
|
||
const FP = foundry.applications?.apps?.FilePicker?.implementation ?? FilePicker;
|
||
try { await FP.createDirectory("data", "vanity-stage"); } catch (e) { /* exists */ }
|
||
const filename = `${name.slugify()}-${Date.now()}.png`;
|
||
const up = await FP.upload("data", "vanity-stage", new File([png], filename, { type: "image/png" }), {}, { notify: false });
|
||
if (!up?.path) throw new Error("Upload failed — check file upload permissions.");
|
||
return String(up.path).replace(/^\/+/, "");
|
||
} finally { URL.revokeObjectURL(url); }
|
||
}
|
||
|
||
async function forgeStage({ type = "barrow", size = "medium", name = "", populate = false, heat = "fight", kind = "", cast = null, activate = true } = {}) {
|
||
if (!game.user.isGM) return;
|
||
const [cols, rows] = STAGE_SIZES[size] ?? STAGE_SIZES.medium;
|
||
name ||= stageName(type);
|
||
ui.notifications.info(`The Stage: raising “${name}”…`);
|
||
|
||
const model = type === "cave" ? genCave(cols, rows) : type === "fen" ? genFen(cols, rows)
|
||
: type === "village" ? genVillage(cols, rows) : type === "forest" ? genForest(cols, rows) : genBarrow(cols, rows);
|
||
if (type === "barrow" || type === "cave") model.segments = stageWalls(model.g, cols, rows, model.doors);
|
||
else if (type === "fen") model.segments = [];
|
||
// village/forest already carry model.segments
|
||
const svg = stageSVG(type, model, cols, rows);
|
||
const gs = STAGE_GS, W = cols * gs, H = rows * gs;
|
||
const bgPath = await stageRasterUpload(svg, W, H, name);
|
||
|
||
const scene = await Scene.create({
|
||
name,
|
||
width: W, height: H, padding: 0,
|
||
grid: { type: CONST.GRID_TYPES?.SQUARE ?? 1, size: gs, distance: 5, units: "ft" },
|
||
tokenVision: !["fen", "village", "forest"].includes(type),
|
||
fog: { exploration: !["fen", "village", "forest"].includes(type) },
|
||
environment: ["fen", "village", "forest"].includes(type) ? { globalLight: { enabled: true } } : {},
|
||
navigation: true
|
||
});
|
||
|
||
// v14: the background lives on the scene's default Level.
|
||
const lv = scene.levels?.contents?.[0];
|
||
if (lv) await scene.updateEmbeddedDocuments("Level", [{ _id: lv.id, background: { src: bgPath, color: "#0a1a18" } }]);
|
||
else await scene.update({ background: { src: bgPath } });
|
||
|
||
if (model.segments.length) {
|
||
const K = {
|
||
move: CONST.WALL_MOVEMENT_TYPES?.NORMAL ?? 20,
|
||
sense: CONST.WALL_SENSE_TYPES?.NORMAL ?? 20,
|
||
door: CONST.WALL_DOOR_TYPES?.DOOR ?? 1,
|
||
closed: CONST.WALL_DOOR_STATES?.CLOSED ?? 0
|
||
};
|
||
const walls = model.segments.map(s => ({
|
||
c: [s.x1 * gs, s.y1 * gs, s.x2 * gs, s.y2 * gs],
|
||
move: K.move, sight: K.sense, sound: K.sense, light: K.sense,
|
||
...(s.kind === "door" ? { door: K.door, ds: K.closed } : {})
|
||
}));
|
||
await scene.createEmbeddedDocuments("Wall", walls);
|
||
}
|
||
|
||
// lights
|
||
const lights = [];
|
||
const floorCells = [];
|
||
for (let y = 0; y < rows; y++) for (let x = 0; x < cols; x++) if ((model.g[y]?.[x] ?? 0) > 0) floorCells.push([x, y]);
|
||
if (type === "barrow") {
|
||
for (const r of model.rooms) {
|
||
if (Math.random() < 0.65) lights.push({
|
||
x: (r.cx + 0.5) * gs, y: (r.cy + 0.5) * gs,
|
||
config: { bright: 10, dim: 25, color: "#b0872f", alpha: 0.3, animation: { type: "torch", speed: 3, intensity: 4 } }
|
||
});
|
||
}
|
||
} else if (type === "cave") {
|
||
for (const [x, y] of pickN(floorCells, 3)) lights.push({
|
||
x: (x + 0.5) * gs, y: (y + 0.5) * gs,
|
||
config: { bright: 5, dim: 20, color: "#1c6f66", alpha: 0.25, animation: { type: "pulse", speed: 2, intensity: 3 } }
|
||
});
|
||
}
|
||
if (lights.length) await scene.createEmbeddedDocuments("AmbientLight", lights);
|
||
|
||
// placement: a supplied cast, else an auto-encounter
|
||
let placed = cast;
|
||
if (!placed && populate) {
|
||
const enc = await forgeEncounter({ heat, kind, forStage: name });
|
||
placed = enc.actors.map(a => ({ actorId: a.id, name: a.name, img: a.img, disposition: -1 }));
|
||
}
|
||
if (placed?.length) {
|
||
const rooms = model.rooms?.length > 1 ? model.rooms.slice(1).map(r => [r.cx, r.cy]) : [];
|
||
const open = pickN(floorCells.filter(([x, y]) => !model.segments.some(sg =>
|
||
sg.kind !== "door" && Math.min(sg.x1, sg.x2) <= x && x < Math.max(sg.x1, sg.x2) + 1 &&
|
||
Math.min(sg.y1, sg.y2) <= y && y < Math.max(sg.y1, sg.y2) + 1)), placed.length + 4);
|
||
const spots = (type === "barrow" && rooms.length) ? rooms : open.length ? open : floorCells;
|
||
const tokens = placed.map((a, i) => {
|
||
const [x, y] = spots[i % spots.length] ?? [1 + i, 1];
|
||
const actor = game.actors.get(a.actorId);
|
||
return { name: a.name ?? actor?.name, actorId: a.actorId, texture: { src: a.img ?? actor?.img },
|
||
x: x * gs, y: y * gs, width: 1, height: 1, disposition: a.disposition ?? -1, hidden: !!a.hidden };
|
||
});
|
||
if (tokens.length) await scene.createEmbeddedDocuments("Token", tokens);
|
||
}
|
||
|
||
if (activate) await scene.activate();
|
||
await ChatMessage.create({
|
||
speaker: { alias: "The Stage" },
|
||
whisper: ChatMessage.getWhisperRecipients("GM"),
|
||
content: `<div class="vanity-roll vanity-forge-card">
|
||
<header><span class="vanity-roll-label">🎭 The stage is set</span>
|
||
<span class="vanity-roll-sub">${type} · ${cols}×${rows} · ${model.segments.length} walls${populate ? " · populated" : ""}</span></header>
|
||
<p><b>${name}</b> is raised and active. ${type === "fen" ? "Open ground — no fog, daylight." : "Token vision and fog are on; doors are gold on the map."}</p>
|
||
</div>`
|
||
});
|
||
return scene;
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
/* THE ENCOUNTER — situation, foes & spoils */
|
||
/* -------------------------------------------- */
|
||
|
||
const ENCOUNTER_SITUATIONS = [
|
||
"They're arguing over the split of fresh loot — half of them aren't watching the door.",
|
||
"An ambush: they saw you first. No Reaction roll — Hostile, and they have position.",
|
||
"Mid-ritual. Interrupting it is loud; letting it finish is worse.",
|
||
"Feeding. It does not want to share.",
|
||
"Lost, frightened, and twice as dangerous for it.",
|
||
"Guarding a door they were told never to open. They're curious too.",
|
||
"Burying one of their own — grief has made them either vicious or reasonable.",
|
||
"Counting heads. One of them is missing, and they think you know why.",
|
||
"Holding a prisoner who might be worth more to you than to them.",
|
||
"Asleep — with one terrible, wide-awake sentry.",
|
||
"Tracking something, and it isn't you. Yet.",
|
||
"Setting a trap meant for something much bigger.",
|
||
"In tense parley with a second party who like you even less.",
|
||
"Licking wounds from an earlier fight. Someone owes them.",
|
||
"Celebrating loudly. The wine is doing half your work.",
|
||
"Waiting for a signal that is never going to come.",
|
||
"Praying — to something that occasionally answers.",
|
||
"Dividing the last of their food. Desperation has a smell."
|
||
];
|
||
|
||
const ENCOUNTER_TERRAIN = [
|
||
"A brazier full of hot coals, begging to be kicked (Environment, 1 Success).",
|
||
"A rope bridge over the dark — Drive Back has opinions here.",
|
||
"Chest-high tombs in tight rows: cover everywhere, charging nowhere.",
|
||
"An oil slick from a shattered lamp, one spark from mattering.",
|
||
"A scree slope — Athletics to charge across, or arrive winded.",
|
||
"A great bell. Any Bane spent may ring it, and everything will know.",
|
||
"A deep black pool splits the field in two.",
|
||
"Scaffolding overhead, groaning, held by exactly one rope.",
|
||
"Knee-deep mist: everything below the waist is a guess.",
|
||
"A portcullis winch in the far corner — first to it owns the exit.",
|
||
"A long ledge and a longer drop.",
|
||
"Pillars everywhere — Backstab country."
|
||
];
|
||
|
||
const ENCOUNTER_COMPLICATIONS = [
|
||
"A prisoner here knows the way you need. Keep them breathing.",
|
||
"One of them wants to defect — if given one dignified excuse.",
|
||
"Reinforcements arrive in 3 rounds if this gets loud.",
|
||
"Their loot is cursed, and they know it. They'd love you to take it.",
|
||
"A rival crew watches from cover, waiting to pick off the winners.",
|
||
"The roof is unstable. Every 2-Success Environment spend brings some down.",
|
||
"One carries a letter naming their employer. That name matters.",
|
||
"They've mistaken you for someone who owes them money. A lot of it.",
|
||
"The smallest one is the actual leader.",
|
||
"Something bigger hunts THEM. It is closer than anyone thinks.",
|
||
"They'll fold fast before real showmanship — Vice bait, +1 Vanity for grandstanding.",
|
||
"The way out closes at the end of round 5. Everyone can hear it grinding."
|
||
];
|
||
|
||
const HEAT_BUILDS = {
|
||
skirmish: () => ({ mook: 2 + d(3), standard: Math.random() < 0.5 ? 1 : 0, threat: 0, nemesis: 0 }),
|
||
fight: () => ({ mook: d(4), standard: 1 + (Math.random() < 0.5 ? 1 : 0), threat: 0, nemesis: 0 }),
|
||
battle: () => ({ mook: d(4), standard: 1, threat: 1, nemesis: 0 }),
|
||
nightmare: () => ({ mook: 0, standard: d(3), threat: Math.random() < 0.4 ? 1 : 0, nemesis: 1 })
|
||
};
|
||
const HEAT_HOARD = { skirmish: "pocket", fight: "cache", battle: "chest", nightmare: "vault" };
|
||
|
||
async function forgeEncounter({ heat = "fight", kind = "", forStage = "" } = {}) {
|
||
const t = FORGE_MONSTERS[kind] ? kind : rnd(Object.keys(FORGE_MONSTERS));
|
||
const build = (HEAT_BUILDS[heat] ?? HEAT_BUILDS.fight)();
|
||
const folder = await Folder.create({ name: `Encounter — ${t} (${heat})`, type: "Actor" });
|
||
|
||
const actors = [];
|
||
for (const [menace, count] of Object.entries(build)) {
|
||
for (let i = 0; i < count; i++) actors.push(await forgeMonster({ type: t, menace, silent: true, folderId: folder.id }));
|
||
}
|
||
|
||
const situation = rnd(ENCOUNTER_SITUATIONS);
|
||
const terrain = rnd(ENCOUNTER_TERRAIN);
|
||
const complication = rnd(ENCOUNTER_COMPLICATIONS);
|
||
const ambush = situation.startsWith("An ambush");
|
||
let mood = "Hostile", moodDice = [];
|
||
if (!ambush) {
|
||
moodDice = rollDice(2, 6);
|
||
const rs = moodDice.filter(x => x >= 5).length;
|
||
mood = ["Hostile", "Wary", "Neutral", "Friendly"][Math.min(rs, 3)];
|
||
}
|
||
|
||
await ChatMessage.create({
|
||
speaker: { alias: "The Forge" },
|
||
whisper: ChatMessage.getWhisperRecipients("GM"),
|
||
content: `<div class="vanity-roll vanity-forge-card">
|
||
<header><span class="vanity-roll-label">⚒ An encounter takes shape</span>
|
||
<span class="vanity-roll-sub">${heat} · ${t}${forStage ? ` · staged at ${forStage}` : ""} · mood: <b>${mood}</b>${moodDice.length ? ` (${moodDice.join(", ")})` : " (they saw you first)"}</span></header>
|
||
<p><b>Foes:</b> ${actors.map(a => `@UUID[${a.uuid}]{${a.name}}`).join(" · ")}</p>
|
||
<p><b>The scene:</b> ${situation}</p>
|
||
<p><b>The ground:</b> ${terrain}</p>
|
||
<p><b>The catch:</b> <i>${complication}</i></p>
|
||
</div>`
|
||
});
|
||
await forgeHoard({ size: HEAT_HOARD[heat] ?? "cache" });
|
||
return { actors, situation, terrain, complication, mood, folder };
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
/* THE CAROUSE — burn gold gloriously (§27) */
|
||
/* -------------------------------------------- */
|
||
|
||
async function carouse({ actorId = "", gold = 20, rate = 20 } = {}) {
|
||
const actor = game.actors.get(actorId);
|
||
if (!actor || actor.type !== "character") return ui.notifications.warn("Pick a character to carouse.");
|
||
gold = Math.max(0, Math.floor(gold));
|
||
const glory = Math.floor(gold / rate);
|
||
if (glory < 1) return ui.notifications.warn(`It takes ~${rate} gp to buy a single point of Glory. Spend like you mean it.`);
|
||
const purse = actor.system.details.coin ?? { gp: 0, sp: 0, cp: 0 };
|
||
if ((purse.gp ?? 0) < gold) return ui.notifications.warn(`${actor.name} carries only ${purse.gp ?? 0} gp.`);
|
||
|
||
await actor.update({
|
||
"system.details.coin.gp": (purse.gp ?? 0) - gold,
|
||
"system.glory": (actor.system.glory ?? 0) + glory
|
||
});
|
||
|
||
await ChatMessage.create({
|
||
speaker: ChatMessage.getSpeaker({ actor }),
|
||
content: `<div class="vanity-roll vanity-forge-card">
|
||
<header><span class="vanity-roll-label">🍷 The Carouse</span>
|
||
<span class="vanity-roll-sub">gold you cling to buys nothing — gold you squander buys legend (§27)</span></header>
|
||
<p><b>${actor.name}</b> burns <b>${gold} gp</b> in one spectacular blow-out — feasts, statues, scandalous commissions —
|
||
and wakes famous: <b>+${glory} Glory</b> (now ${actor.system.glory}).</p>
|
||
<p><i>And then, the morning after…</i></p>
|
||
</div>`
|
||
});
|
||
const table = await getVanityTable("The Morning After (carousing)");
|
||
if (table) await table.draw({ displayChat: true });
|
||
}
|
||
|
||
/* ---------- dialogs for the new tools ---------- */
|
||
|
||
function forgeEncounterDialog() {
|
||
new Dialog({
|
||
title: "The Forge — an Encounter",
|
||
content: `<form class="vanity-roll-dialog">
|
||
<div class="form-group"><label>Foe kind</label><select name="kind">
|
||
<option value="">Random</option>
|
||
${Object.keys(FORGE_MONSTERS).map(t => `<option value="${t}">${t}</option>`).join("")}
|
||
</select></div>
|
||
<div class="form-group"><label>Heat</label><select name="heat">
|
||
<option value="skirmish">Skirmish — mooks and nerves</option>
|
||
<option value="fight" selected>Fight — a proper scrap</option>
|
||
<option value="battle">Battle — a Threat with friends</option>
|
||
<option value="nightmare">Nightmare — a Nemesis</option>
|
||
</select></div>
|
||
</form>`,
|
||
buttons: {
|
||
forge: {
|
||
icon: '<i class="fa-solid fa-hammer"></i>', label: "Forge",
|
||
callback: html => {
|
||
const f = html[0].querySelector("form");
|
||
forgeEncounter({ kind: f.elements.kind.value, heat: f.elements.heat.value });
|
||
}
|
||
}
|
||
},
|
||
default: "forge"
|
||
}).render(true);
|
||
}
|
||
|
||
function forgeStageDialog() {
|
||
new Dialog({
|
||
title: "The Stage — raise a battlemap",
|
||
content: `<form class="vanity-roll-dialog">
|
||
<div class="form-group"><label>Name (blank = fate decides)</label><input type="text" name="name"></div>
|
||
<div class="form-group"><label>Ground</label><select name="type">
|
||
<option value="barrow" selected>Barrow — rooms, doors, torchlight</option>
|
||
<option value="cave">Cave — organic dark</option>
|
||
<option value="fen">Fen — open marsh, daylight</option>
|
||
<option value="village">Village — houses, green, well (daylight)</option>
|
||
<option value="forest">Forest — trees, a path, a clearing (daylight)</option>
|
||
</select></div>
|
||
<div class="form-group"><label>Size</label><select name="size">
|
||
<option value="small">Small (24×16)</option>
|
||
<option value="medium" selected>Medium (30×20)</option>
|
||
<option value="large">Large (38×26)</option>
|
||
</select></div>
|
||
<div class="form-group"><label>Populate with an encounter</label><input type="checkbox" name="populate" checked></div>
|
||
<div class="form-group"><label>…at heat</label><select name="heat">
|
||
<option value="skirmish">Skirmish</option>
|
||
<option value="fight" selected>Fight</option>
|
||
<option value="battle">Battle</option>
|
||
<option value="nightmare">Nightmare</option>
|
||
</select></div>
|
||
</form>`,
|
||
buttons: {
|
||
forge: {
|
||
icon: '<i class="fa-solid fa-map"></i>', label: "Raise the stage",
|
||
callback: html => {
|
||
const f = html[0].querySelector("form");
|
||
forgeStage({
|
||
name: f.elements.name.value.trim(),
|
||
type: f.elements.type.value,
|
||
size: f.elements.size.value,
|
||
populate: f.elements.populate.checked,
|
||
heat: f.elements.heat.value
|
||
});
|
||
}
|
||
}
|
||
},
|
||
default: "forge"
|
||
}).render(true);
|
||
}
|
||
|
||
function carouseDialog() {
|
||
const chars = game.actors.filter(a => a.type === "character");
|
||
new Dialog({
|
||
title: "The Carouse — buy legend with gold",
|
||
content: `<form class="vanity-roll-dialog">
|
||
<div class="form-group"><label>Who's buying?</label><select name="actor">
|
||
${chars.map(a => `<option value="${a.id}">${a.name} (${a.system.details.coin?.gp ?? 0} gp · Glory ${a.system.glory ?? 0})</option>`).join("")}
|
||
</select></div>
|
||
<div class="form-group"><label>Gold to burn (≈20 gp per Glory)</label><input type="number" name="gold" value="20" step="5" min="0"></div>
|
||
<p class="hint">Spends the coin, awards the Glory, then rolls the Morning After. Vanity always sends the bill.</p>
|
||
</form>`,
|
||
buttons: {
|
||
carouse: {
|
||
icon: '<i class="fa-solid fa-wine-glass"></i>', label: "Pour",
|
||
callback: html => {
|
||
const f = html[0].querySelector("form");
|
||
carouse({ actorId: f.elements.actor.value, gold: parseInt(f.elements.gold.value) || 0 });
|
||
}
|
||
}
|
||
},
|
||
default: "carouse"
|
||
}).render(true);
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
/* THE COMMISSION — a one-shot adventure */
|
||
/* -------------------------------------------- */
|
||
|
||
const COMMISSION_TITLES = [
|
||
["The Gilded", "The Hollow", "The Borrowed", "The Drowned", "The Crimson", "The Whispering", "The Counterfeit", "The Thrice-Sold", "The Unburied", "The Peacock's"],
|
||
["Crown", "Reliquary", "Wedding", "Inheritance", "Portrait", "Menagerie", "Funeral", "Masquerade", "Debt", "Songbird", "Mirror", "Testament"]
|
||
];
|
||
|
||
const COMMISSION_PRIZES = [
|
||
"a reliquary said to hold a saint's smile",
|
||
"a portrait that flatters whoever owns it",
|
||
"a circlet last worn at a hanging",
|
||
"a songbird that repeats one dead man's words",
|
||
"a wedding dress sewn with borrowed pearls",
|
||
"a deed to land that is definitely underwater",
|
||
"a mirror that shows you five years younger",
|
||
"an urn of ashes that are the wrong ashes",
|
||
"a chess set carved from a saint's pew",
|
||
"a love letter that would end two houses",
|
||
"a mask worn by the last three usurpers",
|
||
"a bell clapper stolen so a tower stays silent"
|
||
];
|
||
|
||
const COMMISSION_TASKS = [
|
||
"recover {PRIZE} before the next full moon makes it worse",
|
||
"steal back {PRIZE} — quietly, and without admitting it was ever lost",
|
||
"deliver {PRIZE}, sealed, unopened, and unexamined. Especially unexamined",
|
||
"prove {PRIZE} is a forgery without revealing who commissioned the original",
|
||
"bury {PRIZE} properly, in the right grave, this time",
|
||
"escort {PRIZE} to the border and pretend to be robbed on the way",
|
||
"authenticate {PRIZE} in front of witnesses who must not survive being wrong",
|
||
"swap {PRIZE} for a perfect copy before the unveiling",
|
||
"find who really owns {PRIZE} and make the question go away",
|
||
"retrieve {PRIZE} from where the patron very foolishly hid it"
|
||
];
|
||
|
||
const COMMISSION_VILLAIN_MOTIVES = [
|
||
"wants the prize for exactly the reason the patron fears",
|
||
"already has the prize, and is waiting to see who comes",
|
||
"is the patron's sibling, and arguably in the right",
|
||
"was cheated of the prize first — the paperwork agrees",
|
||
"believes the prize is cursed and means to destroy it (it is; they do)",
|
||
"is being paid by the patron's rival — same job, other end",
|
||
"worships what is inside the prize",
|
||
"needs the prize to pay a Reckoning of their own",
|
||
"loved the prize's last owner and will not forgive",
|
||
"is the previous crew, still alive, still owed"
|
||
];
|
||
|
||
const COMMISSION_TWISTS = [
|
||
"The patron is lying about what the prize is.",
|
||
"The prize is cursed, mildly, and contagiously.",
|
||
"Two patrons hired two crews. You are the second.",
|
||
"The villain is right, and everyone important knows it.",
|
||
"The prize must not travel by daylight. Nobody says why.",
|
||
"The patron's payment is itself stolen, and marked.",
|
||
"Whoever holds the prize starts dreaming its owner's dreams.",
|
||
"The prize is heavier every mile it moves from home.",
|
||
"A carousing bard has already put the job in a song.",
|
||
"The real prize is inside the obvious prize.",
|
||
"The patron intends to report it stolen either way.",
|
||
"Someone in the patron's house is the villain's eyes."
|
||
];
|
||
|
||
const COMMISSION_DANGER = {
|
||
cozy: { heat: "fight", hoard: "cache", fee: () => 20 + sum(rollDice(2, 6)) * 2, villain: "threat" },
|
||
proper: { heat: "battle", hoard: "chest", fee: () => 40 + sum(rollDice(3, 6)) * 3, villain: "threat" },
|
||
deadly: { heat: "nightmare", hoard: "vault", fee: () => 80 + sum(rollDice(4, 6)) * 4, villain: "nemesis" }
|
||
};
|
||
|
||
async function forgeAdventure({ danger = "proper", ground = "", raiseStage = true, name = "" } = {}) {
|
||
if (!game.user.isGM) return;
|
||
const cfg = COMMISSION_DANGER[danger] ?? COMMISSION_DANGER.proper;
|
||
name ||= `${rnd(COMMISSION_TITLES[0])} ${rnd(COMMISSION_TITLES[1])}`;
|
||
const type = ["barrow", "cave", "fen"].includes(ground) ? ground : rnd(["barrow", "cave", "fen"]);
|
||
ui.notifications.info(`The Commission: drafting “${name}”…`);
|
||
|
||
const folder = await Folder.create({ name: `Commission — ${name}`, type: "Actor" });
|
||
const patron = await forgeFace({ silent: true, folderId: folder.id });
|
||
const kind = rnd(Object.keys(FORGE_MONSTERS));
|
||
const villain = await forgeMonster({ type: kind, menace: cfg.villain, silent: true, folderId: folder.id });
|
||
|
||
const prize = rnd(COMMISSION_PRIZES);
|
||
const task = rnd(COMMISSION_TASKS).replace("{PRIZE}", `<b>${prize}</b>`);
|
||
const motive = rnd(COMMISSION_VILLAIN_MOTIVES);
|
||
const twist = rnd(COMMISSION_TWISTS);
|
||
const fee = cfg.fee();
|
||
|
||
let scene = null;
|
||
if (raiseStage) scene = await forgeStage({ type, populate: true, heat: cfg.heat, kind });
|
||
|
||
const patronLine = patron.system.notes.split("\n")[0] ?? "";
|
||
const overview = `<div class="vanity-journal">
|
||
<h1>${name}</h1>
|
||
<p><i>A one-sitting commission for VANITY — danger: <b>${danger}</b>.</i></p>
|
||
<h2>The Patron</h2>
|
||
<p>@UUID[${patron.uuid}]{${patron.name}} — ${patronLine} ${patron.system.trick}
|
||
<br><b>Wants:</b> ${patron.system.notes.match(/Wants: (.*)/)?.[1] ?? "the job done quietly"}
|
||
<br><b>Secret:</b> <i>${patron.system.notes.match(/Secret: (.*)/)?.[1] ?? "more than one"}</i></p>
|
||
<h2>The Job</h2>
|
||
<p>${task.charAt(0).toUpperCase() + task.slice(1)}. The fee is <b>${fee} gp</b> — half now, half on delivery, all of it beautifully carousable (§27).</p>
|
||
<h2>The Opposition</h2>
|
||
<p>@UUID[${villain.uuid}]{${villain.name}} — a ${kind} who <b>${motive}</b>.
|
||
<br><i>${villain.system.trick}</i></p>
|
||
<h2>The Ground</h2>
|
||
<p>${scene ? `@UUID[${scene.uuid}]{${scene.name}} — raised, walled, lit and populated (${cfg.heat}).` : `A ${type} of the GM's choosing — raise one with The Stage when ready.`}</p>
|
||
<h2>The Twist</h2>
|
||
<p><i>${twist}</i></p>
|
||
<h2>On Site</h2>
|
||
<p>Whatever else is found: the hoard below. And the prize itself, which is worth more than the fee — a fact the table will notice.</p>
|
||
</div>`;
|
||
|
||
const journal = await JournalEntry.create({
|
||
name: `Commission — ${name}`,
|
||
pages: [{ name: "The Commission", type: "text", title: { show: false, level: 1 }, text: { format: 1, content: overview } }]
|
||
});
|
||
|
||
await ChatMessage.create({
|
||
speaker: { alias: "The Commission" },
|
||
whisper: ChatMessage.getWhisperRecipients("GM"),
|
||
content: `<div class="vanity-roll vanity-forge-card">
|
||
<header><span class="vanity-roll-label">📜 A commission is drafted</span>
|
||
<span class="vanity-roll-sub">${danger} · ${type} · fee ${fee} gp</span></header>
|
||
<p><b>@UUID[${journal.uuid}]{${name}}</b> — patron @UUID[${patron.uuid}]{${patron.name}},
|
||
opposition @UUID[${villain.uuid}]{${villain.name}}${scene ? `, staged at @UUID[${scene.uuid}]{${scene.name}}` : ""}.</p>
|
||
<p><i>${twist}</i></p>
|
||
</div>`
|
||
});
|
||
await forgeHoard({ size: cfg.hoard });
|
||
return { journal, patron, villain, scene };
|
||
}
|
||
|
||
function forgeAdventureDialog() {
|
||
new Dialog({
|
||
title: "The Commission — a one-shot adventure",
|
||
content: `<form class="vanity-roll-dialog">
|
||
<div class="form-group"><label>Title (blank = fate decides)</label><input type="text" name="name"></div>
|
||
<div class="form-group"><label>Danger</label><select name="danger">
|
||
<option value="cozy">Cozy — an evening's trouble</option>
|
||
<option value="proper" selected>Proper — a real job</option>
|
||
<option value="deadly">Deadly — a Nemesis waits</option>
|
||
</select></div>
|
||
<div class="form-group"><label>Ground</label><select name="ground">
|
||
<option value="">Random</option>
|
||
<option value="barrow">Barrow</option>
|
||
<option value="cave">Cave</option>
|
||
<option value="fen">Fen</option>
|
||
</select></div>
|
||
<div class="form-group"><label>Raise the battlemap now</label><input type="checkbox" name="raise" checked></div>
|
||
</form>`,
|
||
buttons: {
|
||
forge: {
|
||
icon: '<i class="fa-solid fa-scroll"></i>', label: "Draft it",
|
||
callback: html => {
|
||
const f = html[0].querySelector("form");
|
||
forgeAdventure({
|
||
name: f.elements.name.value.trim(),
|
||
danger: f.elements.danger.value,
|
||
ground: f.elements.ground.value,
|
||
raiseStage: f.elements.raise.checked
|
||
});
|
||
}
|
||
}
|
||
},
|
||
default: "forge"
|
||
}).render(true);
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
/* THE VAIN CROWN — the expanded adventure */
|
||
/* village → village fight → forest → the barrow */
|
||
/* -------------------------------------------- */
|
||
|
||
const CROWN_NPCS = [
|
||
{ name: "Reeve Aldous Pennywhistle", img: "icons/skills/social/diplomacy-handshake-yellow.webp",
|
||
role: "the reeve of Nettlebrook, and your patron",
|
||
line: "Wrings a velvet cap he cannot afford. Wants the barrow sealed before the dead king wakes wearing the crown — and wants it done quietly, for the village's good name.",
|
||
trick: "Offers 40 gp, half now. Secretly hopes you'll bring the crown to HIM." },
|
||
{ name: "Goodwife Marrow", img: "icons/skills/social/diplomacy-handshake-blue.webp",
|
||
role: "the innkeeper of the Drowned Duck",
|
||
line: "Knows every rumour in three parishes and will trade them for a listened ear. Saw the grave-robbers ride through at dusk, 'gentry-looking, the pale one especially.'",
|
||
trick: "A free bed and a warning: 'Don't take the open water road. Something's been at the sheep.'" },
|
||
{ name: "Brother Cassian", img: "icons/magic/holy/saint-glass-portrait-halo.webp",
|
||
role: "the priest of the very small chapel",
|
||
line: "Old, kind, and quietly terrified. Will bless the party (a Holy water flask each) and beg them to rebury King Aldric properly — 'the boy was vain, not evil.'",
|
||
trick: "Knows the barrow's two-key door needs BOTH a scholar and a thief. Says so, sadly." },
|
||
{ name: "The Pale Stranger", img: "icons/magic/death/grave-tombstone-glow-teal.webp",
|
||
role: "Vesper Kound's agent, posing as a pilgrim",
|
||
line: "Too clean, too calm, asks too many questions about the barrow road. This is one of Vesper's people — sent to see who else is hunting the crown.",
|
||
trick: "Reaction roll at −1 die. If rumbled, bolts for the square and blows a whistle — begins Act Two." }
|
||
];
|
||
|
||
async function makeAdventureNpc(def, folderId) {
|
||
let a = game.actors.getName(def.name);
|
||
if (a) return a;
|
||
return Actor.create({
|
||
name: def.name, type: "npc", img: def.img, folder: folderId,
|
||
system: {
|
||
category: "mook",
|
||
attack1: { name: "Scuffle", pool: 2, note: "villager" }, attack2: { name: "", pool: 0, note: "" },
|
||
defence: { pool: 2, note: "dodge" }, grit: { value: 2, max: 2 }, resolve: { value: 0, max: 0 }, nerve: 2,
|
||
trick: def.trick, notes: `${def.role}.\n${def.line}`
|
||
}
|
||
});
|
||
}
|
||
|
||
async function bestiaryActor(name, folderId, disposition = -1) {
|
||
const existing = game.actors.getName(name);
|
||
if (existing) { await existing.update({ "system.grit.value": existing.system.grit.max }); return existing; }
|
||
const pack = await game.packs.get("vanity.bestiary").getDocuments();
|
||
const src = pack.find(d => d.name === name);
|
||
if (!src) return null;
|
||
const data = src.toObject(); data.folder = folderId;
|
||
return Actor.create(data);
|
||
}
|
||
|
||
async function stageVainCrown() {
|
||
if (!game.user.isGM) return ui.notifications.warn("Only the GM may stage the adventure.");
|
||
ui.notifications.info("The Vain Crown: building the whole road — this takes a minute…");
|
||
|
||
const folder = await Folder.create({ name: "The Vain Crown — cast", type: "Actor" }).catch(() => null)
|
||
?? game.folders.find(f => f.name === "The Vain Crown — cast" && f.type === "Actor");
|
||
const fid = folder?.id ?? null;
|
||
|
||
// ---- cast ----
|
||
const npcs = [];
|
||
for (const def of CROWN_NPCS) npcs.push(await makeAdventureNpc(def, fid));
|
||
const mk = (n, disp) => bestiaryActor(n, fid, disp);
|
||
const bandits = []; for (let i = 0; i < 4; i++) bandits.push(await mk("Bandit"));
|
||
const wolf1 = await mk("Dire Wolf");
|
||
const forestWolves = []; for (let i = 0; i < 3; i++) forestWolves.push(await mk("Dire Wolf"));
|
||
const batSwarm = await mk("Bat Swarm");
|
||
const rats = []; for (let i = 0; i < 3; i++) rats.push(await mk("Giant Rat"));
|
||
const skeletons = []; for (let i = 0; i < 6; i++) skeletons.push(await mk("Skeleton"));
|
||
const ghouls = []; for (let i = 0; i < 2; i++) ghouls.push(await mk("Ghoul"));
|
||
const vesper = await mk("Vesper Kound");
|
||
const aldric = await mk("King Aldric, the Vain Corpse");
|
||
const dispo = arr => arr.filter(Boolean).map(a => ({ actorId: a.id, name: a.name, img: a.img, disposition: -1 }));
|
||
const neutral = arr => arr.filter(Boolean).map(a => ({ actorId: a.id, name: a.name, img: a.img, disposition: 0 }));
|
||
|
||
// ---- treasure ----
|
||
const gearPack = await game.packs.get("vanity.gear").getDocuments();
|
||
const crown = {
|
||
name: "The Peacock Crown", type: "gear",
|
||
img: "icons/commodities/treasure/crown-gold-satin-gems-red.webp",
|
||
system: { quantity: 1, slots: 1, consumable: false, cost: "priceless",
|
||
description: "<p>A gaudy golden circlet, each point tipped with a peacock-eye gem that seems to <i>watch</i>. Whoever wears it gains a permanent <b>+1 die to Charm</b> — and an unrefusable <b>Vice: Pride</b>, and a standing Bane the GM holds against them. Keeping it, destroying it, or reburying it is the party's final, character-defining choice.</p>" }
|
||
};
|
||
|
||
// ---- Act I: the village (daylight, NPCs, no fight) ----
|
||
const village = await forgeStage({ type: "village", size: "large", name: "Nettlebrook", activate: false,
|
||
cast: neutral(npcs) });
|
||
|
||
// ---- Act II: the fight in the square (grave-robbers + a wolf) ----
|
||
const square = await forgeStage({ type: "village", size: "medium", name: "Nettlebrook — the Green", activate: false,
|
||
cast: dispo([...bandits, wolf1]) });
|
||
|
||
// ---- Act III: the forest road (beasts) ----
|
||
const forest = await forgeStage({ type: "forest", size: "large", name: "The Whispering Wood", activate: false,
|
||
cast: dispo([...forestWolves, batSwarm, ...rats]) });
|
||
|
||
// ---- Act IV: the barrow (crypt → throne) ----
|
||
const barrow = await forgeStage({ type: "barrow", size: "large", name: "The Barrow of King Aldric", activate: false,
|
||
cast: dispo([...skeletons, ...ghouls, vesper, aldric]) });
|
||
|
||
// hoard for the finale
|
||
await forgeHoard({ size: "vault" });
|
||
|
||
// ---- the journal ----
|
||
const scenes = { village, square, forest, barrow };
|
||
const npcLink = a => `@UUID[${a.uuid}]{${a.name}}`;
|
||
const sceneLink = s => `@UUID[${s.uuid}]{${s.name}}`;
|
||
const box = t => `<blockquote><p>${t}</p></blockquote>`;
|
||
const page = (name, html, sort) => ({ name, type: "text", title: { show: true, level: 1 },
|
||
text: { format: 1, content: `<div class="vanity-journal">${html}</div>` }, sort });
|
||
|
||
const pages = [
|
||
page("The Vain Crown — the road ahead", `
|
||
<p><i>An expanded one-to-two-session VANITY adventure. The vain boy-king <b>Aldric III</b> was buried a year ago with the <b>Peacock Crown</b>. Now the crown stirs, the dead king will not stay dead, and a grave-robbing sorcerer — <b>Vesper Kound</b> — is already on the road to claim it. It begins, as these things do, in a small village that would very much like the problem to go away.</i></p>
|
||
<h2>The four acts</h2>
|
||
<ul>
|
||
<li><b>Act I — Nettlebrook</b> (${sceneLink(village)}): meet the patron, gather rumours, spot Vesper's agent.</li>
|
||
<li><b>Act II — The Green</b> (${sceneLink(square)}): the whistle blows; grave-robbers and a wolf turn on the village.</li>
|
||
<li><b>Act III — The Whispering Wood</b> (${sceneLink(forest)}): the forest road to the barrow, and what hunts it.</li>
|
||
<li><b>Act IV — The Barrow of King Aldric</b> (${sceneLink(barrow)}): the crypt, the throne, and the crown that admires you back.</li>
|
||
</ul>
|
||
<p><b>Every map is a live Foundry scene</b> with walls, doors and daylight/fog set; <b>every name is a token already placed.</b> Nudge the tokens where you want them and press play.</p>`, 0),
|
||
|
||
page("Act I · Nettlebrook", `
|
||
${box("Nettlebrook is three streets, a green, a well, and a chapel the size of a shed. The reeve is waiting on the green in a velvet cap he plainly cannot afford, and he is very glad to see anyone at all carrying a weapon.")}
|
||
<p>Scene: ${sceneLink(village)} — daylight, no fog, freely walkable. Four faces to play:</p>
|
||
<ul>
|
||
<li>${npcLink(npcs[0])} — <i>${CROWN_NPCS[0].role}.</i> ${CROWN_NPCS[0].trick}</li>
|
||
<li>${npcLink(npcs[1])} — <i>${CROWN_NPCS[1].role}.</i> ${CROWN_NPCS[1].trick}</li>
|
||
<li>${npcLink(npcs[2])} — <i>${CROWN_NPCS[2].role}.</i> ${CROWN_NPCS[2].trick}</li>
|
||
<li>${npcLink(npcs[3])} — <i>${CROWN_NPCS[3].role}.</i> ${CROWN_NPCS[3].trick}</li>
|
||
</ul>
|
||
<p><b>Rolls that matter:</b> a <b>Reaction</b> (§24) for the Pale Stranger at −1 die; <b>Charm/Command</b> to open the reeve's purse wider; <b>Notice/Lore</b> to realise the 'pilgrim' is nothing of the kind. The moment the party corners the Stranger, they whistle and run — <b>go to Act II.</b></p>`, 100),
|
||
|
||
page("Act II · The Green", `
|
||
${box("A whistle, then screaming. Vesper left a handful of hard men in the village to keep it frightened — and something worse on a leash. They break cover from the alleys and the well-house, and a villager is already down in the mud.")}
|
||
<p>Scene: ${sceneLink(square)}. <b>Foes:</b> ${bandits.map(npcLink).join(" · ")} and ${npcLink(wolf1)}.</p>
|
||
<ul>
|
||
<li><b>Bandits</b> (attack 3d, leather, Grit 2): flee when half are down or the wolf falls.</li>
|
||
<li><b>Dire Wolf</b> (attack 4d, dodge 4d, Grit 5): <i>Knock Down free on a hit.</i> Vesper's sentry-beast.</li>
|
||
<li><b>The green</b> is cover country — the well, carts, and building corners. Reward <b>Environment</b> maneuvers and grandstanding (Vice bait, +1 Vanity).</li>
|
||
</ul>
|
||
<p>Take one bandit alive and they'll talk: Vesper rode for the barrow at dawn, by the forest road, 'and good luck to you on it.' <b>Go to Act III.</b></p>`, 200),
|
||
|
||
page("Act III · The Whispering Wood", `
|
||
${box("The barrow sits deep in the old wood, and the wood knows it. The path is there for those who can read it; off the path, the trees close ranks and things move that a year of the dead king's dreaming has made bold.")}
|
||
<p>Scene: ${sceneLink(forest)} — daylight, thickets block sight and step, a path winds east to a <b>clearing with the barrow mouth</b>.</p>
|
||
<ul>
|
||
<li><b>Wildcraft / Survive</b> holds the path (a Ranger auto-succeeds; others need 2 Successes or lose an hour and draw the swarm).</li>
|
||
<li><b>Beasts:</b> ${forestWolves.map(npcLink).join(" · ")} — a hunting pack; ${npcLink(batSwarm)} in the deep shade; ${rats.map(npcLink).join(" · ")} boiling from a rotten log.</li>
|
||
<li><i>Vanity bait:</i> the flashy open-water shortcut back on the fen is faster and watched. Staying on the forest road is slower and safer — let pride choose.</li>
|
||
</ul>
|
||
<p>The path ends at the clearing and the dark mouth of the barrow. <b>Go to Act IV.</b></p>`, 300),
|
||
|
||
page("Act IV · The Barrow of King Aldric", `
|
||
${box("Cold air breathes out of the hill. Somewhere below, a sorcerer is working, and a dead boy-king is beginning to remember that he was beautiful.")}
|
||
<p>Scene: ${sceneLink(barrow)} — rooms, doors and torchlight; token vision and fog on.</p>
|
||
<h3>The Sealed Door</h3>
|
||
<p>The mouth is a slab bound by a glowing <b>arcane sigil</b> (only <b>Arcana</b>, Threshold 2 — failure locks the spell and jolts everyone 2 Grit) <b>and</b> a mundane <b>trapped lock</b> beneath (only <b>Larceny</b> + thieves' tools — a failed roll springs a dart, a Wound). Two keys, two classes.</p>
|
||
<h3>The Crypt of Servants</h3>
|
||
<p>${skeletons.map(npcLink).join(" · ")} and ${ghouls.map(npcLink).join(" · ")} rise as the party crosses. The <b>Cleric's Turn Undead</b> sweeps the skeletons; the <b>Ghouls' paralysing claws</b> are the real danger, and the <b>Warrior</b> must hold the choke while the soft classes work.</p>
|
||
<h3>The Peacock Throne</h3>
|
||
<p>${npcLink(vesper)} has beaten the party here and just <b>woken ${npcLink(aldric)} by mistake</b>. Two-sided fight:</p>
|
||
<ul>
|
||
<li><b>Vesper Kound</b> (Necromancer, Grit 6): Firebolt, Sleep, raises fallen Skeletons; parleys or flees if losing — a live villain for later.</li>
|
||
<li><b>King Aldric, the Vain Corpse</b> (<b>Nemesis</b>, Grit 14, Resolve 3): spectral blade ignores armour; <b>Aura of Admiration</b> — look at the crown, resist with Poise or waste your action gazing; <b>Phase 2 at Grit 7</b> — the crown blazes and he attacks twice. Cap single hits at 4.</li>
|
||
</ul>
|
||
<h3>The spoils</h3>
|
||
<p>Vesper's grave-loot (the Vault hoard rolled to chat), and — if they dare — <b>The Peacock Crown</b>: a permanent +1 die to Charm, an unrefusable <b>Vice: Pride</b>, and a standing Bane. Keeping it, destroying it, or reburying it beside the boy-king is the note the whole adventure has been playing toward.</p>
|
||
<p><b>Rewards:</b> 2–3 Glory each. And whatever the crown costs.</p>`, 400)
|
||
];
|
||
|
||
const journal = await JournalEntry.create({
|
||
name: "The Vain Crown — Expanded", img: "icons/commodities/treasure/crown-gold-satin-gems-red.webp",
|
||
pages
|
||
});
|
||
|
||
// drop the crown into the barrow scene as a note/loot reminder isn't needed; announce
|
||
await village.activate();
|
||
await ChatMessage.create({
|
||
speaker: { alias: "The Vain Crown" }, whisper: ChatMessage.getWhisperRecipients("GM"),
|
||
content: `<div class="vanity-roll vanity-forge-card">
|
||
<header><span class="vanity-roll-label">👑 The Vain Crown is staged</span>
|
||
<span class="vanity-roll-sub">4 scenes · ${npcs.length + bandits.length + 1 + forestWolves.length + 1 + rats.length + skeletons.length + ghouls.length + 2} tokens placed · full journal</span></header>
|
||
<p>Read @UUID[${journal.uuid}]{The Vain Crown — Expanded}. Scenes: ${sceneLink(village)} → ${sceneLink(square)} → ${sceneLink(forest)} → ${sceneLink(barrow)}.</p>
|
||
<p><b>Nettlebrook</b> is active and waiting. Break a leg — gloriously.</p>
|
||
</div>`
|
||
});
|
||
return { journal, scenes };
|
||
}
|