Fix ranged attacks again

Add ranged actions for monsters
2026-05-24 09:42:07 +02:00 · 2026-05-24 09:41:06 +02:00 · 2026-05-23 19:10:10 +02:00 · 2026-05-23 09:08:16 +02:00 · 2026-05-23 00:21:05 +02:00 · 2026-05-23 00:11:58 +02:00
60 changed files with 1613 additions and 548 deletions
@@ -59,5 +59,5 @@ jobs:
          version: ${{github.event.release.tag_name}}
          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-minimum: "14"
+          compatibility-verified: "14"
@@ -0,0 +1,62 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with this repository.
+
+## Overview
+
+FoundryVTT v13+ game system for the **Lethal Fantasy RPG**. Entry point: `lethal-fantasy.mjs`.
+
+## Commands
+
+```bash
+# Compile LESS styles (styles/ -> css/)
+npx gulp css          # one-shot
+npx gulp              # compile + watch
+
+# Lint
+npx eslint .
+
+# Compendium pack management (LevelDB <-> YAML source)
+npm run pushLDBtoYML   # export packs-system/ LevelDB -> source YAML
+npm run pullYMLtoLDB   # import source YAML -> packs-system/ LevelDB
+```
+
+No test suite exists.
+
+## Architecture
+
+Four layers in `module/`, all wired in `lethal-fantasy.mjs` via the `init` hook:
+
+| Layer | Path | Purpose |
+|---|---|---|
+| Config | `module/config/` | Game constants. `SYSTEM` is `globalThis.SYSTEM` — always use `SYSTEM.*` for enumerations. |
+| Models | `module/models/` | `TypeDataModel` subclasses — data schemas per document type. |
+| Documents | `module/documents/` | Actor/Item/Roll/ChatMessage subclasses — game logic, roll processing, hooks. |
+| Applications | `module/applications/` | `ApplicationV2` sheets + custom combat tracker. |
+
+**Actor types**: `character`, `monster`
+**Item types**: `skill`, `gift`, `vulnerability`, `weapon`, `armor`, `shield`, `spell`, `miracle`, `equipment`
+
+Each layer has an `_module.mjs` barrel file that re-exports all classes from that layer.
+
+Templates (`.hbs`) live in `templates/`. Styles are authored in LESS under `styles/` and compiled to `css/`.
+
+### Key Patterns
+
+- **Sheets**: Extend `HandlebarsApplicationMixin(foundry.applications.sheets.ActorSheetV2)` — imported from `foundry.applications.api`. **Not** the legacy `ActorSheet`. Child sheets (e.g. `character-sheet.mjs`) extend `base-actor-sheet.mjs` and override `static PARTS` and `DEFAULT_OPTIONS.actions`. Template paths are prefixed `systems/fvtt-lethal-fantasy/templates/`. Actor sheets have a play/edit toggle via `_sheetMode` and `SHEET_MODES`.
+- **Models**: `static defineSchema()` using `foundry.data.fields.*`. Field definitions derived from SYSTEM config objects.
+- **Rolls**: `LethalFantasyRoll` extends `Roll` with rich metadata via `this.options`. `D30Roll` is a separate class for D30 result tables (initialized in the `ready` hook).
+- **Socket**: Events use `game.socket.on(\`system.${SYSTEM.id}\`, ...)`. Multi-player attack-defense uses a global `pendingDefenses` Map.
+- **i18n**: All user-visible strings are keys in `lang/en.json` as `LETHALFANTASY.Category.Key`. Always use `game.i18n.localize(key)`.
+
+### Compendium Packs
+
+Five LevelDB packs in `packs-system/`: skills, equipment, gifts, vulnerabilities, spells-miracles. Use the `tools/` scripts to export/import editable YAML.
+
+## Code Style
+
+- No semicolons, double quotes, 2-space indent
+- JSDoc `/** */` required on all functions/classes
+- Max line length 180 (strings/templates exempt)
+- Arrow functions: omit parens for single param
+- ESLint + Prettier config in `eslint.config.mjs`
@@ -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);
@@ -1988,9 +2027,12 @@ i.lethalfantasy {
  background: #4a4940 !important;
  color: #ffffff !important;
 }
