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

291 lines
10 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 { Misc } from "./misc.js";
import { HtmlUtility } from "./html-utility.js";
import { ReglesOptionelles } from "./regles-optionelles.js";
import { SYSTEM_RDD } from "./constants.js";
import { RdDSheetUtility } from "./rdd-sheet-utility.js";
2020-12-04 20:52:04 +01:00
2020-05-21 21:48:20 +02:00
/**
* Extend the basic ItemSheet with some very simple modifications
* @extends {ItemSheet}
*/
2020-05-22 00:48:43 +02:00
export class RdDItemSheet extends ItemSheet {
2020-05-21 21:48:20 +02:00
/** @override */
2021-05-07 17:27:02 +02:00
static get defaultOptions() {
return mergeObject(super.defaultOptions, {
classes: [SYSTEM_RDD, "sheet", "item"],
2021-05-07 17:27:02 +02:00
template: "systems/foundryvtt-reve-de-dragon/templates/item-sheet.html",
width: 550,
height: 550
});
2020-05-21 21:48:20 +02:00
}
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();
// Add "Post to chat" button
// We previously restricted this to GM and editable items only. If you ever find this comment because it broke something: eh, sorry!
if ("cout" in Misc.templateData(this.object) && this.object.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()
});
}
buttons.unshift({
class: "montrer",
icon: "fas fa-comment",
onclick: ev => this.item.postItem()
});
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-03-25 09:28:36 +01:00
const objectData = Misc.data(this.object);
2021-05-07 17:27:02 +02:00
let formData = {
id: this.object.id,
2021-03-29 18:08:18 +02:00
title: objectData.name,
2021-03-25 09:28:36 +01:00
type: objectData.type,
img: objectData.img,
name: objectData.name,
data: objectData.data,
2021-03-29 18:08:18 +02:00
isGM: game.user.isGM,
actorId: this.actor?.id,
2021-03-29 18:08:18 +02:00
owner: this.document.isOwner,
editable: this.isEditable,
cssClass: this.isEditable ? "editable" : "locked",
isSoins: false
2021-03-25 09:28:36 +01:00
}
2021-05-07 17:27:02 +02:00
if (this.actor) {
2021-04-10 21:07:53 +02:00
formData.isOwned = true;
if (objectData.type == 'conteneur') {
this.prepareConteneurData(formData);
}
2021-04-10 21:07:53 +02:00
}
2021-03-16 22:56:57 +01:00
formData.categorieCompetences = RdDItemCompetence.getCategorieCompetences();
2021-05-07 17:27:02 +02:00
if (formData.type == 'tache' || formData.type == 'livre' || formData.type == 'meditation' || formData.type == 'oeuvre') {
2021-03-16 22:56:57 +01:00
formData.caracList = duplicate(game.system.model.Actor.personnage.carac);
2021-05-07 17:27:02 +02:00
formData.competences = await RdDUtility.loadCompendium('foundryvtt-reve-de-dragon.competences');
}
2021-05-07 17:27:02 +02:00
if (formData.type == 'arme') {
formData.competences = await RdDUtility.loadCompendium('foundryvtt-reve-de-dragon.competences', it => RdDItemCompetence.isCompetenceArme(it));
console.log(formData.competences);
}
2021-05-07 17:27:02 +02:00
if (formData.type == 'recettealchimique') {
RdDAlchimie.processManipulation(objectData, this.actor && this.actor.id);
2021-01-07 20:04:10 +01:00
}
2021-10-29 09:53:35 +02:00
if (formData.type == 'gemme') {
formData.gemmeTypeList = RdDGemme.getGemmeTypeOptionList();
RdDGemme.calculDataDerivees(formData.data);
2021-10-29 09:53:35 +02:00
}
2021-05-07 17:27:02 +02:00
if (formData.type == 'potion') {
2021-04-04 18:37:16 +02:00
if (this.dateUpdated) {
formData.data.prdate = this.dateUpdated;
this.dateUpdated = undefined;
}
RdDHerbes.updatePotionData(formData);
2021-05-07 17:27:02 +02:00
}
if (formData.isOwned && formData.type == 'herbe' && (formData.data.categorie == 'Soin' || formData.data.categorie == 'Repos')) {
formData.isIngredientPotionBase = true;
}
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
prepareConteneurData(formData) {
formData.itemsByType = Misc.classify(this.actor.items.map(i => foundry.utils.deepClone(i.data)));
RdDUtility.filterEquipementParType(formData);
this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.objets);
formData.subItems = formData.conteneurs.find(it => it._id == this.object.id)?.subItems;
}
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);
2021-12-05 16:48:18 +01:00
if (this.object.type == 'conteneur') {
this.form.ondragstart = (event) => this._onDragStart(event);
this.form.ondrop = (event) => this._onDrop(event);
}
let itemSheetDialog = this;
HtmlUtility._showControlWhen($(".item-cout"), ReglesOptionelles.isUsing('afficher-prix-joueurs') || game.user.isGM || !this.object.isOwned);
2021-05-07 17:27:02 +02:00
HtmlUtility._showControlWhen($(".item-magique"), this.object.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;
2021-05-06 21:34:07 +02:00
2020-05-22 19:28:01 +02:00
// Select competence categorie
2021-05-06 21:34:07 +02:00
html.find(".categorie").change(event => this._onSelectCategorie(event));
2021-03-29 18:08:18 +02:00
html.find('.sheet-competence-xp').change((event) => {
2021-05-07 17:27:02 +02:00
if (this.object.data.type == 'competence') {
RdDUtility.checkThanatosXP(this.object.data.name);
2021-02-06 23:51:04 +01:00
}
2021-05-07 17:27:02 +02:00
});
2021-02-06 23:51:04 +01:00
2021-04-04 18:37:16 +02:00
html.find('.enchanteDate').change((event) => {
let jour = Number($('#jourMois').val());
let mois = $('#nomMois').val();
this.dateUpdated = game.system.rdd.calendrier.getIndexFromDate(jour, mois);
});
2021-03-29 18:08:18 +02:00
html.find('.creer-tache-livre').click((event) => {
let actorId = event.currentTarget.attributes['data-actor-id'].value;
2021-05-07 17:27:02 +02:00
let actor = game.actors.get(actorId);
actor.creerTacheDepuisLivre(this.item);
});
2021-04-04 18:37:16 +02:00
html.find('.consommer-potion').click((event) => {
let actorId = event.currentTarget.attributes['data-actor-id'].value;
2021-05-07 17:27:02 +02:00
let actor = game.actors.get(actorId);
actor.consommerPotion(this.item);
2021-04-04 18:37:16 +02:00
});
2021-04-10 21:07:53 +02:00
html.find('.creer-potion-base').click((event) => {
let actorId = event.currentTarget.attributes['data-actor-id'].value;
2021-05-07 17:27:02 +02:00
let actor = game.actors.get(actorId);
actor.dialogFabriquerPotion(this.item);
2021-04-10 21:07:53 +02:00
});
2021-05-07 17:27:02 +02:00
2021-01-07 20:04:10 +01:00
html.find('.alchimie-tache a').click((event) => {
let actorId = event.currentTarget.attributes['data-actor-id'].value;
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-05-07 17:27:02 +02:00
let actor = game.actors.get(actorId);
if (actor) {
2021-01-07 20:04:10 +01:00
actor.effectuerTacheAlchimie(recetteId, tacheName, tacheData);
} else {
ui.notifications.info("Impossible trouver un actur pour réaliser cette tache Alchimique.");
}
});
2021-05-07 17:27:02 +02:00
html.find('.item-split').click(async event => {
const item = RdDSheetUtility.getItem(event, this.actor);
await RdDSheetUtility.splitItem(item, this.actor, async () => itemSheetDialog.render(true));
});
html.find('.item-edit').click(async event => {
const item = RdDSheetUtility.getItem(event, this.actor);
item.sheet.render(true);
});
html.find('.item-delete').click(async event => {
const li = RdDSheetUtility.getEventElement(event);
RdDUtility.confirmerSuppression(this, li);
});
html.find('.item-vendre').click(async event => {
const item = RdDSheetUtility.getItem(event, this.actor);
item?.proposerVente();
});
html.find('.item-montrer').click(async event => {
const item = RdDSheetUtility.getItem(event, this.actor);
item?.postItem();
});
html.find('.item-action').click(async event => {
const item = RdDSheetUtility.getItem(event, this.actor);
this.actor.actionItem(item, async () => itemSheetDialog.render(true));
});
html.find('.conteneur-name a').click(async event => {
RdDUtility.toggleAfficheContenu(RdDSheetUtility.getItemId(event));
this.render(true);
});
2020-05-21 21:48:20 +02:00
}
2021-05-07 17:27:02 +02: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.object.isCompetence()) {
2021-05-06 21:34:07 +02:00
let level = RdDItemCompetence.getNiveauBase(event.currentTarget.value);
Misc.templateData(this.object).base = level;
$("#base").val(level);
}
2020-05-22 19:28:01 +02:00
}
2020-05-21 21:48:20 +02:00
2020-05-22 19:28:01 +02:00
/* -------------------------------------------- */
2021-05-07 17:27:02 +02:00
get template() {
2021-03-25 09:28:36 +01:00
let type = this.object.data.type;
2020-05-22 19:28:01 +02:00
return `systems/foundryvtt-reve-de-dragon/templates/item-${type}-sheet.html`;
2020-05-21 21:48:20 +02:00
}
/* -------------------------------------------- */
/** @override */
2021-03-25 09:28:36 +01:00
_updateObject(event, formData) { // Deprecated en v0.8 à clarifier
2020-12-04 20:52:04 +01:00
// Données de bonus de cases ?
2021-05-07 17:27:02 +02:00
formData = RdDItemSort.buildBonusCaseStringFromFormData(formData);
2020-05-21 21:48:20 +02:00
return this.object.update(formData);
}
2021-12-05 16:48:18 +01:00
async _onDragStart(event) {
console.log("_onDragStart", event);
if ( event.target.classList.contains("entity-link") ) return;
const itemId = event.srcElement?.attributes["data-item-id"].value;
const item = this.actor.items.get(itemId);
// Create drag data
const dragData = {
actorId: this.actor.id,
type: "Item",
data: item.data
};
event.dataTransfer.setData("text/plain", JSON.stringify(dragData));
}
async _onDrop(event) {
// Try to extract the data
let data;
try {
data = JSON.parse(event.dataTransfer.getData('text/plain'));
} catch (err) {
return false;
}
const allowed = Hooks.call("dropActorSheetData", this.actor, this, data);
if ( allowed === false ) return;
// Handle different data types
switch ( data.type ) {
case "Item":
return this._onDropItem(event, data);
}
return super._onDrop(event);
}
/* -------------------------------------------- */
async _onDropItem(event, dragData) {
if (this.actor) {
const dropParams = RdDSheetUtility.prepareItemDropParameters(this.object.id, this.actor.id, dragData, this.objetVersConteneur);
await this.actor.processDropItem(dropParams);
await this.render(true);
}
}
2020-05-21 21:48:20 +02:00
}