fix: cache results.length before explosion loop to prevent double-count

Pushing explosion dice to DieTerm.results made the for loop condition (j < results.length) grow mid-iteration, re-processing the explosion result as a normal die. This produced spurious entries like `1D6 → 4` alongside the correct `1D6-1 → 3`. Fixes prompt() (for loop) and rollSpellDamageToMessage() (for...of) by caching result count / snapshotting the array before iterating.
fix: push explosion dice to DieTerm results so DSN displays them
2026-06-16 19:34:13 +02:00 · 2026-06-16 19:29:07 +02:00 · 2026-06-14 23:00:39 +02:00 · 2026-06-14 22:57:41 +02:00 · 2026-06-13 23:15:22 +02:00 · 2026-06-13 21:06:18 +02:00
90 changed files with 9506 additions and 973 deletions
@@ -0,0 +1 @@
+packs/** filter=lfs diff=lfs merge=lfs -text
@@ -57,7 +57,7 @@ jobs:
          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"
+          manifest: "https://www.uberwald.me/gitea/uberwald/fvtt-lethal-fantasy/releases/download/latest/system.json"
          notes: "https://www.uberwald.me/gitea/public/fvtt-lethal-fantasy/raw/branch/main/changelog.md"
-          compatibility-minimum: "13"
-          compatibility-verified: "13"
+          compatibility-minimum: "14"
+          compatibility-verified: "14"
@@ -7,4 +7,16 @@ styles/*.css
 node_modules/

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

@@ -0,0 +1,6 @@
+{
+  "cSpell.words": [
+    "biodata",
+    "LETHALFANTASY"
+  ]
+}
@@ -0,0 +1,105 @@
+# Lethal Fantasy FoundryVTT System — Session Context
+
+## Current Goal
+Fix Grit/Luck defense reaction dialog UX (stacking dialogs, multiple clicks, revert on close) and cross-client sync of defense bonuses.
+
+## Accomplished
+
+### Pass 1 — Critical Issues
+- **Telemetry removed**: `ClassCounter`, `registerWorldCount`, orphaned `worldKey` setting deleted from system.json
+- **globalThis side effects**: `globalThis.SYSTEM`, `globalThis.pendingDefenses` moved from top-level to `init` hook
+- **console.log → log()**: All runtime console.log replaced with `log()` helper guarded by `lethalFantasy.debug` setting
+- **Stale Tenebris refs**: `macros.mjs` — `TENEBRIS.Label.jet` → `LETHALFANTASY.Label.jet`, `TENEBRIS.Manager.*` → `LETHALFANTASY.Label.*`, `tenebris.macro` flag → `lethalFantasy.macro`
+
+### Pass 2 — V1/V2 Mixing, Fire-and-Forget
+- **V1 sheet registrations removed**: `foundry.appv1.sheets.*` in system.json
+- **V1 `activateListeners`/jQuery**: removed dead `defaultOptions`, V1 tab code from `combat.mjs`
+- **V2 API paths**: `FilePicker` → V2, `TextEditor.getDragEventData` → V2, `item.sheet.render(true)` → `render({force:true})`, `super._onRender()` → `super._onRender(context, options)`, `token._id` → `token.id`
+- **Fire-and-forget Promises**: All `actor.update()`, `ChatMessage.create()`, `prepareRoll()`, `prepareMonsterRoll()`, socket handler calls now awaited
+- **Misnamed class**: `LethalFantasySkill` → `LethalFantasyWeapon`; added missing `WEAPON_TYPE` import; fixed `weaponCategory`
+
+### Pass 3 — Code Review Fixes
+- **Duplicated dialogs**: Per-element `.rollable`/`.wound-data` bindings moved to `_onRender` (V2 destroys/recreates DOM each render); `_activateListeners` reverted
+- **renderChatMessage reverted**: V2 hook `renderChatMessage` passes jQuery html, `querySelectorAll` fails; kept `renderChatMessageHTML`
+- **Roll actions broken**: Fixed `async` base-actor-sheet methods; `_onRender` bindings for rollable elements restored
+- **Token HUD guard**: `html.querySelector()` → `html.find().length` (html is jQuery object)
+- **All review awaits confirmed**: `showDefenseRequest`/`socket` handlers all awaited
+
+## Defense Dialog Investigation — Status
+
+### Symptom (user process)
+1. Monster (GM) attacks player — hits
+2. Player uses Grit/Luck to boost defense
+3. Defense now beats attack — reports new result
+4. Dialog **stays open** — Grit/Luck/bonus dice options still visible
+5. Closing dialog (Continue or X) causes "rolls vanish" — reverts to original result
+
+### Root Cause Found — Duplicate cross-client processing (FIXED)
+
+When monster (GM) attacks player, the `createChatMessage` hook fires on **both** clients:
+
+```
+Player's client:                         GM's client:
+  defense msg created                      defense msg synced
+  ↓                                        ↓
+  hook fires (line 557)                    hook fires (line 557)
+  isPrimaryController(defender)=true       isPrimaryController(defender)=false
+  ↓                                        ↓
+  Defense dialog A shows                   Defense dialog skipped
+  Player spends Grit                       Cross-client code (line 1009):
+  defenseRoll=10→16                        isPrimaryController(attacker)=true
+  While loop exits                         defenderOwner=player (≠GM)
+  Comparison: "miss"                       ↓
+                                           **Sends attackBoosted with ORIGINAL
+                                            defenseRoll=10 (stale!)**
+                                           ↓
+                                           Player receives socket → handleAttackBoosted
+                                           → Defense dialog B shows with OLD values
+                                           → When closed, comparison: "hit" (overwrites!)
+```
+
+Player sees **two** dialogs (A then B). Dialog B uses unboosted values, so closing/ignoring it produces a stale "hit" result that overwrites the correct "miss."
+
+### Fix
+`lethal-fantasy.mjs:1016` — only send `attackBoosted` socket when `attackerHandledBonus || attackerHasNonGMOwner`. Guards against stale-socket overwrite for GM→player combat (where hook-based processing works without socket), while preserving socket delegation for PC→PC cross-client (where `attackerIsCrossClient` suppresses the hook-based processing on the defender's client).
+
+Before:
+```js
+if (defenderOwner && defenderOwner.id !== game.user.id) {
+  game.socket.emit(`system.${SYSTEM.id}`, { type: "attackBoosted", ... })
+  return
+}
+```
+
+After:
+```js
+if (defenderOwner && defenderOwner.id !== game.user.id) {
+  if (attackerHandledBonus || attackerHasNonGMOwner) {
+    game.socket.emit(`system.${SYSTEM.id}`, { type: "attackBoosted", ... })
+  }
+  return
+}
+```
+
+### Same-Client Path
+Code pattern is identical between attack and defense dialogs — both use `await DialogV2.wait({rejectClose:false})` in a while loop. Same-client defense works correctly because no duplicate socket messages arrive.
+
+### Other Findings
+- `offerGritLuckBonus` (`utils.mjs:1121`) is dead code — never called
+- `promptCombatBonusDie` (`utils.mjs:975`) is correct — DialogV2 resolves to callback return value, not `action`
+- Cross-client `handleAttackBoosted` (`utils.mjs:291`) still uses `else if` chain without `continue` — functionally correct but differs from same-client pattern
+
+### Code Paths
+| Flow | File | Line |
+|------|------|------|
+| Same-client attack | `lethal-fantasy.mjs` | 918-1004 |
+| Same-client defense | `lethal-fantasy.mjs` | 697-870 |
+| Cross-client defense | `module/utils.mjs` | 291-445 |
+| Cross-client socket guard | `lethal-fantasy.mjs` | 1006-1037 |
+| Attack Grit offer | `module/utils.mjs` | 1210-1290 |
+
+### Key Files
+- `lethal-fantasy.mjs` — Main system hooks, same-client attack/defense reactions
+- `module/utils.mjs` — Cross-client defense flow, bonus dialogs, compareAttackDefense
+- `module/documents/actor.mjs` — `prepareRoll()` entry point
+- `module/documents/roll.mjs` — Roll resolution pipeline
@@ -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>
@@ -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>
@@ -1,8 +1,32 @@
 {
  "COMBAT": {
+    "Begin": "Begin Combat",
+    "Create": "Create Encounter",
+    "Delete": "Delete Encounter",
+    "Encounter": "Encounter",
+    "EncounterNext": "Next Encounter",
+    "EncounterPrevious": "Previous Encounter",
+    "End": "End Combat",
+    "InitiativeReset": "Reset Initiative",
+    "InitiativeRoll": "Roll Initiative",
+    "InitiativeScore": "Initiative Score",
+    "NavLabel": "Combat Tracker Navigation",
+    "None": "None",
+    "NotStarted": "Not Started",
+    "PanToCombatant": "Pan to Combatant",
+    "PingCombatant": "Ping Combatant",
+    "RollAll": "Roll All",
+    "RollNPC": "Roll NPCs",
    "Round": "Second {round}",
+    "RoundNext": "Next second",
+    "RoundPrev": "Previous second",
    "Rounds": "Seconds",
-    "RoundNext":    "Next second"
+    "Settings": "Combat Settings",
+    "ToggleDead": "Toggle Dead",
+    "ToggleVis": "Toggle Visible",
+    "TurnEnd": "End Turn",
+    "TurnNext": "Next Turn",
+    "TurnPrev": "Previous Turn"
  },
  "LETHALFANTASY": {
    "Armor": {
@@ -152,6 +176,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 +325,21 @@
        "wis": {
          "label": "Wisdom"
        }
+      },
+      "perception": {
+        "label": "Perception"
+      },
+      "resistIntimidation": {
+        "label": "Resist Intimidation"
+      },
+      "resistPerformance": {
+        "label": "Resist Performance"
+      },
+      "resistTorture": {
+        "label": "Resist Torture"
+      },
+      "stealth": {
+        "label": "Stealth"
      }
    },
    "Delete": "Delete",
@@ -283,6 +373,7 @@
    "Label": {
      "agility": "Dexterity",
      "applyDamage": "Apply damage to:",
+      "selectTarget": "Select target for attack:",
      "rollDamage": "Roll Damage",
      "gotoToken": "Go to token",
      "combatAction": "Combat action",
@@ -315,9 +406,12 @@
      "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",
@@ -392,8 +486,17 @@
      "notes": "Notes",
      "pc": "PC",
      "perception": "Perception",
+      "pointBlank": "Point blank",
+      "short": "Short",
+      "medium": "Medium",
+      "long": "Long",
+      "extreme": "Extreme",
+      "outOfSkill": "Out of skill",
+      "range": "Range",
      "rangeDefenseDialog": "Ranged defense dialog",
      "rangeDefenseRoll": "Ranged defense roll",
+      "rangeAttackDialog": "Ranged attack dialog",
+      "rangeAttackRoll": "Ranged attack roll",
      "rangedAttackDefense": "Ranged attack defense",
      "resource": "Resource",
      "resources": "Resources",
@@ -426,8 +529,42 @@
      "monster-defense": "Monster defense",
      "weapons": "Weapons",
      "wis": "WIS",
-      "weapon-damage-medium": "Weapon damage medium",
-      "weapon-damage-small": "Weapon damage small"
+      "combatProgressionStart": "Combat start threshold",
+      "miracle": "Miracle",
+      "titleStandard": "Standard Roll",
+      "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": {
@@ -483,6 +620,15 @@
        },
        "savingThrow": {
          "label": "Saving throw"
+        },
+        "damageDiceOverpowered": {
+          "label": "Overpowered Damage Dice"
+        },
+        "damageDiceOverpowered2": {
+          "label": "Overpowered 2 Damage Dice"
+        },
+        "damageDice": {
+          "label": "Damage Dice"
        }
      }
    },
@@ -502,7 +648,9 @@
      "messageLethargyKO": "{spellName} : Lethargy still ongoing ... ( dice result : {roll} )",
      "messageProgressionKO": "{name} can't attack this second.",
      "messageProgressionOKMonster": "{name} can attack this second with {weapon}.",
-      "messageProgressionKOMonster": "{name} can't attack this second (dice result {roll})."
+      "messageProgressionKOMonster": "{name} can't attack this second (dice result {roll}).",
+      "bleedingCombatEnd": "Bleeding active out of combat: {names}",
+      "bleedingCombatStart": "Bleeding still active on: {names}"
    },
    "Opponent": {
      "FIELDS": {}
@@ -517,7 +665,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": {
@@ -602,7 +752,8 @@
            "label": "Min"
          }
        }
-      }
+      },
+      "autoDestruction": "Auto-Destruction"
    },
    "Skill": {
      "Category": {
@@ -659,6 +810,9 @@
        "weaponClass": {
          "label": "Class"
        }
+      },
+      "error": {
+        "weaponBonus": "Weapon bonus exceeds the allowed maximum (skill total / 10)"
      }
    },
    "Spell": {
@@ -698,6 +852,12 @@
        "cost": {
          "label": "Cost"
        },
+        "costOverpowered": {
+          "label": "Cost (Overpowered)"
+        },
+        "costOverpowered2": {
+          "label": "Cost (Overpowered 2)"
+        },
        "description": {
          "label": "Description"
        },
@@ -721,14 +881,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": {
@@ -743,7 +924,9 @@
        }
      }
    },
-    "Warning": {},
+    "Warning": {
+      "defenseShieldOrder": "To avoid a hit without using the shield, roll Grit or Luck first — then roll the shield."
+    },
    "Weapon": {
      "FIELDS": {
        "isAgile": {
@@ -876,6 +1059,48 @@
      "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": {
@@ -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"

@@ -18,62 +18,44 @@ export class LethalFantasyCombatTracker extends foundry.applications.sidebar.tab
    actions: {
      initiativePlus: LethalFantasyCombatTracker.#initiativePlus,
      initiativeMinus: LethalFantasyCombatTracker.#initiativeMinus,
+      rollMonsterProgression: LethalFantasyCombatTracker.#rollMonsterProgression,
    },
  });

  async _prepareContext(options) {
    let data = await super._prepareContext(options);
-    console?.log("Combat Tracker Data", data);
+    log("Combat Tracker Data", data);
    /*for (let u of data.turns) {
      let c = game.combat.combatants.get(u.id);
      u.progressionCount = c.system.progressionCount
      u.isMonster = c.actor.type === "monster"
    }
-    console.log("Combat Data", data);*/
+    log("Combat Data", data);*/
    return data;
  }

