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

Reviewed-on: #715
2024-10-17 07:53:59 +02:00 · 2024-10-17 07:53:59 +02:00 · a7e1ca0b07
commit a7e1ca0b07
parent 174ef4256a e2c4d93413
41 changed files with 353 additions and 327 deletions
--- a/changelog.md
+++ b/changelog.md
@ -1,4 +1,11 @@
 # 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, ...)
--- a/module/actor.js
+++ b/module/actor.js
@ -159,7 +159,7 @@ export class RdDActor extends RdDBaseActorSang {
    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: ""
      };

@ -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);
@ -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;
@ -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;
@ -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)
          });
        }
@ -1563,7 +1563,7 @@ export class RdDActor extends RdDBaseActorSang {
      }
      else {
        ChatMessage.create({
-          whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+          whisper: ChatUtility.getOwners(this),
          content: content
        });
      }
@ -1666,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;
@ -1678,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;
@ -1690,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)
      });
    }
  }
@ -2270,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 []
    }
@ -2405,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;
@ -2453,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;
      }
@ -2850,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)
    });
  }
@ -2887,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)
    });
  }
@ -2919,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)
    });
  }
@ -2944,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)
    });
  }
@ -3044,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 : ''}`
    });
  }
--- a/module/actor/base-actor-reve.js
+++ b/module/actor/base-actor-reve.js
@ -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,7 +296,7 @@ export class RdDBaseActorReve extends RdDBaseActor {

  /* -------------------------------------------- */
  async rollCarac(caracName, jetResistance = undefined) {
-    if (Grammar.equalsInsensitive(caracName, 'taille')){
+    if (Grammar.equalsInsensitive(caracName, 'taille')) {
      return
    }
    RdDEmpoignade.checkEmpoignadeEnCours(this)
@ -418,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);
@ -456,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)
      });
    }
--- a/module/actor/base-actor-sang-sheet.js
+++ b/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)
+    })
  }

 }
--- a/module/actor/base-actor-sang.js
+++ b/module/actor/base-actor-sang.js
@ -5,6 +5,7 @@ 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
@ -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,9 +197,9 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
    return blessure;
  }

-  async supprimerBlessure({gravite}) {
+  async supprimerBlessure({ gravite }) {
    const toDelete = this.itemTypes[ITEM_TYPES.blessure].find(it => it.system.gravite == gravite)?.id
-    if (toDelete){
+    if (toDelete) {
      await this.deleteEmbeddedDocuments('Item', [toDelete]);
    }
  }
@ -216,7 +217,10 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
  /* -------------------------------------------- */
  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");
@ -243,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)
+    });
  }

  /* -------------------------------------------- */
--- a/module/actor/base-actor.js
+++ b/module/actor/base-actor.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)
    });

--- a/module/chat-utility.js
+++ b/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
+      })
    }
  }

--- a/module/coeur/rdd-coeur.js
+++ b/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
    });
  }
--- a/module/dialog-chronologie.js
+++ b/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",
--- a/module/dialog-create-signedraconique.js
+++ b/module/dialog-create-signedraconique.js
@ -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
--- a/module/environnement.js
+++ b/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: [
--- a/module/item/blessure.js
+++ b/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)
    });

  }
--- a/module/item/maladie.js
+++ b/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)
    }
  }

--- a/module/rdd-combat.js
+++ b/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,
@ -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
    });
  }
--- a/module/rdd-commands.js
+++ b/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)?/;

@ -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;
  }

--- a/module/rdd-dice.js
+++ b/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,14 @@ 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
  }
@ -155,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) {
@ -223,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 };
-  }
 }
--- a/module/rdd-empoignade.js
+++ b/module/rdd-empoignade.js
@ -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');
--- a/module/rdd-hotbar-drop.js
+++ b/module/rdd-hotbar-drop.js
@ -79,8 +79,7 @@ export class RdDHotbar {
   * Actor     - open actor sheet
   * Journal   - open journal sheet
   */
-  static init() {
-
+  static initHooks() {
    Hooks.on('hotbarDrop', (bar, documentData, slot) => {

      // Create item macro if rollable item - weapon, spell, prayer, trait, or skill
--- a/module/rdd-main.js
+++ b/module/rdd-main.js
@ -61,7 +61,7 @@ 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 { 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"
@ -80,7 +80,7 @@ export class SystemReveDeDragon {
    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() {
@ -115,24 +115,31 @@ export class SystemReveDeDragon {
    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()
    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)
      try {
@ -147,6 +154,7 @@ export class SystemReveDeDragon {

    /* -------------------------------------------- */
    // Define custom Entity classes
+    console.log(`Initializing Reve de Dragon Documents`)
    CONFIG.Actor.documentClass = RdDBaseActor
    CONFIG.Item.documentClass = RdDItem
    CONFIG.RDD = {
@ -192,17 +200,12 @@ export class SystemReveDeDragon {
        "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()
-    OptionsAvancees.init()
-    RdDUtility.init()
+    console.log(`Initializing Reve de Dragon Hooks and handlers`)
+    CONFIG.Combat.documentClass = RdDCombatManager
+    ChatUtility.init()
+    RdDUtility.initHooks()
    RdDDice.init()
    RdDCommands.init()
    RdDCombatManager.init()
@ -211,15 +214,14 @@ export class SystemReveDeDragon {
    RdDCompendiumOrganiser.init()
    EffetsDraconiques.init()
    TMRUtility.init()
-    await RdDTMRDialog.init()
-    RdDHotbar.init()
+    RdDHotbar.initHooks()
    RdDPossession.init()
    TMRRencontres.init()
-    Environnement.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",
@ -318,4 +320,3 @@ export class SystemReveDeDragon {
 }

 SystemReveDeDragon.start()
-
--- a/module/rdd-meteo.js
+++ b/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()
    });
  }

--- a/module/rdd-namegen.js
+++ b/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";

@ -15,7 +16,7 @@ export class RdDNameGen {
    const html = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-command-nom.html`, {
      nom: await RdDNameGen.generate()
    });
