Fix triple damage issue

Fix hp < 0 and D30 with D20 bonus roll
Minor fixes regarding rolls and chat messages
2026-06-11 21:32:26 +02:00 · 2026-06-11 20:48:46 +02:00 · 2026-06-10 20:17:45 +02:00 · 2026-06-10 07:53:51 +02:00 · 2026-06-06 16:11:36 +02:00 · 2026-05-25 20:41:00 +02:00
63 changed files with 2221 additions and 723 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-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`
@@ -529,16 +529,16 @@ i.lethalfantasy {
 }
 .lethalfantasy .tab.character-combat .main-div .combat-details .combat-detail .armor-hp {
  margin-right: 4px;
-  min-width: 10rem;
-  max-width: 10rem;
+  min-width: 11rem;
+  max-width: 11rem;
 }
 .lethalfantasy .tab.character-combat .main-div .combat-details .combat-detail .armor-hp .name {
  min-width: 6rem;
  max-width: 6rem;
 }
 .lethalfantasy .tab.character-combat .main-div .combat-details .combat-detail .armor-hp .input {
-  min-width: 2.5rem;
-  max-width: 2.5rem;
+  min-width: 3.5rem;
+  max-width: 3.5rem;
 }
 .lethalfantasy .tab.character-combat .main-div .combat-details .combat-detail .granted {
  min-width: 8rem;
@@ -2027,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;
@@ -2049,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;
@@ -2144,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);
@@ -2634,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,
@@ -3213,16 +3280,10 @@ i.lethalfantasy {
 .message.lethalfantasy.dice-roll .damage-buttons .damage-buttons-grid,
 .message.fvtt-lethal-fantasy.dice-roll .damage-buttons .damage-buttons-grid {
  display: grid;
-  grid-template-columns: repeat(2, 1fr);
-  gap: 8px;
-}
-.lethalfantasy.dice-roll .damage-buttons .damage-buttons-grid.monster-damage,
-.fvtt-lethal-fantasy.dice-roll .damage-buttons .damage-buttons-grid.monster-damage,
-.message.lethalfantasy.dice-roll .damage-buttons .damage-buttons-grid.monster-damage,
-.message.fvtt-lethal-fantasy.dice-roll .damage-buttons .damage-buttons-grid.monster-damage {
  grid-template-columns: 1fr;
  max-width: 280px;
  margin: 0 auto;
+  gap: 8px;
 }
 .lethalfantasy.dice-roll .damage-buttons .damage-buttons-grid .damage-roll-btn,
 .fvtt-lethal-fantasy.dice-roll .damage-buttons .damage-buttons-grid .damage-roll-btn,
@@ -3482,6 +3543,7 @@ i.lethalfantasy {
  display: grid;
  grid-template-columns: repeat(2, 1fr);
  gap: 8px;
+  justify-items: center;
 }
 .lethalfantasy.dice-roll .d30-message,
 .fvtt-lethal-fantasy.dice-roll .d30-message,
@@ -3928,35 +3990,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;
@@ -4033,6 +4134,59 @@ i.lethalfantasy {
  padding-left: 8px;
  font-size: 0.9rem;
 }
+/* Luck/Grit Styles */
+#token-hud .luck-grit-wrap {
+  position: absolute;
+  left: 75px;
+  display: none;
+  top: 50%;
+  width: 80px;
+  text-align: start;
+  background: rgba(0, 0, 0, 0.8);
+  border: 1px solid rgba(139, 69, 19, 0.5);
+  border-radius: 4px;
+  padding: 4px 6px;
+  transform: translate(-100%, -50%);
+}
+#token-hud .luck-grit-hud-active {
+  display: block;
+}
+#token-hud .luck-grit-hud-disabled {
+  display: none;
+}
+#token-hud .luck-grit-row {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  margin: 2px 0;
+}
+#token-hud .luck-grit-label {
+  flex: 1;
+  color: #c9b896;
+  font-size: 11px;
+  font-weight: 600;
+  text-transform: uppercase;
+}
+#token-hud .luck-grit-btn {
+  width: 28px;
+  height: 22px;
+  padding: 0;
+  background: rgba(139, 69, 19, 0.25);
+  border: 1px solid rgba(139, 69, 19, 0.4);
+  border-radius: 3px;
+  color: #d4c5a9;
+  font-size: 12px;
+  font-weight: 700;
+  cursor: pointer;
+  line-height: 1;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+#token-hud .luck-grit-btn:hover {
+  background: rgba(139, 69, 19, 0.5);
+  border-color: rgba(139, 69, 19, 0.7);
+}
 /* -------------------------------------------------- */
 /* Dice Tray — injected into the Foundry chat sidebar */
 /* -------------------------------------------------- */
@@ -471,6 +471,8 @@
      "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",
@@ -503,11 +505,42 @@
      "monster-defense": "Monster defense",
      "weapons": "Weapons",
      "wis": "WIS",
-      "weapon-damage-medium": "Weapon damage medium",
-      "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": {
@@ -563,6 +596,15 @@
        },
        "savingThrow": {
          "label": "Saving throw"
+        },
+        "damageDiceOverpowered": {
+          "label": "Overpowered Damage Dice"
+        },
+        "damageDiceOverpowered2": {
+          "label": "Overpowered 2 Damage Dice"
+        },
+        "damageDice": {
+          "label": "Damage Dice"
        }
      }
    },
@@ -684,7 +726,8 @@
            "label": "Min"
          }
        }
-      }
+      },
+      "autoDestruction": "Auto-Destruction"
    },
    "Skill": {
      "Category": {
@@ -783,6 +826,12 @@
        "cost": {
          "label": "Cost"
        },
+        "costOverpowered": {
+          "label": "Cost (Overpowered)"
+        },
+        "costOverpowered2": {
+          "label": "Cost (Overpowered 2)"
+        },
        "description": {
          "label": "Description"
        },
@@ -809,6 +858,12 @@
        },
        "damageDice": {
          "label": "Damage dice"
+        },
+        "damageDiceOverpowered": {
+          "label": "Overpowered Damage Dice"
+        },
+        "damageDiceOverpowered2": {
+          "label": "Overpowered 2 Damage Dice"
        }
      },
      "Range": {
@@ -843,7 +898,9 @@
        }
      }
    },
-    "Warning": {},
+    "Warning": {
+      "defenseShieldOrder": "To avoid a hit without using the shield, roll Grit or Luck first — then roll the shield."
+    },
    "Weapon": {
      "FIELDS": {
        "isAgile": {
@@ -989,7 +1046,16 @@
      "progressionCount": "Progression count:"
    },
    "Combat": {
-      "RollMonsters": "Roll Monsters"
+      "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",
@@ -230,12 +230,21 @@ Hooks.on("renderChatMessageHTML", (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
+      const attackDiceResults = message.rolls[0]?.options?.diceResults || null
+      const attackNaturalRoll = attackDiceResults?.[0]?.value || null
+      const damageTier = message.rolls[0]?.options?.damageTier || "standard"
      const attackRerollContext = {
        rollType: message.rolls[0]?.options?.rollType,
        rollTarget: foundry.utils.duplicate(message.rolls[0]?.options?.rollTarget ?? {}),
@@ -256,6 +265,7 @@ Hooks.on("renderChatMessageHTML", (message, html, data) => {
      const isRangedAttack = (rollTargetOptions?.attackMode === "ranged")
        || (attacker?.type === "monster" && attacker.system.attackMode === "ranged")
        || (attackerWeapon?.system?.weaponType === "ranged")
+        || (rollTargetOptions?.isRangedAttack === true)

      const defenseMsg = {
        type: "requestDefense",
@@ -270,6 +280,8 @@ Hooks.on("renderChatMessageHTML", (message, html, data) => {
        attackD30result,
        attackD30message,
        attackRerollContext,
+        attackNaturalRoll,
+        damageTier,
        combatantId,
        tokenId,
        isRanged: isRangedAttack
@@ -331,6 +343,9 @@ Hooks.on("renderChatMessageHTML", (message, html, data) => {
      const damageFormula = btn.dataset.damageFormula
      const damageModifier = btn.dataset.damageModifier
      const isMonster = btn.dataset.isMonster
+      const d30Bleed = btn.dataset.d30Bleed === "true"
+      const d30DamageMultiplier = Number(btn.dataset.d30DamageMult) || 1
+      const d30DrMultiplier = Number(btn.dataset.d30DrMult) || 1

      // Récupérer l'acteur (soit depuis le message, soit depuis attackerId)
      const actor = attackerId ? game.actors.get(attackerId) : game.actors.get(message.rolls[0]?.actorId)
@@ -339,45 +354,70 @@ Hooks.on("renderChatMessageHTML", (message, html, data) => {
        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: () => "cancel"
+            }
+          ],
+          rejectClose: false
        })
+        if (manualDR === null || manualDR === "cancel") 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
+          actorImage: actor.img,
+          d30Bleed,
+          d30DamageMultiplier,
+          d30DrMultiplier
        }
-        const roll = new LethalFantasyRoll(damageFormula, {}, rollOpts)
-        await roll.evaluate()
-        roll.options.rollTotal = roll.total
-        if (game?.dice3d) await game.dice3d.showForRoll(roll, game.user, true)
-        await roll.toMessage()
+        await documents.LethalFantasyRoll.rollSpellDamageToMessage(damageFormula, rollOpts)
        return
      }

      // Pour les boutons de résultat de combat (monster damage)
      if (damageType === "monster" && attackKey) {
-        await actor.system.prepareMonsterRoll("monster-damage", attackKey, undefined, undefined, undefined, defenderId, defenderTokenId, extraShieldDr)
+        await actor.system.prepareMonsterRoll("monster-damage", attackKey, undefined, undefined, undefined, defenderId, defenderTokenId, extraShieldDr, { d30Bleed, d30DamageMultiplier, d30DrMultiplier })
        return
      }

      // Pour les monstres, utiliser prepareMonsterRoll
-      if (isMonster || actor.type === "monster") {
-        await actor.system.prepareMonsterRoll("monster-damage", weaponId, undefined, undefined, damageModifier)
+      if (isMonster === "true" || actor.type === "monster") {
+        await actor.system.prepareMonsterRoll("monster-damage", weaponId, undefined, undefined, damageModifier, defenderId, defenderTokenId, extraShieldDr, { d30Bleed, d30DamageMultiplier, d30DrMultiplier })
        return
      }

@@ -388,9 +428,9 @@ Hooks.on("renderChatMessageHTML", (message, html, data) => {
        return
      }

-      // Lancer les dégâts avec la bonne méthode
-      const rollType = damageType === "small" ? "weapon-damage-small" : "weapon-damage-medium"
-      await actor.prepareRoll(rollType, weaponId, undefined, defenderId, defenderTokenId, extraShieldDr)
+      // Lancer les dégâts
+      const rollType = "weapon-damage"
+      await actor.prepareRoll(rollType, weaponId, undefined, defenderId, defenderTokenId, extraShieldDr, { d30Bleed, d30DamageMultiplier, d30DrMultiplier })
    })
  }

@@ -454,6 +494,8 @@ Hooks.on("createChatMessage", async (message) => {
    attackRollKey,
    attackD30message,
    attackRerollContext,
+    attackNaturalRoll,
+    damageTier,
    defenderId,
    defenderTokenId
  } = attackData
@@ -497,281 +539,376 @@ Hooks.on("createChatMessage", async (message) => {
    })
  }

-  // Si le défenseur est un personnage qui perd, proposer Grit/Luck (seulement s'il a des points)
-  // Seulement si l'utilisateur actuel est le propriétaire du défenseur
+  // Reaction phase — both sides may use grit/luck/shield/mulligan before the outcome is resolved.
+  // After a mulligan reroll (either side), the comparison restarts so both sides can react to the new numbers.
  let defenderHandledBonus = false
+  let attackerHandledBonus = false
  let shieldReaction = null
  let shieldBlocked = false
  const isSpellOrMiracle = attackRollType === "spell-attack" || attackRollType === "miracle-attack"
-  if (defender && defenseRoll < attackRoll && isPrimaryController(defender) && !isSpellOrMiracle) {
-    const shieldData = LethalFantasyUtils.getShieldReactionData(defender)
-    let canRerollDefense = LethalFantasyUtils.hasD30Reroll(defenseD30message)
-    let canShieldReact = !!shieldData
-    let canAdHocShield = !shieldData
-
-    while (defenseRoll < attackRoll) {
-      const currentGrit = Number(defender.system?.grit?.current) || 0
-      const currentLuck = Number(defender.system?.luck?.current) || 0
-      const buttons = []
-
-      if (currentGrit > 0) {
-        buttons.push({
-          action: "grit",
-          label: `Spend 1 Grit (+1D6) [${currentGrit} left]`,
-          icon: "fa-solid fa-fist-raised",
-          callback: () => "grit"
-        })
-      }
-
-      if (currentLuck > 0) {
-        buttons.push({
-          action: "luck",
-          label: `Spend 1 Luck (+1D6) [${currentLuck} left]`,
-          icon: "fa-solid fa-clover",
-          callback: () => "luck"
-        })
-      }
-
-      buttons.push({
-        action: "bonusDie",
-        label: "Add bonus die",
-        icon: "fa-solid fa-dice",
-        callback: () => "bonusDie"
-      })
-
-      if (canRerollDefense) {
-        buttons.push({
-          action: "rerollDefense",
-          label: "Re-roll defense",
-          icon: "fa-solid fa-rotate-right",
-          callback: () => "rerollDefense"
-        })
-      }
-
-      if (canShieldReact) {
-        buttons.push({
-          action: "shieldReact",
-          label: `Roll shield (${shieldData.label})`,
-          icon: "fa-solid fa-shield",
-          callback: () => "shieldReact"
-        })
-      } else if (canAdHocShield) {
-        // No pre-configured shield — offer ad-hoc shield option (useful for monsters)
-        buttons.push({
-          action: "adHocShield",
-          label: "Roll ad-hoc shield (choose dice + DR)",
-          icon: "fa-solid fa-shield-halved",
-          callback: () => "adHocShield"
-        })
-      }
-
-      buttons.push({
-        action: "continue",
-        label: "Continue (no defense bonus)",
-        icon: "fa-solid fa-forward",
-        callback: () => "continue"
-      })
-
-      const choice = await foundry.applications.api.DialogV2.wait({
-        window: { title: "Defense reactions" },
-        classes: ["lethalfantasy"],
-        content: `
-          <div class="grit-luck-dialog">
-            <div class="combat-status">
-              <p><strong>${attackerName}</strong> rolled <strong>${attackRoll}</strong></p>
-              <p><strong>${defenderName}</strong> currently has <strong>${defenseRoll}</strong></p>
-              ${defenseD30message ? `<p class="bonus-info">D30 special: ${defenseD30message.description}</p>` : ""}
-            </div>
-            <p class="offer-text">Choose how to improve the defense before resolving the hit.</p>
-          </div>
-        `,
-        buttons,
-        rejectClose: false
-      })
-
-      if (!choice || choice === "continue") break
-
-      defenderHandledBonus = true
-
-      if (choice === "grit") {
-        const bonusRoll = await LethalFantasyUtils.rollBonusDie("1d6", defender, (total) => `<p><strong>${defenderName}</strong> spends 1 Grit and rolls <strong>${total}</strong> for defense.</p>`)
-        defenseRoll += bonusRoll
-        await defender.update({ "system.grit.current": currentGrit - 1 })
-        continue
-      }
-
-      if (choice === "luck") {
-        const bonusRoll = await LethalFantasyUtils.rollBonusDie("1d6", defender, (total) => `<p><strong>${defenderName}</strong> spends 1 Luck and rolls <strong>${total}</strong> for defense.</p>`)
-        defenseRoll += bonusRoll
-        await defender.update({ "system.luck.current": currentLuck - 1 })
-        continue
-      }
-
-      if (choice === "bonusDie") {
-        const bonusDie = await LethalFantasyUtils.promptCombatBonusDie(defenderName, "attack", defenseRoll, attackRoll)
-        if (!bonusDie) continue
-        const bonusRoll = await LethalFantasyUtils.rollBonusDie(bonusDie, defender, (total, formula) => `<p><strong>${defenderName}</strong> adds <strong>${formula.toUpperCase()}</strong> and rolls <strong>${total}</strong> for defense.</p>`)
-        defenseRoll += bonusRoll
-        continue
-      }
-
-      if (choice === "rerollDefense" && canRerollDefense) {
-        const oldDefenseRoll = defenseRoll
-        const reroll = await LethalFantasyUtils.rerollConfiguredRoll(defenseRerollContext)
-        canRerollDefense = false
-        if (!reroll) continue
-        defenseRoll = reroll.options?.rollTotal || reroll.total || oldDefenseRoll
-        await createReactionMessage(defender, `<p><strong>${defenderName}</strong> uses Mulligan and re-rolls defense: <strong>${oldDefenseRoll}</strong> → <strong>${defenseRoll}</strong>.</p>`)
-        continue
-      }
-
-      if (choice === "shieldReact" && canShieldReact) {
-        const shieldBonus = await LethalFantasyUtils.rollBonusDie(shieldData.formula, defender)
-        const newDefenseTotal = defenseRoll + shieldBonus
-        defenseRoll = newDefenseTotal
-        canShieldReact = false
-
-        if (newDefenseTotal >= attackRoll) {
-          shieldBlocked = true
-          shieldReaction = {
-            damageReduction: shieldData.damageReduction,
-            label: shieldData.label,
-            bonus: shieldBonus
-          }
-          await createReactionMessage(
-            defender,
-            `<p><strong>${defenderName}</strong> rolls <strong>${shieldData.label}</strong> and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} ≥ ${attackRoll}). <strong>Shield blocked the attack!</strong> Both armor DR and shield DR <strong>${shieldData.damageReduction}</strong> will apply to damage.</p>`
-          )
-        } else {
-          shieldReaction = null
-          await createReactionMessage(
-            defender,
-            `<p><strong>${defenderName}</strong> rolls <strong>${shieldData.label}</strong> and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} < ${attackRoll}). Shield did not block — normal hit, armor DR only.</p>`
-          )
-        }
-      }
-
-      if (choice === "adHocShield") {
-        const adHoc = await LethalFantasyUtils.promptAdHocShield(defenderName, attackRoll, defenseRoll)
-        if (!adHoc) continue
-        const shieldBonus = await LethalFantasyUtils.rollBonusDie(adHoc.formula, defender)
-        const newDefenseTotal = defenseRoll + shieldBonus
-        defenseRoll = newDefenseTotal
-        canShieldReact = false
-        canAdHocShield = false
-
-        if (newDefenseTotal >= attackRoll) {
-          shieldBlocked = true
-          shieldReaction = {
-            damageReduction: adHoc.damageReduction,
-            label: `${adHoc.formula.toUpperCase()} shield`,
-            bonus: shieldBonus
-          }
-          await createReactionMessage(
-            defender,
-            `<p><strong>${defenderName}</strong> rolls <strong>${adHoc.formula.toUpperCase()}</strong> shield and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} ≥ ${attackRoll}). <strong>Shield blocked the attack!</strong> Both armor DR and shield DR <strong>${adHoc.damageReduction}</strong> will apply to damage.</p>`
-          )
-        } else {
-          shieldReaction = null
-          await createReactionMessage(
-            defender,
-            `<p><strong>${defenderName}</strong> rolls <strong>${adHoc.formula.toUpperCase()}</strong> shield and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} < ${attackRoll}). Shield did not block — normal hit, armor DR only.</p>`
-          )
-        }
-      }
-    }
-  }

+  // These persist across mulligan restarts (once used they stay consumed)
+  const shieldData = LethalFantasyUtils.getShieldReactionData(defender)
+  let canRerollDefense = LethalFantasyUtils.hasD30Reroll(defenseD30message)
+  let canShieldReact = !!shieldData
+  let canAdHocShield = !shieldData
  let attackRollFinal = attackRoll
-  let attackerHandledBonus = false
+  let canRerollAttack = LethalFantasyUtils.hasD30Reroll(attackD30message)
+  let mulliganRestart = false
+  // These persist across mulligan restarts (D30 bonus only applied once)
+  let defenseD30Processed = false
+  let attackD30Processed = false
+  // D30 combat effects for damage application
+  let d30Bleed = false
+  let d30DamageMultiplier = 1
+  let d30DrMultiplier = 1

-  // Si l'attaquant est un personnage qui perd et a du Grit
-  // Seulement si l'utilisateur actuel est le propriétaire de l'attaquant (pas le MJ)
-  if (!defenderHandledBonus && attacker && attackRollFinal <= defenseRoll && isPrimaryController(attacker)) {
-    let canRerollAttack = LethalFantasyUtils.hasD30Reroll(attackD30message)
+  do {
+    mulliganRestart = false
+    defenderHandledBonus = false
+    attackerHandledBonus = false

-    while (attackRollFinal <= defenseRoll) {
-      const currentGrit = Number(attacker.system?.grit?.current) || 0
-      const buttons = []
-
-      if (currentGrit > 0) {
-        buttons.push({
-          action: "grit",
-          label: `Spend 1 Grit (+1D6) [${currentGrit} left]`,
-          icon: "fa-solid fa-fist-raised",
-          callback: () => "grit"
-        })
+    // ── D30 bonus dice (defense) — resolved before grit/luck/shield ───────
+    if (defenseD30message && !defenseD30Processed && isPrimaryController(defender)) {
+      const d30Result = await LethalFantasyUtils.processD30BonusDice(defenseD30message, "defense", null, defender, true)
+      if (d30Result.modifier) {
+        defenseRoll += d30Result.modifier
+        if (d30Result.modifier > 0) {
+          await createReactionMessage(defender,
+            `<p><strong>${defenderName}</strong> gains <strong>+${d30Result.modifier}</strong> from D30 bonus die for defense.</p>`
+          )
+        }
      }
-
-      buttons.push({
-        action: "bonusDie",
-        label: "Add bonus die",
-        icon: "fa-solid fa-dice",
-        callback: () => "bonusDie"
-      })
-
-      if (canRerollAttack && attackRerollContext) {
-        buttons.push({
-          action: "rerollAttack",
-          label: "Re-roll attack",
-          icon: "fa-solid fa-rotate-right",
-          callback: () => "rerollAttack"
-        })
+      if (d30Result.specialEffect === "auto") {
+        defenseRoll = attackRollFinal + 1 // auto-block
+        await createReactionMessage(defender,
+          `<p><strong>${defenderName}</strong> uses <strong>${d30Result.specialName || "Special Defense"}</strong> from D30 — defense automatically succeeds!</p>`
+        )
      }
+      if (d30Result.specialEffect === "flag") {
+        await createReactionMessage(defender,
+          `<p>D30 — <strong>${d30Result.specialName || "Special Effect"}</strong> triggered for ${defenderName}!</p>`
+        )
+      }
+      if (d30Result.specialEffect === "drMultiplier") {
+        d30DrMultiplier = d30Result.multiplier
+        await createReactionMessage(defender,
+          `<p>D30 — Defense grants <strong>x${d30Result.multiplier} DR</strong> (choose which DR types to multiply when damage is applied)</p>`
+        )
+      }
+      defenseD30Processed = true
+    }

-      buttons.push({
-        action: "continue",
-        label: "Continue (no attack bonus)",
-        icon: "fa-solid fa-forward",
-        callback: () => "continue"
-      })
+    // ── Defense reaction loop ──────────────────────────────────────────────
+    if (defender && defenseRoll < attackRollFinal && isPrimaryController(defender) && !isSpellOrMiracle) {
+      while (defenseRoll < attackRollFinal) {
+        const currentGrit = Number(defender.system?.grit?.current) || 0
+        const currentLuck = Number(defender.system?.luck?.current) || 0
+        const buttons = []

-      const choice = await foundry.applications.api.DialogV2.wait({
-        window: { title: "Attack reactions" },
-        classes: ["lethalfantasy"],
-        content: `
-          <div class="grit-luck-dialog">
-            <div class="combat-status">
-              <p><strong>${attackerName}</strong> currently has <strong>${attackRollFinal}</strong></p>
-              <p><strong>${defenderName}</strong> rolled <strong>${defenseRoll}</strong></p>
-              ${attackD30message ? `<p class="bonus-info">D30 special: ${attackD30message.description}</p>` : ""}
+        if (currentGrit > 0) {
+          buttons.push({
+            action: "grit",
+            label: `Spend 1 Grit (+1D6) [${currentGrit} left]`,
+            icon: "fa-solid fa-fist-raised",
+            callback: () => "grit"
+          })
+        }
+
+        if (currentLuck > 0) {
+          buttons.push({
+            action: "luck",
+            label: `Spend 1 Luck (+1D6) [${currentLuck} left]`,
+            icon: "fa-solid fa-clover",
+            callback: () => "luck"
+          })
+        }
+
+        buttons.push({
+          action: "bonusDie",
+          label: "Add bonus die",
+          icon: "fa-solid fa-dice",
+          callback: () => "bonusDie"
+        })
+
+        if (canRerollDefense) {
+          buttons.push({
+            action: "rerollDefense",
+            label: "Re-roll defense (Mulligan)",
+            icon: "fa-solid fa-rotate-right",
+            callback: () => "rerollDefense"
+          })
+        }
+
+        if (canShieldReact) {
+          buttons.push({
+            action: "shieldReact",
+            label: `Roll shield (${shieldData.label})`,
+            icon: "fa-solid fa-shield",
+            callback: () => "shieldReact"
+          })
+        } else if (canAdHocShield) {
+          buttons.push({
+            action: "adHocShield",
+            label: "Roll ad-hoc shield (choose dice + DR)",
+            icon: "fa-solid fa-shield-halved",
+            callback: () => "adHocShield"
+          })
+        }
+
+        buttons.push({
+          action: "continue",
+          label: "Continue (no defense bonus)",
+          icon: "fa-solid fa-forward",
+          callback: () => "continue"
+        })
+
+        const choice = await foundry.applications.api.DialogV2.wait({
+          window: { title: "Defense reactions" },
+          classes: ["lethalfantasy"],
+          content: `
+            <div class="grit-luck-dialog">
+              <div class="combat-status">
+                <p><strong>${attackerName}</strong> rolled <strong>${attackRollFinal}</strong></p>
+                <p><strong>${defenderName}</strong> currently has <strong>${defenseRoll}</strong></p>
+                ${defenseD30message ? `<p class="bonus-info">D30 special: ${defenseD30message.description}</p>` : ""}
+              </div>
+              <p class="offer-text">Choose how to improve the defense before resolving the hit.</p>
            </div>
-            <p class="offer-text">Choose how to improve the attack before resolving the combat result.</p>
-          </div>
-        `,
-        buttons,
-        rejectClose: false
-      })
+          `,
+          buttons,
+          rejectClose: false
+        })

-      if (!choice || choice === "continue") break
+        if (!choice || choice === "continue") break

-      attackerHandledBonus = true
+        defenderHandledBonus = true

-      if (choice === "grit") {
-        const attackBonus = await LethalFantasyUtils.rollBonusDie("1d6", attacker, (total) => `<p><strong>${attackerName}</strong> spends 1 Grit and rolls <strong>${total}</strong> for attack.</p>`)
-        attackRollFinal += attackBonus
-        await attacker.update({ "system.grit.current": currentGrit - 1 })
-        continue
-      }
+        if (choice === "grit") {
+          const bonusRoll = await LethalFantasyUtils.rollBonusDie("1d6", defender, total => `<p><strong>${defenderName}</strong> spends 1 Grit and rolls <strong>${total}</strong> for defense.</p>`)
+          defenseRoll += bonusRoll
+          await defender.update({ "system.grit.current": currentGrit - 1 })
+          continue
+        }

-      if (choice === "bonusDie") {
-        const bonusDie = await LethalFantasyUtils.promptCombatBonusDie(attackerName, "defense", attackRollFinal, defenseRoll)
-        if (!bonusDie) continue
-        const attackBonus = await LethalFantasyUtils.rollBonusDie(bonusDie, attacker, (total, formula) => `<p><strong>${attackerName}</strong> adds <strong>${formula.toUpperCase()}</strong> and rolls <strong>${total}</strong> for attack.</p>`)
-        attackRollFinal += attackBonus
-        continue
-      }
+        if (choice === "luck") {
+          const bonusRoll = await LethalFantasyUtils.rollBonusDie("1d6", defender, total => `<p><strong>${defenderName}</strong> spends 1 Luck and rolls <strong>${total}</strong> for defense.</p>`)
+          defenseRoll += bonusRoll
+          await defender.update({ "system.luck.current": currentLuck - 1 })
+          continue
+        }

-      if (choice === "rerollAttack" && canRerollAttack && attackRerollContext) {
-        const oldAttackRoll = attackRollFinal
-        const reroll = await LethalFantasyUtils.rerollConfiguredRoll(attackRerollContext)
-        canRerollAttack = false
-        if (!reroll) continue
-        attackRollFinal = reroll.options?.rollTotal || reroll.total || oldAttackRoll
-        await createReactionMessage(attacker, `<p><strong>${attackerName}</strong> uses Mulligan and re-rolls attack: <strong>${oldAttackRoll}</strong> → <strong>${attackRollFinal}</strong>.</p>`)
+        if (choice === "bonusDie") {
+          const bonusDie = await LethalFantasyUtils.promptCombatBonusDie(defenderName, "attack", defenseRoll, attackRollFinal)
+          if (!bonusDie) continue
+          const bonusRoll = await LethalFantasyUtils.rollBonusDie(bonusDie, defender, (total, formula) => `<p><strong>${defenderName}</strong> adds <strong>${formula.toUpperCase()}</strong> and rolls <strong>${total}</strong> for defense.</p>`)
+          defenseRoll += bonusRoll
+          continue
+        }
+
+        if (choice === "rerollDefense" && canRerollDefense) {
+          const oldDefenseRoll = defenseRoll
+          const reroll = await LethalFantasyUtils.rerollConfiguredRoll(defenseRerollContext)
+          canRerollDefense = false
+          if (!reroll) continue
+          defenseRoll = reroll.options?.rollTotal || reroll.total || oldDefenseRoll
+          await createReactionMessage(defender, `<p><strong>${defenderName}</strong> uses Mulligan and re-rolls defense: <strong>${oldDefenseRoll}</strong> → <strong>${defenseRoll}</strong>. Both sides may now react to the new numbers.</p>`)
+          // Restart the full comparison so both sides can react to the new roll
+          mulliganRestart = true
+          break
+        }
+
+        if (choice === "shieldReact" && canShieldReact) {
+          const shieldBonus = await LethalFantasyUtils.rollBonusDie(shieldData.formula, defender)
+          const newDefenseTotal = defenseRoll + shieldBonus
+          defenseRoll = newDefenseTotal
+          canShieldReact = false
+
+          if (newDefenseTotal >= attackRollFinal) {
+            shieldBlocked = true
+            shieldReaction = {
+              damageReduction: shieldData.damageReduction,
+              label: shieldData.label,
+              bonus: shieldBonus
+            }
+            await createReactionMessage(
+              defender,
+              `<p><strong>${defenderName}</strong> rolls <strong>${shieldData.label}</strong> and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} ≥ ${attackRollFinal}). <strong>Shield blocked the attack!</strong> Both armor DR and shield DR <strong>${shieldData.damageReduction}</strong> will apply to damage.</p>`
+            )
+          } else {
+            shieldReaction = null
+            await createReactionMessage(
+              defender,
+              `<p><strong>${defenderName}</strong> rolls <strong>${shieldData.label}</strong> and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} < ${attackRollFinal}). Shield did not block — normal hit, armor DR only.</p>`
+            )
+          }
+        }
+
+        if (choice === "adHocShield") {
+          const adHoc = await LethalFantasyUtils.promptAdHocShield(defenderName, attackRollFinal, defenseRoll)
+          if (!adHoc) continue
+          const shieldBonus = await LethalFantasyUtils.rollBonusDie(adHoc.formula, defender)
+          const newDefenseTotal = defenseRoll + shieldBonus
+          defenseRoll = newDefenseTotal
+          canShieldReact = false
+          canAdHocShield = false
+
+          if (newDefenseTotal >= attackRollFinal) {
+            shieldBlocked = true
+            shieldReaction = {
+              damageReduction: adHoc.damageReduction,
+              label: `${adHoc.formula.toUpperCase()} shield`,
+              bonus: shieldBonus
+            }
+            await createReactionMessage(
+              defender,
+              `<p><strong>${defenderName}</strong> rolls <strong>${adHoc.formula.toUpperCase()}</strong> shield and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} ≥ ${attackRollFinal}). <strong>Shield blocked the attack!</strong> Both armor DR and shield DR <strong>${adHoc.damageReduction}</strong> will apply to damage.</p>`
+            )
+          } else {
+            shieldReaction = null
+            await createReactionMessage(
+              defender,
+              `<p><strong>${defenderName}</strong> rolls <strong>${adHoc.formula.toUpperCase()}</strong> shield and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} < ${attackRollFinal}). Shield did not block — normal hit, armor DR only.</p>`
+            )
+          }
+        }
      }
    }
-  }
+
+    if (mulliganRestart) continue
+
+    // ── D30 bonus dice (attack) — resolved before grit/luck ────────────────
+    if (attackD30message && !attackD30Processed) {
+      const canDialog = isPrimaryController(attacker)
+      const d30Result = await LethalFantasyUtils.processD30BonusDice(attackD30message, "attack", attackNaturalRoll, attacker, canDialog)
+      if (d30Result.modifier) {
+        attackRollFinal += d30Result.modifier
+        if (d30Result.modifier > 0 && canDialog) {
+          await createReactionMessage(attacker,
+            `<p><strong>${attackerName}</strong> gains <strong>+${d30Result.modifier}</strong> from D30 bonus die for attack.</p>`
+          )
+        }
+      }
+      if (d30Result.specialEffect === "auto") {
+        attackRollFinal = defenseRoll + 1 // auto-hit
+        if (canDialog) {
+          await createReactionMessage(attacker,
+            `<p><strong>${attackerName}</strong> uses <strong>${d30Result.specialName || "Special Strike"}</strong> from D30 — attack automatically hits!</p>`
+          )
+        }
+      }
+      if (d30Result.specialEffect === "flag" && canDialog) {
+        await createReactionMessage(attacker,
+          `<p>D30 — <strong>${d30Result.specialName || "Special Effect"}</strong> triggered for ${attackerName}!</p>`
+        )
+      }
+      if (d30Result.specialEffect === "bleed") {
+        d30Bleed = true
+        if (canDialog) {
+          await createReactionMessage(attacker,
+            `<p>D30 — <strong>Bleeding/Internal Injury</strong> on hit! Damage past DR will cause a bleeding wound.</p>`
+          )
+        }
+      }
+      if (d30Result.specialEffect === "damageMultiplier") {
+        d30DamageMultiplier = d30Result.multiplier
+        if (canDialog) {
+          await createReactionMessage(attacker,
+            `<p>D30 — <strong>x${d30Result.multiplier} damage</strong> before damage reduction!</p>`
+          )
+        }
+      }
+      attackD30Processed = true
+    }
+
+    // ── Attack reaction loop ───────────────────────────────────────────────
+    if (!defenderHandledBonus && attacker && attackRollFinal <= defenseRoll && isPrimaryController(attacker)) {
+      while (attackRollFinal <= defenseRoll) {
+        const currentGrit = Number(attacker.system?.grit?.current) || 0
+        const buttons = []
+
+        if (currentGrit > 0) {
+          buttons.push({
+            action: "grit",
+            label: `Spend 1 Grit (+1D6) [${currentGrit} left]`,
+            icon: "fa-solid fa-fist-raised",
+            callback: () => "grit"
+          })
+        }
+
+        buttons.push({
+          action: "bonusDie",
+          label: "Add bonus die",
+          icon: "fa-solid fa-dice",
+          callback: () => "bonusDie"
+        })
+
+        if (canRerollAttack && attackRerollContext) {
+          buttons.push({
+            action: "rerollAttack",
+            label: "Re-roll attack (Mulligan)",
+            icon: "fa-solid fa-rotate-right",
+            callback: () => "rerollAttack"
+          })
+        }
+
+        buttons.push({
+          action: "continue",
+          label: "Continue (no attack bonus)",
+          icon: "fa-solid fa-forward",
+          callback: () => "continue"
+        })
+
+        const choice = await foundry.applications.api.DialogV2.wait({
+          window: { title: "Attack reactions" },
+          classes: ["lethalfantasy"],
+          content: `
+            <div class="grit-luck-dialog">
+              <div class="combat-status">
+                <p><strong>${attackerName}</strong> currently has <strong>${attackRollFinal}</strong></p>
+                <p><strong>${defenderName}</strong> rolled <strong>${defenseRoll}</strong></p>
+                ${attackD30message ? `<p class="bonus-info">D30 special: ${attackD30message.description}</p>` : ""}
+              </div>
+              <p class="offer-text">Choose how to improve the attack before resolving the combat result.</p>
+            </div>
+          `,
+          buttons,
+          rejectClose: false
+        })
+
+        if (!choice || choice === "continue") break
+
+        attackerHandledBonus = true
+
+        if (choice === "grit") {
+          const attackBonus = await LethalFantasyUtils.rollBonusDie("1d6", attacker, total => `<p><strong>${attackerName}</strong> spends 1 Grit and rolls <strong>${total}</strong> for attack.</p>`)
+          attackRollFinal += attackBonus
+          await attacker.update({ "system.grit.current": currentGrit - 1 })
+          continue
+        }
+
+        if (choice === "bonusDie") {
+          const bonusDie = await LethalFantasyUtils.promptCombatBonusDie(attackerName, "defense", attackRollFinal, defenseRoll)
+          if (!bonusDie) continue
+          const attackBonus = await LethalFantasyUtils.rollBonusDie(bonusDie, attacker, (total, formula) => `<p><strong>${attackerName}</strong> adds <strong>${formula.toUpperCase()}</strong> and rolls <strong>${total}</strong> for attack.</p>`)
+          attackRollFinal += attackBonus
+          continue
+        }
+
+        if (choice === "rerollAttack" && canRerollAttack && attackRerollContext) {
+          const oldAttackRoll = attackRollFinal
+          const reroll = await LethalFantasyUtils.rerollConfiguredRoll(attackRerollContext)
+          canRerollAttack = false
+          if (!reroll) continue
+          attackRollFinal = reroll.options?.rollTotal || reroll.total || oldAttackRoll
+          await createReactionMessage(attacker, `<p><strong>${attackerName}</strong> uses Mulligan and re-rolls attack: <strong>${oldAttackRoll}</strong> → <strong>${attackRollFinal}</strong>. Both sides may now react to the new numbers.</p>`)
+          // Restart the full comparison so both sides can react to the new roll
+          mulliganRestart = true
+          break
+        }
+      }
+    }
+  } while (mulliganRestart)

  const shieldDamageReduction = shieldBlocked ? shieldReaction.damageReduction : 0
  const outcome = shieldBlocked ? "shielded-hit" : (attackRollFinal > defenseRoll ? "hit" : "miss")
@@ -795,7 +932,12 @@ Hooks.on("createChatMessage", async (message) => {
      defenderTokenId,
      defenseRoll,
      outcome,
-      shieldDamageReduction
+      shieldDamageReduction,
+      d30Bleed: d30Bleed ? "true" : "",
+      d30DamageMultiplier: d30DamageMultiplier,
+      d30DrMultiplier: d30DrMultiplier,
+      damageTier: damageTier || "standard",
+      attackD30message
    })
  } else {
    console.log("Skipping message creation", { attackerHandledBonus, defenderHandledBonus })
@@ -823,15 +965,19 @@ Hooks.on("createChatMessage", async (message) => {
  const spell = spellId ? actor.items.get(spellId) : null
  if (!spell || spell.type !== "spell") return

-  const cost = Number(spell.system?.cost) || 0
+  const damageTier = message.rolls[0]?.options?.damageTier || "standard"
+  const tierCostMap = { standard: "cost", overpowered: "costOverpowered", overpowered2: "costOverpowered2" }
+  const costField = tierCostMap[damageTier] || "cost"
+  const cost = Number(spell.system?.[costField]) || 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 })

+  const tierLabel = damageTier === "standard" ? "" : ` (${damageTier})`
  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>`,