+.lethalfantasy .grit-luck-dialog {
+  color: var(--color-text-dark-primary, #191813);
+}
 .lethalfantasy .grit-luck-dialog .combat-status {
  padding: 12px;
-  background: linear-gradient(to bottom, rgba(42, 41, 32, 0.8) 0%, rgba(26, 25, 16, 0.9) 100%);
+  background: linear-gradient(to bottom, rgba(42, 41, 32, 0.88) 0%, rgba(26, 25, 16, 0.95) 100%);
  border: 1px solid rgba(212, 175, 55, 0.5);
  border-radius: 6px;
  margin-bottom: 16px;
@@ -2010,11 +2052,25 @@ i.lethalfantasy {
  margin-top: 8px;
 }
 .lethalfantasy .grit-luck-dialog .offer-text {
-  color: #f0e6d2;
+  color: var(--color-text-dark-primary, #191813);
  font-size: calc(var(--font-size-standard) * 1);
  text-align: center;
  font-weight: 600;
+  margin: 0 0 8px 0;
+}
+.lethalfantasy .grit-luck-dialog .shield-warning {
+  color: #7a4000;
+  background: rgba(255, 160, 0, 0.12);
+  border: 1px solid rgba(255, 160, 0, 0.4);
+  border-radius: 5px;
+  font-size: calc(var(--font-size-standard) * 0.88);
+  padding: 6px 10px;
  margin: 0;
+  text-align: center;
+}
+.lethalfantasy .grit-luck-dialog .shield-warning i {
+  color: #c07000;
+  margin-right: 5px;
 }
 .lethalfantasy .attack-result {
  padding: 16px;
@@ -2105,31 +2161,66 @@ i.lethalfantasy {
  color: #d4af37;
 }
 .lethalfantasy .attack-result .attack-result-damage {
-  display: flex;
+  display: grid;
+  grid-template-columns: repeat(2, 1fr);
  gap: 8px;
-  justify-content: center;
+}
+.lethalfantasy .attack-result .attack-result-damage.single-btn {
+  grid-template-columns: 1fr;
+  max-width: 280px;
+  margin: 0 auto;
+}
+.lethalfantasy .attack-result .attack-result-damage.spell-damage {
+  grid-template-columns: 1fr;
+  width: 100%;
 }
 .lethalfantasy .attack-result .attack-result-damage .roll-damage-btn {
-  padding: 10px 16px;
+  padding: 10px 14px;
  background: linear-gradient(to bottom, #8b0000 0%, #660000 100%);
-  border: 1px solid #ff0000;
+  border: 1px solid #4b0000;
  border-radius: 6px;
  color: #f0e6d2;
  font-weight: 600;
+  font-size: calc(var(--font-size-standard) * 0.9);
+  text-align: center;
+  white-space: nowrap;
  cursor: pointer;
  transition: all 0.2s ease;
-  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.3);
+  box-shadow: 0 3px 6px rgba(0, 0, 0, 0.4), inset 0 1px 0 rgba(255, 255, 255, 0.1);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 6px;
+  position: relative;
+  overflow: hidden;
+}
+.lethalfantasy .attack-result .attack-result-damage .roll-damage-btn::before {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: -100%;
+  width: 100%;
+  height: 100%;
+  background: linear-gradient(90deg, transparent, rgba(255, 255, 255, 0.15), transparent);
+  transition: left 0.5s;
+}
+.lethalfantasy .attack-result .attack-result-damage .roll-damage-btn:hover::before {
+  left: 100%;
+}
+.lethalfantasy .attack-result .attack-result-damage .roll-damage-btn i {
+  font-size: calc(var(--font-size-standard) * 1.1);
+  filter: drop-shadow(0 1px 2px rgba(0, 0, 0, 0.5));
+  flex-shrink: 0;
 }
 .lethalfantasy .attack-result .attack-result-damage .roll-damage-btn:hover {
  background: linear-gradient(to bottom, #a00000 0%, #7b0000 100%);
-  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.4);
+  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.5), inset 0 1px 0 rgba(255, 255, 255, 0.15);
  transform: translateY(-2px);
+  border-color: #5b0000;
 }
 .lethalfantasy .attack-result .attack-result-damage .roll-damage-btn:active {
  transform: translateY(0);
-}
-.lethalfantasy .attack-result .attack-result-damage .roll-damage-btn i {
-  margin-right: 6px;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.4), inset 0 1px 3px rgba(0, 0, 0, 0.3);
 }
 .lethalfantasy .equipment-content {
  font-family: var(--font-primary);
@@ -2595,6 +2686,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,
@@ -3889,35 +3995,74 @@ i.lethalfantasy {
 }
 .message .attack-result .attack-result-damage,
 .attack-result .attack-result-damage {
-  display: flex;
+  display: grid;
+  grid-template-columns: repeat(2, 1fr);
  gap: 8px;
-  justify-content: center;
+}
+.message .attack-result .attack-result-damage.single-btn,
+.attack-result .attack-result-damage.single-btn {
+  grid-template-columns: 1fr;
+  max-width: 280px;
+  margin: 0 auto;
+}
+.message .attack-result .attack-result-damage.spell-damage,
+.attack-result .attack-result-damage.spell-damage {
+  grid-template-columns: 1fr;
+  width: 100%;
 }
 .message .attack-result .attack-result-damage .roll-damage-btn,
 .attack-result .attack-result-damage .roll-damage-btn {
-  padding: 10px 16px;
+  padding: 10px 14px;
  background: linear-gradient(to bottom, #8b0000 0%, #660000 100%);
-  border: 1px solid #ff0000;
+  border: 1px solid #4b0000;
  border-radius: 6px;
  color: #f0e6d2;
  font-weight: 600;
+  font-size: calc(var(--font-size-standard) * 0.9);
+  text-align: center;
+  white-space: nowrap;
  cursor: pointer;
  transition: all 0.2s ease;
-  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.3);
+  box-shadow: 0 3px 6px rgba(0, 0, 0, 0.4), inset 0 1px 0 rgba(255, 255, 255, 0.1);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 6px;
+  position: relative;
+  overflow: hidden;
+}
+.message .attack-result .attack-result-damage .roll-damage-btn::before,
+.attack-result .attack-result-damage .roll-damage-btn::before {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: -100%;
+  width: 100%;
+  height: 100%;
+  background: linear-gradient(90deg, transparent, rgba(255, 255, 255, 0.15), transparent);
+  transition: left 0.5s;
+}
+.message .attack-result .attack-result-damage .roll-damage-btn:hover::before,
+.attack-result .attack-result-damage .roll-damage-btn:hover::before {
+  left: 100%;
+}
+.message .attack-result .attack-result-damage .roll-damage-btn i,
+.attack-result .attack-result-damage .roll-damage-btn i {
+  font-size: calc(var(--font-size-standard) * 1.1);
+  filter: drop-shadow(0 1px 2px rgba(0, 0, 0, 0.5));
+  flex-shrink: 0;
 }
 .message .attack-result .attack-result-damage .roll-damage-btn:hover,
 .attack-result .attack-result-damage .roll-damage-btn:hover {
  background: linear-gradient(to bottom, #a00000 0%, #7b0000 100%);
-  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.4);
+  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.5), inset 0 1px 0 rgba(255, 255, 255, 0.15);
  transform: translateY(-2px);
+  border-color: #5b0000;
 }
 .message .attack-result .attack-result-damage .roll-damage-btn:active,
 .attack-result .attack-result-damage .roll-damage-btn:active {
  transform: translateY(0);
-}
-.message .attack-result .attack-result-damage .roll-damage-btn i,
-.attack-result .attack-result-damage .roll-damage-btn i {
-  margin-right: 6px;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.4), inset 0 1px 3px rgba(0, 0, 0, 0.3);
 }
 #token-hud .hp-loss-wrap {
  position: absolute;
@@ -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,8 +462,17 @@
      "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",
+      "rangeAttackDialog": "Ranged attack dialog",
+      "rangeAttackRoll": "Ranged attack roll",
      "rangedAttackDefense": "Ranged attack defense",
      "resource": "Resource",
      "resources": "Resources",
@@ -500,7 +509,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": {
@@ -556,6 +598,15 @@
        },
        "savingThrow": {
          "label": "Saving throw"
+        },
+        "damageDiceOverpowered": {
+          "label": "Overpowered Damage Dice"
+        },
+        "damageDiceOverpowered2": {
+          "label": "Overpowered 2 Damage Dice"
+        },
+        "damageDice": {
+          "label": "Damage Dice"
        }
      }
    },
@@ -677,7 +728,8 @@
            "label": "Min"
          }
        }
-      }
+      },
+      "autoDestruction": "Auto-Destruction"
    },
    "Skill": {
      "Category": {
@@ -802,6 +854,12 @@
        },
        "damageDice": {
          "label": "Damage dice"
+        },
+        "damageDiceOverpowered": {
+          "label": "Overpowered Damage Dice"
+        },
+        "damageDiceOverpowered2": {
+          "label": "Overpowered 2 Damage Dice"
        }
      },
      "Range": {
@@ -836,7 +894,9 @@
        }
      }
    },
