foundryvtt-reve-de-dragon/module/item-sheet.js

315 lines
12 KiB
JavaScript
Raw Normal View History

2020-12-04 20:52:04 +01:00
import { RdDItemSort } from "./item-sort.js";
import { RdDUtility } from "./rdd-utility.js";
2021-01-07 20:04:10 +01:00
import { RdDAlchimie } from "./rdd-alchimie.js";
import { RdDItemCompetence } from "./item-competence.js";
2021-04-04 18:37:16 +02:00
import { RdDHerbes } from "./rdd-herbes.js";
2021-10-29 09:53:35 +02:00
import { RdDGemme } from "./rdd-gemme.js";
import { HtmlUtility } from "./html-utility.js";
2023-06-20 23:43:24 +02:00
import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
import { SYSTEM_RDD } from "./constants.js";
import { RdDSheetUtility } from "./rdd-sheet-utility.js";
import { SystemCompendiums } from "./settings/system-compendiums.js";
import { Misc } from "./misc.js";
import { RdDTimestamp } from "./time/rdd-timestamp.js";
import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
import { ITEM_TYPES } from "./item.js";
2020-12-04 20:52:04 +01:00
2020-05-21 21:48:20 +02:00
/**
* Extend the basic ItemSheet for RdD specific items
2020-05-21 21:48:20 +02:00
*/
2020-05-22 00:48:43 +02:00
export class RdDItemSheet extends ItemSheet {
2020-05-21 21:48:20 +02:00
static get ITEM_TYPE() {
return undefined
}
static defaultTemplate(type) {
return type ?
`systems/foundryvtt-reve-de-dragon/templates/item-${type}-sheet.html` :
"systems/foundryvtt-reve-de-dragon/templates/item-sheet.html";
}
static register(sheetClass) {
Items.registerSheet(SYSTEM_RDD, sheetClass, {
label: Misc.typeName('Item', sheetClass.ITEM_TYPE),
types: [sheetClass.ITEM_TYPE],
makeDefault: true
})
}
2020-05-21 21:48:20 +02:00
/** @override */
2021-05-07 17:27:02 +02:00
static get defaultOptions() {
2024-05-01 09:13:21 +02:00
return foundry.utils.mergeObject(super.defaultOptions, {
classes: [SYSTEM_RDD, "sheet", "item"],
template: RdDItemSheet.defaultTemplate(RdDItemSheet.ITEM_TYPE),
2021-05-07 17:27:02 +02:00
width: 550,
height: 550
}, { inplace: false });
2020-05-21 21:48:20 +02:00
}
/* -------------------------------------------- */
get template() {
return RdDItemSheet.defaultTemplate(this.item.type);
}
get title() {
2024-09-05 23:44:12 +02:00
const owner = (this.item.parent instanceof Actor) ? `(${this.item.parent.name})` : '';
return `${Misc.typeName('Item', this.item.type)}: ${this.item.name} ${owner}`;
}
2021-12-05 16:48:18 +01:00
2020-05-21 21:48:20 +02:00
/* -------------------------------------------- */
2021-01-01 21:11:56 +01:00
_getHeaderButtons() {
let buttons = super._getHeaderButtons();
if (this.item.isInventaire() && this.item.isVideOuNonConteneur()) {
2021-05-07 17:27:02 +02:00
buttons.unshift({
class: "vendre",
2021-05-07 17:27:02 +02:00
icon: "fas fa-comments-dollar",
onclick: ev => this.item.proposerVente(1)
2021-05-07 17:27:02 +02:00
});
}
buttons.unshift({
class: "montrer",
icon: "fas fa-comment",
2022-12-29 02:25:45 +01:00
onclick: ev => this.item.postItemToChat()
});
2021-01-01 21:11:56 +01:00
return buttons
}
2020-05-21 21:48:20 +02:00
2021-01-01 21:11:56 +01:00
/* -------------------------------------------- */
2020-05-21 21:48:20 +02:00
/** @override */
2021-05-07 17:27:02 +02:00
setPosition(options = {}) {
2020-05-21 21:48:20 +02:00
const position = super.setPosition(options);
const sheetHeader = this.element.find(".sheet-header");
2020-05-21 21:48:20 +02:00
const sheetBody = this.element.find(".sheet-body");
const bodyHeight = position.height - sheetHeader[0].clientHeight;
2020-05-21 21:48:20 +02:00
sheetBody.css("height", bodyHeight);
return position;
}
2021-05-07 17:27:02 +02:00
2020-12-04 20:52:04 +01:00
/* -------------------------------------------- */
async getData() {
2021-05-07 17:27:02 +02:00
let formData = {
title: this.item.name,
id: this.item.id,
type: this.item.type,
img: this.item.img,
name: this.item.name,
system: this.item.system,
actorId: this.actor?.id,
description: await TextEditor.enrichHTML(this.item.system.description, { async: true }),
descriptionmj: await TextEditor.enrichHTML(this.item.system.descriptionmj, { async: true }),
isComestible: this.item.getUtilisationCuisine(),
options: RdDSheetUtility.mergeDocumentRights(this.options, this.item, this.isEditable),
2021-03-25 09:28:36 +01:00
}
if (this.item.type == ITEM_TYPES.competencecreature) {
formData.isparade = RdDItemCompetenceCreature.isParade(this.item)
formData.isdommages = RdDItemCompetenceCreature.isDommages(this.item)
}
2021-04-10 21:07:53 +02:00
const competences = await SystemCompendiums.getCompetences('personnage');
formData.categories = this.item.getCategories()
2022-09-17 16:07:38 +02:00
if (this.item.type == 'tache' || this.item.type == 'livre' || this.item.type == 'meditation' || this.item.type == 'oeuvre') {
2024-06-07 11:12:00 +02:00
formData.caracList = foundry.utils.duplicate(game.model.Actor.personnage.carac)
formData.caracList["reve-actuel"] = foundry.utils.duplicate(game.model.Actor.personnage.reve.reve)
formData.competences = competences;
}
2022-09-17 16:07:38 +02:00
if (this.item.type == 'arme') {
formData.competences = competences.filter(it => it.isCompetenceArme())
}
if (['sort', 'sortreserve'].includes(this.item.type)) {
formData.competences = competences.filter(it => RdDItemCompetence.isDraconic(it));
}
2022-09-27 21:03:18 +02:00
if (this.item.type == 'recettecuisine') {
formData.ingredients = await TextEditor.enrichHTML(this.object.system.ingredients, { async: true })
}
if (this.item.type == 'extraitpoetique') {
formData.extrait = await TextEditor.enrichHTML(this.object.system.extrait, { async: true })
formData.texte = await TextEditor.enrichHTML(this.object.system.texte, { async: true })
2022-09-27 21:03:18 +02:00
}
2022-09-17 16:07:38 +02:00
if (this.item.type == 'recettealchimique') {
RdDAlchimie.processManipulation(this.item, this.actor && this.actor.id);
formData.manipulation_update = await TextEditor.enrichHTML(this.object.system.manipulation_update, { async: true })
formData.utilisation = await TextEditor.enrichHTML(this.object.system.utilisation, { async: true })
formData.enchantement = await TextEditor.enrichHTML(this.object.system.enchantement, { async: true })
formData.sureffet = await TextEditor.enrichHTML(this.object.system.sureffet, { async: true })
2021-01-07 20:04:10 +01:00
}
2022-09-17 16:07:38 +02:00
if (this.item.type == 'gemme') {
2021-10-29 09:53:35 +02:00
formData.gemmeTypeList = RdDGemme.getGemmeTypeOptionList();
RdDGemme.calculDataDerivees(this.item);
2021-10-29 09:53:35 +02:00
}
2022-09-17 16:07:38 +02:00
if (this.item.type == 'potion') {
await RdDHerbes.addPotionFormData(formData);
2021-05-07 17:27:02 +02:00
}
if (formData.options.isOwned && this.item.type == 'herbe' && (formData.system.categorie == 'Soin' || formData.system.categorie == 'Repos')) {
2021-05-07 17:27:02 +02:00
formData.isIngredientPotionBase = true;
}
2022-09-17 16:07:38 +02:00
if (this.item.type == 'sortreserve') {
const sortId = this.item.system.sortid;
formData.sort = formData.options.isOwned ? this.item.actor.items.get(sortId) : game.items.get(sortId);
2022-09-17 16:07:38 +02:00
}
2021-03-16 22:56:57 +01:00
formData.bonusCaseList = RdDItemSort.getBonusCaseList(formData, true);
2020-12-04 20:52:04 +01:00
2021-03-16 22:56:57 +01:00
return formData;
2020-12-04 20:52:04 +01:00
}
2021-05-07 17:27:02 +02:00
2020-05-21 21:48:20 +02:00
/* -------------------------------------------- */
/** @override */
2021-05-07 17:27:02 +02:00
activateListeners(html) {
2020-05-21 21:48:20 +02:00
super.activateListeners(html);
this.html = html;
2023-06-20 23:43:24 +02:00
HtmlUtility.showControlWhen(this.html.find(".item-cout"), ReglesOptionnelles.isUsing('afficher-prix-joueurs')
|| game.user.isGM
|| !this.item.isOwned);
HtmlUtility.showControlWhen(this.html.find(".item-magique"), this.item.isMagique());
2020-05-21 21:48:20 +02:00
// Everything below here is only needed if the sheet is editable
if (!this.options.editable) return;
this.form.ondragstart = (event) => this._onDragStart(event);
this.form.ondrop = (event) => this._onDrop(event);
2020-05-22 19:28:01 +02:00
// Select competence categorie
this.html.find(".categorie").change(event => this._onSelectCategorie(event));
this.html.find('.sheet-competence-xp').change((event) => {
if (this.item.isCompetencePersonnage()) {
RdDUtility.checkThanatosXP(this.item.name);
2021-02-06 23:51:04 +01:00
}
2021-05-07 17:27:02 +02:00
});
this.html.find(".item-cout input[name='system.cout']").change(event => {
if (this.item.isMonnaie()) {
const value = event.currentTarget.value;
if (Number(value) == 0) {
ui.notifications.error(`${this.actor?.name ?? 'Monnaie'}: La monnaie ${this.item.name} a maintenant une valeur de 0, et ne peut plus être utilisée pour payer!`)
}
}
})
2021-02-06 23:51:04 +01:00
this.html.find('.date-enchantement').change((event) => {
const jour = Number(this.html.find('input.date-enchantement[name="enchantement.jour"]').val());
const mois = RdDTimestamp.definition(this.html.find('select.date-enchantement[name="enchantement.mois"]').val());
const indexDate = game.system.rdd.calendrier.getIndexFromDate(jour, mois.heure);
2023-01-07 23:58:33 +01:00
this.item.update({ 'system.prdate': indexDate });
console.warn(`Date d'enchantement modifiée ${jour}/${mois.heure}: ${indexDate}`)
2021-04-04 18:37:16 +02:00
});
this.html.find('.creer-tache-livre').click((event) => this._getEventActor(event).creerTacheDepuisLivre(this.item));
this.html.find('.consommer-potion').click((event) => this._getEventActor(event).consommerPotion(this.item, this.getActionRenderItem()));
this.html.find('.creer-potion-base').click((event) => this._getEventActor(event).actionHerbe(this.item));
2023-11-10 22:38:33 +01:00
this.html.find('input[name="system.cacher_points_de_tache"]').change(async event => await this.item.update({ 'system.cacher_points_de_tache': event.currentTarget.checked }));
2021-05-07 17:27:02 +02:00
this.html.find('.alchimie-tache a').click((event) => {
2022-12-05 15:29:00 +01:00
let actor = this._getEventActor(event);
2021-05-07 17:27:02 +02:00
if (actor) {
2022-12-05 15:29:00 +01:00
let recetteId = event.currentTarget.attributes['data-recette-id'].value;
let tacheName = event.currentTarget.attributes['data-alchimie-tache'].value;
let tacheData = event.currentTarget.attributes['data-alchimie-data'].value;
2021-01-07 20:04:10 +01:00
actor.effectuerTacheAlchimie(recetteId, tacheName, tacheData);
} else {
2022-06-12 13:58:55 +02:00
ui.notifications.info("Impossible trouver un acteur pour réaliser cette tache Alchimique.");
2021-01-07 20:04:10 +01:00
}
});
2021-05-07 17:27:02 +02:00
if (this.actor) {
this.html.find('.item-split').click(async event => RdDSheetUtility.splitItem(RdDSheetUtility.getItem(event, this.actor), this.actor, this.getActionRenderItem()));
this.html.find('.item-edit').click(async event => RdDSheetUtility.getItem(event, this.actor)?.sheet.render(true));
this.html.find('.item-delete').click(async event => RdDUtility.confirmActorItemDelete(this, RdDSheetUtility.getItem(event, this.actor)));
this.html.find('.item-vendre').click(async event => RdDSheetUtility.getItem(event, this.actor)?.proposerVente());
this.html.find('.item-montrer').click(async event => RdDSheetUtility.getItem(event, this.actor)?.postItemToChat());
this.html.find('.item-action').click(async event => RdDSheetUtility.getItem(event, this.actor)?.actionPrincipale(this.actor, this.getActionRenderItem()));
this.html.find('.item-quantite-plus').click(async event => {
await this.actor.itemQuantiteIncDec(RdDSheetUtility.getItemId(event), 1)
this.render();
});
this.html.find('.item-quantite-moins').click(async event => {
await this.actor.itemQuantiteIncDec(RdDSheetUtility.getItemId(event), -1)
this.render();
});
}
2023-01-07 23:58:33 +01:00
2024-05-02 14:08:02 +02:00
const updateItemTimestamp = (path, timestamp) => this.item.update({ [path]: foundry.utils.duplicate(timestamp) })
2023-01-07 23:58:33 +01:00
RdDTimestamp.handleTimestampEditor(this.html, 'system.temporel.debut', updateItemTimestamp);
RdDTimestamp.handleTimestampEditor(this.html, 'system.temporel.fin', updateItemTimestamp);
2022-12-05 15:29:00 +01:00
}
getActionRenderItem() {
return async () => {
let item = this.item;
while (item) {
await item.sheet?.render()
item = this.actor.getContenant(item)
}
}
}
2022-12-05 15:29:00 +01:00
_getEventActor(event) {
let actorId = event.currentTarget.attributes['data-actor-id'].value;
let actor = game.actors.get(actorId);
return actor;
2020-05-21 21:48:20 +02:00
}
2021-05-07 17:27:02 +02:00
2023-01-07 23:58:33 +01:00
2020-05-21 21:48:20 +02:00
/* -------------------------------------------- */
2021-05-06 21:34:07 +02:00
async _onSelectCategorie(event) {
2020-05-21 21:48:20 +02:00
event.preventDefault();
2021-05-06 21:34:07 +02:00
if (this.item.isCompetence()) {
const categorie = event.currentTarget.value;
2023-11-10 22:38:33 +01:00
const level = RdDItemCompetence.getNiveauBase(categorie, this.item.getCategories());
this.item.system.base = level;
this.html.find('[name="system.base"]').val(level);
2021-05-06 21:34:07 +02:00
}
2020-05-22 19:28:01 +02:00
}
2020-05-21 21:48:20 +02:00
2020-05-22 19:28:01 +02:00
/* -------------------------------------------- */
2020-05-21 21:48:20 +02:00
/** @override */
_updateObject(event, formData) {
if (this.item.type == 'sort') {
// Données de bonus de cases ?
formData['system.bonuscase'] = RdDItemSort.buildBonuscaseFromArrays(formData.bonusValue, formData.caseValue);
}
return this.item.update(formData);
2020-05-21 21:48:20 +02:00
}
/* -------------------------------------------- */
2021-12-05 16:48:18 +01:00
async _onDragStart(event) {
}
async _onDrop(event) {
// Try to extract the dragData
let dragData = RdDItemSheet.$extractDragData(event);
if (!dragData) return false;
const allowed = Hooks.call("dropActorSheetData", this.actor, this, dragData);
if (allowed === false) return false;
2021-12-05 16:48:18 +01:00
// Handle different dragData types
switch (dragData.type) {
2021-12-05 16:48:18 +01:00
case "Item":
return this._onDropItem(event, dragData);
case "Actor":
return this._onDropActor(event, dragData);
2021-12-05 16:48:18 +01:00
}
return super._onDrop(event);
}
static $extractDragData(event) {
try {
const eventData = event?.dataTransfer?.getData('text/plain');
if (eventData) {
return JSON.parse(eventData);
}
} catch (err) { }
return undefined;
}
2021-12-05 16:48:18 +01:00
async _onDropItem(event, dragData) {
}
async _onDropActor(event, dragData) {
}
2020-05-21 21:48:20 +02:00
}