+    content: `<p>🔮 <strong>${actor.name}</strong> casts <em>${spell.name}${tierLabel}</em> — spends <strong>${cost}</strong> Aether <span style="color:#888;">(${currentAether} → ${newAether})</span>.</p>`,
    speaker: ChatMessage.getSpeaker({ actor })
  })
 })
@@ -922,13 +1068,96 @@ 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)
+  // Lire les effets D30
+  const d30Bleed = message.rolls[0]?.options?.d30Bleed || false
+  const d30DamageMultiplier = message.rolls[0]?.options?.d30DamageMultiplier || 1
+  const d30DrMultiplier = message.rolls[0]?.options?.d30DrMultiplier || 1
+
+  // Appliquer le multiplicateur de dégâts D30 au total AVANT DR
+  const rawDamage = damageTotal * d30DamageMultiplier
+
+  // 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 finalDamage = Math.max(0, damageTotal - totalDR)
+
+  // Décomposer les DR en composants
+  let baseDR = 0
+  let shieldDR = 0
+  let magicDR = 0
+
+  if (isSpellDamage) {
+    baseDR = manualDR
+  } else {
+    const totalDefDR = defender.computeDamageReduction() || 0
+    magicDR = defender.getMagicDR() || 0
+    baseDR = totalDefDR - magicDR // naturalDR + armorDR (ou hpDR + combatDR pour les monstres)
+    shieldDR = extraShieldDr
+  }
+
+  // Appliquer le multiplicateur de DR D30 si actif — boîte de dialogue
+  let appliedBaseDR = baseDR
+  let appliedShieldDR = shieldDR
+  let appliedMagicDR = magicDR
+
+  if (d30DrMultiplier > 1) {
+    const drResult = await (async () => {
+      const checks = {
+        base: true,
+        shield: shieldDR > 0,
+        magic: magicDR > 0
+      }
+      const html = `
+        <div class="grit-luck-dialog">
+          <p><strong>D30 DR Multiplier ×${d30DrMultiplier}</strong></p>
+          <p>Choose which DR types to multiply:</p>
+          <label style="display:block;margin:0.3rem 0">
+            <input type="checkbox" id="d30-dr-base" ${checks.base ? "checked" : ""} ${baseDR <= 0 ? "disabled" : ""}>
+            Base DR (Armor/Natural): ${baseDR} → ×${d30DrMultiplier} = ${baseDR * d30DrMultiplier}
+          </label>
+          <label style="display:block;margin:0.3rem 0">
+            <input type="checkbox" id="d30-dr-shield" ${checks.shield ? "checked" : ""} ${shieldDR <= 0 ? "disabled" : ""}>
+            Shield DR: ${shieldDR} → ×${d30DrMultiplier} = ${shieldDR * d30DrMultiplier}
+          </label>
+          <label style="display:block;margin:0.3rem 0">
+            <input type="checkbox" id="d30-dr-magic" ${checks.magic ? "checked" : ""} ${magicDR <= 0 ? "disabled" : ""}>
+            Magic DR: ${magicDR} → ×${d30DrMultiplier} = ${magicDR * d30DrMultiplier}
+          </label>
+        </div>
+      `
+      const result = await foundry.applications.api.DialogV2.wait({
+        window: { title: "Apply D30 DR Multiplier" },
+        classes: ["lethalfantasy"],
+        content: html,
+        buttons: [
+          {
+            action: "apply",
+            label: "Apply Damage",
+            icon: "fa-solid fa-check",
+            callback: (event, button) => {
+              const form = button.form || button.closest("form")
+              return {
+                applyBase: form.querySelector("#d30-dr-base")?.checked || false,
+                applyShield: form.querySelector("#d30-dr-shield")?.checked || false,
+                applyMagic: form.querySelector("#d30-dr-magic")?.checked || false
+              }
+            }
+          }
+        ],
+        rejectClose: false
+      })
+      return result || { applyBase: false, applyShield: false, applyMagic: false }
+    })()
+
+    appliedBaseDR = drResult.applyBase ? baseDR * d30DrMultiplier : baseDR
+    appliedShieldDR = drResult.applyShield ? shieldDR * d30DrMultiplier : shieldDR
+    appliedMagicDR = drResult.applyMagic ? magicDR * d30DrMultiplier : magicDR
+  }
+
+  const totalDR = appliedBaseDR + appliedShieldDR + appliedMagicDR
+  const finalDamage = Math.max(0, rawDamage - totalDR)

  // Prefer the token ID stored in roll options (set at attack time when the exact token is known).
  // For unlinked tokens (default for monsters), this ensures we target the right instance even
