Fix spell rolls again

.gitea/workflows/release.yaml

@@ -8,45 +8,56 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - run: echo "💡 The ${{ gitea.repository }} repository will cloned to the runner."
+      - run: echo "💡 The ${{ gitea.repository }} repository will cloned to the runner."
 
-    #- uses: actions/checkout@v3
-    - uses: RouxAntoine/checkout@v3.5.4
+      #- uses: actions/checkout@v3
+      - uses: RouxAntoine/checkout@v3.5.4
 
-    # get part of the tag after the `v`
-    - name: Extract tag version number
-      id: get_version
-      uses: battila7/get-version-action@v2
+      # get part of the tag after the `v`
+      - name: Extract tag version number
+        id: get_version
+        uses: battila7/get-version-action@v2
 
-    # Substitute the Manifest and Download URLs in the module.json
-    - name: Substitute Manifest and Download Links For Versioned Ones
-      id: sub_manifest_link_version
-      uses: microsoft/variable-substitution@v1
-      with:
-        files: 'system.json'
-      env:
-        version: ${{steps.get_version.outputs.version-without-v}}
-        url: https://www.uberwald.me/gitea/${{gitea.repository}}
-        manifest: https://www.uberwald.me/gitea/public/${{gitea.repository}}/releases/download/latest/system.json
-        download: https://www.uberwald.me/gitea/${{gitea.repository}}/releases/download/${{github.event.release.tag_name}}/fvtt-lethal-fantasy-${{github.event.release.tag_name}}.zip
+      # Substitute the Manifest and Download URLs in the module.json
+      - name: Substitute Manifest and Download Links For Versioned Ones
+        id: sub_manifest_link_version
+        uses: microsoft/variable-substitution@v1
+        with:
+          files: "system.json"
+        env:
+          version: ${{steps.get_version.outputs.version-without-v}}
+          url: https://www.uberwald.me/gitea/${{gitea.repository}}
+          manifest: https://www.uberwald.me/gitea/public/${{gitea.repository}}/releases/download/latest/system.json
+          download: https://www.uberwald.me/gitea/${{gitea.repository}}/releases/download/${{github.event.release.tag_name}}/fvtt-lethal-fantasy-${{github.event.release.tag_name}}.zip
 
-    # Create a zip file with all files required by the module to add to the release
-    - run: |
-         apt update -y
-         apt install -y zip
+      # Create a zip file with all files required by the module to add to the release
+      - run: |
+          apt update -y
+          apt install -y zip
 
-    - run: zip -r ./fvtt-lethal-fantasy-${{github.event.release.tag_name}}.zip system.json README.md LICENSE assets/ css/ lang/ module/ packs-system/ templates/ lethal-fantasy.mjs
+      - run: zip -r ./fvtt-lethal-fantasy-${{github.event.release.tag_name}}.zip system.json README.md LICENSE assets/ css/ lang/ module/ packs-system/ templates/ lethal-fantasy.mjs
 
-    - name: setup go
-      uses: https://github.com/actions/setup-go@v4
-      with:
-        go-version: '>=1.20.1'
+      - name: setup go
+        uses: https://github.com/actions/setup-go@v4
+        with:
+          go-version: ">=1.20.1"
 
-    - name: Use Go Action  
-      id: use-go-action
-      uses: https://gitea.com/actions/release-action@main
-      with:
-        files: |-
-          ./fvtt-lethal-fantasy-${{github.event.release.tag_name}}.zip
-          system.json
-        api_key: '${{secrets.ALLOW_PUSH_RELEASE}}'
+      - name: Use Go Action
+        id: use-go-action
+        uses: https://gitea.com/actions/release-action@main
+        with:
+          files: |-
+            ./fvtt-lethal-fantasy-${{github.event.release.tag_name}}.zip
+            system.json
+          api_key: "${{secrets.ALLOW_PUSH_RELEASE}}"
+
+      - name: Publish to Foundry server
+        uses: djlechuck/foundryvtt-publish-package-action@v1
+        with:
+          token: ${{ secrets.FOUNDRY_PUBLISH_KEY }}
+          id: "fvtt-lethal-fantasy"
+          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: "14"
+          compatibility-verified: "14"

.gitignore

@@ -7,4 +7,5 @@ styles/*.css
 node_modules/
 
 .history
+.github/
 

CLAUDE.md

@@ -0,0 +1,62 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with this repository.
+
+## Overview
+
+FoundryVTT v13+ game system for the **Lethal Fantasy RPG**. Entry point: `lethal-fantasy.mjs`.
+
+## Commands
+
+```bash
+# Compile LESS styles (styles/ -> css/)
+npx gulp css          # one-shot
+npx gulp              # compile + watch
+
+# Lint
+npx eslint .
+
+# Compendium pack management (LevelDB <-> YAML source)
+npm run pushLDBtoYML   # export packs-system/ LevelDB -> source YAML
+npm run pullYMLtoLDB   # import source YAML -> packs-system/ LevelDB
+```
+
+No test suite exists.
+
+## Architecture
+
+Four layers in `module/`, all wired in `lethal-fantasy.mjs` via the `init` hook:
+
+| Layer | Path | Purpose |
+|---|---|---|
+| Config | `module/config/` | Game constants. `SYSTEM` is `globalThis.SYSTEM` — always use `SYSTEM.*` for enumerations. |
+| Models | `module/models/` | `TypeDataModel` subclasses — data schemas per document type. |
+| Documents | `module/documents/` | Actor/Item/Roll/ChatMessage subclasses — game logic, roll processing, hooks. |
+| Applications | `module/applications/` | `ApplicationV2` sheets + custom combat tracker. |
+
+**Actor types**: `character`, `monster`
+**Item types**: `skill`, `gift`, `vulnerability`, `weapon`, `armor`, `shield`, `spell`, `miracle`, `equipment`
+
+Each layer has an `_module.mjs` barrel file that re-exports all classes from that layer.
+
+Templates (`.hbs`) live in `templates/`. Styles are authored in LESS under `styles/` and compiled to `css/`.
+
+### Key Patterns
+
+- **Sheets**: Extend `HandlebarsApplicationMixin(foundry.applications.sheets.ActorSheetV2)` — imported from `foundry.applications.api`. **Not** the legacy `ActorSheet`. Child sheets (e.g. `character-sheet.mjs`) extend `base-actor-sheet.mjs` and override `static PARTS` and `DEFAULT_OPTIONS.actions`. Template paths are prefixed `systems/fvtt-lethal-fantasy/templates/`. Actor sheets have a play/edit toggle via `_sheetMode` and `SHEET_MODES`.
+- **Models**: `static defineSchema()` using `foundry.data.fields.*`. Field definitions derived from SYSTEM config objects.
+- **Rolls**: `LethalFantasyRoll` extends `Roll` with rich metadata via `this.options`. `D30Roll` is a separate class for D30 result tables (initialized in the `ready` hook).
+- **Socket**: Events use `game.socket.on(\`system.${SYSTEM.id}\`, ...)`. Multi-player attack-defense uses a global `pendingDefenses` Map.
+- **i18n**: All user-visible strings are keys in `lang/en.json` as `LETHALFANTASY.Category.Key`. Always use `game.i18n.localize(key)`.
+
+### Compendium Packs
+
+Five LevelDB packs in `packs-system/`: skills, equipment, gifts, vulnerabilities, spells-miracles. Use the `tools/` scripts to export/import editable YAML.
+
+## Code Style
+
+- No semicolons, double quotes, 2-space indent
+- JSDoc `/** */` required on all functions/classes
+- Max line length 180 (strings/templates exempt)
+- Arrow functions: omit parens for single param
+- ESLint + Prettier config in `eslint.config.mjs`

assets/icons/broken-heart.svg

@@ -1 +1,7 @@
-<svg style="height: 512px; width: 512px;" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><g class="" style="" transform="translate(0,0)"><path d="M373.47 25.5c-33.475-.064-67.614 13.444-94.44 43.156l37.22 145.156-33.437.032 35.343 132.093-116.718-188.375 50.03 5.375L202.5 47.312C120.437-1.43 4.756 40.396 8.5 158.156c4.402 138.44 191.196 184.6 247.406 331.625 59.376-147.035 251.26-184.33 246.656-331.624-2.564-82.042-64.6-132.532-129.093-132.656z" fill="#fff" fill-opacity="1"></path></g></svg>
+<svg style="height: 512px; width: 512px;" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512">
+  <g class="" style="" transform="translate(0,0)">
+    <path
+      d="M373.47 25.5c-33.475-.064-67.614 13.444-94.44 43.156l37.22 145.156-33.437.032 35.343 132.093-116.718-188.375 50.03 5.375L202.5 47.312C120.437-1.43 4.756 40.396 8.5 158.156c4.402 138.44 191.196 184.6 247.406 331.625 59.376-147.035 251.26-184.33 246.656-331.624-2.564-82.042-64.6-132.532-129.093-132.656z"
+      fill="#dc2626" fill-opacity="1"></path>
+  </g>
+</svg>

assets/icons/health-increase.svg

@@ -0,0 +1,10 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor"
+  stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <!-- Heart shape -->
+  <path
+    d="M20.84 4.61a5.5 5.5 0 0 0-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 0 0-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 0 0 0-7.78z"
+    fill="#4ade80" stroke="#22c55e" />
+  <!-- Plus sign inside heart -->
+  <line x1="12" y1="8" x2="12" y2="14" stroke="#ffffff" stroke-width="2.5" />
+  <line x1="9" y1="11" x2="15" y2="11" stroke="#ffffff" stroke-width="2.5" />
+</svg>

changelog.md

@@ -0,0 +1,5 @@
+## v13.0.12
+
+- Fix favor/disfavor
+- Fix granted dice
+- Cosmetic fixes

lang/en.json

@@ -1,8 +1,8 @@
 {
   "COMBAT": {
-    "Round":        "Second {round}",
-    "Rounds":       "Seconds",
-    "RoundNext":    "Next second"
+    "Round": "Second {round}",
+    "Rounds": "Seconds",
+    "RoundNext": "Next second"
   },
   "LETHALFANTASY": {
     "Armor": {
@@ -152,6 +152,57 @@
         "wis": {
           "label": "Wisdom"
         }
+      },
+      "agility": {
+        "label": "Agility"
+      },
+      "app": {
+        "label": "Appearance"
+      },
+      "cha": {
+        "label": "Charisma"
+      },
+      "con": {
+        "label": "Constitution"
+      },
+      "contagion": {
+        "label": "Contagion Save"
+      },
+      "dex": {
+        "label": "Dexterity"
+      },
+      "dodge": {
+        "label": "Dodge Save"
+      },
+      "dying": {
+        "label": "Dying Challenge"
+      },
+      "int": {
+        "label": "Intelligence"
+      },
+      "luc": {
+        "label": "Luck"
+      },
+      "pain": {
+        "label": "Pain Save"
+      },
+      "painCourage": {
+        "label": "Pain/Courage Save"
+      },
+      "poison": {
+        "label": "Poison Save"
+      },
+      "str": {
+        "label": "Strength"
+      },
+      "toughness": {
+        "label": "Toughness Save"
+      },
+      "will": {
+        "label": "Willpower Save"
+      },
+      "wis": {
+        "label": "Wisdom"
       }
     },
     "Monster": {
@@ -250,6 +301,21 @@
         "wis": {
           "label": "Wisdom"
         }
+      },
+      "perception": {
+        "label": "Perception"
+      },
+      "resistIntimidation": {
+        "label": "Resist Intimidation"
+      },
+      "resistPerformance": {
+        "label": "Resist Performance"
+      },
+      "resistTorture": {
+        "label": "Resist Torture"
+      },
+      "stealth": {
+        "label": "Stealth"
       }
     },
     "Delete": "Delete",
@@ -282,6 +348,9 @@
     },
     "Label": {
       "agility": "Dexterity",
+      "applyDamage": "Apply damage to:",
+      "selectTarget": "Select target for attack:",
+      "rollDamage": "Roll Damage",
       "gotoToken": "Go to token",
       "combatAction": "Combat action",
       "currentAction": "Current ongoing action",
@@ -291,31 +360,36 @@
       "miracle-power": "Miracle - Power",
       "miracle-attack": "Miracle - Attack",
       "spell": "Spell",
-      "will":"Will",
-      "dodge":"Dodge",
-      "toughness":"Toughness",
-      "contagion":"Contagion",
-      "poison":"Poison",
-      "pain":"Pain",
-      "paincourage":"Pain/Courage",
+      "will": "Will",
+      "dodge": "Dodge",
+      "toughness": "Toughness",
+      "contagion": "Contagion",
+      "poison": "Poison",
+      "pain": "Pain",
+      "paincourage": "Pain/Courage",
       "granted": "Granted Dice",
       "shields": "Shields",
       "armorHitPoints": "Armor hit points",
       "grantedAttackDice": "Granted attack",
       "grantedDamageDice": "Granted damage",
       "grantedDefenseDice": "Granted defense",
-      "damageResistance": "Damage resistance",
+      "damageResistance": "DR",
       "damageResistanceShort": "DR",
+      "shieldDamageReduction": "Shield DR",
+      "shieldDefenseDice": "Shield dice",
       "stealth": "Stealth",
       "progressionDice": "Progression/Lethargy dice",
       "rollProgressionCount": "Roll progression count",
       "rollProgressionDice": "Roll progression/Lethargy dice",
       "earned": "Earned",
-      "divinityPoints": "Divinity points",
+      "divinityPoints": "Grace",
       "aetherPoints": "Aether points",
       "attacks": "Attacks",
+      "attackMode": "Attack Mode",
+      "meleeModeLabel": "Melee (8 attacks)",
+      "rangedModeLabel": "Ranged (4 attacks)",
       "monster": "Monster",
-      "Resist" :"Resist",
+      "Resist": "Resist",
       "resist": "Resist",
       "resistTorture": "Resist torture",
       "resistPerformance": "Resist performance",
@@ -388,8 +462,17 @@
       "notes": "Notes",
       "pc": "PC",
       "perception": "Perception",
+      "pointBlank": "Point blank",
+      "short": "Short",
+      "medium": "Medium",
+      "long": "Long",
+      "extreme": "Extreme",
+      "outOfSkill": "Out of skill",
+      "range": "Range",
       "rangeDefenseDialog": "Ranged defense dialog",
       "rangeDefenseRoll": "Ranged defense roll",
+      "rangeAttackDialog": "Ranged attack dialog",
+      "rangeAttackRoll": "Ranged attack roll",
       "rangedAttackDefense": "Ranged attack defense",
       "resource": "Resource",
       "resources": "Resources",
@@ -421,7 +504,45 @@
       "monster-damage": "Monster damage",
       "monster-defense": "Monster defense",
       "weapons": "Weapons",
-      "wis": "WIS"
+      "wis": "WIS",
+      "weapon-damage-medium": "Weapon damage medium",
+      "weapon-damage-small": "Weapon damage small",
+      "combatProgressionStart": "Combat start threshold",
+      "miracle": "Miracle",
+      "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": {
@@ -477,6 +598,15 @@
         },
         "savingThrow": {
           "label": "Saving throw"
+        },
+        "damageDiceOverpowered": {
+          "label": "Overpowered Damage Dice"
+        },
+        "damageDiceOverpowered2": {
+          "label": "Overpowered 2 Damage Dice"
+        },
+        "damageDice": {
+          "label": "Damage Dice"
         }
       }
     },
@@ -511,7 +641,9 @@
       "save": "Save roll {save}",
       "success": "Success",
       "visibility": "Visibility",
-      "favorDisfavor": "Favor/Disfavor"
+      "favorDisfavor": "Favor/Disfavor",
+      "displayArmor": "Target: {targetName} — Armor DR: {targetArmor} — Damage: {realDamage}",
+      "resourceLost": "Resource spent"
     },
     "Save": {
       "FIELDS": {
@@ -553,7 +685,7 @@
             "label": "Min"
           }
         },
-        "damagereduction": {
+        "damageReduction": {
           "label": "Damage reduction"
         },
         "defense": {
@@ -596,7 +728,8 @@
             "label": "Min"
           }
         }
-      }
+      },
+      "autoDestruction": "Auto-Destruction"
     },
     "Skill": {
       "Category": {
@@ -653,6 +786,9 @@
         "weaponClass": {
           "label": "Class"
         }
+      },
+      "error": {
+        "weaponBonus": "Weapon bonus exceeds the allowed maximum (skill total / 10)"
       }
     },
     "Spell": {
@@ -715,14 +851,35 @@
         },
         "catalyst": {
           "label": "Catalyst"
+        },
+        "damageDice": {
+          "label": "Damage dice"
+        },
+        "damageDiceOverpowered": {
+          "label": "Overpowered Damage Dice"
+        },
+        "damageDiceOverpowered2": {
+          "label": "Overpowered 2 Damage Dice"
         }
+      },
+      "Range": {
+        "contact": "Contact",
+        "distant": "Distant",
+        "loin": "Far",
+        "na": "N/A",
+        "proche": "Close"
       }
     },
     "ToggleSheet": "Toggle mode",
     "Tooltip": {
       "addEquipment": "New equipment",
       "addSpell": "New spells",
-      "skill": "Skills list"
+      "skill": "Skills list",
+      "combatProgressionStart": "First attack of combat can succeed on a roll of 1 through this value. Resets to 1 for subsequent attacks.",
+      "addMiracle": "Add Miracle",
+      "gifts": "Gifts list",
+      "skills": "Skills list",
+      "vulnerabilities": "Vulnerabilities list"
     },
     "Vulnerability": {
       "FIELDS": {
@@ -737,7 +894,9 @@
         }
       }
     },
-    "Warning": {},
+    "Warning": {
+      "defenseShieldOrder": "To avoid a hit without using the shield, roll Grit or Luck first — then roll the shield."
+    },
     "Weapon": {
       "FIELDS": {
         "isAgile": {
@@ -856,6 +1015,62 @@
         "melee": "Melee",
         "ranged": "Ranged"
       }
+    },
+    "Dialog": {
+      "applyDamageTo": "Apply damage to",
+      "weapon": "Weapon",
+      "totalDamage": "Total Damage",
+      "damageReduction": "Damage Reduction",
+      "armorDR": "Armor DR",
+      "shieldDR": "Shield DR",
+      "totalDR": "Total DR",
+      "selectOption": "Select damage application option",
+      "noDR": "No DR",
+      "withArmor": "With Armor DR only",
+      "withAll": "With Armor + Shield DR",
+      "damage": "damage"
+    },
+    "DamageApplied": {
+      "subtitle": "suffered damage",
+      "damageDealt": "Damage dealt",
+      "from": "from"
+    },
+    "ProgressionMessage": {
+      "canAct": "ready to act!",
+      "cannotAct": "cannot act this second",
+      "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",
+      "EssentialKit": "Essential Kit",
+      "FoodDrink": "Food & Drink",
+      "LandTransport": "Land Transport",
+      "Light": "Light",
+      "LoadBearing": "Load Bearing",
+      "Misc": "Miscellaneous",
+      "Mount": "Mount",
+      "Music": "Music",
+      "Sleeping": "Sleeping",
+      "WaterTransport": "Water Transport"
+    },
+    "DiceTray": {
+      "CountTitle": "Number of dice",
+      "ExplodeTitle": "Exploding dice — re-roll on maximum value",
+      "ChatTitle": "Free Roll"
     }
   },
   "TYPES": {

lethal-fantasy.mjs

@@ -110,6 +110,9 @@ function preLocalizeConfig() {
 Hooks.once("ready", function () {
   console.info("LETHAL FANTASY | Ready")
 
+  // Initialiser la table des résultats D30
+  documents.D30Roll.initialize()
+
   if (!SYSTEM.DEV_MODE) {
     registerWorldCount("lethalFantasy")
   }
@@ -126,37 +129,897 @@ Hooks.once("ready", function () {
   }
 })
 
-// Test if version below 13
-let hookName = "renderChatMessage"
-if (foundry.utils.isNewerVersion(game.version, "12.0",)) {
-  hookName = "renderChatMessageHTML"
-}
-Hooks.on(hookName, (message, html, data) => {
+Hooks.on("renderChatMessageHTML", (message, html, data) => {
   const typeMessage = data.message.flags.lethalFantasy?.typeMessage
   // Message de demande de jet de dés
   if (typeMessage === "askRoll") {
     // Affichage des boutons de jet de dés uniquement pour les joueurs
     if (game.user.isGM) {
-      html.find(".ask-roll-dice").each((i, btn) => {
+      for (const btn of html.querySelectorAll(".ask-roll-dice")) {
         btn.style.display = "none"
-      })
+      }
     } else {
-      html.find(".ask-roll-dice").click((event) => {
-        const btn = $(event.currentTarget)
-        const type = btn.data("type")
-        const value = btn.data("value")
-        const avantage = btn.data("avantage") ?? "="
-        const character = game.user.character
-        if (type === SYSTEM.ROLL_TYPE.RESOURCE) character.rollResource(value)
-        else if (type === SYSTEM.ROLL_TYPE.SAVE) character.rollSave(value, avantage)
+      for (const btn of html.querySelectorAll(".ask-roll-dice")) {
+        btn.addEventListener("click", () => {
+          const type = btn.dataset.type
+          const value = btn.dataset.value
+          const avantage = btn.dataset.avantage ?? "="
+          const character = game.user.character
+          if (type === SYSTEM.ROLL_TYPE.RESOURCE) character.rollResource(value)
+          else if (type === SYSTEM.ROLL_TYPE.SAVE) character.rollSave(value, avantage)
+        })
+      }
+    }
+  }
+
+  // Gestion du survol et du clic sur les boutons de dégâts pour les GMs
+  if (game.user.isGM) {
+    // Show damage buttons only for GM
+    for (const btn of html.querySelectorAll(".li-apply-wounds")) {
+      btn.style.display = "block"
+    }
+
+    for (const btn of html.querySelectorAll(".apply-wounds-btn")) {
+      btn.addEventListener("mouseenter", () => {
+        const combatantId = btn.dataset.combatantId
+        if (combatantId && game.combat) {
+          const combatant = game.combat.combatants.get(combatantId)
+          if (combatant?.token) {
+            const token = canvas.tokens.get(combatant.token.id)
+            if (token) {
+              token.control({ releaseOthers: true })
+              canvas.animatePan(token.center)
+            }
+          }
+        }
       })
+      btn.addEventListener("mouseleave", () => canvas.tokens.releaseAll())
+      btn.addEventListener("click", event => LethalFantasyUtils.applyDamage(message, event))
+    }
+  }
+
+  // Gestion du survol et du clic sur les boutons de défense
+  for (const btn of html.querySelectorAll(".request-defense-btn")) {
+    btn.addEventListener("mouseenter", () => {
+      const tokenId = btn.dataset.tokenId
+      if (tokenId) {
+        const token = canvas.tokens.get(tokenId)
+        if (token) {
+          token.control({ releaseOthers: true })
+          canvas.animatePan(token.center)
+        }
+      }
+    })
+    btn.addEventListener("mouseleave", () => canvas.tokens.releaseAll())
+
+    // Gestionnaire pour les boutons de demande de défense
+    btn.addEventListener("click", event => {
+      event.preventDefault()
+      event.stopPropagation()
+
+      const combatantId = btn.dataset.combatantId
+      const tokenId = btn.dataset.tokenId
+
+      // Récupérer le combattant soit du combat, soit directement du token
+      let combatant = null
+      let token = null
+
+      if (game.combat && combatantId) {
+        combatant = game.combat.combatants.get(combatantId)
+      }
+
+      // Si pas de combattant trouvé, chercher le token directement
+      if (!combatant && tokenId) {
+        token = canvas.tokens.get(tokenId)
+        if (token) {
+          // Créer un pseudo-combattant avec les infos du token
+          combatant = {
+            actor: token.actor,
+            name: token.name,
+            token: token,
+            actorId: token.actorId
+          }
+        }
+      }
+
+      if (!combatant) return
+
+      // Récupérer les informations de l'attaquant depuis le message
+      const attackerName = message.rolls[0]?.actorName || "Unknown"
+      const attackerId = message.rolls[0]?.actorId
+      const weaponName = message.rolls[0]?.rollName || "weapon"
+      const attackRoll = message.rolls[0]?.rollTotal || 0
+      const defenderName = combatant.name
+      const attackRollType = message.rolls[0]?.type
+      const rollTargetData = message.rolls[0]?.rollTarget
+      // For spell/miracle attacks, rollTarget IS the spell item (serialised as its data object).
+      // For weapon attacks, rollTarget is a plain skill+weapon object and weapon.id is the weapon.
+      const isSpellMiracleAttack = attackRollType === "spell-attack" || attackRollType === "miracle-attack"
+      const attackWeaponId = isSpellMiracleAttack
+        ? (rollTargetData?._id || rollTargetData?.id)
+        : (rollTargetData?.weapon?.id || rollTargetData?.weapon?._id)
+      const attackRollKey = rollTargetData?.rollKey
+      console.log(`[LF] request-defense-btn | attackRollType=${attackRollType} defender=${defenderName} defenderType=${combatant.actor?.type}`)
+      const attackD30result = message.rolls[0]?.options?.D30result || null
+      const attackD30message = message.rolls[0]?.options?.D30message || null
+      const attackRerollContext = {
+        rollType: message.rolls[0]?.options?.rollType,
+        rollTarget: foundry.utils.duplicate(message.rolls[0]?.options?.rollTarget ?? {}),
+        actorId: message.rolls[0]?.options?.actorId,
+        actorName: message.rolls[0]?.options?.actorName,
+        actorImage: message.rolls[0]?.options?.actorImage,
+        defenderId: combatant.actor?.id || null,
+        defenderTokenId: tokenId || combatant.token?.id || null,
+        rollContext: foundry.utils.duplicate(message.rolls[0]?.options?.rollData ?? {})
+      }
+
+      // Préparer le message de demande de défense
+      // isRanged: true si le monstre était en mode ranged (via rollTarget.attackMode stocké dans le roll)
+      // OU si l'attaquant utilisait une arme ranged (weapon-attack avec weaponType === "ranged")
+      const attacker = game.actors.get(attackerId)
+      const rollTargetOptions = message.rolls[0]?.options?.rollTarget
+      const attackerWeapon = rollTargetOptions?.weapon
+      const isRangedAttack = (rollTargetOptions?.attackMode === "ranged")
+        || (attacker?.type === "monster" && attacker.system.attackMode === "ranged")
+        || (attackerWeapon?.system?.weaponType === "ranged")
+        || (rollTargetOptions?.isRangedAttack === true)
+
+      const defenseMsg = {
+        type: "requestDefense",
+        attackerName,
+        attackerId,
+        defenderName,
+        weaponName,
+        attackRoll,
+        attackWeaponId,
+        attackRollType,
+        attackRollKey,
+        attackD30result,
+        attackD30message,
+        attackRerollContext,
+        combatantId,
+        tokenId,
+        isRanged: isRangedAttack
+      }
+
+      // Envoyer le message socket à l'utilisateur contrôlant le combatant
+      // Only consider active (online) users; fall back to any active GM for unowned/GM monsters.
+      let owners = game.users.filter(u => u.active && combatant.actor.testUserPermission(u, "OWNER"))
+      if (owners.length === 0) {
+        owners = game.users.filter(u => u.active && u.isGM)
+      }
+
+      // Récupérer l'acteur attaquant pour vérifier qui l'a lancé
+      const attackerOwners = attacker ? game.users.filter(u => attacker.testUserPermission(u, "OWNER")).map(u => u.id) : []
+
+      // Monsters always need their owner (usually the GM) to roll a save/defense,
+      // even if that owner also controls the attacker. Only skip for same-player PC-vs-PC.
+      const defenderIsMonster = combatant.actor?.type === "monster"
+
+      let messageSent = false
+      owners.forEach(owner => {
+        // Don't let a player be both attacker and defender for their own PC, unless defending a monster.
+        if (attackerOwners.includes(owner.id) && owner.id === game.user.id && !defenderIsMonster) {
+          // Ne rien faire - on ne veut pas que l'attaquant se défende contre lui-même
+          return
+        }
+
+        if (owner.id === game.user.id) {
+          // Si l'utilisateur actuel est le propriétaire du défenseur (mais pas l'attaquant), appeler directement
+          LethalFantasyUtils.showDefenseRequest({ ...defenseMsg, userId: owner.id })
+          messageSent = true
+        } else {
+          // Sinon, envoyer via socket
+          game.socket.emit(`system.${SYSTEM.id}`, { ...defenseMsg, userId: owner.id })
+          messageSent = true
+        }
+      })
+
+      // Notification pour l'attaquant
+      if (messageSent) {
+        ui.notifications.info(`Defense request sent to ${defenderName}'s controller`)
+      }
+    })
+  }
+
+  // Gestionnaire pour les boutons de jet de dégâts (armes et résultats de combat)
+  for (const btn of html.querySelectorAll(".damage-roll-btn, .roll-damage-btn")) {
+    btn.addEventListener("click", async event => {
+      event.preventDefault()
+      event.stopPropagation()
+
+      const weaponId = btn.dataset.weaponId
+      const attackKey = btn.dataset.attackKey
+      const attackerId = btn.dataset.attackerId
+      const defenderId = btn.dataset.defenderId
+      const defenderTokenId = btn.dataset.defenderTokenId || null
+      const extraShieldDr = Number(btn.dataset.extraShieldDr || 0)
+      const damageType = btn.dataset.damageType
+      const damageFormula = btn.dataset.damageFormula
+      const damageModifier = btn.dataset.damageModifier
+      const isMonster = btn.dataset.isMonster
+
+      // Récupérer l'acteur (soit depuis le message, soit depuis attackerId)
+      const actor = attackerId ? game.actors.get(attackerId) : game.actors.get(message.rolls[0]?.actorId)
+      if (!actor) {
+        ui.notifications.error("Actor not found")
+        return
+      }
+
+      // Pour les sorts, rouler les dés de dégâts avec DR manuelle optionnelle
+      if (damageType === "spell" && damageFormula) {
+        const manualDR = await foundry.applications.api.DialogV2.wait({
+          window: { title: game.i18n.localize("LETHALFANTASY.Combat.spellDRDialogTitle") },
+          classes: ["lethalfantasy"],
+          position: { width: 320 },
+          content: `<div style="padding:0.5rem 0">
+            <p style="margin-bottom:0.6rem">${game.i18n.localize("LETHALFANTASY.Combat.spellDRDialogMsg")}</p>
+            <div style="display:flex;align-items:center;gap:0.5rem">
+              <label style="font-weight:bold">${game.i18n.localize("LETHALFANTASY.Combat.spellDRLabel")}</label>
+              <input type="number" name="manualDr" value="0" min="0" style="width:5rem"/>
+            </div>
+          </div>`,
+          buttons: [
+            {
+              action: "noDR",
+              label: game.i18n.localize("LETHALFANTASY.Combat.spellNoDR"),
+              icon: "fa-solid fa-wand-magic-sparkles",
+              callback: () => 0
+            },
+            {
+              action: "applyDR",
+              label: game.i18n.localize("LETHALFANTASY.Combat.spellApplyDR"),
+              icon: "fa-solid fa-shield",
+              callback: (event, button) => Number(button.form?.elements?.manualDr?.value) || 0
+            },
+            {
+              action: "cancel",
+              label: game.i18n.localize("LETHALFANTASY.Combat.proceedNo"),
+              callback: () => "cancel"
+            }
+          ],
+          rejectClose: false
+        })
+        if (manualDR === null || manualDR === "cancel") return
+        const rollOpts = {
+          type: "spell-damage",
+          rollType: "spell-damage",
+          rollName: damageFormula,
+          isDamage: true,
+          rollData: { isDamage: true },
+          manualDR: manualDR,
+          defenderId,
+          defenderTokenId,
+          actorId: actor.id,
+          actorName: actor.name,
+          actorImage: actor.img
+        }
+        await documents.LethalFantasyRoll.rollSpellDamageToMessage(damageFormula, rollOpts)
+        return
+      }
+
+      // Pour les boutons de résultat de combat (monster damage)
+      if (damageType === "monster" && attackKey) {
+        await actor.system.prepareMonsterRoll("monster-damage", attackKey, undefined, undefined, undefined, defenderId, defenderTokenId, extraShieldDr)
+        return
+      }
+
+      // Pour les monstres, utiliser prepareMonsterRoll
+      if (isMonster === "true" || actor.type === "monster") {
+        await actor.system.prepareMonsterRoll("monster-damage", weaponId, undefined, undefined, damageModifier)
+        return
+      }
+
+      // Pour les personnages, récupérer l'arme
+      const weapon = actor.items.get(weaponId)
+      if (!weapon) {
+        ui.notifications.error("Weapon not found")
+        return
+      }
+
+      // Lancer les dégâts avec la bonne méthode
+      const rollType = damageType === "small" ? "weapon-damage-small" : "weapon-damage-medium"
+      await actor.prepareRoll(rollType, weaponId, undefined, defenderId, defenderTokenId, extraShieldDr)
+    })
+  }
+
+  // Masquer les boutons de dommages dans les messages de résultat de combat si l'utilisateur n'est pas l'attaquant
+  for (const btn of html.querySelectorAll(".roll-damage-btn")) {
+    const attackerId = btn.dataset.attackerId
+    if (attackerId) {
+      const attacker = game.actors.get(attackerId)
+      // Masquer le bouton si l'utilisateur n'est pas GM et ne possède pas l'attaquant
+      if (!game.user.isGM && !attacker?.testUserPermission(game.user, "OWNER")) {
+        btn.style.display = "none"
+      }
     }
   }
 })
 
