uberwald/fvtt-oath-hammer
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

Nombreuses corrections sur les fiches settlement/NPC

Browse Source
This commit is contained in:
LeRatierBretonnier
2026-03-22 21:35:47 +01:00
parent ec291e9c60
commit b46c6d804c
51 changed files with 2892 additions and 227 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
module/applications/_module.mjs
View File

@@ -12,6 +12,9 @@ export { default as OathHammerOathSheet } from "./sheets/oath-sheet.mjs"
export { default as OathHammerClassSheet } from "./sheets/class-sheet.mjs"
export { default as OathHammerBuildingSheet } from "./sheets/building-sheet.mjs"
export { default as OathHammerSettlementSheet } from "./sheets/settlement-sheet.mjs"
export { default as OathHammerSkillNPCSheet } from "./sheets/skillnpc-sheet.mjs"
export { default as OathHammerNpcAttackSheet } from "./sheets/npcattack-sheet.mjs"
export { default as OathHammerRegimentSheet } from "./sheets/regiment-sheet.mjs"
export { default as OathHammerRollDialog } from "./roll-dialog.mjs"
export { default as OathHammerWeaponDialog } from "./weapon-dialog.mjs"
export { default as OathHammerSpellDialog } from "./spell-dialog.mjs"

13
module/applications/sheets/base-item-sheet.mjs
View File

