UPdate and fixes for roll in combats

.gitea/workflows/release.yaml

@@ -60,4 +60,4 @@ jobs:
           manifest: "https://www.uberwald.me/gitea/${{gitea.repository}}/releases/download/${{github.event.release.tag_name}}/system.json"
           notes: "https://www.uberwald.me/gitea/public/fvtt-lethal-fantasy/raw/branch/main/changelog.md"
           compatibility-minimum: "13"
-          compatibility-verified: "13"
+          compatibility-verified: "14"

css/fvtt-lethal-fantasy.css

@@ -1178,6 +1178,45 @@ i.lethalfantasy {
   margin-left: 4px;
   margin-right: 4px;
 }
+.lethalfantasy .tab.monster-combat .ranged-attacks {
+  grid-template-columns: 1fr;
+}
+.lethalfantasy .tab.monster-combat .ranged-attacks .attack .name {
+  min-width: 10rem;
+  max-width: 10rem;
+}
+.lethalfantasy .tab.monster-combat .ranged-attacks .attack .damage-dice {
+  width: 5rem;
+  max-width: 5rem;
+}
+.lethalfantasy .tab.monster-combat .ranged-attacks .ranged-weapon-range {
+  margin-top: 8px;
+  border-top: 1px solid var(--color-border-light-tertiary, #ccc);
+  padding-top: 6px;
+}
+.lethalfantasy .tab.monster-combat .ranged-attacks .ranged-weapon-range > label {
+  font-weight: bold;
+  margin-bottom: 4px;
+  display: block;
+}
+.lethalfantasy .tab.monster-combat .ranged-attacks .ranged-weapon-range .range-fields {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+}
+.lethalfantasy .tab.monster-combat .ranged-attacks .ranged-weapon-range .range-fields .range-field {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+.lethalfantasy .tab.monster-combat .ranged-attacks .ranged-weapon-range .range-fields .range-field label {
+  font-size: 0.7rem;
+  white-space: nowrap;
+}
+.lethalfantasy .tab.monster-combat .ranged-attacks .ranged-weapon-range .range-fields .range-field input {
+  width: 3.5rem;
+  text-align: center;
+}
 .lethalfantasy .tab.monster-combat .armors {
   display: grid;
   grid-template-columns: repeat(3, 1fr);
@@ -2595,6 +2634,21 @@ i.lethalfantasy {
   max-width: 8rem;
   margin-left: 1rem;
 }
+.dialog-warning {
+  margin: 0.4rem 0.2rem 0.2rem;
+  padding: 0.35rem 0.5rem;
+  border-left: 3px solid #c8941a;
+  background: rgba(200, 148, 26, 0.12);
+  border-radius: 3px;
+  font-family: var(--font-secondary);
+  font-size: calc(var(--font-size-standard) * 0.9);
+  color: #7a5400;
+  line-height: 1.4;
+}
+.dialog-warning i {
+  color: #c8941a;
+  margin-right: 0.4rem;
+}
 .lethalfantasy.dice-roll,
 .fvtt-lethal-fantasy.dice-roll,
 .message.lethalfantasy.dice-roll,

lang/en.json

@@ -382,9 +382,12 @@
       "rollProgressionCount": "Roll progression count",
       "rollProgressionDice": "Roll progression/Lethargy dice",
       "earned": "Earned",
-      "divinityPoints": "Divinity points",
+      "divinityPoints": "Grace",
       "aetherPoints": "Aether points",
       "attacks": "Attacks",
+      "attackMode": "Attack Mode",
+      "meleeModeLabel": "Melee (8 attacks)",
+      "rangedModeLabel": "Ranged (4 attacks)",
       "monster": "Monster",
       "Resist": "Resist",
       "resist": "Resist",
@@ -459,6 +462,13 @@
       "notes": "Notes",
       "pc": "PC",
       "perception": "Perception",
+      "pointBlank": "Point blank",
+      "short": "Short",
+      "medium": "Medium",
+      "long": "Long",
+      "extreme": "Extreme",
+      "outOfSkill": "Out of skill",
+      "range": "Range",
       "rangeDefenseDialog": "Ranged defense dialog",
       "rangeDefenseRoll": "Ranged defense roll",
       "rangedAttackDefense": "Ranged attack defense",
@@ -497,7 +507,40 @@
       "weapon-damage-small": "Weapon damage small",
       "combatProgressionStart": "Combat start threshold",
       "miracle": "Miracle",
-      "titleStandard": "Standard Roll"
+      "titleStandard": "Standard Roll",
+      "privateRoll": "Private Roll",
+      "current": "Current",
+      "max": "Max",
+      "speed": "Speed",
+      "bonuses": "Bonuses",
+      "handToHandAttacks": "Hand To Hand Attacks",
+      "beyondSkill": "Beyond Skill",
+      "letItFly": "Let It Fly!",
+      "class": "Class",
+      "mortal": "Mortal",
+      "alignment": "Alignment",
+      "age": "Age",
+      "height": "Height",
+      "weight": "Weight",
+      "eyes": "Eyes",
+      "hair": "Hair",
+      "magicUser": "Magic User",
+      "clericUser": "Cleric User",
+      "lastHdRoll": "Last HD roll",
+      "naturalDR": "Natural DR",
+      "magicalDR": "Magical DR",
+      "saveBonus": "Save bonus (1/5 levels)",
+      "spellBonus": "Spell bonus (1/5 levels)",
+      "miracleBonus": "Miracle bonus (1/5 levels)",
+      "devPointsTotal": "Dev. Points (Total)",
+      "devPointsRem": "Dev. Points (Rem.)",
+      "length": "Length",
+      "vision": "Vision",
+      "damageType": "Damage Type",
+      "components": "Components",
+      "coverRanged": "Cover vs ranged attacks",
+      "standing": "Standing",
+      "crouching": "Crouching"
     },
     "Miracle": {
       "FIELDS": {
@@ -553,6 +596,15 @@
         },
         "savingThrow": {
           "label": "Saving throw"
+        },
+        "damageDiceOverpowered": {
+          "label": "Overpowered Damage Dice"
+        },
+        "damageDiceOverpowered2": {
+          "label": "Overpowered 2 Damage Dice"
+        },
+        "damageDice": {
+          "label": "Damage Dice"
         }
       }
     },
@@ -674,7 +726,8 @@
             "label": "Min"
           }
         }
-      }
+      },
+      "autoDestruction": "Auto-Destruction"
     },
     "Skill": {
       "Category": {
@@ -799,6 +852,12 @@
         },
         "damageDice": {
           "label": "Damage dice"
+        },
+        "damageDiceOverpowered": {
+          "label": "Overpowered Damage Dice"
+        },
+        "damageDiceOverpowered2": {
+          "label": "Overpowered 2 Damage Dice"
         }
       },
       "Range": {
@@ -833,7 +892,9 @@
         }
       }
     },
