Fin de gestion encaissement/recul V2

module/rdd-combat.js

@@ -373,7 +373,7 @@ export class RdDCombat {
     if (Misc.isOwnerPlayer(defender)) {
       let attackerRoll = msg.attackerRoll;
       let attacker = msg.attackerId ? game.actors.get(msg.attackerId) : undefined;
-      defender.encaisserDommages(attackerRoll, attacker, msg.attackerToken);
+      defender.encaisserDommages(attackerRoll.dmg, attacker, msg.attackerToken);
       const rddCombat = RdDCombat.rddCombatForAttackerAndDefender(msg.attackerId, msg.attackerToken.id, msg.defenderToken.id);
       rddCombat?.removeChatMessageActionsPasseArme(attackerRoll.passeArme);
     }
@@ -982,21 +982,24 @@ export class RdDCombat {
     })
   }
 
-  async doRollDefense(rollData) {
+  async doRollDefense(rollData, callbacks = []) {
     await RollDialog.create(rollData, {
       onRollDone: (dialog) => {
         if (!OptionsAvancees.isUsing(ROLL_DIALOG_V2_TEST))
           dialog.close()
       },
       customChatMessage: true,
-      callbacks: [async (roll) => {
-        this.removeChatMessageActionsPasseArme(roll.passeArme);
-        // defense:  esquive / arme de parade / competence de défense
-        if (!RdDCombat.isParticuliere(roll)) {
-          await roll.active.actor.incDecItemUse(roll.current[PART_DEFENSE].defense?.id);
-        }
-        await this._onDefense(roll);
-      }]
+      callbacks: [
+        async (roll) => {
+          this.removeChatMessageActionsPasseArme(roll.passeArme);
+          // defense:  esquive / arme de parade / competence de défense
+          if (!RdDCombat.isParticuliere(roll)) {
+            await roll.active.actor.incDecItemUse(roll.current[PART_DEFENSE].defense?.id);
+          }
+          await this._onDefense(roll);
+        },
+        ...callbacks
+      ]
     })
   }
 
@@ -1027,12 +1030,10 @@ export class RdDCombat {
   }
 
   async _onDefense(rollData) {
-    console.log("RdDCombat._onDefense >>>", rollData)
     const isEsquive = rollData.current[PART_DEFENSE].isEsquive
     const isParade = !isEsquive
     if (RdDCombat.isReussite(rollData)) {
       if (isParade) {
-        await this.computeRecul(rollData)
         await this.computeDeteriorationArme(rollData)
       }
 
@@ -1040,11 +1041,6 @@ export class RdDCombat {
         await this._onDefenseParticuliere(rollData, isEsquive)
       }
     }
-    else {
-      //await this._sendMessageDefense(rollData.attackerRoll, rollData, { defense: true })
-    }
-
-    // TODO: modify chat message
     this.removeChatMessageActionsPasseArme(rollData.passeArme)
   }
 
@@ -1269,44 +1265,14 @@ export class RdDCombat {
     }
     const attackerRoll = defenderRoll.attackerRoll;
     if (this._isForceOuCharge(attackerRoll, defenderRoll.v2)) {
-      const impact = this._computeImpactRecul(attackerRoll);
-      const rollRecul = await RdDResolutionTable.roll(10, impact)
-      defenderRoll.show.recul = await this.gererRecul(rollRecul, impact)
+      defenderRoll.show.recul = this.defender.encaisserRecul(this.attacker.getForce(), attackerRoll.dmg.dmgArme)
     }
   }
 
-  async gererRecul(rolled, impact) {
-    if (rolled.isSuccess) {
-      return 'encaisse'
-    }
-    if (rolled.isETotal || this._isReculCauseChute(impact)) {
-
-      await this.defender.setEffect(STATUSES.StatusProne, true)
-      return 'chute'
-    }
-    return 'recul'
-  }
-
-  /* -------------------------------------------- */
-  async _isReculCauseChute(impact) {
-    const agilite = this.defender.getAgilite()
-    const chute = await RdDResolutionTable.rollData({ caracValue: agilite, finalLevel: impact })
-    return chute.rolled.isEchec
-  }
-
   _isForceOuCharge(attaque, isRollV2 = false /* TODO: delete roll V1 */) {
     return attaque.particuliere == 'force' || 'charge' == (isRollV2 ? attaque.tactique?.key : attaque.tactique)
   }
 
-  /* -------------------------------------------- */
-  _computeImpactRecul(attackerRoll) {
-    const taille = this.defender.getTaille()
-    const force = this.attacker.getForce()
-    const dommages = attackerRoll.dmg /* TODO: delete roll V1 */
-      ? attackerRoll.dmg.dmgArme
-      : attackerRoll.arme.system.dommagesReels ?? attaque.arme.system.dommages;
-    return taille - (force + dommages);
-  }
 
   /* -------------------------------------------- */
   async encaisser(attackerRoll, defenderRoll) {
@@ -1316,12 +1282,16 @@ export class RdDCombat {
       this._onEchecTotal(defenderRoll);
     }
 
+    await this.doRollEncaissement(attackerRoll, defenderRoll);
+    this.removeChatMessageActionsPasseArme(attackerRoll.passeArme);
+  }
+
+  async doRollEncaissement(attackerRoll, defenderRoll) {
     if (Misc.isOwnerPlayer(this.defender)) {
       attackerRoll.attackerId = this.attackerId;
       attackerRoll.defenderTokenId = this.defenderToken.id;
-
       await this.computeRecul(defenderRoll);
-      await this.defender.encaisserDommages(attackerRoll, this.attacker, defenderRoll?.show, this.attackerToken, this.defenderToken);
+      await this.defender.encaisserDommages(attackerRoll.dmg, this.attacker, defenderRoll?.show, this.attackerToken, this.defenderToken);
     }
     else { // envoi à un GM: les joueurs n'ont pas le droit de modifier les personnages qu'ils ne possèdent pas
       game.socket.emit(SYSTEM_SOCKET_ID, {
@@ -1332,9 +1302,8 @@ export class RdDCombat {
           attackerToken: this.attackerToken,
           defenderToken: this.defenderToken
         }
-      });
+      })
     }
-    this.removeChatMessageActionsPasseArme(attackerRoll.passeArme);
   }
 
   /* -------------------------------------------- */