-    "Warning": {},
+    "Warning": {
+      "defenseShieldOrder": "To avoid a hit without using the shield, roll Grit or Luck first — then roll the shield."
+    },
    "Weapon": {
      "FIELDS": {
        "isAgile": {
@@ -981,6 +1041,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",
@@ -129,93 +129,76 @@ 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") ?? "="
+      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) => {
+    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
@@ -247,9 +230,15 @@ Hooks.on(hookName, (message, html, data) => {
      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
+      const rollTargetData = message.rolls[0]?.rollTarget
+      // For spell/miracle attacks, rollTarget IS the spell item (serialised as its data object).
+      // For weapon attacks, rollTarget is a plain skill+weapon object and weapon.id is the weapon.
+      const isSpellMiracleAttack = attackRollType === "spell-attack" || attackRollType === "miracle-attack"
+      const attackWeaponId = isSpellMiracleAttack
+        ? (rollTargetData?._id || rollTargetData?.id)
+        : (rollTargetData?.weapon?.id || rollTargetData?.weapon?._id)
+      const attackRollKey = rollTargetData?.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
@@ -265,33 +254,37 @@ Hooks.on(hookName, (message, html, data) => {
      }

      // Préparer le message de demande de défense
-    // Récupérer l'acteur attaquant pour vérifier le mode d'attaque
+      // 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 isRangedAttack = attacker?.type === "monster" && attacker.system.attackMode === "ranged"
+      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")
+        || (rollTargetOptions?.isRangedAttack === true)

      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,
+        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")
-    )
+      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)
      }
@@ -317,10 +310,7 @@ Hooks.on(hookName, (message, html, data) => {
          messageSent = true
        } else {
          // Sinon, envoyer via socket
-        game.socket.emit(`system.${SYSTEM.id}`, {
-          ...defenseMsg,
-          userId: owner.id
-        })
+          game.socket.emit(`system.${SYSTEM.id}`, { ...defenseMsg, userId: owner.id })
          messageSent = true
        }
      })
@@ -330,55 +320,89 @@ Hooks.on(hookName, (message, html, data) => {
        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) => {
+  for (const btn of html.querySelectorAll(".damage-roll-btn, .roll-damage-btn")) {
+    btn.addEventListener("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")
+      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)
-    let actor = attackerId ? game.actors.get(attackerId) : game.actors.get(message.rolls[0]?.actorId)
+      const 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
+      // Pour les sorts, rouler les dés de dégâts avec DR manuelle optionnelle
      if (damageType === "spell" && damageFormula) {
-      const bypassArmor = await foundry.applications.api.DialogV2.confirm({
-        window: { title: "Spell Damage" },
+        const manualDR = await foundry.applications.api.DialogV2.wait({
+          window: { title: game.i18n.localize("LETHALFANTASY.Combat.spellDRDialogTitle") },
          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" }
+          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) => Number(button.form?.elements?.manualDr?.value) || 0
+            },
+            {
+              action: "cancel",
+              label: game.i18n.localize("LETHALFANTASY.Combat.proceedNo"),
+              callback: () => null
+            }
+          ],
+          rejectClose: false
        })
+        if (manualDR === null) return
        const rollOpts = {
          type: "spell-damage",
          rollType: "spell-damage",
          rollName: damageFormula,
          isDamage: true,
          rollData: { isDamage: true },
-        bypassArmor: bypassArmor ?? false,
+          manualDR: manualDR,
          defenderId,
          defenderTokenId,
          actorId: actor.id,
          actorName: actor.name,
          actorImage: actor.img
        }
-      const roll = new LethalFantasyRoll(damageFormula, {}, rollOpts)
+        const roll = new documents.LethalFantasyRoll(damageFormula, {}, rollOpts)
        await roll.evaluate()
+        const diceResults = []
+        for (const term of roll.dice) {
+          for (const r of term.results) {
+            diceResults.push({ dice: `1D${term.faces}`, value: r.result })
+          }
+        }
+        roll.options.diceResults = diceResults
        roll.options.rollTotal = roll.total
        if (game?.dice3d) await game.dice3d.showForRoll(roll, game.user, true)
        await roll.toMessage()
@@ -392,7 +416,7 @@ Hooks.on(hookName, (message, html, data) => {
      }

      // Pour les monstres, utiliser prepareMonsterRoll
-    if (isMonster || actor.type === "monster") {
+      if (isMonster === "true" || actor.type === "monster") {
        await actor.system.prepareMonsterRoll("monster-damage", weaponId, undefined, undefined, damageModifier)
        return
      }
@@ -408,26 +432,21 @@ Hooks.on(hookName, (message, html, data) => {
      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 +842,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
@@ -876,12 +962,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).
@@ -914,7 +1002,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
@@ -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 });
@@ -142,11 +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,
    sound: CONFIG.sounds.dice,
+    mode,
  }
-  ChatMessage.applyRollMode(msgData, rollMode)
  await ChatMessage.create(msgData)
 }
@@ -22,6 +22,7 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
      divinityPointsMinus: LethalFantasyCharacterSheet.#onDivinityPointsMinus,
      aetherPointsPlus: LethalFantasyCharacterSheet.#onAetherPointsPlus,
      aetherPointsMinus: LethalFantasyCharacterSheet.#onAetherPointsMinus,
+      rollSpellDamage: LethalFantasyCharacterSheet.#onRollSpellDamage,
    },
  }

@@ -70,10 +71,10 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
    }
    if (this.actor.system.biodata.magicUser) {
-      tabs.spells = { id: "spells", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" }
+      tabs.spells = { id: "spells", group: "sheet", icon: "fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" }
    }
    if (this.actor.system.biodata.clericUser) {
-      tabs.miracles = { id: "miracles", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-hands-praying", label: "LETHALFANTASY.Label.miracles" }
+      tabs.miracles = { id: "miracles", group: "sheet", icon: "fa-solid fa-hands-praying", label: "LETHALFANTASY.Label.miracles" }
    }
    for (const v of Object.values(tabs)) {
      v.active = this.tabGroups[v.group] === v.id
@@ -172,7 +173,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) {
@@ -219,6 +220,86 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
    this.actor.update({ "system.aetherPoints.value": points })
  }

+  /**
+   * Handles spell damage roll from the spell sheet tab.
+   * Shows a DR dialog then rolls the appropriate damage formula.
+   * @param {PointerEvent} event
+   * @param {HTMLElement} target
+   */
+  static async #onRollSpellDamage(event, target) {
+    if (this.isEditMode) return
+    const itemId = target.dataset.itemId
+    const tier = target.dataset.damageTier
+    const spell = this.actor.items.get(itemId)
+    if (!spell) return
+
+    const formulaMap = {
+      standard: spell.system.damageDice,
+      overpowered: spell.system.damageDiceOverpowered,
+      overpowered2: spell.system.damageDiceOverpowered2,
+    }
+    const formula = formulaMap[tier]
+    if (!formula) return
+
+    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) => Number(button.form?.elements?.manualDr?.value) || 0
+        },
+        {
+          action: "cancel",
+          label: game.i18n.localize("LETHALFANTASY.Combat.proceedNo"),
+          callback: () => null
+        }
+      ],
+      rejectClose: false
+    })
+    if (manualDR === null) return
+
+    const rollOpts = {
+      type: "spell-damage",
+      rollType: "spell-damage",
+      rollName: `${spell.name} — ${formula}`,
+      isDamage: true,
+      rollData: { isDamage: true },
+      manualDR,
+      actorId: this.actor.id,
+      actorName: this.actor.name,
+      actorImage: this.actor.img
+    }
+    const roll = new LethalFantasyRoll(formula, {}, rollOpts)
+    await roll.evaluate()
+    const diceResults = []
+    for (const term of roll.dice) {
+      for (const r of term.results) {
+        diceResults.push({ dice: `1D${term.faces}`, value: r.result })
+      }
+    }
+    roll.options.diceResults = diceResults
+    roll.options.rollTotal = roll.total
+    if (game?.dice3d) await game.dice3d.showForRoll(roll, game.user, true)
+    await roll.toMessage()
+  }
+
  static #onCreateEquipment(event, target) {
  }

@@ -259,9 +340,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)

@@ -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) {
@@ -608,7 +608,12 @@
      },
      "arcane_spell_attack": {
        "type": "spell_calamity",
-        "description": "Possible Spell Calamity or Catastrophe"
+        "description": "A possible spell calamity has occurred"
+      },
+      "melee_attack": {
+        "type": "fumble",
+        "detail": "melee_fumble",
+        "description": "Possible Fumble"
      }
    }
  },
@@ -85,11 +85,18 @@ export const RANGE_CHOICES = {
  "pointblank": { label: "Point Blank (Special)", value: "pointblank" },
  "short": { label: "Short (+0)", value: "0" },
  "medium": { label: "Medium (Red +5)", value: "+5" },
-  "long": { label: "Long (Purle +7)", value: "+7" },
+  "long": { label: "Long (Purple +7)", value: "+7" },
  "extreme": { label: "Extreme (Grey +9)", value: "+9" },
  "beyondskill": { label: "Beyond Skill (Blue +11)", value: "beyondskill" }
 }