-Hooks.on("getCombatTrackerEntryContext", (html, options) => {
-  LethalFantasyUtils.pushCombatOptions(html, options);
-});
+// Hook pour ajouter les données d'attaque au message de défense
+Hooks.on("preCreateChatMessage", (message) => {
+  const rollType = message.rolls[0]?.options?.rollType
+
+  // Si c'est un message de défense et qu'on a des données en attente
+  if ((rollType === "weapon-defense" || rollType === "monster-defense" || rollType === "save") && game.lethalFantasy?.nextDefenseData) {
+    // Ajouter les données dans les flags du message
+    message.updateSource({
+      [`flags.${SYSTEM.id}.attackData`]: game.lethalFantasy.nextDefenseData
+    })
+
+    console.log("Added attack data to defense message:", game.lethalFantasy.nextDefenseData)
+
+    // Nettoyer
+    delete game.lethalFantasy.nextDefenseData
+  }
+})
+
+// Hook global pour gérer l'offre de Grit à l'attaquant après une défense
+Hooks.on("createChatMessage", async (message) => {
+  const rollType = message.rolls[0]?.options?.rollType
+
+  console.log("Defense hook checking message, rollType:", rollType)
+
+  // Vérifier si c'est un message de défense
+  if (rollType !== "weapon-defense" && rollType !== "monster-defense" && rollType !== "save") return
+
+  // Récupérer les données d'attaque depuis les flags
+  const attackData = message.flags?.[SYSTEM.id]?.attackData
+
+  console.log("Defense message confirmed, attackData:", attackData)
+
+  if (!attackData) {
+    console.log("No attack data found in message flags")
+    return
+  }
+
+  const {
+    attackerId,
+    attackRoll,
+    attackerName,
+    defenderName,
+    attackWeaponId,
+    attackRollType,
+    attackRollKey,
+    attackD30message,
+    attackRerollContext,
+    defenderId,
+    defenderTokenId
+  } = attackData
+  let defenseRoll = message.rolls[0]?.options?.rollTotal || message.rolls[0]?.total || 0
+  const defenseD30message = message.rolls[0]?.options?.D30message || null
+
+  console.log("Processing defense:", { attackRoll, defenseRoll, attackerId, defenderId })
+
+  // Attendre l'animation 3D
+  if (game?.dice3d) {
+    await game.dice3d.waitFor3DAnimationByMessageID(message.id)
+  }
+
+  // Récupérer le défenseur et l'attaquant
+  const defender = game.actors.get(defenderId)
+  const attacker = game.actors.get(attackerId)
+  const defenseRerollContext = {
+    rollType: message.rolls[0]?.options?.rollType,
+    rollTarget: foundry.utils.duplicate(message.rolls[0]?.options?.rollTarget ?? {}),
+    actorId: message.rolls[0]?.options?.actorId,
+    actorName: message.rolls[0]?.options?.actorName,
+    actorImage: message.rolls[0]?.options?.actorImage,
+    defenderId,
+    defenderTokenId,
+    rollContext: foundry.utils.duplicate(message.rolls[0]?.options?.rollData ?? {})
+  }
+
+  const isPrimaryController = actor => {
+    if (!actor) return false
+    const activePlayerOwners = game.users.filter(u => u.active && !u.isGM && actor.testUserPermission(u, "OWNER"))
+    if (activePlayerOwners.length > 0) {
+      return activePlayerOwners[0].id === game.user.id
+    }
+    return game.user.isGM
+  }
+
+  const createReactionMessage = async (actorDocument, content) => {
+    await ChatMessage.create({
+      content,
+      speaker: ChatMessage.getSpeaker({ actor: actorDocument })
+    })
+  }
+
+  // Reaction phase — both sides may use grit/luck/shield/mulligan before the outcome is resolved.
+  // After a mulligan reroll (either side), the comparison restarts so both sides can react to the new numbers.
+  let defenderHandledBonus = false
+  let attackerHandledBonus = false
+  let shieldReaction = null
+  let shieldBlocked = false
+  const isSpellOrMiracle = attackRollType === "spell-attack" || attackRollType === "miracle-attack"
+
+  // These persist across mulligan restarts (once used they stay consumed)
+  const shieldData = LethalFantasyUtils.getShieldReactionData(defender)
+  let canRerollDefense = LethalFantasyUtils.hasD30Reroll(defenseD30message)
+  let canShieldReact = !!shieldData
+  let canAdHocShield = !shieldData
+  let attackRollFinal = attackRoll
+  let canRerollAttack = LethalFantasyUtils.hasD30Reroll(attackD30message)
+  let mulliganRestart = false
+
+  do {
+    mulliganRestart = false
+    defenderHandledBonus = false
+    attackerHandledBonus = false
+
+    // ── Defense reaction loop ──────────────────────────────────────────────
+    if (defender && defenseRoll < attackRollFinal && isPrimaryController(defender) && !isSpellOrMiracle) {
+      while (defenseRoll < attackRollFinal) {
+        const currentGrit = Number(defender.system?.grit?.current) || 0
+        const currentLuck = Number(defender.system?.luck?.current) || 0
+        const buttons = []
+
+        if (currentGrit > 0) {
+          buttons.push({
+            action: "grit",
+            label: `Spend 1 Grit (+1D6) [${currentGrit} left]`,
+            icon: "fa-solid fa-fist-raised",
+            callback: () => "grit"
+          })
+        }
+
+        if (currentLuck > 0) {
+          buttons.push({
+            action: "luck",
+            label: `Spend 1 Luck (+1D6) [${currentLuck} left]`,
+            icon: "fa-solid fa-clover",
+            callback: () => "luck"
+          })
+        }
+
+        buttons.push({
+          action: "bonusDie",
+          label: "Add bonus die",
+          icon: "fa-solid fa-dice",
+          callback: () => "bonusDie"
+        })
+
+        if (canRerollDefense) {
+          buttons.push({
+            action: "rerollDefense",
+            label: "Re-roll defense (Mulligan)",
+            icon: "fa-solid fa-rotate-right",
+            callback: () => "rerollDefense"
+          })
+        }
+
+        if (canShieldReact) {
+          buttons.push({
+            action: "shieldReact",
+            label: `Roll shield (${shieldData.label})`,
+            icon: "fa-solid fa-shield",
+            callback: () => "shieldReact"
+          })
+        } else if (canAdHocShield) {
+          buttons.push({
+            action: "adHocShield",
+            label: "Roll ad-hoc shield (choose dice + DR)",
+            icon: "fa-solid fa-shield-halved",
+            callback: () => "adHocShield"
+          })
+        }
+
+        buttons.push({
+          action: "continue",
+          label: "Continue (no defense bonus)",
+          icon: "fa-solid fa-forward",
+          callback: () => "continue"
+        })
+
+        const choice = await foundry.applications.api.DialogV2.wait({
+          window: { title: "Defense reactions" },
+          classes: ["lethalfantasy"],
+          content: `
+            <div class="grit-luck-dialog">
+              <div class="combat-status">
+                <p><strong>${attackerName}</strong> rolled <strong>${attackRollFinal}</strong></p>
+                <p><strong>${defenderName}</strong> currently has <strong>${defenseRoll}</strong></p>
+                ${defenseD30message ? `<p class="bonus-info">D30 special: ${defenseD30message.description}</p>` : ""}
+              </div>
+              <p class="offer-text">Choose how to improve the defense before resolving the hit.</p>
+            </div>
+          `,
+          buttons,
+          rejectClose: false
+        })
+
+        if (!choice || choice === "continue") break
+
+        defenderHandledBonus = true
+
+        if (choice === "grit") {
+          const bonusRoll = await LethalFantasyUtils.rollBonusDie("1d6", defender, total => `<p><strong>${defenderName}</strong> spends 1 Grit and rolls <strong>${total}</strong> for defense.</p>`)
+          defenseRoll += bonusRoll
+          await defender.update({ "system.grit.current": currentGrit - 1 })
+          continue
+        }
+
+        if (choice === "luck") {
+          const bonusRoll = await LethalFantasyUtils.rollBonusDie("1d6", defender, total => `<p><strong>${defenderName}</strong> spends 1 Luck and rolls <strong>${total}</strong> for defense.</p>`)
+          defenseRoll += bonusRoll
+          await defender.update({ "system.luck.current": currentLuck - 1 })
+          continue
+        }
+
+        if (choice === "bonusDie") {
+          const bonusDie = await LethalFantasyUtils.promptCombatBonusDie(defenderName, "attack", defenseRoll, attackRollFinal)
+          if (!bonusDie) continue
+          const bonusRoll = await LethalFantasyUtils.rollBonusDie(bonusDie, defender, (total, formula) => `<p><strong>${defenderName}</strong> adds <strong>${formula.toUpperCase()}</strong> and rolls <strong>${total}</strong> for defense.</p>`)
+          defenseRoll += bonusRoll
+          continue
+        }
+
+        if (choice === "rerollDefense" && canRerollDefense) {
+          const oldDefenseRoll = defenseRoll
+          const reroll = await LethalFantasyUtils.rerollConfiguredRoll(defenseRerollContext)
+          canRerollDefense = false
+          if (!reroll) continue
+          defenseRoll = reroll.options?.rollTotal || reroll.total || oldDefenseRoll
+          await createReactionMessage(defender, `<p><strong>${defenderName}</strong> uses Mulligan and re-rolls defense: <strong>${oldDefenseRoll}</strong> → <strong>${defenseRoll}</strong>. Both sides may now react to the new numbers.</p>`)
+          // Restart the full comparison so both sides can react to the new roll
+          mulliganRestart = true
+          break
+        }
+
+        if (choice === "shieldReact" && canShieldReact) {
+          const shieldBonus = await LethalFantasyUtils.rollBonusDie(shieldData.formula, defender)
+          const newDefenseTotal = defenseRoll + shieldBonus
+          defenseRoll = newDefenseTotal
+          canShieldReact = false
+
+          if (newDefenseTotal >= attackRollFinal) {
+            shieldBlocked = true
+            shieldReaction = {
+              damageReduction: shieldData.damageReduction,
+              label: shieldData.label,
+              bonus: shieldBonus
+            }
+            await createReactionMessage(
+              defender,
+              `<p><strong>${defenderName}</strong> rolls <strong>${shieldData.label}</strong> and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} ≥ ${attackRollFinal}). <strong>Shield blocked the attack!</strong> Both armor DR and shield DR <strong>${shieldData.damageReduction}</strong> will apply to damage.</p>`
+            )
+          } else {
+            shieldReaction = null
+            await createReactionMessage(
+              defender,
+              `<p><strong>${defenderName}</strong> rolls <strong>${shieldData.label}</strong> and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} < ${attackRollFinal}). Shield did not block — normal hit, armor DR only.</p>`
+            )
+          }
+        }
+
+        if (choice === "adHocShield") {
+          const adHoc = await LethalFantasyUtils.promptAdHocShield(defenderName, attackRollFinal, defenseRoll)
+          if (!adHoc) continue
+          const shieldBonus = await LethalFantasyUtils.rollBonusDie(adHoc.formula, defender)
+          const newDefenseTotal = defenseRoll + shieldBonus
+          defenseRoll = newDefenseTotal
+          canShieldReact = false
+          canAdHocShield = false
+
+          if (newDefenseTotal >= attackRollFinal) {
+            shieldBlocked = true
+            shieldReaction = {
+              damageReduction: adHoc.damageReduction,
+              label: `${adHoc.formula.toUpperCase()} shield`,
+              bonus: shieldBonus
+            }
+            await createReactionMessage(
+              defender,
+              `<p><strong>${defenderName}</strong> rolls <strong>${adHoc.formula.toUpperCase()}</strong> shield and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} ≥ ${attackRollFinal}). <strong>Shield blocked the attack!</strong> Both armor DR and shield DR <strong>${adHoc.damageReduction}</strong> will apply to damage.</p>`
+            )
+          } else {
+            shieldReaction = null
+            await createReactionMessage(
+              defender,
+              `<p><strong>${defenderName}</strong> rolls <strong>${adHoc.formula.toUpperCase()}</strong> shield and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} < ${attackRollFinal}). Shield did not block — normal hit, armor DR only.</p>`
+            )
+          }
+        }
+      }
+    }
+
+    if (mulliganRestart) continue
+
+    // ── Attack reaction loop ───────────────────────────────────────────────
+    if (!defenderHandledBonus && attacker && attackRollFinal <= defenseRoll && isPrimaryController(attacker)) {
+      while (attackRollFinal <= defenseRoll) {
+        const currentGrit = Number(attacker.system?.grit?.current) || 0
+        const buttons = []
+
+        if (currentGrit > 0) {
+          buttons.push({
+            action: "grit",
+            label: `Spend 1 Grit (+1D6) [${currentGrit} left]`,
+            icon: "fa-solid fa-fist-raised",
+            callback: () => "grit"
+          })
+        }
+
+        buttons.push({
+          action: "bonusDie",
+          label: "Add bonus die",
+          icon: "fa-solid fa-dice",
+          callback: () => "bonusDie"
+        })
+
+        if (canRerollAttack && attackRerollContext) {
+          buttons.push({
+            action: "rerollAttack",
+            label: "Re-roll attack (Mulligan)",
+            icon: "fa-solid fa-rotate-right",
+            callback: () => "rerollAttack"
+          })
+        }
+
+        buttons.push({
+          action: "continue",
+          label: "Continue (no attack bonus)",
+          icon: "fa-solid fa-forward",
+          callback: () => "continue"
+        })
+
+        const choice = await foundry.applications.api.DialogV2.wait({
+          window: { title: "Attack reactions" },
+          classes: ["lethalfantasy"],
+          content: `
+            <div class="grit-luck-dialog">
+              <div class="combat-status">
+                <p><strong>${attackerName}</strong> currently has <strong>${attackRollFinal}</strong></p>
+                <p><strong>${defenderName}</strong> rolled <strong>${defenseRoll}</strong></p>
+                ${attackD30message ? `<p class="bonus-info">D30 special: ${attackD30message.description}</p>` : ""}
+              </div>
+              <p class="offer-text">Choose how to improve the attack before resolving the combat result.</p>
+            </div>
+          `,
+          buttons,
+          rejectClose: false
+        })
+
+        if (!choice || choice === "continue") break
+
+        attackerHandledBonus = true
+
+        if (choice === "grit") {
+          const attackBonus = await LethalFantasyUtils.rollBonusDie("1d6", attacker, total => `<p><strong>${attackerName}</strong> spends 1 Grit and rolls <strong>${total}</strong> for attack.</p>`)
+          attackRollFinal += attackBonus
+          await attacker.update({ "system.grit.current": currentGrit - 1 })
+          continue
+        }
+
+        if (choice === "bonusDie") {
+          const bonusDie = await LethalFantasyUtils.promptCombatBonusDie(attackerName, "defense", attackRollFinal, defenseRoll)
+          if (!bonusDie) continue
+          const attackBonus = await LethalFantasyUtils.rollBonusDie(bonusDie, attacker, (total, formula) => `<p><strong>${attackerName}</strong> adds <strong>${formula.toUpperCase()}</strong> and rolls <strong>${total}</strong> for attack.</p>`)
+          attackRollFinal += attackBonus
+          continue
+        }
+
+        if (choice === "rerollAttack" && canRerollAttack && attackRerollContext) {
+          const oldAttackRoll = attackRollFinal
+          const reroll = await LethalFantasyUtils.rerollConfiguredRoll(attackRerollContext)
+          canRerollAttack = false
+          if (!reroll) continue
+          attackRollFinal = reroll.options?.rollTotal || reroll.total || oldAttackRoll
+          await createReactionMessage(attacker, `<p><strong>${attackerName}</strong> uses Mulligan and re-rolls attack: <strong>${oldAttackRoll}</strong> → <strong>${attackRollFinal}</strong>. Both sides may now react to the new numbers.</p>`)
+          // Restart the full comparison so both sides can react to the new roll
+          mulliganRestart = true
+          break
+        }
+      }
+    }
+  } while (mulliganRestart)
+
+  const shieldDamageReduction = shieldBlocked ? shieldReaction.damageReduction : 0
+  const outcome = shieldBlocked ? "shielded-hit" : (attackRollFinal > defenseRoll ? "hit" : "miss")
+
+  // Créer le message de comparaison - uniquement par le client qui a géré le dernier bonus
+  // Priorité: attaquant si il a géré le bonus, sinon défenseur si il a géré le bonus, sinon défenseur
+  const shouldCreateMessage = attackerHandledBonus || (!attackerHandledBonus && defenderHandledBonus) || (!attackerHandledBonus && !defenderHandledBonus && isPrimaryController(defender))
+
+  if (shouldCreateMessage) {
+    console.log("Creating comparison message", { attackerHandledBonus, defenderHandledBonus, isDefenderOwner: defender.isOwner })
+
+    await LethalFantasyUtils.compareAttackDefense({
+      attackerName,
+      attackerId,
+      attackRoll: attackRollFinal,
+      attackWeaponId,
+      attackRollType,
+      attackRollKey,
+      defenderName,
+      defenderId,
+      defenderTokenId,
+      defenseRoll,
+      outcome,
+      shieldDamageReduction
+    })
+  } else {
+    console.log("Skipping message creation", { attackerHandledBonus, defenderHandledBonus })
+  }
+})
+
+// Hook: deduct aether when a spell-attack or spell-power roll is posted to chat
+Hooks.on("createChatMessage", async (message) => {
+  if (!["spell-attack", "spell-power"].includes(message.rolls[0]?.options?.rollType)) return
+
+  const actorId = message.rolls[0]?.options?.actorId
+  if (!actorId) return
+  const actor = game.actors.get(actorId)
+  if (!actor) return
+
+  // Only the primary controller (player owner or GM) handles this
+  const activePlayerOwners = game.users.filter(u => u.active && !u.isGM && actor.testUserPermission(u, "OWNER"))
+  const isPrimary = activePlayerOwners.length > 0
+    ? activePlayerOwners[0].id === game.user.id
+    : game.user.isGM
+  if (!isPrimary) return
+
+  const rollTarget = message.rolls[0]?.options?.rollTarget
+  const spellId = rollTarget?.id || rollTarget?._id
+  const spell = spellId ? actor.items.get(spellId) : null
+  if (!spell || spell.type !== "spell") return
+
+  const cost = Number(spell.system?.cost) || 0
+  if (cost <= 0) return
+
+  const currentAether = Number(actor.system.aetherPoints?.value) || 0
+  const newAether = Math.max(0, currentAether - cost)
+  await actor.update({ "system.aetherPoints.value": newAether })
+
+  await ChatMessage.create({
+    content: `<p>🔮 <strong>${actor.name}</strong> casts <em>${spell.name}</em> — spends <strong>${cost}</strong> Aether <span style="color:#888;">(${currentAether} → ${newAether})</span>.</p>`,
+    speaker: ChatMessage.getSpeaker({ actor })
+  })
+})
+
+// Hook: deduct grace when a miracle-attack or miracle-power roll is posted to chat
+Hooks.on("createChatMessage", async (message) => {
+  if (!["miracle-attack", "miracle-power"].includes(message.rolls[0]?.options?.rollType)) return
+
+  const actorId = message.rolls[0]?.options?.actorId
+  if (!actorId) return
+  const actor = game.actors.get(actorId)
+  if (!actor) return
+
+  const activePlayerOwners = game.users.filter(u => u.active && !u.isGM && actor.testUserPermission(u, "OWNER"))
+  const isPrimary = activePlayerOwners.length > 0
+    ? activePlayerOwners[0].id === game.user.id
+    : game.user.isGM
+  if (!isPrimary) return
+
+  const rollTarget = message.rolls[0]?.options?.rollTarget
+  const miracleId = rollTarget?.id || rollTarget?._id
+  const miracle = miracleId ? actor.items.get(miracleId) : null
+  if (!miracle || miracle.type !== "miracle") return
+
+  const cost = Number(miracle.system?.level) || 0
+  if (cost <= 0) return
+
+  const currentGrace = Number(actor.system.divinityPoints?.value) || 0
+  const newGrace = Math.max(0, currentGrace - cost)
+  await actor.update({ "system.divinityPoints.value": newGrace })
+
+  await ChatMessage.create({
+    content: `<p>✨ <strong>${actor.name}</strong> invokes <em>${miracle.name}</em> — spends <strong>${cost}</strong> Grace <span style="color:#888;">(${currentGrace} → ${newGrace})</span>.</p>`,
+    speaker: ChatMessage.getSpeaker({ actor })
+  })
+})
+
+// Hook pour appliquer automatiquement les dégâts si une cible est définie
+Hooks.on("createChatMessage", async (message) => {
+  // Vérifier si c'est un message de dégâts avec un defenderId
+  const defenderId = message.rolls[0]?.options?.defenderId
+  const isDamage = message.rolls[0]?.options?.rollData?.isDamage
+
+  console.log("Auto-damage hook:", { defenderId, isDamage, rollType: message.rolls[0]?.options?.rollType })
+
+  if (!defenderId || !isDamage) return
+
+  // Récupérer l'attaquant depuis le roll
+  const attackerId = message.rolls[0]?.options?.actorId
+  const attacker = attackerId ? game.actors.get(attackerId) : null
+
+  // Déterminer qui doit appliquer les dégâts :
+  // 1. Si l'attaquant a un propriétaire joueur, seul ce joueur applique
+  // 2. Si l'attaquant n'a que le MJ comme propriétaire (monstre), seul le MJ applique
+  const attackerOwners = attacker ? game.users.filter(u =>
+    u.active && !u.isGM && attacker.testUserPermission(u, "OWNER")
+  ) : []
+
+  let shouldApplyDamage = false
+  if (attackerOwners.length > 0) {
+    // L'attaquant a des propriétaires joueurs, seul le premier propriétaire applique
+    shouldApplyDamage = attackerOwners[0].id === game.user.id
+  } else {
+    // L'attaquant n'a que le MJ, seul le MJ applique
+    shouldApplyDamage = game.user.isGM
+  }
+
+  if (!shouldApplyDamage) {
+    console.log("Auto-damage hook: Not responsible for applying damage, skipping")
+    return
+  }
+
+  console.log("Auto-damage hook: Applying damage as responsible user")
+
+  // Attendre l'animation 3D avant d'appliquer les dégâts
+  if (game?.dice3d) {
+    await game.dice3d.waitFor3DAnimationByMessageID(message.id)
+  }
+
+  // Récupérer le défenseur
+  const defender = game.actors.get(defenderId)
+  if (!defender) {
+    console.warn("Defender not found:", defenderId)
+    return
+  }
+
+  // Récupérer les dégâts (utiliser rollTotal qui contient le total calculé)
+  const damageTotal = message.rolls[0]?.options?.rollTotal || message.rolls[0]?.total || 0
+  const weaponName = message.rolls[0]?.options?.rollName || "Unknown Weapon"
+  const attackerName = message.rolls[0]?.options?.actorName || "Unknown Attacker"
+  const rollType = message.rolls[0]?.options?.rollType
+
+  // Calculer les DR — les sorts utilisent une DR manuelle saisie par l'utilisateur
+  const isSpellDamage = rollType === "spell-damage"
+  const manualDR = message.rolls[0]?.options?.manualDR ?? 0
+  const extraShieldDr = Number(message.rolls[0]?.options?.extraShieldDr) || 0
+  const armorDR = isSpellDamage ? manualDR : (defender.computeDamageReduction() || 0)
+  const totalDR = isSpellDamage ? manualDR : armorDR + extraShieldDr
+  const finalDamage = Math.max(0, damageTotal - totalDR)
+
+  // Prefer the token ID stored in roll options (set at attack time when the exact token is known).
+  // For unlinked tokens (default for monsters), this ensures we target the right instance even
+  // when multiple unlinked copies of the same monster type are in combat.
+  const rollDefenderTokenId = message.rolls[0]?.options?.defenderTokenId
+  const defenderCombatant = game.combat?.combatants?.find(c => c.actorId === defender.id)
+  const defenderTokenId = rollDefenderTokenId
+    ?? defenderCombatant?.token?.id
+    ?? canvas.tokens?.placeables?.find(t => t.actor?.id === defender.id)?.id
+    ?? null
+
+  // Apply damage. If the current user does not own the defender (e.g. player hitting a GM monster),
+  // route the HP update to the GM via socket. The confirmation message is still created here
+  // since all users can create chat messages.
+  if (defender.isOwner) {
+    // Resolve the token actor: prefer lookup by token ID (exact match for unlinked monsters),
+    // fall back to combatant actor, then base world actor.
+    const tokenActor = (defenderTokenId
+      ? canvas.tokens?.placeables?.find(t => t.id === defenderTokenId)?.actor
+      : defenderCombatant?.actor) ?? defender
+    await tokenActor.applyDamage(-finalDamage)
+  } else {
+    game.socket.emit(`system.${SYSTEM.id}`, { type: "applyDamage", actorId: defender.id, tokenId: defenderTokenId, damage: -finalDamage })
+  }
+
+  // Créer un message de confirmation (visible to GM only)
+  const messageContent = await foundry.applications.handlebars.renderTemplate(
+    "systems/fvtt-lethal-fantasy/templates/damage-applied-message.hbs",
+    {
+      targetName: defender.name,
+      damage: finalDamage,
+      drText: isSpellDamage
+        ? (manualDR > 0 ? `Spell DR: ${manualDR}` : "No DR applied")
+        : (totalDR > 0 ? `Armor DR: ${armorDR}${extraShieldDr > 0 ? ` + Shield DR: ${extraShieldDr}` : ""}` : ""),
+      weaponName: weaponName,
+      attackerName: attackerName,
+      rawDamage: damageTotal
+    }
+  )
+
+  await ChatMessage.create({
+    content: messageContent,
+    speaker: ChatMessage.getSpeaker({ actor: defender }),
+    whisper: ChatMessage.getWhisperRecipients("GM")
+  })
+})
+
 
 /**
  * Create a macro when dropping an entity on the hotbar
@@ -171,6 +1034,12 @@ Hooks.on("hotbarDrop", (bar, data, slot) => {
   }
 })
 
+/* -------------------------------------------- */
+/**
+ * Inject the Lethal Fantasy dice tray into the chat sidebar.
+ */
+Hooks.on("renderChatLog", (_chatLog, html) => applications.injectDiceTray(_chatLog, html))
+
 /**
  * Register world usage statistics
  * @param {string} registerKey

module/applications/_module.mjs

@@ -9,4 +9,5 @@ export { default as LethalFantasySpellSheet } from "./sheets/spell-sheet.mjs"
 export { default as LethalFantasyEquipmentSheet } from "./sheets/equipment-sheet.mjs"
 export { default as LethalFantasyShieldSheet } from "./sheets/shield-sheet.mjs"
 export { default as LethalFantasyMiracleSheet } from "./sheets/miracle-sheet.mjs"
+export { injectDiceTray } from "./free-roll.mjs"
 

module/applications/combat.mjs

@@ -18,6 +18,7 @@ export class LethalFantasyCombatTracker extends foundry.applications.sidebar.tab
     actions: {
       initiativePlus: LethalFantasyCombatTracker.#initiativePlus,
       initiativeMinus: LethalFantasyCombatTracker.#initiativeMinus,
+      rollMonsterProgression: LethalFantasyCombatTracker.#rollMonsterProgression,
     },
   });
 
@@ -49,6 +50,15 @@ export class LethalFantasyCombatTracker extends foundry.applications.sidebar.tab
     c.update({ 'initiative': newInit });
   }
 
+  /**
+   * Roll progression dice for all monster combatants that are eligible this round.
+   * @param {Event} ev Click event.
+   */
+  static async #rollMonsterProgression(ev) {
+    ev.preventDefault();
+    await game.combat.rollMonsterProgression();
+  }
+
   activateListeners(html) {
     super.activateListeners(html);
     // Display Combat settings
@@ -100,29 +110,60 @@ export class LethalFantasyCombat extends Combat {
     return this.turns = turns;
   }
 
+  async startCombat() {
+    this._playCombatSound("startEncounter")
+    const updateData = { round: 0, turn: 0 }
+    Hooks.callAll("combatStart", this, updateData)
+    await this.update(updateData)
+    return this
+  }
+
   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);
-      let user = game.users.find(u => u.active && u.character && u.character.id === c.actor.id);
-      if (user?.hasPlayerOwner) {
-        console.log("Rolling initiative for", c.actor.name);
-        game.socket.emit(`system.${SYSTEM.id}`, { type: "rollInitiative", actorId: c.actor.id, combatId: this.id, combatantId: c.id });
+      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: "rollInitiative", userId: playerOwner.id, actorId: c.actor.id, combatId: this.id, combatantId: c.id });
       } else {
-        user = game.users.find(u => u.active && u.isGM);
-        c.actor.system.rollInitiative(this.id, c.id);
+        await c.actor.system.rollInitiative(this.id, c.id);
       }
     }
 
     return this;
   }
 
+  /** Roll progression dice for all eligible monster combatants this round. Called manually by the GM. */
+  async rollMonsterProgression() {
+    const currentRound = this.round;
+    const monsters = this.combatants.filter(c => c.actor?.type === "monster" && !c.isDefeated);
+
+    if (monsters.length === 0) {
+      ui.notifications.warn("No monsters in combat.");
+      return;
+    }
+
+    let rolled = 0;
+    for (let c of monsters) {
+      if (c.initiative !== null && currentRound >= c.initiative) {
+        await c.actor.system.rollProgressionDice(this.id, c.id);
+        rolled++;
+      }
+    }
+
+    if (rolled === 0) {
+      const earliest = monsters.reduce((min, c) => (c.initiative !== null && c.initiative < min) ? c.initiative : min, Infinity);
+      if (earliest === Infinity) {
+        ui.notifications.warn("Monsters have no initiative set. Roll initiative first.");
+      } else {
+        ui.notifications.info(`No monsters act yet — earliest monster initiative is ${earliest} (current round: ${currentRound}).`);
+      }
+    } else {
+      this._monsterProgressionRolledRound = currentRound;
+    }
+  }
+
   resetProgression(cId) {
     let c = this.combatants.get(cId);
     c.update({ 'system.progressionCount': 0 });
@@ -144,15 +185,12 @@ export class LethalFantasyCombat extends Combat {
   }
 
   async nextTurn() {
-    console.log("NEXT TURN");
-
     let turn = this.turn ?? -1;
     let skipDefeated = this.settings.skipDefeated;
 
     // Determine the next turn number
     let next = null;
     for (let [i, t] of this.turns.entries()) {
-      console.log("Turn", t);
       if (i <= turn) continue;
       if (skipDefeated && t.isDefeated) continue;
       next = i;
@@ -176,7 +214,6 @@ export class LethalFantasyCombat extends Combat {
     this.turnsDone = false
 
     let turn = this.turn === null ? null : 0; // Preserve the fact that it's no-one's turn currently.
-    console.log("ROUND", this);
 
     let advanceTime = Math.max(this.turns.length - this.turn, 0) * CONFIG.time.turnTime;
     advanceTime += CONFIG.time.roundTime;
@@ -194,14 +231,29 @@ 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) {
-        let user = game.users.find(u => u.active && u.character && u.character.id === c.actor.id);
-        if (user?.hasPlayerOwner) {
-          game.socket.emit(`system.${SYSTEM.id}`, { type: "rollProgressionDice", progressionCount: c.system.progressionCount + 1, actorId: c.actor.id, combatId: this.id, combatantId: c.id });
+        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 });
         } else {
-          user = game.users.find(u => u.active && u.isGM);
-          c.actor.system.rollProgressionDice(this.id, c.id);
+          await c.actor.system.rollProgressionDice(this.id, c.id);
         }
       }
     }

module/applications/free-roll.mjs