@@ -943,32 +1172,70 @@ Hooks.on("createChatMessage", async (message) => {
  // Apply damage. If the current user does not own the defender (e.g. player hitting a GM monster),
  // route the HP update to the GM via socket. The confirmation message is still created here
  // since all users can create chat messages.
+  const applyDamageToActor = async (actor) => {
+    await actor.applyDamage(-finalDamage)
+    // Create bleeding wound if D30 triggered it
+    if (d30Bleed && finalDamage > 0 && actor.system.hp?.wounds) {
+      const wounds = foundry.utils.duplicate(actor.system.hp.wounds)
+      const slot = wounds.findIndex(w => !w.value && !w.duration)
+      if (slot !== -1) {
+        wounds[slot] = { value: finalDamage, duration: finalDamage, description: "Bleeding" }
+        await actor.update({ "system.hp.wounds": wounds })
+      }
+    }
+  }
+
  if (defender.isOwner) {
-    // Resolve the token actor: prefer lookup by token ID (exact match for unlinked monsters),
-    // fall back to combatant actor, then base world actor.
    const tokenActor = (defenderTokenId
      ? canvas.tokens?.placeables?.find(t => t.id === defenderTokenId)?.actor
      : defenderCombatant?.actor) ?? defender
-    await tokenActor.applyDamage(-finalDamage)
+    await applyDamageToActor(tokenActor)
  } else {
    game.socket.emit(`system.${SYSTEM.id}`, { type: "applyDamage", actorId: defender.id, tokenId: defenderTokenId, damage: -finalDamage })
+    // Also emit wound creation for bleeding
+    if (d30Bleed && finalDamage > 0 && defender.system.hp?.wounds) {
+      game.socket.emit(`system.${SYSTEM.id}`, { type: "applyBleeding", actorId: defender.id, tokenId: defenderTokenId, damage: finalDamage })
+    }
  }

+  // Build DR text for confirmation message
+  let drText = ""
+  if (isSpellDamage) {
+    drText = manualDR > 0 ? `Spell DR: ${manualDR}` : "No DR applied"
+  } else {
+    const parts = []
+    if (appliedBaseDR > 0) parts.push(`Base DR: ${appliedBaseDR}${d30DrMultiplier > 1 && appliedBaseDR !== baseDR ? ` (×${d30DrMultiplier})` : ""}`)
+    if (appliedShieldDR > 0) parts.push(`Shield DR: ${appliedShieldDR}${d30DrMultiplier > 1 && appliedShieldDR !== shieldDR ? ` (×${d30DrMultiplier})` : ""}`)
+    if (appliedMagicDR > 0) parts.push(`Magic DR: ${appliedMagicDR}${d30DrMultiplier > 1 && appliedMagicDR !== magicDR ? ` (×${d30DrMultiplier})` : ""}`)
+    drText = parts.length > 0 ? parts.join(" + ") : "No DR applied"
+  }
+
+  // Build raw damage text showing D30 multiplier if active
+  const rawDamageText = d30DamageMultiplier > 1
+    ? `${damageTotal} × ${d30DamageMultiplier} = ${rawDamage}`
+    : String(damageTotal)
+
  // Créer un message de confirmation (visible to GM only)
  const messageContent = await foundry.applications.handlebars.renderTemplate(
    "systems/fvtt-lethal-fantasy/templates/damage-applied-message.hbs",
    {
      targetName: defender.name,
      damage: finalDamage,
-      drText: bypassArmor ? "Armor DR bypassed (spell)" : (totalDR > 0 ? `Armor DR: ${armorDR}${extraShieldDr > 0 ? ` + Shield DR: ${extraShieldDr}` : ""}` : ""),
+      drText,
      weaponName: weaponName,
      attackerName: attackerName,
-      rawDamage: damageTotal
+      rawDamage: rawDamageText
    }
  )

+  // Add bleeding notification
+  let bleedContent = ""
+  if (d30Bleed && finalDamage > 0) {
+    bleedContent = `<p><strong>Bleeding:</strong> Wound of ${finalDamage} HP for ${finalDamage} seconds.</p>`
+  }
+
  await ChatMessage.create({
-    content: messageContent,
+    content: messageContent + bleedContent,
    speaker: ChatMessage.getSpeaker({ actor: defender }),
    whisper: ChatMessage.getWhisperRecipients("GM")
  })
@@ -119,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);
@@ -143,12 +137,31 @@ export class LethalFantasyCombat extends Combat {
  /** Roll progression dice for all eligible monster combatants this round. Called manually by the GM. */
  async rollMonsterProgression() {
    const currentRound = this.round;
-    for (let c of this.combatants) {
-      if (c.actor.type !== "monster") continue;
+    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) {
@@ -172,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;
@@ -204,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;
@@ -222,6 +231,21 @@ 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
@@ -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.applyMode(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
@@ -219,6 +220,75 @@ 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: () => "cancel"
+        }
+      ],
+      rejectClose: false
+    })
+    if (manualDR === null || manualDR === "cancel") 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
+    }
+    await LethalFantasyRoll.rollSpellDamageToMessage(formula, rollOpts)
+  }
+
  static #onCreateEquipment(event, target) {
  }

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