+export const ATTACKER_MOVEMENT_CHOICES = {
+  "none": { label: "None / Stationary (D20E Favor)", favor: true, value: "2D20kh" },
+  "walk": { label: "Walk (D20E)", value: "D20" },
+  "incombat": { label: "In Combat (D20E)", value: "D20" },
+  "run": { label: "Jog/Run/Sprint (D20E Disfavor)", disfavor: true, value: "2D20kl" }
+}
+
 export const ATTACKER_AIM_CHOICES = {
  "simple": { label: "Simple (+0)", value: "0" },
  "careful": { label: "Careful (Red +5)", value: "+4" },
@@ -321,6 +328,7 @@ export const SYSTEM = {
  RANGE_CHOICES,
  FAVOR_CHOICES,
  ATTACKER_AIM_CHOICES,
+  ATTACKER_MOVEMENT_CHOICES,
  MORTAL_CHOICES,
  SPELL_CRITICAL,
  MIRACLE_TYPES,
@@ -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)
@@ -245,7 +261,8 @@ export default class LethalFantasyActor extends Actor {
          weapon: weapon,
          weaponSkillModifier: skill.weaponSkillModifier,
          rollKey: rollKey,
-          combat: foundry.utils.duplicate(this.system.combat)
+          combat: foundry.utils.duplicate(this.system.combat),
+          isRangedAttack: weapon.system.weaponType === "ranged"
        }
        if (rollType === "weapon-damage-small" || rollType === "weapon-damage-medium") {
          rollTarget.grantedDice = this.system.granted.damageDice
@@ -263,7 +280,7 @@ export default class LethalFantasyActor extends Actor {
        break
      default:
        ui.notifications.error(game.i18n.localize("LETHALFANTASY.Notifications.rollTypeNotFound") + String(rollType))
-        break
+        return
    }

    // In all cases
@@ -111,17 +111,16 @@ export default class D30Roll {
    if (externalType === "weapon-attack") {
      if (!weapon) {
        console.warn("D30Roll | Weapon object required for weapon-attack type")
-        return this.ROLL_TYPES.MELEE_ATTACK // Default to melee
+        // Fall through to use options.isRanged if available, otherwise default melee
      }
-      return weapon.system?.weaponType === "ranged"
+      return (options.isRanged || weapon?.system?.weaponType === "ranged")
        ? this.ROLL_TYPES.RANGED_ATTACK
        : this.ROLL_TYPES.MELEE_ATTACK
    }

-    // Monster attacks - default to melee
+    // Monster attacks - check options.isRanged (set from rollTarget.attackMode) or weapon type
    if (externalType === "monster-attack") {
-      // Check if weapon object has range information
-      if (weapon?.system?.weaponType === "ranged") {
+      if (options.isRanged || weapon?.system?.weaponType === "ranged") {
        return this.ROLL_TYPES.RANGED_ATTACK
      }
      return this.ROLL_TYPES.MELEE_ATTACK
@@ -237,6 +237,7 @@ export default class LethalFantasyRoll extends Roll {
      baseFormula = "D20"
      hasModifier = true
      hasChangeDice = false
+      hasFavor = true
      options.rollTarget.value = options.rollTarget.actorModifiers.levelSpellModifier + options.rollTarget.actorModifiers.intSpellModifier
      options.rollTarget.charModifier = options.rollTarget.actorModifiers.intSpellModifier
      hasStaticModifier = options.rollType === "spell-power"
@@ -253,6 +254,7 @@ export default class LethalFantasyRoll extends Roll {
      dice = "1D20"
      baseFormula = "D20"
      hasChangeDice = false
+      hasFavor = true
      options.rollTarget.value = options.rollTarget.actorModifiers.levelMiracleModifier + options.rollTarget.actorModifiers.chaMiracleModifier
      options.rollTarget.charModifier = options.rollTarget.actorModifiers.chaMiracleModifier
      hasStaticModifier = options.rollType === "miracle-power"
@@ -272,6 +274,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 +292,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 +309,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,8 +322,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,
@@ -327,6 +338,10 @@ export default class LethalFantasyRoll extends Roll {
    let modifier = "+0"
    let targetName

+    // True for any ranged attack: PC weapon (ranged type) or monster attack (ranged mode)
+    const isRangedAttack = (options.rollType === "weapon-attack" && options.rollTarget?.weapon?.system?.weaponType === "ranged")
+      || (options.rollType === "monster-attack" && options.rollTarget?.attackMode === "ranged")
+
    let dialogContext = {
      rollType: options.rollType,
      rollTarget: options.rollTarget,
@@ -351,7 +366,8 @@ export default class LethalFantasyRoll extends Roll {
      modifier,
      saveSpell: false,
      favor: "none",
-      targetName
+      targetName,
+      isRangedAttack
    }
    let rollContext
    if (options.rollContext) {
@@ -361,7 +377,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}`
@@ -381,7 +399,7 @@ export default class LethalFantasyRoll extends Roll {
            label: label,
            callback: (event, button, dialog) => {
              console.log("Roll context", event, button, dialog)
-              let position = dialog.position
+              let position = dialog?.position
              game.user.setFlag(SYSTEM.id, "roll-dialog-pos", foundry.utils.duplicate(position))
              const output = Array.from(button.form.elements).reduce((obj, input) => {
                if (input.name) obj[input.name] = input.value
@@ -392,22 +410,22 @@ export default class LethalFantasyRoll extends Roll {
          },
        ],
        actions: {
-          "selectGranted": (event, button, dialog) => {
+          "selectGranted": (event, button) => {
            hasGrantedDice = event.target.checked
          },
-          "selectBeyondSkill": (event, button, dialog) => {
+          "selectBeyondSkill": (event, button) => {
            beyondSkill = button.checked
          },
-          "selectPointBlank": (event, button, dialog) => {
+          "selectPointBlank": (event, button) => {
            pointBlank = button.checked
          },
-          "selectLetItFly": (event, button, dialog) => {
+          "selectLetItFly": (event, button) => {
            letItFly = button.checked
          },
-          "saveSpellCheck": (event, button, dialog) => {
+          "saveSpellCheck": (event, button) => {
            saveSpell = button.checked
          },
-          "gotoToken": (event, button, dialog) => {
+          "gotoToken": (event, button) => {
            let tokenId = $(button).data("tokenId")
            let token = canvas.tokens?.get(tokenId)
            if (token) {
@@ -497,7 +515,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,
@@ -580,12 +599,17 @@ export default class LethalFantasyRoll extends Roll {
      }
      options.D30result = rollD30.total

-      // Récupérer le message D30 correspondant
+      // Compute isRanged for D30: covers defense (isRangedDefense), monster ranged attacks (attackMode),
+      // and PC weapon attacks (isRangedAttack or weaponType)
+      const isRangedForD30 = options.isRangedDefense
+        || options.rollTarget?.attackMode === "ranged"
+        || options.rollTarget?.isRangedAttack === true
+        || options.rollTarget?.weapon?.system?.weaponType === "ranged"
      const d30Message = D30Roll.getResult(
        rollD30.total,
        options.rollType,
        options.rollTarget?.weapon,
-        { isRanged: options.isRangedDefense }
+        { isRanged: isRangedForD30 }
      )
      options.D30message = d30Message
    }
@@ -666,7 +690,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,
@@ -698,7 +722,7 @@ export default class LethalFantasyRoll extends Roll {
      buttons: [
        {
          label: label,
-          callback: (event, button, dialog) => {
+          callback: (event, button) => {
            const output = Array.from(button.form.elements).reduce((obj, input) => {
              if (input.name) obj[input.name] = input.value
              return obj
@@ -720,7 +744,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 +758,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,
@@ -766,7 +790,7 @@ export default class LethalFantasyRoll extends Roll {
        buttons.push({
          action: "roll",
          label: "Roll progression dice",
-          callback: (event, button, dialog) => {
+          callback: (event, button) => {
            let pos = $('#combat-action-dialog').position()
            game.user.setFlag(SYSTEM.id, "combat-action-dialog-pos", pos)
            return "rollProgressionDice"
@@ -792,7 +816,7 @@ export default class LethalFantasyRoll extends Roll {
        buttons.push({
          action: "roll",
          label: label,
-          callback: (event, button, dialog) => {
+          callback: (event, button) => {
            let pos = $('#combat-action-dialog').position()
            game.user.setFlag(SYSTEM.id, "combat-action-dialog-pos", foundry.utils.duplicate(pos))
            return "rollLethargyDice"
@@ -803,7 +827,7 @@ export default class LethalFantasyRoll extends Roll {
      buttons.push({
        action: "roll",
        label: "Select action",
-        callback: (event, button, dialog) => {
+        callback: (event, button) => {
          let pos = $('#combat-action-dialog').position()
          game.user.setFlag(SYSTEM.id, "combat-action-dialog-pos", foundry.utils.duplicate(pos))
          const output = Array.from(button.form.elements).reduce((obj, input) => {
@@ -818,7 +842,7 @@ export default class LethalFantasyRoll extends Roll {
    buttons.push({
      action: "cancel",
      label: "Other action, not listed here",
-      callback: (event, button, dialog) => {
+      callback: (event, button) => {
        let pos = $('#combat-action-dialog').position()
        game.user.setFlag(SYSTEM.id, "combat-action-dialog-pos", foundry.utils.duplicate(pos))
        return null;
@@ -968,7 +992,7 @@ export default class LethalFantasyRoll extends Roll {
        }
        // Range weapon loading
        if (!currentAction.weaponLoaded && currentAction.rangedLoad) {
-          if (currentAction.progressionCount <= currentAction.rangedLoad) {
+          if (currentAction.progressionCount < currentAction.rangedLoad) {
            let message = `Ranged weapon ${currentAction.name} is loading, loading count : ${currentAction.progressionCount}/${currentAction.rangedLoad}`
            ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
            currentAction.progressionCount += 1
@@ -991,7 +1015,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 +1057,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,
@@ -1065,7 +1089,7 @@ export default class LethalFantasyRoll extends Roll {
      buttons: [
        {
          label: label,
-          callback: (event, button, dialog) => {
+          callback: (event, button) => {
            const output = Array.from(button.form.elements).reduce((obj, input) => {
              if (input.name) obj[input.name] = input.value
              return obj
@@ -1114,6 +1138,8 @@ export default class LethalFantasyRoll extends Roll {
    options = { ...options, ...rollContext }
    options.rollName = "Ranged Defense"
    options.rollType = "weapon-defense"
+    options.type = options.rollType         // Required: this.type reads options.type
+    options.rollMode = rollContext.visibility  // Required: callers pass roll.options.rollMode to toMessage

    const rollBase = new this(rollContext.movement, options.data, rollData)
    const rollModifier = new Roll(modifierFormula, options.data, rollData)
@@ -1181,6 +1207,161 @@ export default class LethalFantasyRoll extends Roll {
    return rollBase
  }

+  /**
+   * Prompts the GM for ranged attack context (movement, range, target size, aim) when a monster
+   * attacks with a ranged weapon, then evaluates an exploding D20 attack roll with the resulting modifiers.
+   *
+   * @param {Object} options              Options for the roll.
+   * @param {string} options.actorId      The attacker actor ID.
+   * @param {string} options.actorName    The attacker actor name.
+   * @param {Object} options.rollTarget   The rollTarget containing attackModifier and related data.
+   * @returns {Promise<LethalFantasyRoll|null>}  The resulting roll, or null if cancelled.
+   */
+  static async promptRangedAttack(options = {}) {
+    const rollModes = foundry.utils.duplicate(CONFIG.ChatMessage.modes)
+    const fieldRollMode = new foundry.data.fields.StringField({
+      choices: rollModes,
+      blank: false,
+      default: "public",
+    })
+
+    let dialogContext = {
+      attackerMovementChoices: SYSTEM.ATTACKER_MOVEMENT_CHOICES,
+      rangeChoices: SYSTEM.RANGE_CHOICES,
+      sizeChoices: SYSTEM.SIZE_CHOICES,
+      attackerAimChoices: SYSTEM.ATTACKER_AIM_CHOICES,
+      movement: "none",
+      range: "short",
+      size: "+5",
+      attackerAim: "simple",
+      fieldRollMode,
+      rollModes
+    }
+
+    const content = await foundry.applications.handlebars.renderTemplate("systems/fvtt-lethal-fantasy/templates/range-attack-dialog.hbs", dialogContext)
+
+    const label = game.i18n.localize("LETHALFANTASY.Label.rangeAttackRoll")
+    const rollContext = await foundry.applications.api.DialogV2.wait({
+      window: { title: "Ranged Attack" },
+      classes: ["lethalfantasy"],
+      content,
+      buttons: [
+        {
+          label,
+          callback: (event, button) => {
+            const output = Array.from(button.form.elements).reduce((obj, input) => {
+              if (input.name) obj[input.name] = input.value
+              return obj
+            }, {})
+            return output
+          },
+        },
+      ],
+      rejectClose: false
+    })
+
+    if (rollContext === null) return null
+
+    // Handle pointblank: attacker at point blank gets favor (standing still easier to aim)
+    if (rollContext.range === "pointblank") {
+      rollContext.movement = rollContext.movement.replace("kh", "")
+      rollContext.movement = rollContext.movement.replace("kl", "")
+      rollContext.movement += "kh" // Favor for attacker at point blank
+      rollContext.range = "0"
+    }
+    // Handle beyondskill: extreme range gives disfavor to attacker
+    if (rollContext.range === "beyondskill") {
+      rollContext.movement = rollContext.movement.replace("kh", "")
+      rollContext.movement = rollContext.movement.replace("kl", "")
+      rollContext.movement += "kl" // Disfavor for attacker beyond skill range
+      rollContext.range = "+11"
+    }
+
+    // Compute contextual penalty: range + target_size, reduced by aim bonus and attack modifier
+    const attackModifier = options.rollTarget?.attackModifier ?? 0
+    const contextualPenalty = Number(rollContext.range) + Number(rollContext.size)
+    const aimBonus = Number(rollContext.attackerAim || 0)
+    const fullModifier = contextualPenalty - aimBonus - attackModifier
+
+    let modifierFormula
+    if (fullModifier === 0) {
+      modifierFormula = "0"
+    } else {
+      const modAbs = Math.abs(fullModifier)
+      modifierFormula = `D${modAbs + 1} -1`
+    }
+
+    const rollData = { ...rollContext }
+    options = { ...options, ...rollContext }
+    options.rollName = "Ranged Attack"
+    options.rollType = options.rollType || "monster-attack"
+    options.type = options.rollType  // Required: this.type reads options.type, used to build weaponDamageOptions in toHTML
+    options.rollMode = rollContext.visibility   // Required: callers pass roll.options.rollMode to toMessage
+    options.isRangedAttack = true
+
+    const rollBase = new this(rollContext.movement, options.data, rollData)
+    const rollModifier = new Roll(modifierFormula, options.data, rollData)
+    rollModifier.evaluate()
+    await rollBase.evaluate()
+    const rollD30 = await new Roll("1D30").evaluate()
+    options.D30result = rollD30.total
+    options.D30message = D30Roll.getResult(rollD30.total, options.rollType, undefined, { isRanged: true })
+
+    // Determine favor from dice formula
+    let badResult = 0
+    if (rollContext.movement.includes("kh")) {
+      rollData.favor = "favor"
+      badResult = Math.min(rollBase.terms[0].results[0].result, rollBase.terms[0].results[1]?.result || 20)
+    }
+    if (rollContext.movement.includes("kl")) {
+      rollData.favor = "disfavor"
+      badResult = Math.max(rollBase.terms[0].results[0].result, rollBase.terms[0].results[1]?.result || 1)
+    }
+
+    const dice = rollContext.movement
+    const maxValue = 20
+    let rollTotal = -1
+    let diceResults = []
+
+    let diceResult = rollBase.dice[0].results[0].result
+    diceResults.push({ dice: `${dice.toUpperCase()}`, value: diceResult })
+    let diceSum = diceResult
+    // Exploding dice
+    while (diceResult === maxValue) {
+      const r = await new Roll(dice).evaluate()
+      diceResult = r.dice[0].results[0].result
+      diceResults.push({ dice: `${dice.toUpperCase()}-1`, value: diceResult - 1 })
+      diceSum += (diceResult - 1)
+    }
+
+    if (fullModifier !== 0) {
+      diceResults.push({ dice: `${rollModifier.formula.toUpperCase()}`, value: rollModifier.total })
+      if (fullModifier > 0) {
+        // Net penalty: subtract from roll
+        rollTotal = Math.max(diceSum - rollModifier.total, 0)
+      } else {
+        // Net bonus: add to roll
+        rollTotal = diceSum + rollModifier.total
+      }
+    } else {
+      rollTotal = diceSum
+    }
+
+    rollBase.options = { ...rollBase.options, ...options }
+    rollBase.options.resultType = undefined
+    rollBase.options.rollTotal = rollTotal
+    rollBase.options.diceResults = diceResults
+    rollBase.options.rollTarget = options.rollTarget
+    rollBase.options.titleFormula = `1D20E + ${modifierFormula}`
+    rollBase.options.D30result = options.D30result
+    rollBase.options.D30message = options.D30message
+    rollBase.options.rollName = "Ranged Attack"
+    rollBase.options.badResult = badResult
+    rollBase.options.rollData = foundry.utils.duplicate(rollData)
+
+    return rollBase
+  }
+
  /**
   * Creates a title based on the given type.
   *
@@ -1322,11 +1503,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 +1525,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) {
@@ -356,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,
@@ -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
  }
@@ -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
  }

@@ -156,6 +166,22 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
   */
  async roll(rollType, rollTarget, defenderId = undefined, defenderTokenId = undefined, extraShieldDr = 0) {
    const hasTarget = false
+
+    // Ranged monster defense uses the ranged defense dialog (movement, range, size modifiers)
+    if (rollType === "monster-defense" && rollTarget?.isRangedDefense === true) {
+      let roll = await LethalFantasyRoll.promptRangedDefense({
+        actorId: this.parent.id,
+        actorName: this.parent.name,
+        actorImage: this.parent.img,
+        rollTarget,
+        defenderId,
+        defenderTokenId,
+      })
+      if (!roll) return null
+      await roll.toMessage({}, { messageMode: roll.options.rollMode })
+      return
+    }
+
    let roll = await LethalFantasyRoll.prompt({
      rollType,
      rollTarget,
@@ -170,7 +196,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 +208,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
        }
@@ -222,7 +249,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":
@@ -259,7 +286,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)
@@ -273,7 +300,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)
    }
  }
@@ -294,7 +320,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 +332,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,
@@ -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
  }
@@ -324,7 +324,7 @@ export default class LethalFantasyUtils {
            <p>Attack roll: <strong>${attackRoll}</strong></p>
          </div>
          <div class="weapon-selection">
-            <label for="defense-attack">Choose your defense attack:</label>
+            <label for="defense-attack">Choose your defense weapon:</label>
            <select id="defense-attack" name="attackKey" style="width: 100%; margin-top: 8px;">
              ${attacksHTML}
            </select>
@@ -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
@@ -680,6 +711,7 @@ export default class LethalFantasyUtils {
            ${totalBonus > 0 ? `<p class="bonus-info">Bonus already added: +${totalBonus}</p>` : ''}
          </div>
          <p class="offer-text">You are losing! Spend Grit or Luck to add 1D6 to your defense?</p>
+          <p class="shield-warning"><i class="fa-solid fa-triangle-exclamation"></i> If you intend to use a shield, you must spend Grit or Luck <strong>first</strong> — the shield roll comes after.</p>
        </div>
      `

@@ -822,7 +854,7 @@ export default class LethalFantasyUtils {
        `
      } else if (data.attackRollType === "monster-attack") {
        damageButton = `
-          <div class="attack-result-damage">
+          <div class="attack-result-damage single-btn">
            <button class="roll-damage-btn" data-attacker-id="${data.attackerId}" data-defender-id="${data.defenderId}" data-defender-token-id="${data.defenderTokenId || ""}" data-extra-shield-dr="${data.shieldDamageReduction || 0}" data-attack-key="${data.attackRollKey}" data-damage-type="monster">
              <i class="fa-solid fa-burst"></i> Damage
            </button>
@@ -830,21 +862,26 @@ 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">
+        const spell = attacker?.items.get(data.attackWeaponId || data.attackRollKey)
+        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="${damageDice}">
-                <i class="fa-solid fa-wand-magic-sparkles"></i> Spell Damage (${damageDice})
-              </button>
-            </div>
-          `
+              data-damage-formula="${escapedFormula}">
+              <i class="fa-solid fa-wand-magic-sparkles"></i> ${t.label} (${escapedFormula})
+            </button>`
+          }).join("")
+          damageButton = `<div class="attack-result-damage spell-damage">${buttons}</div>`
        }
      }
    }
@@ -871,10 +908,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}
@@ -1061,25 +1098,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
@@ -1157,7 +1201,7 @@ export default class LethalFantasyUtils {
      ChatMessage.create({
        user: game.user.id,
        speaker: { alias: targetActor.name },
-        rollMode: "gmroll",
+        mode: "gm",
        content: messageContent
      })
    }
@@ -1 +1 @@
-MANIFEST-000579
+MANIFEST-000619
@@ -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/24-09:22:43.041326 7fdfa95ff6c0 Recovering log #617
+2026/05/24-09:22:43.083988 7fdfa95ff6c0 Delete type=3 #615
+2026/05/24-09:22:43.084045 7fdfa95ff6c0 Delete type=0 #617
+2026/05/24-09:42:00.304351 7fdf5affd6c0 Level-0 table #622: started
+2026/05/24-09:42:00.304423 7fdf5affd6c0 Level-0 table #622: 0 bytes OK
+2026/05/24-09:42:00.311333 7fdf5affd6c0 Delete type=0 #620
+2026/05/24-09:42:00.334170 7fdf5affd6c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
+2026/05/24-09:42:00.334370 7fdf5affd6c0 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/23-18:45:10.214922 7fa233fff6c0 Recovering log #613
+2026/05/23-18:45:10.223944 7fa233fff6c0 Delete type=3 #611
+2026/05/23-18:45:10.223997 7fa233fff6c0 Delete type=0 #613
+2026/05/23-19:09:56.190877 7fa2327fc6c0 Level-0 table #618: started
+2026/05/23-19:09:56.190922 7fa2327fc6c0 Level-0 table #618: 0 bytes OK
+2026/05/23-19:09:56.224359 7fa2327fc6c0 Delete type=0 #616
+2026/05/23-19:09:56.339160 7fa2327fc6c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
+2026/05/23-19:09:56.339194 7fa2327fc6c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
@@ -1 +1 @@
-MANIFEST-000576
+MANIFEST-000616
@@ -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/24-09:22:43.091828 7fdfa8dfe6c0 Recovering log #614
+2026/05/24-09:22:43.131041 7fdfa8dfe6c0 Delete type=3 #612
+2026/05/24-09:22:43.131104 7fdfa8dfe6c0 Delete type=0 #614
+2026/05/24-09:42:00.326388 7fdf5affd6c0 Level-0 table #619: started
+2026/05/24-09:42:00.326417 7fdf5affd6c0 Level-0 table #619: 0 bytes OK
+2026/05/24-09:42:00.334051 7fdf5affd6c0 Delete type=0 #617
+2026/05/24-09:42:00.334205 7fdf5affd6c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
+2026/05/24-09:42:00.334364 7fdf5affd6c0 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/23-18:45:10.228083 7fa232ffd6c0 Recovering log #610
+2026/05/23-18:45:10.236935 7fa232ffd6c0 Delete type=3 #608
+2026/05/23-18:45:10.236958 7fa232ffd6c0 Delete type=0 #610
+2026/05/23-19:09:56.261648 7fa2327fc6c0 Level-0 table #615: started
+2026/05/23-19:09:56.261672 7fa2327fc6c0 Level-0 table #615: 0 bytes OK
+2026/05/23-19:09:56.304021 7fa2327fc6c0 Delete type=0 #613
+2026/05/23-19:09:56.339181 7fa2327fc6c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
+2026/05/23-19:09:56.339208 7fa2327fc6c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
@@ -1 +1 @@
-MANIFEST-000581
+MANIFEST-000621
@@ -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/24-09:22:42.993966 7fdfa8dfe6c0 Recovering log #619
+2026/05/24-09:22:43.035467 7fdfa8dfe6c0 Delete type=3 #617
+2026/05/24-09:22:43.035518 7fdfa8dfe6c0 Delete type=0 #619
+2026/05/24-09:42:00.319082 7fdf5affd6c0 Level-0 table #624: started
+2026/05/24-09:42:00.319109 7fdf5affd6c0 Level-0 table #624: 0 bytes OK
+2026/05/24-09:42:00.326261 7fdf5affd6c0 Delete type=0 #622
+2026/05/24-09:42:00.334196 7fdf5affd6c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
+2026/05/24-09:42:00.334355 7fdf5affd6c0 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/23-18:45:10.200781 7fa2337fe6c0 Recovering log #615
+2026/05/23-18:45:10.211345 7fa2337fe6c0 Delete type=3 #613
+2026/05/23-18:45:10.211416 7fa2337fe6c0 Delete type=0 #615
+2026/05/23-19:09:56.304132 7fa2327fc6c0 Level-0 table #620: started
+2026/05/23-19:09:56.304162 7fa2327fc6c0 Level-0 table #620: 0 bytes OK
+2026/05/23-19:09:56.339034 7fa2327fc6c0 Delete type=0 #618
+2026/05/23-19:09:56.339189 7fa2327fc6c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
+2026/05/23-19:09:56.339203 7fa2327fc6c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
@@ -1 +1 @@
-MANIFEST-000276
+MANIFEST-000316
@@ -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/24-09:22:43.194643 7fdfa8dfe6c0 Recovering log #314
+2026/05/24-09:22:43.231409 7fdfa8dfe6c0 Delete type=3 #312
+2026/05/24-09:22:43.231470 7fdfa8dfe6c0 Delete type=0 #314
+2026/05/24-09:42:00.341818 7fdf5affd6c0 Level-0 table #319: started
+2026/05/24-09:42:00.341853 7fdf5affd6c0 Level-0 table #319: 0 bytes OK
+2026/05/24-09:42:00.348538 7fdf5affd6c0 Delete type=0 #317
+2026/05/24-09:42:00.367125 7fdf5affd6c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
+2026/05/24-09:42:00.367348 7fdf5affd6c0 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/23-18:45:10.252202 7fa2337fe6c0 Recovering log #310
+2026/05/23-18:45:10.261300 7fa2337fe6c0 Delete type=3 #308
+2026/05/23-18:45:10.261343 7fa2337fe6c0 Delete type=0 #310
+2026/05/23-19:09:56.467263 7fa2327fc6c0 Level-0 table #315: started
+2026/05/23-19:09:56.467308 7fa2327fc6c0 Level-0 table #315: 0 bytes OK
+2026/05/23-19:09:56.509084 7fa2327fc6c0 Delete type=0 #313
+2026/05/23-19:09:56.608544 7fa2327fc6c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
+2026/05/23-19:09:56.665018 7fa2327fc6c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
@@ -1 +1 @@
-MANIFEST-000575
+MANIFEST-000615
@@ -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/24-09:22:43.141936 7fdf5bfff6c0 Recovering log #613
+2026/05/24-09:22:43.189387 7fdf5bfff6c0 Delete type=3 #611
+2026/05/24-09:22:43.189438 7fdf5bfff6c0 Delete type=0 #613
+2026/05/24-09:42:00.311436 7fdf5affd6c0 Level-0 table #618: started
+2026/05/24-09:42:00.311459 7fdf5affd6c0 Level-0 table #618: 0 bytes OK
+2026/05/24-09:42:00.318964 7fdf5affd6c0 Delete type=0 #616
+2026/05/24-09:42:00.334187 7fdf5affd6c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
+2026/05/24-09:42:00.334334 7fdf5affd6c0 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/23-18:45:10.238924 7fa233fff6c0 Recovering log #609
+2026/05/23-18:45:10.250309 7fa233fff6c0 Delete type=3 #607
+2026/05/23-18:45:10.250371 7fa233fff6c0 Delete type=0 #609
+2026/05/23-19:09:56.224507 7fa2327fc6c0 Level-0 table #614: started
+2026/05/23-19:09:56.224539 7fa2327fc6c0 Level-0 table #614: 0 bytes OK
+2026/05/23-19:09:56.261516 7fa2327fc6c0 Delete type=0 #612
+2026/05/23-19:09:56.339172 7fa2327fc6c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
+2026/05/23-19:09:56.339199 7fa2327fc6c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
@@ -145,9 +145,11 @@
 }

 .grit-luck-dialog {
+  color: var(--color-text-dark-primary, #191813);
+
  .combat-status {
    padding: 12px;
-    background: linear-gradient(to bottom, rgba(42, 41, 32, 0.8) 0%, rgba(26, 25, 16, 0.9) 100%);
+    background: linear-gradient(to bottom, rgba(42, 41, 32, 0.88) 0%, rgba(26, 25, 16, 0.95) 100%);
    border: 1px solid rgba(212, 175, 55, 0.5);
    border-radius: 6px;
    margin-bottom: 16px;
@@ -171,11 +173,27 @@
  }

  .offer-text {
-    color: #f0e6d2;
+    color: var(--color-text-dark-primary, #191813);
    font-size: calc(var(--font-size-standard) * 1);
    text-align: center;
    font-weight: 600;
+    margin: 0 0 8px 0;
+  }
+
+  .shield-warning {
+    color: #7a4000;
+    background: rgba(255, 160, 0, 0.12);
+    border: 1px solid rgba(255, 160, 0, 0.4);
+    border-radius: 5px;
+    font-size: calc(var(--font-size-standard) * 0.88);
+    padding: 6px 10px;
    margin: 0;
+    text-align: center;
+
+    i {
+      color: #c07000;
+      margin-right: 5px;
+    }
  }
 }

@@ -283,33 +301,72 @@
  }

  .attack-result-damage {
-    display: flex;
+    display: grid;
+    grid-template-columns: repeat(2, 1fr);
    gap: 8px;
-    justify-content: center;
+
+    &.single-btn {
+      grid-template-columns: 1fr;
+      max-width: 280px;
+      margin: 0 auto;
+    }
+
+    &.spell-damage {
+      grid-template-columns: 1fr;
+      width: 100%;
+    }

    .roll-damage-btn {
-      padding: 10px 16px;
+      padding: 10px 14px;
      background: linear-gradient(to bottom, #8b0000 0%, #660000 100%);
-      border: 1px solid #ff0000;
+      border: 1px solid #4b0000;
      border-radius: 6px;
      color: #f0e6d2;
      font-weight: 600;
+      font-size: calc(var(--font-size-standard) * 0.9);
+      text-align: center;
+      white-space: nowrap;
      cursor: pointer;
      transition: all 0.2s ease;
-      box-shadow: 0 2px 4px rgba(0, 0, 0, 0.3);
+      box-shadow: 0 3px 6px rgba(0, 0, 0, 0.4), inset 0 1px 0 rgba(255, 255, 255, 0.1);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      gap: 6px;
+      position: relative;
+      overflow: hidden;
+
+      &::before {
+        content: '';
+        position: absolute;
+        top: 0;
+        left: -100%;
+        width: 100%;
+        height: 100%;
+        background: linear-gradient(90deg, transparent, rgba(255, 255, 255, 0.15), transparent);
+        transition: left 0.5s;
+      }
+
+      &:hover::before {
+        left: 100%;
+      }
+
+      i {
+        font-size: calc(var(--font-size-standard) * 1.1);
+        filter: drop-shadow(0 1px 2px rgba(0, 0, 0, 0.5));
+        flex-shrink: 0;
+      }

      &:hover {
        background: linear-gradient(to bottom, #a00000 0%, #7b0000 100%);
-        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.4);
+        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.5), inset 0 1px 0 rgba(255, 255, 255, 0.15);
        transform: translateY(-2px);
+        border-color: #5b0000;
      }

      &:active {
        transform: translateY(0);
-      }
-
-      i {
-        margin-right: 6px;
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.4), inset 0 1px 3px rgba(0, 0, 0, 0.3);
      }
    }
  }
@@ -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);
@@ -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,
@@ -1269,33 +1285,72 @@
  }

  .attack-result-damage {
-    display: flex;
+    display: grid;
+    grid-template-columns: repeat(2, 1fr);
    gap: 8px;
-    justify-content: center;
+
+    &.single-btn {
+      grid-template-columns: 1fr;
+      max-width: 280px;
+      margin: 0 auto;
+    }
+
+    &.spell-damage {
+      grid-template-columns: 1fr;
+      width: 100%;
+    }

    .roll-damage-btn {
-      padding: 10px 16px;
+      padding: 10px 14px;
      background: linear-gradient(to bottom, #8b0000 0%, #660000 100%);
-      border: 1px solid #ff0000;
+      border: 1px solid #4b0000;
      border-radius: 6px;
      color: #f0e6d2;
      font-weight: 600;
+      font-size: calc(var(--font-size-standard) * 0.9);
+      text-align: center;
+      white-space: nowrap;
      cursor: pointer;
      transition: all 0.2s ease;
-      box-shadow: 0 2px 4px rgba(0, 0, 0, 0.3);
+      box-shadow: 0 3px 6px rgba(0, 0, 0, 0.4), inset 0 1px 0 rgba(255, 255, 255, 0.1);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      gap: 6px;
+      position: relative;
+      overflow: hidden;
+
+      &::before {
+        content: '';
+        position: absolute;
+        top: 0;
+        left: -100%;
+        width: 100%;
+        height: 100%;
+        background: linear-gradient(90deg, transparent, rgba(255, 255, 255, 0.15), transparent);
+        transition: left 0.5s;
+      }
+
+      &:hover::before {
+        left: 100%;
+      }
+
+      i {
+        font-size: calc(var(--font-size-standard) * 1.1);
+        filter: drop-shadow(0 1px 2px rgba(0, 0, 0, 0.5));
+        flex-shrink: 0;
+      }

      &:hover {
        background: linear-gradient(to bottom, #a00000 0%, #7b0000 100%);
-        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.4);
+        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.5), inset 0 1px 0 rgba(255, 255, 255, 0.15);
        transform: translateY(-2px);
+        border-color: #5b0000;
      }

      &:active {
        transform: translateY(0);
-      }
-
-      i {
-        margin-right: 6px;
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.4), inset 0 1px 3px rgba(0, 0, 0, 0.3);
      }
    }
  }
