Compatibilité v11/v12

modules/mournblade-utility.js

@@ -59,15 +59,6 @@ export class MournbladeUtility {
     return actor
   }
 
-  /* -------------------------------------------- */
-  static getModificateurOptions() {
-    let opt = []
-    for (let i = -15; i <= 15; i++) {
-      opt.push(`<option value="${i}">${i}</option>`)
-    }
-    return opt.concat("\n")
-  }
-
   /* -------------------------------------------- */
   static sortArrayObjectsByName(myArray) {
     myArray.sort((a, b) => {
@@ -75,18 +66,9 @@ export class MournbladeUtility {
     })
   }
 
-  /* -------------------------------------------- */
-  static getPointAmeOptions() {
-    let opt = []
-    for (let i = 1; i <= 20; i++) {
-      opt.push(`<option value="${i}">${i}</option>`)
-    }
-    return opt.concat("\n")
-  }
-
   /* -------------------------------------------- */
   static getAttributs() {
-    return { adr: "Adresse", pui: "Puissance", cla: "Clairvoyance", pre: "Présence", tre: "Trempe" }
+    return game.system.mournblade.config.attributs
   }
   /* -------------------------------------------- */
   static pushInitiativeOptions(html, options) {
@@ -101,6 +83,11 @@ export class MournbladeUtility {
   static async ready() {
     const skills = await MournbladeUtility.loadCompendium("fvtt-mournblade.skills")
     this.skills = skills.map(i => i.toObject())
+
+    game.system.mournblade.config.listeNiveauSkill = MournbladeUtility.createDirectOptionList(0, 10)
+    game.system.mournblade.config.listeNiveauCreature = MournbladeUtility.createDirectOptionList(0, 35)
+    game.system.mournblade.config.modificateurOptions = MournbladeUtility.createArrayOptionList(-15, 15)
+    game.system.mournblade.config.pointsAmeOptions = MournbladeUtility.createDirectOptionList(0, 20)
   }
 
   /* -------------------------------------------- */
@@ -122,8 +109,8 @@ export class MournbladeUtility {
 
   /* -------------------------------------------- */
   static getPredilection(comp, predIdx) {
-    let pred = duplicate(comp.system.predilections)
-    return duplicate(pred[predIdx] || { name: "Error!" })
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    return foundry.utils.duplicate(pred[predIdx] || { name: "Error!" })
   }
 
   /* -------------------------------------------- */
@@ -150,7 +137,7 @@ export class MournbladeUtility {
       let rollData = message.getFlag("world", "mournblade-roll")
       let actor = MournbladeUtility.getActorFromRollData(rollData)
       await actor.setPredilectionUsed(rollData.competence._id, predIdx)
-      rollData.competence = duplicate(actor.getCompetence(rollData.competence._id))
+      rollData.competence = foundry.utils.duplicate(actor.getCompetence(rollData.competence._id))
       rollData.predilectionUsed = MournbladeUtility.getPredilection(rollData.competence, predIdx)
       await MournbladeUtility.rollMournblade(rollData)
     })
@@ -180,9 +167,7 @@ export class MournbladeUtility {
 
     const templatePaths = [
       'systems/fvtt-mournblade/templates/editor-notes-gm.html',
-      'systems/fvtt-mournblade/templates/partial-item-description.html',
-      'systems/fvtt-mournblade/templates/partial-list-niveau.html',
-      'systems/fvtt-mournblade/templates/partial-list-niveau-creature.html'
+      'systems/fvtt-mournblade/templates/partial-item-description.html'
     ]
     return loadTemplates(templatePaths);
   }
@@ -224,12 +209,10 @@ export class MournbladeUtility {
     }
     return options;
   }
-
-  /* -------------------------------------------- */
-  static buildListOptions(min, max) {
-    let options = ""
+  static createArrayOptionList(min, max) {
+    let options = [];
     for (let i = min; i <= max; i++) {
-      options += `<option value="${i}">${i}</option>`
+      options.push({key:`${i}`, label:`${i}`});
     }
     return options;
   }
@@ -337,7 +320,7 @@ export class MournbladeUtility {
     }
     if (!rollData.attr) {
       rollData.actionImg = "systems/fvtt-mournblade/assets/icons/" + actor.system.attributs[rollData.attrKey].labelnorm + ".webp"
-      rollData.attr = duplicate(actor.system.attributs[rollData.attrKey])
+      rollData.attr = foundry.utils.duplicate(actor.system.attributs[rollData.attrKey])
     }
 
     rollData.diceFormula = rollData.mainDice
@@ -349,7 +332,7 @@ export class MournbladeUtility {
     }
     //console.log("BEFORE COMP", rollData)
     if (rollData.competence) {
-      rollData.predilections = duplicate(rollData.competence.system.predilections)
+      rollData.predilections = foundry.utils.duplicate(rollData.competence.system.predilections)
       let compmod = (rollData.competence.system.niveau == 0) ? -3 : 0
       rollData.diceFormula += `+${rollData.attr.value}+${rollData.competence.system.niveau}+${rollData.modificateur}+${compmod}`
     } else {
@@ -376,7 +359,7 @@ export class MournbladeUtility {
     }
     desavantagesBonus = Math.min(15, desavantagesBonus)
     rollData.diceFormula += `+${desavantagesBonus}`
-    
+
     // Monté ?
     if (rollData.isMonte) {
       rollData.diceFormula += "+5"
@@ -411,10 +394,10 @@ export class MournbladeUtility {
         rollData.runeduree = 1
       }
     }
-
-    let myRoll = new Roll(rollData.diceFormula).roll({ async: false })
+    
+    let myRoll = await new Roll(rollData.diceFormula).evaluate();
     await this.showDiceSoNice(myRoll, game.settings.get("core", "rollMode"))
-    rollData.roll = duplicate(myRoll)
+    rollData.roll = foundry.utils.duplicate(myRoll)
     rollData.diceResult = myRoll.terms[0].results[0].result
     console.log(">>>> ", myRoll)
 
@@ -439,7 +422,7 @@ export class MournbladeUtility {
     if (rollData.typeAttaque == "immobiliser" && rollData.difficulte > 0 && rollData.isPureSuccess) {
       actor.setModifier("Immobilisation en cours : -5 pour prochaine action", "roll", -5)
     }
-    if ( rollData.typeAttaque == "chargecavalerie" ) {
+    if (rollData.typeAttaque == "chargecavalerie") {
       actor.setModifier("Charge de Cavalerie : -5 défense pour le tour", "defense", -5)
     }
     this.createChatWithRollMode(rollData.alias, {
@@ -466,10 +449,10 @@ export class MournbladeUtility {
       if (rollData.typeAttaque == "charger") {
         rollData.degatsFormula += "+2"
       }
-      if ( rollData.typeAttaque == "chargecavalerie" ) {
+      if (rollData.typeAttaque == "chargecavalerie") {
         rollData.degatsFormula += "+5"
       }
-      
+
       if (rollData.typeAttaque == "precise") {
         degatsMessage = "Degats normaux"
         if (rollData.isHeroique) { // Degats max
@@ -499,8 +482,8 @@ export class MournbladeUtility {
         degatsMessage = "Pas de dégats, mais l'adversaire ne peut pas vous attaquer pour le reste du tour"
         rollData.degatsFormula = false
         if (rollData.isHeroique) { // Malus pour prochaine action
-          degatsMessage = "Pas de dégats, mais tout les adversaires avec une défense inférieure ou égale à " + rollData.finalResult-10 + 
-              " ne peuvent pas vous attaquer pour le reste du tour"
+          degatsMessage = "Pas de dégats, mais tout les adversaires avec une défense inférieure ou égale à " + rollData.finalResult - 10 +
+            " ne peuvent pas vous attaquer pour le reste du tour"
         }
       }
       if (rollData.typeAttaque == "desarmer") {
@@ -525,14 +508,14 @@ export class MournbladeUtility {
         rollData.degatsFormula += "+" + rollData.degatsFormula
       }
       // Latest modifiers
-      for(let mod of rollData.modifiers) {
-        if (mod.system.modifiertype == "degats") { 
+      for (let mod of rollData.modifiers) {
+        if (mod.system.modifiertype == "degats") {
           rollData.degatsFormula += `+${mod.system.value}`
         }
-      } 
-      let degatsRoll = new Roll(rollData.degatsFormula).roll({ async: false, maximize: maximize })
+      }
+      let degatsRoll = await new Roll(rollData.degatsFormula).evaluate({ maximize: maximize })
       await this.showDiceSoNice(degatsRoll, game.settings.get("core", "rollMode"))
-      rollData.degatsRoll = duplicate(degatsRoll)
+      rollData.degatsRoll = foundry.utils.duplicate(degatsRoll)
       rollData.finalResult = degatsRoll.total
     }
 
@@ -563,7 +546,7 @@ export class MournbladeUtility {
         defender.setModifier("Prochaine action complexe", "roll", -rollData.nextMalus)
       }
       if (rollData.defenderDesarme) {
-        ui.notifications.info("L'arme de " + defender.name + " est arrachée de ses mains (à gérer manuellement)" )
+        ui.notifications.info("L'arme de " + defender.name + " est arrachée de ses mains (à gérer manuellement)")
       }
       let degats = rollData.finalResult
 
@@ -580,9 +563,9 @@ export class MournbladeUtility {
   static async bonusRollMournblade(rollData) {
     rollData.bonusFormula = rollData.addedBonus
 
-    let bonusRoll = new Roll(rollData.bonusFormula).roll({ async: false })
+    let bonusRoll = await new Roll(rollData.bonusFormula).evaluate()
     await this.showDiceSoNice(bonusRoll, game.settings.get("core", "rollMode"));
-    rollData.bonusRoll = duplicate(bonusRoll)
+    rollData.bonusRoll = foundry.utils.duplicate(bonusRoll)
 
     rollData.finalResult += rollData.bonusRoll.total
 
@@ -616,7 +599,7 @@ export class MournbladeUtility {
 
   /* -------------------------------------------- */
   static blindMessageToGM(chatOptions) {
-    let chatGM = duplicate(chatOptions);
+    let chatGM = foundry.utils.duplicate(chatOptions);
     chatGM.whisper = this.getUsers(user => user.isGM);
     chatGM.content = "Blinde message of " + game.user.name + "<br>" + chatOptions.content;
     console.log("blindMessageToGM", chatGM);
@@ -679,13 +662,11 @@ export class MournbladeUtility {
   /* -------------------------------------------- */
   static getBasicRollData() {
     let rollData = {
-      rollId: randomID(16),
+      rollId: foundry.utils.randomID(16),
       rollMode: game.settings.get("core", "rollMode"),
-      modificateursOptions: this.getModificateurOptions(),
-      pointAmeOptions: this.getPointAmeOptions(),
       difficulte: 0,
       modificateur: 0,
-      config: duplicate(game.system.mournblade.config),
+      config: foundry.utils.duplicate(game.system.mournblade.config),
     }
     MournbladeUtility.updateWithTarget(rollData)
     return rollData