@@ -115,7 +115,9 @@ export default class LethalFantasyMonsterSheet extends LethalFantasyActorSheet {
  }

  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) {
@@ -108,6 +108,10 @@
          }
        ],
        "description": "Possible Flawless or Legendary Defense or Add D20E to Defense"
+      },
+      "saving_throws": {
+        "type": "save_auto_success",
+        "description": "Saving Throw Succeeds Regardless of Opposing Roll"
      }
    },
    "29": {
@@ -145,6 +149,11 @@
        "type": "gain_grit",
        "amount": 1,
        "description": "Gain 1 Grit"
+      },
+      "saving_throws": {
+        "type": "gain_grit",
+        "amount": 1,
+        "description": "Gain 1 Grit"
      }
    },
    "28": {
@@ -199,6 +208,12 @@
        "amount": 1,
        "target": "skill",
        "description": "Add 1 to Skill Roll"
+      },
+      "saving_throws": {
+        "type": "bonus_flat",
+        "amount": 1,
+        "target": "save",
+        "description": "Add 1 to Saving Throw"
      }
    },
    "21": {
@@ -239,6 +254,12 @@
      "ranged_defense": {
        "type": "recover_pain",
        "description": "Defender Recovers or ignores any flash of pain"
+      },
+      "saving_throws": {
+        "type": "bonus_dice",
+        "dice": "D6",
+        "target": "save",
+        "description": "Granted D6 (1-6) Saving Throw Modifier for this Saving Throw Attempt"
      }
    },
    "20": {
@@ -325,7 +346,7 @@
            "target": "spell_defense"
          }
        ],
-        "description": "Possible 20/20 Spell defense that Saves Against Any Magical Attack Except a Lethal Magical Strike or add D12 to defense"
+        "description": "Possible 20/20 Spell defense that Saves Against Any Magical Attack Except a Lethal Magical Strike or add D12 to spell defense"
      },
      "skill_rolls": {
        "type": "bonus_flat",
@@ -349,6 +370,12 @@
          }
        ],
        "description": "Possible 20/20 defense that avoids Any Attack Except a Lethal Strike or adds D12 to defense"
+      },
+      "saving_throws": {
+        "type": "bonus_flat",
+        "amount": 20,
+        "target": "save",
+        "description": "20 Added to Saving Throw"
      }
    },
    "15": {
@@ -359,10 +386,10 @@
            "type": "bleed"
          },
          {
-            "type": "knockback"
+            "type": "internal_injury"
          }
        ],
-        "description": "Bleed, Knock-back on Hit"
+        "description": "Bleed, Internal Injury on Hit"
      },
      "ranged_attack": {
        "type": "bleed",
@@ -372,10 +399,9 @@
        "type": "counter_attack",
        "options": [
          "kick",
-          "punch",
-          "shield_bash"
+          "punch"
        ],
-        "description": "Kick, Punch or Shield Bash"
+        "description": "Kick or Punch"
      },
      "skill_rolls": {
        "type": "bonus_flat",
@@ -387,10 +413,15 @@
        "type": "counter_attack",
        "options": [
          "kick",
-          "punch",
-          "shield_bash"
+          "punch"
        ],
-        "description": "Kick, Punch or Shield Bash"
+        "description": "Kick or Punch"
+      },
+      "saving_throws": {
+        "type": "bonus_flat",
+        "amount": 1,
+        "target": "save",
+        "description": "Add 1 to Saving Throw"
      }
    },
    "13": {},
@@ -413,10 +444,10 @@
            "type": "bleed"
          },
          {
-            "type": "knockback"
+            "type": "internal_injury"
          }
        ],
-        "description": "Bleed, Knock-back on Hit"
+        "description": "Bleed, Internal Injury on Hit"
      },
      "ranged_attack": {
        "type": "bleed",
@@ -426,10 +457,9 @@
        "type": "counter_attack",
        "options": [
          "kick",
-          "punch",
-          "shield_bash"
+          "punch"
        ],
-        "description": "Kick, Punch or Shield Bash"
+        "description": "Kick or Punch"
      },
      "skill_rolls": {
        "type": "bonus_flat",
@@ -441,10 +471,15 @@
        "type": "counter_attack",
        "options": [
          "kick",
-          "punch",
-          "shield_bash"
+          "punch"
        ],
-        "description": "Kick, Punch or Shield Bash"
+        "description": "Kick or Punch"
+      },
+      "saving_throws": {
+        "type": "bonus_flat",
+        "amount": 1,
+        "target": "save",
+        "description": "Add 1 to Saving Throw"
      }
    },
    "8": {
@@ -475,6 +510,10 @@
      "ranged_defense": {
        "type": "mulligan",
        "description": "Mulligan, Can Choose to Re-Roll This Defense"
+      },
+      "saving_throws": {
+        "type": "mulligan",
+        "description": "Mulligan, Can Re-Roll This Saving Throw"
      }
    },
    "7": {
@@ -496,10 +535,10 @@
            "type": "bleed"
          },
          {
-            "type": "knockback"
+            "type": "internal_injury"
          }
        ],
