Improve init for monsters and some fixwes around shields

MAnage spell/miracle spending points and favor/disfavor for shield rolls
Corredction sur attack ranged
2026-05-17 13:22:29 +02:00 · 2026-05-10 17:49:53 +02:00 · 2026-05-03 15:12:25 +02:00 · 2026-05-03 10:06:44 +02:00 · 2026-05-02 08:35:22 +02:00 · 2026-05-01 23:55:29 +02:00
41 changed files with 636 additions and 355 deletions
@@ -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"
@@ -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);
@@ -382,7 +382,7 @@
      "rollProgressionCount": "Roll progression count",
      "rollProgressionDice": "Roll progression/Lethargy dice",
      "earned": "Earned",
-      "divinityPoints": "Divinity points",
+      "divinityPoints": "Grace",
      "aetherPoints": "Aether points",
      "attacks": "Attacks",
      "attackMode": "Attack Mode",
@@ -462,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",
@@ -981,6 +988,9 @@
      "diceResult": "Dice result",
      "progressionCount": "Progression count:"
    },
+    "Combat": {
+      "RollMonsters": "Roll Monsters"
+    },
    "EquipmentCategories": {
      "ClassKit": "Class Kit",
      "Clothing": "Clothing",
@@ -129,305 +129,284 @@ 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
-    // Récupérer l'acteur attaquant pour vérifier le mode d'attaque
-    const attacker = game.actors.get(attackerId)
-    const isRangedAttack = attacker?.type === "monster" && attacker.system.attackMode === "ranged"
+      // 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")

-    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,
-      isRanged: isRangedAttack
-    }
+      const defenseMsg = {
+        type: "requestDefense",
+        attackerName,
+        attackerId,
+        defenderName,
+        weaponName,
+        attackRoll,
+        attackWeaponId,
+        attackRollType,
+        attackRollKey,
+        attackD30result,
+        attackD30message,
+        attackRerollContext,
+        combatantId,
+        tokenId,
+        isRanged: isRangedAttack
+      }

-    // 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)
-    }
+      // 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)
+      }

-    // 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) : []
+      // 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) : []

-    // 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"
+      // 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
+      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 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" }
        })
-        messageSent = true
+        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)
    })
-
-    // 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
@@ -823,6 +802,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
@@ -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
@@ -130,6 +140,17 @@ 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;
+    for (let c of this.combatants) {
+      if (c.actor.type !== "monster") continue;
+      if (c.initiative !== null && currentRound >= c.initiative) {
+        await c.actor.system.rollProgressionDice(this.id, c.id);
+      }
+    }
+  }
+
  resetProgression(cId) {
    let c = this.combatants.get(cId);
    c.update({ 'system.progressionCount': 0 });
@@ -203,6 +224,7 @@ export class LethalFantasyCombat extends Combat {

    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 });
@@ -147,6 +147,6 @@ export async function rollFreeDie(dieType, count = 1, explode = false) {
    content,
    sound: CONFIG.sounds.dice,
  }
-  ChatMessage.applyRollMode(msgData, rollMode)
+  ChatMessage.applyMode(msgData, rollMode)
  await ChatMessage.create(msgData)
 }
@@ -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) {
@@ -111,7 +111,7 @@ 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) {
@@ -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)
@@ -272,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")) {
@@ -289,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")) {
@@ -302,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
+      }
    }


@@ -311,7 +320,7 @@ 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)]))
+    const rollModes = foundry.utils.duplicate(CONFIG.ChatMessage.modes);
    console.log("Roll mode", rollModes)

    const fieldRollMode = new foundry.data.fields.StringField({
@@ -497,7 +506,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,
@@ -666,7 +676,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,
@@ -720,7 +730,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)
    }
@@ -734,7 +744,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,
@@ -991,7 +1001,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)
        }
@@ -1033,7 +1043,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,
@@ -1322,11 +1332,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,
@@ -1344,7 +1354,7 @@ export default class LethalFantasyRoll extends Roll {
        rollData: this.rollData,
        ...messageData,
      },
-      { rollMode, create },
+      { messageMode, create },
    )
  }

