Merge pull request 'Version 12.0.15' (#715) from VincentVk/foundryvtt-reve-de-dragon:v11 into v11

Reviewed-on: #715

changelog.md

@@ -1,4 +1,42 @@
 # 12.0
+## 12.0.15 - Le messager d'Astrobazzarh
+- Correction des faces de dés personalisés dice-so-nice
+- Les messages de maladies ne sont plus publics
+- Les messages privés dans les TMR sont aussi envoyés au GM
+- Les informations de compétences pouvant augmenter s'affichent comme tooltips
+- Amélioration du rendu des tables de compendiums (commande /table)
+
+## 12.0.14 - Les légions d'Astrobazzarh
+- Feuille de PNJ:
+  - boutons standard (encaissement, ...)
+  - boutons pour ajuster les compteurs
+  - visualisation des blessures
+  - click sur blessure pour ajouter/enlever
+  - gestion des armes
+
+## 12.0.13 - La Chance d'Astrobazzarh
+- Fix: jets de caractéristiques
+
+## 12.0.12 - L'étalage d'Astrobazzarh
+- Fix: On peut de nouveau vendre des items sans propriétaire, depuis les compendiums ou depuis l'onglet des Objets
+- Début de Feuille PNJ au format des encarts Scriptarium
+  - support des jets de caractéristiques
+  - support des jets de compétences
+
+## 12.0.11 - Le scriptorium d'Astrobazzarh
+- ajout d'un bouton pour générer les éléments de description d'un personnage
+- ajout du logo en background dans la liste des systèmes Foundry
+- ajout d'un champ pour le métier
+- export scriptarium
+  - encodage de l'export en windows-1252
+  - export de l'esquive avec armure et sans armure
+
+## 12.0.10 - Le scriptorium d'Astrobazzarh
+- corrections de l'export scriptarium
+
+## 12.0.9 - Le scriptorium d'Astrobazzarh
+- ajout d'une fonction avancée pour exporter les personnages dans un format csv
+
 ## 12.0.8 - La quincaillerie d'Astrobazzarh
 - le propriétaire est indiqué dans les feuilles d'équipements/compétences/...
 - Ecaille d'efficacité

module/achat-vente/dialog-item-vente.js

@@ -9,7 +9,7 @@ export class DialogItemVente extends Dialog {
     const venteData = {
       item: item,
       alias: item.actor?.name ?? game.user.name,
-      vendeurId: item.actor.id,
+      vendeurId: item.actor?.id,
       prixOrigine: item.calculerPrixCommercant(),
       prixUnitaire: item.calculerPrixCommercant(),
       prixLot: item.calculerPrixCommercant(),

module/actor-sheet.js

@@ -17,6 +17,7 @@ import { RdDItemBlessure } from "./item/blessure.js";
 import { RdDEmpoignade } from "./rdd-empoignade.js";
 import { RdDBaseActorSangSheet } from "./actor/base-actor-sang-sheet.js";
 import { RdDCoeur } from "./coeur/rdd-coeur.js";
+import { AppPersonnageAleatoire } from "./actor/random/app-personnage-aleatoire.js";
 
 /* -------------------------------------------- */
 /**
@@ -127,7 +128,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
       this.render(true);
     });
 
-    this.html.find('.visu-tmr').click(async event => this.actor.displayTMR("visu"))
+    this.html.find('.button-tmr-visu').click(async event => this.actor.displayTMR("visu"))
 
     // Everything below here is only needed if the sheet is editable
     if (!this.options.editable) return;
@@ -185,7 +186,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
     this.html.find('.item-equip').click(async event => this.actor.equiperObjet(RdDSheetUtility.getItemId(event)))
     this.html.find('.chance-actuelle').click(async event => this.actor.rollCarac('chance-actuelle'))
 
-    this.html.find('.chance-appel').click(async event => this.actor.rollAppelChance())
+    this.html.find('.button-appel-chance').click(async event => this.actor.rollAppelChance())
 
     this.html.find('[name="jet-astrologie"]').click(async event => this.actor.astrologieNombresAstraux())
     this.html.find('.tache-label a').click(async event => this.actor.rollTache(RdDSheetUtility.getItemId(event)))
@@ -198,6 +199,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
     this.html.find('.jeu-label a').click(async event => this.actor.rollJeu(RdDSheetUtility.getItemId(event)))
     this.html.find('.recettecuisine-label a').click(async event => this.actor.rollRecetteCuisine(RdDSheetUtility.getItemId(event)))
 
+    this.html.find('.description-aleatoire').click(async event => new AppPersonnageAleatoire(this.actor).render(true))
     if (game.user.isGM) {
       // experience log
       this.html.find('.experiencelog-delete').click(async event => {
@@ -216,9 +218,9 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
     }
 
     // Points de reve actuel
-    this.html.find('.ptreve-actuel a').click(async event => this.actor.rollCarac('reve-actuel', true))
+    this.html.find('.roll-reve-actuel').click(async event => this.actor.rollCarac('reve-actuel', true))
     this.html.find('.empoignade-label a').click(async event => RdDEmpoignade.onAttaqueEmpoignadeFromItem(RdDSheetUtility.getItem(event, this.actor)))
-    this.html.find('.arme-label a').click(async event => this.actor.rollArme(foundry.utils.duplicate(this._getEventArmeCombat(event))))
+    this.html.find('.roll-arme').click(async event => this.actor.rollArme(foundry.utils.duplicate(this._getEventArmeCombat(event))))
 
     // Initiative pour l'arme
     this.html.find('.arme-initiative a').click(async event => {
@@ -232,10 +234,10 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
     });
     // Display TMR
 
-    this.html.find('.monte-tmr').click(async event => this.actor.displayTMR("normal"))
-    this.html.find('.monte-tmr-rapide').click(async event => this.actor.displayTMR("rapide"))
+    this.html.find('.button-tmr').click(async event => this.actor.displayTMR("normal"))
+    this.html.find('.button-tmr-rapide').click(async event => this.actor.displayTMR("rapide"))
 
-    this.html.find('.repos').click(async event => await this.actor.repos())
+    this.html.find('.button-repos').click(async event => await this.actor.repos())
 
     this.html.find('.carac-xp-augmenter').click(async event => this.actor.updateCaracXPAuto(event.currentTarget.name.replace("augmenter.", "")))
     this.html.find('.competence-xp-augmenter').click(async event => this.actor.updateCompetenceXPAuto(RdDSheetUtility.getItemId(event)))
@@ -277,7 +279,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
     this.html.find('.moral-malheureux').click(async event => this.actor.jetDeMoral('malheureuse'))
     this.html.find('.moral-neutre').click(async event => this.actor.jetDeMoral('neutre'))
     this.html.find('.moral-heureux').click(async event => this.actor.jetDeMoral('heureuse'))
-    this.html.find('.ethylisme-test').click(async event => this.actor.jetEthylisme())
+    this.html.find('.button-ethylisme').click(async event => this.actor.jetEthylisme())
 
     this.html.find('.ptreve-actuel-plus').click(async event => this.actor.reveActuelIncDec(1))
     this.html.find('.ptreve-actuel-moins').click(async event => this.actor.reveActuelIncDec(-1))

module/actor.js

@@ -32,7 +32,7 @@ import { RdDItemBlessure } from "./item/blessure.js";
 import { AppAstrologie } from "./sommeil/app-astrologie.js";
 import { RdDEmpoignade } from "./rdd-empoignade.js";
 import { ExperienceLog, XP_TOPIC } from "./actor/experience-log.js";
-import { TYPES } from "./item.js";
+import { ITEM_TYPES } from "./item.js";
 import { RdDBaseActorSang } from "./actor/base-actor-sang.js";
 import { RdDCoeur } from "./coeur/rdd-coeur.js";
 import { DialogChoixXpCarac } from "./dialog-choix-xp-carac.js";
@@ -92,7 +92,7 @@ export class RdDActor extends RdDBaseActorSang {
 
   /* -------------------------------------------- */
   canReceive(item) {
-    return ![TYPES.competencecreature, TYPES.tarot, TYPES.service].includes(item.type)
+    return ![ITEM_TYPES.competencecreature, ITEM_TYPES.tarot, ITEM_TYPES.service].includes(item.type)
   }
 
   isPersonnageJoueur() {
@@ -125,7 +125,7 @@ export class RdDActor extends RdDBaseActorSang {
 
   /* -------------------------------------------- */
   getMalusArmure() {
-    return this.itemTypes[TYPES.armure].filter(it => it.system.equipe)
+    return this.itemTypes[ITEM_TYPES.armure].filter(it => it.system.equipe)
       .map(it => it.system.malus)
       .reduce(Misc.sum(), 0);
   }
@@ -142,7 +142,7 @@ export class RdDActor extends RdDBaseActorSang {
 
   /* -------------------------------------------- */
   getDemiReve() { return this.system.reve.tmrpos.coord }
-  getDraconicList() { return this.itemTypes[TYPES.competence].filter(it => it.system.categorie == 'draconic') }
+  getDraconicList() { return this.itemTypes[ITEM_TYPES.competence].filter(it => it.system.categorie == 'draconic') }
   getBestDraconic() { return foundry.utils.duplicate(this.getDraconicList().sort(Misc.descending(it => it.system.niveau)).find(it => true)) }
   getDraconicOuPossession() {
     return [...this.getDraconicList().filter(it => it.system.niveau >= 0),
@@ -153,13 +153,13 @@ export class RdDActor extends RdDBaseActorSang {
 
   /* -------------------------------------------- */
   async $perteRevePotionsEnchantees() {
-    let potions = this.itemTypes[TYPES.potion]
+    let potions = this.itemTypes[ITEM_TYPES.potion]
       .filter(it => Grammar.includesLowerCaseNoAccent(it.system.categorie, 'enchanté') && !it.system.prpermanent)
 
     const potionUpdates = await Promise.all(potions.map(async it => {
       const nouveauReve = Math.max(it.system.pr - 1, 0)
       ChatMessage.create({
-        whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+        whisper: ChatUtility.getOwners(this),
         content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-potionenchantee-chateaudormant.html`, {
           pr: nouveauReve,
           alias: this.name,
@@ -210,7 +210,7 @@ export class RdDActor extends RdDBaseActorSang {
   /* -------------------------------------------- */
   async grisReve(nbJours) {
     let message = {
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+      whisper: ChatUtility.getOwners(this),
       content: `${nbJours} jours de gris rêve sont passés. `
     };
     for (let i = 0; i < nbJours; i++) {
@@ -264,7 +264,7 @@ export class RdDActor extends RdDBaseActorSang {
   async dormirChateauDormant() {
     if (!ReglesOptionnelles.isUsing("chateau-dormant-gardien") || !this.system.sommeil || this.system.sommeil.nouveaujour) {
       const message = {
-        whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+        whisper: ChatUtility.getOwners(this),
         content: ""
       };
 
@@ -345,7 +345,7 @@ export class RdDActor extends RdDBaseActorSang {
   /* -------------------------------------------- */
   async _recupererBlessures(message, isMaladeEmpoisonne) {
     const timestamp = game.system.rdd.calendrier.getTimestamp()
-    const blessures = this.filterItems(it => it.system.gravite > 0, TYPES.blessure).sort(Misc.ascending(it => it.system.gravite))
+    const blessures = this.filterItems(it => it.system.gravite > 0, ITEM_TYPES.blessure).sort(Misc.ascending(it => it.system.gravite))
 
     await Promise.all(blessures.map(async b => b.recuperationBlessure({
       actor: this,
@@ -361,7 +361,7 @@ export class RdDActor extends RdDBaseActorSang {
   /* -------------------------------------------- */
   async _recupererVie(message, isMaladeEmpoisonne) {
     const tData = this.system
-    let blessures = this.filterItems(it => it.system.gravite > 0, TYPES.blessure);
+    let blessures = this.filterItems(it => it.system.gravite > 0, ITEM_TYPES.blessure);
     if (blessures.length > 0) {
       return
     }
@@ -400,7 +400,7 @@ export class RdDActor extends RdDBaseActorSang {
   /* -------------------------------------------- */
   async remiseANeuf() {
     ChatMessage.create({
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+      whisper: ChatUtility.getOwners(this),
       content: 'Remise à neuf de ' + this.name
     });
     await this.supprimerBlessures(it => true);
@@ -417,7 +417,7 @@ export class RdDActor extends RdDBaseActorSang {
   /* -------------------------------------------- */
   async dormir(heures, options = { grisReve: false, chateauDormant: false }) {
     const message = {
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+      whisper: ChatUtility.getOwners(this),
       content: this.name + ': '
     };
     const insomnie = this.system.sommeil?.insomnie || heures == 0;
@@ -488,7 +488,7 @@ export class RdDActor extends RdDBaseActorSang {
       else {
         if (!ReglesOptionnelles.isUsing("recuperation-reve")) {
           ChatMessage.create({
-            whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+            whisper: ChatUtility.getOwners(this),
             content: `Pas de récupération de rêve (${reve} points ignorés)`
           });
           jetsReve.push(0);
@@ -636,7 +636,7 @@ export class RdDActor extends RdDBaseActorSang {
   /* -------------------------------------------- */
   async sortMisEnReserve(sort, draconic, coord, ptreve) {
     await this.createEmbeddedDocuments("Item", [{
-      type: TYPES.sortreserve,
+      type: ITEM_TYPES.sortreserve,
       name: sort.name,
       img: sort.img,
       system: { sortid: sort._id, draconic: (draconic?.name ?? sort.system.draconic), ptreve: ptreve, coord: coord, heurecible: 'Vaisseau' }
@@ -919,7 +919,7 @@ export class RdDActor extends RdDBaseActorSang {
     await this.createEmbeddedDocuments('Item', [souffle]);
     if (options.chat) {
       ChatMessage.create({
-        whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+        whisper: ChatUtility.getOwners(this),
         content: this.name + " subit un Souffle de Dragon  : " + souffle.name
       });
     }
@@ -939,7 +939,7 @@ export class RdDActor extends RdDBaseActorSang {
     await this.createEmbeddedDocuments('Item', [queue]);
     if (options.chat) {
       ChatMessage.create({
-        whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+        whisper: ChatUtility.getOwners(this),
         content: this.name + " subit une Queue de Dragon : " + queue.name
       });
     }
@@ -977,7 +977,7 @@ export class RdDActor extends RdDBaseActorSang {
     let tmr = await TMRUtility.getTMRAleatoire(tmr => accessible(tmr) && !innaccessible.includes(tmr.coord));
     ChatMessage.create({
       content: `${raison} : ré-insertion aléatoire.`,
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name)
+      whisper: ChatUtility.getOwners(this)
     });
     await this.forcerPositionTMRInconnue(tmr);
     return tmr;
@@ -991,24 +991,24 @@ export class RdDActor extends RdDBaseActorSang {
 
   /* -------------------------------------------- */
   buildTMRInnaccessible() {
-    return this.items.filter(it => it.type == TYPES.casetmr).filter(it => EffetsDraconiques.isInnaccessible(it)).map(it => it.system.coord)
+    return this.items.filter(it => it.type == ITEM_TYPES.casetmr).filter(it => EffetsDraconiques.isInnaccessible(it)).map(it => it.system.coord)
   }
 
   /* -------------------------------------------- */
   getRencontresTMR() {
-    return this.itemTypes[TYPES.rencontre];
+    return this.itemTypes[ITEM_TYPES.rencontre];
   }
 
   /* -------------------------------------------- */
   async deleteRencontreTMRAtPosition() {
-    const rencontreIds = this.itemTypes[TYPES.rencontre].filter(this.filterRencontreTMRDemiReve()).map(it => it.id)
+    const rencontreIds = this.itemTypes[ITEM_TYPES.rencontre].filter(this.filterRencontreTMRDemiReve()).map(it => it.id)
     if (rencontreIds.length > 0) {
       await this.deleteEmbeddedDocuments('Item', rencontreIds)
     }
   }
 
   getRencontreTMREnAttente() {
-    return this.itemTypes[TYPES.rencontre].find(this.filterRencontreTMRDemiReve())
+    return this.itemTypes[ITEM_TYPES.rencontre].find(this.filterRencontreTMRDemiReve())
   }
 
   filterRencontreTMRDemiReve() {
@@ -1082,7 +1082,7 @@ export class RdDActor extends RdDBaseActorSang {
     const jetMoral = await this._jetDeMoral(situation);
     const finMessage = (jetMoral.succes ? messageReussi : messageManque) ?? (jetMoral.ajustement == 0 ? "Vous gardez votre moral" : jetMoral.ajustement > 0 ? "Vous gagnez du moral" : "Vous perdez du moral");
     ChatMessage.create({
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+      whisper: ChatUtility.getOwners(this),
       content: `${finMessage} - jet ${jetMoral.succes ? "réussi" : "manqué"} en situation ${situation} (${jetMoral.jet}/${jetMoral.difficulte}).`
     });
     return jetMoral.ajustement;
@@ -1160,11 +1160,11 @@ export class RdDActor extends RdDBaseActorSang {
     if (result) { return result }
 
     switch (item.type) {
-      case TYPES.potion: return await this.consommerPotion(item, onActionItem);
-      case TYPES.livre: return await this.actionLire(item);
-      case TYPES.conteneur: return await item.sheet.render(true);
-      case TYPES.herbe: return await this.actionHerbe(item, onActionItem);
-      case TYPES.queue: case TYPES.ombre: return await this.actionRefoulement(item);
+      case ITEM_TYPES.potion: return await this.consommerPotion(item, onActionItem);
+      case ITEM_TYPES.livre: return await this.actionLire(item);
+      case ITEM_TYPES.conteneur: return await item.sheet.render(true);
+      case ITEM_TYPES.herbe: return await this.actionHerbe(item, onActionItem);
+      case ITEM_TYPES.queue: case ITEM_TYPES.ombre: return await this.actionRefoulement(item);
     }
     return undefined
   }
@@ -1419,7 +1419,7 @@ export class RdDActor extends RdDBaseActorSang {
     };
 
     ChatMessage.create({
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+      whisper: ChatUtility.getOwners(this),
       content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-resultat-transformer-stress.html`, stressRollData)
     });
 
@@ -1505,7 +1505,7 @@ export class RdDActor extends RdDBaseActorSang {
         }
         if (display) {
           ChatMessage.create({
-            whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+            whisper: ChatUtility.getOwners(this),
             content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-carac-xp.html`, checkXp)
           });
         }
@@ -1537,7 +1537,7 @@ export class RdDActor extends RdDBaseActorSang {
         }
         if (display) {
           ChatMessage.create({
-            whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+            whisper: ChatUtility.getOwners(this),
             content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-competence-xp.html`, checkXp)
           });
         }
@@ -1559,11 +1559,11 @@ export class RdDActor extends RdDBaseActorSang {
         xpData
       })
       if (hideChatMessage) {
-        ChatUtility.blindMessageToGM({ content: content });
+        ChatUtility.blindMessageToGM({ content: content })
       }
       else {
         ChatMessage.create({
-          whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+          whisper: ChatUtility.getOwners(this),
           content: content
         });
       }
@@ -1602,7 +1602,7 @@ export class RdDActor extends RdDBaseActorSang {
   computeDraconicAndSortIndex(sortList) {
     let draconicList = this.getDraconicList();
     for (let sort of sortList) {
-      let draconicsSort = this.getDraconicsSort(draconicList, sort).map(it => it.name);
+      let draconicsSort = RdDItemSort.getDraconicsSort(draconicList, sort).map(it => it.name);
       for (let index = 0; index < draconicList.length && sort.system.listIndex == undefined; index++) {
         if (draconicsSort.includes(draconicList[index].name)) {
           sort.system.listIndex = index;
@@ -1612,19 +1612,6 @@ export class RdDActor extends RdDBaseActorSang {
     return draconicList;
   }
 
-  /* -------------------------------------------- */
-  getDraconicsSort(draconicList, sort) {
-    //console.log(draconicList, bestDraconic, draconic, voie);
-    switch (Grammar.toLowerCaseNoAccent(sort.name)) {
-      case "lecture d'aura":
-      case "detection d'aura":
-        return draconicList;
-      case "annulation de magie":
-        return draconicList.filter(it => !RdDItemCompetence.isThanatos(it));
-    }
-    return [RdDItemCompetence.getVoieDraconic(draconicList, sort.system.draconic)];
-  }
-
   /* -------------------------------------------- */
   async rollUnSort(coord) {
     RdDEmpoignade.checkEmpoignadeEnCours(this)
@@ -1679,7 +1666,7 @@ export class RdDActor extends RdDBaseActorSang {
       }
       ChatMessage.create({
         content: "Vous êtes sous le coup d'une Mauvaise Rencontre en Persective." + addMsg,
-        whisper: ChatMessage.getWhisperRecipients(this.name)
+        whisper: ChatUtility.getOwners(this)
       });
     }
     return rencSpecial;
@@ -1691,7 +1678,7 @@ export class RdDActor extends RdDBaseActorSang {
     if (countInertieDraconique > 0) {
       ChatMessage.create({
         content: `Vous êtes sous le coup d'Inertie Draconique : vous perdrez ${countInertieDraconique + 1} cases de Fatigue par déplacement au lieu d'une.`,
-        whisper: ChatMessage.getWhisperRecipients(this.name)
+        whisper: ChatUtility.getOwners(this)
       });
     }
     return countInertieDraconique + 1;
@@ -1703,7 +1690,7 @@ export class RdDActor extends RdDBaseActorSang {
       await this.reveActuelIncDec(-1);
       ChatMessage.create({
         content: "Vous êtes sous le coup d'un Péage : l'entrée sur cette case vous a coûté 1 Point de Rêve (déduit automatiquement).",
-        whisper: ChatMessage.getWhisperRecipients(this.name)
+        whisper: ChatUtility.getOwners(this)
       });
     }
   }
@@ -1826,7 +1813,7 @@ export class RdDActor extends RdDBaseActorSang {
   }
 
   blessuresASoigner() {
-    return (this.itemTypes[TYPES.blessure])
+    return (this.itemTypes[ITEM_TYPES.blessure])
       .filter(it => it.system.gravite > 0 && it.system.gravite <= 6)
       .filter(it => !(it.system.premierssoins.done && it.system.soinscomplets.done))
       .sort(Misc.descending(b => (b.system.premierssoins.done ? "A" : "B") + b.system.gravite))
@@ -2283,7 +2270,7 @@ export class RdDActor extends RdDBaseActorSang {
       // Cas de désir lancinant, pas d'expérience sur particulière
       ChatMessage.create({
         content: `Vous souffrez au moins d'un Désir Lancinant, vous ne pouvez pas gagner d'expérience sur une Particulière tant que le désir n'est pas assouvi`,
-        whisper: ChatMessage.getWhisperRecipients(this.name)
+        whisper: ChatUtility.getOwners(this)
       });
       return []
     }
@@ -2418,7 +2405,7 @@ export class RdDActor extends RdDBaseActorSang {
     if (countMonteeLaborieuse > 0) {
       ChatMessage.create({
         content: `Vous êtes sous le coup d'une Montée Laborieuse : vos montées en TMR coûtent ${countMonteeLaborieuse} Point de Rêve de plus.`,
-        whisper: ChatMessage.getWhisperRecipients(this.name)
+        whisper: ChatUtility.getOwners(this)
       });
     }
     return countMonteeLaborieuse;
@@ -2466,7 +2453,7 @@ export class RdDActor extends RdDBaseActorSang {
       if (this.getReveActuel() < minReveValue) {
         ChatMessage.create({
           content: `Vous n'avez les ${minReveValue} Points de Reve nécessaires pour monter dans les Terres Médianes`,
-          whisper: ChatMessage.getWhisperRecipients(this.name)
+          whisper: ChatUtility.getOwners(this)
         });
         return;
       }
@@ -2863,7 +2850,7 @@ export class RdDActor extends RdDBaseActorSang {
       await this.setBonusPotionSoin(potionData.system.herbebonus);
     }
     ChatMessage.create({
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+      whisper: ChatUtility.getOwners(this),
       content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-consommer-potion-soin.html`, potionData)
     });
   }
@@ -2900,7 +2887,7 @@ export class RdDActor extends RdDBaseActorSang {
       this.bonusRepos = potionData.system.herbebonus;
     }
     ChatMessage.create({
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+      whisper: ChatUtility.getOwners(this),
       content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-consommer-potion-repos.html`, potionData)
     });
   }
@@ -2932,7 +2919,7 @@ export class RdDActor extends RdDBaseActorSang {
     this.diminuerQuantiteObjet(herbeData._id, herbeData.nbBrins);
 
     ChatMessage.create({
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+      whisper: ChatUtility.getOwners(this),
       content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-fabriquer-potion-base.html`, messageData)
     });
   }
@@ -2957,7 +2944,7 @@ export class RdDActor extends RdDBaseActorSang {
       }
     }
     ChatMessage.create({
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+      whisper: ChatUtility.getOwners(this),
       content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-consommer-potion-generique.html`, potionData)
     });
   }
@@ -3057,7 +3044,7 @@ export class RdDActor extends RdDBaseActorSang {
   /* -------------------------------------------- */
   notifyGestionTeteSouffleQueue(item, manualMessage = true) {
     ChatMessage.create({
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+      whisper: ChatUtility.getOwners(this),
       content: `${this.name} a reçu un/une ${item.type}: ${item.name}, qui ${manualMessage ? "n'est pas" : "est"} géré(e) automatiquement. ${manualMessage ? manualMessage : ''}`
     });
   }
@@ -3065,7 +3052,7 @@ export class RdDActor extends RdDBaseActorSang {
   async nouvelleIncarnation() {
     let incarnation = this.toObject();
 
-    incarnation.items = Array.from(this.items.filter(it => it.type == TYPES.competence),
+    incarnation.items = Array.from(this.items.filter(it => it.type == ITEM_TYPES.competence),
       it => {
         it = it.toObject();
         it.id = undefined;
@@ -3080,7 +3067,7 @@ export class RdDActor extends RdDBaseActorSang {
     incarnation.name = 'Réincarnation de ' + incarnation.name
     incarnation.system = {
       carac: foundry.utils.duplicate(this.system.carac),
-      heure: RdDTimestamp.defHeure(await RdDDice.rollTotal("1dh", { rollMode: "selfroll", showDice: SHOW_DICE })).key,
+      heure: RdDTimestamp.defHeure(await RdDDice.rollHeure( { rollMode: "selfroll", showDice: SHOW_DICE })).key,
       age: 18,
       biographie: '',
       notes: '',

module/actor/base-actor-reve-sheet.js

@@ -24,14 +24,15 @@ export class RdDBaseActorReveSheet extends RdDBaseActorSheet {
     // Everything below here is only needed if the sheet is editable
     if (!this.options.editable) return;
 
-    this.html.find('.encaisser-direct').click(async event => this.actor.encaisser())
-    this.html.find('.carac-label a').click(async event => this.actor.rollCarac(Grammar.toLowerCaseNoAccent(event.currentTarget.attributes.name.value)));
-    this.html.find('a.competence-label').click(async event => this.actor.rollCompetence(RdDSheetUtility.getItemId(event)));
+    this.html.find('.button-encaissement').click(async event => this.actor.encaisser())
+    this.html.find('.roll-carac').click(async event => {
+      this.actor.rollCarac(Grammar.toLowerCaseNoAccent(event.currentTarget.attributes['data-carac-name'].value))});
+    this.html.find('.roll-competence').click(async event => this.actor.rollCompetence(RdDSheetUtility.getItemId(event)));
     this.html.find('.endurance-plus').click(async event => this.actor.santeIncDec("endurance", 1));
     this.html.find('.endurance-moins').click(async event => this.actor.santeIncDec("endurance", -1));
 
     if (game.user.isGM) {
-      this.html.find('.remise-a-neuf').click(async event => this.actor.remiseANeuf())
+      this.html.find('.button-remise-a-neuf').click(async event => this.actor.remiseANeuf())
       this.html.find('.delete-active-effect').click(async event => this.actor.removeEffect(this.html.find(event.currentTarget).parents(".active-effect").data('effect')));
       this.html.find('.enlever-tous-effets').click(async event => await this.actor.removeEffects());
     }

module/actor/base-actor-reve.js

@@ -12,7 +12,7 @@ import { ReglesOptionnelles } from "../settings/regles-optionnelles.js";
 import { RdDBaseActor } from "./base-actor.js";
 import { RdDItemCompetenceCreature } from "../item-competencecreature.js";
 import { StatusEffects } from "../settings/status-effects.js";
-import { TYPES } from "../item.js";
+import { ITEM_TYPES } from "../item.js";
 import { Targets } from "../targets.js";
 import { RdDPossession } from "../rdd-possession.js";
 import { RdDCombat } from "../rdd-combat.js";
@@ -108,14 +108,14 @@ export class RdDBaseActorReve extends RdDBaseActor {
 
   async $finDeRoundSupprimerObsoletes() {
     const obsoletes = []
-      .concat(this.itemTypes[TYPES.empoignade].filter(it => it.system.pointsemp <= 0))
-      .concat(this.itemTypes[TYPES.possession].filter(it => it.system.compteur < -2 || it.system.compteur > 2))
+      .concat(this.itemTypes[ITEM_TYPES.empoignade].filter(it => it.system.pointsemp <= 0))
+      .concat(this.itemTypes[ITEM_TYPES.possession].filter(it => it.system.compteur < -2 || it.system.compteur > 2))
       .map(it => it.id);
     await this.deleteEmbeddedDocuments('Item', obsoletes);
   }
 
   async $finDeRoundEmpoignade() {
-    const immobilisations = this.itemTypes[TYPES.empoignade].filter(it => it.system.pointsemp >= 2 && it.system.empoigneurid == this.id);
+    const immobilisations = this.itemTypes[ITEM_TYPES.empoignade].filter(it => it.system.pointsemp >= 2 && it.system.empoigneurid == this.id);
     immobilisations.forEach(emp => RdDEmpoignade.onImmobilisation(this,
       game.actors.get(emp.system.empoigneid),
       emp
@@ -151,13 +151,13 @@ export class RdDBaseActorReve extends RdDBaseActor {
   }
 
   getPossession(possessionId) {
-    return this.itemTypes[TYPES.possession].find(it => it.system.possessionid == possessionId);
+    return this.itemTypes[ITEM_TYPES.possession].find(it => it.system.possessionid == possessionId);
   }
   getPossessions() {
-    return this.itemTypes[TYPES.possession];
+    return this.itemTypes[ITEM_TYPES.possession];
   }
   getEmpoignades() {
-    return this.itemTypes[TYPES.empoignade];
+    return this.itemTypes[ITEM_TYPES.empoignade];
   }
 
   /* -------------------------------------------- */
@@ -189,7 +189,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
   getEffect(effectId) {
     return this.getEmbeddedCollection("ActiveEffect").find(it => it.statuses?.has(effectId));
   }
-  
+
   async setEffect(effectId, status) {
     if (this.isEffectAllowed(effectId)) {
       const effect = this.getEffect(effectId);
@@ -201,7 +201,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
       }
     }
   }
-  
+
   async removeEffect(id) {
     const effect = this.getEmbeddedCollection("ActiveEffect").find(it => it.id == id);
     if (effect) {
@@ -296,8 +296,12 @@ export class RdDBaseActorReve extends RdDBaseActor {
 
   /* -------------------------------------------- */
   async rollCarac(caracName, jetResistance = undefined) {
+    if (Grammar.equalsInsensitive(caracName, 'taille')) {
+      return
+    }
     RdDEmpoignade.checkEmpoignadeEnCours(this)
     let selectedCarac = this.getCaracByName(caracName)
+    console.log("selectedCarac", selectedCarac)
     await this.openRollDialog({
       name: 'jet-' + caracName,
       label: 'Jet ' + Grammar.apostrophe('de', selectedCarac.label),
@@ -322,7 +326,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
     RdDEmpoignade.checkEmpoignadeEnCours(this)
     const competence = this.getCompetence(idOrName);
     let rollData = { carac: this.system.carac, competence: competence, arme: options.arme }
-    if (competence.type == TYPES.competencecreature) {
+    if (competence.type == ITEM_TYPES.competencecreature) {
       const arme = RdDItemCompetenceCreature.armeCreature(competence)
       if (arme && options.tryTarget && Targets.hasTargets()) {
         Targets.selectOneToken(target => {
@@ -396,19 +400,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
   }
 
   $getCompetenceArme(arme, competenceName) {
-    switch (arme.type) {
-      case TYPES.competencecreature:
-        return arme.name
-      case TYPES.arme:
-        switch (competenceName) {
-          case 'competence': return arme.system.competence;
-          case 'unemain': return RdDItemArme.competence1Mains(arme);
-          case 'deuxmains': return RdDItemArme.competence2Mains(arme);
-          case 'tir': return arme.system.tir;
-          case 'lancer': return arme.system.lancer;
-        }
-    }
-    return undefined
+    return RdDItemArme.getCompetenceArme(arme, competenceName)
   }
 
   verifierForceMin(item) {
@@ -426,9 +418,9 @@ export class RdDBaseActorReve extends RdDBaseActor {
       return;
     }
     const armure = await this.computeArmure(rollData);
-    if (ReglesOptionnelles.isUsing('validation-encaissement-gr')){
+    if (ReglesOptionnelles.isUsing('validation-encaissement-gr')) {
       await this.encaisserDommagesValidationGR(rollData, armure, attacker?.id, show);
-    } 
+    }
     else {
       const jet = await RdDUtility.jetEncaissement(rollData, armure, { showDice: SHOW_DICE });
       await this.$onEncaissement(jet, show, attacker);
@@ -464,16 +456,19 @@ export class RdDBaseActorReve extends RdDBaseActor {
       show: show ?? {}
     });
 
-    await ChatUtility.createChatWithRollMode(this.name, {
-      roll: encaissement.roll,
-      content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-resultat-encaissement.html', encaissement)
-    });
+    await ChatUtility.createChatWithRollMode(
+      {
+        roll: encaissement.roll,
+        content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-resultat-encaissement.html', encaissement)
+      },
+      this
+    )
 
     if (!encaissement.hasPlayerOwner && encaissement.endurance != 0) {
-      encaissement = foundry.utils.duplicate(encaissement);
-      encaissement.isGM = true;
+      encaissement = foundry.utils.duplicate(encaissement)
+      encaissement.isGM = true
       ChatMessage.create({
-        whisper: ChatMessage.getWhisperRecipients("GM"),
+        whisper: ChatUtility.getGMs(),
         content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-resultat-encaissement.html', encaissement)
       });
     }

module/actor/base-actor-sang-sheet.js

@@ -39,8 +39,8 @@ export class RdDBaseActorSangSheet extends RdDBaseActorReveSheet {
     ChatMessage.create({
       content: `Jet d'Endurance : ${result.jetEndurance} / ${endurance}
         <br>${this.actor.name} a ${result.sonne ? 'échoué' : 'réussi'} son Jet d'Endurance ${result.sonne ? 'et devient Sonné' : ''}`,
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.actor.name)
-    });
+      whisper: ChatUtility.getOwners(this.actor)
+    })
   }
 
 }

module/actor/base-actor-sang.js

@@ -1,10 +1,11 @@
 import { MAX_ENDURANCE_FATIGUE, RdDUtility } from "../rdd-utility.js";
 import { ReglesOptionnelles } from "../settings/regles-optionnelles.js";
 import { STATUSES } from "../settings/status-effects.js";
-import { TYPES } from "../item.js";
+import { ITEM_TYPES } from "../item.js";
 import { RdDBaseActorReve } from "./base-actor-reve.js";
 import { RdDDice } from "../rdd-dice.js";
 import { RdDItemBlessure } from "../item/blessure.js";
+import { ChatUtility } from "../chat-utility.js";
 
 /**
  * Classe de base pour les acteurs qui peuvent subir des blessures
@@ -50,9 +51,9 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
 
   isDead() { return this.system.sante.vie.value < -this.getSConst() }
 
-  nbBlessuresLegeres() { return this.itemTypes[TYPES.blessure].filter(it => it.isLegere()).length }
-  nbBlessuresGraves() { return this.itemTypes[TYPES.blessure].filter(it => it.isGrave()).length }
-  nbBlessuresCritiques() { return this.itemTypes[TYPES.blessure].filter(it => it.isCritique()).length }
+  nbBlessuresLegeres() { return this.itemTypes[ITEM_TYPES.blessure].filter(it => it.isLegere()).length }
+  nbBlessuresGraves() { return this.itemTypes[ITEM_TYPES.blessure].filter(it => it.isGrave()).length }
+  nbBlessuresCritiques() { return this.itemTypes[ITEM_TYPES.blessure].filter(it => it.isCritique()).length }
 
   /* -------------------------------------------- */
   computeResumeBlessure() {
@@ -180,7 +181,7 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
       }
     }
     const endActuelle = this.getEnduranceActuelle();
-    const blessure = await RdDItemBlessure.createBlessure(this, encaissement.gravite, encaissement.dmg.loc.label, attacker);
+    const blessure = await RdDItemBlessure.createBlessure(this, encaissement.gravite, encaissement.dmg?.loc.label ?? '', attacker);
     if (blessure.isCritique()) {
       encaissement.endurance = endActuelle;
     }
@@ -196,20 +197,30 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
     return blessure;
   }
 
+  async supprimerBlessure({ gravite }) {
+    const toDelete = this.itemTypes[ITEM_TYPES.blessure].find(it => it.system.gravite == gravite)?.id
+    if (toDelete) {
+      await this.deleteEmbeddedDocuments('Item', [toDelete]);
+    }
+  }
+
   async supprimerBlessures(filterToDelete) {
-    const toDelete = this.filterItems(filterToDelete, TYPES.blessure)
+    const toDelete = this.filterItems(filterToDelete, ITEM_TYPES.blessure)
       .map(it => it.id);
     await this.deleteEmbeddedDocuments('Item', toDelete);
   }
 
   countBlessures(filter = it => !it.isContusion()) {
-    return this.filterItems(filter, 'blessure').length
+    return this.filterItems(filter, ITEM_TYPES.blessure).length
   }
 
   /* -------------------------------------------- */
   async jetDeVie() {
     if (this.isDead()) {
-      ChatMessage.create({ content: `Jet de Vie: ${this.name} est déjà mort, ce n'est pas la peine d'en rajouter !!!!!`, whisper: ChatMessage.getWhisperRecipients(this.name) });
+      ChatMessage.create({
+        content: `Jet de Vie: ${this.name} est déjà mort, ce n'est pas la peine d'en rajouter !!!!!`,
+        whisper: ChatUtility.getOwners(this)
+      })
       return
     }
     const jetDeVie = await RdDDice.roll("1d20");
@@ -236,7 +247,10 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
     else if (prochainJet > 0) {
       msgText += `<br>Prochain jet de vie dans ${prochainJet} ${isCritique ? 'round' : 'minute'}${prochainJet > 1 ? 's' : ''} ${isCritique ? '(état critique)' : '(état grave)'}`
     }
-    ChatMessage.create({ content: msgText, whisper: ChatMessage.getWhisperRecipients(this.name) });
+    ChatMessage.create({
+      content: msgText,
+      whisper: ChatUtility.getOwners(this)
+    });
   }
 
   /* -------------------------------------------- */

module/actor/base-actor-sheet.js

@@ -3,7 +3,7 @@ import { Misc } from "../misc.js";
 import { DialogSplitItem } from "../dialog-split-item.js";
 import { RdDSheetUtility } from "../rdd-sheet-utility.js";
 import { Monnaie } from "../item-monnaie.js";
-import { RdDItem, TYPES } from "../item.js";
+import { RdDItem, ITEM_TYPES } from "../item.js";
 import { RdDItemCompetenceCreature } from "../item-competencecreature.js";
 
 /* -------------------------------------------- */
@@ -51,7 +51,7 @@ export class RdDBaseActorSheet extends ActorSheet {
     this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.inventaires);
     this._appliquerRechercheObjets(formData.conteneurs, formData.inventaires);
     formData.conteneurs = RdDUtility.conteneursRacine(formData.conteneurs);
-    formData.competences.filter(it => it.type == TYPES.competencecreature)
+    formData.competences.filter(it => it.type == ITEM_TYPES.competencecreature)
       .forEach(it => it.isdommages = RdDItemCompetenceCreature.isDommages(it))
     return formData;
   }

module/actor/base-actor.js

@@ -3,7 +3,7 @@ import { ChatUtility } from "../chat-utility.js";
 import { SYSTEM_SOCKET_ID } from "../constants.js";
 import { Grammar } from "../grammar.js";
 import { Monnaie } from "../item-monnaie.js";
-import { TYPES } from "../item.js";
+import { ITEM_TYPES } from "../item.js";
 import { Misc } from "../misc.js";
 import { RdDAudio } from "../rdd-audio.js";
 import { RdDConfirm } from "../rdd-confirm.js";
@@ -270,6 +270,7 @@ export class RdDBaseActor extends Actor {
     }
     let fortune = this.getFortune();
     console.log("payer", game.user.character, depense, fortune);
+    // TODO: passer en handlebars
     let msg = "";
     if (fortune >= depense) {
       await Monnaie.optimiserFortune(this, fortune - depense);
@@ -279,11 +280,10 @@ export class RdDBaseActor extends Actor {
       msg = "Vous n'avez pas assez d'argent pour payer cette somme !";
     }
 
-    let message = {
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+    ChatMessage.create({
+      whisper: ChatUtility.getOwners(this),
       content: msg
-    };
-    ChatMessage.create(message);
+    })
   }
 
   async depenserSols(sols) {
@@ -317,7 +317,7 @@ export class RdDBaseActor extends Actor {
 
       RdDAudio.PlayContextAudio("argent"); // Petit son
       ChatMessage.create({
-        whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+        whisper: ChatUtility.getOwners(this.name),
         content: `Vous avez reçu <strong>${sols} Sols</strong> ${fromActor ? " de " + fromActor.name : ''}, qui ont été ajoutés à votre argent.`
       });
     }
@@ -371,7 +371,7 @@ export class RdDBaseActor extends Actor {
     ChatMessage.create({
       user: achat.userId,
       speaker: { alias: (acheteur ?? vendeur).name },
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+      whisper: ChatUtility.getOwners(this),
       content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-achat-item.html', chatAchatItem)
     });
 
@@ -542,7 +542,7 @@ export class RdDBaseActor extends Actor {
     // Calculer le total actuel des contenus
     const encContenu = dest.getEncContenu();
     const newEnc = moved.getEncTotal(); // Calculer le total actuel du nouvel objet
-    const placeDisponible = Math.roundDecimals(dest.system.capacite - encContenu - newEnc, 4)
+    const placeDisponible = Misc.keepDecimals(dest.system.capacite - encContenu - newEnc, 4)
 
     // Teste si le conteneur de destination a suffisament de capacité pour recevoir le nouvel objet
     if (placeDisponible < 0) {
@@ -704,7 +704,7 @@ export class RdDBaseActor extends Actor {
 
   async actionPrincipale(item, onActionItem = async () => { }) {
     switch (item.type) {
-      case TYPES.conteneur: return await item.sheet.render(true);
+      case ITEM_TYPES.conteneur: return await item.sheet.render(true);
     }
     return undefined
   }

module/actor/creature.js

@@ -1,5 +1,5 @@
 import { ENTITE_INCARNE } from "../constants.js";
-import { TYPES } from "../item.js";
+import { ITEM_TYPES } from "../item.js";
 import { STATUSES } from "../settings/status-effects.js";
 import { RdDBaseActorSang } from "./base-actor-sang.js";
 
@@ -12,7 +12,7 @@ export class RdDCreature extends RdDBaseActorSang {
   isCreature() { return true }
 
   canReceive(item) {
-    return item.type == TYPES.competencecreature || item.isInventaire();
+    return item.type == ITEM_TYPES.competencecreature || item.isInventaire();
   }
 
   async remiseANeuf() {

module/actor/entite.js

@@ -1,5 +1,5 @@
 import { ENTITE_INCARNE, ENTITE_NONINCARNE } from "../constants.js";
-import { TYPES } from "../item.js";
+import { ITEM_TYPES } from "../item.js";
 import { Misc } from "../misc.js";
 import { RdDEncaisser } from "../rdd-roll-encaisser.js";
 import { STATUSES } from "../settings/status-effects.js";
@@ -12,7 +12,7 @@ export class RdDEntite extends RdDBaseActorReve {
   }
 
   canReceive(item) {
-    return item.type == TYPES.competencecreature
+    return item.type == ITEM_TYPES.competencecreature
   }
 
   isEntite(typeentite = []) {
@@ -29,7 +29,7 @@ export class RdDEntite extends RdDBaseActorReve {
   getChance() { return this.getReve() }
 
   getDraconicOuPossession() {
-    return this.itemTypes[TYPES.competencecreature]
+    return this.itemTypes[ITEM_TYPES.competencecreature]
       .filter(it => it.system.categorie == 'possession')
       .sort(Misc.descending(it => it.system.niveau))
       .find(it => true);

module/actor/export-scriptarium/actor-encart-sheet.js

@@ -0,0 +1,115 @@
+import { RdDActorSheet } from "../../actor-sheet.js"
+import { SYSTEM_RDD } from "../../constants.js";
+import { Misc } from "../../misc.js";
+import { EXPORT_CSV_SCRIPTARIUM, OptionsAvancees } from "../../settings/options-avancees.js";
+import { ExportScriptarium } from "./export-scriptarium.js";
+import { CATEGORIES_COMPETENCES, CATEGORIES_DRACONIC, Mapping } from "./mapping.js";
+
+export class RdDActorExportSheet extends RdDActorSheet {
+  static async init() {
+    await loadTemplates([
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/arme.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessure.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessures.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-compteur.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-derivee.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-derivee-compteur.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/competences.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/esquive.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/fatigue.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/protection.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs",
+    ])
+    Actors.registerSheet(SYSTEM_RDD, RdDActorExportSheet, { types: ["personnage"], makeDefault: false, label: "Feuille simplifiée" })
+  }
+  static get defaultOptions() {
+    return foundry.utils.mergeObject(RdDActorSheet.defaultOptions, {
+      template: "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/actor-encart-sheet.hbs",
+      width: 550,
+      showCompNiveauBase: false,
+      vueArchetype: false,
+    }, { inplace: false })
+  }
+
+  constructor(actor, options) {
+    super(actor, options)
+  }
+
+  async getData() {
+    const formData = await super.getData()
+    // Add any structured, precomputed list of data
+    formData.context = Mapping.prepareContext(this.actor)
+    formData.export = this.getMappingValues(formData.context, this.actor)
+    formData.competences = this.getCompetences(CATEGORIES_COMPETENCES)
+    formData.draconic = this.getCompetences(CATEGORIES_DRACONIC)
+    const legeres = this.actor.nbBlessuresLegeres()
+    const graves = this.actor.nbBlessuresGraves()
+    const critiques = this.actor.nbBlessuresCritiques()
+    formData.etat = {
+      surenc: this.actor.computeMalusSurEncombrement(),
+      fatigue: {
+        value: this.actor.getFatigueActuelle(),
+        max: this.actor.getFatigueMax(),
+        malus: this.actor.malusFatigue()
+      },
+      blessures: legeres + graves + critiques,
+      blessure: [legeres > 0, legeres > 1, legeres > 2, legeres > 3, legeres > 4, graves > 0, graves > 1, critiques > 0],
+    }
+    formData.options.exportScriptarium = OptionsAvancees.isUsing(EXPORT_CSV_SCRIPTARIUM)
+    return formData
+  }
+
+  getMappingValues(context, actor) {
+    return Object.fromEntries(Mapping.getMapping().map(it => [it.column, {
+      colName: it.colName ?? it.column,
+      column: it.column,
+      rollClass: it.rollClass,
+      value: String(it.getter(actor, context))
+    }]))
+  }
+
+  getCompetences(categories) {
+    const competences = Mapping.getCompetencesCategorie(this.actor, categories)
+    if (competences.length == 0) {
+      return ''
+    }
+    const byCategories = Mapping.competencesByCategoriesByNiveau(competences, categories)
+    const listByCategories = Object.values(byCategories)
+      .map(it => it.competencesParNiveau)
+      .map(byNiveau => {
+        const niveaux = Object.keys(byNiveau).map(it => Number(it)).sort(Misc.ascending())
+        if (niveaux.length == 0) {
+          return undefined
+        }
+        const listCategorieByNiveau = niveaux.map(niveau => {
+          const list = byNiveau[niveau].sort(Misc.ascending(it => it.name))
+          return { niveau, list }
+        })
+        return Misc.concat(listCategorieByNiveau)
+      }).filter(it => it != undefined)
+
+    return Misc.concat(listByCategories)
+  }
+
+  activateListeners(html) {
+    super.activateListeners(html);
+
+    this.html.find('.click-blessure-remove').click(async event =>
+      await this.actor.supprimerBlessure({
+        gravite: this.html.find(event.currentTarget).data('gravite')
+      })
+    )
+    this.html.find('.click-blessure-add').click(async event =>
+      await this.actor.ajouterBlessure({
+        gravite: this.html.find(event.currentTarget).data('gravite')
+        // event.currentTarget.attributes['data-gravite'].value
+      })
+    )
+    this.html.find('.button-export').click(async event => {
+      ExportScriptarium.INSTANCE.exportActors([this.actor],
+        `${this.actor.uuid}-${this.actor.name}`
+      )
+    })
+  }
+}

module/actor/export-scriptarium/export-scriptarium.js

@@ -0,0 +1,78 @@
+import { ACTOR_TYPES } from "../../item.js"
+import { Misc } from "../../misc.js"
+import { EXPORT_CSV_SCRIPTARIUM, OptionsAvancees } from "../../settings/options-avancees.js"
+import { Mapping } from "./mapping.js"
+
+const IMG_SCRIPTARIUM = '<img class="context-menu-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/scriptarium.svg">'
+
+export class ExportScriptarium {
+
+  static init() {
+    ExportScriptarium.INSTANCE = new ExportScriptarium()
+  }
+
+  constructor() {
+    Hooks.on("getActorDirectoryFolderContext", (actorDirectory, menus) => { ExportScriptarium.INSTANCE.onActorDirectoryMenu(actorDirectory, menus) })
+    Hooks.on("getActorDirectoryEntryContext", (actorDirectory, menus) => { ExportScriptarium.INSTANCE.onActorDirectoryMenu(actorDirectory, menus) })
+  }
+
+  onActorDirectoryMenu(actorDirectory, menus) {
+    menus.push({
+      name: 'Export Personnages <i class="fa-regular fa-file-csv"></i>',
+      icon: IMG_SCRIPTARIUM,
+      condition: (target) => game.user.isGM &&
+        OptionsAvancees.isUsing(EXPORT_CSV_SCRIPTARIUM) &&
+        this.$getActors(actorDirectory, target).length > 0,
+      callback: target => this.exportActors(this.$getActors(actorDirectory, target), this.$getTargetName(actorDirectory, target))
+    })
+  }
+
+  $getTargetName(actorDirectory, target) {
+    const li = target.closest(".directory-item")
+    const folderId = li.data("folderId")
+    const actorId = li.data("documentId")
+    return actorId
+      ? game.actors.get(actorId).name
+      : actorDirectory.folders.find(it => it.id == folderId).name
+  }
+
+  $getActors(actorDirectory, target) {
+    const li = target.closest(".directory-item")
+    const folderId = li.data("folderId")
+    const actorId = li.data("documentId")
+    const actors = actorId
+      ? [game.actors.get(actorId)]
+      : folderId
+        ? actorDirectory.folders.find(it => it.id == folderId).contents
+        : []
+    return actors.filter(it => it.type == ACTOR_TYPES.personnage)
+  }
+
+  exportActors(actors, targetName) {
+    const eol = '\n\r'
+    const header = Misc.join(this.getHeaderLine(), ';')
+    const actorLines = actors.map(actor => Misc.join(this.getActorLine(actor), ';'))
+    const data = Misc.join([header, ...actorLines], eol)
+    const filename = `scriptarium-${targetName?.slugify()}.csv`;
+    saveDataToFile(data, "text/csv;charset=windows-1252", `${filename}`);
+  }
+
+  getHeaderLine() {
+    return Mapping.getColumns()
+  }
+
+  getActorLine(actor) {
+    const values = Mapping.getValues(actor)
+    return values
+      .map(it => this.$escapeQuotes(it))
+      .map(it => it.replaceAll("\n", " ").replaceAll("\r", ""))
+  }
+
+  $escapeQuotes(it) {
+    it = '' + it
+    if (it.includes('"') || it.includes(';')) {
+      return `"${it.replaceAll('"', '\\"')}"`
+    }
+    return it
+  }
+}

module/actor/export-scriptarium/mapping.js

@@ -0,0 +1,376 @@
+import { Grammar } from "../../grammar.js"
+import { RdDItemArme } from "../../item-arme.js"
+import { RdDItemCompetence } from "../../item-competence.js"
+import { RdDItemSort } from "../../item-sort.js"
+import { ITEM_TYPES } from "../../item.js"
+import { Misc } from "../../misc.js"
+import { RdDTimestamp } from "../../time/rdd-timestamp.js"
+import { RdDBonus } from "../../rdd-bonus.js"
+import { TMRType } from "../../tmr-utility.js"
+
+
+export const CATEGORIES_COMPETENCES = [
+  "generale",
+  "particuliere",
+  "specialisee",
+  "connaissance",
+]
+export const CATEGORIES_DRACONIC = [
+  "draconic",
+]
+
+const CATEGORIES_COMBAT = [
+  "melee",
+  "tir",
+  "lancer"
+]
+
+const NIVEAU_BASE = {
+  "generale": -4,
+  "particuliere": -8,
+  "specialisee": -11,
+  "connaissance": -11,
+  "draconic": -11,
+  "melee": -6,
+  "tir": -8,
+  "lancer": -8,
+}
+
+class ColumnMappingFactory {
+  static createMappingArme(part, i) {
+    return { column: `arme_${part}_${i}`, getter: (actor, context) => Mapping.getArme(actor, context, part, i) }
+  }
+
+  static createMappingSort(part, i) {
+    return { column: `sort_${part}_${i}`, getter: (actor, context) => Mapping.getSort(actor, context, part, i) }
+  }
+}
+
+const NB_ARMES = 10
+const NB_SORTS = 20
+const TABLEAU_ARMES = [...Array(NB_ARMES).keys()]
+const TABLEAU_SORTS = [...Array(NB_SORTS).keys()]
+
+const MAPPING_BASE = [
+  { column: "ID", colName: 'ID', getter: (actor, context) => actor.id },
+  { column: "name", getter: (actor, context) => actor.name },
+  { column: "metier", colName: 'Métier', getter: (actor, context) => actor.system.metier },
+  { column: "biographie", colName: 'Biographie', getter: (actor, context) => actor.system.biographie },
+  { column: "taille", getter: (actor, context) => actor.system.carac.taille.value },
+  { column: "apparence", rollClass: 'roll-carac', getter: (actor, context) => actor.system.carac.apparence.value },
+  { column: "constitution", rollClass: 'roll-carac', getter: (actor, context) => actor.system.carac.constitution.value },
+  { column: "force", rollClass: 'roll-carac', getter: (actor, context) => actor.system.carac.force.value },
+  { column: "agilite", rollClass: 'roll-carac', colName: 'Agilité', getter: (actor, context) => actor.system.carac.agilite.value },
+  { column: "dexterite", rollClass: 'roll-carac', colName: 'Dextérité', getter: (actor, context) => actor.system.carac.dexterite.value },
+  { column: "vue", rollClass: 'roll-carac', getter: (actor, context) => actor.system.carac.vue.value },
+  { column: "ouie", rollClass: 'roll-carac', colName: 'Ouïe', getter: (actor, context) => actor.system.carac.ouie.value },
+  { column: "odoratgout", rollClass: 'roll-carac', colName: 'Odo-goût', getter: (actor, context) => actor.system.carac.odoratgout.value },
+  { column: "volonte", rollClass: 'roll-carac', colName: 'Volonté', getter: (actor, context) => actor.system.carac.volonte.value },
+  { column: "intellect", rollClass: 'roll-carac', getter: (actor, context) => actor.system.carac.intellect.value },
+  { column: "empathie", rollClass: 'roll-carac', getter: (actor, context) => actor.system.carac.empathie.value },
+  { column: "reve", rollClass: 'roll-carac', colName: 'Rêve', getter: (actor, context) => actor.system.carac.reve.value },
+  { column: "chance", rollClass: 'roll-carac', getter: (actor, context) => actor.system.carac.chance.value },
+  { column: "melee", rollClass: 'roll-carac', colName: 'Mêlée', getter: (actor, context) => actor.system.carac.melee.value },
+  { column: "tir", rollClass: 'roll-carac', getter: (actor, context) => actor.system.carac.tir.value },
+  { column: "lancer", rollClass: 'roll-carac', getter: (actor, context) => actor.system.carac.lancer.value },
+  { column: "derobee", rollClass: 'roll-carac', colName: 'Dérobée', getter: (actor, context) => actor.system.carac.derobee.value },
+  { column: "vie", getter: (actor, context) => actor.system.sante.vie.max },
+  { column: "endurance", getter: (actor, context) => actor.system.sante.endurance.max },
+  { column: "plusdom", colName: '+dom', getter: (actor, context) => actor.system.attributs.plusdom.value },
+  { column: "protectionnaturelle", colName: 'Protection naturelle', getter: (actor, context) => actor.system.attributs.protection.value > 0 ? actor.system.attributs.protection.value : '' },
+  { column: "description", getter: (actor, context) => Mapping.getDescription(actor) },
+  { column: "armure", getter: (actor, context) => Mapping.getArmure(actor, context) },
+  { column: "protectionarmure", colName: 'Protection', getter: (actor, context) => Mapping.getProtectionArmure(actor, context) },
+  { column: "malus_armure", getter: (actor, context) => Mapping.getMalusArmure(actor, context) },
+  { column: "reve_actuel", rollClass: 'roll-reve-actuel', colName: 'Rêve actuel', getter: (actor, context) => actor.system.reve.reve.value },
+  { column: "vie_actuel", rollClass: 'jet-vie', getter: (actor, context) => actor.system.sante.vie.value },
+  { column: "endurance_actuel", rollClass: 'jet-vie', getter: (actor, context) => actor.system.sante.endurance.value },
+  { column: "esquive", getter: (actor, context) => Mapping.getEsquive(context) },
+  { column: "esquive_armure", getter: (actor, context) => Mapping.getEsquiveArmure(context) },
+  { column: "competences", getter: (actor, context) => Mapping.getCompetences(actor, CATEGORIES_COMPETENCES) },
+  { column: "draconic", getter: (actor, context) => Mapping.getCompetences(actor, CATEGORIES_DRACONIC) },
+]
+
+const MAPPING_ARMES = TABLEAU_ARMES.map(i => ColumnMappingFactory.createMappingArme('name', i))
+  .concat(TABLEAU_ARMES.map(i => ColumnMappingFactory.createMappingArme('niveau', i)))
+  .concat(TABLEAU_ARMES.map(i => ColumnMappingFactory.createMappingArme('init', i)))
+  .concat(TABLEAU_ARMES.map(i => ColumnMappingFactory.createMappingArme('dommages', i)))
+const MAPPING_SORTS = TABLEAU_SORTS.map(i => ColumnMappingFactory.createMappingSort('voie', i))
+  .concat(TABLEAU_SORTS.map(i => ColumnMappingFactory.createMappingSort('description', i)))
+  .concat(TABLEAU_SORTS.map(i => ColumnMappingFactory.createMappingSort('bonus', i)))
+const MAPPING = MAPPING_BASE
+  .concat(MAPPING_ARMES)
+  .concat(MAPPING_SORTS)
+
+export class Mapping {
+
+  static getMapping() {
+    return MAPPING
+  }
+
+  static getColumns() {
+    return MAPPING.map(it => it.column)
+  }
+
+  static getValues(actor) {
+    const context = Mapping.prepareContext(actor)
+    return MAPPING.map(it => it.getter(actor, context))
+  }
+  static getAsObject(actor) {
+    const context = Mapping.prepareContext(actor)
+    return Object.fromEntries(MAPPING.map(it => [it.column, {
+      colName: it.colName ?? it.column,
+      value: it.getter(actor, context)
+    }]))
+  }
+
+  static getValues(actor) {
+    const context = Mapping.prepareContext(actor)
+    return MAPPING.map(it => it.getter(actor, context))
+  }
+
+  static prepareContext(actor) {
+    return {
+      armes: Mapping.prepareArmes(actor),
+      armure: Mapping.prepareArmure(actor),
+      esquive: Mapping.prepareEsquive(actor),
+      sorts: Mapping.prepareSorts(actor)
+    }
+  }
+
+  static prepareArmes(actor) {
+    const armes = actor.items.filter(it => it.type == ITEM_TYPES.arme)
+    return armes.map(arme =>
+      [
+        arme.system.unemain ? Mapping.prepareArme(actor, arme, 'unemain') : undefined,
+        arme.system.deuxmains ? Mapping.prepareArme(actor, arme, 'deuxmains') : undefined,
+        !(arme.system.unemain || arme.system.deuxmains) ? Mapping.prepareArme(actor, arme, 'competence') : undefined,
+        arme.system.lancer != "" ? Mapping.prepareArme(actor, arme, 'lancer') : undefined,
+        arme.system.tir != "" ? Mapping.prepareArme(actor, arme, 'tir') : undefined
+      ]
+        .filter(it => it != undefined)
+    ).reduce((a, b) => a.concat(b), [])
+  }
+
+  static prepareArme(actor, arme, maniement) {
+    const nameCompArme = RdDItemArme.getCompetenceArme(arme, maniement)
+    const competence = actor.getCompetence(nameCompArme)
+    if (RdDItemCompetence.isNiveauBase(competence)) {
+      return undefined
+    }
+    const dmgArme = RdDItemArme.dommagesReels(arme, maniement)
+    const dommages = dmgArme + RdDBonus.bonusDmg(actor, maniement, dmgArme)
+    const categorie = Mapping.complementCategorie(arme, maniement)
+    return {
+      name: arme.name + categorie,
+      niveau: Misc.toSignedString(competence.system.niveau),
+      init: Mapping.calculBaseInit(actor, competence.system.categorie) + competence.system.niveau,
+      dommages: Misc.toSignedString(dommages),
+      competence: competence,
+      arme: arme
+    }
+  }
+
+  static complementCategorie(arme, maniement) {
+    switch (maniement) {
+      case 'unemain': return (arme.system.deuxmains) ? ' 1 main' : (arme.system.lancer||arme.system.tir) ? ' mêlée': '' 
+      case 'deuxmains': return (arme.system.unemain) ? ' 2 mains' : (arme.system.lancer||arme.system.tir) ? ' mêlée': '' 
+      case 'lancer': return (arme.system.unemain || arme.system.deuxmains || arme.system.tir) ? ' jet' : ''
+      case 'tir': return (arme.system.unemain || arme.system.deuxmains || arme.system.lancer) ? ' tir' : ''
+    }
+    return '' 
+  }
+
+  static calculBaseInit(actor, categorie) {
+    const mapping = MAPPING_BASE.find(it => it.column == categorie)
+    if (mapping) {
+      switch (categorie) {
+        case 'melee':
+        case 'tir':
+        case 'lancer':
+          const caracteristique = Number(actor.system.carac[categorie].value)
+          return Math.floor(caracteristique / 2)
+      }
+    }
+    return 0
+  }
+
+  static prepareArmure(actor) {
+    const armures = actor.itemTypes[ITEM_TYPES.armure].filter(it => it.system.equipe)
+    if (armures.length > 1) {
+      console.warn(`${actor.name} a équipé ${armures.length} armures, seule la première sera considérée`)
+    }
+    if (armures.length > 0) {
+      const armure = armures[0]
+      return {
+        name: armure.name,
+        protection: armure.system.protection,
+        malus: armure.system.malus ?? 0
+      }
+    }
+    return {
+      name: '',
+      protection: actor.system.attributs.protection.value,
+      malus: 0
+    }
+  }
+
+  static prepareEsquive(actor) {
+    const esquives = actor.getCompetences("Esquive")
+    if (esquives.length > 0) {
+      const esquive = esquives[0]
+      return {
+        name: esquive.name,
+        niveau: esquive.system.niveau,
+        competence: esquive
+      }
+    }
+    return undefined
+  }
+
+  static prepareSorts(actor) {
+    const codeVoies = Mapping.getCompetencesCategorie(actor, CATEGORIES_DRACONIC)
+      .map(it => RdDItemSort.getVoieCode(it))
+
+    return actor.itemTypes[ITEM_TYPES.sort].map(it => Mapping.prepareSort(it, codeVoies))
+      .sort(Misc.ascending(it => `${it.voie} : ${it.description}`))
+  }
+
+  static prepareSort(sort, voies) {
+    return {
+      voie: RdDItemSort.getCodeDraconic(sort, voies),
+      description: Mapping.descriptionSort(sort),
+      bonus: Mapping.bonusCase(sort)
+    }
+  }
+
+  static descriptionSort(sort) {
+    const ptSeuil = Array(sort.system.coutseuil).map(it => '*')
+    const caseTMR = sort.system.caseTMRspeciale.length > 0 ? Mapping.toVar(sort.system.caseTMRspeciale) : Misc.upperFirst(TMRType[sort.system.caseTMR].name)
+    const ptreve = Mapping.addSpaceToNonNumeric(sort.system.ptreve)
+    const diff = Mapping.addSpaceToNonNumeric(sort.system.difficulte)
+    return `${sort.name}${ptSeuil} (${caseTMR}) R${diff} r${ptreve}`
+  }
+
+  static addSpaceToNonNumeric(value) {
+    return Number.isNumeric(value) ? value : ' ' + Mapping.toVar(value)
+  }
+
+  static toVar(value) {
+    return value.replace('variable', 'var')
+  }
+
+  static bonusCase(sort) {
+    const list = RdDItemSort.bonuscaseStringToList(sort.system.bonuscase).sort(Misc.descending(it => it.bonus))
+    if (list.length > 0) {
+      const bonus = list[0]
+      return `+${bonus.bonus}% en ${bonus.case}`
+    }
+    return ''
+  }
+
+  static getDescription(actor) {
+    const sexe = actor.system.sexe
+    const sexeFeminin = sexe.length > 0 && sexe.charAt(0).toLowerCase() == 'f' ? 'Née' : 'Né'
+    const race = ['', 'humain'].includes(Grammar.toLowerCaseNoAccent(actor.system.race)) ? '' : (actor.system.race + ' ')
+    const heure = actor.system.heure
+    const hn = `${sexeFeminin} à l'heure ${RdDTimestamp.definition(heure).avecArticle}`
+    const age = actor.system.age ? `${actor.system.age} ans` : undefined
+    const taille = actor.system.taille
+    const poids = actor.system.poids
+    const cheveux = actor.system.cheveux ? `cheveux ${actor.system.cheveux}` : undefined
+    const yeux = actor.system.yeux ? `yeux ${actor.system.yeux}` : undefined
+    const beaute = actor.system.beaute ? `beauté ${actor.system.beaute}` : undefined
+    const list = [race, hn, age, taille, poids, cheveux, yeux, beaute]
+    return Misc.join(list.filter(it => it), ', ')
+  }
+
+  static getArmure(actor, context) {
+    return context.armure?.name ?? ''
+  }
+
+  static getProtectionArmure(actor, context) {
+    const naturelle = Number(actor.system.attributs.protection.value)
+    if (context?.armure?.protection == undefined) {
+      return naturelle
+    }
+    if (Number.isNumeric(context?.armure?.protection)) {
+      return Number(context?.armure?.protection ?? 0) + naturelle
+    }
+    return context?.armure.protection + (naturelle > 0 ? `+${naturelle}` : '')
+  }
+
+  static getMalusArmure(actor, context) {
+    return context?.armure?.malus ?? 0
+  }
+
+  static getEsquive(context) {
+    if (context.esquive) {
+      return Misc.toSignedString(context.esquive.niveau)
+    }
+    return ''
+  }
+  static getEsquiveArmure(context) {
+    if (context.esquive) {
+      const niveau = context.esquive.niveau + context.armure.malus
+      return Misc.toSignedString(niveau)
+    }
+    return ''
+  }
+
+  static getCompetences(actor, categories) {
+    const competences = Mapping.getCompetencesCategorie(actor, categories)
+    if (competences.length == 0) {
+      return ''
+    }
+    const byCategories = Mapping.competencesByCategoriesByNiveau(competences, categories)
+    const txtByCategories = Object.values(byCategories)
+      .map(it => it.competencesParNiveau)
+      .map(byNiveau => {
+        const niveaux = Object.keys(byNiveau).map(it => Number(it)).sort(Misc.ascending())
+        if (niveaux.length == 0) {
+          return ''
+        }
+        const txtCategorieByNiveau = niveaux.map(niveau => {
+          const names = Misc.join(byNiveau[niveau].map(it => it.name).sort(Misc.ascending()), ', ')
+          return names + ' ' + Misc.toSignedString(niveau)
+        })
+        const txtCategorie = Misc.join(txtCategorieByNiveau, ' / ')
+        return txtCategorie
+      }).filter(it => it != '')
+
+    return Misc.join(txtByCategories, ' / ')
+  }
+
+  static competencesByCategoriesByNiveau(competences, categories) {
+    return categories.map(c => {
+      return {
+        categorie: c,
+        competencesParNiveau: Misc.classify(
+          competences.filter(comp => comp.system.categorie == c),
+          comp => comp.system.niveau)
+      }
+    })
+  }
+
+  static getArme(actor, context, part, numero) {
+    if (numero < context.armes.length) {
+      return context.armes[numero][part] ?? ''
+    }
+    return ''
+  }
+
+  static getCompetencesCategorie(actor, categories) {
+    return actor.itemTypes[ITEM_TYPES.competence]
+      .filter(it => categories.includes(it.system.categorie))
+      .filter(it => !RdDItemCompetence.isNiveauBase(it))
+  }
+
+  static getSort(actor, context, part, numero) {
+    if (numero < context.sorts.length) {
+      return context.sorts[numero][part]
+    }
+    return ''
+  }
+}
+

module/actor/random/app-personnage-aleatoire.js

@@ -0,0 +1,188 @@
+import { SHOW_DICE } from "../../constants.js";
+import { Misc } from "../../misc.js";
+import { RdDCarac } from "../../rdd-carac.js";
+import { RdDDice } from "../../rdd-dice.js";
+import { RdDNameGen } from "../../rdd-namegen.js";
+import { RdDTimestamp } from "../../time/rdd-timestamp.js";
+
+const PATHS = [
+  'name',
+  'system.sexe',
+  'system.age',
+  'system.taille',
+  'system.poids',
+  'system.main',
+  'system.heure',
+  'system.cheveux',
+  'system.yeux'
+]
+
+const RANDOM_VALUES = {
+  'system.sexe': { 'masculin': 1, 'féminin': 1 },
+  'system.main': { 'droitier': 51, 'gaucher': 15, 'ambidectre': 6 },
+  'system.cheveux': { 'noirs': 2, 'bruns': 5, 'châtains clair': 5, 'blonds': 4, 'blonds très clair': 1, 'roux carotte': 1, 'roux cuivré': 3 },
+  'system.yeux': { 'noirs': 2, 'noisettes': 3, 'bruns vert': 4, 'verts': 3, 'bleus clair': 3, 'bleus gris': 2, 'gris': 1, 'mauves': 1, 'indigos': 1 },
+}
+
+export class AppPersonnageAleatoire extends FormApplication {
+  static preloadHandlebars() {
+    loadTemplates([
+      'systems/foundryvtt-reve-de-dragon/templates/actor/random/champ-aleatoire.hbs',
+    ])
+  }
+
+  static get defaultOptions() {
+    return foundry.utils.mergeObject(super.defaultOptions, {
+      template: "systems/foundryvtt-reve-de-dragon/templates/actor/random/app-personnage-aleatoire.hbs",
+      title: "Génération aléatoire",
+      width: 'fit-content',
+      height: 'fit-content',
+      classes: ['app-personnage-aleatoire'],
+      popOut: true,
+      resizable: true
+    }, { inplace: false })
+  }
+
+  constructor(actor) {
+    super({})
+    this.actor = actor
+    this.current = foundry.utils.duplicate(actor)
+    this.checked = {
+      'name': false,
+      'system.sexe': true,
+      'system.age': true,
+      'system.taille': true,
+      'system.poids': true,
+      'system.main': true,
+      'system.heure': true,
+      'system.cheveux': true,
+      'system.yeux': true
+    }
+  }
+
+  async getData(options) {
+    return foundry.utils.mergeObject(await super.getData(options), {
+      actor: this.actor,
+      current: this.current,
+      checked: this.checked,
+      options: { isGM: game.user.isGM }
+    })
+  }
+
+  activateListeners(html) {
+    super.activateListeners(html)
+    this.html = html
+    this.html.find("button.button-cancel").click(async event => await this.close())
+    this.html.find("button.button-apply").click(async event => await this.onApply())
+    this.html.find("input.current-value").change(async event => await this.onChange(event))
+    this.html.find("div.random-field[data-path='system.heure'] select.current-value").change(async event => await this.onChange(event))
+    this.html.find("a.random").click(async event => await this.onRandom(event))
+    this.html.find("a.reset").click(async event => await this.onReset(event))
+    this.html.find("a.randomize-selected").click(async event => await this.onRandomizeSelected())
+    this.html.find("input.check-for-random").click(async event => await this.onCheckForRandom(event))
+  }
+  async _updateObject(event, formData) { }
+
+  async onApply() {
+    const updates = Object.fromEntries(
+      PATHS.filter(path => game.user.isGM || path != 'name')
+        .map(path => [path, this.current[path]])
+    )
+    await this.actor.update(updates)
+    await this.close()
+  }
+
+  getPath(selector) {
+    const fields = this.html.find(selector).parents("div.random-field:first")
+    return fields[0].attributes['data-path'].value
+  }
+
+  async onChange(event) {
+    const path = this.getPath(event.currentTarget)
+    this.current[path] = event.currentTarget.value
+  }
+
+  async onRandom(event) {
+    const path = this.getPath(event.currentTarget)
+    await this.setRandom(path);
+    this.render()
+  }
+
+  async onReset(event) {
+    const path = this.getPath(event.currentTarget)
+    this.current[path] = this.actor[path]
+    await this.render()
+  }
+
+  async onCheckForRandom(event) {
+    const path = this.getPath(event.currentTarget)
+    this.checked[path] = event.currentTarget.checked
+    this.render()
+  }
+
+  async onRandomizeSelected() {
+    const paths = this.html.find("input.check-for-random:checked")
+      .parents("div.random-field")
+      .toArray()
+      .map(it => it.attributes['data-path'].value)
+    await Promise.all(paths.map(path => this.setRandom(path)))
+    this.render()
+  }
+
+  async setRandom(path) {
+    this.current[path] = await this.random(path);
+  }
+
+  async random(path) {
+    switch (path) {
+      case 'name':
+        return await RdDNameGen.generate()
+      case 'system.sexe':
+      case 'system.main':
+      case 'system.cheveux':
+      case 'system.yeux':
+        return await this.randomFromMap(RANDOM_VALUES[path])
+      case 'system.poids':
+        return await this.randomPoids()
+      case 'system.taille':
+        return await this.randomTaille()
+      case 'system.age':
+        return await RdDDice.rollTotal('(2d4kl)*10 + 1d7xo + 2d20kl')
+      case 'system.heure':
+        return RdDTimestamp.defHeure(await RdDDice.rollHeure({ rollMode: "selfroll", showDice: SHOW_DICE })).key
+    }
+    return 'unknown'
+  }
+
+  async randomFromMap(valuesMap) {
+    const max = Object.values(valuesMap).reduce(Misc.sum(), 0)
+    const total = await RdDDice.rollTotal(`1d${max}`)
+    let sum = 0
+    for (let entry of Object.entries(valuesMap)) {
+      sum = sum + entry[1]
+      if (sum >= total) {
+        return entry[0]
+      }
+    }
+    return Object.keys(valuesMap)[0]
+  }
+
+  async randomPoids() {
+    const caracTaille = RdDCarac.getCaracDerivee(this.current.system.carac.taille.value)
+    const range = caracTaille.poidsMax - caracTaille.poidsMin + 1
+    const total = await RdDDice.rollTotal(`1d${range} + ${caracTaille.poidsMin}`)
+    return total + ' kg'
+  }
+
+  async randomTaille() {
+    const caracTaille = RdDCarac.getCaracDerivee(this.current.system.carac.taille.value)
+    const base = this.current.system.carac.taille.value * 2 + 60 + caracTaille.poidsMin
+    const variation = Math.floor((caracTaille.poidsMax - caracTaille.poidsMin + base / 5) / 2)
+    const total = await RdDDice.rollTotal(`2d${variation} + ${base}`)
+    const cm = total % 100
+    const m = (total - cm) / 100
+    return `${m}m${cm}`
+  }
+
+
+}

module/chat-utility.js

@@ -8,15 +8,20 @@ import { RdDTimestamp } from "./time/rdd-timestamp.js";
  */
 export class ChatUtility {
 
+  static async init() {
+    Hooks.on("renderChatMessage", async (app, html, msg) => await ChatUtility.onRenderChatMessage(app, html, msg))
+    Hooks.on("createChatMessage", async (chatMessage, options, id) => await ChatUtility.onCreateChatMessage(chatMessage, options, id))
+  }
+
   /* -------------------------------------------- */
   static onSocketMessage(sockmsg) {
     switch (sockmsg.msg) {
-      case "msg_delete_chat_message": return ChatUtility.onRemoveMessages(sockmsg.data);
-      case "msg_user_ui_notifications": return ChatUtility.onNotifyUser(sockmsg.data);
+      case "msg_gm_chat_message": return ChatUtility.handleGMChatMessage(sockmsg.data)
+      case "msg_delete_chat_message": return ChatUtility.onRemoveMessages(sockmsg.data)
+      case "msg_user_ui_notifications": return ChatUtility.onNotifyUser(sockmsg.data)
     }
   }
 
-
   /* -------------------------------------------- */
   static notifyUser(userId, level = 'info', message) {
     const socketData = {
@@ -78,73 +83,90 @@ export class ChatUtility {
   }
 
   /* -------------------------------------------- */
-  static async createChatWithRollMode(name, chatOptions) {
-    let rollMode = game.settings.get("core", "rollMode")
-    switch (rollMode) {
+  static async createChatWithRollMode(messageData, actor = undefined) {
+    switch (game.settings.get("core", "rollMode")) {
       case "blindroll": // GM only
         if (!game.user.isGM) {
-          ChatUtility.blindMessageToGM(chatOptions);
-
-          chatOptions.whisper = [game.user.id];
-          chatOptions.content = "Message envoyé en aveugle au Gardien";
+          ChatUtility.blindMessageToGM(messageData)
+          messageData.whisper = [game.user];
+          messageData.content = "Message envoyé en aveugle au Gardien"
         }
         else {
-          chatOptions.whisper = ChatUtility.getUsers(user => user.isGM);
+          messageData.whisper = ChatUtility.getGMs()
         }
-        break;
-      default:
-        chatOptions.whisper = ChatUtility.getWhisperRecipients(rollMode, name);
-        break;
+        break
+      case "gmroll":
+        messageData.whisper = ChatUtility.getOwners(actor)
+        break
+      case "selfroll":
+        messageData.whisper = [game.user]
+        break
     }
-    chatOptions.alias = chatOptions.alias || name;
-    return await ChatMessage.create(chatOptions);
+    messageData.alias = messageData.alias ?? actor?.name ?? game.user.name
+    return await ChatMessage.create(messageData)
+  }
+
+  static getOwners(document) {
+    return game.users.filter(it => document.getUserLevel(it) == CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER)
+  }
+
+  static getUserAndGMs() {
+    return [game.user, ...ChatUtility.getGMs()]
   }
 
   /* -------------------------------------------- */
-  static prepareChatMessage(rollMode, name) {
-    return {
-      user: game.user.id,
-      whisper: ChatUtility.getWhisperRecipients(rollMode, name)
-    }
-  }
-
-  /* -------------------------------------------- */
-  static getWhisperRecipients(rollMode, name) {
-    switch (rollMode) {
-      case "blindroll": return ChatUtility.getUsers(user => user.isGM);
-      case "gmroll": return ChatUtility.getWhisperRecipientsAndGMs(name);
-      case "selfroll": return [game.user.id];
-    }
-    return undefined;
-  }
-
-  /* -------------------------------------------- */
-  static getWhisperRecipientsAndGMs(...names) {
-    let recipients = [...ChatMessage.getWhisperRecipients('GM')]
-    names.forEach(name => recipients.push(...ChatMessage.getWhisperRecipients(name)))
-    return recipients
+  static getMultipleActorsOwners(...actors) {
+    return Misc.concat(actors.map(it => it == undefined ? [] : ChatUtility.getOwners(it)))
   }
 
   /* -------------------------------------------- */
   static getUsers(filter) {
-    return game.users.filter(filter).map(user => user.id);
+    return game.users.filter(filter)
+  }
+
+  static getGMs() {
+    return game.users.filter(user => user.isGM)
+  }
+
+  static applyRollMode(chatMessageData = {}, rollMode = game.settings.get("core", "rollMode")) {
+    switch (rollMode) {
+      case "blindroll":
+        chatMessageData.blind = true
+        chatMessageData.whisper = ChatUtility.getGMs()
+        break
+      case "gmroll":
+        chatMessageData.whisper = ChatUtility.getGMs()
+        chatMessageData.blind = false
+        break
+      case "roll":
+        chatMessageData.whisper = ChatUtility.getUsers(user => user.active)
+        chatMessageData.blind = false
+        break
+      case "selfroll":
+        chatMessageData.whisper = [game.user]
+        chatMessageData.blind = false
+        break
+    }
+    return chatMessageData
   }
 
   /* -------------------------------------------- */
   static blindMessageToGM(chatOptions) {
-    let chatGM = foundry.utils.duplicate(chatOptions);
-    chatGM.whisper = ChatUtility.getUsers(user => user.isGM);
-    chatGM.content = "Message aveugle de " + game.user.name + "<br>" + chatOptions.content;
-    console.log("blindMessageToGM", chatGM);
-    game.socket.emit(SYSTEM_SOCKET_ID, { msg: "msg_gm_chat_message", data: chatGM });
+    const chatGM = foundry.utils.duplicate(chatOptions)
+    chatGM.content = "Message aveugle de " + game.user.name + "<br>" + chatOptions.content
+    console.log("blindMessageToGM", chatGM)
+    game.socket.emit(SYSTEM_SOCKET_ID, { msg: "msg_gm_chat_message", data: chatGM })
   }
 
   /* -------------------------------------------- */
   static handleGMChatMessage(socketData) {
     console.log("blindMessageToGM", socketData);
-    if (game.user.isGM) { // message privé pour GM only
-      socketData.user = game.user.id;
-      ChatMessage.create(socketData);
+    if (Misc.firstConnectedGM()) {
+      ChatMessage.create({
+        user: game.user.id,
+        whisper: ChatUtility.getGMs(),
+        content: socketData.content
+      })
     }
   }
 

module/coeur/rdd-coeur.js

@@ -30,7 +30,8 @@ export class RdDCoeur {
   }
 
   static extractInfoCoeur(event) {
-    return ChatUtility.getMessageData(ChatUtility.getChatMessage(event), INFO_COEUR)
+    const chatMesage = ChatUtility.getChatMessage(event);
+    return ChatUtility.getMessageData(chatMesage, INFO_COEUR)
   }
 
   static getInfoCoeur(sourceActorId, targetActorId) {
@@ -98,12 +99,11 @@ export class RdDCoeur {
 
   static async startSubActeurTendreMoment(actorId, subActeurId) {
     const infoCoeur = RdDCoeur.getInfoCoeur(actorId, subActeurId)
-    if (infoCoeur.target?.actor.id) {
+    if (infoCoeur.target?.actor?.id) {
       // TODO: passer par une fenêtre pour saisir sa proposition (lieu, heure, ...)
-      const chatHtml = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/coeur/chat-proposer-tendre-moment.hbs`, infoCoeur)
       const chatMessage = await ChatMessage.create({
-        whisper: ChatUtility.getWhisperRecipientsAndGMs(infoCoeur.target?.actor.name),
-        content: chatHtml
+        whisper: ChatUtility.getOwners(infoCoeur.target.actor),
+        content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/coeur/chat-proposer-tendre-moment.hbs`, infoCoeur)
       })
       RdDCoeur.addTagsInfoCoeur(infoCoeur, chatMessage)
     }
@@ -127,7 +127,7 @@ export class RdDCoeur {
     }
     const chatHtml = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/coeur/chat-accepter-tendre-moment.hbs`, infoCoeur)
     const chatMessage = await ChatMessage.create({
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(infoCoeur.source?.actor.name, infoCoeur.target?.actor.name),
+      whisper: ChatUtility.getMultipleActorsOwners(infoCoeur.source?.actor, infoCoeur.target?.actor),
       content: chatHtml
     })
     RdDCoeur.addTagsInfoCoeur(infoCoeur, chatMessage)
@@ -142,7 +142,7 @@ export class RdDCoeur {
     ChatUtility.removeChatMessageId(infoCoeur.chatMessageId)
     const chatHtml = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/coeur/chat-refuser-tendre-moment.hbs`, infoCoeur)
     await ChatMessage.create({
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(infoCoeur.source?.actor.name, infoCoeur.target?.actor.name),
+      whisper: ChatUtility.getMultipleActorsOwners(infoCoeur.source?.actor, infoCoeur.target?.actor),
       content: chatHtml
     });
   }

module/dialog-chronologie.js

@@ -8,7 +8,7 @@ const LATEST_USED_JOURNAL_ID = "chronologie-dernier-journal";
 
 export class DialogChronologie extends Dialog {
 
-  static init() {
+  static initSettings() {
     game.settings.register(SYSTEM_RDD, LATEST_USED_JOURNAL_ID, {
       name: "Dernier article de journal utilisé pour enregistrer la chronologie",
       scope: "client",

module/dialog-create-signedraconique.js

@@ -24,7 +24,7 @@ export class DialogCreateSigneDraconique extends Dialog {
   }
 
   constructor(dialogData, html) {
-    let options = { classes: ["DialogCreateSigneDraconiqueActorsActors"], width: 500, height: 650, 'z-index': 99999 };
+    let options = { classes: ["DialogCreateSigneDraconiqueActors"], width: 500, height: 650, 'z-index': 99999 };
     let conf = {
       title: "Créer un signe",
       content: html,
@@ -48,7 +48,7 @@ export class DialogCreateSigneDraconique extends Dialog {
   async _createSigneForActor(actor, signe) {
     actor.createEmbeddedDocuments("Item", [signe]);
     ChatMessage.create({
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(actor.name),
+      whisper: ChatUtility.getOwners(actor),
       content: await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/chat-signe-draconique-actor.html", {
         signe: signe,
         alias: actor.name

module/environnement.js

@@ -7,7 +7,7 @@ import { CompendiumTableHelpers, CompendiumTable, SystemCompendiums } from "./se
 const COMPENDIUMS_RECHERCHE = 'compendiums-recherche';
 
 export class Environnement {
-  static init() {
+  static initSettings() {
     game.settings.register(SYSTEM_RDD, COMPENDIUMS_RECHERCHE, {
       name: COMPENDIUMS_RECHERCHE,
       default: [

module/item-arme.js

@@ -1,5 +1,5 @@
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js"
-import { TYPES } from "./item.js";
+import { ITEM_TYPES } from "./item.js";
 import { RdDCombatManager } from "./rdd-combat.js";
 
 const nomCategorieParade = {
@@ -20,19 +20,35 @@ const nomCategorieParade = {
 export class RdDItemArme extends Item {
 
   static isArme(item) {
-    return item.type == TYPES.arme || RdDItemCompetenceCreature.getCategorieAttaque(item);
+    return item.type == ITEM_TYPES.arme || RdDItemCompetenceCreature.getCategorieAttaque(item);
   }
 
   /* -------------------------------------------- */
   static getArme(arme) {
     switch (arme ? arme.type : '') {
-      case TYPES.arme: return arme;
-      case TYPES.competencecreature:
+      case ITEM_TYPES.arme: return arme;
+      case ITEM_TYPES.competencecreature:
         return RdDItemCompetenceCreature.armeCreature(arme);
     }
     return RdDItemArme.mainsNues();
   }
 
+  static getCompetenceArme(arme, maniement) {
+    switch (arme.type) {
+      case ITEM_TYPES.competencecreature:
+        return arme.name
+      case ITEM_TYPES.arme:
+        switch (maniement) {
+          case 'competence': return arme.system.competence;
+          case 'unemain': return RdDItemArme.competence1Mains(arme);
+          case 'deuxmains': return RdDItemArme.competence2Mains(arme);
+          case 'tir': return arme.system.tir;
+          case 'lancer': return arme.system.lancer;
+        }
+    }
+    return undefined
+  }
+
   static computeNiveauArmes(armes, competences) {
     for (const arme of armes) {
       arme.system.niveau = RdDItemArme.niveauCompetenceArme(arme, competences);
@@ -68,14 +84,14 @@ export class RdDItemArme extends Item {
       return armeData.system.categorie_parade;
     }
     // pour compatibilité avec des personnages existants
-    if (armeData.type == TYPES.competencecreature || armeData.system.categorie == 'creature') {
+    if (armeData.type == ITEM_TYPES.competencecreature || armeData.system.categorie == 'creature') {
       return armeData.system.categorie_parade || (armeData.system.isparade ? 'armes-naturelles' : '');
     }
     if (!armeData.type.match(/arme|competencecreature/)) {
       return '';
     }
     if (armeData.system.competence == undefined) {
-      return TYPES.competencecreature;
+      return ITEM_TYPES.competencecreature;
     }
     let compname = armeData.system.competence.toLowerCase();
     if (compname.match(/^(dague de jet|javelot|fouet|arc|arbalête|fronde|hache de jet|fléau)$/)) return '';
@@ -132,43 +148,46 @@ export class RdDItemArme extends Item {
     return true;
   }
 
-  /* -------------------------------------------- */
-  static armeUneOuDeuxMains(armeData, aUneMain) {
-    if (armeData && !armeData.system.cac) {
-      armeData.system.unemain = armeData.system.unemain || !armeData.system.deuxmains;
-      const uneOuDeuxMains = armeData.system.unemain && armeData.system.deuxmains;
-      const containsSlash = !Number.isInteger(armeData.system.dommages) && armeData.system.dommages.includes("/");
-      if (containsSlash) { // Sanity check
-        armeData = foundry.utils.duplicate(armeData);
-
-        const tableauDegats = armeData.system.dommages.split("/");
-        if (aUneMain)
-          armeData.system.dommagesReels = Number(tableauDegats[0]);
-        else // 2 mains
-          armeData.system.dommagesReels = Number(tableauDegats[1]);
-      }
-      else {
-        armeData.system.dommagesReels = Number(armeData.system.dommages);
-      }
-
-      if (uneOuDeuxMains != containsSlash) {
-        ui.notifications.info("Les dommages de l'arme à 1/2 mains " + armeData.name + " ne sont pas corrects (ie sous la forme X/Y)");
-      }
+  static dommagesReels(arme, maniement) {
+    switch (maniement) {
+      case 'tir':
+      case 'lancer':
+      case 'competence':
+        return Number(arme.system.dommages)
     }
-    return armeData;
+    if (arme.system.unemain && arme.system.deuxmains) {
+      const containsSlash = !Number.isInteger(arme.system.dommages) && arme.system.dommages.includes("/")
+      if (!containsSlash) {
+        ui.notifications.info("Les dommages de l'arme à 1/2 mains " + arme.name + " ne sont pas corrects (ie sous la forme X/Y)");
+        return Number(arme.system.dommages)
+      }
+      const tableauDegats = arme.system.dommages.split("/");
+      return Number(tableauDegats[maniement == 'unemain' ? 0 : 1])
+    }
+    return Number(arme.system.dommages);
   }
-  static competence2Mains(arme) {
-    return arme.system.competence.replace(" 1 main", " 2 mains");
+
+  /* -------------------------------------------- */
+  static armeUneOuDeuxMains(arme, aUneMain) {
+    if (arme && !arme.system.cac) {
+      arme = foundry.utils.duplicate(arme);
+      arme.system.dommagesReels = RdDItemArme.dommagesReels(arme, aUneMain ? 'unemain' : 'deuxmains')
+    }
+    return arme;
   }
 
   static competence1Mains(arme) {
     return arme.system.competence.replace(" 2 mains", " 1 main");
   }
 
+  static competence2Mains(arme) {
+    return arme.system.competence.replace(" 1 main", " 2 mains");
+  }
+
   static isArmeUtilisable(arme) {
     switch (arme.type) {
-      case TYPES.arme: return arme.system.equipe && (arme.system.resistance > 0 || arme.system.portee_courte > 0)
-      case TYPES.competencecreature: return true
+      case ITEM_TYPES.arme: return arme.system.equipe && (arme.system.resistance > 0 || arme.system.portee_courte > 0)
+      case ITEM_TYPES.competencecreature: return true
     }
     return false
   }
@@ -180,11 +199,11 @@ export class RdDItemArme extends Item {
 
   static corpsACorps(actor) {
     let competence = actor?.getCompetenceCorpsACorps() ?? { system: { niveau: -6 } };
-    let melee = actor? actor.system.carac['melee'].value : 0
+    let melee = actor ? actor.system.carac['melee'].value : 0
     return {
       _id: competence?.id,
       name: 'Corps à corps',
-      type: TYPES.arme,
+      type: ITEM_TYPES.arme,
       img: 'systems/foundryvtt-reve-de-dragon/icons/competence_corps_a_corps.webp',
       system: {
         initiative: RdDCombatManager.calculInitiative(competence.system.niveau, melee),

module/item-competence.js

@@ -1,4 +1,5 @@
 import { Grammar } from "./grammar.js";
+import { RdDItem } from "./item.js";
 import { Misc } from "./misc.js";
 
 const competenceTroncs = [["Esquive", "Dague", "Corps à corps"],
@@ -23,12 +24,12 @@ const limitesArchetypes = [
 ];
 
 /* -------------------------------------------- */
-const categoriesCompetences = {
+export const CATEGORIES_COMPETENCES = {
   "generale": { base: -4, label: "Générales" },
   "particuliere": { base: -8, label: "Particulières" },
   "specialisee": { base: -11, label: "Spécialisées" },
   "connaissance": { base: -11, label: "Connaissances" },
-  "draconic": { base: -11, label: "Draconics" },
+  "draconic": { base: -11, label: "Draconic" },
   "melee": { base: -6, label: "Mêlée" },
   "tir": { base: -8, label: "Tir" },
   "lancer": { base: -8, label: "Lancer" }
@@ -48,16 +49,14 @@ function _buildCumulXP() {
 const competence_xp_cumul = _buildCumulXP();
 
 export class RdDItemCompetence extends Item {
-  /* -------------------------------------------- */
-  static getCategories() {
-    return categoriesCompetences;
-  }
   /* -------------------------------------------- */
   static getLabelCategorie(category) {
-    return categoriesCompetences[category].label;
+    return CATEGORIES_COMPETENCES[category].label;
   }
   /* -------------------------------------------- */
-  static getNiveauBase(category, categories = categoriesCompetences) {
+  /* -------------------------------------------- */
+  static getNiveauBase(category, itemType) {
+    let categories = RdDItem.getCategories(itemType)
     return categories[category]?.base ?? 0;
   }
 
@@ -191,7 +190,7 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   static isNiveauBase(item) {
-    return Number(item.system.niveau) == RdDItemCompetence.getNiveauBase(item.system.categorie, item.getCategories());
+    return Number(item.system.niveau) == RdDItemCompetence.getNiveauBase(item.system.categorie, item.type);
   }
 
   /* -------------------------------------------- */

module/item-competencecreature.js

@@ -1,8 +1,8 @@
 
-import { TYPES } from "./item.js";
+import { ITEM_TYPES } from "./item.js";
 import { RdDCombatManager } from "./rdd-combat.js";
 
-const categories = {
+export const CATEGORIES_COMPETENCES_CREATURES = {
   "generale": { base: 0, label: "Générale" },
   "naturelle": { base: 0, label: "Arme naturelle" },
   "melee": { base: 0, label: "Mêlée" },
@@ -15,10 +15,6 @@ const categories = {
 /* -------------------------------------------- */
 export class RdDItemCompetenceCreature extends Item {
 
-  static getCategories() {
-    return categories;
-  }
-
   /* -------------------------------------------- */
   static setRollDataCreature(rollData) {
     rollData.carac = { "carac_creature": { label: rollData.competence.name, value: rollData.competence.system.carac_value } }
@@ -54,7 +50,7 @@ export class RdDItemCompetenceCreature extends Item {
 
   /* -------------------------------------------- */
   static isCompetenceAttaque(item) {
-    if (item.type == TYPES.competencecreature) {
+    if (item.type == ITEM_TYPES.competencecreature) {
       switch (item.system.categorie) {
         case "melee":
         case "tir":
@@ -68,7 +64,7 @@ export class RdDItemCompetenceCreature extends Item {
   }
 
   static getCategorieAttaque(item) {
-    if (item.type == TYPES.competencecreature) {
+    if (item.type == ITEM_TYPES.competencecreature) {
       switch (item.system.categorie) {
         case "melee":
         case "tir":
@@ -82,7 +78,7 @@ export class RdDItemCompetenceCreature extends Item {
     return undefined
   }
   static isDommages(item) {
-    if (item.type == TYPES.competencecreature) {
+    if (item.type == ITEM_TYPES.competencecreature) {
       switch (item.system.categorie) {
         case "melee":
         case "tir":
@@ -94,7 +90,7 @@ export class RdDItemCompetenceCreature extends Item {
     return false
   }
   static isParade(item) {
-    if (item.type == TYPES.competencecreature) {
+    if (item.type == ITEM_TYPES.competencecreature) {
       switch (item.system.categorie) {
         case "melee":
         case "naturelle":

module/item-sheet.js

@@ -12,7 +12,7 @@ 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 { TYPES } from "./item.js";
+import { ITEM_TYPES, RdDItem } from "./item.js";
 
 /**
  * Extend the basic ItemSheet for RdD specific items
@@ -101,13 +101,13 @@ export class RdDItemSheet extends ItemSheet {
       isComestible: this.item.getUtilisationCuisine(),
       options: RdDSheetUtility.mergeDocumentRights(this.options, this.item, this.isEditable),
     }
-    if (this.item.type == TYPES.competencecreature) {
+    if (this.item.type == ITEM_TYPES.competencecreature) {
       formData.isparade = RdDItemCompetenceCreature.isParade(this.item)
       formData.isdommages = RdDItemCompetenceCreature.isDommages(this.item)
     }
 
     const competences = await SystemCompendiums.getCompetences('personnage');
-    formData.categories = this.item.getCategories()
+    formData.categories = RdDItem.getCategories(this.item.type)
     if (this.item.type == 'tache' || this.item.type == 'livre' || this.item.type == 'meditation' || this.item.type == 'oeuvre') {
       formData.caracList = foundry.utils.duplicate(game.model.Actor.personnage.carac)
       formData.caracList["reve-actuel"] = foundry.utils.duplicate(game.model.Actor.personnage.reve.reve)
@@ -258,7 +258,7 @@ export class RdDItemSheet extends ItemSheet {
 
     if (this.item.isCompetence()) {
       const categorie = event.currentTarget.value;
-      const level = RdDItemCompetence.getNiveauBase(categorie, this.item.getCategories());
+      const level = RdDItemCompetence.getNiveauBase(categorie, this.item.type);
       this.item.system.base = level;
       this.html.find('[name="system.base"]').val(level);
     }

module/item-sort.js

@@ -1,9 +1,59 @@
+import { Grammar } from "./grammar.js";
+import { RdDItemCompetence } from "./item-competence.js";
+import { ITEM_TYPES } from "./item.js";
 import { Misc } from "./misc.js";
 import { TMRUtility } from "./tmr-utility.js";
 
+const VOIES_DRACONIC = [
+  { code: 'O', label: "Voie d'Oniros", short: 'Oniros', ordre: 'a' },
+  { code: 'H', label: "Voie d'Hypnos", short: 'Hypnos', ordre: 'b' },
+  { code: 'N', label: "Voie de Narcos", short: 'Narcos', ordre: 'c' },
+  { code: 'T', label: "Voie de Thanatos", short: 'Thanatos', ordre: 'd' },
+  { code: 'O/H/N/T', label: "Oniros/Hypnos/Narcos/Thanatos", short: 'Oniros/Hypnos/Narcos/Thanatos', ordre: 'e' },
+  { code: 'O/H/N', label: "Oniros/Hypnos/Narcos", short: "Oniros/Hypnos/Narcos", ordre: 'f' }
+]
+
 /* -------------------------------------------- */
 export class RdDItemSort extends Item {
 
+  static getDraconicsSort(draconicList, sort) {
+    switch (Grammar.toLowerCaseNoAccent(sort.name)) {
+      case "lecture d'aura":
+      case "detection d'aura":
+        return draconicList;
+      case "annulation de magie":
+        return draconicList.filter(it => !RdDItemCompetence.isThanatos(it));
+    }
+    return [RdDItemCompetence.getVoieDraconic(draconicList, sort.system.draconic)];
+  }
+
+  static getOrdreCode(code) {
+    return (VOIES_DRACONIC.find(it => it.code == code)?.ordre ?? '?')
+  }
+
+  static getVoieCode(voie) {
+    return VOIES_DRACONIC.find(it => voie.name.includes(it.short))?.code ?? '?'
+  }
+
+  static getCodeDraconic(sort, voies = ['O', 'H', 'N', 'T']) {
+    switch (Grammar.toLowerCaseNoAccent(sort.name)) {
+      case "lecture d'aura":
+      case "detection d'aura":
+        return RdDItemSort.$voiesConnues('O/H/N/T', voies)
+      case "annulation de magie":
+        return RdDItemSort.$voiesConnues('O/H/N', voies)
+    }
+    const voie = VOIES_DRACONIC.find(it => it.label.includes(sort.system.draconic))
+    return voie?.code ?? sort.system.draconic
+  }
+
+
+  static $voiesConnues(voiesSort, voies) {
+    const codes = voies.filter(it => voiesSort.includes(it))
+      .sort(Misc.ascending(it => RdDItemSort.getOrdreCode(it)))
+    return Misc.join(codes ?? [''], '/');
+  }
+
   /* -------------------------------------------- */
   static isDifficulteVariable(sort) {
     return sort && (sort.system.difficulte.toLowerCase() == "variable");
@@ -31,9 +81,9 @@ export class RdDItemSort extends Item {
 
   /* -------------------------------------------- */
   static buildBonusCaseList(bonuscase, newCase) {
-    const list = RdDItemSort._bonuscaseStringToList(bonuscase)
+    const list = RdDItemSort.bonuscaseStringToList(bonuscase)
     if (newCase) {
-      return list.concat({ case: "Nouvelle", bonus: 0 });
+      list.push({ case: "Nouvelle", bonus: 0 })
     }
     return list;
   }
@@ -44,7 +94,7 @@ export class RdDItemSort extends Item {
   */
   static getBonusCaseList(item, newCase = false) {
     // Gestion spéciale case bonus
-    if (item.type == 'sort') {
+    if (item.type == ITEM_TYPES.sort) {
       return RdDItemSort.buildBonusCaseList(item.system.bonuscase, newCase);
     }
     return undefined;
@@ -104,8 +154,11 @@ export class RdDItemSort extends Item {
       .sort(Misc.ascending())
       .join(',');
   }
-  static _bonuscaseStringToList(bonuscase) {
-    return (bonuscase ?? '').split(',').map(it => {
+  static bonuscaseStringToList(bonuscase) {
+    if (bonuscase == undefined || bonuscase == '') {
+      return []
+    }
+    return bonuscase.split(',').map(it => {
       const b = it.split(':');
       return { case: b[0], bonus: b[1] };
     });

module/item.js

@@ -6,10 +6,18 @@ import { RdDTimestamp } from "./time/rdd-timestamp.js";
 import { RdDUtility } from "./rdd-utility.js";
 import { SystemCompendiums } from "./settings/system-compendiums.js";
 import { RdDRaretes } from "./item/raretes.js";
-import { RdDItemCompetence } from "./item-competence.js";
-import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
+import { CATEGORIES_COMPETENCES } from "./item-competence.js";
+import { CATEGORIES_COMPETENCES_CREATURES } from "./item-competencecreature.js";
 
-export const TYPES = {
+export const ACTOR_TYPES = {
+  personnage: 'personnage',
+  creature: 'creature',
+  entite: 'entite',
+  commerce: 'commerce',
+  vehicule: 'vehicule'
+}
+
+export const ITEM_TYPES = {
   competence: 'competence',
   competencecreature: 'competencecreature',
   empoignade: 'empoignade',
@@ -56,33 +64,33 @@ export const TYPES = {
 }
 
 const typesInventaireMateriel = [
-  TYPES.arme,
-  TYPES.armure,
-  TYPES.conteneur,
-  TYPES.faune,
-  TYPES.gemme,
-  TYPES.herbe,
-  TYPES.plante,
-  TYPES.ingredient,
-  TYPES.livre,
-  TYPES.monnaie,
-  TYPES.munition,
-  TYPES.nourritureboisson,
-  TYPES.objet,
-  TYPES.potion,
+  ITEM_TYPES.arme,
+  ITEM_TYPES.armure,
+  ITEM_TYPES.conteneur,
+  ITEM_TYPES.faune,
+  ITEM_TYPES.gemme,
+  ITEM_TYPES.herbe,
+  ITEM_TYPES.plante,
+  ITEM_TYPES.ingredient,
+  ITEM_TYPES.livre,
+  ITEM_TYPES.monnaie,
+  ITEM_TYPES.munition,
+  ITEM_TYPES.nourritureboisson,
+  ITEM_TYPES.objet,
+  ITEM_TYPES.potion,
 ]
 const typesInventaire = {
   materiel: typesInventaireMateriel,
   all: ['service'].concat(typesInventaireMateriel),
 }
 
-const typesObjetsOeuvres = [TYPES.oeuvre, TYPES.recettecuisine, TYPES.musique, TYPES.chant, TYPES.danse, TYPES.jeu]
-const typesObjetsDraconiques = [TYPES.queue, TYPES.ombre, TYPES.souffle, TYPES.tete, TYPES.signedraconique, TYPES.sortreserve, TYPES.rencontre]
-const typesObjetsConnaissance = [TYPES.meditation, TYPES.recettealchimique, TYPES.sort]
-const typesObjetsEffet = [TYPES.possession, TYPES.poison, TYPES.maladie, TYPES.blessure]
-const typesObjetsCompetence = [TYPES.competence, TYPES.competencecreature]
-const typesObjetsTemporels = [TYPES.blessure, TYPES.poison, TYPES.maladie, TYPES.queue, TYPES.ombre, TYPES.souffle, TYPES.signedraconique, TYPES.rencontre]
-const typesObjetsEquipable = [TYPES.arme, TYPES.armure, TYPES.objet];
+const typesObjetsOeuvres = [ITEM_TYPES.oeuvre, ITEM_TYPES.recettecuisine, ITEM_TYPES.musique, ITEM_TYPES.chant, ITEM_TYPES.danse, ITEM_TYPES.jeu]
+const typesObjetsDraconiques = [ITEM_TYPES.queue, ITEM_TYPES.ombre, ITEM_TYPES.souffle, ITEM_TYPES.tete, ITEM_TYPES.signedraconique, ITEM_TYPES.sortreserve, ITEM_TYPES.rencontre]
+const typesObjetsConnaissance = [ITEM_TYPES.meditation, ITEM_TYPES.recettealchimique, ITEM_TYPES.sort]
+const typesObjetsEffet = [ITEM_TYPES.possession, ITEM_TYPES.poison, ITEM_TYPES.maladie, ITEM_TYPES.blessure]
+const typesObjetsCompetence = [ITEM_TYPES.competence, ITEM_TYPES.competencecreature]
+const typesObjetsTemporels = [ITEM_TYPES.blessure, ITEM_TYPES.poison, ITEM_TYPES.maladie, ITEM_TYPES.queue, ITEM_TYPES.ombre, ITEM_TYPES.souffle, ITEM_TYPES.signedraconique, ITEM_TYPES.rencontre]
+const typesObjetsEquipable = [ITEM_TYPES.arme, ITEM_TYPES.armure, ITEM_TYPES.objet];
 const typesEnvironnement = typesInventaireMateriel;
 const encBrin = 0.00005; // un brin = 1 décigramme = 1/10g = 1/10000kg = 1/20000 enc
 const encPepin = 0.0007; /* un pépin de gemme = 1/10 cm3 = 1/1000 l = 3.5/1000 kg = 7/2000 kg = 7/1000 enc
@@ -141,12 +149,12 @@ export class RdDItem extends Item {
   static isFieldInventaireModifiable(type, field) {
     switch (field) {
       case 'quantite':
-        if ([TYPES.conteneur].includes(type)) {
+        if ([ITEM_TYPES.conteneur].includes(type)) {
           return false;
         }
         break;
       case 'cout':
-        if ([TYPES.monnaie].includes(type)) {
+        if ([ITEM_TYPES.monnaie].includes(type)) {
           return game.user.isGM;
         }
         break;
@@ -164,9 +172,11 @@ export class RdDItem extends Item {
   static getItemTypesInventaire(mode = 'materiel') {
     return typesInventaire[mode ?? 'materiel']
   }
+
   static getItemTypesDraconiques() {
     return typesObjetsDraconiques;
   }
+
   static getItemTypesEnvironnement() {
     return typesEnvironnement;
   }
@@ -175,6 +185,16 @@ export class RdDItem extends Item {
     return typesObjetsOeuvres
   }
 
+  static getCategories(itemType) {
+    switch (itemType) {
+      case ITEM_TYPES.competence:
+        return CATEGORIES_COMPETENCES
+      case ITEM_TYPES.competencecreature:
+        return CATEGORIES_COMPETENCES_CREATURES
+    }
+    return {}
+  }
+
   constructor(docData, context = {}) {
     if (!context.rdd?.ready) {
       foundry.utils.mergeObject(context, { rdd: { ready: true } });
@@ -195,15 +215,15 @@ export class RdDItem extends Item {
 
   getUniteQuantite() {
     switch (this.type) {
-      case TYPES.monnaie: return "(Pièces)"
-      case TYPES.herbe:
+      case ITEM_TYPES.monnaie: return "(Pièces)"
+      case ITEM_TYPES.herbe:
         switch (this.system.categorie) {
           case 'Alchimie': case 'Repos': case 'Soin':
             return "(Brins)"
           case 'Cuisine': return '';
         }
         return '';
-      case TYPES.ingredient: return "(Pépins ou Brins)"
+      case ITEM_TYPES.ingredient: return "(Pépins ou Brins)"
     }
     return '';
   }
@@ -212,13 +232,13 @@ export class RdDItem extends Item {
     return typesObjetsEquipable.includes(this.type)
   }
 
-  isCompetencePersonnage() { return this.type == TYPES.competence }
-  isCompetenceCreature() { return this.type == TYPES.competencecreature }
-  isConteneur() { return this.type == TYPES.conteneur; }
-  isMonnaie() { return this.type == TYPES.monnaie; }
-  isPotion() { return this.type == TYPES.potion; }
-  isNourritureBoisson() { return this.type == TYPES.nourritureboisson; }
-  isService() { return this.type == TYPES.service; }
+  isCompetencePersonnage() { return this.type == ITEM_TYPES.competence }
+  isCompetenceCreature() { return this.type == ITEM_TYPES.competencecreature }
+  isConteneur() { return this.type == ITEM_TYPES.conteneur; }
+  isMonnaie() { return this.type == ITEM_TYPES.monnaie; }
+  isPotion() { return this.type == ITEM_TYPES.potion; }
+  isNourritureBoisson() { return this.type == ITEM_TYPES.nourritureboisson; }
+  isService() { return this.type == ITEM_TYPES.service; }
 
   isCompetence() { return typesObjetsCompetence.includes(this.type) }
   isEsquive() {
@@ -237,30 +257,23 @@ export class RdDItem extends Item {
     return this.isCompetence() && ['melee', 'tir', 'lancer'].includes(this.system.categorie)
   }
 
-  isCompetencePossession() { return TYPES.competencecreature == this.type && this.system.categorie == "possession" }
+  isCompetencePossession() { return ITEM_TYPES.competencecreature == this.type && this.system.categorie == "possession" }
   isTemporel() { return typesObjetsTemporels.includes(this.type) }
   isOeuvre() { return typesObjetsOeuvres.includes(this.type) }
   isDraconique() { return RdDItem.getItemTypesDraconiques().includes(this.type) }
-  isQueueDragon() { return [TYPES.queue, TYPES.ombre].includes(this.type) }
+  isQueueDragon() { return [ITEM_TYPES.queue, ITEM_TYPES.ombre].includes(this.type) }
   isEffet() { return typesObjetsEffet.includes(this.type) }
   isConnaissance() { return typesObjetsConnaissance.includes(this.type) }
 
   isInventaire(mode = 'materiel') { return RdDItem.getItemTypesInventaire(mode).includes(this.type); }
   isBoisson() { return this.isNourritureBoisson() && this.system.boisson; }
   isAlcool() { return this.isNourritureBoisson() && this.system.boisson && this.system.alcoolise; }
-  isHerbeAPotion() { return this.type == TYPES.herbe && (this.system.categorie == 'Soin' || this.system.categorie == 'Repos'); }
-  isBlessure() { return this.type == TYPES.blessure }
+  isHerbeAPotion() { return this.type == ITEM_TYPES.herbe && (this.system.categorie == 'Soin' || this.system.categorie == 'Repos'); }
+  isBlessure() { return this.type == ITEM_TYPES.blessure }
 
   isPresentDansMilieux(milieux) {
     return this.getEnvironnements(milieux).length > 0
   }
-  getCategories() {
-    switch (this.type) {
-      case TYPES.competence: return RdDItemCompetence.getCategories()
-      case TYPES.competencecreature: return RdDItemCompetenceCreature.getCategories()
-    }
-    return {}
-  }
 
   getEnvironnements(milieux = undefined) {
     const environnements = this.isInventaire() ? this.system.environnement : undefined;
@@ -341,15 +354,15 @@ export class RdDItem extends Item {
 
   getUtilisation() {
     switch (this.type) {
-      case TYPES.potion:
+      case ITEM_TYPES.potion:
         switch (this.system.categorie) {
           case 'Alchimie': case 'AlchimieEnchante': case 'AlchimieAutre': return 'alchimie'
           case 'Cuisine': return 'cuisine'
           case 'Remede': case 'Repos': case 'ReposEnchante': case 'Soin': case 'SoinEnchante': return 'soins'
         }
         return '';
-      case TYPES.nourritureboisson: return 'cuisine';
-      case TYPES.herbe: case TYPES.faune: case TYPES.ingredient: case TYPES.plante:
+      case ITEM_TYPES.nourritureboisson: return 'cuisine';
+      case ITEM_TYPES.herbe: case ITEM_TYPES.faune: case ITEM_TYPES.ingredient: case ITEM_TYPES.plante:
         switch (this.system.categorie) {
           case 'Cuisine': return 'cuisine';
           case 'Toxique': case 'Poison': return 'poison';
@@ -364,9 +377,9 @@ export class RdDItem extends Item {
   getUtilisationCuisine() {
     if (this.getUtilisation() == 'cuisine') {
       switch (this.type) {
-        case TYPES.nourritureboisson:
+        case ITEM_TYPES.nourritureboisson:
           return 'pret';
-        case TYPES.herbe: case TYPES.faune: case TYPES.ingredient: case TYPES.plante:
+        case ITEM_TYPES.herbe: case ITEM_TYPES.faune: case ITEM_TYPES.ingredient: case ITEM_TYPES.plante:
           return 'brut';
       }
     }
@@ -374,7 +387,7 @@ export class RdDItem extends Item {
   }
 
   isCristalAlchimique() {
-    return this.type == TYPES.objet && Grammar.includesLowerCaseNoAccent(this.name, 'cristal alchimique') && this.system.quantite > 0;
+    return this.type == ITEM_TYPES.objet && Grammar.includesLowerCaseNoAccent(this.name, 'cristal alchimique') && this.system.quantite > 0;
   }
 
   isMagique() {
@@ -402,11 +415,11 @@ export class RdDItem extends Item {
 
   getEnc() {
     switch (this.type) {
-      case TYPES.service:
+      case ITEM_TYPES.service:
         return 0;
-      case TYPES.herbe:
+      case ITEM_TYPES.herbe:
         return this.getEncHerbe();
-      case TYPES.gemme:
+      case ITEM_TYPES.gemme:
         return encPepin * this.system.taille;
     }
     return Math.max(this.system.encombrement ?? 0, 0);
@@ -484,7 +497,7 @@ export class RdDItem extends Item {
 
   getActionPrincipale(options = { warnIfNot: true }) {
     switch (this.type) {
-      case TYPES.conteneur: return 'Ouvrir';
+      case ITEM_TYPES.conteneur: return 'Ouvrir';
     }
     if (this.actor?.isPersonnage()) {
       const warn = options.warnIfNot;
@@ -492,11 +505,11 @@ export class RdDItem extends Item {
         return 'Cuisiner';
       }
       switch (this.type) {
-        case TYPES.nourritureboisson: return this._actionOrWarnQuantiteZero(this.system.boisson ? 'Boire' : 'Manger', warn);
-        case TYPES.potion: return this._actionOrWarnQuantiteZero('Consommer', warn);
-        case TYPES.livre: return this._actionOrWarnQuantiteZero('Lire', warn);
-        case TYPES.herbe: return this.isHerbeAPotion() ? this._actionOrWarnQuantiteZero('Décoction', warn) : undefined;
-        case TYPES.queue: case TYPES.ombre: return this.system.refoulement > 0 ? 'Refouler' : undefined;
+        case ITEM_TYPES.nourritureboisson: return this._actionOrWarnQuantiteZero(this.system.boisson ? 'Boire' : 'Manger', warn);
+        case ITEM_TYPES.potion: return this._actionOrWarnQuantiteZero('Consommer', warn);
+        case ITEM_TYPES.livre: return this._actionOrWarnQuantiteZero('Lire', warn);
+        case ITEM_TYPES.herbe: return this.isHerbeAPotion() ? this._actionOrWarnQuantiteZero('Décoction', warn) : undefined;
+        case ITEM_TYPES.queue: case ITEM_TYPES.ombre: return this.system.refoulement > 0 ? 'Refouler' : undefined;
       }
     }
     return undefined;

module/item/blessure.js

@@ -62,7 +62,7 @@ export class RdDItemBlessure extends RdDItem {
       content: `Blessure ${definition.label} appliquée à ${actor.name}`+
         `<br>Perte d'endurance : ${lostEndurance}`+
         `<br>Perte de Vie : ${lostVie}`,
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(actor.name)
+      whisper: ChatUtility.getOwners(actor)
     });
 
   }

module/item/maladie.js

@@ -1,3 +1,4 @@
+import { ChatUtility } from "../chat-utility.js";
 import { RdDItem } from "../item.js";
 import { Misc } from "../misc.js";
 import { RdDTimestamp } from "../time/rdd-timestamp.js";
@@ -21,9 +22,12 @@ export class RdDItemMaladie extends RdDItem {
       const souffrance = mal.system.identifie
         ? `de ${mal.name}`
         : `d'un mal inconnu`
-      ChatMessage.create({ content: `${mal.actor.name} souffre ${souffrance} (${Misc.typeName('Item', mal.type)}): vérifiez que les effets ne se sont pas aggravés !` });
-      mal.postItemToChat('gmroll');
-      await RdDItemMaladie.prolongerPeriode(mal,oldTimestamp, newTimestamp);
+      ChatMessage.create({
+        whisper: ChatUtility.getOwners(mal.actor),
+        content: `${mal.actor.name} souffre ${souffrance} (${Misc.typeName('Item', mal.type)}): vérifiez que les effets ne se sont pas aggravés !`
+      })
+      mal.postItemToChat('gmroll')
+      await RdDItemMaladie.prolongerPeriode(mal, oldTimestamp, newTimestamp)
     }
   }
 

module/migrations.js

@@ -2,7 +2,7 @@ import { RdDBaseActor } from "./actor/base-actor.js";
 import { LOG_HEAD, SYSTEM_RDD } from "./constants.js";
 import { Grammar } from "./grammar.js";
 import { Monnaie } from "./item-monnaie.js";
-import { RdDItem, TYPES } from "./item.js";
+import { RdDItem, ITEM_TYPES } from "./item.js";
 import { RdDTimestamp } from "./time/rdd-timestamp.js";
 import { RdDRaretes } from "./item/raretes.js";
 import { RdDCalendrier } from "./time/rdd-calendrier.js";
@@ -465,7 +465,7 @@ class _10_7_19_CategorieCompetenceCreature extends Migration {
 
   async migrate() {
     await this.applyItemsUpdates(items => items
-      .filter(it => TYPES.competencecreature == it.type)
+      .filter(it => ITEM_TYPES.competencecreature == it.type)
       .map(it => this.migrateCompetenceCreature(it))
     );
   }
@@ -502,7 +502,7 @@ class _10_7_19_PossessionsEntiteVictime extends Migration {
 
   async migrate() {
     await this.applyItemsUpdates(items => items
-      .filter(it => TYPES.possession == it.type)
+      .filter(it => ITEM_TYPES.possession == it.type)
       .map(it => this.migratePossession(it))
     );
   }

module/rdd-bonus.js

@@ -31,8 +31,8 @@ export class RdDBonus {
   }
 
   /* -------------------------------------------- */
-  static dmg(rollData, dmgActor, isEntiteIncarnee = false) {
-    const dmgArme = RdDBonus._dmgArme(rollData)
+  static dmg(rollData, actor, isEntiteIncarnee = false) {
+    const dmgArme = RdDBonus.dmgArme(rollData.arme)
     let dmg = {
       total: 0,
       dmgArme: dmgArme,
@@ -41,7 +41,7 @@ export class RdDBonus {
       dmgParticuliere: RdDBonus._dmgParticuliere(rollData),
       dmgSurprise: RdDBonus.dmgBonus(rollData.ajustements?.attaqueDefenseurSurpris.used),
       mortalite: RdDBonus._calculMortalite(rollData, isEntiteIncarnee),
-      dmgActor: RdDBonus._dmgPerso(dmgActor, rollData.selectedCarac?.label, dmgArme)
+      dmgActor: RdDBonus.bonusDmg(actor, rollData.selectedCarac?.label.toLowerCase(), dmgArme)
     }
     dmg.total = dmg.dmgSurprise + dmg.dmgTactique + dmg.dmgArme + dmg.dmgActor + dmg.dmgParticuliere;
     return dmg;
@@ -71,11 +71,11 @@ export class RdDBonus {
   }
 
   /* -------------------------------------------- */
-  static _dmgArme(rollData) {
-    if (rollData.arme) {
-      let dmgBase = rollData.arme.system.dommagesReels ?? Number(rollData.arme.system.dommages ?? 0);
+  static dmgArme(arme) {
+    if (arme) {
+      let dmgBase = arme.system.dommagesReels ?? Number(arme.system.dommages ?? 0);
       //Le bonus dégats magiques ne peut pas faire dépasser le bonus de l'arme (cf p.278)
-      return dmgBase + Math.min(dmgBase, rollData.arme.system.magique ? rollData.arme.system.ecaille_efficacite : 0);
+      return dmgBase + Math.min(dmgBase, arme.system.magique ? arme.system.ecaille_efficacite : 0);
     }
     return 0;
   }
@@ -86,13 +86,14 @@ export class RdDBonus {
   }
 
   /* -------------------------------------------- */
-  static _dmgPerso(dmgActor, categorie, dmgArme) {
+  static bonusDmg(actor, categorie, dmgArme) {
+    const dmgActor = actor.getBonusDegat()
     if (categorie == undefined) {
       return 0
     }
     switch (categorie) {
-      case "Tir": return 0;
-      case "Lancer": return Math.max(0, Math.min(dmgArme, dmgActor));
+      case "tir": return 0;
+      case "lancer": return Math.max(0, Math.min(dmgArme, dmgActor));
     }
     return dmgActor;
   }

module/rdd-carac.js

@@ -3,38 +3,38 @@ import { Misc } from "./misc.js";
 
 const TABLE_CARACTERISTIQUES_DERIVEES = {
   // xp: coût pour passer du niveau inférieur à ce niveau
-  1: { xp: 3, poids: "moins de 1kg", plusdom: -5, sconst: 0.5, sust: 0.1 },
-  2: { xp: 3, poids: "1-5", plusdom: -4, sconst: 0.5, sust: 0.3 },
-  3: { xp: 4, poids: "6-10", plusdom: -3, sconst: 1, sust: 0.5, beaute: 'hideux' },
-  4: { xp: 4, poids: "11-20", plusdom: -3, sconst: 1, sust: 1, beaute: 'repoussant' },
-  5: { xp: 5, poids: "21-30", plusdom: -2, sconst: 1, sust: 1, beaute: 'franchement très laid' },
-  6: { xp: 5, poids: "31-40", plusdom: -1, sconst: 2, sust: 2, beaute: 'laid' },
-  7: { xp: 6, poids: "41-50", plusdom: -1, sconst: 2, sust: 2, beaute: 'très désavantagé' },
-  8: { xp: 6, poids: "51-60", plusdom: 0, sconst: 2, sust: 2, beaute: 'désavantagé' },
-  9: { xp: 7, poids: "61-65", plusdom: 0, sconst: 3, sust: 2, beaute: 'pas terrible' },
-  10: { xp: 7, poids: "66-70", plusdom: 0, sconst: 3, sust: 3, beaute: 'commun' },
-  11: { xp: 8, poids: "71-75", plusdom: 0, sconst: 3, sust: 3, beaute: 'pas mal' },
-  12: { xp: 8, poids: "76-80", plusdom: +1, sconst: 4, sust: 3, beaute: 'avantagé' },
-  13: { xp: 9, poids: "81-90", plusdom: +1, sconst: 4, sust: 3, beaute: 'mignon' },
-  14: { xp: 9, poids: "91-100", plusdom: +2, sconst: 4, sust: 4, beaute: 'beau' },
-  15: { xp: 10, poids: "101-110", plusdom: +2, sconst: 5, sust: 4, beaute: 'très beau' },
-  16: { xp: 20, poids: "111-120", plusdom: +3, sconst: 5, sust: 4, beaute: 'éblouissant' },
-  17: { xp: 30, poids: "121-131", plusdom: +3, sconst: 5, sust: 5 },
-  18: { xp: 40, poids: "131-141", plusdom: +4, sconst: 6, sust: 5 },
-  19: { xp: 50, poids: "141-150", plusdom: +4, sconst: 6, sust: 5 },
-  20: { xp: 60, poids: "151-160", plusdom: +4, sconst: 6, sust: 6 },
-  21: { xp: 70, poids: "161-180", plusdom: +5, sconst: 7, sust: 6 },
-  22: { xp: 80, poids: "181-200", plusdom: +5, sconst: 7, sust: 7 },
-  23: { xp: 90, poids: "201-300", plusdom: +6, sconst: 7, sust: 8 },
-  24: { xp: 100, poids: "301-400", plusdom: +6, sconst: 8, sust: 9 },
-  25: { xp: 110, poids: "401-500", plusdom: +7, sconst: 8, sust: 10 },
-  26: { xp: 120, poids: "501-600", plusdom: +7, sconst: 8, sust: 11 },
-  27: { xp: 130, poids: "601-700", plusdom: +8, sconst: 9, sust: 12 },
-  28: { xp: 140, poids: "701-800", plusdom: +8, sconst: 9, sust: 13 },
-  29: { xp: 150, poids: "801-900", plusdom: +9, sconst: 9, sust: 14 },
-  30: { xp: 160, poids: "901-1000", plusdom: +9, sconst: 10, sust: 15 },
-  31: { xp: 170, poids: "1001-1500", plusdom: +10, sconst: 10, sust: 16 },
-  32: { xp: 180, poids: "1501-2000", plusdom: +11, sconst: 10, sust: 17 }
+  1: { xp: 3, poids: "moins de 1kg", poidsMin: 0, poidsMax: 1, plusdom: -5, sconst: 0.5, sust: 0.1 },
+  2: { xp: 3, poids: "1-5", poidsMin: 1, poidsMax: 5, plusdom: -4, sconst: 0.5, sust: 0.3 },
+  3: { xp: 4, poids: "6-10", poidsMin: 6, poidsMax: 10, plusdom: -3, sconst: 1, sust: 0.5, beaute: 'hideux' },
+  4: { xp: 4, poids: "11-20", poidsMin: 11, poidsMax: 20, plusdom: -3, sconst: 1, sust: 1, beaute: 'repoussant' },
+  5: { xp: 5, poids: "21-30", poidsMin: 21, poidsMax: 30, plusdom: -2, sconst: 1, sust: 1, beaute: 'franchement très laid' },
+  6: { xp: 5, poids: "31-40", poidsMin: 31, poidsMax: 40, plusdom: -1, sconst: 2, sust: 2, beaute: 'laid' },
+  7: { xp: 6, poids: "41-50", poidsMin: 41, poidsMax: 50, plusdom: -1, sconst: 2, sust: 2, beaute: 'très désavantagé' },
+  8: { xp: 6, poids: "51-60", poidsMin: 51, poidsMax: 60, plusdom: 0, sconst: 2, sust: 2, beaute: 'désavantagé' },
+  9: { xp: 7, poids: "61-65", poidsMin: 61, poidsMax: 65, plusdom: 0, sconst: 3, sust: 2, beaute: 'pas terrible' },
+  10: { xp: 7, poids: "66-70", poidsMin: 66, poidsMax: 70, plusdom: 0, sconst: 3, sust: 3, beaute: 'commun' },
+  11: { xp: 8, poids: "71-75", poidsMin: 71, poidsMax: 75, plusdom: 0, sconst: 3, sust: 3, beaute: 'pas mal' },
+  12: { xp: 8, poids: "76-80", poidsMin: 76, poidsMax: 80, plusdom: +1, sconst: 4, sust: 3, beaute: 'avantagé' },
+  13: { xp: 9, poids: "81-90", poidsMin: 81, poidsMax: 90, plusdom: +1, sconst: 4, sust: 3, beaute: 'mignon' },
+  14: { xp: 9, poids: "91-100", poidsMin: 91, poidsMax: 100, plusdom: +2, sconst: 4, sust: 4, beaute: 'beau' },
+  15: { xp: 10, poids: "101-110", poidsMin: 101, poidsMax: 110, plusdom: +2, sconst: 5, sust: 4, beaute: 'très beau' },
+  16: { xp: 20, poids: "111-120", poidsMin: 111, poidsMax: 120, plusdom: +3, sconst: 5, sust: 4, beaute: 'éblouissant' },
+  17: { xp: 30, poids: "121-131", poidsMin: 121, poidsMax: 131, plusdom: +3, sconst: 5, sust: 5 },
+  18: { xp: 40, poids: "131-141", poidsMin: 131, poidsMax: 141, plusdom: +4, sconst: 6, sust: 5 },
+  19: { xp: 50, poids: "141-150", poidsMin: 141, poidsMax: 150, plusdom: +4, sconst: 6, sust: 5 },
+  20: { xp: 60, poids: "151-160", poidsMin: 151, poidsMax: 160, plusdom: +4, sconst: 6, sust: 6 },
+  21: { xp: 70, poids: "161-180", poidsMin: 161, poidsMax: 180, plusdom: +5, sconst: 7, sust: 6 },
+  22: { xp: 80, poids: "181-200", poidsMin: 181, poidsMax: 200, plusdom: +5, sconst: 7, sust: 7 },
+  23: { xp: 90, poids: "201-300", poidsMin: 201, poidsMax: 300, plusdom: +6, sconst: 7, sust: 8 },
+  24: { xp: 100, poids: "301-400", poidsMin: 301, poidsMax: 400, plusdom: +6, sconst: 8, sust: 9 },
+  25: { xp: 110, poids: "401-500", poidsMin: 401, poidsMax: 500, plusdom: +7, sconst: 8, sust: 10 },
+  26: { xp: 120, poids: "501-600", poidsMin: 501, poidsMax: 600, plusdom: +7, sconst: 8, sust: 11 },
+  27: { xp: 130, poids: "601-700", poidsMin: 601, poidsMax: 700, plusdom: +8, sconst: 9, sust: 12 },
+  28: { xp: 140, poids: "701-800", poidsMin: 701, poidsMax: 800, plusdom: +8, sconst: 9, sust: 13 },
+  29: { xp: 150, poids: "801-900", poidsMin: 801, poidsMax: 900, plusdom: +9, sconst: 9, sust: 14 },
+  30: { xp: 160, poids: "901-1000", poidsMin: 901, poidsMax: 1000, plusdom: +9, sconst: 10, sust: 15 },
+  31: { xp: 170, poids: "1001-1500", poidsMin: 1001, poidsMax: 1500, plusdom: +10, sconst: 10, sust: 16 },
+  32: { xp: 180, poids: "1501-2000", poidsMin: 1501, poidsMax: 2000, plusdom: +11, sconst: 10, sust: 17 }
 };
 
 export class RdDCarac {

module/rdd-combat.js

@@ -54,10 +54,10 @@ export class RdDCombatManager extends Combat {
   /* -------------------------------------------- */
   async onPreDeleteCombat() {
     if (Misc.isUniqueConnectedGM()) {
-      await this.finDeRound({ terminer: true });
+      await this.finDeRound({ terminer: true })
       ChatUtility.removeChatMessageContaining(`<div data-combatid="${this.id}" data-combatmessage="actor-turn-summary">`)
       game.messages.filter(m => ChatUtility.getMessageData(m, 'attacker-roll') != undefined && ChatUtility.getMessageData(m, 'defender-roll') != undefined)
-        .forEach(it => it.delete());
+        .forEach(it => it.delete())
       RdDEmpoignade.deleteAllEmpoignades()
     }
   }
@@ -698,7 +698,7 @@ export class RdDCombat {
       if (this.defender.isEntite([ENTITE_BLURETTE])) {
         ChatMessage.create({
           content: `<strong>La cible est une blurette, l'arme à distance sera perdue dans le blurêve`,
-          whisper: ChatMessage.getWhisperRecipients("GM")
+          whisper: ChatUtility.getGMs()
         })
       }
       else {
@@ -721,7 +721,7 @@ export class RdDCombat {
             activite: activite,
             total: total
           }),
-          whisper: ChatMessage.getWhisperRecipients("GM")
+          whisper: ChatUtility.getGMs()
         })
       }
     }
@@ -846,7 +846,7 @@ export class RdDCombat {
 
     const choixParticuliere = await ChatMessage.create({
       alias: this.attacker.name,
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.attacker.name),
+      whisper: ChatUtility.getOwners(this.attacker),
       content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-demande-attaque-particuliere.html', {
         alias: this.attacker.name,
         attackerId: this.attackerId,
@@ -864,7 +864,7 @@ export class RdDCombat {
   async _onAttaqueNormale(attackerRoll) {
     console.log("RdDCombat.onAttaqueNormale >>>", attackerRoll);
 
-    attackerRoll.dmg = RdDBonus.dmg(attackerRoll, this.attacker.getBonusDegat(), this.defender.isEntite());
+    attackerRoll.dmg = RdDBonus.dmg(attackerRoll, this.attacker, this.defender.isEntite());
     let defenderRoll = { attackerRoll: attackerRoll, passeArme: attackerRoll.passeArme, show: {} }
     attackerRoll.show = {
       cible: this.target ? this.defender.name : 'la cible',
@@ -933,7 +933,7 @@ export class RdDCombat {
       // message privé: du défenseur à lui même (et aux GMs)
       speaker: ChatMessage.getSpeaker(this.defender, canvas.tokens.get(this.defenderTokenId)),
       alias: this.attacker.name,
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.defender.name),
+      whisper: ChatUtility.getOwners(this.defender),
       content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-demande-defense.html', paramDemandeDefense),
     });
     // flag pour garder les jets d'attaque/defense
@@ -976,7 +976,7 @@ export class RdDCombat {
   /* -------------------------------------------- */
   async _onAttaqueEchecTotal(attackerRoll) {
     const choixEchecTotal = await ChatMessage.create({
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.attacker.name),
+      whisper: ChatUtility.getOwners(this.attacker),
       content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-demande-attaque-etotal.html', {
         attackerId: this.attackerId,
         attacker: this.attacker,
@@ -994,9 +994,9 @@ export class RdDCombat {
     const arme = rollData.arme;
     const avecArme = !['', 'sans-armes', 'armes-naturelles'].includes(arme?.system.categorie_parade ?? '');
     const action = (rollData.attackerRoll ? (arme ? "la parade" : "l'esquive") : "l'attaque");
-    ChatUtility.createChatWithRollMode(this.defender.name, {
-      content: `<strong>Maladresse à ${action}!</strong> ` + await RdDRollTables.getMaladresse({ arme: avecArme })
-    });
+    ChatUtility.createChatWithRollMode(
+      { content: `<strong>Maladresse à ${action}!</strong> ` + await RdDRollTables.getMaladresse({ arme: avecArme }) },
+      this.defender)
   }
 
   /* -------------------------------------------- */
@@ -1076,9 +1076,9 @@ export class RdDCombat {
     console.log("RdDCombat._onParadeParticuliere >>>", defenderRoll);
     if (!defenderRoll.attackerRoll.isPart) {
       // TODO: attaquant doit jouer résistance et peut être désarmé p132
-      ChatUtility.createChatWithRollMode(this.defender.name, {
-        content: `(à gérer) L'attaquant doit jouer résistance et peut être désarmé (p132)`
-      });
+      ChatUtility.createChatWithRollMode(
+        { content: `(à gérer) L'attaquant doit jouer résistance et peut être désarmé (p132)` },
+        this.defender)
     }
   }
 
@@ -1152,9 +1152,9 @@ export class RdDCombat {
   /* -------------------------------------------- */
   _onEsquiveParticuliere(rollData) {
     console.log("RdDCombat._onEsquiveParticuliere >>>", rollData);
-    ChatUtility.createChatWithRollMode(this.defender.name, {
-      content: "<strong>Vous pouvez esquiver une deuxième fois!</strong>"
-    });
+    ChatUtility.createChatWithRollMode(
+      { content: "<strong>Vous pouvez esquiver une deuxième fois!</strong>" },
+      this.defender);
   }
 
   /* -------------------------------------------- */
@@ -1322,10 +1322,10 @@ export class RdDCombat {
     await ChatMessage.create({
       content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-turn-acteur.hbs`, formData),
       alias: actor.name
-    });
+    })
     await ChatMessage.create({
       content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-turn-sante.hbs`, formData),
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(actor.name),
+      whisper: ChatUtility.getOwners(actor),
       alias: actor.name
     });
   }

module/rdd-commands.js

@@ -17,6 +17,7 @@ import { RdDUtility } from "./rdd-utility.js";
 import { FenetreRechercheTirage } from "./tirage/fenetre-recherche-tirage.js";
 import { TMRUtility } from "./tmr-utility.js";
 import { DialogFatigueVoyage } from "./voyage/dialog-fatigue-voyage.js";
+import { ChatUtility } from "./chat-utility.js";
 
 const rddRollNumeric = /^(\d+)\s*([\+\-]?\d+)?\s*(s)?/;
 
@@ -81,7 +82,7 @@ export class RdDCommands {
 
     this.registerCommand({ path: ["/sommeil"], func: (content, msg, params) => this.sommeil(msg, params), descr: "Prépare le passage de journée pour chateau dormant" });
     this.registerCommand({ path: ["/meteo"], func: (content, msg, params) => this.getMeteo(msg, params), descr: "Propose une météo marine" });
-    this.registerCommand({ path: ["/nom"], func: (content, msg, params) => RdDNameGen.getName(msg, params), descr: "Génère un nom aléatoire" });
+    this.registerCommand({ path: ["/nom"], func: (content, msg, params) => RdDNameGen.proposeName(msg, params), descr: "Génère un nom aléatoire" });
 
     this.registerCommand({
       path: ["/tmr"], func: (content, msg, params) => this.findTMR(msg, params),
@@ -206,26 +207,20 @@ export class RdDCommands {
   /* Manage chat commands */
   processChatCommand(commandLine, content = '', msg = {}) {
     // Setup new message's visibility
-    let rollMode = game.settings.get("core", "rollMode");
-    if (["gmroll", "blindroll"].includes(rollMode)) {
-      msg["whisper"] = ChatMessage.getWhisperRecipients("GM");
-    }
-    if (rollMode === "blindroll") {
-      msg["blind"] = true;
-    }
-    msg["type"] = 0;
+    ChatUtility.applyRollMode(msg)
+    msg.type = 0;
 
     if (!this.commandsTable) {
-      this._registerCommands();
+      this._registerCommands()
     }
 
     let command = commandLine[0].toLowerCase();
     if (this._isCommandHandled(command)) {
       let params = commandLine.slice(1);
-      this._processCommand(this.commandsTable, command, params, content, msg);
-      return true;
+      this._processCommand(this.commandsTable, command, params, content, msg)
+      return true
     }
-    return false;
+    return false
   }
 
   _isCommandHandled(command) {
@@ -300,7 +295,7 @@ export class RdDCommands {
   async getRencontreTMR(params) {
     if (params.length == 1 || params.length == 2) {
       return game.system.rdd.rencontresTMR.rollRencontre(params[0], params[1])
-    }    
+    }
     return false;
   }
 

module/rdd-dice.js

@@ -2,19 +2,14 @@ import { ChatUtility } from "./chat-utility.js";
 import { HIDE_DICE, SHOW_DICE } from "./constants.js";
 import { Misc } from "./misc.js";
 
-function img(src) {
-  return `<img src="${src}" class="dice-img" />`
-}
-
-function iconHeure(heure) {
+const imgHeures = [1, 2, 3, 4, 5, 6, 7, 9, 9, 10, 11, 12].map(heure => {
   if (heure < 10) {
     heure = '0' + heure;
   }
-  return `systems/foundryvtt-reve-de-dragon/icons/heures/hd${heure}.webp`
-}
-const imagesHeures = [1, 2, 3, 4, 5, 6, 7, 9, 9, 10, 11, 12].map(it => iconHeure(it));
+  return `<img src="systems/foundryvtt-reve-de-dragon/icons/heures/hd${heure}.webp" class="dice-img" />`
+})
 
-const imgSigneDragon = img(imagesHeures[4]);
+const imgSigneDragon = imgHeures[4]
 
 /** De pour les jets de rencontre */
 export class DeTMR extends Die {
@@ -25,7 +20,7 @@ export class DeTMR extends Die {
     return {
       type: "dt",
       font: "HeuresDraconiques",
-      fontScale: 0.7,
+      fontScale: 0.8,
       labels: ['1', '2', '3', '4', '5', '6', 'd', '0'],
       system: system
     }
@@ -37,13 +32,13 @@ export class DeTMR extends Die {
   }
 
   async evaluate(options) {
-    await super.evaluate(options);
-    this.explode("x=8");
+    await super.evaluate(options)
+    await this.reroll('r=8', { recursive: true })
     return this;
   }
 
   get total() {
-    return this.values.filter(it => it != 8).reduce(Misc.sum(), 0);
+    return this.values.map(it => Misc.modulo(it, 8)).reduce(Misc.sum(), 0);
   }
 
   getResultLabel(diceTerm) {
@@ -56,13 +51,14 @@ export class DeTMR extends Die {
 
 /** DeDraconique pour le D8 sans limite avec 8=>0 */
 export class DeDraconique extends Die {
+  /** @override */
   static DENOMINATION = "r";
 
   static diceSoNiceData(system) {
     return {
       type: "dr",
       font: "HeuresDraconiques",
-      fontScale: 0.7,
+      fontScale: 0.8,
       labels: ['1', '2', '3', '4', '5', '6', 'd', '0'],
       system: system
     }
@@ -75,7 +71,7 @@ export class DeDraconique extends Die {
 
   async evaluate(options) {
     await super.evaluate(options);
-    this.explode("x=7");
+    await this.explode("x=7");
     return this;
   }
 
@@ -85,7 +81,7 @@ export class DeDraconique extends Die {
 
   getResultLabel(diceTerm) {
     switch (diceTerm.result) {
-      case 7: return imgSigneDragon;
+      case 7: return imgSigneDragon
       case 8: return '0';
     }
     return diceTerm.result.toString();
@@ -102,6 +98,7 @@ export class DeHeure extends Die {
     return {
       type: "dh",
       font: "HeuresDraconiques",
+      fontScale: 1.2,
       labels: ['v', 'i', 'f', 'o', 'd', 'e', 'l', 's', 'p', 'a', 'r', 'c'],
       system: system
     }
@@ -113,15 +110,15 @@ export class DeHeure extends Die {
   }
 
   getResultLabel(diceTerm) {
-    return img(imagesHeures[diceTerm.result - 1]);
+    return imgHeures[diceTerm.result - 1]
   }
 }
 
 export class RdDDice {
   static init() {
-    CONFIG.Dice.terms[DeTMR.DENOMINATION] = DeTMR;
-    CONFIG.Dice.terms[DeDraconique.DENOMINATION] = DeDraconique;
-    CONFIG.Dice.terms[DeHeure.DENOMINATION] = DeHeure;
+    CONFIG.Dice.terms[DeTMR.DENOMINATION] = DeTMR
+    CONFIG.Dice.terms[DeDraconique.DENOMINATION] = DeDraconique
+    CONFIG.Dice.terms[DeHeure.DENOMINATION] = DeHeure
   }
 
   static onReady() {
@@ -132,6 +129,18 @@ export class RdDDice {
     }
   }
 
+  static diceSoNiceReady(dice3d) {
+    dice3d.DiceFactory.systems.keys().forEach(system => {
+      dice3d.addDicePreset(DeTMR.diceSoNiceData(system));
+      dice3d.addDicePreset(DeDraconique.diceSoNiceData(system));
+      dice3d.addDicePreset(DeHeure.diceSoNiceData(system));
+    })
+  }
+
+  static async rollHeure(options = { showDice: HIDE_DICE }) {
+    return await RdDDice.rollTotal("1dh", options) - 1
+  }
+
   static async rollTotal(formula, options = { showDice: HIDE_DICE }) {
     return (await RdDDice.roll(formula, options)).total;
   }
@@ -151,21 +160,13 @@ export class RdDDice {
     return array[roll - 1];
   }
 
-  static diceSoNiceReady(dice3d) {
-    for (const system of Object.keys(dice3d.DiceFactory.systems)) {
-      dice3d.addDicePreset(DeTMR.diceSoNiceData(system));
-      dice3d.addDicePreset(DeDraconique.diceSoNiceData(system));
-      dice3d.addDicePreset(DeHeure.diceSoNiceData(system));
-    }
-  }
-
   /* -------------------------------------------- */
   static async showDiceSoNice(roll, options) {
     if (options.showDice == HIDE_DICE || !game.modules.get("dice-so-nice")?.active || !game.dice3d) {
       return;
     }
 
-    let { whisper, blind } = RdDDice._getWhisperBlind(options);
+    let { whisper, blind } = ChatUtility.applyRollMode({}, options?.rollMode);
     if (options.forceDiceResult?.total) {
       let terms = await RdDDice._getForcedTerms(options);
       if (terms) {
@@ -219,24 +220,4 @@ export class RdDDice {
     await roll.evaluate();
     return roll.total;
   }
-
-  static _getWhisperBlind(options) {
-    let whisper = undefined;
-    let blind = false;
-    let rollMode = options.rollMode ?? game.settings.get("core", "rollMode");
-    switch (rollMode) {
-      case "blindroll": //GM only
-        blind = true;
-      case "gmroll": //GM + rolling player
-        whisper = ChatUtility.getUsers(user => user.isGM);
-        break;
-      case "roll": //everybody
-        whisper = ChatUtility.getUsers(user => user.active);
-        break;
-      case "selfroll":
-        whisper = [game.user.id];
-        break;
-    }
-    return { whisper, blind };
-  }
 }

module/rdd-empoignade.js

@@ -5,7 +5,7 @@ import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
 import { ChatUtility } from "./chat-utility.js";
 import { STATUSES } from "./settings/status-effects.js";
 import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
-import { TYPES } from "./item.js";
+import { ITEM_TYPES } from "./item.js";
 
 /* -------------------------------------------- */
 
@@ -92,18 +92,18 @@ export class RdDEmpoignade {
 
   /* -------------------------------------------- */
   static isEmpoignadeEnCours(actor) {
-    return actor.itemTypes[TYPES.empoignade].find(it => it.system.pointsemp > 0)
+    return actor.itemTypes[ITEM_TYPES.empoignade].find(it => it.system.pointsemp > 0)
   }
 
   /* -------------------------------------------- */
   static getEmpoignadeById(actor, id) {
-    let emp = actor.itemTypes[TYPES.empoignade].find(it => it.system.empoignadeid == id)
+    let emp = actor.itemTypes[ITEM_TYPES.empoignade].find(it => it.system.empoignadeid == id)
     return emp && foundry.utils.duplicate(emp) || undefined;
   }
 
   /* -------------------------------------------- */
   static getEmpoignade(attacker, defender) {
-    let emp = attacker.itemTypes[TYPES.empoignade].find(it =>
+    let emp = attacker.itemTypes[ITEM_TYPES.empoignade].find(it =>
       (it.system.empoigneurid == attacker.id && it.system.empoigneid == defender.id) ||
       (it.system.empoigneurid == defender.id && it.system.empoigneid == attacker.id)
     )
@@ -158,9 +158,12 @@ export class RdDEmpoignade {
     empoignade = empoignade ?? (await RdDEmpoignade.createEmpoignade(attacker, defender))
     //console.log("W.", empoignade, defender.hasArmeeMeleeEquipee())
     if ((isNouvelle || empoignade.system.pointsemp == 0) && defender.hasArmeeMeleeEquipee()) {
-      ChatUtility.createChatWithRollMode(attacker.name, {
-        content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-empoignade-valider.html`, { attacker: attacker, defender: defender })
-      })
+      ChatUtility.createChatWithRollMode(
+        {
+          content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-empoignade-valider.html`, { attacker: attacker, defender: defender })
+        },
+        attacker
+      )
     } else {
       await this.onAttaqueEmpoignadeValidee(attacker, defender)
     }
@@ -213,7 +216,7 @@ export class RdDEmpoignade {
       competence: attacker.getCompetenceCorpsACorps()
     }
     const msg = await ChatMessage.create({
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(attacker.name),
+      whisper: ChatUtility.getOwners(attacker),
       content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-empoignade-immobilise.html`, rollData)
     })
     RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
@@ -300,7 +303,7 @@ export class RdDEmpoignade {
   /* -------------------------------------------- */
   static async $onRollContrerLiberer(rollData) {
     let empoignade = rollData.empoignade
-    
+
     if (rollData.mode == "contrer-empoigner" && !rollData.rolled.isSuccess) {
       empoignade.system.pointsemp++
       RdDEmpoignade.$updateEtatEmpoignade(empoignade)
@@ -309,7 +312,7 @@ export class RdDEmpoignade {
       empoignade.system.pointsemp--
       RdDEmpoignade.$updateEtatEmpoignade(empoignade)
     }
-    
+
     await RdDResolutionTable.displayRollData(rollData, rollData.defender, 'chat-empoignade-resultat.html')
     if (empoignade.system.pointsemp >= 2) {
       let msg = await RdDResolutionTable.displayRollData(rollData, rollData.attacker, 'chat-empoignade-entrainer.html');

module/rdd-herbes.js

@@ -6,7 +6,7 @@ import { RdDTimestamp } from "./time/rdd-timestamp.js";
 export class RdDHerbes extends Item {
 
   /* -------------------------------------------- */
-  static async initializeHerbes() {
+  static async onReady() {
     this.herbesSoins = await RdDHerbes.listCategorieHerbes('Soin');
     this.herbesRepos = await RdDHerbes.listCategorieHerbes('Repos');
   }

module/rdd-hotbar-drop.js

@@ -1,6 +1,6 @@
 import { RdDItemArme } from "./item-arme.js";
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
-import { TYPES } from "./item.js";
+import { ITEM_TYPES } from "./item.js";
 
 export class RdDHotbar {
 
@@ -35,7 +35,7 @@ export class RdDHotbar {
 
   static async addToHotbar(item, slot) {
     switch (item?.type ?? '') {
-      case TYPES.arme:
+      case ITEM_TYPES.arme:
         {
           // Les armes peuvent avoir plusieurs usages
           if (item.system.competence != '') {
@@ -54,12 +54,12 @@ export class RdDHotbar {
           }
         }
         return
-      case TYPES.competencecreature:
+      case ITEM_TYPES.competencecreature:
         const categorie = RdDItemCompetenceCreature.getCategorieAttaque(item) ?? 'competence';
         await this.createItemMacro(item, slot, categorie)
         return
       default:
-      case TYPES.competence:
+      case ITEM_TYPES.competence:
         await this.createItemMacro(item, slot++, 'competence')
         if (item.isCorpsACorps()) {
           await this.createItemMacro(item, slot++, 'pugilat')
@@ -79,8 +79,7 @@ export class RdDHotbar {
    * Actor     - open actor sheet
    * Journal   - open journal sheet
    */
-  static initDropbar() {
-
+  static initHooks() {
     Hooks.on('hotbarDrop', (bar, documentData, slot) => {
 
       // Create item macro if rollable item - weapon, spell, prayer, trait, or skill
@@ -88,9 +87,9 @@ export class RdDHotbar {
         const item = fromUuidSync(documentData.uuid) ?? this.actor.items.get(documentData.uuid)
         console.log('DROP', documentData, item)
         switch (item?.type) {
-          case TYPES.arme:
-          case TYPES.competence:
-          case TYPES.competencecreature:
+          case ITEM_TYPES.arme:
+          case ITEM_TYPES.competence:
+          case ITEM_TYPES.competencecreature:
             this.addToHotbar(item, slot)
             return false
         }
@@ -116,9 +115,9 @@ export class RdDHotbar {
 
     // Trigger the item roll
     switch (item.type) {
-      case TYPES.arme:
+      case ITEM_TYPES.arme:
         return actor.rollArme(item, categorieArme);
-      case TYPES.competence:
+      case ITEM_TYPES.competence:
         if (item.isCorpsACorps()) {
           switch (categorieArme) {
             case 'pugilat':
@@ -128,7 +127,7 @@ export class RdDHotbar {
           }
         }
         return actor.rollCompetence(item);
-      case TYPES.competencecreature:
+      case ITEM_TYPES.competencecreature:
         return item.system.iscombat && !item.system.isparade
           ? actor.rollArme(item, categorieArme)
           : actor.rollCompetence(item);

module/rdd-main.js

@@ -1,69 +1,73 @@
-import { SYSTEM_RDD, SYSTEM_SOCKET_ID, RDD_CONFIG } from "./constants.js";
-import { Migrations } from './migrations.js';
+import { SYSTEM_RDD, SYSTEM_SOCKET_ID, RDD_CONFIG } from "./constants.js"
+import { Migrations } from './migrations.js'
 
-import { RdDUtility } from "./rdd-utility.js";
-import { TMRUtility } from "./tmr-utility.js";
-import { TMRRencontres } from "./tmr-rencontres.js";
-import { RdDCalendrier } from "./time/rdd-calendrier.js";
-import { RdDTimestamp } from "./time/rdd-timestamp.js";
-import { DialogChronologie } from "./dialog-chronologie.js";
+import { RdDUtility } from "./rdd-utility.js"
+import { TMRUtility } from "./tmr-utility.js"
+import { TMRRencontres } from "./tmr-rencontres.js"
+import { RdDCalendrier } from "./time/rdd-calendrier.js"
+import { RdDTimestamp } from "./time/rdd-timestamp.js"
+import { DialogChronologie } from "./dialog-chronologie.js"
 
-import { RdDResolutionTable } from "./rdd-resolution-table.js";
-import { RdDTokenHud } from "./rdd-token-hud.js";
-import { RdDCommands } from "./rdd-commands.js";
-import { RdDCombatManager, RdDCombat } from "./rdd-combat.js";
-import { ChatUtility } from "./chat-utility.js";
-import { StatusEffects } from "./settings/status-effects.js";
-import { RdDCompendiumOrganiser } from "./rdd-compendium-organiser.js";
-import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
+import { RdDResolutionTable } from "./rdd-resolution-table.js"
+import { RdDTokenHud } from "./rdd-token-hud.js"
+import { RdDCommands } from "./rdd-commands.js"
+import { RdDCombatManager, RdDCombat } from "./rdd-combat.js"
+import { ChatUtility } from "./chat-utility.js"
+import { StatusEffects } from "./settings/status-effects.js"
+import { RdDCompendiumOrganiser } from "./rdd-compendium-organiser.js"
+import { ReglesOptionnelles } from "./settings/regles-optionnelles.js"
 import { RdDHotbar } from "./rdd-hotbar-drop.js"
-import { EffetsDraconiques } from "./tmr/effets-draconiques.js";
-import { RdDHerbes } from "./rdd-herbes.js";
-import { RdDDice } from "./rdd-dice.js";
-import { RdDPossession } from "./rdd-possession.js";
-import { Misc } from "./misc.js";
+import { EffetsDraconiques } from "./tmr/effets-draconiques.js"
+import { RdDHerbes } from "./rdd-herbes.js"
+import { RdDDice } from "./rdd-dice.js"
+import { RdDPossession } from "./rdd-possession.js"
+import { Misc } from "./misc.js"
 
-import { SystemCompendiums } from "./settings/system-compendiums.js";
-import { Environnement } from "./environnement.js";
+import { SystemCompendiums } from "./settings/system-compendiums.js"
+import { Environnement } from "./environnement.js"
 
-import { RdDActor } from "./actor.js";
-import { RdDBaseActor } from "./actor/base-actor.js";
-import { RdDCommerce } from "./actor/commerce.js";
-import { RdDEntite } from "./actor/entite.js";
-import { RdDVehicule } from "./actor/vehicule.js";
-import { RdDActorSheet } from "./actor-sheet.js";
-import { RdDCommerceSheet } from "./actor/commerce-sheet.js";
-import { RdDCreatureSheet } from "./actor/creature-sheet.js";
-import { RdDActorEntiteSheet } from "./actor/entite-sheet.js";
-import { RdDActorVehiculeSheet } from "./actor/vehicule-sheet.js";
+import { RdDActor } from "./actor.js"
+import { RdDBaseActor } from "./actor/base-actor.js"
+import { RdDCommerce } from "./actor/commerce.js"
+import { RdDEntite } from "./actor/entite.js"
+import { RdDVehicule } from "./actor/vehicule.js"
+import { RdDActorSheet } from "./actor-sheet.js"
+import { RdDCommerceSheet } from "./actor/commerce-sheet.js"
+import { RdDCreatureSheet } from "./actor/creature-sheet.js"
+import { RdDActorEntiteSheet } from "./actor/entite-sheet.js"
+import { RdDActorVehiculeSheet } from "./actor/vehicule-sheet.js"
 
-import { RdDItem } from "./item.js";
-import { RdDItemBlessure } from "./item/blessure.js";
-import { RdDItemService } from "./item/service.js";
-import { RdDItemMaladie } from "./item/maladie.js";
-import { RdDItemPoison } from "./item/poison.js";
-import { RdDItemSigneDraconique } from "./item/signedraconique.js";
-import { RdDItemQueue } from "./item/queue.js";
-import { RdDItemOmbre } from "./item/ombre.js";
-import { RdDItemSouffle } from "./item/souffle.js";
-import { RdDRencontre } from "./item/rencontre.js";
+import { RdDItem } from "./item.js"
+import { RdDItemBlessure } from "./item/blessure.js"
+import { RdDItemService } from "./item/service.js"
+import { RdDItemMaladie } from "./item/maladie.js"
+import { RdDItemPoison } from "./item/poison.js"
+import { RdDItemSigneDraconique } from "./item/signedraconique.js"
+import { RdDItemQueue } from "./item/queue.js"
+import { RdDItemOmbre } from "./item/ombre.js"
+import { RdDItemSouffle } from "./item/souffle.js"
+import { RdDRencontre } from "./item/rencontre.js"
 
-import { RdDItemSheet } from "./item-sheet.js";
-import { RdDBlessureItemSheet } from "./item/sheet-blessure.js";
-import { RdDServiceItemSheet } from "./item/sheet-service.js";
-import { RdDRencontreItemSheet } from "./item/sheet-rencontre.js";
-import { RdDHerbeItemSheet } from "./item/sheet-herbe.js";
-import { RdDPlanteItemSheet } from "./item/sheet-plante.js";
-import { RdDIngredientItemSheet } from "./item/sheet-ingredient.js";
-import { RdDFauneItemSheet } from "./item/sheet-faune.js";
-import { RdDConteneurItemSheet } from "./item/sheet-conteneur.js";
-import { RdDSigneDraconiqueItemSheet } from "./item/sheet-signedraconique.js";
-import { RdDItemInventaireSheet } from "./item/sheet-base-inventaire.js";
-import { AppAstrologie } from "./sommeil/app-astrologie.js";
-import { RdDItemArmure } from "./item/armure.js";
-import { AutoAdjustDarkness as AutoAdjustDarkness } from "./time/auto-adjust-darkness.js";
-import { RdDCreature } from "./actor/creature.js";
-import { RdDTMRDialog } from "./rdd-tmr-dialog.js";
+import { RdDItemSheet } from "./item-sheet.js"
+import { RdDBlessureItemSheet } from "./item/sheet-blessure.js"
+import { RdDServiceItemSheet } from "./item/sheet-service.js"
+import { RdDRencontreItemSheet } from "./item/sheet-rencontre.js"
+import { RdDHerbeItemSheet } from "./item/sheet-herbe.js"
+import { RdDPlanteItemSheet } from "./item/sheet-plante.js"
+import { RdDIngredientItemSheet } from "./item/sheet-ingredient.js"
+import { RdDFauneItemSheet } from "./item/sheet-faune.js"
+import { RdDConteneurItemSheet } from "./item/sheet-conteneur.js"
+import { RdDSigneDraconiqueItemSheet } from "./item/sheet-signedraconique.js"
+import { RdDItemInventaireSheet } from "./item/sheet-base-inventaire.js"
+import { AppAstrologie } from "./sommeil/app-astrologie.js"
+import { RdDItemArmure } from "./item/armure.js"
+import { AutoAdjustDarkness } from "./time/auto-adjust-darkness.js"
+import { RdDCreature } from "./actor/creature.js"
+import { RdDTMRDialog } from "./rdd-tmr-dialog.js"
+import { OptionsAvancees } from "./settings/options-avancees.js"
+import { ExportScriptarium } from "./actor/export-scriptarium/export-scriptarium.js"
+import { AppPersonnageAleatoire } from "./actor/random/app-personnage-aleatoire.js"
+import { RdDActorExportSheet } from "./actor/export-scriptarium/actor-encart-sheet.js"
 
 /**
  * RdD system
@@ -71,18 +75,18 @@ import { RdDTMRDialog } from "./rdd-tmr-dialog.js";
  * Software License: GNU GPLv3
  */
 export class SystemReveDeDragon {
-  
+
   static start() {
     const system = new SystemReveDeDragon()
     Hooks.once('init', async () => await system.onInit())
     Hooks.once('diceSoNiceReady', (dice3d) => RdDDice.diceSoNiceReady(dice3d))
-    Hooks.once('ready', () => system.onReady())
+    Hooks.once('ready', async () => await system.onReady())
   }
-  
+
   constructor() {
-    this.config = RDD_CONFIG; 
-    this.RdDUtility = RdDUtility;
-    this.RdDHotbar = RdDHotbar;
+    this.config = RDD_CONFIG
+    this.RdDUtility = RdDUtility
+    this.RdDHotbar = RdDHotbar
     this.itemClasses = {
       armure: RdDItemArmure,
       blessure: RdDItemBlessure,
@@ -108,42 +112,51 @@ export class SystemReveDeDragon {
   /*  Foundry VTT Initialization                  */
   /* -------------------------------------------- */
   async onInit() {
-    game.system.rdd = this;
-    this.AppAstrologie = AppAstrologie;    
+    game.system.rdd = this
+    this.AppAstrologie = AppAstrologie
 
-
-    console.log(`Initializing Reve de Dragon System`);
+    console.log(`Initializing Reve de Dragon System Settings`)
 
     // preload handlebars templates
-    RdDUtility.preloadHandlebarsTemplates();
+    RdDUtility.preloadHandlebarsTemplates()
+    AppPersonnageAleatoire.preloadHandlebars()
 
     /* -------------------------------------------- */
-    this.initSystemSettings();
+    ReglesOptionnelles.initSettings()
+    OptionsAvancees.initSettings()
+    AutoAdjustDarkness.initSettings()
+    RdDTimestamp.initSettings()
+    RdDCalendrier.initSettings()
+    SystemCompendiums.initSettings()
+    DialogChronologie.initSettings()
+    RdDTMRDialog.initSettings()
+    Environnement.initSettings()
+
+    this.initSettings()
 
     /* -------------------------------------------- */
     // Set an initiative formula for the system 
-    CONFIG.Combat.initiative = {
-      formula: "1+(1d6/10)",
-      decimals: 2
-    };
+    CONFIG.Combat.initiative = { formula: "1+(1d6/10)", decimals: 2 }
 
     /* -------------------------------------------- */
+    console.log(`Initializing Reve de Dragon Socket handlers`)
     game.socket.on(SYSTEM_SOCKET_ID, async (sockmsg) => {
-      console.log(">>>>> MSG RECV", sockmsg);
+      console.log(">>>>> MSG RECV", sockmsg)
       try {
-        RdDUtility.onSocketMessage(sockmsg);
-        RdDCombat.onSocketMessage(sockmsg);
-        ChatUtility.onSocketMessage(sockmsg);
-        RdDBaseActor.onSocketMessage(sockmsg);
+        RdDUtility.onSocketMessage(sockmsg)
+        RdDCombat.onSocketMessage(sockmsg)
+        ChatUtility.onSocketMessage(sockmsg)
+        RdDBaseActor.onSocketMessage(sockmsg)
       } catch (e) {
         console.error('game.socket.on(SYSTEM_SOCKET_ID) Exception: ', sockmsg, ' => ', e)
       }
-    });
+    })
 
     /* -------------------------------------------- */
     // Define custom Entity classes
-    CONFIG.Actor.documentClass = RdDBaseActor;
-    CONFIG.Item.documentClass = RdDItem;
+    console.log(`Initializing Reve de Dragon Documents`)
+    CONFIG.Actor.documentClass = RdDBaseActor
+    CONFIG.Item.documentClass = RdDItem
     CONFIG.RDD = {
       resolutionTable: RdDResolutionTable.resolutionTable,
       carac_array: RdDUtility.getCaracArray(),
@@ -153,30 +166,31 @@ export class SystemReveDeDragon {
 
     /* -------------------------------------------- */
     // Register sheet application classes
-    Actors.unregisterSheet("core", ActorSheet);
-    Actors.registerSheet(SYSTEM_RDD, RdDCommerceSheet, { types: ["commerce"], makeDefault: true });
-    Actors.registerSheet(SYSTEM_RDD, RdDActorSheet, { types: ["personnage"], makeDefault: true });
-    Actors.registerSheet(SYSTEM_RDD, RdDCreatureSheet, { types: ["creature"], makeDefault: true });
-    Actors.registerSheet(SYSTEM_RDD, RdDActorVehiculeSheet, { types: ["vehicule"], makeDefault: true });
-    Actors.registerSheet(SYSTEM_RDD, RdDActorEntiteSheet, { types: ["entite"], makeDefault: true });
-    Items.unregisterSheet("core", ItemSheet);
+    Actors.unregisterSheet("core", ActorSheet)
+    Actors.registerSheet(SYSTEM_RDD, RdDCommerceSheet, { types: ["commerce"], makeDefault: true })
+    Actors.registerSheet(SYSTEM_RDD, RdDActorSheet, { types: ["personnage"], makeDefault: true })
+    Actors.registerSheet(SYSTEM_RDD, RdDCreatureSheet, { types: ["creature"], makeDefault: true })
+    Actors.registerSheet(SYSTEM_RDD, RdDActorVehiculeSheet, { types: ["vehicule"], makeDefault: true })
+    Actors.registerSheet(SYSTEM_RDD, RdDActorEntiteSheet, { types: ["entite"], makeDefault: true })
+    Items.unregisterSheet("core", ItemSheet)
+    await RdDActorExportSheet.init()
 
-    RdDItemSheet.register(RdDSigneDraconiqueItemSheet);
-    RdDItemSheet.register(RdDRencontreItemSheet);
-    RdDItemSheet.register(RdDConteneurItemSheet);
-    RdDItemSheet.register(RdDHerbeItemSheet);
-    RdDItemSheet.register(RdDFauneItemSheet);
-    RdDItemSheet.register(RdDPlanteItemSheet);
-    RdDItemSheet.register(RdDIngredientItemSheet);
-    RdDItemSheet.register(RdDServiceItemSheet);
-    RdDItemSheet.register(RdDBlessureItemSheet);
+    RdDItemSheet.register(RdDSigneDraconiqueItemSheet)
+    RdDItemSheet.register(RdDRencontreItemSheet)
+    RdDItemSheet.register(RdDConteneurItemSheet)
+    RdDItemSheet.register(RdDHerbeItemSheet)
+    RdDItemSheet.register(RdDFauneItemSheet)
+    RdDItemSheet.register(RdDPlanteItemSheet)
+    RdDItemSheet.register(RdDIngredientItemSheet)
+    RdDItemSheet.register(RdDServiceItemSheet)
+    RdDItemSheet.register(RdDBlessureItemSheet)
 
     Items.registerSheet(SYSTEM_RDD, RdDItemInventaireSheet, {
       types: [
         "objet", "arme", "armure", "livre", "potion", "munition",
         "monnaie", "nourritureboisson", "gemme",
       ], makeDefault: true
-    });
+    })
     Items.registerSheet(SYSTEM_RDD, RdDItemSheet, {
       types: [
         "competence", "competencecreature",
@@ -185,34 +199,29 @@ export class SystemReveDeDragon {
         "nombreastral", "tache", "maladie", "poison", "possession",
         "tarot", "extraitpoetique", "empoignade"
       ], makeDefault: true
-    });
-    CONFIG.Combat.documentClass = RdDCombatManager;
+    })
 
     // préparation des différents modules
-    AutoAdjustDarkness.init();
-    RdDTimestamp.init();
-    RdDCalendrier.init();
-    SystemCompendiums.init();
-    DialogChronologie.init();
-    ReglesOptionnelles.init();
-    RdDUtility.init();
-    RdDDice.init();
-    RdDCommands.init();
-    RdDCombatManager.init();
-    RdDTokenHud.init();
-    RdDBaseActor.init();
-    RdDCompendiumOrganiser.init();
+    console.log(`Initializing Reve de Dragon Hooks and handlers`)
+    CONFIG.Combat.documentClass = RdDCombatManager
+    ChatUtility.init()
+    RdDUtility.initHooks()
+    RdDDice.init()
+    RdDCommands.init()
+    RdDCombatManager.init()
+    RdDTokenHud.init()
+    RdDBaseActor.init()
+    RdDCompendiumOrganiser.init()
     EffetsDraconiques.init()
-    TMRUtility.init();
-    await RdDTMRDialog.init()
-    RdDHotbar.initDropbar();
-    RdDPossession.init();
-    TMRRencontres.init();
-    Environnement.init();
-
+    TMRUtility.init()
+    RdDHotbar.initHooks()
+    RdDPossession.init()
+    TMRRencontres.init()
+    ExportScriptarium.init()
   }
 
-  initSystemSettings() {
+  initSettings() {
+    // TODO: déplacer vers les modules correspondants
     game.settings.register(SYSTEM_RDD, "accorder-entite-cauchemar", {
       name: "Accorder le rêve aux entités",
       hint: "A quel moment les personnages doivent accorder leur rêve aux entités de cauchemar",
@@ -225,7 +234,7 @@ export class SystemReveDeDragon {
         "avant-encaissement": "Avant l'encaissement",
       },
       default: "avant-encaissement"
-    });
+    })
 
     /* -------------------------------------------- */
     game.settings.register(SYSTEM_RDD, "supprimer-dialogues-combat-chat", {
@@ -235,7 +244,7 @@ export class SystemReveDeDragon {
       config: true,
       default: true,
       type: Boolean
-    });
+    })
 
     /* -------------------------------------------- */
     game.settings.register(SYSTEM_RDD, "activer-sons-audio", {
@@ -245,7 +254,8 @@ export class SystemReveDeDragon {
       config: true,
       default: true,
       type: Boolean
-    });
+    })
+
     /* -------------------------------------------- */
     game.settings.register(SYSTEM_RDD, "appliquer-famine-soif", {
       name: "Notifier de la famine et la soif pour",
@@ -259,7 +269,7 @@ export class SystemReveDeDragon {
         "famine-soif": "la famine et la soif",
       },
       default: "aucun"
-    });
+    })
   }
 
   async onReady() {
@@ -267,47 +277,46 @@ export class SystemReveDeDragon {
     /* -------------------------------------------- */
     /*  Foundry VTT Initialization                  */
     /* -------------------------------------------- */
-    game.system.rdd.calendrier = new RdDCalendrier();
+    game.system.rdd.calendrier = new RdDCalendrier()
     if (Misc.isUniqueConnectedGM()) {
-      new Migrations().migrate();
-      this.messageDeBienvenue();
-      import("https://www.uberwald.me/fvtt_appcount/count-class-ready.js").then(moduleCounter=>{
+      new Migrations().migrate()
+      this.messageDeBienvenue()
+      import("https://www.uberwald.me/fvtt_appcount/count-class-ready.js").then(moduleCounter => {
         console.log("ClassCounter loaded", moduleCounter)
         moduleCounter.ClassCounter.registerUsageCount()
-      }).catch(err=>
+      }).catch(err =>
         console.log("No stats available, giving up.")
-      )    
+      )
     }
 
-    StatusEffects.onReady();
-    RdDHerbes.initializeHerbes();
-    RdDDice.onReady();
+    StatusEffects.onReady()
+    RdDHerbes.onReady()
+    RdDDice.onReady()
     /* -------------------------------------------- */
     /* Affiche/Init le calendrier */
-    game.system.rdd.calendrier.display();
+    game.system.rdd.calendrier.display()
     // Avertissement si joueur sans personnage
     if (!game.user.isGM && game.user.character == undefined) {
-      ui.notifications.info("Attention ! Vous n'êtes connecté à aucun personnage !");
+      ui.notifications.info("Attention ! Vous n'êtes connecté à aucun personnage !")
       ChatMessage.create({
         content: "<b>ATTENTION</b> Le joueur " + game.user.name + " n'est connecté à aucun personnage !",
         user: game.user.id
-      });
+      })
     }
   }
 
   /* -------------------------------------------- */
   messageDeBienvenue() {
     if (game.user.isGM) {
-      ChatUtility.removeChatMessageContaining('<div id="message-bienvenue-rdd">');
+      ChatUtility.removeChatMessageContaining('<div id="message-bienvenue-rdd">')
       ChatMessage.create({
         user: game.user.id,
         content: `<div id="message-bienvenue-rdd"><span class="rdd-roll-part">Bienvenue dans le Rêve des Dragons !</span>
       <br>Vous trouverez quelques informations pour démarrer dans ce document : @Compendium[foundryvtt-reve-de-dragon.rappel-des-regles.7uGrUHGdPu0EmIu2]{Documentation MJ/Joueurs}
       <br>La commande <code>/aide</code> dans le chat permet de voir les commandes spécifiques à Rêve de Dragon.</div>
-      ` });
+      ` })
     }
   }
 }
 
-SystemReveDeDragon.start();
-
+SystemReveDeDragon.start()

module/rdd-meteo.js

@@ -1,3 +1,4 @@
+import { ChatUtility } from "./chat-utility.js"
 
 const vents = [
   { min: 0, max: 0, valeur: 'Calme' },
@@ -117,7 +118,7 @@ export class RdDMeteo {
 
     ChatMessage.create({
       content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-resultat-meteo.html', meteo),
-      whisper: ChatMessage.getWhisperRecipients('GM')
+      whisper: ChatUtility.getGMs()
     });
   }
 

module/rdd-namegen.js

@@ -1,4 +1,5 @@
 import { RdDBaseActor } from "./actor/base-actor.js";
+import { ChatUtility } from "./chat-utility.js";
 import { Misc } from "./misc.js";
 import { RdDDice } from "./rdd-dice.js";
 
@@ -11,11 +12,15 @@ const words = ['pore', 'pre', 'flor', 'lane', 'turlu', 'pin', 'a', 'alph', 'i',
 /* -------------------------------------------- */
 export class RdDNameGen {
 
-  static async getName(msg, params) {
+  static async proposeName(msg, params) {
     const html = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-command-nom.html`, {
-      nom: Misc.upperFirst(await RdDDice.rollOneOf(words) + await RdDDice.rollOneOf(words))
+      nom: await RdDNameGen.generate()
     });
-    ChatMessage.create({ content: html, whisper: ChatMessage.getWhisperRecipients("GM") });
+    ChatMessage.create({ content: html, whisper: ChatUtility.getGMs() });
+  }
+
+  static async generate() {
+    return Misc.upperFirst(await RdDDice.rollOneOf(words) + await RdDDice.rollOneOf(words));
   }
 
   static async onCreerActeur(event) {

module/rdd-possession.js

@@ -3,7 +3,7 @@ import { RdDResolutionTable } from "./rdd-resolution-table.js";
 import { RdDRoll } from "./rdd-roll.js";
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
 import { Targets } from "./targets.js";
-import { TYPES } from "./item.js";
+import { ITEM_TYPES } from "./item.js";
 
 /* -------------------------------------------- */
 /* On part du principe qu'une entité démarre tjs 
@@ -20,9 +20,9 @@ export class RdDPossession {
 
   /* -------------------------------------------- */
   static searchPossessionFromEntite(attacker, defender) {
-    let poss = attacker.items.find(poss => poss.type == TYPES.possession && poss.system.victime.actorid == defender.id);
+    let poss = attacker.items.find(poss => poss.type == ITEM_TYPES.possession && poss.system.victime.actorid == defender.id);
     if (!poss) {
-      poss = defender.items.find(poss => poss.type == TYPES.possession && poss.system.victime.actorid == defender.id);
+      poss = defender.items.find(poss => poss.type == ITEM_TYPES.possession && poss.system.victime.actorid == defender.id);
     }
     return poss && foundry.utils.duplicate(poss) || undefined;
   }

module/rdd-resolution-table.js

@@ -91,13 +91,14 @@ export class RdDResolutionTable {
 
   /* -------------------------------------------- */
   static async displayRollData(rollData, actor = undefined, template = 'chat-resultat-general.html') {
-    return await ChatUtility.createChatWithRollMode(RdDResolutionTable.actorChatName(actor), {
-      content: await RdDResolutionTable.buildRollDataHtml(rollData, template)
-    });
+    return await ChatUtility.createChatWithRollMode(
+      { content: await RdDResolutionTable.buildRollDataHtml(rollData, template) },
+      actor
+    )
   }
 
   static actorChatName(actor) {
-    return actor?.name ?? game.user.name;
+    return actor ?? game.user.name;
   }
 
   /* -------------------------------------------- */
@@ -138,14 +139,14 @@ export class RdDResolutionTable {
     if (carac == 0) {
       return NaN;
     }
-    if (rolled >= carac){
-      const upper = Math.ceil(rolled/carac);
-      return 2*upper -10
+    if (rolled >= carac) {
+      const upper = Math.ceil(rolled / carac);
+      return 2 * upper - 10
     }
-    if (rolled > Math.floor(carac/2)) {
+    if (rolled > Math.floor(carac / 2)) {
       return -8
     }
-    if (rolled > Math.floor(carac/4)) {
+    if (rolled > Math.floor(carac / 4)) {
       return -9
     }
     if (rolled > 1) {
@@ -265,7 +266,7 @@ export class RdDResolutionTable {
   }
 
   /* -------------------------------------------- */
-  static subTable(carac, level, delta = { carac: 2, level: 5}) {
+  static subTable(carac, level, delta = { carac: 2, level: 5 }) {
     return {
       carac,
       level,
@@ -287,8 +288,8 @@ export class RdDResolutionTable {
       carac: carac,
       difficulte: level,
       min: minLevel,
-      rows: Misc.intArray(minCarac, maxCarac+1),
-      cols: Misc.intArray(minLevel, maxLevel+1)
+      rows: Misc.intArray(minCarac, maxCarac + 1),
+      cols: Misc.intArray(minLevel, maxLevel + 1)
     });
   }
 

module/rdd-roll.js

@@ -307,7 +307,7 @@ export class RdDRoll extends Dialog {
   async updateRollResult(html) {
     const rollData = this.rollData;
 
-    rollData.dmg = rollData.attackerRoll?.dmg ?? RdDBonus.dmg(rollData, this.actor.getBonusDegat())
+    rollData.dmg = rollData.attackerRoll?.dmg ?? RdDBonus.dmg(rollData, this.actor)
     rollData.caracValue = parseInt(rollData.selectedCarac.value)
     rollData.dmg.mortalite = rollData.dmg.mortalite ?? 'mortel';
     rollData.use.appelAuMoral = this.actor.isPersonnage() && RdDCarac.isActionPhysique(rollData.selectedCarac);

module/rdd-tmr-dialog.js

@@ -16,7 +16,7 @@ import { RdDDice } from "./rdd-dice.js";
 import { STATUSES } from "./settings/status-effects.js";
 import { RdDRencontre } from "./item/rencontre.js";
 import { RdDTimestamp } from "./time/rdd-timestamp.js";
-import { TYPES } from "./item.js";
+import { ITEM_TYPES } from "./item.js";
 import { Misc } from "./misc.js";
 
 const TMR_DISPLAY_SIZE = {
@@ -34,7 +34,7 @@ const TMR_DISPLAY_SIZE = {
 
 /* -------------------------------------------- */
 export class RdDTMRDialog extends Dialog {
-  static async init() {
+  static initSettings() {
     game.settings.register(SYSTEM_RDD, TMR_DISPLAY_SIZE.code, {
       name: 'Taille des cases des TMR',
       hint: "Taille en pixel des cases des TMR (réglable directement dans la fenêtre des TMR)",
@@ -50,7 +50,7 @@ export class RdDTMRDialog extends Dialog {
     await PixiTMR.init()
     let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/dialog-tmr.html', tmrData);
     if (tmrData.mode != 'visu' && !game.user.isGM) {
-      ChatMessage.create({ content: actor.name + " est monté dans les TMR en mode : " + tmrData.mode, whisper: ChatMessage.getWhisperRecipients("GM") });
+      ChatMessage.create({ content: actor.name + " est monté dans les TMR en mode : " + tmrData.mode, whisper: ChatUtility.getGMs() });
     }
     return new RdDTMRDialog(html, actor, tmrData)
   }
@@ -82,7 +82,7 @@ export class RdDTMRDialog extends Dialog {
     this.rencontreState = 'aucune';
     this.subdialog = undefined
     this.displaySize = undefined
-    if (!this.viewOnly) {
+    if (!this.viewOnly && !game.user.isGM) {
       this._tellToGM(this.actor.name + " monte dans les terres médianes (" + tmrData.mode + ")");
     }
     this.callbacksOnAnimate = [];
@@ -208,11 +208,11 @@ export class RdDTMRDialog extends Dialog {
   }
 
   get sortsReserve() {
-    return this.actor.itemTypes[TYPES.sortreserve];
+    return this.actor.itemTypes[ITEM_TYPES.sortreserve];
   }
 
   getSortsReserve(coord) {
-    return this.actor.itemTypes[TYPES.sortreserve].filter(// Reserve sur une case fleuve ou normale
+    return this.actor.itemTypes[ITEM_TYPES.sortreserve].filter(// Reserve sur une case fleuve ou normale
       TMRUtility.getTMR(coord).type == 'fleuve'
         ? it => TMRUtility.getTMR(it.system.coord).type == 'fleuve'
         : it => it.system.coord == coord
@@ -270,7 +270,7 @@ export class RdDTMRDialog extends Dialog {
   }
 
   _getTokensSortsReserve() {
-    const sortsReserve = this.actor.itemTypes[TYPES.sortreserve];
+    const sortsReserve = this.actor.itemTypes[ITEM_TYPES.sortreserve];
     return Misc.concat(sortsReserve.map(sortReserve =>
       EffetsDraconiques.sortReserve.tokens(this.pixiTMR, sortReserve, () => sortReserve.system.coord)))
   }
@@ -496,7 +496,7 @@ export class RdDTMRDialog extends Dialog {
     rencData.message = this.formatMessageRencontre(rencData, result.message);
 
     ChatMessage.create({
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
+      whisper: ChatUtility.getOwners(this.actor),
       content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-rencontre-tmr.html`, rencData)
     });
 
@@ -571,12 +571,20 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   _tellToGM(message) {
-    ChatMessage.create({ content: message, user: game.user.id, whisper: ChatMessage.getWhisperRecipients("GM") });
+    ChatMessage.create({
+      user: game.user.id,
+      content: message,
+      whisper: ChatUtility.getGMs()
+    });
   }
 
   /* -------------------------------------------- */
   _tellToUserAndGM(message) {
-    ChatMessage.create({ content: message, user: game.user.id, whisper: [game.user.id].concat(ChatMessage.getWhisperRecipients("GM")) });
+    ChatMessage.create({
+      user: game.user.id,
+      content: message,
+      whisper: ChatUtility.getUserAndGMs()
+    })
   }
 
   /* -------------------------------------------- */
@@ -715,7 +723,7 @@ export class RdDTMRDialog extends Dialog {
     }
     rollData.poesie = await Poetique.getExtrait();
     ChatMessage.create({
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
+      whisper: ChatUtility.getOwners(this.actor),
       content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-resultat-maitrise-tmr.html`, rollData)
     });
     if (rollData.rolled.isEchec) {
@@ -739,7 +747,7 @@ export class RdDTMRDialog extends Dialog {
     if (this.isCaseMaitrisee(tmr.coord)) {
       ChatMessage.create({
         content: tmr.label + ": cette case humide est déja maitrisée grâce à votre Tête <strong>Quête des Eaux</strong>",
-        whisper: ChatMessage.getWhisperRecipients(game.user.name)
+        whisper: ChatUtility.getOwners(this.actor)
       });
       return false;
     }
@@ -751,14 +759,14 @@ export class RdDTMRDialog extends Dialog {
     if (tmr.type == 'pont' && EffetsDraconiques.isPontImpraticable(this.actor)) {
       ChatMessage.create({
         content: tmr.label + ": Vous êtes sous le coup d'une Impraticabilité des Ponts : ce pont doit être maîtrisé comme une case humide.",
-        whisper: ChatMessage.getWhisperRecipients(game.user.name)
+        whisper: ChatUtility.getOwners(this.actor)
       });
       return true;
     }
     if (this.isCaseInondee(tmr.coord)) {
       ChatMessage.create({
         content: tmr.label + ": cette case est inondée, elle doit être maîtrisée comme une case humide.",
-        whisper: ChatMessage.getWhisperRecipients(game.user.name)
+        whisper: ChatUtility.getOwners(this.actor)
       });
       return true;
     }
@@ -832,7 +840,7 @@ export class RdDTMRDialog extends Dialog {
     }
     rollData.poesie = await Poetique.getExtrait();
     ChatMessage.create({
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
+      whisper: ChatUtility.getOwners(this.actor),
       content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-resultat-maitrise-tmr.html`, rollData)
     });
     if (rollData.rolled.isEchec) {
@@ -882,17 +890,16 @@ export class RdDTMRDialog extends Dialog {
       const reserveSecurite = EffetsDraconiques.isReserveEnSecurite(this.actor);
       const reserveExtensible = this.isReserveExtensible(coord);
       if (!EffetsDraconiques.isUrgenceDraconique(this.actor) && (reserveSecurite || reserveExtensible)) {
-        const msg = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-demande-declencher-sort.hbs`, {
-          actor: this.actor,
-          sorts: sorts,
-          coord: coord,
-          tete: { reserveSecurite: reserveSecurite, reserveExtensible: reserveExtensible }
-        })
         ChatMessage.create({
-          content: msg,
-          whisper: ChatMessage.getWhisperRecipients(game.user.name)
-        });
-        return;
+          content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-demande-declencher-sort.hbs`, {
+            actor: this.actor,
+            sorts: sorts,
+            coord: coord,
+            tete: { reserveSecurite: reserveSecurite, reserveExtensible: reserveExtensible }
+          }),
+          whisper: ChatUtility.getOwners(this.actor)
+        })
+        return
       }
       await this.processSortReserve(sorts[0]);
     }
@@ -906,9 +913,8 @@ export class RdDTMRDialog extends Dialog {
       this.processSortReserve(sort);
     } else {
       ChatMessage.create({
-        content:
-          "Une erreur est survenue : impossible de récupérer le sort en réserve demandé.",
-        whisper: ChatMessage.getWhisperRecipients(game.user.name),
+        content: "Une erreur est survenue : impossible de récupérer le sort en réserve demandé.",
+        whisper: ChatUtility.getOwners(this.actor)
       });
     }
   }
@@ -1091,7 +1097,7 @@ export class RdDTMRDialog extends Dialog {
   async notifierResonanceSigneDraconique(coord) {
     if (!this.viewOnly && this.actor.isResonanceSigneDraconique(coord)) {
       ChatMessage.create({
-        whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
+        whisper: ChatUtility.getOwners(this.actor),
         content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-signe-draconique-resonance.html`, { alias: this.actor.name, typeTMR: TMRUtility.getTMRType(coord) })
       });
     }

module/rdd-utility.js

@@ -99,9 +99,7 @@ export class RdDUtility {
   // persistent handling of conteneur show/hide
   static afficheContenu = {}
   /* -------------------------------------------- */
-  static async init() {
-    Hooks.on("renderChatMessage", async (app, html, msg) => await ChatUtility.onRenderChatMessage(app, html, msg))
-    Hooks.on("createChatMessage", async (chatMessage, options, id) => await ChatUtility.onCreateChatMessage(chatMessage, options, id))
+  static async initHooks() {
     Hooks.on('renderChatLog', (log, html, chatLog) => RdDUtility.chatListeners(html))
   }
 
@@ -292,6 +290,7 @@ export class RdDUtility {
 
     Handlebars.registerHelper('array-includes', (array, value) => array.includes(value));
     Handlebars.registerHelper('min', (...args) => Math.min(...args.slice(0, -1)));
+    Handlebars.registerHelper('isLastIndex', (index, list) => index + 1 >= list.length);
     Handlebars.registerHelper('regle-optionnelle', (option) => ReglesOptionnelles.isUsing(option));
     Handlebars.registerHelper('trier', list => list.sort((a, b) => a.name.localeCompare(b.name)));
     Handlebars.registerHelper('filtreTriCompetences', competences => RdDItemCompetence.triVisible(competences));
@@ -644,18 +643,16 @@ export class RdDUtility {
   /* -------------------------------------------- */
   static onSocketMessage(sockmsg) {
     switch (sockmsg.msg) {
-      case "msg_gm_chat_message":
-        return ChatUtility.handleGMChatMessage(sockmsg.data);
       case "msg_app_astrologie_refresh":
-        return Hooks.callAll(APP_ASTROLOGIE_REFRESH);
+        return Hooks.callAll(APP_ASTROLOGIE_REFRESH)
       case "msg_request_nombre_astral":
-        return game.system.rdd.calendrier.requestNombreAstral(sockmsg.data);
+        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();
+          actor.refreshTMRView()
         }
-        break;
+        break
     }
   }
 
@@ -807,17 +804,13 @@ export class RdDUtility {
       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];
+    }
+    ChatUtility.applyRollMode(chatData)
 
     if (forceWhisper) { // Final force !
-      chatData["speaker"] = ChatMessage.getSpeaker();
-      chatData["whisper"] = ChatMessage.getWhisperRecipients(forceWhisper);
+      chatData.speaker = ChatMessage.getSpeaker();
+      chatData.whisper = ChatMessage.getWhisperRecipients(forceWhisper);
     }
-
     return chatData;
   }
 
@@ -880,7 +873,7 @@ export class RdDUtility {
         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: ChatMessage.getWhisperRecipients("GM")
+          whisper: ChatUtility.getGMs()
         });
       }
       else if (heureNaissance) {
@@ -899,7 +892,7 @@ export class RdDUtility {
     if (compName.includes('Thanatos')) {
       let message = "Vous avez mis des points d'Expérience dans la Voie de Thanatos !<br>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),
+        whisper: ChatUtility.getUserAndGMs(),
         content: message
       });
     }

module/settings/options-avancees.js

@@ -0,0 +1,91 @@
+import { SYSTEM_RDD } from "../constants.js"
+import { Misc } from "../misc.js"
+
+export const EXPORT_CSV_SCRIPTARIUM = 'export-csv-scriptarium'
+
+const OPTIONS_AVANCEES = [
+  { group: 'Menus', name: EXPORT_CSV_SCRIPTARIUM, descr: "Proposer le menu d'export csv Scriptarium" },
+]
+
+export class OptionsAvancees extends FormApplication {
+  static initSettings() {
+    for (const regle of OPTIONS_AVANCEES) {
+      const name = regle.name
+      const id = OptionsAvancees._getId(name)
+      game.settings.register(SYSTEM_RDD, id, { name: id, scope: regle.scope ?? "world", config: false, default: regle.default == undefined ? true : regle.default, type: Boolean })
+    }
+
+    game.settings.registerMenu(SYSTEM_RDD, "rdd-options-avancees", {
+      name: "Configurer les options avancées",
+      label: "Options avancées",
+      hint: "Ouvre la fenêtre de configuration des options avancées",
+      icon: "fas fa-bars",
+      type: OptionsAvancees
+    })
+  }
+
+  constructor(...args) {
+    super(...args)
+  }
+
+  static _getId(name) {
+    return `rdd-advanced-${name}`
+  }
+
+  static get defaultOptions() {
+    return foundry.utils.mergeObject(super.defaultOptions, {
+      id: "options-avancees",
+      template: "systems/foundryvtt-reve-de-dragon/templates/settings/options-avancees.hbs",
+      height: 650,
+      width: 550,
+      minimizable: false,
+      closeOnSubmit: true,
+      title: "Options avancées"
+    }, { inplace: false })
+  }
+
+  getData() {
+    let formData = super.getData()
+    const regles = OPTIONS_AVANCEES.filter(it => game.user.isGM || it.scope == "client")
+      .map(it => {
+        it = foundry.utils.duplicate(it)
+        it.id = OptionsAvancees._getId(it.name)
+        it.active = OptionsAvancees.isSet(it.name)
+        return it
+      })
+    formData.regles = regles
+    formData.groups = Misc.classify(regles, it => it.group)
+    return formData
+  }
+
+  static getSettingKey(name){
+    return `${SYSTEM_RDD}.${this._getId(name)}`
+  }
+
+  static isUsing(name) {
+    return OptionsAvancees.isSet(name)
+  }
+
+  static isSet(name) {
+    return game.settings.get(SYSTEM_RDD, OptionsAvancees._getId(name))
+  }
+
+  static set(name, value) {
+    return game.settings.set(SYSTEM_RDD, OptionsAvancees._getId(name), value ? true : false)
+  }
+
+  activateListeners(html) {
+    html.find(".select-option").click((event) => {
+      if (event.currentTarget.attributes.name) {
+        let id = event.currentTarget.attributes.name.value
+        let isChecked = event.currentTarget.checked
+        game.settings.set(SYSTEM_RDD, id, isChecked)
+      }
+    })
+  }
+
+  async _updateObject(event, formData) {
+    this.close()
+  }
+}
+

module/settings/regles-optionnelles.js

@@ -46,7 +46,7 @@ const listeReglesOptionnelles = [
 const uniquementJoueur = listeReglesOptionnelles.filter(it => it.uniquementJoueur).map(it=>it.name);
 
 export class ReglesOptionnelles extends FormApplication {
-  static init() {
+  static initSettings() {
     for (const regle of listeReglesOptionnelles) {
       const name = regle.name;
       const id = ReglesOptionnelles._getIdRegle(name);
@@ -73,7 +73,7 @@ export class ReglesOptionnelles extends FormApplication {
   static get defaultOptions() {
     return foundry.utils.mergeObject(super.defaultOptions, {
       id: "regles-optionnelles",
-      template: "systems/foundryvtt-reve-de-dragon/templates/settings/regles-optionnelles.html",
+      template: "systems/foundryvtt-reve-de-dragon/templates/settings/regles-optionnelles.hbs",
       height: 650,
       width: 550,
       minimizable: false,

module/settings/system-compendiums.js

@@ -25,7 +25,7 @@ const CONFIGURABLE_COMPENDIUMS = {
  * ======= Gestion des accès aux compendiums systèmes (ou surchargés) =======
  */
 export class SystemCompendiums extends FormApplication {
-  static init() {
+  static initSettings() {
     Object.keys(CONFIGURABLE_COMPENDIUMS).forEach(compendium => {
       const definition = CONFIGURABLE_COMPENDIUMS[compendium];
       foundry.utils.mergeObject(definition, {
@@ -236,12 +236,12 @@ export class CompendiumTableHelpers {
     let max = 0;
     const total = rows.map(it => it.frequence).reduce(Misc.sum(), 0);
     return rows.map(row => {
-      const frequence = row.frequence;
-      row.min = max + 1;
-      row.max = max + frequence;
+      const frequence = row.frequence
+      row.min = max + 1
+      row.max = max + frequence
       row.total = total
-      max += frequence;
-      return row;
+      max += frequence
+      return row
     })
   }
   static async getRandom(table, type, subTypes = ['objet'], forcedRoll = undefined, localisation = undefined) {
@@ -260,8 +260,8 @@ export class CompendiumTableHelpers {
     }
     const total = table[0].total;
     const formula = `1d${total}`;
-    if (forcedRoll == undefined && (forcedRoll > total || forcedRoll <= 0)) {
-      ui.notifications.warn(`Jet de rencontre ${forcedRoll} en dehors de la table [1..${total}], le jet est relancé`);
+    if (forcedRoll != undefined && (forcedRoll > total || forcedRoll <= 0)) {
+      ui.notifications.warn(`Jet forcé ${forcedRoll} en dehors de la table [1..${total}], le jet est relancé`);
       forcedRoll = undefined;
     }
     const roll = forcedRoll ? { total: forcedRoll, formula } : await RdDDice.roll(formula, { showDice: HIDE_DICE });
@@ -276,7 +276,7 @@ export class CompendiumTableHelpers {
       return;
     }
     const percentages = (row.total == 100) ? '%' : ''
-    const flavorContent = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-compendium-table-roll.html', {
+    const flavorContent = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-compendium-table-roll.hbs', {
       roll: row.roll,
       document: row.document,
       percentages,
@@ -291,12 +291,12 @@ export class CompendiumTableHelpers {
       sound: CONFIG.sounds.dice,
       content: flavorContent
     };
-    await ChatUtility.createChatWithRollMode(game.user.id, messageData)
+    await ChatUtility.createChatWithRollMode(messageData)
   }
 
   /* -------------------------------------------- */
   static async tableToChatMessage(table, type, subTypes, typeName = undefined) {
-    const flavorContent = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-compendium-table.html', {
+    const flavorContent = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-compendium-table.hbs', {
       img: RdDItem.getDefaultImg(subTypes[0]),
       typeName: typeName ?? Misc.typeName(type, subTypes[0]),
       table,
@@ -304,10 +304,10 @@ export class CompendiumTableHelpers {
     });
     const messageData = {
       user: game.user.id,
-      whisper: game.user.id,
+      whisper: [game.user],
       content: flavorContent
     };
-    await ChatUtility.createChatWithRollMode(game.user.id, messageData)
+    await ChatUtility.createChatWithRollMode(messageData)
   }
 
 }

module/time/auto-adjust-darkness.js

@@ -4,7 +4,7 @@ export const AUTO_ADJUST_DARKNESS = "auto-adjust-darkness";
 
 export class AutoAdjustDarkness {
 
-  static init() {
+  static initSettings() {
     game.settings.register(SYSTEM_RDD, AUTO_ADJUST_DARKNESS, {
       name: AUTO_ADJUST_DARKNESS,
       scope: "world",

module/time/rdd-calendrier.js

@@ -1,7 +1,6 @@
 import { MAX_NOMBRE_ASTRAL, RdDTimestamp, WORLD_TIMESTAMP_SETTING } from "./rdd-timestamp.js";
 import { RdDCalendrierEditor } from "./rdd-calendrier-editor.js";
 import { RdDResolutionTable } from "../rdd-resolution-table.js";
-import { RdDUtility } from "../rdd-utility.js";
 import { RdDDice } from "../rdd-dice.js";
 import { Misc } from "../misc.js";
 import { DialogChronologie } from "../dialog-chronologie.js";
@@ -16,7 +15,7 @@ const TEMPLATE_CALENDRIER = "systems/foundryvtt-reve-de-dragon/templates/time/ca
 const INITIAL_CALENDAR_POS = { top: 200, left: 200, horlogeAnalogique: true };
 /* -------------------------------------------- */
 export class RdDCalendrier extends Application {
-  static init() {
+  static initSettings() {
     game.settings.register(SYSTEM_RDD, "liste-nombre-astral", {
       name: "liste-nombre-astral",
       scope: "world",
@@ -228,7 +227,7 @@ export class RdDCalendrier extends Application {
 
   /* -------------------------------------------- */
   async ajouterNombreAstral(indexDate) {
-    const nombreAstral = await RdDDice.rollTotal("1dh", { showDice: HIDE_DICE, rollMode: "selfroll" });
+    const nombreAstral = await RdDDice.rollHeure( { showDice: HIDE_DICE, rollMode: "selfroll" });
     return {
       nombreAstral: nombreAstral,
       lectures: [],

module/time/rdd-timestamp.js

@@ -15,18 +15,18 @@ export const RDD_MINUTES_PAR_JOUR = 1440; //RDD_HEURES_PAR_JOUR * RDD_MINUTES_PA
 const ROUNDS_PAR_MINUTE = 10;
 
 const DEFINITION_HEURES = [
-  { key: "vaisseau", label: "Vaisseau", lettreFont: 'v', saison: "Printemps", darkness: 0.9 },
-  { key: "sirene", label: "Sirène", lettreFont: 'i', saison: "Printemps", darkness: 0.1 },
-  { key: "faucon", label: "Faucon", lettreFont: 'f', saison: "Printemps", darkness: 0 },
-  { key: "couronne", label: "Couronne", lettreFont: '', saison: "Eté", darkness: 0 },
-  { key: "dragon", label: "Dragon", lettreFont: 'd', saison: "Eté", darkness: 0 },
-  { key: "epees", label: "Epées", lettreFont: 'e', saison: "Eté", darkness: 0 },
-  { key: "lyre", label: "Lyre", lettreFont: 'l', saison: "Automne", darkness: 0.1 },
-  { key: "serpent", label: "Serpent", lettreFont: 's', saison: "Automne", darkness: 0.9 },
-  { key: "poissonacrobate", label: "Poisson Acrobate", lettreFont: 'p', saison: "Automne", darkness: 1 },
-  { key: "araignee", label: "Araignée", lettreFont: 'a', saison: "Hiver", darkness: 1 },
-  { key: "roseau", label: "Roseau", lettreFont: 'r', saison: "Hiver", darkness: 1 },
-  { key: "chateaudormant", label: "Château Dormant", lettreFont: 'c', saison: "Hiver", darkness: 1 },
+  { key: "vaisseau", article: "du ", label: "Vaisseau", lettreFont: 'v', saison: "Printemps", darkness: 0.9 },
+  { key: "sirene", article: "de la ", label: "Sirène", lettreFont: 'i', saison: "Printemps", darkness: 0.1 },
+  { key: "faucon", article: "du ", label: "Faucon", lettreFont: 'f', saison: "Printemps", darkness: 0 },
+  { key: "couronne", article: "de la ", label: "Couronne", lettreFont: '', saison: "Eté", darkness: 0 },
+  { key: "dragon", article: "du ", label: "Dragon", lettreFont: 'd', saison: "Eté", darkness: 0 },
+  { key: "epees", article: "des ", label: "Epées", lettreFont: 'e', saison: "Eté", darkness: 0 },
+  { key: "lyre", article: "de la ", label: "Lyre", lettreFont: 'l', saison: "Automne", darkness: 0.1 },
+  { key: "serpent", article: "du ", label: "Serpent", lettreFont: 's', saison: "Automne", darkness: 0.9 },
+  { key: "poissonacrobate", article: "du ", label: "Poisson Acrobate", lettreFont: 'p', saison: "Automne", darkness: 1 },
+  { key: "araignee", article: "de l'", label: "Araignée", lettreFont: 'a', saison: "Hiver", darkness: 1 },
+  { key: "roseau", article: "du ", label: "Roseau", lettreFont: 'r', saison: "Hiver", darkness: 1 },
+  { key: "chateaudormant", article: "du ", label: "Château Dormant", lettreFont: 'c', saison: "Hiver", darkness: 1 },
 ]
 
 const FORMULES_DUREE = [
@@ -49,7 +49,7 @@ const FORMULES_PERIODE = [
 
 export class RdDTimestamp {
 
-  static init() {
+  static initSettings() {
     game.settings.register(SYSTEM_RDD, WORLD_TIMESTAMP_SETTING, {
       name: WORLD_TIMESTAMP_SETTING,
       scope: "world",
@@ -64,6 +64,7 @@ export class RdDTimestamp {
       DEFINITION_HEURES[i].hh = RdDTimestamp.hh(i);
       DEFINITION_HEURES[i].icon = RdDTimestamp.iconeHeure(i);
       DEFINITION_HEURES[i].webp = DEFINITION_HEURES[i].icon.replace(".svg", ".webp");
+      DEFINITION_HEURES[i].avecArticle = DEFINITION_HEURES[i].article + DEFINITION_HEURES[i].label
     }
   }
 
@@ -241,7 +242,7 @@ export class RdDTimestamp {
 
   get darkness() {
     const darknessDebut = 100 * RdDTimestamp.definition(this.heure).darkness
-    const darknessFin =  100 * RdDTimestamp.definition(this.heure + 1).darkness
+    const darknessFin = 100 * RdDTimestamp.definition(this.heure + 1).darkness
     const darknessMinute = Math.round((darknessFin - darknessDebut) * this.minute / RDD_MINUTES_PAR_HEURES);
     return (darknessDebut + darknessMinute) / 100
   }

module/tmr-rencontres.js

@@ -105,7 +105,7 @@ export class TMRRencontres {
 
   /* -------------------------------------------- */
   async $chatRolledRencontre(row, rencontre, tmr) {
-    const flavorContent = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-compendium-table-roll-rencontre.html',
+    const flavorContent = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-compendium-table-roll-rencontre.hbs',
       {
         roll: row.roll,
         rencontre,

module/tmr/draconique.js

@@ -1,4 +1,4 @@
-import { TYPES } from "../item.js";
+import { ITEM_TYPES } from "../item.js";
 import { TMRUtility } from "../tmr-utility.js";
 import { PixiTMR } from "./pixi-tmr.js";
 
@@ -12,10 +12,10 @@ export class Draconique {
   static init() {
   }
 
-  static isCaseTMR(item) { return item.type == TYPES.casetmr; }
+  static isCaseTMR(item) { return item.type == ITEM_TYPES.casetmr; }
   static isQueueDragon(item) { return item.isQueueDragon(); }
-  static isSouffleDragon(item) { return item.type == TYPES.souffle; }
-  static isTeteDragon(item) { return item.type == TYPES.tete; }
+  static isSouffleDragon(item) { return item.type == ITEM_TYPES.souffle; }
+  static isTeteDragon(item) { return item.type == ITEM_TYPES.tete; }
   static isQueueSouffle(item) { return Draconique.isQueueDragon(item) || Draconique.isSouffleDragon(item); }
 
   static register(draconique, code = undefined) {

module/tmr/effets-draconiques.js

@@ -18,7 +18,7 @@ import { Periple } from "./periple.js";
 import { UrgenceDraconique } from "./urgence-draconique.js";
 import { Grammar } from "../grammar.js";
 import { AugmentationSeuil } from "./augmentation-seuil.js";
-import { TYPES } from "../item.js";
+import { ITEM_TYPES } from "../item.js";
 
 export class EffetsDraconiques {
   static carteTmr = new CarteTmr();
@@ -122,11 +122,11 @@ export class EffetsDraconiques {
   }
 
   static tetesDragon(actor, name) {
-    return actor.itemTypes[TYPES.tete].filter(it => Grammar.includesLowerCaseNoAccent(it.name, name));
+    return actor.itemTypes[ITEM_TYPES.tete].filter(it => Grammar.includesLowerCaseNoAccent(it.name, name));
   }
 
   static soufflesDragon(actor, name) {
-    return actor.itemTypes[TYPES.souffle].filter(it => Grammar.includesLowerCaseNoAccent(it.name, name));
+    return actor.itemTypes[ITEM_TYPES.souffle].filter(it => Grammar.includesLowerCaseNoAccent(it.name, name));
   }
 
   static queuesDragon(actor, name) {
@@ -134,7 +134,7 @@ export class EffetsDraconiques {
   }
 
   static queuesSoufflesDragon(actor, name) {
-    return actor.filterItems(it => [TYPES.queue, TYPES.ombre, TYPES.souffle].includes(it.type) && Grammar.includesLowerCaseNoAccent(it.name, name));
+    return actor.filterItems(it => [ITEM_TYPES.queue, ITEM_TYPES.ombre, ITEM_TYPES.souffle].includes(it.type) && Grammar.includesLowerCaseNoAccent(it.name, name));
   }
 
   static countAugmentationSeuil(actor) {

module/tmr/effets-rencontres.js

@@ -30,7 +30,7 @@ export class EffetsRencontre {
   static $reve_plus = async (actor, reve) => {
     if (!ReglesOptionnelles.isUsing("recuperation-reve") && reve < 0) { 
       ChatMessage.create({
-        whisper: ChatUtility.getWhisperRecipientsAndGMs(actor.name),
+        whisper: ChatUtility.getOwners(actor),
         content: `Pas de récupération de rêve (${reve} points ignorés)`
       });
       return
@@ -112,7 +112,7 @@ export class EffetsRencontre {
       poesie: await Poetique.getExtrait()
     })
     ChatMessage.create({
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(context.actor.name),
+      whisper: ChatUtility.getOwners(context.actor),
       content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-resultat-reve-de-dragon.html`, context)
     });
   }
@@ -127,7 +127,7 @@ export class EffetsRencontre {
     }
 
     ChatMessage.create({
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+      whisper: ChatUtility.getOwners(context.actor),
       content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-resultat-reve-de-dragon.html`, context)
     });
   }

module/tmr/present-cites.js

@@ -28,7 +28,7 @@ export class PresentCites extends Draconique {
     let existants = actor.items.filter(it => this.isCase(it)).map(it => it.system.coord);
     if (existants.length > 0) {
       ChatMessage.create({
-        whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
+        whisper: ChatUtility.getOwners(actor),
         content: "Vous avez encore des présents dans des cités, vous devrez tirer une autre tête pour remplacer celle ci!"
       })
     }

module/tmr/urgence-draconique.js

@@ -5,7 +5,7 @@ import { RdDRollTables } from "../rdd-rolltables.js";
 import { TMRUtility } from "../tmr-utility.js";
 import { tmrTokenZIndex } from "../tmr-constants.js";
 import { Draconique } from "./draconique.js";
-import { TYPES } from "../item.js";
+import { ITEM_TYPES } from "../item.js";
 import { TMRAnimations } from "./animation.js";
 
 export class UrgenceDraconique extends Draconique {
@@ -14,12 +14,12 @@ export class UrgenceDraconique extends Draconique {
   match(item) { return Draconique.isQueueDragon(item) && Grammar.toLowerCaseNoAccent(item.name).includes('urgence draconique'); }
   manualMessage() { return false }
   async onActorCreateOwned(actor, queue) {
-    const coordSortsReserve = actor.itemTypes[TYPES.sortreserve].map(it => it.system.coord) ?? [];
+    const coordSortsReserve = actor.itemTypes[ITEM_TYPES.sortreserve].map(it => it.system.coord) ?? [];
     if (coordSortsReserve.length == 0) {
       // La queue se transforme en idée fixe
       const ideeFixe = await RdDRollTables.getIdeeFixe();
       ChatMessage.create({
-        whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
+        whisper: ChatUtility.getOwners(actor),
         content: `En l'absence de sorts en réserve, l'urgence draconique de ${actor.name} se transforme en ${ideeFixe.name}`
       });
       await actor.createEmbeddedDocuments('Item', [ideeFixe]);

module/voyage/dialog-fatigue-voyage.js

@@ -1,4 +1,4 @@
-import { TYPES } from "../item.js"
+import { ITEM_TYPES } from "../item.js"
 import { RdDItemCompetence } from "../item-competence.js"
 import { ChatUtility } from "../chat-utility.js"
 import { Misc } from "../misc.js"
@@ -69,7 +69,7 @@ export class DialogFatigueVoyage extends Dialog {
     }
     const competencesVoyage = {}
     CODES_COMPETENCES_VOYAGE.forEach(codeSurvie => {
-      competencesVoyage[codeSurvie] = RdDItemCompetence.findCompetence(actor.itemTypes[TYPES.competence], codeSurvie, { onMessage: () => { } })
+      competencesVoyage[codeSurvie] = RdDItemCompetence.findCompetence(actor.itemTypes[ITEM_TYPES.competence], codeSurvie, { onMessage: () => { } })
     })
     TABLEAU_FATIGUE_MARCHE.forEach(terrain => {
       actorParameters.survies[terrain.code] = Misc.join(
@@ -175,7 +175,7 @@ export class DialogFatigueVoyage extends Dialog {
       .forEach(async it => {
         const perteFatigue = fatigueBase + it.ajustement
         ChatMessage.create({
-          whisper: ChatUtility.getWhisperRecipientsAndGMs(it.actor.name),
+          whisper: ChatUtility.getOwners(it.actor),
           content: await renderTemplate(
             'systems/foundryvtt-reve-de-dragon/templates/voyage/chat-fatigue_voyage.hbs',
             foundry.utils.mergeObject(it,

styles/simple.css

@@ -326,7 +326,7 @@ table {border: 1px solid #7a7971;}
   display: grid;
   grid-column: span 2 / span 2;
   grid-template-columns: repeat(2, minmax(0, 1fr));
-  gap: 10px;
+  gap: 30px;
   margin: 10px 0;
   padding: 0;
 }
@@ -411,6 +411,11 @@ table {border: 1px solid #7a7971;}
   text-align: left;
 }
 
+.flex-group-top {
+  vertical-align: top;
+  align-self: start;
+}
+
 .flex-group-right {
   -webkit-box-pack: end;
   -ms-flex-pack: end;
@@ -562,7 +567,11 @@ input:is(.blessure-premiers_soins, .blessure-soins_complets) {
 
 .dice-img {
   border-width: 0;
+  max-width: 1.5rem;
+  max-height: 1.5rem;
+  vertical-align: top;
 }
+
 .in-text-img {
   max-width: 1.2em;
   max-height: 1.2em;
@@ -572,6 +581,15 @@ input:is(.blessure-premiers_soins, .blessure-soins_complets) {
   border: none;
   padding: 0.1rem;
 }
+.context-menu-img {
+  max-width: 2rem;
+  max-height: 1rem;
+  flex-grow: 0;
+  margin: 0.2rem 0.3rem 0 0;
+  vertical-align: middle;
+  border: none;
+  padding: 0rem;
+}
 
 .button-img {
   vertical-align: baseline;
@@ -666,6 +684,7 @@ input:is(.blessure-premiers_soins, .blessure-soins_complets) {
 }
 
 .carac-label {
+  font-weight: bold;
   flex-basis: 40%;
 }
 .rdd.sheet .window-content .sheet-body .carac-list .caracteristique > .utiliser-attribut {
@@ -1174,9 +1193,6 @@ ul.chat-list li:nth-child(odd) {
   padding: 0.5rem;
   cursor: pointer;
 }
-.carac-label {
-  font-weight: bold;
-}
 .list-item {
   margin: 0.1rem;
   box-shadow: inset 0px 0px 1px #00000096;

system.json

@@ -1,8 +1,8 @@
 {
   "id": "foundryvtt-reve-de-dragon",
   "title": "Rêve de Dragon",
-  "version": "12.0.8",
-  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-12.0.8.zip",
+  "version": "12.0.15",
+  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-12.0.15.zip",
   "manifest": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/v11/system.json",
   "changelog": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/branch/v11/changelog.md",
   "compatibility": {
@@ -534,6 +534,7 @@
   },
   "primaryTokenAttribute": "sante.vie",
   "secondaryTokenAttribute": "sante.endurance",
+  "background": "systems/foundryvtt-reve-de-dragon/styles/img/reve-de-dragon-cover.webp",
   "media": [
     {
       "type": "icon",

template.json

@@ -15,12 +15,14 @@
         }
       },
       "background": {
+        "metier": "",
         "biographie": "Histoire personnelle...",
         "notes": "Notes",
         "notesmj": "Notes du MJ",
         "race": "Humain",
         "yeux": "",
         "cheveux": "",
+        "taille": "",
         "poids": "",
         "heure": "",
         "sexe": "",

templates/actor-creature-sheet.html

@@ -9,9 +9,9 @@
           <div class="flexrow">
             <h1 class="charname"><input name="name" type="text" value="{{name}}" placeholder="Name" /></h1>
             <div class="header-buttons">
-              <span class="encaisser-direct"><a><img class="button-img" src="icons/svg/bones.svg" data-tooltip="Encaisser des dommages"/></a></span>
+              <span><a class="button-encaissement"><img class="button-img" src="icons/svg/bones.svg" data-tooltip="Encaisser des dommages"/></a></span>
               {{#if @root.options.isGM}}
-              <span class="remise-a-neuf"><a><img class="button-img" src="icons/svg/regen.svg" data-tooltip="Remise à neuf"/></a></span>
+              <span><a class="button-remise-a-neuf"><img class="button-img" src="icons/svg/regen.svg" data-tooltip="Remise à neuf"/></a></span>
               {{/if}}
             </div>
           </div>

templates/actor-entite-sheet.html

@@ -9,9 +9,9 @@
           <div class="flexrow">
             <h1 class="charname"><input name="name" type="text" value="{{name}}" placeholder="Name" /></h1>
             <div class="header-buttons">
-              <span class="encaisser-direct"><a><img class="button-img" src="icons/svg/bones.svg" data-tooltip="Encaisser des dommages"/></a></span>
+              <span><a class="button-encaissement"><img class="button-img" src="icons/svg/bones.svg" data-tooltip="Encaisser des dommages"/></a></span>
               {{#if @root.options.isGM}}
-              <span class="remise-a-neuf"><a><img class="button-img" src="icons/svg/regen.svg" data-tooltip="Remise à neuf"/></a></span>
+              <span><a class="button-remise-a-neuf"><img class="button-img" src="icons/svg/regen.svg" data-tooltip="Remise à neuf"/></a></span>
               {{/if}}
             </div>
           </div>

templates/actor-sheet.html

@@ -172,6 +172,10 @@
               <label for="system.poids">Poids :</label>
               <input class="flex-grow" type="text" name="system.poids" value="{{system.poids}}" data-dtype="String"/>
             </li>
+            <li class="item flexrow list-item">
+              <label for="system.metier">Métier :</label>
+              <input class="flex-grow" type="text" name="system.metier" value="{{system.metier}}" data-dtype="String"/>
+            </li>
           </ul>
           <ul class="item-list alterne-list">
             <li class="item flexrow list-item">
@@ -201,6 +205,7 @@
               <label for="system.yeux">Yeux :</label>
               <input class="flex-grow" type="text" name="system.yeux" value="{{system.yeux}}" data-dtype="String"/>
             </li>
+            <a class="chat-card-button description-aleatoire" data-tooltip="Déterminer aléatoirement les détails de description">Description <i class="fa-solid fa-dice-d20"></i></a>
           </ul>
         </article>
 

templates/actor/carac-main.html

@@ -7,7 +7,7 @@
         <label class="carac-xp"/>
       {{else}}
         {{#if carac.derivee}}
-          <span class="carac-label" name="system.carac.{{key}}.label"><a name={{key}}>{{carac.label}}</a></span>
+          <span class="carac-label" name="system.carac.{{key}}.label"><a class="roll-carac" data-carac-name={{key}}>{{carac.label}}</a></span>
           <label class="competence-value">{{carac.value}}</label>
           <label class="carac-xp"/>
         {{else}}
@@ -22,7 +22,7 @@
               </a>
             </span>
           {{else}}
-            <span class="carac-label tooltip" name="system.carac.{{key}}.label"><a name={{key}}>{{carac.label}}</a></span>
+            <span class="carac-label tooltip" name="system.carac.{{key}}.label"><a class="roll-carac" data-carac-name={{key}}>{{carac.label}}</a></span>
           {{/if}}
           <input class="carac-value" type="text" name="system.carac.{{key}}.value" value="{{carac.value}}" data-dtype="{{carac.type}}" {{#unless @root.options.vueDetaillee}}disabled{{/unless}} />
           <span class="carac-xp tooltip">

templates/actor/combat.html

@@ -13,7 +13,7 @@
       data-competence-name="{{arme.system.competence}}" 
       data-tooltip="{{arme.name}}: niveau {{plusMoins arme.system.niveau}}">
     <span class="arme-label">
-      <a>
+      <a class="roll-arme">
         {{#if arme.img}}
         <img class="sheet-competence-img" src="{{arme.img}}" data-tooltip="{{arme.name}}"/>
         {{/if}}
@@ -32,7 +32,7 @@
   <li class="item flexrow list-item" data-item-id="{{esq._id}}"
     data-tooltip="{{esq.name}}: niveau {{plusMoins esq.system.niveau}}">
     <span class="competence-label">
-      <a class="competence-label" name="{{esq.name}}">
+      <a class="roll-competence" name="{{esq.name}}">
         <img class="sheet-competence-img" src="{{esq.img}}" />
         <span>{{esq.name}}</span>
       </a>

templates/actor/comp-creature.html

@@ -1,7 +1,7 @@
 <ol class="item-list alterne-list">
   {{#each (trier competences) as |comp key|}}
   <li class="item flexrow list-item" data-item-id="{{comp._id}}">
-    <a class="competence-label">
+    <a class="competence-label roll-competence">
       <img class="sheet-competence-img" src="{{comp.img}}" data-tooltip="{{comp.name}}"/>
       <span>{{comp.name}}</span>
     </a>

templates/actor/competence.html

@@ -1,17 +1,19 @@
 {{#unless system.isHidden}}
-  <li class="item flexrow list-item {{#if system.isLevelUp}}xp-level-up tooltip{{/if}}" data-item-id="{{_id}}">
-    <a class="competence-label" name="{{name}}" data-tooltip="Niveau {{plusMoins system.niveau}} en {{name}}">
-      <img class="sheet-competence-img" src="{{img}}"/>
-      <span>{{name}}</span>
-    </a>
-
-    {{#if system.isLevelUp}}
-    <span class="tooltiptext ttt-levelup">Vous pouvez dépenser {{system.xpNext}} points d'Experience pour augmenter de 1 votre compétence {{name}}</span>
-    <a class="competence-xp-augmenter" compname="{{name}}">
-      <i class="fas fa-arrow-alt-circle-up"></i>
-    </a>
-    {{/if}}
-
+  <li class="item flexrow list-item {{#if system.isLevelUp}}xp-level-up{{/if}}" data-item-id="{{_id}}">
+    <span class="tooltip">
+      <a class="competence-label roll-competence" name="{{name}}" data-tooltip="Niveau {{plusMoins system.niveau}} en {{name}}">
+        <img class="sheet-competence-img" src="{{img}}"/>
+        <span>{{name}}</span>
+      </a>
+      
+      {{#if system.isLevelUp}}
+      <span class="tooltiptext ttt-levelup">Vous pouvez dépenser {{system.xpNext}} points d'Experience pour augmenter de 1 votre compétence {{name}}</span>
+      <a class="competence-xp-augmenter" compname="{{name}}">
+        <i class="fas fa-arrow-alt-circle-up"></i>
+      </a>
+      {{/if}}
+    </span>
+      
     <input class="competence-value" type="text" compname="{{name}}" name="comp-value-{{name}}"
           value="{{plusMoins system.niveau}}" data-dtype="number"
           {{#if (or (not @root.options.vueDetaillee) @root.options.vueArchetype)}}disabled{{/if}} />
@@ -50,7 +52,7 @@
       {{/if}}
       &nbsp;
       <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
-  </div>
+    </div>
     {{/if}}
-  </li>
+</li>
 {{/unless}}

templates/actor/export-scriptarium/actor-encart-sheet.hbs

@@ -0,0 +1,130 @@
+<form class="{{cssClass}}" autocomplete="off" >
+  <section class="sheet-header">
+    <div class="flexrow">
+      <div class="flex-group-left flex-grow-0-5">
+        <h1 class="charname">{{name}}
+        </h1>
+      </div>
+      <div class="flex-group-right flex-grow-3">
+        {{#if system.attributs.hautrevant.value}}
+        <a class="button-tmr" data-tooltip="Montée dans les Terres M&eacute;dianes !" {{#if hautreve.isDemiReve}}disabled{{/if}}>
+          <img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-normal.svg"/>
+        </a>
+        <a class="button-tmr-rapide" data-tooltip="Montée accélérée dans les Terres M&eacute;dianes !" {{#if hautreve.isDemiReve}}disabled{{/if}}>
+          <img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-rapide.svg"/>
+        </a>
+        <a class="button-tmr-visu" data-tooltip="Regarder les Terres M&eacute;dianes">
+          <img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-view.svg"/>
+        </a>
+        {{/if}}
+        <a class="button-appel-chance"><img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/appel-chance.svg" data-tooltip="Appel à la chance"/></a>
+        <a class="button-encaissement"><img class="button-img" src="icons/svg/bones.svg" data-tooltip="Encaisser des dommages"/></a>
+        <a class="button-ethylisme"><img class="button-img" src="icons/svg/tankard.svg" data-tooltip="Boire"/></a>
+        <a class="button-repos"><img class="button-img" src="icons/svg/sleep.svg" data-tooltip="Se reposer"/></a>
+        {{#if @root.options.isGM}}
+        <a class="button-remise-a-neuf"><img class="button-img" src="icons/svg/regen.svg" data-tooltip="Remise à neuf"/></a>
+        {{/if}}
+        {{#if options.exportScriptarium}}
+        <a class="button-export">
+          <img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/scriptarium.svg" data-tooltip="Export format Scriptarium"/>
+        </a>
+        {{/if}}
+      </div>
+    </div>
+  </section>
+  <section class="sheet-body" style=:"margin-bottom: 3rem;">
+    <div>
+      <strong>{{export.name.value}}</strong>{{#if export.description.value}}, {{export.description.value}}{{/if}}
+      </div>
+    <hr>
+    <div class="grid-2col">
+      <div class="flexcol flex-group-top">
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.taille}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.apparence}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.constitution}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.force}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.agilite}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.dexterite}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.vue}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.ouie}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.odoratgout}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.volonte}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.empathie}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.intellect}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-compteur.hbs" carac=export.reve actuel=export.reve_actuel button-name='ptreve-actuel'}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.chance}}
+      </div>
+      <div class="flexcol flex-group-top">
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-derivee.hbs" carac=export.melee}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-derivee.hbs" carac=export.tir}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-derivee.hbs" carac=export.lancer}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-derivee.hbs" carac=export.derobee}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-derivee-compteur.hbs" carac=export.vie actuel=export.vie_actuel}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-derivee-compteur.hbs" carac=export.endurance actuel=export.endurance_actuel}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/fatigue.hbs" }}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-derivee.hbs" carac=export.plusdom}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/protection.hbs" export}}
+        <div class="flexrow">&nbsp;</div>
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessures.hbs" }}
+      </div>
+    </div>
+  <hr>
+    <div>
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/arme.hbs" name='' niveau='Niv' init='Init' dommages='+dom'}}
+      {{#each context.armes as |arme|}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/arme.hbs"
+          name=arme.name niveau=arme.niveau init=arme.init dommages=arme.dommages
+          arme=arme.arme competence=arme.competence
+        }}
+      {{/each}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/esquive.hbs" name='Esquive' niveau=context.esquive.value competence=context.esquive.competence}}
+      {{#if (gt export.malue_armure.value 0)}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/esquive.hbs" name='Esquive (avec armure)' niveau=export.esquive_armure.value
+        competence=context.esquive.competence}}
+      {{/if}}
+    </div>
+  <hr>
+    <div>
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/competences.hbs" competences=competences}}
+    </div>
+  <hr>
+    <div>
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/competences.hbs" competences=draconic }}
+    </div>
+    <hr>
+    <div>
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_0.value description=export.sort_description_0.value bonus=export.sort_bonus_0.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_1.value description=export.sort_description_1.value bonus=export.sort_bonus_1.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_2.value description=export.sort_description_2.value bonus=export.sort_bonus_2.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_3.value description=export.sort_description_3.value bonus=export.sort_bonus_3.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_4.value description=export.sort_description_4.value bonus=export.sort_bonus_4.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_5.value description=export.sort_description_5.value bonus=export.sort_bonus_5.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_6.value description=export.sort_description_6.value bonus=export.sort_bonus_6.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_7.value description=export.sort_description_7.value bonus=export.sort_bonus_7.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_8.value description=export.sort_description_8.value bonus=export.sort_bonus_8.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_9.value description=export.sort_description_9.value bonus=export.sort_bonus_9.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_10.value description=export.sort_description_10.value bonus=export.sort_bonus_10.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_11.value description=export.sort_description_11.value bonus=export.sort_bonus_11.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_12.value description=export.sort_description_12.value bonus=export.sort_bonus_12.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_13.value description=export.sort_description_13.value bonus=export.sort_bonus_13.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_14.value description=export.sort_description_14.value bonus=export.sort_bonus_14.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_15.value description=export.sort_description_15.value bonus=export.sort_bonus_15.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_16.value description=export.sort_description_16.value bonus=export.sort_bonus_16.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_17.value description=export.sort_description_17.value bonus=export.sort_bonus_17.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_18.value description=export.sort_description_18.value bonus=export.sort_bonus_18.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_19.value description=export.sort_description_19.value bonus=export.sort_bonus_19.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_20.value description=export.sort_description_20.value bonus=export.sort_bonus_20.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_21.value description=export.sort_description_21.value bonus=export.sort_bonus_21.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_22.value description=export.sort_description_22.value bonus=export.sort_bonus_22.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_23.value description=export.sort_description_23.value bonus=export.sort_bonus_23.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_24.value description=export.sort_description_24.value bonus=export.sort_bonus_24.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_25.value description=export.sort_description_25.value bonus=export.sort_bonus_25.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_26.value description=export.sort_description_26.value bonus=export.sort_bonus_26.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_27.value description=export.sort_description_27.value bonus=export.sort_bonus_27.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_28.value description=export.sort_description_28.value bonus=export.sort_bonus_28.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_29.value description=export.sort_description_29.value bonus=export.sort_bonus_29.value}}
+      <div>&nbsp;</div>
+      <div>&nbsp;</div>
+    </div>
+  </section>
+</form>

templates/actor/export-scriptarium/arme.hbs

@@ -0,0 +1,20 @@
+<div class="flexrow item"
+      data-item-id="{{arme._id}}"
+      data-arme-name="{{arme.name}}"
+      data-competence-name="{{competence.name}}">
+      {{#if name}}
+      <a class="roll-arme">{{upperFirst name}}</a>
+      {{else}}
+      <div></div>
+      {{/if}}
+  <div class="flexrow">
+    <div>{{niveau}}</div>
+    {{#if init}}
+    <div>{{init}}</div>
+    <div>{{dommages}}</div>
+    {{else}}
+    <div></div>
+    <div></div>
+    {{/if}}
+  </div>
+</div>

templates/actor/export-scriptarium/blessure.hbs

@@ -0,0 +1,5 @@
+{{#if blessure}}
+<a class="click-blessure-remove" data-gravite="{{gravite}}"><i class="fa-regular fa-face-head-bandage blessure-active-{{gravite}}"></i></a>
+{{else}}
+<a class="click-blessure-add" data-gravite="{{gravite}}"><i class="fa-regular fa-circle"></i></a>
+{{/if}}

templates/actor/export-scriptarium/blessures.hbs

@@ -0,0 +1,26 @@
+
+<div class="flexcol">
+  <div class="flexrow">
+    <div>Légères</div>
+    <div class="flex-group-right">
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessure.hbs" blessure=etat.blessure.[0] gravite=2}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessure.hbs" blessure=etat.blessure.[1] gravite=2}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessure.hbs" blessure=etat.blessure.[2] gravite=2}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessure.hbs" blessure=etat.blessure.[3] gravite=2}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessure.hbs" blessure=etat.blessure.[4] gravite=2}}
+    </div>
+  </div>
+  <div class="flexrow">
+    <div>Graves</div>
+    <div class="flex-group-right">
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessure.hbs" blessure=etat.blessure.[5] gravite=4}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessure.hbs" blessure=etat.blessure.[6] gravite=4}}
+    </div>
+  </div>
+  <div class="flexrow">
+    <div>Critiques</div>
+    <div class="flex-group-right">
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessure.hbs" blessure=etat.blessure.[7] gravite=6}}
+    </div>
+  </div>
+</div>

templates/actor/export-scriptarium/carac-compteur.hbs

@@ -0,0 +1,18 @@
+<div class="flexrow">
+  <div>
+    {{#if carac.rollClass}}
+    <a class="{{carac.rollClass}}" data-carac-name="{{carac.column}}">
+      {{upper carac.colName}}
+    </a>
+    {{else}}
+    {{upper carac.colName}}
+    {{/if}}
+    <a class="{{button-name}}-moins"><i class="fa-regular fa-square-minus"></i></a>
+    <a class="{{button-name}}-plus"><i class="fa-regular fa-square-plus"></i></a>
+  </div>
+  <div class="flex-group-right">
+    {{log carac.colName carac.value (eq carac.value actuel.value) actuel.value}}
+    {{log carac.colName carac.value (eq 1 1) actuel.value}}
+    <a class="{{actuel.rollClass}}" data-carac-name="{{actuel.column}}">{{carac.value}} {{#unless (eq carac.value actuel.value)}}(Actuel : {{actuel.value}}){{/unless}}</a>
+  </div>
+</div>

templates/actor/export-scriptarium/carac-derivee-compteur.hbs

@@ -0,0 +1,10 @@
+<div class="flexrow">
+  <div>
+    {{upperFirst carac.colName}}
+    <a class="{{carac.column}}-moins"><i class="fa-regular fa-square-minus"></i></a>
+    <a class="{{carac.column}}-plus"><i class="fa-regular fa-square-plus"></i></a>
+  </div>
+  <div class="flex-group-right">
+    <a class="{{actuel.rollClass}}" data-carac-name="{{actuel.column}}">{{carac.value}} {{#unless (eq carac.value actuel.value)}}(Actuel : {{actuel.value}}){{/unless}}</a>
+  </div>
+</div>

templates/actor/export-scriptarium/carac-derivee.hbs

@@ -0,0 +1,12 @@
+<div class="flexrow">
+  <div>
+    {{#if carac.rollClass}}
+    <a class="{{carac.rollClass}}" data-carac-name="{{carac.column}}">
+      {{upperFirst carac.colName}}
+    </a>
+    {{else}}
+    {{upperFirst carac.colName}}
+    {{/if}}
+  </div>
+  <div class="flex-group-right">{{carac.value}}</div>
+</div>

templates/actor/export-scriptarium/carac.hbs

@@ -0,0 +1,10 @@
+<div class="flexrow">
+  <div>
+    {{#if carac.rollClass}}
+    <a class="{{carac.rollClass}}" data-carac-name="{{carac.column}}">{{upper carac.colName}}</a>
+    {{else}}
+    {{upper carac.colName}}
+    {{/if}}
+  </div>
+  <div class="flex-group-right">{{carac.value}}</div>
+</div>

templates/actor/export-scriptarium/competences.hbs

@@ -0,0 +1,9 @@
+{{#each competences as |group|}}
+  {{#if @index}}/{{/if}}
+  {{#with group}}
+    {{#each list as |comp|}}
+      <span class="item" data-item-id="{{comp._id}}"><a class="roll-competence">{{comp.name}}</a></span>{{~#unless (isLastIndex @index ../list)~}},{{/unless~}}
+    {{/each}}
+    {{numberFormat niveau decimals=0 sign=true}}
+  {{/with}}
+{{/each}}

templates/actor/export-scriptarium/esquive.hbs

@@ -0,0 +1,10 @@
+{{#if name}}
+<div class="flexrow item" data-item-id="{{competence._id}}">
+  <a class="roll-competence" name="Esquive">{{upperFirst name}}</a>
+  <div class="flexrow">
+    <div>{{niveau}}</div>
+    <div></div>
+    <div></div>
+  </div>
+</div>
+{{/if}}

templates/actor/export-scriptarium/fatigue.hbs

@@ -0,0 +1,12 @@
+<div class="flexrow">
+  <div>Fatigue 
+    {{#if etat.fatigue.malus}}
+    ({{etat.fatigue.malus}})
+    {{/if}}
+    <a class="fatigue-moins"><i class="fa-regular fa-square-minus"></i></a>
+    <a class="fatigue-plus"><i class="fa-regular fa-square-plus"></i></a>
+  </div>
+  <div class="flex-group-right">
+    {{etat.fatigue.value}}{{#if etat.fatigue.value}} / {{etat.fatigue.max}}{{/if}}
+  </div>
+</div>

templates/actor/export-scriptarium/protection.hbs

@@ -0,0 +1,7 @@
+{{#if protectionnaturelle.value}}
+  {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-derivee.hbs" carac=protectionnaturelle}}
+{{/if}}
+{{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-derivee.hbs" carac=protectionarmure}}
+{{#if armure.value}}
+<div class="flexrow flex-group-right"><i>{{armure.value}}</i></div>
+{{/if}}

templates/actor/export-scriptarium/sort.hbs

@@ -0,0 +1,11 @@
+{{#if voie}}
+<div class="flexrow">
+  <div style="flex-grow: 0.4;">{{voie}}</div>
+  <div class="flex-grow-2">{{upperFirst description}}</div>
+  {{#if bonus}}
+  <div>{{bonus}}</div>
+  {{else}}
+  <div></div>
+  {{/if}}
+</div>
+{{/if}}

templates/actor/header-buttons.html

@@ -1,19 +1,19 @@
 <div class="header-buttons">
-  <span class="chance-appel">
-    <a><img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/appel-chance.svg" data-tooltip="Appel à la chance"/></a>
+  <span>
+    <a class="button-appel-chance"><img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/appel-chance.svg" data-tooltip="Appel à la chance"/></a>
   </span>
-  <span class="encaisser-direct">
-    <a><img class="button-img" src="icons/svg/bones.svg" data-tooltip="Encaisser des dommages"/></a>
+  <span>
+    <a class="button-encaissement"><img class="button-img" src="icons/svg/bones.svg" data-tooltip="Encaisser des dommages"/></a>
   </span>
-  <span class="ethylisme-test">
-    <a><img class="button-img" src="icons/svg/tankard.svg" data-tooltip="Boire"/></a>
+  <span>
+    <a class="button-ethylisme"><img class="button-img" src="icons/svg/tankard.svg" data-tooltip="Boire"/></a>
   </span>
-  <span class="repos">
-    <a><img class="button-img" src="icons/svg/sleep.svg" data-tooltip="Se reposer"/></a>
+  <span>
+    <a class="button-repos"><img class="button-img" src="icons/svg/sleep.svg" data-tooltip="Se reposer"/></a>
   </span>
   {{#if @root.options.isGM}}
-  <span class="remise-a-neuf">
-    <a><img class="button-img" src="icons/svg/regen.svg" data-tooltip="Remise à neuf"/></a>
+  <span>
+    <a class="button-remise-a-neuf"><img class="button-img" src="icons/svg/regen.svg" data-tooltip="Remise à neuf"/></a>
   </span>
   {{/if}}
 </div>

templates/actor/header-compteurs.html

@@ -30,7 +30,7 @@
     </li>
     <li>
       <label class="compteur">
-        <span class="ptreve-actuel"  data-tooltip="Faire un jet de Rêve actuel (ou jet de résistance)"><a>Rêve</a></span>
+        <span class="roll-reve-actuel" data-tooltip="Faire un jet de Rêve actuel (ou jet de résistance)"><a>Rêve</a></span>
         <a class="ptreve-actuel-moins"><i class="fa-solid fa-square-minus"></i></a>
         <input class="resource-content" class="pointsreve-value" type="text" name="system.reve.reve.value" value="{{system.reve.reve.value}}" data-dtype="Number" />
         <span>/ {{system.reve.seuil.value}}</span>

templates/actor/header-hautreve.html

@@ -1,17 +1,17 @@
 {{#if system.attributs.hautrevant.value}}
   <div class="tmr-buttons">
-    <span class="monte-tmr">
-      <a data-tooltip="Montée dans les Terres M&eacute;dianes !" {{#if hautreve.isDemiReve}}disabled{{/if}}>
+    <span>
+      <a class="button-tmr" data-tooltip="Montée dans les Terres M&eacute;dianes !" {{#if hautreve.isDemiReve}}disabled{{/if}}>
         <img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-normal.svg"/>
       </a>
     </span>
-    <span class="monte-tmr-rapide">
-      <a data-tooltip="Montée accélérée dans les Terres M&eacute;dianes !" {{#if hautreve.isDemiReve}}disabled{{/if}}>
+    <span>
+      <a class="button-tmr-rapide" data-tooltip="Montée accélérée dans les Terres M&eacute;dianes !" {{#if hautreve.isDemiReve}}disabled{{/if}}>
         <img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-rapide.svg"/>
       </a>
     </span>
-    <span class="visu-tmr">
-      <a data-tooltip="Regarder les Terres M&eacute;dianes">
+    <span>
+      <a class="button-tmr-visu" data-tooltip="Regarder les Terres M&eacute;dianes">
         <img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-view.svg"/>
       </a>
     </span>

templates/actor/random/app-personnage-aleatoire.hbs

@@ -0,0 +1,53 @@
+<form class="app-personnage-aleatoire">
+  <h2>Génération aléatoire pour {{actor.name}}</h2>
+  <div class="flex-group-left">
+    {{#if options.isGM}}
+    {{>"systems/foundryvtt-reve-de-dragon/templates/actor/random/champ-aleatoire.hbs"
+      label="Nom" path="name" type="text" value=current.name checked=checked.name
+    }}
+    {{/if}}
+    {{>"systems/foundryvtt-reve-de-dragon/templates/actor/random/champ-aleatoire.hbs"
+      label="Sexe" path="system.sexe" type="text"
+      value=current.system.sexe checked=checked.system.sexe
+    }}
+    {{>"systems/foundryvtt-reve-de-dragon/templates/actor/random/champ-aleatoire.hbs"
+      label="Age" path="system.age" type="entier" min=10 max=100
+      value=current.system.age checked=checked.system.age
+    }}
+    {{>"systems/foundryvtt-reve-de-dragon/templates/actor/random/champ-aleatoire.hbs"
+      label="Taille" path="system.taille" type="text"
+      value=current.system.taille checked=checked.system.taille
+    }}
+    {{>"systems/foundryvtt-reve-de-dragon/templates/actor/random/champ-aleatoire.hbs"
+      label="Poids" path="system.poids" type="text"
+      value=current.system.poids checked=checked.system.poids
+    }}
+    {{>"systems/foundryvtt-reve-de-dragon/templates/actor/random/champ-aleatoire.hbs"
+      label="Main directrice" path="system.main" type="text"
+      value=current.system.main checked=checked.system.main
+    }}
+    {{>"systems/foundryvtt-reve-de-dragon/templates/actor/random/champ-aleatoire.hbs"
+      label="Heure de naissance" path="system.heure" type="heure"
+      value=current.system.heure checked=checked.system.heure
+    }}
+    {{>"systems/foundryvtt-reve-de-dragon/templates/actor/random/champ-aleatoire.hbs"
+      label="Cheveux" path="system.cheveux" type="text"
+      value=current.system.cheveux checked=checked.system.cheveux
+    }}
+    {{>"systems/foundryvtt-reve-de-dragon/templates/actor/random/champ-aleatoire.hbs"
+      label="Yeux" path="system.yeux" type="text"
+      value=current.system.yeux checked=checked.system.yeux
+    }}
+  </div>
+  <hr>
+  <div style="text-align: right;">
+    <a class="chat-card-button randomize-selected">Générer les valeurs sélectionnés</a>
+  </div>
+  <br>
+  <div class="flexrow">
+  <button class="button-cancel">Annuler</button>
+  <button class="button-apply">Appliquer à {{actor.name}}</button>
+  </div>
+  <br>
+</form>
+

templates/actor/random/champ-aleatoire.hbs

@@ -0,0 +1,19 @@
+<div class="flexrow random-field" data-path="{{path}}">
+  <label for="{{path}}">{{label}}:</label>
+  {{#if (eq type 'entier')}}
+  <input class="current-value" name="current.{{path}}" value="{{value}}" placeholder="{{label}}" type="number" data-dtype="Number" min="{{min}}" max="{{max}}"/>
+  {{else if (eq type 'heure')}}
+  <select class="current-value" name="current.{{path}}" value="{{value}}" type="text" data-dtype="String">
+    {{#select value}}
+    {{> "systems/foundryvtt-reve-de-dragon/templates/enum-heures.html"}}
+    {{/select}}
+  </select>
+  {{else}}
+  <input class="current-value" name="current.{{path}}" value="{{value}}" placeholder="{{label}}" type="text" data-dtype="String"/>
+  {{/if}}
+  <div class="item-controls">
+    <a class="random" data-action="random" data-tooltip="Aléatoire"><i class="fa-solid fa-dice-d20"></i></a>
+    <a class="reset" data-action="reset" data-tooltip="Reset"><i class="fa-solid fa-eraser"></i></a>
+    <input class="check-for-random" type="checkbox" data-tooltip="Sélectionné pour génération automatique" {{#if checked}}checked{{/if}}/>
+  </div>
+</div>

templates/chat-compendium-table-roll.hbs

@@ -1,5 +1,5 @@
-<h4>Tirage aléatoire: {{typeName}}</h4>
-<div>{{document.pack}}</div>
+<h4>Tirage aléatoire: {{document.name}}</h4>
+<div>Tirage de {{typeName}} aléatoire depuis {{document.pack}}</div>
 <div>Jet {{roll.formula}} : {{roll.total}}{{percentages}}</div>
 <hr>
 <div>
@@ -15,4 +15,4 @@
     {{{document.system.description}}}
   </div>
   {{/if}}
-</div>
+</div>

templates/chat-compendium-table.hbs

@@ -11,9 +11,10 @@
 <div>
   <ul class="flexcol item-list alterne-list">
     {{#each table as |row|}}
-    <li class="item list-item" >
-      <span>{{row.min}}{{#unless (eq row.min row.max)}}-{{row.max}}{{/unless}} : &nbsp;</span>
-      <span>{{linkCompendium row.document.pack row.document.id row.document.name}}</span>
+    <li class="item list-item ">
+      <span class="flex-group-left">
+        {{row.min}}{{#unless (eq row.min row.max)}}-{{row.max}}{{/unless}}&nbsp;: {{linkCompendium row.document.pack row.document.id row.document.name}}
+      </span>
     </li>
     {{/each}}
   </ul>

templates/enum-draconic.html

@@ -3,3 +3,5 @@
   <option value="{{competence.name}}">{{competence.name}}</option>
   {{/if}}
 {{/each}}
+<option value="O/H/N/T">Oniros/Hypnos/Narcos/Thanatos</option>
+<option value="O/H/N">Oniros/Hypnos/Narcos</option>

templates/settings/regles-optionnelles.hbs

@@ -0,0 +1,13 @@
+<form autocomplete="off" onsubmit="event.preventDefault();">
+  {{#each groups as |group key|}}
+  <h3>{{key}}</h3>
+  <ul>
+    {{#each group as |regle r|}}
+    <li>
+      <input class="select-option" type="checkbox" name="{{regle.id}}" {{#if regle.active}}checked{{/if}}/>
+      <label>{{regle.descr}}</label>
+    </li>
+    {{/each}}
+  </ul>
+  {{/each}}
+</form>