Merge pull request 'v13.0.33 - L'ébriété d'Illysis' (#798) from feature/v13-corrections into v13

Reviewed-on: https, #798
2026-03-26 23:11:26 +01:00
parent a768419029 f3e7cc38a7
commit afcd200913
17 changed files with 234 additions and 223 deletions
--- a/changelog.md
+++ b/changelog.md
@@ -1,5 +1,9 @@
 # 13.0

+## 13.0.33 - L'ébriété d'Illysis
+
+- le stade éméché ne cause plus de perte d'endurance
+
 ## 13.0.32 - Le surpoids d'Illysis

 - Le malus d'encombrement sur jet d'Agilité avec Natation ou Acrobatie peuvent être changés, et sont correctement arrondis
--- a/info-message.html
+++ b/info-message.html
@@ -1,5 +1,6 @@
-<h3>Joyeuses fêtes</h3>
+<h3>L'oeuf de Dragon</h3>
 <p>
-  VincentVK, LeRatierBretonnien et toute l'équipe de Scriptrarium vous
-  souhaitent de joyeuses et oniriques fêtes !
+  On raconte que si le premier Vaisseau, on trouve un oeuf couvé par
+  un lapin, il faut bien s'occuper dudit lapin, car quatre mois plus tard
+  pourrait bien éclore un dragon!
 </p>
--- a/module/actor.js
+++ b/module/actor.js
@@ -1074,13 +1074,13 @@ export class RdDActor extends RdDBaseActorSang {
    }
    const donHR = await RdDItemTete.teteDonDeHautReve()
    if (donHR) {
-      this.createEmbeddedDocuments('Item', [donHR.toObject()])
+      await this.createEmbeddedDocuments('Item', [donHR.toObject()])
    }
  }

  async addSortReserve(item) {
    if (item?.type == ITEM_TYPES.sort && !item.system.isrituel) {
-      this.$createSortReserve(item)
+      await this.$createSortReserve(item)
      return
    }
    const selectSortReserve = {
@@ -1091,9 +1091,9 @@ export class RdDActor extends RdDBaseActorSang {
    DialogSelect.select(selectSortReserve, sort => this.$createSortReserve(sort))
  }

-  $createSortReserve(sort) {
+  async $createSortReserve(sort) {
    const ptReve = Number.isInteger(sort.system.ptreve) ? Number(sort.system.ptreve) : Number(sort.system.ptreve.match(/\d+/))
-    this.createEmbeddedDocuments("Item",
+    await this.createEmbeddedDocuments("Item",
      [{
        type: ITEM_TYPES.sortreserve,
        name: sort.name,
@@ -1141,7 +1141,7 @@ export class RdDActor extends RdDBaseActorSang {
  async addTMRRencontre(currentRencontre) {
    const toCreate = currentRencontre.toObject();
    console.log('actor.addTMRRencontre(', toCreate, ')');
-    this.createEmbeddedDocuments('Item', [toCreate]);
+    await this.createEmbeddedDocuments('Item', [toCreate]);
  }

  /* -------------------------------------------- */
@@ -1421,6 +1421,7 @@ export class RdDActor extends RdDBaseActorSang {
      actor: this,
      vie: this.system.sante.vie.max,
      alcool: alcool,
+      perteEndurance: 0,
      jetVie: {
        forceAlcool: forceAlcool,
        nbDoses: nbDoses,
@@ -1433,7 +1434,7 @@ export class RdDActor extends RdDBaseActorSang {
    }

    await RdDResolutionTable.rollData(ethylismeData.jetVie);
-    this.gererExperience(ethylismeData.jetVie);
+    this.ajoutExperience(ethylismeData.jetVie);
    RollDataAjustements.calcul(ethylismeData.jetVie, this);
    if (ethylismeData.jetVie.rolled.isSuccess) {
      ethylisme.nb_doses++;
@@ -1441,8 +1442,9 @@ export class RdDActor extends RdDBaseActorSang {
      ethylisme.value = Math.max(ethylisme.value - 1, -7);
      ethylisme.nb_doses = 0;

-      let perte = await RdDDice.rollTotal("1d6");
-      ethylismeData.perteEndurance = await this.santeIncDec("endurance", -perte);
+      if (ethylisme.value > 0) {
+        ethylismeData.perteEndurance = await this.santeIncDec("endurance", -(await RdDDice.rollTotal("1d6")))
+      }

      if (!ethylisme.jet_moral) {
        ethylismeData.jetMoral = await this._jetDeMoral(MORAL.HEUREUX, "Ethylisme");
@@ -1465,7 +1467,7 @@ export class RdDActor extends RdDBaseActorSang {
          finalLevel: Number(ethylisme.value) + Number(this.system.compteurs.moral.value)
        }
        await RdDResolutionTable.rollData(ethylismeData.jetVolonte);
-        this.gererExperience(ethylismeData.jetVolonte);
+        this.ajoutExperience(ethylismeData.jetVolonte);
        RollDataAjustements.calcul(ethylismeData.jetVolonte, this);
      }
    }
@@ -1560,21 +1562,6 @@ export class RdDActor extends RdDBaseActorSang {
    return 0;
  }

-  /* -------------------------------------------- */
-  createCallbackExperience() {
-    return {
-      action: r => this.appliquerAjoutExperience(r)
-    };
-  }
-
-  /* -------------------------------------------- */
-  createCallbackAppelAuMoral() { /* Si l'appel au moral est utilisé, on l'affiche dans le chat et on diminue éventuellement le moral */
-    return {
-      action: r => this.appliquerAppelMoral(r)
-    };
-  }
-
-
  /* -------------------------------------------- */
  isCaracMax(code) {
    return RdDItemRace.isRacialMax(this, code)
@@ -1639,7 +1626,7 @@ export class RdDActor extends RdDBaseActorSang {
  }

  /* -------------------------------------------- */
-  async appliquerAjoutExperience(rollData, hideChatMessage = 'show') {
+  async ajoutExperience(rollData, hideChatMessage = 'show') {
    if (!rollData.rolled.isPart ||
      rollData.finalLevel >= 0 ||
      game.settings.get("core", "rollMode") == 'selfroll' ||
@@ -1891,16 +1878,11 @@ export class RdDActor extends RdDBaseActorSang {
    };
    RollDataAjustements.calcul(rollData, this);
    await RdDResolutionTable.rollData(rollData);
-    this.gererExperience(rollData);
+    this.ajoutExperience(rollData);
    await RdDRollResult.displayRollData(rollData, this)
    return rollData.rolled;
  }

-  /* -------------------------------------------- */
-  gererExperience(rollData) {
-    this.createCallbackExperience().action(rollData);
-  }
-
  /* -------------------------------------------- */
  async creerTacheDepuisLivre(item, options = { renderSheet: true }) {
    const nomTache = "Lire " + item.name;
--- a/module/actor/base-actor-reve.js
+++ b/module/actor/base-actor-reve.js
@@ -26,7 +26,7 @@ import { BASE_CORPS_A_CORPS, BASE_ESQUIVE, CATEGORIES_COMPETENCES_CREATURES } fr
 import { RollDataAjustements } from "../rolldata-ajustements-v1.js";
 import { MappingCreatureArme } from "../item/mapping-creature-arme.mjs";
 import RollDialog from "../roll/roll-dialog.mjs";
-import { ATTAQUE_ROLL_TYPES, DEFAULT_ROLL_TYPES, DIFF, ROLL_TYPE_ATTAQUE } from "../roll/roll-constants.mjs";
+import { DEFAULT_ROLL_TYPES, DIFF, ROLL_TYPE_ATTAQUE } from "../roll/roll-constants.mjs";
 import { OptionsAvancees, ROLL_DIALOG_V2 } from "../settings/options-avancees.js";
 import { PART_COMP } from "../roll/roll-part-comp.mjs";
 import { RdDInitiative } from "../initiative.mjs";
@@ -154,7 +154,7 @@ export class RdDBaseActorReve extends RdDBaseActor {

  async computeArmure(dmg) { return this.getProtectionNaturelle() }
  async remiseANeuf() { }
-  async appliquerAjoutExperience(rollData, hideChatMessage = 'show') { }
+  async ajoutExperience(rollData, hideChatMessage = 'show') { }

  computeResumeBlessure() { }
  countBlessures(filter = it => !it.isContusion()) { return 0 }
@@ -295,7 +295,7 @@ export class RdDBaseActorReve extends RdDBaseActor {

  /* -------------------------------------------- */
  createCallbackExperience() {
-    return { action: r => this.appliquerAjoutExperience(r) }
+    return { action: r => this.ajoutExperience(r) }
  }

  /* -------------------------------------------- */
@@ -304,7 +304,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
    return { action: r => this.appliquerAppelMoral(r) }
  }

-  async appliquerAjoutExperience(rollData, hideChatMessage = 'show') { }
+  async ajoutExperience(rollData, hideChatMessage = 'show') { }
  async appliquerAppelMoral(rollData) { }

  async _onCloseRollDialog(html) { }
@@ -371,13 +371,11 @@ export class RdDBaseActorReve extends RdDBaseActor {
    }
    RollDataAjustements.calcul(rollData, this);
    await RdDResolutionTable.rollData(rollData);
-    this.gererExperience(rollData);
+    this.ajoutExperience(rollData);
    await RdDResolutionTable.displayRollData(rollData, this)
    return rollData.rolled;
  }

-  gererExperience(rollData) { }
-
  /* -------------------------------------------- */
  async roll() {
    if (OptionsAvancees.isUsing(ROLL_DIALOG_V2)) {
@@ -727,7 +725,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
    }

    await RdDRollResult.displayRollData(rollData, this, 'chat-resultat-accorder-cauchemar.hbs')
-    await this.appliquerAjoutExperience(rollData, true)
+    await this.ajoutExperience(rollData, true)
    return rolled.isSuccess;
  }

--- a/module/actor/base-actor-sang.js
+++ b/module/actor/base-actor-sang.js
@@ -107,7 +107,7 @@ export class RdDBaseActorSang extends RdDBaseActorReve {

  async computeArmure(attackerRoll) { return this.getProtectionNaturelle() }
  async remiseANeuf() { }
-  async appliquerAjoutExperience(rollData, hideChatMessage = 'show') { }
+  async ajoutExperience(rollData, hideChatMessage = 'show') { }

  /* -------------------------------------------- */

--- a/module/actor/base-actor.js
+++ b/module/actor/base-actor.js
@@ -93,13 +93,8 @@ export class RdDBaseActor extends Actor {
  }

  static getRealActor(actorId, tokenId) {
-    if (tokenId) {
-      let token = canvas.tokens.get(tokenId)
-      if (token) {
-        return token.actor
-      }
-    }
-    return game.actors.get(actorId)
+    const actor = tokenId ? canvas.tokens.get(tokenId)?.actor : undefined
+    return actor ?? game.actors.get(actorId)
  }

  getAlias() {
@@ -285,7 +280,7 @@ export class RdDBaseActor extends Actor {
    return this.getEffects().filter(it => it.statuses.has(effectId))
  }

-  async setEffect(effectId, status, options = {render: true}) {
+  async setEffect(effectId, status, options = { render: true }) {
    if (this.isEffectAllowed(effectId)) {
      const effects = this.getEffectsByStatus(effectId)
      if (!status && effects.length > 0) {
@@ -301,7 +296,7 @@ export class RdDBaseActor extends Actor {
    this.removeEffects(it => it.id == id)
  }

-  async removeEffects(filter = e => true, options = {render: true}) {
+  async removeEffects(filter = e => true, options = { render: true }) {
    if (game.user.isGM) {
      const ids = this.getEffects(filter)
        .filter(it => this.canRemoveEffects(it))
@@ -879,6 +874,7 @@ export class RdDBaseActor extends Actor {
    ui.notifications.info(`${this.getAlias()} ne peut pas faire cette action: ${action}`)
  }

+  ajoutExperience(rollData) { }
  isAlcoolise() { return false }
  async jetEthylisme() { this.actionImpossible("jet d'éthylisme") }
  async rollAppelChance() { this.actionImpossible("appel à la chance") }
--- a/module/actor/entite-sheet.js
+++ b/module/actor/entite-sheet.js
@@ -18,6 +18,7 @@ export class RdDActorEntiteSheet extends RdDBaseActorReveSheet {
    formData.niveau = this.actor.getNiveau()
    delete formData.system.carac.niveau
    formData.resonances = this.actor.system.sante.resonnance.actors.map(actorId => game.actors.get(actorId))
+      .filter(actor => actor != undefined)
      .map(actor => { return { id: actor.id, name: actor.name, img: actor.img } })
    return formData
  }
--- a/module/migrations.js
+++ b/module/migrations.js
@@ -16,22 +16,18 @@ class Migration {
  async migrate() { }

  async applyItemsUpdates(computeUpdates) {
-    await game.actors.forEach(async (actor) => {
+    await Promise.all(game.actors.map(actor => {
      const actorItemUpdates = computeUpdates(actor.items).filter(it => it != undefined);
      if (actorItemUpdates.length > 0) {
-        console.log(
-          this.code,
-          `Applying updates on actor ${actor.name} items`,
-          actorItemUpdates
-        );
-        await actor.updateEmbeddedDocuments("Item", actorItemUpdates);
+        console.log(this.code, `Applying updates on actor ${actor.name} items`, actorItemUpdates);
+        return actor.updateEmbeddedDocuments("Item", actorItemUpdates);
      }
-    });
+    }))

-    const itemUpdates = computeUpdates(game.items).filter(it => it != undefined);
+    const itemUpdates = computeUpdates(game.items).filter(it => it != undefined)
    if (itemUpdates.length > 0) {
-      console.log(this.code, "Applying updates on items", itemUpdates);
-      await Item.updateDocuments(itemUpdates);
+      console.log(this.code, "Applying updates on items", itemUpdates)
+      await Item.updateDocuments(itemUpdates)
    }
  }
 }
@@ -58,13 +54,13 @@ class _1_5_34_migrationPngWebp {
    //Migrate system png to webp
    await Item.updateDocuments(itemsUpdates);
    await Actor.updateDocuments(actorsUpdates);
-    game.actors.forEach(actor => {
-      if (actor.token?.img && actor.token.img.match(regexOldPngJpg)) {
-        actor.update({ "token.img": convertImgToWebp(actor.token.img) });
-      }
-      const actorItemsToUpdate = prepareDocumentsImgUpdate(actor.items);
-      actor.updateEmbeddedDocuments('Item', actorItemsToUpdate);
-    });
+    await Promise.all(game.actors
+      .filter(actor => actor.token?.img && actor.token.img.match(regexOldPngJpg))
+      .map(actor => actor.update({ "token.img": convertImgToWebp(actor.token.img) }))
+    )
+    await Promise.all(game.actors.map(actor =>
+      actor.updateEmbeddedDocuments('Item', prepareDocumentsImgUpdate(actor.items))
+    ))
  }
 }

@@ -125,16 +121,15 @@ class _10_0_21_VehiculeStructureResistanceMax extends Migration {
  get version() { return "10.0.21"; }

  async migrate() {
-    await game.actors
-      .filter((actor) => actor.type == "vehicule")
-      .forEach(async (actor) => {
-        await actor.update({
+    await Promise.all(
+      game.actors.filter(actor => actor.type == "vehicule")
+        .map(actor => actor.update({
          'system.etat.resistance.value': actor.system.resistance,
          'system.etat.resistance.max': actor.system.resistance,
          'system.etat.structure.value': actor.system.structure,
          'system.etat.structure.max': actor.system.structure
-        })
-      });
+        }))
+    )
  }
 }

@@ -192,9 +187,9 @@ class _10_2_5_ArmesTirLancer extends Migration {
  get version() { return "10.2.5"; }

  migrateArmeTirLancer(it) {
-    let updates = foundry.utils.mergeObject({ _id: it.id }, this.getMapping(it).updates);
-    console.log(it.name, updates);
-    return updates;
+    const updates = foundry.utils.mergeObject({ _id: it.id }, this.getMapping(it).updates)
+    console.log(it.name, updates)
+    return updates
  }

  async migrate() {
--- a/module/rdd-combat.js
+++ b/module/rdd-combat.js
@@ -63,6 +63,7 @@ export class RdDCombatManager extends Combat {
      it.token.id == tokenId
    )
  }
+
  static getRangInitiativeCombatant(actorId, tokenId) {
    const combatant = RdDCombatManager.getCombatant(actorId, tokenId)
    return combatant?.system.init?.rang
@@ -387,7 +388,7 @@ export class RdDCombat {

  /* -------------------------------------------- */
  static onMsgEncaisser(msg) {
-    let defender = canvas.tokens.get(msg.defenderToken.id).actor;
+    let defender = canvas.tokens.get(msg.defenderToken.id)?.actor;
    if (Misc.isOwnerPlayer(defender)) {
      let attackerRoll = msg.attackerRoll;
      let attacker = msg.attackerId ? game.actors.get(msg.attackerId) : undefined;
@@ -466,24 +467,10 @@ export class RdDCombat {
    this.defenderId = this.defender.id
    this.attackerTokenId = attackerTokenId
    this.defenderTokenId = defenderTokenId
-    this.attackerToken = RdDCombat.$extractAttackerTokenData(attacker, attackerTokenId)
-    this.defenderToken = RdDCombat.$extractDefenderTokenData(defender, defenderTokenId, target)
+    this.attackerToken = Targets.getTokenData(attacker, attackerTokenId)
+    this.defenderToken = Targets.getTokenData(defender, defenderTokenId, target)
  }

-  static $extractAttackerTokenData(attacker, attackerTokenId) {
-    const token = canvas.tokens.get(attackerTokenId);
-    return token ? Targets.extractTokenData(token) : Targets.buildActorTokenData(attackerTokenId, attacker)
-  }
-
-  static $extractDefenderTokenData(defender, defenderTokenId, target) {
-    if (target) {
-      return Targets.extractTokenData(target)
-    }
-    const token = canvas.tokens.get(defenderTokenId);
-    return token ? Targets.extractTokenData(token) : Targets.buildActorTokenData(defenderTokenId, defender)
-  }
-
-
  /* -------------------------------------------- */
  async onEvent(button, event) {
    const chatMessage = ChatUtility.getChatMessage(event);
@@ -736,7 +723,7 @@ export class RdDCombat {

    const choixDefense = await ChatMessage.create({
      // message privé: du défenseur à lui même (et aux GMs)
-      speaker: ChatMessage.getSpeaker(this.defender, canvas.tokens.get(this.defenderTokenId)),
+      speaker: ChatMessage.getSpeaker({ actor: this.defender, token: canvas.tokens.get(this.defenderTokenId) }),
      alias: this.attacker?.getAlias(),
      whisper: ChatUtility.getOwners(this.defender),
      content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-demande-defense.hbs', defenseData)
@@ -942,7 +929,7 @@ export class RdDCombat {
  async _chatMessageDefense(paramDemandeDefense, defenderRoll) {
    const choixDefense = await ChatMessage.create({
      // message privé: du défenseur à lui même (et aux GMs)
-      speaker: ChatMessage.getSpeaker(this.defender, canvas.tokens.get(this.defenderTokenId)),
+      speaker: ChatMessage.getSpeaker({ actor: this.defender, token: canvas.tokens.get(this.defenderTokenId) }),
      alias: this.attacker?.getAlias(),
      whisper: ChatUtility.getOwners(this.defender),
      content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-demande-defense-v1.hbs', paramDemandeDefense),
--- a/module/rdd-empoignade.js
+++ b/module/rdd-empoignade.js
@@ -15,21 +15,28 @@ export class RdDEmpoignade {
  }

  /* -------------------------------------------- */
+  static getActorEmpoignade(actorId) {
+    const actor = game.actors.get(actorId)
+    if (actor == undefined) {
+      ui.notifications.warn(`Impossible de retrouver l'acteur ${actorId}, l'empoignade ne peut pas être continuée.`)
+    }
+    return actor
+  }
+
  static isCombatantEmpoignade(actorId, tokenId) {
    const combatant = RdDCombatManager.getCombatant(actorId, tokenId)
-    return MAP_PHASE.empoignade.rang == combatant?.system.init?.rang
+    return combatant && MAP_PHASE.empoignade.rang == combatant?.system.init?.rang
  }

  static async ajustementEmpoignade(attacker, defender, adjust = 1) {
    let empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)
    if (empoignade?.system.empoigneurid == defender.id) {
-      let empoignade = RdDEmpoignade.getEmpoignade(defender, attacker)
+      empoignade = RdDEmpoignade.getEmpoignade(defender, attacker)
      return await RdDEmpoignade.$ajustementEmpoignade(empoignade, defender, attacker, - adjust);
    }
    return await RdDEmpoignade.$ajustementEmpoignade(empoignade, attacker, defender, adjust);
  }

-
  static async $ajustementEmpoignade(empoignade, attacker, defender, adjust) {
    const empId = empoignade?.system.empoignadeid ?? foundry.utils.randomID(16);
    const empFin = (empoignade?.system.pointsemp ?? 0) + adjust
@@ -73,30 +80,32 @@ export class RdDEmpoignade {
      const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
      let defenseMode = event.currentTarget.attributes['data-defense-mode'].value
      RdDEmpoignade.onDefenseEmpoignade(rollData, defenseMode, "Corps à corps", "melee")
-    });
+    })
    $(html).on("click", '.defense-empoignade-esquive', event => {
      const chatMessage = ChatUtility.getChatMessage(event);
      const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
      let defenseMode = event.currentTarget.attributes['data-defense-mode'].value
      RdDEmpoignade.onDefenseEmpoignade(rollData, defenseMode, "Esquive", "derobee")
-    });
+    })
    $(html).on("click", '.empoignade-poursuivre', event => {
-      let attackerId = event.currentTarget.attributes['data-attackerId'].value
-      let defenderId = event.currentTarget.attributes['data-defenderId'].value
-      RdDEmpoignade.onAttaqueEmpoignadeValidee(game.actors.get(attackerId), game.actors.get(defenderId))
-    });
+      const attacker = RdDEmpoignade.getActorFromEventTag(event, 'data-attackerId')
+      const defender = RdDEmpoignade.getActorFromEventTag(event, 'data-defenderId')
+      if (attacker && defender) {
+        RdDEmpoignade.onAttaqueEmpoignadeValidee(attacker, defender)
+      }
+    })
    $(html).on("click", '.empoignade-entrainer-sol', event => {
      const chatMessage = ChatUtility.getChatMessage(event);
      const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
      RdDEmpoignade.entrainerAuSol(rollData)
      ChatUtility.remover(chatMessage)()
-    });
+    })
    $(html).on("click", '.empoignade-projeter-sol', event => {
      const chatMessage = ChatUtility.getChatMessage(event);
      const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
      RdDEmpoignade.projeterAuSol(rollData)
      ChatUtility.remover(chatMessage)()
-    });
+    })
    $(html).on("change", '.empoignade-perte-endurance', event => {
      const chatMessage = ChatUtility.getChatMessage(event);
      const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
@@ -104,7 +113,11 @@ export class RdDEmpoignade {
        RdDEmpoignade.perteEndurance(rollData, event.currentTarget.value)
        ChatUtility.remover(chatMessage)()
      }
-    });
+    })
+  }
+
+  static getActorFromEventTag(event, tag) {
+    return RdDEmpoignade.getActorEmpoignade(event.currentTarget.attributes[tag]?.value ?? '<inconnu>')
  }

  /* -------------------------------------------- */
@@ -112,32 +125,31 @@ export class RdDEmpoignade {
    // TODO: autoriser la perception? la comédie/séduction?
    if (RdDEmpoignade.isEmpoignadeEnCours(actor)) {
      ui.notifications.warn("Une empoignade est en cours ! Normalement, vous ne pouvez rien faire d'autre que continuer l'empoignade ou la rompre.")
-      return true;
+      return true
    }
-    return false;
+    return false
  }

  /* -------------------------------------------- */
  static $storeRollEmpoignade(msg, rollData) {
-    RdDEmpoignade.$reduceActorToIds(rollData);
-    ChatUtility.setMessageData(msg, "empoignade-roll-data", rollData);
+    ChatUtility.setMessageData(msg, "empoignade-roll-data", RdDEmpoignade.$reduceActorToIds(rollData))
  }

  static $reduceActorToIds(rollData) {
-    rollData.attacker = { id: rollData.attacker.id };
-    rollData.defender = { id: rollData.defender.id };
+    rollData.attacker = { id: rollData.attacker.id }
+    rollData.defender = { id: rollData.defender.id }
+    return rollData
  }

  /* -------------------------------------------- */
  static $readRollEmpoignade(msg) {
-    const rollData = ChatUtility.getMessageData(msg, 'empoignade-roll-data');
-    RdDEmpoignade.$replaceIdsWithActors(rollData);
-    return rollData
+    return RdDEmpoignade.$replaceIdsWithActors(ChatUtility.getMessageData(msg, 'empoignade-roll-data'))
  }

  static $replaceIdsWithActors(rollData) {
-    rollData.attacker = game.actors.get(rollData.attacker.id);
-    rollData.defender = game.actors.get(rollData.defender.id);
+    rollData.attacker = RdDEmpoignade.getActorEmpoignade(rollData.attacker.id)
+    rollData.defender = RdDEmpoignade.getActorEmpoignade(rollData.defender.id)
+    return rollData
  }

  /* -------------------------------------------- */
@@ -147,19 +159,21 @@ export class RdDEmpoignade {

  /* -------------------------------------------- */
  static getEmpoignadeById(actor, id) {
-    return actor.itemTypes[ITEM_TYPES.empoignade].find(it => it.system.empoignadeid == id)
+    return actor?.itemTypes[ITEM_TYPES.empoignade].find(it => it.system.empoignadeid == id)
  }

  /* -------------------------------------------- */
  static getEmpoignade(attacker, defender) {
-    let emp = attacker.itemTypes[ITEM_TYPES.empoignade].find(it =>
-      (it.system.empoigneurid == attacker.id && it.system.empoigneid == defender.id) ||
-      (it.system.empoigneurid == defender.id && it.system.empoigneid == attacker.id)
-    )
-    if (emp) {
-      return foundry.utils.duplicate(emp);
+    if (attacker && defender) {
+      const empoignade = attacker.itemTypes[ITEM_TYPES.empoignade].find(it =>
+        (it.system.empoigneurid == attacker.id && it.system.empoigneid == defender.id) ||
+        (it.system.empoigneurid == defender.id && it.system.empoigneid == attacker.id)
+      )
+      if (empoignade) {
+        return foundry.utils.duplicate(empoignade)
+      }
    }
-    return undefined;
+    return undefined
  }

  /* -------------------------------------------- */
@@ -180,10 +194,14 @@ export class RdDEmpoignade {
  }

  static isActionAutorisee(mode, attacker, defender) {
-    const acting = RdDEmpoignade.isActionDefenseur(mode) ? defender : attacker;
+    if (!defender || !attacker) {
+      return false
+    }
+
+    const acting = RdDEmpoignade.isActionDefenseur(mode) ? defender : attacker
    if (acting.getUserLevel(game.user) < CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER) {
      ui.notifications.warn(`Vous n'êtes pas autorisé à choisir l'action de ${acting.name}`)
-      return false;
+      return false
    }
    return true
  }
@@ -205,7 +223,6 @@ export class RdDEmpoignade {
    let empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)
    const isNouvelle = empoignade == undefined;
    empoignade = empoignade ?? (await RdDEmpoignade.createEmpoignade(attacker, defender))
-    //console.log("W.", empoignade, defender.hasArmeeMeleeEquipee())
    if ((isNouvelle || empoignade.system.pointsemp == 0) && defender.hasArmeeMeleeEquipee()) {
      ChatUtility.createChatWithRollMode(
        {
@@ -264,30 +281,34 @@ export class RdDEmpoignade {

  /* -------------------------------------------- */
  static async onAttaqueEmpoignadeFromItem(empoignade) {
-    let attacker = game.actors.get(empoignade.system.empoigneurid)
-    let defender = game.actors.get(empoignade.system.empoigneid)
-    await this.onAttaqueEmpoignadeValidee(attacker, defender)
+    const attacker = RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneurid)
+    const defender = RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneid)
+    if (attacker && defender) {
+      await this.onAttaqueEmpoignadeValidee(attacker, defender)
+    }
  }

  static async onImmobilisation(attacker, empoignade) {
-    const defender = game.actors.get(empoignade.system.empoigneid)
-    const empDefenseur = defender.itemTypes[ITEM_TYPES.empoignade]
-      .find(it => it.system.empoignadeid == empoignade.system.empoignadeid);
-    await defender.updateEmbeddedDocuments('Item', [{
-      _id: empDefenseur.id,
-      'system.immobilise': true
-    }])
-    const rollData = {
-      mode: "immobilise",
-      empoignade, attacker, defender,
-      isEmpoignade: true,
-      competence: attacker.getCompetenceCorpsACorps()
+    const defender = RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneid)
+    if (defender) {
+      const empDefenseur = defender.itemTypes[ITEM_TYPES.empoignade]
+        .find(it => it.system.empoignadeid == empoignade.system.empoignadeid);
+      await defender.updateEmbeddedDocuments('Item', [{
+        _id: empDefenseur.id,
+        'system.immobilise': true
+      }])
+      const rollData = {
+        mode: "immobilise",
+        empoignade, attacker, defender,
+        isEmpoignade: true,
+        competence: attacker.getCompetenceCorpsACorps()
+      }
+      const msg = await ChatMessage.create({
+        whisper: ChatUtility.getOwners(attacker),
+        content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-empoignade-immobilise.hbs`, rollData)
+      })
+      RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
    }
-    const msg = await ChatMessage.create({
-      whisper: ChatUtility.getOwners(attacker),
-      content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-empoignade-immobilise.hbs`, rollData)
-    })
-    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
  }

  /* -------------------------------------------- */
@@ -304,30 +325,30 @@ export class RdDEmpoignade {

  /* -------------------------------------------- */
  static async $onRollEmpoignade(rollData, isNouvelle = false) {
-    let attacker = game.actors.get(rollData.attacker.id)
-    let defender = game.actors.get(rollData.defender.id)
+    const attacker = RdDEmpoignade.getActorEmpoignade(rollData.attacker.id)
+    const defender = RdDEmpoignade.getActorEmpoignade(rollData.defender.id)

+    if (attacker && defender) {
+      if (rollData.rolled.isSuccess && isNouvelle) {
+        RdDEmpoignade.$createEtatEmpoignade(rollData.empoignade)
+      }

-    if (rollData.rolled.isSuccess && isNouvelle) {
-      RdDEmpoignade.$createEtatEmpoignade(rollData.empoignade)
+      rollData.empoignade.isSuccess = rollData.rolled.isSuccess;
+      if (rollData.rolled.isPart) {
+        rollData.particuliere = "finesse";
+      }
+      let msg = await RdDRollResult.displayRollData(rollData, defender, 'chat-empoignade-resultat.hbs');
+      RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
    }
-
-    rollData.empoignade.isSuccess = rollData.rolled.isSuccess;
-    if (rollData.rolled.isPart) {
-      rollData.particuliere = "finesse";
-    }
-    let msg = await RdDRollResult.displayRollData(rollData, defender, 'chat-empoignade-resultat.hbs');
-    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
  }

  /* -------------------------------------------- */
  static async onDefenseEmpoignade(attackerRoll, mode, competenceName = "Corps à corps", carac = "melee") {
-    let attacker = game.actors.get(attackerRoll.attacker.id)
-    let defender = game.actors.get(attackerRoll.defender.id)
+    const attacker = RdDEmpoignade.getActorEmpoignade(rollData.attacker.id)
+    const defender = RdDEmpoignade.getActorEmpoignade(rollData.defender.id)
    if (!RdDEmpoignade.isActionAutorisee(mode, attacker, defender)) {
      return
    }
-
    let empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)

    if (!empoignade) {
@@ -367,7 +388,7 @@ export class RdDEmpoignade {

  /* -------------------------------------------- */
  static async $onRollContrerLiberer(rollData) {
-    let empoignade = rollData.empoignade
+    const empoignade = rollData.empoignade

    if (rollData.mode == "contrer-empoigner" && !rollData.rolled.isSuccess) {
      empoignade.system.pointsemp++
@@ -389,35 +410,40 @@ export class RdDEmpoignade {
  static async $createEtatEmpoignade(empoignade) {
    console.log("CREATE Empoignade", empoignade)

-    let defender = game.actors.get(empoignade.system.empoigneid)
-    let attacker = game.actors.get(empoignade.system.empoigneurid)
+    const attacker = RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneurid)
+    const defender = RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneid)

-    // Creer l'empoignade sur attaquant/defenseur
-    await attacker.creerObjetParMJ(empoignade)
-    await defender.creerObjetParMJ(empoignade)
+    if (attacker && defender) {
+      // Creer l'empoignade sur attaquant et defenseur
+      await attacker.creerObjetParMJ(empoignade)
+      await defender.creerObjetParMJ(empoignade)
+    }
  }

  /* -------------------------------------------- */
  static async $updateEtatEmpoignade(empoignade, attacker, defender) {
-    const belligerants = [
-      attacker ?? game.actors.get(empoignade.system.empoigneurid),
-      defender ?? game.actors.get(empoignade.system.empoigneid)]
-    const removeEmp = empoignade.system.pointsemp == 0
+    attacker = attacker ?? RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneurid)
+    defender = defender ?? RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneid)

-    if (removeEmp) {
-      const emp = RdDEmpoignade.getEmpoignadeById(attacker, empoignade.system.empoignadeid)
-      return await attacker.deleteEmbeddedDocuments('Item', [emp.id])
-    }
-    else {
-      await Promise.all(
-        belligerants.map(async belligerant => {
-          const emp = RdDEmpoignade.getEmpoignadeById(belligerant, empoignade.system.empoignadeid)
-          return await belligerant.updateEmbeddedDocuments('Item', [{
-            _id: emp.id,
-            "system.pointsemp": empoignade.system.pointsemp,
-            "system.ausol": empoignade.system.ausol
-          }])
-        }))
+    if (attacker && defender) {
+      const belligerants = [attacker, defender]
+      const removeEmp = empoignade.system.pointsemp == 0
+
+      if (removeEmp) {
+        const emp = RdDEmpoignade.getEmpoignadeById(attacker, empoignade.system.empoignadeid)
+        return await attacker.deleteEmbeddedDocuments('Item', [emp.id])
+      }
+      else {
+        await Promise.all(
+          belligerants.map(async belligerant => {
+            const emp = RdDEmpoignade.getEmpoignadeById(belligerant, empoignade.system.empoignadeid)
+            return await belligerant.updateEmbeddedDocuments('Item', [{
+              _id: emp.id,
+              "system.pointsemp": empoignade.system.pointsemp,
+              "system.ausol": empoignade.system.ausol
+            }])
+          }))
+      }
    }
  }

@@ -425,19 +451,21 @@ export class RdDEmpoignade {
  static async $deleteEmpoignade(empoignade) {
    console.log("DELETE Empoignade", empoignade)

-    const defender = game.actors.get(empoignade.system.empoigneid)
-    const emp = RdDEmpoignade.getEmpoignadeById(defender, empoignade.system.empoignadeid)
-    await defender.deleteEmbeddedDocuments('Item', [emp.id])
+    const defender = RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneid)
+    if (defender) {
+      const emp = RdDEmpoignade.getEmpoignadeById(defender, empoignade.system.empoignadeid)
+      await defender.deleteEmbeddedDocuments('Item', [emp.id])
+    }
  }

  /* -------------------------------------------- */
  static async entrainerAuSol(rollData) {
-    let attacker = game.actors.get(rollData.attacker.id)
-    let defender = game.actors.get(rollData.defender.id)
+    const attacker = RdDEmpoignade.getActorEmpoignade(rollData.attacker.id)
+    const defender = RdDEmpoignade.getActorEmpoignade(rollData.defender.id)
    if (!RdDEmpoignade.isActionAutorisee("immobilise", attacker, defender)) {
      return
    }
-    let empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)
+    const empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)

    empoignade.system.ausol = true
    await this.$updateEtatEmpoignade(empoignade)
@@ -445,14 +473,14 @@ export class RdDEmpoignade {
    await attacker.setEffect(STATUSES.StatusProne, true);
    await defender.setEffect(STATUSES.StatusProne, true);

-    let msg = await RdDRollResult.displayRollData(rollData, attacker, 'chat-empoignade-entrainer-sol.hbs');
+    const msg = await RdDRollResult.displayRollData(rollData, attacker, 'chat-empoignade-entrainer-sol.hbs');
    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
  }

  /* -------------------------------------------- */
  static async projeterAuSol(rollData) {
-    let attacker = game.actors.get(rollData.attacker.id)
-    let defender = game.actors.get(rollData.defender.id)
+    const attacker = RdDEmpoignade.getActorEmpoignade(rollData.attacker.id)
+    const defender = RdDEmpoignade.getActorEmpoignade(rollData.defender.id)
    if (!RdDEmpoignade.isActionAutorisee("immobilise", attacker, defender)) {
      return
    }
@@ -467,8 +495,8 @@ export class RdDEmpoignade {

  /* -------------------------------------------- */
  static async perteEndurance(rollData, perteMode) {
-    let attacker = game.actors.get(rollData.attacker.id)
-    let defender = game.actors.get(rollData.defender.id)
+    const attacker = RdDEmpoignade.getActorEmpoignade(rollData.attacker.id)
+    const defender = RdDEmpoignade.getActorEmpoignade(rollData.defender.id)
    if (perteMode == "none" || !RdDEmpoignade.isActionAutorisee("immobilise", attacker, defender)) {
      return
    }
@@ -501,11 +529,11 @@ export class RdDEmpoignade {

  /* -------------------------------------------- */
  static async deleteLinkedEmpoignade(actorId, empoignade) {
-    let actorDeleteId = (actorId == empoignade.system.empoigneurid) ? empoignade.system.empoigneid : empoignade.system.empoigneurid
-    let actor = game.actors.get(actorDeleteId)
-    let emp = this.getEmpoignadeById(actor, empoignade.system.empoignadeid)
-    if (emp) {
-      await actor.deleteEmbeddedDocuments('Item', [emp.id])
+    const actorDeleteId = (actorId == empoignade.system.empoigneurid) ? empoignade.system.empoigneid : empoignade.system.empoigneurid
+    const actor = RdDEmpoignade.getActorEmpoignade(actorDeleteId)
+    const empoignadeOpposant = this.getEmpoignadeById(actor, empoignade.system.empoignadeid)
+    if (actor && empoignadeOpposant) {
+      await actor.deleteEmbeddedDocuments('Item', [empoignadeOpposant.id])
    }
  }

--- a/module/roll/roll-dialog.mjs
+++ b/module/roll/roll-dialog.mjs
@@ -380,7 +380,7 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
    this.rollData = rollData
    this.rollOptions = {
      callbacks: [
-        async r => await r.active.actor.appliquerAjoutExperience(r),
+        async r => await r.active.actor.ajoutExperience(r),
        async r => await r.active.actor.appliquerAppelMoral(r),
        ...(rollOptions.callbacks ?? [])
      ],
@@ -569,7 +569,7 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
  }

  async defaultCallback(roll, rolled) {
-    await roll.active.actor.appliquerAjoutExperience(roll)
+    await roll.active.actor.ajoutExperience(roll)
    await roll.active.actor.appliquerAppelMoral(roll)
  }

--- a/module/sommeil/app-astrologie.js
+++ b/module/sommeil/app-astrologie.js
@@ -107,7 +107,7 @@ export class AppAstrologie extends Application {
    const detail = foundry.utils.duplicate(nombreAstral);
    const timestamp = new RdDTimestamp({ indexDate: nombreAstral.index });
    detail.date = { mois: timestamp.mois, jour: timestamp.jour + 1 };
-    detail.lectures.forEach(lecture => lecture.actorName = game.actors.get(lecture.actorId).name ?? "Inconnu");
+    detail.lectures.forEach(lecture => lecture.actorName = game.actors.get(lecture.actorId)?.getAlias() ?? "Inconnu");
    return detail;
  }

--- a/module/sommeil/dialog-stress.js
+++ b/module/sommeil/dialog-stress.js
@@ -9,10 +9,10 @@ export class DialogStress extends Dialog {
      immediat: false,
      actors: game.actors.filter(actor => actor.isPersonnageJoueur())
        .map(actor => ({
-            id: actor.id,
-            name: actor.name,
-            selected: true
-          })
+          id: actor.id,
+          name: actor.name,
+          selected: true
+        })
        )
    };

@@ -22,7 +22,8 @@ export class DialogStress extends Dialog {
  }

  constructor(dialogData, html) {
-    const options = { classes: ["DialogStress"],
+    const options = {
+      classes: ["DialogStress"],
      width: 400,
      height: 'fit-content',
      'z-index': 99999
@@ -49,9 +50,12 @@ export class DialogStress extends Dialog {
    const stress = Number(this.html.find("form.rdddialogstress input[name='stress']").val());
    const compteur = (this.html.find("form.rdddialogstress input[name='immediat']").prop("checked")) ? 'experience' : 'stress';

-    this.dialogData.actors.filter(it => it.selected)
-      .map(it => game.actors.get(it.id))
-      .forEach(async actor => await actor.distribuerStress(compteur, stress, motif));
+    await Promise.all(
+      this.dialogData.actors.filter(it => it.selected)
+        .map(actor => game.actors.get(actor.id))
+        .filter(actor => actor != undefined)
+        .map(actor => actor.distribuerStress(compteur, stress, motif))
+    )
  }

  async onSelectActor(event) {
--- a/module/targets.js
+++ b/module/targets.js
@@ -10,13 +10,24 @@ export class Targets {
    return Targets.listTargets().length > 0;
  }

+  static getTokenData( actor, tokenId, target = undefined) {
+    if ( target){
+      return Targets.extractTokenData(target)
+    }
+    const token = canvas.tokens.get(tokenId);
+    return token == undefined
+      ? Targets.buildActorTokenData(tokenId, actor)
+      : Targets.extractTokenData(token);
+  }
+
  static extractTokenData(target) {
    return {
      id: target?.id,
      name: target?.document.name,
      img: target?.document.texture.src ?? target?.actor.img ?? 'icons/svg/mystery-man.svg'
-    }
-  }
+    }  
+  }  
+

  static extractActorData(actor) {
    return {
@@ -27,7 +38,7 @@ export class Targets {
  }

  static buildActorTokenData(tokenId, actor) {
-    return { id: tokenId, name: actor.name, img: actor.img ?? 'icons/svg/mystery-man.svg' };
+    return { id: tokenId, name: actor?.name?? "pas d'acteur", img: actor?.img ?? 'icons/svg/mystery-man.svg' };
  }

  static isTargetEntite(target) {
--- a/module/time/rdd-calendrier.js
+++ b/module/time/rdd-calendrier.js
@@ -359,7 +359,7 @@ export class RdDCalendrier extends Application {
          // Gestion expérience (si existante)
          request.competence = actor.getCompetence('Astrologie')
          request.selectedCarac = actor.system.carac["vue"];
-          actor.appliquerAjoutExperience(request, 'hide');
+          actor.ajoutExperience(request, 'hide');
        }
      }
      else {
--- a/module/tmr/effets-rencontres.js
+++ b/module/tmr/effets-rencontres.js
@@ -125,7 +125,7 @@ export class EffetsRencontre {
  }

  static experience_particuliere = async (dialog, context) => {
-    await context.actor.appliquerAjoutExperience(context)
+    await context.actor.ajoutExperience(context)
  }

  static regain_seuil = async (dialog, context) => {
--- a/templates/chat-resultat-ethylisme.hbs
+++ b/templates/chat-resultat-ethylisme.hbs
@@ -16,7 +16,11 @@
 {{#if jetVie.rolled.isEchec}}
 <br>
 <span>
-    {{alias}} perd {{perteEndurance.perte}} points d'endurance. {{#if perteEndurance.perteVie}}<br/>Il tombe inconscient et perd un point de vie.{{/if}}
+    {{#if perteEndurance.perte}}Perte de {{perteEndurance.perte}} points d'endurance.
+    {{else if (eq ajustementEthylique 0)}}Pas de perte d'endurance.
+    {{/if}}
+    {{#if perteEndurance.perteVie}}{{alias}} tombe inconscient et perd un point de vie.{{/if}}
+
    {{#if jetMoral}}
    <br/>Jet de moral {{#if jetMoral.succes}}réussi{{else}}manqué{{/if}} en situation heureuse ({{jetMoral.jet}}/{{jetMoral.difficulte}}).
    {{#if (gt jetMoral.ajustement 0)}}L'alcool met en joie {{alias}} qui gagne un point de moral.