-  static #initiativePlus(ev) {
+  static async #initiativePlus(ev) {
    ev.preventDefault();
    let cId = ev.target.closest(".combatant").dataset.combatantId;
    let c = game.combat.combatants.get(cId);
-    c.update({ 'initiative': c.initiative + 1 });
-    console.log("Initiative Plus");
+    await c.update({ 'initiative': c.initiative + 1 });
  }

-  static #initiativeMinus(ev) {
+  static async #initiativeMinus(ev) {
    ev.preventDefault();
    let cId = ev.target.closest(".combatant").dataset.combatantId;
    let c = game.combat.combatants.get(cId);
    let newInit = Math.max(c.initiative - 1, 0);
-    c.update({ 'initiative': newInit });
+    await c.update({ 'initiative': newInit });
  }

-  activateListeners(html) {
-    super.activateListeners(html);
-    // Display Combat settings
-    html.find(".initiative-plus").click(ev => {
+  /**
+   * Roll progression dice for all monster combatants that are eligible this round.
+   * @param {Event} ev Click event.
+   */
+  static async #rollMonsterProgression(ev) {
    ev.preventDefault();
-      let cId = ev.currentTarget.closest(".combatant").dataset.combatantId;
-      let c = game.combat.combatants.get(cId);
-      c.update({ 'initiative': c.initiative + 1 });
-    });
-
-    html.find(".initiative-minus").click(ev => {
-      ev.preventDefault();
-      let cId = ev.currentTarget.closest(".combatant").dataset.combatantId;
-      let c = game.combat.combatants.get(cId);
-      c.update({ 'initiative': c.initiative - 1 });
-      console.log("Initiative Minus");
-    });
-  }
-
-  /* -------------------------------------------- */
-  static get defaultOptions() {
-    let path = "systems/fvtt-lethal-fantasy/templates/combat-tracker.hbs";
-    return foundry.utils.mergeObject(super.defaultOptions, {
-      template: path,
-    });
+    await game.combat.rollMonsterProgression();
  }
 }

