Add rolls and new fixes

module/documents/roll.mjs

@@ -62,11 +62,7 @@ export default class HellbornRoll extends Roll {
 
   static updateFullFormula(options) {
     let fullFormula
-    if ( options.numericModifier >= 0) {
-      fullFormula = `${options.formula} + ${options.rollItem.value} + ${options.numericModifier}D`
-    } else {
-      fullFormula = `${options.formula} + ${options.rollItem.value} - ${Math.abs(options.numericModifier)}D`
-    }
+    fullFormula = `3D6 + ${options.nbAdvantages}D6kh - ${options.nbDisadvantages}D6kh + ${options.rollItem.value}`
     $('#roll-dialog-full-formula').text(fullFormula)
     options.fullFormula = fullFormula
   }
@@ -86,81 +82,68 @@ export default class HellbornRoll extends Roll {
    * @returns {Promise<Object|null>} The roll result or null if the dialog was cancelled.
    */
   static async prompt(options = {}) {
-    let formula = "2d6"
+    let formula = `3D6 + 0D6KH - 0D6KH + ${options?.rollItem?.value}`
 
     switch (options.rollType) {
-      case "skill":
+      case "stat":
         break
       case "damage":
-        let formula = options.rollItem.system.damage
-        let damageRoll = new Roll(formula)
-        await damageRoll.evaluate()
-        await damageRoll.toMessage({
-          flavor: `${options.rollItem.name} - Damage Roll`
-        });
-        return
+        {
+          let formula = options.rollItem.system.damage
+          let damageRoll = new Roll(formula)
+          await damageRoll.evaluate()
+          await damageRoll.toMessage({
+            flavor: `${options.rollItem.name} - Damage Roll`
+          });
+          return
+        }
       case "weapon":
-        let actor = game.actors.get(options.actorId)
-        options.weapon = foundry.utils.duplicate(options.rollItem)
-        options.rollItem = actor.system.skills.combat
+        {
+          let actor = game.actors.get(options.actorId)
+          options.weapon = foundry.utils.duplicate(options.rollItem)
+          let statKey = "skin"
+          if (options.weapon.system.weaponType === "melee") {
+            if ( options.weapon.system.properties.toLowerCase().match("heavy")  || options.weapon.system.properties.toLowerCase().match("oversized")) {
+              statKey = "flesh"
+            }
+          }
+          options.rollItem = actor.system.stats[statKey]
+        }
         break
       default:
         break
     }
 
-    const rollModes = Object.fromEntries(Object.entries(CONFIG.Dice.rollModes).map(([key, value]) => [key, game.i18n.localize(value)]))
+    const rollModes = foundry.utils.duplicate(CONFIG.Dice.rollModes)
     const fieldRollMode = new foundry.data.fields.StringField({
       choices: rollModes,
       blank: false,
       default: "public",
     })
 
-    const choiceModifier = SYSTEM.MODIFIER_CHOICES
-    let choiceRangeModifier = {}
-    let rangeModifier = 0
-    if ( options.weapon) {
-      // Build the range modifiers
-      let range = SYSTEM.WEAPON_RANGE[options.weapon.system.rangeType]
-      for (let [key, value] of Object.entries(range.range)) {
-        choiceRangeModifier[key] = { label: `${key} (${value}D)`, value: value }
-        if (!rangeModifier && value) {
-          rangeModifier = value
-        }
-      }
-    }
-
-    let modifier = "0"
-    options.numericModifier = rangeModifier
-    let fullFormula = `${formula} + ${options.rollItem.value}`
-    if (options.isEncumbered) {
-      options.numericModifier += -1
-      fullFormula += ` - ${options.numericModifier}D`
-    } else {
-      options.numericModifier += 0
-      fullFormula += ` + ${options.numericModifier}D`
-    }
-    options.fullFormula = fullFormula
     options.formula = formula
+    options.nbAdvantages = "0"
+    options.nbDisadvantages = "0"
 
     let dialogContext = {
       actorId: options.actorId,
       actorName: options.actorName,
       rollType: options.rollType,
       rollItem: foundry.utils.duplicate(options.rollItem), // Object only, no class
-      fullFormula,
       weapon: options?.weapon,
-      isEncumbered: options.isEncumbered,
-      talents: options.talents,
+      formula: formula,
+      fullFormula: formula,
       rollModes,
       fieldRollMode,
-      choiceModifier,
-      choiceRangeModifier,
-      rangeModifier,
-      formula,
+      difficultyChoices: SYSTEM.DIFFICULTY_CHOICES,
+      choiceAdvantages: SYSTEM.CHOICE_ADVANTAGES_DISADVANTAGES,
+      choiceDisadvantages: SYSTEM.CHOICE_ADVANTAGES_DISADVANTAGES,
       hasTarget: options.hasTarget,
-      modifier,
+      difficulty: "unknown",
+      nbAdvantages: "0",
+      nbDisadvantages: "0",
     }
-    const content = await renderTemplate("systems/fvtt-hellborn/templates/roll-dialog.hbs", dialogContext)
+    const content = await foundry.applications.handlebars.renderTemplate("systems/fvtt-hellborn/templates/roll-dialog.hbs", dialogContext)
 
     const title = HellbornRoll.createTitle(options.rollType, options.rollTarget)
     const label = game.i18n.localize("HELLBORN.Roll.roll")
@@ -184,19 +167,19 @@ export default class HellbornRoll extends Roll {
       },
       rejectClose: false, // Click on Close button will not launch an error
       render: (event, dialog) => {
-        $(".roll-skill-modifier").change(event => {
-          options.numericModifier += Number(event.target.value)
+        $(".roll-stat-advantages").change(event => {
+          options.nbAdvantages = Number(event.target.value)
           HellbornRoll.updateFullFormula(options)
         })
-        $(".roll-skill-range-modifier").change(event => {
-          options.numericModifier += Number(event.target.value)
+        $(".roll-stat-disadvantages").change(event => {
+          options.nbDisadvantages = Number(event.target.value)
           HellbornRoll.updateFullFormula(options)
         })
         $(".select-combat-option").change(event => {
           console.log(event)
           let field = $(event.target).data("field")
           let modifier = SYSTEM.ATTACK_MODIFIERS[field]
-          if ( event.target.checked) {
+          if (event.target.checked) {
             options.numericModifier += modifier
           } else {
             options.numericModifier -= modifier
@@ -211,42 +194,55 @@ export default class HellbornRoll extends Roll {
 
     let rollData = foundry.utils.mergeObject(foundry.utils.duplicate(options), rollContext)
     rollData.rollMode = rollContext.visibility
-    // Update target score
     rollData.targetScore = 8
 
     if (Hooks.call("fvtt-hellborn.preRoll", options, rollData) === false) return
 
-    let diceFormula = `${2+Math.abs(options.numericModifier)}D6`
-    if ( options.numericModifier > 0 ) {
-      diceFormula += `kh2 + ${options.rollItem.value}`
-    } else {
-      diceFormula += `kl2 + ${options.rollItem.value}`
-    }
-
+    options.nbAdvantages = Number(options.nbAdvantages)
+    options.nbDisadvantages = Number(options.nbDisadvantages)
+    let diceFormula = `3D6 + ${options.nbAdvantages}D6kh - ${options.nbDisadvantages}D6kh +  ${options.rollItem.value}`
     const roll = new this(diceFormula, options.data, rollData)
     await roll.evaluate()
+    console.log("Roll", rollData, roll)
+    options.difficulty = (rollData.difficulty === "unknown") ? 0 : (Number(rollData.difficulty) || 0)
 
-    roll.displayRollResult(roll, options, rollData)
+    roll.displayRollResult(roll, options, rollData, roll)
 
     if (Hooks.call("fvtt-hellborn.Roll", options, rollData, roll) === false) return
 
     return roll
   }
 
-  displayRollResult(formula, options, rollData) {
-
-    // Compute the result quality
+  displayRollResult(formula, options, rollData, roll) {
     let resultType = "failure"
-    if (this.total >= 8) {
+    if (options.difficulty === 0) {
+      resultType = "unknown"
+    } else if (this.total >= options.difficulty) {
       resultType = "success"
-      // Detect if decimal == unit in the dire total result
     }
-
+    // Compute the result quality
+    this.options.satanicSuccess = false
+    this.options.fiendishFailure = false
+    this.options.rollData = foundry.utils.duplicate(rollData)
+    if (resultType === "success") {
+      let nb6 = roll.terms[0].results.filter(r => r.result === 6).length
+      nb6 += roll.terms[3].total === 6 ? 1 : 0
+      this.options.satanicSuccess = nb6 >= 3
+      if (this.options.satanicSuccess) {
+        resultType = "success"
+      }
+    }
+    if (resultType === "failure") {
+      let nb1 = roll.terms[0].results.filter(r => r.result === 1).length
+      nb1 += roll.terms[5].total === 1 ? 1 : 0
+      this.options.fiendishFailure = nb1 >= 3
+      if (this.options.fiendishFailure) {
+        resultType = "failure"
+      }
+    }
     this.options.resultType = resultType
     this.options.isSuccess = resultType === "success"
     this.options.isFailure = resultType === "failure"
-    this.options.isEncumbered = rollData.isEncumbered
-    this.options.rollData = foundry.utils.duplicate(rollData)
   }
 
   /**
@@ -258,8 +254,8 @@ export default class HellbornRoll extends Roll {
    */
   static createTitle(type, target) {
     switch (type) {
-      case "skill":
-        return `${game.i18n.localize("HELLBORN.Label.titleSkill")}`
+      case "stat":
+        return `${game.i18n.localize("HELLBORN.Label.titleStat")}`
       case "weapon":
         return `${game.i18n.localize("HELLBORN.Label.titleWeapon")}`
       default:
@@ -270,7 +266,7 @@ export default class HellbornRoll extends Roll {
   /** @override */
   async render(chatOptions = {}) {
     let chatData = await this._getChatCardData(chatOptions.isPrivate)
-    return await renderTemplate(this.constructor.CHAT_TEMPLATE, chatData)
+    return await foundry.applications.handlebars.renderTemplate(this.constructor.CHAT_TEMPLATE, chatData)
   }
 
   /**
@@ -317,7 +313,6 @@ export default class HellbornRoll extends Roll {
     cardData.realDamage = this.realDamage
     cardData.isPrivate = isPrivate
     cardData.weapon = this.weapon
-    cardData.isEncumbered = this.isEncumbered
 
     cardData.cssClass = cardData.css.join(" ")
     cardData.tooltip = isPrivate ? "" : await this.getTooltip()