@@ -1,5 +1,5 @@
const { HandlebarsApplicationMixin } = foundry.applications.api
import { ARMOR_TYPE_CHOICES, WEAPON_PROFICIENCY_GROUPS } from "../../config/system.mjs"
import { ARMOR_TYPE_CHOICES, CLASS_RESTRICTION_CHOICES, SYSTEM, WEAPON_PROFICIENCY_GROUPS } from "../../config/system.mjs"
import { rollRarityCheck } from "../../rolls.mjs"
export default class OathHammerItemSheet extends HandlebarsApplicationMixin(foundry.applications.sheets.ItemSheetV2) {
@@ -57,6 +57,10 @@ export default class OathHammerItemSheet extends HandlebarsApplicationMixin(foun
if (this.document.system.description !== undefined) {
context.enrichedDescription = await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.document.system.description ?? "", { async: true })
}
if (this.document.system.magicEffect !== undefined) {
context.enrichedMagicEffect = await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.document.system.magicEffect ?? "", { async: true })
}
context.classRestrictionChoices = CLASS_RESTRICTION_CHOICES
// Armor-specific numeric selects
context.armorValueChoices = Object.fromEntries(
Array.from({ length: 13 }, (_, i) => [i, String(i)])
@@ -71,6 +75,13 @@ export default class OathHammerItemSheet extends HandlebarsApplicationMixin(foun
context.apChoices = Object.fromEntries(
Array.from({ length: 7 }, (_, i) => [i, String(i)])
)
// Skill choices for weapon skill override (empty = auto-detect)
context.skillChoices = {
"": `— ${game.i18n.localize("OATHHAMMER.Weapon.SkillOverrideAuto")} —`,
...Object.fromEntries(
Object.entries(SYSTEM.SKILLS).map(([k, v]) => [k, game.i18n.localize(v.label)])
)
}
// Class proficiency choices (for class-sheet checkboxes)
context.armorTypeChoices = ARMOR_TYPE_CHOICES
context.weaponGroupChoices = WEAPON_PROFICIENCY_GROUPS

4
module/applications/sheets/character-sheet.mjs
View File

@@ -118,7 +118,6 @@ export default class OathHammerCharacterSheet extends OathHammerActorSheet {
_descTooltip: _stripHtml(parts.join(" "))
}
})
context.enrichedBackground = await foundry.applications.ux.TextEditor.implementation.enrichHTML(doc.system.background ?? "", { async: true })
break
case "skills": {
context.tab = context.tabs.skills
@@ -149,7 +148,7 @@ export default class OathHammerCharacterSheet extends OathHammerActorSheet {
modifierName: `system.skills.${skillKey}.modifier`,
colorDiceName: `system.skills.${skillKey}.colorDice`,
colorDiceTypeName: `system.skills.${skillKey}.colorDiceType`,
rankOptions: [0,1,2,3,4].map(v => ({ value: v, label: String(v), selected: v === sk.rank })),
rankOptions: [0,1,2,3,4,5,6].map(v => ({ value: v, label: String(v), selected: v === sk.rank })),
total: attrRanks[attr] + sk.rank,
// legacy - kept for formInput compatibility
name: `system.skills.${skillKey}.rank`,
@@ -232,6 +231,7 @@ export default class OathHammerCharacterSheet extends OathHammerActorSheet {
break
case "notes":
context.tab = context.tabs.notes
context.enrichedBackground = await foundry.applications.ux.TextEditor.implementation.enrichHTML(doc.system.background ?? "", { async: true })
context.enrichedDescription = await foundry.applications.ux.TextEditor.implementation.enrichHTML(doc.system.description ?? "", { async: true })
context.enrichedNotes = await foundry.applications.ux.TextEditor.implementation.enrichHTML(doc.system.notes ?? "", { async: true })
break

382
module/applications/sheets/npc-sheet.mjs
View File

@@ -1,50 +1,56 @@
import OathHammerActorSheet from "./base-actor-sheet.mjs"
import { rollInitiativeCheck } from "../../rolls.mjs"
import { SYSTEM } from "../../config/system.mjs"
import { rollInitiativeCheck, rollNPCSkill, rollNPCArmor, rollNPCSpell, rollNPCMiracle, rollNPCAttackDamage } from "../../rolls.mjs"
export default class OathHammerNPCSheet extends OathHammerActorSheet {
/** @override */
static DEFAULT_OPTIONS = {
classes: ["npc"],
position: {
width: 720,
height: "auto",
},
window: {
contentClasses: ["npc-content"],
},
position: { width: 720, height: "auto" },
window: { contentClasses: ["npc-content"] },
actions: {
rollInitiative: OathHammerNPCSheet.#onRollInitiative,
rollInitiative: OathHammerNPCSheet.#onRollInitiative,
adjustGrit: OathHammerNPCSheet.#onAdjustGrit,
rollSkillNPC: OathHammerNPCSheet.#onRollSkillNPC,
rollArmor: OathHammerNPCSheet.#onRollArmor,
createSpell: OathHammerNPCSheet.#onCreateSpell,
createMiracle: OathHammerNPCSheet.#onCreateMiracle,
castNPCSpell: OathHammerNPCSheet.#onCastNPCSpell,
castNPCMiracle: OathHammerNPCSheet.#onCastNPCMiracle,
createNpcAttack: OathHammerNPCSheet.#onCreateNpcAttack,
rollNpcAttack: OathHammerNPCSheet.#onRollNpcAttack,
},
}
/** @override */
static PARTS = {
main: {
template: "systems/fvtt-oath-hammer/templates/actor/npc-sheet.hbs",
},
tabs: {
template: "templates/generic/tab-navigation.hbs",
},
combat: {
template: "systems/fvtt-oath-hammer/templates/actor/npc-combat.hbs",
},
notes: {
template: "systems/fvtt-oath-hammer/templates/actor/npc-notes.hbs",
},
main: { template: "systems/fvtt-oath-hammer/templates/actor/npc-sheet.hbs" },
tabs: { template: "templates/generic/tab-navigation.hbs" },
skills: { template: "systems/fvtt-oath-hammer/templates/actor/npc-skills.hbs" },
combat: { template: "systems/fvtt-oath-hammer/templates/actor/npc-combat.hbs" },
traits: { template: "systems/fvtt-oath-hammer/templates/actor/npc-traits.hbs" },
magic: { template: "systems/fvtt-oath-hammer/templates/actor/npc-magic.hbs" },
equipment: { template: "systems/fvtt-oath-hammer/templates/actor/npc-equipment.hbs" },
notes: { template: "systems/fvtt-oath-hammer/templates/actor/npc-notes.hbs" },
}
/** @override */
tabGroups = {
sheet: "combat",
}
tabGroups = { sheet: "skills" }
#getTabs() {
const isNPC = this.document.system.subtype === "npc"
const hasMagic = this.document.items.some(i => i.type === "spell" || i.type === "miracle")
const tabs = {
combat: { id: "combat", group: "sheet", icon: "fa-solid fa-swords", label: "OATHHAMMER.Tab.Combat" },
notes: { id: "notes", group: "sheet", icon: "fa-solid fa-book", label: "OATHHAMMER.Tab.Notes" },
skills: { id: "skills", group: "sheet", icon: "fa-solid fa-dice-d6", label: "OATHHAMMER.Tab.Skills" },
combat: { id: "combat", group: "sheet", icon: "fa-solid fa-swords", label: "OATHHAMMER.Tab.Combat" },
traits: { id: "traits", group: "sheet", icon: "fa-solid fa-star", label: "OATHHAMMER.Tab.Traits" },
notes: { id: "notes", group: "sheet", icon: "fa-solid fa-book", label: "OATHHAMMER.Tab.Notes" },
}
if (isNPC) {
tabs.equipment = { id: "equipment", group: "sheet", icon: "fa-solid fa-backpack", label: "OATHHAMMER.Tab.Equipment" }
}
if (hasMagic || !this.isPlayMode) {
tabs.magic = { id: "magic", group: "sheet", icon: "fa-solid fa-wand-sparkles", label: "OATHHAMMER.Tab.Magic" }
}
for (const v of Object.values(tabs)) {
v.active = this.tabGroups[v.group] === v.id
v.active = this.tabGroups[v.group] === v.id
v.cssClass = v.active ? "active" : ""
}
return tabs
@@ -54,6 +60,23 @@ export default class OathHammerNPCSheet extends OathHammerActorSheet {
async _prepareContext() {
const context = await super._prepareContext()
context.tabs = this.#getTabs()
context.subtypeChoices = Object.fromEntries(
Object.entries(SYSTEM.NPC_SUBTYPES).map(([k, v]) => [k, game.i18n.localize(v)])
)
context.subtypeLabels = context.subtypeChoices
const armorColor = this.document.system.armorDice?.colorDiceType ?? "white"
context.armorDiceEmoji = armorColor === "black" ? "⬛" : armorColor === "red" ? "🔴" : "⬜"
context.colorChoices = Object.fromEntries(
Object.entries(SYSTEM.DICE_COLOR_TYPES).map(([k, v]) => [k, game.i18n.localize(v)])
)
context.traitTypeLabels = Object.fromEntries(
Object.entries(SYSTEM.TRAIT_TYPE_CHOICES).map(([k, v]) => [k, v])
)
return context
}
@@ -61,29 +84,265 @@ export default class OathHammerNPCSheet extends OathHammerActorSheet {
async _preparePartContext(partId, context) {
const doc = this.document
switch (partId) {
case "main":
case "skills":
context.tab = context.tabs.skills
context.skills = (doc.itemTypes.skillnpc ?? []).slice().sort((a, b) => a.name.localeCompare(b.name))
break
case "combat":
context.tab = context.tabs.combat
context.weapons = doc.itemTypes.weapon
context.npcAttacks = (doc.itemTypes.npcattack ?? []).map(a => ({
id: a.id, uuid: a.uuid, img: a.img, name: a.name, system: a.system,
_descTooltip: a.system.description?.replace(/<[^>]+>/g, "").slice(0, 300) ?? ""
}))
context.combatantInitiative = game.combat?.combatants.find(c => c.actor?.id === doc.id)?.initiative ?? null
break
case "traits":
context.tab = context.tabs.traits
context.traits = (doc.itemTypes.trait ?? []).slice().sort((a, b) => a.name.localeCompare(b.name)).map(t => ({
id: t.id, uuid: t.uuid, img: t.img, name: t.name, system: t.system,
_descTooltip: t.system.description?.replace(/<[^>]+>/g, "").slice(0, 300) ?? ""
}))
break
case "magic":
context.tab = context.tabs.magic
context.spells = (doc.itemTypes.spell ?? []).map(s => ({
id: s.id, uuid: s.uuid, img: s.img, name: s.name, system: s.system,
_descTooltip: s.system.effect?.replace(/<[^>]+>/g, "").slice(0, 300) ?? ""
}))
context.miracles = (doc.itemTypes.miracle ?? []).map(m => ({
id: m.id, uuid: m.uuid, img: m.img, name: m.name, system: m.system,
_descTooltip: m.system.effect?.replace(/<[^>]+>/g, "").slice(0, 300) ?? ""
}))
break
case "equipment":
context.tab = context.tabs.equipment
context.armors = doc.itemTypes.armor ?? []
context.equipment = doc.itemTypes.equipment ?? []
break
case "notes":
context.tab = context.tabs.notes
context.enrichedDescription = await foundry.applications.ux.TextEditor.implementation.enrichHTML(doc.system.description, { async: true })
context.enrichedNotes = await foundry.applications.ux.TextEditor.implementation.enrichHTML(doc.system.notes, { async: true })
context.enrichedNotes = await foundry.applications.ux.TextEditor.implementation.enrichHTML(doc.system.notes, { async: true })
break
}
return context
}
/** @override */
async _onDrop(event) {
if (!this.isEditable || !this.isEditMode) return
const data = foundry.applications.ux.TextEditor.implementation.getDragEventData(event)
if (data.type === "Item") {
const item = await fromUuid(data.uuid)
return this._onDropItem(item)
}
if (data.type !== "Item") return
const item = await fromUuid(data.uuid)
if (!item) return
const ALLOWED = new Set(["skillnpc", "npcattack", "trait", "armor", "equipment", "spell", "miracle"])
if (!ALLOWED.has(item.type)) return
return this._onDropItem(item)
}
static async #onAdjustGrit(event, target) {
const delta = parseInt(target.dataset.delta, 10)
const current = this.document.system.grit?.value ?? 0
const max = this.document.system.grit?.max ?? current
await this.document.update({ "system.grit.value": Math.max(0, Math.min(max, current + delta)) })
}
static #onCreateNpcAttack() {
this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("OATHHAMMER.NewItem.NpcAttack"), type: "npcattack" }])
}
static async #onRollNpcAttack(event, target) {
const attack = this.document.items.get(target.dataset.itemId)
if (!attack) return
const bonusOptions = Array.from({ length: 13 }, (_, i) => {
const v = i - 6
return { value: v, label: v > 0 ? `+${v}` : String(v), selected: v === 0 }
})
const content = await foundry.applications.handlebars.renderTemplate(
"systems/fvtt-oath-hammer/templates/npc-skill-dialog.hbs",
{
skillName: attack.name,
skillImg: attack.img,
dicePool: attack.system.damageDice,
colorEmoji: attack.system.colorEmoji,
colorType: attack.system.colorDiceType,
threshold: attack.system.threshold,
bonusOptions,
colorChoices: Object.fromEntries(
Object.entries(SYSTEM.DICE_COLOR_TYPES).map(([k, v]) => [k, game.i18n.localize(v)])
),
rollModes: foundry.utils.duplicate(CONFIG.Dice.rollModes),
visibility: game.settings.get("core", "rollMode"),
}
)
const result = await foundry.applications.api.DialogV2.prompt({
window: { title: attack.name, resizable: true },
classes: ["fvtt-oath-hammer"],
position: { width: 420 },
content,
ok: { label: game.i18n.localize("OATHHAMMER.Dialog.Roll"), icon: "fa-solid fa-burst" },
})
if (!result) return
const form = new DOMParser().parseFromString(result, "text/html")
const getValue = name => form.querySelector(`[name="${name}"]`)?.value
await rollNPCAttackDamage(this.document, attack, {
bonus: parseInt(getValue("bonus")) || 0,
visibility: getValue("visibility"),
})
}
static #onCreateSpell() {
this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("OATHHAMMER.NewItem.Spell"), type: "spell" }])
}
static #onCreateMiracle() {
this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("OATHHAMMER.NewItem.Miracle"), type: "miracle" }])
}
static async #onCastNPCSpell(event, target) {
const spell = this.document.items.get(target.dataset.itemId)
if (!spell) return
const colorChoices = Object.fromEntries(
Object.entries(SYSTEM.DICE_COLOR_TYPES).map(([k, v]) => [k, game.i18n.localize(v)])
)
const poolOptions = Array.from({ length: 10 }, (_, i) => {
const v = i + 1
return { value: v, label: String(v), selected: v === 3 }
})
const bonusOptions = Array.from({ length: 13 }, (_, i) => {
const v = i - 6
return { value: v, label: v > 0 ? `+${v}` : String(v), selected: v === 0 }
})
const content = await foundry.applications.handlebars.renderTemplate(
"systems/fvtt-oath-hammer/templates/npc-magic-dialog.hbs",
{
itemName: spell.name, itemImg: spell.img,
dv: spell.system.difficultyValue,
poolOptions, bonusOptions, colorChoices, showColor: true,
rollModes: foundry.utils.duplicate(CONFIG.Dice.rollModes),
visibility: game.settings.get("core", "rollMode"),
}
)
const result = await foundry.applications.api.DialogV2.prompt({
window: { title: spell.name, resizable: true },
classes: ["fvtt-oath-hammer"],
position: { width: 420 },
content,
ok: { label: game.i18n.localize("OATHHAMMER.Dialog.Roll"), icon: "fa-solid fa-wand-sparkles" },
})
if (!result) return
const form = new DOMParser().parseFromString(result, "text/html")
const getValue = name => form.querySelector(`[name="${name}"]`)?.value
await rollNPCSpell(this.document, spell, {
dicePool: parseInt(getValue("dicePool")) || 3,
bonus: parseInt(getValue("bonus")) || 0,
colorOverride: getValue("colorOverride") || null,
visibility: getValue("visibility"),
})
}
static async #onCastNPCMiracle(event, target) {
const miracle = this.document.items.get(target.dataset.itemId)
if (!miracle) return
const poolOptions = Array.from({ length: 10 }, (_, i) => {
const v = i + 1
return { value: v, label: String(v), selected: v === 3 }
})
const bonusOptions = Array.from({ length: 13 }, (_, i) => {
const v = i - 6
return { value: v, label: v > 0 ? `+${v}` : String(v), selected: v === 0 }
})
const content = await foundry.applications.handlebars.renderTemplate(
"systems/fvtt-oath-hammer/templates/npc-magic-dialog.hbs",
{
itemName: miracle.name, itemImg: miracle.img,
dv: null, showColor: false,
poolOptions, bonusOptions,
rollModes: foundry.utils.duplicate(CONFIG.Dice.rollModes),
visibility: game.settings.get("core", "rollMode"),
}
)
const result = await foundry.applications.api.DialogV2.prompt({
window: { title: miracle.name, resizable: true },
classes: ["fvtt-oath-hammer"],
position: { width: 420 },
content,
ok: { label: game.i18n.localize("OATHHAMMER.Dialog.Roll"), icon: "fa-solid fa-hands-praying" },
})
if (!result) return
const form = new DOMParser().parseFromString(result, "text/html")
const getValue = name => form.querySelector(`[name="${name}"]`)?.value
await rollNPCMiracle(this.document, miracle, {
dicePool: parseInt(getValue("dicePool")) || 3,
bonus: parseInt(getValue("bonus")) || 0,
visibility: getValue("visibility"),
})
}
static async #onRollArmor() {
const actor = this.document
const sys = actor.system
const colorType = sys.armorDice?.colorDiceType || "white"
const threshold = colorType === "black" ? 2 : colorType === "red" ? 3 : 4
const colorEmoji = colorType === "black" ? "⬛" : colorType === "red" ? "🔴" : "⬜"
const dicePool = sys.armorDice?.value ?? 0
const colorChoices = Object.fromEntries(
Object.entries(SYSTEM.DICE_COLOR_TYPES).map(([k, v]) => [k, game.i18n.localize(v)])
)
const bonusOptions = Array.from({ length: 13 }, (_, i) => {
const v = i - 6
return { value: v, label: v > 0 ? `+${v}` : String(v), selected: v === 0 }
})
const content = await foundry.applications.handlebars.renderTemplate(
"systems/fvtt-oath-hammer/templates/npc-skill-dialog.hbs",
{
skillName: game.i18n.localize("OATHHAMMER.Label.ArmorDice"),
skillImg: actor.img,
dicePool,
colorEmoji,
colorType,
threshold,
bonusOptions,
colorChoices,
rollModes: foundry.utils.duplicate(CONFIG.Dice.rollModes),
visibility: game.settings.get("core", "rollMode"),
}
)
const result = await foundry.applications.api.DialogV2.prompt({
window: { title: game.i18n.localize("OATHHAMMER.Label.ArmorDice"), resizable: true },
classes: ["fvtt-oath-hammer"],
position: { width: 420 },
content,
ok: { label: game.i18n.localize("OATHHAMMER.Dialog.Roll"), icon: "fa-solid fa-dice-d6" },
})
if (!result) return
const form = new DOMParser().parseFromString(result, "text/html")
const getValue = name => form.querySelector(`[name="${name}"]`)?.value
await rollNPCArmor(actor, {
bonus: parseInt(getValue("bonus")) || 0,
colorOverride: getValue("colorOverride") || null,
visibility: getValue("visibility"),
})
}
static async #onRollInitiative() {
@@ -95,4 +354,53 @@ export default class OathHammerNPCSheet extends OathHammerActorSheet {
await rollInitiativeCheck(actor)
}
}
static async #onRollSkillNPC(event, target) {
const itemId = target.dataset.itemId
const item = this.document.items.get(itemId)
if (!item) return
const colorChoices = Object.fromEntries(
Object.entries(SYSTEM.DICE_COLOR_TYPES).map(([k, v]) => [k, game.i18n.localize(v)])
)
const bonusOptions = Array.from({ length: 13 }, (_, i) => {
const v = i - 6
return { value: v, label: v > 0 ? `+${v}` : String(v), selected: v === 0 }
})
const content = await foundry.applications.handlebars.renderTemplate(
"systems/fvtt-oath-hammer/templates/npc-skill-dialog.hbs",
{
skillName: item.name,
skillImg: item.img,
dicePool: item.system.dicePool,
colorEmoji: item.system.colorEmoji,
colorType: item.system.colorDiceType,
threshold: item.system.threshold,
bonusOptions,
colorChoices,
rollModes: foundry.utils.duplicate(CONFIG.Dice.rollModes),
visibility: game.settings.get("core", "rollMode"),
}
)
const result = await foundry.applications.api.DialogV2.prompt({
window: { title: item.name, resizable: true },
classes: ["fvtt-oath-hammer"],
position: { width: 420 },
content,
ok: { label: game.i18n.localize("OATHHAMMER.Dialog.Roll"), icon: "fa-solid fa-dice-d6" },
})
if (!result) return
const form = new DOMParser().parseFromString(result, "text/html")
const getValue = name => form.querySelector(`[name="${name}"]`)?.value
await rollNPCSkill(this.document, item, {
bonus: parseInt(getValue("bonus")) || 0,
colorOverride: getValue("colorOverride") || null,
visibility: getValue("visibility"),
})
}
}