@@ -0,0 +1,155 @@
+/**
+ * Free Dice Tray — injected into the Foundry chat sidebar.
+ *
+ * Provides a compact bar for GM and players to roll any standard die (d4–d30)
+ * or its exploding variant (dXx) without needing an actor sheet.
+ * Supports selecting how many dice to roll (1–9).
+ */
+
+/** Standard dice available in Lethal Fantasy */
+const DICE_TYPES = ["d4", "d6", "d8", "d10", "d12", "d20", "d30"]
+
+/**
+ * Inject the dice tray bar into the ChatLog HTML.
+ * Called from `Hooks.on("renderChatLog", ...)`.
+ *
+ * @param {Application} _chatLog
+ * @param {HTMLElement|jQuery} html
+ */
+export function injectDiceTray(_chatLog, html) {
+  const el = (html instanceof HTMLElement) ? html : (html[0] ?? html)
+  if (!el?.querySelector) return
+  if (el.querySelector(".lf-dice-tray")) return
+
+  const bar = document.createElement("div")
+  bar.className = "lf-dice-tray"
+
+  const diceButtons = DICE_TYPES.map(d =>
+    `<button type="button" class="lf-dt-die-btn" data-die="${d}" title="${d.toUpperCase()}">${d.toUpperCase()}</button>`
+  ).join("")
+
+  const countOptions = Array.from({ length: 9 }, (_, i) =>
+    `<option value="${i + 1}">${i + 1}</option>`
+  ).join("")
+
+  bar.innerHTML = `
+    <div class="lf-dt-row">
+      <span class="lf-dt-label"><i class="fa-solid fa-dice"></i></span>
+      <select class="lf-dt-count" title="${game.i18n.localize("LETHALFANTASY.DiceTray.CountTitle")}">
+        ${countOptions}
+      </select>
+      <div class="lf-dt-dice">${diceButtons}</div>
+      <label class="lf-dt-explode-label" title="${game.i18n.localize("LETHALFANTASY.DiceTray.ExplodeTitle")}">
+        <input type="checkbox" class="lf-dt-explode" />
+        <i class="fa-solid fa-explosion"></i>
+      </label>
+    </div>
+  `
+
+  bar.addEventListener("click", async ev => {
+    const btn = ev.target.closest(".lf-dt-die-btn")
+    if (!btn) return
+    ev.stopPropagation()
+
+    const dieType = btn.dataset.die
+    const count = parseInt(bar.querySelector(".lf-dt-count").value) || 1
+    const explode = bar.querySelector(".lf-dt-explode").checked
+
+    try {
+      await rollFreeDie(dieType, count, explode)
+    } catch (err) {
+      console.error("Lethal Fantasy | Dice Tray error:", err)
+      ui.notifications?.error("Dice Tray roll failed — see console")
+    }
+  })
+
+  const anchor = el.querySelector(".chat-form")
+    ?? el.querySelector(".chat-message-form")
+    ?? el.querySelector("form")
+  if (anchor) {
+    anchor.parentElement.insertBefore(bar, anchor)
+  } else {
+    el.appendChild(bar)
+  }
+}
+
+/**
+ * Roll one or more dice of the given type and post the result to chat.
+ * For exploding dice, follows the Lethal Fantasy rule: each exploded reroll
+ * contributes (result − 1) to the total, same as all other system rolls.
+ *
+ * @param {string}  dieType  Die face, e.g. "d20"
+ * @param {number}  count    Number of dice to roll (1–9)
+ * @param {boolean} explode  Whether to use the exploding variant (max triggers reroll at −1)
+ * @returns {Promise<void>}
+ */
+export async function rollFreeDie(dieType, count = 1, explode = false) {
+  const sides = parseInt(dieType.replace("d", "")) || 20
+  const baseFormula = `1d${sides}`
+  const label = explode
+    ? `${count}${dieType.toUpperCase()}E`
+    : `${count}${dieType.toUpperCase()}`
+
+  const dieLabel = dieType.toUpperCase()
+  const dieChips = []
+  let total = 0
+
+  for (let i = 0; i < count; i++) {
+    const r0 = await new Roll(baseFormula).evaluate()
+    if (game?.dice3d) await game.dice3d.showForRoll(r0, game.user, true)
+    let diceResult = r0.dice[0].results[0].result
+    dieChips.push({ label: dieLabel, value: diceResult, exploded: false })
+    total += diceResult
+
+    if (explode) {
+      while (diceResult === sides) {
+        const rx = await new Roll(baseFormula).evaluate()
+        if (game?.dice3d) await game.dice3d.showForRoll(rx, game.user, true)
+        diceResult = rx.dice[0].results[0].result
+        const contrib = diceResult - 1
+        dieChips.push({ label: `${dieLabel}-1`, value: contrib, exploded: true })
+        total += contrib
+      }
+    }
+  }
+
+  const resultHtml = dieChips.map(chip => {
+    const isMax = !chip.exploded && chip.value === sides
+    const isMin = chip.value === 1
+    const explodeIcon = chip.exploded ? `<i class="fa-solid fa-burst lf-dt-explode-icon"></i>` : ""
+    const classes = ["lf-frc-die-chip", isMax ? "lf-frc-max" : "", isMin ? "lf-frc-min" : ""].filter(Boolean).join(" ")
+    return `<div class="${classes}">
+      <span class="lf-frc-die-type">${chip.label}</span>
+      <span class="lf-frc-die-sep">→</span>
+      <span class="lf-frc-die-val">${chip.value}${explodeIcon}</span>
+    </div>`
+  }).join("")
+
+  const totalLabel = game.i18n.localize("LETHALFANTASY.Label.total").toUpperCase()
+  const content = `
+    <div class="lf-free-roll-card">
+      <div class="lf-frc-header">
+        <i class="fa-solid fa-dice"></i>
+        <span class="lf-frc-title-text">${game.i18n.localize("LETHALFANTASY.DiceTray.ChatTitle")}</span>
+        <span class="lf-frc-badge">${label}</span>
+      </div>
+      <div class="lf-frc-dice">${resultHtml}</div>
+      <div class="lf-frc-total-bar">
+        <span class="lf-frc-total-label">${totalLabel}</span>
+        <span class="lf-frc-total-value">${total}</span>
+      </div>
+    </div>
+  `
+
+  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,
+  }
+  await ChatMessage.create(msgData)
+}

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
@@ -95,13 +96,26 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
     const doc = this.document
     switch (partId) {
       case "main":
+        context.armorDR = this.actor.getArmorDR()
+        context.damageReduction = this.actor.computeDamageReduction()
+        context.damageReductionShield = this.actor.getShieldDR()
         break
-      case "skills":
+      case "skills": {
         context.tab = context.tabs.skills
         context.skills = doc.itemTypes.skill
+        // Organiser les skills par catégorie
+        const categories = ['layperson', 'professional', 'weapon', 'armor', 'resist']
+        context.skillsByCategory = categories.map(cat => {
+          return {
+            category: cat,
+            label: `LETHALFANTASY.Skill.Category.${cat}`,
+            skills: context.skills.filter(s => s.system.category === cat)
+          }
+        }).filter(catData => catData.skills.length > 0)
         context.gifts = doc.itemTypes.gift
         context.vulnerabilities = doc.itemTypes.vulnerability
         break
+      }
       case "spells":
         context.tab = context.tabs.spells
         context.spells = doc.itemTypes.spell
@@ -159,7 +173,7 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
     })
     if (!roll) return null
 
-    await roll.toMessage({}, { rollMode: roll.options.rollMode })
+    await roll.toMessage({}, { messageMode: roll.options.rollMode })
   }
 
   static async #onRollInitiative(event, target) {
@@ -206,6 +220,75 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
     this.actor.update({ "system.aetherPoints.value": points })
   }
 
+  /**
+   * Handles spell damage roll from the spell sheet tab.
+   * Shows a DR dialog then rolls the appropriate damage formula.
+   * @param {PointerEvent} event
+   * @param {HTMLElement} target
+   */
+  static async #onRollSpellDamage(event, target) {
+    if (this.isEditMode) return
+    const itemId = target.dataset.itemId
+    const tier = target.dataset.damageTier
+    const spell = this.actor.items.get(itemId)
+    if (!spell) return
+
+    const formulaMap = {
+      standard: spell.system.damageDice,
+      overpowered: spell.system.damageDiceOverpowered,
+      overpowered2: spell.system.damageDiceOverpowered2,
+    }
+    const formula = formulaMap[tier]
+    if (!formula) return
+
+    const manualDR = await foundry.applications.api.DialogV2.wait({
+      window: { title: game.i18n.localize("LETHALFANTASY.Combat.spellDRDialogTitle") },
+      classes: ["lethalfantasy"],
+      position: { width: 320 },
+      content: `<div style="padding:0.5rem 0">
+        <p style="margin-bottom:0.6rem">${game.i18n.localize("LETHALFANTASY.Combat.spellDRDialogMsg")}</p>
+        <div style="display:flex;align-items:center;gap:0.5rem">
+          <label style="font-weight:bold">${game.i18n.localize("LETHALFANTASY.Combat.spellDRLabel")}</label>
+          <input type="number" name="manualDr" value="0" min="0" style="width:5rem"/>
+        </div>
+      </div>`,
+      buttons: [
+        {
+          action: "noDR",
+          label: game.i18n.localize("LETHALFANTASY.Combat.spellNoDR"),
+          icon: "fa-solid fa-wand-magic-sparkles",
+          callback: () => 0
+        },
+        {
+          action: "applyDR",
+          label: game.i18n.localize("LETHALFANTASY.Combat.spellApplyDR"),
+          icon: "fa-solid fa-shield",
+          callback: (event, button) => Number(button.form?.elements?.manualDr?.value) || 0
+        },
+        {
+          action: "cancel",
+          label: game.i18n.localize("LETHALFANTASY.Combat.proceedNo"),
+          callback: () => "cancel"
+        }
+      ],
+      rejectClose: false
+    })
+    if (manualDR === null || manualDR === "cancel") return
+
+    const rollOpts = {
+      type: "spell-damage",
+      rollType: "spell-damage",
+      rollName: `${spell.name} — ${formula}`,
+      isDamage: true,
+      rollData: { isDamage: true },
+      manualDR,
+      actorId: this.actor.id,
+      actorName: this.actor.name,
+      actorImage: this.actor.img
+    }
+    await LethalFantasyRoll.rollSpellDamageToMessage(formula, rollOpts)
+  }
+
   static #onCreateEquipment(event, target) {
   }
 
@@ -246,9 +329,11 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
 
   async _onRoll(event, target) {
     if (this.isEditMode) return
-    const rollType = event.target.dataset.rollType
-    let rollKey = event.target.dataset.rollKey;
-    let rollDice = event.target.dataset?.rollDice;
+    const el = event.currentTarget
+    const rollType = el.dataset.rollType
+    if (!rollType) return
+    let rollKey = el.dataset.rollKey
+    let rollDice = el.dataset.rollDice
 
     this.actor.prepareRoll(rollType, rollKey, rollDice)
 

module/applications/sheets/monster-sheet.mjs

@@ -111,11 +111,13 @@ export default class LethalFantasyMonsterSheet extends LethalFantasyActorSheet {
     })
     if (!roll) return null
 
-    await roll.toMessage({}, { rollMode: roll.options.rollMode })
+    await roll.toMessage({}, { messageMode: roll.options.rollMode })
   }
 
   static async #onRollInitiative(event, target) {
-    await this.document.system.rollInitiative(event, target)
+    const combat = game.combat
+    const combatant = combat?.combatants.find(c => c.actorId === this.document.id)
+    await this.document.system.rollInitiative(combat?.id, combatant?.id)
   }
 
   getBestWeaponClassSkill(skills, rollType, multiplier = 1.0) {
@@ -162,9 +164,11 @@ export default class LethalFantasyMonsterSheet 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 || "0"
+    const rollable = event.target.closest('.rollable')
+    if (!rollable) return
+    const rollType = rollable.dataset.rollType
+    let rollKey = rollable.dataset.rollKey
+    let rollDice = rollable.dataset?.rollDice || "0"
     this.actor.system.prepareMonsterRoll(rollType, rollKey, rollDice)
   }
 }

module/config/d30_results_tables.json

@@ -0,0 +1,675 @@
+{
+  "d30_dice_results": {
+    "30": {
+      "melee_attack": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_strike",
+            "options": [
+              "lethal",
+              "vital"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D20E",
+            "target": "attack"
+          }
+        ],
+        "description": "Possible Lethal or Vital Strike or Add D20E to Attack"
+      },
+      "ranged_attack": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_strike",
+            "options": [
+              "lethal",
+              "vital"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D20E",
+            "target": "attack"
+          }
+        ],
+        "description": "Possible Lethal or Vital Strike or Add D20E to Attack"
+      },
+      "melee_defense": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_defense",
+            "options": [
+              "flawless",
+              "legendary"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D20E",
+            "target": "defense"
+          }
+        ],
+        "description": "Possible Flawless or Legendary Defense or Add D20E to Defense"
+      },
+      "arcane_spell_attack": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_strike",
+            "options": [
+              "lethal_magical",
+              "vital_magical"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D20E",
+            "target": "spell_attack"
+          }
+        ],
+        "description": "Possible Lethal or Vital Magical Strike or Add D20E to Spell Attack"
+      },
+      "arcane_spell_defense": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "spell_calamity"
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D20E",
+            "target": "spell_defense"
+          }
+        ],
+        "description": "Possible Spell Catastrophe or adds D20E to Spell Defense"
+      },
+      "skill_rolls": {
+        "type": "skill_auto_success",
+        "description": "Skill Succeeds Regardless of Opposing Roll"
+      },
+      "ranged_defense": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_defense",
+            "options": [
+              "flawless",
+              "legendary"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D20E",
+            "target": "defense"
+          }
+        ],
+        "description": "Possible Flawless or Legendary Defense or Add D20E to Defense"
+      },
+      "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"
+      },
+      "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"
+      }
+    },
+    "27": {
+      "melee_attack": {
+        "type": "bonus_dice",
+        "dice": "D6",
+        "target": "attack",
+        "description": "Granted D6 (1-6) Attack Modifier for This Melee Attack"
+      },
+      "ranged_attack": {
+        "type": "bonus_dice",
+        "dice": "D6",
+        "target": "attack",
+        "description": "Granted D6 (1-6) Attack Modifier for This Ranged Attack"
+      },
+      "melee_defense": {
+        "type": "luck_die",
+        "scope": "combat",
+        "description": "Granted 1 Luck dice for Use in This Combat Only"
+      },
+      "arcane_spell_attack": {
+        "type": "no_lethargy",
+        "description": "No Spell Lethargy the Aether Approves of Characters Efforts"
+      },
+      "arcane_spell_defense": {
+        "type": "flash_of_pain",
+        "duration_dice": "1D6E",
+        "target": "caster",
+        "description": "Caster Suffers Severe pain and will be under a flash of pain for 1D6E seconds"
+      },
+      "ranged_defense": {
+        "type": "luck_die",
+        "scope": "combat",
+        "description": "Granted 1 Luck dice for Use in This Combat Only"
+      }
+    },
+    "26": {
+      "melee_attack": {
+        "type": "shield_destruction",
+        "description": "Shield Destruction"
+      }
+    },
+    "25": {
+      "skill_rolls": {
+        "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",
+        "description": "Hit Inflicts Flash of Pain 1D6E seconds"
+      },
+      "ranged_attack": {
+        "type": "flash_of_pain",
+        "duration_dice": "1D6E",
+        "target": "defender",
+        "description": "Hit Inflicts Flash of Pain 1D6E seconds"
+      },
+      "melee_defense": {
+        "type": "recover_pain",
+        "description": "Defender Recovers or ignores any flash of pain"
+      },
+      "arcane_spell_attack": {
+        "type": "flash_of_pain",
+        "duration_dice": "1D6E",
+        "target": "defender",
+        "description": "Magical Damage inflicts Flash of pain 1D6E seconds"
+      },
+      "arcane_spell_defense": {
+        "type": "flash_of_pain",
+        "duration_dice": "1D6E",
+        "target": "caster",
+        "description": "Caster Suffers Severe pain and will be under a flash of pain for 1D6E seconds"
+      },
+      "skill_rolls": {
+        "type": "bonus_dice",
+        "dice": "D6",
+        "target": "skill",
+        "description": "Granted D6 (1-6) Skill Modifier for this Skill Attempt"
+      },
+      "ranged_defense": {
+        "type": "recover_pain",
+        "description": "Defender Recovers or ignores any flash of pain"
+      },
+      "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"
+          }
+        ],
+        "description": "Possible Vicious Strike or Add D12 to attack"
+      },
+      "ranged_attack": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_strike",
+            "options": [
+              "vicious"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D12",
+            "target": "attack"
+          }
+        ],
+        "description": "Possible Vicious Strike or add D12 to attack"
+      },
+      "melee_defense": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_defense",
+            "options": [
+              "perfect"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D12",
+            "target": "defense"
+          }
+        ],
+        "description": "Possible 20/20 defense that avoids Any Attack Except a Lethal Strike or adds D12 to defense"
+      },
+      "arcane_spell_attack": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_strike",
+            "options": [
+              "vicious_magical"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D12",
+            "target": "spell_attack"
+          }
+        ],
+        "description": "Possible Vicious Application of a Magical Attack or add D12 to attack"
+      },
+      "arcane_spell_defense": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_defense",
+            "options": [
+              "perfect_spell"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D12",
+            "target": "spell_defense"
+          }
+        ],
+        "description": "Possible 20/20 Spell defense that Saves Against Any Magical Attack Except a Lethal Magical Strike or add D12 to defense"
+      },
+      "skill_rolls": {
+        "type": "bonus_flat",
+        "amount": 20,
+        "target": "skill",
+        "description": "20 Added to Skill Roll"
+      },
+      "ranged_defense": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_defense",
+            "options": [
+              "perfect"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D12",
+            "target": "defense"
+          }
+        ],
+        "description": "Possible 20/20 defense that avoids Any Attack Except a Lethal Strike or adds D12 to defense"
+      },
+      "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"
+          }
+        ],
+        "description": "Bleed, Knock-back on Hit"
+      },
+      "ranged_attack": {
+        "type": "bleed",
+        "description": "Bleed"
+      },
+      "melee_defense": {
+        "type": "counter_attack",
+        "options": [
+          "kick",
+          "punch",
+          "shield_bash"
+        ],
+        "description": "Kick, Punch or Shield Bash"
+      },
+      "skill_rolls": {
+        "type": "bonus_flat",
+        "amount": 1,
+        "target": "skill",
+        "description": "Add 1 to Skill Roll"
+      },
+      "ranged_defense": {
+        "type": "counter_attack",
+        "options": [
+          "kick",
+          "punch",
+          "shield_bash"
+        ],
+        "description": "Kick, Punch or Shield Bash"
+      },
+      "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"
+      },
+      "ranged_attack": {
+        "type": "double_damage_dice",
+        "description": "Roll 2x Damage Dice"
+      }
+    },
+    "10": {
+      "melee_attack": {
+        "type": "combo",
+        "effects": [
+          {
+            "type": "bleed"
+          },
+          {
+            "type": "knockback"
+          }
+        ],
+        "description": "Bleed, Knock-back on Hit"
+      },
+      "ranged_attack": {
+        "type": "bleed",
+        "description": "Bleed"
+      },
+      "melee_defense": {
+        "type": "counter_attack",
+        "options": [
+          "kick",
+          "punch",
+          "shield_bash"
+        ],
+        "description": "Kick, Punch or Shield Bash"
+      },
+      "skill_rolls": {
+        "type": "bonus_flat",
+        "amount": 1,
+        "target": "skill",
+        "description": "Add 1 to Skill Roll"
+      },
+      "ranged_defense": {
+        "type": "counter_attack",
+        "options": [
+          "kick",
+          "punch",
+          "shield_bash"
+        ],
+        "description": "Kick, Punch or Shield Bash"
+      },
+      "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"
+      },
+      "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",
+        "description": "Flurry Attack on Hit or Miss"
+      },
+      "ranged_attack": {
+        "type": "double_damage_dice",
+        "description": "Roll 2x Damage Dice"
+      }
+    },
+    "5": {
+      "melee_attack": {
+        "type": "combo",
+        "effects": [
+          {
+            "type": "bleed"
+          },
+          {
+            "type": "knockback"
+          }
+        ],
+        "description": "Bleed, Knock-back on Hit"
+      },
+      "ranged_attack": {
+        "type": "bleed",
+        "description": "Bleed"
+      },
+      "melee_defense": {
+        "type": "counter_attack",
+        "options": [
+          "kick",
+          "punch",
+          "shield_bash"
+        ],
+        "description": "Kick, Punch, or Shield Bash"
+      },
+      "skill_rolls": {
+        "type": "bonus_flat",
+        "amount": 1,
+        "target": "skill",
+        "description": "Add 1 to Skill Roll"
+      },
+      "ranged_defense": {
+        "type": "counter_attack",
+        "options": [
+          "kick",
+          "punch",
+          "shield_bash"
+        ],
+        "description": "Kick, Punch, or Shield Bash"
+      },
+      "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_defense": {
+        "type": "dr_multiplier",
+        "multiplier": 3,
+        "includes_shield": true,
+        "description": "DR Tripled including Shield"
+      },
+      "arcane_spell_attack": {
+        "type": "damage_multiplier",
+        "multiplier": 3,
+        "description": "Triple Damage on Spell Damage"
+      },
+      "arcane_spell_defense": {
+        "type": "bonus_dice",
+        "dice": "D12",
+        "target": "spell_defense",
+        "description": "D12 Added to Spell Defense Modifier"
+      },
+      "ranged_defense": {
+        "type": "dr_multiplier",
+        "multiplier": 3,
+        "includes_shield": true,
+        "description": "DR Tripled including Shield"
+      }
+    },
+    "2": {
+      "melee_attack": {
+        "type": "damage_multiplier",
+        "multiplier": 2,
+        "description": "Double Damage"
+      },
+      "ranged_attack": {
+        "type": "damage_multiplier",
+        "multiplier": 2,
+        "description": "Double Damage"
+      },
+      "melee_defense": {
+        "type": "dr_multiplier",
+        "multiplier": 2,
+        "includes_shield": true,
+        "description": "DR Doubled including Shield"
+      },
+      "arcane_spell_attack": {
+        "type": "damage_multiplier",
+        "multiplier": 2,
+        "description": "Double Damage on Spell Damage"
+      },
+      "arcane_spell_defense": {
+        "type": "bonus_dice",
+        "dice": "D6",
+        "target": "spell_defense",
+        "description": "D6 Added to Spell Defense Modifier"
+      },
+      "ranged_defense": {
+        "type": "dr_multiplier",
+        "multiplier": 2,
+        "includes_shield": true,
+        "description": "DR Doubled including Shield"
+      }
+    },
+    "1": {
+      "ranged_attack": {
+        "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"
+      },
+      "melee_attack": {
+        "type": "fumble",
+        "detail": "melee_fumble",
+        "description": "Possible Fumble"
+      }
+    }
+  },
+  "definitions": {
+    "flash_of_pain": "Causes the victim to defend against melee and spell attacks with disfavor. They can only walk and cannot attack, cast spells, call miracles or perform skills.",
+    "shield_destruction_condition": "Shield destruction occurs only if damage exceeds the shields DR.",
+    "matching_30s": "Matching 30s on skill rolls cancel each other out and is resolved by the skill roll.",
+    "skill_roll_30": "A 30 on a skill roll indicates success at highest level of the skill involved."
+  }
+}

module/config/system.mjs

@@ -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/_module.mjs

@@ -2,3 +2,4 @@ export { default as LethalFantasyActor } from "./actor.mjs"
 export { default as LethalFantasyItem } from "./item.mjs"
 export { default as LethalFantasyRoll } from "./roll.mjs"
 export { default as LethalFantasyChatMessage } from "./chat-message.mjs"
+export { default as D30Roll } from "./d30-roll.mjs"

module/documents/actor.mjs

@@ -65,7 +65,7 @@ export default class LethalFantasyActor extends Actor {
         }
       }
     }
-    goodSkill.weaponSkillModifier = maxValue * multiplier
+    goodSkill.weaponSkillModifier = Math.ceil(maxValue * multiplier)
     return goodSkill
   }
 
@@ -79,8 +79,82 @@ export default class LethalFantasyActor extends Actor {
   }
 
   /* *************************************************/
