Fix D30 management, again

delete on game.lethalFantasy.spellDefense was breaking roll flow
on Foundry's proxied game object.  Use try/finally with
assignment to false instead, which is safe on any object type.

Initialize saveSpell local var from one-shot flag so D30
chart lookup correctly uses arcane_spell_defense for spell saves
without requiring user to click the pre-checked checkbox.

.gitattributes

@@ -0,0 +1 @@
+packs/** filter=lfs diff=lfs merge=lfs -text

.gitea/workflows/release.yaml

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

.gitignore

@@ -9,3 +9,14 @@ node_modules/
 .history
 .github/
 
+# LevelDB internals (auto-generated, churn on every open)
+packs-system/**/*.log
+packs-system/**/LOG
+packs-system/**/LOG.old
+packs-system/**/CURRENT
+packs-system/**/LOCK
+packs-system/**/MANIFEST-*
+
+# YAML source for pack round-trip
+packs_src/
+

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+  "cSpell.words": [
+    "biodata",
+    "LETHALFANTASY"
+  ]
+}

AGENTS.md

@@ -0,0 +1,105 @@
+# Lethal Fantasy FoundryVTT System — Session Context
+
+## Current Goal
+Fix Grit/Luck defense reaction dialog UX (stacking dialogs, multiple clicks, revert on close) and cross-client sync of defense bonuses.
+
+## Accomplished
+
+### Pass 1 — Critical Issues
+- **Telemetry removed**: `ClassCounter`, `registerWorldCount`, orphaned `worldKey` setting deleted from system.json
+- **globalThis side effects**: `globalThis.SYSTEM`, `globalThis.pendingDefenses` moved from top-level to `init` hook
+- **console.log → log()**: All runtime console.log replaced with `log()` helper guarded by `lethalFantasy.debug` setting
+- **Stale Tenebris refs**: `macros.mjs` — `TENEBRIS.Label.jet` → `LETHALFANTASY.Label.jet`, `TENEBRIS.Manager.*` → `LETHALFANTASY.Label.*`, `tenebris.macro` flag → `lethalFantasy.macro`
+
+### Pass 2 — V1/V2 Mixing, Fire-and-Forget
+- **V1 sheet registrations removed**: `foundry.appv1.sheets.*` in system.json
+- **V1 `activateListeners`/jQuery**: removed dead `defaultOptions`, V1 tab code from `combat.mjs`
+- **V2 API paths**: `FilePicker` → V2, `TextEditor.getDragEventData` → V2, `item.sheet.render(true)` → `render({force:true})`, `super._onRender()` → `super._onRender(context, options)`, `token._id` → `token.id`
+- **Fire-and-forget Promises**: All `actor.update()`, `ChatMessage.create()`, `prepareRoll()`, `prepareMonsterRoll()`, socket handler calls now awaited
+- **Misnamed class**: `LethalFantasySkill` → `LethalFantasyWeapon`; added missing `WEAPON_TYPE` import; fixed `weaponCategory`
+
+### Pass 3 — Code Review Fixes
+- **Duplicated dialogs**: Per-element `.rollable`/`.wound-data` bindings moved to `_onRender` (V2 destroys/recreates DOM each render); `_activateListeners` reverted
+- **renderChatMessage reverted**: V2 hook `renderChatMessage` passes jQuery html, `querySelectorAll` fails; kept `renderChatMessageHTML`
+- **Roll actions broken**: Fixed `async` base-actor-sheet methods; `_onRender` bindings for rollable elements restored
+- **Token HUD guard**: `html.querySelector()` → `html.find().length` (html is jQuery object)
+- **All review awaits confirmed**: `showDefenseRequest`/`socket` handlers all awaited
+
+## Defense Dialog Investigation — Status
+
+### Symptom (user process)
+1. Monster (GM) attacks player — hits
+2. Player uses Grit/Luck to boost defense
+3. Defense now beats attack — reports new result
+4. Dialog **stays open** — Grit/Luck/bonus dice options still visible
+5. Closing dialog (Continue or X) causes "rolls vanish" — reverts to original result
+
+### Root Cause Found — Duplicate cross-client processing (FIXED)
+
+When monster (GM) attacks player, the `createChatMessage` hook fires on **both** clients:
+
+```
+Player's client:                         GM's client:
+  defense msg created                      defense msg synced
+  ↓                                        ↓
+  hook fires (line 557)                    hook fires (line 557)
+  isPrimaryController(defender)=true       isPrimaryController(defender)=false
+  ↓                                        ↓
+  Defense dialog A shows                   Defense dialog skipped
+  Player spends Grit                       Cross-client code (line 1009):
+  defenseRoll=10→16                        isPrimaryController(attacker)=true
+  While loop exits                         defenderOwner=player (≠GM)
+  Comparison: "miss"                       ↓
+                                           **Sends attackBoosted with ORIGINAL
+                                            defenseRoll=10 (stale!)**
+                                           ↓
+                                           Player receives socket → handleAttackBoosted
+                                           → Defense dialog B shows with OLD values
+                                           → When closed, comparison: "hit" (overwrites!)
+```
+
+Player sees **two** dialogs (A then B). Dialog B uses unboosted values, so closing/ignoring it produces a stale "hit" result that overwrites the correct "miss."
+
+### Fix
+`lethal-fantasy.mjs:1016` — only send `attackBoosted` socket when `attackerHandledBonus || attackerHasNonGMOwner`. Guards against stale-socket overwrite for GM→player combat (where hook-based processing works without socket), while preserving socket delegation for PC→PC cross-client (where `attackerIsCrossClient` suppresses the hook-based processing on the defender's client).
+
+Before:
+```js
+if (defenderOwner && defenderOwner.id !== game.user.id) {
+  game.socket.emit(`system.${SYSTEM.id}`, { type: "attackBoosted", ... })
+  return
+}
+```
+
+After:
+```js
+if (defenderOwner && defenderOwner.id !== game.user.id) {
+  if (attackerHandledBonus || attackerHasNonGMOwner) {
+    game.socket.emit(`system.${SYSTEM.id}`, { type: "attackBoosted", ... })
+  }
+  return
+}
+```
+
+### Same-Client Path
+Code pattern is identical between attack and defense dialogs — both use `await DialogV2.wait({rejectClose:false})` in a while loop. Same-client defense works correctly because no duplicate socket messages arrive.
+
+### Other Findings
+- `offerGritLuckBonus` (`utils.mjs:1121`) is dead code — never called
+- `promptCombatBonusDie` (`utils.mjs:975`) is correct — DialogV2 resolves to callback return value, not `action`
+- Cross-client `handleAttackBoosted` (`utils.mjs:291`) still uses `else if` chain without `continue` — functionally correct but differs from same-client pattern
+
+### Code Paths
+| Flow | File | Line |
+|------|------|------|
+| Same-client attack | `lethal-fantasy.mjs` | 918-1004 |
+| Same-client defense | `lethal-fantasy.mjs` | 697-870 |
+| Cross-client defense | `module/utils.mjs` | 291-445 |
+| Cross-client socket guard | `lethal-fantasy.mjs` | 1006-1037 |
+| Attack Grit offer | `module/utils.mjs` | 1210-1290 |
+
+### Key Files
+- `lethal-fantasy.mjs` — Main system hooks, same-client attack/defense reactions
+- `module/utils.mjs` — Cross-client defense flow, bonus dialogs, compareAttackDefense
+- `module/documents/actor.mjs` — `prepareRoll()` entry point
+- `module/documents/roll.mjs` — Roll resolution pipeline

css/fvtt-lethal-fantasy.css

@@ -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;
@@ -1178,6 +1178,45 @@ i.lethalfantasy {
   margin-left: 4px;
   margin-right: 4px;
 }
+.lethalfantasy .tab.monster-combat .ranged-attacks {
+  grid-template-columns: 1fr;
+}
+.lethalfantasy .tab.monster-combat .ranged-attacks .attack .name {
+  min-width: 10rem;
+  max-width: 10rem;
+}
+.lethalfantasy .tab.monster-combat .ranged-attacks .attack .damage-dice {
+  width: 5rem;
+  max-width: 5rem;
+}
+.lethalfantasy .tab.monster-combat .ranged-attacks .ranged-weapon-range {
+  margin-top: 8px;
+  border-top: 1px solid var(--color-border-light-tertiary, #ccc);
+  padding-top: 6px;
+}
+.lethalfantasy .tab.monster-combat .ranged-attacks .ranged-weapon-range > label {
+  font-weight: bold;
+  margin-bottom: 4px;
+  display: block;
+}
+.lethalfantasy .tab.monster-combat .ranged-attacks .ranged-weapon-range .range-fields {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+}
+.lethalfantasy .tab.monster-combat .ranged-attacks .ranged-weapon-range .range-fields .range-field {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+.lethalfantasy .tab.monster-combat .ranged-attacks .ranged-weapon-range .range-fields .range-field label {
+  font-size: 0.7rem;
+  white-space: nowrap;
+}
+.lethalfantasy .tab.monster-combat .ranged-attacks .ranged-weapon-range .range-fields .range-field input {
+  width: 3.5rem;
+  text-align: center;
+}
 .lethalfantasy .tab.monster-combat .armors {
   display: grid;
   grid-template-columns: repeat(3, 1fr);
@@ -1988,9 +2027,12 @@ i.lethalfantasy {
   background: #4a4940 !important;
   color: #ffffff !important;
 }
+.lethalfantasy .grit-luck-dialog {
+  color: var(--color-text-dark-primary, #191813);
+}
 .lethalfantasy .grit-luck-dialog .combat-status {
   padding: 12px;
-  background: linear-gradient(to bottom, rgba(42, 41, 32, 0.8) 0%, rgba(26, 25, 16, 0.9) 100%);
+  background: linear-gradient(to bottom, rgba(42, 41, 32, 0.88) 0%, rgba(26, 25, 16, 0.95) 100%);
   border: 1px solid rgba(212, 175, 55, 0.5);
   border-radius: 6px;
   margin-bottom: 16px;
@@ -2010,11 +2052,25 @@ i.lethalfantasy {
   margin-top: 8px;
 }
 .lethalfantasy .grit-luck-dialog .offer-text {
-  color: #f0e6d2;
+  color: var(--color-text-dark-primary, #191813);
   font-size: calc(var(--font-size-standard) * 1);
   text-align: center;
   font-weight: 600;
+  margin: 0 0 8px 0;
+}
+.lethalfantasy .grit-luck-dialog .shield-warning {
+  color: #7a4000;
+  background: rgba(255, 160, 0, 0.12);
+  border: 1px solid rgba(255, 160, 0, 0.4);
+  border-radius: 5px;
+  font-size: calc(var(--font-size-standard) * 0.88);
+  padding: 6px 10px;
   margin: 0;
+  text-align: center;
+}
+.lethalfantasy .grit-luck-dialog .shield-warning i {
+  color: #c07000;
+  margin-right: 5px;
 }
 .lethalfantasy .attack-result {
   padding: 16px;
@@ -2105,31 +2161,66 @@ i.lethalfantasy {
   color: #d4af37;
 }
 .lethalfantasy .attack-result .attack-result-damage {
-  display: flex;
+  display: grid;
+  grid-template-columns: repeat(2, 1fr);
   gap: 8px;
-  justify-content: center;
+}
+.lethalfantasy .attack-result .attack-result-damage.single-btn {
+  grid-template-columns: 1fr;
+  max-width: 280px;
+  margin: 0 auto;
+}
+.lethalfantasy .attack-result .attack-result-damage.spell-damage {
+  grid-template-columns: 1fr;
+  width: 100%;
 }
 .lethalfantasy .attack-result .attack-result-damage .roll-damage-btn {
-  padding: 10px 16px;
+  padding: 10px 14px;
   background: linear-gradient(to bottom, #8b0000 0%, #660000 100%);
-  border: 1px solid #ff0000;
+  border: 1px solid #4b0000;
   border-radius: 6px;
   color: #f0e6d2;
   font-weight: 600;
+  font-size: calc(var(--font-size-standard) * 0.9);
+  text-align: center;
+  white-space: nowrap;
   cursor: pointer;
   transition: all 0.2s ease;
-  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.3);
+  box-shadow: 0 3px 6px rgba(0, 0, 0, 0.4), inset 0 1px 0 rgba(255, 255, 255, 0.1);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 6px;
+  position: relative;
+  overflow: hidden;
+}
+.lethalfantasy .attack-result .attack-result-damage .roll-damage-btn::before {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: -100%;
+  width: 100%;
+  height: 100%;
+  background: linear-gradient(90deg, transparent, rgba(255, 255, 255, 0.15), transparent);
+  transition: left 0.5s;
+}
+.lethalfantasy .attack-result .attack-result-damage .roll-damage-btn:hover::before {
+  left: 100%;
+}
+.lethalfantasy .attack-result .attack-result-damage .roll-damage-btn i {
+  font-size: calc(var(--font-size-standard) * 1.1);
+  filter: drop-shadow(0 1px 2px rgba(0, 0, 0, 0.5));
+  flex-shrink: 0;
 }
 .lethalfantasy .attack-result .attack-result-damage .roll-damage-btn:hover {
   background: linear-gradient(to bottom, #a00000 0%, #7b0000 100%);
-  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.4);
+  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.5), inset 0 1px 0 rgba(255, 255, 255, 0.15);
   transform: translateY(-2px);
+  border-color: #5b0000;
 }
 .lethalfantasy .attack-result .attack-result-damage .roll-damage-btn:active {
   transform: translateY(0);
-}
-.lethalfantasy .attack-result .attack-result-damage .roll-damage-btn i {
-  margin-right: 6px;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.4), inset 0 1px 3px rgba(0, 0, 0, 0.3);
 }
 .lethalfantasy .equipment-content {
   font-family: var(--font-primary);
@@ -2595,6 +2686,21 @@ i.lethalfantasy {
   max-width: 8rem;
   margin-left: 1rem;
 }
+.dialog-warning {
+  margin: 0.4rem 0.2rem 0.2rem;
+  padding: 0.35rem 0.5rem;
+  border-left: 3px solid #c8941a;
+  background: rgba(200, 148, 26, 0.12);
+  border-radius: 3px;
+  font-family: var(--font-secondary);
+  font-size: calc(var(--font-size-standard) * 0.9);
+  color: #7a5400;
+  line-height: 1.4;
+}
+.dialog-warning i {
+  color: #c8941a;
+  margin-right: 0.4rem;
+}
 .lethalfantasy.dice-roll,
 .fvtt-lethal-fantasy.dice-roll,
 .message.lethalfantasy.dice-roll,
@@ -3174,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,
@@ -3443,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,
@@ -3889,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;
@@ -3994,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 */
 /* -------------------------------------------------- */

lang/en.json

@@ -1,8 +1,32 @@
 {
   "COMBAT": {
+    "Begin": "Begin Combat",
+    "Create": "Create Encounter",
+    "Delete": "Delete Encounter",
+    "Encounter": "Encounter",
+    "EncounterNext": "Next Encounter",
+    "EncounterPrevious": "Previous Encounter",
+    "End": "End Combat",
+    "InitiativeReset": "Reset Initiative",
+    "InitiativeRoll": "Roll Initiative",
+    "InitiativeScore": "Initiative Score",
+    "NavLabel": "Combat Tracker Navigation",
+    "None": "None",
+    "NotStarted": "Not Started",
+    "PanToCombatant": "Pan to Combatant",
+    "PingCombatant": "Ping Combatant",
+    "RollAll": "Roll All",
+    "RollNPC": "Roll NPCs",
     "Round": "Second {round}",
+    "RoundNext": "Next second",
+    "RoundPrev": "Previous second",
     "Rounds": "Seconds",
-    "RoundNext": "Next second"
+    "Settings": "Combat Settings",
+    "ToggleDead": "Toggle Dead",
+    "ToggleVis": "Toggle Visible",
+    "TurnEnd": "End Turn",
+    "TurnNext": "Next Turn",
+    "TurnPrev": "Previous Turn"
   },
   "LETHALFANTASY": {
     "Armor": {
@@ -382,7 +406,7 @@
       "rollProgressionCount": "Roll progression count",
       "rollProgressionDice": "Roll progression/Lethargy dice",
       "earned": "Earned",
-      "divinityPoints": "Divinity points",
+      "divinityPoints": "Grace",
       "aetherPoints": "Aether points",
       "attacks": "Attacks",
       "attackMode": "Attack Mode",
@@ -462,8 +486,17 @@
       "notes": "Notes",
       "pc": "PC",
       "perception": "Perception",
+      "pointBlank": "Point blank",
+      "short": "Short",
+      "medium": "Medium",
+      "long": "Long",
+      "extreme": "Extreme",
+      "outOfSkill": "Out of skill",
+      "range": "Range",
       "rangeDefenseDialog": "Ranged defense dialog",
       "rangeDefenseRoll": "Ranged defense roll",
+      "rangeAttackDialog": "Ranged attack dialog",
+      "rangeAttackRoll": "Ranged attack roll",
       "rangedAttackDefense": "Ranged attack defense",
       "resource": "Resource",
       "resources": "Resources",
@@ -496,11 +529,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": {
@@ -556,6 +620,15 @@
         },
         "savingThrow": {
           "label": "Saving throw"
+        },
+        "damageDiceOverpowered": {
+          "label": "Overpowered Damage Dice"
+        },
+        "damageDiceOverpowered2": {
+          "label": "Overpowered 2 Damage Dice"
+        },
+        "damageDice": {
+          "label": "Damage Dice"
         }
       }
     },
@@ -575,7 +648,9 @@
       "messageLethargyKO": "{spellName} : Lethargy still ongoing ... ( dice result : {roll} )",
       "messageProgressionKO": "{name} can't attack this second.",
       "messageProgressionOKMonster": "{name} can attack this second with {weapon}.",
-      "messageProgressionKOMonster": "{name} can't attack this second (dice result {roll})."
+      "messageProgressionKOMonster": "{name} can't attack this second (dice result {roll}).",
+      "bleedingCombatEnd": "Bleeding active out of combat: {names}",
+      "bleedingCombatStart": "Bleeding still active on: {names}"
     },
     "Opponent": {
       "FIELDS": {}
@@ -677,7 +752,8 @@
             "label": "Min"
           }
         }
-      }
+      },
+      "autoDestruction": "Auto-Destruction"
     },
     "Skill": {
       "Category": {
@@ -776,6 +852,12 @@
         "cost": {
           "label": "Cost"
         },
+        "costOverpowered": {
+          "label": "Cost (Overpowered)"
+        },
+        "costOverpowered2": {
+          "label": "Cost (Overpowered 2)"
+        },
         "description": {
           "label": "Description"
         },
@@ -802,6 +884,12 @@
         },
         "damageDice": {
           "label": "Damage dice"
+        },
+        "damageDiceOverpowered": {
+          "label": "Overpowered Damage Dice"
+        },
+        "damageDiceOverpowered2": {
+          "label": "Overpowered 2 Damage Dice"
         }
       },
       "Range": {
@@ -836,7 +924,9 @@
         }
       }
     },
