";
} else {
str = str + "";
}
for (let subItem of objet.subItems) {
str = str + this.buildConteneur(subItem, niveau + 1);
}
str = str + "
";
}
return new Handlebars.SafeString(str);
}
/* -------------------------------------------- */
static getCaracArray() {
return carac_array;
}
static getDifficultesLibres() {
return difficultesLibres;
}
static getAjustementsConditions() {
return ajustementsConditions;
}
static getAjustementsEncaissement() {
return ajustementsEncaissement;
}
static getDefinitionsBlessures() {
return definitionsBlessures;
}
/* -------------------------------------------- */
static getSegmentsFatigue(maxEnd) {
maxEnd = Math.max(maxEnd, 1);
maxEnd = Math.min(maxEnd, fatigueMatrix.length);
return fatigueMatrix[maxEnd];
}
/* -------------------------------------------- */
static calculMalusFatigue(fatigue, maxEnd) {
maxEnd = Math.max(maxEnd, 1);
maxEnd = Math.min(maxEnd, cumulFatigueMatrix.length);
let segments = cumulFatigueMatrix[maxEnd];
for (let i = 0; i < 12; i++) {
if (fatigue <= segments[i]) {
return fatigueMalus[i]
}
}
return -7;
}
static calculFatigueHtml(fatigue, endurance) {
return ReglesOptionelles.isUsing("appliquer-fatigue") ? {
malus: RdDUtility.calculMalusFatigue(fatigue, endurance),
html: "" + RdDUtility.makeHTMLfatigueMatrix(fatigue, endurance).html() + "
"
} : { malus: 0, html: '' };
}
/* -------------------------------------------- */
// Build the nice (?) html table used to manage fatigue.
// max should be the endurance max value
static makeHTMLfatigueMatrix(fatigue, maxEndurance) {
let 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 = $("").addClass('table-fatigue');
let segmentIdx = 0;
let fatigueCount = 0;
for (var line = 0; line < fatigueLineSize.length; line++) {
let row = $("|
");
let segmentsPerLine = fatigueLineSize[line];
row.append("" + fatigueLineMalus[line] + " | ");
while (segmentIdx < segmentsPerLine) {
let freeSize = segments[segmentIdx];
for (let col = 0; col < 5; col++) {
if (col < freeSize) {
if (fatigueCount < fatigue)
row.append("X | ");
else
row.append(" | ");
fatigueCount++;
} else {
row.append(" | ");
}
}
row.append(" | ");
segmentIdx = segmentIdx + 1;
}
table.append(row);
}
return table;
}
/* -------------------------------------------- */
static async getLocalisation(type = 'personnage') {
let result = await RdDDice.rollTotal("1d20");
let txt = ""
if (type == 'personnage') {
if (result <= 3) txt = "Jambe, genou, pied, jarret";
else if (result <= 7) txt = "Hanche, cuisse, fesse";
else if (result <= 9) txt = "Ventre, reins";
else if (result <= 12) txt = "Poitrine, dos";
else if (result <= 14) txt = "Avant-bras, main, coude";
else if (result <= 18) txt = "Epaule, bras, omoplate";
else if (result == 19) txt = "Tête";
else if (result == 20) txt = "Tête (visage)";
} else {
if (result <= 7) txt = "Jambes/Pattes";
else if (result <= 18) txt = "Corps";
else if (result <= 20) txt = "Tête";
}
return { result: result, label: txt };
}
/* -------------------------------------------- */
static selectEncaissement(degats, mortalite) {
const table = definitionsEncaissement[mortalite] === undefined ? definitionsEncaissement["mortel"] : definitionsEncaissement[mortalite];
for (let encaissement of table) {
if ((encaissement.minimum === undefined || encaissement.minimum <= degats)
&& (encaissement.maximum === undefined || degats <= encaissement.maximum)) {
return duplicate(encaissement);
}
}
return duplicate(table[0]);
}
/* -------------------------------------------- */
static currentFatigueMalus(value, max) {
if (ReglesOptionelles.isUsing("appliquer-fatigue")) {
max = Math.max(1, Math.min(max, 60));
value = Math.min(max * 2, Math.max(0, value));
let fatigueTab = fatigueMatrix[max];
let fatigueRem = value;
for (let idx = 0; idx < fatigueTab.length; idx++) {
fatigueRem -= fatigueTab[idx];
if (fatigueRem <= 0) {
return fatigueMalus[idx];
}
}
return -7; // This is the max !
}
return 0;
}
/* -------------------------------------------- */
static async loadCompendiumData(compendium) {
const pack = game.packs.get(compendium);
return await pack?.getDocuments() ?? [];
}
/* -------------------------------------------- */
static async loadCompendium(compendium, filter = item => true) {
let compendiumData = await RdDUtility.loadCompendiumData(compendium);
return compendiumData.filter(filter);
}
/* -------------------------------------------- */
static async responseNombreAstral(data) {
let actor = game.actors.get(data.id);
actor.ajouteNombreAstral(data);
}
/* -------------------------------------------- */
static onSocketMesssage(sockmsg) {
switch (sockmsg.msg) {
case "msg_gm_chat_message":
return ChatUtility.handleGMChatMessage(sockmsg.data);
case "msg_sync_time":
return game.system.rdd.calendrier.syncPlayerTime(sockmsg.data);
case "msg_request_nombre_astral":
return game.system.rdd.calendrier.requestNombreAstral(sockmsg.data);
case "msg_response_nombre_astral":
return RdDUtility.responseNombreAstral(sockmsg.data);
case "msg_tmr_move":
let actor = game.actors.get(sockmsg.data.actorId);
if (actor.isOwner || game.user.isGM) {
actor.refreshTMRView(sockmsg.data.tmrPos);
}
break;
}
}
/* -------------------------------------------- */
static async chatListeners(html) {
RdDCombat.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.forceDemiRevePosition(coord);
});
// Gestion spécifique des sorts en réserve multiples (ie têtes)
html.on("click", '#sort-reserve', 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);
actor.tmrApp.lancerSortEnReserve(coord, sortId);
});
// gestion bouton tchat Acheter
html.on("click", '.button-acheter', event => DialogItemAchat.onButtonAcheter(event));
// Gestion du bouton payer
html.on("click", '.payer-button', event => {
let sumdenier = event.currentTarget.attributes['data-somme-denier']?.value ?? 0;
let quantite = event.currentTarget.attributes['data-quantite']?.value ?? 1;
let fromActorId = event.currentTarget.attributes['data-actor-id']?.value;
let jsondata = event.currentTarget.attributes['data-jsondata']
let objData
if (jsondata) {
objData = JSON.parse(jsondata.value)
}
let actor = RdDUtility.getSelectedActor("Pour effectuer le paiement:");
if (actor) {
actor.depenserDeniers(sumdenier, objData, quantite, fromActorId);
let chatMessageId = RdDUtility.findChatMessageId(event.currentTarget);
if (chatMessageId) {
ChatUtility.removeChatMessageId(chatMessageId);
}
}
});
}
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 getSelectedActor(msgPlayer = undefined) {
if (canvas.tokens.controlled.length == 1) {
let token = canvas.tokens.controlled[0];
if (token.actor && token.data.actorLink) {
return token.actor;
}
if (msgPlayer != undefined) {
msgPlayer += "
le token sélectionné doit être lié à un personnage";
}
}
if (game.user.character) {
return game.user.character;
}
if (msgPlayer != undefined) {
msgPlayer += "
vous pouvez sélectionner un seul token lié à un personnage";
msgPlayer += "
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 createMonnaie(name, valeur_deniers, img = "", enc = 0.01) {
let piece = {
name: name, type: 'monnaie', img: img, _id: randomID(16),
data: {
quantite: 0,
valeur_deniers: valeur_deniers,
encombrement: enc,
description: ""
}
}
return piece;
}
/* -------------------------------------------- */
static afficherDemandePayer(som1, som2) {
som1 = (som1) ? som1.toLowerCase() : "0d";
som2 = (som2) ? som2.toLowerCase() : "0d";
let regExp = /(\d+)(\w+)/g;
let p1 = regExp.exec(som1);
regExp = /(\d+)(\w+)/g;
let p2 = regExp.exec(som2);
let sumd = 0;
let sums = 0;
if (p1[2] == 'd') sumd += Number(p1[1]);
if (p1[2] == 's') sums += Number(p1[1]);
if (p2[2] == 'd') sumd += Number(p2[1]);
if (p2[2] == 's') sums += Number(p2[1]);
let sumtotald = sumd + (sums * 100);
let msgPayer = "La somme de " + sums + " Sols et " + sumd + " Deniers est à payer, cliquer sur le lien ci-dessous si besoin.
";
msgPayer += "Payer"
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
};
if (["gmroll", "blindroll"].includes(chatData.rollMode)) chatData["whisper"] = ChatMessage.getWhisperRecipients("GM").map(u => u.id);
if (chatData.rollMode === "blindroll") chatData["blind"] = true;
else if (chatData.rollMode === "selfroll") chatData["whisper"] = [game.user];
if (forceWhisper) { // Final force !
chatData["speaker"] = ChatMessage.getSpeaker();
chatData["whisper"] = ChatMessage.getWhisperRecipients(forceWhisper);
}
return chatData;
}
/* -------------------------------------------- */
static confirmerSuppressionSubacteur(actorSheet, li) {
let actorId = li.data("actor-id");
let actor = game.actors.get(actorId);
let msgTxt = "Etes vous certain de vouloir supprimer le lien vers ce véhicule/monture/suivant : " + actor.data.name + " ?
";
let d = new Dialog({
title: "Confirmer la suppression du lien",
content: msgTxt,
buttons: {
delete: {
icon: '',
label: "Supprimer le lien",
callback: () => {
console.log("Delete : ", actorId);
actorSheet.actor.removeSubacteur(actorId);
li.slideUp(200, () => actorSheet.render(false));
}
},
cancel: {
icon: '',
label: "Annuler"
}
},
default: "cancel"
});
d.render(true);
}
/* -------------------------------------------- */
static async confirmerSuppression(actorSheet, li) {
let itemId = li.data("item-id");
let objet = actorSheet.actor.getObjet(itemId);
let msgTxt = "Etes vous certain de vouloir supprimer cet objet ?";
let buttons = {
delete: {
icon: '',
label: "Supprimer l'objet",
callback: () => {
console.log("Delete : ", itemId);
actorSheet.actor.deleteEmbeddedDocuments('Item', [itemId]);
li.slideUp(200, () => actorSheet.render(false));
}
},
cancel: {
icon: '',
label: "Annuler"
}
}
const docData = Misc.data(objet);
if (docData.type == 'conteneur' && docData.data.contenu.length > 0) {
msgTxt += "
Ce conteneur n'est pas vide. Choisissez l'option de suppression";
buttons['deleteall'] = {
icon: '',
label: "Supprimer le conteneur et tout son contenu",
callback: () => {
console.log("Delete : ", itemId);
actorSheet.actor.deleteAllConteneur(itemId);
li.slideUp(200, () => actorSheet.render(false));
}
}
}
msgTxt += "
";
let d = new Dialog({
title: "Confirmer la suppression",
content: msgTxt,
buttons: buttons,
default: "cancel"
});
d.render(true);
}
/* -------------------------------------------- */
static afficherHeuresChanceMalchance(heureNaissance) {
if (heureNaissance) {
let ajustement = game.system.rdd.calendrier.getAjustementAstrologique(heureNaissance);
ChatMessage.create({
content: `A l'heure ${game.system.rdd.calendrier.getCurrentHeure()}, le modificateur de Chance/Malchance pour l'heure de naissance ${heureNaissance} est de : ${ajustement}.`,
whisper: ChatMessage.getWhisperRecipients("GM")
});
}
else {
ui.notifications.warn("Pas d'heure de naissance selectionnée")
}
}
/*-------------------------------------------- */
static checkThanatosXP(compName) {
if (compName.includes('Thanatos')) {
let message = "Vous avez mis des points d'Expérience dans la Voie de Thanatos !
Vous devez réduire manuellement d'un même montant d'XP une autre compétence Draconique.";
ChatMessage.create({
whisper: ChatMessage.getWhisperRecipients(game.user.name),
content: message
});
}
}
/*-------------------------------------------- */
static distribuerStress(stressValue, raison = 'Inconnu', nomJoueur = undefined) {
if (game.user.isGM) {
if (nomJoueur == undefined) {
for (let actor of game.actors) {
if (actor.hasPlayerOwner) {
actor.addCompteurValue('stress', stressValue, raison);
ui.notifications.info(`${actor.name} a reçu ${stressValue} points de Stress (raison : ${raison})`);
}
}
} else {
//console.log(stressValue, nomJoueur);
let joueur = game.users.find(user => user.name.toLowerCase() == nomJoueur.toLowerCase());
//console.log("Player", joueur, joueur.character );
joueur.character.addCompteurValue('stress', stressValue, raison);
ui.notifications.info(`${joueur.character.name} a reçu ${stressValue} points de Stress (raison : ${raison})`);
}
} else {
ui.notifications.warn("Seul le MJ est autorisé à utiliser la commande /stress");
}
}
/*-------------------------------------------- */
static async onRenderChatMessage(app, html, msg) {
// TODO
//console.log(app, html, msg);
}
}