-        "description": "Bleed, Knock-back on Hit"
+        "description": "Bleed, Internal Injury on Hit"
      },
      "ranged_attack": {
        "type": "bleed",
@@ -509,10 +548,9 @@
        "type": "counter_attack",
        "options": [
          "kick",
-          "punch",
-          "shield_bash"
+          "punch"
        ],
-        "description": "Kick, Punch, or Shield Bash"
+        "description": "Kick or Punch"
      },
      "skill_rolls": {
        "type": "bonus_flat",
@@ -524,10 +562,15 @@
        "type": "counter_attack",
        "options": [
          "kick",
-          "punch",
-          "shield_bash"
+          "punch"
        ],
-        "description": "Kick, Punch, or Shield Bash"
+        "description": "Kick or Punch"
+      },
+      "saving_throws": {
+        "type": "bonus_flat",
+        "amount": 1,
+        "target": "save",
+        "description": "Add 1 to Saving Throw"
      }
    },
    "3": {
@@ -608,7 +651,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,
@@ -72,23 +72,32 @@ export default class LethalFantasyActor extends Actor {
  /* *************************************************/
  async applyDamage(hpLoss) {
    let hp = this.system.hp.value + hpLoss
-    if (hp < 0) {
-      hp = 0
-    }
    this.update({ "system.hp.value": hp })
  }

  /* *************************************************/
-  computeDamageReduction() {
-    // Pour les monstres, utiliser hp.damageResistance et combat.damageReduction
+  getNaturalDR() {
    if (this.type === "monster") {
-      let hpDR = Number(this.system.hp?.damageResistance) || 0
+      return Number(this.system.hp?.damageResistance) || 0
+    }
+    return Number(this.system.biodata?.naturalDR) || 0
+  }
+
+  /* *************************************************/
+  getMagicDR() {
+    if (this.type === "monster") return 0
+    return Number(this.system.biodata?.magicDR) || 0
+  }
+
+  /* *************************************************/
+  computeDamageReduction() {
+    if (this.type === "monster") {
+      let hpDR = this.getNaturalDR()
      let combatDR = Number(this.system.combat?.damageReduction) || 0
      return hpDR + combatDR
    }
-    // Pour les personnages, utiliser biodata et items
-    let naturalDR = Number(this.system.biodata?.naturalDR) || 0
-    let magicDR = Number(this.system.biodata?.magicDR) || 0
+    let naturalDR = this.getNaturalDR()
+    let magicDR = this.getMagicDR()
    let armorDR = this.getArmorDR()
    return naturalDR + magicDR + armorDR
  }
@@ -153,7 +162,7 @@ export default class LethalFantasyActor extends Actor {
  }

  /* *************************************************/
-  async prepareRoll(rollType, rollKey, rollDice, defenderId, defenderTokenId, extraShieldDr = 0) {
+  async prepareRoll(rollType, rollKey, rollDice, defenderId, defenderTokenId, extraShieldDr = 0, d30Effects = {}) {
    console.log("Preparing roll", rollType, rollKey, rollDice, defenderId)
    let rollTarget
    switch (rollType) {
@@ -198,8 +207,15 @@ 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
+        // Read damage tier from combatant currentAction if available
+        const activeCombatant = game.combat?.combatants?.find(c => c.actorId === this.id)
+        const currentAction = activeCombatant?.getFlag(SYSTEM.id, "currentAction")
+        const damageTier = currentAction?.damageTier || "standard"
+        rollTarget.damageTier = damageTier
        if (rollType === "spell-attack" || rollType === "spell-power") {
-          const cost = Number(rollTarget.system?.cost) || 0
+          const tierCostMap = { standard: "cost", overpowered: "costOverpowered", overpowered2: "costOverpowered2" }
+          const costField = tierCostMap[damageTier] || "cost"
+          const cost = Number(rollTarget.system?.[costField]) || 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}).`)
@@ -222,8 +238,7 @@ export default class LethalFantasyActor extends Actor {
        rollTarget.rollKey = rollKey
      }
        break;
-      case "weapon-damage-small":
-      case "weapon-damage-medium":
+      case "weapon-damage":
      case "weapon-attack":
      case "weapon-defense": {
        let weapon = this.items.find((i) => i.type === "weapon" && i.id === rollKey)
@@ -261,9 +276,10 @@ 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") {
+        if (rollType === "weapon-damage") {
          rollTarget.grantedDice = this.system.granted.damageDice
        }
        if (rollType === "weapon-attack") {
@@ -279,14 +295,14 @@ export default class LethalFantasyActor extends Actor {
        break
      default:
        ui.notifications.error(game.i18n.localize("LETHALFANTASY.Notifications.rollTypeNotFound") + String(rollType))
-        break
+        return
    }

    // In all cases
    rollTarget.magicUser = this.system.biodata.magicUser
    rollTarget.actorModifiers = foundry.utils.duplicate(this.system.modifiers)
    rollTarget.actorLevel = this.system.biodata.level
-    await this.system.roll(rollType, rollTarget, defenderId, defenderTokenId, extraShieldDr)
+    await this.system.roll(rollType, rollTarget, defenderId, defenderTokenId, extraShieldDr, d30Effects)
  }

 }
@@ -25,7 +25,8 @@ export default class D30Roll {
    RANGED_DEFENSE: "ranged_defense",
    ARCANE_SPELL_ATTACK: "arcane_spell_attack",
    ARCANE_SPELL_DEFENSE: "arcane_spell_defense",
-    SKILL_ROLLS: "skill_rolls"
+    SKILL_ROLLS: "skill_rolls",
+    SAVING_THROWS: "saving_throws"
  }

  /**
@@ -111,17 +112,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
@@ -138,11 +138,15 @@ export default class D30Roll {
    }

    // Skill types
-    if (externalType === "skill" || externalType === "monster-skill" ||
-        externalType === "save" || externalType === "challenge") {
+    if (externalType === "skill" || externalType === "monster-skill" || externalType === "challenge") {
      return this.ROLL_TYPES.SKILL_ROLLS
    }

+    // Saving throw types
+    if (externalType === "save") {
+      return options.isSpellSave ? this.ROLL_TYPES.ARCANE_SPELL_DEFENSE : this.ROLL_TYPES.SAVING_THROWS
+    }
+
    // If no match, return null
    console.warn(`D30Roll | Unknown external roll type: ${externalType}`)
    return null
@@ -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"
@@ -283,13 +285,7 @@ export default class LethalFantasyRoll extends Roll {
      let damageBonus = (options.rollTarget.weapon.system.applyStrengthDamageBonus) ? options.rollTarget.combat.damageModifier : 0
      options.rollTarget.value = damageBonus + options.rollTarget.weaponSkillModifier + options.rollTarget.weapon.system.bonuses.damageBonus
      options.rollTarget.charModifier = damageBonus
-      if (options.rollType.includes("small")) {
-        options.damageSmall = true
-        dice = options.rollTarget.weapon.system.damage.damageS
-      } else {
-        options.damageMedium = true
-        dice = options.rollTarget.weapon.system.damage.damageM
-      }
+      dice = options.rollTarget.weapon.system.damage.damageM
      if (/NE$/i.test(dice)) {
        hasMaxValue = false
        hasExplode = false
@@ -321,7 +317,7 @@ export default class LethalFantasyRoll extends Roll {
    }

    const rollModes = foundry.utils.duplicate(CONFIG.ChatMessage.modes);
-    console.log("Roll mode", rollModes)
+

    const fieldRollMode = new foundry.data.fields.StringField({
      choices: rollModes,
@@ -336,6 +332,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,
@@ -360,7 +360,8 @@ export default class LethalFantasyRoll extends Roll {
      modifier,
      saveSpell: false,
      favor: "none",
-      targetName
+      targetName,
+      isRangedAttack
    }
    let rollContext
    if (options.rollContext) {
@@ -370,7 +371,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}`
@@ -390,7 +393,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
@@ -401,22 +404,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) {
@@ -520,8 +523,6 @@ export default class LethalFantasyRoll extends Roll {
      rollMode: rollContext.visibility,
      hasTarget: options.hasTarget,
      isDamage: options.isDamage,
-      damageSmall: options.damageSmall,
-      damageMedium: options.damageMedium,
      pointBlank,
      beyondSkill,
      letItFly,
@@ -590,12 +591,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, isSpellSave: saveSpell }
      )
      options.D30message = d30Message
    }
@@ -614,9 +620,6 @@ export default class LethalFantasyRoll extends Roll {
        if (hasMaxValue) {
          while (diceResult === maxValue) {
            let r = await new Roll(baseFormula).evaluate()
-            if (game?.dice3d) {
-              await game.dice3d.showForRoll(r, game.user, true)
-            }
            diceResult = r.dice[0].results[0].result
            diceResults.push({ dice: `${singleDice.toUpperCase()}-1`, value: diceResult - 1 })
            diceSum += (diceResult - 1)
@@ -659,6 +662,10 @@ export default class LethalFantasyRoll extends Roll {
    rollBase.options.defenderId = options.defenderId
    rollBase.options.defenderTokenId = options.defenderTokenId
    rollBase.options.extraShieldDr = options.extraShieldDr || 0
+    rollBase.options.damageTier = options.damageTier || "standard"
+    rollBase.options.d30Bleed = options.d30Bleed || false
+    rollBase.options.d30DamageMultiplier = options.d30DamageMultiplier || 1
+    rollBase.options.d30DrMultiplier = options.d30DrMultiplier || 1

    /**
     * A hook event that fires after the roll has been made.
@@ -708,7 +715,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
@@ -773,10 +780,19 @@ export default class LethalFantasyRoll extends Roll {
    let buttons = []
    if (currentAction) {
      if (currentAction.type === "weapon") {
+        let weaponLabel = "Roll progression dice"
+        if (currentAction.rangedMode) {
+          // Compute loading count from the speed formula (e.g. "3+1d6" → load=3)
+          const speedStr = currentAction.system?.speed?.[currentAction.rangedMode] ?? ""
+          const rangedLoad = currentAction.rangedLoad ?? (Number(speedStr.split("+")[0]) || 0)
+          if (rangedLoad > 0 && !currentAction.weaponLoaded) {
+            weaponLabel = "Load weapon"
+          }
+        }
        buttons.push({
          action: "roll",
-          label: "Roll progression dice",
-          callback: (event, button, dialog) => {
+          label: weaponLabel,
+          callback: (event, button) => {
            let pos = $('#combat-action-dialog').position()
            game.user.setFlag(SYSTEM.id, "combat-action-dialog-pos", pos)
            return "rollProgressionDice"
@@ -802,7 +818,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"
@@ -813,7 +829,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) => {
@@ -828,7 +844,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;
@@ -880,6 +896,29 @@ export default class LethalFantasyRoll extends Roll {
      actionItem.progressionCount = firstActionTaken ? 1 : (combatant.actor.system.combat?.combatProgressionStart ?? 1)
      if (!firstActionTaken) await combatant.setFlag(SYSTEM.id, "firstActionTaken", true)
      actionItem.rangedMode = rangedMode
+      // If this is a spell/miracle with multiple damage tiers, prompt tier choice
+      if (actionItem.system?.damageDice) {
+        const tiers = [
+          { id: "standard", label: "Standard", dice: actionItem.system.damageDice },
+          { id: "overpowered", label: "Overpowered", dice: actionItem.system.damageDiceOverpowered },
+          { id: "overpowered2", label: "Overpowered 2", dice: actionItem.system.damageDiceOverpowered2 },
+        ].filter(t => t.dice)
+        if (tiers.length > 1) {
+          const tierChoice = await foundry.applications.api.DialogV2.wait({
+            window: { title: "Choose Damage Tier" },
+            classes: ["lethalfantasy"],
+            content: `<div class="grit-luck-dialog"><p><strong>${selectedItem.name}</strong> has multiple damage tiers.</p><p>Choose which damage to use when the attack lands:</p></div>`,
+            buttons: tiers.map(t => ({
+              action: t.id,
+              label: `${t.label} (${t.dice.toUpperCase()})`,
+              icon: "fa-solid fa-wand-magic-sparkles",
+              callback: () => t.id
+            })),
+            rejectClose: false
+          })
+          actionItem.damageTier = tierChoice || "standard"
+        }
+      }
      actionItem.castingTime = 1
      actionItem.spellStatus = "castingTime"
      // Set the flag on the combatant
@@ -901,7 +940,8 @@ export default class LethalFantasyRoll extends Roll {
            await combatant.setFlag(SYSTEM.id, "currentAction", foundry.utils.duplicate(currentAction))
            return
          } else {
-            let message = `Spell/Miracle ${currentAction.name} ready to be cast on next second !`
+            // Last counting second — announce ready and transition immediately (no extra second consumed)
+            let message = `Casting time : ${currentAction.name}, count : ${time}/${time} — ready to cast next second !`
            ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
            currentAction.castingTime = 1
            currentAction.spellStatus = "toBeCasted"
@@ -978,7 +1018,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
@@ -1075,7 +1115,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
@@ -1124,6 +1164,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)
@@ -1191,6 +1233,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.
   *
@@ -1211,10 +1408,8 @@ export default class LethalFantasyRoll extends Roll {
        return `${game.i18n.localize("LETHALFANTASY.Label.weapon-attack")}`
      case "weapon-defense":
        return `${game.i18n.localize("LETHALFANTASY.Label.weapon-defense")}`
-      case "weapon-damage-small":
-        return `${game.i18n.localize("LETHALFANTASY.Label.weapon-damage-small")}`
-      case "weapon-damage-medium":
-        return `${game.i18n.localize("LETHALFANTASY.Label.weapon-damage-medium")}`
+      case "weapon-damage":
+        return `${game.i18n.localize("LETHALFANTASY.Label.weapon-damage")}`
      case "spell":
      case "spell-attack":
      case "spell-power":
@@ -1275,7 +1470,6 @@ export default class LethalFantasyRoll extends Roll {
      weaponDamageOptions = {
        weaponId: weapon._id || weapon.id,
        weaponName: weapon.name,
-        damageS: weapon.system?.damage?.damageS,
        damageM: weapon.system?.damage?.damageM
      }
      console.log("Weapon damage options:", weaponDamageOptions)
@@ -1358,4 +1552,42 @@ export default class LethalFantasyRoll extends Roll {
    )
  }

+  /**
+   * Evaluate a spell/miracle damage formula with per-die explosion, then post to chat.
+   * Explosion dice are shown manually via showForRoll; the main roll is shown automatically
+   * by toMessage() (which triggers Dice So Nice via its createChatMessage hook).
+   * Append "NE" to the formula to disable explosion.
+   *
+   * @param {string} formula    Dice formula, e.g. "1d8", "2d6", "1d8NE"
+   * @param {Object} rollOpts   Options for LethalFantasyRoll (rollType, actorId, defenderId, etc.)
+   * @returns {Promise<ChatMessage>}
+   */
+  static async rollSpellDamageToMessage(formula, rollOpts) {
+    const roll = new LethalFantasyRoll(formula, {}, rollOpts)
+    await roll.evaluate()
+    const shouldExplode = !/NE$/i.test(formula)
+    const diceResults = []
+    let diceSum = 0
+    for (const term of roll.dice) {
+      const singleDice = `1D${term.faces}`
+      for (const r of term.results) {
+        let diceResult = r.result
+        diceResults.push({ dice: singleDice.toUpperCase(), value: diceResult })
+        diceSum += diceResult
+        if (shouldExplode && term.faces > 0) {
+          while (diceResult === term.faces) {
+            const xr = await new Roll(singleDice).evaluate()
+            // Optional chaining guards against unexpected roll structure
+            diceResult = xr.dice?.[0]?.results?.[0]?.result ?? (term.faces - 1)
+            diceResults.push({ dice: `${singleDice.toUpperCase()}-1`, value: diceResult - 1 })
+            diceSum += (diceResult - 1)
+          }
+        }
+      }
+    }
+    roll.options.diceResults = diceResults
+    roll.options.rollTotal = diceSum
+    return roll.toMessage()
+  }
+
 }
@@ -65,7 +65,7 @@ export default class LethalFantasyCharacter extends foundry.abstract.TypeDataMod
    }

    schema.hp = new fields.SchemaField({
-      value: new fields.NumberField({ ...requiredInteger, initial: 1, min: 0 }),
+      value: new fields.NumberField({ ...requiredInteger, initial: 1 }),
      max: new fields.NumberField({ ...requiredInteger, initial: 1, min: 0 }),
      painDamage: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
      wounds: new fields.ArrayField(new fields.SchemaField(woundFieldSchema), {
@@ -281,7 +281,7 @@ export default class LethalFantasyCharacter extends foundry.abstract.TypeDataMod
   * @param {"="|"+"|"++"|"-"|"--"} rollAdvantage If there is an avantage (+), a disadvantage (-), a double advantage (++), a double disadvantage (--) or a normal roll (=).
   * @returns {Promise<null>} - A promise that resolves to null if the roll is cancelled.
   */
-  async roll(rollType, rollTarget, defenderId, defenderTokenId, extraShieldDr = 0) {
+  async roll(rollType, rollTarget, defenderId, defenderTokenId, extraShieldDr = 0, d30Effects = {}) {
    const hasTarget = false
    let roll = await LethalFantasyRoll.prompt({
      rollType,
@@ -293,7 +293,11 @@ export default class LethalFantasyCharacter extends foundry.abstract.TypeDataMod
      target: false,
      defenderId,
      defenderTokenId,
-      extraShieldDr
+      extraShieldDr,
+      damageTier: rollTarget.damageTier || "standard",
+      d30Bleed: d30Effects.d30Bleed || false,
+      d30DamageMultiplier: d30Effects.d30DamageMultiplier || 1,
+      d30DrMultiplier: d30Effects.d30DrMultiplier || 1
    })
    if (!roll) return null

@@ -356,6 +360,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
  }
@@ -56,10 +56,28 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
      }, {}),
    )

+    const woundFieldSchema = {
+      value: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      duration: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      description: new fields.StringField({ initial: "", required: false, nullable: true }),
+    }
+
    schema.hp = new fields.SchemaField({
-      value: new fields.NumberField({ ...requiredInteger, initial: 1, min: 0 }),
+      value: new fields.NumberField({ ...requiredInteger, initial: 1 }),
      average: new fields.NumberField({ ...requiredInteger, initial: 1, min: 0 }),
      max: new fields.NumberField({ ...requiredInteger, initial: 1, min: 0 }),
+      wounds: new fields.ArrayField(new fields.SchemaField(woundFieldSchema), {
+        initial: [
+          { description: "", value: 0, duration: 0 },
+          { description: "", value: 0, duration: 0 },
+          { description: "", value: 0, duration: 0 },
+          { description: "", value: 0, duration: 0 },
+          { description: "", value: 0, duration: 0 },
+          { description: "", value: 0, duration: 0 },
+          { description: "", value: 0, duration: 0 },
+          { description: "", value: 0, duration: 0 }
+        ], min: 8
+      }),
      damageResistance: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
      painDamage: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 })
    })
@@ -164,8 +182,24 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
   * @param {"="|"+"|"++"|"-"|"--"} rollAdvantage If there is an avantage (+), a disadvantage (-), a double advantage (++), a double disadvantage (--) or a normal roll (=).
   * @returns {Promise<null>} - A promise that resolves to null if the roll is cancelled.
   */
-  async roll(rollType, rollTarget, defenderId = undefined, defenderTokenId = undefined, extraShieldDr = 0) {
+  async roll(rollType, rollTarget, defenderId = undefined, defenderTokenId = undefined, extraShieldDr = 0, d30Effects = {}) {
    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,
@@ -176,14 +210,18 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
      target: false,
      defenderId,
      defenderTokenId,
-      extraShieldDr
+      extraShieldDr,
+      damageTier: rollTarget.damageTier || "standard",
+      d30Bleed: d30Effects.d30Bleed || false,
+      d30DamageMultiplier: d30Effects.d30DamageMultiplier || 1,
+      d30DrMultiplier: d30Effects.d30DrMultiplier || 1
    })
    if (!roll) return null

    await roll.toMessage({}, { messageMode: roll.options.rollMode })
  }

-  async prepareMonsterRoll(rollType, rollKey, rollDice = undefined, tokenId = undefined, damageModifier = undefined, defenderId = undefined, defenderTokenId = undefined, extraShieldDr = 0) {
+  async prepareMonsterRoll(rollType, rollKey, rollDice = undefined, tokenId = undefined, damageModifier = undefined, defenderId = undefined, defenderTokenId = undefined, extraShieldDr = 0, d30Effects = {}) {
    let rollTarget
    switch (rollType) {
      case "monster-attack":
@@ -233,11 +271,10 @@ 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":
-      case "weapon-damage-medium":
+      case "weapon-damage":
      case "weapon-attack":
      case "weapon-defense": {
        let weapon = this.actor.items.find((i) => i.type === "weapon" && i.id === rollKey)
@@ -284,8 +321,7 @@ 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)
+      await this.roll(rollType, rollTarget, defenderId, defenderTokenId, extraShieldDr, d30Effects)
    }
  }

@@ -19,6 +19,8 @@ export default class LethalFantasySpell extends foundry.abstract.TypeDataModel {
    })

    schema.cost = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
+    schema.costOverpowered = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
+    schema.costOverpowered2 = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
    schema.memorized = new fields.BooleanField({ required: true, initial: false })
    
    schema.components = new fields.SchemaField({
@@ -40,6 +42,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
  }
@@ -45,9 +45,9 @@ export default class LethalFantasySkill extends foundry.abstract.TypeDataModel {
    })

    schema.bonuses = new fields.SchemaField({
-      attackBonus: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
-      damageBonus: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
-      defenseBonus: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
+      attackBonus: new fields.NumberField({ ...requiredInteger, required: true, initial: 0 }),
+      damageBonus: new fields.NumberField({ ...requiredInteger, required: true, initial: 0 }),
+      defenseBonus: new fields.NumberField({ ...requiredInteger, required: true, initial: 0 })
    })

    schema.encLoad = new fields.NumberField({ required: true, initial: 0, min: 0 })
@@ -105,6 +105,35 @@ export default class LethalFantasyUtils {
          $(html).find('.hp-gain-wrap')[2].classList.add('hp-gain-hud-disabled');
        }
      })
+
+      // Luck/Grit Buttons
+      const luckGritButton = await foundry.applications.handlebars.renderTemplate('systems/fvtt-lethal-fantasy/templates/luck-grit-hud.hbs', {})
+      $(html).find('div.left').append(luckGritButton);
+      $(html).find('.lethal-luck-grit-hud').click((event) => {
+        event.preventDefault();
+        let wrap = $(html).find('.luck-grit-wrap')[0]
+        if (wrap.classList.contains("luck-grit-hud-disabled")) {
+          wrap.classList.add('luck-grit-hud-active');
+          wrap.classList.remove('luck-grit-hud-disabled');
+        } else {
+          wrap.classList.remove('luck-grit-hud-active');
+          wrap.classList.add('luck-grit-hud-disabled');
+        }
+      })
+      $(html).find('.luck-grit-btn').click((event) => {
+        event.preventDefault();
+        if (token) {
+          let tokenFull = canvas.tokens.placeables.find(t => t.id === token._id);
+          let actor = tokenFull.actor;
+          const resource = event.currentTarget.dataset.resource;
+          const amount = Number(event.currentTarget.dataset.amount);
+          const current = Number(foundry.utils.getProperty(actor.system, `${resource}.current`)) || 0;
+          const newValue = Math.max(0, current + amount);
+          actor.update({ [`system.${resource}.current`]: newValue });
+          $(html).find('.luck-grit-wrap')[0].classList.remove('luck-grit-hud-active');
+          $(html).find('.luck-grit-wrap')[0].classList.add('luck-grit-hud-disabled');
+        }
+      })
    })
  }

