Améliorations du combat

- nettoyage des infos et messages de combat améliorés
- message de status envoyé uniquement par le GM (pour éviter les
doublons)
- stockage des infos de passes d'armes géré par RdDCombat

Déplacement des Hooks/notifications de messages socket:
- liés au combat dans la méthode RdDCombat.init

Convention de nommage: les méthodes de gestion de notification par
hook/socket sont préfixées 'on'
ex: onSocketMessage, onUpdateCombat, onPreDeleteCombat

module/rdd-combat.js

@@ -9,6 +9,67 @@ import { RdDRollTables } from "./rdd-rolltables.js";
 
 export class RdDCombat {
 
+  static init() {
+    this.initStorePasseArmes();
+    Hooks.on("updateCombat", (combat, data) => { RdDCombat.onUpdateCombat(combat, data) });
+    Hooks.on("preDeleteCombat", (combat, options) => { RdDCombat.onPreDeleteCombat(combat, options); });
+  }
+
+  /* -------------------------------------------- */
+  static initStorePasseArmes() {
+    game.system.rdd.combatStore = {
+      attaques: {},
+      defenses: {}
+    };
+  }
+
+  /* -------------------------------------------- */
+  static onSocketMessage(sockmsg) {
+    switch (sockmsg.msg) {
+      case "msg_encaisser":
+        return RdDCombat.terminerPasseArmes(data);
+      case "msg_defense":
+        return RdDCombat.handleMsgDefense(sockmsg.data);
+    }
+  }
+
+  /* -------------------------------------------- */
+  static onUpdateCombat(combat, data) {
+    if (combat.data.round != 0 && combat.turns && combat.data.active) {
+      RdDCombat.combatNouveauRound(combat);
+    }
+  }
+
+  /* -------------------------------------------- */
+  static onPreDeleteCombat(combat, options) {
+    if (game.user.isGM) {
+      ChatUtility.removeMyChatMessageContaining(`<div data-combatid="${combat.id}" data-combatmessage="actor-turn-summary">`)
+      /*
+      * TODO: support de plusieurs combats parallèles
+      * il faudrait avoir un id de combat en plus de celui de passe d'armes
+      */
+      for (const key in game.system.rdd.combatStore.attaques) {
+        const attackerRoll = game.system.rdd.combatStore.attaques[key];
+        ChatUtility.removeChatMessageActionsPasseArme(`<div data-passearme="${attackerRoll.passeArme}">`);
+      }
+      for (const key in game.system.rdd.combatStore.defenses) {
+        const defenderRoll = game.system.rdd.combatStore.defenses[key];
+        ChatUtility.removeMyChatMessageContaining(`<div data-passearme="${defenderRoll.passeArme}">`);
+      }
+      RdDCombat.initStorePasseArmes();
+    }
+  }
+
+  /* -------------------------------------------- */
+  static combatNouveauRound(combat) {
+    let turn = combat.turns.find(t => t.tokenId == combat.current.tokenId);
+    if (game.user.isGM) {
+      // seul le GM notifie le status
+      this.displayActorCombatStatus(combat, turn.actor);
+      // TODO Playaudio for player??
+    }
+  }
+
   /* -------------------------------------------- */
   static isActive() {
     return true;
@@ -58,6 +119,33 @@ export class RdDCombat {
     return RdDCombat.createUsingTarget(attacker)
   }
 
+  /* -------------------------------------------- */
+  static handleMsgDefense(data) {
+    let defenderToken = canvas.tokens.get(data.defenderTokenId);
+    if (defenderToken) {
+      if (!game.user.isGM && game.user.character == undefined) { // vérification / sanity check
+        ui.notifications.error("Le joueur " + game.user.name + " n'est connecté à aucun personnage. Impossible de continuer.");
+        return;
+      }
+      if ((game.user.isGM && !defenderToken.actor.hasPlayerOwner) || (defenderToken.actor.hasPlayerOwner && (game.user.character.id == defenderToken.actor.data._id))) {
+        //console.log("User is pushing message...", game.user.name);
+        game.system.rdd.combatStore.attaques[data.attackerId] = duplicate(data.rollData);
+        data.whisper = [game.user];
+        data.blind = true;
+        data.rollMode = "blindroll";
+        ChatMessage.create(data);
+      }
+    }
+  }
+
+  static terminerPasseArmes(data) {
+    if (game.user.isGM) { // Seul le GM nettoie le stockage des données de combat
+      let attackerRoll = game.system.rdd.combatStore.attaques[data.attackerId]; // Retrieve the rolldata from the store
+      game.system.rdd.combatStore.attaques[data.attackerId] = undefined;
+      game.system.rdd.combatStore.defenses[attackerRoll.passeArme] = undefined;
+    }
+  }
+
   /* -------------------------------------------- */
   static _sendRollMessage(sender, recipient, defenderTokenId, topic, message, rollData) {
     let chatMessage = {
@@ -129,7 +217,7 @@ export class RdDCombat {
 
   /* -------------------------------------------- */
   async onEvent(button, event) {
-    let attackerRoll = game.system.rdd.rollDataHandler.attaques[this.attackerId];
+    let attackerRoll = game.system.rdd.combatStore.attaques[this.attackerId];
     if (!attackerRoll) {
       ui.notifications.warn("Action automatisée impossible, le jet de l'attaquant a été perdu (suite à un raffraichissement?)")
       return;
@@ -163,18 +251,18 @@ export class RdDCombat {
   /* -------------------------------------------- */
   _consumeDefense(passeArme) {
     let defenderRoll = this._getDefense(passeArme);
-    game.system.rdd.rollDataHandler.defenses[passeArme] = undefined;
+    game.system.rdd.combatStore.defenses[passeArme] = undefined;
     return defenderRoll;
   }
 
   /* -------------------------------------------- */
   _getDefense(passeArme) {
-    return game.system.rdd.rollDataHandler.defenses[passeArme];
+    return game.system.rdd.combatStore.defenses[passeArme];
   }
 
   /* -------------------------------------------- */
   _storeDefense(defenderRoll) {
-    game.system.rdd.rollDataHandler.defenses[defenderRoll.passeArme] = defenderRoll;
+    game.system.rdd.combatStore.defenses[defenderRoll.passeArme] = defenderRoll;
   }
 
   /* -------------------------------------------- */
@@ -320,7 +408,7 @@ export class RdDCombat {
 
   /* -------------------------------------------- */
   async _onAttaqueParticuliere(rollData) {
-    game.system.rdd.rollDataHandler.attaques[this.attackerId] = duplicate(rollData);
+    game.system.rdd.combatStore.attaques[this.attackerId] = duplicate(rollData);
 
     // Finesse et Rapidité seulement en mêlée et si la difficulté libre est de -1 minimum
     const isMeleeDiffNegative = rollData.selectedCarac.label == "Mêlée" && rollData.diffLibre < 0;
@@ -342,7 +430,7 @@ export class RdDCombat {
     attackerRoll.dmg = RdDBonus.dmg(attackerRoll, this.attacker.getBonusDegat(), this.defender.isEntiteCauchemar());
 
     // Save rollData for defender
-    game.system.rdd.rollDataHandler.attaques[this.attackerId] = duplicate(attackerRoll);
+    game.system.rdd.combatStore.attaques[this.attackerId] = duplicate(attackerRoll);
 
     attackerRoll.show = {
       cible: this.target ? this.defender.data.name : 'la cible',
@@ -401,7 +489,7 @@ export class RdDCombat {
   /* -------------------------------------------- */
   async _onAttaqueEchecTotal(attackerRoll) {
 
-    game.system.rdd.rollDataHandler.attaques[this.attackerId] = duplicate(attackerRoll);
+    game.system.rdd.combatStore.attaques[this.attackerId] = duplicate(attackerRoll);
 
     // Finesse et Rapidité seulement en mêlée et si la difficulté libre est de -1 minimum
     ChatMessage.create({
@@ -755,8 +843,9 @@ export class RdDCombat {
   }
 
   /* -------------------------------------------- */
-  static async displayActorCombatStatus(actor) {
-    let rollData = {
+  static async displayActorCombatStatus(combat, actor) {
+    let data = {
+      combatId: combat._id,
       alias: actor.name,
       etatGeneral: actor.getEtatGeneral(),
       isSonne: actor.getSonne(),
@@ -767,22 +856,14 @@ export class RdDCombat {
       isCritique: false
     }
     if (actor.countBlessuresByName("critiques") > 0) { // Pour éviter le cumul grave + critique
-      rollData.isCritique = true;
+      data.isCritique = true;
     } else if (actor.countBlessuresByName("graves") > 0) {
-      rollData.isGrave = true;
+      data.isGrave = true;
     }
+
     ChatUtility.createChatWithRollMode(actor.name, {
-      content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-turn-summary.html`, rollData)
+      content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-turn-summary.html`, data)
     });
   }
 
-  /* -------------------------------------------- */
-  static updateCombatRound(combat, data) {
-    if (combat.data.round != 0 && combat.turns && combat.data.active) {
-      let turn = combat.turns.find(t => t.tokenId == combat.current.tokenId);
-      this.displayActorCombatStatus(turn.actor);
-      // TODO Playaudio ??
-    }
-  }
-
 }