-  async prepareRoll(rollType, rollKey, rollDice ) {
-    console.log("Preparing roll", rollType, rollKey, rollDice)
+  computeDamageReduction() {
+    // Pour les monstres, utiliser hp.damageResistance et combat.damageReduction
+    if (this.type === "monster") {
+      let hpDR = Number(this.system.hp?.damageResistance) || 0
+      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 armorDR = this.getArmorDR()
+    return naturalDR + magicDR + armorDR
+  }
+
+  /* *************************************************/
+  getShieldDR() {
+    // Pour les monstres, utiliser combat.shieldDamageReduction
+    if (this.type === "monster") {
+      return Number(this.system.combat?.shieldDamageReduction) || 0
+    }
+    // Pour les personnages, utiliser les items de type shield
+    let dr = 0
+    for (let item of this.items) {
+      if (item.type === "shield" && item.system.equipped) {
+        dr += Number(item.system.damageReduction)
+      }
+    }
+    return dr
+  }
+
+  /* *************************************************/
+  getArmorDR() {
+    let dr = 0
+    for (let item of this.items) {
+      if (item.type === "armor" && item.system.equipped) {
+        dr += Number(item.system.damageReduction)
+      }
+    }
+    return dr
+  }
+
+  /* *************************************************/
+  getArmorDefenseValue() {
+    let defenseValue = 0
+    for (let item of this.items) {
+      if (item.type === "armor" && item.system.equipped) {
+        defenseValue += Number(item.system.defense)
+      }
+    }
+    return defenseValue
+  }
+
+  /* *************************************************/
+  fuzzyNameSearchWeaponSkills(weaponName, weaponClass = null) {
+    // Get all weapon skills without the " skill" suffix
+    let skills = this.items.filter((i) => i.type === "skill" && i.system.weaponClass === weaponClass && i.system.category === "weapon")
+    // Remove parenthesis in the weapon name for better matching
+    weaponName = weaponName.replace(/\(.*?\)/g, "").trim()
+    // Now search if we find all the words of the weapon name in the skill name
+    skills = skills.filter((s) => {
+      let skillName = s.name.toLowerCase().replace(" skill", "").trim()
+      let wName = weaponName.toLowerCase().trim()
+      let wWords = wName.split(" ")
+      for (let w of wWords) {
+        if (!skillName.includes(w)) {
+          return false
+        }
+      }
+      return true
+    })
+    return skills
+  }
+
+  /* *************************************************/
+  async prepareRoll(rollType, rollKey, rollDice, defenderId, defenderTokenId, extraShieldDr = 0) {
+    console.log("Preparing roll", rollType, rollKey, rollDice, defenderId)
     let rollTarget
     switch (rollType) {
       case "granted":
@@ -89,7 +163,7 @@ export default class LethalFantasyActor extends Actor {
           formula: foundry.utils.duplicate(this.system.granted[rollKey]),
           rollKey: rollKey
         }
-        if ( rollTarget.formula === "" || rollTarget.formula === undefined) {
+        if (rollTarget.formula === "" || rollTarget.formula === undefined) {
           rollTarget.formula = 0
         }
         break;
@@ -124,73 +198,96 @@ export default class LethalFantasyActor extends Actor {
       case "miracle-power":
         rollTarget = this.items.find((i) => (i.type === "miracle" || i.type == "spell") && i.id === rollKey)
         rollTarget.rollKey = rollKey
+        if (rollType === "spell-attack" || rollType === "spell-power") {
+          const cost = Number(rollTarget.system?.cost) || 0
+          const currentAether = Number(this.system.aetherPoints?.value) || 0
+          if (cost > currentAether) {
+            ui.notifications.warn(`${this.name} cannot cast ${rollTarget.name}: insufficient Aether (needs ${cost}, has ${currentAether}).`)
+            return
+          }
+        }
+        if (rollType === "miracle-attack" || rollType === "miracle-power") {
+          const cost = Number(rollTarget.system?.level) || 0
+          const currentGrace = Number(this.system.divinityPoints?.value) || 0
+          if (cost > currentGrace) {
+            ui.notifications.warn(`${this.name} cannot invoke ${rollTarget.name}: insufficient Grace (needs ${cost}, has ${currentGrace}).`)
+            return
+          }
+        }
         break
       case "shield-roll": {
-          rollTarget = this.items.find((i) => i.type === "shield" && i.id === rollKey)
-          let shieldSkill = this.items.find((i) => i.type === "skill" && i.name.toLowerCase() === rollTarget.name.toLowerCase())
-          rollTarget.skill = shieldSkill
-          rollTarget.rollKey = rollKey
-        }
+        rollTarget = this.items.find((i) => i.type === "shield" && i.id === rollKey)
+        let shieldSkill = this.items.find((i) => i.type === "skill" && i.name.toLowerCase() === rollTarget.name.toLowerCase())
+        rollTarget.skill = shieldSkill
+        rollTarget.rollKey = rollKey
+      }
         break;
       case "weapon-damage-small":
       case "weapon-damage-medium":
       case "weapon-attack":
       case "weapon-defense": {
-          let weapon = this.items.find((i) => i.type === "weapon" && i.id === rollKey)
-          let skill
-          let skills = this.items.filter((i) => i.type === "skill" && i.name.toLowerCase() === weapon.name.toLowerCase())
+        let weapon = this.items.find((i) => i.type === "weapon" && i.id === rollKey)
+        let skill
+        let skills = this.items.filter((i) => i.type === "skill" && i.system.category === "weapon" && i.name.toLowerCase() === weapon.name.toLowerCase())
+        if (skills.length > 0) {
+          skill = this.getBestWeaponClassSkill(skills, rollType, 1.0)
+        } else {
+          skills = this.fuzzyNameSearchWeaponSkills(weapon.name, weapon.system.weaponClass)
           if (skills.length > 0) {
             skill = this.getBestWeaponClassSkill(skills, rollType, 1.0)
           } else {
-            skills = this.items.filter((i) => i.type === "skill" && i.name.toLowerCase().replace(" skill", "") === weapon.name.toLowerCase())
+            skills = this.items.filter((i) => i.type === "skill" && i.system.category === "weapon" && i.system.weaponClass === weapon.system.weaponClass)
             if (skills.length > 0) {
-              skill = this.getBestWeaponClassSkill(skills, rollType, 1.0)
+              skill = this.getBestWeaponClassSkill(skills, rollType, 0.5)
             } else {
-              skills = this.items.filter((i) => i.type === "skill" && i.system.weaponClass === weapon.system.weaponClass)
+              skills = this.items.filter((i) => i.type === "skill" && i.system.category === "weapon" && i.system.weaponClass.includes(SYSTEM.WEAPON_CATEGORIES[weapon.system.weaponClass]))
               if (skills.length > 0) {
-                skill = this.getBestWeaponClassSkill(skills, rollType, 0.5)
+                skill = this.getBestWeaponClassSkill(skills, rollType, 0.25)
               } else {
-                skills = this.items.filter((i) => i.type === "skill" && i.system.weaponClass.includes(SYSTEM.WEAPON_CATEGORIES[weapon.system.weaponClass]))
-                if (skills.length > 0) {
-                  skill = this.getBestWeaponClassSkill(skills, rollType, 0.25)
-                } else {
-                  ui.notifications.warn(game.i18n.localize("LETHALFANTASY.Notifications.skillNotFound"))
-                  return
-                }
+                ui.notifications.warn(game.i18n.localize("LETHALFANTASY.Notifications.skillNotFound"))
+                return
               }
             }
           }
-          if (!weapon || !skill) {
-            console.error("Weapon or skill not found", weapon, skill)
-            ui.notifications.warn(game.i18n.localize("LETHALFANTASY.Notifications.skillNotFound"))
-            return
-          }
-          rollTarget = skill
-          rollTarget.weapon = weapon
-          rollTarget.weaponSkillModifier = skill.weaponSkillModifier
-          rollTarget.rollKey = rollKey
-          rollTarget.combat = foundry.utils.duplicate(this.system.combat)
-          if ( rollType === "weapon-damage-small" || rollType === "weapon-damage-medium") {
-            rollTarget.grantedDice = this.system.granted.damageDice
-          }
-          if ( rollType === "weapon-attack") {
-            rollTarget.grantedDice = this.system.granted.attackDice
-          }
-          if ( rollType === "weapon-defense") {
-            rollTarget.grantedDice = this.system.granted.defenseDice
-          }
         }
+        if (!weapon || !skill) {
+          console.error("Weapon or skill not found", weapon, skill)
+          ui.notifications.warn(game.i18n.localize("LETHALFANTASY.Notifications.skillNotFound"))
+          return
+        }
+        // Créer un objet plain au lieu de modifier directement le skill
+        rollTarget = {
+          ...skill,
+          weapon: weapon,
+          weaponSkillModifier: skill.weaponSkillModifier,
+          rollKey: rollKey,
+          combat: foundry.utils.duplicate(this.system.combat),
+          isRangedAttack: weapon.system.weaponType === "ranged"
+        }
+        if (rollType === "weapon-damage-small" || rollType === "weapon-damage-medium") {
+          rollTarget.grantedDice = this.system.granted.damageDice
+        }
+        if (rollType === "weapon-attack") {
+          rollTarget.grantedDice = this.system.granted.attackDice
+        }
+        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)
+    await this.system.roll(rollType, rollTarget, defenderId, defenderTokenId, extraShieldDr)
   }
 
 }

module/documents/d30-roll.mjs

@@ -0,0 +1,226 @@
+/**
+ * Classe pour gérer les résultats du D30 dans Lethal Fantasy
+ */
+export default class D30Roll {
+  /**
+   * Table des résultats D30 chargée depuis le fichier JSON
+   * @type {Object}
+   */
+  static resultsTable = null
+
+  /**
+   * Définitions des conditions spéciales
+   * @type {Object}
+   */
+  static definitions = null
+
+  /**
+   * Types de jets supportés
+   * @type {Object}
+   */
+  static ROLL_TYPES = {
+    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",
+    SAVING_THROWS: "saving_throws"
+  }
+
+  /**
+   * Initialise la classe en chargeant la table des résultats
+   * @returns {Promise<void>}
+   */
+  static async initialize() {
+    try {
+      const response = await fetch("systems/fvtt-lethal-fantasy/module/config/d30_results_tables.json")
+      const data = await response.json()
+
+      this.resultsTable = data.d30_dice_results
+      this.definitions = data.definitions
+
+      console.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")
+    }
+  }
+
+  /**
+   * Récupère le résultat d'un jet de D30 sous forme d'objet structuré.
+   * @param {number} diceValue La valeur du dé (1-30)
+   * @param {string} rollType Le type de jet externe (ex: "weapon-attack", "spell-attack", etc.)
+   * @param {Object} weapon L'arme ou l'objet utilisé (optionnel, nécessaire pour certains types)
+   * @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, options = {}) {
+    if (!this.resultsTable) {
+      console.warn("D30Roll | Results table is not initialized. Call D30Roll.initialize() first.")
+      return null
+    }
+
+    if (diceValue < 1 || diceValue > 30) {
+      console.warn(`D30Roll | Invalid dice value: ${diceValue}. Must be between 1 and 30.`)
+      return null
+    }
+
+    const internalType = this.convertToInternalType(rollType, weapon, options)
+
+    if (!internalType) {
+      console.warn(`D30Roll | Could not convert roll type: ${rollType}`)
+      return null
+    }
+
+    if (!Object.values(this.ROLL_TYPES).includes(internalType)) {
+      console.warn(`D30Roll | Invalid internal roll type: ${internalType}`)
+      return null
+    }
+
+    const resultEntry = this.resultsTable[diceValue]
+    if (!resultEntry) {
+      console.warn(`D30Roll | No entry found for value ${diceValue}`)
+      return null
+    }
+
+    const result = resultEntry[internalType]
+    return result ?? null
+  }
+
+  /**
+   * Retourne le type d'effet d'un résultat D30.
+   * @param {Object|null} result L'objet retourné par getResult()
+   * @returns {string|null} Le type d'effet ou null
+   */
+  static getEffectType(result) {
+    return result?.type ?? null
+  }
+
+  /**
+   * Convertit un rollType externe en rollType interne
+   * @param {string} externalType Le type de jet externe (ex: "weapon-attack")
+   * @param {Object} weapon L'arme ou l'objet utilisé (optionnel)
+   * @param {Object} options Options supplémentaires (optionnel)
+   * @param {boolean} options.isRanged Si true, utilise ranged_defense au lieu de melee_defense
+   * @returns {string|null} Le type interne correspondant ou null
+   */
+  static convertToInternalType(externalType, weapon = null, 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")
+        // Fall through to use options.isRanged if available, otherwise default melee
+      }
+      return (options.isRanged || weapon?.system?.weaponType === "ranged")
+        ? this.ROLL_TYPES.RANGED_ATTACK
+        : this.ROLL_TYPES.MELEE_ATTACK
+    }
+
+    // Monster attacks - check options.isRanged (set from rollTarget.attackMode) or weapon type
+    if (externalType === "monster-attack") {
+      if (options.isRanged || weapon?.system?.weaponType === "ranged") {
+        return this.ROLL_TYPES.RANGED_ATTACK
+      }
+      return this.ROLL_TYPES.MELEE_ATTACK
+    }
+
+    // Defense types
+    if (externalType === "weapon-defense" || externalType === "monster-defense") {
+      return options.isRanged ? this.ROLL_TYPES.RANGED_DEFENSE : this.ROLL_TYPES.MELEE_DEFENSE
+    }
+
+    // Spell types
+    if (externalType === "spell-attack" || externalType === "spell" || externalType === "spell-power") {
+      return this.ROLL_TYPES.ARCANE_SPELL_ATTACK
+    }
+
+    // Skill types
+    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
+  }
+
+  /**
+   * Récupère toutes les informations pour une valeur de dé donnée
+   * @param {number} diceValue La valeur du dé (1-30)
+   * @returns {Object|null} Tous les résultats pour cette valeur ou null
+   */
+  static getAllResultsForValue(diceValue) {
+    if (!this.resultsTable) {
+      console.warn("D30Roll | Results table is not initialized.")
+      return null
+    }
+
+    if (diceValue < 1 || diceValue > 30) {
+      console.warn(`D30Roll | Invalid dice value: ${diceValue}`)
+      return null
+    }
+
+    return this.resultsTable[diceValue]
+  }
+
+  /**
+   * Récupère la définition d'une condition spéciale
+   * @param {string} definitionKey La clé de la définition (ex: "flash_of_pain")
+   * @returns {string|null} La définition ou null
+   */
+  static getDefinition(definitionKey) {
+    if (!this.definitions) {
+      console.warn("D30Roll | Definitions are not initialized.")
+      return null
+    }
+
+    return this.definitions[definitionKey] || null
+  }
+
+  /**
+   * Vérifie si un résultat est vide
+   * @param {Object|null} result Le résultat à vérifier
+   * @returns {boolean} True si le résultat est vide
+   */
+  static isEmptyResult(result) {
+    return !result || !result.type
+  }
+
+  /**
+   * Récupère un résultat formaté pour l'affichage
+   * @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, options = {}) {
+    const result = this.getResult(diceValue, rollType, weapon, options)
+    const internalType = this.convertToInternalType(rollType, weapon, options)
+
+    return {
+      value: diceValue,
+      rollType: rollType,
+      internalType: internalType,
+      result: result,
+      isEmpty: this.isEmptyResult(result),
+      hasResult: !this.isEmptyResult(result)
+    }
+  }
+
+  /**
+   * Vérifie si la table est chargée
+   * @returns {boolean} True si la table est chargée
+   */
+  static isInitialized() {
+    return this.resultsTable !== null && this.definitions !== null
+  }
+}

module/documents/roll.mjs

@@ -1,5 +1,6 @@
 import { SYSTEM } from "../config/system.mjs"
 import LethalFantasyUtils from "../utils.mjs"
+import D30Roll from "./d30-roll.mjs"
 
 export default class LethalFantasyRoll extends Roll {
   /**
@@ -92,6 +93,10 @@ export default class LethalFantasyRoll extends Roll {
     return this.options.D30result
   }
 
+  get D30message() {
+    return this.options.D30message
+  }
+
   get badResult() {
     return this.options.badResult
   }
@@ -100,6 +105,10 @@ export default class LethalFantasyRoll extends Roll {
     return this.options.rollData
   }
 
+  get defenderId() {
+    return this.options.defenderId
+  }
+
   /**
    * Prompt the user with a dialog to configure and execute a roll.
    *
@@ -134,6 +143,7 @@ export default class LethalFantasyRoll extends Roll {
     let beyondSkill = false
     let hasStaticModifier = false
     let hasExplode = true
+    let actor = game.actors.get(options.actorId)
 
     if (options.rollType === "challenge" || options.rollType === "save") {
       options.rollName = game.i18n.localize(`LETHALFANTASY.Label.${options.rollTarget.rollKey}`)
@@ -172,6 +182,7 @@ export default class LethalFantasyRoll extends Roll {
       } else {
         options.rollTarget.value = options.rollTarget.defenseModifier
         options.rollTarget.charModifier = 0
+        options.isRangedDefense = options.rollTarget.isRangedDefense ?? false
       }
 
     } else if (options.rollType === "monster-skill") {
@@ -209,8 +220,14 @@ export default class LethalFantasyRoll extends Roll {
           options.rollTarget.charModifier = options.rollTarget.combat.rangedAttackModifier
         }
       } else {
-        options.rollTarget.value = options.rollTarget.combat.defenseModifier + options.rollTarget.weaponSkillModifier + options.rollTarget.weapon.system.bonuses.defenseBonus
-        options.rollTarget.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") {
@@ -220,6 +237,7 @@ export default class LethalFantasyRoll extends Roll {
       baseFormula = "D20"
       hasModifier = true
       hasChangeDice = false
+      hasFavor = true
       options.rollTarget.value = options.rollTarget.actorModifiers.levelSpellModifier + options.rollTarget.actorModifiers.intSpellModifier
       options.rollTarget.charModifier = options.rollTarget.actorModifiers.intSpellModifier
       hasStaticModifier = options.rollType === "spell-power"
@@ -236,6 +254,7 @@ export default class LethalFantasyRoll extends Roll {
       dice = "1D20"
       baseFormula = "D20"
       hasChangeDice = false
+      hasFavor = true
       options.rollTarget.value = options.rollTarget.actorModifiers.levelMiracleModifier + options.rollTarget.actorModifiers.chaMiracleModifier
       options.rollTarget.charModifier = options.rollTarget.actorModifiers.chaMiracleModifier
       hasStaticModifier = options.rollType === "miracle-power"
@@ -255,25 +274,34 @@ 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")) {
       options.rollName = options.rollTarget.name
+      options.isDamage = true
       hasModifier = true
       hasChangeDice = false
       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 = dice.replace("E", "")
+      if (/NE$/i.test(dice)) {
+        hasMaxValue = false
+        hasExplode = false
+      }
+      dice = dice.replace(/NE$/i, "").replace("E", "")
       baseFormula = dice
 
     } else if (options.rollType.includes("monster-damage")) {
       options.rollName = options.rollTarget.name
+      options.isDamage = true
       hasModifier = true
       hasChangeDice = false
       options.rollTarget.value = options.rollTarget.damageModifier
@@ -281,6 +309,10 @@ export default class LethalFantasyRoll extends Roll {
       dice = options.rollTarget.damageDice
       dice = dice.replace("E", "")
       baseFormula = dice
+      if (options.rollTarget.noExplode) {
+        hasMaxValue = false
+        hasExplode = false
+      }
     }
 
 
@@ -290,8 +322,8 @@ export default class LethalFantasyRoll extends Roll {
       hasModifier = false
     }
 
-    const rollModes = foundry.utils.duplicate(CONFIG.Dice.rollModes); // v12 : Object.fromEntries(Object.entries(CONFIG.Dice.rollModes).map(([key, value]) => [key, game.i18n.localize(value)]))
-    console.log("Roll mode", rollModes)
+    const rollModes = foundry.utils.duplicate(CONFIG.ChatMessage.modes);
+
 
     const fieldRollMode = new foundry.data.fields.StringField({
       choices: rollModes,
@@ -306,6 +338,10 @@ export default class LethalFantasyRoll extends Roll {
     let modifier = "+0"
     let targetName
 
+    // True for any ranged attack: PC weapon (ranged type) or monster attack (ranged mode)
+    const isRangedAttack = (options.rollType === "weapon-attack" && options.rollTarget?.weapon?.system?.weaponType === "ranged")
+      || (options.rollType === "monster-attack" && options.rollTarget?.attackMode === "ranged")
+
     let dialogContext = {
       rollType: options.rollType,
       rollTarget: options.rollTarget,
@@ -330,60 +366,78 @@ export default class LethalFantasyRoll extends Roll {
       modifier,
       saveSpell: false,
       favor: "none",
-      targetName
+      targetName,
+      isRangedAttack
     }
-    const content = await foundry.applications.handlebars.renderTemplate("systems/fvtt-lethal-fantasy/templates/roll-dialog.hbs", dialogContext)
+    let rollContext
+    if (options.rollContext) {
+      rollContext = foundry.utils.duplicate(options.rollContext)
+      hasGrantedDice = !!rollContext.hasGrantedDice
+      pointBlank = !!rollContext.pointBlank
+      beyondSkill = !!rollContext.beyondSkill
+      letItFly = !!rollContext.letItFly
+      saveSpell = !!rollContext.saveSpell
+      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}`
+      rollContext.attackerAim ||= "0"
+    } else {
+      const content = await foundry.applications.handlebars.renderTemplate("systems/fvtt-lethal-fantasy/templates/roll-dialog.hbs", dialogContext)
 
-    let position = game.user.getFlag(SYSTEM.id, "roll-dialog-pos") || { top: -1, left: -1 }
-    const label = game.i18n.localize("LETHALFANTASY.Roll.roll")
-    const rollContext = await foundry.applications.api.DialogV2.wait({
-      window: { title: "Roll dialog" },
-      classes: ["lethalfantasy"],
-      content,
-      position,
-      buttons: [
-        {
-          label: label,
-          callback: (event, button, dialog) => {
-            console.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
-              return obj
-            }, {})
-            return output
+      let position = game.user.getFlag(SYSTEM.id, "roll-dialog-pos") || { top: -1, left: -1 }
+      const label = game.i18n.localize("LETHALFANTASY.Roll.roll")
+      rollContext = await foundry.applications.api.DialogV2.wait({
+        window: { title: "Roll dialog" },
+        classes: ["lethalfantasy"],
+        content,
+        position,
+        buttons: [
+          {
+            label: label,
+            callback: (event, button, dialog) => {
+              console.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
+                return obj
+              }, {})
+              return output
+            },
           },
-        },
-      ],
-      actions: {
-        "selectGranted": (event, button, dialog) => {
-          hasGrantedDice = event.target.checked
-        },
-        "selectBeyondSkill": (event, button, dialog) => {
-          beyondSkill = button.checked
-        },
-        "selectPointBlank": (event, button, dialog) => {
-          pointBlank = button.checked
-        },
-        "selectLetItFly": (event, button, dialog) => {
-          letItFly = button.checked
-        },
-        "saveSpellCheck": (event, button, dialog) => {
-          saveSpell = button.checked
-        },
-        "gotoToken": (event, button, dialog) => {
-          let tokenId = $(button).data("tokenId")
-          let token = canvas.tokens?.get(tokenId)
-          if (token) {
-            canvas.animatePan({ x: token.x, y: token.y, duration: 200 })
-            canvas.tokens.releaseAll();
-            token.control({ releaseOthers: true });
+        ],
+        actions: {
+          "selectGranted": (event, button) => {
+            hasGrantedDice = event.target.checked
+          },
+          "selectBeyondSkill": (event, button) => {
+            beyondSkill = button.checked
+          },
+          "selectPointBlank": (event, button) => {
+            pointBlank = button.checked
+          },
+          "selectLetItFly": (event, button) => {
+            letItFly = button.checked
+          },
+          "saveSpellCheck": (event, button) => {
+            saveSpell = button.checked
+          },
+          "gotoToken": (event, button) => {
+            let tokenId = $(button).data("tokenId")
+            let token = canvas.tokens?.get(tokenId)
+            if (token) {
+              canvas.animatePan({ x: token.x, y: token.y, duration: 200 })
+              canvas.tokens.releaseAll()
+              token.control({ releaseOthers: true })
+            }
           }
-        }
-      },
-      rejectClose: false // Click on Close button will not launch an error
-    })
+        },
+        rejectClose: false // Click on Close button will not launch an error
+      })
+    }
 
     // If the user cancels the dialog, exit
     if (rollContext === null) return
@@ -461,7 +515,8 @@ export default class LethalFantasyRoll extends Roll {
       rollContext.favor = "none"
     }
 
-    maxValue = Number(baseFormula.match(/\d+$/)[0]) // Update the max value agains
+    const maxMatch = baseFormula ? baseFormula.match(/\d+$/) : null
+    maxValue = maxMatch ? Number(maxMatch[0]) : 0
 
     const rollData = {
       type: options.rollType,
@@ -473,6 +528,9 @@ export default class LethalFantasyRoll extends Roll {
       actorImage: options.actorImage,
       rollMode: rollContext.visibility,
       hasTarget: options.hasTarget,
+      isDamage: options.isDamage,
+      damageSmall: options.damageSmall,
+      damageMedium: options.damageMedium,
       pointBlank,
       beyondSkill,
       letItFly,
@@ -530,12 +588,30 @@ export default class LethalFantasyRoll extends Roll {
       rollFavor = null
     }
 
+    if (options.forceNoD30) {
+      hasD30 = false
+    }
+
     if (hasD30) {
       let rollD30 = await new Roll("1D30").evaluate()
       if (game?.dice3d) {
         game.dice3d.showForRoll(rollD30, game.user, true)
       }
       options.D30result = rollD30.total
+
+      // Compute isRanged for D30: covers defense (isRangedDefense), monster ranged attacks (attackMode),
+      // and PC weapon attacks (isRangedAttack or weaponType)
+      const isRangedForD30 = options.isRangedDefense
+        || options.rollTarget?.attackMode === "ranged"
+        || options.rollTarget?.isRangedAttack === true
+        || options.rollTarget?.weapon?.system?.weaponType === "ranged"
+      const d30Message = D30Roll.getResult(
+        rollD30.total,
+        options.rollType,
+        options.rollTarget?.weapon,
+        { isRanged: isRangedForD30, isSpellSave: saveSpell }
+      )
+      options.D30message = d30Message
     }
 
     let rollTotal = 0
@@ -591,8 +667,12 @@ export default class LethalFantasyRoll extends Roll {
     rollBase.options.rollTarget = options.rollTarget
     rollBase.options.titleFormula = titleFormula
     rollBase.options.D30result = options.D30result
+    rollBase.options.D30message = options.D30message
     rollBase.options.badResult = badResult
     rollBase.options.rollData = foundry.utils.duplicate(rollData)
+    rollBase.options.defenderId = options.defenderId
+    rollBase.options.defenderTokenId = options.defenderTokenId
+    rollBase.options.extraShieldDr = options.extraShieldDr || 0
 
     /**
      * A hook event that fires after the roll has been made.
@@ -610,7 +690,7 @@ export default class LethalFantasyRoll extends Roll {
 
   /* ***********************************************************/
   static async promptInitiative(options = {}) {
-    const rollModes = foundry.utils.duplicate(CONFIG.Dice.rollModes); // v12 :  Object.fromEntries(Object.entries(CONFIG.Dice.rollModes).map(([key, value]) => [key, game.i18n.localize(value)]))
+    const rollModes = foundry.utils.duplicate(CONFIG.ChatMessage.modes); // v12 :  Object.fromEntries(Object.entries(CONFIG.Dice.rollModes).map(([key, value]) => [key, game.i18n.localize(value)]))
     const fieldRollMode = new foundry.data.fields.StringField({
       choices: rollModes,
       blank: false,
@@ -642,7 +722,7 @@ export default class LethalFantasyRoll extends Roll {
       buttons: [
         {
           label: label,
-          callback: (event, button, dialog) => {
+          callback: (event, button) => {
             const output = Array.from(button.form.elements).reduce((obj, input) => {
               if (input.name) obj[input.name] = input.value
               return obj
@@ -654,23 +734,31 @@ export default class LethalFantasyRoll extends Roll {
       rejectClose: false // Click on Close button will not launch an error
     })
 
-    let initRoll = new Roll(`min(${rollContext.initiativeDice}, ${options.maxInit})`, options.data, rollContext)
+    if (!rollContext) return
+
+    // When the value is a plain number (e.g. "1" for Declared Ready on Alert), wrapping it in
+    // min(1, maxInit) produces a dice-less formula that FoundryVTT cannot evaluate to a valid
+    // total. Use the constant directly; min() is only needed for actual dice expressions.
+    const isDiceFormula = /[dD]/.test(rollContext.initiativeDice)
+    const formula = isDiceFormula ? `min(${rollContext.initiativeDice}, ${options.maxInit})` : rollContext.initiativeDice
+
+    let initRoll = new Roll(formula, options.data)
     await initRoll.evaluate()
-    let msg = await initRoll.toMessage({ flavor: `Initiative for ${options.actorName}` }, { rollMode: rollContext.visibility })
-    if (game?.dice3d) {
+    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)
     }
 
     if (options.combatId && options.combatantId) {
       let combat = game.combats.get(options.combatId)
-      combat.updateEmbeddedDocuments("Combatant", [{ _id: options.combatantId, initiative: initRoll.total, 'system.progressionCount': 0 }]);
+      await combat.updateEmbeddedDocuments("Combatant", [{ _id: options.combatantId, initiative: initRoll.total, 'system.progressionCount': 0, [`flags.${SYSTEM.id}.firstActionTaken`]: false }])
     }
   }
 
   /* ***********************************************************/
   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,
@@ -699,10 +787,19 @@ export default class LethalFantasyRoll extends Roll {
     let buttons = []
     if (currentAction) {
       if (currentAction.type === "weapon") {
+        let weaponLabel = "Roll progression dice"
+        if (currentAction.rangedMode) {
+          // Compute loading count from the speed formula (e.g. "3+1d6" → load=3)
+          const speedStr = currentAction.system?.speed?.[currentAction.rangedMode] ?? ""
+          const rangedLoad = currentAction.rangedLoad ?? (Number(speedStr.split("+")[0]) || 0)
+          if (rangedLoad > 0 && !currentAction.weaponLoaded) {
+            weaponLabel = "Load weapon"
+          }
+        }
         buttons.push({
           action: "roll",
-          label: "Roll progression dice",
-          callback: (event, button, dialog) => {
+          label: weaponLabel,
+          callback: (event, button) => {
             let pos = $('#combat-action-dialog').position()
             game.user.setFlag(SYSTEM.id, "combat-action-dialog-pos", pos)
             return "rollProgressionDice"
@@ -728,7 +825,7 @@ export default class LethalFantasyRoll extends Roll {
         buttons.push({
           action: "roll",
           label: label,
-          callback: (event, button, dialog) => {
+          callback: (event, button) => {
             let pos = $('#combat-action-dialog').position()
             game.user.setFlag(SYSTEM.id, "combat-action-dialog-pos", foundry.utils.duplicate(pos))
             return "rollLethargyDice"
@@ -739,7 +836,7 @@ export default class LethalFantasyRoll extends Roll {
       buttons.push({
         action: "roll",
         label: "Select action",
-        callback: (event, button, dialog) => {
+        callback: (event, button) => {
           let pos = $('#combat-action-dialog').position()
           game.user.setFlag(SYSTEM.id, "combat-action-dialog-pos", foundry.utils.duplicate(pos))
           const output = Array.from(button.form.elements).reduce((obj, input) => {
@@ -754,7 +851,7 @@ export default class LethalFantasyRoll extends Roll {
     buttons.push({
       action: "cancel",
       label: "Other action, not listed here",
-      callback: (event, button, dialog) => {
+      callback: (event, button) => {
         let pos = $('#combat-action-dialog').position()
         game.user.setFlag(SYSTEM.id, "combat-action-dialog-pos", foundry.utils.duplicate(pos))
         return null;
@@ -800,7 +897,11 @@ export default class LethalFantasyRoll extends Roll {
       let selectedItem = combatant.actor.items.find(i => i.id === selectedChoice)
       // Setup flag for combat action usage
       let actionItem = foundry.utils.duplicate(selectedItem)
-      actionItem.progressionCount = 1
+      // First action of this combat: use the class-based starting threshold;
+      // all subsequent actions reset to 1 (normal progression).
+      const firstActionTaken = combatant.getFlag(SYSTEM.id, "firstActionTaken")
+      actionItem.progressionCount = firstActionTaken ? 1 : (combatant.actor.system.combat?.combatProgressionStart ?? 1)
+      if (!firstActionTaken) await combatant.setFlag(SYSTEM.id, "firstActionTaken", true)
       actionItem.rangedMode = rangedMode
       actionItem.castingTime = 1
       actionItem.spellStatus = "castingTime"
@@ -823,7 +924,8 @@ export default class LethalFantasyRoll extends Roll {
             await combatant.setFlag(SYSTEM.id, "currentAction", foundry.utils.duplicate(currentAction))
             return
           } else {
-            let message = `Spell/Miracle ${currentAction.name} ready to be cast on next second !`
+            // Last counting second — announce ready and transition immediately (no extra second consumed)
+            let message = `Casting time : ${currentAction.name}, count : ${time}/${time} — ready to cast next second !`
             ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
             currentAction.castingTime = 1
             currentAction.spellStatus = "toBeCasted"
@@ -854,8 +956,17 @@ export default class LethalFantasyRoll extends Roll {
           let toCompare = Math.min(currentAction.progressionCount, max)
           if (roll.total <= toCompare) {
             // Notify that the player can act now with a chat message
-            let message = game.i18n.format("LETHALFANTASY.Notifications.messageLethargyOK", { name: combatant.actor.name, spellName: currentAction.name, roll: roll.total })
-            ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+            const messageContent = await foundry.applications.handlebars.renderTemplate(
+              "systems/fvtt-lethal-fantasy/templates/progression-message.hbs",
+              {
+                success: true,
+                actorName: combatant.actor.name,
+                weaponName: currentAction.name,
+                rollResult: roll.total,
+                isLethargy: true
+              }
+            )
+            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
@@ -864,8 +975,18 @@ export default class LethalFantasyRoll extends Roll {
             // Notify that the player cannot act now with a chat message
             currentAction.progressionCount += 1
             await combatant.setFlag(SYSTEM.id, "currentAction", foundry.utils.duplicate(currentAction))
-            let message = game.i18n.format("LETHALFANTASY.Notifications.messageLethargyKO", { name: combatant.actor.name, spellName: currentAction.name, roll: roll.total })
-            ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+            const messageContent = await foundry.applications.handlebars.renderTemplate(
+              "systems/fvtt-lethal-fantasy/templates/progression-message.hbs",
+              {
+                success: false,
+                actorName: combatant.actor.name,
+                weaponName: currentAction.name,
+                rollResult: roll.total,
+                progressionCount: currentAction.progressionCount,
+                isLethargy: true
+              }
+            )
+            ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
           }
         }
       }
@@ -881,7 +1002,7 @@ export default class LethalFantasyRoll extends Roll {
         }
         // Range weapon loading
         if (!currentAction.weaponLoaded && currentAction.rangedLoad) {
-          if (currentAction.progressionCount <= currentAction.rangedLoad) {
+          if (currentAction.progressionCount < currentAction.rangedLoad) {
             let message = `Ranged weapon ${currentAction.name} is loading, loading count : ${currentAction.progressionCount}/${currentAction.rangedLoad}`
             ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
             currentAction.progressionCount += 1
@@ -904,23 +1025,40 @@ 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)
         }
 
         if (roll.total <= max) {
           // Notify that the player can act now with a chat message
-          let message = game.i18n.format("LETHALFANTASY.Notifications.messageProgressionOK", { isMonster, name: combatant.actor.name, weapon: currentAction.name, roll: roll.total })
-          ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+          const messageContent = await foundry.applications.handlebars.renderTemplate(
+            "systems/fvtt-lethal-fantasy/templates/progression-message.hbs",
+            {
+              success: true,
+              actorName: combatant.actor.name,
+              weaponName: currentAction.name,
+              rollResult: roll.total
+            }
+          )
+          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))
-          let message = game.i18n.format("LETHALFANTASY.Notifications.messageProgressionKO", { isMonster, name: combatant.actor.name, weapon: currentAction.name, roll: roll.total })
-          ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+          const messageContent = await foundry.applications.handlebars.renderTemplate(
+            "systems/fvtt-lethal-fantasy/templates/progression-message.hbs",
+            {
+              success: false,
+              actorName: combatant.actor.name,
+              weaponName: currentAction.name,
+              rollResult: roll.total,
+              progressionCount: currentAction.progressionCount
+            }
+          )
+          ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
         }
       }
     }
@@ -929,7 +1067,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,
@@ -961,7 +1099,7 @@ export default class LethalFantasyRoll extends Roll {
       buttons: [
         {
           label: label,
-          callback: (event, button, dialog) => {
+          callback: (event, button) => {
             const output = Array.from(button.form.elements).reduce((obj, input) => {
               if (input.name) obj[input.name] = input.value
               return obj
@@ -1009,6 +1147,9 @@ export default class LethalFantasyRoll extends Roll {
     // Merge rollContext object into options object
     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)
@@ -1016,6 +1157,7 @@ export default class LethalFantasyRoll extends Roll {
     await rollBase.evaluate()
     let rollD30 = await new Roll("1D30").evaluate()
     options.D30result = rollD30.total
+    options.D30message = D30Roll.getResult(rollD30.total, options.rollType, options.rollTarget?.weapon, { isRanged: true })
 
     let badResult = 0
     if (rollContext.movement.includes("kh")) {
@@ -1058,6 +1200,7 @@ export default class LethalFantasyRoll extends Roll {
     rollBase.options.rollTarget = options.rollTarget
     rollBase.options.titleFormula = `1D20E + ${modifierFormula}`
     rollBase.options.D30result = options.D30result
+    rollBase.options.D30message = options.D30message
     rollBase.options.rollName = "Ranged Defense"
     rollBase.options.badResult = badResult
     rollBase.options.rollData = foundry.utils.duplicate(rollData)
@@ -1074,6 +1217,161 @@ export default class LethalFantasyRoll extends Roll {
     return rollBase
   }
 
+  /**
+   * Prompts the GM for ranged attack context (movement, range, target size, aim) when a monster
+   * attacks with a ranged weapon, then evaluates an exploding D20 attack roll with the resulting modifiers.
+   *
+   * @param {Object} options              Options for the roll.
+   * @param {string} options.actorId      The attacker actor ID.
+   * @param {string} options.actorName    The attacker actor name.
+   * @param {Object} options.rollTarget   The rollTarget containing attackModifier and related data.
+   * @returns {Promise<LethalFantasyRoll|null>}  The resulting roll, or null if cancelled.
+   */
+  static async promptRangedAttack(options = {}) {
+    const rollModes = foundry.utils.duplicate(CONFIG.ChatMessage.modes)
+    const fieldRollMode = new foundry.data.fields.StringField({
+      choices: rollModes,
+      blank: false,
+      default: "public",
+    })
+
+    let dialogContext = {
+      attackerMovementChoices: SYSTEM.ATTACKER_MOVEMENT_CHOICES,
+      rangeChoices: SYSTEM.RANGE_CHOICES,
+      sizeChoices: SYSTEM.SIZE_CHOICES,
+      attackerAimChoices: SYSTEM.ATTACKER_AIM_CHOICES,
+      movement: "none",
+      range: "short",
+      size: "+5",
+      attackerAim: "simple",
+      fieldRollMode,
+      rollModes
+    }
+
+    const content = await foundry.applications.handlebars.renderTemplate("systems/fvtt-lethal-fantasy/templates/range-attack-dialog.hbs", dialogContext)
+
+    const label = game.i18n.localize("LETHALFANTASY.Label.rangeAttackRoll")
+    const rollContext = await foundry.applications.api.DialogV2.wait({
+      window: { title: "Ranged Attack" },
+      classes: ["lethalfantasy"],
+      content,
+      buttons: [
+        {
+          label,
+          callback: (event, button) => {
+            const output = Array.from(button.form.elements).reduce((obj, input) => {
+              if (input.name) obj[input.name] = input.value
+              return obj
+            }, {})
+            return output
+          },
+        },
+      ],
+      rejectClose: false
+    })
+
+    if (rollContext === null) return null
+
+    // Handle pointblank: attacker at point blank gets favor (standing still easier to aim)
+    if (rollContext.range === "pointblank") {
+      rollContext.movement = rollContext.movement.replace("kh", "")
+      rollContext.movement = rollContext.movement.replace("kl", "")
+      rollContext.movement += "kh" // Favor for attacker at point blank
+      rollContext.range = "0"
+    }
+    // Handle beyondskill: extreme range gives disfavor to attacker
+    if (rollContext.range === "beyondskill") {
+      rollContext.movement = rollContext.movement.replace("kh", "")
+      rollContext.movement = rollContext.movement.replace("kl", "")
+      rollContext.movement += "kl" // Disfavor for attacker beyond skill range
+      rollContext.range = "+11"
+    }
+
+    // Compute contextual penalty: range + target_size, reduced by aim bonus and attack modifier
+    const attackModifier = options.rollTarget?.attackModifier ?? 0
+    const contextualPenalty = Number(rollContext.range) + Number(rollContext.size)
+    const aimBonus = Number(rollContext.attackerAim || 0)
+    const fullModifier = contextualPenalty - aimBonus - attackModifier
+
+    let modifierFormula
+    if (fullModifier === 0) {
+      modifierFormula = "0"
+    } else {
+      const modAbs = Math.abs(fullModifier)
+      modifierFormula = `D${modAbs + 1} -1`
+    }
+
+    const rollData = { ...rollContext }
+    options = { ...options, ...rollContext }
+    options.rollName = "Ranged Attack"
+    options.rollType = options.rollType || "monster-attack"
+    options.type = options.rollType  // Required: this.type reads options.type, used to build weaponDamageOptions in toHTML
+    options.rollMode = rollContext.visibility   // Required: callers pass roll.options.rollMode to toMessage
+    options.isRangedAttack = true
+
+    const rollBase = new this(rollContext.movement, options.data, rollData)
+    const rollModifier = new Roll(modifierFormula, options.data, rollData)
+    rollModifier.evaluate()
+    await rollBase.evaluate()
+    const rollD30 = await new Roll("1D30").evaluate()
+    options.D30result = rollD30.total
+    options.D30message = D30Roll.getResult(rollD30.total, options.rollType, undefined, { isRanged: true })
+
+    // Determine favor from dice formula
+    let badResult = 0
+    if (rollContext.movement.includes("kh")) {
+      rollData.favor = "favor"
+      badResult = Math.min(rollBase.terms[0].results[0].result, rollBase.terms[0].results[1]?.result || 20)
+    }
+    if (rollContext.movement.includes("kl")) {
+      rollData.favor = "disfavor"
+      badResult = Math.max(rollBase.terms[0].results[0].result, rollBase.terms[0].results[1]?.result || 1)
+    }
+
+    const dice = rollContext.movement
+    const maxValue = 20
+    let rollTotal = -1
+    let diceResults = []
+
+    let diceResult = rollBase.dice[0].results[0].result
+    diceResults.push({ dice: `${dice.toUpperCase()}`, value: diceResult })
+    let diceSum = diceResult
+    // Exploding dice
+    while (diceResult === maxValue) {
+      const r = await new Roll(dice).evaluate()
+      diceResult = r.dice[0].results[0].result
+      diceResults.push({ dice: `${dice.toUpperCase()}-1`, value: diceResult - 1 })
+      diceSum += (diceResult - 1)
+    }
+
+    if (fullModifier !== 0) {
+      diceResults.push({ dice: `${rollModifier.formula.toUpperCase()}`, value: rollModifier.total })
+      if (fullModifier > 0) {
+        // Net penalty: subtract from roll
+        rollTotal = Math.max(diceSum - rollModifier.total, 0)
+      } else {
+        // Net bonus: add to roll
+        rollTotal = diceSum + rollModifier.total
+      }
+    } else {
+      rollTotal = diceSum
+    }
+
+    rollBase.options = { ...rollBase.options, ...options }
+    rollBase.options.resultType = undefined
+    rollBase.options.rollTotal = rollTotal
+    rollBase.options.diceResults = diceResults
+    rollBase.options.rollTarget = options.rollTarget
+    rollBase.options.titleFormula = `1D20E + ${modifierFormula}`
+    rollBase.options.D30result = options.D30result
+    rollBase.options.D30message = options.D30message
+    rollBase.options.rollName = "Ranged Attack"
+    rollBase.options.badResult = badResult
+    rollBase.options.rollData = foundry.utils.duplicate(rollData)
+
+    return rollBase
+  }
+
   /**
    * Creates a title based on the given type.
    *
@@ -1122,6 +1420,57 @@ export default class LethalFantasyRoll extends Roll {
    * Generates the data required for rendering a roll chat card.
    */
   async _getChatCardData(isPrivate) {
+    // Générer la liste des combatants de la scène
+    let combatants = []
+    let isAttack = this.type === "weapon-attack" || this.type === "monster-attack" || this.type === "spell-attack" || this.type === "miracle-attack"
+    if (this.rollData?.isDamage || isAttack) {
+      // D'abord, ajouter les combattants du combat actif
+      if (game?.combat?.combatants) {
+        for (let c of game.combat.combatants) {
+          if (c.actorId !== this.actorId) {
+            combatants.push({ id: c.id, name: c.name, tokenId: c.token.id })
+          }
+        }
+      }
+
+      // Ensuite, ajouter tous les tokens de la scène active qui ne sont pas déjà dans la liste
+      if (canvas?.scene?.tokens) {
+        const existingTokenIds = new Set(combatants.map(c => c.tokenId))
+        for (let token of canvas.scene.tokens) {
+          if (token.actorId !== this.actorId && !existingTokenIds.has(token.id)) {
+            combatants.push({
+              id: token.id,
+              name: token.name,
+              tokenId: token.id
+            })
+          }
+        }
+      }
+    }
+
+    // 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)
+    if (this.type === "weapon-attack" && this.rollTarget?.weapon) {
+      const weapon = this.rollTarget.weapon
+      weaponDamageOptions = {
+        weaponId: weapon._id || weapon.id,
+        weaponName: weapon.name,
+        damageS: weapon.system?.damage?.damageS,
+        damageM: weapon.system?.damage?.damageM
+      }
+      console.log("Weapon damage options:", weaponDamageOptions)
+    } else if (this.type === "monster-attack" && this.rollTarget) {
+      weaponDamageOptions = {
+        weaponId: this.rollTarget.rollKey,
+        weaponName: this.rollTarget.name,
+        damageFormula: this.rollTarget.damageDice,
+        damageModifier: this.rollTarget.damageModifier,
+        isMonster: true
+      }
+      console.log("Monster damage options:", weaponDamageOptions)
+    }
+
     const cardData = {
       css: [SYSTEM.id, "dice-roll"],
       data: this.data,
@@ -1143,9 +1492,16 @@ export default class LethalFantasyRoll extends Roll {
       targetName: this.targetName,
       targetArmor: this.targetArmor,
       D30result: this.D30result,
+      D30message: this.D30message,
       badResult: this.badResult,
       rollData: this.rollData,
-      isPrivate: isPrivate
+      isPrivate: isPrivate,
+      combatants: combatants,
+      weaponDamageOptions: weaponDamageOptions,
+      isAttack: isAttack,
+      defenderId: this.defenderId,
+      // Vérifier si l'utilisateur peut sélectionner une cible (est GM ou possède l'acteur)
+      canSelectTarget: game.user.isGM || game.actors.get(this.actorId)?.testUserPermission(game.user, "OWNER")
     }
     cardData.cssClass = cardData.css.join(" ")
     cardData.tooltip = isPrivate ? "" : await this.getTooltip()
@@ -1157,12 +1513,12 @@ 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 } = {}) {
-    super.toMessage(
+  async toMessage(messageData = {}, { messageMode, create = true } = {}) {
+    return await super.toMessage(
       {
         isSave: this.isSave,
         isChallenge: this.isChallenge,
@@ -1179,8 +1535,47 @@ export default class LethalFantasyRoll extends Roll {
         rollData: this.rollData,
         ...messageData,
       },
-      { rollMode: rollMode },
+      { 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()
+            if (game?.dice3d) await game.dice3d.showForRoll(xr, game.user, true)
+            // 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/models/character.mjs

@@ -120,6 +120,8 @@ export default class LethalFantasyCharacter extends foundry.abstract.TypeDataMod
       magicUser: new fields.BooleanField({ initial: false }),
       clericUser: new fields.BooleanField({ initial: false }),
       hpPerLevel: new fields.StringField({ required: true, nullable: false, initial: "" }),
+      naturalDR: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      magicDR: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
     })
 
     schema.modifiers = new fields.SchemaField({
@@ -150,9 +152,11 @@ 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 }),
+      combatProgressionStart: new fields.NumberField({ ...requiredInteger, initial: 1, min: 1 }),
     })
 
     const moneyField = (label) => {
@@ -256,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)
@@ -271,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) {
+  async roll(rollType, rollTarget, defenderId, defenderTokenId, extraShieldDr = 0) {
     const hasTarget = false
     let roll = await LethalFantasyRoll.prompt({
       rollType,
@@ -280,11 +290,14 @@ export default class LethalFantasyCharacter extends foundry.abstract.TypeDataMod
       actorName: this.parent.name,
       actorImage: this.parent.img,
       hasTarget,
-      target: false
+      target: false,
+      defenderId,
+      defenderTokenId,
+      extraShieldDr
     })
     if (!roll) return null
 
-    await roll.toMessage({}, { rollMode: roll.options.rollMode })
+    await roll.toMessage({}, { messageMode: roll.options.rollMode })
   }
 
   async rollInitiative(combatId = undefined, combatantId = undefined) {
@@ -305,10 +318,17 @@ 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) {
+    let combatant = game.combats.get(combatId)?.combatants?.get(combatantId)
+
+    // Don't roll if the combatant is defeated
+    if (combatant?.isDefeated) {
+      ui.notifications.warn(`${this.parent.name} is defeated and cannot attack.`)
+      return
+    }
 
     // Get all weapons from the actor
     let weapons = this.parent.items.filter(i => i.type === "weapon" && i.system.weaponType === "melee")
@@ -336,6 +356,11 @@ export default class LethalFantasyCharacter extends foundry.abstract.TypeDataMod
       }
     }
 
+    if (weaponsChoices.length === 0) {
+      ui.notifications.warn(`${this.parent.name} has no weapons or spells available for combat. Add a weapon to the character sheet first.`)
+      return
+    }
+
     let roll = await LethalFantasyRoll.promptCombatAction({
       actorId: this.parent.id,
       actorName: this.parent.name,

module/models/miracle.mjs

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

module/models/monster.mjs

@@ -64,7 +64,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
       painDamage: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 })
     })
 
-    const attackField = (label) => {
+    const attackField = (label, initialNoExplode = false) => {
       const schema = {
         key: new fields.StringField({ required: true, nullable: false, initial: `attack${label}` }),
         name: new fields.StringField({ required: true, nullable: false, initial: `Attack ${label}` }),
@@ -74,6 +74,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
         damageDice: new fields.StringField({ required: true, nullable: false, initial: "1D6" }),
         damageModifier: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
         enabled: new fields.BooleanField({ initial: true, required: true, nullable: false }),
+        noExplode: new fields.BooleanField({ initial: initialNoExplode, required: true, nullable: false }),
       }
       return new fields.SchemaField(schema, { label })
     }
@@ -118,8 +119,37 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
       defenseModifier: 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 }),
+      damageReduction: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      shieldDamageReduction: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      shieldDefenseDice: new fields.StringField({ required: true, nullable: false, initial: "d4" })
+    })
+    schema.combatHTH = new fields.SchemaField({
+      attack1: attackField("1", true),
+      attack2: attackField("2", true)
     })
 
+    schema.attackMode = new fields.StringField({
+      required: true,
+      nullable: false,
+      initial: "melee",
+      choices: { melee: "Melee", ranged: "Ranged" }
+    })
+
+    schema.rangedAttacks = new fields.SchemaField({
+      attack1: attackField("1"),
+      attack2: attackField("2"),
+      attack3: attackField("3"),
+      attack4: attackField("4")
+    })
+
+    schema.rangedWeaponRange = new fields.SchemaField({
+      pointBlank: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
+      short: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
+      medium: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
+      long: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
+      extreme: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),
+      outOfSkill: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
+    })
 
     return schema
   }
@@ -134,8 +164,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) {
+  async roll(rollType, rollTarget, defenderId = undefined, defenderTokenId = undefined, extraShieldDr = 0) {
     const hasTarget = false
+
+    // Ranged monster defense uses the ranged defense dialog (movement, range, size modifiers)
+    if (rollType === "monster-defense" && rollTarget?.isRangedDefense === true) {
+      let roll = await LethalFantasyRoll.promptRangedDefense({
+        actorId: this.parent.id,
+        actorName: this.parent.name,
+        actorImage: this.parent.img,
+        rollTarget,
+        defenderId,
+        defenderTokenId,
+      })
+      if (!roll) return null
+      await roll.toMessage({}, { messageMode: roll.options.rollMode })
+      return
+    }
+
     let roll = await LethalFantasyRoll.prompt({
       rollType,
       rollTarget,
@@ -143,21 +189,46 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
       actorName: this.parent.name,
       actorImage: this.parent.img,
       hasTarget,
-      target: false
+      target: false,
+      defenderId,
+      defenderTokenId,
+      extraShieldDr
     })
     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) {
+  async prepareMonsterRoll(rollType, rollKey, rollDice = undefined, tokenId = undefined, damageModifier = undefined, defenderId = undefined, defenderTokenId = undefined, extraShieldDr = 0) {
     let rollTarget
     switch (rollType) {
       case "monster-attack":
       case "monster-defense":
-      case "monster-damage":
-        rollTarget = foundry.utils.duplicate(this.attacks[rollKey])
+      case "monster-damage": {
+        const attacksSet = this.attackMode === "ranged" ? this.rangedAttacks : this.attacks
+        rollTarget = foundry.utils.duplicate(attacksSet[rollKey])
         rollTarget.rollKey = rollKey
+        rollTarget.attackMode = this.attackMode
+        if (rollType === "monster-defense") {
+          rollTarget.isRangedDefense = game.lethalFantasy?.nextDefenseData?.isRanged ?? false
+        }
+        // Si damageModifier est fourni (depuis le chat), l'utiliser au lieu de celui de la fiche
+        if (damageModifier !== undefined && rollType === "monster-damage") {
+          rollTarget.damageModifier = damageModifier
+        }
+        break
+      }
+      case "monster-attack-hth":
+      case "monster-defense-hth":
+      case "monster-damage-hth":
+        rollTarget = foundry.utils.duplicate(this.combatHTH[rollKey])
+        rollTarget.rollKey = rollKey
+        // Si damageModifier est fourni (depuis le chat), l'utiliser au lieu de celui de la fiche
+        if (damageModifier !== undefined && rollType === "monster-damage-hth") {
+          rollTarget.damageModifier = damageModifier
+        }
+        // Convertir le type de roll pour utiliser les mêmes handlers que les attaques normales
+        rollType = rollType.replace("-hth", "")
         break
       case "monster-skill":
         rollTarget = foundry.utils.duplicate(this.resists[rollKey])
@@ -168,6 +239,19 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
         rollTarget.rollKey = rollKey
         rollTarget.rollDice = rollDice
         break
+      case "shield-defense": {
+        // Lance directement le dé de défense du bouclier
+        const formula = rollDice || this.combat.shieldDefenseDice
+        const roll = new Roll(formula)
+        await roll.evaluate()
+
+        const flavor = game.i18n.localize("LETHALFANTASY.Label.shieldDefenseDice")
+        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-attack":
@@ -202,7 +286,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
           return
         }
         rollTarget = skill
-        rollTarget.weapon = weapon
+        rollTarget.weapon = foundry.utils.duplicate(weapon)
         rollTarget.weaponSkillModifier = skill.weaponSkillModifier
         rollTarget.rollKey = rollKey
         rollTarget.combat = foundry.utils.duplicate(this.combat)
@@ -210,13 +294,14 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
         break
       default:
         ui.notifications.error(game.i18n.localize("LETHALFANTASY.Notifications.rollTypeNotFound") + String(rollType))
-        break
+        return
     }
 
     // In all cases
-    rollTarget.tokenId = tokenId
-    console.log(rollTarget)
-    await this.roll(rollType, rollTarget)
+    if (rollTarget) {
+      rollTarget.tokenId = tokenId
+      await this.roll(rollType, rollTarget, defenderId, defenderTokenId, extraShieldDr)
+    }
   }
 
   async rollInitiative(combatId = undefined, combatantId = undefined) {
@@ -235,12 +320,19 @@ 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) {
+    let combatant = game.combats.get(combatId)?.combatants?.get(combatantId)
 
-    const rollModes = foundry.utils.duplicate(CONFIG.Dice.rollModes)
+    // Don't roll if the combatant is defeated
+    if (combatant?.isDefeated) {
+      ui.notifications.warn(`${this.parent.name} is defeated and cannot attack.`)
+      return
+    }
+
+    const rollModes = foundry.utils.duplicate(CONFIG.ChatMessage.modes)
     const fieldRollMode = new foundry.data.fields.StringField({
       choices: rollModes,
       blank: false,
@@ -249,7 +341,6 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
 
     let roll = new Roll("1D12")
     await roll.evaluate()
-    let combatant = game.combats.get(combatId)?.combatants?.get(combatantId)
 
     let msg = await roll.toMessage({ flavor: `Progression Roll for ${this.parent.name}` })
     if (game?.dice3d) {
@@ -257,12 +348,21 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
     }
 
     let hasAttack = false
-    for (let key in this.attacks) {
-      let attack = this.attacks[key]
+    const attacksSet = this.attackMode === "ranged" ? this.rangedAttacks : this.attacks
+    for (let key in attacksSet) {
+      let attack = attacksSet[key]
       if (attack.enabled && attack.attackScore > 0 && attack.attackScore === roll.total) {
         hasAttack = true
-        let message = game.i18n.format("LETHALFANTASY.Notifications.messageProgressionOKMonster", { isMonster: true, name: this.parent.name, weapon: attack.name, roll: roll.total })
-        ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
+        const messageContent = await foundry.applications.handlebars.renderTemplate(
+          "systems/fvtt-lethal-fantasy/templates/progression-message.hbs",
+          {
+            success: true,
+            actorName: this.parent.name,
+            weaponName: attack.name,
+            rollResult: roll.total
+          }
+        )
+        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) {
@@ -271,9 +371,41 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
         }
       }
     }
+    // Check Hand To Hand attacks as well
     if (!hasAttack) {
-      let message = game.i18n.format("LETHALFANTASY.Notifications.messageProgressionKOMonster", { isMonster: true, name: this.parent.name, roll: roll.total })
-      ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
+      for (let key in this.combatHTH) {
+        let attack = this.combatHTH[key]
+        if (attack.enabled && attack.attackScore > 0 && attack.attackScore === roll.total) {
+          hasAttack = true
+          const messageContent = await foundry.applications.handlebars.renderTemplate(
+            "systems/fvtt-lethal-fantasy/templates/progression-message.hbs",
+            {
+              success: true,
+              actorName: this.parent.name,
+              weaponName: `${attack.name} (HTH)`,
+              rollResult: roll.total
+            }
+          )
+          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) {
+            token.object?.control({ releaseOthers: true });
+            return canvas.animatePan(token.object.center);
+          }
+        }
+      }
+    }
+    if (!hasAttack) {
+      const messageContent = await foundry.applications.handlebars.renderTemplate(
+        "systems/fvtt-lethal-fantasy/templates/progression-message.hbs",
+        {
+          success: false,
+          actorName: this.parent.name,
+          rollResult: roll.total
+        }
+      )
+      ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
     }
 
   }

module/models/shield.mjs

@@ -6,9 +6,10 @@ export default class LethalFantasyShield extends foundry.abstract.TypeDataModel
     const requiredInteger = { required: true, nullable: false, integer: true }
 
     schema.description = new fields.HTMLField({ required: true, textSearch: true })
-    schema.defense = new fields.StringField({required: true, initial: "d4", choices: SYSTEM.SHIELD_DEFENSE_DICE})
+    schema.defense = new fields.StringField({ required: true, initial: "d4", choices: SYSTEM.SHIELD_DEFENSE_DICE })
     schema.movementreduction = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
     schema.hascover = new fields.BooleanField({ required: true, initial: false })
+    schema.damageReduction = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
 
     schema.standing = new fields.SchemaField({
       min: new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 }),

module/models/spell.mjs

@@ -39,6 +39,9 @@ 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
   }

packs-system/lf-equipment/CURRENT

@@ -1 +1 @@
-MANIFEST-000436
+MANIFEST-000623

packs-system/lf-equipment/LOG

@@ -1,8 +1,8 @@
-2025/10/01-16:42:57.866432 7fc499ffb6c0 Recovering log #434
-2025/10/01-16:42:57.877314 7fc499ffb6c0 Delete type=3 #432
-2025/10/01-16:42:57.877388 7fc499ffb6c0 Delete type=0 #434
-2025/10/01-17:11:30.188440 7fc497ff76c0 Level-0 table #439: started
-2025/10/01-17:11:30.188469 7fc497ff76c0 Level-0 table #439: 0 bytes OK
-2025/10/01-17:11:30.194363 7fc497ff76c0 Delete type=0 #437
-2025/10/01-17:11:30.200618 7fc497ff76c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
-2025/10/01-17:11:30.200653 7fc497ff76c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
+2026/05/25-11:43:40.059603 7f88315ff6c0 Recovering log #621
+2026/05/25-11:43:40.071136 7f88315ff6c0 Delete type=3 #619
+2026/05/25-11:43:40.071202 7f88315ff6c0 Delete type=0 #621
+2026/05/25-12:29:17.727995 7f87e2ffd6c0 Level-0 table #626: started
+2026/05/25-12:29:17.728028 7f87e2ffd6c0 Level-0 table #626: 0 bytes OK
+2026/05/25-12:29:17.733783 7f87e2ffd6c0 Delete type=0 #624
+2026/05/25-12:29:17.740143 7f87e2ffd6c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
+2026/05/25-12:29:17.740167 7f87e2ffd6c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)

packs-system/lf-equipment/LOG.old

@@ -1,8 +1,8 @@
-2025/10/01-09:52:37.607891 7fc498ff96c0 Recovering log #430
-2025/10/01-09:52:37.617656 7fc498ff96c0 Delete type=3 #428
-2025/10/01-09:52:37.617728 7fc498ff96c0 Delete type=0 #430
-2025/10/01-10:19:09.456857 7fc497ff76c0 Level-0 table #435: started
-2025/10/01-10:19:09.456891 7fc497ff76c0 Level-0 table #435: 0 bytes OK
-2025/10/01-10:19:09.500293 7fc497ff76c0 Delete type=0 #433
-2025/10/01-10:19:09.675931 7fc497ff76c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
-2025/10/01-10:19:09.675968 7fc497ff76c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
+2026/05/24-09:22:43.041326 7fdfa95ff6c0 Recovering log #617
+2026/05/24-09:22:43.083988 7fdfa95ff6c0 Delete type=3 #615
+2026/05/24-09:22:43.084045 7fdfa95ff6c0 Delete type=0 #617
+2026/05/24-09:42:00.304351 7fdf5affd6c0 Level-0 table #622: started
+2026/05/24-09:42:00.304423 7fdf5affd6c0 Level-0 table #622: 0 bytes OK
+2026/05/24-09:42:00.311333 7fdf5affd6c0 Delete type=0 #620
+2026/05/24-09:42:00.334170 7fdf5affd6c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
+2026/05/24-09:42:00.334370 7fdf5affd6c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)

packs-system/lf-gifts/CURRENT

@@ -1 +1 @@
-MANIFEST-000436
+MANIFEST-000620

packs-system/lf-gifts/LOG

@@ -1,8 +1,8 @@
-2025/10/01-16:42:57.881962 7fc4987f86c0 Recovering log #434
-2025/10/01-16:42:57.892761 7fc4987f86c0 Delete type=3 #432
-2025/10/01-16:42:57.892833 7fc4987f86c0 Delete type=0 #434
-2025/10/01-17:11:30.181134 7fc497ff76c0 Level-0 table #439: started
-2025/10/01-17:11:30.181171 7fc497ff76c0 Level-0 table #439: 0 bytes OK
-2025/10/01-17:11:30.188327 7fc497ff76c0 Delete type=0 #437
-2025/10/01-17:11:30.200601 7fc497ff76c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!zjvGljrLk5SshC9D' @ 0 : 0; will stop at (end)
-2025/10/01-17:11:30.200645 7fc497ff76c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!zjvGljrLk5SshC9D' @ 0 : 0; will stop at (end)
+2026/05/25-11:43:40.077580 7f87e37fe6c0 Recovering log #618
+2026/05/25-11:43:40.087750 7f87e37fe6c0 Delete type=3 #616
+2026/05/25-11:43:40.087800 7f87e37fe6c0 Delete type=0 #618
+2026/05/25-12:29:17.758832 7f87e2ffd6c0 Level-0 table #623: started
+2026/05/25-12:29:17.758858 7f87e2ffd6c0 Level-0 table #623: 0 bytes OK
+2026/05/25-12:29:17.764622 7f87e2ffd6c0 Delete type=0 #621
+2026/05/25-12:29:17.777473 7f87e2ffd6c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
+2026/05/25-12:29:17.784124 7f87e2ffd6c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)

packs-system/lf-gifts/LOG.old

@@ -1,8 +1,8 @@
-2025/10/01-09:52:37.622704 7fc4997fa6c0 Recovering log #430
-2025/10/01-09:52:37.632146 7fc4997fa6c0 Delete type=3 #428
-2025/10/01-09:52:37.632199 7fc4997fa6c0 Delete type=0 #430
-2025/10/01-10:19:09.736826 7fc497ff76c0 Level-0 table #435: started
-2025/10/01-10:19:09.736857 7fc497ff76c0 Level-0 table #435: 0 bytes OK
-2025/10/01-10:19:09.782928 7fc497ff76c0 Delete type=0 #433
-2025/10/01-10:19:09.809673 7fc497ff76c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!zjvGljrLk5SshC9D' @ 0 : 0; will stop at (end)
-2025/10/01-10:19:09.809700 7fc497ff76c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!zjvGljrLk5SshC9D' @ 0 : 0; will stop at (end)
+2026/05/24-09:22:43.091828 7fdfa8dfe6c0 Recovering log #614
+2026/05/24-09:22:43.131041 7fdfa8dfe6c0 Delete type=3 #612
+2026/05/24-09:22:43.131104 7fdfa8dfe6c0 Delete type=0 #614
+2026/05/24-09:42:00.326388 7fdf5affd6c0 Level-0 table #619: started
+2026/05/24-09:42:00.326417 7fdf5affd6c0 Level-0 table #619: 0 bytes OK
+2026/05/24-09:42:00.334051 7fdf5affd6c0 Delete type=0 #617
+2026/05/24-09:42:00.334205 7fdf5affd6c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
+2026/05/24-09:42:00.334364 7fdf5affd6c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)

packs-system/lf-skills/CURRENT

@@ -1 +1 @@
-MANIFEST-000436
+MANIFEST-000625

packs-system/lf-skills/LOG

@@ -1,8 +1,8 @@
-2025/10/01-16:42:57.852986 7fc498ff96c0 Recovering log #434
-2025/10/01-16:42:57.862534 7fc498ff96c0 Delete type=3 #432
-2025/10/01-16:42:57.862603 7fc498ff96c0 Delete type=0 #434
-2025/10/01-17:11:30.174361 7fc497ff76c0 Level-0 table #439: started
-2025/10/01-17:11:30.174817 7fc497ff76c0 Level-0 table #439: 0 bytes OK
-2025/10/01-17:11:30.181000 7fc497ff76c0 Delete type=0 #437
-2025/10/01-17:11:30.200584 7fc497ff76c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
-2025/10/01-17:11:30.200638 7fc497ff76c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
+2026/05/25-11:43:40.044921 7f87e3fff6c0 Recovering log #623
+2026/05/25-11:43:40.054992 7f87e3fff6c0 Delete type=3 #621
+2026/05/25-11:43:40.055048 7f87e3fff6c0 Delete type=0 #623
+2026/05/25-12:29:17.710484 7f87e2ffd6c0 Level-0 table #628: started
+2026/05/25-12:29:17.710568 7f87e2ffd6c0 Level-0 table #628: 0 bytes OK
+2026/05/25-12:29:17.716928 7f87e2ffd6c0 Delete type=0 #626
+2026/05/25-12:29:17.740121 7f87e2ffd6c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
+2026/05/25-12:29:17.758707 7f87e2ffd6c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)

packs-system/lf-skills/LOG.old

@@ -1,8 +1,8 @@
-2025/10/01-09:52:37.593230 7fc4987f86c0 Recovering log #430
-2025/10/01-09:52:37.603848 7fc4987f86c0 Delete type=3 #428
-2025/10/01-09:52:37.603909 7fc4987f86c0 Delete type=0 #430
-2025/10/01-10:19:09.418020 7fc497ff76c0 Level-0 table #435: started
-2025/10/01-10:19:09.418055 7fc497ff76c0 Level-0 table #435: 0 bytes OK
-2025/10/01-10:19:09.456709 7fc497ff76c0 Delete type=0 #433
-2025/10/01-10:19:09.675920 7fc497ff76c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
-2025/10/01-10:19:09.675962 7fc497ff76c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
+2026/05/24-09:22:42.993966 7fdfa8dfe6c0 Recovering log #619
+2026/05/24-09:22:43.035467 7fdfa8dfe6c0 Delete type=3 #617
+2026/05/24-09:22:43.035518 7fdfa8dfe6c0 Delete type=0 #619
+2026/05/24-09:42:00.319082 7fdf5affd6c0 Level-0 table #624: started
+2026/05/24-09:42:00.319109 7fdf5affd6c0 Level-0 table #624: 0 bytes OK
+2026/05/24-09:42:00.326261 7fdf5affd6c0 Delete type=0 #622
+2026/05/24-09:42:00.334196 7fdf5affd6c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
+2026/05/24-09:42:00.334355 7fdf5affd6c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)

packs-system/lf-spells-miracles/CURRENT

@@ -1 +1 @@
-MANIFEST-000136
+MANIFEST-000320

packs-system/lf-spells-miracles/LOG

@@ -1,8 +1,8 @@
-2025/10/01-16:42:57.908006 7fc4997fa6c0 Recovering log #134
-2025/10/01-16:42:57.919602 7fc4997fa6c0 Delete type=3 #132
-2025/10/01-16:42:57.919658 7fc4997fa6c0 Delete type=0 #134
-2025/10/01-17:11:30.207352 7fc497ff76c0 Level-0 table #139: started
-2025/10/01-17:11:30.207416 7fc497ff76c0 Level-0 table #139: 0 bytes OK
-2025/10/01-17:11:30.214221 7fc497ff76c0 Delete type=0 #137
-2025/10/01-17:11:30.239177 7fc497ff76c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
-2025/10/01-17:11:30.278471 7fc497ff76c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
+2026/05/25-11:43:40.107633 7f8830dfe6c0 Recovering log #318
+2026/05/25-11:43:40.118039 7f8830dfe6c0 Delete type=3 #316
+2026/05/25-11:43:40.118104 7f8830dfe6c0 Delete type=0 #318
+2026/05/25-12:29:17.777484 7f87e2ffd6c0 Level-0 table #323: started
+2026/05/25-12:29:17.777511 7f87e2ffd6c0 Level-0 table #323: 0 bytes OK
+2026/05/25-12:29:17.784021 7f87e2ffd6c0 Delete type=0 #321
+2026/05/25-12:29:17.784188 7f87e2ffd6c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
+2026/05/25-12:29:17.803354 7f87e2ffd6c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)

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

@@ -1,8 +1,8 @@
-2025/10/01-09:52:37.648603 7fc498ff96c0 Recovering log #130
-2025/10/01-09:52:37.658051 7fc498ff96c0 Delete type=3 #128
-2025/10/01-09:52:37.658136 7fc498ff96c0 Delete type=0 #130
-2025/10/01-10:19:09.381699 7fc497ff76c0 Level-0 table #135: started
-2025/10/01-10:19:09.381742 7fc497ff76c0 Level-0 table #135: 0 bytes OK
-2025/10/01-10:19:09.417885 7fc497ff76c0 Delete type=0 #133
-2025/10/01-10:19:09.675902 7fc497ff76c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
-2025/10/01-10:19:09.675956 7fc497ff76c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
+2026/05/24-09:22:43.194643 7fdfa8dfe6c0 Recovering log #314
+2026/05/24-09:22:43.231409 7fdfa8dfe6c0 Delete type=3 #312
+2026/05/24-09:22:43.231470 7fdfa8dfe6c0 Delete type=0 #314
+2026/05/24-09:42:00.341818 7fdf5affd6c0 Level-0 table #319: started
+2026/05/24-09:42:00.341853 7fdf5affd6c0 Level-0 table #319: 0 bytes OK
+2026/05/24-09:42:00.348538 7fdf5affd6c0 Delete type=0 #317
+2026/05/24-09:42:00.367125 7fdf5affd6c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
+2026/05/24-09:42:00.367348 7fdf5affd6c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)

packs-system/lf-vulnerabilities/CURRENT

@@ -1 +1 @@
-MANIFEST-000435
+MANIFEST-000619

packs-system/lf-vulnerabilities/LOG

@@ -1,8 +1,8 @@
-2025/10/01-16:42:57.895507 7fc498ff96c0 Recovering log #433
-2025/10/01-16:42:57.905329 7fc498ff96c0 Delete type=3 #431
-2025/10/01-16:42:57.905405 7fc498ff96c0 Delete type=0 #433
-2025/10/01-17:11:30.194475 7fc497ff76c0 Level-0 table #438: started
-2025/10/01-17:11:30.194505 7fc497ff76c0 Level-0 table #438: 0 bytes OK
-2025/10/01-17:11:30.200450 7fc497ff76c0 Delete type=0 #436
-2025/10/01-17:11:30.200628 7fc497ff76c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
-2025/10/01-17:11:30.200661 7fc497ff76c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
+2026/05/25-11:43:40.093877 7f87e3fff6c0 Recovering log #617
+2026/05/25-11:43:40.103670 7f87e3fff6c0 Delete type=3 #615
+2026/05/25-11:43:40.103720 7f87e3fff6c0 Delete type=0 #617
+2026/05/25-12:29:17.764689 7f87e2ffd6c0 Level-0 table #622: started
+2026/05/25-12:29:17.764705 7f87e2ffd6c0 Level-0 table #622: 0 bytes OK
+2026/05/25-12:29:17.770486 7f87e2ffd6c0 Delete type=0 #620
+2026/05/25-12:29:17.784104 7f87e2ffd6c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
+2026/05/25-12:29:17.784130 7f87e2ffd6c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)

packs-system/lf-vulnerabilities/LOG.old

@@ -1,8 +1,8 @@
-2025/10/01-09:52:37.634817 7fc4987f86c0 Recovering log #429
-2025/10/01-09:52:37.645670 7fc4987f86c0 Delete type=3 #427
-2025/10/01-09:52:37.645745 7fc4987f86c0 Delete type=0 #429
-2025/10/01-10:19:09.704901 7fc497ff76c0 Level-0 table #434: started
-2025/10/01-10:19:09.704973 7fc497ff76c0 Level-0 table #434: 0 bytes OK
-2025/10/01-10:19:09.736698 7fc497ff76c0 Delete type=0 #432
-2025/10/01-10:19:09.809658 7fc497ff76c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
-2025/10/01-10:19:09.809691 7fc497ff76c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
+2026/05/24-09:22:43.141936 7fdf5bfff6c0 Recovering log #613
+2026/05/24-09:22:43.189387 7fdf5bfff6c0 Delete type=3 #611
+2026/05/24-09:22:43.189438 7fdf5bfff6c0 Delete type=0 #613
+2026/05/24-09:42:00.311436 7fdf5affd6c0 Level-0 table #618: started
+2026/05/24-09:42:00.311459 7fdf5affd6c0 Level-0 table #618: 0 bytes OK
+2026/05/24-09:42:00.318964 7fdf5affd6c0 Delete type=0 #616
+2026/05/24-09:42:00.334187 7fdf5affd6c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
+2026/05/24-09:42:00.334334 7fdf5affd6c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)

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

@@ -1,33 +1,34 @@
 &.fortune {
-    img {
-        border: 0px;
-      }
-      .intro-chat {
-        border-radius: 20px;
-        display: flex;
-        flex-direction: row;
-        .intro-img {
-          padding: 5px;
-          width: 80px;
-          align-self: center;
-        }
-        .intro-right {
-          display: flex;
-          flex-direction: column;
-          .introText {
-            font-family: var(--font-secondary);
-            font-size: calc(var(--font-size-standard) * 1.2);
-            width: 210px;
-            text-align: center;
-          }
-        }
-      }
-      .button.control, .fortune-accepted {
-        display: flex;
-        justify-content: center;
-        align-items: center;
-        font-size: calc(var(--font-size-standard) * 1.3);
+  img {
+    border: 0px;
+  }
+  .intro-chat {
+    border-radius: 20px;
+    display: flex;
+    flex-direction: row;
+    .intro-img {
+      padding: 5px;
+      width: 80px;
+      align-self: center;
+    }
+    .intro-right {
+      display: flex;
+      flex-direction: column;
+      .introText {
+        font-family: var(--font-secondary);
+        font-size: calc(var(--font-size-standard) * 1.2);
+        width: 210px;
+        text-align: center;
       }
+    }
+  }
+  .button.control,
+  .fortune-accepted {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    font-size: calc(var(--font-size-standard) * 1.3);
+  }
 }
 
 &.ask-roll {
@@ -38,3 +39,335 @@
   font-family: var(--font-secondary);
   font-size: calc(var(--font-size-standard) * 1.2);
 }
+.defense-request {
+  padding: 12px;
+  background: linear-gradient(to bottom, #3a3930 0%, #2a2920 100%);
+  border: 2px solid #d4af37;
+  border-radius: 8px;
+  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.4);
+
+  h3 {
+    margin: 0 0 10px 0;
+    color: #d4af37;
+    font-size: calc(var(--font-size-standard) * 1.1);
+    font-weight: 700;
+    text-align: center;
+    text-transform: uppercase;
+    letter-spacing: 1px;
+
+    i {
+      margin-right: 6px;
+    }
+  }
+
+  p {
+    margin: 8px 0;
+    color: #f0e6d2;
+    font-size: calc(var(--font-size-standard) * 0.95);
+    line-height: 1.4;
+
+    strong {
+      color: #d4af37;
+      font-weight: 600;
+    }
+  }
+
+  .defense-prompt {
+    margin-top: 12px;
+    padding: 8px;
+    background: rgba(212, 175, 55, 0.1);
+    border-left: 3px solid #d4af37;
+    border-radius: 4px;
+    font-weight: 600;
+    color: #d4af37;
+    text-align: center;
+  }
+}
+
+.defense-request-dialog {
+  .attack-info {
+    padding: 12px;
+    background: linear-gradient(to bottom, rgba(42, 41, 32, 0.8) 0%, rgba(26, 25, 16, 0.9) 100%);
+    border: 1px solid rgba(212, 175, 55, 0.5);
+    border-radius: 6px;
+    margin-bottom: 16px;
+
+    p {
+      margin: 6px 0;
+      color: #f0e6d2;
+      font-size: calc(var(--font-size-standard) * 0.95);
+
+      strong {
+        color: #d4af37;
+        font-weight: 600;
+      }
+    }
+  }
+
+  .weapon-selection {
+    label {
+      display: block;
+      margin-bottom: 8px;
+      color: #d4af37;
+      font-weight: 600;
+      font-size: calc(var(--font-size-standard) * 0.95);
+    }
+
+    select {
+      width: 100%;
+      padding: 8px 12px;
+      background: #3a3930 !important;
+      border: 1px solid #d4af37;
+      border-radius: 4px;
+      color: #ffffff !important;
+      font-size: calc(var(--font-size-standard) * 0.95);
+      cursor: pointer;
+
+      &:focus {
+        outline: none;
+        border-color: #f0e6d2;
+        box-shadow: 0 0 0 2px rgba(212, 175, 55, 0.3);
+      }
+
+      option {
+        background: #3a3930 !important;
+        color: #ffffff !important;
+        padding: 6px;
+
+        &:checked,
+        &:hover {
+          background: #4a4940 !important;
+          color: #ffffff !important;
+        }
+      }
+    }
+  }
+}
+
+.grit-luck-dialog {
+  color: var(--color-text-dark-primary, #191813);
+
+  .combat-status {
+    padding: 12px;
+    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;
+
+    p {
+      margin: 6px 0;
+      color: #f0e6d2;
+      font-size: calc(var(--font-size-standard) * 0.95);
+
+      strong {
+        color: #d4af37;
+        font-weight: 600;
+      }
+    }
+
+    .bonus-info {
+      color: #90EE90;
+      font-style: italic;
+      margin-top: 8px;
+    }
+  }
+
+  .offer-text {
+    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;
+    }
+  }
+}
+
+.attack-result {
+  padding: 16px;
+  border-radius: 8px;
+  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.4);
+  margin: 8px 0;
+
+  &.attack-success {
+    background: linear-gradient(to bottom, rgba(139, 0, 0, 0.2) 0%, rgba(100, 0, 0, 0.3) 100%);
+    border: 2px solid rgba(220, 20, 60, 0.6);
+  }
+
+  &.attack-failure {
+    background: linear-gradient(to bottom, rgba(0, 100, 139, 0.2) 0%, rgba(0, 70, 100, 0.3) 100%);
+    border: 2px solid rgba(70, 130, 180, 0.6);
+  }
+
+  h3 {
+    margin: 0 0 16px 0;
+    color: #d4af37;
+    font-size: calc(var(--font-size-standard) * 1.2);
+    font-weight: 700;
+    text-align: center;
+    text-transform: uppercase;
+    letter-spacing: 1px;
+
+    i {
+      margin-right: 8px;
+    }
+  }
+
+  .combat-comparison {
+    display: flex;
+    align-items: center;
+    justify-content: space-around;
+    margin-bottom: 16px;
+    padding: 12px;
+    background: rgba(0, 0, 0, 0.3);
+    border-radius: 6px;
+
+    .combat-side {
+      flex: 1;
+      text-align: center;
+      padding: 12px;
+      border-radius: 6px;
+
+      &.winner {
+        background: rgba(0, 255, 0, 0.1);
+        border: 2px solid rgba(0, 255, 0, 0.4);
+      }
+
+      &.loser {
+        background: rgba(255, 0, 0, 0.1);
+        border: 2px solid rgba(255, 0, 0, 0.3);
+      }
+
+      .side-label {
+        font-size: calc(var(--font-size-standard) * 0.8);
+        color: #aaa;
+        text-transform: uppercase;
+        letter-spacing: 1px;
+        margin-bottom: 4px;
+      }
+
+      .side-name {
+        font-size: calc(var(--font-size-standard) * 1);
+        color: #f0e6d2;
+        font-weight: 600;
+        margin-bottom: 8px;
+      }
+
+      .side-roll {
+        font-size: calc(var(--font-size-standard) * 1.5);
+        color: #d4af37;
+        font-weight: 700;
+      }
+    }
+
+    .combat-vs {
+      font-size: calc(var(--font-size-standard) * 1.2);
+      color: #d4af37;
+      font-weight: 700;
+      padding: 0 16px;
+    }
+  }
+
+  .combat-result-text {
+    text-align: center;
+    font-size: calc(var(--font-size-standard) * 1.1);
+    color: #f0e6d2;
+    margin-bottom: 16px;
+    padding: 12px;
+    background: rgba(0, 0, 0, 0.2);
+    border-radius: 6px;
+
+    i {
+      margin-right: 8px;
+    }
+
+    strong {
+      color: #d4af37;
+    }
+  }
+
+  .attack-result-damage {
+    display: grid;
+    grid-template-columns: repeat(2, 1fr);
+    gap: 8px;
+
+    &.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 14px;
+      background: linear-gradient(to bottom, #8b0000 0%, #660000 100%);
+      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 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.5), inset 0 1px 0 rgba(255, 255, 255, 0.15);
+        transform: translateY(-2px);
+        border-color: #5b0000;
+      }
+
+      &:active {
+        transform: translateY(0);
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.4), inset 0 1px 3px rgba(0, 0, 0, 0.3);
+      }
+    }
+  }
+}

styles/global.less

@@ -47,7 +47,7 @@ i.lethalfantasy {
 
 .application.dialog.lethalfantasy {
   font-family: var(--font-primary);
-  font-size: calc(var(--font-size-standard) * 1.0);
+  font-size: calc(var(--font-size-standard) * 1);
   background-image: var(--background-image-base);
   button:hover {
     background: var(--color-dark-6);
@@ -70,12 +70,12 @@ i.lethalfantasy {
   background-size: 100% 100%;
 }
 
-.combat-sidebar li.combatant .token-initiative .initiative{
+.combat-sidebar li.combatant .token-initiative .initiative {
   margin-right: 16px;
 }
 
 .combat-sidebar li.combatant .token-initiative {
-  flex:none;
+  flex: none;
 }
 .initiative-minus {
   margin-right: 8px;

styles/hud.less

@@ -35,10 +35,302 @@
   padding-bottom: 0;
   width: max-content;
   margin: 0;
-  color:#252424;
+  color: #252424;
 }
 
-#token-hud .hp-loss-wrap  .hud-loss-hp-button-select {
+#token-hud .hp-loss-wrap .hud-loss-hp-button-select {
   padding-left: 8px;
   font-size: 0.9rem;
 }
+
+/* HP Gain Styles */
+#token-hud .hp-gain-wrap {
+  position: absolute;
+  left: 75px;
+  display: none;
+  top: 50%;
+  width: 48px;
+  text-align: start;
+  overflow-y: auto;
+}
+
+#token-hud .hp-gain-wrap-col1 {
+  transform: translate(-200%, -50%);
+}
+
+#token-hud .hp-gain-wrap-col2 {
+  transform: translate(-300%, -50%);
+}
+
+#token-hud .hp-gain-wrap-col3 {
+  transform: translate(-400%, -50%);
+}
+
+#token-hud .hp-gain-hud-active {
+  display: block;
+}
+
+#token-hud .hp-gain-hud-disabled {
+  display: none;
+}
+
+#token-hud .hud-gain-hp-button-select {
+  max-width: 40px;
+  background-image: var(--background-image-base);
+  padding-top: 0;
+  padding-bottom: 0;
+  width: max-content;
+  margin: 0;
+  color: #252424;
+}
+
+#token-hud .hp-gain-wrap .hud-gain-hp-button-select {
+  padding-left: 8px;
+  font-size: 0.9rem;
+}
+
+/* -------------------------------------------------- */
+/* Dice Tray — injected into the Foundry chat sidebar */
+/* -------------------------------------------------- */
+
+.lf-dice-tray {
+  padding: 6px 8px;
+  background:
+    linear-gradient(135deg, rgba(245, 232, 200, 0.97) 0%, rgba(238, 222, 185, 0.97) 100%),
+    url("/systems/fvtt-lethal-fantasy/assets/ui/lethal_fantasy_background.webp") center / cover;
+  border-top: 2px solid rgba(139, 69, 19, 0.5);
+  border-bottom: 1px solid rgba(139, 69, 19, 0.25);
+  width: 100%;
+  box-sizing: border-box;
+  pointer-events: all;
+
+  .lf-dt-row {
+    display: flex;
+    align-items: center;
+    gap: 5px;
+    flex-wrap: wrap;
+  }
+
+  .lf-dt-label {
+    color: #3a2a10;
+    font-size: 15px;
+    flex-shrink: 0;
+    opacity: 0.7;
+  }
+
+  .lf-dt-count {
+    width: 44px;
+    flex-shrink: 0;
+    padding: 3px 4px;
+    background: rgba(139, 69, 19, 0.15);
+    border: 1px solid rgba(139, 69, 19, 0.45);
+    border-radius: 4px;
+    color: #2a1a08;
+    font-size: 11px;
+    font-weight: 700;
+    cursor: pointer;
+    text-align: center;
+
+    option { background: #f5ead0; color: #2a1a08; }
+
+    &:focus {
+      outline: none;
+      border-color: rgba(139, 69, 19, 0.7);
+      box-shadow: 0 0 4px rgba(139, 69, 19, 0.25);
+    }
+  }
+
+  .lf-dt-dice {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 3px;
+    flex: 1;
+  }
+
+  .lf-dt-die-btn {
+    padding: 3px 7px;
+    background: rgba(139, 69, 19, 0.15);
+    border: 1px solid rgba(139, 69, 19, 0.4);
+    border-radius: 4px;
+    color: #2a1a08;
+    font-size: 10px;
+    font-weight: 700;
+    cursor: pointer;
+    transition: background 0.15s, border-color 0.15s, box-shadow 0.15s, transform 0.1s;
+    line-height: 1.5;
+    letter-spacing: 0.3px;
+
+    &:hover {
+      background: rgba(139, 69, 19, 0.35);
+      border-color: rgba(139, 69, 19, 0.7);
+      color: #5a2a00;
+      box-shadow: 0 0 5px rgba(139, 69, 19, 0.3);
+      transform: translateY(-1px);
+    }
+
+    &:active {
+      transform: translateY(0);
+      box-shadow: none;
+      background: rgba(139, 69, 19, 0.5);
+    }
+  }
+
+  .lf-dt-explode-label {
+    display: flex;
+    align-items: center;
+    gap: 3px;
+    cursor: pointer;
+    color: rgba(160, 80, 20, 0.7);
+    font-size: 14px;
+    flex-shrink: 0;
+    padding: 3px 6px;
+    border: 1px solid transparent;
+    border-radius: 4px;
+    transition: color 0.15s, border-color 0.15s, background 0.15s;
+
+    &:hover {
+      color: rgba(200, 100, 30, 0.9);
+      border-color: rgba(139, 69, 19, 0.45);
+      background: rgba(139, 69, 19, 0.12);
+    }
+
+    input[type="checkbox"] {
+      appearance: none;
+      width: 0;
+      height: 0;
+      position: absolute;
+      opacity: 0;
+
+      &:checked ~ i {
+        color: #cc4400;
+        filter: drop-shadow(0 0 4px rgba(200, 80, 0, 0.6));
+      }
+    }
+
+    &:has(input:checked) {
+      color: #cc4400;
+      border-color: rgba(139, 69, 19, 0.55);
+      background: rgba(139, 60, 10, 0.2);
+    }
+  }
+}
+
+/* Free roll chat card — styled to match regular system roll cards */
+.lf-free-roll-card {
+  border-radius: 6px;
+  overflow: hidden;
+
+  .lf-frc-header {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    padding: 6px 8px;
+    background: linear-gradient(135deg, rgba(40, 30, 20, 0.7) 0%, rgba(30, 22, 15, 0.9) 100%);
+    border-bottom: 2px solid rgba(139, 69, 19, 0.4);
+
+    i { color: #c9b896; font-size: calc(var(--font-size-standard, 14px) * 1.1); }
+
+    .lf-frc-title-text {
+      font-size: calc(var(--font-size-standard, 14px) * 0.85);
+      color: #c9b896;
+      text-transform: uppercase;
+      letter-spacing: 0.5px;
+    }
+
+    .lf-frc-badge {
+      display: inline-flex;
+      align-items: center;
+      padding: 2px 8px;
+      background: rgba(139, 69, 19, 0.3);
+      border: 1px solid rgba(139, 69, 19, 0.5);
+      border-radius: 10px;
+      font-size: calc(var(--font-size-standard, 14px) * 0.85);
+      font-weight: 600;
+      color: #d4c5a9;
+    }
+  }
+
+  .lf-frc-dice {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 4px;
+    padding: 6px 8px;
+    background: rgba(0, 0, 0, 0.15);
+    border: 1px solid rgba(139, 69, 19, 0.3);
+    border-top: none;
+
+    .lf-frc-die-chip {
+      display: flex;
+      align-items: center;
+      gap: 4px;
+      padding: 3px 8px;
+      background: rgba(139, 69, 19, 0.2);
+      border: 1px solid rgba(139, 69, 19, 0.3);
+      border-radius: 4px;
+
+      .lf-frc-die-type {
+        font-size: calc(var(--font-size-standard, 14px) * 0.85);
+        font-weight: 600;
+        color: #2a2a1a;
+        text-transform: uppercase;
+      }
+
+      .lf-frc-die-sep {
+        color: rgba(0, 0, 0, 0.35);
+        font-weight: 300;
+        font-size: calc(var(--font-size-standard, 14px) * 0.8);
+      }
+
+      .lf-frc-die-val {
+        font-weight: bold;
+        color: #ffd700;
+        font-size: calc(var(--font-size-standard, 14px) * 0.95);
+
+        .lf-dt-explode-icon {
+          font-size: 8px;
+          color: #ffcc00;
+          margin-left: 2px;
+          vertical-align: super;
+          text-shadow: 0 0 4px rgba(255, 200, 0, 0.8);
+        }
+      }
+
+      &.lf-frc-max {
+        background: rgba(139, 90, 19, 0.35);
+        border-color: rgba(200, 116, 42, 0.6);
+        .lf-frc-die-val { color: #ff9a40; text-shadow: 0 0 6px rgba(200, 116, 42, 0.6); }
+      }
+
+      &.lf-frc-min {
+        background: rgba(139, 20, 20, 0.25);
+        border-color: rgba(139, 34, 34, 0.5);
+        .lf-frc-die-val { color: #ff6b6b; }
+      }
+    }
+  }
+
+  .lf-frc-total-bar {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 8px;
+    padding: 6px 10px;
+    background: linear-gradient(135deg, rgba(40, 30, 20, 0.6) 0%, rgba(20, 15, 10, 0.8) 100%);
+    border: 2px solid rgba(139, 69, 19, 0.5);
+
+    .lf-frc-total-label {
+      font-size: calc(var(--font-size-standard, 14px) * 0.85);
+      text-transform: uppercase;
+      letter-spacing: 0.5px;
+      color: #c9b896;
+    }
+
+    .lf-frc-total-value {
+      font-family: var(--font-primary, serif);
+      font-size: calc(var(--font-size-standard, 14px) * 1.6);
+      font-weight: bold;
+      color: #e8d5a0;
+      text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.8);
+    }
+  }
+}

styles/monster.less

@@ -25,7 +25,6 @@
     gap: 10px;
     flex: 1;
 
-
     .monster-hp {
       display: flex;
       gap: 4px;
@@ -46,7 +45,7 @@
         min-width: 2.2rem;
         max-width: 2.2rem;
         margin-left: 4px;
-        font-size: calc(var(--font-size-standard) * 1.0);
+        font-size: calc(var(--font-size-standard) * 1);
       }
       .character-hp-max {
         clear: both;
@@ -58,7 +57,7 @@
         input {
           width: 3.2rem;
           text-align: center;
-          font-size: calc(var(--font-size-standard) * 1.0);
+          font-size: calc(var(--font-size-standard) * 1);
         }
       }
     }
@@ -121,9 +120,11 @@
     flex: 1;
 
     .monster-skill {
-      display: flex;
+      display: grid;
+      grid-template-columns: repeat(3, auto 2.5rem);
+      gap: 0.5rem;
       align-items: center;
-      margin-right: 0.5rem;
+
       .rollable:hover,
       .rollable:focus {
         text-shadow: 0 0 8px var(--color-shadow-primary);
@@ -134,12 +135,9 @@
         max-width: 2.5rem;
       }
       .name {
-        flex: 1;
-        min-width: 3.2rem;
         margin-left: 4px;
       }
       .form-group {
-        flex: 1;
         padding-left: 4px;
         .form-fields {
           flex: none;
@@ -157,8 +155,9 @@
 
     .monster-movement {
       display: flex;
-      align-items: center;
-      margin-right: 0.5rem;
+      flex-direction: column;
+      gap: 4px;
+
       .rollable:hover,
       .rollable:focus {
         text-shadow: 0 0 8px var(--color-shadow-primary);
@@ -252,7 +251,7 @@
   }
 }
 
-.tab.monster-skills .main-div{
+.tab.monster-skills .main-div {
   display: grid;
   grid-template-columns: 1fr;
   legend {
@@ -411,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);

system.json

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

templates/apply-damage-dialog.hbs

@@ -0,0 +1,37 @@
+<div class="apply-damage-dialog">
+  <div class="dialog-content">
+    <div class="header">
+      <strong>{{targetName}}</strong>
+      -
+      {{weaponName}}
+    </div>
+
+    <div class="damage-summary">
+      <span class="label">{{localize
+          "LETHALFANTASY.Dialog.totalDamage"
+        }}:</span>
+      <span class="damage-value">{{damageTotal}}</span>
+    </div>
+
+    <div class="dr-summary">
+      <span>{{localize "LETHALFANTASY.Dialog.armorDR"}}: {{armorDR}}</span>
+      <span>{{localize "LETHALFANTASY.Dialog.shieldDR"}}: {{shieldDR}}</span>
+      <span class="total">DR: <strong>{{totalDR}}</strong></span>
+    </div>
+
+    <div class="damage-options">
+      <div class="option-line">
+        <span>{{localize "LETHALFANTASY.Dialog.noDR"}}</span>
+        <strong>{{damageNoDR}}</strong>
+      </div>
+      <div class="option-line">
+        <span>{{localize "LETHALFANTASY.Dialog.withArmor"}}</span>
+        <strong>{{damageWithArmor}}</strong>
+      </div>
+      <div class="option-line">
+        <span>{{localize "LETHALFANTASY.Dialog.withAll"}}</span>
+        <strong>{{damageWithAll}}</strong>
+      </div>
+    </div>
+  </div>
+</div>

templates/character-biography.hbs

@@ -1,97 +1,180 @@
-<section class="tab character-{{tab.id}} {{tab.cssClass}}" data-tab="{{tab.id}}" data-group="{{tab.group}}">
+<section
+  class="tab character-{{tab.id}} {{tab.cssClass}}"
+  data-tab="{{tab.id}}"
+  data-group="{{tab.group}}"
+>
   <div class="main-div">
 
-  <fieldset>
-    <legend>{{localize "LETHALFANTASY.Label.biodata"}}</legend>
-    <div class="biodata">
-      <div class="biodata-elem">
-        <span class="name">Class</span>
-        {{formInput systemFields.biodata.fields.class value=system.biodata.class }}
-      </div>
-      <div class="biodata-elem">
-        <span class="name">Level</span>
-        {{formInput systemFields.biodata.fields.level value=system.biodata.level }}
-      </div>
-      <div class="biodata-elem">
-        <span class="name">Mortal</span>
-        {{formInput systemFields.biodata.fields.mortal value=system.biodata.mortal }}
-      </div>
-      <div class="biodata-elem">
-        <span class="name">Alignment</span>
-        {{formInput systemFields.biodata.fields.alignment value=system.biodata.alignment }}
-      </div>
-      <div class="biodata-elem">
-        <span class="name">Age</span>
-        {{formInput systemFields.biodata.fields.age value=system.biodata.age }}
-      </div>
-      <div class="biodata-elem">
-        <span class="name">Height</span>
-        {{formInput systemFields.biodata.fields.height value=system.biodata.height }}
-      </div>
-      <div class="biodata-elem">
-        <span class="name">Weight</span>
-        {{formInput systemFields.biodata.fields.weight value=system.biodata.weight }}
-      </div>
-      <div class="biodata-elem">
-        <span class="name">Eyes</span>
-        {{formInput systemFields.biodata.fields.eyes value=system.biodata.eyes }}
-      </div>
-      <div class="biodata-elem">
-        <span class="name">Hair</span>
-        {{formInput systemFields.biodata.fields.hair value=system.biodata.hair }}
-      </div>
-      <div class="biodata-elem">
-        <span class="name">Dev. Points (Total)</span>
-        {{formInput systemFields.developmentPoints.fields.total value=system.developmentPoints.total }}
-      </div>
-      <div class="biodata-elem">
-        <span class="name">Dev. Points (Rem.)</span>
-        {{formInput systemFields.developmentPoints.fields.remaining value=system.developmentPoints.remaining }}
-      </div>
-      <div class="biodata-elem">
-        <span class="name">Magic User</span>
-        {{formInput systemFields.biodata.fields.magicUser value=system.biodata.magicUser }}
-      </div>
-      <div class="biodata-elem">
-        <span class="name">Cleric User</span>
-        {{formInput systemFields.biodata.fields.clericUser value=system.biodata.clericUser }}
-      </div>
-      <div class="biodata-elem">
-        <span class="name">Save bonus (1/5levels)</span>
-        {{formInput systemFields.modifiers.fields.saveModifier value=system.modifiers.saveModifier disabled=true}}
-      </div>
+    <fieldset>
+      <legend>{{localize "LETHALFANTASY.Label.biodata"}}</legend>
+      <div class="biodata">
+        <div class="biodata-elem">
+          <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">{{localize "LETHALFANTASY.Label.level"}}</span>
+          {{formInput
+            systemFields.biodata.fields.level
+            value=system.biodata.level
+          }}
+        </div>
+        <div class="biodata-elem">
+          <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">{{localize "LETHALFANTASY.Label.alignment"}}</span>
+          {{formInput
+            systemFields.biodata.fields.alignment
+            value=system.biodata.alignment
+          }}
+        </div>
+        <div class="biodata-elem">
+          <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">{{localize "LETHALFANTASY.Label.height"}}</span>
+          {{formInput
+            systemFields.biodata.fields.height
+            value=system.biodata.height
+          }}
+        </div>
+        <div class="biodata-elem">
+          <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">{{localize "LETHALFANTASY.Label.eyes"}}</span>
+          {{formInput
+            systemFields.biodata.fields.eyes
+            value=system.biodata.eyes
+          }}
+        </div>
+        <div class="biodata-elem">
+          <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">{{localize "LETHALFANTASY.Label.devPointsTotal"}}</span>
+          {{formInput
+            systemFields.developmentPoints.fields.total
+            value=system.developmentPoints.total
+          }}
+        </div>
+        <div class="biodata-elem">
+          <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">{{localize "LETHALFANTASY.Label.magicUser"}}</span>
+          {{formInput
+            systemFields.biodata.fields.magicUser
+            value=system.biodata.magicUser
+          }}
+        </div>
+        <div class="biodata-elem">
+          <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">{{localize "LETHALFANTASY.Label.saveBonus"}}</span>
+          {{formInput
+            systemFields.modifiers.fields.saveModifier
+            value=system.modifiers.saveModifier
+            disabled=true
+          }}
+        </div>
 
-      {{#if system.biodata.magicUser}}
-      <div class="biodata-elem">
-        <span class="name">Spell bonus (1/5levels)</span>
-        {{formInput systemFields.modifiers.fields.levelSpellModifier value=system.modifiers.levelSpellModifier disabled=true}}
-      </div>
-      {{/if}}
-      {{#if system.biodata.clericUser}}
-      <div class="biodata-elem">
-        <span class="name">Miracle bonus (1/5levels)</span>
-        {{formInput systemFields.modifiers.fields.levelMiracleModifier value=system.modifiers.levelMiracleModifier disabled=true}}
-      </div>
-      {{/if}}
+        {{#if system.biodata.magicUser}}
+          <div class="biodata-elem">
+            <span class="name">{{localize "LETHALFANTASY.Label.spellBonus"}}</span>
+            {{formInput
+              systemFields.modifiers.fields.levelSpellModifier
+              value=system.modifiers.levelSpellModifier
+              disabled=true
+            }}
+          </div>
+        {{/if}}
+        {{#if system.biodata.clericUser}}
+          <div class="biodata-elem">
+            <span class="name">{{localize "LETHALFANTASY.Label.miracleBonus"}}</span>
+            {{formInput
+              systemFields.modifiers.fields.levelMiracleModifier
+              value=system.modifiers.levelMiracleModifier
+              disabled=true
+            }}
+          </div>
+        {{/if}}
 
-      <div class="biodata-elem">
-        <span class="name">Last HD roll</span>
-        {{formInput systemFields.biodata.fields.hpPerLevel value=system.biodata.hpPerLevel disabled=true}}
-      </div>
+        <div class="biodata-elem">
+          <span class="name">{{localize "LETHALFANTASY.Label.lastHdRoll"}}</span>
+          {{formInput
+            systemFields.biodata.fields.hpPerLevel
+            value=system.biodata.hpPerLevel
+            disabled=isPlayMode
+          }}
+        </div>
 
+        <div class="biodata-elem">
+          <span class="name">{{localize "LETHALFANTASY.Label.naturalDR"}}</span>
+          {{formInput
+            systemFields.biodata.fields.naturalDR
+            value=system.biodata.naturalDR
+            disabled=isPlayMode
+          }}
+        </div>
 
-    </div>
-  </fieldset>
+        <div class="biodata-elem">
+          <span class="name">{{localize "LETHALFANTASY.Label.magicalDR"}}</span>
+          {{formInput
+            systemFields.biodata.fields.magicDR
+            value=system.biodata.magicDR
+            disabled=isPlayMode
+          }}
+        </div>
 
-  <fieldset>
-    <legend>{{localize "LETHALFANTASY.Label.description"}}</legend>
-    {{formInput systemFields.description enriched=enrichedDescription value=system.description name="system.description"
-    toggled=true}}
-  </fieldset>
+      </fieldset>
 
-  <fieldset>
-    <legend>{{localize "LETHALFANTASY.Label.notes"}}</legend>
-    {{formInput systemFields.notes enriched=enrichedNotes value=system.notes name="system.notes" toggled=true}}
-  </fieldset>
+    <fieldset>
+      <legend>{{localize "LETHALFANTASY.Label.description"}}</legend>
+      {{formInput
+        systemFields.description
+        enriched=enrichedDescription
+        value=system.description
+        name="system.description"
+        toggled=true
+      }}
+    </fieldset>
+
+    <fieldset>
+      <legend>{{localize "LETHALFANTASY.Label.notes"}}</legend>
+      {{formInput
+        systemFields.notes
+        enriched=enrichedNotes
+        value=system.notes
+        name="system.notes"
+        toggled=true
+      }}
+    </fieldset>
   </div>
 </section>

templates/character-combat.hbs

@@ -21,6 +21,11 @@
             <a data-action="armorHitPointsMinus"><i class="fa-solid fa-hexagon-minus"></i></a>
           </div>
 
+          <div class="flexrow armor-hp">
+            <span class="name" data-tooltip="{{localize 'LETHALFANTASY.Tooltip.combatProgressionStart'}}">{{localize "LETHALFANTASY.Label.combatProgressionStart"}}</span>
+            {{formInput systemFields.combat.fields.combatProgressionStart value=system.combat.combatProgressionStart disabled=isPlayMode }}
+          </div>
+
           <div class="flexrow granted">
             <span class="">{{localize
               "LETHALFANTASY.Label.grantedAttackDice"}}</a></span>
@@ -120,6 +125,7 @@
           <div class="item-detail" data-tooltip="Maximum movement">{{item.system.maximumMovement}}</div>
           <div class="item-detail" data-tooltip="HP">{{item.system.hp}}</div>
           <div class="item-detail" data-tooltip="Damage Reduction">{{item.system.damageReduction}}</div>
+          <div class="item-detail" data-tooltip={{#if item.system.equipped}}"Equipped"{{else}}"Not Equipped"{{/if}}>{{#if item.system.equipped}}<i class="fas fa-check"></i>{{else}}<i class="fas fa-times"></i>{{/if}}</div>
           <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>
@@ -149,7 +155,7 @@
           </div>
           <div class="item-detail" data-tooltip="Movement reduction">{{item.system.movementreduction}}</div>
           <div class="item-detail" data-tooltip="Has cover">{{#if item.system.hascover}}Cover{{/if}}</div>
-
+          <div class="item-detail" data-tooltip={{#if item.system.equipped}}"Equipped"{{else}}"Not Equipped"{{/if}}>{{#if item.system.equipped}}<i class="fas fa-check"></i>{{else}}<i class="fas fa-times"></i>{{/if}}</div>
           <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/character-main.hbs

@@ -1,4 +1,6 @@
-<section class="character-main character-main-{{ifThen isPlayMode 'play' 'edit'}}">
+<section
+  class="character-main character-main-{{ifThen isPlayMode 'play' 'edit'}}"
+>
   {{log "character-main" this}}
 
   <fieldset>
@@ -6,99 +8,189 @@
     <div class="character-pc character-pc-{{ifThen isPlayMode 'play' 'edit'}}">
       <div class="character-left">
         <div class="character-left-image">
-          <img class="character-img" src="{{actor.img}}" data-edit="img" data-action="editImage"
-            data-tooltip="{{actor.name}}" />
+          <img
+            class="character-img"
+            src="{{actor.img}}"
+            data-edit="img"
+            data-action="editImage"
+            data-tooltip="{{actor.name}}"
+          />
         </div>
 
         <fieldset class="">
           <div class="flexrow character-hp">
             <span class="name">{{localize "LETHALFANTASY.Label.HP"}}</span>
-            {{formInput systemFields.hp.fields.value value=system.hp.value disabled=isPlayMode
-            classes="character-hp-value"}}
+            {{formInput
+              systemFields.hp.fields.value
+              value=system.hp.value
+              disabled=isPlayMode
+              classes="character-hp-value"
+            }}
             &nbsp;/&nbsp;
-            {{formInput systemFields.hp.fields.max value=system.hp.max disabled=isPlayMode
-            classes="character-hp-value"}}
+            {{formInput
+              systemFields.hp.fields.max
+              value=system.hp.max
+              disabled=isPlayMode
+              classes="character-hp-value"
+            }}
           </div>
           <div class="flexrow character-hp">
             <span class="name">{{localize "LETHALFANTASY.Label.grit"}}</span>
-            {{formInput systemFields.grit.fields.current value=system.grit.current disabled=isPlayMode
-            classes="character-hp"}}
+            {{formInput
+              systemFields.grit.fields.current
+              value=system.grit.current
+              disabled=isPlayMode
+              classes="character-hp"
+            }}
             <span class="name">{{localize "LETHALFANTASY.Label.earned"}}</span>
-            {{formInput systemFields.grit.fields.earned value=system.grit.earned disabled=isPlayMode
-            classes="character-hp"}}
+            {{formInput
+              systemFields.grit.fields.earned
+              value=system.grit.earned
+              disabled=isPlayMode
+              classes="character-hp"
+            }}
           </div>
           <div class="flexrow character-hp">
             <span class="name">{{localize "LETHALFANTASY.Label.luck"}}</span>
-            {{formInput systemFields.luck.fields.current value=system.luck.current disabled=isPlayMode
-            classes="character-hp"}}
+            {{formInput
+              systemFields.luck.fields.current
+              value=system.luck.current
+              disabled=isPlayMode
+              classes="character-hp"
+            }}
             <span class="name">{{localize "LETHALFANTASY.Label.earned"}}</span>
-            {{formInput systemFields.luck.fields.earned value=system.luck.earned disabled=isPlayMode
-            classes="character-hp"}}
+            {{formInput
+              systemFields.luck.fields.earned
+              value=system.luck.earned
+              disabled=isPlayMode
+              classes="character-hp"
+            }}
           </div>
 
-          <div class="flexrow ">
-            <span class="">{{localize "LETHALFANTASY.Label.damageResistanceShort"}}</span>
-            {{formInput systemFields.hp.fields.damageResistance value=system.hp.fields.damageResistance
-            disabled=isPlayMode classes="character-hp"}}
-          </div>
+          <div class="flexrow">
+            <span class="" data-tooltip="Damage reduction">{{localize
+                "LETHALFANTASY.Label.damageResistanceShort"
+              }}
+            </span>
+            <input
+              type="text"
+              class="character-damage-reduction"
+              data-tooltip="DR (armor+natural+magical)"
+              disabled
+              value={{damageReduction}}
+            />
+            <input
+              type="text"
+              class="character-damage-reduction"
+              data-tooltip="DR (shield)"
+              disabled
+              value={{damageReductionShield}}
+            />
 
+          </div>
 
         </fieldset>
 
       </div>
       <div class="character-right">
         <div class="character-name">
-          {{formInput fields.name value=source.name rootId=partId disabled=isPlayMode}}
-          <a class="control" data-action="toggleSheet" data-tooltip="LETHALFANTASY.ToggleSheet"
-            data-tooltip-direction="UP">
+          {{formInput
+            fields.name
+            value=source.name
+            rootId=partId
+            disabled=isPlayMode
+          }}
+          <a
+            class="control"
+            data-action="toggleSheet"
+            data-tooltip="LETHALFANTASY.ToggleSheet"
+            data-tooltip-direction="UP"
+          >
             <i class="fa-solid fa-user-{{ifThen isPlayMode 'lock' 'pen'}}"></i>
           </a>
         </div>
 
-        <fieldset class="character-characteristics character-characteristics-{{ifThen isPlayMode 'play' 'edit'}}">
+        <fieldset
+          class="character-characteristics character-characteristics-{{ifThen
+              isPlayMode
+              'play'
+              'edit'
+            }}"
+        >
           <legend>{{localize "LETHALFANTASY.Label.Saves"}}</legend>
           <div class="character-saves">
             <div class="character-save">
-              <span class="name"><a class="rollable" data-roll-type="save" data-roll-key="will"><i
-                    class="lf-roll-small fa-solid fa-dice-d20"></i>
+              <span class="name"><a
+                  class="rollable"
+                  data-roll-type="save"
+                  data-roll-key="will"
+                ><i class="lf-roll-small fa-solid fa-dice-d20"></i>
                   {{localize "LETHALFANTASY.Label.saves.will"}}
                 </a></span>
-              {{formField systemFields.saves.fields.will.fields.value value=system.saves.will.value disabled=true}}
+              {{formField
+                systemFields.saves.fields.will.fields.value
+                value=system.saves.will.value
+                disabled=true
+              }}
               <span class="name">
-                <a class="rollable" data-roll-type="save" data-roll-key="dodge"><i
-                    class="lf-roll-small fa-solid fa-dice-d20"></i>
+                <a
+                  class="rollable"
+                  data-roll-type="save"
+                  data-roll-key="dodge"
+                ><i class="lf-roll-small fa-solid fa-dice-d20"></i>
                   {{localize "LETHALFANTASY.Label.saves.dodge"}}
                 </a>
               </span>
-              {{formField systemFields.saves.fields.dodge.fields.value value=system.saves.dodge.value
-              disabled=true}}
+              {{formField
+                systemFields.saves.fields.dodge.fields.value
+                value=system.saves.dodge.value
+                disabled=true
+              }}
               <span class="name">
-                <a class="rollable" data-roll-type="save" data-roll-key="toughness"><i
-                    class="lf-roll-small fa-solid fa-dice-d20"></i>
+                <a
+                  class="rollable"
+                  data-roll-type="save"
+                  data-roll-key="toughness"
+                ><i class="lf-roll-small fa-solid fa-dice-d20"></i>
                   {{localize "LETHALFANTASY.Label.saves.toughness"}}
                 </a>
               </span>
-              {{formField systemFields.saves.fields.toughness.fields.value value=system.saves.toughness.value
-              disabled=true}}
+              {{formField
+                systemFields.saves.fields.toughness.fields.value
+                value=system.saves.toughness.value
+                disabled=true
+              }}
             </div>
             <div class="character-save">
               <span class="name">
-                <a class="rollable" data-roll-type="save" data-roll-key="contagion"><i
-                    class="lf-roll-small fa-solid fa-dice-d20"></i>
+                <a
+                  class="rollable"
+                  data-roll-type="save"
+                  data-roll-key="contagion"
+                ><i class="lf-roll-small fa-solid fa-dice-d20"></i>
                   {{localize "LETHALFANTASY.Label.saves.contagion"}}
                 </a>
               </span>
-              {{formField systemFields.saves.fields.contagion.fields.value value=system.saves.contagion.value
-              disabled=true}}
+              {{formField
+                systemFields.saves.fields.contagion.fields.value
+                value=system.saves.contagion.value
+                disabled=true
+              }}
 
               <span class="name">
-                <a class="rollable" data-roll-type="save" data-roll-key="poison"><i
-                    class="lf-roll-small fa-solid fa-dice-d20"></i>
+                <a
+                  class="rollable"
+                  data-roll-type="save"
+                  data-roll-key="poison"
+                ><i class="lf-roll-small fa-solid fa-dice-d20"></i>
                   {{localize "LETHALFANTASY.Label.saves.poison"}}
                 </a>
               </span>
-              {{formField systemFields.saves.fields.poison.fields.value value=system.saves.poison.value
-              disabled=true }}
+              {{formField
+                systemFields.saves.fields.poison.fields.value
+                value=system.saves.poison.value
+                disabled=true
+              }}
 
               <!--
               <span class="name-pain">
@@ -125,51 +217,124 @@
           </div>
         </fieldset>
 
-        <fieldset class="character-characteristics character-characteristics-{{ifThen isPlayMode 'play' 'edit'}}">
+        <fieldset
+          class="character-characteristics character-characteristics-{{ifThen
+              isPlayMode
+              'play'
+              'edit'
+            }}"
+        >
           <legend>{{localize "LETHALFANTASY.Label.Challenges"}}</legend>
           <div class="character-challenges">
             <div class="character-challenge">
-              <span class="name"><a class="rollable" data-roll-type="challenge" data-roll-key="str"><i
-                    class="lf-roll-small fa-solid fa-dice-d20"></i>{{localize
-                  "LETHALFANTASY.Label.challenges.strength"}}</a></span>
-              {{formField systemFields.challenges.fields.str.fields.value value=system.challenges.str.value
-              disabled=true
+              <span class="name"><a
+                  class="rollable"
+                  data-roll-type="challenge"
+                  data-roll-key="str"
+                ><i class="lf-roll-small fa-solid fa-dice-d20"></i>{{localize
+                    "LETHALFANTASY.Label.challenges.strength"
+                  }}</a></span>
+              {{formField
+                systemFields.challenges.fields.str.fields.value
+                value=system.challenges.str.value
+                disabled=true
               }}
-              <span class="name"><a class="rollable" data-roll-type="challenge" data-roll-key="agility"><i
-                    class="lf-roll-small fa-solid fa-dice-d20"></i>{{localize
-                  "LETHALFANTASY.Label.challenges.agility"}}</a></span>
-              {{formField systemFields.challenges.fields.agility.fields.value value=system.challenges.agility.value
-              disabled=true
+              <span class="name"><a
+                  class="rollable"
+                  data-roll-type="challenge"
+                  data-roll-key="agility"
+                ><i class="lf-roll-small fa-solid fa-dice-d20"></i>{{localize
+                    "LETHALFANTASY.Label.challenges.agility"
+                  }}</a></span>
+              {{formField
+                systemFields.challenges.fields.agility.fields.value
+                value=system.challenges.agility.value
+                disabled=true
+              }}
+              <span class="name"><a
+                  class="rollable"
+                  data-roll-type="challenge"
+                  data-roll-key="dying"
+                ><i class="lf-roll-small fa-solid fa-dice-d20"></i>{{localize
+                    "LETHALFANTASY.Label.challenges.dying"
+                  }}</a></span>
+              {{formField
+                systemFields.challenges.fields.dying.fields.value
+                value=system.challenges.dying.value
+                disabled=true
               }}
-              <span class="name"><a class="rollable" data-roll-type="challenge" data-roll-key="dying"><i
-                    class="lf-roll-small fa-solid fa-dice-d20"></i>{{localize
-                  "LETHALFANTASY.Label.challenges.dying"}}</a></span>
-              {{formField systemFields.challenges.fields.dying.fields.value value=system.challenges.dying.value
-              disabled=true }}
             </div>
           </div>
         </fieldset>
 
-        <fieldset class="character-characteristics character-characteristics-{{ifThen isPlayMode 'play' 'edit'}}">
+        <fieldset
+          class="character-characteristics character-characteristics-{{ifThen
+              isPlayMode
+              'play'
+              'edit'
+            }}"
+        >
           <legend>{{localize "LETHALFANTASY.Label.Movement"}}</legend>
           <div class="character-movements">
             <div class="character-movement">
-              <span class="name">{{localize "LETHALFANTASY.Label.movement.walk"}}</span>
-              {{formField systemFields.movement.fields.walk value=system.movement.walk disabled=isPlayMode}}
-              <span class="name">{{localize "LETHALFANTASY.Label.movement.jog"}}</span>
-              {{formField systemFields.movement.fields.jog value=system.movement.jog disabled=isPlayMode}}
-              <span class="name">{{localize "LETHALFANTASY.Label.movement.run"}}</span>
-              {{formField systemFields.movement.fields.run value=system.movement.run disabled=isPlayMode}}
-              <span class="name">{{localize "LETHALFANTASY.Label.movement.sprint"}}</span>
-              {{formField systemFields.movement.fields.sprint value=system.movement.sprint disabled=isPlayMode}}
+              <span class="name">{{localize
+                  "LETHALFANTASY.Label.movement.walk"
+                }}</span>
+              {{formField
+                systemFields.movement.fields.walk
+                value=system.movement.walk
+                disabled=isPlayMode
+              }}
+              <span class="name">{{localize
+                  "LETHALFANTASY.Label.movement.jog"
+                }}</span>
+              {{formField
+                systemFields.movement.fields.jog
+                value=system.movement.jog
+                disabled=isPlayMode
+              }}
+              <span class="name">{{localize
+                  "LETHALFANTASY.Label.movement.run"
+                }}</span>
+              {{formField
+                systemFields.movement.fields.run
+                value=system.movement.run
+                disabled=isPlayMode
+              }}
+              <span class="name">{{localize
+                  "LETHALFANTASY.Label.movement.sprint"
+                }}</span>
+              {{formField
+                systemFields.movement.fields.sprint
+                value=system.movement.sprint
+                disabled=isPlayMode
+              }}
             </div>
             <div class="character-movement">
-              <span class="name">{{localize "LETHALFANTASY.Label.movement.jumpBroad"}}</span>
-              {{formField systemFields.jump.fields.broad value=system.jump.broad disabled=isPlayMode}}
-              <span class="name">{{localize "LETHALFANTASY.Label.movement.jumpRunning"}}</span>
-              {{formField systemFields.jump.fields.running value=system.jump.running disabled=isPlayMode}}
-              <span class="name">{{localize "LETHALFANTASY.Label.movement.jumpVertical"}}</span>
-              {{formField systemFields.jump.fields.vertical value=system.jump.vertical disabled=isPlayMode}}
+              <span class="name">{{localize
+                  "LETHALFANTASY.Label.movement.jumpBroad"
+                }}</span>
+              {{formField
+                systemFields.jump.fields.broad
+                value=system.jump.broad
+                disabled=isPlayMode
+              }}
+              <span class="name">{{localize
+                  "LETHALFANTASY.Label.movement.jumpRunning"
+                }}</span>
+              {{formField
+                systemFields.jump.fields.running
+                value=system.jump.running
+                disabled=isPlayMode
+              }}
+              <span class="name">{{localize
+                  "LETHALFANTASY.Label.movement.jumpVertical"
+                }}</span>
+              {{formField
+                systemFields.jump.fields.vertical
+                value=system.jump.vertical
+                disabled=isPlayMode
+              }}
             </div>
           </div>
         </fieldset>
@@ -178,62 +343,124 @@
     </div>
   </fieldset>
 
-  <fieldset class="character-characteristics character-characteristics-{{ifThen isPlayMode 'play' 'edit'}}">
+  <fieldset
+    class="character-characteristics character-characteristics-{{ifThen
+        isPlayMode
+        'play'
+        'edit'
+      }}"
+  >
     <legend>{{localize "LETHALFANTASY.Label.characteristics"}}</legend>
     <div class="character-characteristic">
       <span>{{localize "LETHALFANTASY.Label.str"}}</span>
-      {{formField systemFields.characteristics.fields.str.fields.value value=system.characteristics.str.value
-      disabled=isPlayMode data-char-id="str" }}
-      {{formField systemFields.characteristics.fields.str.fields.percent value=system.characteristics.str.percent
-      disabled=isPlayMode type="number"}}
+      {{formField
+        systemFields.characteristics.fields.str.fields.value
+        value=system.characteristics.str.value
+        disabled=isPlayMode
+        data-char-id="str"
+      }}
+      {{formField
+        systemFields.characteristics.fields.str.fields.percent
+        value=system.characteristics.str.percent
+        disabled=isPlayMode
+        type="number"
+      }}
     </div>
     <div class="character-characteristic">
       <span>{{localize "LETHALFANTASY.Label.int"}}</span>
-      {{formField systemFields.characteristics.fields.int.fields.value value=system.characteristics.int.value
-      disabled=isPlayMode data-char-id="int" }}
+      {{formField
+        systemFields.characteristics.fields.int.fields.value
+        value=system.characteristics.int.value
+        disabled=isPlayMode
+        data-char-id="int"
+      }}
 
-      {{formField systemFields.characteristics.fields.int.fields.percent value=system.characteristics.int.percent
-      disabled=isPlayMode type="number" }}
+      {{formField
+        systemFields.characteristics.fields.int.fields.percent
+        value=system.characteristics.int.percent
+        disabled=isPlayMode
+        type="number"
+      }}
     </div>
     <div class="character-characteristic">
       <span>{{localize "LETHALFANTASY.Label.wis"}}</span>
-      {{formField systemFields.characteristics.fields.wis.fields.value value=system.characteristics.wis.value
-      disabled=isPlayMode data-char-id="wis" }}
+      {{formField
+        systemFields.characteristics.fields.wis.fields.value
+        value=system.characteristics.wis.value
+        disabled=isPlayMode
+        data-char-id="wis"
+      }}
 
-      {{formField systemFields.characteristics.fields.wis.fields.percent value=system.characteristics.wis.percent
-      disabled=isPlayMode type="number"}}
+      {{formField
+        systemFields.characteristics.fields.wis.fields.percent
+        value=system.characteristics.wis.percent
+        disabled=isPlayMode
+        type="number"
+      }}
     </div>
     <div class="character-characteristic">
       <span>{{localize "LETHALFANTASY.Label.dex"}}</span>
-      {{formField systemFields.characteristics.fields.dex.fields.value value=system.characteristics.dex.value
-      disabled=isPlayMode data-char-id="wis" }}
+      {{formField
+        systemFields.characteristics.fields.dex.fields.value
+        value=system.characteristics.dex.value
+        disabled=isPlayMode
+        data-char-id="wis"
+      }}
 
-      {{formField systemFields.characteristics.fields.dex.fields.percent value=system.characteristics.dex.percent
-      disabled=isPlayMode type="number" }}
+      {{formField
+        systemFields.characteristics.fields.dex.fields.percent
+        value=system.characteristics.dex.percent
+        disabled=isPlayMode
+        type="number"
+      }}
     </div>
     <div class="character-characteristic">
       <span>{{localize "LETHALFANTASY.Label.con"}}</span>
-      {{formField systemFields.characteristics.fields.con.fields.value value=system.characteristics.con.value
-      disabled=isPlayMode data-char-id="con" }}
+      {{formField
+        systemFields.characteristics.fields.con.fields.value
+        value=system.characteristics.con.value
+        disabled=isPlayMode
+        data-char-id="con"
+      }}
 
-      {{formField systemFields.characteristics.fields.con.fields.percent value=system.characteristics.con.percent
-      disabled=isPlayMode type="number"}}
+      {{formField
+        systemFields.characteristics.fields.con.fields.percent
+        value=system.characteristics.con.percent
+        disabled=isPlayMode
+        type="number"
+      }}
     </div>
     <div class="character-characteristic">
       <span>{{localize "LETHALFANTASY.Label.cha"}}</span>
-      {{formField systemFields.characteristics.fields.cha.fields.value value=system.characteristics.cha.value
-      disabled=isPlayMode data-char-id="cha" }}
+      {{formField
+        systemFields.characteristics.fields.cha.fields.value
+        value=system.characteristics.cha.value
+        disabled=isPlayMode
+        data-char-id="cha"
+      }}
 
-      {{formField systemFields.characteristics.fields.cha.fields.percent value=system.characteristics.cha.percent
-      disabled=isPlayMode type="number"}}
+      {{formField
+        systemFields.characteristics.fields.cha.fields.percent
+        value=system.characteristics.cha.percent
+        disabled=isPlayMode
+        type="number"
+      }}
     </div>
     <div class="character-characteristic">
       <span>{{localize "LETHALFANTASY.Label.luc"}}</span>
-      {{formField systemFields.characteristics.fields.luc.fields.value value=system.characteristics.luc.value
-      disabled=isPlayMode data-char-id="luc" }}
+      {{formField
+        systemFields.characteristics.fields.luc.fields.value
+        value=system.characteristics.luc.value
+        disabled=isPlayMode
+        data-char-id="luc"
+      }}
 
-      {{formField systemFields.characteristics.fields.luc.fields.percent value=system.characteristics.luc.percent
-      disabled=isPlayMode type="number"}}
+      {{formField
+        systemFields.characteristics.fields.luc.fields.percent
+        value=system.characteristics.luc.percent
+        disabled=isPlayMode
+        type="number"
+      }}
     </div>
   </fieldset>
 

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-skills.hbs

@@ -1,73 +1,145 @@
-<section class="tab character-{{tab.id}} {{tab.cssClass}}" data-tab="skills" data-group="sheet">
+<section
+  class="tab character-{{tab.id}} {{tab.cssClass}}"
+  data-tab="skills"
+  data-group="sheet"
+>
   <div class="main-div">
 
-  <fieldset>
-    <legend data-tooltip="{{localize " LETHALFANTASY.Tooltip.skills"}}" data-tooltip-direction="UP">{{localize
-      "LETHALFANTASY.Label.skills"}}</legend>
-    <div class="skills">
-      {{#each skills as |item|}}
-      <div class="skill " data-item-id="{{item.id}}" data-item-uuid="{{item.uuid}}">
-        <img class="item-img" src="{{item.img}}" data-tooltip="{{item.name}}" />
-        <div class="name">
-          <a class="rollable" data-roll-type="skill" data-roll-key="{{item.id}}">
-              <i class="lf-roll-small fa-duotone fa-solid fa-dice-d10"></i>
-            {{item.name}}
-          </a>
+    {{#each skillsByCategory as |categoryData|}}
+      <fieldset>
+        <legend
+          data-tooltip="{{localize ' LETHALFANTASY.Tooltip.skills'}}"
+          data-tooltip-direction="UP"
+        >{{localize categoryData.label}}</legend>
+        <div class="skills">
+          {{#each categoryData.skills as |item|}}
+            <div
+              class="skill"
+              data-item-id="{{item.id}}"
+              data-item-uuid="{{item.uuid}}"
+            >
+              <img
+                class="item-img"
+                src="{{item.img}}"
+                data-tooltip="{{item.name}}"
+              />
+              <div class="name">
+                <a
+                  class="rollable"
+                  data-roll-type="skill"
+                  data-roll-key="{{item.id}}"
+                >
+                  <i class="lf-roll-small fa-duotone fa-solid fa-dice-d10"></i>
+                  {{item.name}}
+                </a>
+              </div>
+              <div class="score">
+                +{{item.system.skillTotal}}
+              </div>
+              <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>
+                <a
+                  data-tooltip="{{localize 'LETHALFANTASY.Delete'}}"
+                  data-action="delete"
+                  data-item-id="{{item.id}}"
+                  data-item-uuid="{{item.uuid}}"
+                ><i class="fas fa-trash"></i></a>
+              </div>
+            </div>
+          {{/each}}
         </div>
-        <div class="score">
-          +{{item.system.skillTotal}}
-        </div>
-        <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>
-          <a data-tooltip="{{localize 'LETHALFANTASY.Delete'}}" data-action="delete" data-item-id="{{item.id}}"
-            data-item-uuid="{{item.uuid}}"><i class="fas fa-trash"></i></a>
-        </div>
-      </div>
-      {{/each}}
-    </div>
-  </fieldset>
+      </fieldset>
+    {{/each}}
 
-  <fieldset>
-    <legend data-tooltip="{{localize " LETHALFANTASY.Tooltip.gifts"}}" data-tooltip-direction="UP">{{localize
-      "LETHALFANTASY.Label.gifts"}}</legend>
-    <div class="gifts">
-      {{#each gifts as |item|}}
-      <div class="gift " data-item-id="{{item.id}}" data-item-uuid="{{item.uuid}}">
-        <img class="item-img" src="{{item.img}}" data-tooltip="{{item.name}}" />
-        <div class="name" data-tooltip="{{{item.description}}}<br><br>{{item.path}}" data-tooltip-direction="UP">
-          {{item.name}}
-        </div>
-        <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>
-          <a data-tooltip="{{localize 'LETHALFANTASY.Delete'}}" data-action="delete" data-item-id="{{item.id}}"
-            data-item-uuid="{{item.uuid}}"><i class="fas fa-trash"></i></a>
-        </div>
+    <fieldset>
+      <legend
+        data-tooltip="{{localize ' LETHALFANTASY.Tooltip.gifts'}}"
+        data-tooltip-direction="UP"
+      >{{localize "LETHALFANTASY.Label.gifts"}}</legend>
+      <div class="gifts">
+        {{#each gifts as |item|}}
+          <div
+            class="gift"
+            data-item-id="{{item.id}}"
+            data-item-uuid="{{item.uuid}}"
+          >
+            <img
+              class="item-img"
+              src="{{item.img}}"
+              data-tooltip="{{item.name}}"
+            />
+            <div
+              class="name"
+              data-tooltip="{{{item.description}}}<br><br>{{item.path}}"
+              data-tooltip-direction="UP"
+            >
+              {{item.name}}
+            </div>
+            <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>
+              <a
+                data-tooltip="{{localize 'LETHALFANTASY.Delete'}}"
+                data-action="delete"
+                data-item-id="{{item.id}}"
+                data-item-uuid="{{item.uuid}}"
+              ><i class="fas fa-trash"></i></a>
+            </div>
+          </div>
+        {{/each}}
       </div>
-      {{/each}}
-    </div>
-  </fieldset>
+    </fieldset>
 
-  <fieldset>
-    <legend data-tooltip="{{localize " LETHALFANTASY.Tooltip.vulnerabilities"}}" data-tooltip-direction="UP">{{localize
-      "LETHALFANTASY.Label.vulnerabilities"}}</legend>
-    <div class="vulnerabilities">
-      {{#each vulnerabilities as |item|}}
-      <div class="vulnerability " data-item-id="{{item.id}}" data-item-uuid="{{item.uuid}}">
-        <img class="item-img" src="{{item.img}}" data-tooltip="{{item.name}}" />
-        <div class="name" data-tooltip="{{{item.description}}}<br><br>{{item.path}}" data-tooltip-direction="UP">
-          {{item.name}}
-        </div>
-        <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>
-          <a data-tooltip="{{localize 'LETHALFANTASY.Delete'}}" data-action="delete" data-item-id="{{item.id}}"
-            data-item-uuid="{{item.uuid}}"><i class="fas fa-trash"></i></a>
-        </div>
+    <fieldset>
+      <legend
+        data-tooltip="{{localize ' LETHALFANTASY.Tooltip.vulnerabilities'}}"
+        data-tooltip-direction="UP"
+      >{{localize "LETHALFANTASY.Label.vulnerabilities"}}</legend>
+      <div class="vulnerabilities">
+        {{#each vulnerabilities as |item|}}
+          <div
+            class="vulnerability"
+            data-item-id="{{item.id}}"
+            data-item-uuid="{{item.uuid}}"
+          >
+            <img
+              class="item-img"
+              src="{{item.img}}"
+              data-tooltip="{{item.name}}"
+            />
+            <div
+              class="name"
+              data-tooltip="{{{item.description}}}<br><br>{{item.path}}"
+              data-tooltip-direction="UP"
+            >
+              {{item.name}}
+            </div>
+            <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>
+              <a
+                data-tooltip="{{localize 'LETHALFANTASY.Delete'}}"
+                data-action="delete"
+                data-item-id="{{item.id}}"
+                data-item-uuid="{{item.uuid}}"
+              ><i class="fas fa-trash"></i></a>
+            </div>
+          </div>
+        {{/each}}
       </div>
-      {{/each}}
-    </div>
-  </fieldset>
-</div>
+    </fieldset>
+  </div>
 </section>

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

@@ -1,88 +1,291 @@
 {{!log 'chat-message' this}}
+{{!log 'weaponDamageOptions' weaponDamageOptions}}
 <div class="{{cssClass}}">
-  <div class="intro-chat">
-    <div class="intro-img">
-      <img src="{{actingCharImg}}" data-tooltip="{{actingCharName}}" />
-    </div>
-
-    <div class="intro-right">
-      <span><STRONG>{{actingCharName}} - {{upperFirst rollName}}</STRONG></span>
-
-      {{#if (match rollType "attack")}}
-      <span>Attack roll !</span>
-      {{/if}}
-      {{#if (match rollType "defense")}}
-      <span>Defense roll !</span>
-      {{/if}}
-
-      {{#if (eq rollData.favor "favor")}}
-      <span><strong>Favor roll</strong></span>
-      {{/if}}
-      {{#if (eq rollData.favor "disfavor")}}
-      <span><strong>Disfavor roll</strong></span>
-      {{/if}}
-      {{#if badResult}}
-      <span><strong>{{localize "LETHALFANTASY.Label.otherResult"}}</strong> : {{badResult}}</span>
-      {{/if}}
-
-      {{#if rollTarget.weapon}}
-      <span>{{rollTarget.weapon.name}}</span>
-      {{/if}}
-
-      {{#if rollData.letItFly}}
-      <span>Let It Fly attack ! </span>
-      {{/if}}
-      {{#if rollData.pointBlank}}
-      <span>Point Blank Range Attack !</span>
-      {{/if}}
-      {{#if rollData.beyondSkill}}
-      <span>Beyond Skill Range Attack !</span>
-      {{/if}}
-
-      <span><strong>Formula</strong> : {{titleFormula}}</span>
-
-      {{#each diceResults as |result|}}
-      <span>{{result.dice}} : {{result.value}}</span>
-      {{/each}}
-
+  <!-- Header with character info -->
+  <div class="chat-header">
+    <div class="character-info">
+      <div class="character-avatar">
+        <img src="{{actingCharImg}}" data-tooltip="{{actingCharName}}" />
+      </div>
+      <div class="character-details">
+        <div class="character-name">{{actingCharName}}</div>
+        <div class="roll-type-badge">
+          {{#if (match rollType "attack")}}
+            <i class="fa-solid fa-swords"></i>
+          {{/if}}
+          {{#if (match rollType "defense")}}
+            <i class="fa-solid fa-shield"></i>
+          {{/if}}
+          {{#if rollData.isDamage}}
+            <i class="fa-solid fa-burst"></i>
+          {{/if}}
+          {{#if (eq rollType "skill")}}
+            <i class="fa-solid fa-hand-sparkles"></i>
+          {{/if}}
+          {{upperFirst rollName}}
+        </div>
+      </div>
     </div>
   </div>
-  {{#if isSave}}
-  <div class="result">
-    {{#if (eq resultType "success")}}
-    {{#if isPrivate}}?{{else}}{{localize "LETHALFANTASY.Roll.success"}}{{/if}}
-    {{else}}
-    {{#if isPrivate}}?{{else}}{{localize "LETHALFANTASY.Roll.failure"}}{{/if}}
-    {{/if}}
-  </div>
-  {{/if}}
-  {{#if isResource}}
-  <div class="result">
-    {{#if (eq resultType "success")}}
-    {{#if isPrivate}}?{{else}}{{localize "LETHALFANTASY.Roll.success"}}{{/if}}
-    {{else}}
-    {{#if isPrivate}}?{{else}}{{localize "LETHALFANTASY.Roll.failure"}}{{#if isFailure}} ({{localize
-    "LETHALFANTASY.Roll.resourceLost"}}){{/if}}{{/if}}
-    {{/if}}
-  </div>
-  {{/if}}
-  {{#if isDamage}}
-  <div>
-    {{#if (and isGM hasTarget)}}
-    {{{localize "LETHALFANTASY.Roll.displayArmor" targetName=targetName targetArmor=targetArmor realDamage=realDamage}}}
-    {{/if}}
-  </div>
-  {{/if}}
 
+  <!-- Roll details and modifiers -->
+  <div class="roll-details">
+    {{#if rollTarget.weapon}}
+      <div class="detail-item weapon-name">
+        <i class="fa-solid fa-sword"></i>
+        <span>{{rollTarget.weapon.name}}</span>
+      </div>
+    {{/if}}
+
+    {{#if (eq rollData.favor "favor")}}
+      <div class="detail-badge favor-badge">
+        <i class="fa-solid fa-sparkles"></i>
+        <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>{{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>{{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>{{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>{{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}}
+      <div class="detail-badge damage-badge">
+        <i class="fa-solid fa-dice-d20"></i>
+        <span>{{localize "LETHALFANTASY.Label.weapon-damage-medium"}}</span>
+      </div>
+    {{/if}}
+
+    {{#if badResult}}
+      <div class="detail-item other-result">
+        <strong>{{localize "LETHALFANTASY.Label.otherResult"}}</strong>: {{badResult}}
+      </div>
+    {{/if}}
+  </div>
+
+  <!-- Formula and dice results -->
+  <div class="formula-section">
+    <div class="formula-display">
+      <i class="fa-solid fa-dice-d20"></i>
+      <span class="formula-text">{{titleFormula}}</span>
+    </div>
+    {{#if diceResults}}
+      <div class="dice-breakdown">
+        {{#each diceResults as |result|}}
+          <div class="dice-item">
+            <span class="dice-type">{{result.dice}}</span>
+            <span class="dice-separator">→</span>
+            <span class="dice-value">{{result.value}}</span>
+          </div>
+        {{/each}}
+      </div>
+    {{/if}}
+  </div>
+  <!-- Result section -->
   {{#unless isPrivate}}
-  <div class="dice-result">
-    <h4 class="dice-total">{{total}}</h4>
-  </div>
-  {{#if D30result}}
-  <div class="dice-result">
-    <h4 class="dice-total">D30 result: {{D30result}}</h4>
-  </div>
+    <div class="result-section">
+      <div class="main-result">
+        <div class="result-label">{{localize "LETHALFANTASY.Label.total"}}</div>
+        <div class="result-value {{#if (eq resultType 'success')}}success{{else}}failure{{/if}}">
+          {{total}}
+        </div>
+      </div>
+
+      {{#if D30result}}
+        <div class="d30-result">
+          <div class="d30-header">
+            <i class="fa-solid fa-dice-d20"></i>
+            <span class="d30-label">D30 Special</span>
+            <span class="d30-value">{{D30result}}</span>
+          </div>
+          {{#if D30message}}
+            <div class="d30-message">
+              <i class="fa-solid fa-wand-magic-sparkles"></i>
+              <span>{{D30message.description}}</span>
+            </div>
+          {{/if}}
+        </div>
+      {{/if}}
+    </div>
+
+    {{#if isSave}}
+      <div class="outcome-badge {{#if (eq resultType 'success')}}success-outcome{{else}}failure-outcome{{/if}}">
+        {{#if (eq resultType "success")}}
+          <i class="fa-solid fa-circle-check"></i>
+          {{localize "LETHALFANTASY.Roll.success"}}
+        {{else}}
+          <i class="fa-solid fa-circle-xmark"></i>
+          {{localize "LETHALFANTASY.Roll.failure"}}
+        {{/if}}
+      </div>
+    {{/if}}
+
+    {{#if isResource}}
+      <div class="outcome-badge {{#if (eq resultType 'success')}}success-outcome{{else}}failure-outcome{{/if}}">
+        {{#if (eq resultType "success")}}
+          <i class="fa-solid fa-circle-check"></i>
+          {{localize "LETHALFANTASY.Roll.success"}}
+        {{else}}
+          <i class="fa-solid fa-circle-xmark"></i>
+          {{localize "LETHALFANTASY.Roll.failure"}}
+          {{#if isFailure}}
+            <span class="resource-lost">({{localize "LETHALFANTASY.Roll.resourceLost"}})</span>
+          {{/if}}
+        {{/if}}
+      </div>
+    {{/if}}
+
+    {{#if isDamage}}
+      {{#if (and isGM hasTarget)}}
+        <div class="target-info">
+          <i class="fa-solid fa-crosshairs"></i>
+          {{{localize
+            "LETHALFANTASY.Roll.displayArmor"
+            targetName=targetName
+            targetArmor=targetArmor
+            realDamage=realDamage
+          }}}
+        </div>
+      {{/if}}
+    {{/if}}
+  {{else}}
+    <div class="private-result">
+      <i class="fa-solid fa-eye-slash"></i>
+      <span>{{localize "LETHALFANTASY.Label.privateRoll"}}</span>
+    </div>
+  {{/unless}}
+
+  {{#if weaponDamageOptions}}
+    {{#if canSelectTarget}}
+      <div class="damage-buttons">
+        <div class="damage-buttons-grid {{#if weaponDamageOptions.isMonster}}monster-damage{{/if}}">
+          {{#if weaponDamageOptions.isMonster}}
+            <button
+              class="damage-roll-btn"
+              data-weapon-id="{{weaponDamageOptions.weaponId}}"
+              data-damage-type="monster"
+              data-damage-formula="{{weaponDamageOptions.damageFormula}}"
+              data-damage-modifier="{{weaponDamageOptions.damageModifier}}"
+              data-is-monster="true"
+              title="{{localize 'LETHALFANTASY.Label.rollDamage'}} - {{weaponDamageOptions.weaponName}}"
+            >
+              <i class="fa-solid fa-dice"></i>
+              Damage:
+              {{weaponDamageOptions.damageFormula}}{{#if
+                weaponDamageOptions.damageModifier
+              }}+{{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"
+                data-weapon-id="{{weaponDamageOptions.weaponId}}"
+                data-damage-type="medium"
+                data-damage-formula="{{weaponDamageOptions.damageM}}"
+                data-is-monster="false"
+                title="{{localize 'LETHALFANTASY.Label.rollDamage'}}"
+              >
+                <i class="fa-solid fa-dice-d20"></i>
+                Damage Medium
+              </button>
+            {{/if}}
+          {{/if}}
+        </div>
+      </div>
+    {{/if}}
+  {{/if}}
+
+  {{#if rollData.isDamage}}
+    {{#if defenderId}}
+      <div class="damage-result auto-applied">
+        <div class="auto-damage-notice">
+          <i class="fa-solid fa-check-circle"></i>
+          <span>Damage automatically applied to defender (with damage reduction)</span>
+        </div>
+      </div>
+    {{else}}
+      <div class="damage-result">
+        <ul>
+          <li class="li-apply-wounds">
+            <div>{{localize "LETHALFANTASY.Label.applyDamage"}}</div>
+            <div class="combatants-grid">
+              {{#each combatants}}
+                <button
+                  class="apply-wounds-btn"
+                  data-combatant-id="{{this.id}}"
+                  title="{{this.name}}"
+                >
+                  {{this.name}}
+                </button>
+              {{/each}}
+            </div>
+          </li>
+        </ul>
+      </div>
+    {{/if}}
+  {{/if}}
+
+  {{#if isAttack}}
+    {{#if canSelectTarget}}
+      <div class="attack-targets">
+        <ul>
+          <li class="li-select-target">
+            <div>{{localize "LETHALFANTASY.Label.selectTarget"}}</div>
+            <div class="combatants-grid">
+              {{#each combatants}}
+                <button
+                  class="request-defense-btn"
+                  data-combatant-id="{{this.id}}"
+                  data-token-id="{{this.tokenId}}"
+                  title="{{this.name}}"
+                >
+                  {{this.name}}
+                </button>
+              {{/each}}
+            </div>
+          </li>
+        </ul>
+      </div>
+    {{/if}}
   {{/if}}
 
-  {{/unless}}
 </div>

templates/combat-tracker-footer-v2.hbs

@@ -3,7 +3,7 @@
 
     {{!-- GM Controls --}}
     {{#if user.isGM}}
-    {{#if combat.round}}
+    {{#if (or combat.round (eq combat.turn 0))}}
     <!-- <button type="button" class="inline-control combat-control icon fa-solid fa-backward-step"
             data-action="previousRound" data-tooltip aria-label="{{ localize "COMBAT.RoundPrev" }}"></button>
     <button type="button" class="inline-control combat-control icon fa-solid fa-arrow-left" data-action="previousTurn"
@@ -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/combat-tracker-header-v2.hbs

@@ -70,7 +70,7 @@
         {{!-- Combat Status --}}
         <strong class="encounter-title">
             {{#if combats.length}}
-            {{#if combat.round}}
+            {{#if (or combat.round (eq combat.turn 0))}}
             {{ localize "COMBAT.Round" round=combat.round }}
             {{else}}
             {{ localize "COMBAT.NotStarted" }}

templates/damage-applied-message.hbs

@@ -0,0 +1,36 @@
+<div class="fvtt-lethal-fantasy damage-applied-message">
+  <div class="damage-header">
+    <div class="damage-icon">
+      <i class="fa-solid fa-heart-crack"></i>
+    </div>
+    <div class="damage-info">
+      <div class="target-name">{{targetName}}</div>
+      <div class="damage-subtitle">{{localize "LETHALFANTASY.DamageApplied.subtitle"}}</div>
+    </div>
+  </div>
+
+  <div class="damage-details">
+    <div class="damage-amount">
+      <span class="damage-label">{{localize "LETHALFANTASY.DamageApplied.damageDealt"}}</span>
+      <span class="damage-value">{{damage}}</span>
+      {{#if rawDamage}}
+        <span class="damage-raw">({{rawDamage}} raw)</span>
+      {{/if}}
+    </div>
+
+    {{#if drText}}
+      <div class="damage-reduction">
+        <i class="fa-solid fa-shield"></i>
+        <span>{{drText}}</span>
+      </div>
+    {{/if}}
+
+    <div class="damage-source">
+      <i class="fa-solid fa-crosshairs"></i>
+      <span>{{localize "LETHALFANTASY.DamageApplied.from"}}
+        {{#if attackerName}}<strong>{{attackerName}}</strong> with {{/if}}
+        <strong>{{weaponName}}</strong>
+      </span>
+    </div>
+  </div>
+</div>

templates/gain-hp-hud.hbs

@@ -0,0 +1,43 @@
+<div class="control-icon" data-action="lethal-gain-hp-hud">
+  <img
+    class="lethal-hp-gain-hud"
+    src="systems/fvtt-lethal-fantasy/assets/icons/health-increase.svg"
+    width="36"
+    height="36"
+    title="Restore HP"
+  />
+
+  <div class="hp-gain-wrap hp-gain-wrap-col1 hp-gain-hud-disabled">
+    {{#for 1 11 1}}
+      <button
+        class="hud-gain-hp-button-select gain-hp-hud-click"
+        data-hp-value="{{this}}"
+      >
+        <span class="">+{{this}}</span>
+      </button>
+    {{/for}}
+  </div>
+
+  <div class="hp-gain-wrap hp-gain-wrap-col2 hp-gain-hud-disabled">
+    {{#for 11 21 1}}
+      <button
+        class="hud-gain-hp-button-select gain-hp-hud-click"
+        data-hp-value="{{this}}"
+      >
+        <span class="">+{{this}}</span>
+      </button>
+    {{/for}}
+  </div>
+
+  <div class="hp-gain-wrap hp-gain-wrap-col3 hp-gain-hud-disabled">
+    {{#for 21 31 1}}
+      <button
+        class="hud-gain-hp-button-select gain-hp-hud-click"
+        data-hp-value="{{this}}"
+      >
+        <span class="">+{{this}}</span>
+      </button>
+    {{/for}}
+  </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

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

templates/monster-main.hbs

@@ -6,80 +6,175 @@
     <div class="monster-pc monster-pc-{{ifThen isPlayMode 'play' 'edit'}}">
       <div class="monster-left">
         <div class="monster-left-image">
-          <img class="monster-img" src="{{actor.img}}" data-edit="img" data-action="editImage"
-            data-tooltip="{{actor.name}}" />
+          <img
+            class="monster-img"
+            src="{{actor.img}}"
+            data-edit="img"
+            data-action="editImage"
+            data-tooltip="{{actor.name}}"
+          />
         </div>
 
-        <fieldset class="monster-characteristics monster-characteristics-{{ifThen isPlayMode 'play' 'edit'}}">
+        <fieldset
+          class="monster-characteristics monster-characteristics-{{ifThen
+              isPlayMode
+              'play'
+              'edit'
+            }}"
+        >
           <div class="flexrow monster-hp">
             <span class="name">{{localize "LETHALFANTASY.Label.HP"}}</span>
-            {{formInput systemFields.hp.fields.value value=system.hp.value disabled=isPlayMode
-            classes="monster-hp-value"}}
+            {{formInput
+              systemFields.hp.fields.value
+              value=system.hp.value
+              disabled=isPlayMode
+              classes="monster-hp-value"
+            }}
             &nbsp;/&nbsp;
-            {{formInput systemFields.hp.fields.max value=system.hp.max disabled=isPlayMode classes="monster-hp-value"}}
+            {{formInput
+              systemFields.hp.fields.max
+              value=system.hp.max
+              disabled=isPlayMode
+              classes="monster-hp-value"
+            }}
           </div>
           <div class="flexrow monster-hp">
-            <span class="damage-resistance">{{localize "LETHALFANTASY.Label.damageResistance"}}</span>
-            {{formInput systemFields.hp.fields.damageResistance value=system.hp.damageResistance disabled=isPlayMode
-            classes="monster-hp-value"}}
+            <span class="name">{{localize
+                "LETHALFANTASY.Label.damageResistance"
+              }}</span>
+            {{formInput
+              systemFields.hp.fields.damageResistance
+              value=system.hp.damageResistance
+              disabled=isPlayMode
+              classes="monster-hp-value"
+            }}
+            <span class="name">{{localize
+                "LETHALFANTASY.Label.shieldDamageReduction"
+              }}</span>
+            {{formInput
+              systemFields.combat.fields.shieldDamageReduction
+              value=system.combat.shieldDamageReduction
+              disabled=isPlayMode
+              classes="monster-hp-value"
+            }}
+          </div>
+          <div class="flexrow monster-hp">
+            <span class="name"><a
+                class="rollable"
+                data-roll-type="shield-defense"
+                data-roll-dice={{system.combat.shieldDefenseDice}}
+              ><i class="lf-roll-small fa-solid fa-dice-d20"></i>{{localize
+                  "LETHALFANTASY.Label.shieldDefenseDice"
+                }}</a></span>
+            {{formInput
+              systemFields.combat.fields.shieldDefenseDice
+              value=system.combat.shieldDefenseDice
+              disabled=isPlayMode
+              classes="monster-hp-value"
+            }}
           </div>
         </fieldset>
 
       </div>
       <div class="monster-right">
         <div class="monster-name">
-          {{formInput fields.name value=source.name rootId=partId disabled=isPlayMode}}
-          <a class="control" data-action="toggleSheet" data-tooltip="LETHALFANTASY.ToggleSheet"
-            data-tooltip-direction="UP">
+          {{formInput
+            fields.name
+            value=source.name
+            rootId=partId
+            disabled=isPlayMode
+          }}
+          <a
+            class="control"
+            data-action="toggleSheet"
+            data-tooltip="LETHALFANTASY.ToggleSheet"
+            data-tooltip-direction="UP"
+          >
             <i class="fa-solid fa-user-{{ifThen isPlayMode 'lock' 'pen'}}"></i>
           </a>
         </div>
 
-        <fieldset class="monster-characteristics monster-characteristics-{{ifThen isPlayMode 'play' 'edit'}}">
+        <fieldset
+          class="monster-characteristics monster-characteristics-{{ifThen
+              isPlayMode
+              'play'
+              'edit'
+            }}"
+        >
           <legend>{{localize "LETHALFANTASY.Label.Saves"}}</legend>
           <div class="monster-saves">
             <div class="monster-save">
-              <span class="name"><a class="rollable" data-roll-type="save" data-roll-key="will"><i
-                    class="lf-roll-small fa-solid fa-dice-d20"></i>
+              <span class="name"><a
+                  class="rollable"
+                  data-roll-type="save"
+                  data-roll-key="will"
+                ><i class="lf-roll-small fa-solid fa-dice-d20"></i>
                   {{localize "LETHALFANTASY.Label.saves.will"}}
                 </a></span>
-              {{formField systemFields.saves.fields.will.fields.value value=system.saves.will.value disabled=isPlayMode
+              {{formField
+                systemFields.saves.fields.will.fields.value
+                value=system.saves.will.value
+                disabled=isPlayMode
               }}
               <span class="name">
-                <a class="rollable" data-roll-type="save" data-roll-key="dodge"><i
-                    class="lf-roll-small fa-solid fa-dice-d20"></i>
+                <a
+                  class="rollable"
+                  data-roll-type="save"
+                  data-roll-key="dodge"
+                ><i class="lf-roll-small fa-solid fa-dice-d20"></i>
                   {{localize "LETHALFANTASY.Label.saves.dodge"}}
                 </a>
               </span>
-              {{formField systemFields.saves.fields.dodge.fields.value value=system.saves.dodge.value
-              disabled=isPlayMode}}
+              {{formField
+                systemFields.saves.fields.dodge.fields.value
+                value=system.saves.dodge.value
+                disabled=isPlayMode
+              }}
               <span class="name">
-                <a class="rollable" data-roll-type="save" data-roll-key="toughness"><i
-                    class="lf-roll-small fa-solid fa-dice-d20"></i>
+                <a
+                  class="rollable"
+                  data-roll-type="save"
+                  data-roll-key="toughness"
+                ><i class="lf-roll-small fa-solid fa-dice-d20"></i>
                   {{localize "LETHALFANTASY.Label.saves.toughness"}}
                 </a>
               </span>
-              {{formField systemFields.saves.fields.toughness.fields.value value=system.saves.toughness.value
-              disabled=isPlayMode}}
+              {{formField
+                systemFields.saves.fields.toughness.fields.value
+                value=system.saves.toughness.value
+                disabled=isPlayMode
+              }}
             </div>
             <div class="monster-save">
               <span class="name">
-                <a class="rollable" data-roll-type="save" data-roll-key="contagion"><i
-                    class="lf-roll-small fa-solid fa-dice-d20"></i>
+                <a
+                  class="rollable"
+                  data-roll-type="save"
+                  data-roll-key="contagion"
+                ><i class="lf-roll-small fa-solid fa-dice-d20"></i>
                   {{localize "LETHALFANTASY.Label.saves.contagion"}}
                 </a>
               </span>
-              {{formField systemFields.saves.fields.contagion.fields.value value=system.saves.contagion.value
-              disabled=isPlayMode}}
+              {{formField
+                systemFields.saves.fields.contagion.fields.value
+                value=system.saves.contagion.value
+                disabled=isPlayMode
+              }}
 
               <span class="name">
-                <a class="rollable" data-roll-type="save" data-roll-key="poison"><i
-                    class="lf-roll-small fa-solid fa-dice-d20"></i>
+                <a
+                  class="rollable"
+                  data-roll-type="save"
+                  data-roll-key="poison"
+                ><i class="lf-roll-small fa-solid fa-dice-d20"></i>
                   {{localize "LETHALFANTASY.Label.saves.poison"}}
                 </a>
               </span>
-              {{formField systemFields.saves.fields.poison.fields.value value=system.saves.poison.value
-              disabled=isPlayMode }}
+              {{formField
+                systemFields.saves.fields.poison.fields.value
+                value=system.saves.poison.value
+                disabled=isPlayMode
+              }}
 
               <!-- <span class="name">
                 <a class="rollable" data-roll-type="save" data-roll-key="paincourage" data-roll-dice="D20" data-tooltip="Pain/Courage check on wound of..."><i
@@ -98,61 +193,81 @@
           </div>
         </fieldset>
 
-        <fieldset class="monster-characteristics monster-characteristics-{{ifThen isPlayMode 'play' 'edit'}}">
+        <fieldset
+          class="monster-characteristics monster-characteristics-{{ifThen
+              isPlayMode
+              'play'
+              'edit'
+            }}"
+        >
           <legend>{{localize "LETHALFANTASY.Label.skills"}}</legend>
           <div class="monster-skills">
             <div class="monster-skill">
-              <span class="name"><a class="rollable" data-roll-type="monster-skill" data-roll-key="resistTorture"><i
-                    class="lf-roll-small fa-solid fa-dice-d20"></i>{{localize
-                  "LETHALFANTASY.Label.resistTorture"}}</a></span>
-              {{formField systemFields.resists.fields.resistTorture.fields.value
-              value=system.resists.resistTorture.value
-              disabled=isPlayMode
+              <span class="name"><a
+                  class="rollable"
+                  data-roll-type="monster-skill"
+                  data-roll-key="resistTorture"
+                ><i class="lf-roll-small fa-solid fa-dice-d20"></i>{{localize
+                    "LETHALFANTASY.Label.resistTorture"
+                  }}</a></span>
+              {{formField
+                systemFields.resists.fields.resistTorture.fields.value
+                value=system.resists.resistTorture.value
+                disabled=isPlayMode
               }}
-              <span class="name"><a class="rollable" data-roll-type="monster-skill" data-roll-key="resistPerformance"><i
-                    class="lf-roll-small fa-solid fa-dice-d20"></i>{{localize
-                  "LETHALFANTASY.Label.resistPerformance"}}</a></span>
-              {{formField systemFields.resists.fields.resistPerformance.fields.value
-              value=system.resists.resistPerformance.value
-              disabled=isPlayMode
+              <span class="name"><a
+                  class="rollable"
+                  data-roll-type="monster-skill"
+                  data-roll-key="resistPerformance"
+                ><i class="lf-roll-small fa-solid fa-dice-d20"></i>{{localize
+                    "LETHALFANTASY.Label.resistPerformance"
+                  }}</a></span>
+              {{formField
+                systemFields.resists.fields.resistPerformance.fields.value
+                value=system.resists.resistPerformance.value
+                disabled=isPlayMode
+              }}
+              <span class="name"><a
+                  class="rollable"
+                  data-roll-type="monster-skill"
+                  data-roll-key="resistIntimidation"
+                ><i class="lf-roll-small fa-solid fa-dice-d20"></i>{{localize
+                    "LETHALFANTASY.Label.resistIntimidation"
+                  }}</a></span>
+              {{formField
+                systemFields.resists.fields.resistIntimidation.fields.value
+                value=system.resists.resistIntimidation.value
+                disabled=isPlayMode
               }}
-              <span class="name"><a class="rollable" data-roll-type="monster-skill"
-                  data-roll-key="resistIntimidation"><i class="lf-roll-small fa-solid fa-dice-d20"></i>{{localize
-                  "LETHALFANTASY.Label.resistIntimidation"}}</a></span>
-              {{formField systemFields.resists.fields.resistIntimidation.fields.value
-              value=system.resists.resistIntimidation.value
-              disabled=isPlayMode }}
-
-              <span class="name"><a class="rollable" data-roll-type="monster-skill" data-roll-key="perception"><i
-                    class="lf-roll-small fa-solid fa-dice-d20"></i>{{localize
-                  "LETHALFANTASY.Label.perception"}}</a></span>
-              {{formField systemFields.resists.fields.perception.fields.value value=system.resists.perception.value
-              disabled=isPlayMode }}
-
-              <span class="name"><a class="rollable" data-roll-type="monster-skill" data-roll-key="stealth"><i
-                    class="lf-roll-small fa-solid fa-dice-d20"></i>{{localize
-                  "LETHALFANTASY.Label.stealth"}}</a></span>
-              {{formField systemFields.resists.fields.stealth.fields.value value=system.resists.stealth.value
-              disabled=isPlayMode }}
-
             </div>
-          </div>
-        </fieldset>
+            <div class="monster-skill">
+              <span class="name"><a
+                  class="rollable"
+                  data-roll-type="monster-skill"
+                  data-roll-key="perception"
+                ><i class="lf-roll-small fa-solid fa-dice-d20"></i>{{localize
+                    "LETHALFANTASY.Label.perception"
+                  }}</a></span>
+              {{formField
+                systemFields.resists.fields.perception.fields.value
+                value=system.resists.perception.value
+                disabled=isPlayMode
+              }}
 
-
-        <fieldset class="monster-characteristics monster-characteristics-{{ifThen isPlayMode 'play' 'edit'}}">
-          <legend>{{localize "LETHALFANTASY.Label.Movement"}}</legend>
-          <div class="monster-movements">
-            <div class="monster-movement">
-              <span class="name">{{localize "LETHALFANTASY.Label.movement.walk"}}</span>
-              {{formField systemFields.movement.fields.walk value=system.movement.walk disabled=isPlayMode}}
-              <span class="name">{{localize "LETHALFANTASY.Label.movement.jog"}}</span>
-              {{formField systemFields.movement.fields.jog value=system.challenges.movement.jog disabled=isPlayMode}}
-              <span class="name">{{localize "LETHALFANTASY.Label.movement.run"}}</span>
-              {{formField systemFields.movement.fields.run value=system.movement.run disabled=isPlayMode}}
-              <span class="name">{{localize "LETHALFANTASY.Label.movement.sprint"}}</span>
-              {{formField systemFields.movement.fields.sprint value=system.movement.sprint disabled=isPlayMode}}
+              <span class="name"><a
+                  class="rollable"
+                  data-roll-type="monster-skill"
+                  data-roll-key="stealth"
+                ><i class="lf-roll-small fa-solid fa-dice-d20"></i>{{localize
+                    "LETHALFANTASY.Label.stealth"
+                  }}</a></span>
+              {{formField
+                systemFields.resists.fields.stealth.fields.value
+                value=system.resists.stealth.value
+                disabled=isPlayMode
+              }}
             </div>
+
           </div>
         </fieldset>
 
@@ -160,23 +275,77 @@
     </div>
   </fieldset>
 
-  <fieldset class="monster-characteristics monster-characteristics-{{ifThen isPlayMode 'play' 'edit'}}">
+  <fieldset
+    class="monster-characteristics monster-characteristics-{{ifThen
+        isPlayMode
+        'play'
+        'edit'
+      }}"
+  >
     <legend>{{localize "LETHALFANTASY.Label.characteristics"}}</legend>
     <div class="monster-characteristic">
       <span>{{localize "LETHALFANTASY.Label.int"}}</span>
-      {{formField systemFields.characteristics.fields.int.fields.value value=system.characteristics.int.value
-      disabled=isPlayMode data-char-id="int" }}
-
-      {{formField systemFields.characteristics.fields.int.fields.percent value=system.characteristics.int.percent
-      disabled=isPlayMode type="number" }}
+      {{formField
+        systemFields.characteristics.fields.int.fields.value
+        value=system.characteristics.int.value
+        disabled=isPlayMode
+        data-char-id="int"
+      }}
     </div>
     <div class="monster-characteristic">
       <span>{{localize "LETHALFANTASY.Label.dex"}}</span>
-      {{formField systemFields.characteristics.fields.dex.fields.value value=system.characteristics.dex.value
-      disabled=isPlayMode data-char-id="wis" }}
+      {{formField
+        systemFields.characteristics.fields.dex.fields.value
+        value=system.characteristics.dex.value
+        disabled=isPlayMode
+        data-char-id="wis"
+      }}
+    </div>
 
-      {{formField systemFields.characteristics.fields.dex.fields.percent value=system.characteristics.dex.percent
-      disabled=isPlayMode type="number" }}
+    <legend>{{localize "LETHALFANTASY.Label.Movement"}}</legend>
+    <div class="monster-movements">
+      <div class="monster-movement">
+        <div class="flexrow monster-hp">
+          <span class="name">{{localize
+              "LETHALFANTASY.Label.movement.walk"
+            }}</span>
+          {{formField
+            systemFields.movement.fields.walk
+            value=system.movement.walk
+            disabled=isPlayMode
+          }}
+        </div>
+        <div class="flexrow monster-hp">
+          <span class="name">{{localize
+              "LETHALFANTASY.Label.movement.jog"
+            }}</span>
+          {{formField
+            systemFields.movement.fields.jog
+            value=system.movement.jog
+            disabled=isPlayMode
+          }}
+        </div>
+        <div class="flexrow monster-hp">
+          <span class="name">{{localize
+              "LETHALFANTASY.Label.movement.run"
+            }}</span>
+          {{formField
+            systemFields.movement.fields.run
+            value=system.movement.run
+            disabled=isPlayMode
+          }}
+        </div>
+        <div class="flexrow monster-hp">
+          <span class="name">{{localize
+              "LETHALFANTASY.Label.movement.sprint"
+            }}</span>
+          {{formField
+            systemFields.movement.fields.sprint
+            value=system.movement.sprint
+            disabled=isPlayMode
+          }}
+        </div>
+      </div>
     </div>
   </fieldset>
 

templates/progression-message.hbs

@@ -0,0 +1,44 @@
+<div class="fvtt-lethal-fantasy progression-message {{#if success}}progression-success{{else}}progression-failure{{/if}}">
+  <div class="progression-header">
+    <div class="progression-icon">
+      {{#if success}}
+        <i class="fa-solid fa-check-circle"></i>
+      {{else}}
+        <i class="fa-solid fa-hourglass-half"></i>
+      {{/if}}
+    </div>
+    <div class="progression-info">
+      <div class="actor-name">{{actorName}}</div>
+      <div class="progression-subtitle">
+        {{#if success}}
+          {{localize "LETHALFANTASY.ProgressionMessage.canAct"}}
+        {{else}}
+          {{localize "LETHALFANTASY.ProgressionMessage.cannotAct"}}
+        {{/if}}
+      </div>
+    </div>
+  </div>
+
+  <div class="progression-details">
+    {{#if weaponName}}
+      <div class="progression-weapon">
+        <i class="fa-solid fa-sword"></i>
+        <span><strong>{{weaponName}}</strong></span>
+      </div>
+    {{/if}}
+
+    {{#if rollResult}}
+      <div class="progression-roll">
+        <span class="roll-label">{{localize "LETHALFANTASY.ProgressionMessage.diceResult"}}</span>
+        <span class="roll-value">{{rollResult}}</span>
+      </div>
+    {{/if}}
+
+    {{#if progressionCount}}
+      <div class="progression-count">
+        <i class="fa-solid fa-dice-d20"></i>
+        <span>{{localize "LETHALFANTASY.ProgressionMessage.progressionCount"}} <strong>{{progressionCount}}</strong></span>
+      </div>
+    {{/if}}
+  </div>
+</div>

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

@@ -1,111 +1,150 @@
 <div class="lethalfantasy-roll-dialog">
 
   <fieldSet class="">
-    <legend>{{localize (concat "LETHALFANTASY.Label." rollType)}} - {{actorName}}</legend>
+    <legend>{{localize (concat "LETHALFANTASY.Label." rollType)}}
+      -
+      {{actorName}}</legend>
 
     {{#if rollTarget.tokenId}}
-    <div class="dialog-save">
-      <a class="goto-token-button" data-action="gotoToken" data-token-id="{{rollTarget.tokenId}}">{{localize
-        "LETHALFANTASY.Label.gotoToken"}} </a>
-    </div>
+      <div class="dialog-save">
+        <a
+          class="goto-token-button"
+          data-action="gotoToken"
+          data-token-id="{{rollTarget.tokenId}}"
+        >{{localize "LETHALFANTASY.Label.gotoToken"}} </a>
+      </div>
     {{/if}}
 
     {{#if (match rollType "attack")}}
-    <div class="dialog-save">Attack roll ! - {{rollTarget.name}}</div>
+      <div class="dialog-save">Attack roll ! - {{rollTarget.name}}</div>
     {{/if}}
     {{#if (match rollType "defense")}}
-    <div class="dialog-save">Defense roll ! - {{rollTarget.name}}</div>
+      <div class="dialog-save">Defense roll ! - {{rollTarget.name}}</div>
     {{/if}}
 
     {{#if hasModifier}}
-    <div class="dialog-save">{{upperFirst rollName}} : {{baseFormula}} + {{baseValue}}</div>
+      <div class="dialog-save">{{upperFirst rollName}}
+        :
+        {{baseFormula}}
+        +
+        {{baseValue}}</div>
     {{else}}
-    <div class="dialog-save">{{upperFirst rollName}} : {{baseFormula}}</div>
+      <div class="dialog-save">{{upperFirst rollName}} : {{baseFormula}}</div>
     {{/if}}
+
     {{#if rollTarget.weapon}}
-    <div class="dialog-save">{{localize "LETHALFANTASY.Label.baseModifier"}} : {{rollTarget.charModifier}}</div>
-    <div class="dialog-save">{{localize "LETHALFANTASY.Label.weapon"}} : {{rollTarget.weapon.name}}</div>
-    <div class="dialog-save">{{localize "LETHALFANTASY.Label.skill"}} : {{rollTarget.name}}</div>
-    <div class="dialog-save">{{localize "LETHALFANTASY.Label.skillBonus"}} : {{rollTarget.weaponSkillModifier}}</div>
+      <div class="dialog-save">{{localize "LETHALFANTASY.Label.baseModifier"}}
+        :
+        {{rollTarget.charModifier}}</div>
+      {{#if (match rollType "defense")}}
+        <div class="dialog-save">Armor defense modifier :
+          {{rollTarget.armorDefense}}</div>
+      {{/if}}
+      <div class="dialog-save">{{localize "LETHALFANTASY.Label.weapon"}}
+        :
+        {{rollTarget.weapon.name}}</div>
+      <div class="dialog-save">{{localize "LETHALFANTASY.Label.skill"}}
+        :
+        {{rollTarget.name}}</div>
+      <div class="dialog-save">{{localize "LETHALFANTASY.Label.skillBonus"}}
+        :
+        {{rollTarget.weaponSkillModifier}}</div>
     {{/if}}
 
     {{#if (match rollType "attack")}}
-    <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}}
+      <div class="dialog-save">Add Granted Attack Dice
+        <input type="checkbox" data-action="selectGranted" name="granted" />
+      </div>
+      {{#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}}
     {{#if (match rollType "defense")}}
-    <div class="dialog-save">Add Granted Defense Dice
-      <input type="checkbox" data-action="selectGranted" name="granted">
-    </div>
+      <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
-      <input type="checkbox" data-action="selectGranted" name="granted">
-    </div>
+      <div class="dialog-save">Add Granted Damage Dice
+        <input type="checkbox" data-action="selectGranted" name="granted" />
+      </div>
     {{/if}}
 
     {{#if rollTarget.staticModifier}}
-    <div class="dialog-save">Static modifier : +{{rollTarget.staticModifier}}</div>
+      <div class="dialog-save">Static modifier : +{{rollTarget.staticModifier}}</div>
     {{/if}}
 
   </fieldSet>
 
-
   {{#if hasFavor}}
-  <fieldSet class="dialog-favor">
-    <legend>{{localize "LETHALFANTASY.Roll.favorDisfavor"}}</legend>
-    <select name="favor" class="favor-choice" data-tooltip-direction="UP">
-      {{selectOptions choiceFavor selected=favor}}
-    </select>
-  </fieldSet>
+    <fieldSet class="dialog-favor">
+      <legend>{{localize "LETHALFANTASY.Roll.favorDisfavor"}}</legend>
+      <select name="favor" class="favor-choice" data-tooltip-direction="UP">
+        {{selectOptions choiceFavor selected=favor}}
+      </select>
+    </fieldSet>
   {{/if}}
 
   {{#if hasModifier}}
-  <fieldSet class="dialog-modifier">
-    <legend>{{localize "LETHALFANTASY.Roll.modifierBonusMalus"}}</legend>
-    <select name="modifier" data-tooltip-direction="UP">
-      {{selectOptions choiceModifier selected=modifier}}
-    </select>
+    <fieldSet class="dialog-modifier">
+      <legend>{{localize "LETHALFANTASY.Roll.modifierBonusMalus"}}</legend>
+      <select name="modifier" data-tooltip-direction="UP">
+        {{selectOptions choiceModifier selected=modifier}}
+      </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}}
-    {{/if}}
-  </fieldSet>
+      {{#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}}
+      {{/if}}
+    </fieldSet>
   {{/if}}
 
   {{#if hasChangeDice}}
-  <fieldSet class="dialog-modifier">
-    <legend>{{localize "LETHALFANTASY.Roll.changeDice"}}</legend>
-    <select name="changeDice" data-tooltip-direction="UP">
-      {{selectOptions choiceDice selected=changeDice}}
-    </select>
-  </fieldSet>
+    <fieldSet class="dialog-modifier">
+      <legend>{{localize "LETHALFANTASY.Roll.changeDice"}}</legend>
+      <select name="changeDice" data-tooltip-direction="UP">
+        {{selectOptions choiceDice selected=changeDice}}
+      </select>
+    </fieldSet>
   {{/if}}
 
   <fieldSet>
@@ -115,5 +154,4 @@
     </select>
   </fieldSet>
 
-
 </div>

templates/shield.hbs

@@ -1,6 +1,12 @@
 <section>
   <div class="header">
-    <img class="item-img" src="{{item.img}}" data-edit="img" data-action="editImage" data-tooltip="{{item.name}}" />
+    <img
+      class="item-img"
+      src="{{item.img}}"
+      data-edit="img"
+      data-action="editImage"
+      data-tooltip="{{item.name}}"
+    />
     {{formInput fields.name value=source.name}}
   </div>
 
@@ -8,23 +14,32 @@
     <div class="align-top">
       {{formField systemFields.defense value=system.defense}}
 
+      {{formField systemFields.damageReduction value=system.damageReduction}}
+
       <div class="shift-right">&nbsp;
       </div>
 
       {{formField systemFields.hascover value=system.hascover}}
 
       {{#if system.hascover}}
-      <label>Cover vs ranged attacks</label>
-      <div class="shift-right">
-        <label>Standing </label>
-        <div class="flexrow">{{formField systemFields.standing.fields.min value=system.standing.min}} &nbsp;...&nbsp;30
+        <label>{{localize "LETHALFANTASY.Label.coverRanged"}}</label>
+        <div class="shift-right">
+          <label>{{localize "LETHALFANTASY.Label.standing"}}</label>
+          <div class="flexrow">{{formField
+              systemFields.standing.fields.min
+              value=system.standing.min
+            }}
+            &nbsp;...&nbsp;30
+          </div>
+        </div>
+        <div class="shift-right">
+          <label>{{localize "LETHALFANTASY.Label.crouching"}}</label>
+          <div class="flexrow">{{formField
+              systemFields.crouching.fields.min
+              value=system.crouching.min
+            }}
+            &nbsp;...&nbsp;30</div>
         </div>
-      </div>
-      <div class="shift-right">
-        <label>Crouching</label>
-        <div class="flexrow">{{formField systemFields.crouching.fields.min value=system.crouching.min}}
-          &nbsp;...&nbsp;30</div>
-      </div>
       {{/if}}
     </div>
 
@@ -53,15 +68,14 @@
     </div>
   </div>
 
-
   <fieldset>
     <legend>{{localize "LETHALFANTASY.Label.description"}}</legend>
     {{formInput
-    systemFields.description
-    enriched=enrichedDescription
-    value=system.description
-    name="system.description"
-    toggled="false"
+      systemFields.description
+      enriched=enrichedDescription
+      value=system.description
+      name="system.description"
+      toggled="false"
     }}
   </fieldset>
 </section>

templates/spell.hbs

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

templates/weapon.hbs

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