Vincent Vandemeulebrouck
7fb0ee1659
ChatMessage.create est async, il faut donc de préférence l'appeler avec un await. Des effets secondaires avaient lieu (ordre de messages, updates ultérieurs parfois pas pris en compte)
1011 lines
46 KiB
JavaScript
1011 lines
46 KiB
JavaScript
/* Common useful functions shared between objects */
|
|
import { ChatUtility } from "./chat-utility.js";
|
|
import { RdDCombat } from "./rdd-combat.js";
|
|
import { Misc } from "./misc.js";
|
|
import { Grammar } from "./grammar.js";
|
|
import { TMRUtility } from "./tmr-utility.js";
|
|
import { DialogItemAchat } from "./achat-vente/dialog-item-achat.js";
|
|
import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
|
|
import { RdDDice } from "./rdd-dice.js";
|
|
import { RdDItem } from "./item.js";
|
|
import { RdDPossession } from "./rdd-possession.js";
|
|
import { RdDNameGen } from "./rdd-namegen.js";
|
|
import { RdDConfirm } from "./rdd-confirm.js";
|
|
import { RdDResolutionTable } from "./rdd-resolution-table.js";
|
|
import { RdDTimestamp } from "./time/rdd-timestamp.js";
|
|
import { RdDRaretes } from "./item/raretes.js";
|
|
import { RdDEmpoignade } from "./rdd-empoignade.js";
|
|
import { ExperienceLog } from "./actor/experience-log.js";
|
|
import { RdDCoeur } from "./coeur/rdd-coeur.js";
|
|
import { APP_ASTROLOGIE_REFRESH } from "./sommeil/app-astrologie.js";
|
|
import { ACTOR_TYPES, ITEM_TYPES, RDD_CONFIG, SYSTEM_RDD } from "./constants.js";
|
|
import { RdDBaseActor } from "./actor/base-actor.js";
|
|
import { RdDCarac } from "./rdd-carac.js";
|
|
import { RdDTextEditor } from "./apps/rdd-text-roll-editor.js";
|
|
|
|
import { RdDItemCompetence } from "./item-competence.js";
|
|
import { Monnaie } from "./item-monnaie.js";
|
|
import { ItemAction } from "./item/item-actions.js";
|
|
import { Targets } from "./targets.js";
|
|
import { DialogSelect } from "./dialog-select.js";
|
|
|
|
/* -------------------------------------------- */
|
|
// This table starts at 0 -> niveau -10
|
|
const carac_array = ["taille", "apparence", "constitution", "force", "agilite", "dexterite", "vue", "ouie", "odoratgout", "volonte", "intellect", "empathie", "reve", "chance", "melee", "tir", "lancer", "derobee"];
|
|
const difficultesLibres = Misc.intArray(0, -11);
|
|
const ajustementsConditions = Misc.intArray(-10, 11);
|
|
const ajustementsEncaissement = Misc.intArray(-10, 26);
|
|
|
|
/* -------------------------------------------- */
|
|
function _buildAllSegmentsFatigue(max) {
|
|
const cycle = [5, 2, 4, 1, 3, 0];
|
|
const fatigue = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]];
|
|
for (let i = 0; i <= max; i++) {
|
|
const ligneFatigue = foundry.utils.duplicate(fatigue[i]);
|
|
const caseIncrementee = cycle[i % 6];
|
|
ligneFatigue[caseIncrementee]++;
|
|
ligneFatigue[caseIncrementee + 6]++;
|
|
ligneFatigue.fatigueMax = 2 * (i + 1);
|
|
fatigue[i + 1] = ligneFatigue;
|
|
}
|
|
return fatigue;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
function _cumulSegmentsFatigue(matrix) {
|
|
let cumulMatrix = [];
|
|
for (let line of matrix) {
|
|
let cumul = foundry.utils.duplicate(line);
|
|
|
|
for (let i = 1; i < 12; i++) {
|
|
cumul[i] += cumul[i - 1];
|
|
}
|
|
cumulMatrix.push(cumul);
|
|
}
|
|
return cumulMatrix;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
export const MAX_ENDURANCE_FATIGUE = 60;
|
|
const fatigueMatrix = _buildAllSegmentsFatigue(MAX_ENDURANCE_FATIGUE);
|
|
const cumulFatigueMatrix = _cumulSegmentsFatigue(fatigueMatrix);
|
|
|
|
const fatigueMalus = [0, 0, 0, -1, -1, -1, -2, -3, -4, -5, -6, -7]; // Provides the malus for each segment of fatigue
|
|
const fatigueLineSize = [3, 6, 7, 8, 9, 10, 11, 12];
|
|
const fatigueLineMalus = [0, -1, -2, -3, -4, -5, -6, -7];
|
|
|
|
/* -------------------------------------------- */
|
|
const nomEthylisme = ["Emeché", "Gris", "Pinté", "Pas frais", "Ivre", "Bu", "Complètement fait", "Ivre mort"];
|
|
|
|
const TABLE_ENCAISSEMENT_MORTEL = [
|
|
{ minimum: undefined, maximum: 0, endurance: "0", vie: "0", gravite: -1 },
|
|
{ minimum: 1, maximum: 10, endurance: "1d4", vie: "0", gravite: 0 },
|
|
{ minimum: 11, maximum: 15, endurance: "1d6", vie: "0", gravite: 2 },
|
|
{ minimum: 16, maximum: 19, endurance: "2d6", vie: "2", gravite: 4 },
|
|
{ minimum: 20, maximum: undefined, endurance: "100", vie: "4 + @over20", gravite: 6 },
|
|
]
|
|
const TABLE_ENCAISSEMENT_NONMORTEL = [
|
|
{ minimum: undefined, maximum: 0, endurance: "0", vie: "0", gravite: -1 },
|
|
{ minimum: 1, maximum: 10, endurance: "1d4", vie: "0", gravite: 0 },
|
|
{ minimum: 11, maximum: 15, endurance: "1d6", vie: "0", gravite: 0 },
|
|
{ minimum: 16, maximum: 19, endurance: "2d6", vie: "0", gravite: 2 },
|
|
{ minimum: 20, maximum: undefined, endurance: "100", vie: "0", gravite: 2 },
|
|
]
|
|
const TABLE_ENCAISSEMENT_ENTITE = [
|
|
{ minimum: undefined, maximum: 0, endurance: "0", vie: "0", gravite: -1 },
|
|
{ minimum: 1, maximum: 10, endurance: "1d4", vie: "0", gravite: 0 },
|
|
{ minimum: 11, maximum: 15, endurance: "1d6", vie: "0", gravite: 2 },
|
|
{ minimum: 16, maximum: 19, endurance: "2d6", vie: "0", gravite: 4 },
|
|
{ minimum: 20, maximum: undefined, endurance: "3d6 + @over20", vie: "0", gravite: 6 },
|
|
]
|
|
|
|
/* -------------------------------------------- */
|
|
export class RdDUtility {
|
|
// persistent handling of conteneur show/hide
|
|
static afficheContenu = {}
|
|
/* -------------------------------------------- */
|
|
static async initHooks() {
|
|
Hooks.on('renderChatLog', (log, html, chatLog) => RdDUtility.chatListeners(html))
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static preloadHandlebarsTemplates() {
|
|
const templatePaths = [
|
|
//Character Sheets
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor-sheet.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor-creature-sheet.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor-entite-sheet.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor-vehicule-sheet.hbs',
|
|
// sous-parties de feuilles de personnages
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/item-action-controls.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/header-buttons.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/header-etat.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/header-compteurs.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/header-compteurs-creature.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/header-compteurs-entitee.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/header-effects.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/header-hautreve.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/archetype.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/vue-detaillee.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/armures.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/carac-main.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/carac-derivee.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/carac-creature.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/carac-entitee.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/carac-total.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/comp-creature.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/comp-possession.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/competence.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/competence-categorie.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/xp-competences.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/combat.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/blessures.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/blessure.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/maladies-poisons.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/possessions.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/resonances.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/taches.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/oeuvres.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/oeuvre.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/jeux.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/alchimie.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/astrologie.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/chirurgie.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/non-haut-revant.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/haut-revant.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/dragon-queues.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/dragon-queue.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/dragon-souffles.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/dragon-tetes.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/hr-signes-draconiques.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/hr-rencontres.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/hr-sorts.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/hr-sorts-reserve.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/hr-meditations.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/hr-casetmrs.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/xp-journal.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/editor-notes-mj.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/inventaire.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-item.hbs',
|
|
"systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-monnaie.hbs",
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/liens-animaux.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/liens-suivants.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/liens-vehicules.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire-item.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/actor/tooltip-bonmoments.hbs',
|
|
//Items
|
|
'systems/foundryvtt-reve-de-dragon/templates/scripts/autocomplete-script.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/scripts/autocomplete.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/item/boutons-comestible.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/item/icon-arme-broken.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/item/temporel.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/item/partial-inventaire.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/item/partial-environnement.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/item/partial-tab-environnement.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/item/partial-header.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/item/partial-hautrevant.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/item/partial-frequence.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/item/partial-description.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/item/partial-appreciable.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/item/enum-appreciation-bonmoment.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/item/enum-appreciation-carac.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/item/enum-appreciation-moral.hbs',
|
|
// partial enums
|
|
'systems/foundryvtt-reve-de-dragon/templates/enum-aspect-tarot.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/enum-base-competence.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/enum-caracteristiques.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/enum-categories.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-ingredient.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-parade.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/item/enum-categorie-alchimie.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/item/enum-etat-alchimie.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-queue.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-vehicule.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/enum-competence.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/enum-draconic.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/enum-heures.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/enum-initpremierround.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/enum-mortalite.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/enum-niveau-ethylisme.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/enum-periode.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/enum-rarete.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/enum-tmr-effet.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/enum-tmr-type.hbs',
|
|
// Partials
|
|
'systems/foundryvtt-reve-de-dragon/templates/enchantement/partial-enchantement.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/coeur/chat-effet-tendre-moment.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/coeur/afficher-coeur.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/tirage/liste-resultats-recherche.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/time/horloge.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/voyage/fatigue-actor.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/voyage/option-vitesse-fatigue.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/common/timestamp.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/common/date-heure.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/common/periodicite.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/common/enum-duree.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/common/compendium-link.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/partial-description-overflow.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/partial-description-sort.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/partial-description.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/partial-roll-ajustements.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/partial-roll-astrologique.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/partial-roll-coeur.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/partial-roll-competences.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/partial-roll-diffLibre.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/partial-roll-diffFixe.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/partial-roll-diffCondition.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/partial-roll-enctotal.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/partial-roll-forcer.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/partial-roll-moral.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/partial-roll-surenc.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/partial-select-carac.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/roll/explain.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/resolution-table.hbs',
|
|
// Dialogs
|
|
'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-resolution.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-competence.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-carac.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-sort.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-encaisser.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/dialog-validation-encaissement.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-meditation.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/dialog-tmr.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-alchimie.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/sommeil/sommeil-actor-moral.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/sommeil/astrologie-gardien.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/sommeil/astrologie-joueur.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/sommeil/astrologie-theme.hbs',
|
|
// HUD
|
|
'systems/foundryvtt-reve-de-dragon/templates/hud-actor-init.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/hud-actor-attaque.hbs',
|
|
// messages tchat
|
|
'systems/foundryvtt-reve-de-dragon/templates/chat-infojet.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/chat-description.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/chat-info-appel-au-moral.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/chat-info-distance.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/chat-actor-turn-acteur.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/chat-actor-turn-sante.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/chat-actor-competence-xp.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/chat-actor-carac-xp.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/chat-fabriquer-potion-base.hbs',
|
|
'systems/foundryvtt-reve-de-dragon/templates/chat-signe-draconique-actor.hbs'
|
|
];
|
|
|
|
// foundry et options
|
|
Handlebars.registerHelper('RDD_CONFIG', path => RDD_CONFIG[path])
|
|
Handlebars.registerHelper('settings-get', (setting) => game.settings.get(SYSTEM_RDD, setting))
|
|
Handlebars.registerHelper('linkCompendium', (pack, id, name) => RdDUtility.linkCompendium(pack, id, name));
|
|
Handlebars.registerHelper('regle-optionnelle', (option) => ReglesOptionnelles.isUsing(option));
|
|
|
|
Handlebars.registerHelper('plusMoins', diff => parseInt(diff) ? (diff > 0 ? '+' : '') + Math.round(diff) : diff)
|
|
Handlebars.registerHelper('fractionOneN', n => new Handlebars.SafeString(Misc.getFractionOneN(n)))
|
|
|
|
// Handle v12 removal of this helper
|
|
Handlebars.registerHelper('select', function (selected, options) {
|
|
const escapedValue = RegExp.escape(Handlebars.escapeExpression(selected));
|
|
const rgx = new RegExp(' value=[\"\']' + escapedValue + '[\"\']');
|
|
const html = options.fn(this);
|
|
return html.replace(rgx, "$& selected");
|
|
})
|
|
|
|
// logic
|
|
Handlebars.registerHelper('either', (a, b) => a ?? b);
|
|
// string manipulation
|
|
Handlebars.registerHelper('upperFirst', str => Misc.upperFirst(str ?? 'Null'));
|
|
Handlebars.registerHelper('lowerFirst', str => Misc.lowerFirst(str ?? 'Null'));
|
|
Handlebars.registerHelper('uppercase', str => str?.toUpperCase() ?? '');
|
|
Handlebars.registerHelper('lowercase', str => str?.toLowerCase() ?? '');
|
|
Handlebars.registerHelper('grammar-le', str => Grammar.articleDetermine(str));
|
|
Handlebars.registerHelper('grammar-apostrophe', (article, str) => Grammar.apostrophe(article, str));
|
|
Handlebars.registerHelper('grammar-un', str => Grammar.articleIndetermine(str));
|
|
Handlebars.registerHelper('grammar-accord', (genre, ...args) => Grammar.accord(genre, args));
|
|
Handlebars.registerHelper('json-stringify', object => JSON.stringify(object))
|
|
Handlebars.registerHelper('escapeHtml', object => foundry.utils.escapeHTML(object))
|
|
|
|
// math
|
|
Handlebars.registerHelper('math-sum', (...values) => values.slice(0, -1).reduce(Misc.sum(), 0))
|
|
Handlebars.registerHelper('math-abs', diff => Math.abs(parseInt(diff)))
|
|
Handlebars.registerHelper('min', (...args) => Math.min(...args.slice(0, -1)));
|
|
Handlebars.registerHelper('repeat', function (n, block) {
|
|
let accum = '';
|
|
for (let i = 0; i < n; ++i) {
|
|
accum += block.fn(i)
|
|
}
|
|
return accum
|
|
})
|
|
|
|
// tableaux, listes
|
|
Handlebars.registerHelper('array-includes', (array, value) => array.includes(value));
|
|
Handlebars.registerHelper('isLastIndex', (index, list) => index + 1 >= list.length);
|
|
Handlebars.registerHelper('trier', list => list.sort((a, b) => a.name.localeCompare(b.name)));
|
|
|
|
// table de résolution
|
|
Handlebars.registerHelper('computeResolutionScore', (row, col) => RdDResolutionTable.computePercentage(row, col));
|
|
Handlebars.registerHelper('computeResolutionChances', (row, col) => RdDResolutionTable.computeChances(row, col));
|
|
|
|
// gestion des dates et heures
|
|
Handlebars.registerHelper('timestamp-imgSigneHeure', (heure) => { return new Handlebars.SafeString(RdDTimestamp.imgSigneHeure(heure)) });
|
|
Handlebars.registerHelper('timestamp-imgSigne', (heure) => { return new Handlebars.SafeString(RdDTimestamp.imgSigne(heure)) });
|
|
Handlebars.registerHelper('timestamp-label', (heure) => RdDTimestamp.definition(heure)?.label ?? 'inconnue')
|
|
Handlebars.registerHelper('timestamp-definition', (heure) => RdDTimestamp.definition(heure))
|
|
Handlebars.registerHelper('timestamp-extract', timestamp => new RdDTimestamp(timestamp).toCalendrier());
|
|
Handlebars.registerHelper('timestamp-formulesDuree', () => RdDTimestamp.formulesDuree());
|
|
Handlebars.registerHelper('timestamp-formulesPeriode', () => RdDTimestamp.formulesPeriode());
|
|
|
|
// informations sur les acteurs
|
|
Handlebars.registerHelper('actor-default', (actorType, ...path) => RdDBaseActor.getDefaultValue(actorType, path.slice(0, -1)));
|
|
Handlebars.registerHelper('filtreTriCompetences', competences => RdDItemCompetence.triVisible(competences));
|
|
Handlebars.registerHelper('experienceLog-topic', topic => ExperienceLog.labelTopic(topic));
|
|
|
|
Handlebars.registerHelper('carac-label', (code) => RdDCarac.label(code))
|
|
|
|
// inventaire et marchands
|
|
Handlebars.registerHelper('buildLigneInventaire', (item, options) => { return new Handlebars.SafeString(RdDUtility.buildLigneInventaire(item, options)); });
|
|
Handlebars.registerHelper('buildInventaireConteneur', (actorId, itemId, options) => { return new Handlebars.SafeString(RdDUtility.buildInventaireConteneur(actorId, itemId, options)); });
|
|
Handlebars.registerHelper('buildContenuConteneur', (item, options) => { return new Handlebars.SafeString(RdDUtility.buildContenuConteneur(item, options)); });
|
|
Handlebars.registerHelper('calculerPrixCommercant', item => item.calculerPrixCommercant());
|
|
Handlebars.registerHelper('uniteQuantite', (itemId, actorId) => RdDUtility.getItem(itemId, actorId)?.getUniteQuantite());
|
|
Handlebars.registerHelper('isFieldInventaireModifiable', (type, field) => RdDItem.isFieldInventaireModifiable(type, field));
|
|
// Items
|
|
Handlebars.registerHelper('rarete-getChamp', (rarete, field) => RdDRaretes.getChamp(rarete, field));
|
|
Handlebars.registerHelper('item-action-applies', (action, item, options) => ItemAction.applies(action, item, options))
|
|
Handlebars.registerHelper('item-action-label', (action, item) => new Handlebars.SafeString(ItemAction.label(action, item)))
|
|
Handlebars.registerHelper('item-action-img', (action, item) => new Handlebars.SafeString(ItemAction.img(action, item)))
|
|
Handlebars.registerHelper('item-name', (item) => item.nameDisplay)
|
|
|
|
// TMRs
|
|
Handlebars.registerHelper('caseTmr-label', coord => TMRUtility.getTMRLabel(coord));
|
|
Handlebars.registerHelper('caseTmr-type', coord => TMRUtility.getTMRType(coord));
|
|
Handlebars.registerHelper('typeTmr-name', type => TMRUtility.typeTmrName(type));
|
|
Handlebars.registerHelper('effetRencontre-name', coord => TMRUtility.typeTmrName(coord));
|
|
|
|
foundry.applications.handlebars.loadTemplates(templatePaths);
|
|
}
|
|
|
|
static getItem(itemId, actorId = undefined) {
|
|
return actorId ? game.actors.get(actorId)?.getItem(itemId) : game.items.get(itemId);
|
|
}
|
|
|
|
static linkCompendium(pack, id, name) {
|
|
return `@Compendium[${pack}.${id}]{${name}}`;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static buildListOptions(min, max) {
|
|
let options = ""
|
|
for (let i = min; i <= max; i++) {
|
|
options += `<option value="${i}">${i}</option>`
|
|
}
|
|
return options;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static arrayOrEmpty(items) {
|
|
if (items?.length) {
|
|
return items;
|
|
}
|
|
return [];
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static getNomEthylisme(niveauEthylisme) { return niveauEthylisme > 0 ? 'Aucun' : nomEthylisme[-niveauEthylisme] }
|
|
|
|
/* -------------------------------------------- */
|
|
static toggleAfficheContenu(conteneurId) {
|
|
RdDUtility.afficheContenu[conteneurId] = !RdDUtility.afficheContenu[conteneurId];
|
|
}
|
|
/* -------------------------------------------- */
|
|
static getAfficheContenu(conteneurId) {
|
|
if (conteneurId)
|
|
return RdDUtility.afficheContenu[conteneurId];
|
|
return undefined;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static buildArbreDeConteneurs(conteneurs, inventaires) {
|
|
let objetVersConteneur = {};
|
|
// Attribution des objets aux conteneurs
|
|
for (let conteneur of conteneurs) {
|
|
if (conteneur.isConteneur()) {
|
|
conteneur.subItems = [];
|
|
for (let id of conteneur.system.contenu ?? []) {
|
|
let objet = inventaires.find(objet => (id == objet._id));
|
|
if (objet) {
|
|
objet.estContenu = true;
|
|
objetVersConteneur[id] = conteneur._id;
|
|
conteneur.subItems.push(objet);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (let conteneur of conteneurs) {
|
|
conteneur.system.encTotal = RdDUtility.calculEncContenu(conteneur, inventaires);
|
|
}
|
|
return objetVersConteneur;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static calculEncContenu(conteneur, inventaires) {
|
|
const contenus = (conteneur.system.contenu ?? []).filter(id => id != undefined)
|
|
.map(id => inventaires.find(it => (id == it.id)))
|
|
.filter(it => it);
|
|
let enc = Number(conteneur.system.encombrement ?? 0) * Number(conteneur.system.quantite ?? 1);
|
|
for (let contenu of contenus) {
|
|
if (contenu.type == 'conteneur') {
|
|
enc += RdDUtility.calculEncContenu(contenu, inventaires);
|
|
}
|
|
else {
|
|
enc += Number(contenu.system.encombrement ?? 0) * Number(contenu.system.quantite ?? 1)
|
|
}
|
|
}
|
|
return enc
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
// Construit la liste des conteneurs de niveau 1 (c'est à dire non contenu eux-même dans un conteneur)
|
|
static conteneursRacine(conteneurs) {
|
|
return conteneurs.filter((conteneur, index, arr) => !conteneur.estContenu);
|
|
}
|
|
|
|
static prepareOptionsArbreInventaire(item, optionsArbre) {
|
|
if (!optionsArbre.profondeur) {
|
|
optionsArbre.profondeur = 1
|
|
};
|
|
if (!optionsArbre.templateItem) {
|
|
optionsArbre.templateItem = item.parent?.type == 'commerce'
|
|
? "systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire-item.hbs"
|
|
: "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-item.hbs";
|
|
}
|
|
item.niveau = optionsArbre.profondeur;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
/**
|
|
* Construit la structure récursive des conteneurs, avec imbrication potentielle
|
|
*/
|
|
static buildLigneInventaire(item, options = {}, optionsArbre = { ouvert: false, profondeur: 1 }) {
|
|
RdDUtility.prepareOptionsArbreInventaire(item, optionsArbre);
|
|
|
|
const isConteneur = item.type == 'conteneur';
|
|
const inventaire = {
|
|
item: item,
|
|
vide: isConteneur && item.system.contenu.length == 0,
|
|
ouvert: isConteneur && RdDUtility.getAfficheContenu(item._id),
|
|
options: options
|
|
};
|
|
optionsArbre.ouvert = inventaire.ouvert
|
|
const ligneObjet = Handlebars.partials[optionsArbre.templateItem](inventaire);
|
|
if (isConteneur) {
|
|
return ligneObjet + RdDUtility.buildContenuConteneur(item, options, optionsArbre);
|
|
}
|
|
return ligneObjet;
|
|
}
|
|
|
|
static filterItemsPerTypeForSheet(formData, itemTypes) {
|
|
Object.values(ITEM_TYPES).forEach(t => {
|
|
formData[RdDItem.itemTypePluriel(t)] = Misc.arrayOrEmpty(itemTypes[t])
|
|
itemTypes[t].forEach(item => item.actions = item.itemActions())
|
|
})
|
|
|
|
formData.maladiesPoisons = formData.maladies.concat(formData.poisons)
|
|
formData.competences = formData.competences.concat(formData.competencecreatures)
|
|
formData.monnaies = formData.monnaies.sort(Monnaie.triValeurEntiere())
|
|
|
|
formData.inventaires = RdDUtility.prepareInventaire(itemTypes)
|
|
}
|
|
|
|
static buildInventaireConteneur(actorId, itemId, options) {
|
|
const actor = game.actors.get(actorId)
|
|
const item = actor?.items.get(itemId)
|
|
if (item?.type == ITEM_TYPES.conteneur) {
|
|
const formData = {}
|
|
RdDUtility.filterItemsPerTypeForSheet(formData, actor.itemTypes);
|
|
RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.inventaires);
|
|
item.subItems = formData.conteneurs.find(it => it._id == itemId)?.subItems;
|
|
|
|
return RdDUtility.buildContenuConteneur(item, options, { ouvert: true, profondeur: 1 })
|
|
}
|
|
return ''
|
|
}
|
|
|
|
static prepareInventaire(itemTypes) {
|
|
return RdDItem.getItemTypesInventaire('all')
|
|
.map(t => Misc.arrayOrEmpty(itemTypes[t]))
|
|
.reduce((a, b) => a.concat(b), [])
|
|
.sort(Misc.ascending(it => it.name))
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static buildContenuConteneur(conteneur, options = {}, optionsArbre = {}) {
|
|
RdDUtility.prepareOptionsArbreInventaire(conteneur, optionsArbre);
|
|
const display = optionsArbre.ouvert ? 'item-display-show' : 'item-display-hide';
|
|
const profondeur = optionsArbre.profondeur;
|
|
|
|
optionsArbre.profondeur++;
|
|
const lignesContenu = conteneur.subItems.sort(Misc.ascending(it => it.name))
|
|
.map(contenu => this.buildLigneInventaire(contenu, options, optionsArbre));
|
|
|
|
return `<ul class='item-list alterne-list ${display} list-item-margin${Math.min(profondeur, 6)}'>`
|
|
+ lignesContenu.reduce(Misc.joining(''), '')
|
|
+ "</ul>";
|
|
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static getCaracArray() {
|
|
return carac_array;
|
|
}
|
|
static getDifficultesLibres() {
|
|
return difficultesLibres;
|
|
}
|
|
static getAjustementsConditions() {
|
|
return ajustementsConditions;
|
|
}
|
|
static getAjustementsEncaissement() {
|
|
return ajustementsEncaissement;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static getSegmentsFatigue(maxEndurance) {
|
|
return fatigueMatrix[Math.min(Math.max(maxEndurance, 1), fatigueMatrix.length)];
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static calculMalusFatigue(fatigue, endurance) {
|
|
endurance = Math.min(Math.max(endurance, 1), cumulFatigueMatrix.length);
|
|
let segments = cumulFatigueMatrix[endurance];
|
|
for (let i = 0; i < segments.length; i++) {
|
|
if (fatigue <= segments[i]) {
|
|
return fatigueMalus[i]
|
|
}
|
|
}
|
|
return -7;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static calculFatigueHtml(fatigue, endurance) {
|
|
return ReglesOptionnelles.isUsing("appliquer-fatigue") ? {
|
|
malus: RdDUtility.calculMalusFatigue(fatigue, endurance),
|
|
html: "<table class='table-fatigue'>" + RdDUtility.makeHTMLfatigueMatrix(fatigue, endurance).html() + "</table>"
|
|
} : { malus: 0, html: '' };
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
// Build the nice (?) html table used to manage fatigue.
|
|
// max should be the endurance max value
|
|
static makeHTMLfatigueMatrix(fatigue, maxEndurance) {
|
|
const segments = this.getSegmentsFatigue(maxEndurance);
|
|
return this.makeHTMLfatigueMatrixForSegment(fatigue, segments);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static makeHTMLfatigueMatrixForSegment(fatigue, segments) {
|
|
fatigue = Math.max(fatigue, 0);
|
|
fatigue = Math.min(fatigue, segments.fatigueMax);
|
|
|
|
let table = $("<table/>").addClass('table-fatigue');
|
|
let segmentIdx = 0;
|
|
let fatigueCount = 0;
|
|
for (var line = 0; line < fatigueLineSize.length; line++) {
|
|
let row = $("<tr/>");
|
|
let segmentsPerLine = fatigueLineSize[line];
|
|
row.append("<td class='fatigue-malus'>" + fatigueLineMalus[line] + "</td>");
|
|
while (segmentIdx < segmentsPerLine) {
|
|
let freeSize = segments[segmentIdx];
|
|
for (let col = 0; col < 5; col++) {
|
|
if (col < freeSize) {
|
|
if (fatigueCount < fatigue)
|
|
row.append("<td class='fatigue-used'>X</td>");
|
|
|
|
|
|
else
|
|
row.append("<td class='fatigue-free'/>");
|
|
fatigueCount++;
|
|
} else {
|
|
row.append("<td class='fatigue-none'/>");
|
|
}
|
|
}
|
|
row.append("<td class='fatigue-separator'/>");
|
|
segmentIdx = segmentIdx + 1;
|
|
}
|
|
table.append(row);
|
|
}
|
|
return table;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static async getLocalisation(type = 'personnage') {
|
|
const loc = { result: await RdDDice.rollTotal("1d20") };
|
|
if (type == 'personnage') {
|
|
if (loc.result <= 3) loc.txt = "Jambe, genou, pied, jarret";
|
|
else if (loc.result <= 7) loc.txt = "Hanche, cuisse, fesse";
|
|
else if (loc.result <= 9) loc.txt = "Ventre, reins";
|
|
else if (loc.result <= 12) loc.txt = "Poitrine, dos";
|
|
else if (loc.result <= 14) loc.txt = "Avant-bras, main, coude";
|
|
else if (loc.result <= 18) loc.txt = "Epaule, bras, omoplate";
|
|
else if (loc.result == 19) loc.txt = "Tête";
|
|
else if (loc.result == 20) loc.txt = "Tête (visage)";
|
|
} else {
|
|
if (loc.result <= 7) loc.txt = "Jambes/Pattes";
|
|
else if (loc.result <= 18) loc.txt = "Corps";
|
|
else if (loc.result <= 20) loc.txt = "Tête";
|
|
}
|
|
return loc
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static async jetEncaissement(actor, dmg, armure, options = { showDice: HIDE_DICE }) {
|
|
const diff = Math.abs(dmg.diff)
|
|
const formula = RdDUtility.formuleEncaissement(diff, options)
|
|
const roll = await RdDDice.roll(formula, options);
|
|
|
|
RdDUtility.remplaceDeMinParDifficulte(roll, diff, options);
|
|
|
|
return await RdDUtility.prepareEncaissement(actor, dmg, roll, armure);
|
|
}
|
|
|
|
static remplaceDeMinParDifficulte(roll, diff, options) {
|
|
if (!ReglesOptionnelles.isUsing('degat-minimum-malus-libre-simple')) {
|
|
return
|
|
}
|
|
// 1 dé fait au minmum la difficulté libre
|
|
const total = options.forceDiceResult?.total;
|
|
if (total) {
|
|
const reste = Math.max(total - diff, 1)
|
|
roll.terms[0].number = reste + diff
|
|
}
|
|
else {
|
|
if (roll.terms[0].results[0].result < diff) {
|
|
roll.terms[0].results[0].result = diff;
|
|
} else if (roll.terms[0].results[1].result < diff) {
|
|
roll.terms[0].results[1].result = diff;
|
|
}
|
|
roll._total = roll.terms[0].results[0].result + roll.terms[0].results[1].result;
|
|
}
|
|
}
|
|
|
|
static formuleEncaissement(diff) {
|
|
// Chaque dé fait au minimum la difficulté libre
|
|
if (ReglesOptionnelles.isUsing('degat-minimum-malus-libre')) {
|
|
return `2d10min${diff}`
|
|
}
|
|
return '2d10'
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static async prepareEncaissement(targetActor, dmg, roll, armure) {
|
|
const jetTotal = roll.total + dmg.total - armure
|
|
const encaissement = RdDUtility.$selectEncaissement(targetActor, jetTotal, dmg.mortalite)
|
|
const over20 = Math.max(jetTotal - 20, 0)
|
|
encaissement.dmg = dmg
|
|
if (ReglesOptionnelles.isUsing('localisation-aleatoire')) {
|
|
encaissement.dmg.loc = dmg.loc ?? await RdDUtility.getLocalisation(targetActor.type)
|
|
encaissement.dmg.loc.label = encaissement.dmg.loc.label ?? 'Corps'
|
|
}
|
|
else {
|
|
encaissement.dmg.loc = { label: '' }
|
|
}
|
|
encaissement.roll = roll
|
|
encaissement.armure = armure
|
|
encaissement.penetration = dmg.penetration
|
|
encaissement.total = jetTotal
|
|
encaissement.vie = await RdDUtility._evaluatePerte(encaissement.vie, over20)
|
|
encaissement.endurance = await RdDUtility._evaluatePerte(encaissement.endurance, over20)
|
|
return encaissement
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static $selectEncaissement(targetActor, degats, mortalite) {
|
|
const table = RdDUtility.$getTableEncaissement(targetActor, mortalite)
|
|
const encaissement = table.find(it => ((it.minimum ?? degats) <= degats && degats <= (it.maximum ?? degats)))
|
|
return foundry.utils.duplicate(encaissement ?? table[0])
|
|
}
|
|
|
|
static $getTableEncaissement(targetActor, mortalite) {
|
|
if (targetActor.isEntite()) {
|
|
return TABLE_ENCAISSEMENT_ENTITE
|
|
}
|
|
switch (mortalite) {
|
|
case RDD_CONFIG.encaissement.nonmortel: return TABLE_ENCAISSEMENT_NONMORTEL
|
|
case RDD_CONFIG.encaissement.entiteincarnee: return TABLE_ENCAISSEMENT_ENTITE
|
|
}
|
|
return TABLE_ENCAISSEMENT_MORTEL
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static async _evaluatePerte(formula, over20) {
|
|
let perte = new Roll(formula, { over20: over20 });
|
|
await perte.evaluate();
|
|
return perte.total;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static onSocketMessage(sockmsg) {
|
|
switch (sockmsg.msg) {
|
|
case "msg_app_astrologie_refresh":
|
|
return Hooks.callAll(APP_ASTROLOGIE_REFRESH)
|
|
case "msg_request_nombre_astral":
|
|
return game.system.rdd.calendrier.requestNombreAstral(sockmsg.data)
|
|
case "msg_tmr_move":
|
|
let actor = game.actors.get(sockmsg.data.actorId);
|
|
if (actor.isOwner || game.user.isGM) {
|
|
actor.refreshTMRView()
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static async chatListeners(html) {
|
|
RdDCombat.registerChatCallbacks(html)
|
|
RdDEmpoignade.registerChatCallbacks(html)
|
|
RdDCoeur.registerChatCallbacks(html)
|
|
RdDTextEditor.registerChatCallbacks(html)
|
|
|
|
// Gestion spécifique message passeurs
|
|
$(html).on("click", '.tmr-passeur-coord a', event => {
|
|
let coord = event.currentTarget.attributes['data-tmr-coord'].value;
|
|
let actorId = event.currentTarget.attributes['data-actor-id'].value;
|
|
let actor = game.actors.get(actorId);
|
|
actor.tmrApp.positionnerDemiReve(coord);
|
|
});
|
|
// Gestion spécifique des sorts en réserve multiples (ie têtes)
|
|
$(html).on("click", '.declencher-sort-reserve', async event => {
|
|
let coord = event.currentTarget.attributes['data-tmr-coord'].value;
|
|
let sortId = event.currentTarget.attributes['data-sort-id'].value;
|
|
let actorId = event.currentTarget.attributes['data-actor-id'].value;
|
|
let actor = game.actors.get(actorId);
|
|
await actor.tmrApp.lancerSortEnReserve(coord, sortId);
|
|
// TODO: supprimer le message?
|
|
});
|
|
|
|
// gestion bouton tchat Possession
|
|
$(html).on("click", '.defense-possession', event => {
|
|
let attackerId = event.currentTarget.attributes['data-attackerId'].value
|
|
let defenderId = event.currentTarget.attributes['data-defenderId'].value
|
|
let possessionId = event.currentTarget.attributes['data-possessionId'].value
|
|
RdDPossession.onDefensePossession(attackerId, defenderId, possessionId)
|
|
});
|
|
|
|
// gestion bouton tchat Acheter
|
|
$(html).on("click", '.button-acheter', event => {
|
|
const venteData = DialogItemAchat.preparerAchat(event.currentTarget);
|
|
if (venteData) {
|
|
DialogItemAchat.onAcheter(venteData);
|
|
}
|
|
});
|
|
$(html).on("click", '.button-creer-acteur', event => RdDNameGen.onCreerActeur(event));
|
|
|
|
// Gestion du bouton payer
|
|
$(html).on("click", '.payer-button', event => {
|
|
let sommeAPayer = Number(event.currentTarget.attributes['data-somme-a-payer']?.value ?? 0);
|
|
let actor = RdDUtility.getSelectedActor("Pour effectuer le paiement:");
|
|
if (actor) {
|
|
actor.payerSols(sommeAPayer)
|
|
const chatMessage = RdDUtility.findChatMessageId(event.currentTarget)
|
|
ChatUtility.remover(chatMessage)()
|
|
}
|
|
});
|
|
$(html).on("click", '.rdd-world-content-link', async event => {
|
|
const htmlElement = $(html).find(event.currentTarget);
|
|
const id = htmlElement?.data("id");
|
|
const doctype = htmlElement?.data("doctype");
|
|
switch (doctype ?? 'Item') {
|
|
case 'Actor':
|
|
return game.actors.get(id)?.sheet.render(true);
|
|
case 'Item':
|
|
default:
|
|
return game.items.get(id)?.sheet.render(true);
|
|
}
|
|
});
|
|
}
|
|
|
|
static findChatMessageId(current) {
|
|
return RdDUtility.getChatMessageId(RdDUtility.findChatMessage(current));
|
|
}
|
|
|
|
static getChatMessageId(node) {
|
|
return node?.attributes.getNamedItem('data-message-id')?.value;
|
|
}
|
|
|
|
static findChatMessage(current) {
|
|
return RdDUtility.findNodeMatching(current, it => it.classList.contains('chat-message') && it.attributes.getNamedItem('data-message-id'));
|
|
}
|
|
|
|
static findNodeMatching(current, predicate) {
|
|
if (current) {
|
|
if (predicate(current)) {
|
|
return current;
|
|
}
|
|
return RdDUtility.findNodeMatching(current.parentElement, predicate);
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
static getSelectedToken(actor) {
|
|
if (canvas.tokens.controlled.length > 0) {
|
|
return canvas.tokens.controlled
|
|
.find(it => it.actor.id == actor.id)
|
|
}
|
|
return undefined
|
|
}
|
|
|
|
static getSelectedActor(msgPlayer = undefined) {
|
|
if (canvas.tokens.controlled.length == 1) {
|
|
let token = canvas.tokens.controlled[0];
|
|
if (token.actor) {
|
|
return token.actor;
|
|
}
|
|
if (msgPlayer != undefined) {
|
|
msgPlayer += "<br>le token sélectionné doit être lié à un personnage";
|
|
}
|
|
}
|
|
if (game.user.character) {
|
|
return game.user.character;
|
|
}
|
|
if (msgPlayer != undefined) {
|
|
msgPlayer += "<br>vous pouvez sélectionner un seul token lié à un personnage"
|
|
msgPlayer += "<br>vous devez être connecté comme joueur avec un personnage sélectionné";
|
|
ui.notifications.warn(msgPlayer);
|
|
ChatMessage.create({ content: msgPlayer, whisper: [game.user] })
|
|
}
|
|
return undefined
|
|
}
|
|
|
|
static doWithSelectedActor(onSelected = () => { }, filter = actor => true) {
|
|
const selected = RdDUtility.getSelectedActor()
|
|
if (selected) {
|
|
onSelected(selected)
|
|
}
|
|
else {
|
|
const actors = game.actors
|
|
.filter(it => it.getUserLevel(game.user) == CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER)
|
|
.filter(it => ![ACTOR_TYPES.commerce, ACTOR_TYPES.vehicule].includes(it.type))
|
|
.filter(filter)
|
|
const selectData = {
|
|
title: "Choisir un acteur",
|
|
label: "Choisir un acteur",
|
|
list: actors.map(it => Targets.extractActorData(it))
|
|
};
|
|
DialogSelect.select(selectData, it => onSelected(game.actors.get(it.id)))
|
|
}
|
|
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static createMonnaie(name, cout, img = "", enc = 0.01) {
|
|
let piece = {
|
|
name: name, type: 'monnaie', img: img, _id: foundry.utils.randomID(16),
|
|
dasystemta: {
|
|
quantite: 0,
|
|
cout: cout,
|
|
encombrement: enc,
|
|
description: ""
|
|
}
|
|
}
|
|
return piece;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static afficherDemandePayer(som1, som2) {
|
|
som1 = (som1) ? som1.toLowerCase() : "0d";
|
|
som2 = (som2) ? som2.toLowerCase() : "0d";
|
|
let regExp1 = /(\d+)(\w+)/g;
|
|
let p1 = regExp1.exec(som1);
|
|
let regExp2 = /(\d+)(\w+)/g;
|
|
let p2 = regExp2.exec(som2);
|
|
let deniers = 0;
|
|
let sols = 0;
|
|
if (p1[2] == 'd') deniers += Number(p1[1]);
|
|
if (p1[2] == 's') sols += Number(p1[1]);
|
|
if (p2[2] == 'd') deniers += Number(p2[1]);
|
|
if (p2[2] == 's') sols += Number(p2[1]);
|
|
|
|
let sommeAPayer = sols + deniers / 100;
|
|
let msgPayer = `La somme de ${sols} Sols et ${deniers} Deniers est à payer<br>
|
|
<a class='payer-button chat-card-button' data-somme-a-payer='${sommeAPayer}'>Payer</a>`
|
|
ChatMessage.create({ content: msgPayer });
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static chatDataSetup(content, modeOverride, isRoll = false, forceWhisper) {
|
|
let chatData = {
|
|
user: game.user.id,
|
|
rollMode: modeOverride || game.settings.get("core", "rollMode"),
|
|
content: content
|
|
}
|
|
ChatUtility.applyRollMode(chatData)
|
|
|
|
if (forceWhisper) { // Final force !
|
|
chatData.speaker = ChatMessage.getSpeaker();
|
|
chatData.whisper = ChatMessage.getWhisperRecipients(forceWhisper);
|
|
}
|
|
return chatData;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static confirmSubActeurDelete(sheet, subActor, htmlToDelete, onSuppression = () => { }) {
|
|
RdDConfirm.confirmer({
|
|
settingConfirmer: "confirmation-supprimer-lien-acteur",
|
|
content: `<p>Etes vous certain de vouloir supprimer le lien vers ${subActor.name} ?</p>`,
|
|
title: 'Confirmer la suppression',
|
|
buttonLabel: 'Supprimer le lien',
|
|
onAction: onSuppression
|
|
})
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static async confirmActorItemDelete(item, actor) {
|
|
const itemId = item.id;
|
|
const confirmationSuppression = {
|
|
settingConfirmer: "confirmation-supprimer-" + item.getItemGroup(),
|
|
content: `<p>Etes vous certain de vouloir supprimer: ${item.name}?</p>`,
|
|
title: `Supprimer ${item.name}`,
|
|
buttonLabel: "Supprimer",
|
|
onAction: async () => {
|
|
console.log('Delete : ', itemId);
|
|
await actor.deleteEmbeddedDocuments('Item', [itemId], { renderSheet: false });
|
|
}
|
|
};
|
|
if (item.isConteneurNonVide()) {
|
|
confirmationSuppression.content += `<p>Ce conteneur n'est pas vide. Que voulez vous supprimer?</p>`;
|
|
confirmationSuppression.settingConfirmer = undefined;
|
|
RdDConfirm.confirmer(confirmationSuppression,
|
|
{
|
|
'deleteall': {
|
|
icon: '<i class="fas fa-check"></i>',
|
|
label: "Supprimer conteneur et contenu",
|
|
callback: async () => {
|
|
console.log("Delete : ", itemId);
|
|
await actor.deleteAllConteneur(itemId, { renderSheet: false });
|
|
}
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
RdDConfirm.confirmer(confirmationSuppression)
|
|
}
|
|
}
|
|
|
|
static slideOnDelete(sheet, htmlToDelete) {
|
|
return htmlToDelete?.slideUp(200, () => sheet.render(false));
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static afficherHeuresChanceMalchance(heureNaissance) {
|
|
if (game.user.isGM) {
|
|
const heure = RdDTimestamp.findHeure(heureNaissance)
|
|
if (heureNaissance && heure) {
|
|
const ajustement = game.system.rdd.calendrier.getAjustementAstrologique(heureNaissance)
|
|
const current = game.system.rdd.calendrier.heureCourante()
|
|
ChatMessage.create({
|
|
content: `A l'heure de <strong>${current.label}</strong>, le modificateur de Chance/Malchance est de <strong>${Misc.toSignedString(ajustement)}</strong> pour l'heure de naissance <strong>${heure.label}</strong>.`,
|
|
whisper: ChatUtility.getGMs()
|
|
});
|
|
}
|
|
else if (heureNaissance) {
|
|
ui.notifications.warn(heureNaissance + " ne correspond pas à une heure de naissance");
|
|
}
|
|
else {
|
|
ui.notifications.warn("Pas d'heure de naissance selectionnée");
|
|
}
|
|
} else {
|
|
ui.notifications.warn("Vous n'avez pas accès à cette commande");
|
|
}
|
|
}
|
|
|
|
/*-------------------------------------------- */
|
|
static async checkThanatosXP(item) {
|
|
if (item.isCompetencePersonnage() && item.name.includes('Thanatos')) {
|
|
let message = "Vous avez mis des points d'Expérience en Thanatos !<br>Vous devez réduire manuellement d'un même montant d'XP une autre compétence Draconique.";
|
|
await ChatMessage.create({
|
|
whisper: ChatUtility.getUserAndGMs(),
|
|
content: message
|
|
});
|
|
}
|
|
}
|
|
|
|
}
|