28
module/applications/sheets/npcattack-sheet.mjs Normal file
View File

@@ -0,0 +1,28 @@
import OathHammerItemSheet from "./base-item-sheet.mjs"
import { SYSTEM } from "../../config/system.mjs"
export default class OathHammerNpcAttackSheet extends OathHammerItemSheet {
/** @override */
static DEFAULT_OPTIONS = {
classes: ["npcattack"],
position: { width: 460 },
window: { contentClasses: ["npcattack-content"] },
}
/** @override */
static PARTS = {
main: { template: "systems/fvtt-oath-hammer/templates/item/npcattack-sheet.hbs" },
}
/** @override */
async _prepareContext() {
const context = await super._prepareContext()
context.dicePoolChoices = Object.fromEntries(
Array.from({ length: 21 }, (_, i) => [i, String(i)])
)
context.colorChoices = Object.fromEntries(
Object.entries(SYSTEM.DICE_COLOR_TYPES).map(([k, v]) => [k, game.i18n.localize(v)])
)
return context
}
}

80
module/applications/sheets/regiment-sheet.mjs Normal file
View File

@@ -0,0 +1,80 @@
import OathHammerItemSheet from "./base-item-sheet.mjs"
import { SYSTEM } from "../../config/system.mjs"
export default class OathHammerRegimentSheet extends OathHammerItemSheet {
/** @override */
static DEFAULT_OPTIONS = {
classes: ["regiment"],
position: { width: 560, height: "auto" },
window: { contentClasses: ["regiment-content"] },
actions: {
addSkill: OathHammerRegimentSheet.#onAddSkill,
removeSkill: OathHammerRegimentSheet.#onRemoveSkill,
addAttack: OathHammerRegimentSheet.#onAddAttack,
removeAttack:OathHammerRegimentSheet.#onRemoveAttack,
addTrait: OathHammerRegimentSheet.#onAddTrait,
removeTrait: OathHammerRegimentSheet.#onRemoveTrait,
},
}
/** @override */
static PARTS = {
main: { template: "systems/fvtt-oath-hammer/templates/item/regiment-sheet.hbs" },
}
/** @override */
async _prepareContext() {
const context = await super._prepareContext()
context.colorChoices = Object.fromEntries(
Object.entries(SYSTEM.DICE_COLOR_TYPES).map(([k, v]) => [k, game.i18n.localize(v)])
)
context.dicePoolChoices = Object.fromEntries(
Array.from({ length: 21 }, (_, i) => [i, String(i)])
)
context.apChoices = Object.fromEntries(
Array.from({ length: 7 }, (_, i) => [i, String(i)])
)
return context
}
// ── Array helpers ────────────────────────────────────────────────────────────
static async #onAddSkill() {
const skills = foundry.utils.deepClone(this.document.system.skills ?? [])
skills.push({ name: "", value: 2, colorDiceType: "white" })
await this.document.update({ "system.skills": skills })
}
static async #onRemoveSkill(event, target) {
const idx = parseInt(target.dataset.idx, 10)
const skills = foundry.utils.deepClone(this.document.system.skills ?? [])
skills.splice(idx, 1)
await this.document.update({ "system.skills": skills })
}
static async #onAddAttack() {
const attacks = foundry.utils.deepClone(this.document.system.attacks ?? [])
attacks.push({ name: "", damageDice: 6, colorDiceType: "white", ap: 0, special: "" })
await this.document.update({ "system.attacks": attacks })
}
static async #onRemoveAttack(event, target) {
const idx = parseInt(target.dataset.idx, 10)
const attacks = foundry.utils.deepClone(this.document.system.attacks ?? [])
attacks.splice(idx, 1)
await this.document.update({ "system.attacks": attacks })
}
static async #onAddTrait() {
const traits = foundry.utils.deepClone(this.document.system.traits ?? [])
traits.push({ name: "", description: "" })
await this.document.update({ "system.traits": traits })
}
static async #onRemoveTrait(event, target) {
const idx = parseInt(target.dataset.idx, 10)
const traits = foundry.utils.deepClone(this.document.system.traits ?? [])
traits.splice(idx, 1)
await this.document.update({ "system.traits": traits })
}
}