-    "Warning": {},
+    "Warning": {
+      "defenseShieldOrder": "To avoid a hit without using the shield, roll Grit or Luck first — then roll the shield."
+    },
     "Weapon": {
       "FIELDS": {
         "isAgile": {
@@ -978,6 +1039,18 @@
       "diceResult": "Dice result",
       "progressionCount": "Progression count:"
     },
+    "Combat": {
+      "RollMonsters": "Roll Monsters",
+      "monstersNotRolledTitle": "Monsters Not Rolled",
+      "monstersNotRolledMsg": "Monsters have not rolled this second. Proceed anyway?",
+      "proceedYes": "Proceed",
+      "proceedNo": "Cancel",
+      "spellDRDialogTitle": "Spell Damage — Apply DR?",
+      "spellDRDialogMsg": "Enter a damage reduction value to subtract, or click No DR to apply full damage.",
+      "spellDRLabel": "DR:",
+      "spellNoDR": "No DR",
+      "spellApplyDR": "Apply DR"
+    },
     "EquipmentCategories": {
       "ClassKit": "Class Kit",
       "Clothing": "Clothing",

lethal-fantasy.mjs

@@ -129,301 +129,310 @@ Hooks.once("ready", function () {
   }
 })
 
-// Test if version below 13
-let hookName = "renderChatMessage"
-if (foundry.utils.isNewerVersion(game.version, "12.0",)) {
-  hookName = "renderChatMessageHTML"
-}
-Hooks.on(hookName, (message, html, data) => {
+Hooks.on("renderChatMessageHTML", (message, html, data) => {
   const typeMessage = data.message.flags.lethalFantasy?.typeMessage
   // Message de demande de jet de dés
   if (typeMessage === "askRoll") {
     // Affichage des boutons de jet de dés uniquement pour les joueurs
     if (game.user.isGM) {
-      html.find(".ask-roll-dice").each((i, btn) => {
+      for (const btn of html.querySelectorAll(".ask-roll-dice")) {
         btn.style.display = "none"
-      })
+      }
     } else {
-      html.find(".ask-roll-dice").click((event) => {
-        const btn = $(event.currentTarget)
-        const type = btn.data("type")
-        const value = btn.data("value")
-        const avantage = btn.data("avantage") ?? "="
-        const character = game.user.character
-        if (type === SYSTEM.ROLL_TYPE.RESOURCE) character.rollResource(value)
-        else if (type === SYSTEM.ROLL_TYPE.SAVE) character.rollSave(value, avantage)
-      })
+      for (const btn of html.querySelectorAll(".ask-roll-dice")) {
+        btn.addEventListener("click", () => {
+          const type = btn.dataset.type
+          const value = btn.dataset.value
+          const avantage = btn.dataset.avantage ?? "="
+          const character = game.user.character
+          if (type === SYSTEM.ROLL_TYPE.RESOURCE) character.rollResource(value)
+          else if (type === SYSTEM.ROLL_TYPE.SAVE) character.rollSave(value, avantage)
+        })
+      }
     }
   }
 
   // Gestion du survol et du clic sur les boutons de dégâts pour les GMs
   if (game.user.isGM) {
     // Show damage buttons only for GM
-    $(html).find(".li-apply-wounds").each((i, btn) => {
+    for (const btn of html.querySelectorAll(".li-apply-wounds")) {
       btn.style.display = "block"
-    })
+    }
 
-    $(html).find(".apply-wounds-btn").hover(
-      function (event) {
-        // Mouse enter - select the token and pan to it
-        let combatantId = $(this).data("combatant-id")
+    for (const btn of html.querySelectorAll(".apply-wounds-btn")) {
+      btn.addEventListener("mouseenter", () => {
+        const combatantId = btn.dataset.combatantId
         if (combatantId && game.combat) {
-          let combatant = game.combat.combatants.get(combatantId)
+          const combatant = game.combat.combatants.get(combatantId)
           if (combatant?.token) {
-            let token = canvas.tokens.get(combatant.token.id)
+            const token = canvas.tokens.get(combatant.token.id)
             if (token) {
               token.control({ releaseOthers: true })
               canvas.animatePan(token.center)
             }
           }
         }
-      },
-      function (event) {
-        // Mouse leave - release selection
-        canvas.tokens.releaseAll()
-      }
-    )
-
-    $(html).find(".apply-wounds-btn").click((event) => {
-      LethalFantasyUtils.applyDamage(message, event)
-    })
+      })
+      btn.addEventListener("mouseleave", () => canvas.tokens.releaseAll())
+      btn.addEventListener("click", event => LethalFantasyUtils.applyDamage(message, event))
+    }
   }
 
   // Gestion du survol et du clic sur les boutons de défense
-  $(html).find(".request-defense-btn").hover(
-    function (event) {
-      // Mouse enter - select the token and pan to it
-      let tokenId = $(this).data("token-id")
+  for (const btn of html.querySelectorAll(".request-defense-btn")) {
+    btn.addEventListener("mouseenter", () => {
+      const tokenId = btn.dataset.tokenId
       if (tokenId) {
-        let token = canvas.tokens.get(tokenId)
+        const token = canvas.tokens.get(tokenId)
         if (token) {
           token.control({ releaseOthers: true })
           canvas.animatePan(token.center)
         }
       }
-    },
-    function (event) {
-      // Mouse leave - release selection
-      canvas.tokens.releaseAll()
-    }
-  )
+    })
+    btn.addEventListener("mouseleave", () => canvas.tokens.releaseAll())
 
-  // Gestionnaire pour les boutons de demande de défense
-  $(html).find(".request-defense-btn").off("click").on("click", (event) => {
-    event.preventDefault()
-    event.stopPropagation()
+    // Gestionnaire pour les boutons de demande de défense
+    btn.addEventListener("click", event => {
+      event.preventDefault()
+      event.stopPropagation()
 
-    const button = $(event.currentTarget)
-    const combatantId = button.data("combatant-id")
-    const tokenId = button.data("token-id")
+      const combatantId = btn.dataset.combatantId
+      const tokenId = btn.dataset.tokenId
 
-    // Récupérer le combattant soit du combat, soit directement du token
-    let combatant = null
-    let token = null
+      // Récupérer le combattant soit du combat, soit directement du token
+      let combatant = null
+      let token = null
 
-    if (game.combat && combatantId) {
-      combatant = game.combat.combatants.get(combatantId)
-    }
+      if (game.combat && combatantId) {
+        combatant = game.combat.combatants.get(combatantId)
+      }
 
-    // Si pas de combattant trouvé, chercher le token directement
-    if (!combatant && tokenId) {
-      token = canvas.tokens.get(tokenId)
-      if (token) {
-        // Créer un pseudo-combattant avec les infos du token
-        combatant = {
-          actor: token.actor,
-          name: token.name,
-          token: token,
-          actorId: token.actorId
+      // Si pas de combattant trouvé, chercher le token directement
+      if (!combatant && tokenId) {
+        token = canvas.tokens.get(tokenId)
+        if (token) {
+          // Créer un pseudo-combattant avec les infos du token
+          combatant = {
+            actor: token.actor,
+            name: token.name,
+            token: token,
+            actorId: token.actorId
+          }
         }
       }
-    }
 
-    if (!combatant) return
+      if (!combatant) return
 
-    // Récupérer les informations de l'attaquant depuis le message
-    const attackerName = message.rolls[0]?.actorName || "Unknown"
-    const attackerId = message.rolls[0]?.actorId
-    const weaponName = message.rolls[0]?.rollName || "weapon"
-    const attackRoll = message.rolls[0]?.rollTotal || 0
-    const defenderName = combatant.name
-    const attackWeaponId = message.rolls[0]?.rollTarget?.weapon?.id || message.rolls[0]?.rollTarget?.weapon?._id
-    const attackRollType = message.rolls[0]?.type
-    const attackRollKey = message.rolls[0]?.rollTarget?.rollKey
-    console.log(`[LF] request-defense-btn | attackRollType=${attackRollType} defender=${defenderName} defenderType=${combatant.actor?.type}`)
-    const attackD30result = message.rolls[0]?.options?.D30result || null
-    const attackD30message = message.rolls[0]?.options?.D30message || null
-    const attackRerollContext = {
-      rollType: message.rolls[0]?.options?.rollType,
-      rollTarget: foundry.utils.duplicate(message.rolls[0]?.options?.rollTarget ?? {}),
-      actorId: message.rolls[0]?.options?.actorId,
-      actorName: message.rolls[0]?.options?.actorName,
-      actorImage: message.rolls[0]?.options?.actorImage,
-      defenderId: combatant.actor?.id || null,
-      defenderTokenId: tokenId || combatant.token?.id || null,
-      rollContext: foundry.utils.duplicate(message.rolls[0]?.options?.rollData ?? {})
-    }
+      // Récupérer les informations de l'attaquant depuis le message
+      const attackerName = message.rolls[0]?.actorName || "Unknown"
+      const attackerId = message.rolls[0]?.actorId
+      const weaponName = message.rolls[0]?.rollName || "weapon"
+      const attackRoll = message.rolls[0]?.rollTotal || 0
+      const defenderName = combatant.name
+      const attackWeaponId = message.rolls[0]?.rollTarget?.weapon?.id || message.rolls[0]?.rollTarget?.weapon?._id
+      const attackRollType = message.rolls[0]?.type
+      const attackRollKey = message.rolls[0]?.rollTarget?.rollKey
+      console.log(`[LF] request-defense-btn | attackRollType=${attackRollType} defender=${defenderName} defenderType=${combatant.actor?.type}`)
+      const attackD30result = message.rolls[0]?.options?.D30result || null
+      const attackD30message = message.rolls[0]?.options?.D30message || null
+      const attackRerollContext = {
+        rollType: message.rolls[0]?.options?.rollType,
+        rollTarget: foundry.utils.duplicate(message.rolls[0]?.options?.rollTarget ?? {}),
+        actorId: message.rolls[0]?.options?.actorId,
+        actorName: message.rolls[0]?.options?.actorName,
+        actorImage: message.rolls[0]?.options?.actorImage,
+        defenderId: combatant.actor?.id || null,
+        defenderTokenId: tokenId || combatant.token?.id || null,
+        rollContext: foundry.utils.duplicate(message.rolls[0]?.options?.rollData ?? {})
+      }
 
-    // Préparer le message de demande de défense
-    const defenseMsg = {
-      type: "requestDefense",
-      attackerName: attackerName,
-      attackerId: attackerId,
-      defenderName: defenderName,
-      weaponName: weaponName,
-      attackRoll: attackRoll,
-      attackWeaponId: attackWeaponId,
-      attackRollType: attackRollType,
-      attackRollKey: attackRollKey,
-      attackD30result: attackD30result,
-      attackD30message: attackD30message,
-      attackRerollContext: attackRerollContext,
-      combatantId: combatantId,
-      tokenId: tokenId
-    }
+      // Préparer le message de demande de défense
+      // isRanged: true si le monstre était en mode ranged (via rollTarget.attackMode stocké dans le roll)
+      // OU si l'attaquant utilisait une arme ranged (weapon-attack avec weaponType === "ranged")
+      const attacker = game.actors.get(attackerId)
+      const rollTargetOptions = message.rolls[0]?.options?.rollTarget
+      const attackerWeapon = rollTargetOptions?.weapon
+      const isRangedAttack = (rollTargetOptions?.attackMode === "ranged")
+        || (attacker?.type === "monster" && attacker.system.attackMode === "ranged")
+        || (attackerWeapon?.system?.weaponType === "ranged")
 
-    // Envoyer le message socket à l'utilisateur contrôlant le combatant
-    // Only consider active (online) users; fall back to any active GM for unowned/GM monsters.
-    let owners = game.users.filter(u =>
-      u.active && combatant.actor.testUserPermission(u, "OWNER")
-    )
-    if (owners.length === 0) {
-      owners = game.users.filter(u => u.active && u.isGM)
-    }
+      const defenseMsg = {
+        type: "requestDefense",
+        attackerName,
+        attackerId,
+        defenderName,
+        weaponName,
+        attackRoll,
+        attackWeaponId,
+        attackRollType,
+        attackRollKey,
+        attackD30result,
+        attackD30message,
+        attackRerollContext,
+        combatantId,
+        tokenId,
+        isRanged: isRangedAttack
+      }
 
-    // Récupérer l'acteur attaquant pour vérifier qui l'a lancé
-    const attacker = game.actors.get(attackerId)
-    const attackerOwners = attacker ? game.users.filter(u => attacker.testUserPermission(u, "OWNER")).map(u => u.id) : []
+      // Envoyer le message socket à l'utilisateur contrôlant le combatant
+      // Only consider active (online) users; fall back to any active GM for unowned/GM monsters.
+      let owners = game.users.filter(u => u.active && combatant.actor.testUserPermission(u, "OWNER"))
+      if (owners.length === 0) {
+        owners = game.users.filter(u => u.active && u.isGM)
+      }
 
-    // Monsters always need their owner (usually the GM) to roll a save/defense,
-    // even if that owner also controls the attacker. Only skip for same-player PC-vs-PC.
-    const defenderIsMonster = combatant.actor?.type === "monster"
+      // Récupérer l'acteur attaquant pour vérifier qui l'a lancé
+      const attackerOwners = attacker ? game.users.filter(u => attacker.testUserPermission(u, "OWNER")).map(u => u.id) : []
 
-    let messageSent = false
-    owners.forEach(owner => {
-      // Don't let a player be both attacker and defender for their own PC, unless defending a monster.
-      if (attackerOwners.includes(owner.id) && owner.id === game.user.id && !defenderIsMonster) {
-        // Ne rien faire - on ne veut pas que l'attaquant se défende contre lui-même
+      // Monsters always need their owner (usually the GM) to roll a save/defense,
+      // even if that owner also controls the attacker. Only skip for same-player PC-vs-PC.
+      const defenderIsMonster = combatant.actor?.type === "monster"
+
+      let messageSent = false
+      owners.forEach(owner => {
+        // Don't let a player be both attacker and defender for their own PC, unless defending a monster.
+        if (attackerOwners.includes(owner.id) && owner.id === game.user.id && !defenderIsMonster) {
+          // Ne rien faire - on ne veut pas que l'attaquant se défende contre lui-même
+          return
+        }
+
+        if (owner.id === game.user.id) {
+          // Si l'utilisateur actuel est le propriétaire du défenseur (mais pas l'attaquant), appeler directement
+          LethalFantasyUtils.showDefenseRequest({ ...defenseMsg, userId: owner.id })
+          messageSent = true
+        } else {
+          // Sinon, envoyer via socket
+          game.socket.emit(`system.${SYSTEM.id}`, { ...defenseMsg, userId: owner.id })
+          messageSent = true
+        }
+      })
+
+      // Notification pour l'attaquant
+      if (messageSent) {
+        ui.notifications.info(`Defense request sent to ${defenderName}'s controller`)
+      }
+    })
+  }
+
+  // Gestionnaire pour les boutons de jet de dégâts (armes et résultats de combat)
+  for (const btn of html.querySelectorAll(".damage-roll-btn, .roll-damage-btn")) {
+    btn.addEventListener("click", async event => {
+      event.preventDefault()
+      event.stopPropagation()
+
+      const weaponId = btn.dataset.weaponId
+      const attackKey = btn.dataset.attackKey
+      const attackerId = btn.dataset.attackerId
+      const defenderId = btn.dataset.defenderId
+      const defenderTokenId = btn.dataset.defenderTokenId || null
+      const extraShieldDr = Number(btn.dataset.extraShieldDr || 0)
+      const damageType = btn.dataset.damageType
+      const damageFormula = btn.dataset.damageFormula
+      const damageModifier = btn.dataset.damageModifier
+      const isMonster = btn.dataset.isMonster
+
+      // Récupérer l'acteur (soit depuis le message, soit depuis attackerId)
+      const actor = attackerId ? game.actors.get(attackerId) : game.actors.get(message.rolls[0]?.actorId)
+      if (!actor) {
+        ui.notifications.error("Actor not found")
         return
       }
 
-      if (owner.id === game.user.id) {
-        // Si l'utilisateur actuel est le propriétaire du défenseur (mais pas l'attaquant), appeler directement
-        LethalFantasyUtils.showDefenseRequest({ ...defenseMsg, userId: owner.id })
-        messageSent = true
-      } else {
-        // Sinon, envoyer via socket
-        game.socket.emit(`system.${SYSTEM.id}`, {
-          ...defenseMsg,
-          userId: owner.id
+      // Pour les sorts, rouler les dés de dégâts avec DR manuelle optionnelle
+      if (damageType === "spell" && damageFormula) {
+        const manualDR = await foundry.applications.api.DialogV2.wait({
+          window: { title: game.i18n.localize("LETHALFANTASY.Combat.spellDRDialogTitle") },
+          classes: ["lethalfantasy"],
+          position: { width: 320 },
+          content: `<div style="padding:0.5rem 0">
+            <p style="margin-bottom:0.6rem">${game.i18n.localize("LETHALFANTASY.Combat.spellDRDialogMsg")}</p>
+            <div style="display:flex;align-items:center;gap:0.5rem">
+              <label style="font-weight:bold">${game.i18n.localize("LETHALFANTASY.Combat.spellDRLabel")}</label>
+              <input type="number" name="manualDr" value="0" min="0" style="width:5rem"/>
+            </div>
+          </div>`,
+          buttons: [
+            {
+              action: "noDR",
+              label: game.i18n.localize("LETHALFANTASY.Combat.spellNoDR"),
+              icon: "fa-solid fa-wand-magic-sparkles",
+              callback: () => 0
+            },
+            {
+              action: "applyDR",
+              label: game.i18n.localize("LETHALFANTASY.Combat.spellApplyDR"),
+              icon: "fa-solid fa-shield",
+              callback: (event, button, dialog) => Number(dialog.querySelector("[name='manualDr']")?.value) || 0
+            },
+            {
+              action: "cancel",
+              label: game.i18n.localize("LETHALFANTASY.Combat.proceedNo"),
+              callback: () => null
+            }
+          ],
+          rejectClose: false
         })
-        messageSent = true
+        if (manualDR === null) return
+        const rollOpts = {
+          type: "spell-damage",
+          rollType: "spell-damage",
+          rollName: damageFormula,
+          isDamage: true,
+          rollData: { isDamage: true },
+          manualDR: manualDR,
+          defenderId,
+          defenderTokenId,
+          actorId: actor.id,
+          actorName: actor.name,
+          actorImage: actor.img
+        }
+        const roll = new LethalFantasyRoll(damageFormula, {}, rollOpts)
+        await roll.evaluate()
+        roll.options.rollTotal = roll.total
+        if (game?.dice3d) await game.dice3d.showForRoll(roll, game.user, true)
+        await roll.toMessage()
+        return
       }
+
+      // Pour les boutons de résultat de combat (monster damage)
+      if (damageType === "monster" && attackKey) {
+        await actor.system.prepareMonsterRoll("monster-damage", attackKey, undefined, undefined, undefined, defenderId, defenderTokenId, extraShieldDr)
+        return
+      }
+
+      // Pour les monstres, utiliser prepareMonsterRoll
+      if (isMonster || actor.type === "monster") {
+        await actor.system.prepareMonsterRoll("monster-damage", weaponId, undefined, undefined, damageModifier)
+        return
+      }
+
+      // Pour les personnages, récupérer l'arme
+      const weapon = actor.items.get(weaponId)
+      if (!weapon) {
+        ui.notifications.error("Weapon not found")
+        return
+      }
+
+      // Lancer les dégâts avec la bonne méthode
+      const rollType = damageType === "small" ? "weapon-damage-small" : "weapon-damage-medium"
+      await actor.prepareRoll(rollType, weaponId, undefined, defenderId, defenderTokenId, extraShieldDr)
     })
-
-    // Notification pour l'attaquant
-    if (messageSent) {
-      ui.notifications.info(`Defense request sent to ${defenderName}'s controller`)
-    }
-  })
-
-  // Gestionnaire pour les boutons de jet de dégâts (armes et résultats de combat)
-  $(html).find(".damage-roll-btn, .roll-damage-btn").off("click").on("click", async (event) => {
-    event.preventDefault()
-    event.stopPropagation()
-
-    const button = $(event.currentTarget)
-    const weaponId = button.data("weapon-id")
-    const attackKey = button.data("attack-key")
-    let attackerId = button.data("attacker-id")
-    const defenderId = button.data("defender-id")
-    const defenderTokenId = button.data("defender-token-id") || null
-    const extraShieldDr = Number(button.data("extra-shield-dr") || 0)
-    const damageType = button.data("damage-type")
-    const damageFormula = button.data("damage-formula")
-    const damageModifier = button.data("damage-modifier")
-    const isMonster = button.data("is-monster")
-
-    // Récupérer l'acteur (soit depuis le message, soit depuis attackerId)
-    let actor = attackerId ? game.actors.get(attackerId) : game.actors.get(message.rolls[0]?.actorId)
-    if (!actor) {
-      ui.notifications.error("Actor not found")
-      return
-    }
-
-    // Pour les sorts, rouler les dés de dégâts avec option bypass DR
-    if (damageType === "spell" && damageFormula) {
-      const bypassArmor = await foundry.applications.api.DialogV2.confirm({
-        window: { title: "Spell Damage" },
-        classes: ["lethalfantasy"],
-        content: "<p>Does this spell's damage bypass armor DR?</p>",
-        yes: { label: "Yes (ignore armor)", icon: "fa-solid fa-wand-magic-sparkles" },
-        no: { label: "No (apply armor DR)", icon: "fa-solid fa-shield" }
-      })
-      const rollOpts = {
-        type: "spell-damage",
-        rollType: "spell-damage",
-        rollName: damageFormula,
-        isDamage: true,
-        rollData: { isDamage: true },
-        bypassArmor: bypassArmor ?? false,
-        defenderId,
-        defenderTokenId,
-        actorId: actor.id,
-        actorName: actor.name,
-        actorImage: actor.img
-      }
-      const roll = new LethalFantasyRoll(damageFormula, {}, rollOpts)
-      await roll.evaluate()
-      roll.options.rollTotal = roll.total
-      if (game?.dice3d) await game.dice3d.showForRoll(roll, game.user, true)
-      await roll.toMessage()
-      return
-    }
-
-    // Pour les boutons de résultat de combat (monster damage)
-    if (damageType === "monster" && attackKey) {
-      await actor.system.prepareMonsterRoll("monster-damage", attackKey, undefined, undefined, undefined, defenderId, defenderTokenId, extraShieldDr)
-      return
-    }
-
-    // Pour les monstres, utiliser prepareMonsterRoll
-    if (isMonster || actor.type === "monster") {
-      await actor.system.prepareMonsterRoll("monster-damage", weaponId, undefined, undefined, damageModifier)
-      return
-    }
-
-    // Pour les personnages, récupérer l'arme
-    const weapon = actor.items.get(weaponId)
-    if (!weapon) {
-      ui.notifications.error("Weapon not found")
-      return
-    }
-
-    // Lancer les dégâts avec la bonne méthode
-    const rollType = damageType === "small" ? "weapon-damage-small" : "weapon-damage-medium"
-    await actor.prepareRoll(rollType, weaponId, undefined, defenderId, defenderTokenId, extraShieldDr)
-  })
+  }
 
   // Masquer les boutons de dommages dans les messages de résultat de combat si l'utilisateur n'est pas l'attaquant
-  $(html).find(".roll-damage-btn").each(function() {
-    const button = $(this)
-    const attackerId = button.data("attacker-id")
-
+  for (const btn of html.querySelectorAll(".roll-damage-btn")) {
+    const attackerId = btn.dataset.attackerId
     if (attackerId) {
       const attacker = game.actors.get(attackerId)
       // Masquer le bouton si l'utilisateur n'est pas GM et ne possède pas l'attaquant
       if (!game.user.isGM && !attacker?.testUserPermission(game.user, "OWNER")) {
-        button.hide()
+        btn.style.display = "none"
       }
     }
-  })
+  }
 })
 
-Hooks.on("getCombatTrackerEntryContext", (html, options) => {
-  LethalFantasyUtils.pushCombatOptions(html, options);
-});
-
 // Hook pour ajouter les données d'attaque au message de défense
 Hooks.on("preCreateChatMessage", (message) => {
   const rollType = message.rolls[0]?.options?.rollType
@@ -597,7 +606,7 @@ Hooks.on("createChatMessage", async (message) => {
             <div class="combat-status">
               <p><strong>${attackerName}</strong> rolled <strong>${attackRoll}</strong></p>
               <p><strong>${defenderName}</strong> currently has <strong>${defenseRoll}</strong></p>
-              ${defenseD30message ? `<p class="bonus-info">D30 special: ${defenseD30message}</p>` : ""}
+              ${defenseD30message ? `<p class="bonus-info">D30 special: ${defenseD30message.description}</p>` : ""}
             </div>
             <p class="offer-text">Choose how to improve the defense before resolving the hit.</p>
           </div>
@@ -751,7 +760,7 @@ Hooks.on("createChatMessage", async (message) => {
             <div class="combat-status">
               <p><strong>${attackerName}</strong> currently has <strong>${attackRollFinal}</strong></p>
               <p><strong>${defenderName}</strong> rolled <strong>${defenseRoll}</strong></p>
-              ${attackD30message ? `<p class="bonus-info">D30 special: ${attackD30message}</p>` : ""}
+              ${attackD30message ? `<p class="bonus-info">D30 special: ${attackD30message.description}</p>` : ""}
             </div>
             <p class="offer-text">Choose how to improve the attack before resolving the combat result.</p>
           </div>
@@ -819,6 +828,73 @@ Hooks.on("createChatMessage", async (message) => {
   }
 })
 
+// Hook: deduct aether when a spell-attack or spell-power roll is posted to chat
+Hooks.on("createChatMessage", async (message) => {
+  if (!["spell-attack", "spell-power"].includes(message.rolls[0]?.options?.rollType)) return
+
+  const actorId = message.rolls[0]?.options?.actorId
+  if (!actorId) return
+  const actor = game.actors.get(actorId)
+  if (!actor) return
+
+  // Only the primary controller (player owner or GM) handles this
+  const activePlayerOwners = game.users.filter(u => u.active && !u.isGM && actor.testUserPermission(u, "OWNER"))
+  const isPrimary = activePlayerOwners.length > 0
+    ? activePlayerOwners[0].id === game.user.id
+    : game.user.isGM
+  if (!isPrimary) return
+
+  const rollTarget = message.rolls[0]?.options?.rollTarget
+  const spellId = rollTarget?.id || rollTarget?._id
+  const spell = spellId ? actor.items.get(spellId) : null
+  if (!spell || spell.type !== "spell") return
+
+  const cost = Number(spell.system?.cost) || 0
+  if (cost <= 0) return
+
+  const currentAether = Number(actor.system.aetherPoints?.value) || 0
+  const newAether = Math.max(0, currentAether - cost)
+  await actor.update({ "system.aetherPoints.value": newAether })
+
+  await ChatMessage.create({
+    content: `<p>🔮 <strong>${actor.name}</strong> casts <em>${spell.name}</em> — spends <strong>${cost}</strong> Aether <span style="color:#888;">(${currentAether} → ${newAether})</span>.</p>`,
+    speaker: ChatMessage.getSpeaker({ actor })
+  })
+})
+
+// Hook: deduct grace when a miracle-attack or miracle-power roll is posted to chat
+Hooks.on("createChatMessage", async (message) => {
+  if (!["miracle-attack", "miracle-power"].includes(message.rolls[0]?.options?.rollType)) return
+
+  const actorId = message.rolls[0]?.options?.actorId
+  if (!actorId) return
+  const actor = game.actors.get(actorId)
+  if (!actor) return
+
+  const activePlayerOwners = game.users.filter(u => u.active && !u.isGM && actor.testUserPermission(u, "OWNER"))
+  const isPrimary = activePlayerOwners.length > 0
+    ? activePlayerOwners[0].id === game.user.id
+    : game.user.isGM
+  if (!isPrimary) return
+
+  const rollTarget = message.rolls[0]?.options?.rollTarget
+  const miracleId = rollTarget?.id || rollTarget?._id
+  const miracle = miracleId ? actor.items.get(miracleId) : null
+  if (!miracle || miracle.type !== "miracle") return
+
+  const cost = Number(miracle.system?.level) || 0
+  if (cost <= 0) return
+
+  const currentGrace = Number(actor.system.divinityPoints?.value) || 0
+  const newGrace = Math.max(0, currentGrace - cost)
+  await actor.update({ "system.divinityPoints.value": newGrace })
+
+  await ChatMessage.create({
+    content: `<p>✨ <strong>${actor.name}</strong> invokes <em>${miracle.name}</em> — spends <strong>${cost}</strong> Grace <span style="color:#888;">(${currentGrace} → ${newGrace})</span>.</p>`,
+    speaker: ChatMessage.getSpeaker({ actor })
+  })
+})
+
 // Hook pour appliquer automatiquement les dégâts si une cible est définie
 Hooks.on("createChatMessage", async (message) => {
   // Vérifier si c'est un message de dégâts avec un defenderId
@@ -872,12 +948,14 @@ Hooks.on("createChatMessage", async (message) => {
   const damageTotal = message.rolls[0]?.options?.rollTotal || message.rolls[0]?.total || 0
   const weaponName = message.rolls[0]?.options?.rollName || "Unknown Weapon"
   const attackerName = message.rolls[0]?.options?.actorName || "Unknown Attacker"
+  const rollType = message.rolls[0]?.options?.rollType
 
-  // Calculer les DR
-  const bypassArmor = message.rolls[0]?.options?.bypassArmor || false
-  const armorDR = bypassArmor ? 0 : (defender.computeDamageReduction() || 0)
+  // Calculer les DR — les sorts utilisent une DR manuelle saisie par l'utilisateur
+  const isSpellDamage = rollType === "spell-damage"
+  const manualDR = message.rolls[0]?.options?.manualDR ?? 0
   const extraShieldDr = Number(message.rolls[0]?.options?.extraShieldDr) || 0
-  const totalDR = armorDR + extraShieldDr
+  const armorDR = isSpellDamage ? manualDR : (defender.computeDamageReduction() || 0)
+  const totalDR = isSpellDamage ? manualDR : armorDR + extraShieldDr
   const finalDamage = Math.max(0, damageTotal - totalDR)
 
   // Prefer the token ID stored in roll options (set at attack time when the exact token is known).
@@ -910,7 +988,9 @@ Hooks.on("createChatMessage", async (message) => {
     {
       targetName: defender.name,
       damage: finalDamage,
-      drText: bypassArmor ? "Armor DR bypassed (spell)" : (totalDR > 0 ? `Armor DR: ${armorDR}${extraShieldDr > 0 ? ` + Shield DR: ${extraShieldDr}` : ""}` : ""),
+      drText: isSpellDamage
+        ? (manualDR > 0 ? `Spell DR: ${manualDR}` : "No DR applied")
+        : (totalDR > 0 ? `Armor DR: ${armorDR}${extraShieldDr > 0 ? ` + Shield DR: ${extraShieldDr}` : ""}` : ""),
       weaponName: weaponName,
       attackerName: attackerName,
       rawDamage: damageTotal

module/applications/combat.mjs

@@ -18,6 +18,7 @@ export class LethalFantasyCombatTracker extends foundry.applications.sidebar.tab
     actions: {
       initiativePlus: LethalFantasyCombatTracker.#initiativePlus,
       initiativeMinus: LethalFantasyCombatTracker.#initiativeMinus,
+      rollMonsterProgression: LethalFantasyCombatTracker.#rollMonsterProgression,
     },
   });
 
@@ -49,6 +50,15 @@ export class LethalFantasyCombatTracker extends foundry.applications.sidebar.tab
     c.update({ 'initiative': newInit });
   }
 
+  /**
+   * Roll progression dice for all monster combatants that are eligible this round.
+   * @param {Event} ev Click event.
+   */
+  static async #rollMonsterProgression(ev) {
+    ev.preventDefault();
+    await game.combat.rollMonsterProgression();
+  }
+
   activateListeners(html) {
     super.activateListeners(html);
     // Display Combat settings
@@ -109,18 +119,12 @@ export class LethalFantasyCombat extends Combat {
   }
 
   async rollInitiative(ids, options) {
-    console.log("%%%%%%%%% Roll Initiative", ids, options);
-
     ids = typeof ids === "string" ? [ids] : ids;
-    let messages = [];
-    let rollMode = game.settings.get("core", "rollMode");
 
-    let updates = [];
     for (let cId of ids) {
       const c = this.combatants.get(cId);
       const playerOwner = game.users.find(u => u.active && !u.isGM && u.character?.id === c.actor.id);
       if (game.user.isGM && playerOwner) {
-        console.log("Rolling initiative for", c.actor.name);
         game.socket.emit(`system.${SYSTEM.id}`, { type: "rollInitiative", userId: playerOwner.id, actorId: c.actor.id, combatId: this.id, combatantId: c.id });
       } else {
         await c.actor.system.rollInitiative(this.id, c.id);
@@ -130,6 +134,36 @@ export class LethalFantasyCombat extends Combat {
     return this;
   }
 
+  /** Roll progression dice for all eligible monster combatants this round. Called manually by the GM. */
+  async rollMonsterProgression() {
+    const currentRound = this.round;
+    const monsters = this.combatants.filter(c => c.actor?.type === "monster" && !c.isDefeated);
+
+    if (monsters.length === 0) {
+      ui.notifications.warn("No monsters in combat.");
+      return;
+    }
+
+    let rolled = 0;
+    for (let c of monsters) {
+      if (c.initiative !== null && currentRound >= c.initiative) {
+        await c.actor.system.rollProgressionDice(this.id, c.id);
+        rolled++;
+      }
+    }
+
+    if (rolled === 0) {
+      const earliest = monsters.reduce((min, c) => (c.initiative !== null && c.initiative < min) ? c.initiative : min, Infinity);
+      if (earliest === Infinity) {
+        ui.notifications.warn("Monsters have no initiative set. Roll initiative first.");
+      } else {
+        ui.notifications.info(`No monsters act yet — earliest monster initiative is ${earliest} (current round: ${currentRound}).`);
+      }
+    } else {
+      this._monsterProgressionRolledRound = currentRound;
+    }
+  }
+
   resetProgression(cId) {
     let c = this.combatants.get(cId);
     c.update({ 'system.progressionCount': 0 });
@@ -151,15 +185,12 @@ export class LethalFantasyCombat extends Combat {
   }
 
   async nextTurn() {
-    console.log("NEXT TURN");
-
     let turn = this.turn ?? -1;
     let skipDefeated = this.settings.skipDefeated;
 
     // Determine the next turn number
     let next = null;
     for (let [i, t] of this.turns.entries()) {
-      console.log("Turn", t);
       if (i <= turn) continue;
       if (skipDefeated && t.isDefeated) continue;
       next = i;
@@ -183,7 +214,6 @@ export class LethalFantasyCombat extends Combat {
     this.turnsDone = false
 
     let turn = this.turn === null ? null : 0; // Preserve the fact that it's no-one's turn currently.
-    console.log("ROUND", this);
 
     let advanceTime = Math.max(this.turns.length - this.turn, 0) * CONFIG.time.turnTime;
     advanceTime += CONFIG.time.roundTime;
@@ -201,8 +231,24 @@ export class LethalFantasyCombat extends Combat {
       return this;
     }
 
+    // Warn if eligible monsters have not rolled progression dice this round
+    const eligibleMonsters = this.combatants.filter(
+      c => c.actor?.type === "monster" && !c.isDefeated && c.initiative !== null && this.round >= c.initiative
+    );
+    if (eligibleMonsters.length > 0 && this._monsterProgressionRolledRound !== this.round) {
+      const proceed = await foundry.applications.api.DialogV2.confirm({
+        window: { title: game.i18n.localize("LETHALFANTASY.Combat.monstersNotRolledTitle") },
+        content: `<p>${game.i18n.localize("LETHALFANTASY.Combat.monstersNotRolledMsg")}</p>`,
+        yes: { label: game.i18n.localize("LETHALFANTASY.Combat.proceedYes") },
+        no: { label: game.i18n.localize("LETHALFANTASY.Combat.proceedNo") },
+        rejectClose: false,
+      });
+      if (!proceed) return this;
+    }
+
     for (let c of this.combatants) {
       if (nextRound >= c.initiative) {
+        if (c.actor.type === "monster") continue;  // Monsters roll manually via the "Roll Monsters" button
         const playerOwner = game.users.find(u => u.active && !u.isGM && u.character?.id === c.actor.id);
         if (game.user.isGM && playerOwner) {
           game.socket.emit(`system.${SYSTEM.id}`, { type: "rollProgressionDice", userId: playerOwner.id, progressionCount: c.system.progressionCount + 1, actorId: c.actor.id, combatId: this.id, combatantId: c.id });

module/applications/free-roll.mjs

@@ -75,39 +75,53 @@ export function injectDiceTray(_chatLog, html) {
 
 /**
  * Roll one or more dice of the given type and post the result to chat.
+ * For exploding dice, follows the Lethal Fantasy rule: each exploded reroll
+ * contributes (result − 1) to the total, same as all other system rolls.
  *
  * @param {string}  dieType  Die face, e.g. "d20"
  * @param {number}  count    Number of dice to roll (1–9)
- * @param {boolean} explode  Whether to use the exploding modifier (x = max-value explode)
+ * @param {boolean} explode  Whether to use the exploding variant (max triggers reroll at −1)
  * @returns {Promise<void>}
  */
 export async function rollFreeDie(dieType, count = 1, explode = false) {
   const sides = parseInt(dieType.replace("d", "")) || 20
-  const formula = explode ? `${count}d${sides}x` : `${count}d${sides}`
+  const baseFormula = `1d${sides}`
   const label = explode
     ? `${count}${dieType.toUpperCase()}E`
     : `${count}${dieType.toUpperCase()}`
 
-  const roll = new Roll(formula)
-  await roll.evaluate()
-
-  const results = roll.terms
-    .filter(t => t.results)
-    .flatMap(t => t.results)
-
-  const total = roll.total
-
   const dieLabel = dieType.toUpperCase()
-  const resultHtml = results.map(r => {
-    const val = r.result
-    const isMax = val === sides
-    const isMin = val === 1
-    const explodeIcon = r.exploded ? `<i class="fa-solid fa-burst lf-dt-explode-icon"></i>` : ""
+  const dieChips = []
+  let total = 0
+
+  for (let i = 0; i < count; i++) {
+    const r0 = await new Roll(baseFormula).evaluate()
+    if (game?.dice3d) await game.dice3d.showForRoll(r0, game.user, true)
+    let diceResult = r0.dice[0].results[0].result
+    dieChips.push({ label: dieLabel, value: diceResult, exploded: false })
+    total += diceResult
+
+    if (explode) {
+      while (diceResult === sides) {
+        const rx = await new Roll(baseFormula).evaluate()
+        if (game?.dice3d) await game.dice3d.showForRoll(rx, game.user, true)
+        diceResult = rx.dice[0].results[0].result
+        const contrib = diceResult - 1
+        dieChips.push({ label: `${dieLabel}-1`, value: contrib, exploded: true })
+        total += contrib
+      }
+    }
+  }
+
+  const resultHtml = dieChips.map(chip => {
+    const isMax = !chip.exploded && chip.value === sides
+    const isMin = chip.value === 1
+    const explodeIcon = chip.exploded ? `<i class="fa-solid fa-burst lf-dt-explode-icon"></i>` : ""
     const classes = ["lf-frc-die-chip", isMax ? "lf-frc-max" : "", isMin ? "lf-frc-min" : ""].filter(Boolean).join(" ")
     return `<div class="${classes}">
-      <span class="lf-frc-die-type">${dieLabel}</span>
+      <span class="lf-frc-die-type">${chip.label}</span>
       <span class="lf-frc-die-sep">→</span>
-      <span class="lf-frc-die-val">${val}${explodeIcon}</span>
+      <span class="lf-frc-die-val">${chip.value}${explodeIcon}</span>
     </div>`
   }).join("")
 
@@ -128,12 +142,14 @@ export async function rollFreeDie(dieType, count = 1, explode = false) {
   `
 
   const rollMode = game.settings.get("core", "rollMode")
+  // Normalize old-style rollMode keys (v12/v13) to new-style (v14), fallback to "public"
+  const modeMap = { publicroll: "public", gmroll: "gm", blindroll: "blind", selfroll: "self" }
+  const mode = modeMap[rollMode] ?? rollMode ?? "public"
   const msgData = {
     speaker: ChatMessage.getSpeaker(),
     content,
-    rolls: [roll],
     sound: CONFIG.sounds.dice,
+    mode,
   }
-  ChatMessage.applyRollMode(msgData, rollMode)
   await ChatMessage.create(msgData)
 }

module/applications/sheets/character-sheet.mjs

@@ -172,7 +172,7 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
     })
     if (!roll) return null
 
-    await roll.toMessage({}, { rollMode: roll.options.rollMode })
+    await roll.toMessage({}, { messageMode: roll.options.rollMode })
   }
 
   static async #onRollInitiative(event, target) {
@@ -259,9 +259,11 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
 
   async _onRoll(event, target) {
     if (this.isEditMode) return
-    const rollType = event.target.dataset.rollType
-    let rollKey = event.target.dataset.rollKey;
-    let rollDice = event.target.dataset?.rollDice;
+    const el = event.currentTarget
+    const rollType = el.dataset.rollType
+    if (!rollType) return
+    let rollKey = el.dataset.rollKey
+    let rollDice = el.dataset.rollDice
 
     this.actor.prepareRoll(rollType, rollKey, rollDice)
 

module/applications/sheets/monster-sheet.mjs

@@ -111,11 +111,13 @@ export default class LethalFantasyMonsterSheet extends LethalFantasyActorSheet {
     })
     if (!roll) return null
 
-    await roll.toMessage({}, { rollMode: roll.options.rollMode })
+    await roll.toMessage({}, { messageMode: roll.options.rollMode })
   }
 
   static async #onRollInitiative(event, target) {
-    await this.document.system.rollInitiative(event, target)
+    const combat = game.combat
+    const combatant = combat?.combatants.find(c => c.actorId === this.document.id)
+    await this.document.system.rollInitiative(combat?.id, combatant?.id)
   }
 
   getBestWeaponClassSkill(skills, rollType, multiplier = 1.0) {

module/config/d30_results_tables.json

@@ -1,148 +1,615 @@
 {
   "d30_dice_results": {
     "30": {
-      "melee_attack": "Possible Lethal or Vital Strike or Add D20E to Attack",
-      "ranged_attack": "Possible Lethal or Vital Strike or Add D20E to Attack",
-      "melee_defense": "Possible Flawless or Legendary Defense or Add D20E to Defense",
-      "arcane_spell_attack": "Possible Lethal or Vital Magical Strike or Add D20E to Spell Attack",
-      "arcane_spell_defense": "Possible Spell Catastrophe or adds D20E to Spell Defense",
-      "skill_rolls": "Skill Succeeds Regardless of Opposing Roll"
+      "melee_attack": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_strike",
+            "options": [
+              "lethal",
+              "vital"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D20E",
+            "target": "attack"
+          }
+        ],
+        "description": "Possible Lethal or Vital Strike or Add D20E to Attack"
+      },
+      "ranged_attack": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_strike",
+            "options": [
+              "lethal",
+              "vital"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D20E",
+            "target": "attack"
+          }
+        ],
+        "description": "Possible Lethal or Vital Strike or Add D20E to Attack"
+      },
+      "melee_defense": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_defense",
+            "options": [
+              "flawless",
+              "legendary"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D20E",
+            "target": "defense"
+          }
+        ],
+        "description": "Possible Flawless or Legendary Defense or Add D20E to Defense"
+      },
+      "arcane_spell_attack": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_strike",
+            "options": [
+              "lethal_magical",
+              "vital_magical"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D20E",
+            "target": "spell_attack"
+          }
+        ],
+        "description": "Possible Lethal or Vital Magical Strike or Add D20E to Spell Attack"
+      },
+      "arcane_spell_defense": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "spell_calamity"
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D20E",
+            "target": "spell_defense"
+          }
+        ],
+        "description": "Possible Spell Catastrophe or adds D20E to Spell Defense"
+      },
+      "skill_rolls": {
+        "type": "skill_auto_success",
+        "description": "Skill Succeeds Regardless of Opposing Roll"
+      },
+      "ranged_defense": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_defense",
+            "options": [
+              "flawless",
+              "legendary"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D20E",
+            "target": "defense"
+          }
+        ],
+        "description": "Possible Flawless or Legendary Defense or Add D20E to Defense"
+      }
     },
     "29": {
-      "melee_attack": "Gain 1 Grit",
-      "ranged_attack": "Gain 1 Grit",
-      "melee_defense": "Gain 1 Grit",
-      "arcane_spell_attack": "Gain 1 Grit",
-      "arcane_spell_defense": "Gain 1 Grit",
-      "skill_rolls": "Gain 1 Grit"
+      "melee_attack": {
+        "type": "gain_grit",
+        "amount": 1,
+        "description": "Gain 1 Grit"
+      },
+      "ranged_attack": {
+        "type": "gain_grit",
+        "amount": 1,
+        "description": "Gain 1 Grit"
+      },
+      "melee_defense": {
+        "type": "gain_grit",
+        "amount": 1,
+        "description": "Gain 1 Grit"
+      },
+      "arcane_spell_attack": {
+        "type": "gain_grit",
+        "amount": 1,
+        "description": "Gain 1 Grit"
+      },
+      "arcane_spell_defense": {
+        "type": "gain_grit",
+        "amount": 1,
+        "description": "Gain 1 Grit"
+      },
+      "skill_rolls": {
+        "type": "gain_grit",
+        "amount": 1,
+        "description": "Gain 1 Grit"
+      },
+      "ranged_defense": {
+        "type": "gain_grit",
+        "amount": 1,
+        "description": "Gain 1 Grit"
+      }
     },
     "28": {
-      "melee_attack": "Shield Destruction",
-      "ranged_attack": "empty",
-      "melee_defense": "empty",
-      "arcane_spell_attack": "empty",
-      "arcane_spell_defense": "empty",
-      "skill_rolls": "empty"
+      "melee_attack": {
+        "type": "shield_destruction",
+        "description": "Shield Destruction"
+      }
     },
     "27": {
-      "melee_attack": "Granted D6 (1-6) Attack Modifier for This Melee Attack",
-      "ranged_attack": "Granted D6 (1-6) Attack Modifier for This Ranged Attack",
-      "melee_defense": "Granted 1 Luck dice for Use in This Combat Only",
-      "arcane_spell_attack": "No Spell Lethargy the Aether Approves of Characters Efforts",
-      "arcane_spell_defense": "Caster Suffers Severe pain and will be under a flash of pain for 1D6E seconds",
-      "skill_rolls": "empty"
+      "melee_attack": {
+        "type": "bonus_dice",
+        "dice": "D6",
+        "target": "attack",
+        "description": "Granted D6 (1-6) Attack Modifier for This Melee Attack"
+      },
+      "ranged_attack": {
+        "type": "bonus_dice",
+        "dice": "D6",
+        "target": "attack",
+        "description": "Granted D6 (1-6) Attack Modifier for This Ranged Attack"
+      },
+      "melee_defense": {
+        "type": "luck_die",
+        "scope": "combat",
+        "description": "Granted 1 Luck dice for Use in This Combat Only"
+      },
+      "arcane_spell_attack": {
+        "type": "no_lethargy",
+        "description": "No Spell Lethargy the Aether Approves of Characters Efforts"
+      },
+      "arcane_spell_defense": {
+        "type": "flash_of_pain",
+        "duration_dice": "1D6E",
+        "target": "caster",
+        "description": "Caster Suffers Severe pain and will be under a flash of pain for 1D6E seconds"
+      },
+      "ranged_defense": {
+        "type": "luck_die",
+        "scope": "combat",
+        "description": "Granted 1 Luck dice for Use in This Combat Only"
+      }
     },
     "26": {
-      "melee_attack": "Shield Destruction",
-      "ranged_attack": "empty",
-      "melee_defense": "empty",
-      "arcane_spell_attack": "empty",
-      "arcane_spell_defense": "empty",
-      "skill_rolls": "empty"
+      "melee_attack": {
+        "type": "shield_destruction",
+        "description": "Shield Destruction"
+      }
     },
     "25": {
-      "melee_attack": "empty",
-      "ranged_attack": "empty",
-      "melee_defense": "empty",
-      "arcane_spell_attack": "empty",
-      "arcane_spell_defense": "empty",
-      "skill_rolls": "Add 1 to Skill Roll"
+      "skill_rolls": {
+        "type": "bonus_flat",
+        "amount": 1,
+        "target": "skill",
+        "description": "Add 1 to Skill Roll"
+      }
     },
     "21": {
-      "melee_attack": "Hit Inflicts Flash of Pain 1D6E seconds",
-      "ranged_attack": "Hit Inflicts Flash of Pain 1D6E seconds",
-      "melee_defense": "Defender Recovers or ignores any flash of pain",
-      "arcane_spell_attack": "Magical Damage inflicts Flash of pain 1D6E seconds",
-      "arcane_spell_defense": "Caster Suffers Severe pain and will be under a flash of pain for 1D6E seconds",
-      "skill_rolls": "Granted D6 (1-6) Skill Modifier for this Skill Attempt"
+      "melee_attack": {
+        "type": "flash_of_pain",
+        "duration_dice": "1D6E",
+        "target": "defender",
+        "description": "Hit Inflicts Flash of Pain 1D6E seconds"
+      },
+      "ranged_attack": {
+        "type": "flash_of_pain",
+        "duration_dice": "1D6E",
+        "target": "defender",
+        "description": "Hit Inflicts Flash of Pain 1D6E seconds"
+      },
+      "melee_defense": {
+        "type": "recover_pain",
+        "description": "Defender Recovers or ignores any flash of pain"
+      },
+      "arcane_spell_attack": {
+        "type": "flash_of_pain",
+        "duration_dice": "1D6E",
+        "target": "defender",
+        "description": "Magical Damage inflicts Flash of pain 1D6E seconds"
+      },
+      "arcane_spell_defense": {
+        "type": "flash_of_pain",
+        "duration_dice": "1D6E",
+        "target": "caster",
+        "description": "Caster Suffers Severe pain and will be under a flash of pain for 1D6E seconds"
+      },
+      "skill_rolls": {
+        "type": "bonus_dice",
+        "dice": "D6",
+        "target": "skill",
+        "description": "Granted D6 (1-6) Skill Modifier for this Skill Attempt"
+      },
+      "ranged_defense": {
+        "type": "recover_pain",
+        "description": "Defender Recovers or ignores any flash of pain"
+      }
     },
     "20": {
-      "melee_attack": "Possible Vicious Strike or Add D12 to attack",
-      "ranged_attack": "Possible Vicious Strike or add D12 to attack",
-      "melee_defense": "Possible 20/20 defense that avoids Any Attack Except a Lethal Strike or adds D12 to defense",
-      "arcane_spell_attack": "Possible Vicious Application of a Magical Attack or add D12 to attack",
-      "arcane_spell_defense": "Possible 20/20 Spell defense that Saves Against Any Magical Attack Except a Lethal Magical Strike or add D12 to defense",
-      "skill_rolls": "20 Added to Skill Roll"
+      "melee_attack": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_strike",
+            "options": [
+              "vicious"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D12",
+            "target": "attack"
+          }
+        ],
+        "description": "Possible Vicious Strike or Add D12 to attack"
+      },
+      "ranged_attack": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_strike",
+            "options": [
+              "vicious"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D12",
+            "target": "attack"
+          }
+        ],
+        "description": "Possible Vicious Strike or add D12 to attack"
+      },
+      "melee_defense": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_defense",
+            "options": [
+              "perfect"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D12",
+            "target": "defense"
+          }
+        ],
+        "description": "Possible 20/20 defense that avoids Any Attack Except a Lethal Strike or adds D12 to defense"
+      },
+      "arcane_spell_attack": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_strike",
+            "options": [
+              "vicious_magical"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D12",
+            "target": "spell_attack"
+          }
+        ],
+        "description": "Possible Vicious Application of a Magical Attack or add D12 to attack"
+      },
+      "arcane_spell_defense": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_defense",
+            "options": [
+              "perfect_spell"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D12",
+            "target": "spell_defense"
+          }
+        ],
+        "description": "Possible 20/20 Spell defense that Saves Against Any Magical Attack Except a Lethal Magical Strike or add D12 to defense"
+      },
+      "skill_rolls": {
+        "type": "bonus_flat",
+        "amount": 20,
+        "target": "skill",
+        "description": "20 Added to Skill Roll"
+      },
+      "ranged_defense": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_defense",
+            "options": [
+              "perfect"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D12",
+            "target": "defense"
+          }
+        ],
+        "description": "Possible 20/20 defense that avoids Any Attack Except a Lethal Strike or adds D12 to defense"
+      }
     },
     "15": {
-      "melee_attack": "Bleed, Knock-back on Hit",
-      "ranged_attack": "Bleed",
-      "melee_defense": "Kick, Punch or Shield Bash",
-      "arcane_spell_attack": "empty",
-      "arcane_spell_defense": "empty",
-      "skill_rolls": "Add 1 to Skill Roll"
-    },
-    "13": {
-      "melee_attack": "empty",
-      "ranged_attack": "empty",
-      "melee_defense": "empty",
-      "arcane_spell_attack": "empty",
-      "arcane_spell_defense": "empty",
-      "skill_rolls": "empty"
+      "melee_attack": {
+        "type": "combo",
+        "effects": [
+          {
+            "type": "bleed"
+          },
+          {
+            "type": "knockback"
+          }
+        ],
+        "description": "Bleed, Knock-back on Hit"
+      },
+      "ranged_attack": {
+        "type": "bleed",
+        "description": "Bleed"
+      },
+      "melee_defense": {
+        "type": "counter_attack",
+        "options": [
+          "kick",
+          "punch",
+          "shield_bash"
+        ],
+        "description": "Kick, Punch or Shield Bash"
+      },
+      "skill_rolls": {
+        "type": "bonus_flat",
+        "amount": 1,
+        "target": "skill",
+        "description": "Add 1 to Skill Roll"
+      },
+      "ranged_defense": {
+        "type": "counter_attack",
+        "options": [
+          "kick",
+          "punch",
+          "shield_bash"
+        ],
+        "description": "Kick, Punch or Shield Bash"
+      }
     },
+    "13": {},
     "11": {
-      "melee_attack": "Flurry Attack or Hit to Miss",
-      "ranged_attack": "Roll 2x Damage Dice",
-      "melee_defense": "empty",
-      "arcane_spell_attack": "empty",
-      "arcane_spell_defense": "empty",
-      "skill_rolls": "empty"
+      "melee_attack": {
+        "type": "flurry",
+        "condition": "hit_or_miss",
+        "description": "Flurry Attack or Hit to Miss"
+      },
+      "ranged_attack": {
+        "type": "double_damage_dice",
+        "description": "Roll 2x Damage Dice"
+      }
     },
     "10": {
-      "melee_attack": "Bleed, Knock-back on Hit",
-      "ranged_attack": "Bleed",
-      "melee_defense": "Kick, Punch or Shield Bash",
-      "arcane_spell_attack": "empty",
-      "arcane_spell_defense": "empty",
-      "skill_rolls": "Add 1 to Skill Roll"
+      "melee_attack": {
+        "type": "combo",
+        "effects": [
+          {
+            "type": "bleed"
+          },
+          {
+            "type": "knockback"
+          }
+        ],
+        "description": "Bleed, Knock-back on Hit"
+      },
+      "ranged_attack": {
+        "type": "bleed",
+        "description": "Bleed"
+      },
+      "melee_defense": {
+        "type": "counter_attack",
+        "options": [
+          "kick",
+          "punch",
+          "shield_bash"
+        ],
+        "description": "Kick, Punch or Shield Bash"
+      },
+      "skill_rolls": {
+        "type": "bonus_flat",
+        "amount": 1,
+        "target": "skill",
+        "description": "Add 1 to Skill Roll"
+      },
+      "ranged_defense": {
+        "type": "counter_attack",
+        "options": [
+          "kick",
+          "punch",
+          "shield_bash"
+        ],
+        "description": "Kick, Punch or Shield Bash"
+      }
     },
     "8": {
-      "melee_attack": "Mulligan, Can Choose to Re-roll This Attack",
-      "ranged_attack": "Mulligan, Can Choose to Re-Roll This Attack",
-      "melee_defense": "Mulligan, Can Choose to Re-Roll This Defense",
-      "arcane_spell_attack": "Mulligan, Can Re-Roll This Spell Attack",
-      "arcane_spell_defense": "Mulligan, Can Re-Roll This Spell Defense",
-      "skill_rolls": "Mulligan, Can Re-Roll This Skill roll"
+      "melee_attack": {
+        "type": "mulligan",
+        "description": "Mulligan, Can Choose to Re-roll This Attack"
+      },
+      "ranged_attack": {
+        "type": "mulligan",
+        "description": "Mulligan, Can Choose to Re-Roll This Attack"
+      },
+      "melee_defense": {
+        "type": "mulligan",
+        "description": "Mulligan, Can Choose to Re-Roll This Defense"
+      },
+      "arcane_spell_attack": {
+        "type": "mulligan",
+        "description": "Mulligan, Can Re-Roll This Spell Attack"
+      },
+      "arcane_spell_defense": {
+        "type": "mulligan",
+        "description": "Mulligan, Can Re-Roll This Spell Defense"
+      },
+      "skill_rolls": {
+        "type": "mulligan",
+        "description": "Mulligan, Can Re-Roll This Skill roll"
+      },
+      "ranged_defense": {
+        "type": "mulligan",
+        "description": "Mulligan, Can Choose to Re-Roll This Defense"
+      }
     },
     "7": {
-      "melee_attack": "Flurry Attack on Hit or Miss",
-      "ranged_attack": "Roll 2x Damage Dice",
-      "melee_defense": "empty",
-      "arcane_spell_attack": "empty",
-      "arcane_spell_defense": "empty",
-      "skill_rolls": "empty"
+      "melee_attack": {
+        "type": "flurry",
+        "condition": "hit_or_miss",
+        "description": "Flurry Attack on Hit or Miss"
+      },
+      "ranged_attack": {
+        "type": "double_damage_dice",
+        "description": "Roll 2x Damage Dice"
+      }
     },
     "5": {
-      "melee_attack": "Bleed, Knock-back on Hit",
-      "ranged_attack": "Bleed",
-      "melee_defense": "Kick, Punch, or Shield Bash",
-      "arcane_spell_attack": "empty",
-      "arcane_spell_defense": "empty",
-      "skill_rolls": "Add 1 to Skill Roll"
+      "melee_attack": {
+        "type": "combo",
+        "effects": [
+          {
+            "type": "bleed"
+          },
+          {
+            "type": "knockback"
+          }
+        ],
+        "description": "Bleed, Knock-back on Hit"
+      },
+      "ranged_attack": {
+        "type": "bleed",
+        "description": "Bleed"
+      },
+      "melee_defense": {
+        "type": "counter_attack",
+        "options": [
+          "kick",
+          "punch",
+          "shield_bash"
+        ],
+        "description": "Kick, Punch, or Shield Bash"
+      },
+      "skill_rolls": {
+        "type": "bonus_flat",
+        "amount": 1,
+        "target": "skill",
+        "description": "Add 1 to Skill Roll"
+      },
+      "ranged_defense": {
+        "type": "counter_attack",
+        "options": [
+          "kick",
+          "punch",
+          "shield_bash"
+        ],
+        "description": "Kick, Punch, or Shield Bash"
+      }
     },
     "3": {
-      "melee_attack": "Triple Damage",
-      "ranged_attack": "Triple Damage",
-      "melee_defense": "DR Tripled including Shield",
-      "arcane_spell_attack": "Triple Damage on Spell Damage",
-      "arcane_spell_defense": "D12 Added to Spell Defense Modifier",
-      "skill_rolls": "empty"
+      "melee_attack": {
+        "type": "damage_multiplier",
+        "multiplier": 3,
+        "description": "Triple Damage"
+      },
+      "ranged_attack": {
+        "type": "damage_multiplier",
+        "multiplier": 3,
+        "description": "Triple Damage"
+      },
+      "melee_defense": {
+        "type": "dr_multiplier",
+        "multiplier": 3,
+        "includes_shield": true,
+        "description": "DR Tripled including Shield"
+      },
+      "arcane_spell_attack": {
+        "type": "damage_multiplier",
+        "multiplier": 3,
+        "description": "Triple Damage on Spell Damage"
+      },
+      "arcane_spell_defense": {
+        "type": "bonus_dice",
+        "dice": "D12",
+        "target": "spell_defense",
+        "description": "D12 Added to Spell Defense Modifier"
+      },
+      "ranged_defense": {
+        "type": "dr_multiplier",
+        "multiplier": 3,
+        "includes_shield": true,
+        "description": "DR Tripled including Shield"
+      }
     },
     "2": {
-      "melee_attack": "Double Damage",
-      "ranged_attack": "Double Damage",
-      "melee_defense": "DR Doubled including Shield",
-      "arcane_spell_attack": "Double Damage on Spell Damage",
-      "arcane_spell_defense": "D6 Added to Spell Defense Modifier",
-      "skill_rolls": "empty"
+      "melee_attack": {
+        "type": "damage_multiplier",
+        "multiplier": 2,
+        "description": "Double Damage"
+      },
+      "ranged_attack": {
+        "type": "damage_multiplier",
+        "multiplier": 2,
+        "description": "Double Damage"
+      },
+      "melee_defense": {
+        "type": "dr_multiplier",
+        "multiplier": 2,
+        "includes_shield": true,
+        "description": "DR Doubled including Shield"
+      },
+      "arcane_spell_attack": {
+        "type": "damage_multiplier",
+        "multiplier": 2,
+        "description": "Double Damage on Spell Damage"
+      },
+      "arcane_spell_defense": {
+        "type": "bonus_dice",
+        "dice": "D6",
+        "target": "spell_defense",
+        "description": "D6 Added to Spell Defense Modifier"
+      },
+      "ranged_defense": {
+        "type": "dr_multiplier",
+        "multiplier": 2,
+        "includes_shield": true,
+        "description": "DR Doubled including Shield"
+      }
     },
     "1": {
-      "melee_attack": "empty",
-      "ranged_attack": "Possible Fumble Ranged ammo is broken unrecoverable",
-      "melee_defense": "empty",
-      "arcane_spell_attack": "Possible Spell Calamity or Catastrophe",
-      "arcane_spell_defense": "empty",
-      "skill_rolls": "empty"
+      "ranged_attack": {
+        "type": "fumble",
+        "detail": "ranged_ammo_broken",
+        "description": "Possible Fumble Ranged ammo is broken unrecoverable"
+      },
+      "arcane_spell_attack": {
+        "type": "spell_calamity",
+        "description": "Possible Spell Calamity or Catastrophe"
+      }
     }
   },
   "definitions": {
@@ -151,4 +618,4 @@
     "matching_30s": "Matching 30s on skill rolls cancel each other out and is resolved by the skill roll.",
     "skill_roll_30": "A 30 on a skill roll indicates success at highest level of the skill involved."
   }
-}
+}

module/config/system.mjs

@@ -193,6 +193,7 @@ export const DICE_VALUES = {
 export const CHARACTERISTIC_ATTACK = ["str", "int", "wis", "dex"]
 export const CHARACTERISTIC_RANGED_ATTACK = ["int", "wis", "dex"]
 export const CHARACTERISTIC_DEFENSE = ["int", "wis", "dex"]
+export const CHARACTERISTIC_RANGED_DEFENSE = ["int", "wis", "dex"]
 export const CHARACTERISTIC_DAMAGE = ["str"]
 
 export const DEFENSE_DICE_VALUES = {
@@ -304,6 +305,7 @@ export const SYSTEM = {
   CHARACTERISTIC_ATTACK,
   CHARACTERISTIC_RANGED_ATTACK,
   CHARACTERISTIC_DEFENSE,
+  CHARACTERISTIC_RANGED_DEFENSE,
   CHARACTERISTIC_DAMAGE,
   INITIATIVE_DICE_CHOICES_PER_CLASS,
   CHAR_CLASSES,

module/documents/actor.mjs

@@ -198,6 +198,22 @@ export default class LethalFantasyActor extends Actor {
       case "miracle-power":
         rollTarget = this.items.find((i) => (i.type === "miracle" || i.type == "spell") && i.id === rollKey)
         rollTarget.rollKey = rollKey
+        if (rollType === "spell-attack" || rollType === "spell-power") {
+          const cost = Number(rollTarget.system?.cost) || 0
+          const currentAether = Number(this.system.aetherPoints?.value) || 0
+          if (cost > currentAether) {
+            ui.notifications.warn(`${this.name} cannot cast ${rollTarget.name}: insufficient Aether (needs ${cost}, has ${currentAether}).`)
+            return
+          }
+        }
+        if (rollType === "miracle-attack" || rollType === "miracle-power") {
+          const cost = Number(rollTarget.system?.level) || 0
+          const currentGrace = Number(this.system.divinityPoints?.value) || 0
+          if (cost > currentGrace) {
+            ui.notifications.warn(`${this.name} cannot invoke ${rollTarget.name}: insufficient Grace (needs ${cost}, has ${currentGrace}).`)
+            return
+          }
+        }
         break
       case "shield-roll": {
         rollTarget = this.items.find((i) => i.type === "shield" && i.id === rollKey)
@@ -256,12 +272,14 @@ export default class LethalFantasyActor extends Actor {
         if (rollType === "weapon-defense") {
           rollTarget.armorDefense = this.getArmorDefenseValue()
           rollTarget.grantedDice = this.system.granted.defenseDice
+          // Check if this is a ranged defense
+          rollTarget.isRangedDefense = game.lethalFantasy?.nextDefenseData?.isRanged ?? false
         }
       }
         break
       default:
         ui.notifications.error(game.i18n.localize("LETHALFANTASY.Notifications.rollTypeNotFound") + String(rollType))
-        break
+        return
     }
 
     // In all cases

module/documents/d30-roll.mjs

@@ -22,6 +22,7 @@ export default class D30Roll {
     MELEE_ATTACK: "melee_attack",
     RANGED_ATTACK: "ranged_attack",
     MELEE_DEFENSE: "melee_defense",
+    RANGED_DEFENSE: "ranged_defense",
     ARCANE_SPELL_ATTACK: "arcane_spell_attack",
     ARCANE_SPELL_DEFENSE: "arcane_spell_defense",
     SKILL_ROLLS: "skill_rolls"
@@ -47,26 +48,26 @@ export default class D30Roll {
   }
 
   /**
-   * Récupère le résultat d'un jet de D30
+   * Récupère le résultat d'un jet de D30 sous forme d'objet structuré.
    * @param {number} diceValue La valeur du dé (1-30)
    * @param {string} rollType Le type de jet externe (ex: "weapon-attack", "spell-attack", etc.)
    * @param {Object} weapon L'arme ou l'objet utilisé (optionnel, nécessaire pour certains types)
-   * @returns {string|null} Le résultat correspondant ou null si vide/non trouvé
+   * @param {Object} options Options supplémentaires (optionnel)
+   * @param {boolean} options.isRanged Si true, utilise ranged_defense au lieu de melee_defense
+   * @returns {Object|null} L'objet effet `{ type, description, ...fields }` ou null si aucun effet
    */
-  static getResult(diceValue, rollType, weapon = null) {
+  static getResult(diceValue, rollType, weapon = null, options = {}) {
     if (!this.resultsTable) {
       console.warn("D30Roll | Results table is not initialized. Call D30Roll.initialize() first.")
       return null
     }
 
-    // Validation des paramètres
     if (diceValue < 1 || diceValue > 30) {
       console.warn(`D30Roll | Invalid dice value: ${diceValue}. Must be between 1 and 30.`)
       return null
     }
 
-    // Convert external rollType to internal rollType
-    const internalType = this.convertToInternalType(rollType, weapon)
+    const internalType = this.convertToInternalType(rollType, weapon, options)
 
     if (!internalType) {
       console.warn(`D30Roll | Could not convert roll type: ${rollType}`)
@@ -85,22 +86,27 @@ export default class D30Roll {
     }
 
     const result = resultEntry[internalType]
+    return result ?? null
+  }
 
-    // Retourne null si le résultat est "empty"
-    if (result === "empty" || !result) {
-      return null
-    }
-
-    return result
+  /**
+   * Retourne le type d'effet d'un résultat D30.
+   * @param {Object|null} result L'objet retourné par getResult()
+   * @returns {string|null} Le type d'effet ou null
+   */
+  static getEffectType(result) {
+    return result?.type ?? null
   }
 
   /**
    * Convertit un rollType externe en rollType interne
    * @param {string} externalType Le type de jet externe (ex: "weapon-attack")
    * @param {Object} weapon L'arme ou l'objet utilisé (optionnel)
+   * @param {Object} options Options supplémentaires (optionnel)
+   * @param {boolean} options.isRanged Si true, utilise ranged_defense au lieu de melee_defense
    * @returns {string|null} Le type interne correspondant ou null
    */
-  static convertToInternalType(externalType, weapon = null) {
+  static convertToInternalType(externalType, weapon = null, options = {}) {
     // Attack types - need weapon to determine if melee or ranged
     if (externalType === "weapon-attack") {
       if (!weapon) {
@@ -123,7 +129,7 @@ export default class D30Roll {
 
     // Defense types
     if (externalType === "weapon-defense" || externalType === "monster-defense") {
-      return this.ROLL_TYPES.MELEE_DEFENSE
+      return options.isRanged ? this.ROLL_TYPES.RANGED_DEFENSE : this.ROLL_TYPES.MELEE_DEFENSE
     }
 
     // Spell types
@@ -177,11 +183,11 @@ export default class D30Roll {
 
   /**
    * Vérifie si un résultat est vide
-   * @param {string} result Le résultat à vérifier
+   * @param {Object|null} result Le résultat à vérifier
    * @returns {boolean} True si le résultat est vide
    */
   static isEmptyResult(result) {
-    return !result || result === "empty"
+    return !result || !result.type
   }
 
   /**
@@ -189,11 +195,12 @@ export default class D30Roll {
    * @param {number} diceValue La valeur du dé (1-30)
    * @param {string} rollType Le type de jet externe
    * @param {Object} weapon L'arme ou l'objet utilisé (optionnel)
+   * @param {Object} options Options supplémentaires (optionnel)
    * @returns {Object} Un objet avec le résultat et des informations de formatage
    */
-  static getFormattedResult(diceValue, rollType, weapon = null) {
-    const result = this.getResult(diceValue, rollType, weapon)
-    const internalType = this.convertToInternalType(rollType, weapon)
+  static getFormattedResult(diceValue, rollType, weapon = null, options = {}) {
+    const result = this.getResult(diceValue, rollType, weapon, options)
+    const internalType = this.convertToInternalType(rollType, weapon, options)
 
     return {
       value: diceValue,

module/documents/roll.mjs

@@ -182,6 +182,7 @@ export default class LethalFantasyRoll extends Roll {
       } else {
         options.rollTarget.value = options.rollTarget.defenseModifier
         options.rollTarget.charModifier = 0
+        options.isRangedDefense = options.rollTarget.isRangedDefense ?? false
       }
 
     } else if (options.rollType === "monster-skill") {
@@ -219,8 +220,14 @@ export default class LethalFantasyRoll extends Roll {
           options.rollTarget.charModifier = options.rollTarget.combat.rangedAttackModifier
         }
       } else {
-        options.rollTarget.value = options.rollTarget.combat.defenseModifier + options.rollTarget.weaponSkillModifier + options.rollTarget.weapon.system.bonuses.defenseBonus + options.rollTarget.armorDefense
-        options.rollTarget.charModifier = options.rollTarget.combat.defenseModifier
+        // For defense, check if it's a ranged defense
+        const defenseModifier = options.rollTarget.isRangedDefense
+          ? options.rollTarget.combat.rangedDefenseModifier
+          : options.rollTarget.combat.defenseModifier
+        options.rollTarget.value = defenseModifier + options.rollTarget.weaponSkillModifier + options.rollTarget.weapon.system.bonuses.defenseBonus + options.rollTarget.armorDefense
+        options.rollTarget.charModifier = defenseModifier
+        // Store isRanged flag for D30 lookup
+        options.isRangedDefense = options.rollTarget.isRangedDefense
       }
 
     } else if (options.rollType === "spell" || options.rollType === "spell-attack" || options.rollType === "spell-power") {
@@ -265,6 +272,7 @@ export default class LethalFantasyRoll extends Roll {
       hasChangeDice = false
       hasMaxValue = false
       hasExplode = false
+      hasFavor = true
       options.rollTarget.value = 0
 
     } else if (options.rollType.includes("weapon-damage")) {
@@ -282,7 +290,11 @@ export default class LethalFantasyRoll extends Roll {
         options.damageMedium = true
         dice = options.rollTarget.weapon.system.damage.damageM
       }
-      dice = dice.replace("E", "")
+      if (/NE$/i.test(dice)) {
+        hasMaxValue = false
+        hasExplode = false
+      }
+      dice = dice.replace(/NE$/i, "").replace("E", "")
       baseFormula = dice
 
     } else if (options.rollType.includes("monster-damage")) {
@@ -295,6 +307,10 @@ export default class LethalFantasyRoll extends Roll {
       dice = options.rollTarget.damageDice
       dice = dice.replace("E", "")
       baseFormula = dice
+      if (options.rollTarget.noExplode) {
+        hasMaxValue = false
+        hasExplode = false
+      }
     }
 
 
@@ -304,8 +320,8 @@ export default class LethalFantasyRoll extends Roll {
       hasModifier = false
     }
 
-    const rollModes = foundry.utils.duplicate(CONFIG.Dice.rollModes); // v12 : Object.fromEntries(Object.entries(CONFIG.Dice.rollModes).map(([key, value]) => [key, game.i18n.localize(value)]))
-    console.log("Roll mode", rollModes)
+    const rollModes = foundry.utils.duplicate(CONFIG.ChatMessage.modes);
+
 
     const fieldRollMode = new foundry.data.fields.StringField({
       choices: rollModes,
@@ -354,7 +370,9 @@ export default class LethalFantasyRoll extends Roll {
       beyondSkill = !!rollContext.beyondSkill
       letItFly = !!rollContext.letItFly
       saveSpell = !!rollContext.saveSpell
-      rollContext.visibility ||= rollContext.rollMode || game.settings.get("core", "rollMode")
+      const _rawMode = rollContext.rollMode || game.settings.get("core", "rollMode")
+      const _modeMap = { publicroll: "public", gmroll: "gm", blindroll: "blind", selfroll: "self" }
+      rollContext.visibility ||= _modeMap[_rawMode] ?? _rawMode ?? "public"
       rollContext.modifier ||= modifier
       rollContext.favor ||= "none"
       rollContext.changeDice ||= `${dice}`
@@ -490,7 +508,8 @@ export default class LethalFantasyRoll extends Roll {
       rollContext.favor = "none"
     }
 
-    maxValue = Number(baseFormula.match(/\d+$/)[0]) // Update the max value agains
+    const maxMatch = baseFormula ? baseFormula.match(/\d+$/) : null
+    maxValue = maxMatch ? Number(maxMatch[0]) : 0
 
     const rollData = {
       type: options.rollType,
@@ -577,7 +596,8 @@ export default class LethalFantasyRoll extends Roll {
       const d30Message = D30Roll.getResult(
         rollD30.total,
         options.rollType,
-        options.rollTarget?.weapon
+        options.rollTarget?.weapon,
+        { isRanged: options.isRangedDefense }
       )
       options.D30message = d30Message
     }
@@ -658,7 +678,7 @@ export default class LethalFantasyRoll extends Roll {
 
   /* ***********************************************************/
   static async promptInitiative(options = {}) {
-    const rollModes = foundry.utils.duplicate(CONFIG.Dice.rollModes); // v12 :  Object.fromEntries(Object.entries(CONFIG.Dice.rollModes).map(([key, value]) => [key, game.i18n.localize(value)]))
+    const rollModes = foundry.utils.duplicate(CONFIG.ChatMessage.modes); // v12 :  Object.fromEntries(Object.entries(CONFIG.Dice.rollModes).map(([key, value]) => [key, game.i18n.localize(value)]))
     const fieldRollMode = new foundry.data.fields.StringField({
       choices: rollModes,
       blank: false,
@@ -712,7 +732,7 @@ export default class LethalFantasyRoll extends Roll {
 
     let initRoll = new Roll(formula, options.data)
     await initRoll.evaluate()
-    let msg = await initRoll.toMessage({ flavor: `Initiative for ${options.actorName}` }, { rollMode: rollContext.visibility })
+    let msg = await initRoll.toMessage({ flavor: `Initiative for ${options.actorName}` }, { messageMode: rollContext.visibility })
     if (game?.dice3d && initRoll.dice?.length) {
       await game.dice3d.waitFor3DAnimationByMessageID(msg.id)
     }
@@ -726,7 +746,7 @@ export default class LethalFantasyRoll extends Roll {
   /* ***********************************************************/
   static async promptCombatAction(options = {}) {
 
-    const rollModes = foundry.utils.duplicate(CONFIG.Dice.rollModes); // v12 : Object.fromEntries(Object.entries(CONFIG.Dice.rollModes).map(([key, value]) => [key, game.i18n.localize(value)]))
+    const rollModes = foundry.utils.duplicate(CONFIG.ChatMessage.modes); // v12 : Object.fromEntries(Object.entries(CONFIG.Dice.rollModes).map(([key, value]) => [key, game.i18n.localize(value)]))
     const fieldRollMode = new foundry.data.fields.StringField({
       choices: rollModes,
       blank: false,
@@ -983,7 +1003,7 @@ export default class LethalFantasyRoll extends Roll {
 
         let max = roll.dice[0].faces - 1
         max = Math.min(currentAction.progressionCount, max)
-        let msg = await roll.toMessage({ flavor: `Progression Roll for ${currentAction.name}, progression count : ${currentAction.progressionCount}/${max}` }, { rollMode: rollContext.visibility })
+        let msg = await roll.toMessage({ flavor: `Progression Roll for ${currentAction.name}, progression count : ${currentAction.progressionCount}/${max}` }, { messageMode: rollContext.visibility })
         if (game?.dice3d) {
           await game.dice3d.waitFor3DAnimationByMessageID(msg.id)
         }
@@ -1025,7 +1045,7 @@ export default class LethalFantasyRoll extends Roll {
   /* ***********************************************************/
   static async promptRangedDefense(options = {}) {
 
-    const rollModes = foundry.utils.duplicate(CONFIG.Dice.rollModes);
+    const rollModes = foundry.utils.duplicate(CONFIG.ChatMessage.modes);
     const fieldRollMode = new foundry.data.fields.StringField({
       choices: rollModes,
       blank: false,
@@ -1105,6 +1125,7 @@ export default class LethalFantasyRoll extends Roll {
     // Merge rollContext object into options object
     options = { ...options, ...rollContext }
     options.rollName = "Ranged Defense"
+    options.rollType = "weapon-defense"
 
     const rollBase = new this(rollContext.movement, options.data, rollData)
     const rollModifier = new Roll(modifierFormula, options.data, rollData)
@@ -1112,6 +1133,7 @@ export default class LethalFantasyRoll extends Roll {
     await rollBase.evaluate()
     let rollD30 = await new Roll("1D30").evaluate()
     options.D30result = rollD30.total
+    options.D30message = D30Roll.getResult(rollD30.total, options.rollType, options.rollTarget?.weapon, { isRanged: true })
 
     let badResult = 0
     if (rollContext.movement.includes("kh")) {
@@ -1154,6 +1176,7 @@ export default class LethalFantasyRoll extends Roll {
     rollBase.options.rollTarget = options.rollTarget
     rollBase.options.titleFormula = `1D20E + ${modifierFormula}`
     rollBase.options.D30result = options.D30result
+    rollBase.options.D30message = options.D30message
     rollBase.options.rollName = "Ranged Defense"
     rollBase.options.badResult = badResult
     rollBase.options.rollData = foundry.utils.duplicate(rollData)
@@ -1311,11 +1334,11 @@ export default class LethalFantasyRoll extends Roll {
    *
    * @param {Object} [messageData={}] Additional data to include in the message.
    * @param {Object} options Options for message creation.
-   * @param {string} options.rollMode The mode of the roll (e.g., public, private).
+   * @param {string} options.messageMode The mode of the roll (e.g., public, private).
    * @param {boolean} [options.create=true] Whether to create the message.
    * @returns {Promise} - A promise that resolves when the message is created.
    */
-  async toMessage(messageData = {}, { rollMode, create = true } = {}) {
+  async toMessage(messageData = {}, { messageMode, create = true } = {}) {
     return await super.toMessage(
       {
         isSave: this.isSave,
@@ -1333,7 +1356,7 @@ export default class LethalFantasyRoll extends Roll {
         rollData: this.rollData,
         ...messageData,
       },
-      { rollMode, create },
+      { messageMode, create },
     )
   }
 

module/models/character.mjs

@@ -152,6 +152,7 @@ export default class LethalFantasyCharacter extends foundry.abstract.TypeDataMod
       attackModifier: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
       rangedAttackModifier: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
       defenseModifier: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      rangedDefenseModifier: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
       defenseBonus: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
       damageModifier: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
       armorHitPoints: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
@@ -259,6 +260,12 @@ export default class LethalFantasyCharacter extends foundry.abstract.TypeDataMod
       this.combat.defenseModifier += chaDef.defense
     }
 
+    this.combat.rangedDefenseModifier = this.combat.defenseBonus
+    for (let chaKey of SYSTEM.CHARACTERISTIC_RANGED_DEFENSE) {
+      let chaDef = SYSTEM.CHARACTERISTICS_TABLES[chaKey].find(s => s.value === this.characteristics[chaKey].value)
+      this.combat.rangedDefenseModifier += chaDef.defense
+    }
+
     this.combat.damageModifier = 0
     for (let chaKey of SYSTEM.CHARACTERISTIC_DAMAGE) {
       let chaDef = SYSTEM.CHARACTERISTICS_TABLES[chaKey].find(s => s.value === this.characteristics[chaKey].value)
@@ -290,7 +297,7 @@ export default class LethalFantasyCharacter extends foundry.abstract.TypeDataMod
     })
     if (!roll) return null
 
-    await roll.toMessage({}, { rollMode: roll.options.rollMode })
+    await roll.toMessage({}, { messageMode: roll.options.rollMode })
   }
 
   async rollInitiative(combatId = undefined, combatantId = undefined) {
@@ -311,7 +318,7 @@ export default class LethalFantasyCharacter extends foundry.abstract.TypeDataMod
     })
     if (!roll) return null
 
-    await roll.toMessage({}, { rollMode: roll.options.rollMode })
+    await roll.toMessage({}, { messageMode: roll.options.rollMode })
   }
 
   async rollProgressionDice(combatId, combatantId, rollProgressionCount) {
@@ -349,6 +356,11 @@ export default class LethalFantasyCharacter extends foundry.abstract.TypeDataMod
       }
     }
 
+    if (weaponsChoices.length === 0) {
+      ui.notifications.warn(`${this.parent.name} has no weapons or spells available for combat. Add a weapon to the character sheet first.`)
+      return
+    }
+
     let roll = await LethalFantasyRoll.promptCombatAction({
       actorId: this.parent.id,
       actorName: this.parent.name,

module/models/miracle.mjs

@@ -35,6 +35,9 @@ export default class LethalFantasyMiracle extends foundry.abstract.TypeDataModel
 
     schema.attackRoll = new fields.StringField({ required: true, initial: "" })
     schema.powerRoll = new fields.StringField({ required: true, initial: "" })
+    schema.damageDice = new fields.StringField({ required: false, initial: "" })
+    schema.damageDiceOverpowered = new fields.StringField({ required: false, initial: "" })
+    schema.damageDiceOverpowered2 = new fields.StringField({ required: false, initial: "" })
 
     return schema
   }

module/models/monster.mjs

@@ -64,7 +64,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
       painDamage: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 })
     })
 
-    const attackField = (label) => {
+    const attackField = (label, initialNoExplode = false) => {
       const schema = {
         key: new fields.StringField({ required: true, nullable: false, initial: `attack${label}` }),
         name: new fields.StringField({ required: true, nullable: false, initial: `Attack ${label}` }),
@@ -74,6 +74,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
         damageDice: new fields.StringField({ required: true, nullable: false, initial: "1D6" }),
         damageModifier: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
         enabled: new fields.BooleanField({ initial: true, required: true, nullable: false }),
+        noExplode: new fields.BooleanField({ initial: initialNoExplode, required: true, nullable: false }),
       }
       return new fields.SchemaField(schema, { label })
     }
@@ -123,10 +124,32 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
       shieldDefenseDice: new fields.StringField({ required: true, nullable: false, initial: "d4" })
     })
     schema.combatHTH = new fields.SchemaField({
-      attack1: attackField("1"),
-      attack2: attackField("2")
+      attack1: attackField("1", true),
+      attack2: attackField("2", true)
     })
 
+    schema.attackMode = new fields.StringField({
+      required: true,
+      nullable: false,
+      initial: "melee",
+      choices: { melee: "Melee", ranged: "Ranged" }
+    })
+
+    schema.rangedAttacks = new fields.SchemaField({
+      attack1: attackField("1"),
+      attack2: attackField("2"),
+      attack3: attackField("3"),
+      attack4: attackField("4")
+    })
+
+    schema.rangedWeaponRange = new fields.SchemaField({
+      pointBlank: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
+      short: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
+      medium: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
+      long: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
+      extreme: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
+      outOfSkill: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
+    })
 
     return schema
   }
@@ -157,7 +180,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
     })
     if (!roll) return null
 
-    await roll.toMessage({}, { rollMode: roll.options.rollMode })
+    await roll.toMessage({}, { messageMode: roll.options.rollMode })
   }
 
   async prepareMonsterRoll(rollType, rollKey, rollDice = undefined, tokenId = undefined, damageModifier = undefined, defenderId = undefined, defenderTokenId = undefined, extraShieldDr = 0) {
@@ -165,14 +188,20 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
     switch (rollType) {
       case "monster-attack":
       case "monster-defense":
-      case "monster-damage":
-        rollTarget = foundry.utils.duplicate(this.attacks[rollKey])
+      case "monster-damage": {
+        const attacksSet = this.attackMode === "ranged" ? this.rangedAttacks : this.attacks
+        rollTarget = foundry.utils.duplicate(attacksSet[rollKey])
         rollTarget.rollKey = rollKey
+        rollTarget.attackMode = this.attackMode
+        if (rollType === "monster-defense") {
+          rollTarget.isRangedDefense = game.lethalFantasy?.nextDefenseData?.isRanged ?? false
+        }
         // Si damageModifier est fourni (depuis le chat), l'utiliser au lieu de celui de la fiche
         if (damageModifier !== undefined && rollType === "monster-damage") {
           rollTarget.damageModifier = damageModifier
         }
         break
+      }
       case "monster-attack-hth":
       case "monster-defense-hth":
       case "monster-damage-hth":
@@ -204,7 +233,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
         await roll.toMessage({
           flavor,
           speaker: ChatMessage.getSpeaker({ actor: this.parent })
-        })
+        }, { messageMode: roll.options.rollMode ?? game.settings.get("core", "rollMode") })
         return
       }
       case "weapon-damage-small":
@@ -241,7 +270,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
           return
         }
         rollTarget = skill
-        rollTarget.weapon = weapon
+        rollTarget.weapon = foundry.utils.duplicate(weapon)
         rollTarget.weaponSkillModifier = skill.weaponSkillModifier
         rollTarget.rollKey = rollKey
         rollTarget.combat = foundry.utils.duplicate(this.combat)
@@ -255,7 +284,6 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
     // In all cases
     if (rollTarget) {
       rollTarget.tokenId = tokenId
-      console.log(rollTarget)
       await this.roll(rollType, rollTarget, defenderId, defenderTokenId, extraShieldDr)
     }
   }
@@ -276,7 +304,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
     })
     if (!roll) return null
 
-    await roll.toMessage({}, { rollMode: roll.options.rollMode })
+    await roll.toMessage({}, { messageMode: roll.options.rollMode })
   }
 
   async rollProgressionDice(combatId, combatantId) {
@@ -288,7 +316,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
       return
     }
 
-    const rollModes = foundry.utils.duplicate(CONFIG.Dice.rollModes)
+    const rollModes = foundry.utils.duplicate(CONFIG.ChatMessage.modes)
     const fieldRollMode = new foundry.data.fields.StringField({
       choices: rollModes,
       blank: false,
@@ -304,8 +332,9 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
     }
 
     let hasAttack = false
-    for (let key in this.attacks) {
-      let attack = this.attacks[key]
+    const attacksSet = this.attackMode === "ranged" ? this.rangedAttacks : this.attacks
+    for (let key in attacksSet) {
+      let attack = attacksSet[key]
       if (attack.enabled && attack.attackScore > 0 && attack.attackScore === roll.total) {
         hasAttack = true
         const messageContent = await foundry.applications.handlebars.renderTemplate(

module/models/spell.mjs

@@ -40,6 +40,8 @@ export default class LethalFantasySpell extends foundry.abstract.TypeDataModel {
     schema.attackRoll = new fields.StringField({ required: true, initial: "" })
     schema.powerRoll = new fields.StringField({ required: true, initial: "" })
     schema.damageDice = new fields.StringField({ required: false, initial: "" })
+    schema.damageDiceOverpowered = new fields.StringField({ required: false, initial: "" })
+    schema.damageDiceOverpowered2 = new fields.StringField({ required: false, initial: "" })
   
     return schema
   }

module/utils.mjs

@@ -304,7 +304,8 @@ export default class LethalFantasyUtils {
 
     // Pour les monstres, récupérer les attaques activées
     if (isMonster) {
-      const enabledAttacks = Object.entries(defender.system.attacks).filter(([key, attack]) => attack.enabled)
+      const attacksSet = defender.system.attackMode === "ranged" ? defender.system.rangedAttacks : defender.system.attacks
+      const enabledAttacks = Object.entries(attacksSet).filter(([key, attack]) => attack.enabled)
 
       if (enabledAttacks.length === 0) {
         ui.notifications.warn("No enabled attacks available for defense")
@@ -333,7 +334,7 @@ export default class LethalFantasyUtils {
 
       // Afficher le dialogue
       const result = await foundry.applications.api.DialogV2.wait({
-        window: { title: "Defense Roll" },
+        window: { title: msg.isRanged ? "Ranged Defense Roll" : "Defense Roll" },
         classes: ["lethalfantasy"],
         content,
         buttons: [
@@ -365,7 +366,8 @@ export default class LethalFantasyUtils {
           attackD30message,
           attackRerollContext,
           defenderId: defender.id,
-          defenderTokenId
+          defenderTokenId,
+          isRanged: msg.isRanged
         }
 
         defender.system.prepareMonsterRoll("monster-defense", result)
@@ -373,6 +375,37 @@ export default class LethalFantasyUtils {
       return
     }
 
+    // Pour les personnages, récupérer les armes équipées
+    // Si l'attaque est une attaque à distance, utiliser le dialogue de défense à distance
+    if (msg.isRanged) {
+      const { default: LethalFantasyRoll } = await import("./documents/roll.mjs")
+      const roll = await LethalFantasyRoll.promptRangedDefense({
+        actorId: defender.id,
+        actorName: defender.name,
+        actorImage: defender.img,
+      })
+      if (roll) {
+        game.lethalFantasy = game.lethalFantasy || {}
+        game.lethalFantasy.nextDefenseData = {
+          attackerId,
+          attackRoll,
+          attackerName,
+          defenderName,
+          attackWeaponId,
+          attackRollType,
+          attackRollKey,
+          attackD30result,
+          attackD30message,
+          attackRerollContext,
+          defenderId: defender.id,
+          defenderTokenId,
+          isRanged: true
+        }
+        await roll.toMessage({}, { messageMode: roll.options.rollMode })
+      }
+      return
+    }
+
     // Pour les personnages, récupérer les armes équipées
     const equippedWeapons = defender.items.filter(i =>
       i.type === "weapon" && i.system.equipped === true
@@ -437,7 +470,8 @@ export default class LethalFantasyUtils {
         attackD30message,
         attackRerollContext,
         defenderId: defender.id,
-        defenderTokenId
+        defenderTokenId,
+        isRanged: msg.isRanged
       }
 
       console.log("Storing defense data for character:", defender.id)
@@ -448,7 +482,7 @@ export default class LethalFantasyUtils {
 
   /* -------------------------------------------- */
   static hasD30Reroll(d30Message) {
-    return /mulligan|re-?roll/i.test(d30Message || "")
+    return d30Message?.type === "mulligan"
   }
 
   /* -------------------------------------------- */
@@ -828,20 +862,25 @@ export default class LethalFantasyUtils {
       } else if (data.attackRollType === "spell-attack" || data.attackRollType === "miracle-attack") {
         const attacker = game.actors.get(data.attackerId)
         const spell = attacker?.items.get(data.attackWeaponId)
-        const damageDice = spell?.system?.damageDice
-        if (damageDice) {
-          damageButton = `
-            <div class="attack-result-damage">
-              <button class="roll-damage-btn"
-                data-attacker-id="${data.attackerId}"
-                data-defender-id="${data.defenderId}"
-                data-defender-token-id="${data.defenderTokenId || ""}"
-                data-damage-type="spell"
-                data-damage-formula="${damageDice}">
-                <i class="fa-solid fa-wand-magic-sparkles"></i> Spell Damage (${damageDice})
-              </button>
-            </div>
-          `
+        const tiers = [
+          { formula: spell?.system?.damageDice, label: "Standard" },
+          { formula: spell?.system?.damageDiceOverpowered, label: "Overpowered" },
+          { formula: spell?.system?.damageDiceOverpowered2, label: "Overpowered 2" },
+        ].filter(t => t.formula)
+        if (tiers.length) {
+          const buttons = tiers.map(t => {
+            const escapedFormula = Handlebars.escapeExpression(t.formula)
+            return `
+            <button class="roll-damage-btn"
+              data-attacker-id="${data.attackerId}"
+              data-defender-id="${data.defenderId}"
+              data-defender-token-id="${data.defenderTokenId || ""}"
+              data-damage-type="spell"
+              data-damage-formula="${escapedFormula}">
+              <i class="fa-solid fa-wand-magic-sparkles"></i> ${t.label} (${escapedFormula})
+            </button>`
+          }).join("")
+          damageButton = `<div class="attack-result-damage">${buttons}</div>`
         }
       }
     }
@@ -868,10 +907,10 @@ export default class LethalFantasyUtils {
         </div>
         <div class="combat-result-text">
           ${outcome === "shielded-hit"
-        ? `<i class="fa-solid fa-shield"></i> <strong>${data.attackerName}</strong> hits <strong>${data.defenderName}</strong>, but the shield blocked — apply armor DR + shield DR <strong>${data.shieldDamageReduction || 0}</strong>.`
+        ? `<i class="fa-solid fa-shield"></i> <strong>${data.defenderName}</strong> has blocked with shield — apply armor DR + shield DR <strong>${data.shieldDamageReduction || 0}</strong>.`
         : isAttackWin
           ? `<i class="fa-solid fa-circle-check"></i> <strong>${data.attackerName}</strong> hits <strong>${data.defenderName}</strong>!`
-          : `<i class="fa-solid fa-shield-halved"></i> <strong>${data.defenderName}</strong> parries the attack!`
+          : `<i class="fa-solid fa-shield-halved"></i> <strong>${data.defenderName}</strong> avoided the attack!`
       }
         </div>
         ${damageButton}
@@ -1058,25 +1097,32 @@ export default class LethalFantasyUtils {
   static async applyDamage(message, event) {
     // Récupérer les données du message
     let combatantId = event.currentTarget.dataset.combatantId
-    if (!combatantId || !game.combat) {
+    if (!combatantId) {
       ui.notifications.error("No combatant selected")
       return
     }
 
-    let combatant = game.combat.combatants.get(combatantId)
-    if (!combatant) {
-      ui.notifications.error("Combatant not found")
-      return
+    // Try to find the target: first as a combat combatant, then as a scene token
+    let targetActor = null
+    if (game.combat) {
+      const combatant = game.combat.combatants.get(combatantId)
+      if (combatant) {
+        targetActor = combatant.token?.actor || game.actors.get(combatant.actorId)
+      }
+    }
+    if (!targetActor) {
+      // Fall back to scene token lookup (non-combat tokens use tokenId as their combatantId)
+      const token = canvas.tokens?.placeables?.find(t => t.id === combatantId)
+      targetActor = token?.actor
     }
-
-    let targetActor = combatant.token?.actor || game.actors.get(combatant.actorId)
     if (!targetActor) {
       ui.notifications.error("Target actor not found")
       return
     }
 
     // Récupérer les données de dégâts du message
-    let damageTotal = message.rolls[0]?.total || 0
+    // Use options.rollTotal (includes weapon modifier bonus) rather than roll.total (dice formula only)
+    let damageTotal = message.rolls[0]?.options?.rollTotal ?? message.rolls[0]?.total ?? 0
     let weaponName = message.rolls[0]?.options?.rollName || "Unknown Weapon"
 
     // Calculer les DR
@@ -1154,7 +1200,7 @@ export default class LethalFantasyUtils {
       ChatMessage.create({
         user: game.user.id,
         speaker: { alias: targetActor.name },
-        rollMode: "gmroll",
+        mode: "gm",
         content: messageContent
       })
     }

packs-system/lf-equipment/CURRENT

@@ -1 +1 @@
-MANIFEST-000567
+MANIFEST-000599

packs-system/lf-equipment/LOG

@@ -1,8 +1,8 @@
-2026/04/17-15:59:28.854423 7fc1d9fbd6c0 Recovering log #565
-2026/04/17-15:59:28.865018 7fc1d9fbd6c0 Delete type=3 #563
-2026/04/17-15:59:28.865088 7fc1d9fbd6c0 Delete type=0 #565
-2026/04/17-17:32:42.752073 7fc1d8fbb6c0 Level-0 table #570: started
-2026/04/17-17:32:42.752102 7fc1d8fbb6c0 Level-0 table #570: 0 bytes OK
-2026/04/17-17:32:42.757979 7fc1d8fbb6c0 Delete type=0 #568
-2026/04/17-17:32:42.764071 7fc1d8fbb6c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
-2026/04/17-17:32:42.764104 7fc1d8fbb6c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
+2026/05/18-17:40:11.769288 7f5a477fe6c0 Recovering log #597
+2026/05/18-17:40:11.780605 7f5a477fe6c0 Delete type=3 #595
+2026/05/18-17:40:11.780699 7f5a477fe6c0 Delete type=0 #597
+2026/05/18-20:25:54.228818 7f5a467fc6c0 Level-0 table #602: started
+2026/05/18-20:25:54.230037 7f5a467fc6c0 Level-0 table #602: 0 bytes OK
+2026/05/18-20:25:54.236369 7f5a467fc6c0 Delete type=0 #600
+2026/05/18-20:25:54.251050 7f5a467fc6c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
+2026/05/18-20:25:54.251106 7f5a467fc6c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)

packs-system/lf-equipment/LOG.old

@@ -1,8 +1,8 @@
-2026/04/16-08:58:49.556234 7fc1d97bc6c0 Recovering log #561
-2026/04/16-08:58:49.566786 7fc1d97bc6c0 Delete type=3 #559
-2026/04/16-08:58:49.566849 7fc1d97bc6c0 Delete type=0 #561
-2026/04/16-10:53:23.903167 7fc1d8fbb6c0 Level-0 table #566: started
-2026/04/16-10:53:23.903203 7fc1d8fbb6c0 Level-0 table #566: 0 bytes OK
-2026/04/16-10:53:23.909050 7fc1d8fbb6c0 Delete type=0 #564
-2026/04/16-10:53:23.921766 7fc1d8fbb6c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
-2026/04/16-10:53:23.921790 7fc1d8fbb6c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
+2026/05/18-07:32:52.671725 7f5a94bff6c0 Recovering log #593
+2026/05/18-07:32:52.684619 7f5a94bff6c0 Delete type=3 #591
+2026/05/18-07:32:52.684760 7f5a94bff6c0 Delete type=0 #593
+2026/05/18-07:58:12.225439 7f5a467fc6c0 Level-0 table #598: started
+2026/05/18-07:58:12.225593 7f5a467fc6c0 Level-0 table #598: 0 bytes OK
+2026/05/18-07:58:12.232817 7f5a467fc6c0 Delete type=0 #596
+2026/05/18-07:58:12.252837 7f5a467fc6c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
+2026/05/18-07:58:12.252955 7f5a467fc6c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)

packs-system/lf-gifts/CURRENT

@@ -1 +1 @@
-MANIFEST-000564
+MANIFEST-000596

packs-system/lf-gifts/LOG

@@ -1,8 +1,8 @@
-2026/04/17-15:59:28.871085 7fc1dafbf6c0 Recovering log #562
-2026/04/17-15:59:28.880683 7fc1dafbf6c0 Delete type=3 #560
-2026/04/17-15:59:28.880729 7fc1dafbf6c0 Delete type=0 #562
-2026/04/17-17:32:42.744598 7fc1d8fbb6c0 Level-0 table #567: started
-2026/04/17-17:32:42.744627 7fc1d8fbb6c0 Level-0 table #567: 0 bytes OK
-2026/04/17-17:32:42.751972 7fc1d8fbb6c0 Delete type=0 #565
-2026/04/17-17:32:42.764061 7fc1d8fbb6c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
-2026/04/17-17:32:42.764085 7fc1d8fbb6c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
+2026/05/18-17:40:11.793894 7f5a94bff6c0 Recovering log #594
+2026/05/18-17:40:11.804447 7f5a94bff6c0 Delete type=3 #592
+2026/05/18-17:40:11.804549 7f5a94bff6c0 Delete type=0 #594
+2026/05/18-20:25:54.236611 7f5a467fc6c0 Level-0 table #599: started
+2026/05/18-20:25:54.236652 7f5a467fc6c0 Level-0 table #599: 0 bytes OK
+2026/05/18-20:25:54.243997 7f5a467fc6c0 Delete type=0 #597
+2026/05/18-20:25:54.251069 7f5a467fc6c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
+2026/05/18-20:25:54.264439 7f5a467fc6c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)

packs-system/lf-gifts/LOG.old

@@ -1,8 +1,8 @@
-2026/04/16-08:58:49.571861 7fc1da7be6c0 Recovering log #558
-2026/04/16-08:58:49.581625 7fc1da7be6c0 Delete type=3 #556
-2026/04/16-08:58:49.581687 7fc1da7be6c0 Delete type=0 #558
-2026/04/16-10:53:23.896992 7fc1d8fbb6c0 Level-0 table #563: started
-2026/04/16-10:53:23.897059 7fc1d8fbb6c0 Level-0 table #563: 0 bytes OK
-2026/04/16-10:53:23.903074 7fc1d8fbb6c0 Delete type=0 #561
-2026/04/16-10:53:23.921755 7fc1d8fbb6c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
-2026/04/16-10:53:23.921797 7fc1d8fbb6c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
+2026/05/18-07:32:52.700651 7f5a477fe6c0 Recovering log #590
+2026/05/18-07:32:52.712680 7f5a477fe6c0 Delete type=3 #588
+2026/05/18-07:32:52.712814 7f5a477fe6c0 Delete type=0 #590
+2026/05/18-07:58:12.232998 7f5a467fc6c0 Level-0 table #595: started
+2026/05/18-07:58:12.233130 7f5a467fc6c0 Level-0 table #595: 0 bytes OK
+2026/05/18-07:58:12.244133 7f5a467fc6c0 Delete type=0 #593
+2026/05/18-07:58:12.252873 7f5a467fc6c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
+2026/05/18-07:58:12.252977 7f5a467fc6c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)

packs-system/lf-skills/CURRENT

@@ -1 +1 @@
-MANIFEST-000569
+MANIFEST-000601

packs-system/lf-skills/LOG

@@ -1,8 +1,8 @@
-2026/04/17-15:59:28.839432 7fc1da7be6c0 Recovering log #567
-2026/04/17-15:59:28.849242 7fc1da7be6c0 Delete type=3 #565
-2026/04/17-15:59:28.849292 7fc1da7be6c0 Delete type=0 #567
-2026/04/17-17:32:42.764151 7fc1d8fbb6c0 Level-0 table #572: started
-2026/04/17-17:32:42.764181 7fc1d8fbb6c0 Level-0 table #572: 0 bytes OK
-2026/04/17-17:32:42.770357 7fc1d8fbb6c0 Delete type=0 #570
-2026/04/17-17:32:42.789018 7fc1d8fbb6c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
-2026/04/17-17:32:42.789049 7fc1d8fbb6c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
+2026/05/18-17:40:11.749971 7f5a46ffd6c0 Recovering log #599
+2026/05/18-17:40:11.761423 7f5a46ffd6c0 Delete type=3 #597
+2026/05/18-17:40:11.761520 7f5a46ffd6c0 Delete type=0 #599
+2026/05/18-20:25:54.219239 7f5a467fc6c0 Level-0 table #604: started
+2026/05/18-20:25:54.219522 7f5a467fc6c0 Level-0 table #604: 0 bytes OK
+2026/05/18-20:25:54.228610 7f5a467fc6c0 Delete type=0 #602
+2026/05/18-20:25:54.251028 7f5a467fc6c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
+2026/05/18-20:25:54.251085 7f5a467fc6c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)

packs-system/lf-skills/LOG.old

@@ -1,8 +1,8 @@
-2026/04/16-08:58:49.542216 7fc1dafbf6c0 Recovering log #563
-2026/04/16-08:58:49.551998 7fc1dafbf6c0 Delete type=3 #561
-2026/04/16-08:58:49.552067 7fc1dafbf6c0 Delete type=0 #563
-2026/04/16-10:53:23.915570 7fc1d8fbb6c0 Level-0 table #568: started
-2026/04/16-10:53:23.915589 7fc1d8fbb6c0 Level-0 table #568: 0 bytes OK
-2026/04/16-10:53:23.921669 7fc1d8fbb6c0 Delete type=0 #566
-2026/04/16-10:53:23.921782 7fc1d8fbb6c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
-2026/04/16-10:53:23.921813 7fc1d8fbb6c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
+2026/05/18-07:32:52.650924 7f5a47fff6c0 Recovering log #595
+2026/05/18-07:32:52.662191 7f5a47fff6c0 Delete type=3 #593
+2026/05/18-07:32:52.662331 7f5a47fff6c0 Delete type=0 #595
+2026/05/18-07:58:12.218060 7f5a467fc6c0 Level-0 table #600: started
+2026/05/18-07:58:12.218402 7f5a467fc6c0 Level-0 table #600: 0 bytes OK
+2026/05/18-07:58:12.225237 7f5a467fc6c0 Delete type=0 #598
+2026/05/18-07:58:12.244392 7f5a467fc6c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
+2026/05/18-07:58:12.252899 7f5a467fc6c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)

packs-system/lf-spells-miracles/CURRENT

@@ -1 +1 @@
-MANIFEST-000264
+MANIFEST-000296

packs-system/lf-spells-miracles/LOG

@@ -1,8 +1,8 @@
-2026/04/17-15:59:28.899464 7fc1d97bc6c0 Recovering log #262
-2026/04/17-15:59:28.910004 7fc1d97bc6c0 Delete type=3 #260
-2026/04/17-15:59:28.910074 7fc1d97bc6c0 Delete type=0 #262
-2026/04/17-17:32:42.770457 7fc1d8fbb6c0 Level-0 table #267: started
-2026/04/17-17:32:42.770479 7fc1d8fbb6c0 Level-0 table #267: 0 bytes OK
-2026/04/17-17:32:42.777091 7fc1d8fbb6c0 Delete type=0 #265
-2026/04/17-17:32:42.789028 7fc1d8fbb6c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
-2026/04/17-17:32:42.789054 7fc1d8fbb6c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
+2026/05/18-17:40:11.831491 7f5a94bff6c0 Recovering log #294
+2026/05/18-17:40:11.842913 7f5a94bff6c0 Delete type=3 #292
+2026/05/18-17:40:11.843005 7f5a94bff6c0 Delete type=0 #294
+2026/05/18-20:25:54.257813 7f5a467fc6c0 Level-0 table #299: started
+2026/05/18-20:25:54.257869 7f5a467fc6c0 Level-0 table #299: 0 bytes OK
+2026/05/18-20:25:54.264186 7f5a467fc6c0 Delete type=0 #297
+2026/05/18-20:25:54.267118 7f5a467fc6c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
+2026/05/18-20:25:54.296812 7f5a467fc6c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)

packs-system/lf-spells-miracles/LOG.old

@@ -1,8 +1,8 @@
-2026/04/16-08:58:49.600337 7fc1dafbf6c0 Recovering log #258
-2026/04/16-08:58:49.610136 7fc1dafbf6c0 Delete type=3 #256
-2026/04/16-08:58:49.610209 7fc1dafbf6c0 Delete type=0 #258
-2026/04/16-10:53:23.940580 7fc1d8fbb6c0 Level-0 table #263: started
-2026/04/16-10:53:23.940611 7fc1d8fbb6c0 Level-0 table #263: 0 bytes OK
-2026/04/16-10:53:23.947242 7fc1d8fbb6c0 Delete type=0 #261
-2026/04/16-10:53:23.947402 7fc1d8fbb6c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
-2026/04/16-10:53:23.947419 7fc1d8fbb6c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
+2026/05/18-07:32:52.738234 7f5a477fe6c0 Recovering log #290
+2026/05/18-07:32:52.749839 7f5a477fe6c0 Delete type=3 #288
+2026/05/18-07:32:52.749970 7f5a477fe6c0 Delete type=0 #290
+2026/05/18-07:58:12.253340 7f5a467fc6c0 Level-0 table #295: started
+2026/05/18-07:58:12.253449 7f5a467fc6c0 Level-0 table #295: 0 bytes OK
+2026/05/18-07:58:12.261029 7f5a467fc6c0 Delete type=0 #293
+2026/05/18-07:58:12.286385 7f5a467fc6c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
+2026/05/18-07:58:12.286487 7f5a467fc6c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)

packs-system/lf-vulnerabilities/CURRENT

@@ -1 +1 @@
-MANIFEST-000563
+MANIFEST-000595

packs-system/lf-vulnerabilities/LOG

@@ -1,8 +1,8 @@
-2026/04/17-15:59:28.886104 7fc1da7be6c0 Recovering log #561
-2026/04/17-15:59:28.896104 7fc1da7be6c0 Delete type=3 #559
-2026/04/17-15:59:28.896157 7fc1da7be6c0 Delete type=0 #561
-2026/04/17-17:32:42.758102 7fc1d8fbb6c0 Level-0 table #566: started
-2026/04/17-17:32:42.758128 7fc1d8fbb6c0 Level-0 table #566: 0 bytes OK
-2026/04/17-17:32:42.763950 7fc1d8fbb6c0 Delete type=0 #564
-2026/04/17-17:32:42.764079 7fc1d8fbb6c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
-2026/04/17-17:32:42.764099 7fc1d8fbb6c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
+2026/05/18-17:40:11.812004 7f5a47fff6c0 Recovering log #593
+2026/05/18-17:40:11.823277 7f5a47fff6c0 Delete type=3 #591
+2026/05/18-17:40:11.823388 7f5a47fff6c0 Delete type=0 #593
+2026/05/18-20:25:54.244177 7f5a467fc6c0 Level-0 table #598: started
+2026/05/18-20:25:54.244222 7f5a467fc6c0 Level-0 table #598: 0 bytes OK
+2026/05/18-20:25:54.250810 7f5a467fc6c0 Delete type=0 #596
+2026/05/18-20:25:54.251096 7f5a467fc6c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
+2026/05/18-20:25:54.264461 7f5a467fc6c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)

packs-system/lf-vulnerabilities/LOG.old

@@ -1,8 +1,8 @@
-2026/04/16-08:58:49.586323 7fc1d9fbd6c0 Recovering log #557
-2026/04/16-08:58:49.596973 7fc1d9fbd6c0 Delete type=3 #555
-2026/04/16-08:58:49.597026 7fc1d9fbd6c0 Delete type=0 #557
-2026/04/16-10:53:23.909144 7fc1d8fbb6c0 Level-0 table #562: started
-2026/04/16-10:53:23.909174 7fc1d8fbb6c0 Level-0 table #562: 0 bytes OK
-2026/04/16-10:53:23.915478 7fc1d8fbb6c0 Delete type=0 #560
-2026/04/16-10:53:23.921775 7fc1d8fbb6c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
-2026/04/16-10:53:23.921804 7fc1d8fbb6c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
+2026/05/18-07:32:52.720162 7f5a94bff6c0 Recovering log #589
+2026/05/18-07:32:52.731519 7f5a94bff6c0 Delete type=3 #587
+2026/05/18-07:32:52.731690 7f5a94bff6c0 Delete type=0 #589
+2026/05/18-07:58:12.244424 7f5a467fc6c0 Level-0 table #594: started
+2026/05/18-07:58:12.244618 7f5a467fc6c0 Level-0 table #594: 0 bytes OK
+2026/05/18-07:58:12.252579 7f5a467fc6c0 Delete type=0 #592
+2026/05/18-07:58:12.252922 7f5a467fc6c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
+2026/05/18-07:58:12.252996 7f5a467fc6c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)

styles/monster.less

@@ -410,6 +410,48 @@
     }
   }
 
+  .ranged-attacks {
+    grid-template-columns: 1fr;
+    .attack {
+      .name {
+        min-width: 10rem;
+        max-width: 10rem;
+      }
+      .damage-dice {
+        width: 5rem;
+        max-width: 5rem;
+      }
+    }
+    .ranged-weapon-range {
+      margin-top: 8px;
+      border-top: 1px solid var(--color-border-light-tertiary, #ccc);
+      padding-top: 6px;
+      > label {
+        font-weight: bold;
+        margin-bottom: 4px;
+        display: block;
+      }
+      .range-fields {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 6px;
+        .range-field {
+          display: flex;
+          flex-direction: column;
+          align-items: center;
+          label {
+            font-size: 0.7rem;
+            white-space: nowrap;
+          }
+          input {
+            width: 3.5rem;
+            text-align: center;
+          }
+        }
+      }
+    }
+  }
+
   .armors {
     display: grid;
     grid-template-columns: repeat(3, 1fr);

styles/roll.less

@@ -176,6 +176,22 @@
   }
 }
 
+.dialog-warning {
+  margin: 0.4rem 0.2rem 0.2rem;
+  padding: 0.35rem 0.5rem;
+  border-left: 3px solid #c8941a;
+  background: rgba(200, 148, 26, 0.12);
+  border-radius: 3px;
+  font-family: var(--font-secondary);
+  font-size: calc(var(--font-size-standard) * 0.9);
+  color: #7a5400;
+  line-height: 1.4;
+  i {
+    color: #c8941a;
+    margin-right: 0.4rem;
+  }
+}
+
 .lethalfantasy,
 .fvtt-lethal-fantasy,
 .message.lethalfantasy,

system.json

@@ -6,7 +6,7 @@
   "download": "#{DOWNLOAD}#",
   "url": "#{URL}#",
   "license": "LICENSE",
-  "version": "13.0.0",
+  "version": "14.0.0",
   "authors": [
     {
       "name": "Uberwald",
@@ -15,7 +15,7 @@
   ],
   "compatibility": {
     "minimum": "13",
-    "verified": "13"
+    "verified": "14"
   },
   "esmodules": ["lethal-fantasy.mjs"],
   "styles": ["css/fvtt-lethal-fantasy.css"],

templates/character-biography.hbs

@@ -9,95 +9,95 @@
       <legend>{{localize "LETHALFANTASY.Label.biodata"}}</legend>
       <div class="biodata">
         <div class="biodata-elem">
-          <span class="name">Class</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.class"}}</span>
           {{formInput
             systemFields.biodata.fields.class
             value=system.biodata.class
           }}
         </div>
         <div class="biodata-elem">
-          <span class="name">Level</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.level"}}</span>
           {{formInput
             systemFields.biodata.fields.level
             value=system.biodata.level
           }}
         </div>
         <div class="biodata-elem">
-          <span class="name">Mortal</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.mortal"}}</span>
           {{formInput
             systemFields.biodata.fields.mortal
             value=system.biodata.mortal
           }}
         </div>
         <div class="biodata-elem">
-          <span class="name">Alignment</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.alignment"}}</span>
           {{formInput
             systemFields.biodata.fields.alignment
             value=system.biodata.alignment
           }}
         </div>
         <div class="biodata-elem">
-          <span class="name">Age</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.age"}}</span>
           {{formInput systemFields.biodata.fields.age value=system.biodata.age}}
         </div>
         <div class="biodata-elem">
-          <span class="name">Height</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.height"}}</span>
           {{formInput
             systemFields.biodata.fields.height
             value=system.biodata.height
           }}
         </div>
         <div class="biodata-elem">
-          <span class="name">Weight</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.weight"}}</span>
           {{formInput
             systemFields.biodata.fields.weight
             value=system.biodata.weight
           }}
         </div>
         <div class="biodata-elem">
-          <span class="name">Eyes</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.eyes"}}</span>
           {{formInput
             systemFields.biodata.fields.eyes
             value=system.biodata.eyes
           }}
         </div>
         <div class="biodata-elem">
-          <span class="name">Hair</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.hair"}}</span>
           {{formInput
             systemFields.biodata.fields.hair
             value=system.biodata.hair
           }}
         </div>
         <div class="biodata-elem">
-          <span class="name">Dev. Points (Total)</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.devPointsTotal"}}</span>
           {{formInput
             systemFields.developmentPoints.fields.total
             value=system.developmentPoints.total
           }}
         </div>
         <div class="biodata-elem">
-          <span class="name">Dev. Points (Rem.)</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.devPointsRem"}}</span>
           {{formInput
             systemFields.developmentPoints.fields.remaining
             value=system.developmentPoints.remaining
           }}
         </div>
         <div class="biodata-elem">
-          <span class="name">Magic User</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.magicUser"}}</span>
           {{formInput
             systemFields.biodata.fields.magicUser
             value=system.biodata.magicUser
           }}
         </div>
         <div class="biodata-elem">
-          <span class="name">Cleric User</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.clericUser"}}</span>
           {{formInput
             systemFields.biodata.fields.clericUser
             value=system.biodata.clericUser
           }}
         </div>
         <div class="biodata-elem">
-          <span class="name">Save bonus (1/5levels)</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.saveBonus"}}</span>
           {{formInput
             systemFields.modifiers.fields.saveModifier
             value=system.modifiers.saveModifier
@@ -107,7 +107,7 @@
 
         {{#if system.biodata.magicUser}}
           <div class="biodata-elem">
-            <span class="name">Spell bonus (1/5levels)</span>
+            <span class="name">{{localize "LETHALFANTASY.Label.spellBonus"}}</span>
             {{formInput
               systemFields.modifiers.fields.levelSpellModifier
               value=system.modifiers.levelSpellModifier
@@ -117,7 +117,7 @@
         {{/if}}
         {{#if system.biodata.clericUser}}
           <div class="biodata-elem">
-            <span class="name">Miracle bonus (1/5levels)</span>
+            <span class="name">{{localize "LETHALFANTASY.Label.miracleBonus"}}</span>
             {{formInput
               systemFields.modifiers.fields.levelMiracleModifier
               value=system.modifiers.levelMiracleModifier
@@ -127,7 +127,7 @@
         {{/if}}
 
         <div class="biodata-elem">
-          <span class="name">Last HD roll</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.lastHdRoll"}}</span>
           {{formInput
             systemFields.biodata.fields.hpPerLevel
             value=system.biodata.hpPerLevel
@@ -136,7 +136,7 @@
         </div>
 
         <div class="biodata-elem">
-          <span class="name">Natural DR</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.naturalDR"}}</span>
           {{formInput
             systemFields.biodata.fields.naturalDR
             value=system.biodata.naturalDR
@@ -145,7 +145,7 @@
         </div>
 
         <div class="biodata-elem">
-          <span class="name">Magical DR</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.magicalDR"}}</span>
           {{formInput
             systemFields.biodata.fields.magicDR
             value=system.biodata.magicDR

templates/character-miracles.hbs

@@ -5,12 +5,12 @@
       <legend>{{localize "LETHALFANTASY.Label.divinityPoints"}}</legend>
       <div class="miracle-details">
         <div class="miracle-detail">
-          <span>Current</span>
+          <span>{{localize "LETHALFANTASY.Label.current"}}</span>
           {{formField systemFields.divinityPoints.fields.value value=system.divinityPoints.value localize=true}}
           <a data-action="divinityPointsPlus"><i class="fa-solid fa-hexagon-plus"></i></a>
           <a data-action="divinityPointsMinus"><i class="fa-solid fa-hexagon-minus"></i></a>
 
-          <span>Max</span>
+          <span>{{localize "LETHALFANTASY.Label.max"}}</span>
           {{formField systemFields.divinityPoints.fields.max value=system.divinityPoints.max localize=true
           disabled=isPlayMode}}
         </div>

templates/character-spells.hbs

@@ -5,12 +5,12 @@
       <legend>{{localize "LETHALFANTASY.Label.aetherPoints"}}</legend>
       <div class="spell-details">
         <div class="spell-detail">
-          <span>Current</span>
+          <span>{{localize "LETHALFANTASY.Label.current"}}</span>
           {{formField systemFields.aetherPoints.fields.value value=system.aetherPoints.value localize=true}}
           <a data-action="aetherPointsPlus"><i class="fa-solid fa-hexagon-plus"></i></a>
           <a data-action="aetherPointsMinus"><i class="fa-solid fa-hexagon-minus"></i></a>
 
-          <span>Max</span>
+          <span>{{localize "LETHALFANTASY.Label.max"}}</span>
           {{formField systemFields.aetherPoints.fields.max value=system.aetherPoints.max localize=true
           disabled=isPlayMode}}
         </div>

templates/chat-message.hbs

@@ -40,32 +40,32 @@
     {{#if (eq rollData.favor "favor")}}
       <div class="detail-badge favor-badge">
         <i class="fa-solid fa-sparkles"></i>
-        <span>Favor</span>
+        <span>{{localize "LETHALFANTASY.Label.favor"}}</span>
       </div>
     {{/if}}
     {{#if (eq rollData.favor "disfavor")}}
       <div class="detail-badge disfavor-badge">
         <i class="fa-solid fa-skull"></i>
-        <span>Disfavor</span>
+        <span>{{localize "LETHALFANTASY.Label.disfavor"}}</span>
       </div>
     {{/if}}
 
     {{#if rollData.letItFly}}
       <div class="detail-badge special-badge">
         <i class="fa-solid fa-bow-arrow"></i>
-        <span>Let It Fly!</span>
+        <span>{{localize "LETHALFANTASY.Label.letItFly"}}</span>
       </div>
     {{/if}}
     {{#if rollData.pointBlank}}
       <div class="detail-badge special-badge">
         <i class="fa-solid fa-bullseye-arrow"></i>
-        <span>Point Blank</span>
+        <span>{{localize "LETHALFANTASY.Label.pointBlank"}}</span>
       </div>
     {{/if}}
     {{#if rollData.beyondSkill}}
       <div class="detail-badge special-badge">
         <i class="fa-solid fa-target-lock"></i>
-        <span>Beyond Skill</span>
+        <span>{{localize "LETHALFANTASY.Label.beyondSkill"}}</span>
       </div>
     {{/if}}
 
@@ -111,7 +111,7 @@
   {{#unless isPrivate}}
     <div class="result-section">
       <div class="main-result">
-        <div class="result-label">Total</div>
+        <div class="result-label">{{localize "LETHALFANTASY.Label.total"}}</div>
         <div class="result-value {{#if (eq resultType 'success')}}success{{else}}failure{{/if}}">
           {{total}}
         </div>
@@ -127,7 +127,7 @@
           {{#if D30message}}
             <div class="d30-message">
               <i class="fa-solid fa-wand-magic-sparkles"></i>
-              <span>{{D30message}}</span>
+              <span>{{D30message.description}}</span>
             </div>
           {{/if}}
         </div>
@@ -177,7 +177,7 @@
   {{else}}
     <div class="private-result">
       <i class="fa-solid fa-eye-slash"></i>
-      <span>Private Roll</span>
+      <span>{{localize "LETHALFANTASY.Label.privateRoll"}}</span>
     </div>
   {{/unless}}
 

templates/combat-tracker-footer-v2.hbs

@@ -13,6 +13,14 @@
         <span>{{ localize "COMBAT.End" }}</span>
     </button>
 
+    {{#if combat.round}}
+    <button type="button" class="combat-control combat-control-lg" data-action="rollMonsterProgression"
+            data-tooltip="{{ localize 'LETHALFANTASY.Combat.RollMonsters' }}">
+        <i class="fa-solid fa-dragon" inert></i>
+        <span>{{ localize "LETHALFANTASY.Combat.RollMonsters" }}</span>
+    </button>
+    {{/if}}
+
     <!-- <button type="button" class="inline-control combat-control icon fa-solid fa-arrow-right" data-action="nextTurn"
             data-tooltip aria-label="{{ localize "COMBAT.TurnNext" }}"></button> -->
     <button type="button" class="inline-control combat-control icon fa-solid fa-forward-step" data-action="nextRound"

templates/miracle.hbs

@@ -7,7 +7,7 @@
   {{formField systemFields.miracleType value=system.miracleType}}
   {{formField systemFields.level value=system.level}}
 
-  <label>Components</label>
+  <label>{{localize "LETHALFANTASY.Label.components"}}</label>
   <div class="shift-right">
     {{formField systemFields.components.fields.verbal value=system.components.verbal}}
     {{formField systemFields.components.fields.somatic value=system.components.somatic}}
@@ -27,6 +27,9 @@
   {{formField systemFields.areaAffected value=system.areaAffected}}
   {{formField systemFields.duration value=system.duration}}
   {{formField systemFields.savingThrow value=system.savingThrow}}
+  {{formField systemFields.damageDice value=system.damageDice}}
+  {{formField systemFields.damageDiceOverpowered value=system.damageDiceOverpowered}}
+  {{formField systemFields.damageDiceOverpowered2 value=system.damageDiceOverpowered2}}
 
 
   

templates/monster-biography.hbs

@@ -6,23 +6,23 @@
     <div class="biodata">
 
       <div class="biodata-elem">
-        <span class="name">Alignment</span>
+        <span class="name">{{localize "LETHALFANTASY.Label.alignment"}}</span>
         {{formInput systemFields.biodata.fields.alignment value=system.biodata.alignment }}
       </div>
       <div class="biodata-elem">
-        <span class="name">Height</span>
+        <span class="name">{{localize "LETHALFANTASY.Label.height"}}</span>
         {{formInput systemFields.biodata.fields.height value=system.biodata.height }}
       </div>
       <div class="biodata-elem">
-        <span class="name">Weight</span>
+        <span class="name">{{localize "LETHALFANTASY.Label.weight"}}</span>
         {{formInput systemFields.biodata.fields.weight value=system.biodata.weight }}
       </div>
       <div class="biodata-elem">
-        <span class="name">Length</span>
+        <span class="name">{{localize "LETHALFANTASY.Label.length"}}</span>
         {{formInput systemFields.biodata.fields.length value=system.biodata.length }}
       </div>
       <div class="biodata-elem">
-        <span class="name">Vision</span>
+        <span class="name">{{localize "LETHALFANTASY.Label.vision"}}</span>
         {{formInput systemFields.biodata.fields.vision value=system.biodata.vision }}
       </div>
 

templates/monster-combat.hbs

@@ -18,7 +18,16 @@
 
   <fieldset>
     <legend>{{localize "LETHALFANTASY.Label.attacks"}}</legend>
-    <div class="attacks">
+    <div class="attack-mode-selector">
+      <label>{{localize "LETHALFANTASY.Label.attackMode"}}</label>
+      <select name="system.attackMode">
+        <option value="melee" {{#if (eq system.attackMode "melee")}}selected{{/if}}>{{localize "LETHALFANTASY.Label.meleeModeLabel"}}</option>
+        <option value="ranged" {{#if (eq system.attackMode "ranged")}}selected{{/if}}>{{localize "LETHALFANTASY.Label.rangedModeLabel"}}</option>
+      </select>
+    </div>
+
+    {{#if (eq system.attackMode "melee")}}
+    <div class="attacks melee-attacks">
       {{#each system.attacks as |item key|}}
       <div class="attack" data-attack-key="{{key}}" >
         <div class="">
@@ -42,6 +51,9 @@
         <div class="numeric">
           <input type="number" name="system.attacks.{{item.key}}.damageModifier" value="{{item.damageModifier}}" data-tooltip="Damage modifier"/>
         </div>
+        <div class="">
+          <input type="checkbox" name="system.attacks.{{item.key}}.noExplode" {{checked item.noExplode}} data-tooltip="No exploding dice on damage" />
+        </div>
 
         <div class="attack-icons">
 
@@ -64,10 +76,91 @@
       </div>
       {{/each}}
     </div>
+    {{else}}
+    <div class="attacks ranged-attacks">
+      {{#each system.rangedAttacks as |item key|}}
+      <div class="attack" data-attack-key="{{key}}" >
+        <div class="">
+          <input type="checkbox" name="system.rangedAttacks.{{item.key}}.enabled" {{checked item.enabled}} data-tooltip="Attack enabled/disabled" />
+        </div>
+        <div class="name">
+          <input type="text" name="system.rangedAttacks.{{item.key}}.name" value="{{item.name}}" data-tooltip="Attack name" />
+        </div>
+        <div class="numeric">
+          <input type="number" name="system.rangedAttacks.{{item.key}}.attackScore" value="{{item.attackScore}}" data-tooltip="Progression number" />
+        </div>
+        <div class="numeric">
+          <input type="number" name="system.rangedAttacks.{{item.key}}.attackModifier" value="{{item.attackModifier}}" data-tooltip="Attack modifier" />
+        </div>
+        <div class="numeric">
+          <input type="number" name="system.rangedAttacks.{{item.key}}.defenseModifier" value="{{item.defenseModifier}}" data-tooltip="Defense modifier"/>
+        </div>
+        <div class="damage-dice">
+          <input type="text" name="system.rangedAttacks.{{item.key}}.damageDice" value="{{item.damageDice}}" data-tooltip="Damage dice"/>
+        </div>
+        <div class="numeric">
+          <input type="number" name="system.rangedAttacks.{{item.key}}.damageModifier" value="{{item.damageModifier}}" data-tooltip="Damage modifier"/>
+        </div>
+        <div class="">
+          <input type="checkbox" name="system.rangedAttacks.{{item.key}}.noExplode" {{checked item.noExplode}} data-tooltip="No exploding dice on damage" />
+        </div>
+
+        <div class="attack-icons">
+
+          <a class="rollable" data-roll-type="monster-attack" data-roll-key="{{item.key}}" data-tooltip="Roll Attack">
+            <i class="lf-roll-small fa-solid fa-bow-arrow" data-roll-type="monster-attack" data-roll-key="{{item.key}}"></i>
+          </a>
+
+          <a class="rollable" data-roll-type="monster-defense" data-roll-key="{{item.key}}" data-tooltip="Roll Defense">
+            <i class="fa-solid fa-shield-halved" data-roll-type="monster-defense" data-roll-key="{{item.key}}"></i>
+          </a>
+
+          <a class="rollable" data-roll-type="monster-damage" data-roll-key="{{item.key}}"
+            data-tooltip="Roll Damage">
+            <i class="fa-regular fa-face-head-bandage" data-roll-type="monster-damage"
+              data-roll-key="{{item.key}}"></i>
+          </a>
+
+        </div>
+
+      </div>
+      {{/each}}
+
+      <div class="ranged-weapon-range">
+        <label>{{localize "LETHALFANTASY.Label.range"}}</label>
+        <div class="range-fields">
+          <div class="range-field">
+            <label>{{localize "LETHALFANTASY.Label.pointBlank"}}</label>
+            <input type="number" name="system.rangedWeaponRange.pointBlank" value="{{system.rangedWeaponRange.pointBlank}}" />
+          </div>
+          <div class="range-field">
+            <label>{{localize "LETHALFANTASY.Label.short"}}</label>
+            <input type="number" name="system.rangedWeaponRange.short" value="{{system.rangedWeaponRange.short}}" />
+          </div>
+          <div class="range-field">
+            <label>{{localize "LETHALFANTASY.Label.medium"}}</label>
+            <input type="number" name="system.rangedWeaponRange.medium" value="{{system.rangedWeaponRange.medium}}" />
+          </div>
+          <div class="range-field">
+            <label>{{localize "LETHALFANTASY.Label.long"}}</label>
+            <input type="number" name="system.rangedWeaponRange.long" value="{{system.rangedWeaponRange.long}}" />
+          </div>
+          <div class="range-field">
+            <label>{{localize "LETHALFANTASY.Label.extreme"}}</label>
+            <input type="number" name="system.rangedWeaponRange.extreme" value="{{system.rangedWeaponRange.extreme}}" />
+          </div>
+          <div class="range-field">
+            <label>{{localize "LETHALFANTASY.Label.outOfSkill"}}</label>
+            <input type="number" name="system.rangedWeaponRange.outOfSkill" value="{{system.rangedWeaponRange.outOfSkill}}" />
+          </div>
+        </div>
+      </div>
+    </div>
+    {{/if}}
   </fieldset>
 
   <fieldset>
-    <legend>Hand To Hand Attacks</legend>
+    <legend>{{localize "LETHALFANTASY.Label.handToHandAttacks"}}</legend>
     <div class="attacks">
       {{#each system.combatHTH as |item key|}}
       <div class="attack" data-attack-key="{{key}}" >
@@ -92,6 +185,9 @@
         <div class="numeric">
           <input type="number" name="system.combatHTH.{{item.key}}.damageModifier" value="{{item.damageModifier}}" data-tooltip="Damage modifier"/>
         </div>
+        <div class="">
+          <input type="checkbox" name="system.combatHTH.{{item.key}}.noExplode" {{checked item.noExplode}} data-tooltip="No exploding dice on damage" />
+        </div>
 
         <div class="attack-icons">
 

templates/roll-dialog.hbs

@@ -91,6 +91,10 @@
       <div class="dialog-save">Add Granted Defense Dice
         <input type="checkbox" data-action="selectGranted" name="granted" />
       </div>
+      <div class="dialog-warning">
+        <i class="fa-solid fa-triangle-exclamation"></i>
+        {{localize "LETHALFANTASY.Warning.defenseShieldOrder"}}
+      </div>
     {{/if}}
     {{#if (match rollType "damage")}}
       <div class="dialog-save">Add Granted Damage Dice

templates/shield.hbs

@@ -22,9 +22,9 @@
       {{formField systemFields.hascover value=system.hascover}}
 
       {{#if system.hascover}}
-        <label>Cover vs ranged attacks</label>
+        <label>{{localize "LETHALFANTASY.Label.coverRanged"}}</label>
         <div class="shift-right">
-          <label>Standing </label>
+          <label>{{localize "LETHALFANTASY.Label.standing"}}</label>
           <div class="flexrow">{{formField
               systemFields.standing.fields.min
               value=system.standing.min
@@ -33,7 +33,7 @@
           </div>
         </div>
         <div class="shift-right">
-          <label>Crouching</label>
+          <label>{{localize "LETHALFANTASY.Label.crouching"}}</label>
           <div class="flexrow">{{formField
               systemFields.crouching.fields.min
               value=system.crouching.min

templates/spell.hbs

@@ -7,7 +7,7 @@
   {{formField systemFields.level value=system.level}}
   {{formField systemFields.cost value=system.cost}}
 
-  <label>Components</label>
+  <label>{{localize "LETHALFANTASY.Label.components"}}</label>
   <div class="shift-right">
     {{formField systemFields.components.fields.verbal value=system.components.verbal}}
     {{formField systemFields.components.fields.somatic value=system.components.somatic}}
@@ -31,6 +31,8 @@
   {{formField systemFields.extraAetherPoints value=system.extraAetherPoints}}
   {{formField systemFields.criticalType value=system.criticalType}}
   {{formField systemFields.damageDice value=system.damageDice}}
+  {{formField systemFields.damageDiceOverpowered value=system.damageDiceOverpowered}}
+  {{formField systemFields.damageDiceOverpowered2 value=system.damageDiceOverpowered2}}
 
 
   <fieldset>

templates/weapon.hbs

@@ -10,14 +10,14 @@
       {{formField systemFields.weaponType value=system.weaponType localize=true}}
       {{formField systemFields.weaponClass value=system.weaponClass localize=true}}
       
-      <label>Damage Type</label>
+      <label>{{localize "LETHALFANTASY.Label.damageType"}}</label>
       <div class="shift-right">
         {{formField systemFields.damageType.fields.typeP value=system.damageType.typeP}}
         {{formField systemFields.damageType.fields.typeB value=system.damageType.typeB}}
         {{formField systemFields.damageType.fields.typeS value=system.damageType.typeS}}
       </div>
 
-      <label>Damage</label>
+      <label>{{localize "LETHALFANTASY.Label.damage"}}</label>
       <div class="shift-right">
         {{formField systemFields.damage.fields.damageS value=system.damage.damageS}}
         {{formField systemFields.damage.fields.damageM value=system.damage.damageM}}
@@ -34,7 +34,7 @@
        {{/if}}
 
       {{#if (eq system.weaponType "ranged")}}
-        <label>Speed</label>
+        <label>{{localize "LETHALFANTASY.Label.speed"}}</label>
         <div class="shift-right">
           {{formField systemFields.speed.fields.simpleAim value=system.speed.simpleAim}}
           {{formField systemFields.speed.fields.carefulAim value=system.speed.carefulAim}}
@@ -47,7 +47,7 @@
 
         {{formField systemFields.defense value=system.defense}}
 
-        <label>Range</label>
+        <label>{{localize "LETHALFANTASY.Label.range"}}</label>
         <div class="shift-right">
           {{formField systemFields.weaponRange.fields.pointBlank value=system.weaponRange.pointBlank}}
           {{formField systemFields.weaponRange.fields.short value=system.weaponRange.short}}
@@ -60,7 +60,7 @@
 
       {{formField systemFields.equipped value=system.equipped}}
 
-      <label>Bonuses</label>
+      <label>{{localize "LETHALFANTASY.Label.bonuses"}}</label>
       <div class="shift-right">
         {{formField systemFields.bonuses.fields.attackBonus value=system.bonuses.attackBonus}}
         {{formField systemFields.bonuses.fields.defenseBonus value=system.bonuses.defenseBonus}}