@@ -84,7 +66,7 @@ export class LethalFantasyCombat extends Combat {
 * @returns {Combatant[]}
 */
  setupTurns() {
-    console?.log("Setup Turns....");
+    log("Setup Turns....");
    this.turns ||= [];

    // Determine the turn order and the current turn
@@ -100,42 +82,73 @@ 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;
  }

-  resetProgression(cId) {
-    let c = this.combatants.get(cId);
-    c.update({ 'system.progressionCount': 0 });
+  /** Roll progression dice for all eligible monster combatants this round. Called manually by the GM. */
+  async rollMonsterProgression() {
+    const currentRound = this.round;
+    const monsters = this.combatants.filter(c => c.actor?.type === "monster" && !c.isDefeated);
+
+    if (monsters.length === 0) {
+      ui.notifications.warn("No monsters in combat.");
+      return;
    }

-  setCasting(cId) {
-    let c = this.combatants.get(cId);
-    c.setFlag(SYSTEM.id, "casting", true);
+    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++;
+      }
    }

-  resetCasting(cId) {
+    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;
+    }
+  }
+
+  async resetProgression(cId) {
    let c = this.combatants.get(cId);
-    c.setFlag(SYSTEM.id, "casting", false);
+    await c.update({ 'system.progressionCount': 0 });
+  }
+
+  async setCasting(cId) {
+    let c = this.combatants.get(cId);
+    await c.setFlag(SYSTEM.id, "casting", true);
+  }
+
+  async resetCasting(cId) {
+    let c = this.combatants.get(cId);
+    await c.setFlag(SYSTEM.id, "casting", false);
  }

  isCasting(cId) {
@@ -144,15 +157,12 @@ export class LethalFantasyCombat extends Combat {
  }

  async nextTurn() {
-    console.log("NEXT TURN");
-
    let turn = this.turn ?? -1;
    let skipDefeated = this.settings.skipDefeated;

    // Determine the next turn number
    let next = null;
    for (let [i, t] of this.turns.entries()) {
-      console.log("Turn", t);
      if (i <= turn) continue;
      if (skipDefeated && t.isDefeated) continue;
      next = i;
@@ -176,7 +186,6 @@ export class LethalFantasyCombat extends Combat {
    this.turnsDone = false

    let turn = this.turn === null ? null : 0; // Preserve the fact that it's no-one's turn currently.
-    console.log("ROUND", this);

    let advanceTime = Math.max(this.turns.length - this.turn, 0) * CONFIG.time.turnTime;
    advanceTime += CONFIG.time.roundTime;
@@ -194,14 +203,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);
        }
      }
    }
@@ -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)
+}
@@ -78,7 +78,6 @@ export default class LethalFantasyActorSheet extends HandlebarsApplicationMixin(
  /** @override */
  _onRender(context, options) {
    this.#dragDrop.forEach((d) => d.bind(this.element))
-    // Add listeners to rollable elements
    const rollables = this.element.querySelectorAll(".rollable")
    rollables.forEach((d) => d.addEventListener("click", this._onRoll.bind(this)))
  }
@@ -234,12 +233,12 @@ export default class LethalFantasyActorSheet extends HandlebarsApplicationMixin(
    const attr = target.dataset.edit
    const current = foundry.utils.getProperty(this.document, attr)
    const { img } = this.document.constructor.getDefaultArtwork?.(this.document.toObject()) ?? {}
-    const fp = new FilePicker({
+    const fp = new foundry.applications.ux.FilePicker.implementation({
      current,
      type: "image",
      redirectToRoot: img ? [img] : [],
-      callback: (path) => {
-        this.document.update({ [attr]: path })
+      callback: async (path) => {
+        await this.document.update({ [attr]: path })
      },
      top: this.position.top + 40,
      left: this.position.left + 10,
@@ -261,7 +260,7 @@ export default class LethalFantasyActorSheet extends HandlebarsApplicationMixin(
    item = await fromUuid(uuid)
    if (!item) item = this.document.items.get(id)
    if (!item) return
-    item.sheet.render(true)
+    item.sheet.render({ force: true })
  }

  /**
@@ -284,8 +283,8 @@ export default class LethalFantasyActorSheet extends HandlebarsApplicationMixin(
   * @private
   * @static
   */
-  static #onCreateSpell(event, target) {
-    const item = this.document.createEmbeddedDocuments("Item", [{ name: "Nouveau sortilège", type: "spell" }])
+  static async #onCreateSpell(event, target) {
+    await this.document.createEmbeddedDocuments("Item", [{ name: "Nouveau sortilège", type: "spell" }])
  }

  // #endregion
@@ -177,12 +177,12 @@ export default class LethalFantasyItemSheet extends HandlebarsApplicationMixin(f
    const attr = target.dataset.edit
    const current = foundry.utils.getProperty(this.document, attr)
    const { img } = this.document.constructor.getDefaultArtwork?.(this.document.toObject()) ?? {}
-    const fp = new FilePicker({
+    const fp = new foundry.applications.ux.FilePicker.implementation({
      current,
      type: "image",
      redirectToRoot: img ? [img] : [],
-      callback: (path) => {
-        this.document.update({ [attr]: path })
+      callback: async (path) => {
+        await this.document.update({ [attr]: path })
      },
      top: this.position.top + 40,
      left: this.position.left + 10,
@@ -22,6 +22,7 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
      divinityPointsMinus: LethalFantasyCharacterSheet.#onDivinityPointsMinus,
      aetherPointsPlus: LethalFantasyCharacterSheet.#onAetherPointsPlus,
      aetherPointsMinus: LethalFantasyCharacterSheet.#onAetherPointsMinus,
+      rollSpellDamage: LethalFantasyCharacterSheet.#onRollSpellDamage,
    },
  }

@@ -70,10 +71,10 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "LETHALFANTASY.Label.biography" },
    }
    if (this.actor.system.biodata.magicUser) {
-      tabs.spells = { id: "spells", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" }
+      tabs.spells = { id: "spells", group: "sheet", icon: "fa-solid fa-wand-magic-sparkles", label: "LETHALFANTASY.Label.spells" }
    }
    if (this.actor.system.biodata.clericUser) {
-      tabs.miracles = { id: "miracles", group: "sheet", icon: "fa-sharp-duotone fa-solid fa-hands-praying", label: "LETHALFANTASY.Label.miracles" }
+      tabs.miracles = { id: "miracles", group: "sheet", icon: "fa-solid fa-hands-praying", label: "LETHALFANTASY.Label.miracles" }
    }
    for (const v of Object.values(tabs)) {
      v.active = this.tabGroups[v.group] === v.id
@@ -172,61 +173,132 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
    })
    if (!roll) return null

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

  static async #onRollInitiative(event, target) {
    await this.document.system.rollInitiative()
  }

-  static #onArmorHitPointsPlus(event, target) {
+  static async #onArmorHitPointsPlus(event, target) {
    let armorHP = this.actor.system.combat.armorHitPoints
    armorHP += 1
-    this.actor.update({ "system.combat.armorHitPoints": armorHP })
+    await this.actor.update({ "system.combat.armorHitPoints": armorHP })
  }

-  static #onArmorHitPointsMinus(event, target) {
+  static async #onArmorHitPointsMinus(event, target) {
    let armorHP = this.actor.system.combat.armorHitPoints
    armorHP -= 1
-    this.actor.update({ "system.combat.armorHitPoints": Math.max(armorHP, 0) })
+    await this.actor.update({ "system.combat.armorHitPoints": Math.max(armorHP, 0) })
  }

-  static #onDivinityPointsPlus(event, target) {
+  static async #onDivinityPointsPlus(event, target) {
    let points = this.actor.system.divinityPoints.value
    points += 1
    points = Math.min(points, this.actor.system.divinityPoints.max)
-    this.actor.update({ "system.divinityPoints.value": points })
+    await this.actor.update({ "system.divinityPoints.value": points })
  }

-  static #onDivinityPointsMinus(event, target) {
+  static async #onDivinityPointsMinus(event, target) {
    let points = this.actor.system.divinityPoints.value
    points -= 1
    points = Math.max(points, 0)
-    this.actor.update({ "system.divinityPoints.value": points })
+    await this.actor.update({ "system.divinityPoints.value": points })
  }

-  static #onAetherPointsPlus(event, target) {
+  static async #onAetherPointsPlus(event, target) {
    let points = this.actor.system.aetherPoints.value
    points += 1
    points = Math.min(points, this.actor.system.aetherPoints.max)
-    this.actor.update({ "system.aetherPoints.value": points })
+    await this.actor.update({ "system.aetherPoints.value": points })
  }

-  static #onAetherPointsMinus(event, target) {
+  static async #onAetherPointsMinus(event, target) {
    let points = this.actor.system.aetherPoints.value
    points -= 1
    points = Math.max(points, 0)
-    this.actor.update({ "system.aetherPoints.value": points })
+    await this.actor.update({ "system.aetherPoints.value": points })
+  }
+
+  /**
+   * Handles spell damage roll from the spell sheet tab.
+   * Shows a DR dialog then rolls the appropriate damage formula.
+   * @param {PointerEvent} event
+   * @param {HTMLElement} target
+   */
+  static async #onRollSpellDamage(event, target) {
+    if (this.isEditMode) return
+    const itemId = target.dataset.itemId
+    const tier = target.dataset.damageTier
+    const spell = this.actor.items.get(itemId)
+    if (!spell) return
+
+    const formulaMap = {
+      standard: spell.system.damageDice,
+      overpowered: spell.system.damageDiceOverpowered,
+      overpowered2: spell.system.damageDiceOverpowered2,
+    }
+    const formula = formulaMap[tier]
+    if (!formula) return
+
+    const manualDR = await foundry.applications.api.DialogV2.wait({
+      window: { title: game.i18n.localize("LETHALFANTASY.Combat.spellDRDialogTitle") },
+      classes: ["lethalfantasy"],
+      position: { width: 320 },
+      content: `<div style="padding:0.5rem 0">
+        <p style="margin-bottom:0.6rem">${game.i18n.localize("LETHALFANTASY.Combat.spellDRDialogMsg")}</p>
+        <div style="display:flex;align-items:center;gap:0.5rem">
+          <label style="font-weight:bold">${game.i18n.localize("LETHALFANTASY.Combat.spellDRLabel")}</label>
+          <input type="number" name="manualDr" value="0" min="0" style="width:5rem"/>
+        </div>
+      </div>`,
+      buttons: [
+        {
+          action: "noDR",
+          type: "button",
+          label: game.i18n.localize("LETHALFANTASY.Combat.spellNoDR"),
+          icon: "fa-solid fa-wand-magic-sparkles",
+          callback: () => 0
+        },
+        {
+          action: "applyDR",
+          type: "button",
+          label: game.i18n.localize("LETHALFANTASY.Combat.spellApplyDR"),
+          icon: "fa-solid fa-shield",
+          callback: (event, button) => Number(button.form?.elements?.manualDr?.value) || 0
+        },
+        {
+          action: "cancel",
+          type: "button",
+          label: game.i18n.localize("LETHALFANTASY.Combat.proceedNo"),
+          callback: () => "cancel"
+        }
+      ],
+      rejectClose: false
+    })
+    if (manualDR === null || manualDR === "cancel") return
+
+    const rollOpts = {
+      type: "spell-damage",
+      rollType: "spell-damage",
+      rollName: `${spell.name} — ${formula}`,
+      isDamage: true,
+      rollData: { isDamage: true },
+      manualDR,
+      actorId: this.actor.id,
+      actorName: this.actor.name,
+      actorImage: this.actor.img
+    }
+    await LethalFantasyRoll.rollSpellDamageToMessage(formula, rollOpts)
  }

  static #onCreateEquipment(event, target) {
  }

  _onRender(context, options) {
-    // Inputs with class `item-quantity`
    const woundDescription = this.element.querySelectorAll('.wound-data')
    for (const input of woundDescription) {
-      input.addEventListener("change", (e) => {
+      input.addEventListener("change", async (e) => {
        e.preventDefault();
        e.stopImmediatePropagation();
        const newValue = e.currentTarget.value
@@ -234,11 +306,11 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
        const fieldName = e.currentTarget.dataset.name
        let tab = foundry.utils.duplicate(this.actor.system.hp.wounds)
        tab[index][fieldName] = newValue
-        console.log(tab, index, fieldName, newValue)
-        this.actor.update({ "system.hp.wounds": tab });
+        log(tab, index, fieldName, newValue)
+        await this.actor.update({ "system.hp.wounds": tab });
      })
    }
-    super._onRender();
+    super._onRender(context, options);
  }


@@ -259,9 +331,11 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet

  async _onRoll(event, target) {
    if (this.isEditMode) return
-    const rollType = event.target.dataset.rollType
-    let rollKey = event.target.dataset.rollKey;
-    let rollDice = event.target.dataset?.rollDice;
+    const el = event.currentTarget
+    const rollType = el.dataset.rollType
+    if (!rollType) return
+    let rollKey = el.dataset.rollKey
+    let rollDice = el.dataset.rollDice

    this.actor.prepareRoll(rollType, rollKey, rollDice)

@@ -91,7 +91,7 @@ export default class LethalFantasyMonsterSheet extends LethalFantasyActorSheet {
   */
  async _onDrop(event) {
    if (!this.isEditable || !this.isEditMode) return
-    const data = TextEditor.getDragEventData(event)
+    const data = foundry.applications.ux.TextEditor.implementation.getDragEventData(event)

    // Handle different data types
    switch (data.type) {
@@ -111,11 +111,13 @@ export default class LethalFantasyMonsterSheet extends LethalFantasyActorSheet {
    })
    if (!roll) return null

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

  static async #onRollInitiative(event, target) {
-    await this.document.system.rollInitiative(event, target)
+    const combat = game.combat
+    const combatant = combat?.combatants.find(c => c.actorId === this.document.id)
+    await this.document.system.rollInitiative(combat?.id, combatant?.id)
  }

  getBestWeaponClassSkill(skills, rollType, multiplier = 1.0) {
@@ -0,0 +1,620 @@
+{
+  "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"
+      },
+      "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"
+      },
+      "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"
+      }
+    },
+    "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"
+      },
+      "skill_rolls": {
+        "type": "gain_grit",
+        "amount": 1,
+        "description": "Gain 1 Grit"
+      },
+      "ranged_defense": {
+        "type": "gain_grit",
+        "amount": 1,
+        "description": "Gain 1 Grit"
+      },
+      "arcane_spell_defense": {
+        "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"
+      },
+      "ranged_defense": {
+        "type": "luck_die",
+        "scope": "combat",
+        "description": "Granted 1 Luck dice for Use in This Combat Only"
+      },
+      "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"
+      }
+    },
+    "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"
+      }
+    },
+    "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"
+      },
+      "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"
+      },
+      "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"
+      }
+    },
+    "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"
+      },
+      "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"
+      },
+      "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 spell defense"
+      }
+    },
+    "15": {
+      "melee_attack": {
+        "type": "combo",
+        "effects": [
+          {
+            "type": "bleed"
+          },
+          {
+            "type": "internal_injury"
+          }
+        ],
+        "description": "Bleed, Internal Injury on Hit"
+      },
+      "ranged_attack": {
+        "type": "bleed",
+        "description": "Bleed"
+      },
+      "melee_defense": {
+        "type": "counter_attack",
+        "options": [
+          "kick",
+          "punch"
+        ],
+        "description": "Kick or Punch"
+      },
+      "skill_rolls": {
+        "type": "bonus_flat",
+        "amount": 1,
+        "target": "skill",
+        "description": "Add 1 to Skill Roll"
+      },
+      "ranged_defense": {
+        "type": "counter_attack",
+        "options": [
+          "kick",
+          "punch"
+        ],
+        "description": "Kick or Punch"
+      }
+    },
+    "13": {},
+    "11": {
+      "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"
+      }
+    },
+    "10": {
+      "melee_attack": {
+        "type": "combo",
+        "effects": [
+          {
+            "type": "bleed"
+          },
+          {
+            "type": "internal_injury"
+          }
+        ],
+        "description": "Bleed, Internal Injury on Hit"
+      },
+      "ranged_attack": {
+        "type": "bleed",
+        "description": "Bleed"
+      },
+      "melee_defense": {
+        "type": "counter_attack",
+        "options": [
+          "kick",
+          "punch"
+        ],
+        "description": "Kick or Punch"
+      },
+      "skill_rolls": {
+        "type": "bonus_flat",
+        "amount": 1,
+        "target": "skill",
+        "description": "Add 1 to Skill Roll"
+      },
+      "ranged_defense": {
+        "type": "counter_attack",
+        "options": [
+          "kick",
+          "punch"
+        ],
+        "description": "Kick or Punch"
+      }
+    },
+    "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"
+      },
+      "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"
+      },
+      "arcane_spell_defense": {
+        "type": "mulligan",
+        "description": "Mulligan, Can Re-Roll This Spell Defense"
+      }
+    },
+    "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": "internal_injury"
+          }
+        ],
+        "description": "Bleed, Internal Injury on Hit"
+      },
+      "ranged_attack": {
+        "type": "bleed",
+        "description": "Bleed"
+      },
+      "melee_defense": {
+        "type": "counter_attack",
+        "options": [
+          "kick",
+          "punch"
+        ],
+        "description": "Kick or Punch"
+      },
+      "skill_rolls": {
+        "type": "bonus_flat",
+        "amount": 1,
+        "target": "skill",
+        "description": "Add 1 to Skill Roll"
+      },
+      "ranged_defense": {
+        "type": "counter_attack",
+        "options": [
+          "kick",
+          "punch"
+        ],
+        "description": "Kick or Punch"
+      }
+    },
+    "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"
+      },
+      "ranged_defense": {
+        "type": "dr_multiplier",
+        "multiplier": 3,
+        "includes_shield": true,
+        "description": "DR Tripled including Shield"
+      },
+      "arcane_spell_defense": {
+        "type": "bonus_dice",
+        "dice": "D12",
+        "target": "spell_defense",
+        "description": "D12 Added to Spell Defense Modifier"
+      }
+    },
+    "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"
+      },
+      "ranged_defense": {
+        "type": "dr_multiplier",
+        "multiplier": 2,
+        "includes_shield": true,
+        "description": "DR Doubled including Shield"
+      },
+      "arcane_spell_defense": {
+        "type": "bonus_dice",
+        "dice": "D6",
+        "target": "spell_defense",
+        "description": "D6 Added to Spell Defense Modifier"
+      }
+    },
+    "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."
+  }
+}
@@ -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,
@@ -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"
@@ -72,23 +72,32 @@ export default class LethalFantasyActor extends Actor {
  /* *************************************************/
  async applyDamage(hpLoss) {
    let hp = this.system.hp.value + hpLoss
-    if (hp < 0) {
-      hp = 0
+    await this.update({ "system.hp.value": hp })
  }
-    this.update({ "system.hp.value": hp })
+
+  /* *************************************************/
+  getNaturalDR() {
+    if (this.type === "monster") {
+      return Number(this.system.hp?.damageResistance) || 0
+    }
+    return Number(this.system.biodata?.naturalDR) || 0
+  }
+
+  /* *************************************************/
+  getMagicDR() {
+    if (this.type === "monster") return 0
+    return Number(this.system.biodata?.magicDR) || 0
  }

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

  /* *************************************************/
-  async prepareRoll(rollType, rollKey, rollDice) {
-    console.log("Preparing roll", rollType, rollKey, rollDice)
+  async prepareRoll(rollType, rollKey, rollDice, defenderId, defenderTokenId, extraShieldDr = 0, d30Effects = {}) {
+    log("Preparing roll", rollType, rollKey, rollDice, defenderId)
    let rollTarget
    switch (rollType) {
      case "granted":
@@ -196,8 +205,53 @@ export default class LethalFantasyActor extends Actor {
      case "spell-power":
      case "miracle-attack":
      case "miracle-power":
-        rollTarget = this.items.find((i) => (i.type === "miracle" || i.type == "spell") && i.id === rollKey)
+        rollTarget = foundry.utils.duplicate(this.items.find((i) => (i.type === "miracle" || i.type == "spell") && i.id === rollKey))
        rollTarget.rollKey = rollKey
+        // Read damage tier from combatant currentAction if available
+        const activeCombatant = game.combat?.combatants?.find(c => c.actorId === this.id)
+        const currentAction = activeCombatant?.getFlag(SYSTEM.id, "currentAction")
+        let damageTier = currentAction?.damageTier
+        // No tier from combat action — prompt the user if multiple tiers exist
+        if (!damageTier) {
+          const tierMap = { standard: "damageDice", overpowered: "damageDiceOverpowered", overpowered2: "damageDiceOverpowered2" }
+          const available = Object.entries(tierMap).filter(([k, v]) => rollTarget.system?.[v])
+          if (available.length > 1) {
+            const buttons = available.map(([id]) => ({
+              action: id,
+              type: "button",
+              label: id.charAt(0).toUpperCase() + id.slice(1),
+              callback: () => id,
+            }))
+            damageTier = await foundry.applications.api.DialogV2.wait({
+              window: { title: "Choose spell tier" },
+              classes: ["lethalfantasy"],
+              content: `<p>Select the power level for <strong>${rollTarget.name}</strong>:</p>`,
+              buttons,
+              rejectClose: false,
+            }) || "standard"
+          } else {
+            damageTier = "standard"
+          }
+        }
+        rollTarget.damageTier = damageTier
+        if (rollType === "spell-attack" || rollType === "spell-power") {
+          const tierCostMap = { standard: "cost", overpowered: "costOverpowered", overpowered2: "costOverpowered2" }
+          const costField = tierCostMap[damageTier] || "cost"
+          const cost = Number(rollTarget.system?.[costField]) || 0
+          const currentAether = Number(this.system.aetherPoints?.value) || 0
+          if (cost > currentAether) {
+            ui.notifications.warn(`${this.name} cannot cast ${rollTarget.name}: insufficient Aether (needs ${cost}, has ${currentAether}).`)
+            return
+          }
+        }
+        if (rollType === "miracle-attack" || rollType === "miracle-power") {
+          const cost = Number(rollTarget.system?.level) || 0
+          const currentGrace = Number(this.system.divinityPoints?.value) || 0
+          if (cost > currentGrace) {
+            ui.notifications.warn(`${this.name} cannot invoke ${rollTarget.name}: insufficient Grace (needs ${cost}, has ${currentGrace}).`)
+            return
+          }
+        }
        break
      case "shield-roll": {
        rollTarget = this.items.find((i) => i.type === "shield" && i.id === rollKey)
@@ -206,8 +260,7 @@ export default class LethalFantasyActor extends Actor {
        rollTarget.rollKey = rollKey
      }
        break;
-      case "weapon-damage-small":
-      case "weapon-damage-medium":
+      case "weapon-damage":
      case "weapon-attack":
      case "weapon-defense": {
        let weapon = this.items.find((i) => i.type === "weapon" && i.id === rollKey)
@@ -245,9 +298,10 @@ export default class LethalFantasyActor extends Actor {
          weapon: weapon,
          weaponSkillModifier: skill.weaponSkillModifier,
          rollKey: rollKey,
-          combat: foundry.utils.duplicate(this.system.combat)
+          combat: foundry.utils.duplicate(this.system.combat),
+          isRangedAttack: weapon.system.weaponType === "ranged"
        }
-        if (rollType === "weapon-damage-small" || rollType === "weapon-damage-medium") {
+        if (rollType === "weapon-damage") {
          rollTarget.grantedDice = this.system.granted.damageDice
        }
        if (rollType === "weapon-attack") {
@@ -256,19 +310,21 @@ export default class LethalFantasyActor extends Actor {
        if (rollType === "weapon-defense") {
          rollTarget.armorDefense = this.getArmorDefenseValue()
          rollTarget.grantedDice = this.system.granted.defenseDice
+          // Check if this is a ranged defense
+          rollTarget.isRangedDefense = game.lethalFantasy?.nextDefenseData?.isRanged ?? false
        }
      }
        break
      default:
        ui.notifications.error(game.i18n.localize("LETHALFANTASY.Notifications.rollTypeNotFound") + String(rollType))
-        break
+        return
    }

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

 }
@@ -0,0 +1,228 @@
+import { log } from "../utils.mjs"
+
+/**
+ * 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"
+  }
+
+  /**
+   * 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
+
+      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/Miracle types
+    if (externalType === "spell-attack" || externalType === "spell" || externalType === "spell-power"
+      || externalType === "miracle-attack" || externalType === "miracle" || externalType === "miracle-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 this.ROLL_TYPES.ARCANE_SPELL_DEFENSE
+    }
+
+    // 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
+  }
+}
@@ -32,20 +32,20 @@ export class Macros {
          dropData.rollType === "save"
            ? `game.actors.get('${dropData.actorId}').system.roll('${dropData.rollType}', '${dropData.rollTarget}', '=');`
            : `game.actors.get('${dropData.actorId}').system.roll('${dropData.rollType}', '${dropData.rollTarget}');`
-        const rollName = `${game.i18n.localize("TENEBRIS.Label.jet")} ${game.i18n.localize(`TENEBRIS.Manager.${dropData.rollTarget}`)}`
+        const rollName = `${game.i18n.localize("LETHALFANTASY.Label.jet")} ${game.i18n.localize(`LETHALFANTASY.Label.${dropData.rollTarget}`)}`
        this.createMacro(slot, rollName, rollCommand, "icons/svg/d20-grey.svg")
        break

      case "rollDamage":
        const weapon = game.actors.get(dropData.actorId).items.get(dropData.rollTarget)
        const rollDamageCommand = `game.actors.get('${dropData.actorId}').system.roll('${dropData.rollType}', '${dropData.rollTarget}');`
-        const rollDamageName = `${game.i18n.localize("TENEBRIS.Label.jet")} ${weapon.name}`
+        const rollDamageName = `${game.i18n.localize("LETHALFANTASY.Label.jet")} ${weapon.name}`
        this.createMacro(slot, rollDamageName, rollDamageCommand, weapon.img)
        break

      case "rollAttack":
        const rollAttackCommand = `game.actors.get('${dropData.actorId}').system.roll('${dropData.rollValue}', '${dropData.rollTarget}');`
-        const rollAttackName = `${game.i18n.localize("TENEBRIS.Label.jet")} ${dropData.rollTarget}`
+        const rollAttackName = `${game.i18n.localize("LETHALFANTASY.Label.jet")} ${dropData.rollTarget}`
        this.createMacro(slot, rollAttackName, rollAttackCommand, "icons/svg/d20-grey.svg")
        break

@@ -57,7 +57,7 @@ export class Macros {

  /**
   * Create a macro
-   * All macros are flaged with a tenebris.macro flag at true
+   * All macros are flaged with a lethalFantasy.macro flag at true
   * @param {*} slot
   * @param {*} name
   * @param {*} command
@@ -72,7 +72,7 @@ export class Macros {
          type: "script",
          img: img,
          command: command,
-          flags: { "tenebris.macro": true },
+          flags: { "lethalFantasy.macro": true },
        },
        { displaySheet: false },
      )
@@ -65,7 +65,7 @@ export default class LethalFantasyCharacter extends foundry.abstract.TypeDataMod
    }

    schema.hp = new fields.SchemaField({
-      value: new fields.NumberField({ ...requiredInteger, initial: 1, min: 0 }),
+      value: new fields.NumberField({ ...requiredInteger, initial: 1 }),
      max: new fields.NumberField({ ...requiredInteger, initial: 1, min: 0 }),
      painDamage: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
      wounds: new fields.ArrayField(new fields.SchemaField(woundFieldSchema), {
@@ -152,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) => {
@@ -258,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)
@@ -273,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, d30Effects = {}) {
    const hasTarget = false
    let roll = await LethalFantasyRoll.prompt({
      rollType,
@@ -282,11 +290,18 @@ export default class LethalFantasyCharacter extends foundry.abstract.TypeDataMod
      actorName: this.parent.name,
      actorImage: this.parent.img,
      hasTarget,
-      target: false
+      target: false,
+      defenderId,
+      defenderTokenId,
+      extraShieldDr,
+      damageTier: rollTarget.damageTier || "standard",
+      d30Bleed: d30Effects.d30Bleed || false,
+      d30DamageMultiplier: d30Effects.d30DamageMultiplier || 1,
+      d30DrMultiplier: d30Effects.d30DrMultiplier || 1
    })
    if (!roll) return null

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

  async rollInitiative(combatId = undefined, combatantId = undefined) {
@@ -307,10 +322,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")
@@ -338,6 +360,11 @@ export default class LethalFantasyCharacter extends foundry.abstract.TypeDataMod
      }
    }

+    if (weaponsChoices.length === 0) {
+      ui.notifications.warn(`${this.parent.name} has no weapons or spells available for combat. Add a weapon to the character sheet first.`)
+      return
+    }
+
    let roll = await LethalFantasyRoll.promptCombatAction({
      actorId: this.parent.id,
      actorName: this.parent.name,
@@ -35,6 +35,9 @@ export default class LethalFantasyMiracle extends foundry.abstract.TypeDataModel

    schema.attackRoll = new fields.StringField({ required: true, initial: "" })
    schema.powerRoll = new fields.StringField({ required: true, initial: "" })
+    schema.damageDice = new fields.StringField({ required: false, initial: "" })
+    schema.damageDiceOverpowered = new fields.StringField({ required: false, initial: "" })
+    schema.damageDiceOverpowered2 = new fields.StringField({ required: false, initial: "" })

    return schema
  }
@@ -56,15 +56,33 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
      }, {}),
    )

+    const woundFieldSchema = {
+      value: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      duration: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      description: new fields.StringField({ initial: "", required: false, nullable: true }),
+    }
+
    schema.hp = new fields.SchemaField({
-      value: new fields.NumberField({ ...requiredInteger, initial: 1, min: 0 }),
+      value: new fields.NumberField({ ...requiredInteger, initial: 1 }),
      average: new fields.NumberField({ ...requiredInteger, initial: 1, min: 0 }),
      max: new fields.NumberField({ ...requiredInteger, initial: 1, min: 0 }),
+      wounds: new fields.ArrayField(new fields.SchemaField(woundFieldSchema), {
+        initial: [
+          { description: "", value: 0, duration: 0 },
+          { description: "", value: 0, duration: 0 },
+          { description: "", value: 0, duration: 0 },
+          { description: "", value: 0, duration: 0 },
+          { description: "", value: 0, duration: 0 },
+          { description: "", value: 0, duration: 0 },
+          { description: "", value: 0, duration: 0 },
+          { description: "", value: 0, duration: 0 }
+        ], min: 8
+      }),
      damageResistance: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
      painDamage: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 })
    })

-    const attackField = (label) => {
+    const attackField = (label, initialNoExplode = false) => {
      const schema = {
        key: new fields.StringField({ required: true, nullable: false, initial: `attack${label}` }),
        name: new fields.StringField({ required: true, nullable: false, initial: `Attack ${label}` }),
@@ -74,6 +92,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
        damageDice: new fields.StringField({ required: true, nullable: false, initial: "1D6" }),
        damageModifier: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
        enabled: new fields.BooleanField({ initial: true, required: true, nullable: false }),
+        noExplode: new fields.BooleanField({ initial: initialNoExplode, required: true, nullable: false }),
      }
      return new fields.SchemaField(schema, { label })
    }
@@ -122,7 +141,33 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
      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
  }
@@ -137,8 +182,24 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
   * @param {"="|"+"|"++"|"-"|"--"} rollAdvantage If there is an avantage (+), a disadvantage (-), a double advantage (++), a double disadvantage (--) or a normal roll (=).
   * @returns {Promise<null>} - A promise that resolves to null if the roll is cancelled.
   */
-  async roll(rollType, rollTarget) {
+  async roll(rollType, rollTarget, defenderId = undefined, defenderTokenId = undefined, extraShieldDr = 0, d30Effects = {}) {
    const hasTarget = false
+
+    // Ranged monster defense uses the ranged defense dialog (movement, range, size modifiers)
+    if (rollType === "monster-defense" && rollTarget?.isRangedDefense === true) {
+      let roll = await LethalFantasyRoll.promptRangedDefense({
+        actorId: this.parent.id,
+        actorName: this.parent.name,
+        actorImage: this.parent.img,
+        rollTarget,
+        defenderId,
+        defenderTokenId,
+      })
+      if (!roll) return null
+      await roll.toMessage({}, { messageMode: roll.options.rollMode })
+      return
+    }
+
    let roll = await LethalFantasyRoll.prompt({
      rollType,
      rollTarget,
@@ -146,26 +207,51 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
      actorName: this.parent.name,
      actorImage: this.parent.img,
      hasTarget,
-      target: false
+      target: false,
+      defenderId,
+      defenderTokenId,
+      extraShieldDr,
+      damageTier: rollTarget.damageTier || "standard",
+      d30Bleed: d30Effects.d30Bleed || false,
+      d30DamageMultiplier: d30Effects.d30DamageMultiplier || 1,
+      d30DrMultiplier: d30Effects.d30DrMultiplier || 1
    })
    if (!roll) return null

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

-  async prepareMonsterRoll(rollType, rollKey, rollDice = undefined, tokenId = undefined, damageModifier = undefined) {
+  async prepareMonsterRoll(rollType, rollKey, rollDice = undefined, tokenId = undefined, damageModifier = undefined, defenderId = undefined, defenderTokenId = undefined, extraShieldDr = 0, d30Effects = {}) {
    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])
        rollTarget.rollKey = rollKey
@@ -185,11 +271,10 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
        await roll.toMessage({
          flavor,
          speaker: ChatMessage.getSpeaker({ actor: this.parent })
-        })
+        }, { messageMode: roll.options.rollMode ?? game.settings.get("core", "rollMode") })
        return
      }
-      case "weapon-damage-small":
-      case "weapon-damage-medium":
+      case "weapon-damage":
      case "weapon-attack":
      case "weapon-defense": {
        let weapon = this.actor.items.find((i) => i.type === "weapon" && i.id === rollKey)
@@ -222,7 +307,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
          return
        }
        rollTarget = skill
-        rollTarget.weapon = weapon
+        rollTarget.weapon = foundry.utils.duplicate(weapon)
        rollTarget.weaponSkillModifier = skill.weaponSkillModifier
        rollTarget.rollKey = rollKey
        rollTarget.combat = foundry.utils.duplicate(this.combat)
@@ -236,8 +321,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
    // In all cases
    if (rollTarget) {
      rollTarget.tokenId = tokenId
-      console.log(rollTarget)
-      await this.roll(rollType, rollTarget)
+      await this.roll(rollType, rollTarget, defenderId, defenderTokenId, extraShieldDr, d30Effects)
    }
  }

@@ -257,12 +341,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,
@@ -271,7 +362,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) {
@@ -279,12 +369,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
+          }
+        )
+        await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
        let token = combatant?.token
        this.prepareMonsterRoll("monster-attack", key, undefined, token?.id)
        if (token?.object) {
@@ -293,9 +392,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
+            }
+          )
+          await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
+          let token = combatant?.token
+          this.prepareMonsterRoll("monster-attack-hth", key, undefined, token?.id)
+          if (token?.object) {
+            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
+        }
+      )
+      await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
    }

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

    schema.cost = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
+    schema.costOverpowered = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
+    schema.costOverpowered2 = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
    schema.memorized = new fields.BooleanField({ required: true, initial: false })
    
    schema.components = new fields.SchemaField({
@@ -39,6 +41,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
  }
@@ -1,6 +1,7 @@
 import { SYSTEM } from "../config/system.mjs"
+import { WEAPON_TYPE } from "../config/weapon.mjs"

-export default class LethalFantasySkill extends foundry.abstract.TypeDataModel {
+export default class LethalFantasyWeapon extends foundry.abstract.TypeDataModel {
  static defineSchema() {
    const fields = foundry.data.fields
    const schema = {}
@@ -45,9 +46,9 @@ export default class LethalFantasySkill extends foundry.abstract.TypeDataModel {
    })

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

    schema.encLoad = new fields.NumberField({ required: true, initial: 0, min: 0 })
@@ -62,7 +63,7 @@ export default class LethalFantasySkill extends foundry.abstract.TypeDataModel {
  static LOCALIZATION_PREFIXES = ["LETHALFANTASY.Weapon"]

  get weaponCategory() {
-    return game.i18n.localize(CATEGORY[this.weaponType].label)
+    return game.i18n.localize(WEAPON_TYPE[this.weaponType] || this.weaponType)
  }

 }
@@ -1 +0,0 @@
-MANIFEST-000498
@@ -1,15 +0,0 @@
-2026/01/12-14:22:56.040680 7fd462ffd6c0 Recovering log #496
-2026/01/12-14:22:56.051263 7fd462ffd6c0 Delete type=3 #494
-2026/01/12-14:22:56.051335 7fd462ffd6c0 Delete type=0 #496
-2026/01/12-14:27:05.789368 7fd4627fc6c0 Level-0 table #501: started
-2026/01/12-14:27:05.793070 7fd4627fc6c0 Level-0 table #501: 26835 bytes OK
-2026/01/12-14:27:05.799160 7fd4627fc6c0 Delete type=0 #499
-2026/01/12-14:27:05.815143 7fd4627fc6c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
-2026/01/12-14:27:05.815173 7fd4627fc6c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at '!items!zFrygJ2TnrxchBai' @ 1178 : 1
-2026/01/12-14:27:05.815179 7fd4627fc6c0 Compacting 1@1 + 1@2 files
-2026/01/12-14:27:05.821137 7fd4627fc6c0 Generated table #502@1: 486 keys, 220368 bytes
-2026/01/12-14:27:05.821151 7fd4627fc6c0 Compacted 1@1 + 1@2 files => 220368 bytes
-2026/01/12-14:27:05.827440 7fd4627fc6c0 compacted to: files[ 0 0 1 0 0 0 0 ]
-2026/01/12-14:27:05.827535 7fd4627fc6c0 Delete type=2 #489
-2026/01/12-14:27:05.828221 7fd4627fc6c0 Delete type=2 #501
-2026/01/12-14:27:05.839529 7fd4627fc6c0 Manual compaction at level-1 from '!items!zFrygJ2TnrxchBai' @ 1178 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
@@ -1,8 +0,0 @@
-2026/01/04-22:23:04.765915 7f93ebfff6c0 Recovering log #492
-2026/01/04-22:23:04.775983 7f93ebfff6c0 Delete type=3 #490
-2026/01/04-22:23:04.776035 7f93ebfff6c0 Delete type=0 #492
-2026/01/04-22:40:50.964348 7f93e9ffb6c0 Level-0 table #497: started
-2026/01/04-22:40:50.964370 7f93e9ffb6c0 Level-0 table #497: 0 bytes OK
-2026/01/04-22:40:50.975783 7f93e9ffb6c0 Delete type=0 #495
-2026/01/04-22:40:50.986019 7f93e9ffb6c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
-2026/01/04-22:40:50.986046 7f93e9ffb6c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
@@ -1 +0,0 @@
-MANIFEST-000496
@@ -1,8 +0,0 @@
-2026/01/12-14:22:56.057091 7fd4637fe6c0 Recovering log #494
-2026/01/12-14:22:56.067553 7fd4637fe6c0 Delete type=3 #492
-2026/01/12-14:22:56.067610 7fd4637fe6c0 Delete type=0 #494
-2026/01/12-14:27:05.799253 7fd4627fc6c0 Level-0 table #499: started
-2026/01/12-14:27:05.799272 7fd4627fc6c0 Level-0 table #499: 0 bytes OK
-2026/01/12-14:27:05.805798 7fd4627fc6c0 Delete type=0 #497
-2026/01/12-14:27:05.815153 7fd4627fc6c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
-2026/01/12-14:27:05.828314 7fd4627fc6c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
@@ -1,8 +0,0 @@
-2026/01/04-22:23:04.780744 7f93eb7fe6c0 Recovering log #490
-2026/01/04-22:23:04.790510 7f93eb7fe6c0 Delete type=3 #488
-2026/01/04-22:23:04.790582 7f93eb7fe6c0 Delete type=0 #490
-2026/01/04-22:40:50.951234 7f93e9ffb6c0 Level-0 table #495: started
-2026/01/04-22:40:50.951256 7f93e9ffb6c0 Level-0 table #495: 0 bytes OK
-2026/01/04-22:40:50.964192 7f93e9ffb6c0 Delete type=0 #493
-2026/01/04-22:40:50.986007 7f93e9ffb6c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
-2026/01/04-22:40:50.986038 7f93e9ffb6c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
@@ -1 +0,0 @@
-MANIFEST-000499
@@ -1,15 +0,0 @@
-2026/01/12-14:22:56.026652 7fd478fff6c0 Recovering log #497
-2026/01/12-14:22:56.036317 7fd478fff6c0 Delete type=3 #495
-2026/01/12-14:22:56.036373 7fd478fff6c0 Delete type=0 #497
-2026/01/12-14:27:05.805895 7fd4627fc6c0 Level-0 table #502: started
-2026/01/12-14:27:05.809094 7fd4627fc6c0 Level-0 table #502: 1650 bytes OK
-2026/01/12-14:27:05.815051 7fd4627fc6c0 Delete type=0 #500
-2026/01/12-14:27:05.815162 7fd4627fc6c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
-2026/01/12-14:27:05.828330 7fd4627fc6c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at '!items!3cU5wW47VwlEPNqj' @ 736 : 1
-2026/01/12-14:27:05.828340 7fd4627fc6c0 Compacting 1@1 + 1@2 files
-2026/01/12-14:27:05.833408 7fd4627fc6c0 Generated table #503@1: 91 keys, 118712 bytes
-2026/01/12-14:27:05.833433 7fd4627fc6c0 Compacted 1@1 + 1@2 files => 118712 bytes
-2026/01/12-14:27:05.839289 7fd4627fc6c0 compacted to: files[ 0 0 1 0 0 0 0 ]
-2026/01/12-14:27:05.839370 7fd4627fc6c0 Delete type=2 #494
-2026/01/12-14:27:05.839480 7fd4627fc6c0 Delete type=2 #502
-2026/01/12-14:27:05.852151 7fd4627fc6c0 Manual compaction at level-1 from '!items!3cU5wW47VwlEPNqj' @ 736 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
@@ -1,8 +0,0 @@
-2026/01/04-22:23:04.753572 7f93ea7fc6c0 Recovering log #492
-2026/01/04-22:23:04.763198 7f93ea7fc6c0 Delete type=3 #490
-2026/01/04-22:23:04.763251 7f93ea7fc6c0 Delete type=0 #492
-2026/01/04-22:40:50.941164 7f93e9ffb6c0 Level-0 table #498: started
-2026/01/04-22:40:50.941212 7f93e9ffb6c0 Level-0 table #498: 0 bytes OK
-2026/01/04-22:40:50.951122 7f93e9ffb6c0 Delete type=0 #496
-2026/01/04-22:40:50.985987 7f93e9ffb6c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
-2026/01/04-22:40:50.986053 7f93e9ffb6c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
@@ -1 +0,0 @@
-MANIFEST-000196
@@ -1,8 +0,0 @@
-2026/01/12-14:22:56.089280 7fd478fff6c0 Recovering log #194
-2026/01/12-14:22:56.099242 7fd478fff6c0 Delete type=3 #192
-2026/01/12-14:22:56.099341 7fd478fff6c0 Delete type=0 #194
-2026/01/12-14:27:05.839539 7fd4627fc6c0 Level-0 table #199: started
-2026/01/12-14:27:05.839559 7fd4627fc6c0 Level-0 table #199: 0 bytes OK
-2026/01/12-14:27:05.845408 7fd4627fc6c0 Delete type=0 #197
-2026/01/12-14:27:05.858412 7fd4627fc6c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
-2026/01/12-14:27:05.864408 7fd4627fc6c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
@@ -1,8 +0,0 @@
-2026/01/04-22:23:04.807684 7f93ebfff6c0 Recovering log #190
-2026/01/04-22:23:04.818050 7f93ebfff6c0 Delete type=3 #188
-2026/01/04-22:23:04.818118 7f93ebfff6c0 Delete type=0 #190
-2026/01/04-22:40:51.016662 7f93e9ffb6c0 Level-0 table #195: started
-2026/01/04-22:40:51.016694 7f93e9ffb6c0 Level-0 table #195: 0 bytes OK
-2026/01/04-22:40:51.026652 7f93e9ffb6c0 Delete type=0 #193
-2026/01/04-22:40:51.026790 7f93e9ffb6c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
-2026/01/04-22:40:51.026806 7f93e9ffb6c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
@@ -1 +0,0 @@
-MANIFEST-000495
@@ -1,8 +0,0 @@
-2026/01/12-14:22:56.075339 7fd463fff6c0 Recovering log #493
-2026/01/12-14:22:56.084731 7fd463fff6c0 Delete type=3 #491
-2026/01/12-14:22:56.084798 7fd463fff6c0 Delete type=0 #493
-2026/01/12-14:27:05.782342 7fd4627fc6c0 Level-0 table #498: started
-2026/01/12-14:27:05.782393 7fd4627fc6c0 Level-0 table #498: 0 bytes OK
-2026/01/12-14:27:05.789274 7fd4627fc6c0 Delete type=0 #496
-2026/01/12-14:27:05.815132 7fd4627fc6c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
-2026/01/12-14:27:05.828301 7fd4627fc6c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
@@ -1,8 +0,0 @@
-2026/01/04-22:23:04.794525 7f93ea7fc6c0 Recovering log #489
-2026/01/04-22:23:04.804229 7f93ea7fc6c0 Delete type=3 #487
-2026/01/04-22:23:04.804296 7f93ea7fc6c0 Delete type=0 #489
-2026/01/04-22:40:50.975950 7f93e9ffb6c0 Level-0 table #494: started
-2026/01/04-22:40:50.975985 7f93e9ffb6c0 Level-0 table #494: 0 bytes OK
-2026/01/04-22:40:50.985836 7f93e9ffb6c0 Delete type=0 #492
-2026/01/04-22:40:50.986029 7f93e9ffb6c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
-2026/01/04-22:40:50.986073 7f93e9ffb6c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
@@ -387,11 +387,11 @@
          min-width: 6rem;
          max-width: 6rem;
        }
-        min-width: 10rem;
-        max-width: 10rem;
+        min-width: 11rem;
+        max-width: 11rem;
        .input {
-          min-width: 2.5rem;
-          max-width: 2.5rem;
+          min-width: 3.5rem;
+          max-width: 3.5rem;
        }
      }
      .granted {
@@ -39,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);
+      }
+    }
+  }
+}
@@ -42,3 +42,355 @@
  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;
