407 lines
16 KiB
JavaScript
407 lines
16 KiB
JavaScript
import OathHammerActorSheet from "./base-actor-sheet.mjs"
|
|
import { SYSTEM } from "../../config/system.mjs"
|
|
import { rollInitiativeCheck, rollNPCSkill, rollNPCArmor, rollNPCSpell, rollNPCMiracle, rollNPCAttackDamage } from "../../rolls.mjs"
|
|
|
|
export default class OathHammerNPCSheet extends OathHammerActorSheet {
|
|
static DEFAULT_OPTIONS = {
|
|
classes: ["npc"],
|
|
position: { width: 720, height: "auto" },
|
|
window: { contentClasses: ["npc-content"] },
|
|
actions: {
|
|
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,
|
|
},
|
|
}
|
|
|
|
static PARTS = {
|
|
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" },
|
|
}
|
|
|
|
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 = {
|
|
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.cssClass = v.active ? "active" : ""
|
|
}
|
|
return tabs
|
|
}
|
|
|
|
/** @override */
|
|
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
|
|
}
|
|
|
|
/** @override */
|
|
async _preparePartContext(partId, context) {
|
|
const doc = this.document
|
|
switch (partId) {
|
|
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.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 })
|
|
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") 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() {
|
|
const actor = this.document
|
|
const combatant = game.combat?.combatants.find(c => c.actor?.id === actor.id)
|
|
if (combatant) {
|
|
await game.combat.rollInitiative([combatant.id])
|
|
} else {
|
|
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"),
|
|
})
|
|
}
|
|
|
|
}
|