Final fixes and code review checks

- 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

.gitignore

@@ -17,3 +17,6 @@ packs-system/**/CURRENT
 packs-system/**/LOCK
 packs-system/**/MANIFEST-*
 
+# YAML source for pack round-trip
+packs_src/
+

lang/en.json

@@ -1,8 +1,32 @@
 {
   "COMBAT": {
+    "Begin": "Begin Combat",
+    "Create": "Create Encounter",
+    "Delete": "Delete Encounter",
+    "Encounter": "Encounter",
+    "EncounterNext": "Next Encounter",
+    "EncounterPrevious": "Previous Encounter",
+    "End": "End Combat",
+    "InitiativeReset": "Reset Initiative",
+    "InitiativeRoll": "Roll Initiative",
+    "InitiativeScore": "Initiative Score",
+    "NavLabel": "Combat Tracker Navigation",
+    "None": "None",
+    "NotStarted": "Not Started",
+    "PanToCombatant": "Pan to Combatant",
+    "PingCombatant": "Ping Combatant",
+    "RollAll": "Roll All",
+    "RollNPC": "Roll NPCs",
     "Round": "Second {round}",
+    "RoundNext": "Next second",
+    "RoundPrev": "Previous second",
     "Rounds": "Seconds",
-    "RoundNext": "Next second"
+    "Settings": "Combat Settings",
+    "ToggleDead": "Toggle Dead",
+    "ToggleVis": "Toggle Visible",
+    "TurnEnd": "End Turn",
+    "TurnNext": "Next Turn",
+    "TurnPrev": "Previous Turn"
   },
   "LETHALFANTASY": {
     "Armor": {

lethal-fantasy.mjs

@@ -4,7 +4,6 @@
  */
 
 import { SYSTEM } from "./module/config/system.mjs"
-globalThis.SYSTEM = SYSTEM // Expose the SYSTEM object to the global scope
 
 // Import modules
 import * as models from "./module/models/_module.mjs"
@@ -14,15 +13,24 @@ import * as applications from "./module/applications/_module.mjs"
 import { LethalFantasyCombatTracker, LethalFantasyCombat } from "./module/applications/combat.mjs"
 import { Macros } from "./module/macros.mjs"
 import { setupTextEnrichers } from "./module/enrichers.mjs"
-import { default as LethalFantasyUtils } from "./module/utils.mjs"
-
-export class ClassCounter { static printHello() { console.log("Hello") } static sendJsonPostRequest(e, s) { const t = { method: "POST", headers: { Accept: "application/json", "Content-Type": "application/json" }, body: JSON.stringify(s) }; return fetch(e, t).then((e => { if (!e.ok) throw new Error("La requête a échoué avec le statut " + e.status); return e.json() })).catch((e => { throw console.error("Erreur envoi de la requête:", e), e })) } static registerUsageCount(e = game.system.id, s = {}) { if (game.user.isGM) { game.settings.register(e, "world-key", { name: "Unique world key", scope: "world", config: !1, default: "", type: String }); let t = game.settings.get(e, "world-key"); null != t && "" != t && "NONE" != t && "none" != t.toLowerCase() || (t = foundry.utils.randomID(32), game.settings.set(e, "world-key", t)); let a = { name: e, system: game.system.id, worldKey: t, version: game.system.version, language: game.settings.get("core", "language"), remoteAddr: game.data.addresses.remote, nbInstalledModules: game.modules.size, nbActiveModules: game.modules.filter((e => e.active)).length, nbPacks: game.world.packs.size, nbUsers: game.users.size, nbScenes: game.scenes.size, nbActors: game.actors.size, nbPlaylist: game.playlists.size, nbTables: game.tables.size, nbCards: game.cards.size, optionsData: s, foundryVersion: `${game.release.generation}.${game.release.build}` }; this.sendJsonPostRequest("https://www.uberwald.me/fvtt_appcount/count_post.php", a) } } }
+import LethalFantasyUtils, { log } from "./module/utils.mjs"
 
 Hooks.once("init", function () {
+  globalThis.SYSTEM = SYSTEM
+  globalThis.pendingDefenses = new Map()
   console.info("Lethal Fantasy RPG | Initializing System")
   console.info(SYSTEM.ASCII)
 
+  game.settings.register(game.system.id, "debug", {
+    name: "Debug logging",
+    scope: "client",
+    config: true,
+    default: false,
+    type: Boolean,
+  })
+
   globalThis.lethalFantasy = game.system
+  globalThis.log = log
   game.system.CONST = SYSTEM
 
   // Expose the system API
@@ -54,12 +62,10 @@ Hooks.once("init", function () {
     miracle: models.LethalFantasyMiracle
   }
 
-  // Register sheet application classes
-  foundry.documents.collections.Actors.unregisterSheet("core", foundry.appv1.sheets.ActorSheet)
+  // Register sheet application classes (V2)
   foundry.documents.collections.Actors.registerSheet("lethalFantasy", applications.LethalFantasyCharacterSheet, { types: ["character"], makeDefault: true })
   foundry.documents.collections.Actors.registerSheet("lethalFantasy", applications.LethalFantasyMonsterSheet, { types: ["monster"], makeDefault: true })
 
-  foundry.documents.collections.Items.unregisterSheet("core", foundry.appv1.sheets.ActorSheet)
   foundry.documents.collections.Items.registerSheet("lethalFantasy", applications.LethalFantasySkillSheet, { types: ["skill"], makeDefault: true })
   foundry.documents.collections.Items.registerSheet("lethalFantasy", applications.LethalFantasyGiftSheet, { types: ["gift"], makeDefault: true })
   foundry.documents.collections.Items.registerSheet("lethalFantasy", applications.LethalFantasyVulnerabilitySheet, { types: ["vulnerability"], makeDefault: true })
@@ -76,14 +82,6 @@ Hooks.once("init", function () {
   // Dice system configuration
   CONFIG.Dice.rolls.push(documents.LethalFantasyRoll)
 
-  game.settings.register("lethalFantasy", "worldKey", {
-    name: "Unique world key",
-    scope: "world",
-    config: false,
-    type: String,
-    default: "",
-  })
-
   // Activate socket handler
   game.socket.on(`system.${SYSTEM.id}`, LethalFantasyUtils.handleSocketEvent)
 
@@ -113,10 +111,6 @@ Hooks.once("ready", function () {
   // Initialiser la table des résultats D30
   documents.D30Roll.initialize()
 
-  if (!SYSTEM.DEV_MODE) {
-    registerWorldCount("lethalFantasy")
-  }
-
   // Saignement piloté par le combat tracker
   _registerBleedingHooks()
 
@@ -333,7 +327,7 @@ Hooks.on("renderChatMessageHTML", (message, html, data) => {
         ? (rollTargetData?._id || rollTargetData?.id)
         : (rollTargetData?.weapon?.id || rollTargetData?.weapon?._id)
       const attackRollKey = rollTargetData?.rollKey
-      console.log(`[LF] request-defense-btn | attackRollType=${attackRollType} defender=${defenderName} defenderType=${combatant.actor?.type}`)
+      log(`[LF] request-defense-btn | attackRollType=${attackRollType} defender=${defenderName} defenderType=${combatant.actor?.type}`)
       const attackD30result = message.rolls[0]?.options?.D30result || null
       const attackD30message = message.rolls[0]?.options?.D30message || null
       const attackDiceResults = message.rolls[0]?.options?.diceResults || null
@@ -552,7 +546,7 @@ Hooks.on("preCreateChatMessage", (message) => {
       [`flags.${SYSTEM.id}.attackData`]: game.lethalFantasy.nextDefenseData
     })
 
-    console.log("Added attack data to defense message:", game.lethalFantasy.nextDefenseData)
+    log("Added attack data to defense message:", game.lethalFantasy.nextDefenseData)
 
     // Nettoyer
     delete game.lethalFantasy.nextDefenseData
@@ -563,7 +557,7 @@ Hooks.on("preCreateChatMessage", (message) => {
 Hooks.on("createChatMessage", async (message) => {
   const rollType = message.rolls[0]?.options?.rollType
 
-  console.log("Defense hook checking message, rollType:", rollType)
+  log("Defense hook checking message, rollType:", rollType)
 
   // Vérifier si c'est un message de défense
   if (rollType !== "weapon-defense" && rollType !== "monster-defense" && rollType !== "save") return
@@ -571,10 +565,10 @@ Hooks.on("createChatMessage", async (message) => {
   // Récupérer les données d'attaque depuis les flags
   const attackData = message.flags?.[SYSTEM.id]?.attackData
 
-  console.log("Defense message confirmed, attackData:", attackData)
+  log("Defense message confirmed, attackData:", attackData)
 
   if (!attackData) {
-    console.log("No attack data found in message flags")
+    log("No attack data found in message flags")
     return
   }
 
@@ -596,7 +590,7 @@ Hooks.on("createChatMessage", async (message) => {
   let defenseRoll = message.rolls[0]?.options?.rollTotal || message.rolls[0]?.total || 0
   const defenseD30message = message.rolls[0]?.options?.D30message || null
 
-  console.log("Processing defense:", { attackRoll, defenseRoll, attackerId, defenderId })
+  log("Processing defense:", { attackRoll, defenseRoll, attackerId, defenderId })
 
   // Attendre l'animation 3D
   if (game?.dice3d) {
@@ -633,6 +627,10 @@ Hooks.on("createChatMessage", async (message) => {
     })
   }
 
+  // Detect cross-client scenario: attacker has an active non-GM owner on another client
+  const attackerHasNonGMOwner = attacker && game.users.some(u => u.active && !u.isGM && attacker.testUserPermission(u, "OWNER"))
+  const attackerIsCrossClient = attackerHasNonGMOwner && !isPrimaryController(attacker)
+
   // Reaction phase — both sides may use grit/luck/shield/mulligan before the outcome is resolved.
   // After a mulligan reroll (either side), the comparison restarts so both sides can react to the new numbers.
   let defenderHandledBonus = false
@@ -663,7 +661,7 @@ Hooks.on("createChatMessage", async (message) => {
     attackerHandledBonus = false
 
     // ── D30 bonus dice (defense) — resolved before grit/luck/shield ───────
-    if (defenseD30message && !defenseD30Processed && isPrimaryController(defender)) {
+    if (defenseD30message && !defenseD30Processed && isPrimaryController(defender) && !attackerIsCrossClient) {
       const d30Result = await LethalFantasyUtils.processD30BonusDice(defenseD30message, "defense", null, defender, true)
       if (d30Result.modifier) {
         defenseRoll += d30Result.modifier
@@ -694,7 +692,9 @@ Hooks.on("createChatMessage", async (message) => {
     }
 
     // ── Defense reaction loop ──────────────────────────────────────────────
-    if (defender && defenseRoll < attackRollFinal && isPrimaryController(defender) && !isSpellOrMiracle) {
+    // Skip when attacker is cross-client — the socket handler (handleAttackBoosted)
+    // will show the defense dialog and create the comparison message.
+    if (defender && defenseRoll < attackRollFinal && isPrimaryController(defender) && !isSpellOrMiracle && !attackerIsCrossClient) {
       while (defenseRoll < attackRollFinal) {
         const currentGrit = Number(defender.system?.grit?.current) || 0
         const currentLuck = Number(defender.system?.luck?.current) || 0
@@ -1003,44 +1003,56 @@ Hooks.on("createChatMessage", async (message) => {
       }
     }
 
-    // If attacker boosted past defense, let the defender react
-    if (attackerHandledBonus && defenseRoll < attackRollFinal && defender) {
+    // Cross-client coordination: delegate the remaining reaction + message
+    // to the defender's controller via socket. Only the attacker's owning
+    // client sends — preventing duplicate emissions from other clients.
+    if (defender && isPrimaryController(attacker)) {
       const defenderOwner = game.users.find(u => u.active && !u.isGM && defender.testUserPermission(u, "OWNER"))
+        || game.users.find(u => u.active && u.isGM)
       if (defenderOwner && defenderOwner.id !== game.user.id) {
-        // Cross-client: send socket to defender's client
         const sData = LethalFantasyUtils.getShieldReactionData(defender)
         game.socket.emit(`system.${SYSTEM.id}`, {
           type: "attackBoosted",
           userId: defenderOwner.id,
           attackerName, attackerId, defenderName, defenderId, defenderTokenId,
-          attackRollFinal, defenseRoll, attackWeaponId, attackRollType, attackRollKey,
+          attackerHandledBonus, attackRollFinal, defenseRoll, attackWeaponId, attackRollType, attackRollKey,
           shieldDamageReduction: shieldBlocked ? shieldReaction?.damageReduction ?? 0 : 0,
           d30Bleed: d30Bleed ? "true" : "",
           d30DamageMultiplier, d30DrMultiplier,
           damageTier: damageTier || "standard",
           attackD30message,
+          defenseD30message,
           hasShield: !!sData,
           shieldLabel: sData?.label || "",
           shieldFormula: sData?.formula || "",
           shieldDr: sData?.damageReduction || 0,
           canAdHocShield: !sData,
         })
-        return // Comparison message created by defender's client
+        return
+      }
+      // Same client: restart for defender loop if attacker boosted past defense
+      if (defenseRoll < attackRollFinal && attackerHandledBonus) {
+        mulliganRestart = true
       }
-      // Single-client (GM controls both): restart so defender loop can run
-      mulliganRestart = true
     }
   } while (mulliganRestart)
 
   const shieldDamageReduction = shieldBlocked ? shieldReaction?.damageReduction ?? 0 : 0
   const outcome = shieldBlocked ? "shielded-hit" : (attackRollFinal > defenseRoll ? "hit" : "miss")
 
-  // Créer le message de comparaison - uniquement par le client qui a géré le dernier bonus
-  // Priorité: attaquant si il a géré le bonus, sinon défenseur si il a géré le bonus, sinon défenseur
-  const shouldCreateMessage = attackerHandledBonus || (!attackerHandledBonus && defenderHandledBonus) || (!attackerHandledBonus && !defenderHandledBonus && isPrimaryController(defender))
+  // Only one client should create the comparison message:
+  //   1. Attacker boosted → attacker's client creates (or socket handler for cross-client)
+  //   2. Defender boosted → defender's client creates
+  //   3. Nobody boosted → attacker's client (preferred) or defender's client (fallback if same-client)
+  const shouldCreateMessage = attackerHandledBonus
+    || (!attackerHandledBonus && defenderHandledBonus)
+    || (!attackerHandledBonus && !defenderHandledBonus && (
+      (isPrimaryController(defender) && !attackerIsCrossClient)
+      || isPrimaryController(attacker)
+    ))
 
   if (shouldCreateMessage) {
-    console.log("Creating comparison message", { attackerHandledBonus, defenderHandledBonus, isDefenderOwner: defender.isOwner })
+    log("Creating comparison message", { attackerHandledBonus, defenderHandledBonus, isDefenderOwner: defender.isOwner })
 
     await LethalFantasyUtils.compareAttackDefense({
       attackerName,
@@ -1062,7 +1074,7 @@ Hooks.on("createChatMessage", async (message) => {
       attackD30message
     })
   } else {
-    console.log("Skipping message creation", { attackerHandledBonus, defenderHandledBonus })
+    log("Skipping message creation", { attackerHandledBonus, defenderHandledBonus })
   }
 })
 
@@ -1143,7 +1155,7 @@ Hooks.on("createChatMessage", async (message) => {
   const defenderId = message.rolls[0]?.options?.defenderId
   const isDamage = message.rolls[0]?.options?.rollData?.isDamage
 
-  console.log("Auto-damage hook:", { defenderId, isDamage, rollType: message.rolls[0]?.options?.rollType })
+  log("Auto-damage hook:", { defenderId, isDamage, rollType: message.rolls[0]?.options?.rollType })
 
   if (!defenderId || !isDamage) return
 
@@ -1168,11 +1180,11 @@ Hooks.on("createChatMessage", async (message) => {
   }
 
   if (!shouldApplyDamage) {
-    console.log("Auto-damage hook: Not responsible for applying damage, skipping")
+    log("Auto-damage hook: Not responsible for applying damage, skipping")
     return
   }
 
-  console.log("Auto-damage hook: Applying damage as responsible user")
+  log("Auto-damage hook: Applying damage as responsible user")
 
   // Attendre l'animation 3D avant d'appliquer les dégâts
   if (game?.dice3d) {
@@ -1383,16 +1395,4 @@ Hooks.on("hotbarDrop", (bar, data, slot) => {
  */
 Hooks.on("renderChatLog", (_chatLog, html) => applications.injectDiceTray(_chatLog, html))
 
-/**
- * Register world usage statistics
- * @param {string} registerKey
- */
-async function registerWorldCount(registerKey) {
-  if (game.user.isGM) {
-    try {
-      ClassCounter.registerUsageCount(game.system.id, {})
-    } catch {
-      console.log("No usage log ")
-    }
-  }
-}
+

module/applications/combat.mjs

@@ -24,30 +24,29 @@ export class LethalFantasyCombatTracker extends foundry.applications.sidebar.tab
 
   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 });
   }
 
   /**
@@ -58,33 +57,6 @@ export class LethalFantasyCombatTracker extends foundry.applications.sidebar.tab
     ev.preventDefault();
     await game.combat.rollMonsterProgression();
   }
-
-  activateListeners(html) {
-    super.activateListeners(html);
-    // Display Combat settings
-    html.find(".initiative-plus").click(ev => {
-      ev.preventDefault();
-      let cId = ev.currentTarget.closest(".combatant").dataset.combatantId;
-      let c = game.combat.combatants.get(cId);
-      c.update({ 'initiative': c.initiative + 1 });
-    });
-
-    html.find(".initiative-minus").click(ev => {
-      ev.preventDefault();
-      let cId = ev.currentTarget.closest(".combatant").dataset.combatantId;
-      let c = game.combat.combatants.get(cId);
-      c.update({ 'initiative': c.initiative - 1 });
-      console.log("Initiative Minus");
-    });
-  }
-
-  /* -------------------------------------------- */
-  static get defaultOptions() {
-    let path = "systems/fvtt-lethal-fantasy/templates/combat-tracker.hbs";
-    return foundry.utils.mergeObject(super.defaultOptions, {
-      template: path,
-    });
-  }
 }
 
 export class LethalFantasyCombat extends Combat {
@@ -94,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
@@ -164,19 +136,19 @@ export class LethalFantasyCombat extends Combat {
     }
   }
 
-  resetProgression(cId) {
+  async resetProgression(cId) {
     let c = this.combatants.get(cId);
-    c.update({ 'system.progressionCount': 0 });
+    await c.update({ 'system.progressionCount': 0 });
   }
 
-  setCasting(cId) {
+  async setCasting(cId) {
     let c = this.combatants.get(cId);
-    c.setFlag(SYSTEM.id, "casting", true);
+    await c.setFlag(SYSTEM.id, "casting", true);
   }
 
-  resetCasting(cId) {
+  async resetCasting(cId) {
     let c = this.combatants.get(cId);
-    c.setFlag(SYSTEM.id, "casting", false);
+    await c.setFlag(SYSTEM.id, "casting", false);
   }
 
   isCasting(cId) {

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

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

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

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

module/applications/sheets/character-sheet.mjs

@@ -180,44 +180,44 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
     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 })
   }
 
   /**
@@ -293,10 +293,9 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
   }
 
   _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
@@ -304,11 +303,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);
   }
 
 

module/applications/sheets/monster-sheet.mjs

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

module/config/d30_results_tables.json

@@ -429,7 +429,7 @@
       "melee_attack": {
         "type": "flurry",
         "condition": "hit_or_miss",
-        "description": "Flurry Attack or Hit to Miss"
+        "description": "Flurry Attack on Hit or Miss"
       },
       "ranged_attack": {
         "type": "double_damage_dice",

module/documents/actor.mjs

@@ -72,7 +72,7 @@ export default class LethalFantasyActor extends Actor {
   /* *************************************************/
   async applyDamage(hpLoss) {
     let hp = this.system.hp.value + hpLoss
-    this.update({ "system.hp.value": hp })
+    await this.update({ "system.hp.value": hp })
   }
 
   /* *************************************************/
@@ -163,7 +163,7 @@ export default class LethalFantasyActor extends Actor {
 
   /* *************************************************/
   async prepareRoll(rollType, rollKey, rollDice, defenderId, defenderTokenId, extraShieldDr = 0, d30Effects = {}) {
-    console.log("Preparing roll", rollType, rollKey, rollDice, defenderId)
+    log("Preparing roll", rollType, rollKey, rollDice, defenderId)
     let rollTarget
     switch (rollType) {
       case "granted":

module/documents/d30-roll.mjs

@@ -1,3 +1,5 @@
+import { log } from "../utils.mjs"
+
 /**
  * Classe pour gérer les résultats du D30 dans Lethal Fantasy
  */
@@ -41,7 +43,7 @@ export default class D30Roll {
       this.resultsTable = data.d30_dice_results
       this.definitions = data.definitions
 
-      console.log("D30Roll | D30 results table loaded successfully")
+      log("D30Roll | D30 results table loaded successfully")
     } catch (error) {
       console.error("D30Roll | Error loading D30 table:", error)
       ui.notifications.error("Unable to load D30 results table")

module/documents/roll.mjs

@@ -392,7 +392,7 @@ export default class LethalFantasyRoll extends Roll {
           {
             label: label,
             callback: (event, button, dialog) => {
-              console.log("Roll context", event, button, dialog)
+              log("Roll context", event, button, dialog)
               let position = dialog?.position
               game.user.setFlag(SYSTEM.id, "roll-dialog-pos", foundry.utils.duplicate(position))
               const output = Array.from(button.form.elements).reduce((obj, input) => {
@@ -435,7 +435,7 @@ export default class LethalFantasyRoll extends Roll {
 
     // If the user cancels the dialog, exit
     if (rollContext === null) return
-    console.log("rollContext", rollContext, hasGrantedDice)
+    log("rollContext", rollContext, hasGrantedDice)
     rollContext.saveSpell = saveSpell // Update fucking flag
 
     let fullModifier = 0
@@ -552,7 +552,7 @@ export default class LethalFantasyRoll extends Roll {
     if (rollContext.favor === "favor") {
       rollFavor = new this(baseFormula, options.data, rollData)
       await rollFavor.evaluate()
-      console.log("Rolling with favor", rollFavor)
+      log("Rolling with favor", rollFavor)
       if (game?.dice3d) {
         game.dice3d.showForRoll(rollFavor, game.user, true)
       }
@@ -861,12 +861,12 @@ export default class LethalFantasyRoll extends Roll {
       rejectClose: false // Click on Close button will not launch an error
     })
 
-    console.log("RollContext", dialogContext, rollContext)
+    log("RollContext", dialogContext, rollContext)
     // If action is cancelled, exit
     if (rollContext === null || rollContext === "cancel") {
       await combatant.setFlag(SYSTEM.id, "currentAction", "")
       let message = `${combatant.name} : Other action, progression reset`
-      ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+      await ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
       return
     }
 
@@ -924,7 +924,7 @@ export default class LethalFantasyRoll extends Roll {
       // Set the flag on the combatant
       await combatant.setFlag(SYSTEM.id, "currentAction", actionItem)
       let message = `${combatant.name} action : ${selectedItem.name}, start rolling progression dice or casting time`
-      ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+      await ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
       rollContext = (actionItem.type === "weapon") ? "rollProgressionDice" : "rollLethargyDice" // Set the roll context to rollProgressionDice
       currentAction = actionItem
     }
@@ -935,14 +935,14 @@ export default class LethalFantasyRoll extends Roll {
           let time = currentAction.type === "spell" ? currentAction.system.castingTime : currentAction.system.prayerTime
           if (currentAction.castingTime < time) {
             let message = `Casting time : ${currentAction.name}, count : ${currentAction.castingTime}/${time}`
-            ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+            await ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
             currentAction.castingTime += 1
             await combatant.setFlag(SYSTEM.id, "currentAction", foundry.utils.duplicate(currentAction))
             return
           } else {
             // Last counting second — announce ready and transition immediately (no extra second consumed)
             let message = `Casting time : ${currentAction.name}, count : ${time}/${time} — ready to cast next second !`
-            ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+            await ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
             currentAction.castingTime = 1
             currentAction.spellStatus = "toBeCasted"
             await combatant.setFlag(SYSTEM.id, "currentAction", foundry.utils.duplicate(currentAction))
@@ -982,7 +982,7 @@ export default class LethalFantasyRoll extends Roll {
                 isLethargy: true
               }
             )
-            ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+            await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
             // Update the combatant progression count
             await combatant.setFlag(SYSTEM.id, "currentAction", "")
             // Display the action selection window again
@@ -1002,7 +1002,7 @@ export default class LethalFantasyRoll extends Roll {
                 isLethargy: true
               }
             )
-            ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+            await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
           }
         }
       }
@@ -1014,18 +1014,18 @@ export default class LethalFantasyRoll extends Roll {
           let split = toSplit.split("+")
           currentAction.rangedLoad = Number(split[0]) || 0
           formula = split[1]
-          console.log("Ranged Mode", currentAction.rangedMode, currentAction.rangedLoad, formula)
+          log("Ranged Mode", currentAction.rangedMode, currentAction.rangedLoad, formula)
         }
         // Range weapon loading
         if (!currentAction.weaponLoaded && currentAction.rangedLoad) {
           if (currentAction.progressionCount < currentAction.rangedLoad) {
             let message = `Ranged weapon ${currentAction.name} is loading, loading count : ${currentAction.progressionCount}/${currentAction.rangedLoad}`
-            ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+            await ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
             currentAction.progressionCount += 1
             await combatant.setFlag(SYSTEM.id, "currentAction", foundry.utils.duplicate(currentAction))
           } else {
             let message = `Ranged weapon ${currentAction.name} is loaded !`
-            ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+            await ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
             currentAction.weaponLoaded = true
             currentAction.progressionCount = 1
             await combatant.setFlag(SYSTEM.id, "currentAction", foundry.utils.duplicate(currentAction))
@@ -1057,13 +1057,13 @@ export default class LethalFantasyRoll extends Roll {
               rollResult: roll.total
             }
           )
-          ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+          await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
           await combatant.setFlag(SYSTEM.id, "currentAction", "")
           combatant.actor.prepareRoll(currentAction.type === "weapon" ? "weapon-attack" : "spell-attack", currentAction._id)
         } else {
           // Notify that the player cannot act now with a chat message
           currentAction.progressionCount += 1
-          combatant.setFlag(SYSTEM.id, "currentAction", foundry.utils.duplicate(currentAction))
+          await combatant.setFlag(SYSTEM.id, "currentAction", foundry.utils.duplicate(currentAction))
           const messageContent = await foundry.applications.handlebars.renderTemplate(
             "systems/fvtt-lethal-fantasy/templates/progression-message.hbs",
             {
@@ -1074,7 +1074,7 @@ export default class LethalFantasyRoll extends Roll {
               progressionCount: currentAction.progressionCount
             }
           )
-          ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+          await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
         }
       }
     }
@@ -1130,7 +1130,7 @@ export default class LethalFantasyRoll extends Roll {
     // If the user cancels the dialog, exit
     if (rollContext === null) return
 
-    console.log("RollContext", rollContext)
+    log("RollContext", rollContext)
     // Add disfavor/favor option if point blank range
     if (rollContext.range === "pointblank") {
       rollContext.movement = rollContext.movement.replace("kh", "")
@@ -1426,7 +1426,7 @@ export default class LethalFantasyRoll extends Roll {
   /** @override */
   async render(chatOptions = {}) {
     let chatData = await this._getChatCardData(chatOptions.isPrivate)
-    console.log("ChatData", chatData)
+    log("ChatData", chatData)
     return await foundry.applications.handlebars.renderTemplate(this.constructor.CHAT_TEMPLATE, chatData)
   }
 
@@ -1464,15 +1464,15 @@ export default class LethalFantasyRoll extends Roll {
 
     // Récupérer les informations de l'arme pour les attaques réussies
     let weaponDamageOptions = null
-    console.log("Roll type:", this.type, "rollTarget:", this.rollTarget, "Has weapon:", !!this.rollTarget?.weapon)
+    log("Roll type:", this.type, "rollTarget:", this.rollTarget, "Has weapon:", !!this.rollTarget?.weapon)
     if (this.type === "weapon-attack" && this.rollTarget?.weapon) {
       const weapon = this.rollTarget.weapon
       weaponDamageOptions = {
-        weaponId: weapon._id || weapon.id,
+        weaponId: weapon.id,
         weaponName: weapon.name,
         damageM: weapon.system?.damage?.damageM
       }
-      console.log("Weapon damage options:", weaponDamageOptions)
+      log("Weapon damage options:", weaponDamageOptions)
     } else if (this.type === "monster-attack" && this.rollTarget) {
       weaponDamageOptions = {
         weaponId: this.rollTarget.rollKey,
@@ -1481,7 +1481,7 @@ export default class LethalFantasyRoll extends Roll {
         damageModifier: this.rollTarget.damageModifier,
         isMonster: true
       }
-      console.log("Monster damage options:", weaponDamageOptions)
+      log("Monster damage options:", weaponDamageOptions)
     }
 
     const cardData = {

module/macros.mjs

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

module/models/monster.mjs

@@ -383,7 +383,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
             rollResult: roll.total
           }
         )
-        ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
+        await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
         let token = combatant?.token
         this.prepareMonsterRoll("monster-attack", key, undefined, token?.id)
         if (token?.object) {
@@ -407,7 +407,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
               rollResult: roll.total
             }
           )
-          ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
+          await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
           let token = combatant?.token
           this.prepareMonsterRoll("monster-attack-hth", key, undefined, token?.id)
           if (token?.object) {
@@ -426,7 +426,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
           rollResult: roll.total
         }
       )
-      ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
+      await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
     }
 
   }

module/models/weapon.mjs

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

module/utils.mjs

@@ -1,8 +1,9 @@
 import { SYSTEM } from "./config/system.mjs"
 
-// Map temporaire pour stocker les données d'attaque en attente de défense
-if (!globalThis.pendingDefenses) {
-  globalThis.pendingDefenses = new Map()
+export function log(...args) {
+  if (game?.settings?.get(game.system.id, "debug")) {
+    console.log(...args)
+  }
 }
 
 export default class LethalFantasyUtils {
@@ -28,6 +29,7 @@ export default class LethalFantasyUtils {
   static setHookListeners() {
 
     Hooks.on('renderTokenHUD', async (hud, html, token) => {
+      if (html.querySelector(".lethal-hp-loss-hud")) return
       // HP Loss Button (existing)
       const lossHPButton = await foundry.applications.handlebars.renderTemplate('systems/fvtt-lethal-fantasy/templates/loss-hp-hud.hbs', {})
       $(html).find('div.left').append(lossHPButton);
@@ -50,14 +52,14 @@ export default class LethalFantasyUtils {
           $(html).find('.hp-loss-wrap')[2].classList.add('hp-loss-hud-disabled');
         }
       })
-      $(html).find('.loss-hp-hud-click').click((event) => {
+      $(html).find('.loss-hp-hud-click').click(async (event) => {
         event.preventDefault();
         let hpLoss = event.currentTarget.dataset.hpValue;
         if (token) {
-          let tokenFull = canvas.tokens.placeables.find(t => t.id === token._id);
-          console.log(tokenFull, token)
+          let tokenFull = canvas.tokens.placeables.find(t => t.id === token.id);
+          log(tokenFull, token)
           let actor = tokenFull.actor;
-          actor.applyDamage(Number(hpLoss));
+          await actor.applyDamage(Number(hpLoss));
           $(html).find('.hp-loss-wrap')[0].classList.remove('hp-loss-hud-active');
           $(html).find('.hp-loss-wrap')[0].classList.add('hp-loss-hud-disabled');
           $(html).find('.hp-loss-wrap')[1].classList.remove('hp-loss-hud-active');
@@ -89,14 +91,14 @@ export default class LethalFantasyUtils {
           $(html).find('.hp-gain-wrap')[2].classList.add('hp-gain-hud-disabled');
         }
       })
-      $(html).find('.gain-hp-hud-click').click((event) => {
+      $(html).find('.gain-hp-hud-click').click(async (event) => {
         event.preventDefault();
         let hpGain = event.currentTarget.dataset.hpValue;
         if (token) {
-          let tokenFull = canvas.tokens.placeables.find(t => t.id === token._id);
-          console.log(tokenFull, token)
+          let tokenFull = canvas.tokens.placeables.find(t => t.id === token.id);
+          log(tokenFull, token)
           let actor = tokenFull.actor;
-          actor.applyDamage(Number(hpGain)); // Positive value to add HP
+          await actor.applyDamage(Number(hpGain)); // Positive value to add HP
           $(html).find('.hp-gain-wrap')[0].classList.remove('hp-gain-hud-active');
           $(html).find('.hp-gain-wrap')[0].classList.add('hp-gain-hud-disabled');
           $(html).find('.hp-gain-wrap')[1].classList.remove('hp-gain-hud-active');
@@ -120,16 +122,16 @@ export default class LethalFantasyUtils {
           wrap.classList.add('luck-grit-hud-disabled');
         }
       })
-      $(html).find('.luck-grit-btn').click((event) => {
+      $(html).find('.luck-grit-btn').click(async (event) => {
         event.preventDefault();
         if (token) {
-          let tokenFull = canvas.tokens.placeables.find(t => t.id === token._id);
+          let tokenFull = canvas.tokens.placeables.find(t => t.id === token.id);
           let actor = tokenFull.actor;
           const resource = event.currentTarget.dataset.resource;
           const amount = Number(event.currentTarget.dataset.amount);
           const current = Number(foundry.utils.getProperty(actor.system, `${resource}.current`)) || 0;
           const newValue = Math.max(0, current + amount);
-          actor.update({ [`system.${resource}.current`]: newValue });
+          await actor.update({ [`system.${resource}.current`]: newValue });
           $(html).find('.luck-grit-wrap')[0].classList.remove('luck-grit-hud-active');
           $(html).find('.luck-grit-wrap')[0].classList.add('luck-grit-hud-disabled');
         }
@@ -138,8 +140,8 @@ export default class LethalFantasyUtils {
   }
 
   /* -------------------------------------------- */
-  static handleSocketEvent(msg = {}) {
-    console.log(`handleSocketEvent !`, msg)
+  static async handleSocketEvent(msg = {}) {
+    log(`handleSocketEvent !`, msg)
     let actor
     switch (msg.type) {
       case "applyDamage":
@@ -149,18 +151,18 @@ export default class LethalFantasyUtils {
             ? canvas.tokens?.placeables?.find(t => t.id === msg.tokenId)?.actor
             : (game.combat?.combatants?.find(c => c.actorId === msg.actorId)?.actor
               ?? game.actors.get(msg.actorId))
-          if (actor) actor.applyDamage(msg.damage)
+          if (actor) await actor.applyDamage(msg.damage)
         }
         break
       case "rollInitiative":
         if (msg.userId && msg.userId !== game.user.id) break
         actor = game.actors.get(msg.actorId)
-        actor.system.rollInitiative(msg.combatId, msg.combatantId)
+        await actor.system.rollInitiative(msg.combatId, msg.combatantId)
         break
       case "rollProgressionDice":
         if (msg.userId && msg.userId !== game.user.id) break
         actor = game.actors.get(msg.actorId)
-        actor.system.rollProgressionDice(msg.combatId, msg.combatantId, msg.rollProgressionCount)
+        await actor.system.rollProgressionDice(msg.combatId, msg.combatantId, msg.rollProgressionCount)
         break
       case "requestDefense":
         // Vérifier si le message est destiné à cet utilisateur
@@ -184,7 +186,7 @@ export default class LethalFantasyUtils {
             const slot = wounds.findIndex(w => !w.value && !w.duration)
             if (slot !== -1) {
               wounds[slot] = { value: msg.damage, duration: msg.damage, description: "Bleeding" }
-              actor.update({ "system.hp.wounds": wounds })
+              await actor.update({ "system.hp.wounds": wounds })
             }
           }
         }
@@ -235,10 +237,10 @@ export default class LethalFantasyUtils {
   static async handleAttackBoosted(msg) {
     const {
       attackerName, attackerId, defenderName, defenderId, defenderTokenId,
-      attackRollFinal, defenseRoll, attackWeaponId, attackRollType, attackRollKey,
+      attackerHandledBonus, attackRollFinal, defenseRoll, attackWeaponId, attackRollType, attackRollKey,
       shieldDamageReduction: initialShieldDR,
       d30Bleed, d30DamageMultiplier, d30DrMultiplier,
-      damageTier, attackD30message,
+      damageTier, attackD30message, defenseD30message,
       hasShield, shieldLabel, shieldFormula, shieldDr, canAdHocShield
     } = msg
 
@@ -251,138 +253,177 @@ export default class LethalFantasyUtils {
     let canShieldReact = hasShield
     let canAdHoc = canAdHocShield
 
-    // Show the defense reaction dialog
-    if (defender && updatedDefenseRoll < attackRollFinal) {
-      const currentGrit = Number(defender.system?.grit?.current) || 0
-      const currentLuck = Number(defender.system?.luck?.current) || 0
-      const buttons = []
-
-      if (currentGrit > 0) {
-        buttons.push({
-          action: "grit",
-          label: `Spend 1 Grit (+1D6) [${currentGrit} left]`,
-          icon: "fa-solid fa-fist-raised",
-          callback: () => "grit"
+    // ── D30 bonus dice (defense) — resolved before grit/luck/shield ───────
+    let defenseDrMultiplier = null
+    if (defenseD30message && defender) {
+      const d30Result = await LethalFantasyUtils.processD30BonusDice(defenseD30message, "defense", null, defender, true)
+      if (d30Result.modifier) {
+        updatedDefenseRoll += d30Result.modifier
+        if (d30Result.modifier > 0) {
+          await ChatMessage.create({
+            content: `<p><strong>${defenderName}</strong> gains <strong>+${d30Result.modifier}</strong> from D30 bonus die for defense.</p>`,
+            speaker: ChatMessage.getSpeaker({ actor: defender })
+          })
+        }
+      }
+      if (d30Result.specialEffect === "auto") {
+        updatedDefenseRoll = attackRollFinal + 1
+        await ChatMessage.create({
+          content: `<p><strong>${defenderName}</strong> uses <strong>${d30Result.specialName || "Special Defense"}</strong> from D30 — defense automatically succeeds!</p>`,
+          speaker: ChatMessage.getSpeaker({ actor: defender })
         })
       }
-
-      if (currentLuck > 0) {
-        buttons.push({
-          action: "luck",
-          label: `Spend 1 Luck (+1D6) [${currentLuck} left]`,
-          icon: "fa-solid fa-clover",
-          callback: () => "luck"
+      if (d30Result.specialEffect === "flag") {
+        await ChatMessage.create({
+          content: `<p>D30 — <strong>${d30Result.specialName || "Special Effect"}</strong> triggered for ${defenderName}!</p>`,
+          speaker: ChatMessage.getSpeaker({ actor: defender })
         })
       }
-
-      buttons.push({
-        action: "bonusDie",
-        label: "Add bonus die",
-        icon: "fa-solid fa-dice",
-        callback: () => "bonusDie"
-      })
-
-      if (canShieldReact) {
-        buttons.push({
-          action: "shieldReact",
-          label: `Roll shield (${shieldLabel})`,
-          icon: "fa-solid fa-shield",
-          callback: () => "shieldReact"
-        })
-      } else if (canAdHoc) {
-        buttons.push({
-          action: "adHocShield",
-          label: "Roll ad-hoc shield (choose dice + DR)",
-          icon: "fa-solid fa-shield-halved",
-          callback: () => "adHocShield"
+      if (d30Result.specialEffect === "drMultiplier") {
+        defenseDrMultiplier = d30Result.multiplier
+        await ChatMessage.create({
+          content: `<p>D30 — Defense grants <strong>x${d30Result.multiplier} DR</strong> (choose which DR types to multiply when damage is applied)</p>`,
+          speaker: ChatMessage.getSpeaker({ actor: defender })
         })
       }
+    }
 
-      buttons.push({
-        action: "continue",
-        label: "Continue (no defense bonus)",
-        icon: "fa-solid fa-forward",
-        callback: () => "continue"
-      })
+    // Show the defense reaction dialog — while-loop for multiple reactions
+    if (defender) {
+      while (updatedDefenseRoll < attackRollFinal) {
+        const currentGrit = Number(defender.system?.grit?.current) || 0
+        const currentLuck = Number(defender.system?.luck?.current) || 0
+        const buttons = []
 
-      const choice = await foundry.applications.api.DialogV2.wait({
-        window: { title: "Defense reactions — attack boosted" },
-        classes: ["lethalfantasy"],
-        content: `
-          <div class="grit-luck-dialog">
-            <div class="combat-status">
-              <p><strong>${attackerName}</strong> boosted attack to <strong>${attackRollFinal}</strong></p>
-              <p><strong>${defenderName}</strong> currently has <strong>${updatedDefenseRoll}</strong></p>
+        if (currentGrit > 0) {
+          buttons.push({
+            action: "grit",
+            label: `Spend 1 Grit (+1D6) [${currentGrit} left]`,
+            icon: "fa-solid fa-fist-raised",
+            callback: () => "grit"
+          })
+        }
+
+        if (currentLuck > 0) {
+          buttons.push({
+            action: "luck",
+            label: `Spend 1 Luck (+1D6) [${currentLuck} left]`,
+            icon: "fa-solid fa-clover",
+            callback: () => "luck"
+          })
+        }
+
+        buttons.push({
+          action: "bonusDie",
+          label: "Add bonus die",
+          icon: "fa-solid fa-dice",
+          callback: () => "bonusDie"
+        })
+
+        if (canShieldReact) {
+          buttons.push({
+            action: "shieldReact",
+            label: `Roll shield (${shieldLabel})`,
+            icon: "fa-solid fa-shield",
+            callback: () => "shieldReact"
+          })
+        } else if (canAdHoc) {
+          buttons.push({
+            action: "adHocShield",
+            label: "Roll ad-hoc shield (choose dice + DR)",
+            icon: "fa-solid fa-shield-halved",
+            callback: () => "adHocShield"
+          })
+        }
+
+        buttons.push({
+          action: "continue",
+          label: "Continue (no defense bonus)",
+          icon: "fa-solid fa-forward",
+          callback: () => "continue"
+        })
+
+        const choice = await foundry.applications.api.DialogV2.wait({
+          window: { title: "Defense reactions — attack boosted" },
+          classes: ["lethalfantasy"],
+          content: `
+            <div class="grit-luck-dialog">
+              <div class="combat-status">
+                <p><strong>${attackerName}</strong> boosted attack to <strong>${attackRollFinal}</strong></p>
+                <p><strong>${defenderName}</strong> currently has <strong>${updatedDefenseRoll}</strong></p>
+              </div>
+              <p class="offer-text">The attack was boosted! Choose how to improve the defense.</p>
             </div>
-            <p class="offer-text">The attack was boosted! Choose how to improve the defense.</p>
-          </div>
-        `,
-        buttons,
-        rejectClose: false
-      })
+          `,
+          buttons,
+          rejectClose: false
+        })
 
-      if (choice === "grit") {
-        const bonusRoll = await LethalFantasyUtils.rollBonusDie("1d6", defender,
-          total => `<p><strong>${defenderName}</strong> spends 1 Grit and rolls <strong>${total}</strong> for defense.</p>`)
-        updatedDefenseRoll += bonusRoll
-        await defender.update({ "system.grit.current": currentGrit - 1 })
-      } else if (choice === "luck") {
-        const bonusRoll = await LethalFantasyUtils.rollBonusDie("1d6", defender,
-          total => `<p><strong>${defenderName}</strong> spends 1 Luck and rolls <strong>${total}</strong> for defense.</p>`)
-        updatedDefenseRoll += bonusRoll
-        await defender.update({ "system.luck.current": currentLuck - 1 })
-      } else if (choice === "bonusDie") {
-        const bonusDie = await LethalFantasyUtils.promptCombatBonusDie(defenderName, "attack", updatedDefenseRoll, attackRollFinal)
-        if (bonusDie) {
-          const bonusRoll = await LethalFantasyUtils.rollBonusDie(bonusDie, defender,
-            (total, formula) => `<p><strong>${defenderName}</strong> adds <strong>${formula.toUpperCase()}</strong> and rolls <strong>${total}</strong> for defense.</p>`)
+        if (!choice || choice === "continue") break
+
+        if (choice === "grit") {
+          const bonusRoll = await LethalFantasyUtils.rollBonusDie("1d6", defender,
+            total => `<p><strong>${defenderName}</strong> spends 1 Grit and rolls <strong>${total}</strong> for defense.</p>`)
           updatedDefenseRoll += bonusRoll
-        }
-      } else if (choice === "shieldReact" && canShieldReact) {
-        const shieldBonus = await LethalFantasyUtils.rollBonusDie(shieldFormula, defender)
-        const newDefenseTotal = updatedDefenseRoll + shieldBonus
-        updatedDefenseRoll = newDefenseTotal
-        canShieldReact = false
-        if (newDefenseTotal >= attackRollFinal) {
-          shieldBlocked = true
-          shieldReaction = { damageReduction: shieldDr, label: shieldLabel, bonus: shieldBonus }
-          await ChatMessage.create({
-            content: `<p><strong>${defenderName}</strong> rolls <strong>${shieldLabel}</strong> and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} ≥ ${attackRollFinal}). <strong>Shield blocked the attack!</strong> Both armor DR and shield DR <strong>${shieldDr}</strong> will apply to damage.</p>`,
-            speaker: ChatMessage.getSpeaker({ actor: defender })
-          })
-        } else {
-          await ChatMessage.create({
-            content: `<p><strong>${defenderName}</strong> rolls <strong>${shieldLabel}</strong> and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} < ${attackRollFinal}). Shield did not block — normal hit, armor DR only.</p>`,
-            speaker: ChatMessage.getSpeaker({ actor: defender })
-          })
-        }
-      } else if (choice === "adHocShield" && canAdHoc) {
-        const adHoc = await LethalFantasyUtils.promptAdHocShield(defenderName, attackRollFinal, updatedDefenseRoll)
-        if (adHoc) {
-          const shieldBonus = await LethalFantasyUtils.rollBonusDie(adHoc.formula, defender)
+          await defender.update({ "system.grit.current": currentGrit - 1 })
+        } else if (choice === "luck") {
+          const bonusRoll = await LethalFantasyUtils.rollBonusDie("1d6", defender,
+            total => `<p><strong>${defenderName}</strong> spends 1 Luck and rolls <strong>${total}</strong> for defense.</p>`)
+          updatedDefenseRoll += bonusRoll
+          await defender.update({ "system.luck.current": currentLuck - 1 })
+        } else if (choice === "bonusDie") {
+          const bonusDie = await LethalFantasyUtils.promptCombatBonusDie(defenderName, "attack", updatedDefenseRoll, attackRollFinal)
+          if (bonusDie) {
+            const bonusRoll = await LethalFantasyUtils.rollBonusDie(bonusDie, defender,
+              (total, formula) => `<p><strong>${defenderName}</strong> adds <strong>${formula.toUpperCase()}</strong> and rolls <strong>${total}</strong> for defense.</p>`)
+            updatedDefenseRoll += bonusRoll
+          }
+        } else if (choice === "shieldReact" && canShieldReact) {
+          const shieldBonus = await LethalFantasyUtils.rollBonusDie(shieldFormula, defender)
           const newDefenseTotal = updatedDefenseRoll + shieldBonus
           updatedDefenseRoll = newDefenseTotal
           canShieldReact = false
-          canAdHoc = false
           if (newDefenseTotal >= attackRollFinal) {
             shieldBlocked = true
-            shieldReaction = { damageReduction: adHoc.damageReduction, label: `${adHoc.formula.toUpperCase()} shield`, bonus: shieldBonus }
+            shieldReaction = { damageReduction: shieldDr, label: shieldLabel, bonus: shieldBonus }
             await ChatMessage.create({
-              content: `<p><strong>${defenderName}</strong> rolls <strong>${adHoc.formula.toUpperCase()}</strong> shield and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} ≥ ${attackRollFinal}). <strong>Shield blocked the attack!</strong> Both armor DR and shield DR <strong>${adHoc.damageReduction}</strong> will apply to damage.</p>`,
+              content: `<p><strong>${defenderName}</strong> rolls <strong>${shieldLabel}</strong> and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} ≥ ${attackRollFinal}). <strong>Shield blocked the attack!</strong> Both armor DR and shield DR <strong>${shieldDr}</strong> will apply to damage.</p>`,
               speaker: ChatMessage.getSpeaker({ actor: defender })
             })
           } else {
             await ChatMessage.create({
-              content: `<p><strong>${defenderName}</strong> rolls <strong>${adHoc.formula.toUpperCase()}</strong> shield and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} < ${attackRollFinal}). Shield did not block — normal hit, armor DR only.</p>`,
+              content: `<p><strong>${defenderName}</strong> rolls <strong>${shieldLabel}</strong> and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} < ${attackRollFinal}). Shield did not block — normal hit, armor DR only.</p>`,
               speaker: ChatMessage.getSpeaker({ actor: defender })
             })
           }
+        } else if (choice === "adHocShield" && canAdHoc) {
+          const adHoc = await LethalFantasyUtils.promptAdHocShield(defenderName, attackRollFinal, updatedDefenseRoll)
+          if (adHoc) {
+            const shieldBonus = await LethalFantasyUtils.rollBonusDie(adHoc.formula, defender)
+            const newDefenseTotal = updatedDefenseRoll + shieldBonus
+            updatedDefenseRoll = newDefenseTotal
+            canShieldReact = false
+            canAdHoc = false
+            if (newDefenseTotal >= attackRollFinal) {
+              shieldBlocked = true
+              shieldReaction = { damageReduction: adHoc.damageReduction, label: `${adHoc.formula.toUpperCase()} shield`, bonus: shieldBonus }
+              await ChatMessage.create({
+                content: `<p><strong>${defenderName}</strong> rolls <strong>${adHoc.formula.toUpperCase()}</strong> shield and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} ≥ ${attackRollFinal}). <strong>Shield blocked the attack!</strong> Both armor DR and shield DR <strong>${adHoc.damageReduction}</strong> will apply to damage.</p>`,
+                speaker: ChatMessage.getSpeaker({ actor: defender })
+              })
+            } else {
+              await ChatMessage.create({
+                content: `<p><strong>${defenderName}</strong> rolls <strong>${adHoc.formula.toUpperCase()}</strong> shield and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} < ${attackRollFinal}). Shield did not block — normal hit, armor DR only.</p>`,
+                speaker: ChatMessage.getSpeaker({ actor: defender })
+              })
+            }
+          }
         }
       }
     }
 
     const finalShieldDR = shieldBlocked ? (shieldReaction?.damageReduction || 0) : 0
-    const outcome = shieldBlocked ? "shielded-hit" : (updatedDefenseRoll > attackRollFinal ? "miss" : "hit")
+    const outcome = shieldBlocked ? "shielded-hit" : (updatedDefenseRoll >= attackRollFinal ? "miss" : "hit")
 
     await LethalFantasyUtils.compareAttackDefense({
       attackerName,
@@ -399,7 +440,7 @@ export default class LethalFantasyUtils {
       shieldDamageReduction: finalShieldDR,
       d30Bleed: d30Bleed || "",
       d30DamageMultiplier: d30DamageMultiplier || 1,
-      d30DrMultiplier: d30DrMultiplier || 1,
+      d30DrMultiplier: (d30DrMultiplier != null && d30DrMultiplier !== 1) ? d30DrMultiplier : (defenseDrMultiplier ?? d30DrMultiplier ?? 1),
       damageTier: damageTier || "standard",
       attackD30message
     })
@@ -458,7 +499,7 @@ export default class LethalFantasyUtils {
 
     const isMonster = defender.type === "monster"
 
-    console.log(`[LF] showDefenseRequest | attackRollType=${attackRollType} isMonster=${isMonster} defender=${defender?.name}`)
+    log(`[LF] showDefenseRequest | attackRollType=${attackRollType} isMonster=${isMonster} defender=${defender?.name}`)
 
     // Spell/miracle attacks use saving throws instead of weapon defense
     const isSpellAttack = attackRollType === "spell-attack" || attackRollType === "miracle-attack"
@@ -520,9 +561,9 @@ export default class LethalFantasyUtils {
           defenderTokenId
         }
         if (isMonster) {
-          defender.system.prepareMonsterRoll("save", result)
+          await defender.system.prepareMonsterRoll("save", result)
         } else {
-          defender.prepareRoll("save", result)
+          await defender.prepareRoll("save", result)
         }
       }
       return
@@ -598,7 +639,7 @@ export default class LethalFantasyUtils {
           isRanged: msg.isRanged
         }
 
-        defender.system.prepareMonsterRoll("monster-defense", result)
+        await defender.system.prepareMonsterRoll("monster-defense", result)
       }
       return
     }
@@ -705,9 +746,9 @@ export default class LethalFantasyUtils {
         isRanged: msg.isRanged
       }
 
-      console.log("Storing defense data for character:", defender.id)
+      log("Storing defense data for character:", defender.id)
 
-      defender.prepareRoll("weapon-defense", result)
+      await defender.prepareRoll("weapon-defense", result)
     }
   }
 
@@ -742,18 +783,11 @@ export default class LethalFantasyUtils {
 
     // ── Choice type ── present all options to the player
     if (d30Message.type === "choice") {
-      // Try to find a bonus_dice option matching this side
-      const autoBonus = d30Message.choices.find(c => c.type === "bonus_dice" && validTargets.includes(c.target))
-
-      // If we can't show dialogs (wrong client), auto-roll bonus dice if available
+      // If we can't show dialogs (wrong client), skip — the primary client
+      // will communicate its choice result via socket. Auto-rolling here
+      // would give a different modifier on each client, causing divergence.
       if (!canDialog) {
-        if (autoBonus) {
-          const modifier = await this._rollD30BonusDie(autoBonus.dice, actor, true)
-          return { modifier, specialEffect: null, specialName: null }
-        }
-        // No bonus dice available on this side — just report as flag
-        const first = d30Message.choices[0]
-        return { modifier: 0, specialEffect: "flag", specialName: first?.type || "choice" }
+        return { modifier: 0, specialEffect: null, specialName: null }
       }
 
       const buttons = d30Message.choices.map(c => {
@@ -1253,7 +1287,7 @@ export default class LethalFantasyUtils {
 
   /* -------------------------------------------- */
   static async compareAttackDefense(data) {
-    console.log("compareAttackDefense called with:", data)
+    log("compareAttackDefense called with:", data)
 
     // Compute D30 effects from the attack D30 message directly.
     // This is more reliable than depending on the caller-provided values, which are
@@ -1268,11 +1302,11 @@ export default class LethalFantasyUtils {
 
     const outcome = data.outcome || (data.attackRoll > data.defenseRoll ? "hit" : "miss")
     const isAttackWin = outcome !== "miss"
-    console.log("isAttackWin:", isAttackWin, "attackRoll:", data.attackRoll, "defenseRoll:", data.defenseRoll)
+    log("isAttackWin:", isAttackWin, "attackRoll:", data.attackRoll, "defenseRoll:", data.defenseRoll)
 
     let damageButton = ""
     if (isAttackWin && (data.attackWeaponId || data.attackRollKey)) {
-      console.log("Creating damage button. defenderId:", data.defenderId)
+      log("Creating damage button. defenderId:", data.defenderId)
       // Déterminer le type de dégâts à lancer
       if (data.attackRollType === "weapon-attack") {
         damageButton = `
@@ -1353,12 +1387,12 @@ export default class LethalFantasyUtils {
       </div>
     `
 
-    console.log("Creating combat result message...")
+    log("Creating combat result message...")
     await ChatMessage.create({
       content: resultMessage,
       speaker: { alias: "Combat System" }
     })
-    console.log("Combat result message created!")
+    log("Combat result message created!")
   }
 
   static registerHandlebarsHelpers() {
@@ -1495,7 +1529,7 @@ export default class LethalFantasyUtils {
       return eval(expr);
     })
     Handlebars.registerHelper('isOwnerOrGM', function (actor) {
-      console.log("Testing actor", actor.isOwner, game.userId)
+      log("Testing actor", actor.isOwner, game.userId)
       return actor.isOwner || game.isGM;
     })
     Handlebars.registerHelper('upperCase', function (text) {
@@ -1633,7 +1667,7 @@ export default class LethalFantasyUtils {
         }
       )
 
-      ChatMessage.create({
+      await ChatMessage.create({
         user: game.user.id,
         speaker: { alias: targetActor.name },
         mode: "gm",

templates/roll-dialog.hbs

@@ -130,6 +130,7 @@
             type="checkbox"
             name="saveSpellCheck"
             data-action="saveSpellCheck"
+            {{#if saveSpell}}checked{{/if}}
           />
         </div>
       {{/if}}

templates/weapon.hbs

@@ -17,7 +17,7 @@
         {{formField systemFields.damageType.fields.typeS value=system.damageType.typeS}}
       </div>
 
-      {{formField systemFields.damage.fields.damageM value=system.damage.damageM label="LETHALFANTASY.Label.damage"}}
+      {{formField systemFields.damage.fields.damageM value=system.damage.damageM label=(localize "LETHALFANTASY.Label.damage")}}
 
       {{formField systemFields.applyStrengthDamageBonus value=system.applyStrengthDamageBonus localize=true}}
     

tools/pullYMLtoLDB.mjs

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

tools/pushLDBtoYML.mjs

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