389 lines
14 KiB
JavaScript
389 lines
14 KiB
JavaScript
import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
|
|
import LethalFantasyRoll from "../../documents/roll.mjs"
|
|
|
|
export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
|
|
/** @override */
|
|
static DEFAULT_OPTIONS = {
|
|
classes: ["character"],
|
|
position: {
|
|
width: 972,
|
|
height: 780,
|
|
},
|
|
window: {
|
|
contentClasses: ["character-content"],
|
|
},
|
|
actions: {
|
|
createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
|
|
rangedAttackDefense: LethalFantasyCharacterSheet.#onRangedAttackDefense,
|
|
rollInitiative: LethalFantasyCharacterSheet.#onRollInitiative,
|
|
armorHitPointsPlus: LethalFantasyCharacterSheet.#onArmorHitPointsPlus,
|
|
armorHitPointsMinus: LethalFantasyCharacterSheet.#onArmorHitPointsMinus,
|
|
divinityPointsPlus: LethalFantasyCharacterSheet.#onDivinityPointsPlus,
|
|
divinityPointsMinus: LethalFantasyCharacterSheet.#onDivinityPointsMinus,
|
|
aetherPointsPlus: LethalFantasyCharacterSheet.#onAetherPointsPlus,
|
|
aetherPointsMinus: LethalFantasyCharacterSheet.#onAetherPointsMinus,
|
|
},
|
|
}
|
|
|
|
/** @override */
|
|
static PARTS = {
|
|
main: {
|
|
template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
|
|
},
|
|
tabs: {
|
|
template: "templates/generic/tab-navigation.hbs",
|
|
},
|
|
skills: {
|
|
template: "systems/fvtt-lethal-fantasy/templates/character-skills.hbs",
|
|
},
|
|
combat: {
|
|
template: "systems/fvtt-lethal-fantasy/templates/character-combat.hbs",
|
|
},
|
|
equipment: {
|
|
template: "systems/fvtt-lethal-fantasy/templates/character-equipment.hbs",
|
|
},
|
|
spells: {
|
|
template: "systems/fvtt-lethal-fantasy/templates/character-spells.hbs",
|
|
},
|
|
miracles: {
|
|
template: "systems/fvtt-lethal-fantasy/templates/character-miracles.hbs",
|
|
},
|
|
biography: {
|
|
template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
|
|
},
|
|
}
|
|
|
|
/** @override */
|
|
tabGroups = {
|
|
sheet: "skills",
|
|
}
|
|
|
|
/**
|
|
* Prepare an array of form header tabs.
|
|
* @returns {Record<string, Partial<ApplicationTab>>}
|
|
*/
|
|
#getTabs() {
|
|
let tabs = {
|
|
skills: { id: "skills", group: "sheet", icon: "fa-solid fa-shapes", label: "LETHALFANTASY.Label.skills" },
|
|
combat: { id: "combat", group: "sheet", icon: "fa-solid fa-swords", label: "LETHALFANTASY.Label.combat" },
|
|
equipment: { id: "equipment", group: "sheet", icon: "fa-solid fa-backpack", label: "LETHALFANTASY.Label.equipment" },
|
|
biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
|
|
}
|
|
if (this.actor.system.biodata.magicUser) {
|
|
tabs.spells = { id: "spells", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" }
|
|
}
|
|
if (this.actor.system.biodata.clericUser) {
|
|
tabs.miracles = { id: "miracles", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-hands-praying", label: "LETHALFANTASY.Label.miracles" }
|
|
}
|
|
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()
|
|
|
|
return context
|
|
}
|
|
|
|
_generateTooltip(type, target) {
|
|
}
|
|
|
|
/** @override */
|
|
async _preparePartContext(partId, context) {
|
|
const doc = this.document
|
|
switch (partId) {
|
|
case "main":
|
|
break
|
|
case "skills":
|
|
context.tab = context.tabs.skills
|
|
context.skills = doc.itemTypes.skill
|
|
context.gifts = doc.itemTypes.gift
|
|
context.vulnerabilities = doc.itemTypes.vulnerability
|
|
break
|
|
case "spells":
|
|
context.tab = context.tabs.spells
|
|
context.spells = doc.itemTypes.spell
|
|
context.hasSpells = context.spells.length > 0
|
|
break
|
|
case "miracles":
|
|
context.tab = context.tabs.miracles
|
|
context.miracles = doc.itemTypes.miracle
|
|
context.hasMiracles = context.miracles.length > 0
|
|
break
|
|
case "combat":
|
|
context.tab = context.tabs.combat
|
|
context.weapons = doc.itemTypes.weapon
|
|
context.armors = doc.itemTypes.armor
|
|
context.shields = doc.itemTypes.shield
|
|
break
|
|
case "equipment":
|
|
context.tab = context.tabs.equipment
|
|
context.equipments = doc.itemTypes.equipment
|
|
break
|
|
case "biography":
|
|
context.tab = context.tabs.biography
|
|
context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
|
|
context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
|
|
break
|
|
}
|
|
return context
|
|
}
|
|
|
|
// #region Drag-and-Drop Workflow
|
|
|
|
/**
|
|
* Callback actions which occur when a dragged element is dropped on a target.
|
|
* @param {DragEvent} event The originating DragEvent
|
|
* @protected
|
|
*/
|
|
async _onDrop(event) {
|
|
if (!this.isEditable || !this.isEditMode) return
|
|
const data = TextEditor.getDragEventData(event)
|
|
|
|
// Handle different data types
|
|
switch (data.type) {
|
|
case "Item":
|
|
const item = await fromUuid(data.uuid)
|
|
return this._onDropItem(item)
|
|
}
|
|
}
|
|
|
|
static async #onRangedAttackDefense(event, target) {
|
|
const hasTarget = false
|
|
|
|
let roll = await LethalFantasyRoll.promptRangedDefense({
|
|
actorId: this.actor.id,
|
|
actorName: this.actor.name,
|
|
actorImage: this.actor.img,
|
|
})
|
|
if (!roll) return null
|
|
|
|
await roll.toMessage({}, { rollMode: roll.options.rollMode })
|
|
}
|
|
|
|
static async #onRollInitiative(event, target) {
|
|
await this.document.system.rollInitiative()
|
|
}
|
|
|
|
static #onArmorHitPointsPlus(event, target) {
|
|
let armorHP = this.actor.system.combat.armorHitPoints
|
|
armorHP += 1
|
|
this.actor.update({ "system.combat.armorHitPoints": armorHP })
|
|
}
|
|
|
|
static #onArmorHitPointsMinus(event, target) {
|
|
let armorHP = this.actor.system.combat.armorHitPoints
|
|
armorHP -= 1
|
|
this.actor.update({ "system.combat.armorHitPoints": Math.max(armorHP, 0) })
|
|
}
|
|
|
|
static #onDivinityPointsPlus(event, target) {
|
|
let points = this.actor.system.divinityPoints.value
|
|
points += 1
|
|
points = Math.min(points, this.actor.system.divinityPoints.max)
|
|
this.actor.update({ "system.divinityPoints.value": points })
|
|
}
|
|
|
|
static #onDivinityPointsMinus(event, target) {
|
|
let points = this.actor.system.divinityPoints.value
|
|
points -= 1
|
|
points = Math.max(points, 0)
|
|
this.actor.update({ "system.divinityPoints.value": points })
|
|
}
|
|
|
|
static #onAetherPointsPlus(event, target) {
|
|
let points = this.actor.system.aetherPoints.value
|
|
points += 1
|
|
points = Math.min(points, this.actor.system.aetherPoints.max)
|
|
this.actor.update({ "system.aetherPoints.value": points })
|
|
}
|
|
|
|
static #onAetherPointsMinus(event, target) {
|
|
let points = this.actor.system.aetherPoints.value
|
|
points -= 1
|
|
points = Math.max(points, 0)
|
|
this.actor.update({ "system.aetherPoints.value": points })
|
|
}
|
|
|
|
static #onCreateEquipment(event, target) {
|
|
}
|
|
|
|
_onRender(context, options) {
|
|
// Inputs with class `item-quantity`
|
|
const woundDescription = this.element.querySelectorAll('.wound-data')
|
|
for (const input of woundDescription) {
|
|
input.addEventListener("change", (e) => {
|
|
e.preventDefault();
|
|
e.stopImmediatePropagation();
|
|
const newValue = e.currentTarget.value
|
|
const index = e.currentTarget.dataset.index
|
|
const fieldName = e.currentTarget.dataset.name
|
|
let tab = foundry.utils.duplicate(this.actor.system.hp.wounds)
|
|
tab[index][fieldName] = newValue
|
|
console.log(tab, index, fieldName, newValue)
|
|
this.actor.update({ "system.hp.wounds": tab });
|
|
})
|
|
}
|
|
super._onRender();
|
|
}
|
|
|
|
getBestWeaponClassSkill(skills, rollType, multiplier = 1.0) {
|
|
let maxValue = 0
|
|
let goodSkill = skills[0]
|
|
for (let s of skills) {
|
|
if (rollType === "weapon-attack") {
|
|
if (s.system.weaponBonus.attack > maxValue) {
|
|
maxValue = Number(s.system.weaponBonus.attack)
|
|
goodSkill = s
|
|
}
|
|
}
|
|
if (rollType === "weapon-defense") {
|
|
if (s.system.weaponBonus.defense > maxValue) {
|
|
maxValue = Number(s.system.weaponBonus.defense)
|
|
goodSkill = s
|
|
}
|
|
}
|
|
if (rollType.includes("weapon-damage")) {
|
|
if (s.system.weaponBonus.damage > maxValue) {
|
|
maxValue = Number(s.system.weaponBonus.damage)
|
|
goodSkill = s
|
|
}
|
|
}
|
|
}
|
|
goodSkill.weaponSkillModifier = maxValue * multiplier
|
|
return goodSkill
|
|
}
|
|
|
|
/**
|
|
* Handles the roll action triggered by user interaction.
|
|
*
|
|
* @param {PointerEvent} event The event object representing the user interaction.
|
|
* @param {HTMLElement} target The target element that triggered the roll.
|
|
*
|
|
* @returns {Promise<void>} A promise that resolves when the roll action is complete.
|
|
*
|
|
* @throws {Error} Throws an error if the roll type is not recognized.
|
|
*
|
|
* @description This method checks the current mode (edit or not) and determines the type of roll
|
|
* (save, resource, or damage) based on the target element's data attributes. It retrieves the
|
|
* corresponding value from the document's system and performs the roll.
|
|
*/
|
|
|
|
async _onRoll(event, target) {
|
|
if (this.isEditMode) return
|
|
const rollType = event.target.dataset.rollType
|
|
let rollTarget
|
|
let rollKey = event.target.dataset.rollKey
|
|
switch (rollType) {
|
|
case "granted":
|
|
rollTarget = {
|
|
name: rollKey,
|
|
formula: foundry.utils.duplicate(this.document.system.granted[rollKey]),
|
|
rollKey: rollKey
|
|
}
|
|
if ( rollTarget.formula === "" || rollTarget.formula === undefined) {
|
|
rollTarget.formula = 0
|
|
}
|
|
break;
|
|
case "challenge":
|
|
rollTarget = foundry.utils.duplicate(this.document.system.challenges[rollKey])
|
|
rollTarget.rollKey = rollKey
|
|
break
|
|
case "save":
|
|
rollTarget = foundry.utils.duplicate(this.document.system.saves[rollKey])
|
|
rollTarget.rollKey = rollKey
|
|
rollTarget.rollDice = event.target.dataset?.rollDice
|
|
break
|
|
case "spell":
|
|
rollTarget = this.actor.items.find((i) => i.type === "spell" && i.id === rollKey)
|
|
rollTarget.rollKey = rollKey
|
|
break
|
|
case "miracle":
|
|
rollTarget = this.actor.items.find((i) => i.type === "miracle" && i.id === rollKey)
|
|
rollTarget.rollKey = rollKey
|
|
break
|
|
case "skill":
|
|
rollTarget = this.actor.items.find((i) => i.type === "skill" && i.id === rollKey)
|
|
rollTarget.rollKey = rollKey
|
|
if (rollTarget.system.category === "weapon") {
|
|
ui.notifications.warn(game.i18n.localize("LETHALFANTASY.Notifications.rollFromWeapon"))
|
|
return
|
|
}
|
|
break
|
|
case "miracle-attack":
|
|
case "miracle-power":
|
|
rollTarget = this.actor.items.find((i) => i.type === "miracle" && i.id === rollKey)
|
|
rollTarget.rollKey = rollKey
|
|
break
|
|
case "spell-attack":
|
|
case "spell-power":
|
|
rollTarget = this.actor.items.find((i) => i.type === "spell" && i.id === rollKey)
|
|
rollTarget.rollKey = rollKey
|
|
break
|
|
case "weapon-damage-small":
|
|
case "weapon-damage-medium":
|
|
case "weapon-attack":
|
|
case "weapon-defense":
|
|
let weapon = this.actor.items.find((i) => i.type === "weapon" && i.id === rollKey)
|
|
let skill
|
|
let skills = this.actor.items.filter((i) => i.type === "skill" && i.name.toLowerCase() === weapon.name.toLowerCase())
|
|
if (skills.length > 0) {
|
|
skill = this.getBestWeaponClassSkill(skills, rollType, 1.0)
|
|
} else {
|
|
skills = this.actor.items.filter((i) => i.type === "skill" && i.name.toLowerCase().replace(" skill", "") === weapon.name.toLowerCase())
|
|
if (skills.length > 0) {
|
|
skill = this.getBestWeaponClassSkill(skills, rollType, 1.0)
|
|
} else {
|
|
skills = this.actor.items.filter((i) => i.type === "skill" && i.system.weaponClass === weapon.system.weaponClass)
|
|
if (skills.length > 0) {
|
|
skill = this.getBestWeaponClassSkill(skills, rollType, 0.5)
|
|
} else {
|
|
skills = this.actor.items.filter((i) => i.type === "skill" && i.system.weaponClass.includes(SYSTEM.WEAPON_CATEGORIES[weapon.system.weaponClass]))
|
|
if (skills.length > 0) {
|
|
skill = this.getBestWeaponClassSkill(skills, rollType, 0.25)
|
|
} else {
|
|
ui.notifications.warn(game.i18n.localize("LETHALFANTASY.Notifications.skillNotFound"))
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!weapon || !skill) {
|
|
console.error("Weapon or skill not found", weapon, skill)
|
|
ui.notifications.warn(game.i18n.localize("LETHALFANTASY.Notifications.skillNotFound"))
|
|
return
|
|
}
|
|
rollTarget = skill
|
|
rollTarget.weapon = weapon
|
|
rollTarget.weaponSkillModifier = skill.weaponSkillModifier
|
|
rollTarget.rollKey = rollKey
|
|
rollTarget.combat = foundry.utils.duplicate(this.actor.system.combat)
|
|
if ( rollType === "weapon-damage-small" || rollType === "weapon-damage-medium") {
|
|
rollTarget.grantedDice = this.actor.system.granted.damageDice
|
|
}
|
|
if ( rollType === "weapon-attack") {
|
|
rollTarget.grantedDice = this.actor.system.granted.attackDice
|
|
}
|
|
if ( rollType === "weapon-defense") {
|
|
rollTarget.grantedDice = this.actor.system.granted.defenseDice
|
|
}
|
|
break
|
|
default:
|
|
ui.notifications.error(game.i18n.localize("LETHALFANTASY.Notifications.rollTypeNotFound") + String(rollType))
|
|
break
|
|
}
|
|
|
|
// In all cases
|
|
rollTarget.magicUser = this.actor.system.biodata.magicUser
|
|
rollTarget.actorModifiers = foundry.utils.duplicate(this.actor.system.modifiers)
|
|
rollTarget.actorLevel = this.actor.system.biodata.level
|
|
await this.document.system.roll(rollType, rollTarget)
|
|
}
|
|
// #endregion
|
|
}
|