@@ -145,6 +174,21 @@ export default class LethalFantasyUtils {
          LethalFantasyUtils.handleAttackerGritOffer(msg)
        }
        break
+      case "applyBleeding":
+        if (game.user.isGM) {
+          actor = msg.tokenId
+            ? canvas.tokens?.placeables?.find(t => t.id === msg.tokenId)?.actor
+            : game.actors.get(msg.actorId)
+          if (actor && actor.system.hp?.wounds && msg.damage > 0) {
+            const wounds = foundry.utils.duplicate(actor.system.hp.wounds)
+            const slot = wounds.findIndex(w => !w.value && !w.duration)
+            if (slot !== -1) {
+              wounds[slot] = { value: msg.damage, duration: msg.damage, description: "Bleeding" }
+              actor.update({ "system.hp.wounds": wounds })
+            }
+          }
+        }
+        break
    }
  }

@@ -290,6 +334,8 @@ export default class LethalFantasyUtils {
          attackD30result,
          attackD30message,
          attackRerollContext,
+          attackNaturalRoll: msg.attackNaturalRoll,
+          damageTier: msg.damageTier,
          defenderId: defender.id,
          defenderTokenId
        }
@@ -324,7 +370,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>
@@ -365,6 +411,8 @@ export default class LethalFantasyUtils {
          attackD30result,
          attackD30message,
          attackRerollContext,
+          attackNaturalRoll: msg.attackNaturalRoll,
+          damageTier: msg.damageTier,
          defenderId: defender.id,
          defenderTokenId,
          isRanged: msg.isRanged
@@ -397,6 +445,7 @@ export default class LethalFantasyUtils {
          attackD30result,
          attackD30message,
          attackRerollContext,
+          damageTier: msg.damageTier,
          defenderId: defender.id,
          defenderTokenId,
          isRanged: true
@@ -467,9 +516,11 @@ export default class LethalFantasyUtils {
        attackRollType,
        attackRollKey,
        attackD30result,
-        attackD30message,
-        attackRerollContext,
-        defenderId: defender.id,
+          attackD30message,
+          attackRerollContext,
+          attackNaturalRoll: msg.attackNaturalRoll,
+          damageTier: msg.damageTier,
+          defenderId: defender.id,
        defenderTokenId,
        isRanged: msg.isRanged
      }
@@ -485,6 +536,196 @@ export default class LethalFantasyUtils {
    return d30Message?.type === "mulligan"
  }

+  /* -------------------------------------------- */
+  /**
+   * Process D30 bonus dice for attack or defense.
+   * Rolls and applies bonus dice BEFORE grit/luck/shield decisions.
+   * For `choice` type results (D30=20, 30), shows dialog to choose between bonus dice and special effect.
+   * For `bonus_dice` type results (D30=27, 2, 3), auto-rolls the dice.
+   * @param {Object|null} d30Message The D30 result object
+   * @param {"attack"|"defense"} side Whether processing the attack or defense side
+   * @param {number|null} naturalRoll The natural D20 roll (for special strike type detection)
+   * @param {Object} actor The actor (for dice3d display)
+   * @returns {Promise<{modifier: number, specialEffect: string|null, specialName: string|null}>}
+   */
+  static async processD30BonusDice(d30Message, side, naturalRoll = null, actor = null, canDialog = true) {
+    if (!d30Message) return { modifier: 0, specialEffect: null, specialName: null }
+
+    const validTargets = side === "attack" ? ["attack", "spell_attack"] : ["defense", "spell_defense"]
+
+    // ── Simple bonus_dice type ── auto-roll if target matches
+    if (d30Message.type === "bonus_dice") {
+      if (!validTargets.includes(d30Message.target)) return { modifier: 0, specialEffect: null, specialName: null }
+      const modifier = await this._rollD30BonusDie(d30Message.dice, actor, !canDialog)
+      return { modifier, specialEffect: null, specialName: null }
+    }
+
+    // ── Choice type ── present all options to the player
+    if (d30Message.type === "choice") {
+      // Try to find a bonus_dice option matching this side
+      const autoBonus = d30Message.choices.find(c => c.type === "bonus_dice" && validTargets.includes(c.target))
+
+      // If we can't show dialogs (wrong client), auto-roll bonus dice if available
+      if (!canDialog) {
+        if (autoBonus) {
+          const modifier = await this._rollD30BonusDie(autoBonus.dice, actor, true)
+          return { modifier, specialEffect: null, specialName: null }
+        }
+        // No bonus dice available on this side — just report as flag
+        const first = d30Message.choices[0]
+        return { modifier: 0, specialEffect: "flag", specialName: first?.type || "choice" }
+      }
+
+      const buttons = d30Message.choices.map(c => {
+        let label
+        let icon
+        if (c.type === "bonus_dice") {
+          label = `Roll ${c.dice.toUpperCase()} and add to ${side}`
+          icon = "fa-solid fa-dice"
+        } else if (c.type === "special_strike") {
+          label = this._buildSpecialLabel(c, naturalRoll)
+          icon = "fa-solid fa-star"
+        } else if (c.type === "special_defense") {
+          label = this._buildSpecialLabel(c, naturalRoll)
+          icon = "fa-solid fa-shield-halved"
+        } else {
+          label = c.type.replace(/_/g, " ").replace(/\b\w/g, l => l.toUpperCase())
+          icon = "fa-solid fa-question"
+        }
+        return {
+          action: c.type,
+          label,
+          icon,
+          callback: () => c
+        }
+      })
+
+      const choice = await foundry.applications.api.DialogV2.wait({
+        window: { title: "D30 Special — Choose Effect" },
+        classes: ["lethalfantasy"],
+        content: `
+          <div class="grit-luck-dialog">
+            <p><strong>D30 result:</strong> ${d30Message.description}</p>
+            <p>Choose how to use this result:</p>
+          </div>
+        `,
+        buttons,
+        rejectClose: false
+      })
+
+      if (!choice) return { modifier: 0, specialEffect: null, specialName: null }
+
+      if (choice.type === "bonus_dice") {
+        const modifier = await this._rollD30BonusDie(choice.dice, actor)
+        return { modifier, specialEffect: null, specialName: null }
+      }
+
+      if (choice.type === "special_strike" || choice.type === "special_defense") {
+        return { modifier: 0, specialEffect: "auto", specialName: this._buildSpecialName(choice, naturalRoll) }
+      }
+
+      // Non-standard choice (spell_calamity, etc.) — report it
+      return { modifier: 0, specialEffect: "flag", specialName: choice.type }
+    }
+
+    // ── Combo type (bleed / internal injury) — flag for wound creation
+    if (d30Message.type === "combo") {
+      const hasBleed = d30Message.effects?.some(e => e.type === "bleed" || e.type === "internal_injury")
+      if (hasBleed) {
+        return { modifier: 0, specialEffect: "bleed", specialName: "Bleeding/Internal Injury" }
+      }
+    }
+
+    // ── Damage multiplier type (2x/3x damage before DR)
+    if (d30Message.type === "damage_multiplier") {
+      return { modifier: 0, specialEffect: "damageMultiplier", specialName: `x${d30Message.multiplier} Damage`, multiplier: d30Message.multiplier }
+    }
+
+    // ── DR multiplier type (2x/3x DR including shield)
+    if (d30Message.type === "dr_multiplier") {
+      return { modifier: 0, specialEffect: "drMultiplier", specialName: `x${d30Message.multiplier} DR`, multiplier: d30Message.multiplier }
+    }
+
+    return { modifier: 0, specialEffect: null, specialName: null }
+  }
+
+  /* -------------------------------------------- */
+  /**
+   * Roll a D30 bonus die and show with 3D dice if available.
+   * @param {string} formula Dice formula (e.g. "D6", "D12", "D20E")
+   * @param {Object} actor Actor for chat message speaker
+   * @returns {Promise<number>} The roll total
+   */
+  static async _rollD30BonusDie(formula, actor, silent = false) {
+    const cleaned = formula.replace(/NE$/i, "").replace("E", "")
+    const roll = new Roll(cleaned)
+    await roll.evaluate()
+    if (game?.dice3d) {
+      await game.dice3d.showForRoll(roll, game.user, true)
+    }
+    if (!silent) {
+      await ChatMessage.create({
+        content: `<p>D30 bonus: rolled <strong>${cleaned.toUpperCase()}</strong> = <strong>${roll.total}</strong></p>`,
+        speaker: ChatMessage.getSpeaker({ actor })
+      })
+    }
+    return roll.total
+  }
+
+  /* -------------------------------------------- */
+  /**
+   * Build a human-readable label for a special strike/defense choice in the D30 prompt.
+   * @param {Object} specialChoice The choice object with type and options
+   * @param {number|null} naturalRoll The natural D20 roll
+   * @returns {string} Display label
+   */
+  static _buildSpecialLabel(specialChoice, naturalRoll) {
+    if (specialChoice.type === "special_strike") {
+      if (specialChoice.options.includes("lethal")) {
+        if (naturalRoll === 20) return "Lethal Strike (auto-hit)"
+        if (naturalRoll >= 16 && naturalRoll <= 19) return "Vital Strike (auto-hit)"
+        return "Lethal/Vital Strike (auto-hit)"
+      }
+      if (specialChoice.options.includes("vicious")) return "Vicious Strike (auto-hit)"
+      return "Special Strike (auto-hit)"
+    }
+    if (specialChoice.type === "special_defense") {
+      if (specialChoice.options.includes("perfect_spell")) return "Perfect Spell Defense (auto-block)"
+      if (specialChoice.options.includes("flawless")) return "Flawless Defense (auto-block)"
+      if (specialChoice.options.includes("legendary")) return "Legendary Defense (auto-block)"
+      if (specialChoice.options.includes("perfect")) return "Perfect Defense (auto-block)"
+      return "Special Defense (auto-block)"
+    }
+    return "Special Effect"
+  }
+
+  /* -------------------------------------------- */
+  /**
+   * Build the special effect name based on the D30 result and natural roll.
+   * @param {Object} specialChoice The choice object with type and options
+   * @param {number|null} naturalRoll The natural D20 roll
+   * @returns {string} The special effect name
+   */
+  static _buildSpecialName(specialChoice, naturalRoll) {
+    if (specialChoice.type === "special_strike") {
+      if (specialChoice.options.includes("lethal")) {
+        if (naturalRoll === 20) return "Lethal Strike"
+        if (naturalRoll >= 16 && naturalRoll <= 19) return "Vital Strike"
+        return "Lethal/Vital Strike"
+      }
+      if (specialChoice.options.includes("vicious")) return "Vicious Strike"
+      return "Special Strike"
+    }
+    if (specialChoice.type === "special_defense") {
+      if (specialChoice.options.includes("perfect_spell")) return "Perfect Spell Defense"
+      if (specialChoice.options.includes("flawless")) return "Flawless Defense"
+      if (specialChoice.options.includes("legendary")) return "Legendary Defense"
+      if (specialChoice.options.includes("perfect")) return "Perfect Defense"
+      return "Special Defense"
+    }
+    return "Special Effect"
+  }
+
  /* -------------------------------------------- */
  static getCombatBonusDiceChoices() {
    return ["1d4", "1d6", "1d8", "1d10", "1d12", "1d20", "1d20e"]
@@ -711,6 +952,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>
      `

@@ -832,6 +1074,18 @@ export default class LethalFantasyUtils {
  /* -------------------------------------------- */
  static async compareAttackDefense(data) {
    console.log("compareAttackDefense called with:", data)
+
+    // Compute D30 effects from the attack D30 message directly.
+    // This is more reliable than depending on the caller-provided values, which are
+    // computed per-client and may differ between clients due to cross-client processing order.
+    const d30DamageMultiplier = data.attackD30message?.type === "damage_multiplier"
+      ? data.attackD30message.multiplier
+      : (data.d30DamageMultiplier || 1)
+    const d30Bleed = data.attackD30message?.type === "combo"
+      ? (data.attackD30message.effects?.some(e => e.type === "bleed" || e.type === "internal_injury") ? "true" : "")
+      : data.attackD30message?.type === "bleed" ? "true" : (data.d30Bleed || "")
+    const d30DrMultiplier = data.d30DrMultiplier || 1
+
    const outcome = data.outcome || (data.attackRoll > data.defenseRoll ? "hit" : "miss")
    const isAttackWin = outcome !== "miss"
    console.log("isAttackWin:", isAttackWin, "attackRoll:", data.attackRoll, "defenseRoll:", data.defenseRoll)
@@ -842,40 +1096,47 @@ export default class LethalFantasyUtils {
      // Déterminer le type de dégâts à lancer
      if (data.attackRollType === "weapon-attack") {
        damageButton = `
-          <div class="attack-result-damage">
-            <button class="roll-damage-btn" data-attacker-id="${data.attackerId}" data-defender-id="${data.defenderId}" data-defender-token-id="${data.defenderTokenId || ""}" data-extra-shield-dr="${data.shieldDamageReduction || 0}" data-weapon-id="${data.attackWeaponId}" data-damage-type="small">
-              <i class="fa-solid fa-dice-d6"></i> Damage (Small)
-            </button>
-            <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-weapon-id="${data.attackWeaponId}" data-damage-type="medium">
-              <i class="fa-solid fa-dice-d20"></i> Damage (Medium)
+          <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-weapon-id="${data.attackWeaponId}" data-damage-type="medium" data-d30-bleed="${d30Bleed}" data-d30-damage-mult="${d30DamageMultiplier}" data-d30-dr-mult="${d30DrMultiplier}">
+              <i class="fa-solid fa-dice-d20"></i> Damage
            </button>
          </div>
        `
      } else if (data.attackRollType === "monster-attack") {
        damageButton = `
-          <div class="attack-result-damage">
-            <button class="roll-damage-btn" data-attacker-id="${data.attackerId}" data-defender-id="${data.defenderId}" data-defender-token-id="${data.defenderTokenId || ""}" data-extra-shield-dr="${data.shieldDamageReduction || 0}" data-attack-key="${data.attackRollKey}" data-damage-type="monster">
+          <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" data-d30-bleed="${d30Bleed}" data-d30-damage-mult="${d30DamageMultiplier}" data-d30-dr-mult="${d30DrMultiplier}">
              <i class="fa-solid fa-burst"></i> Damage
            </button>
          </div>
        `
      } else if (data.attackRollType === "spell-attack" || data.attackRollType === "miracle-attack") {
        const attacker = game.actors.get(data.attackerId)
-        const spell = attacker?.items.get(data.attackWeaponId)
-        const damageDice = spell?.system?.damageDice
-        if (damageDice) {
-          damageButton = `
-            <div class="attack-result-damage">
-              <button class="roll-damage-btn"
-                data-attacker-id="${data.attackerId}"
-                data-defender-id="${data.defenderId}"
-                data-defender-token-id="${data.defenderTokenId || ""}"
-                data-damage-type="spell"
-                data-damage-formula="${damageDice}">
-                <i class="fa-solid fa-wand-magic-sparkles"></i> Spell Damage (${damageDice})
-              </button>
-            </div>
-          `
+        const spell = attacker?.items.get(data.attackWeaponId || data.attackRollKey)
+        const chosenTier = data.damageTier || "standard"
+        const allTiers = [
+          { id: "standard", formula: spell?.system?.damageDice, label: "Standard" },
+          { id: "overpowered", formula: spell?.system?.damageDiceOverpowered, label: "Overpowered" },
+          { id: "overpowered2", formula: spell?.system?.damageDiceOverpowered2, label: "Overpowered 2" },
+        ]
+        const tiers = allTiers.filter(t => t.id === chosenTier && t.formula)
+        if (tiers.length) {
+          const buttons = tiers.map(t => {
+            const escapedFormula = Handlebars.escapeExpression(t.formula)
+            return `
+            <button class="roll-damage-btn"
+              data-attacker-id="${data.attackerId}"
+              data-defender-id="${data.defenderId}"
+              data-defender-token-id="${data.defenderTokenId || ""}"
+              data-damage-type="spell"
+              data-damage-formula="${escapedFormula}"
+              data-d30-bleed="${d30Bleed}"
+              data-d30-damage-mult="${d30DamageMultiplier}"
+              data-d30-dr-mult="${d30DrMultiplier}">
+              <i class="fa-solid fa-wand-magic-sparkles"></i> ${t.label} (${escapedFormula})
+            </button>`
+          }).join("")
+          damageButton = `<div class="attack-result-damage spell-damage">${buttons}</div>`
        }
      }
    }
@@ -902,10 +1163,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}
@@ -1195,7 +1456,7 @@ export default class LethalFantasyUtils {
      ChatMessage.create({
        user: game.user.id,
        speaker: { alias: targetActor.name },
-        rollMode: "gmroll",
+        mode: "gm",
        content: messageContent
      })
    }
@@ -1 +1 @@
-MANIFEST-000591
+MANIFEST-000631
@@ -1,8 +1,8 @@
-2026/05/17-11:57:50.231387 7f16423fc6c0 Recovering log #589
-2026/05/17-11:57:50.249229 7f16423fc6c0 Delete type=3 #587
-2026/05/17-11:57:50.249281 7f16423fc6c0 Delete type=0 #589
-2026/05/17-13:21:53.429711 7f1641bfb6c0 Level-0 table #594: started
-2026/05/17-13:21:53.429759 7f1641bfb6c0 Level-0 table #594: 0 bytes OK
-2026/05/17-13:21:53.437714 7f1641bfb6c0 Delete type=0 #592
-2026/05/17-13:21:53.449134 7f1641bfb6c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
-2026/05/17-13:21:53.461721 7f1641bfb6c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
+2026/06/11-20:25:36.058631 7f37427ed6c0 Recovering log #629
+2026/06/11-20:25:36.068520 7f37427ed6c0 Delete type=3 #627
+2026/06/11-20:25:36.068574 7f37427ed6c0 Delete type=0 #629
+2026/06/11-20:41:45.938413 7f3740fff6c0 Level-0 table #634: started
+2026/06/11-20:41:45.938512 7f3740fff6c0 Level-0 table #634: 0 bytes OK
+2026/06/11-20:41:45.945312 7f3740fff6c0 Delete type=0 #632
+2026/06/11-20:41:45.965586 7f3740fff6c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
+2026/06/11-20:41:45.965944 7f3740fff6c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
@@ -1,8 +1,8 @@
-2026/05/02-08:40:55.892385 7fd7557ee6c0 Recovering log #585
-2026/05/02-08:40:55.903385 7fd7557ee6c0 Delete type=3 #583
-2026/05/02-08:40:55.903442 7fd7557ee6c0 Delete type=0 #585
-2026/05/02-08:41:12.057856 7fd7477fe6c0 Level-0 table #590: started
-2026/05/02-08:41:12.057882 7fd7477fe6c0 Level-0 table #590: 0 bytes OK
-2026/05/02-08:41:12.121845 7fd7477fe6c0 Delete type=0 #588
-2026/05/02-08:41:12.122077 7fd7477fe6c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
-2026/05/02-08:41:12.122121 7fd7477fe6c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
+2026/06/10-19:56:01.455200 7f301cbff6c0 Recovering log #625
+2026/06/10-19:56:01.464323 7f301cbff6c0 Delete type=3 #623
+2026/06/10-19:56:01.464355 7f301cbff6c0 Delete type=0 #625
+2026/06/10-20:16:07.843239 7f2fce7fc6c0 Level-0 table #630: started
+2026/06/10-20:16:07.843267 7f2fce7fc6c0 Level-0 table #630: 0 bytes OK
+2026/06/10-20:16:07.849298 7f2fce7fc6c0 Delete type=0 #628
+2026/06/10-20:16:07.849522 7f2fce7fc6c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
+2026/06/10-20:16:07.849556 7f2fce7fc6c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
@@ -1 +1 @@
-MANIFEST-000588
+MANIFEST-000628
@@ -1,8 +1,8 @@
-2026/05/17-11:57:50.260046 7f16433fe6c0 Recovering log #586
-2026/05/17-11:57:50.276348 7f16433fe6c0 Delete type=3 #584
-2026/05/17-11:57:50.276460 7f16433fe6c0 Delete type=0 #586
-2026/05/17-13:21:53.474443 7f1641bfb6c0 Level-0 table #591: started
-2026/05/17-13:21:53.474485 7f1641bfb6c0 Level-0 table #591: 0 bytes OK
-2026/05/17-13:21:53.481502 7f1641bfb6c0 Delete type=0 #589
-2026/05/17-13:21:53.490389 7f1641bfb6c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
-2026/05/17-13:21:53.512946 7f1641bfb6c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
+2026/06/11-20:25:36.074598 7f37437ef6c0 Recovering log #626
+2026/06/11-20:25:36.084983 7f37437ef6c0 Delete type=3 #624
+2026/06/11-20:25:36.085075 7f37437ef6c0 Delete type=0 #626
+2026/06/11-20:41:45.965954 7f3740fff6c0 Level-0 table #631: started
+2026/06/11-20:41:45.965991 7f3740fff6c0 Level-0 table #631: 0 bytes OK
+2026/06/11-20:41:45.972550 7f3740fff6c0 Delete type=0 #629
+2026/06/11-20:41:45.992980 7f3740fff6c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
+2026/06/11-20:41:45.993323 7f3740fff6c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
@@ -1,8 +1,8 @@
-2026/05/02-08:40:55.909564 7fd747fff6c0 Recovering log #582
-2026/05/02-08:40:55.919159 7fd747fff6c0 Delete type=3 #580
-2026/05/02-08:40:55.919214 7fd747fff6c0 Delete type=0 #582
-2026/05/02-08:41:11.999050 7fd7477fe6c0 Level-0 table #587: started
-2026/05/02-08:41:11.999076 7fd7477fe6c0 Level-0 table #587: 0 bytes OK
-2026/05/02-08:41:12.057672 7fd7477fe6c0 Delete type=0 #585
-2026/05/02-08:41:12.122063 7fd7477fe6c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
-2026/05/02-08:41:12.122111 7fd7477fe6c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
+2026/06/10-19:56:01.470668 7f2fcffff6c0 Recovering log #622
+2026/06/10-19:56:01.480292 7f2fcffff6c0 Delete type=3 #620
+2026/06/10-19:56:01.480316 7f2fcffff6c0 Delete type=0 #622
+2026/06/10-20:16:07.810643 7f2fce7fc6c0 Level-0 table #627: started
+2026/06/10-20:16:07.810662 7f2fce7fc6c0 Level-0 table #627: 0 bytes OK
+2026/06/10-20:16:07.816355 7f2fce7fc6c0 Delete type=0 #625
+2026/06/10-20:16:07.823439 7f2fce7fc6c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
+2026/06/10-20:16:07.823453 7f2fce7fc6c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
@@ -1 +1 @@
-MANIFEST-000593
+MANIFEST-000633
@@ -1,8 +1,8 @@
-2026/05/17-11:57:50.206131 7f1643bff6c0 Recovering log #591
-2026/05/17-11:57:50.222037 7f1643bff6c0 Delete type=3 #589
-2026/05/17-11:57:50.222089 7f1643bff6c0 Delete type=0 #591
-2026/05/17-13:21:53.292176 7f1641bfb6c0 Level-0 table #596: started
-2026/05/17-13:21:53.292219 7f1641bfb6c0 Level-0 table #596: 0 bytes OK
-2026/05/17-13:21:53.299322 7f1641bfb6c0 Delete type=0 #594
-2026/05/17-13:21:53.306548 7f1641bfb6c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
-2026/05/17-13:21:53.318889 7f1641bfb6c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
+2026/06/11-20:25:36.041244 7f3742fee6c0 Recovering log #631
+2026/06/11-20:25:36.052153 7f3742fee6c0 Delete type=3 #629
+2026/06/11-20:25:36.052218 7f3742fee6c0 Delete type=0 #631
+2026/06/11-20:41:45.958653 7f3740fff6c0 Level-0 table #636: started
+2026/06/11-20:41:45.958703 7f3740fff6c0 Level-0 table #636: 0 bytes OK
+2026/06/11-20:41:45.965435 7f3740fff6c0 Delete type=0 #634
+2026/06/11-20:41:45.965798 7f3740fff6c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
+2026/06/11-20:41:45.965918 7f3740fff6c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
@@ -1,8 +1,8 @@
-2026/05/02-08:40:55.873571 7fd747fff6c0 Recovering log #587
-2026/05/02-08:40:55.883892 7fd747fff6c0 Delete type=3 #585
-2026/05/02-08:40:55.883950 7fd747fff6c0 Delete type=0 #587
-2026/05/02-08:41:11.870087 7fd7477fe6c0 Level-0 table #592: started
-2026/05/02-08:41:11.870140 7fd7477fe6c0 Level-0 table #592: 0 bytes OK
-2026/05/02-08:41:11.937524 7fd7477fe6c0 Delete type=0 #590
-2026/05/02-08:41:12.122025 7fd7477fe6c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
-2026/05/02-08:41:12.122087 7fd7477fe6c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
+2026/06/10-19:56:01.439055 7f2fcffff6c0 Recovering log #627
+2026/06/10-19:56:01.451210 7f2fcffff6c0 Delete type=3 #625
+2026/06/10-19:56:01.451236 7f2fcffff6c0 Delete type=0 #627
+2026/06/10-20:16:07.804529 7f2fce7fc6c0 Level-0 table #632: started
+2026/06/10-20:16:07.804550 7f2fce7fc6c0 Level-0 table #632: 0 bytes OK
+2026/06/10-20:16:07.810504 7f2fce7fc6c0 Delete type=0 #630
+2026/06/10-20:16:07.823431 7f2fce7fc6c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
+2026/06/10-20:16:07.823457 7f2fce7fc6c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
@@ -1 +1 @@
-MANIFEST-000288
+MANIFEST-000328
@@ -1,8 +1,8 @@
-2026/05/17-11:57:50.303535 7f16433fe6c0 Recovering log #286
-2026/05/17-11:57:50.318955 7f16433fe6c0 Delete type=3 #284
-2026/05/17-11:57:50.319061 7f16433fe6c0 Delete type=0 #286
-2026/05/17-13:21:53.481662 7f1641bfb6c0 Level-0 table #291: started
-2026/05/17-13:21:53.481693 7f1641bfb6c0 Level-0 table #291: 0 bytes OK
-2026/05/17-13:21:53.490187 7f1641bfb6c0 Delete type=0 #289
-2026/05/17-13:21:53.502325 7f1641bfb6c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
-2026/05/17-13:21:53.512979 7f1641bfb6c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
+2026/06/11-20:25:36.103531 7f37437ef6c0 Recovering log #326
+2026/06/11-20:25:36.114200 7f37437ef6c0 Delete type=3 #324
+2026/06/11-20:25:36.114249 7f37437ef6c0 Delete type=0 #326
+2026/06/11-20:41:45.972686 7f3740fff6c0 Level-0 table #331: started
+2026/06/11-20:41:45.972724 7f3740fff6c0 Level-0 table #331: 0 bytes OK
+2026/06/11-20:41:45.979068 7f3740fff6c0 Delete type=0 #329
+2026/06/11-20:41:45.993007 7f3740fff6c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
+2026/06/11-20:41:45.993301 7f3740fff6c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
@@ -1,8 +1,8 @@
-2026/05/02-08:40:55.939668 7fd754fed6c0 Recovering log #282
-2026/05/02-08:40:55.949715 7fd754fed6c0 Delete type=3 #280
-2026/05/02-08:40:55.949784 7fd754fed6c0 Delete type=0 #282
-2026/05/02-08:41:12.184448 7fd7477fe6c0 Level-0 table #287: started
-2026/05/02-08:41:12.184496 7fd7477fe6c0 Level-0 table #287: 0 bytes OK
-2026/05/02-08:41:12.252892 7fd7477fe6c0 Delete type=0 #285
-2026/05/02-08:41:12.365481 7fd7477fe6c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
-2026/05/02-08:41:12.365509 7fd7477fe6c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
+2026/06/10-19:56:01.497944 7f301cbff6c0 Recovering log #322
+2026/06/10-19:56:01.506991 7f301cbff6c0 Delete type=3 #320
+2026/06/10-19:56:01.507034 7f301cbff6c0 Delete type=0 #322
+2026/06/10-20:16:07.829554 7f2fce7fc6c0 Level-0 table #327: started
+2026/06/10-20:16:07.829571 7f2fce7fc6c0 Level-0 table #327: 0 bytes OK
+2026/06/10-20:16:07.836328 7f2fce7fc6c0 Delete type=0 #325
+2026/06/10-20:16:07.849487 7f2fce7fc6c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
+2026/06/10-20:16:07.849533 7f2fce7fc6c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
@@ -1 +1 @@
-MANIFEST-000587
+MANIFEST-000627
@@ -1,8 +1,8 @@
-2026/05/17-11:57:50.282340 7f16423fc6c0 Recovering log #585
-2026/05/17-11:57:50.297125 7f16423fc6c0 Delete type=3 #583
-2026/05/17-11:57:50.297189 7f16423fc6c0 Delete type=0 #585
-2026/05/17-13:21:53.299508 7f1641bfb6c0 Level-0 table #590: started
-2026/05/17-13:21:53.299854 7f1641bfb6c0 Level-0 table #590: 0 bytes OK
-2026/05/17-13:21:53.306309 7f1641bfb6c0 Delete type=0 #588
-2026/05/17-13:21:53.318877 7f1641bfb6c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
-2026/05/17-13:21:53.325564 7f1641bfb6c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
+2026/06/11-20:25:36.088952 7f37427ed6c0 Recovering log #625
+2026/06/11-20:25:36.100017 7f37427ed6c0 Delete type=3 #623
+2026/06/11-20:25:36.100073 7f37427ed6c0 Delete type=0 #625
+2026/06/11-20:41:45.945442 7f3740fff6c0 Level-0 table #630: started
+2026/06/11-20:41:45.945486 7f3740fff6c0 Level-0 table #630: 0 bytes OK
+2026/06/11-20:41:45.951778 7f3740fff6c0 Delete type=0 #628
+2026/06/11-20:41:45.965603 7f3740fff6c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
+2026/06/11-20:41:45.965769 7f3740fff6c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
@@ -1,8 +1,8 @@
-2026/05/02-08:40:55.925402 7fd755fef6c0 Recovering log #581
-2026/05/02-08:40:55.935869 7fd755fef6c0 Delete type=3 #579
-2026/05/02-08:40:55.935924 7fd755fef6c0 Delete type=0 #581
-2026/05/02-08:41:11.937698 7fd7477fe6c0 Level-0 table #586: started
-2026/05/02-08:41:11.937727 7fd7477fe6c0 Level-0 table #586: 0 bytes OK
-2026/05/02-08:41:11.998871 7fd7477fe6c0 Delete type=0 #584
-2026/05/02-08:41:12.122041 7fd7477fe6c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
-2026/05/02-08:41:12.122099 7fd7477fe6c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
+2026/06/10-19:56:01.483620 7f2fceffd6c0 Recovering log #621
+2026/06/10-19:56:01.493981 7f2fceffd6c0 Delete type=3 #619
+2026/06/10-19:56:01.494004 7f2fceffd6c0 Delete type=0 #621
+2026/06/10-20:16:07.797521 7f2fce7fc6c0 Level-0 table #626: started
+2026/06/10-20:16:07.797566 7f2fce7fc6c0 Level-0 table #626: 0 bytes OK
+2026/06/10-20:16:07.804440 7f2fce7fc6c0 Delete type=0 #624
+2026/06/10-20:16:07.823416 7f2fce7fc6c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
+2026/06/10-20:16:07.823449 7f2fce7fc6c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
@@ -387,11 +387,11 @@
          min-width: 6rem;
          max-width: 6rem;
        }
-        min-width: 10rem;
-        max-width: 10rem;
+        min-width: 11rem;
+        max-width: 11rem;
        .input {
-          min-width: 2.5rem;
-          max-width: 2.5rem;
+          min-width: 3.5rem;
+          max-width: 3.5rem;
        }
      }
      .granted {
@@ -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);
      }
    }
  }
@@ -89,6 +89,66 @@
  font-size: 0.9rem;
 }

+/* Luck/Grit Styles */
+#token-hud .luck-grit-wrap {
+  position: absolute;
+  left: 75px;
+  display: none;
+  top: 50%;
+  width: 80px;
+  text-align: start;
+  background: rgba(0, 0, 0, 0.8);
+  border: 1px solid rgba(139, 69, 19, 0.5);
+  border-radius: 4px;
+  padding: 4px 6px;
+  transform: translate(-100%, -50%);
+}
+
+#token-hud .luck-grit-hud-active {
+  display: block;
+}
+
+#token-hud .luck-grit-hud-disabled {
+  display: none;
+}
+
+#token-hud .luck-grit-row {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  margin: 2px 0;
+}
+
+#token-hud .luck-grit-label {
+  flex: 1;
+  color: #c9b896;
+  font-size: 11px;
+  font-weight: 600;
+  text-transform: uppercase;
+}
+
+#token-hud .luck-grit-btn {
+  width: 28px;
+  height: 22px;
+  padding: 0;
+  background: rgba(139, 69, 19, 0.25);
+  border: 1px solid rgba(139, 69, 19, 0.4);
+  border-radius: 3px;
+  color: #d4c5a9;
+  font-size: 12px;
+  font-weight: 700;
+  cursor: pointer;
+  line-height: 1;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+
+  &:hover {
+    background: rgba(139, 69, 19, 0.5);
+    border-color: rgba(139, 69, 19, 0.7);
+  }
+}
+
 /* -------------------------------------------------- */
 /* Dice Tray — injected into the Foundry chat sidebar */
 /* -------------------------------------------------- */
@@ -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,
@@ -631,15 +647,11 @@

    .damage-buttons-grid {
      display: grid;
-      grid-template-columns: repeat(2, 1fr);
+      grid-template-columns: 1fr;
+      max-width: 280px;
+      margin: 0 auto;
      gap: 8px;

-      &.monster-damage {
-        grid-template-columns: 1fr;
-        max-width: 280px;
-        margin: 0 auto;
-      }
-
      .damage-roll-btn {
        padding: 10px 14px;
        background: linear-gradient(to bottom, #8b4513 0%, #6b3410 100%);
@@ -831,6 +843,7 @@
        display: grid;
        grid-template-columns: repeat(2, 1fr);
        gap: 8px;
+        justify-items: center;
      }
    }
  }
@@ -1269,33 +1282,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
@@ -87,16 +87,10 @@
              <i class="fa-solid fa-shield-halved" data-roll-type="weapon-defense" data-roll-key="{{item.id}}"></i>
            </a>

-            <a class="rollable" data-roll-type="weapon-damage-small" data-roll-key="{{item.id}}"
-              data-tooltip="Roll Damage (Small)">
-              <i class="fa-regular fa-face-head-bandage" data-roll-type="weapon-damage-small"
-                data-roll-key="{{item.id}}"></i>S
-            </a>
-
-            <a class="rollable" data-roll-type="weapon-damage-medium" data-roll-key="{{item.id}}"
-              data-tooltip="Roll Damage (Medium)">
-              <i class="fa-regular fa-face-head-bandage" data-roll-type="weapon-damage-medium"
-                data-roll-key="{{item.id}}"></i>M
+            <a class="rollable" data-roll-type="weapon-damage" data-roll-key="{{item.id}}"
+              data-tooltip="Roll Damage">
+              <i class="fa-regular fa-face-head-bandage" data-roll-type="weapon-damage"
+                data-roll-key="{{item.id}}"></i>
            </a>

          </div>
@@ -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,45 +40,39 @@
    {{#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}}

-    {{#if rollData.damageSmall}}
-      <div class="detail-badge damage-badge">
-        <i class="fa-solid fa-dice-d6"></i>
-        <span>{{localize "LETHALFANTASY.Label.weapon-damage-small"}}</span>
-      </div>
-    {{/if}}
-    {{#if rollData.damageMedium}}
+    {{#if rollData.isDamage}}
      <div class="detail-badge damage-badge">
        <i class="fa-solid fa-dice-d20"></i>
-        <span>{{localize "LETHALFANTASY.Label.weapon-damage-medium"}}</span>
+        <span>{{localize "LETHALFANTASY.Label.weapon-damage"}}</span>
      </div>
    {{/if}}

@@ -111,7 +105,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 +171,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}}

@@ -202,19 +196,6 @@
              }}+{{weaponDamageOptions.damageModifier}}{{/if}}
            </button>
          {{else}}
-            {{#if weaponDamageOptions.damageS}}
-              <button
-                class="damage-roll-btn"
-                data-weapon-id="{{weaponDamageOptions.weaponId}}"
-                data-damage-type="small"
-                data-damage-formula="{{weaponDamageOptions.damageS}}"
-                data-is-monster="false"
-                title="{{localize 'LETHALFANTASY.Label.rollDamage'}}"
-              >
-                <i class="fa-solid fa-dice-d6"></i>
-                Damage Small
-              </button>
-            {{/if}}
            {{#if weaponDamageOptions.damageM}}
              <button
                class="damage-roll-btn"
@@ -225,7 +206,7 @@
                title="{{localize 'LETHALFANTASY.Label.rollDamage'}}"
              >
                <i class="fa-solid fa-dice-d20"></i>
-                Damage Medium
+                {{localize "LETHALFANTASY.Label.damage"}}
              </button>
            {{/if}}
          {{/if}}
@@ -0,0 +1,16 @@
+<div class="control-icon" data-action="lethal-luck-grit-hud">
+  <i class="fa-solid fa-dice" title="Adjust Luck/Grit" style="width:36px;height:36px;display:flex;align-items:center;justify-content:center;font-size:18px;cursor:pointer"></i>
+
+  <div class="luck-grit-wrap luck-grit-hud-disabled">
+    <div class="luck-grit-row">
+      <span class="luck-grit-label">Luck</span>
+      <button class="luck-grit-btn" data-resource="luck" data-amount="-1">−1</button>
+      <button class="luck-grit-btn" data-resource="luck" data-amount="1">+1</button>
+    </div>
+    <div class="luck-grit-row">
+      <span class="luck-grit-label">Grit</span>
+      <button class="luck-grit-btn" data-resource="grit" data-amount="-1">−1</button>
+      <button class="luck-grit-btn" data-resource="grit" data-amount="1">+1</button>
+    </div>
+  </div>
+</div>
@@ -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>

@@ -160,7 +160,7 @@
  </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}}" >
@@ -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,35 +55,33 @@
      <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}}
-          <div class="dialog-save">Point Blank Range Attack
-            <input
-              type="checkbox"
-              data-action="selectPointBlank"
-              name="pointBlankV"
-            />
-          </div>
-          <div class="dialog-save">Beyond Skill Range Attack
-            <input
-              type="checkbox"
-              data-action="selectBeyondSkill"
-              name="beyondSkillV"
-            />
-          </div>
-          <div class="dialog-save">Let it Fly (Pure D20E)
-            <input
-              type="checkbox"
-              data-action="selectLetItFly"
-              name="letItFlyV"
-            />
-          </div>
-          <div class="dialog-save">Aiming
-            <select name="attackerAim" data-tooltip-direction="UP">
-              {{selectOptions attackerAimChoices selected=attackerAim}}
-            </select>
-          </div>
-        {{/if}}
+      {{#if isRangedAttack}}
+        <div class="dialog-save">Point Blank Range Attack
+          <input
+            type="checkbox"
+            data-action="selectPointBlank"
+            name="pointBlankV"
+          />
+        </div>
+        <div class="dialog-save">Beyond Skill Range Attack
+          <input
+            type="checkbox"
+            data-action="selectBeyondSkill"
+            name="beyondSkillV"
+          />
+        </div>
+        <div class="dialog-save">Let it Fly (Pure D20E)
+          <input
+            type="checkbox"
+            data-action="selectLetItFly"
+            name="letItFlyV"
+          />
+        </div>
+        <div class="dialog-save">Aiming
+          <select name="attackerAim" data-tooltip-direction="UP">
+            {{selectOptions attackerAimChoices selected=attackerAim}}
+          </select>
+        </div>
      {{/if}}

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

      {{#if (eq rollType "save")}}
-        {{#if rollTarget.magicUser}}
-          <div>
-            <span>Save against spell (+{{rollTarget.actorModifiers.saveModifier}})
-              ?</span>
-            <input
-              type="checkbox"
-              name="saveSpellCheck"
-              data-action="saveSpellCheck"
-            />
-          </div>
-        {{/if}}
+        <div>
+          <span>Save against spell (+{{rollTarget.actorModifiers.saveModifier}})
+            ?</span>
+          <input
+            type="checkbox"
+            name="saveSpellCheck"
+            data-action="saveSpellCheck"
+          />
+        </div>
      {{/if}}
    </fieldSet>
  {{/if}}
@@ -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
@@ -6,8 +6,10 @@

  {{formField systemFields.level value=system.level}}
  {{formField systemFields.cost value=system.cost}}
+  {{formField systemFields.costOverpowered value=system.costOverpowered}}
+  {{formField systemFields.costOverpowered2 value=system.costOverpowered2}}

-  <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 +33,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,18 +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>
-      <div class="shift-right">
-        {{formField systemFields.damage.fields.damageS value=system.damage.damageS}}
-        {{formField systemFields.damage.fields.damageM value=system.damage.damageM}}
-      </div>
+      {{formField systemFields.damage.fields.damageM value=system.damage.damageM label="LETHALFANTASY.Label.damage"}}

      {{formField systemFields.applyStrengthDamageBonus value=system.applyStrengthDamageBonus localize=true}}
    
@@ -34,7 +30,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 +43,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 +56,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	141d6048e0	Fix triple damage issue	2026-06-11 21:32:26 +02:00
uberwald	ea7acf6bf8	Fix hp < 0 and D30 with D20 bonus roll	2026-06-11 20:48:46 +02:00
uberwald	c20750caa7	Minor fixes regarding rolls and chat messages Release Creation / build (release) Successful in 48s Details	2026-06-10 20:17:45 +02:00
uberwald	ce630feb51	feat: D30 combat effects, spell tiers, small damage removal, token HUD luck/grit - Replace Knockback with Internal Injury on D30 (5, 10, 15); remove Shield Bash from D30 counter-attacks - Eliminate small weapon damage: keep only medium damage labelled Damage in sheets, rolls, and chat - D30 bonus dice (20, 27, 30) auto-resolved before grit/luck/shield decisions; choice dialogs for special strikes - D30 combat effects: bleeding wounds, damage ×2/×3 before DR, DR ×2/×3 with component picker dialog - Add hp.wounds to monster schema for bleeding support - Show Save against spell? checkbox for all save rolls (not just magic users) - Fix mulligan restart: persistent D30 process flags prevent double-application and allow both sides to react - For Dice So Nice, show main roll animation before explosion dice for correct ordering - Spell tier selection: force Standard/Overpowered choice at cast time, tier-specific aether cost, only chosen damage button shown - Add +1/−1 luck and grit controls to Token HUD - Fix inconsistent indentation, remove duplicate i18n key, remove unused includesShield return	2026-06-10 07:53:51 +02:00
uberwald	b35b684d50	NEgative values for HP and weapon bonuses	2026-06-06 16:11:36 +02:00
uberwald	f6fb0b68b8	Fix spell rolls again Release Creation / build (release) Successful in 47s Details	2026-05-25 20:41:00 +02:00
uberwald	e45edd60c4	FIx spell order and dual rollll for spell damages Release Creation / build (release) Successful in 1m6s Details	2026-05-25 12:29:39 +02:00
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