@@ -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
@@ -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>
@@ -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>
@@ -37,6 +37,25 @@
            <i class="fa-duotone fa-solid fa-stars" data-roll-type="spell-power" data-roll-key="{{item.id}}"></i>
          </a>

+          {{#if item.system.damageDice}}
+          <a data-action="rollSpellDamage" data-item-id="{{item.id}}" data-damage-tier="standard"
+            data-tooltip="Spell Damage (Standard)">
+            <i class="fa-solid fa-wand-magic-sparkles"></i>S
+          </a>
+          {{/if}}
+          {{#if item.system.damageDiceOverpowered}}
+          <a data-action="rollSpellDamage" data-item-id="{{item.id}}" data-damage-tier="overpowered"
+            data-tooltip="Spell Damage (Overpowered)">
+            <i class="fa-solid fa-wand-magic-sparkles"></i>O
+          </a>
+          {{/if}}
+          {{#if item.system.damageDiceOverpowered2}}
+          <a data-action="rollSpellDamage" data-item-id="{{item.id}}" data-damage-tier="overpowered2"
+            data-tooltip="Spell Damage (Overpowered 2)">
+            <i class="fa-solid fa-wand-magic-sparkles"></i>O2
+          </a>
+          {{/if}}
+
          <div class="controls">
            <a data-tooltip="{{localize 'LETHALFANTASY.Edit'}}" data-action="edit" data-item-id="{{item.id}}"
              data-item-uuid="{{item.uuid}}"><i class="fas fa-edit"></i></a>
@@ -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>
@@ -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}}

@@ -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"
@@ -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}}


  
@@ -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>

@@ -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,12 +125,42 @@

      </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}}" >