83
module/applications/sheets/settlement-sheet.mjs
View File

@@ -1,6 +1,6 @@
import OathHammerActorSheet from "./base-actor-sheet.mjs"
const ALLOWED_ITEM_TYPES = new Set(["building", "equipment", "weapon", "armor"])
const ALLOWED_ITEM_TYPES = new Set(["building", "equipment", "weapon", "armor", "regiment"])
export default class OathHammerSettlementSheet extends OathHammerActorSheet {
/** @override */
@@ -14,9 +14,11 @@ export default class OathHammerSettlementSheet extends OathHammerActorSheet {
contentClasses: ["settlement-content"],
},
actions: {
adjustCurrency: OathHammerSettlementSheet.#onAdjustCurrency,
adjustQty: OathHammerSettlementSheet.#onAdjustQty,
adjustCurrency: OathHammerSettlementSheet.#onAdjustCurrency,
adjustQty: OathHammerSettlementSheet.#onAdjustQty,
toggleConstructed: OathHammerSettlementSheet.#onToggleConstructed,
createRegiment: OathHammerSettlementSheet.#onCreateRegiment,
collectTaxes: OathHammerSettlementSheet.#onCollectTaxes,
},
}
@@ -37,6 +39,9 @@ export default class OathHammerSettlementSheet extends OathHammerActorSheet {
inventory: {
template: "systems/fvtt-oath-hammer/templates/actor/settlement-inventory.hbs",
},
garrison: {
template: "systems/fvtt-oath-hammer/templates/actor/settlement-garrison.hbs",
},
}
/** @override */
@@ -46,9 +51,10 @@ export default class OathHammerSettlementSheet extends OathHammerActorSheet {
#getTabs() {
const tabs = {
overview: { id: "overview", group: "sheet", icon: "fa-solid fa-city", label: "OATHHAMMER.Tab.Overview" },
buildings: { id: "buildings", group: "sheet", icon: "fa-solid fa-building", label: "OATHHAMMER.Tab.Buildings" },
inventory: { id: "inventory", group: "sheet", icon: "fa-solid fa-boxes-stacked", label: "OATHHAMMER.Tab.Inventory" },
overview: { id: "overview", group: "sheet", icon: "fa-solid fa-city", label: "OATHHAMMER.Tab.Overview" },
buildings: { id: "buildings", group: "sheet", icon: "fa-solid fa-building", label: "OATHHAMMER.Tab.Buildings" },
inventory: { id: "inventory", group: "sheet", icon: "fa-solid fa-boxes-stacked", label: "OATHHAMMER.Tab.Inventory" },
garrison: { id: "garrison", group: "sheet", icon: "fa-solid fa-shield-halved", label: "OATHHAMMER.Tab.Garrison" },
}
for (const v of Object.values(tabs)) {
v.active = this.tabGroups[v.group] === v.id
@@ -81,7 +87,11 @@ export default class OathHammerSettlementSheet extends OathHammerActorSheet {
break
case "buildings":
context.tab = context.tabs.buildings
context.buildings = doc.itemTypes.building
context.buildings = doc.itemTypes.building.map(b => ({
id: b.id, uuid: b.uuid, img: b.img, name: b.name, system: b.system,
_descTooltip: b.system.description?.replace(/<[^>]+>/g, "").trim().slice(0, 400) ?? ""
}))
context.hasTaxBuildings = doc.itemTypes.building.some(b => b.system.constructed && b.system.taxRevenue?.trim())
break
case "inventory": {
context.tab = context.tabs.inventory
@@ -90,6 +100,10 @@ export default class OathHammerSettlementSheet extends OathHammerActorSheet {
context.equipments = doc.itemTypes.equipment
break
}
case "garrison":
context.tab = context.tabs.garrison
context.regiments = doc.itemTypes.regiment ?? []
break
}
return context
}
@@ -129,4 +143,59 @@ export default class OathHammerSettlementSheet extends OathHammerActorSheet {
if (!item) return
await item.update({ "system.constructed": !item.system.constructed })
}
static async #onCreateRegiment() {
await this.document.createEmbeddedDocuments("Item", [{
name: game.i18n.localize("OATHHAMMER.NewItem.Regiment"),
type: "regiment",
}])
}
static async #onCollectTaxes() {
const actor = this.document
// Only constructed buildings with a non-empty taxRevenue formula
const taxBuildings = actor.itemTypes.building.filter(
b => b.system.constructed && b.system.taxRevenue?.trim()
)
if (!taxBuildings.length) {
ui.notifications.warn(game.i18n.localize("OATHHAMMER.Settlement.NoTaxRevenue"))
return
}
// Roll each building's formula individually, sum totals
const rolls = []
const lines = []
let total = 0
for (const b of taxBuildings) {
const r = new Roll(b.system.taxRevenue.trim())
await r.evaluate()
rolls.push(r)
total += r.total
lines.push(`<li><strong>${b.name}</strong> — ${b.system.taxRevenue} = <em>${r.total} gp</em></li>`)
}
const content = `
<div class="oh-roll-card oh-weapon-card">
<div class="oh-roll-header">
<span class="oh-roll-title">🏛 ${actor.name}</span>
<span class="oh-roll-subtitle">${game.i18n.localize("OATHHAMMER.Settlement.CollectTaxes")}</span>
</div>
<div class="oh-roll-info">
<ul style="margin:4px 0;padding-left:1.2em;">${lines.join("")}</ul>
</div>
<div class="oh-roll-result">
<span class="oh-roll-successes">${total} gp</span>
<span class="oh-roll-verdict">${game.i18n.localize("OATHHAMMER.Settlement.TotalRevenue")}</span>
</div>
</div>`
const msgData = {
speaker: ChatMessage.getSpeaker({ actor }),
content,
rolls,
sound: CONFIG.sounds.dice,
}
ChatMessage.applyRollMode(msgData, game.settings.get("core", "rollMode"))
await ChatMessage.create(msgData)
}
}

37
module/applications/sheets/skillnpc-sheet.mjs Normal file
View File

