Implements actions management

module/documents/actor.mjs

@@ -41,4 +41,144 @@ export default class LethalFantasyActor extends Actor {
     }
   }
 
+  getBestWeaponClassSkill(skills, rollType, multiplier = 1.0) {
+    let maxValue = 0
+    let goodSkill = skills[0]
+    for (let s of skills) {
+      if (rollType === "weapon-attack") {
+        if (s.system.weaponBonus.attack > maxValue) {
+          maxValue = Number(s.system.weaponBonus.attack)
+          goodSkill = s
+        }
+      }
+      if (rollType === "weapon-defense") {
+        if (s.system.weaponBonus.defense > maxValue) {
+          maxValue = Number(s.system.weaponBonus.defense)
+          goodSkill = s
+        }
+      }
+      if (rollType.includes("weapon-damage")) {
+        if (s.system.weaponBonus.damage > maxValue) {
+          maxValue = Number(s.system.weaponBonus.damage)
+          goodSkill = s
+        }
+      }
+    }
+    goodSkill.weaponSkillModifier = maxValue * multiplier
+    return goodSkill
+  }
+
+  async prepareRoll(rollType, rollKey, rollDice ) {
+    let rollTarget
+    switch (rollType) {
+      case "granted":
+        rollTarget = {
+          name: rollKey,
+          formula: foundry.utils.duplicate(this.system.granted[rollKey]),
+          rollKey: rollKey
+        }
+        if ( rollTarget.formula === "" || rollTarget.formula === undefined) {
+          rollTarget.formula = 0
+        }
+        break;
+      case "challenge":
+        rollTarget = foundry.utils.duplicate(this.system.challenges[rollKey])
+        rollTarget.rollKey = rollKey
+        break
+      case "save":
+        rollTarget = foundry.utils.duplicate(this.system.saves[rollKey])
+        rollTarget.rollKey = rollKey
+        rollTarget.rollDice = rollDice
+        break
+      case "spell":
+        rollTarget = this.items.find((i) => i.type === "spell" && i.id === rollKey)
+        rollTarget.rollKey = rollKey
+        break
+      case "miracle":
+        rollTarget = this.items.find((i) => i.type === "miracle" && i.id === rollKey)
+        rollTarget.rollKey = rollKey
+        break
+      case "skill":
+        rollTarget = this.items.find((i) => i.type === "skill" && i.id === rollKey)
+        rollTarget.rollKey = rollKey
+        if (rollTarget.system.category === "weapon") {
+          ui.notifications.warn(game.i18n.localize("LETHALFANTASY.Notifications.rollFromWeapon"))
+          return
+        }
+        break
+      case "spell-attack":
+      case "spell-power":
+      case "miracle-attack":
+      case "miracle-power":
+        rollTarget = this.items.find((i) => (i.type === "miracle" || i.type == "spell") && i.id === rollKey)
+        rollTarget.rollKey = rollKey
+        break
+      case "shield-roll": {
+          rollTarget = this.items.find((i) => i.type === "shield" && i.id === rollKey)
+          let shieldSkill = this.items.find((i) => i.type === "skill" && i.name.toLowerCase() === rollTarget.name.toLowerCase())
+          rollTarget.skill = shieldSkill
+          rollTarget.rollKey = rollKey
+        }
+        break;
+      case "weapon-damage-small":
+      case "weapon-damage-medium":
+      case "weapon-attack":
+      case "weapon-defense": {
+          let weapon = this.items.find((i) => i.type === "weapon" && i.id === rollKey)
+          let skill
+          let skills = this.items.filter((i) => i.type === "skill" && i.name.toLowerCase() === weapon.name.toLowerCase())
+          if (skills.length > 0) {
+            skill = this.getBestWeaponClassSkill(skills, rollType, 1.0)
+          } else {
+            skills = this.items.filter((i) => i.type === "skill" && i.name.toLowerCase().replace(" skill", "") === weapon.name.toLowerCase())
+            if (skills.length > 0) {
+              skill = this.getBestWeaponClassSkill(skills, rollType, 1.0)
+            } else {
+              skills = this.items.filter((i) => i.type === "skill" && i.system.weaponClass === weapon.system.weaponClass)
+              if (skills.length > 0) {
+                skill = this.getBestWeaponClassSkill(skills, rollType, 0.5)
+              } else {
+                skills = this.items.filter((i) => i.type === "skill" && i.system.weaponClass.includes(SYSTEM.WEAPON_CATEGORIES[weapon.system.weaponClass]))
+                if (skills.length > 0) {
+                  skill = this.getBestWeaponClassSkill(skills, rollType, 0.25)
+                } else {
+                  ui.notifications.warn(game.i18n.localize("LETHALFANTASY.Notifications.skillNotFound"))
+                  return
+                }
+              }
+            }
+          }
+          if (!weapon || !skill) {
+            console.error("Weapon or skill not found", weapon, skill)
+            ui.notifications.warn(game.i18n.localize("LETHALFANTASY.Notifications.skillNotFound"))
+            return
+          }
+          rollTarget = skill
+          rollTarget.weapon = weapon
+          rollTarget.weaponSkillModifier = skill.weaponSkillModifier
+          rollTarget.rollKey = rollKey
+          rollTarget.combat = foundry.utils.duplicate(this.system.combat)
+          if ( rollType === "weapon-damage-small" || rollType === "weapon-damage-medium") {
+            rollTarget.grantedDice = this.system.granted.damageDice
+          }
+          if ( rollType === "weapon-attack") {
+            rollTarget.grantedDice = this.system.granted.attackDice
+          }
+          if ( rollType === "weapon-defense") {
+            rollTarget.grantedDice = this.system.granted.defenseDice
+          }
+        }
+        break
+      default:
+        ui.notifications.error(game.i18n.localize("LETHALFANTASY.Notifications.rollTypeNotFound") + String(rollType))
+        break
+    }
+
+    // In all cases
+    rollTarget.magicUser = this.system.biodata.magicUser
+    rollTarget.actorModifiers = foundry.utils.duplicate(this.system.modifiers)
+    rollTarget.actorLevel = this.system.biodata.level
+    await this.system.roll(rollType, rollTarget)
+  }
+
 }