Fix roll pouvoir + pouvoirs passifs

modules/heritiers-actor.js

@@ -259,6 +259,11 @@ export class HeritiersActor extends Actor {
   /* -------------------------------------------- */
   async prepareData() {
     super.prepareData();
+
+    let pvMax = (this.system.caracteristiques.con.rang * 3) + 9 + this.system.pv.mod
+    if (this.system.pv.max != pvMax) {
+      this.update({ 'system.pv.max': pvMax })
+    }
   }
 
   /* -------------------------------------------- */
@@ -533,6 +538,7 @@ export class HeritiersActor extends Actor {
     }
     return undefined
   }
+
   /* -------------------------------------------- */
   getCommonRollData(compId = undefined, compName = undefined) {
     let rollData = HeritiersUtility.getBasicRollData()
@@ -703,10 +709,73 @@ export class HeritiersActor extends Actor {
     }
   }
 
+  /* -------------------------------------------- */
+  pouvoirPassifDialog(pouvoir) {
+    let rollData = this.getCommonRollData()
+    rollData.pouvoir = pouvoir
+    rollData.mode = "pouvoirpassif"
+    rollData.pouvoirPointsUsage = 0
+    rollData.noRoll = true
+
+    let d = new Dialog({
+      title: "Activer le pouvoir passif " + pouvoir.name,
+      content: "<p>Choisissez le nombre de Points d'Usage</p>",
+      buttons: {
+        one: {
+          icon: '<i class="fas fa-check"></i>',
+          label: "1 Point d'Usage",
+          callback: () => {
+            rollData.pouvoirPointsUsage = 1;
+            HeritiersUtility.rollHeritiers(rollData);
+            }
+        },
+        two: {
+          icon: '<i class="fas fa-check"></i>',
+          label: "2 Points d'Usage",
+          callback: () => {
+            rollData.pouvoirPointsUsage = 2;
+            HeritiersUtility.rollHeritiers(rollData);
+            }
+        },
+        three: {
+          icon: '<i class="fas fa-check"></i>',
+          label: "3 Points d'Usage",
+          callback: () => {
+            rollData.pouvoirPointsUsage = 3;
+            HeritiersUtility.rollHeritiers(rollData);
+            }
+        },
+        four: {
+          icon: '<i class="fas fa-check"></i>',
+          label: "4 Points d'Usage",
+          callback: () => {
+            rollData.pouvoirPointsUsage = 4;
+            HeritiersUtility.rollHeritiers(rollData);
+            }
+        },
+        close: {
+          icon: '<i class="fas fa-times"></i>',
+          label: "Annuler",
+          callback: () => {
+            }
+        }
+      },
+      default: "one",
+      render: html => console.log("Pouvoir passif"),
+      close: html => console.log("No option")
+    });
+    d.render(true);
+  }
+  
   /* -------------------------------------------- */
   async rollPouvoir(pouvoirId) {
     let pouvoir = this.items.get(pouvoirId)
     if (pouvoir) {
+      if (pouvoir.system.pouvoirtype == "passif") {
+        this.pouvoirPassifDialog(pouvoir)
+        return
+      }
+
       let rollData = this.getCommonRollData(undefined, undefined)
       if (pouvoir.system.feeriemasque != "autre") {
         rollData.pouvoirBase = duplicate(this.system.rang[pouvoir.system.feeriemasque.toLowerCase()])
@@ -755,7 +824,7 @@ export class HeritiersActor extends Actor {
         updates.push({ _id: pouvoir.id, 'system.pointsusagecourant': newValue })
       }
     }
-    if (updates.length  > 0) {
+    if (updates.length > 0) {
       this.updateEmbeddedDocuments('Item', updates)
     }
   }

modules/heritiers-roll-dialog.js

@@ -22,10 +22,10 @@ export class HeritiersRollDialog extends Dialog {
     }
     let enableD10 = false
     let enableD12 = false
-    if (rollData.competence?.system.niveau > 0) {
+    if (rollData.mode == "pouvoir" || rollData.competence?.system.niveau > 0) {
       enableD10 = true
     }
-    if (rollData.competence?.system.niveau > 1) {
+    if (rollData.mode == "pouvoir" || rollData.competence?.system.niveau > 1) {
       enableD12 = true
     }
     if (enableD10) {

modules/heritiers-utility.js

@@ -535,20 +535,21 @@ export class HeritiersUtility {
       }
     }
 
-
-    let myRoll = new Roll(rollData.diceFormula).roll({ async: false })
-    await this.showDiceSoNice(myRoll, game.settings.get("core", "rollMode"))
-    rollData.roll = duplicate(myRoll)
-    console.log(">>>> ", myRoll)
-    this.computeResult(actor, rollData)
-    this.computeMarge(rollData, rollData.sdValue) // Calcul de la marge si seuil présent
+    if ( !rollData.noRoll) { 
+      let myRoll = new Roll(rollData.diceFormula).roll({ async: false })
+      await this.showDiceSoNice(myRoll, game.settings.get("core", "rollMode"))
+      rollData.roll = duplicate(myRoll)
+      console.log(">>>> ", myRoll)
+      this.computeResult(actor, rollData)
+      this.computeMarge(rollData, rollData.sdValue) // Calcul de la marge si seuil présent
+    }
 
     if (rollData.mode == "init") {
       actor.setFlag("world", "last-initiative", rollData.finalResult)
     }
 
     // Gestion pouvoir et points d'usage
-    if (rollData.mode == "pouvoir") {
+    if (rollData.mode == "pouvoir" || rollData.mode == "pouvoirpassif") {
       actor.incDecPointsUsage(rollData.pouvoir._id, -rollData.pouvoirPointsUsage)
     }