Ajout des queues et souffles automatique

module/actor.js

@@ -444,12 +444,10 @@ export class RdDActor extends Actor {
       message += "<br>Vous gagnez une Tête de dragon: " + tete;
     }
     if (roll.isEchec) {
-      message += "<br>Vous subissez une Queue de Dragon";
+      message += "<br>Vous subissez une Queue de Dragon: " + await this.ajouterQueue();
-      this.ajouterQueue();
     }
     if (roll.isETotal) {
-      message += "<br>A cause de votre échec total, vous subissez une deuxième Queue de Dragon !"
+      message += "<br>A cause de votre échec total, vous subissez une deuxième Queue de Dragon: " + await this.ajouterQueue();
-      this.ajouterQueue();
     }
     return message;
   }
@@ -694,7 +692,7 @@ export class RdDActor extends Actor {
     let total = new Roll("1d20").roll().total;
     if ( total <= refoulement.value ) {
       refoulement.value = 0;
-      this.ajouterSouffle();
+      this.ajouterSouffle({chat: true});
       ret = "souffle";
     }
 
@@ -703,17 +701,20 @@ export class RdDActor extends Actor {
   }
 
   /* -------------------------------------------- */
-  ajouterSouffle() {
+  async ajouterSouffle(options = {chat : false}) {
     let souffle = RdDRollTables.getSouffle();
-    // ChatMessage.create({
+    await this.createOwnedItem(souffle);
-    //   title: "Souffle de Dragon",
+    if (options.chat){
-    //   content: this.name + " subit un Souffle de Dragon  : " + souffle.name
+      ChatMessage.create({
-    // });
+        whisper: ChatUtility.getWhisperRecipientsAndGMs( this.name ),
-    // this.actor.createOwnedItem(souffle);
+        content: this.name + " subit un Souffle de Dragon  : " + souffle.name
+      });
+    }
+    return souffle;
   }
 
   /* -------------------------------------------- */
-  async ajouterQueue() {
+  async ajouterQueue(options = {chat : false}) {
     // TODO: Déterminer si Thanatos a été utilisé? => laisser le joueur ne pas choisir Thanatos => choisir sa voie?
     let utiliseThanatos = false;
     let queue;
@@ -724,17 +725,14 @@ export class RdDActor extends Actor {
     else {
       queue = await RdDRollTables.getQueue();
     }
-    /*
+    await this.createOwnedItem(queue);
-    // TODO: convertir la queue obtenue en nouvel item ... 
+    if (options.chat){
-    // ou bien l'ajouter à la liste spécifique => this.data.data.reve.queues
+      ChatMessage.create({
-    this.createOwnedItem(queue);
+        whisper: ChatUtility.getWhisperRecipientsAndGMs( this.name ),
-    
+        content: this.name + " subit une Queue de Dragon : " + queue.name
-    ChatMessage.create({
+      });
-      content: this.name + " subit un Queue de Dragon  : " + queue.name
+    }
-    });
+    return queue;
-    
-    return queue.name;
-    */
   }
   
   /* -------------------------------------------- */  
@@ -1313,6 +1311,10 @@ export class RdDActor extends Actor {
 
   /* -------------------------------------------- */  
   async rollCompetence( name ) {
+    if (name == 'queue') {
+      await this.ajouterQueue({chat: true});
+      return;
+    }
     let rollData = {
       competence:  duplicate(this.getCompetence(name)),
       needSignificative : !this.isEntiteCauchemar() && this.data.data.sante.sonne.value

module/rdd-rolltables.js

@@ -6,38 +6,46 @@ export class RdDRollTables {
     const index = await pack.getIndex();
     const entry = index.find(e => e.name === tableName);
     const table = await pack.getEntity(entry._id);
-    const result = await table.draw({ displayChat: toChat });
+    const draw = await table.draw({ displayChat: toChat });
-    console.log("RdDRollTables", tableName, toChat, ":", result);
+    console.log("RdDRollTables", tableName, toChat, ":", draw);
-    return result;
+    console.log("RdDRollTables", tableName, toChat, ":", draw.roll, draw.results);
+    return draw;
   }
 
+  /* -------------------------------------------- */
+  static async drawItemFromRollTable(tableName, toChat) {
+    const draw = await RdDRollTables.genericGetTableResult(tableName, toChat);
+    const drawnItemRef = draw.results.length > 0 ? draw.results[0] : undefined;
+    const pack = game.packs.get(drawnItemRef.collection);
+    return await pack.getEntity(drawnItemRef.resultId);
+  }
   /* -------------------------------------------- */
   static async getSouffle(toChat = true) {
-    return RdDRollTables.genericGetTableResult("Souffles de Dragon", toChat);
+    return await RdDRollTables.drawItemFromRollTable("Souffles de Dragon", toChat);
   }
 
   /* -------------------------------------------- */
   static async getQueue(toChat = true) {
-    return RdDRollTables.genericGetTableResult("Queues de dragon", toChat);
+    return await RdDRollTables.drawItemFromRollTable("Queues de dragon", toChat);
   }
 
   /* -------------------------------------------- */
   static async getTete(toChat = true) {
-    return RdDRollTables.genericGetTableResult("Têtes de Dragon pour haut-rêvants", toChat);
+    return await RdDRollTables.drawItemFromRollTable("Têtes de Dragon pour haut-rêvants", toChat);
   }
 
   /* -------------------------------------------- */
   static async getTeteHR(toChat = true) {
-    return RdDRollTables.genericGetTableResult("Têtes de Dragon pour tous personnages", toChat);
+    return await RdDRollTables.drawItemFromRollTable("Têtes de Dragon pour tous personnages", toChat);
   }
 
   /* -------------------------------------------- */
   static async getOmbre(toChat = true) {
-    return RdDRollTables.genericGetTableResult("Ombre de Thanatos", toChat);
+    return await RdDRollTables.drawItemFromRollTable("Ombre de Thanatos", toChat);
   }
 
   /* -------------------------------------------- */
   static async getTarot(toChat = true) {
-    return RdDRollTables.genericGetTableResult("Tarot Draconique", toChat);
+    return await RdDRollTables.drawItemFromRollTable("Tarot Draconique", toChat);
   }
 }

module/rdd-tmr-dialog.js

@@ -342,10 +342,9 @@ export class RdDTMRDialog extends Dialog {
         + RdDResolutionTable.explain(rolled);
 
       if (rolled.isETotal) {
-        let souffle = await RdDRollTables.getSouffle();
+        let souffle = await this.actor.ajouterSouffle({chat: false});
         explication += "<br>Vous avez fait un Echec Total. Vous subissez un Souffle de Dragon : " + souffle.name;
         msg2MJ += "<br>Et a reçu un Souffle de Dragon : " + souffle.name;
-        this.actor.createOwnedItem(souffle);
       }
       if (rolled.isPart) {
         explication += "<br>Vous avez fait une Réussite Particulière";

module/tmr-utility.js

@@ -526,18 +526,6 @@ export class TMRUtility  {
     return { message: message, state: state };
   }
 
-  /* -------------------------------------------- */
-  static async genericGetTableResult( tableName, toChat)
-  {
-    let pack = game.packs.get("foundryvtt-reve-de-dragon.tables-diverses");
-    await pack.getIndex();
-    let entry = pack.index.find(e => e.name === tableName);
-    let rollQueues = await pack.getEntity(entry._id);
-    let result = await rollQueues.draw( { displayChat: toChat } );
-    console.log("CAT", result);
-    return result;
-  }
-
   /* -------------------------------------------- */
   static getTMRAleatoire()
   {