-    ChatMessage.create({ content: html, whisper: ChatMessage.getWhisperRecipients("GM") });
+    ChatMessage.create({ content: html, whisper: ChatUtility.getGMs() });
  }

  static async generate() {
--- a/module/rdd-resolution-table.js
+++ b/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)
    });
  }

--- a/module/rdd-tmr-dialog.js
+++ b/module/rdd-tmr-dialog.js
@ -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 = [];
@ -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) })
      });
    }
--- a/module/rdd-utility.js
+++ b/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,7 +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('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));
@ -645,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
    }
  }

@ -808,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;
  }

@ -881,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) {
@ -900,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
      });
    }
--- a/module/settings/options-avancees.js
+++ b/module/settings/options-avancees.js
@ -8,7 +8,7 @@ const OPTIONS_AVANCEES = [
 ]

 export class OptionsAvancees extends FormApplication {
-  static init() {
+  static initSettings() {
    for (const regle of OPTIONS_AVANCEES) {
      const name = regle.name
      const id = OptionsAvancees._getId(name)
--- a/module/settings/regles-optionnelles.js
+++ b/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);
--- a/module/settings/system-compendiums.js
+++ b/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)
  }

 }
--- a/module/time/auto-adjust-darkness.js
+++ b/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",
--- a/module/time/rdd-calendrier.js
+++ b/module/time/rdd-calendrier.js
@ -15,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",
--- a/module/time/rdd-timestamp.js
+++ b/module/time/rdd-timestamp.js
@ -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",
--- a/module/tmr-rencontres.js
+++ b/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,
--- a/module/tmr/effets-rencontres.js
+++ b/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)
    });
  }
--- a/module/tmr/present-cites.js
+++ b/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!"
      })
    }
--- a/module/tmr/urgence-draconique.js
+++ b/module/tmr/urgence-draconique.js
@ -19,7 +19,7 @@ export class UrgenceDraconique extends Draconique {
      // 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]);
--- a/module/voyage/dialog-fatigue-voyage.js
+++ b/module/voyage/dialog-fatigue-voyage.js
@ -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,
--- a/styles/simple.css
+++ b/styles/simple.css
@ -567,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;
--- a/system.json
+++ b/system.json
@ -1,8 +1,8 @@
 {
  "id": "foundryvtt-reve-de-dragon",
  "title": "Rêve de Dragon",
-  "version": "12.0.14",
-  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-12.0.14.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": {
--- a/templates/actor/competence.html
+++ b/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 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}}
-
+  <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}}
--- a/templates/chat-compendium-table-roll-rencontre.html
+++ b/templates/chat-compendium-table-roll-rencontre.html
--- a/templates/chat-compendium-table-roll.html
+++ b/templates/chat-compendium-table-roll.html
--- a/templates/chat-compendium-table.html
+++ b/templates/chat-compendium-table.html
@ -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>