Automatisations de combats, WIP

modules/mournblade-utility.js

@@ -119,12 +119,12 @@ export class MournbladeUtility {
     return this.optionsStatusList;
   }
 
-    /* -------------------------------------------- */
+  /* -------------------------------------------- */
   static getPredilection(comp, predIdx) {
     let pred = duplicate(comp.system.predilections)
-    return duplicate(pred[predIdx] || {name: "Error!"} )
+    return duplicate(pred[predIdx] || { name: "Error!" })
   }
-  
+
   /* -------------------------------------------- */
   static async chatListeners(html) {
 
@@ -139,6 +139,13 @@ export class MournbladeUtility {
       rollData.predilectionUsed = MournbladeUtility.getPredilection(rollData.competence, predIdx)
       await MournbladeUtility.rollMournblade(rollData)
     })
+
+    html.on("click", '.arme-roll-degats', async event => {
+      let messageId = MournbladeUtility.findChatMessageId(event.currentTarget)
+      let message = game.messages.get(messageId)
+      let rollData = message.getFlag("world", "mournblade-roll")
+      MournbladeUtility.rollDegatsFromAttaque(rollData)
+    })
   }
 
   /* -------------------------------------------- */
@@ -337,10 +344,30 @@ export class MournbladeUtility {
       rollData.diceFormula += `+${rollData.attr.value}*2+${rollData.modificateur}`
     }
 
-    if (rollData.arme && rollData.arme.type == "arme") {
+    if (rollData.arme?.type == "arme") {
       rollData.diceFormula += `+${rollData.arme.system.bonusmaniementoff}`
     }
 
+    // Specific modifier for distance
+    if (rollData.arme?.system?.isDistance) {
+      if (rollData.visee) {
+        rollData.diceFormula += "+5"
+      }
+      if (rollData.cibleconsciente) {
+        rollData.diceFormula += `-${rollData.defender.system.attributs.adr.value}`
+      }
+      if (rollData.ciblecourt) {
+        if (rollData.difficulte <= 15) { // Portée courte ou moins
+          rollData.diceFormula += `-5`
+        } else {
+          rollData.diceFormula += `-10`
+        }
+      }
+      if (rollData.typeCouvert != "aucun") {
+        rollData.diceFormula += `-${rollData.config.couverts[rollData.typeCouvert].value}`
+      }
+    }
+
     if (rollData.rune) {
       rollData.runeduree = Math.ceil((rollData.runeame + 3) / 3)
       if (rollData.runemode == "inscrire") {
@@ -374,6 +401,66 @@ export class MournbladeUtility {
 
   }
 
+  /* -------------------------------------------- */
+  static async rollDegatsFromAttaque(rollData) {
+    let maximize = false
+    let degatsMessage = "Degats normaux"
+
+    if (rollData.arme?.system?.isMelee) {
+      if (rollData.typeAttaque == "assaut") {
+        rollData.degatsFormula = rollData.arme.system.totalDegats
+        if (rollData.isHeroique) { // Deux fois les dés de dégats
+          rollData.degatsFormula += " + " + rollData.arme.system.totalDegats        
+          degatsMessage = "Dégats doublés"
+        }
+      }
+      if (rollData.typeAttaque == "precise") {
+        let degatsMessage = "Degats normaux"
+        if (rollData.isHeroique) { // Degats max
+          maximize = true
+          degatsMessage = "Dégats maximaux, ignore l'armure du défenseur"
+          rollData.ignoreDefenseArmor = true
+        }
+      }
+      if (rollData.typeAttaque == "feinte") {
+        degatsMessage = "Pas de dégats, mais bonus pour prochaine attaque"
+        rollData.degatsFormula = false
+        rollData.nextBonus = 5
+        if (rollData.isHeroique) { // Bonus pour prochaine action
+          rollData.nextBonus = 10
+          rollData.nextBonusDegats = 10
+        }
+      }
+      if (rollData.typeAttaque == "coupbas") {
+        degatsMessage = "Pas de dégats, mais malus pour prochaine action complexe du défenseur"
+        rollData.degatsFormula = false
+        rollData.nextMalus = -5
+        if (rollData.isHeroique) { // Malus pour prochaine action
+          rollData.nextMalus = -15
+        }
+      }
+    } else { // Armes à distance
+      rollData.degatsFormula = rollData.arme.system.totalDegats
+      if (rollData.isHeroique) { // Deux fois les dés de dégats
+        rollData.degatsFormula += " + " + rollData.arme.system.totalDegats        
+      }
+    }
+    // Perform the roll, show the dice
+    rollData.finalResult = 0
+    rollData.degatsMessage = degatsMessage
+    if (rollData.degatsFormula) {
+      let degatsRoll = new Roll(rollData.degatsFormula).roll({ async: false, maximize: maximize })
+      await this.showDiceSoNice(degatsRoll, game.settings.get("core", "rollMode"))
+      rollData.degatsRoll = duplicate(degatsRoll)
+      rollData.finalResult = degatsRoll.total
+    }
+
+    this.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade/templates/chat-degats-result.html`, rollData)
+    }, rollData)
+
+  }
+
   /* -------------------------------------------- */
   static async bonusRollMournblade(rollData) {
     rollData.bonusFormula = rollData.addedBonus
@@ -482,6 +569,7 @@ export class MournbladeUtility {
       pointAmeOptions: this.getPointAmeOptions(),
       difficulte: 0,
       modificateur: 0,
+      config: game.system.mournblade.config,
     }
     MournbladeUtility.updateWithTarget(rollData)
     return rollData
@@ -493,6 +581,7 @@ export class MournbladeUtility {
     if (target) {
       rollData.defenderTokenId = target.id
       let defender = game.canvas.tokens.get(rollData.defenderTokenId).actor
+      rollData.defender = defender.toObject() // Simpler
       rollData.armeDefense = defender.getBestDefenseValue()
       if (rollData.armeDefense) {
         rollData.difficulte = rollData.armeDefense.system.totalDefensif
@@ -655,11 +744,11 @@ export class MournbladeUtility {
   /* -------------------------------------------- */
   static async confirmDelete(actorSheet, li) {
     let itemId = li.data("item-id");
-    let msgTxt = "<p>Are you sure to remove this Item ?";
+    let msgTxt = "<p>Voulez vous supprimer cet item ?";
     let buttons = {
       delete: {
         icon: '<i class="fas fa-check"></i>',
-        label: "Yes, remove it",
+        label: "Oui !",
         callback: () => {
           actorSheet.actor.deleteEmbeddedDocuments("Item", [itemId]);
           li.slideUp(200, () => actorSheet.render(false));
@@ -667,12 +756,12 @@ export class MournbladeUtility {
       },
       cancel: {
         icon: '<i class="fas fa-times"></i>',
-        label: "Cancel"
+        label: "Non !"
       }
     }
     msgTxt += "</p>";
     let d = new Dialog({
-      title: "Confirm removal",
+      title: "Confirmer la suppression",
       content: msgTxt,
       buttons: buttons,
       default: "cancel"