+}
+
+/* Luck/Grit Styles */
+#token-hud .luck-grit-wrap {
+  position: absolute;
+  left: 75px;
+  display: none;
+  top: 50%;
+  width: 80px;
+  text-align: start;
+  background: rgba(0, 0, 0, 0.8);
+  border: 1px solid rgba(139, 69, 19, 0.5);
+  border-radius: 4px;
+  padding: 4px 6px;
+  transform: translate(-100%, -50%);
+}
+
+#token-hud .luck-grit-hud-active {
+  display: block;
+}
+
+#token-hud .luck-grit-hud-disabled {
+  display: none;
+}
+
+#token-hud .luck-grit-row {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  margin: 2px 0;
+}
+
+#token-hud .luck-grit-label {
+  flex: 1;
+  color: #c9b896;
+  font-size: 11px;
+  font-weight: 600;
+  text-transform: uppercase;
+}
+
+#token-hud .luck-grit-btn {
+  width: 28px;
+  height: 22px;
+  padding: 0;
+  background: rgba(139, 69, 19, 0.25);
+  border: 1px solid rgba(139, 69, 19, 0.4);
+  border-radius: 3px;
+  color: #d4c5a9;
+  font-size: 12px;
+  font-weight: 700;
+  cursor: pointer;
+  line-height: 1;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+
+  &:hover {
+    background: rgba(139, 69, 19, 0.5);
+    border-color: rgba(139, 69, 19, 0.7);
+  }
+}
+
+/* -------------------------------------------------- */
+/* Dice Tray — injected into the Foundry chat sidebar */
+/* -------------------------------------------------- */
+
+.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);
+    }
+  }
+}
@@ -410,6 +410,48 @@
    }
  }