-    "Warning": {},
+    "Warning": {
+      "defenseShieldOrder": "To avoid a hit without using the shield, roll Grit or Luck first — then roll the shield."
+    },
     "Weapon": {
       "FIELDS": {
         "isAgile": {
@@ -981,6 +1071,18 @@
       "diceResult": "Dice result",
       "progressionCount": "Progression count:"
     },
+    "Combat": {
+      "RollMonsters": "Roll Monsters",
+      "monstersNotRolledTitle": "Monsters Not Rolled",
+      "monstersNotRolledMsg": "Monsters have not rolled this second. Proceed anyway?",
+      "proceedYes": "Proceed",
+      "proceedNo": "Cancel",
+      "spellDRDialogTitle": "Spell Damage — Apply DR?",
+      "spellDRDialogMsg": "Enter a damage reduction value to subtract, or click No DR to apply full damage.",
+      "spellDRLabel": "DR:",
+      "spellNoDR": "No DR",
+      "spellApplyDR": "Apply DR"
+    },
     "EquipmentCategories": {
       "ClassKit": "Class Kit",
       "Clothing": "Clothing",

module/applications/combat.mjs

@@ -18,62 +18,44 @@ export class LethalFantasyCombatTracker extends foundry.applications.sidebar.tab
     actions: {
       initiativePlus: LethalFantasyCombatTracker.#initiativePlus,
       initiativeMinus: LethalFantasyCombatTracker.#initiativeMinus,
+      rollMonsterProgression: LethalFantasyCombatTracker.#rollMonsterProgression,
     },
   });
 
   async _prepareContext(options) {
     let data = await super._prepareContext(options);
-    console?.log("Combat Tracker Data", data);
+    log("Combat Tracker Data", data);
     /*for (let u of data.turns) {
       let c = game.combat.combatants.get(u.id);
       u.progressionCount = c.system.progressionCount
       u.isMonster = c.actor.type === "monster"
     }
-    console.log("Combat Data", data);*/
+    log("Combat Data", data);*/
     return data;
   }
 
-  static #initiativePlus(ev) {
+  static async #initiativePlus(ev) {
     ev.preventDefault();
     let cId = ev.target.closest(".combatant").dataset.combatantId;
     let c = game.combat.combatants.get(cId);
-    c.update({ 'initiative': c.initiative + 1 });
-    console.log("Initiative Plus");
+    await c.update({ 'initiative': c.initiative + 1 });
   }
 
-  static #initiativeMinus(ev) {
+  static async #initiativeMinus(ev) {
     ev.preventDefault();
     let cId = ev.target.closest(".combatant").dataset.combatantId;
     let c = game.combat.combatants.get(cId);
     let newInit = Math.max(c.initiative - 1, 0);
-    c.update({ 'initiative': newInit });
+    await c.update({ 'initiative': newInit });
   }
 
-  activateListeners(html) {
-    super.activateListeners(html);
-    // Display Combat settings
-    html.find(".initiative-plus").click(ev => {
-      ev.preventDefault();
-      let cId = ev.currentTarget.closest(".combatant").dataset.combatantId;
-      let c = game.combat.combatants.get(cId);
-      c.update({ 'initiative': c.initiative + 1 });
-    });
-
-    html.find(".initiative-minus").click(ev => {
-      ev.preventDefault();
-      let cId = ev.currentTarget.closest(".combatant").dataset.combatantId;
-      let c = game.combat.combatants.get(cId);
-      c.update({ 'initiative': c.initiative - 1 });
-      console.log("Initiative Minus");
-    });
-  }
-
-  /* -------------------------------------------- */
-  static get defaultOptions() {
-    let path = "systems/fvtt-lethal-fantasy/templates/combat-tracker.hbs";
-    return foundry.utils.mergeObject(super.defaultOptions, {
-      template: path,
-    });
+  /**
+   * Roll progression dice for all monster combatants that are eligible this round.
+   * @param {Event} ev Click event.
+   */
+  static async #rollMonsterProgression(ev) {
+    ev.preventDefault();
+    await game.combat.rollMonsterProgression();
   }
 }
 