@@ -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">

@@ -0,0 +1,45 @@
+<div class="lethalfantasy-range-defense-dialog">
+
+  <fieldSet class="">
+    <legend>{{localize "LETHALFANTASY.Label.rangeAttackDialog"}}</legend>
+
+    <div class="field-section">
+      <span class="field-name">Attacker Movement :</span>
+      <select name="movement" data-tooltip-direction="UP">
+        {{selectOptions attackerMovementChoices selected=movement}}
+      </select>
+    </div>
+
+    <div class="field-section">
+      <span class="field-name">Range :</span>
+      <select name="range" data-tooltip-direction="UP">
+        {{selectOptions rangeChoices selected=range}}
+      </select>
+    </div>
+
+    <div class="field-section">
+      <span class="field-name">Target Size :</span>
+      <select name="size" data-tooltip-direction="UP">
+        {{selectOptions sizeChoices selected=size}}
+      </select>
+    </div>
+
+    <div class="field-section">
+      <span class="field-name">Aim :</span>
+      <select name="attackerAim" data-tooltip-direction="UP">
+        {{selectOptions attackerAimChoices selected=attackerAim}}
+      </select>
+    </div>
+
+  </fieldSet>
+
+  <fieldSet>
+    <legend>{{localize "LETHALFANTASY.Roll.visibility"}}</legend>
+    <span class="fieldset-centered">
+      <select name="visibility">
+        {{selectOptions rollModes selected=visibility localize=true}}
+      </select>
+    </span>
+  </fieldSet>
+
+</div>
@@ -55,8 +55,7 @@
      <div class="dialog-save">Add Granted Attack Dice
        <input type="checkbox" data-action="selectGranted" name="granted" />
      </div>