@@ -0,0 +1,37 @@
import OathHammerItemSheet from "./base-item-sheet.mjs"
import { SYSTEM } from "../../config/system.mjs"
export default class OathHammerSkillNPCSheet extends OathHammerItemSheet {
/** @override */
static DEFAULT_OPTIONS = {
classes: ["skillnpc"],
position: { width: 460 },
window: { contentClasses: ["skillnpc-content"] },
}
/** @override */
static PARTS = {
main: { template: "systems/fvtt-oath-hammer/templates/item/skillnpc-sheet.hbs" },
}
/** @override */
async _prepareContext() {
const context = await super._prepareContext()
// Build dicePool selector (0–20)
context.dicePoolChoices = Object.fromEntries(
Array.from({ length: 21 }, (_, i) => [i, String(i)])
)
// Color choices (localized labels)
context.colorChoices = Object.fromEntries(
Object.entries(SYSTEM.DICE_COLOR_TYPES).map(([k, v]) => [k, game.i18n.localize(v)])
)
// Skill reference choices (optional)
context.skillRefChoices = {
"": `— ${game.i18n.localize("OATHHAMMER.Label.None")} —`,
...Object.fromEntries(
Object.entries(SYSTEM.SKILLS).map(([k, v]) => [k, game.i18n.localize(v.label)])
)
}
return context
}
}

12
module/applications/weapon-dialog.mjs
View File

