342 lines
11 KiB
JavaScript
342 lines
11 KiB
JavaScript
import LethalFantasyActorSheet from "./base-actor-sheet.mjs"
|
|
import { ROLL_TYPE } from "../../config/system.mjs"
|
|
|
|
export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet {
|
|
/** @override */
|
|
static DEFAULT_OPTIONS = {
|
|
classes: ["character"],
|
|
position: {
|
|
width: 1150,
|
|
height: 780,
|
|
},
|
|
window: {
|
|
contentClasses: ["character-content"],
|
|
},
|
|
actions: {
|
|
deleteVoieMajeure: LethalFantasyCharacterSheet.#onDeleteVoieMajeure,
|
|
deleteVoieMineure: LethalFantasyCharacterSheet.#onDeleteVoieMineure,
|
|
createEquipment: LethalFantasyCharacterSheet.#onCreateEquipment,
|
|
},
|
|
}
|
|
|
|
/** @override */
|
|
static PARTS = {
|
|
main: {
|
|
template: "systems/fvtt-lethal-fantasy/templates/character-main.hbs",
|
|
},
|
|
tabs: {
|
|
template: "templates/generic/tab-navigation.hbs",
|
|
},
|
|
items: {
|
|
template: "systems/fvtt-lethal-fantasy/templates/character-items.hbs",
|
|
},
|
|
biography: {
|
|
template: "systems/fvtt-lethal-fantasy/templates/character-biography.hbs",
|
|
},
|
|
}
|
|
|
|
/** @override */
|
|
tabGroups = {
|
|
sheet: "items",
|
|
}
|
|
|
|
/**
|
|
* Prepare an array of form header tabs.
|
|
* @returns {Record<string, Partial<ApplicationTab>>}
|
|
*/
|
|
#getTabs() {
|
|
const tabs = {
|
|
items: { id: "items", group: "sheet", icon: "fa-solid fa-shapes", label: "TENEBRIS.Character.Label.details" },
|
|
biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "TENEBRIS.Character.Label.biography" },
|
|
}
|
|
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.tooltipsCaracteristiques = {
|
|
rob: this._generateTooltip("save", "rob"),
|
|
dex: this._generateTooltip("save", "dex"),
|
|
int: this._generateTooltip("save", "int"),
|
|
per: this._generateTooltip("save", "per"),
|
|
vol: this._generateTooltip("save", "vol"),
|
|
dmax: this._generateTooltip("other", "dmax"),
|
|
}
|
|
|
|
context.tooltipsRessources = {
|
|
san: this._generateTooltip("resource", "san"),
|
|
oeil: this._generateTooltip("resource", "oeil"),
|
|
verbe: this._generateTooltip("resource", "verbe"),
|
|
bourse: this._generateTooltip("resource", "bourse"),
|
|
magie: this._generateTooltip("resource", "magie"),
|
|
}
|
|
|
|
context.rollType = {
|
|
saveRob: {
|
|
action: "roll",
|
|
rollType: "save",
|
|
rollTarget: "rob",
|
|
tooltip: this._generateTooltip("save", "rob"),
|
|
},
|
|
saveDex: {
|
|
action: "roll",
|
|
rollType: "save",
|
|
rollTarget: "dex",
|
|
tooltip: this._generateTooltip("save", "dex"),
|
|
},
|
|
saveInt: {
|
|
action: "roll",
|
|
rollType: "save",
|
|
rollTarget: "int",
|
|
tooltip: this._generateTooltip("save", "int"),
|
|
},
|
|
savePer: {
|
|
action: "roll",
|
|
rollType: "save",
|
|
rollTarget: "per",
|
|
tooltip: this._generateTooltip("save", "per"),
|
|
drag: true,
|
|
},
|
|
saveVol: {
|
|
action: "roll",
|
|
rollType: "save",
|
|
rollTarget: "vol",
|
|
tooltip: this._generateTooltip("save", "vol"),
|
|
drag: true,
|
|
},
|
|
resourceSan: {
|
|
action: "roll",
|
|
rollType: "resource",
|
|
rollTarget: "san",
|
|
tooltip: this._generateTooltip("resource", "san"),
|
|
drag: true,
|
|
},
|
|
resourceOeil: {
|
|
action: "roll",
|
|
rollType: "resource",
|
|
rollTarget: "oeil",
|
|
tooltip: this._generateTooltip("resource", "oeil"),
|
|
drag: true,
|
|
},
|
|
resourceVerbe: {
|
|
action: "roll",
|
|
rollType: "resource",
|
|
rollTarget: "verbe",
|
|
tooltip: this._generateTooltip("resource", "verbe"),
|
|
drag: true,
|
|
},
|
|
resourceBourse: {
|
|
action: "roll",
|
|
rollType: "resource",
|
|
rollTarget: "bourse",
|
|
tooltip: this._generateTooltip("resource", "bourse"),
|
|
drag: true,
|
|
},
|
|
resourceMagie: {
|
|
action: "roll",
|
|
rollType: "resource",
|
|
rollTarget: "magie",
|
|
tooltip: this._generateTooltip("resource", "magie"),
|
|
drag: true,
|
|
},
|
|
}
|
|
return context
|
|
}
|
|
|
|
_generateTooltip(type, target) {
|
|
if (type === ROLL_TYPE.SAVE) {
|
|
const progres = this.document.system.caracteristiques[target].progression.progres
|
|
? game.i18n.localize("TENEBRIS.Label.hasProgressed")
|
|
: game.i18n.localize("TENEBRIS.Label.noProgress")
|
|
return `${game.i18n.localize("TENEBRIS.Label.experience")} : ${this.document.system.caracteristiques[target].progression.experience} <br> ${progres}`
|
|
} else if (type === ROLL_TYPE.RESOURCE) {
|
|
return `${game.i18n.localize("TENEBRIS.Label.maximum")} : ${this.document.system.ressources[target].max} <br> ${game.i18n.localize("TENEBRIS.Label.experience")} : ${this.document.system.ressources[target].experience}`
|
|
} else if (type === "other") {
|
|
return `${game.i18n.localize("TENEBRIS.Label.experience")} : ${this.document.system.dmax.experience}`
|
|
}
|
|
}
|
|
|
|
/** @override */
|
|
async _preparePartContext(partId, context) {
|
|
const doc = this.document
|
|
switch (partId) {
|
|
case "main":
|
|
context.enrichedBiens = await TextEditor.enrichHTML(doc.system.biens, { async: true })
|
|
break
|
|
case "items":
|
|
context.tab = context.tabs.items
|
|
const talents = await this._prepareTalents()
|
|
context.talents = talents
|
|
context.talentsAppris = talents.filter((talent) => talent.appris)
|
|
context.weapons = doc.itemTypes.weapon
|
|
context.armors = doc.itemTypes.armor
|
|
context.spells = doc.itemTypes.spell
|
|
context.hasSpells = context.spells.length > 0
|
|
break
|
|
case "biography":
|
|
context.tab = context.tabs.biography
|
|
context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
|
|
context.enrichedLangues = await TextEditor.enrichHTML(doc.system.langues, { async: true })
|
|
context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
|
|
break
|
|
}
|
|
return context
|
|
}
|
|
|
|
/**
|
|
* Prepares the talents for the character sheet.
|
|
*
|
|
* @returns {Array} An array of talents with their properties.
|
|
*/
|
|
async _prepareTalents() {
|
|
const talents = await Promise.all(
|
|
this.document.itemTypes.talent.map(async (talent) => {
|
|
const pathName = await talent.system.getPathName()
|
|
return {
|
|
id: talent.id,
|
|
uuid: talent.uuid,
|
|
name: talent.name,
|
|
img: talent.img,
|
|
path: `Obtenu par ${pathName}`,
|
|
description: talent.system.improvedDescription,
|
|
progression: talent.system.progression,
|
|
niveau: talent.system.niveau,
|
|
appris: talent.system.appris,
|
|
details: talent.system.details,
|
|
}
|
|
}),
|
|
)
|
|
talents.sort((a, b) => b.appris - a.appris || a.name.localeCompare(b.name, game.i18n.lang))
|
|
return talents
|
|
}
|
|
|
|
// #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)
|
|
if (!["path", "weapon", "armor", "spell"].includes(item.type)) return
|
|
if (item.type === "path") return this.#onDropPathItem(item)
|
|
if (item.type === "weapon") return super._onDropItem(item)
|
|
if (item.type === "armor") return this._onDropItem(item)
|
|
if (item.type === "spell") return this._onDropItem(item)
|
|
}
|
|
}
|
|
|
|
async #onDropPathItem(item) {
|
|
await this.document.addPath(item)
|
|
}
|
|
|
|
// #endregion
|
|
|
|
// #region Actions
|
|
|
|
/**
|
|
* Suppression de la voie majeure
|
|
* @param {Event} event The initiating click event.
|
|
* @param {HTMLElement} target The current target of the event listener.
|
|
*/
|
|
static async #onDeleteVoieMajeure(event, target) {
|
|
const proceed = await foundry.applications.api.DialogV2.confirm({
|
|
content: game.i18n.localize("TENEBRIS.Dialog.suppressionTalents"),
|
|
rejectClose: false,
|
|
modal: true,
|
|
})
|
|
if (!proceed) return
|
|
const path = this.document.items.get(this.document.system.voies.majeure.id)
|
|
if (!path) return
|
|
await this.document.deletePath(path, true)
|
|
}
|
|
|
|
/**
|
|
* Suppression de la voie mineure
|
|
* @param {Event} event The initiating click event.
|
|
* @param {HTMLElement} target The current target of the event listener.
|
|
*/
|
|
static async #onDeleteVoieMineure(event, target) {
|
|
const proceed = await foundry.applications.api.DialogV2.confirm({
|
|
content: game.i18n.localize("TENEBRIS.Dialog.suppressionTalents"),
|
|
rejectClose: false,
|
|
modal: true,
|
|
})
|
|
if (!proceed) return
|
|
const path = this.document.items.get(this.document.system.voies.mineure.id)
|
|
if (!path) return
|
|
await this.document.deletePath(path, false)
|
|
}
|
|
|
|
/**
|
|
* Creates a new attack item directly from the sheet and embeds it into the document.
|
|
* @param {Event} event The initiating click event.
|
|
* @param {HTMLElement} target The current target of the event listener.
|
|
*/
|
|
static #onCreateEquipment(event, target) {
|
|
// Création d'une armure
|
|
if (event.shiftKey) {
|
|
this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("TENEBRIS.Label.newArmor"), type: "armor" }])
|
|
}
|
|
// Création d'une arme
|
|
else {
|
|
this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("TENEBRIS.Label.newWeapon"), type: "weapon" }])
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
// Jet de sauvegarde
|
|
let elt = event.currentTarget.querySelector("input")
|
|
// Jet de ressource
|
|
if (!elt) elt = event.currentTarget.querySelector("select")
|
|
// Jet de dégâts
|
|
if (!elt) elt = event.currentTarget
|
|
const rollType = elt.dataset.rollType
|
|
let rollTarget
|
|
switch (rollType) {
|
|
case ROLL_TYPE.SAVE:
|
|
rollTarget = elt.dataset.rollTarget
|
|
break
|
|
case ROLL_TYPE.RESOURCE:
|
|
rollTarget = elt.dataset.rollTarget
|
|
break
|
|
case ROLL_TYPE.DAMAGE:
|
|
rollTarget = elt.dataset.itemId
|
|
break
|
|
default:
|
|
break
|
|
}
|
|
await this.document.system.roll(rollType, rollTarget)
|
|
}
|
|
// #endregion
|
|
}
|