+  .ranged-attacks {
+    grid-template-columns: 1fr;
+    .attack {
+      .name {
+        min-width: 10rem;
+        max-width: 10rem;
+      }
+      .damage-dice {
+        width: 5rem;
+        max-width: 5rem;
+      }
+    }
+    .ranged-weapon-range {
+      margin-top: 8px;
+      border-top: 1px solid var(--color-border-light-tertiary, #ccc);
+      padding-top: 6px;
+      > label {
+        font-weight: bold;
+        margin-bottom: 4px;
+        display: block;
+      }
+      .range-fields {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 6px;
+        .range-field {
+          display: flex;
+          flex-direction: column;
+          align-items: center;
+          label {
+            font-size: 0.7rem;
+            white-space: nowrap;
+          }
+          input {
+            width: 3.5rem;
+            text-align: center;
+          }
+        }
+      }
+    }
+  }
+
  .armors {
    display: grid;
    grid-template-columns: repeat(3, 1fr);
@@ -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"],
@@ -9,95 +9,95 @@
      <legend>{{localize "LETHALFANTASY.Label.biodata"}}</legend>
      <div class="biodata">
        <div class="biodata-elem">
-          <span class="name">Class</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.class"}}</span>
          {{formInput
            systemFields.biodata.fields.class
            value=system.biodata.class
          }}
        </div>
        <div class="biodata-elem">
-          <span class="name">Level</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.level"}}</span>
          {{formInput
            systemFields.biodata.fields.level
            value=system.biodata.level
          }}
        </div>
        <div class="biodata-elem">
-          <span class="name">Mortal</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.mortal"}}</span>
          {{formInput
            systemFields.biodata.fields.mortal
            value=system.biodata.mortal
          }}
        </div>
        <div class="biodata-elem">
-          <span class="name">Alignment</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.alignment"}}</span>
          {{formInput
            systemFields.biodata.fields.alignment
            value=system.biodata.alignment
          }}
        </div>
        <div class="biodata-elem">
-          <span class="name">Age</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.age"}}</span>
          {{formInput systemFields.biodata.fields.age value=system.biodata.age}}
        </div>
        <div class="biodata-elem">
-          <span class="name">Height</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.height"}}</span>
          {{formInput
            systemFields.biodata.fields.height
            value=system.biodata.height
          }}
        </div>
        <div class="biodata-elem">
-          <span class="name">Weight</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.weight"}}</span>
          {{formInput
            systemFields.biodata.fields.weight
            value=system.biodata.weight
          }}
        </div>
        <div class="biodata-elem">
-          <span class="name">Eyes</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.eyes"}}</span>
          {{formInput
            systemFields.biodata.fields.eyes
            value=system.biodata.eyes
          }}
        </div>
        <div class="biodata-elem">
-          <span class="name">Hair</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.hair"}}</span>
          {{formInput
            systemFields.biodata.fields.hair
            value=system.biodata.hair
          }}
        </div>
        <div class="biodata-elem">
-          <span class="name">Dev. Points (Total)</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.devPointsTotal"}}</span>
          {{formInput
            systemFields.developmentPoints.fields.total
            value=system.developmentPoints.total
          }}
        </div>
        <div class="biodata-elem">
-          <span class="name">Dev. Points (Rem.)</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.devPointsRem"}}</span>
          {{formInput
            systemFields.developmentPoints.fields.remaining
            value=system.developmentPoints.remaining
          }}
        </div>
        <div class="biodata-elem">
-          <span class="name">Magic User</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.magicUser"}}</span>
          {{formInput
            systemFields.biodata.fields.magicUser
            value=system.biodata.magicUser
          }}
        </div>
        <div class="biodata-elem">
-          <span class="name">Cleric User</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.clericUser"}}</span>
          {{formInput
            systemFields.biodata.fields.clericUser
            value=system.biodata.clericUser
          }}
        </div>
        <div class="biodata-elem">
-          <span class="name">Save bonus (1/5levels)</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.saveBonus"}}</span>
          {{formInput
            systemFields.modifiers.fields.saveModifier
            value=system.modifiers.saveModifier
@@ -107,7 +107,7 @@

        {{#if system.biodata.magicUser}}
          <div class="biodata-elem">
-            <span class="name">Spell bonus (1/5levels)</span>
+            <span class="name">{{localize "LETHALFANTASY.Label.spellBonus"}}</span>
            {{formInput
              systemFields.modifiers.fields.levelSpellModifier
              value=system.modifiers.levelSpellModifier
@@ -117,7 +117,7 @@
        {{/if}}
        {{#if system.biodata.clericUser}}
          <div class="biodata-elem">
-            <span class="name">Miracle bonus (1/5levels)</span>
+            <span class="name">{{localize "LETHALFANTASY.Label.miracleBonus"}}</span>
            {{formInput
              systemFields.modifiers.fields.levelMiracleModifier
              value=system.modifiers.levelMiracleModifier
@@ -127,7 +127,7 @@
        {{/if}}

        <div class="biodata-elem">
-          <span class="name">Last HD roll</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.lastHdRoll"}}</span>
          {{formInput
            systemFields.biodata.fields.hpPerLevel
            value=system.biodata.hpPerLevel
@@ -136,7 +136,7 @@
        </div>

        <div class="biodata-elem">
-          <span class="name">Natural DR</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.naturalDR"}}</span>
          {{formInput
            systemFields.biodata.fields.naturalDR
            value=system.biodata.naturalDR
@@ -145,7 +145,7 @@
        </div>

        <div class="biodata-elem">
-          <span class="name">Magical DR</span>
+          <span class="name">{{localize "LETHALFANTASY.Label.magicalDR"}}</span>
          {{formInput
            systemFields.biodata.fields.magicDR
            value=system.biodata.magicDR
@@ -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>
@@ -82,16 +87,10 @@
              <i class="fa-solid fa-shield-halved" data-roll-type="weapon-defense" data-roll-key="{{item.id}}"></i>
            </a>

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

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

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

-          <span>Max</span>
+          <span>{{localize "LETHALFANTASY.Label.max"}}</span>
          {{formField systemFields.aetherPoints.fields.max value=system.aetherPoints.max localize=true
          disabled=isPlayMode}}
        </div>
@@ -37,6 +37,25 @@
            <i class="fa-duotone fa-solid fa-stars" data-roll-type="spell-power" data-roll-key="{{item.id}}"></i>
          </a>

+          {{#if item.system.damageDice}}
+          <a data-action="rollSpellDamage" data-item-id="{{item.id}}" data-damage-tier="standard"
+            data-tooltip="Spell Damage (Standard)">
+            <i class="fa-solid fa-wand-magic-sparkles"></i>S
+          </a>
+          {{/if}}
+          {{#if item.system.damageDiceOverpowered}}
+          <a data-action="rollSpellDamage" data-item-id="{{item.id}}" data-damage-tier="overpowered"
+            data-tooltip="Spell Damage (Overpowered)">
+            <i class="fa-solid fa-wand-magic-sparkles"></i>O
+          </a>
+          {{/if}}
+          {{#if item.system.damageDiceOverpowered2}}
+          <a data-action="rollSpellDamage" data-item-id="{{item.id}}" data-damage-tier="overpowered2"
+            data-tooltip="Spell Damage (Overpowered 2)">
+            <i class="fa-solid fa-wand-magic-sparkles"></i>O2
+          </a>
+          {{/if}}
+
          <div class="controls">
            <a data-tooltip="{{localize 'LETHALFANTASY.Edit'}}" data-action="edit" data-item-id="{{item.id}}"
              data-item-uuid="{{item.uuid}}"><i class="fas fa-edit"></i></a>
@@ -1,125 +1,183 @@
 {{!log 'chat-message' this}}
 {{!log 'weaponDamageOptions' weaponDamageOptions}}
 <div class="{{cssClass}}">
-  <div class="intro-chat">
-    <div class="intro-img">
+  <!-- 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="intro-right">
-      <span><STRONG>{{actingCharName}} - {{upperFirst rollName}}</STRONG></span>
-
+      <div class="character-details">
+        <div class="character-name">{{actingCharName}}</div>
+        <div class="roll-type-badge">
          {{#if (match rollType "attack")}}
-        <span>Attack roll !</span>
+            <i class="fa-solid fa-swords"></i>
          {{/if}}
          {{#if (match rollType "defense")}}
-        <span>Defense roll !</span>
+            <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>
+
+  <!-- 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")}}
-        <span><strong>Favor roll</strong></span>
+      <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")}}
-        <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.isDamage}}
-        <span><strong>Damage Roll</strong></span>
-      {{/if}}
-      {{#if rollData.damageSmall}}
-        <span><strong>{{localize
-              "LETHALFANTASY.Label.weapon-damage-small"
-            }}</strong></span>
-      {{/if}}
-      {{#if rollData.damageMedium}}
-        <span><strong>{{localize
-              "LETHALFANTASY.Label.weapon-damage-medium"
-            }}</strong></span>
+      <div class="detail-badge disfavor-badge">
+        <i class="fa-solid fa-skull"></i>
+        <span>{{localize "LETHALFANTASY.Label.disfavor"}}</span>
+      </div>
    {{/if}}

    {{#if rollData.letItFly}}
-        <span>Let It Fly attack ! </span>
+      <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}}
-        <span>Point Blank Range Attack !</span>
+      <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}}
-        <span>Beyond Skill Range Attack !</span>
+      <div class="detail-badge special-badge">
+        <i class="fa-solid fa-target-lock"></i>
+        <span>{{localize "LETHALFANTASY.Label.beyondSkill"}}</span>
+      </div>
    {{/if}}

-      <span><strong>Formula</strong> : {{titleFormula}}</span>
+    {{#if rollData.isDamage}}
+      <div class="detail-badge damage-badge">
+        <i class="fa-solid fa-dice-d20"></i>
+        <span>{{localize "LETHALFANTASY.Label.weapon-damage"}}</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|}}
-        <span>{{result.dice}} : {{result.value}}</span>
+          <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="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="result">
+      <div class="outcome-badge {{#if (eq resultType 'success')}}success-outcome{{else}}failure-outcome{{/if}}">
        {{#if (eq resultType "success")}}
-        {{#if isPrivate}}?{{else}}{{localize
-            "LETHALFANTASY.Roll.success"
-          }}{{/if}}
+          <i class="fa-solid fa-circle-check"></i>
+          {{localize "LETHALFANTASY.Roll.success"}}
        {{else}}
-        {{#if isPrivate}}?{{else}}{{localize
-            "LETHALFANTASY.Roll.failure"
-          }}{{/if}}
+          <i class="fa-solid fa-circle-xmark"></i>
+          {{localize "LETHALFANTASY.Roll.failure"}}
        {{/if}}
      </div>
    {{/if}}
+
    {{#if isResource}}
-    <div class="result">
+      <div class="outcome-badge {{#if (eq resultType 'success')}}success-outcome{{else}}failure-outcome{{/if}}">
        {{#if (eq resultType "success")}}
-        {{#if isPrivate}}?{{else}}{{localize
-            "LETHALFANTASY.Roll.success"
-          }}{{/if}}
+          <i class="fa-solid fa-circle-check"></i>
+          {{localize "LETHALFANTASY.Roll.success"}}
        {{else}}
-        {{#if isPrivate}}?{{else}}{{localize "LETHALFANTASY.Roll.failure"}}{{#if
-            isFailure
-          }} ({{localize "LETHALFANTASY.Roll.resourceLost"}}){{/if}}{{/if}}
+          <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}}
-    <div>
      {{#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
          }}}
-      {{/if}}
        </div>
      {{/if}}
-
-  {{#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>
    {{/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-title">{{localize
-          "LETHALFANTASY.Label.rollDamage"
-        }}</div>
        <div class="damage-buttons-grid {{#if weaponDamageOptions.isMonster}}monster-damage{{/if}}">
          {{#if weaponDamageOptions.isMonster}}
            <button
@@ -129,7 +187,7 @@
              data-damage-formula="{{weaponDamageOptions.damageFormula}}"
              data-damage-modifier="{{weaponDamageOptions.damageModifier}}"
              data-is-monster="true"
-            title="{{weaponDamageOptions.weaponName}}"
+              title="{{localize 'LETHALFANTASY.Label.rollDamage'}} - {{weaponDamageOptions.weaponName}}"
            >
              <i class="fa-solid fa-dice"></i>
              Damage:
@@ -138,19 +196,6 @@
              }}+{{weaponDamageOptions.damageModifier}}{{/if}}
            </button>
          {{else}}
-          {{#if weaponDamageOptions.damageS}}
-            <button
-              class="damage-roll-btn"
-              data-weapon-id="{{weaponDamageOptions.weaponId}}"
-              data-damage-type="small"
-              data-damage-formula="{{weaponDamageOptions.damageS}}"
-              data-is-monster="false"
-              title="{{localize 'LETHALFANTASY.Label.weapon-damage-small'}}"
-            >
-              <i class="fa-solid fa-dice-d6"></i>
-              {{localize "LETHALFANTASY.Label.weapon-damage-small"}}
-            </button>
-          {{/if}}
            {{#if weaponDamageOptions.damageM}}
              <button
                class="damage-roll-btn"
@@ -158,18 +203,27 @@
                data-damage-type="medium"
                data-damage-formula="{{weaponDamageOptions.damageM}}"
                data-is-monster="false"
-              title="{{localize 'LETHALFANTASY.Label.weapon-damage-medium'}}"
+                title="{{localize 'LETHALFANTASY.Label.rollDamage'}}"
              >
                <i class="fa-solid fa-dice-d20"></i>
-              {{localize "LETHALFANTASY.Label.weapon-damage-medium"}}
+                {{localize "LETHALFANTASY.Label.damage"}}
              </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">
@@ -189,5 +243,30 @@
        </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}}

 </div>
@@ -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"
@@ -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" }}
@@ -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>
@@ -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>
@@ -0,0 +1,16 @@
+<div class="control-icon lethal-luck-grit-hud" data-action="lethal-luck-grit-hud">
+  <i class="fa-solid fa-dice" title="Adjust Luck/Grit" style="width:36px;height:36px;display:flex;align-items:center;justify-content:center;font-size:18px;cursor:pointer"></i>
+
+  <div class="luck-grit-wrap luck-grit-hud-disabled">
+    <div class="luck-grit-row">
+      <span class="luck-grit-label">Luck</span>
+      <button class="luck-grit-btn" data-resource="luck" data-amount="-1">−1</button>
+      <button class="luck-grit-btn" data-resource="luck" data-amount="1">+1</button>
+    </div>
+    <div class="luck-grit-row">
+      <span class="luck-grit-label">Grit</span>
+      <button class="luck-grit-btn" data-resource="grit" data-amount="-1">−1</button>
+      <button class="luck-grit-btn" data-resource="grit" data-amount="1">+1</button>
+    </div>
+  </div>
+</div>
@@ -7,7 +7,7 @@
  {{formField systemFields.miracleType value=system.miracleType}}
  {{formField systemFields.level value=system.level}}

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


  
@@ -6,23 +6,23 @@
    <div class="biodata">

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

@@ -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>
@@ -291,13 +291,6 @@
        disabled=isPlayMode
        data-char-id="int"
      }}
-
-      {{formField
-        systemFields.characteristics.fields.int.fields.percent
-        value=system.characteristics.int.percent
-        disabled=isPlayMode
-        type="number"
-      }}
    </div>
    <div class="monster-characteristic">
      <span>{{localize "LETHALFANTASY.Label.dex"}}</span>
@@ -307,13 +300,6 @@
        disabled=isPlayMode
        data-char-id="wis"
      }}
-
-      {{formField
-        systemFields.characteristics.fields.dex.fields.percent
-        value=system.characteristics.dex.percent
-        disabled=isPlayMode
-        type="number"
-      }}
    </div>

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

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

      {{#if (eq rollType "save")}}
-        {{#if rollTarget.magicUser}}
        <div>
          <span>Save against spell (+{{rollTarget.actorModifiers.saveModifier}})
            ?</span>
@@ -129,10 +130,10 @@
            type="checkbox"
            name="saveSpellCheck"
            data-action="saveSpellCheck"
+            {{#if saveSpell}}checked{{/if}}
          />
        </div>
      {{/if}}
-      {{/if}}
    </fieldSet>
  {{/if}}

@@ -22,9 +22,9 @@
      {{formField systemFields.hascover value=system.hascover}}

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

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

-  <label>Components</label>
+  <label>{{localize "LETHALFANTASY.Label.components"}}</label>
  <div class="shift-right">
    {{formField systemFields.components.fields.verbal value=system.components.verbal}}
    {{formField systemFields.components.fields.somatic value=system.components.somatic}}
@@ -30,6 +32,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>
@@ -10,18 +10,14 @@
      {{formField systemFields.weaponType value=system.weaponType localize=true}}
      {{formField systemFields.weaponClass value=system.weaponClass localize=true}}
      
-      <label>Damage Type</label>
+      <label>{{localize "LETHALFANTASY.Label.damageType"}}</label>
      <div class="shift-right">
        {{formField systemFields.damageType.fields.typeP value=system.damageType.typeP}}
        {{formField systemFields.damageType.fields.typeB value=system.damageType.typeB}}
        {{formField systemFields.damageType.fields.typeS value=system.damageType.typeS}}
      </div>

-      <label>Damage</label>
-      <div class="shift-right">
-        {{formField systemFields.damage.fields.damageS value=system.damage.damageS}}
-        {{formField systemFields.damage.fields.damageM value=system.damage.damageM}}
-      </div>
+      {{formField systemFields.damage.fields.damageM value=system.damage.damageM label=(localize "LETHALFANTASY.Label.damage")}}

      {{formField systemFields.applyStrengthDamageBonus value=system.applyStrengthDamageBonus localize=true}}
    
@@ -34,7 +30,7 @@
       {{/if}}

      {{#if (eq system.weaponType "ranged")}}
-        <label>Speed</label>
+        <label>{{localize "LETHALFANTASY.Label.speed"}}</label>
        <div class="shift-right">
          {{formField systemFields.speed.fields.simpleAim value=system.speed.simpleAim}}
          {{formField systemFields.speed.fields.carefulAim value=system.speed.carefulAim}}
@@ -47,7 +43,7 @@

        {{formField systemFields.defense value=system.defense}}

-        <label>Range</label>
+        <label>{{localize "LETHALFANTASY.Label.range"}}</label>
        <div class="shift-right">
          {{formField systemFields.weaponRange.fields.pointBlank value=system.weaponRange.pointBlank}}
          {{formField systemFields.weaponRange.fields.short value=system.weaponRange.short}}
@@ -60,7 +56,7 @@

      {{formField systemFields.equipped value=system.equipped}}

-      <label>Bonuses</label>
+      <label>{{localize "LETHALFANTASY.Label.bonuses"}}</label>
      <div class="shift-right">
        {{formField systemFields.bonuses.fields.attackBonus value=system.bonuses.attackBonus}}
        {{formField systemFields.bonuses.fields.defenseBonus value=system.bonuses.defenseBonus}}
@@ -0,0 +1,2 @@
+import { CompendiumsManager } from './CompendiumsManager.mjs';
+CompendiumsManager.packToDistDir('packs_src', 'packs-system');
@@ -0,0 +1,2 @@
+import { CompendiumsManager } from './CompendiumsManager.mjs';
+CompendiumsManager.unpackToSrcDir('packs_src', 'packs-system');
Author	SHA1	Message	Date
uberwald	3b0d4e032e	fix: cache results.length before explosion loop to prevent double-count Release Creation / build (release) Successful in 50s Details Pushing explosion dice to DieTerm.results made the for loop condition (j < results.length) grow mid-iteration, re-processing the explosion result as a normal die. This produced spurious entries like `1D6 → 4` alongside the correct `1D6-1 → 3`. Fixes prompt() (for loop) and rollSpellDamageToMessage() (for...of) by caching result count / snapshotting the array before iterating.	2026-06-16 19:34:13 +02:00
uberwald	539841c4ff	fix: push explosion dice to DieTerm results so DSN displays them Explosion rolls were evaluated as separate Roll instances but never added to the original DieTerm's results array. Dice So Nice reads DieTerm.results to render 3D dice, so explosions were invisible. Now each explosion result is pushed into the DieTerm's results array ({result, active:true}), letting DSN render explosion dice in the correct chronological order alongside the main die. Applies to prompt(), promptRangedDefense(), promptRangedAttack(), and rollSpellDamageToMessage().	2026-06-16 19:29:07 +02:00
uberwald	ffba37b59e	Fix D30 management, again	2026-06-14 23:00:39 +02:00
uberwald	1a7585e1f6	fix: merge saving_throws D30 table into arcane_spell_defense Release Creation / build (release) Successful in 49s Details saving_throws was redundant — all saves in this system are vs spells. Removed SAVING_THROWS constant; all save rollType lookups use ARCANE_SPELL_DEFENSE. D30=1 arcane_spell_defense blank (no special result). Added miracle types to ARCANE_SPELL_ATTACK mapping so they get D30 results instead of null.	2026-06-14 22:57:41 +02:00
uberwald	b567c8bbea	Fix D30 management, again Release Creation / build (release) Successful in 48s Details	2026-06-13 23:15:22 +02:00
uberwald	60b351f50d	Fix spell save/defense again Release Creation / build (release) Successful in 45s Details	2026-06-13 21:06:18 +02:00
uberwald	ace726a1fc	fix: use try/finally for spellDefense cleanup instead of delete Release Creation / build (release) Successful in 47s Details delete on game.lethalFantasy.spellDefense was breaking roll flow on Foundry's proxied game object. Use try/finally with assignment to false instead, which is safe on any object type. Initialize saveSpell local var from one-shot flag so D30 chart lookup correctly uses arcane_spell_defense for spell saves without requiring user to click the pre-checked checkbox.	2026-06-13 16:51:52 +02:00
uberwald	67499bc199	fix: add missing arcane_spell_defense entry for D30=1 Release Creation / build (release) Successful in 49s Details User spec lists D30=1 as 'Possible Spell Calamity or Catastrophe' for Arcane Spell Defense but it was missing from the table.	2026-06-13 16:29:54 +02:00
uberwald	7eae95cbbd	fix: use arcane spell defense D30 chart for spell saves Release Creation / build (release) Successful in 43s Details Bug: saveSpell local var initialized to false (line 142), while dialog checkbox was pre-checked via dialogContext.saveSpell = game.lethalFantasy.spellDefense. If user didn't click the checkbox, D30 call used SAVING_THROWS chart instead of ARCANE_SPELL_DEFENSE. Also: game.lethalFantasy.spellDefense was set true before spell defense rolls but never cleared, leaking to subsequent non-spell saves. Fix: initialize saveSpell from the one-shot flag and delete it immediately. Dialog context now uses the local saveSpell variable instead of re-reading the deleted flag.	2026-06-13 15:22:34 +02:00
uberwald	1b53bf9152	fix: resolve hud actor from hud.token not render context param Release Creation / build (release) Successful in 41s Details V2 renderTokenHUD passes (hud, html, data) where data is a render context object — not a TokenDocument. data.actor was undefined, and data?.token?.actor was also undefined. Use hud.token.actor (or hud.object.actor) instead, which is the real PlaceableObject with proper actor resolution. Also fix html.find() → html.querySelector() for V2 HTMLElement.	2026-06-12 19:01:54 +02:00
uberwald	2570bf707e	fix: prevent duplicate cross-client defense dialog, clear bleed on heal - Only send attackBoosted socket when attackerHandledBonus \|\| attackerHasNonGMOwner (GM→player: hook handles it, no socket needed; PC→PC: socket needed) - Clear bleeding wounds when HP restored via token HUD heal buttons	2026-06-12 17:23:39 +02:00
uberwald	cbeaaeec99	Final fixes and code review checks Release Creation / build (release) Successful in 39s Details	2026-06-12 08:19:42 +02:00
uberwald	37badf2619	fix: attack/defense cross-client reaction flow - C1: Stop D30 auto-roll on non-primary clients (caused divergence) - C2: defenderOwner fallback to GM for monster defenders - C3: Fix tie outcome in handleAttackBoosted (>= not >) - C5: Convert handleAttackBoosted to while-loop (multi-reaction) - C4/C6: shouldCreateMessage cross-client guard - M2: Coordinate main flow defender dialog vs socket handler - M3: Fresh grit/luck reads each socket handler iteration - M4: Include defenseD30message in socket payload + re-process - M5: Communicate attackerHandledBonus in socket payload - i18n: Add missing COMBAT.* keys, fix weapon.hbs label localize - d30_results_tables: Fix string typo	2026-06-12 02:51:59 +02:00
uberwald	5839616863	chore: add pushLDBtoYML/pullYMLtoLDB scripts, gitignore packs_src	2026-06-12 01:56:19 +02:00
uberwald	89298490ef	fix: pre-check 'Save against spell' checkbox in template when saveSpell is true	2026-06-12 01:56:03 +02:00
uberwald	bb42de19bd	REmove unused file	2026-06-11 23:05:55 +02:00
uberwald	53f9c33419	chore: gitignore LevelDB internal files, stop tracking auto-generated LDB bookkeeping Release Creation / build (release) Successful in 46s Details	2026-06-11 23:00:45 +02:00
uberwald	06eba5f835	fix: show spell tier dialog on character sheet cast; duplicate rollTarget to prevent Item mutation	2026-06-11 22:56:54 +02:00
uberwald	46fa2d15a3	fix: allow defender to react when attacker boosts past defense via cross-client socket	2026-06-11 22:41:54 +02:00
uberwald	8aae7bada0	fix: pre-check 'Save against spell' checkbox when defense originates from spell attack	2026-06-11 22:17:37 +02:00
uberwald	ceb62bca3f	fix: add missing class lethal-luck-grit-hud to template so JS selector matches	2026-06-11 22:03:56 +02:00
uberwald	110ac65ba5	fix: replace hardcoded French bleeding notifications with i18n keys	2026-06-11 21:50:19 +02:00
uberwald	9b75fd4d96	feat: combat-tracker-driven bleeding (HP loss per wound per round)	2026-06-11 21:49:35 +02:00
uberwald	141d6048e0	Fix triple damage issue	2026-06-11 21:32:26 +02:00
uberwald	ea7acf6bf8	Fix hp < 0 and D30 with D20 bonus roll	2026-06-11 20:48:46 +02:00
uberwald	c20750caa7	Minor fixes regarding rolls and chat messages Release Creation / build (release) Successful in 48s Details	2026-06-10 20:17:45 +02:00
uberwald	ce630feb51	feat: D30 combat effects, spell tiers, small damage removal, token HUD luck/grit - Replace Knockback with Internal Injury on D30 (5, 10, 15); remove Shield Bash from D30 counter-attacks - Eliminate small weapon damage: keep only medium damage labelled Damage in sheets, rolls, and chat - D30 bonus dice (20, 27, 30) auto-resolved before grit/luck/shield decisions; choice dialogs for special strikes - D30 combat effects: bleeding wounds, damage ×2/×3 before DR, DR ×2/×3 with component picker dialog - Add hp.wounds to monster schema for bleeding support - Show Save against spell? checkbox for all save rolls (not just magic users) - Fix mulligan restart: persistent D30 process flags prevent double-application and allow both sides to react - For Dice So Nice, show main roll animation before explosion dice for correct ordering - Spell tier selection: force Standard/Overpowered choice at cast time, tier-specific aether cost, only chosen damage button shown - Add +1/−1 luck and grit controls to Token HUD - Fix inconsistent indentation, remove duplicate i18n key, remove unused includesShield return	2026-06-10 07:53:51 +02:00
uberwald	b35b684d50	NEgative values for HP and weapon bonuses	2026-06-06 16:11:36 +02:00
uberwald	f6fb0b68b8	Fix spell rolls again Release Creation / build (release) Successful in 47s Details	2026-05-25 20:41:00 +02:00
uberwald	e45edd60c4	FIx spell order and dual rollll for spell damages Release Creation / build (release) Successful in 1m6s Details	2026-05-25 12:29:39 +02:00
uberwald	d389a85a9f	Fix ranged attacks again Release Creation / build (release) Successful in 43s Details	2026-05-24 09:42:07 +02:00
uberwald	c217490a5b	Fix ranged attacks again Release Creation / build (release) Has been cancelled Details	2026-05-24 09:41:06 +02:00
uberwald	38eb1a8d3d	Add ranged actions for monsters Release Creation / build (release) Successful in 54s Details	2026-05-23 19:10:10 +02:00
uberwald	4724cdf2bb	VArious fixes for rolls and ranged attacks Release Creation / build (release) Successful in 44s Details	2026-05-23 09:08:16 +02:00
uberwald	6d06c8ddad	Various fixes for spell and ranged attacks	2026-05-23 00:21:05 +02:00
uberwald	2770774aa3	Various fixes for spell and ranged attacks	2026-05-23 00:11:58 +02:00
uberwald	e417b61625	Spells fixe Release Creation / build (release) Successful in 46s Details	2026-05-20 23:17:07 +02:00
uberwald	9a8d580ef6	Other fixes for damage buttons from chat Release Creation / build (release) Successful in 53s Details	2026-05-20 10:53:46 +02:00
uberwald	9ccb0f90f0	Other fixes for damage buttons from chat	2026-05-20 10:53:22 +02:00
uberwald	6cf0880ad3	Enhance spell damage and messages content Release Creation / build (release) Successful in 44s Details	2026-05-19 10:52:03 +02:00
uberwald	96306623e5	UPdate and fixes for roll in combats Release Creation / build (release) Successful in 43s Details	2026-05-18 20:26:39 +02:00
uberwald	7279cd752d	Fix initiative again Release Creation / build (release) Successful in 43s Details	2026-05-18 07:58:28 +02:00
uberwald	db3e8b5d35	Improve init for monsters and some fixwes around shields Release Creation / build (release) Successful in 48s Details	2026-05-17 13:22:29 +02:00
uberwald	54421e4a83	MAnage spell/miracle spending points and favor/disfavor for shield rolls Release Creation / build (release) Successful in 43s Details	2026-05-10 17:49:53 +02:00
uberwald	ac44419b7a	Corredction sur attack ranged	2026-05-03 15:12:25 +02:00
uberwald	a3fc0a42b9	Corredction sur attack ranged Release Creation / build (release) Successful in 1m19s Details	2026-05-03 10:06:44 +02:00
uberwald	c8ce840e98	Fix ranged defense + HTH attacks Release Creation / build (release) Successful in 1m17s Details	2026-05-02 08:35:22 +02:00
uberwald	55a040062a	Fix ranged defense + HTH attacks Release Creation / build (release) Successful in 1m19s Details	2026-05-01 23:55:29 +02:00
uberwald	1818a76499	Fix ranged defense + HTH attacks Release Creation / build (release) Successful in 1m19s Details	2026-05-01 23:34:05 +02:00
uberwald	55d1b41ca4	Fix ranged defense + HTH attacks	2026-05-01 23:32:53 +02:00
uberwald	841ed82277	Fix for ranged monsters attack Release Creation / build (release) Successful in 1m2s Details	2026-05-01 01:12:56 +02:00
uberwald	968d156d09	Upgrade to r14 Release Creation / build (release) Successful in 48s Details	2026-04-30 14:38:56 +02:00
uberwald	59ff098fca	Add ranged attacks for monsters	2026-04-29 20:27:20 +02:00
uberwald	b8174d5e22	Fix E dice in dice Tray Release Creation / build (release) Successful in 55s Details	2026-04-17 23:21:49 +02:00
uberwald	7f15450566	Add specific diceTray and enhance message styles Release Creation / build (release) Successful in 49s Details	2026-04-17 17:32:46 +02:00
uberwald	28fdaff2ec	Add specific diceTray and enhance message styles	2026-04-17 17:32:32 +02:00
uberwald	81584ed5d6	Update D30 descriptions and add simple shield option for NPCs	2026-04-16 23:42:24 +02:00
uberwald	8c9a13faf1	Fixes around D30 managemen	2026-04-16 21:39:51 +02:00
uberwald	6c6c473147	Fixes regarding shields usage and spells Release Creation / build (release) Successful in 52s Details	2026-04-14 21:31:17 +02:00
uberwald	2e2a917a45	Fixes regarding shields usage and spells	2026-04-14 21:31:03 +02:00
uberwald	343abc32e2	FIx init à 1 again Release Creation / build (release) Successful in 50s Details	2026-04-12 11:08:19 +02:00
uberwald	c37d92af25	Various initiative fixes + shield management messages Release Creation / build (release) Successful in 46s Details	2026-04-12 01:07:58 +02:00
uberwald	42945d33db	ATtempt to fix init rolls Release Creation / build (release) Successful in 52s Details	2026-04-07 20:44:13 +02:00
uberwald	1bf88bac06	ATtempt to fix init rolls	2026-04-07 20:43:15 +02:00
uberwald	3ad5681539	Fix inititiative rolls Release Creation / build (release) Successful in 52s Details	2026-04-06 00:02:14 +02:00
uberwald	df6f8e5710	Add token HUD +HP Release Creation / build (release) Successful in 1m37s Details	2026-02-06 22:20:20 +01:00
uberwald	52877e3a68	New combat management and various improvments Release Creation / build (release) Successful in 48s Details	2026-01-19 23:22:32 +01:00
				`@@ -0,0 +1 @@`
				`packs/** filter=lfs diff=lfs merge=lfs -text`