@@ -20,7 +20,7 @@ export default class OathHammerWeaponDialog {
const actorSys = actor.system
const isRanged = sys.proficiencyGroup === "bows" || sys.proficiencyGroup === "throwing"
const skillKey = isRanged ? "shooting" : "fighting"
const skillKey = (sys.skillOverride && SYSTEM.SKILLS[sys.skillOverride]) ? sys.skillOverride : (isRanged ? "shooting" : "fighting")
const skillDef = SYSTEM.SKILLS[skillKey]
const defaultAttr = skillDef.attribute
const attrRank = actorSys.attributes[defaultAttr].rank
@@ -53,7 +53,8 @@ export default class OathHammerWeaponDialog {
const damageThreshold = hasDeadly ? 2 : hasBrutal ? 3 : 4
const damageColorLabel = hasDeadly ? "⬛" : hasBrutal ? "🔴" : "⬜"
const mightRank = actorSys.attributes.might.rank
const baseDamageDice = sys.usesMight ? Math.max(mightRank + sys.damageMod, 1) : Math.max(sys.damageMod, 1)
const damageAttrRank = actorSys.attributes[skillDef.attribute].rank
const baseDamageDice = sys.usesMight ? Math.max(damageAttrRank + sys.damageMod, 1) : Math.max(sys.damageMod, 1)
const traitLabels = [...sys.traits].map(t => {
const key = SYSTEM.WEAPON_TRAITS[t]
@@ -329,8 +330,11 @@ export default class OathHammerWeaponDialog {
const damageColorType = hasDeadly ? "black" : hasBrutal ? "red" : "white"
const damageThreshold = hasDeadly ? 2 : hasBrutal ? 3 : 4
const damageColorLabel = hasDeadly ? "⬛" : hasBrutal ? "🔴" : "⬜"
const mightRank = actorSys.attributes.might.rank
const baseDamageDice = sys.usesMight ? Math.max(mightRank + sys.damageMod, 1) : Math.max(sys.damageMod, 1)
const isRanged = sys.proficiencyGroup === "bows" || sys.proficiencyGroup === "throwing"
const damageSkillKey = (sys.skillOverride && SYSTEM.SKILLS[sys.skillOverride]) ? sys.skillOverride : (isRanged ? "shooting" : "fighting")
const damageAttrKey = SYSTEM.SKILLS[damageSkillKey].attribute
const damageAttrRank = actorSys.attributes[damageAttrKey].rank
const baseDamageDice = sys.usesMight ? Math.max(damageAttrRank + sys.damageMod, 1) : Math.max(sys.damageMod, 1)
// Auto-bonuses from special properties
let autoDamageBonus = 0

35
module/config/system.mjs
View File

@@ -177,6 +177,19 @@ export const MAGIC_QUALITY_CHOICES = {
legendary: "OATHHAMMER.MagicQuality.Legendary"
}
export const CLASS_RESTRICTION_CHOICES = {
berserker: "OATHHAMMER.Class.Berserker",
champion: "OATHHAMMER.Class.Champion",
delver: "OATHHAMMER.Class.Delver",
knight: "OATHHAMMER.Class.Knight",
mage: "OATHHAMMER.Class.Mage",
priest: "OATHHAMMER.Class.Priest",
scout: "OATHHAMMER.Class.Scout",
soldier: "OATHHAMMER.Class.Soldier",
spellblade: "OATHHAMMER.Class.Spellblade",
troubadour: "OATHHAMMER.Class.Troubadour",
}
export const RARITY_CHOICES = {
always: "OATHHAMMER.Rarity.Always",
common: "OATHHAMMER.Rarity.Common",
@@ -198,9 +211,22 @@ export const RARITY_DV = {
// Two types of trait per the rulebook terminology
export const TRAIT_TYPE_CHOICES = {
"special-trait": "OATHHAMMER.TraitType.SpecialTrait",
"class-trait": "OATHHAMMER.TraitType.ClassTrait",
"lineage-trait": "OATHHAMMER.TraitType.LineageTrait"
"special-trait": "OATHHAMMER.TraitType.SpecialTrait",
"class-trait": "OATHHAMMER.TraitType.ClassTrait",
"lineage-trait": "OATHHAMMER.TraitType.LineageTrait",
"npc-trait": "OATHHAMMER.TraitType.NpcTrait",
"creature-trait": "OATHHAMMER.TraitType.CreatureTrait"
}
export const NPC_SUBTYPES = {
"creature": "OATHHAMMER.NpcSubtype.Creature",
"npc": "OATHHAMMER.NpcSubtype.Npc"
}
export const DICE_COLOR_TYPES = {
"white": "OATHHAMMER.DiceColor.White",
"red": "OATHHAMMER.DiceColor.Red",
"black": "OATHHAMMER.DiceColor.Black"
}
// When a trait's uses reset (none = passive/always on)
@@ -395,10 +421,13 @@ export const SYSTEM = {
EQUIPMENT_TYPE_CHOICES,
MAGIC_ITEM_TYPE_CHOICES,
MAGIC_QUALITY_CHOICES,
CLASS_RESTRICTION_CHOICES,
RARITY_CHOICES,
RARITY_DV,
TRAIT_TYPE_CHOICES,
TRAIT_USAGE_PERIOD,
NPC_SUBTYPES,
DICE_COLOR_TYPES,
BUILDING_SKILL_CHOICES,
SETTLEMENT_ARCHETYPES,
STATUS_EFFECTS,

3
module/models/_module.mjs
View File

@@ -12,3 +12,6 @@ export { default as OathHammerOath } from "./oath.mjs"
export { default as OathHammerClass } from "./class.mjs"
export { default as OathHammerBuilding } from "./building.mjs"
export { default as OathHammerSettlement } from "./settlement.mjs"
export { default as OathHammerSkillNPC } from "./skillnpc.mjs"
export { default as OathHammerNpcAttack } from "./npcattack.mjs"
export { default as OathHammerRegiment } from "./regiment.mjs"

2
module/models/character.mjs
View File

@@ -31,7 +31,7 @@ export default class OathHammerCharacter extends foundry.abstract.TypeDataModel
// Total dice = attr rank + skill rank. Modifier = bonus (+) or penalty (-) dice.
// Color dice: type (white 4+, red 3+, black 2+) + count of colored dice in the pool.
const skillField = () => new fields.SchemaField({
rank: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0, max: 4 }),
rank: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0, max: 6 }),
modifier: new fields.NumberField({ required: true, nullable: false, integer: true, initial: 0 }),
colorDiceType: new fields.StringField({ required: true, nullable: false, initial: "white",
choices: { white: "OATHHAMMER.ColorDice.White", red: "OATHHAMMER.ColorDice.Red", black: "OATHHAMMER.ColorDice.Black" } }),

25
module/models/npc.mjs
View File

@@ -9,16 +9,9 @@ export default class OathHammerNPC extends foundry.abstract.TypeDataModel {
schema.description = new fields.HTMLField({ required: true, textSearch: true })
schema.notes = new fields.HTMLField({ required: true, textSearch: true })
const attributeField = () => new fields.SchemaField({
rank: new fields.NumberField({ ...requiredInteger, initial: 1, min: 1, max: 4 })
})
schema.attributes = new fields.SchemaField({
might: attributeField(),
toughness: attributeField(),
agility: attributeField(),
willpower: attributeField(),
intelligence: attributeField(),
fate: attributeField()
// NPC (humanoid, needs light) vs Creature (monster, darkvision)
schema.subtype = new fields.StringField({
required: true, initial: "creature", choices: SYSTEM.NPC_SUBTYPES
})
schema.grit = new fields.SchemaField({
@@ -26,8 +19,15 @@ export default class OathHammerNPC extends foundry.abstract.TypeDataModel {
max: new fields.NumberField({ ...requiredInteger, initial: 2, min: 0 })
})
// Armor dice pool (value + color)
schema.armorDice = new fields.SchemaField({
value: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0, max: 20 }),
colorDiceType: new fields.StringField({ required: true, initial: "white", choices: SYSTEM.DICE_COLOR_TYPES })
})
schema.defense = new fields.SchemaField({
value: new fields.NumberField({ ...requiredInteger, initial: 10, min: 0 })
value: new fields.NumberField({ ...requiredInteger, initial: 10, min: 0 }),
colorDiceType: new fields.StringField({ required: true, initial: "white", choices: SYSTEM.DICE_COLOR_TYPES })
})
schema.movement = new fields.SchemaField({
@@ -37,7 +37,7 @@ export default class OathHammerNPC extends foundry.abstract.TypeDataModel {
schema.attackBonus = new fields.NumberField({ ...requiredInteger, initial: 0 })
schema.damageBonus = new fields.NumberField({ ...requiredInteger, initial: 0 })
schema.initiativeBonus = new fields.NumberField({ ...requiredInteger, initial: 0 })
schema.challengeRating = new fields.StringField({ required: true, nullable: false, initial: "1" })
schema.challengeRating = new fields.StringField({ required: true, nullable: false, initial: "1" })
return schema
}
@@ -46,6 +46,5 @@ export default class OathHammerNPC extends foundry.abstract.TypeDataModel {
prepareDerivedData() {
super.prepareDerivedData()
this.grit.max = this.attributes.might.rank + this.attributes.toughness.rank
}
}

42
module/models/npcattack.mjs Normal file
View File

@@ -0,0 +1,42 @@
import { SYSTEM } from "../config/system.mjs"
export default class OathHammerNpcAttack extends foundry.abstract.TypeDataModel {
static defineSchema() {
const fields = foundry.data.fields
const requiredInteger = { required: true, nullable: false, integer: true }
const schema = {}
schema.description = new fields.HTMLField({ required: true, textSearch: true })
// Flat damage dice pool (no Might)
schema.damageDice = new fields.NumberField({
...requiredInteger, initial: 1, min: 0, max: 20
})
// Dice color: white (4+), red (3+), black (2+)
schema.colorDiceType = new fields.StringField({
required: true, initial: "white", choices: SYSTEM.DICE_COLOR_TYPES
})
// AP (Armor Penetration): penalty imposed on armor rolls
schema.ap = new fields.NumberField({
...requiredInteger, initial: 0, min: 0, max: 16
})
return schema
}
static LOCALIZATION_PREFIXES = ["OATHHAMMER.NpcAttack"]
get threshold() {
return this.colorDiceType === "black" ? 2 : this.colorDiceType === "red" ? 3 : 4
}
get colorEmoji() {
return this.colorDiceType === "black" ? "⬛" : this.colorDiceType === "red" ? "🔴" : "⬜"
}
get damageLabel() {
return `${this.colorEmoji} ${this.damageDice}d (${this.threshold}+)`
}
}

57
module/models/regiment.mjs Normal file
View File

@@ -0,0 +1,57 @@
import { SYSTEM } from "../config/system.mjs"
export default class OathHammerRegiment extends foundry.abstract.TypeDataModel {
static defineSchema() {
const { fields } = foundry.data
const requiredInteger = { required: true, nullable: false, integer: true }
const schema = {}
schema.description = new fields.HTMLField({ required: false, nullable: true, initial: "" })
schema.notes = new fields.StringField({ required: false, nullable: true, initial: "" })
schema.grit = new fields.SchemaField({
max: new fields.NumberField({ ...requiredInteger, initial: 20, min: 0, max: 200 }),
})
schema.armorDice = new fields.SchemaField({
value: new fields.NumberField({ ...requiredInteger, initial: 1, min: 0, max: 20 }),
colorDiceType: new fields.StringField({ required: true, nullable: false, initial: "white", choices: SYSTEM.DICE_COLOR_TYPES }),
})
schema.movement = new fields.NumberField({ ...requiredInteger, initial: 60, min: 0, max: 500 })
// Embedded skill rows: [{name, value, colorDiceType}]
schema.skills = new fields.ArrayField(new fields.SchemaField({
name: new fields.StringField({ required: true, nullable: false, initial: "" }),
value: new fields.NumberField({ ...requiredInteger, initial: 2, min: 0, max: 6 }),
colorDiceType: new fields.StringField({ required: true, nullable: false, initial: "white", choices: SYSTEM.DICE_COLOR_TYPES }),
}))
// Embedded attack rows: [{name, damageDice, colorDiceType, ap, special}]
schema.attacks = new fields.ArrayField(new fields.SchemaField({
name: new fields.StringField({ required: true, nullable: false, initial: "" }),
damageDice: new fields.NumberField({ ...requiredInteger, initial: 6, min: 0, max: 20 }),
colorDiceType: new fields.StringField({ required: true, nullable: false, initial: "white", choices: SYSTEM.DICE_COLOR_TYPES }),
ap: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0, max: 6 }),
special: new fields.StringField({ required: false, nullable: true, initial: "" }),
}))
// Embedded trait rows: [{name, description}]
schema.traits = new fields.ArrayField(new fields.SchemaField({
name: new fields.StringField({ required: true, nullable: false, initial: "" }),
description: new fields.StringField({ required: false, nullable: true, initial: "" }),
}))
return schema
}
static LOCALIZATION_PREFIXES = ["OATHHAMMER.Regiment"]
get colorEmoji() {
return { white: "⬜", red: "🔴", black: "⬛" }[this.armorDice.colorDiceType] ?? "⬜"
}
get armorLabel() {
return `${this.colorEmoji} ${this.armorDice.value}d`
}
}

36
module/models/skillnpc.mjs Normal file
View File

@@ -0,0 +1,36 @@
import { SYSTEM } from "../config/system.mjs"
export default class OathHammerSkillNPC extends foundry.abstract.TypeDataModel {
static defineSchema() {
const fields = foundry.data.fields
const schema = {}
schema.description = new fields.HTMLField({ required: true, textSearch: true })
// Total dice pool for this skill (attribute + skill ranks combined)
schema.dicePool = new fields.NumberField({
required: true, nullable: false, integer: true, initial: 1, min: 0, max: 20
})
// Dice color: white (4+), red (3+), black (2+)
schema.colorDiceType = new fields.StringField({
required: true, initial: "white", choices: SYSTEM.DICE_COLOR_TYPES
})
// Optional reference to a system skill key (e.g. "fighting", "perception")
// Used for display/tooltip only — does not restrict the roll.
schema.skillRef = new fields.StringField({ required: false, nullable: true, initial: null })
return schema
}
static LOCALIZATION_PREFIXES = ["OATHHAMMER.SkillNPC"]
get threshold() {
return this.colorDiceType === "black" ? 2 : this.colorDiceType === "red" ? 3 : 4
}
get colorEmoji() {
return this.colorDiceType === "black" ? "⬛" : this.colorDiceType === "red" ? "🔴" : "⬜"
}
}

7
module/models/weapon.mjs
View File

@@ -57,7 +57,12 @@ export default class OathHammerWeapon extends foundry.abstract.TypeDataModel {
// Enchantment description (displayed when isMagic is true)
schema.magicEffect = new fields.HTMLField({ required: false, textSearch: true })
// Class/lineage restriction, e.g. "Dwarves only" (empty = no restriction)
schema.classRestriction = new fields.StringField({ required: true, nullable: false, initial: "" })
schema.classRestriction = new fields.StringField({ required: false, nullable: true, initial: null, choices: SYSTEM.CLASS_RESTRICTION_CHOICES })
// Override which skill (and its linked attribute) is used for attack rolls.
// Null / "" = auto-detect (fighting for melee, shooting for ranged).
// Use this for abilities like Magic Bolt that roll Magic+Willpower instead.
schema.skillOverride = new fields.StringField({ required: false, nullable: true, initial: null })
return schema
}

336
module/rolls.mjs
View File

@@ -242,7 +242,7 @@ export async function rollWeaponAttack(actor, weapon, options = {}) {
const actorSys = actor.system
const isRanged = sys.proficiencyGroup === "bows" || sys.proficiencyGroup === "throwing"
const skillKey = isRanged ? "shooting" : "fighting"
const skillKey = (sys.skillOverride && SYSTEM.SKILLS[sys.skillOverride]) ? sys.skillOverride : (isRanged ? "shooting" : "fighting")
const skillDef = SYSTEM.SKILLS[skillKey]
const defaultAttr = skillDef.attribute
@@ -339,8 +339,11 @@ export async function rollWeaponDamage(actor, weapon, options = {}) {
const colorEmoji = hasDeadly ? "⬛" : hasBrutal ? "🔴" : "⬜"
const colorLabel = hasDeadly ? "Black" : hasBrutal ? "Red" : "White"
const mightRank = actorSys.attributes.might.rank
const baseDamageDice = sys.usesMight ? Math.max(mightRank + sys.damageMod, 1) : Math.max(sys.damageMod, 1)
const isRangedDmg = sys.proficiencyGroup === "bows" || sys.proficiencyGroup === "throwing"
const dmgSkillKey = (sys.skillOverride && SYSTEM.SKILLS[sys.skillOverride]) ? sys.skillOverride : (isRangedDmg ? "shooting" : "fighting")
const dmgAttrKey = SYSTEM.SKILLS[dmgSkillKey].attribute
const dmgAttrRank = actorSys.attributes[dmgAttrKey].rank
const baseDamageDice = sys.usesMight ? Math.max(dmgAttrRank + sys.damageMod, 1) : Math.max(sys.damageMod, 1)
const totalDice = Math.max(baseDamageDice + sv + damageBonus + autoDamageBonus, 1)
const { roll, rolls, successes, diceResults } = await _rollPool(totalDice, threshold)
@@ -951,3 +954,330 @@ export async function rollInitiativeCheck(actor, options = {}) {
return { successes, dv: 0, isSuccess: null }
}
// ============================================================
// NPC SKILL ROLL
// ============================================================
/**
* Roll an NPC skill check (skillnpc item) and post to chat.
*
* @param {Actor} actor The NPC/creature actor
* @param {Item} skillItem The skillnpc item
* @param {object} options
*/
export async function rollNPCSkill(actor, skillItem, options = {}) {
const { bonus = 0, colorOverride, visibility } = options
const sys = skillItem.system
const colorType = colorOverride || sys.colorDiceType
const threshold = colorType === "black" ? 2 : colorType === "red" ? 3 : 4
const colorEmoji = colorType === "black" ? "⬛" : colorType === "red" ? "🔴" : "⬜"
const totalDice = Math.max(sys.dicePool + bonus, 1)
const { roll, rolls, successes, diceResults } = await _rollPool(totalDice, threshold, false)
const diceHtml = _diceHtml(diceResults, threshold)
const modLine = bonus !== 0
? `<div class="oh-roll-mods">${bonus > 0 ? "+" : ""}${bonus} ${game.i18n.localize("OATHHAMMER.Dialog.Modifier")}</div>`
: ""
const content = `
<div class="oh-roll-card">
<div class="oh-roll-header">
<img src="${skillItem.img}" class="oh-card-weapon-img" alt="${skillItem.name}" />
<span>${skillItem.name} — ${actor.name}</span>
</div>
<div class="oh-roll-info">
<span>${colorEmoji} ${totalDice}d6 (${threshold}+)</span>
</div>
${modLine}
<div class="oh-roll-dice">${diceHtml}</div>
<div class="oh-roll-result">
<span class="oh-roll-successes">${successes} ${game.i18n.localize("OATHHAMMER.Roll.Successes")}</span>
</div>
</div>
`
const rollMode = visibility ?? game.settings.get("core", "rollMode")
const msgData = { speaker: ChatMessage.getSpeaker({ actor }), content, rolls: rolls, sound: CONFIG.sounds.dice }
ChatMessage.applyRollMode(msgData, rollMode)
await ChatMessage.create(msgData)
return { successes }
}
/**
* NPC weapon attack roll — uses NPC's flat attackBonus as dice pool.
* Rolls white dice (4+) with optional bonus modifier.
*/
export async function rollNPCWeaponAttack(actor, weapon, options = {}) {
const { bonus = 0, visibility } = options
const sys = actor.system
const basePool = sys.attackBonus ?? 0
const totalDice = Math.max(basePool + bonus, 1)
const threshold = 4
const colorEmoji = "⬜"
const { roll, rolls, successes, diceResults } = await _rollPool(totalDice, threshold, false)
const diceHtml = _diceHtml(diceResults, threshold)
const modParts = []
if (bonus !== 0) modParts.push(`${bonus > 0 ? "+" : ""}${bonus} ${game.i18n.localize("OATHHAMMER.Dialog.Modifier")}`)
const modLine = modParts.length ? `<div class="oh-roll-mods">${modParts.join(" · ")}</div>` : ""
const content = `
<div class="oh-roll-card oh-weapon-card">
<div class="oh-roll-header">
<img src="${weapon.img}" class="oh-card-weapon-img" alt="${weapon.name}" />
<span>${weapon.name} — ${game.i18n.localize("OATHHAMMER.Dialog.Attack")} (${actor.name})</span>
</div>
<div class="oh-roll-info">
<span>${colorEmoji} ${totalDice}d6 (${threshold}+)</span>
</div>
${modLine}
<div class="oh-roll-dice">${diceHtml}</div>
<div class="oh-roll-result">
<span class="oh-roll-successes">${successes} ${game.i18n.localize("OATHHAMMER.Roll.Successes")}</span>
</div>
</div>
`
const rollMode = visibility ?? game.settings.get("core", "rollMode")
const msgData = { speaker: ChatMessage.getSpeaker({ actor }), content, rolls: rolls, sound: CONFIG.sounds.dice }
ChatMessage.applyRollMode(msgData, rollMode)
await ChatMessage.create(msgData)
return { successes }
}
/**
* NPC weapon damage roll — uses NPC damageBonus + weapon damageMod as dice pool.
*/
export async function rollNPCWeaponDamage(actor, weapon, options = {}) {
const { bonus = 0, visibility } = options
const sys = actor.system
const basePool = (sys.damageBonus ?? 0) + (weapon.system.damageMod ?? 0)
const totalDice = Math.max(basePool + bonus, 1)
const threshold = 4
const colorEmoji = "⬜"
const { roll, rolls, successes, diceResults } = await _rollPool(totalDice, threshold, false)
const diceHtml = _diceHtml(diceResults, threshold)
const modParts = []
if (bonus !== 0) modParts.push(`${bonus > 0 ? "+" : ""}${bonus} ${game.i18n.localize("OATHHAMMER.Dialog.Modifier")}`)
const modLine = modParts.length ? `<div class="oh-roll-mods">${modParts.join(" · ")}</div>` : ""
const content = `
<div class="oh-roll-card oh-weapon-card">
<div class="oh-roll-header">
<img src="${weapon.img}" class="oh-card-weapon-img" alt="${weapon.name}" />
<span>${weapon.name} — ${game.i18n.localize("OATHHAMMER.Dialog.Damage")} (${actor.name})</span>
</div>
<div class="oh-roll-info">
<span>${colorEmoji} ${totalDice}d6 (${threshold}+)</span>
<span>${game.i18n.localize("OATHHAMMER.Label.Damage")}: ${weapon.system.damageLabel}</span>
</div>
${modLine}
<div class="oh-roll-dice">${diceHtml}</div>
<div class="oh-roll-result">
<span class="oh-roll-successes">${successes} ${game.i18n.localize("OATHHAMMER.Roll.Successes")}</span>
</div>
</div>
`
const rollMode = visibility ?? game.settings.get("core", "rollMode")
const msgData = { speaker: ChatMessage.getSpeaker({ actor }), content, rolls: rolls, sound: CONFIG.sounds.dice }
ChatMessage.applyRollMode(msgData, rollMode)
await ChatMessage.create(msgData)
return { successes }
}
/**
* NPC armor dice roll — rolls actor's armorDice.value dice with armorDice.colorDiceType color.
*/
export async function rollNPCArmor(actor, options = {}) {
const { bonus = 0, colorOverride, visibility } = options
const sys = actor.system
const basePool = sys.armorDice?.value ?? 0
const colorType = colorOverride || sys.armorDice?.colorDiceType || "white"
const threshold = colorType === "black" ? 2 : colorType === "red" ? 3 : 4
const colorEmoji = colorType === "black" ? "⬛" : colorType === "red" ? "🔴" : "⬜"
const totalDice = Math.max(basePool + bonus, 1)
const { roll, rolls, successes, diceResults } = await _rollPool(totalDice, threshold, false)
const diceHtml = _diceHtml(diceResults, threshold)
const modLine = bonus !== 0
? `<div class="oh-roll-mods">${bonus > 0 ? "+" : ""}${bonus} ${game.i18n.localize("OATHHAMMER.Dialog.Modifier")}</div>`
: ""
const label = game.i18n.localize("OATHHAMMER.Label.ArmorDice")
const content = `
<div class="oh-roll-card oh-armor-card">
<div class="oh-roll-header">
<img src="${actor.img}" class="oh-card-weapon-img" alt="${actor.name}" />
<span>${label} — ${actor.name}</span>
</div>
<div class="oh-roll-info">
<span>${colorEmoji} ${totalDice}d6 (${threshold}+)</span>
</div>
${modLine}
<div class="oh-roll-dice">${diceHtml}</div>
<div class="oh-roll-result ${successes > 0 ? "roll-success" : ""}">
<span class="oh-roll-successes">${successes} ${game.i18n.localize("OATHHAMMER.Roll.Successes")}</span>
<span class="oh-roll-verdict">−${successes} ${game.i18n.localize("OATHHAMMER.Roll.Damage")}</span>
</div>
</div>
`
const rollMode = visibility ?? game.settings.get("core", "rollMode")
const msgData = { speaker: ChatMessage.getSpeaker({ actor }), content, rolls: rolls, sound: CONFIG.sounds.dice }
ChatMessage.applyRollMode(msgData, rollMode)
await ChatMessage.create(msgData)
return { successes }
}
/**
* NPC spell cast — flat dice pool, no arcane stress, posts DV success/failure to chat.
*/
export async function rollNPCSpell(actor, spell, options = {}) {
const { dicePool = 3, bonus = 0, colorOverride, visibility } = options
const dv = spell.system.difficultyValue ?? 1
const colorType = colorOverride || "white"
const threshold = colorType === "black" ? 2 : colorType === "red" ? 3 : 4
const colorEmoji = colorType === "black" ? "⬛" : colorType === "red" ? "🔴" : "⬜"
const totalDice = Math.max(dicePool + bonus, 1)
const { roll, rolls, successes, diceResults } = await _rollPool(totalDice, threshold, false)
const diceHtml = _diceHtml(diceResults, threshold)
const isSuccess = successes >= dv
const modLine = bonus !== 0
? `<div class="oh-roll-mods">${bonus > 0 ? "+" : ""}${bonus} ${game.i18n.localize("OATHHAMMER.Dialog.Modifier")}</div>`
: ""
const resultClass = isSuccess ? "roll-success" : "roll-failure"
const resultLabel = isSuccess
? game.i18n.localize("OATHHAMMER.Roll.Success")
: game.i18n.localize("OATHHAMMER.Roll.Failure")
const content = `
<div class="oh-roll-card oh-spell-card">
<div class="oh-roll-header">
<img src="${spell.img}" class="oh-card-weapon-img" alt="${spell.name}" />
<span>${spell.name} (DV ${dv}) — ${actor.name}</span>
</div>
<div class="oh-roll-info">
<span>${colorEmoji} ${totalDice}d6 (${threshold}+)</span>
</div>
${modLine}
<div class="oh-roll-dice">${diceHtml}</div>
<div class="oh-roll-result ${resultClass}">
<span class="oh-roll-successes">${successes} / ${dv}</span>
<span class="oh-roll-verdict">${resultLabel}</span>
</div>
</div>
`
const rollMode = visibility ?? game.settings.get("core", "rollMode")
const msgData = { speaker: ChatMessage.getSpeaker({ actor }), content, rolls, sound: CONFIG.sounds.dice }
ChatMessage.applyRollMode(msgData, rollMode)
await ChatMessage.create(msgData)
return { successes, dv, isSuccess }
}
/**
* NPC miracle invocation — flat dice pool, no blocked tracking, posts DV success/failure to chat.
*/
export async function rollNPCMiracle(actor, miracle, options = {}) {
const { dicePool = 3, bonus = 0, visibility } = options
const dv = 1
const threshold = 4
const colorEmoji = "⬜"
const totalDice = Math.max(dicePool + bonus, 1)
const { roll, rolls, successes, diceResults } = await _rollPool(totalDice, threshold, false)
const diceHtml = _diceHtml(diceResults, threshold)
const isSuccess = successes >= dv
const modLine = bonus !== 0
? `<div class="oh-roll-mods">${bonus > 0 ? "+" : ""}${bonus} ${game.i18n.localize("OATHHAMMER.Dialog.Modifier")}</div>`
: ""
const resultClass = isSuccess ? "roll-success" : "roll-failure"
const resultLabel = isSuccess
? game.i18n.localize("OATHHAMMER.Roll.Success")
: game.i18n.localize("OATHHAMMER.Roll.Failure")
const content = `
<div class="oh-roll-card oh-miracle-card">
<div class="oh-roll-header">
<img src="${miracle.img}" class="oh-card-weapon-img" alt="${miracle.name}" />
<span>${miracle.name} — ${actor.name}</span>
</div>
<div class="oh-roll-info">
<span>${colorEmoji} ${totalDice}d6 (${threshold}+)</span>
</div>
${modLine}
<div class="oh-roll-dice">${diceHtml}</div>
<div class="oh-roll-result ${resultClass}">
<span class="oh-roll-successes">${successes} / ${dv}</span>
<span class="oh-roll-verdict">${resultLabel}</span>
</div>
</div>
`
const rollMode = visibility ?? game.settings.get("core", "rollMode")
const msgData = { speaker: ChatMessage.getSpeaker({ actor }), content, rolls, sound: CONFIG.sounds.dice }
ChatMessage.applyRollMode(msgData, rollMode)
await ChatMessage.create(msgData)
return { successes, dv, isSuccess }
}
/**
* NPC attack damage roll — flat dice pool from the npcattack item, no Might.
*/
export async function rollNPCAttackDamage(actor, attack, options = {}) {
const { bonus = 0, visibility } = options
const sys = attack.system
const colorType = sys.colorDiceType || "white"
const threshold = colorType === "black" ? 2 : colorType === "red" ? 3 : 4
const colorEmoji = colorType === "black" ? "⬛" : colorType === "red" ? "🔴" : "⬜"
const totalDice = Math.max((sys.damageDice ?? 1) + bonus, 1)
const ap = sys.ap ?? 0
const { roll, rolls, successes, diceResults } = await _rollPool(totalDice, threshold, false)
const diceHtml = _diceHtml(diceResults, threshold)
const modParts = []
if (bonus !== 0) modParts.push(`${bonus > 0 ? "+" : ""}${bonus} ${game.i18n.localize("OATHHAMMER.Dialog.Modifier")}`)
if (ap > 0) modParts.push(`AP ${ap}`)
const modLine = modParts.length ? `<div class="oh-roll-mods">${modParts.join(" · ")}</div>` : ""
const content = `
<div class="oh-roll-card oh-weapon-card">
<div class="oh-roll-header">
<img src="${attack.img}" class="oh-card-weapon-img" alt="${attack.name}" />
<span>${attack.name} — ${game.i18n.localize("OATHHAMMER.Dialog.Damage")} (${actor.name})</span>
</div>
<div class="oh-roll-info">
<span>${colorEmoji} ${totalDice}d6 (${threshold}+)</span>
${ap > 0 ? `<span>AP ${ap}</span>` : ""}
</div>
${modLine}
<div class="oh-roll-dice">${diceHtml}</div>
<div class="oh-roll-result">
<span class="oh-roll-successes">${successes} ${game.i18n.localize("OATHHAMMER.Roll.Successes")}</span>
</div>
</div>
`
const rollMode = visibility ?? game.settings.get("core", "rollMode")
const msgData = { speaker: ChatMessage.getSpeaker({ actor }), content, rolls, sound: CONFIG.sounds.dice }
ChatMessage.applyRollMode(msgData, rollMode)
await ChatMessage.create(msgData)
return { successes }
}