@@ -84,7 +66,7 @@ export class LethalFantasyCombat extends Combat {
  * @returns {Combatant[]}
  */
   setupTurns() {
-    console?.log("Setup Turns....");
+    log("Setup Turns....");
     this.turns ||= [];
 
     // Determine the turn order and the current turn
@@ -109,18 +91,12 @@ export class LethalFantasyCombat extends Combat {
   }
 
   async rollInitiative(ids, options) {
-    console.log("%%%%%%%%% Roll Initiative", ids, options);
-
     ids = typeof ids === "string" ? [ids] : ids;
-    let messages = [];
-    let rollMode = game.settings.get("core", "rollMode");
 
-    let updates = [];
     for (let cId of ids) {
       const c = this.combatants.get(cId);
       const playerOwner = game.users.find(u => u.active && !u.isGM && u.character?.id === c.actor.id);
       if (game.user.isGM && playerOwner) {
-        console.log("Rolling initiative for", c.actor.name);
         game.socket.emit(`system.${SYSTEM.id}`, { type: "rollInitiative", userId: playerOwner.id, actorId: c.actor.id, combatId: this.id, combatantId: c.id });
       } else {
         await c.actor.system.rollInitiative(this.id, c.id);
@@ -130,19 +106,49 @@ export class LethalFantasyCombat extends Combat {
     return this;
   }
 
-  resetProgression(cId) {
-    let c = this.combatants.get(cId);
-    c.update({ 'system.progressionCount': 0 });
+  /** Roll progression dice for all eligible monster combatants this round. Called manually by the GM. */
+  async rollMonsterProgression() {
+    const currentRound = this.round;
+    const monsters = this.combatants.filter(c => c.actor?.type === "monster" && !c.isDefeated);
+
+    if (monsters.length === 0) {
+      ui.notifications.warn("No monsters in combat.");
+      return;
+    }
+
+    let rolled = 0;
+    for (let c of monsters) {
+      if (c.initiative !== null && currentRound >= c.initiative) {
+        await c.actor.system.rollProgressionDice(this.id, c.id);
+        rolled++;
+      }
+    }
+
+    if (rolled === 0) {
+      const earliest = monsters.reduce((min, c) => (c.initiative !== null && c.initiative < min) ? c.initiative : min, Infinity);
+      if (earliest === Infinity) {
+        ui.notifications.warn("Monsters have no initiative set. Roll initiative first.");
+      } else {
+        ui.notifications.info(`No monsters act yet — earliest monster initiative is ${earliest} (current round: ${currentRound}).`);
+      }
+    } else {
+      this._monsterProgressionRolledRound = currentRound;
+    }
   }
 
-  setCasting(cId) {
+  async resetProgression(cId) {
     let c = this.combatants.get(cId);
-    c.setFlag(SYSTEM.id, "casting", true);
+    await c.update({ 'system.progressionCount': 0 });
   }
 
-  resetCasting(cId) {
+  async setCasting(cId) {
     let c = this.combatants.get(cId);
-    c.setFlag(SYSTEM.id, "casting", false);
+    await c.setFlag(SYSTEM.id, "casting", true);
+  }
+
+  async resetCasting(cId) {
+    let c = this.combatants.get(cId);
+    await c.setFlag(SYSTEM.id, "casting", false);
   }
 
   isCasting(cId) {
@@ -151,15 +157,12 @@ export class LethalFantasyCombat extends Combat {
   }
 
   async nextTurn() {
-    console.log("NEXT TURN");
-
     let turn = this.turn ?? -1;
     let skipDefeated = this.settings.skipDefeated;
 
     // Determine the next turn number
     let next = null;
     for (let [i, t] of this.turns.entries()) {
-      console.log("Turn", t);
       if (i <= turn) continue;
       if (skipDefeated && t.isDefeated) continue;
       next = i;
@@ -183,7 +186,6 @@ export class LethalFantasyCombat extends Combat {
     this.turnsDone = false
 
     let turn = this.turn === null ? null : 0; // Preserve the fact that it's no-one's turn currently.
-    console.log("ROUND", this);
 
     let advanceTime = Math.max(this.turns.length - this.turn, 0) * CONFIG.time.turnTime;
     advanceTime += CONFIG.time.roundTime;
@@ -201,8 +203,24 @@ export class LethalFantasyCombat extends Combat {
       return this;
     }
 
+    // Warn if eligible monsters have not rolled progression dice this round
+    const eligibleMonsters = this.combatants.filter(
+      c => c.actor?.type === "monster" && !c.isDefeated && c.initiative !== null && this.round >= c.initiative
+    );
+    if (eligibleMonsters.length > 0 && this._monsterProgressionRolledRound !== this.round) {
+      const proceed = await foundry.applications.api.DialogV2.confirm({
+        window: { title: game.i18n.localize("LETHALFANTASY.Combat.monstersNotRolledTitle") },
+        content: `<p>${game.i18n.localize("LETHALFANTASY.Combat.monstersNotRolledMsg")}</p>`,
+        yes: { label: game.i18n.localize("LETHALFANTASY.Combat.proceedYes") },
+        no: { label: game.i18n.localize("LETHALFANTASY.Combat.proceedNo") },
+        rejectClose: false,
+      });
+      if (!proceed) return this;
+    }
+
     for (let c of this.combatants) {
       if (nextRound >= c.initiative) {
+        if (c.actor.type === "monster") continue;  // Monsters roll manually via the "Roll Monsters" button
         const playerOwner = game.users.find(u => u.active && !u.isGM && u.character?.id === c.actor.id);
         if (game.user.isGM && playerOwner) {
           game.socket.emit(`system.${SYSTEM.id}`, { type: "rollProgressionDice", userId: playerOwner.id, progressionCount: c.system.progressionCount + 1, actorId: c.actor.id, combatId: this.id, combatantId: c.id });

module/applications/free-roll.mjs

@@ -142,11 +142,14 @@ export async function rollFreeDie(dieType, count = 1, explode = false) {
   `
 
   const rollMode = game.settings.get("core", "rollMode")
+  // Normalize old-style rollMode keys (v12/v13) to new-style (v14), fallback to "public"
+  const modeMap = { publicroll: "public", gmroll: "gm", blindroll: "blind", selfroll: "self" }
+  const mode = modeMap[rollMode] ?? rollMode ?? "public"
   const msgData = {
     speaker: ChatMessage.getSpeaker(),
     content,
     sound: CONFIG.sounds.dice,
+    mode,
   }
-  ChatMessage.applyRollMode(msgData, rollMode)
   await ChatMessage.create(msgData)
 }

module/applications/sheets/base-actor-sheet.mjs

@@ -78,7 +78,6 @@ export default class LethalFantasyActorSheet extends HandlebarsApplicationMixin(
   /** @override */
   _onRender(context, options) {
     this.#dragDrop.forEach((d) => d.bind(this.element))
-    // Add listeners to rollable elements
     const rollables = this.element.querySelectorAll(".rollable")
     rollables.forEach((d) => d.addEventListener("click", this._onRoll.bind(this)))
   }
@@ -234,12 +233,12 @@ export default class LethalFantasyActorSheet extends HandlebarsApplicationMixin(
     const attr = target.dataset.edit
     const current = foundry.utils.getProperty(this.document, attr)
     const { img } = this.document.constructor.getDefaultArtwork?.(this.document.toObject()) ?? {}
-    const fp = new FilePicker({
+    const fp = new foundry.applications.ux.FilePicker.implementation({
       current,
       type: "image",
       redirectToRoot: img ? [img] : [],
-      callback: (path) => {
-        this.document.update({ [attr]: path })
+      callback: async (path) => {
+        await this.document.update({ [attr]: path })
       },
       top: this.position.top + 40,
       left: this.position.left + 10,
@@ -261,7 +260,7 @@ export default class LethalFantasyActorSheet extends HandlebarsApplicationMixin(
     item = await fromUuid(uuid)
     if (!item) item = this.document.items.get(id)
     if (!item) return
-    item.sheet.render(true)
+    item.sheet.render({ force: true })
   }
 
   /**
@@ -284,8 +283,8 @@ export default class LethalFantasyActorSheet extends HandlebarsApplicationMixin(
    * @private
    * @static
    */
-  static #onCreateSpell(event, target) {
-    const item = this.document.createEmbeddedDocuments("Item", [{ name: "Nouveau sortilège", type: "spell" }])
+  static async #onCreateSpell(event, target) {
+    await this.document.createEmbeddedDocuments("Item", [{ name: "Nouveau sortilège", type: "spell" }])
   }
 
   // #endregion

module/applications/sheets/base-item-sheet.mjs

@@ -177,12 +177,12 @@ export default class LethalFantasyItemSheet extends HandlebarsApplicationMixin(f
     const attr = target.dataset.edit
     const current = foundry.utils.getProperty(this.document, attr)
     const { img } = this.document.constructor.getDefaultArtwork?.(this.document.toObject()) ?? {}
-    const fp = new FilePicker({
+    const fp = new foundry.applications.ux.FilePicker.implementation({
       current,
       type: "image",
       redirectToRoot: img ? [img] : [],
-      callback: (path) => {
-        this.document.update({ [attr]: path })
+      callback: async (path) => {
+        await this.document.update({ [attr]: path })
       },
       top: this.position.top + 40,
       left: this.position.left + 10,

module/applications/sheets/character-sheet.mjs

@@ -22,6 +22,7 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
       divinityPointsMinus: LethalFantasyCharacterSheet.#onDivinityPointsMinus,
       aetherPointsPlus: LethalFantasyCharacterSheet.#onAetherPointsPlus,
       aetherPointsMinus: LethalFantasyCharacterSheet.#onAetherPointsMinus,
+      rollSpellDamage: LethalFantasyCharacterSheet.#onRollSpellDamage,
     },
   }
 
@@ -70,10 +71,10 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
       biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
     }
     if (this.actor.system.biodata.magicUser) {
-      tabs.spells = { id: "spells", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" }
+      tabs.spells = { id: "spells", group: "sheet", icon: "fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" }
     }
     if (this.actor.system.biodata.clericUser) {
-      tabs.miracles = { id: "miracles", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-hands-praying", label: "LETHALFANTASY.Label.miracles" }
+      tabs.miracles = { id: "miracles", group: "sheet", icon: "fa-solid fa-hands-praying", label: "LETHALFANTASY.Label.miracles" }
     }
     for (const v of Object.values(tabs)) {
       v.active = this.tabGroups[v.group] === v.id
@@ -172,61 +173,132 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
     })
     if (!roll) return null
 
-    await roll.toMessage({}, { rollMode: roll.options.rollMode })
+    await roll.toMessage({}, { messageMode: roll.options.rollMode })
   }
 
   static async #onRollInitiative(event, target) {
     await this.document.system.rollInitiative()
   }
 
-  static #onArmorHitPointsPlus(event, target) {
+  static async #onArmorHitPointsPlus(event, target) {
     let armorHP = this.actor.system.combat.armorHitPoints
     armorHP += 1
-    this.actor.update({ "system.combat.armorHitPoints": armorHP })
+    await this.actor.update({ "system.combat.armorHitPoints": armorHP })
   }
 
-  static #onArmorHitPointsMinus(event, target) {
+  static async #onArmorHitPointsMinus(event, target) {
     let armorHP = this.actor.system.combat.armorHitPoints
     armorHP -= 1
-    this.actor.update({ "system.combat.armorHitPoints": Math.max(armorHP, 0) })
+    await this.actor.update({ "system.combat.armorHitPoints": Math.max(armorHP, 0) })
   }
 
-  static #onDivinityPointsPlus(event, target) {
+  static async #onDivinityPointsPlus(event, target) {
     let points = this.actor.system.divinityPoints.value
     points += 1
     points = Math.min(points, this.actor.system.divinityPoints.max)
-    this.actor.update({ "system.divinityPoints.value": points })
+    await this.actor.update({ "system.divinityPoints.value": points })
   }
 
-  static #onDivinityPointsMinus(event, target) {
+  static async #onDivinityPointsMinus(event, target) {
     let points = this.actor.system.divinityPoints.value
     points -= 1
     points = Math.max(points, 0)
-    this.actor.update({ "system.divinityPoints.value": points })
+    await this.actor.update({ "system.divinityPoints.value": points })
   }
 
-  static #onAetherPointsPlus(event, target) {
+  static async #onAetherPointsPlus(event, target) {
     let points = this.actor.system.aetherPoints.value
     points += 1
     points = Math.min(points, this.actor.system.aetherPoints.max)
-    this.actor.update({ "system.aetherPoints.value": points })
+    await this.actor.update({ "system.aetherPoints.value": points })
   }
 
-  static #onAetherPointsMinus(event, target) {
+  static async #onAetherPointsMinus(event, target) {
     let points = this.actor.system.aetherPoints.value
     points -= 1
     points = Math.max(points, 0)
-    this.actor.update({ "system.aetherPoints.value": points })
+    await 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",
+          type: "button",
+          label: game.i18n.localize("LETHALFANTASY.Combat.spellNoDR"),
+          icon: "fa-solid fa-wand-magic-sparkles",
+          callback: () => 0
+        },
+        {
+          action: "applyDR",
+          type: "button",
+          label: game.i18n.localize("LETHALFANTASY.Combat.spellApplyDR"),
+          icon: "fa-solid fa-shield",
+          callback: (event, button) => Number(button.form?.elements?.manualDr?.value) || 0
+        },
+        {
+          action: "cancel",
+          type: "button",
+          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) {
   }
 
   _onRender(context, options) {
-    // Inputs with class `item-quantity`
     const woundDescription = this.element.querySelectorAll('.wound-data')
     for (const input of woundDescription) {
-      input.addEventListener("change", (e) => {
+      input.addEventListener("change", async (e) => {
         e.preventDefault();
         e.stopImmediatePropagation();
         const newValue = e.currentTarget.value
@@ -234,11 +306,11 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
         const fieldName = e.currentTarget.dataset.name
         let tab = foundry.utils.duplicate(this.actor.system.hp.wounds)
         tab[index][fieldName] = newValue
-        console.log(tab, index, fieldName, newValue)
-        this.actor.update({ "system.hp.wounds": tab });
+        log(tab, index, fieldName, newValue)
+        await this.actor.update({ "system.hp.wounds": tab });
       })
     }
-    super._onRender();
+    super._onRender(context, options);
   }
 
 
@@ -259,9 +331,11 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
 
   async _onRoll(event, target) {
     if (this.isEditMode) return
-    const rollType = event.target.dataset.rollType
-    let rollKey = event.target.dataset.rollKey;
-    let rollDice = event.target.dataset?.rollDice;
+    const el = event.currentTarget
+    const rollType = el.dataset.rollType
+    if (!rollType) return
+    let rollKey = el.dataset.rollKey
+    let rollDice = el.dataset.rollDice
 
     this.actor.prepareRoll(rollType, rollKey, rollDice)
 

module/applications/sheets/monster-sheet.mjs

@@ -91,7 +91,7 @@ export default class LethalFantasyMonsterSheet extends LethalFantasyActorSheet {
    */
   async _onDrop(event) {
     if (!this.isEditable || !this.isEditMode) return
-    const data = TextEditor.getDragEventData(event)
+    const data = foundry.applications.ux.TextEditor.implementation.getDragEventData(event)
 
     // Handle different data types
     switch (data.type) {
@@ -111,11 +111,13 @@ export default class LethalFantasyMonsterSheet extends LethalFantasyActorSheet {
     })
     if (!roll) return null
 
-    await roll.toMessage({}, { rollMode: roll.options.rollMode })
+    await roll.toMessage({}, { messageMode: roll.options.rollMode })
   }
 
   static async #onRollInitiative(event, target) {
-    await this.document.system.rollInitiative(event, target)
+    const combat = game.combat
+    const combatant = combat?.combatants.find(c => c.actorId === this.document.id)
+    await this.document.system.rollInitiative(combat?.id, combatant?.id)
   }
 
   getBestWeaponClassSkill(skills, rollType, multiplier = 1.0) {

module/config/d30_results_tables.json

@@ -4,70 +4,180 @@
       "melee_attack": {
         "type": "choice",
         "choices": [
-          { "type": "special_strike", "options": ["lethal", "vital"] },
-          { "type": "bonus_dice", "dice": "D20E", "target": "attack" }
+          {
+            "type": "special_strike",
+            "options": [
+              "lethal",
+              "vital"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D20E",
+            "target": "attack"
+          }
         ],
         "description": "Possible Lethal or Vital Strike or Add D20E to Attack"
       },
       "ranged_attack": {
         "type": "choice",
         "choices": [
-          { "type": "special_strike", "options": ["lethal", "vital"] },
-          { "type": "bonus_dice", "dice": "D20E", "target": "attack" }
+          {
+            "type": "special_strike",
+            "options": [
+              "lethal",
+              "vital"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D20E",
+            "target": "attack"
+          }
         ],
         "description": "Possible Lethal or Vital Strike or Add D20E to Attack"
       },
       "melee_defense": {
         "type": "choice",
         "choices": [
-          { "type": "special_defense", "options": ["flawless", "legendary"] },
-          { "type": "bonus_dice", "dice": "D20E", "target": "defense" }
+          {
+            "type": "special_defense",
+            "options": [
+              "flawless",
+              "legendary"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D20E",
+            "target": "defense"
+          }
         ],
         "description": "Possible Flawless or Legendary Defense or Add D20E to Defense"
       },
       "arcane_spell_attack": {
         "type": "choice",
         "choices": [
-          { "type": "special_strike", "options": ["lethal_magical", "vital_magical"] },
-          { "type": "bonus_dice", "dice": "D20E", "target": "spell_attack" }
+          {
+            "type": "special_strike",
+            "options": [
+              "lethal_magical",
+              "vital_magical"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D20E",
+            "target": "spell_attack"
+          }
         ],
         "description": "Possible Lethal or Vital Magical Strike or Add D20E to Spell Attack"
       },
       "arcane_spell_defense": {
         "type": "choice",
         "choices": [
-          { "type": "spell_calamity" },
-          { "type": "bonus_dice", "dice": "D20E", "target": "spell_defense" }
+          {
+            "type": "spell_calamity"
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D20E",
+            "target": "spell_defense"
+          }
         ],
         "description": "Possible Spell Catastrophe or adds D20E to Spell Defense"
       },
       "skill_rolls": {
         "type": "skill_auto_success",
         "description": "Skill Succeeds Regardless of Opposing Roll"
+      },
+      "ranged_defense": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_defense",
+            "options": [
+              "flawless",
+              "legendary"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D20E",
+            "target": "defense"
+          }
+        ],
+        "description": "Possible Flawless or Legendary Defense or Add D20E to Defense"
+      },
+      "saving_throws": {
+        "type": "save_auto_success",
+        "description": "Saving Throw Succeeds Regardless of Opposing Roll"
       }
     },
     "29": {
-      "melee_attack": { "type": "gain_grit", "amount": 1, "description": "Gain 1 Grit" },
-      "ranged_attack": { "type": "gain_grit", "amount": 1, "description": "Gain 1 Grit" },
-      "melee_defense": { "type": "gain_grit", "amount": 1, "description": "Gain 1 Grit" },
-      "arcane_spell_attack": { "type": "gain_grit", "amount": 1, "description": "Gain 1 Grit" },
-      "arcane_spell_defense": { "type": "gain_grit", "amount": 1, "description": "Gain 1 Grit" },
-      "skill_rolls": { "type": "gain_grit", "amount": 1, "description": "Gain 1 Grit" }
+      "melee_attack": {
+        "type": "gain_grit",
+        "amount": 1,
+        "description": "Gain 1 Grit"
+      },
+      "ranged_attack": {
+        "type": "gain_grit",
+        "amount": 1,
+        "description": "Gain 1 Grit"
+      },
+      "melee_defense": {
+        "type": "gain_grit",
+        "amount": 1,
+        "description": "Gain 1 Grit"
+      },
+      "arcane_spell_attack": {
+        "type": "gain_grit",
+        "amount": 1,
+        "description": "Gain 1 Grit"
+      },
+      "arcane_spell_defense": {
+        "type": "gain_grit",
+        "amount": 1,
+        "description": "Gain 1 Grit"
+      },
+      "skill_rolls": {
+        "type": "gain_grit",
+        "amount": 1,
+        "description": "Gain 1 Grit"
+      },
+      "ranged_defense": {
+        "type": "gain_grit",
+        "amount": 1,
+        "description": "Gain 1 Grit"
+      },
+      "saving_throws": {
+        "type": "gain_grit",
+        "amount": 1,
+        "description": "Gain 1 Grit"
+      }
     },
     "28": {
-      "melee_attack": { "type": "shield_destruction", "description": "Shield Destruction" }
+      "melee_attack": {
+        "type": "shield_destruction",
+        "description": "Shield Destruction"
+      }
     },
     "27": {
       "melee_attack": {
-        "type": "bonus_dice", "dice": "D6", "target": "attack",
+        "type": "bonus_dice",
+        "dice": "D6",
+        "target": "attack",
         "description": "Granted D6 (1-6) Attack Modifier for This Melee Attack"
       },
       "ranged_attack": {
-        "type": "bonus_dice", "dice": "D6", "target": "attack",
+        "type": "bonus_dice",
+        "dice": "D6",
+        "target": "attack",
         "description": "Granted D6 (1-6) Attack Modifier for This Ranged Attack"
       },
       "melee_defense": {
-        "type": "luck_die", "scope": "combat",
+        "type": "luck_die",
+        "scope": "combat",
         "description": "Granted 1 Luck dice for Use in This Combat Only"
       },
       "arcane_spell_attack": {
@@ -75,26 +185,48 @@
         "description": "No Spell Lethargy the Aether Approves of Characters Efforts"
       },
       "arcane_spell_defense": {
-        "type": "flash_of_pain", "duration_dice": "1D6E", "target": "caster",
+        "type": "flash_of_pain",
+        "duration_dice": "1D6E",
+        "target": "caster",
         "description": "Caster Suffers Severe pain and will be under a flash of pain for 1D6E seconds"
+      },
+      "ranged_defense": {
+        "type": "luck_die",
+        "scope": "combat",
+        "description": "Granted 1 Luck dice for Use in This Combat Only"
       }
     },
     "26": {
-      "melee_attack": { "type": "shield_destruction", "description": "Shield Destruction" }
+      "melee_attack": {
+        "type": "shield_destruction",
+        "description": "Shield Destruction"
+      }
     },
     "25": {
       "skill_rolls": {
-        "type": "bonus_flat", "amount": 1, "target": "skill",
+        "type": "bonus_flat",
+        "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": {
       "melee_attack": {
-        "type": "flash_of_pain", "duration_dice": "1D6E", "target": "defender",
+        "type": "flash_of_pain",
+        "duration_dice": "1D6E",
+        "target": "defender",
         "description": "Hit Inflicts Flash of Pain 1D6E seconds"
       },
       "ranged_attack": {
-        "type": "flash_of_pain", "duration_dice": "1D6E", "target": "defender",
+        "type": "flash_of_pain",
+        "duration_dice": "1D6E",
+        "target": "defender",
         "description": "Hit Inflicts Flash of Pain 1D6E seconds"
       },
       "melee_defense": {
@@ -102,181 +234,433 @@
         "description": "Defender Recovers or ignores any flash of pain"
       },
       "arcane_spell_attack": {
-        "type": "flash_of_pain", "duration_dice": "1D6E", "target": "defender",
+        "type": "flash_of_pain",
+        "duration_dice": "1D6E",
+        "target": "defender",
         "description": "Magical Damage inflicts Flash of pain 1D6E seconds"
       },
       "arcane_spell_defense": {
-        "type": "flash_of_pain", "duration_dice": "1D6E", "target": "caster",
+        "type": "flash_of_pain",
+        "duration_dice": "1D6E",
+        "target": "caster",
         "description": "Caster Suffers Severe pain and will be under a flash of pain for 1D6E seconds"
       },
       "skill_rolls": {
-        "type": "bonus_dice", "dice": "D6", "target": "skill",
+        "type": "bonus_dice",
+        "dice": "D6",
+        "target": "skill",
         "description": "Granted D6 (1-6) Skill Modifier for this Skill Attempt"
+      },
+      "ranged_defense": {
+        "type": "recover_pain",
+        "description": "Defender Recovers or ignores any flash of pain"
+      },
+      "saving_throws": {
+        "type": "bonus_dice",
+        "dice": "D6",
+        "target": "save",
+        "description": "Granted D6 (1-6) Saving Throw Modifier for this Saving Throw Attempt"
       }
     },
     "20": {
       "melee_attack": {
         "type": "choice",
         "choices": [
-          { "type": "special_strike", "options": ["vicious"] },
-          { "type": "bonus_dice", "dice": "D12", "target": "attack" }
+          {
+            "type": "special_strike",
+            "options": [
+              "vicious"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D12",
+            "target": "attack"
+          }
         ],
         "description": "Possible Vicious Strike or Add D12 to attack"
       },
       "ranged_attack": {
         "type": "choice",
         "choices": [
-          { "type": "special_strike", "options": ["vicious"] },
-          { "type": "bonus_dice", "dice": "D12", "target": "attack" }
+          {
+            "type": "special_strike",
+            "options": [
+              "vicious"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D12",
+            "target": "attack"
+          }
         ],
         "description": "Possible Vicious Strike or add D12 to attack"
       },
       "melee_defense": {
         "type": "choice",
         "choices": [
-          { "type": "special_defense", "options": ["perfect"] },
-          { "type": "bonus_dice", "dice": "D12", "target": "defense" }
+          {
+            "type": "special_defense",
+            "options": [
+              "perfect"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D12",
+            "target": "defense"
+          }
         ],
         "description": "Possible 20/20 defense that avoids Any Attack Except a Lethal Strike or adds D12 to defense"
       },
       "arcane_spell_attack": {
         "type": "choice",
         "choices": [
-          { "type": "special_strike", "options": ["vicious_magical"] },
-          { "type": "bonus_dice", "dice": "D12", "target": "spell_attack" }
+          {
+            "type": "special_strike",
+            "options": [
+              "vicious_magical"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D12",
+            "target": "spell_attack"
+          }
         ],
         "description": "Possible Vicious Application of a Magical Attack or add D12 to attack"
       },
       "arcane_spell_defense": {
         "type": "choice",
         "choices": [
-          { "type": "special_defense", "options": ["perfect_spell"] },
-          { "type": "bonus_dice", "dice": "D12", "target": "spell_defense" }
+          {
+            "type": "special_defense",
+            "options": [
+              "perfect_spell"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D12",
+            "target": "spell_defense"
+          }
         ],
-        "description": "Possible 20/20 Spell defense that Saves Against Any Magical Attack Except a Lethal Magical Strike or add D12 to defense"
+        "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", "amount": 20, "target": "skill",
+        "type": "bonus_flat",
+        "amount": 20,
+        "target": "skill",
         "description": "20 Added to Skill Roll"
+      },
+      "ranged_defense": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_defense",
+            "options": [
+              "perfect"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D12",
+            "target": "defense"
+          }
+        ],
+        "description": "Possible 20/20 defense that avoids Any Attack Except a Lethal Strike or adds D12 to defense"
+      },
+      "saving_throws": {
+        "type": "bonus_flat",
+        "amount": 20,
+        "target": "save",
+        "description": "20 Added to Saving Throw"
       }
     },
     "15": {
       "melee_attack": {
         "type": "combo",
         "effects": [
-          { "type": "bleed" },
-          { "type": "knockback" }
+          {
+            "type": "bleed"
+          },
+          {
+            "type": "internal_injury"
+          }
         ],
-        "description": "Bleed, Knock-back on Hit"
+        "description": "Bleed, Internal Injury on Hit"
+      },
+      "ranged_attack": {
+        "type": "bleed",
+        "description": "Bleed"
       },
-      "ranged_attack": { "type": "bleed", "description": "Bleed" },
       "melee_defense": {
         "type": "counter_attack",
-        "options": ["kick", "punch", "shield_bash"],
-        "description": "Kick, Punch or Shield Bash"
+        "options": [
+          "kick",
+          "punch"
+        ],
+        "description": "Kick or Punch"
       },
       "skill_rolls": {
-        "type": "bonus_flat", "amount": 1, "target": "skill",
+        "type": "bonus_flat",
+        "amount": 1,
+        "target": "skill",
         "description": "Add 1 to Skill Roll"
+      },
+      "ranged_defense": {
+        "type": "counter_attack",
+        "options": [
+          "kick",
+          "punch"
+        ],
+        "description": "Kick or Punch"
+      },
+      "saving_throws": {
+        "type": "bonus_flat",
+        "amount": 1,
+        "target": "save",
+        "description": "Add 1 to Saving Throw"
       }
     },
     "13": {},
     "11": {
       "melee_attack": {
-        "type": "flurry", "condition": "hit_or_miss",
-        "description": "Flurry Attack or Hit to Miss"
+        "type": "flurry",
+        "condition": "hit_or_miss",
+        "description": "Flurry Attack on Hit or Miss"
       },
-      "ranged_attack": { "type": "double_damage_dice", "description": "Roll 2x Damage Dice" }
+      "ranged_attack": {
+        "type": "double_damage_dice",
+        "description": "Roll 2x Damage Dice"
+      }
     },
     "10": {
       "melee_attack": {
         "type": "combo",
         "effects": [
-          { "type": "bleed" },
-          { "type": "knockback" }
+          {
+            "type": "bleed"
+          },
+          {
+            "type": "internal_injury"
+          }
         ],
-        "description": "Bleed, Knock-back on Hit"
+        "description": "Bleed, Internal Injury on Hit"
+      },
+      "ranged_attack": {
+        "type": "bleed",
+        "description": "Bleed"
       },
-      "ranged_attack": { "type": "bleed", "description": "Bleed" },
       "melee_defense": {
         "type": "counter_attack",
-        "options": ["kick", "punch", "shield_bash"],
-        "description": "Kick, Punch or Shield Bash"
+        "options": [
+          "kick",
+          "punch"
+        ],
+        "description": "Kick or Punch"
       },
       "skill_rolls": {
-        "type": "bonus_flat", "amount": 1, "target": "skill",
+        "type": "bonus_flat",
+        "amount": 1,
+        "target": "skill",
         "description": "Add 1 to Skill Roll"
+      },
+      "ranged_defense": {
+        "type": "counter_attack",
+        "options": [
+          "kick",
+          "punch"
+        ],
+        "description": "Kick or Punch"
+      },
+      "saving_throws": {
+        "type": "bonus_flat",
+        "amount": 1,
+        "target": "save",
+        "description": "Add 1 to Saving Throw"
       }
     },
     "8": {
-      "melee_attack": { "type": "mulligan", "description": "Mulligan, Can Choose to Re-roll This Attack" },
-      "ranged_attack": { "type": "mulligan", "description": "Mulligan, Can Choose to Re-Roll This Attack" },
-      "melee_defense": { "type": "mulligan", "description": "Mulligan, Can Choose to Re-Roll This Defense" },
-      "arcane_spell_attack": { "type": "mulligan", "description": "Mulligan, Can Re-Roll This Spell Attack" },
-      "arcane_spell_defense": { "type": "mulligan", "description": "Mulligan, Can Re-Roll This Spell Defense" },
-      "skill_rolls": { "type": "mulligan", "description": "Mulligan, Can Re-Roll This Skill roll" }
+      "melee_attack": {
+        "type": "mulligan",
+        "description": "Mulligan, Can Choose to Re-roll This Attack"
+      },
+      "ranged_attack": {
+        "type": "mulligan",
+        "description": "Mulligan, Can Choose to Re-Roll This Attack"
+      },
+      "melee_defense": {
+        "type": "mulligan",
+        "description": "Mulligan, Can Choose to Re-Roll This Defense"
+      },
+      "arcane_spell_attack": {
+        "type": "mulligan",
+        "description": "Mulligan, Can Re-Roll This Spell Attack"
+      },
+      "arcane_spell_defense": {
+        "type": "mulligan",
+        "description": "Mulligan, Can Re-Roll This Spell Defense"
+      },
+      "skill_rolls": {
+        "type": "mulligan",
+        "description": "Mulligan, Can Re-Roll This Skill roll"
+      },
+      "ranged_defense": {
+        "type": "mulligan",
+        "description": "Mulligan, Can Choose to Re-Roll This Defense"
+      },
+      "saving_throws": {
+        "type": "mulligan",
+        "description": "Mulligan, Can Re-Roll This Saving Throw"
+      }
     },
     "7": {
       "melee_attack": {
-        "type": "flurry", "condition": "hit_or_miss",
+        "type": "flurry",
+        "condition": "hit_or_miss",
         "description": "Flurry Attack on Hit or Miss"
       },
-      "ranged_attack": { "type": "double_damage_dice", "description": "Roll 2x Damage Dice" }
+      "ranged_attack": {
+        "type": "double_damage_dice",
+        "description": "Roll 2x Damage Dice"
+      }
     },
     "5": {
       "melee_attack": {
         "type": "combo",
         "effects": [
-          { "type": "bleed" },
-          { "type": "knockback" }
+          {
+            "type": "bleed"
+          },
+          {
+            "type": "internal_injury"
+          }
         ],
-        "description": "Bleed, Knock-back on Hit"
+        "description": "Bleed, Internal Injury on Hit"
+      },
+      "ranged_attack": {
+        "type": "bleed",
+        "description": "Bleed"
       },
-      "ranged_attack": { "type": "bleed", "description": "Bleed" },
       "melee_defense": {
         "type": "counter_attack",
-        "options": ["kick", "punch", "shield_bash"],
-        "description": "Kick, Punch, or Shield Bash"
+        "options": [
+          "kick",
+          "punch"
+        ],
+        "description": "Kick or Punch"
       },
       "skill_rolls": {
-        "type": "bonus_flat", "amount": 1, "target": "skill",
+        "type": "bonus_flat",
+        "amount": 1,
+        "target": "skill",
         "description": "Add 1 to Skill Roll"
+      },
+      "ranged_defense": {
+        "type": "counter_attack",
+        "options": [
+          "kick",
+          "punch"
+        ],
+        "description": "Kick or Punch"
+      },
+      "saving_throws": {
+        "type": "bonus_flat",
+        "amount": 1,
+        "target": "save",
+        "description": "Add 1 to Saving Throw"
       }
     },
     "3": {
-      "melee_attack": { "type": "damage_multiplier", "multiplier": 3, "description": "Triple Damage" },
-      "ranged_attack": { "type": "damage_multiplier", "multiplier": 3, "description": "Triple Damage" },
+      "melee_attack": {
+        "type": "damage_multiplier",
+        "multiplier": 3,
+        "description": "Triple Damage"
+      },
+      "ranged_attack": {
+        "type": "damage_multiplier",
+        "multiplier": 3,
+        "description": "Triple Damage"
+      },
       "melee_defense": {
-        "type": "dr_multiplier", "multiplier": 3, "includes_shield": true,
+        "type": "dr_multiplier",
+        "multiplier": 3,
+        "includes_shield": true,
         "description": "DR Tripled including Shield"
       },
-      "arcane_spell_attack": { "type": "damage_multiplier", "multiplier": 3, "description": "Triple Damage on Spell Damage" },
+      "arcane_spell_attack": {
+        "type": "damage_multiplier",
+        "multiplier": 3,
+        "description": "Triple Damage on Spell Damage"
+      },
       "arcane_spell_defense": {
-        "type": "bonus_dice", "dice": "D12", "target": "spell_defense",
+        "type": "bonus_dice",
+        "dice": "D12",
+        "target": "spell_defense",
         "description": "D12 Added to Spell Defense Modifier"
+      },
+      "ranged_defense": {
+        "type": "dr_multiplier",
+        "multiplier": 3,
+        "includes_shield": true,
+        "description": "DR Tripled including Shield"
       }
     },
     "2": {
-      "melee_attack": { "type": "damage_multiplier", "multiplier": 2, "description": "Double Damage" },
-      "ranged_attack": { "type": "damage_multiplier", "multiplier": 2, "description": "Double Damage" },
+      "melee_attack": {
+        "type": "damage_multiplier",
+        "multiplier": 2,
+        "description": "Double Damage"
+      },
+      "ranged_attack": {
+        "type": "damage_multiplier",
+        "multiplier": 2,
+        "description": "Double Damage"
+      },
       "melee_defense": {
-        "type": "dr_multiplier", "multiplier": 2, "includes_shield": true,
+        "type": "dr_multiplier",
+        "multiplier": 2,
+        "includes_shield": true,
         "description": "DR Doubled including Shield"
       },
-      "arcane_spell_attack": { "type": "damage_multiplier", "multiplier": 2, "description": "Double Damage on Spell Damage" },
+      "arcane_spell_attack": {
+        "type": "damage_multiplier",
+        "multiplier": 2,
+        "description": "Double Damage on Spell Damage"
+      },
       "arcane_spell_defense": {
-        "type": "bonus_dice", "dice": "D6", "target": "spell_defense",
+        "type": "bonus_dice",
+        "dice": "D6",
+        "target": "spell_defense",
         "description": "D6 Added to Spell Defense Modifier"
+      },
+      "ranged_defense": {
+        "type": "dr_multiplier",
+        "multiplier": 2,
+        "includes_shield": true,
+        "description": "DR Doubled including Shield"
       }
     },
     "1": {
       "ranged_attack": {
-        "type": "fumble", "detail": "ranged_ammo_broken",
+        "type": "fumble",
+        "detail": "ranged_ammo_broken",
         "description": "Possible Fumble Ranged ammo is broken unrecoverable"
       },
       "arcane_spell_attack": {
+        "type": "spell_calamity",
+        "description": "A possible spell calamity has occurred"
+      },
+      "arcane_spell_defense": {
         "type": "spell_calamity",
         "description": "Possible Spell Calamity or Catastrophe"
+      },
+      "melee_attack": {
+        "type": "fumble",
+        "detail": "melee_fumble",
+        "description": "Possible Fumble"
       }
     }
   },

module/config/system.mjs

@@ -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" },
@@ -193,6 +200,7 @@ export const DICE_VALUES = {
 export const CHARACTERISTIC_ATTACK = ["str", "int", "wis", "dex"]
 export const CHARACTERISTIC_RANGED_ATTACK = ["int", "wis", "dex"]
 export const CHARACTERISTIC_DEFENSE = ["int", "wis", "dex"]
+export const CHARACTERISTIC_RANGED_DEFENSE = ["int", "wis", "dex"]
 export const CHARACTERISTIC_DAMAGE = ["str"]
 
 export const DEFENSE_DICE_VALUES = {
@@ -304,6 +312,7 @@ export const SYSTEM = {
   CHARACTERISTIC_ATTACK,
   CHARACTERISTIC_RANGED_ATTACK,
   CHARACTERISTIC_DEFENSE,
+  CHARACTERISTIC_RANGED_DEFENSE,
   CHARACTERISTIC_DAMAGE,
   INITIATIVE_DICE_CHOICES_PER_CLASS,
   CHAR_CLASSES,
@@ -319,6 +328,7 @@ export const SYSTEM = {
   RANGE_CHOICES,
   FAVOR_CHOICES,
   ATTACKER_AIM_CHOICES,
+  ATTACKER_MOVEMENT_CHOICES,
   MORTAL_CHOICES,
   SPELL_CRITICAL,
   MIRACLE_TYPES,

module/documents/actor.mjs

@@ -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
+    await this.update({ "system.hp.value": hp })
+  }
+
+  /* *************************************************/
+  getNaturalDR() {
+    if (this.type === "monster") {
+      return Number(this.system.hp?.damageResistance) || 0
     }
-    this.update({ "system.hp.value": hp })
+    return Number(this.system.biodata?.naturalDR) || 0
+  }
+
+  /* *************************************************/
+  getMagicDR() {
+    if (this.type === "monster") return 0
+    return Number(this.system.biodata?.magicDR) || 0
   }
 
   /* *************************************************/
   computeDamageReduction() {
-    // Pour les monstres, utiliser hp.damageResistance et combat.damageReduction
     if (this.type === "monster") {
-      let hpDR = Number(this.system.hp?.damageResistance) || 0
+      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,8 +162,8 @@ export default class LethalFantasyActor extends Actor {
   }
 
   /* *************************************************/
-  async prepareRoll(rollType, rollKey, rollDice, defenderId, defenderTokenId, extraShieldDr = 0) {
-    console.log("Preparing roll", rollType, rollKey, rollDice, defenderId)
+  async prepareRoll(rollType, rollKey, rollDice, defenderId, defenderTokenId, extraShieldDr = 0, d30Effects = {}) {
+    log("Preparing roll", rollType, rollKey, rollDice, defenderId)
     let rollTarget
     switch (rollType) {
       case "granted":
@@ -196,8 +205,53 @@ export default class LethalFantasyActor extends Actor {
       case "spell-power":
       case "miracle-attack":
       case "miracle-power":
-        rollTarget = this.items.find((i) => (i.type === "miracle" || i.type == "spell") && i.id === rollKey)
+        rollTarget = foundry.utils.duplicate(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")
+        let damageTier = currentAction?.damageTier
+        // No tier from combat action — prompt the user if multiple tiers exist
+        if (!damageTier) {
+          const tierMap = { standard: "damageDice", overpowered: "damageDiceOverpowered", overpowered2: "damageDiceOverpowered2" }
+          const available = Object.entries(tierMap).filter(([k, v]) => rollTarget.system?.[v])
+          if (available.length > 1) {
+            const buttons = available.map(([id]) => ({
+              action: id,
+              type: "button",
+              label: id.charAt(0).toUpperCase() + id.slice(1),
+              callback: () => id,
+            }))
+            damageTier = await foundry.applications.api.DialogV2.wait({
+              window: { title: "Choose spell tier" },
+              classes: ["lethalfantasy"],
+              content: `<p>Select the power level for <strong>${rollTarget.name}</strong>:</p>`,
+              buttons,
+              rejectClose: false,
+            }) || "standard"
+          } else {
+            damageTier = "standard"
+          }
+        }
+        rollTarget.damageTier = damageTier
+        if (rollType === "spell-attack" || rollType === "spell-power") {
+          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}).`)
+            return
+          }
+        }
+        if (rollType === "miracle-attack" || rollType === "miracle-power") {
+          const cost = Number(rollTarget.system?.level) || 0
+          const currentGrace = Number(this.system.divinityPoints?.value) || 0
+          if (cost > currentGrace) {
+            ui.notifications.warn(`${this.name} cannot invoke ${rollTarget.name}: insufficient Grace (needs ${cost}, has ${currentGrace}).`)
+            return
+          }
+        }
         break
       case "shield-roll": {
         rollTarget = this.items.find((i) => i.type === "shield" && i.id === rollKey)
@@ -206,8 +260,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)
@@ -245,9 +298,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") {
@@ -256,19 +310,21 @@ export default class LethalFantasyActor extends Actor {
         if (rollType === "weapon-defense") {
           rollTarget.armorDefense = this.getArmorDefenseValue()
           rollTarget.grantedDice = this.system.granted.defenseDice
+          // Check if this is a ranged defense
+          rollTarget.isRangedDefense = game.lethalFantasy?.nextDefenseData?.isRanged ?? false
         }
       }
         break
       default:
         ui.notifications.error(game.i18n.localize("LETHALFANTASY.Notifications.rollTypeNotFound") + String(rollType))
-        break
+        return
     }
 
     // In all cases
     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)
   }
 
 }

module/documents/d30-roll.mjs

@@ -1,3 +1,5 @@
+import { log } from "../utils.mjs"
+
 /**
  * Classe pour gérer les résultats du D30 dans Lethal Fantasy
  */
@@ -22,9 +24,11 @@ export default class D30Roll {
     MELEE_ATTACK: "melee_attack",
     RANGED_ATTACK: "ranged_attack",
     MELEE_DEFENSE: "melee_defense",
+    RANGED_DEFENSE: "ranged_defense",
     ARCANE_SPELL_ATTACK: "arcane_spell_attack",
     ARCANE_SPELL_DEFENSE: "arcane_spell_defense",
-    SKILL_ROLLS: "skill_rolls"
+    SKILL_ROLLS: "skill_rolls",
+    SAVING_THROWS: "saving_throws"
   }
 
   /**
@@ -39,7 +43,7 @@ export default class D30Roll {
       this.resultsTable = data.d30_dice_results
       this.definitions = data.definitions
 
-      console.log("D30Roll | D30 results table loaded successfully")
+      log("D30Roll | D30 results table loaded successfully")
     } catch (error) {
       console.error("D30Roll | Error loading D30 table:", error)
       ui.notifications.error("Unable to load D30 results table")
@@ -51,9 +55,11 @@ export default class D30Roll {
    * @param {number} diceValue La valeur du dé (1-30)
    * @param {string} rollType Le type de jet externe (ex: "weapon-attack", "spell-attack", etc.)
    * @param {Object} weapon L'arme ou l'objet utilisé (optionnel, nécessaire pour certains types)
+   * @param {Object} options Options supplémentaires (optionnel)
+   * @param {boolean} options.isRanged Si true, utilise ranged_defense au lieu de melee_defense
    * @returns {Object|null} L'objet effet `{ type, description, ...fields }` ou null si aucun effet
    */
-  static getResult(diceValue, rollType, weapon = null) {
+  static getResult(diceValue, rollType, weapon = null, options = {}) {
     if (!this.resultsTable) {
       console.warn("D30Roll | Results table is not initialized. Call D30Roll.initialize() first.")
       return null
@@ -64,7 +70,7 @@ export default class D30Roll {
       return null
     }
 
-    const internalType = this.convertToInternalType(rollType, weapon)
+    const internalType = this.convertToInternalType(rollType, weapon, options)
 
     if (!internalType) {
       console.warn(`D30Roll | Could not convert roll type: ${rollType}`)
@@ -99,24 +105,25 @@ export default class D30Roll {
    * Convertit un rollType externe en rollType interne
    * @param {string} externalType Le type de jet externe (ex: "weapon-attack")
    * @param {Object} weapon L'arme ou l'objet utilisé (optionnel)
+   * @param {Object} options Options supplémentaires (optionnel)
+   * @param {boolean} options.isRanged Si true, utilise ranged_defense au lieu de melee_defense
    * @returns {string|null} Le type interne correspondant ou null
    */
-  static convertToInternalType(externalType, weapon = null) {
+  static convertToInternalType(externalType, weapon = null, options = {}) {
     // Attack types - need weapon to determine if melee or ranged
     if (externalType === "weapon-attack") {
       if (!weapon) {
         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
@@ -124,7 +131,7 @@ export default class D30Roll {
 
     // Defense types
     if (externalType === "weapon-defense" || externalType === "monster-defense") {
-      return this.ROLL_TYPES.MELEE_DEFENSE
+      return options.isRanged ? this.ROLL_TYPES.RANGED_DEFENSE : this.ROLL_TYPES.MELEE_DEFENSE
     }
 
     // Spell types
@@ -133,11 +140,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
@@ -190,11 +201,12 @@ export default class D30Roll {
    * @param {number} diceValue La valeur du dé (1-30)
    * @param {string} rollType Le type de jet externe
    * @param {Object} weapon L'arme ou l'objet utilisé (optionnel)
+   * @param {Object} options Options supplémentaires (optionnel)
    * @returns {Object} Un objet avec le résultat et des informations de formatage
    */
-  static getFormattedResult(diceValue, rollType, weapon = null) {
-    const result = this.getResult(diceValue, rollType, weapon)
-    const internalType = this.convertToInternalType(rollType, weapon)
+  static getFormattedResult(diceValue, rollType, weapon = null, options = {}) {
+    const result = this.getResult(diceValue, rollType, weapon, options)
+    const internalType = this.convertToInternalType(rollType, weapon, options)
 
     return {
       value: diceValue,

module/documents/roll.mjs

@@ -127,6 +127,7 @@ export default class LethalFantasyRoll extends Roll {
    * @returns {Promise<Object|null>} The roll result or null if the dialog was cancelled.
    */
   static async prompt(options = {}) {
+    try {
     let dice = "1D20"
     let maxValue = 20
     let baseFormula = "1D20"
@@ -139,7 +140,7 @@ export default class LethalFantasyRoll extends Roll {
     let hasGrantedDice = false
     let pointBlank = false
     let letItFly = false
-    let saveSpell = false
+    let saveSpell = game.lethalFantasy?.spellDefense ?? false
     let beyondSkill = false
     let hasStaticModifier = false
     let hasExplode = true
@@ -182,6 +183,7 @@ export default class LethalFantasyRoll extends Roll {
       } else {
         options.rollTarget.value = options.rollTarget.defenseModifier
         options.rollTarget.charModifier = 0
+        options.isRangedDefense = options.rollTarget.isRangedDefense ?? false
       }
 
     } else if (options.rollType === "monster-skill") {
@@ -219,8 +221,14 @@ export default class LethalFantasyRoll extends Roll {
           options.rollTarget.charModifier = options.rollTarget.combat.rangedAttackModifier
         }
       } else {
-        options.rollTarget.value = options.rollTarget.combat.defenseModifier + options.rollTarget.weaponSkillModifier + options.rollTarget.weapon.system.bonuses.defenseBonus + options.rollTarget.armorDefense
-        options.rollTarget.charModifier = options.rollTarget.combat.defenseModifier
+        // For defense, check if it's a ranged defense
+        const defenseModifier = options.rollTarget.isRangedDefense
+          ? options.rollTarget.combat.rangedDefenseModifier
+          : options.rollTarget.combat.defenseModifier
+        options.rollTarget.value = defenseModifier + options.rollTarget.weaponSkillModifier + options.rollTarget.weapon.system.bonuses.defenseBonus + options.rollTarget.armorDefense
+        options.rollTarget.charModifier = defenseModifier
+        // Store isRanged flag for D30 lookup
+        options.isRangedDefense = options.rollTarget.isRangedDefense
       }
 
     } else if (options.rollType === "spell" || options.rollType === "spell-attack" || options.rollType === "spell-power") {
@@ -230,6 +238,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"
@@ -246,6 +255,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"
@@ -265,6 +275,7 @@ export default class LethalFantasyRoll extends Roll {
       hasChangeDice = false
       hasMaxValue = false
       hasExplode = false
+      hasFavor = true
       options.rollTarget.value = 0
 
     } else if (options.rollType.includes("weapon-damage")) {
@@ -275,14 +286,12 @@ 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
       }
-      dice = dice.replace("E", "")
+      dice = dice.replace(/NE$/i, "").replace("E", "")
       baseFormula = dice
 
     } else if (options.rollType.includes("monster-damage")) {
@@ -295,6 +304,10 @@ export default class LethalFantasyRoll extends Roll {
       dice = options.rollTarget.damageDice
       dice = dice.replace("E", "")
       baseFormula = dice
+      if (options.rollTarget.noExplode) {
+        hasMaxValue = false
+        hasExplode = false
+      }
     }
 
 
@@ -304,8 +317,8 @@ export default class LethalFantasyRoll extends Roll {
       hasModifier = false
     }
 
-    const rollModes = foundry.utils.duplicate(CONFIG.Dice.rollModes); // v12 : Object.fromEntries(Object.entries(CONFIG.Dice.rollModes).map(([key, value]) => [key, game.i18n.localize(value)]))
-    console.log("Roll mode", rollModes)
+    const rollModes = foundry.utils.duplicate(CONFIG.ChatMessage.modes);
+
 
     const fieldRollMode = new foundry.data.fields.StringField({
       choices: rollModes,
@@ -320,6 +333,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,
@@ -342,9 +359,10 @@ export default class LethalFantasyRoll extends Roll {
       dice,
       hasTarget: options.hasTarget,
       modifier,
-      saveSpell: false,
+      saveSpell,
       favor: "none",
-      targetName
+      targetName,
+      isRangedAttack
     }
     let rollContext
     if (options.rollContext) {
@@ -354,7 +372,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}`
@@ -371,10 +391,12 @@ export default class LethalFantasyRoll extends Roll {
         position,
         buttons: [
           {
+            action: "roll",
+            type: "button",
             label: label,
             callback: (event, button, dialog) => {
-              console.log("Roll context", event, button, dialog)
-              let position = dialog.position
+              log("Roll context", event, button, dialog)
+              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
@@ -385,22 +407,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) {
@@ -416,7 +438,7 @@ export default class LethalFantasyRoll extends Roll {
 
     // If the user cancels the dialog, exit
     if (rollContext === null) return
-    console.log("rollContext", rollContext, hasGrantedDice)
+    log("rollContext", rollContext, hasGrantedDice)
     rollContext.saveSpell = saveSpell // Update fucking flag
 
     let fullModifier = 0
@@ -425,7 +447,7 @@ export default class LethalFantasyRoll extends Roll {
     if (hasModifier) {
       let bonus = Number(options.rollTarget.value)
       fullModifier = rollContext.modifier === "" ? 0 : parseInt(rollContext.modifier, 10) + bonus
-      fullModifier += (rollContext.saveSpell) ? options.rollTarget.actorModifiers.saveModifier : 0
+      fullModifier += (rollContext.saveSpell) ? (options.rollTarget.actorModifiers?.saveModifier ?? 0) : 0
       if (Number(rollContext.attackerAim) > 0) {
         fullModifier += Number(rollContext.attackerAim)
       }
@@ -490,7 +512,8 @@ export default class LethalFantasyRoll extends Roll {
       rollContext.favor = "none"
     }
 
-    maxValue = Number(baseFormula.match(/\d+$/)[0]) // Update the max value agains
+    const maxMatch = baseFormula ? baseFormula.match(/\d+$/) : null
+    maxValue = maxMatch ? Number(maxMatch[0]) : 0
 
     const rollData = {
       type: options.rollType,
@@ -503,8 +526,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,
@@ -534,7 +555,7 @@ export default class LethalFantasyRoll extends Roll {
     if (rollContext.favor === "favor") {
       rollFavor = new this(baseFormula, options.data, rollData)
       await rollFavor.evaluate()
-      console.log("Rolling with favor", rollFavor)
+      log("Rolling with favor", rollFavor)
       if (game?.dice3d) {
         game.dice3d.showForRoll(rollFavor, game.user, true)
       }
@@ -573,11 +594,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
+        options.rollTarget?.weapon,
+        { isRanged: isRangedForD30, isSpellSave: saveSpell }
       )
       options.D30message = d30Message
     }
@@ -596,9 +623,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)
@@ -641,6 +665,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.
@@ -654,11 +682,15 @@ export default class LethalFantasyRoll extends Roll {
     if (Hooks.call("fvtt-lethal-fantasy.Roll", options, rollData, rollBase) === false) return
 
     return rollBase
+    } finally {
+      // Clear one-shot flag so it doesn't leak to subsequent non-spell saves
+      if (game.lethalFantasy) game.lethalFantasy.spellDefense = false
+    }
   }
 
   /* ***********************************************************/
   static async promptInitiative(options = {}) {
-    const rollModes = foundry.utils.duplicate(CONFIG.Dice.rollModes); // v12 :  Object.fromEntries(Object.entries(CONFIG.Dice.rollModes).map(([key, value]) => [key, game.i18n.localize(value)]))
+    const rollModes = foundry.utils.duplicate(CONFIG.ChatMessage.modes); // v12 :  Object.fromEntries(Object.entries(CONFIG.Dice.rollModes).map(([key, value]) => [key, game.i18n.localize(value)]))
     const fieldRollMode = new foundry.data.fields.StringField({
       choices: rollModes,
       blank: false,
@@ -689,8 +721,10 @@ export default class LethalFantasyRoll extends Roll {
       content,
       buttons: [
         {
+          action: "initiative",
+          type: "button",
           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
@@ -712,7 +746,7 @@ export default class LethalFantasyRoll extends Roll {
 
     let initRoll = new Roll(formula, options.data)
     await initRoll.evaluate()
-    let msg = await initRoll.toMessage({ flavor: `Initiative for ${options.actorName}` }, { rollMode: rollContext.visibility })
+    let msg = await initRoll.toMessage({ flavor: `Initiative for ${options.actorName}` }, { messageMode: rollContext.visibility })
     if (game?.dice3d && initRoll.dice?.length) {
       await game.dice3d.waitFor3DAnimationByMessageID(msg.id)
     }
@@ -726,7 +760,7 @@ export default class LethalFantasyRoll extends Roll {
   /* ***********************************************************/
   static async promptCombatAction(options = {}) {
 
-    const rollModes = foundry.utils.duplicate(CONFIG.Dice.rollModes); // v12 : Object.fromEntries(Object.entries(CONFIG.Dice.rollModes).map(([key, value]) => [key, game.i18n.localize(value)]))
+    const rollModes = foundry.utils.duplicate(CONFIG.ChatMessage.modes); // v12 : Object.fromEntries(Object.entries(CONFIG.Dice.rollModes).map(([key, value]) => [key, game.i18n.localize(value)]))
     const fieldRollMode = new foundry.data.fields.StringField({
       choices: rollModes,
       blank: false,
@@ -755,10 +789,20 @@ 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) => {
+          type: "button",
+          label: weaponLabel,
+          callback: (event, button) => {
             let pos = $('#combat-action-dialog').position()
             game.user.setFlag(SYSTEM.id, "combat-action-dialog-pos", pos)
             return "rollProgressionDice"
@@ -783,8 +827,9 @@ export default class LethalFantasyRoll extends Roll {
         }
         buttons.push({
           action: "roll",
+          type: "button",
           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"
@@ -794,8 +839,9 @@ export default class LethalFantasyRoll extends Roll {
     } else {
       buttons.push({
         action: "roll",
+        type: "button",
         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) => {
@@ -809,8 +855,9 @@ export default class LethalFantasyRoll extends Roll {
     }
     buttons.push({
       action: "cancel",
+      type: "button",
       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;
@@ -827,12 +874,12 @@ export default class LethalFantasyRoll extends Roll {
       rejectClose: false // Click on Close button will not launch an error
     })
 
-    console.log("RollContext", dialogContext, rollContext)
+    log("RollContext", dialogContext, rollContext)
     // If action is cancelled, exit
     if (rollContext === null || rollContext === "cancel") {
       await combatant.setFlag(SYSTEM.id, "currentAction", "")
       let message = `${combatant.name} : Other action, progression reset`
-      ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+      await ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
       return
     }
 
@@ -862,12 +909,36 @@ 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,
+              type: "button",
+              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
       await combatant.setFlag(SYSTEM.id, "currentAction", actionItem)
       let message = `${combatant.name} action : ${selectedItem.name}, start rolling progression dice or casting time`
-      ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+      await ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
       rollContext = (actionItem.type === "weapon") ? "rollProgressionDice" : "rollLethargyDice" // Set the roll context to rollProgressionDice
       currentAction = actionItem
     }
@@ -878,13 +949,14 @@ export default class LethalFantasyRoll extends Roll {
           let time = currentAction.type === "spell" ? currentAction.system.castingTime : currentAction.system.prayerTime
           if (currentAction.castingTime < time) {
             let message = `Casting time : ${currentAction.name}, count : ${currentAction.castingTime}/${time}`
-            ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+            await ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
             currentAction.castingTime += 1
             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 !`
-            ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+            // 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 !`
+            await ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
             currentAction.castingTime = 1
             currentAction.spellStatus = "toBeCasted"
             await combatant.setFlag(SYSTEM.id, "currentAction", foundry.utils.duplicate(currentAction))
@@ -924,7 +996,7 @@ export default class LethalFantasyRoll extends Roll {
                 isLethargy: true
               }
             )
-            ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+            await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
             // Update the combatant progression count
             await combatant.setFlag(SYSTEM.id, "currentAction", "")
             // Display the action selection window again
@@ -944,7 +1016,7 @@ export default class LethalFantasyRoll extends Roll {
                 isLethargy: true
               }
             )
-            ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+            await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
           }
         }
       }
@@ -956,18 +1028,18 @@ export default class LethalFantasyRoll extends Roll {
           let split = toSplit.split("+")
           currentAction.rangedLoad = Number(split[0]) || 0
           formula = split[1]
-          console.log("Ranged Mode", currentAction.rangedMode, currentAction.rangedLoad, formula)
+          log("Ranged Mode", currentAction.rangedMode, currentAction.rangedLoad, formula)
         }
         // 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 }) })
+            await ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
             currentAction.progressionCount += 1
             await combatant.setFlag(SYSTEM.id, "currentAction", foundry.utils.duplicate(currentAction))
           } else {
             let message = `Ranged weapon ${currentAction.name} is loaded !`
-            ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+            await ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
             currentAction.weaponLoaded = true
             currentAction.progressionCount = 1
             await combatant.setFlag(SYSTEM.id, "currentAction", foundry.utils.duplicate(currentAction))
@@ -983,7 +1055,7 @@ export default class LethalFantasyRoll extends Roll {
 
         let max = roll.dice[0].faces - 1
         max = Math.min(currentAction.progressionCount, max)
-        let msg = await roll.toMessage({ flavor: `Progression Roll for ${currentAction.name}, progression count : ${currentAction.progressionCount}/${max}` }, { rollMode: rollContext.visibility })
+        let msg = await roll.toMessage({ flavor: `Progression Roll for ${currentAction.name}, progression count : ${currentAction.progressionCount}/${max}` }, { messageMode: rollContext.visibility })
         if (game?.dice3d) {
           await game.dice3d.waitFor3DAnimationByMessageID(msg.id)
         }
@@ -999,13 +1071,13 @@ export default class LethalFantasyRoll extends Roll {
               rollResult: roll.total
             }
           )
-          ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+          await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
           await combatant.setFlag(SYSTEM.id, "currentAction", "")
           combatant.actor.prepareRoll(currentAction.type === "weapon" ? "weapon-attack" : "spell-attack", currentAction._id)
         } else {
           // Notify that the player cannot act now with a chat message
           currentAction.progressionCount += 1
-          combatant.setFlag(SYSTEM.id, "currentAction", foundry.utils.duplicate(currentAction))
+          await combatant.setFlag(SYSTEM.id, "currentAction", foundry.utils.duplicate(currentAction))
           const messageContent = await foundry.applications.handlebars.renderTemplate(
             "systems/fvtt-lethal-fantasy/templates/progression-message.hbs",
             {
@@ -1016,7 +1088,7 @@ export default class LethalFantasyRoll extends Roll {
               progressionCount: currentAction.progressionCount
             }
           )
-          ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+          await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
         }
       }
     }
@@ -1025,7 +1097,7 @@ export default class LethalFantasyRoll extends Roll {
   /* ***********************************************************/
   static async promptRangedDefense(options = {}) {
 
-    const rollModes = foundry.utils.duplicate(CONFIG.Dice.rollModes);
+    const rollModes = foundry.utils.duplicate(CONFIG.ChatMessage.modes);
     const fieldRollMode = new foundry.data.fields.StringField({
       choices: rollModes,
       blank: false,
@@ -1056,8 +1128,10 @@ export default class LethalFantasyRoll extends Roll {
       content,
       buttons: [
         {
+          action: "rangeDefense",
+          type: "button",
           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
@@ -1072,7 +1146,7 @@ export default class LethalFantasyRoll extends Roll {
     // If the user cancels the dialog, exit
     if (rollContext === null) return
 
-    console.log("RollContext", rollContext)
+    log("RollContext", rollContext)
     // Add disfavor/favor option if point blank range
     if (rollContext.range === "pointblank") {
       rollContext.movement = rollContext.movement.replace("kh", "")
@@ -1106,6 +1180,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)
@@ -1113,7 +1189,7 @@ export default class LethalFantasyRoll extends Roll {
     await rollBase.evaluate()
     let rollD30 = await new Roll("1D30").evaluate()
     options.D30result = rollD30.total
-    options.D30message = D30Roll.getResult(rollD30.total, options.rollType, options.rollTarget?.weapon)
+    options.D30message = D30Roll.getResult(rollD30.total, options.rollType, options.rollTarget?.weapon, { isRanged: true })
 
     let badResult = 0
     if (rollContext.movement.includes("kh")) {
@@ -1173,6 +1249,163 @@ 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: [
+        {
+          action: "rangedAttack",
+          type: "button",
+          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.
    *
@@ -1193,10 +1426,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":
@@ -1213,7 +1444,7 @@ export default class LethalFantasyRoll extends Roll {
   /** @override */
   async render(chatOptions = {}) {
     let chatData = await this._getChatCardData(chatOptions.isPrivate)
-    console.log("ChatData", chatData)
+    log("ChatData", chatData)
     return await foundry.applications.handlebars.renderTemplate(this.constructor.CHAT_TEMPLATE, chatData)
   }
 
@@ -1251,16 +1482,15 @@ export default class LethalFantasyRoll extends Roll {
 
     // Récupérer les informations de l'arme pour les attaques réussies
     let weaponDamageOptions = null
-    console.log("Roll type:", this.type, "rollTarget:", this.rollTarget, "Has weapon:", !!this.rollTarget?.weapon)
+    log("Roll type:", this.type, "rollTarget:", this.rollTarget, "Has weapon:", !!this.rollTarget?.weapon)
     if (this.type === "weapon-attack" && this.rollTarget?.weapon) {
       const weapon = this.rollTarget.weapon
       weaponDamageOptions = {
-        weaponId: weapon._id || weapon.id,
+        weaponId: weapon.id,
         weaponName: weapon.name,
-        damageS: weapon.system?.damage?.damageS,
         damageM: weapon.system?.damage?.damageM
       }
-      console.log("Weapon damage options:", weaponDamageOptions)
+      log("Weapon damage options:", weaponDamageOptions)
     } else if (this.type === "monster-attack" && this.rollTarget) {
       weaponDamageOptions = {
         weaponId: this.rollTarget.rollKey,
@@ -1269,7 +1499,7 @@ export default class LethalFantasyRoll extends Roll {
         damageModifier: this.rollTarget.damageModifier,
         isMonster: true
       }
-      console.log("Monster damage options:", weaponDamageOptions)
+      log("Monster damage options:", weaponDamageOptions)
     }
 
     const cardData = {
@@ -1314,11 +1544,11 @@ export default class LethalFantasyRoll extends Roll {
    *
    * @param {Object} [messageData={}] Additional data to include in the message.
    * @param {Object} options Options for message creation.
-   * @param {string} options.rollMode The mode of the roll (e.g., public, private).
+   * @param {string} options.messageMode The mode of the roll (e.g., public, private).
    * @param {boolean} [options.create=true] Whether to create the message.
    * @returns {Promise} - A promise that resolves when the message is created.
    */
-  async toMessage(messageData = {}, { rollMode, create = true } = {}) {
+  async toMessage(messageData = {}, { messageMode, create = true } = {}) {
     return await super.toMessage(
       {
         isSave: this.isSave,
@@ -1336,8 +1566,46 @@ export default class LethalFantasyRoll extends Roll {
         rollData: this.rollData,
         ...messageData,
       },
-      { rollMode, create },
+      { messageMode, create },
     )
   }
 
+  /**
+   * 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()
+  }
+
 }

module/macros.mjs

@@ -32,20 +32,20 @@ export class Macros {
           dropData.rollType === "save"
             ? `game.actors.get('${dropData.actorId}').system.roll('${dropData.rollType}', '${dropData.rollTarget}', '=');`
             : `game.actors.get('${dropData.actorId}').system.roll('${dropData.rollType}', '${dropData.rollTarget}');`
-        const rollName = `${game.i18n.localize("TENEBRIS.Label.jet")} ${game.i18n.localize(`TENEBRIS.Manager.${dropData.rollTarget}`)}`
+        const rollName = `${game.i18n.localize("LETHALFANTASY.Label.jet")} ${game.i18n.localize(`LETHALFANTASY.Label.${dropData.rollTarget}`)}`
         this.createMacro(slot, rollName, rollCommand, "icons/svg/d20-grey.svg")
         break
 
       case "rollDamage":
         const weapon = game.actors.get(dropData.actorId).items.get(dropData.rollTarget)
         const rollDamageCommand = `game.actors.get('${dropData.actorId}').system.roll('${dropData.rollType}', '${dropData.rollTarget}');`
-        const rollDamageName = `${game.i18n.localize("TENEBRIS.Label.jet")} ${weapon.name}`
+        const rollDamageName = `${game.i18n.localize("LETHALFANTASY.Label.jet")} ${weapon.name}`
         this.createMacro(slot, rollDamageName, rollDamageCommand, weapon.img)
         break
 
       case "rollAttack":
         const rollAttackCommand = `game.actors.get('${dropData.actorId}').system.roll('${dropData.rollValue}', '${dropData.rollTarget}');`
-        const rollAttackName = `${game.i18n.localize("TENEBRIS.Label.jet")} ${dropData.rollTarget}`
+        const rollAttackName = `${game.i18n.localize("LETHALFANTASY.Label.jet")} ${dropData.rollTarget}`
         this.createMacro(slot, rollAttackName, rollAttackCommand, "icons/svg/d20-grey.svg")
         break
 
@@ -57,7 +57,7 @@ export class Macros {
 
   /**
    * Create a macro
-   * All macros are flaged with a tenebris.macro flag at true
+   * All macros are flaged with a lethalFantasy.macro flag at true
    * @param {*} slot
    * @param {*} name
    * @param {*} command
@@ -72,7 +72,7 @@ export class Macros {
           type: "script",
           img: img,
           command: command,
-          flags: { "tenebris.macro": true },
+          flags: { "lethalFantasy.macro": true },
         },
         { displaySheet: false },
       )

module/models/character.mjs

@@ -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), {
@@ -152,6 +152,7 @@ export default class LethalFantasyCharacter extends foundry.abstract.TypeDataMod
       attackModifier: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
       rangedAttackModifier: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
       defenseModifier: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      rangedDefenseModifier: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
       defenseBonus: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
       damageModifier: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
       armorHitPoints: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
@@ -259,6 +260,12 @@ export default class LethalFantasyCharacter extends foundry.abstract.TypeDataMod
       this.combat.defenseModifier += chaDef.defense
     }
 
+    this.combat.rangedDefenseModifier = this.combat.defenseBonus
+    for (let chaKey of SYSTEM.CHARACTERISTIC_RANGED_DEFENSE) {
+      let chaDef = SYSTEM.CHARACTERISTICS_TABLES[chaKey].find(s => s.value === this.characteristics[chaKey].value)
+      this.combat.rangedDefenseModifier += chaDef.defense
+    }
+
     this.combat.damageModifier = 0
     for (let chaKey of SYSTEM.CHARACTERISTIC_DAMAGE) {
       let chaDef = SYSTEM.CHARACTERISTICS_TABLES[chaKey].find(s => s.value === this.characteristics[chaKey].value)
@@ -274,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,
@@ -286,11 +293,15 @@ 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
 
-    await roll.toMessage({}, { rollMode: roll.options.rollMode })
+    await roll.toMessage({}, { messageMode: roll.options.rollMode })
   }
 
   async rollInitiative(combatId = undefined, combatantId = undefined) {
@@ -311,7 +322,7 @@ export default class LethalFantasyCharacter extends foundry.abstract.TypeDataMod
     })
     if (!roll) return null
 
-    await roll.toMessage({}, { rollMode: roll.options.rollMode })
+    await roll.toMessage({}, { messageMode: roll.options.rollMode })
   }
 
   async rollProgressionDice(combatId, combatantId, rollProgressionCount) {
@@ -349,6 +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,

module/models/miracle.mjs

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

module/models/monster.mjs

@@ -56,15 +56,33 @@ 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 })
     })
 
-    const attackField = (label) => {
+    const attackField = (label, initialNoExplode = false) => {
       const schema = {
         key: new fields.StringField({ required: true, nullable: false, initial: `attack${label}` }),
         name: new fields.StringField({ required: true, nullable: false, initial: `Attack ${label}` }),
@@ -74,6 +92,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
         damageDice: new fields.StringField({ required: true, nullable: false, initial: "1D6" }),
         damageModifier: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
         enabled: new fields.BooleanField({ initial: true, required: true, nullable: false }),
+        noExplode: new fields.BooleanField({ initial: initialNoExplode, required: true, nullable: false }),
       }
       return new fields.SchemaField(schema, { label })
     }
@@ -123,8 +142,8 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
       shieldDefenseDice: new fields.StringField({ required: true, nullable: false, initial: "d4" })
     })
     schema.combatHTH = new fields.SchemaField({
-      attack1: attackField("1"),
-      attack2: attackField("2")
+      attack1: attackField("1", true),
+      attack2: attackField("2", true)
     })
 
     schema.attackMode = new fields.StringField({
@@ -141,6 +160,15 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
       attack4: attackField("4")
     })
 
+    schema.rangedWeaponRange = new fields.SchemaField({
+      pointBlank: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
+      short: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
+      medium: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
+      long: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
+      extreme: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
+      outOfSkill: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
+    })
+
     return schema
   }
 
@@ -154,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,
@@ -166,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({}, { rollMode: roll.options.rollMode })
+    await roll.toMessage({}, { messageMode: roll.options.rollMode })
   }
 
-  async prepareMonsterRoll(rollType, rollKey, rollDice = undefined, tokenId = undefined, damageModifier = undefined, defenderId = undefined, defenderTokenId = undefined, extraShieldDr = 0) {
+  async prepareMonsterRoll(rollType, rollKey, rollDice = undefined, tokenId = undefined, damageModifier = undefined, defenderId = undefined, defenderTokenId = undefined, extraShieldDr = 0, d30Effects = {}) {
     let rollTarget
     switch (rollType) {
       case "monster-attack":
@@ -182,6 +230,10 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
         const attacksSet = this.attackMode === "ranged" ? this.rangedAttacks : this.attacks
         rollTarget = foundry.utils.duplicate(attacksSet[rollKey])
         rollTarget.rollKey = rollKey
+        rollTarget.attackMode = this.attackMode
+        if (rollType === "monster-defense") {
+          rollTarget.isRangedDefense = game.lethalFantasy?.nextDefenseData?.isRanged ?? false
+        }
         // Si damageModifier est fourni (depuis le chat), l'utiliser au lieu de celui de la fiche
         if (damageModifier !== undefined && rollType === "monster-damage") {
           rollTarget.damageModifier = damageModifier
@@ -219,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)
@@ -256,7 +307,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
           return
         }
         rollTarget = skill
-        rollTarget.weapon = weapon
+        rollTarget.weapon = foundry.utils.duplicate(weapon)
         rollTarget.weaponSkillModifier = skill.weaponSkillModifier
         rollTarget.rollKey = rollKey
         rollTarget.combat = foundry.utils.duplicate(this.combat)
@@ -270,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)
     }
   }
 
@@ -291,7 +341,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
     })
     if (!roll) return null
 
-    await roll.toMessage({}, { rollMode: roll.options.rollMode })
+    await roll.toMessage({}, { messageMode: roll.options.rollMode })
   }
 
   async rollProgressionDice(combatId, combatantId) {
@@ -303,7 +353,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
       return
     }
 
-    const rollModes = foundry.utils.duplicate(CONFIG.Dice.rollModes)
+    const rollModes = foundry.utils.duplicate(CONFIG.ChatMessage.modes)
     const fieldRollMode = new foundry.data.fields.StringField({
       choices: rollModes,
       blank: false,
@@ -333,7 +383,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
             rollResult: roll.total
           }
         )
-        ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
+        await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
         let token = combatant?.token
         this.prepareMonsterRoll("monster-attack", key, undefined, token?.id)
         if (token?.object) {
@@ -357,7 +407,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
               rollResult: roll.total
             }
           )
-          ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
+          await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
           let token = combatant?.token
           this.prepareMonsterRoll("monster-attack-hth", key, undefined, token?.id)
           if (token?.object) {
@@ -376,7 +426,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
           rollResult: roll.total
         }
       )
-      ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
+      await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
     }
 
   }

module/models/spell.mjs

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

module/models/weapon.mjs

@@ -1,6 +1,7 @@
 import { SYSTEM } from "../config/system.mjs"
+import { WEAPON_TYPE } from "../config/weapon.mjs"
 
-export default class LethalFantasySkill extends foundry.abstract.TypeDataModel {
+export default class LethalFantasyWeapon extends foundry.abstract.TypeDataModel {
   static defineSchema() {
     const fields = foundry.data.fields
     const schema = {}
@@ -45,9 +46,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 })
@@ -62,7 +63,7 @@ export default class LethalFantasySkill extends foundry.abstract.TypeDataModel {
   static LOCALIZATION_PREFIXES = ["LETHALFANTASY.Weapon"]
 
   get weaponCategory() {
-    return game.i18n.localize(CATEGORY[this.weaponType].label)
+    return game.i18n.localize(WEAPON_TYPE[this.weaponType] || this.weaponType)
   }
 
 }

module/utils.mjs

@@ -1,8 +1,9 @@
 import { SYSTEM } from "./config/system.mjs"
 
-// Map temporaire pour stocker les données d'attaque en attente de défense
-if (!globalThis.pendingDefenses) {
-  globalThis.pendingDefenses = new Map()
+export function log(...args) {
+  if (game?.settings?.get(game.system.id, "debug")) {
+    console.log(...args)
+  }
 }
 
 export default class LethalFantasyUtils {
@@ -27,7 +28,12 @@ export default class LethalFantasyUtils {
   /* -------------------------------------------- */
   static setHookListeners() {
 
-    Hooks.on('renderTokenHUD', async (hud, html, token) => {
+    Hooks.on('renderTokenHUD', async (hud, html, data) => {
+      if (html.querySelector(".lethal-hp-loss-hud")) return
+      // The token/actor is on the HUD application instance, not the third param.
+      // hud.token / hud.object gives the Token (PlaceableObject), which has .actor.
+      const hudActor = hud.token?.actor ?? hud.object?.actor
+      if (!hudActor) return
       // HP Loss Button (existing)
       const lossHPButton = await foundry.applications.handlebars.renderTemplate('systems/fvtt-lethal-fantasy/templates/loss-hp-hud.hbs', {})
       $(html).find('div.left').append(lossHPButton);
@@ -50,21 +56,16 @@ export default class LethalFantasyUtils {
           $(html).find('.hp-loss-wrap')[2].classList.add('hp-loss-hud-disabled');
         }
       })
-      $(html).find('.loss-hp-hud-click').click((event) => {
+      $(html).find('.loss-hp-hud-click').click(async (event) => {
         event.preventDefault();
         let hpLoss = event.currentTarget.dataset.hpValue;
-        if (token) {
-          let tokenFull = canvas.tokens.placeables.find(t => t.id === token._id);
-          console.log(tokenFull, token)
-          let actor = tokenFull.actor;
-          actor.applyDamage(Number(hpLoss));
+        await hudActor.applyDamage(Number(hpLoss));
           $(html).find('.hp-loss-wrap')[0].classList.remove('hp-loss-hud-active');
           $(html).find('.hp-loss-wrap')[0].classList.add('hp-loss-hud-disabled');
           $(html).find('.hp-loss-wrap')[1].classList.remove('hp-loss-hud-active');
           $(html).find('.hp-loss-wrap')[1].classList.add('hp-loss-hud-disabled');
           $(html).find('.hp-loss-wrap')[2].classList.remove('hp-loss-hud-active');
           $(html).find('.hp-loss-wrap')[2].classList.add('hp-loss-hud-disabled');
-        }
       })
 
       // HP Gain Button (new)
@@ -89,28 +90,59 @@ export default class LethalFantasyUtils {
           $(html).find('.hp-gain-wrap')[2].classList.add('hp-gain-hud-disabled');
         }
       })
-      $(html).find('.gain-hp-hud-click').click((event) => {
+      $(html).find('.gain-hp-hud-click').click(async (event) => {
         event.preventDefault();
         let hpGain = event.currentTarget.dataset.hpValue;
-        if (token) {
-          let tokenFull = canvas.tokens.placeables.find(t => t.id === token._id);
-          console.log(tokenFull, token)
-          let actor = tokenFull.actor;
-          actor.applyDamage(Number(hpGain)); // Positive value to add HP
+        await hudActor.applyDamage(Number(hpGain)); // Positive value to add HP
+          // Clear bleeding wounds on heal — regardless of heal amount, any
+          // healing is enough to stop bleeding (field dressing / magic / rest).
+          const wounds = foundry.utils.duplicate(hudActor.system.hp.wounds || [])
+          const hadBleeding = wounds.some(w => w.description === "Bleeding")
+          if (hadBleeding) {
+            await hudActor.update({
+              "system.hp.wounds": wounds.map(w =>
+                w.description === "Bleeding" ? { value: 0, duration: 0 } : w
+              )
+            })
+          }
           $(html).find('.hp-gain-wrap')[0].classList.remove('hp-gain-hud-active');
           $(html).find('.hp-gain-wrap')[0].classList.add('hp-gain-hud-disabled');
           $(html).find('.hp-gain-wrap')[1].classList.remove('hp-gain-hud-active');
           $(html).find('.hp-gain-wrap')[1].classList.add('hp-gain-hud-disabled');
           $(html).find('.hp-gain-wrap')[2].classList.remove('hp-gain-hud-active');
           $(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(async (event) => {
+        event.preventDefault();
+        const resource = event.currentTarget.dataset.resource;
+        const amount = Number(event.currentTarget.dataset.amount);
+        const current = Number(foundry.utils.getProperty(hudActor.system, `${resource}.current`)) || 0;
+        const newValue = Math.max(0, current + amount);
+        await hudActor.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');
+      })
     })
   }
 
   /* -------------------------------------------- */
-  static handleSocketEvent(msg = {}) {
-    console.log(`handleSocketEvent !`, msg)
+  static async handleSocketEvent(msg = {}) {
+    log(`handleSocketEvent !`, msg)
     let actor
     switch (msg.type) {
       case "applyDamage":
@@ -120,18 +152,18 @@ export default class LethalFantasyUtils {
             ? canvas.tokens?.placeables?.find(t => t.id === msg.tokenId)?.actor
             : (game.combat?.combatants?.find(c => c.actorId === msg.actorId)?.actor
               ?? game.actors.get(msg.actorId))
-          if (actor) actor.applyDamage(msg.damage)
+          if (actor) await actor.applyDamage(msg.damage)
         }
         break
       case "rollInitiative":
         if (msg.userId && msg.userId !== game.user.id) break
         actor = game.actors.get(msg.actorId)
-        actor.system.rollInitiative(msg.combatId, msg.combatantId)
+        await actor.system.rollInitiative(msg.combatId, msg.combatantId)
         break
       case "rollProgressionDice":
         if (msg.userId && msg.userId !== game.user.id) break
         actor = game.actors.get(msg.actorId)
-        actor.system.rollProgressionDice(msg.combatId, msg.combatantId, msg.rollProgressionCount)
+        await actor.system.rollProgressionDice(msg.combatId, msg.combatantId, msg.rollProgressionCount)
         break
       case "requestDefense":
         // Vérifier si le message est destiné à cet utilisateur
@@ -145,6 +177,26 @@ 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" }
+              await actor.update({ "system.hp.wounds": wounds })
+            }
+          }
+        }
+        break
+      case "attackBoosted":
+        if (msg.userId === game.user.id) {
+          LethalFantasyUtils.handleAttackBoosted(msg)
+        }
+        break
     }
   }
 
@@ -182,6 +234,225 @@ export default class LethalFantasyUtils {
     })
   }
 
+  /* -------------------------------------------- */
+  static async handleAttackBoosted(msg) {
+    const {
+      attackerName, attackerId, defenderName, defenderId, defenderTokenId,
+      attackerHandledBonus, attackRollFinal, defenseRoll, attackWeaponId, attackRollType, attackRollKey,
+      shieldDamageReduction: initialShieldDR,
+      d30Bleed, d30DamageMultiplier, d30DrMultiplier,
+      damageTier, attackD30message, defenseD30message,
+      hasShield, shieldLabel, shieldFormula, shieldDr, canAdHocShield
+    } = msg
+
+    const defender = game.actors.get(defenderId)
+    if (!defender) return
+
+    let updatedDefenseRoll = defenseRoll
+    let shieldBlocked = false
+    let shieldReaction = null
+    let canShieldReact = hasShield
+    let canAdHoc = canAdHocShield
+
+    // ── D30 bonus dice (defense) — resolved before grit/luck/shield ───────
+    let defenseDrMultiplier = null
+    if (defenseD30message && defender) {
+      const d30Result = await LethalFantasyUtils.processD30BonusDice(defenseD30message, "defense", null, defender, true)
+      if (d30Result.modifier) {
+        updatedDefenseRoll += d30Result.modifier
+        if (d30Result.modifier > 0) {
+          await ChatMessage.create({
+            content: `<p><strong>${defenderName}</strong> gains <strong>+${d30Result.modifier}</strong> from D30 bonus die for defense.</p>`,
+            speaker: ChatMessage.getSpeaker({ actor: defender })
+          })
+        }
+      }
+      if (d30Result.specialEffect === "auto") {
+        updatedDefenseRoll = attackRollFinal + 1
+        await ChatMessage.create({
+          content: `<p><strong>${defenderName}</strong> uses <strong>${d30Result.specialName || "Special Defense"}</strong> from D30 — defense automatically succeeds!</p>`,
+          speaker: ChatMessage.getSpeaker({ actor: defender })
+        })
+      }
+      if (d30Result.specialEffect === "flag") {
+        await ChatMessage.create({
+          content: `<p>D30 — <strong>${d30Result.specialName || "Special Effect"}</strong> triggered for ${defenderName}!</p>`,
+          speaker: ChatMessage.getSpeaker({ actor: defender })
+        })
+      }
+      if (d30Result.specialEffect === "drMultiplier") {
+        defenseDrMultiplier = d30Result.multiplier
+        await ChatMessage.create({
+          content: `<p>D30 — Defense grants <strong>x${d30Result.multiplier} DR</strong> (choose which DR types to multiply when damage is applied)</p>`,
+          speaker: ChatMessage.getSpeaker({ actor: defender })
+        })
+      }
+    }
+
+    // Show the defense reaction dialog — while-loop for multiple reactions
+    if (defender) {
+      while (updatedDefenseRoll < attackRollFinal) {
+        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",
+            type: "button",
+            label: `Spend 1 Grit (+1D6) [${currentGrit} left]`,
+            icon: "fa-solid fa-fist-raised",
+            callback: () => "grit"
+          })
+        }
+
+        if (currentLuck > 0) {
+          buttons.push({
+            action: "luck",
+            type: "button",
+            label: `Spend 1 Luck (+1D6) [${currentLuck} left]`,
+            icon: "fa-solid fa-clover",
+            callback: () => "luck"
+          })
+        }
+
+        buttons.push({
+          action: "bonusDie",
+          type: "button",
+          label: "Add bonus die",
+          icon: "fa-solid fa-dice",
+          callback: () => "bonusDie"
+        })
+
+        if (canShieldReact) {
+          buttons.push({
+            action: "shieldReact",
+            type: "button",
+            label: `Roll shield (${shieldLabel})`,
+            icon: "fa-solid fa-shield",
+            callback: () => "shieldReact"
+          })
+        } else if (canAdHoc) {
+          buttons.push({
+            action: "adHocShield",
+            type: "button",
+            label: "Roll ad-hoc shield (choose dice + DR)",
+            icon: "fa-solid fa-shield-halved",
+            callback: () => "adHocShield"
+          })
+        }
+
+        buttons.push({
+          action: "continue",
+          type: "button",
+          label: "Continue (no defense bonus)",
+          icon: "fa-solid fa-forward",
+          callback: () => "continue"
+        })
+
+        const choice = await foundry.applications.api.DialogV2.wait({
+          window: { title: "Defense reactions — attack boosted" },
+          classes: ["lethalfantasy"],
+          content: `
+            <div class="grit-luck-dialog">
+              <div class="combat-status">
+                <p><strong>${attackerName}</strong> boosted attack to <strong>${attackRollFinal}</strong></p>
+                <p><strong>${defenderName}</strong> currently has <strong>${updatedDefenseRoll}</strong></p>
+              </div>
+              <p class="offer-text">The attack was boosted! Choose how to improve the defense.</p>
+            </div>
+          `,
+          buttons,
+          rejectClose: false
+        })
+
+        if (!choice || choice === "continue") break
+
+        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>`)
+          updatedDefenseRoll += bonusRoll
+          await defender.update({ "system.grit.current": currentGrit - 1 })
+        } else 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>`)
+          updatedDefenseRoll += bonusRoll
+          await defender.update({ "system.luck.current": currentLuck - 1 })
+        } else if (choice === "bonusDie") {
+          const bonusDie = await LethalFantasyUtils.promptCombatBonusDie(defenderName, "attack", updatedDefenseRoll, attackRollFinal)
+          if (bonusDie) {
+            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>`)
+            updatedDefenseRoll += bonusRoll
+          }
+        } else if (choice === "shieldReact" && canShieldReact) {
+          const shieldBonus = await LethalFantasyUtils.rollBonusDie(shieldFormula, defender)
+          const newDefenseTotal = updatedDefenseRoll + shieldBonus
+          updatedDefenseRoll = newDefenseTotal
+          canShieldReact = false
+          if (newDefenseTotal >= attackRollFinal) {
+            shieldBlocked = true
+            shieldReaction = { damageReduction: shieldDr, label: shieldLabel, bonus: shieldBonus }
+            await ChatMessage.create({
+              content: `<p><strong>${defenderName}</strong> rolls <strong>${shieldLabel}</strong> and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} ≥ ${attackRollFinal}). <strong>Shield blocked the attack!</strong> Both armor DR and shield DR <strong>${shieldDr}</strong> will apply to damage.</p>`,
+              speaker: ChatMessage.getSpeaker({ actor: defender })
+            })
+          } else {
+            await ChatMessage.create({
+              content: `<p><strong>${defenderName}</strong> rolls <strong>${shieldLabel}</strong> and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} < ${attackRollFinal}). Shield did not block — normal hit, armor DR only.</p>`,
+              speaker: ChatMessage.getSpeaker({ actor: defender })
+            })
+          }
+        } else if (choice === "adHocShield" && canAdHoc) {
+          const adHoc = await LethalFantasyUtils.promptAdHocShield(defenderName, attackRollFinal, updatedDefenseRoll)
+          if (adHoc) {
+            const shieldBonus = await LethalFantasyUtils.rollBonusDie(adHoc.formula, defender)
+            const newDefenseTotal = updatedDefenseRoll + shieldBonus
+            updatedDefenseRoll = newDefenseTotal
+            canShieldReact = false
+            canAdHoc = false
+            if (newDefenseTotal >= attackRollFinal) {
+              shieldBlocked = true
+              shieldReaction = { damageReduction: adHoc.damageReduction, label: `${adHoc.formula.toUpperCase()} shield`, bonus: shieldBonus }
+              await ChatMessage.create({
+                content: `<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>`,
+                speaker: ChatMessage.getSpeaker({ actor: defender })
+              })
+            } else {
+              await ChatMessage.create({
+                content: `<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>`,
+                speaker: ChatMessage.getSpeaker({ actor: defender })
+              })
+            }
+          }
+        }
+      }
+    }
+
+    const finalShieldDR = shieldBlocked ? (shieldReaction?.damageReduction || 0) : 0
+    const outcome = shieldBlocked ? "shielded-hit" : (updatedDefenseRoll >= attackRollFinal ? "miss" : "hit")
+
+    await LethalFantasyUtils.compareAttackDefense({
+      attackerName,
+      attackerId,
+      attackRoll: attackRollFinal,
+      attackWeaponId,
+      attackRollType,
+      attackRollKey,
+      defenderName,
+      defenderId,
+      defenderTokenId,
+      defenseRoll: updatedDefenseRoll,
+      outcome,
+      shieldDamageReduction: finalShieldDR,
+      d30Bleed: d30Bleed || "",
+      d30DamageMultiplier: d30DamageMultiplier || 1,
+      d30DrMultiplier: (d30DrMultiplier != null && d30DrMultiplier !== 1) ? d30DrMultiplier : (defenseDrMultiplier ?? d30DrMultiplier ?? 1),
+      damageTier: damageTier || "standard",
+      attackD30message
+    })
+  }
+
   /* -------------------------------------------- */
   static async showDefenseRequest(msg) {
     const attackerName = msg.attackerName
@@ -235,7 +506,7 @@ export default class LethalFantasyUtils {
 
     const isMonster = defender.type === "monster"
 
-    console.log(`[LF] showDefenseRequest | attackRollType=${attackRollType} isMonster=${isMonster} defender=${defender?.name}`)
+    log(`[LF] showDefenseRequest | attackRollType=${attackRollType} isMonster=${isMonster} defender=${defender?.name}`)
 
     // Spell/miracle attacks use saving throws instead of weapon defense
     const isSpellAttack = attackRollType === "spell-attack" || attackRollType === "miracle-attack"
@@ -269,6 +540,7 @@ export default class LethalFantasyUtils {
         buttons: [
           {
             action: "rollSave",
+            type: "button",
             label: "Roll Save",
             icon: "fa-solid fa-person-running",
             callback: (event, button) => button.form.elements.saveKey.value,
@@ -279,6 +551,7 @@ export default class LethalFantasyUtils {
 
       if (result) {
         game.lethalFantasy = game.lethalFantasy || {}
+        game.lethalFantasy.spellDefense = true // pré-cocher "Save against spell" dans le dialog
         game.lethalFantasy.nextDefenseData = {
           attackerId,
           attackRoll,
@@ -290,13 +563,15 @@ export default class LethalFantasyUtils {
           attackD30result,
           attackD30message,
           attackRerollContext,
+          attackNaturalRoll: msg.attackNaturalRoll,
+          damageTier: msg.damageTier,
           defenderId: defender.id,
           defenderTokenId
         }
         if (isMonster) {
-          defender.system.prepareMonsterRoll("save", result)
+          await defender.system.prepareMonsterRoll("save", result)
         } else {
-          defender.prepareRoll("save", result)
+          await defender.prepareRoll("save", result)
         }
       }
       return
@@ -324,7 +599,7 @@ export default class LethalFantasyUtils {
             <p>Attack roll: <strong>${attackRoll}</strong></p>
           </div>
           <div class="weapon-selection">
-            <label for="defense-attack">Choose your defense attack:</label>
+            <label for="defense-attack">Choose your defense weapon:</label>
             <select id="defense-attack" name="attackKey" style="width: 100%; margin-top: 8px;">
               ${attacksHTML}
             </select>
@@ -334,11 +609,13 @@ export default class LethalFantasyUtils {
 
       // Afficher le dialogue
       const result = await foundry.applications.api.DialogV2.wait({
-        window: { title: "Defense Roll" },
+        window: { title: msg.isRanged ? "Ranged Defense Roll" : "Defense Roll" },
         classes: ["lethalfantasy"],
         content,
         buttons: [
           {
+            action: "rangeDefense",
+            type: "button",
             label: "Roll Defense",
             icon: "fa-solid fa-shield",
             callback: (event, button, dialog) => {
@@ -365,11 +642,46 @@ export default class LethalFantasyUtils {
           attackD30result,
           attackD30message,
           attackRerollContext,
+          attackNaturalRoll: msg.attackNaturalRoll,
+          damageTier: msg.damageTier,
           defenderId: defender.id,
-          defenderTokenId
+          defenderTokenId,
+          isRanged: msg.isRanged
         }
 
-        defender.system.prepareMonsterRoll("monster-defense", result)
+        await defender.system.prepareMonsterRoll("monster-defense", result)
+      }
+      return
+    }
+
+    // Pour les personnages, récupérer les armes équipées
+    // Si l'attaque est une attaque à distance, utiliser le dialogue de défense à distance
+    if (msg.isRanged) {
+      const { default: LethalFantasyRoll } = await import("./documents/roll.mjs")
+      const roll = await LethalFantasyRoll.promptRangedDefense({
+        actorId: defender.id,
+        actorName: defender.name,
+        actorImage: defender.img,
+      })
+      if (roll) {
+        game.lethalFantasy = game.lethalFantasy || {}
+        game.lethalFantasy.nextDefenseData = {
+          attackerId,
+          attackRoll,
+          attackerName,
+          defenderName,
+          attackWeaponId,
+          attackRollType,
+          attackRollKey,
+          attackD30result,
+          attackD30message,
+          attackRerollContext,
+          damageTier: msg.damageTier,
+          defenderId: defender.id,
+          defenderTokenId,
+          isRanged: true
+        }
+        await roll.toMessage({}, { messageMode: roll.options.rollMode })
       }
       return
     }
@@ -411,6 +723,8 @@ export default class LethalFantasyUtils {
       content,
       buttons: [
         {
+          action: "defenseRoll",
+          type: "button",
           label: "Roll Defense",
           icon: "fa-solid fa-shield",
           callback: (event, button, dialog) => {
@@ -435,15 +749,18 @@ export default class LethalFantasyUtils {
         attackRollType,
         attackRollKey,
         attackD30result,
-        attackD30message,
-        attackRerollContext,
-        defenderId: defender.id,
-        defenderTokenId
+          attackD30message,
+          attackRerollContext,
+          attackNaturalRoll: msg.attackNaturalRoll,
+          damageTier: msg.damageTier,
+          defenderId: defender.id,
+        defenderTokenId,
+        isRanged: msg.isRanged
       }
 
-      console.log("Storing defense data for character:", defender.id)
+      log("Storing defense data for character:", defender.id)
 
-      defender.prepareRoll("weapon-defense", result)
+      await defender.prepareRoll("weapon-defense", result)
     }
   }
 
@@ -452,6 +769,190 @@ 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") {
+      // If we can't show dialogs (wrong client), skip — the primary client
+      // will communicate its choice result via socket. Auto-rolling here
+      // would give a different modifier on each client, causing divergence.
+      if (!canDialog) {
+        return { modifier: 0, specialEffect: null, specialName: null }
+      }
+
+      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,
+          type: "button",
+          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"]
@@ -509,6 +1010,7 @@ export default class LethalFantasyUtils {
       buttons: [
         {
           action: "roll",
+          type: "button",
           label: "Roll Bonus Die",
           icon: "fa-solid fa-dice",
           callback: (event, button) => {
@@ -518,6 +1020,7 @@ export default class LethalFantasyUtils {
         },
         {
           action: "cancel",
+          type: "button",
           label: "Cancel",
           icon: "fa-solid fa-xmark",
           callback: () => null
@@ -565,6 +1068,7 @@ export default class LethalFantasyUtils {
       buttons: [
         {
           action: "roll",
+          type: "button",
           label: "Roll Shield",
           icon: "fa-solid fa-shield",
           callback: (event, button) => {
@@ -578,6 +1082,7 @@ export default class LethalFantasyUtils {
         },
         {
           action: "cancel",
+          type: "button",
           label: "Cancel",
           icon: "fa-solid fa-xmark",
           callback: () => null
@@ -648,6 +1153,7 @@ export default class LethalFantasyUtils {
       if (currentGrit > 0) {
         buttons.push({
           action: "grit",
+          type: "button",
           label: `Spend 1 Grit (+1D6) [${currentGrit} left]`,
           icon: "fa-solid fa-fist-raised",
           callback: () => "grit"
@@ -657,6 +1163,7 @@ export default class LethalFantasyUtils {
       if (currentLuck > 0) {
         buttons.push({
           action: "luck",
+          type: "button",
           label: `Spend 1 Luck (+1D6) [${currentLuck} left]`,
           icon: "fa-solid fa-clover",
           callback: () => "luck"
@@ -665,6 +1172,7 @@ export default class LethalFantasyUtils {
 
       buttons.push({
         action: "continue",
+        type: "button",
         label: "Continue (no bonus)",
         icon: "fa-solid fa-forward",
         callback: () => "continue"
@@ -678,6 +1186,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>
       `
 
@@ -739,12 +1248,14 @@ export default class LethalFantasyUtils {
       const buttons = [
         {
           action: "grit",
+          type: "button",
           label: `Spend 1 Grit (+1D6) [${currentGrit} left]`,
           icon: "fa-solid fa-fist-raised",
           callback: () => "grit"
         },
         {
           action: "continue",
+          type: "button",
           label: "Continue (no bonus)",
           icon: "fa-solid fa-forward",
           callback: () => "continue"
@@ -798,51 +1309,70 @@ export default class LethalFantasyUtils {
 
   /* -------------------------------------------- */
   static async compareAttackDefense(data) {
-    console.log("compareAttackDefense called with:", data)
+    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)
+    log("isAttackWin:", isAttackWin, "attackRoll:", data.attackRoll, "defenseRoll:", data.defenseRoll)
 
     let damageButton = ""
     if (isAttackWin && (data.attackWeaponId || data.attackRollKey)) {
-      console.log("Creating damage button. defenderId:", data.defenderId)
+      log("Creating damage button. defenderId:", data.defenderId)
       // 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>`
         }
       }
     }
@@ -869,22 +1399,22 @@ 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}
       </div>
     `
 
-    console.log("Creating combat result message...")
+    log("Creating combat result message...")
     await ChatMessage.create({
       content: resultMessage,
       speaker: { alias: "Combat System" }
     })
-    console.log("Combat result message created!")
+    log("Combat result message created!")
   }
 
   static registerHandlebarsHelpers() {
@@ -1021,7 +1551,7 @@ export default class LethalFantasyUtils {
       return eval(expr);
     })
     Handlebars.registerHelper('isOwnerOrGM', function (actor) {
-      console.log("Testing actor", actor.isOwner, game.userId)
+      log("Testing actor", actor.isOwner, game.userId)
       return actor.isOwner || game.isGM;
     })
     Handlebars.registerHelper('upperCase', function (text) {
@@ -1059,25 +1589,32 @@ export default class LethalFantasyUtils {
   static async applyDamage(message, event) {
     // Récupérer les données du message
     let combatantId = event.currentTarget.dataset.combatantId
-    if (!combatantId || !game.combat) {
+    if (!combatantId) {
       ui.notifications.error("No combatant selected")
       return
     }
 
-    let combatant = game.combat.combatants.get(combatantId)
-    if (!combatant) {
-      ui.notifications.error("Combatant not found")
-      return
+    // Try to find the target: first as a combat combatant, then as a scene token
+    let targetActor = null
+    if (game.combat) {
+      const combatant = game.combat.combatants.get(combatantId)
+      if (combatant) {
+        targetActor = combatant.token?.actor || game.actors.get(combatant.actorId)
+      }
+    }
+    if (!targetActor) {
+      // Fall back to scene token lookup (non-combat tokens use tokenId as their combatantId)
+      const token = canvas.tokens?.placeables?.find(t => t.id === combatantId)
+      targetActor = token?.actor
     }
-
-    let targetActor = combatant.token?.actor || game.actors.get(combatant.actorId)
     if (!targetActor) {
       ui.notifications.error("Target actor not found")
       return
     }
 
     // Récupérer les données de dégâts du message
-    let damageTotal = message.rolls[0]?.total || 0
+    // Use options.rollTotal (includes weapon modifier bonus) rather than roll.total (dice formula only)
+    let damageTotal = message.rolls[0]?.options?.rollTotal ?? message.rolls[0]?.total ?? 0
     let weaponName = message.rolls[0]?.options?.rollName || "Unknown Weapon"
 
     // Calculer les DR
@@ -1109,21 +1646,25 @@ export default class LethalFantasyUtils {
       buttons: [
         {
           action: "noDR",
+          type: "button",
           label: "No DR",
           callback: () => ({ drType: "none", damage: damageTotal })
         },
         {
           action: "armorDR",
+          type: "button",
           label: "With Armor DR",
           callback: () => ({ drType: "armor", damage: Math.max(0, damageTotal - armorDR) })
         },
         {
           action: "allDR",
+          type: "button",
           label: "With Armor + Shield DR",
           callback: () => ({ drType: "all", damage: Math.max(0, damageTotal - totalDR) })
         },
         {
           action: "cancel",
+          type: "button",
           label: "Cancel",
           callback: () => null
         }
@@ -1152,10 +1693,10 @@ export default class LethalFantasyUtils {
         }
       )
 
-      ChatMessage.create({
+      await ChatMessage.create({
         user: game.user.id,
         speaker: { alias: targetActor.name },
-        rollMode: "gmroll",
+        mode: "gm",
         content: messageContent
       })
     }

packs-system/lf-equipment/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000579

packs-system/lf-equipment/LOG

@@ -1,8 +0,0 @@
-2026/04/30-14:38:06.808992 7f3f35bff6c0 Recovering log #577
-2026/04/30-14:38:06.818757 7f3f35bff6c0 Delete type=3 #575
-2026/04/30-14:38:06.818831 7f3f35bff6c0 Delete type=0 #577
-2026/04/30-14:38:35.518816 7f3ee77fe6c0 Level-0 table #582: started
-2026/04/30-14:38:35.518836 7f3ee77fe6c0 Level-0 table #582: 0 bytes OK
-2026/04/30-14:38:35.525869 7f3ee77fe6c0 Delete type=0 #580
-2026/04/30-14:38:35.538258 7f3ee77fe6c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
-2026/04/30-14:38:35.538288 7f3ee77fe6c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)

packs-system/lf-equipment/LOG.old

@@ -1,8 +0,0 @@
-2026/04/29-20:13:54.005832 7fed937fe6c0 Recovering log #573
-2026/04/29-20:13:54.016172 7fed937fe6c0 Delete type=3 #571
-2026/04/29-20:13:54.016279 7fed937fe6c0 Delete type=0 #573
-2026/04/29-20:27:06.418200 7feb10fff6c0 Level-0 table #578: started
-2026/04/29-20:27:06.418231 7feb10fff6c0 Level-0 table #578: 0 bytes OK
-2026/04/29-20:27:06.424568 7feb10fff6c0 Delete type=0 #576
-2026/04/29-20:27:06.431809 7feb10fff6c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
-2026/04/29-20:27:06.431871 7feb10fff6c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)

packs-system/lf-gifts/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000576

packs-system/lf-gifts/LOG

@@ -1,8 +0,0 @@
-2026/04/30-14:38:06.823818 7f3f353fe6c0 Recovering log #574
-2026/04/30-14:38:06.834104 7f3f353fe6c0 Delete type=3 #572
-2026/04/30-14:38:06.834187 7f3f353fe6c0 Delete type=0 #574
-2026/04/30-14:38:35.525993 7f3ee77fe6c0 Level-0 table #579: started
-2026/04/30-14:38:35.526019 7f3ee77fe6c0 Level-0 table #579: 0 bytes OK
-2026/04/30-14:38:35.532067 7f3ee77fe6c0 Delete type=0 #577
-2026/04/30-14:38:35.538267 7f3ee77fe6c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
-2026/04/30-14:38:35.538302 7f3ee77fe6c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)

packs-system/lf-gifts/LOG.old

@@ -1,8 +0,0 @@
-2026/04/29-20:13:54.023030 7fed93fff6c0 Recovering log #570
-2026/04/29-20:13:54.032615 7fed93fff6c0 Delete type=3 #568
-2026/04/29-20:13:54.032677 7fed93fff6c0 Delete type=0 #570
-2026/04/29-20:27:06.286266 7feb10fff6c0 Level-0 table #575: started
-2026/04/29-20:27:06.286286 7feb10fff6c0 Level-0 table #575: 0 bytes OK
-2026/04/29-20:27:06.292048 7feb10fff6c0 Delete type=0 #573
-2026/04/29-20:27:06.299186 7feb10fff6c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
-2026/04/29-20:27:06.299236 7feb10fff6c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)

packs-system/lf-skills/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000581

packs-system/lf-skills/LOG

@@ -1,8 +0,0 @@
-2026/04/30-14:38:06.795186 7f3f353fe6c0 Recovering log #579
-2026/04/30-14:38:06.805935 7f3f353fe6c0 Delete type=3 #577
-2026/04/30-14:38:06.805994 7f3f353fe6c0 Delete type=0 #579
-2026/04/30-14:38:35.512680 7f3ee77fe6c0 Level-0 table #584: started
-2026/04/30-14:38:35.512729 7f3ee77fe6c0 Level-0 table #584: 0 bytes OK
-2026/04/30-14:38:35.518704 7f3ee77fe6c0 Delete type=0 #582
-2026/04/30-14:38:35.538247 7f3ee77fe6c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
-2026/04/30-14:38:35.538281 7f3ee77fe6c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)

packs-system/lf-skills/LOG.old

@@ -1,8 +0,0 @@
-2026/04/29-20:13:53.990808 7fed927fc6c0 Recovering log #575
-2026/04/29-20:13:54.001559 7fed927fc6c0 Delete type=3 #573
-2026/04/29-20:13:54.001699 7fed927fc6c0 Delete type=0 #575
-2026/04/29-20:27:06.273802 7feb10fff6c0 Level-0 table #580: started
-2026/04/29-20:27:06.273877 7feb10fff6c0 Level-0 table #580: 0 bytes OK
-2026/04/29-20:27:06.280252 7feb10fff6c0 Delete type=0 #578
-2026/04/29-20:27:06.299161 7feb10fff6c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
-2026/04/29-20:27:06.299217 7feb10fff6c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)

packs-system/lf-spells-miracles/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000276

packs-system/lf-spells-miracles/LOG

@@ -1,8 +0,0 @@
-2026/04/30-14:38:06.849252 7f3f353fe6c0 Recovering log #274
-2026/04/30-14:38:06.859072 7f3f353fe6c0 Delete type=3 #272
-2026/04/30-14:38:06.859126 7f3f353fe6c0 Delete type=0 #274
-2026/04/30-14:38:35.538433 7f3ee77fe6c0 Level-0 table #279: started
-2026/04/30-14:38:35.538452 7f3ee77fe6c0 Level-0 table #279: 0 bytes OK
-2026/04/30-14:38:35.544715 7f3ee77fe6c0 Delete type=0 #277
-2026/04/30-14:38:35.567736 7f3ee77fe6c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
-2026/04/30-14:38:35.567785 7f3ee77fe6c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)

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

@@ -1,8 +0,0 @@
-2026/04/29-20:13:54.051682 7fed937fe6c0 Recovering log #270
-2026/04/29-20:13:54.062010 7fed937fe6c0 Delete type=3 #268
-2026/04/29-20:13:54.062071 7fed937fe6c0 Delete type=0 #270
-2026/04/29-20:27:06.292128 7feb10fff6c0 Level-0 table #275: started
-2026/04/29-20:27:06.292152 7feb10fff6c0 Level-0 table #275: 0 bytes OK
-2026/04/29-20:27:06.299041 7feb10fff6c0 Delete type=0 #273
-2026/04/29-20:27:06.299199 7feb10fff6c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
-2026/04/29-20:27:06.299226 7feb10fff6c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)

packs-system/lf-vulnerabilities/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000575

packs-system/lf-vulnerabilities/LOG

@@ -1,8 +0,0 @@
-2026/04/30-14:38:06.836968 7f3ee7fff6c0 Recovering log #573
-2026/04/30-14:38:06.846980 7f3ee7fff6c0 Delete type=3 #571
-2026/04/30-14:38:06.847050 7f3ee7fff6c0 Delete type=0 #573
-2026/04/30-14:38:35.532186 7f3ee77fe6c0 Level-0 table #578: started
-2026/04/30-14:38:35.532209 7f3ee77fe6c0 Level-0 table #578: 0 bytes OK
-2026/04/30-14:38:35.538132 7f3ee77fe6c0 Delete type=0 #576
-2026/04/30-14:38:35.538276 7f3ee77fe6c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
-2026/04/30-14:38:35.538295 7f3ee77fe6c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)

packs-system/lf-vulnerabilities/LOG.old

@@ -1,8 +0,0 @@
-2026/04/29-20:13:54.036694 7fed92ffd6c0 Recovering log #569
-2026/04/29-20:13:54.047834 7fed92ffd6c0 Delete type=3 #567
-2026/04/29-20:13:54.047922 7fed92ffd6c0 Delete type=0 #569
-2026/04/29-20:27:06.280338 7feb10fff6c0 Level-0 table #574: started
-2026/04/29-20:27:06.280357 7feb10fff6c0 Level-0 table #574: 0 bytes OK
-2026/04/29-20:27:06.286179 7feb10fff6c0 Delete type=0 #572
-2026/04/29-20:27:06.299174 7feb10fff6c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
-2026/04/29-20:27:06.299209 7feb10fff6c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)

styles/character.less

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

styles/chat.less

@@ -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);
       }
     }
   }

styles/hud.less

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

styles/monster.less

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

styles/roll.less

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

templates/character-biography.hbs

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

templates/character-combat.hbs

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

templates/character-miracles.hbs

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

templates/character-spells.hbs

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

templates/chat-message.hbs

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

templates/combat-tracker-footer-v2.hbs

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

templates/luck-grit-hud.hbs

@@ -0,0 +1,16 @@
+<div class="control-icon lethal-luck-grit-hud" 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>

templates/miracle.hbs

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

templates/monster-biography.hbs

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

templates/monster-combat.hbs

@@ -51,6 +51,9 @@
         <div class="numeric">
           <input type="number" name="system.attacks.{{item.key}}.damageModifier" value="{{item.damageModifier}}" data-tooltip="Damage modifier"/>
         </div>
+        <div class="">
+          <input type="checkbox" name="system.attacks.{{item.key}}.noExplode" {{checked item.noExplode}} data-tooltip="No exploding dice on damage" />
+        </div>
 
         <div class="attack-icons">
 
@@ -98,6 +101,9 @@
         <div class="numeric">
           <input type="number" name="system.rangedAttacks.{{item.key}}.damageModifier" value="{{item.damageModifier}}" data-tooltip="Damage modifier"/>
         </div>
+        <div class="">
+          <input type="checkbox" name="system.rangedAttacks.{{item.key}}.noExplode" {{checked item.noExplode}} data-tooltip="No exploding dice on damage" />
+        </div>
 
         <div class="attack-icons">
 
@@ -119,12 +125,42 @@
 
       </div>
       {{/each}}
+
+      <div class="ranged-weapon-range">
+        <label>{{localize "LETHALFANTASY.Label.range"}}</label>
+        <div class="range-fields">
+          <div class="range-field">
+            <label>{{localize "LETHALFANTASY.Label.pointBlank"}}</label>
+            <input type="number" name="system.rangedWeaponRange.pointBlank" value="{{system.rangedWeaponRange.pointBlank}}" />
+          </div>
+          <div class="range-field">
+            <label>{{localize "LETHALFANTASY.Label.short"}}</label>
+            <input type="number" name="system.rangedWeaponRange.short" value="{{system.rangedWeaponRange.short}}" />
+          </div>
+          <div class="range-field">
+            <label>{{localize "LETHALFANTASY.Label.medium"}}</label>
+            <input type="number" name="system.rangedWeaponRange.medium" value="{{system.rangedWeaponRange.medium}}" />
+          </div>
+          <div class="range-field">
+            <label>{{localize "LETHALFANTASY.Label.long"}}</label>
+            <input type="number" name="system.rangedWeaponRange.long" value="{{system.rangedWeaponRange.long}}" />
+          </div>
+          <div class="range-field">
+            <label>{{localize "LETHALFANTASY.Label.extreme"}}</label>
+            <input type="number" name="system.rangedWeaponRange.extreme" value="{{system.rangedWeaponRange.extreme}}" />
+          </div>
+          <div class="range-field">
+            <label>{{localize "LETHALFANTASY.Label.outOfSkill"}}</label>
+            <input type="number" name="system.rangedWeaponRange.outOfSkill" value="{{system.rangedWeaponRange.outOfSkill}}" />
+          </div>
+        </div>
+      </div>
     </div>
     {{/if}}
   </fieldset>
 
   <fieldset>
-    <legend>Hand To Hand Attacks</legend>
+    <legend>{{localize "LETHALFANTASY.Label.handToHandAttacks"}}</legend>
     <div class="attacks">
       {{#each system.combatHTH as |item key|}}
       <div class="attack" data-attack-key="{{key}}" >
@@ -149,6 +185,9 @@
         <div class="numeric">
           <input type="number" name="system.combatHTH.{{item.key}}.damageModifier" value="{{item.damageModifier}}" data-tooltip="Damage modifier"/>
         </div>
+        <div class="">
+          <input type="checkbox" name="system.combatHTH.{{item.key}}.noExplode" {{checked item.noExplode}} data-tooltip="No exploding dice on damage" />
+        </div>
 
         <div class="attack-icons">
 

templates/range-attack-dialog.hbs

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

templates/roll-dialog.hbs

@@ -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,16 @@
       </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"
+            {{#if saveSpell}}checked{{/if}}
+          />
+        </div>
       {{/if}}
     </fieldSet>
   {{/if}}

templates/shield.hbs

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

templates/spell.hbs

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

templates/weapon.hbs

@@ -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=(localize "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}}

tools/pullYMLtoLDB.mjs

@@ -0,0 +1,2 @@
+import { CompendiumsManager } from './CompendiumsManager.mjs';
+CompendiumsManager.packToDistDir('packs_src', 'packs-system');

tools/pushLDBtoYML.mjs

@@ -0,0 +1,2 @@
+import { CompendiumsManager } from './CompendiumsManager.mjs';
+CompendiumsManager.unpackToSrcDir('packs_src', 'packs-system');