-      {{#if rollTarget.weapon}}
-        {{#if (eq rollTarget.weapon.system.weaponType "melee")}}{{else}}
+      {{#if isRangedAttack}}
        <div class="dialog-save">Point Blank Range Attack
          <input
            type="checkbox"
@@ -84,13 +83,16 @@
          </select>
        </div>
      {{/if}}
-      {{/if}}

    {{/if}}
    {{#if (match rollType "defense")}}
      <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
@@ -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
@@ -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>
@@ -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}}
Author	SHA1	Message	Date
uberwald	d389a85a9f	Fix ranged attacks again Release Creation / build (release) Successful in 43s Details	2026-05-24 09:42:07 +02:00
uberwald	c217490a5b	Fix ranged attacks again Release Creation / build (release) Has been cancelled Details	2026-05-24 09:41:06 +02:00
uberwald	38eb1a8d3d	Add ranged actions for monsters Release Creation / build (release) Successful in 54s Details	2026-05-23 19:10:10 +02:00
uberwald	4724cdf2bb	VArious fixes for rolls and ranged attacks Release Creation / build (release) Successful in 44s Details	2026-05-23 09:08:16 +02:00
uberwald	6d06c8ddad	Various fixes for spell and ranged attacks	2026-05-23 00:21:05 +02:00
uberwald	2770774aa3	Various fixes for spell and ranged attacks	2026-05-23 00:11:58 +02:00
uberwald	e417b61625	Spells fixe Release Creation / build (release) Successful in 46s Details	2026-05-20 23:17:07 +02:00
uberwald	9a8d580ef6	Other fixes for damage buttons from chat Release Creation / build (release) Successful in 53s Details	2026-05-20 10:53:46 +02:00
uberwald	9ccb0f90f0	Other fixes for damage buttons from chat	2026-05-20 10:53:22 +02:00
uberwald	6cf0880ad3	Enhance spell damage and messages content Release Creation / build (release) Successful in 44s Details	2026-05-19 10:52:03 +02:00
uberwald	96306623e5	UPdate and fixes for roll in combats Release Creation / build (release) Successful in 43s Details	2026-05-18 20:26:39 +02:00
uberwald	7279cd752d	Fix initiative again Release Creation / build (release) Successful in 43s Details	2026-05-18 07:58:28 +02:00
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