@@ -297,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) {
@@ -318,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) {
@@ -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,8 +124,8 @@ 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({
@@ -141,6 +142,15 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
      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
  }

@@ -170,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) {
@@ -182,6 +192,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
        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
        }
@@ -259,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)
@@ -294,7 +305,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) {
@@ -306,7 +317,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,
@@ -334,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: [
@@ -375,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
@@ -1061,25 +1092,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
@@ -1 +1 @@
-MANIFEST-000579
+MANIFEST-000591
@@ -1,8 +1,8 @@
-2026/04/30-14:38:06.808992 7f3f35bff6c0 Recovering log #577
-2026/04/30-14:38:06.818757 7f3f35bff6c0 Delete type=3 #575
-2026/04/30-14:38:06.818831 7f3f35bff6c0 Delete type=0 #577
-2026/04/30-14:38:35.518816 7f3ee77fe6c0 Level-0 table #582: started
-2026/04/30-14:38:35.518836 7f3ee77fe6c0 Level-0 table #582: 0 bytes OK
-2026/04/30-14:38:35.525869 7f3ee77fe6c0 Delete type=0 #580
-2026/04/30-14:38:35.538258 7f3ee77fe6c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
-2026/04/30-14:38:35.538288 7f3ee77fe6c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
+2026/05/17-11:57:50.231387 7f16423fc6c0 Recovering log #589
+2026/05/17-11:57:50.249229 7f16423fc6c0 Delete type=3 #587
+2026/05/17-11:57:50.249281 7f16423fc6c0 Delete type=0 #589
+2026/05/17-13:21:53.429711 7f1641bfb6c0 Level-0 table #594: started
+2026/05/17-13:21:53.429759 7f1641bfb6c0 Level-0 table #594: 0 bytes OK
+2026/05/17-13:21:53.437714 7f1641bfb6c0 Delete type=0 #592
+2026/05/17-13:21:53.449134 7f1641bfb6c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
+2026/05/17-13:21:53.461721 7f1641bfb6c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
@@ -1,8 +1,8 @@
-2026/04/29-20:13:54.005832 7fed937fe6c0 Recovering log #573
-2026/04/29-20:13:54.016172 7fed937fe6c0 Delete type=3 #571
-2026/04/29-20:13:54.016279 7fed937fe6c0 Delete type=0 #573
-2026/04/29-20:27:06.418200 7feb10fff6c0 Level-0 table #578: started
-2026/04/29-20:27:06.418231 7feb10fff6c0 Level-0 table #578: 0 bytes OK
-2026/04/29-20:27:06.424568 7feb10fff6c0 Delete type=0 #576
-2026/04/29-20:27:06.431809 7feb10fff6c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
-2026/04/29-20:27:06.431871 7feb10fff6c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
+2026/05/02-08:40:55.892385 7fd7557ee6c0 Recovering log #585
+2026/05/02-08:40:55.903385 7fd7557ee6c0 Delete type=3 #583
+2026/05/02-08:40:55.903442 7fd7557ee6c0 Delete type=0 #585
+2026/05/02-08:41:12.057856 7fd7477fe6c0 Level-0 table #590: started
+2026/05/02-08:41:12.057882 7fd7477fe6c0 Level-0 table #590: 0 bytes OK
+2026/05/02-08:41:12.121845 7fd7477fe6c0 Delete type=0 #588
+2026/05/02-08:41:12.122077 7fd7477fe6c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
+2026/05/02-08:41:12.122121 7fd7477fe6c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
@@ -1 +1 @@
-MANIFEST-000576
+MANIFEST-000588
@@ -1,8 +1,8 @@
-2026/04/30-14:38:06.823818 7f3f353fe6c0 Recovering log #574
-2026/04/30-14:38:06.834104 7f3f353fe6c0 Delete type=3 #572
-2026/04/30-14:38:06.834187 7f3f353fe6c0 Delete type=0 #574
-2026/04/30-14:38:35.525993 7f3ee77fe6c0 Level-0 table #579: started
-2026/04/30-14:38:35.526019 7f3ee77fe6c0 Level-0 table #579: 0 bytes OK
-2026/04/30-14:38:35.532067 7f3ee77fe6c0 Delete type=0 #577
-2026/04/30-14:38:35.538267 7f3ee77fe6c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
-2026/04/30-14:38:35.538302 7f3ee77fe6c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
+2026/05/17-11:57:50.260046 7f16433fe6c0 Recovering log #586
+2026/05/17-11:57:50.276348 7f16433fe6c0 Delete type=3 #584
+2026/05/17-11:57:50.276460 7f16433fe6c0 Delete type=0 #586
+2026/05/17-13:21:53.474443 7f1641bfb6c0 Level-0 table #591: started
+2026/05/17-13:21:53.474485 7f1641bfb6c0 Level-0 table #591: 0 bytes OK
+2026/05/17-13:21:53.481502 7f1641bfb6c0 Delete type=0 #589
+2026/05/17-13:21:53.490389 7f1641bfb6c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
+2026/05/17-13:21:53.512946 7f1641bfb6c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
@@ -1,8 +1,8 @@
-2026/04/29-20:13:54.023030 7fed93fff6c0 Recovering log #570
-2026/04/29-20:13:54.032615 7fed93fff6c0 Delete type=3 #568
-2026/04/29-20:13:54.032677 7fed93fff6c0 Delete type=0 #570
-2026/04/29-20:27:06.286266 7feb10fff6c0 Level-0 table #575: started
-2026/04/29-20:27:06.286286 7feb10fff6c0 Level-0 table #575: 0 bytes OK
-2026/04/29-20:27:06.292048 7feb10fff6c0 Delete type=0 #573
-2026/04/29-20:27:06.299186 7feb10fff6c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
-2026/04/29-20:27:06.299236 7feb10fff6c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
+2026/05/02-08:40:55.909564 7fd747fff6c0 Recovering log #582
+2026/05/02-08:40:55.919159 7fd747fff6c0 Delete type=3 #580
+2026/05/02-08:40:55.919214 7fd747fff6c0 Delete type=0 #582
+2026/05/02-08:41:11.999050 7fd7477fe6c0 Level-0 table #587: started
+2026/05/02-08:41:11.999076 7fd7477fe6c0 Level-0 table #587: 0 bytes OK
+2026/05/02-08:41:12.057672 7fd7477fe6c0 Delete type=0 #585
+2026/05/02-08:41:12.122063 7fd7477fe6c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
+2026/05/02-08:41:12.122111 7fd7477fe6c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
@@ -1 +1 @@
-MANIFEST-000581
+MANIFEST-000593
@@ -1,8 +1,8 @@
-2026/04/30-14:38:06.795186 7f3f353fe6c0 Recovering log #579
-2026/04/30-14:38:06.805935 7f3f353fe6c0 Delete type=3 #577
-2026/04/30-14:38:06.805994 7f3f353fe6c0 Delete type=0 #579
-2026/04/30-14:38:35.512680 7f3ee77fe6c0 Level-0 table #584: started
-2026/04/30-14:38:35.512729 7f3ee77fe6c0 Level-0 table #584: 0 bytes OK
-2026/04/30-14:38:35.518704 7f3ee77fe6c0 Delete type=0 #582
-2026/04/30-14:38:35.538247 7f3ee77fe6c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
-2026/04/30-14:38:35.538281 7f3ee77fe6c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
+2026/05/17-11:57:50.206131 7f1643bff6c0 Recovering log #591
+2026/05/17-11:57:50.222037 7f1643bff6c0 Delete type=3 #589
+2026/05/17-11:57:50.222089 7f1643bff6c0 Delete type=0 #591
+2026/05/17-13:21:53.292176 7f1641bfb6c0 Level-0 table #596: started
+2026/05/17-13:21:53.292219 7f1641bfb6c0 Level-0 table #596: 0 bytes OK
+2026/05/17-13:21:53.299322 7f1641bfb6c0 Delete type=0 #594
+2026/05/17-13:21:53.306548 7f1641bfb6c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
+2026/05/17-13:21:53.318889 7f1641bfb6c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
@@ -1,8 +1,8 @@
-2026/04/29-20:13:53.990808 7fed927fc6c0 Recovering log #575
-2026/04/29-20:13:54.001559 7fed927fc6c0 Delete type=3 #573
-2026/04/29-20:13:54.001699 7fed927fc6c0 Delete type=0 #575
-2026/04/29-20:27:06.273802 7feb10fff6c0 Level-0 table #580: started
-2026/04/29-20:27:06.273877 7feb10fff6c0 Level-0 table #580: 0 bytes OK
-2026/04/29-20:27:06.280252 7feb10fff6c0 Delete type=0 #578
-2026/04/29-20:27:06.299161 7feb10fff6c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
-2026/04/29-20:27:06.299217 7feb10fff6c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
+2026/05/02-08:40:55.873571 7fd747fff6c0 Recovering log #587
+2026/05/02-08:40:55.883892 7fd747fff6c0 Delete type=3 #585
+2026/05/02-08:40:55.883950 7fd747fff6c0 Delete type=0 #587
+2026/05/02-08:41:11.870087 7fd7477fe6c0 Level-0 table #592: started
+2026/05/02-08:41:11.870140 7fd7477fe6c0 Level-0 table #592: 0 bytes OK
+2026/05/02-08:41:11.937524 7fd7477fe6c0 Delete type=0 #590
+2026/05/02-08:41:12.122025 7fd7477fe6c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
+2026/05/02-08:41:12.122087 7fd7477fe6c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
@@ -1 +1 @@
-MANIFEST-000276
+MANIFEST-000288
@@ -1,8 +1,8 @@
-2026/04/30-14:38:06.849252 7f3f353fe6c0 Recovering log #274
-2026/04/30-14:38:06.859072 7f3f353fe6c0 Delete type=3 #272
-2026/04/30-14:38:06.859126 7f3f353fe6c0 Delete type=0 #274
-2026/04/30-14:38:35.538433 7f3ee77fe6c0 Level-0 table #279: started
-2026/04/30-14:38:35.538452 7f3ee77fe6c0 Level-0 table #279: 0 bytes OK
-2026/04/30-14:38:35.544715 7f3ee77fe6c0 Delete type=0 #277
-2026/04/30-14:38:35.567736 7f3ee77fe6c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
-2026/04/30-14:38:35.567785 7f3ee77fe6c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
+2026/05/17-11:57:50.303535 7f16433fe6c0 Recovering log #286
+2026/05/17-11:57:50.318955 7f16433fe6c0 Delete type=3 #284
+2026/05/17-11:57:50.319061 7f16433fe6c0 Delete type=0 #286
+2026/05/17-13:21:53.481662 7f1641bfb6c0 Level-0 table #291: started
+2026/05/17-13:21:53.481693 7f1641bfb6c0 Level-0 table #291: 0 bytes OK
+2026/05/17-13:21:53.490187 7f1641bfb6c0 Delete type=0 #289
+2026/05/17-13:21:53.502325 7f1641bfb6c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
+2026/05/17-13:21:53.512979 7f1641bfb6c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
@@ -1,8 +1,8 @@
-2026/04/29-20:13:54.051682 7fed937fe6c0 Recovering log #270
-2026/04/29-20:13:54.062010 7fed937fe6c0 Delete type=3 #268
-2026/04/29-20:13:54.062071 7fed937fe6c0 Delete type=0 #270
-2026/04/29-20:27:06.292128 7feb10fff6c0 Level-0 table #275: started
-2026/04/29-20:27:06.292152 7feb10fff6c0 Level-0 table #275: 0 bytes OK
-2026/04/29-20:27:06.299041 7feb10fff6c0 Delete type=0 #273
-2026/04/29-20:27:06.299199 7feb10fff6c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
-2026/04/29-20:27:06.299226 7feb10fff6c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
+2026/05/02-08:40:55.939668 7fd754fed6c0 Recovering log #282
+2026/05/02-08:40:55.949715 7fd754fed6c0 Delete type=3 #280
+2026/05/02-08:40:55.949784 7fd754fed6c0 Delete type=0 #282
+2026/05/02-08:41:12.184448 7fd7477fe6c0 Level-0 table #287: started
+2026/05/02-08:41:12.184496 7fd7477fe6c0 Level-0 table #287: 0 bytes OK
+2026/05/02-08:41:12.252892 7fd7477fe6c0 Delete type=0 #285
+2026/05/02-08:41:12.365481 7fd7477fe6c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
+2026/05/02-08:41:12.365509 7fd7477fe6c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
@@ -1 +1 @@
-MANIFEST-000575
+MANIFEST-000587
@@ -1,8 +1,8 @@
-2026/04/30-14:38:06.836968 7f3ee7fff6c0 Recovering log #573
-2026/04/30-14:38:06.846980 7f3ee7fff6c0 Delete type=3 #571
-2026/04/30-14:38:06.847050 7f3ee7fff6c0 Delete type=0 #573
-2026/04/30-14:38:35.532186 7f3ee77fe6c0 Level-0 table #578: started
-2026/04/30-14:38:35.532209 7f3ee77fe6c0 Level-0 table #578: 0 bytes OK
-2026/04/30-14:38:35.538132 7f3ee77fe6c0 Delete type=0 #576
-2026/04/30-14:38:35.538276 7f3ee77fe6c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
-2026/04/30-14:38:35.538295 7f3ee77fe6c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
+2026/05/17-11:57:50.282340 7f16423fc6c0 Recovering log #585
+2026/05/17-11:57:50.297125 7f16423fc6c0 Delete type=3 #583
+2026/05/17-11:57:50.297189 7f16423fc6c0 Delete type=0 #585
+2026/05/17-13:21:53.299508 7f1641bfb6c0 Level-0 table #590: started
+2026/05/17-13:21:53.299854 7f1641bfb6c0 Level-0 table #590: 0 bytes OK
+2026/05/17-13:21:53.306309 7f1641bfb6c0 Delete type=0 #588
+2026/05/17-13:21:53.318877 7f1641bfb6c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
+2026/05/17-13:21:53.325564 7f1641bfb6c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
@@ -1,8 +1,8 @@
-2026/04/29-20:13:54.036694 7fed92ffd6c0 Recovering log #569
-2026/04/29-20:13:54.047834 7fed92ffd6c0 Delete type=3 #567
-2026/04/29-20:13:54.047922 7fed92ffd6c0 Delete type=0 #569
-2026/04/29-20:27:06.280338 7feb10fff6c0 Level-0 table #574: started
-2026/04/29-20:27:06.280357 7feb10fff6c0 Level-0 table #574: 0 bytes OK
-2026/04/29-20:27:06.286179 7feb10fff6c0 Delete type=0 #572
-2026/04/29-20:27:06.299174 7feb10fff6c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
-2026/04/29-20:27:06.299209 7feb10fff6c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
+2026/05/02-08:40:55.925402 7fd755fef6c0 Recovering log #581
+2026/05/02-08:40:55.935869 7fd755fef6c0 Delete type=3 #579
+2026/05/02-08:40:55.935924 7fd755fef6c0 Delete type=0 #581
+2026/05/02-08:41:11.937698 7fd7477fe6c0 Level-0 table #586: started
+2026/05/02-08:41:11.937727 7fd7477fe6c0 Level-0 table #586: 0 bytes OK
+2026/05/02-08:41:11.998871 7fd7477fe6c0 Delete type=0 #584
+2026/05/02-08:41:12.122041 7fd7477fe6c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
+2026/05/02-08:41:12.122099 7fd7477fe6c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
@@ -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);
@@ -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"
@@ -51,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">

@@ -98,6 +101,9 @@
        <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">

@@ -119,6 +125,36 @@

      </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>
@@ -149,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">
Author	SHA1	Message	Date
uberwald	db3e8b5d35	Improve init for monsters and some fixwes around shields Release Creation / build (release) Successful in 48s Details	2026-05-17 13:22:29 +02:00
uberwald	54421e4a83	MAnage spell/miracle spending points and favor/disfavor for shield rolls Release Creation / build (release) Successful in 43s Details	2026-05-10 17:49:53 +02:00
uberwald	ac44419b7a	Corredction sur attack ranged	2026-05-03 15:12:25 +02:00
uberwald	a3fc0a42b9	Corredction sur attack ranged Release Creation / build (release) Successful in 1m19s Details	2026-05-03 10:06:44 +02:00
uberwald	c8ce840e98	Fix ranged defense + HTH attacks Release Creation / build (release) Successful in 1m17s Details	2026-05-02 08:35:22 +02:00
uberwald	55a040062a	Fix ranged defense + HTH attacks Release Creation / build (release) Successful in 1m19s Details	2026-05-01 23:55:29 +02:00
uberwald	1818a76499	Fix ranged defense + HTH attacks Release Creation / build (release) Successful in 1m19s Details	2026-05-01 23:34:05 +02:00
uberwald	55d1b41ca4	Fix ranged defense + HTH attacks	2026-05-01 23:32:53 +02:00