Fix: reset des utilisations d'items

module/rdd-combat.js

@@ -42,7 +42,8 @@ export class RdDCombatManager extends Combat {
     /* -------------------------------------------- */
     Hooks.on("getCombatTrackerEntryContext", (html, options) => { RdDCombatManager.pushInitiativeOptions(html, options); });
     Hooks.on("updateCombat", (combat, change, options, userId) => { RdDCombat.onUpdateCombat(combat, change, options, userId) });
-    Hooks.on("preDeleteCombat", (combat, html, id) => { combat.onPreDeleteCombat() });
+    Hooks.on("preDeleteCombat", (combat, html, id) => { combat.onPreDeleteCombat() })
+    Hooks.on("deleteCombat", (combat, html, id) => { combat.onDeleteCombat() })
   }
 
   /* -------------------------------------------- */
@@ -61,20 +62,31 @@ export class RdDCombatManager extends Combat {
       RdDEmpoignade.deleteAllEmpoignades()
     }
   }
-
-  /* -------------------------------------------- */
-  async finDeRound(options = { terminer: false }) {
-    this.turns.forEach(turn => turn.actor.resetItemUse());
-
-    for (let combatant of this.combatants) {
-      if (combatant.actor) {
-        await combatant.actor.finDeRound(options);
-      }
-      else {
-        ui.notifications.warn(`Le combatant ${combatant.name} n'est pas associé à un acteur!`)
+  async onDeleteCombat() {
+    if (Misc.isFirstConnectedGM()) {
+      if (game.combats.size <= 1) {
+        game.actors.forEach(actor => actor.resetItemUse())
       }
     }
   }
+
+  /* -------------------------------------------- */
+  async finDeRound(options = { terminer: false }) {
+
+    for (let combatant of this.combatants) {
+      if (!combatant.actor) {
+        ui.notifications.warn(`Le combatant ${combatant.name} n'est pas associé à un acteur!`)
+      }
+      else if (!combatant.actor.isActorCombat()) {
+        ui.notifications.warn(`Le combatant ${combatant.name} ne peut pas combattre!`)
+      }
+      else {
+        await combatant.actor.finDeRound(options)
+        await combatant.actor.resetItemUse()
+      }
+    }
+  }
+
   static calculAjustementInit(actor, arme) {
     const efficacite = (arme?.system.magique) ? arme.system.ecaille_efficacite : 0
     const etatGeneral = actor.getEtatGeneral() ?? 0
@@ -125,7 +137,6 @@ export class RdDCombatManager extends Combat {
           }
         }
       }
-      //console.log("Combatat", c);
       const roll = combatant.getInitiativeRoll(rollFormula);
       if (!roll.total) {
         await roll.evaluate();
@@ -236,29 +247,12 @@ export class RdDCombatManager extends Combat {
     return attaque;
   }
 
-  static listActionsCreature(competences) {
-    return competences
-      .filter(it => RdDItemCompetenceCreature.isCompetenceAttaque(it))
-      .map(it => RdDItemCompetenceCreature.armeCreature(it))
-      .filter(it => it != undefined);
-  }
-
-  static listActionsPossessions(actor) {
-    return RdDCombatManager._indexActions(actor.getPossessions().map(p => {
-      return {
-        name: p.name,
-        action: 'possession',
-        system: {
-          competence: p.name,
-          possessionid: p.system.possessionid,
-        }
-      }
-    }));
-  }
-
   /* -------------------------------------------- */
   static listActionsCombat(combatant) {
     const actor = combatant.actor;
+    if (!actor.isActorCombat()) {
+      return
+    }
     let actions = RdDCombatManager.listActionsPossessions(actor);
     if (actions.length > 0) {
       return actions;
@@ -281,6 +275,26 @@ export class RdDCombatManager extends Combat {
     return RdDCombatManager._indexActions(actions);
   }
 
+  static listActionsCreature(competences) {
+    return competences
+      .filter(it => RdDItemCompetenceCreature.isCompetenceAttaque(it))
+      .map(it => RdDItemCompetenceCreature.armeCreature(it))
+      .filter(it => it != undefined);
+  }
+
+  static listActionsPossessions(actor) {
+    return RdDCombatManager._indexActions(actor.getPossessions().map(p => {
+      return {
+        name: p.name,
+        action: 'possession',
+        system: {
+          competence: p.name,
+          possessionid: p.system.possessionid,
+        }
+      }
+    }));
+  }
+
   static _indexActions(actions) {
     for (let index = 0; index < actions.length; index++) {
       actions[index].index = index;
@@ -457,8 +471,8 @@ export class RdDCombat {
     if (Misc.isFirstConnectedGM()) {
       let turn = combat.turns.find(t => t.token?.id == combat.current.tokenId);
       if (turn?.actor) {
-        RdDCombat.displayActorCombatStatus(combat, turn.actor, turn.token);
         // TODO Playaudio for player??
+        RdDCombat.displayActorCombatStatus(combat, turn.actor, turn.token);
       }
     }
   }
@@ -574,15 +588,15 @@ export class RdDCombat {
 
   static $extractAttackerTokenData(attacker, attackerTokenId) {
     const token = canvas.tokens.get(attackerTokenId);
-    return token ? Targets.extractTokenData(token) : Targets.buildActorTokenData(attackerTokenId, attacker) 
+    return token ? Targets.extractTokenData(token) : Targets.buildActorTokenData(attackerTokenId, attacker)
   }
-  
+
   static $extractDefenderTokenData(defender, defenderTokenId, target) {
     if (target) {
       return Targets.extractTokenData(target)
     }
     const token = canvas.tokens.get(defenderTokenId);
-    return token ? Targets.extractTokenData(token) : Targets.buildActorTokenData(defenderTokenId, defender) 
+    return token ? Targets.extractTokenData(token) : Targets.buildActorTokenData(defenderTokenId, defender)
   }
 
 
@@ -811,7 +825,7 @@ export class RdDCombat {
     dialog.render(true);
   }
 
-  
+
   /* -------------------------------------------- */
   _prepareAttaque(competence, arme) {
     let rollData = {
@@ -825,7 +839,7 @@ export class RdDCombat {
       targetToken: this.defenderToken,
       essais: {}
     };
-    
+
     if (this.attacker.isCreatureEntite()) {
       RdDItemCompetenceCreature.setRollDataCreature(rollData);
     }
@@ -978,7 +992,7 @@ export class RdDCombat {
   }
 
   /* -------------------------------------------- */
-  _filterArmesParade(defender, competence) {
+  _filterArmesParade(defender, competence, arme) {
     let items = defender.items.filter(it => RdDItemArme.isArmeUtilisable(it) || RdDItemCompetenceCreature.isCompetenceParade(it))
     items.forEach(item => item.system.nbUsage = defender.getItemUse(item.id)); // Ajout du # d'utilisation ce round  
 
@@ -1335,11 +1349,14 @@ export class RdDCombat {
 
   /* -------------------------------------------- */
   static async displayActorCombatStatus(combat, actor, token) {
+    if (!actor?.isActorCombat()) {
+      return
+    }
     let formData = {
       combatId: combat._id,
       alias: token.name ?? actor.name,
       etatGeneral: actor.getEtatGeneral(),
-      isSonne: actor.getSonne(),
+      isSonne: actor.isSonne(),
       blessuresStatus: actor.computeResumeBlessure(),
       SConst: actor.getSConst(),
       actorId: actor.id,