480 lines
19 KiB
JavaScript
480 lines
19 KiB
JavaScript
import HamalronActorSheet from "./base-actor-sheet.mjs"
|
|
import { SYSTEM } from "../../config/system.mjs"
|
|
|
|
export default class HamalronPersonnageSheet extends HamalronActorSheet {
|
|
/** @override */
|
|
static DEFAULT_OPTIONS = {
|
|
classes: ["character"],
|
|
position: {
|
|
width: 860,
|
|
height: 620,
|
|
},
|
|
window: {
|
|
contentClasses: ["character-content"],
|
|
},
|
|
actions: {
|
|
createEquipment: HamalronPersonnageSheet.#onCreateEquipment,
|
|
createArmor: HamalronPersonnageSheet.#onCreateArmor,
|
|
createWeapon: HamalronPersonnageSheet.#onCreateWeapon,
|
|
createDeal: HamalronPersonnageSheet.#onCreateDeal,
|
|
createMalefica: HamalronPersonnageSheet.#onCreateMalefica,
|
|
createRitual: HamalronPersonnageSheet.#onCreateRitual,
|
|
createPerk: HamalronPersonnageSheet.#onCreatePerk,
|
|
modifyAmmo: HamalronPersonnageSheet.#onModifyAmmo,
|
|
modifyResistance: HamalronPersonnageSheet.#onModifyResistance,
|
|
discardCard: HamalronPersonnageSheet.#onDiscardCard,
|
|
rollCompetence: HamalronPersonnageSheet.#onRollCompetence,
|
|
drawCard: HamalronPersonnageSheet.#onDrawCard,
|
|
selectCard: HamalronPersonnageSheet.#onSelectCard,
|
|
discardAndDraw: HamalronPersonnageSheet.#onDiscardAndDraw,
|
|
},
|
|
}
|
|
|
|
/** @override */
|
|
static PARTS = {
|
|
main: {
|
|
template: "systems/fvtt-hamalron/templates/personnage-main.hbs",
|
|
},
|
|
tabs: {
|
|
template: "templates/generic/tab-navigation.hbs",
|
|
},
|
|
competences: {
|
|
template: "systems/fvtt-hamalron/templates/personnage-status.hbs",
|
|
},
|
|
tarot: {
|
|
template: "systems/fvtt-hamalron/templates/personnage-tarot.hbs",
|
|
},
|
|
sortileges: {
|
|
template: "systems/fvtt-hamalron/templates/personnage-sortileges.hbs",
|
|
},
|
|
equipment: {
|
|
template: "systems/fvtt-hamalron/templates/personnage-equipement.hbs",
|
|
},
|
|
biography: {
|
|
template: "systems/fvtt-hamalron/templates/personnage-biographie.hbs",
|
|
},
|
|
}
|
|
|
|
/** @override */
|
|
tabGroups = {
|
|
sheet: "competences",
|
|
}
|
|
|
|
/**
|
|
* Prepare an array of form header tabs.
|
|
* @returns {Record<string, Partial<ApplicationTab>>}
|
|
*/
|
|
#getTabs() {
|
|
const tabs = {
|
|
competences: { id: "competences", group: "sheet", icon: "fa-solid fa-list-check", label: "HAMALRON.Label.competences" },
|
|
tarot: { id: "tarot", group: "sheet", icon: "fa-solid fa-cards", label: "HAMALRON.Label.tarot" },
|
|
sortileges: { id: "sortileges", group: "sheet", icon: "fa-solid fa-wand-magic-sparkles", label: "HAMALRON.Label.sortileges" },
|
|
equipment: { id: "equipment", group: "sheet", icon: "fa-solid fa-shapes", label: "HAMALRON.Label.equipment" },
|
|
biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "HAMALRON.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()
|
|
|
|
const doc = this.document
|
|
|
|
return context
|
|
}
|
|
|
|
/** @override */
|
|
async _preparePartContext(partId, context) {
|
|
const doc = this.document
|
|
context.systemFields = this.document.system.schema.fields
|
|
switch (partId) {
|
|
case "main":
|
|
// Get peuple and faction items (only one of each allowed)
|
|
context.peuple = doc.itemTypes.peuple?.[0] || null
|
|
context.faction = doc.itemTypes.faction?.[0] || null
|
|
context.isEditMode = this.isEditMode
|
|
context.isPlayMode = this.isPlayMode
|
|
break
|
|
case "competences":
|
|
context.tab = context.tabs.competences
|
|
const allCompetences = doc.itemTypes.competence || []
|
|
// Ajouter les données de niveau enrichies à chaque compétence
|
|
allCompetences.forEach(c => {
|
|
const niveauData = SYSTEM.NIVEAU_COMPETENCES[c.system.niveau]
|
|
c.niveauName = niveauData?.name || c.system.niveau
|
|
c.niveauModificateur = niveauData?.modificateur ?? 0
|
|
})
|
|
// Grouper les compétences par type et trier par nom dans chaque groupe
|
|
context.competencesCommunes = allCompetences.filter(c => c.system.type === 'commune').sort((a, b) => a.name.localeCompare(b.name))
|
|
context.competencesPeuple = allCompetences.filter(c => c.system.type === 'peuple').sort((a, b) => a.name.localeCompare(b.name))
|
|
context.competencesFaction = allCompetences.filter(c => c.system.type === 'faction').sort((a, b) => a.name.localeCompare(b.name))
|
|
break;
|
|
case "sortileges":
|
|
context.tab = context.tabs.sortileges
|
|
context.sortileges = doc.itemTypes.sortilege || []
|
|
// Sort the sortileges by system.domain and then by the system.level
|
|
context.sortileges.sort((a, b) => {
|
|
if (a.system.domain === b.system.domain) {
|
|
return a.system.level.localeCompare(b.system.level)
|
|
}
|
|
return a.system.domain.localeCompare(b.system.domain)
|
|
})
|
|
break
|
|
case "equipment":
|
|
context.tab = context.tabs.equipment
|
|
context.weapons = doc.itemTypes.weapon || []
|
|
context.weapons.sort((a, b) => a.name.localeCompare(b.name))
|
|
context.armors = doc.itemTypes.armor || []
|
|
context.armors.sort((a, b) => a.name.localeCompare(b.name))
|
|
context.equipments = doc.itemTypes.equipment || []
|
|
context.equipments.sort((a, b) => a.name.localeCompare(b.name))
|
|
break
|
|
case "tarot":
|
|
context.tab = context.tabs.tarot
|
|
context.tarotCards = doc.itemTypes.tarot || []
|
|
context.tarotCards.sort((a, b) => a.name.localeCompare(b.name))
|
|
context.handLimit = 7
|
|
context.handSize = context.tarotCards.length
|
|
context.isOverLimit = context.handSize > context.handLimit
|
|
context.canAddCard = context.handSize < 8
|
|
// Marquer les cartes de succès et enrichir les descriptions
|
|
for (const card of context.tarotCards) {
|
|
card.enrichedDescription = await foundry.applications.ux.TextEditor.implementation.enrichHTML(card.system.description, { async: true })
|
|
// Vérifier si c'est une carte de succès
|
|
if (doc.system.cartesSucces && card.system.type !== "atout") {
|
|
card.isSuccessCard = Object.keys(doc.system.cartesSucces).some(symbole => {
|
|
const successCardData = doc.system.cartesSucces[symbole]
|
|
return card.system.symbole === symbole &&
|
|
card.system.valeur === successCardData.value.toString()
|
|
})
|
|
} else {
|
|
card.isSuccessCard = false
|
|
}
|
|
}
|
|
break
|
|
case "biography":
|
|
context.tab = context.tabs.biography
|
|
context.deals = doc.itemTypes.deal || []
|
|
context.enrichedBackstory = await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.document.system.backstory, { async: true })
|
|
context.enrichedAppearance = await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.document.system.appearance, { async: true })
|
|
context.enrichedScars = await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.document.system.scars, { async: true })
|
|
context.enrichedLikes = await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.document.system.likes, { async: true })
|
|
context.enrichedDislikes = await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.document.system.dislikes, { async: true })
|
|
context.enrichedFears = await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.document.system.fears, { async: true })
|
|
context.enrichedVices = await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.document.system.vices, { async: true })
|
|
context.enrichedGoals = await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.document.system.goals, { async: true })
|
|
context.enrichedAmbitions = await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.document.system.ambitions, { async: true })
|
|
context.enrichedValues = await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.document.system.values, { async: true })
|
|
context.enrichedBonds = await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.document.system.bonds, { async: true })
|
|
context.enrichedNotes = await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.document.system.notes, { async: true })
|
|
break
|
|
}
|
|
return context
|
|
}
|
|
|
|
|
|
static #onCreateEquipment(event, target) {
|
|
this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("HAMALRON.Label.newEquipment"), type: "equipment" }])
|
|
}
|
|
|
|
static #onCreateDeal(event, target) {
|
|
this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("HAMALRON.Label.newDeal"), type: "deal" }])
|
|
}
|
|
|
|
static #onCreateMalefica(event, target) {
|
|
this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("HAMALRON.Label.newMalefica"), type: "malefica" }])
|
|
}
|
|
|
|
static #onCreateRitual(event, target) {
|
|
this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("HAMALRON.Label.newRitual"), type: "ritual" }])
|
|
}
|
|
|
|
static #onCreateWeapon(event, target) {
|
|
this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("HAMALRON.Label.newWeapon"), type: "weapon" }])
|
|
}
|
|
|
|
static #onCreateArmor(event, target) {
|
|
this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("HAMALRON.Label.newArmor"), type: "armor" }])
|
|
}
|
|
|
|
static #onCreatePerk(event, target) {
|
|
this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("HAMALRON.Label.newPerk"), type: "perk" }])
|
|
}
|
|
|
|
static async #onModifyAmmo(event, target) {
|
|
const quantity = parseInt($(event.target).data("quantity"))
|
|
const itemId = $(event.target).data("item-id")
|
|
const item = this.document.items.get(itemId)
|
|
if (!item) {
|
|
console.warn(`HamalronCharacterSheet: Item with ID ${itemId} not found`)
|
|
return
|
|
}
|
|
const currentAmmo = item.system.ammoQuantity || 0
|
|
const newAmmo = Math.max(0, currentAmmo + quantity) // Ensure ammo doesn't go below 0
|
|
await item.update({ "system.ammoQuantity": newAmmo })
|
|
}
|
|
|
|
static async #onModifyResistance(event, target) {
|
|
const symbole = target.dataset.symbole
|
|
const delta = Number.parseInt(target.dataset.delta)
|
|
|
|
if (!symbole || isNaN(delta)) {
|
|
console.warn(`HamalronPersonnageSheet: Invalid resistance modification parameters`)
|
|
return
|
|
}
|
|
|
|
const resistance = this.document.system.resistances[symbole]
|
|
if (!resistance) {
|
|
console.warn(`HamalronPersonnageSheet: Resistance ${symbole} not found`)
|
|
return
|
|
}
|
|
|
|
const newValue = Math.max(0, Math.min(resistance.max, resistance.value + delta))
|
|
await this.document.update({ [`system.resistances.${symbole}.value`]: newValue })
|
|
}
|
|
|
|
static async #onDiscardCard(event, target) {
|
|
const itemId = $(event.target).data("item-id")
|
|
const item = this.document.items.get(itemId)
|
|
if (!item || item.type !== "tarot") {
|
|
console.warn(`HamalronPersonnageSheet: Tarot card with ID ${itemId} not found`)
|
|
return
|
|
}
|
|
|
|
// Supprimer la carte du personnage
|
|
await item.delete()
|
|
ui.notifications.info(game.i18n.localize("HAMALRON.Notifications.cardDiscarded") + item.name)
|
|
}
|
|
|
|
static async #onSelectCard(event, target) {
|
|
const cardWrapper = $(target).closest(".tarot-card-wrapper")
|
|
const wasSelected = cardWrapper.hasClass("selected")
|
|
|
|
// Désélectionner toutes les cartes
|
|
$(".tarot-card-wrapper").removeClass("selected")
|
|
|
|
// Sélectionner la carte cliquée si elle n'était pas déjà sélectionnée
|
|
if (!wasSelected) {
|
|
cardWrapper.addClass("selected")
|
|
}
|
|
}
|
|
|
|
static async #onDiscardAndDraw(event, target) {
|
|
const itemId = $(target).data("item-id")
|
|
const item = this.document.items.get(itemId)
|
|
if (!item || item.type !== "tarot") {
|
|
console.warn(`HamalronPersonnageSheet: Tarot card with ID ${itemId} not found`)
|
|
return
|
|
}
|
|
|
|
// Dialog de confirmation
|
|
const confirmed = await foundry.applications.api.DialogV2.confirm({
|
|
window: {
|
|
title: game.i18n.localize("HAMALRON.Dialog.discardCardTitle"),
|
|
},
|
|
content: `<p>${game.i18n.format("HAMALRON.Dialog.discardCardContent", { cardName: item.name })}</p>`,
|
|
rejectClose: false,
|
|
modal: true,
|
|
})
|
|
|
|
if (!confirmed) return
|
|
|
|
// Récupérer le deck manager
|
|
const module = await import("../tarot-deck-manager.mjs")
|
|
const HamalronTarotDeckManager = module.default
|
|
|
|
if (!HamalronTarotDeckManager._instance) {
|
|
HamalronTarotDeckManager._instance = new HamalronTarotDeckManager()
|
|
}
|
|
|
|
const deckManager = HamalronTarotDeckManager._instance
|
|
|
|
if (!deckManager) {
|
|
ui.notifications.warn(game.i18n.localize("HAMALRON.Notifications.deckManagerNotAvailable"))
|
|
return
|
|
}
|
|
|
|
// Ajouter la carte à la défausse
|
|
deckManager.addToDiscard({
|
|
id: item.id,
|
|
name: item.name,
|
|
img: item.img,
|
|
symbole: item.system.symbole,
|
|
valeur: item.system.valeur,
|
|
type: item.system.type,
|
|
description: item.system.description,
|
|
})
|
|
|
|
// Supprimer la carte du personnage
|
|
await item.delete()
|
|
|
|
// Tirer une nouvelle carte si le deck n'est pas vide
|
|
if (deckManager.deck.length > 0) {
|
|
const newCards = deckManager.drawCards(1)
|
|
if (newCards.length > 0) {
|
|
const newCard = newCards[0]
|
|
|
|
// Cas spécial : Le Mat
|
|
if (newCard.valeur === "lemat") {
|
|
console.log("Le Mat drawn! Executing special rules...")
|
|
const { default: HamalronTirageTarot } = await import("../../documents/tirage-tarot.mjs")
|
|
await HamalronTirageTarot.handleLeMatEffect(this.document, deckManager)
|
|
} else {
|
|
const originalItem = game.items.get(newCard.id)
|
|
if (originalItem) {
|
|
await this.document.createEmbeddedDocuments("Item", [originalItem.toObject()])
|
|
ui.notifications.info(game.i18n.localize("HAMALRON.Notifications.cardDiscardedAndDrawn") + newCard.name)
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
ui.notifications.info(game.i18n.localize("HAMALRON.Notifications.cardDiscardedNoNew"))
|
|
}
|
|
|
|
deckManager.saveDeckState()
|
|
deckManager.render()
|
|
}
|
|
|
|
static async #onDrawCard(event, target) {
|
|
const currentTarotCount = this.document.items.filter(i => i.type === "tarot").length
|
|
|
|
// Vérifier que le joueur a moins de 7 cartes
|
|
if (currentTarotCount >= 7) {
|
|
ui.notifications.warn(game.i18n.localize("HAMALRON.Notifications.cannotDrawCard"))
|
|
return
|
|
}
|
|
|
|
// Récupérer le deck manager singleton
|
|
const module = await import("../tarot-deck-manager.mjs")
|
|
const HamalronTarotDeckManager = module.default
|
|
|
|
// Vérifier si l'instance existe, sinon la créer
|
|
if (!HamalronTarotDeckManager._instance) {
|
|
HamalronTarotDeckManager._instance = new HamalronTarotDeckManager()
|
|
}
|
|
|
|
const deckManager = HamalronTarotDeckManager._instance
|
|
|
|
if (!deckManager) {
|
|
ui.notifications.warn(game.i18n.localize("HAMALRON.Notifications.deckManagerNotAvailable"))
|
|
return
|
|
}
|
|
|
|
if (deckManager.deck.length === 0) {
|
|
ui.notifications.warn(game.i18n.localize("HAMALRON.Notifications.deckEmpty"))
|
|
return
|
|
}
|
|
|
|
// Tirer une nouvelle carte
|
|
const newCards = deckManager.drawCards(1)
|
|
if (newCards.length > 0) {
|
|
const newCard = newCards[0]
|
|
|
|
// Cas spécial : Le Mat
|
|
if (newCard.valeur === "lemat") {
|
|
console.log("Le Mat drawn! Executing special rules...")
|
|
const { default: HamalronTirageTarot } = await import("../../documents/tirage-tarot.mjs")
|
|
await HamalronTirageTarot.handleLeMatEffect(this.document, deckManager)
|
|
} else {
|
|
// Trouver l'item original pour le dupliquer
|
|
const originalItem = game.items.get(newCard.id)
|
|
if (originalItem) {
|
|
await this.document.createEmbeddedDocuments("Item", [originalItem.toObject()])
|
|
ui.notifications.info(game.i18n.localize("HAMALRON.Notifications.newCardDrawn") + newCard.name)
|
|
}
|
|
}
|
|
deckManager.saveDeckState()
|
|
deckManager.render()
|
|
}
|
|
}
|
|
|
|
static async #onRollCompetence(event, target) {
|
|
const itemId = $(target).data("item-id")
|
|
const item = this.document.items.get(itemId)
|
|
if (!item || item.type !== "competence") {
|
|
console.warn(`HamalronPersonnageSheet: Competence with ID ${itemId} not found`)
|
|
return
|
|
}
|
|
await this.document.system.roll("competence", item)
|
|
}
|
|
|
|
/**
|
|
* 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) {
|
|
const rollType = $(event.currentTarget).data("roll-type")
|
|
let item
|
|
let li
|
|
let statKey
|
|
switch (rollType) {
|
|
case "stat":
|
|
statKey = $(event.currentTarget).data("stat-id");
|
|
item = this.actor.system.stats[statKey];
|
|
break
|
|
case "weapon":
|
|
case "damage":
|
|
li = $(event.currentTarget).parents(".item");
|
|
item = this.actor.items.get(li.data("item-id"));
|
|
break
|
|
default:
|
|
throw new Error(`Unknown roll type ${rollType}`)
|
|
}
|
|
await this.document.system.roll(rollType, item)
|
|
}
|
|
|
|
async _onDrop(event) {
|
|
if (!this.isEditable || !this.isEditMode) return
|
|
const data = foundry.applications.ux.TextEditor.implementation.getDragEventData(event)
|
|
|
|
// Handle different data types
|
|
if (data.type === "Item") {
|
|
const item = await fromUuid(data.uuid)
|
|
if (item.type === "tarot") {
|
|
// Check if a card with the same name already exists
|
|
const existingCard = this.document.items.find(i => i.type === "tarot" && i.name === item.name)
|
|
if (existingCard) {
|
|
ui.notifications.warn(game.i18n.localize("HAMALRON.Notifications.tarotCardAlreadyExists") + item.name)
|
|
return
|
|
}
|
|
|
|
const currentTarotCount = this.document.items.filter(i => i.type === "tarot").length
|
|
|
|
// Check if we already have 8 cards (hard limit)
|
|
if (currentTarotCount >= 8) {
|
|
ui.notifications.warn(game.i18n.localize("HAMALRON.Notifications.tarotHandFull"))
|
|
return
|
|
}
|
|
}
|
|
if (item.type === "species-trait") {
|
|
// Check if the item is already in the actor
|
|
const existingTrait = this.document.items.find(i => i.type === "species-trait" && i.name === item.name)
|
|
if (existingTrait) {
|
|
await existingTrait.delete()
|
|
// Display info message
|
|
ui.notifications.info(game.i18n.localize("HAMALRON.Notifications.speciesTraitDeleted") + existingTrait.name)
|
|
}
|
|
}
|
|
return super._onDropItem(item)
|
|
}
|
|
|
|
}
|
|
|
|
}
|