Corrections relecture IA

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]);
   }
 
   /* -------------------------------------------- */

module/actor/base-actor.js

@@ -93,13 +93,8 @@ export class RdDBaseActor extends Actor {
   }
 
   static getRealActor(actorId, tokenId) {
-    if (tokenId) {
+    const actor = tokenId ? canvas.tokens.get(tokenId)?.actor : undefined
-      let token = canvas.tokens.get(tokenId)
+    return actor ?? game.actors.get(actorId)
-      if (token) {
-        return token.actor
-      }
-    }
-    return 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))

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
   }

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(
+        console.log(this.code, `Applying updates on actor ${actor.name} items`, actorItemUpdates);
-          this.code,
+        return actor.updateEmbeddedDocuments("Item", actorItemUpdates);
-          `Applying updates on actor ${actor.name} items`,
-          actorItemUpdates
-        );
-        await 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);
+      console.log(this.code, "Applying updates on items", itemUpdates)
-      await Item.updateDocuments(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 => {
+    await Promise.all(game.actors
-      if (actor.token?.img && actor.token.img.match(regexOldPngJpg)) {
+      .filter(actor => actor.token?.img && actor.token.img.match(regexOldPngJpg))
-        actor.update({ "token.img": convertImgToWebp(actor.token.img) });
+      .map(actor => actor.update({ "token.img": convertImgToWebp(actor.token.img) }))
-      }
+    )
-      const actorItemsToUpdate = prepareDocumentsImgUpdate(actor.items);
+    await Promise.all(game.actors.map(actor =>
-      actor.updateEmbeddedDocuments('Item', actorItemsToUpdate);
+      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
+    await Promise.all(
-      .filter((actor) => actor.type == "vehicule")
+      game.actors.filter(actor => actor.type == "vehicule")
-      .forEach(async (actor) => {
+        .map(actor => actor.update({
-        await 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);
+    const updates = foundry.utils.mergeObject({ _id: it.id }, this.getMapping(it).updates)
-    console.log(it.name, updates);
+    console.log(it.name, updates)
-    return updates;
+    return updates
   }
 
   async migrate() {

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.attackerToken = Targets.getTokenData(attacker, attackerTokenId)
-    this.defenderToken = RdDCombat.$extractDefenderTokenData(defender, defenderTokenId, target)
+    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),

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
+      const attacker = RdDEmpoignade.getActorFromEventTag(event, 'data-attackerId')
-      let defenderId = event.currentTarget.attributes['data-defenderId'].value
+      const defender = RdDEmpoignade.getActorFromEventTag(event, 'data-defenderId')
-      RdDEmpoignade.onAttaqueEmpoignadeValidee(game.actors.get(attackerId), game.actors.get(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", RdDEmpoignade.$reduceActorToIds(rollData))
-    ChatUtility.setMessageData(msg, "empoignade-roll-data", rollData);
   }
 
   static $reduceActorToIds(rollData) {
-    rollData.attacker = { id: rollData.attacker.id };
+    rollData.attacker = { id: rollData.attacker.id }
-    rollData.defender = { id: rollData.defender.id };
+    rollData.defender = { id: rollData.defender.id }
+    return rollData
   }
 
   /* -------------------------------------------- */
   static $readRollEmpoignade(msg) {
-    const rollData = ChatUtility.getMessageData(msg, 'empoignade-roll-data');
+    return RdDEmpoignade.$replaceIdsWithActors(ChatUtility.getMessageData(msg, 'empoignade-roll-data'))
-    RdDEmpoignade.$replaceIdsWithActors(rollData);
-    return rollData
   }
 
   static $replaceIdsWithActors(rollData) {
-    rollData.attacker = game.actors.get(rollData.attacker.id);
+    rollData.attacker = RdDEmpoignade.getActorEmpoignade(rollData.attacker.id)
-    rollData.defender = game.actors.get(rollData.defender.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 =>
+    if (attacker && defender) {
-      (it.system.empoigneurid == attacker.id && it.system.empoigneid == defender.id) ||
+      const empoignade = attacker.itemTypes[ITEM_TYPES.empoignade].find(it =>
-      (it.system.empoigneurid == defender.id && it.system.empoigneid == attacker.id)
+        (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 (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)
+    const attacker = RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneurid)
-    let defender = game.actors.get(empoignade.system.empoigneid)
+    const defender = RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneid)
-    await this.onAttaqueEmpoignadeValidee(attacker, defender)
+    if (attacker && defender) {
+      await this.onAttaqueEmpoignadeValidee(attacker, defender)
+    }
   }
 
   static async onImmobilisation(attacker, empoignade) {
-    const defender = game.actors.get(empoignade.system.empoigneid)
+    const defender = RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneid)
-    const empDefenseur = defender.itemTypes[ITEM_TYPES.empoignade]
+    if (defender) {
-      .find(it => it.system.empoignadeid == empoignade.system.empoignadeid);
+      const empDefenseur = defender.itemTypes[ITEM_TYPES.empoignade]
-    await defender.updateEmbeddedDocuments('Item', [{
+        .find(it => it.system.empoignadeid == empoignade.system.empoignadeid);
-      _id: empDefenseur.id,
+      await defender.updateEmbeddedDocuments('Item', [{
-      'system.immobilise': true
+        _id: empDefenseur.id,
-    }])
+        'system.immobilise': true
-    const rollData = {
+      }])
-      mode: "immobilise",
+      const rollData = {
-      empoignade, attacker, defender,
+        mode: "immobilise",
-      isEmpoignade: true,
+        empoignade, attacker, defender,
-      competence: attacker.getCompetenceCorpsACorps()
+        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)
+    const attacker = RdDEmpoignade.getActorEmpoignade(rollData.attacker.id)
-    let defender = game.actors.get(rollData.defender.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) {
+      rollData.empoignade.isSuccess = rollData.rolled.isSuccess;
-      RdDEmpoignade.$createEtatEmpoignade(rollData.empoignade)
+      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)
+    const attacker = RdDEmpoignade.getActorEmpoignade(rollData.attacker.id)
-    let defender = game.actors.get(attackerRoll.defender.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)
+    const attacker = RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneurid)
-    let attacker = game.actors.get(empoignade.system.empoigneurid)
+    const defender = RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneid)
 
-    // Creer l'empoignade sur attaquant/defenseur
+    if (attacker && defender) {
-    await attacker.creerObjetParMJ(empoignade)
+      // Creer l'empoignade sur attaquant et defenseur
-    await defender.creerObjetParMJ(empoignade)
+      await attacker.creerObjetParMJ(empoignade)
+      await defender.creerObjetParMJ(empoignade)
+    }
   }
 
   /* -------------------------------------------- */
   static async $updateEtatEmpoignade(empoignade, attacker, defender) {
-    const belligerants = [
+    attacker = attacker ?? RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneurid)
-      attacker ?? game.actors.get(empoignade.system.empoigneurid),
+    defender = defender ?? RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneid)
-      defender ?? game.actors.get(empoignade.system.empoigneid)]
-    const removeEmp = empoignade.system.pointsemp == 0
 
-    if (removeEmp) {
+    if (attacker && defender) {
-      const emp = RdDEmpoignade.getEmpoignadeById(attacker, empoignade.system.empoignadeid)
+      const belligerants = [attacker, defender]
-      return await attacker.deleteEmbeddedDocuments('Item', [emp.id])
+      const removeEmp = empoignade.system.pointsemp == 0
-    }
+
-    else {
+      if (removeEmp) {
-      await Promise.all(
+        const emp = RdDEmpoignade.getEmpoignadeById(attacker, empoignade.system.empoignadeid)
-        belligerants.map(async belligerant => {
+        return await attacker.deleteEmbeddedDocuments('Item', [emp.id])
-          const emp = RdDEmpoignade.getEmpoignadeById(belligerant, empoignade.system.empoignadeid)
+      }
-          return await belligerant.updateEmbeddedDocuments('Item', [{
+      else {
-            _id: emp.id,
+        await Promise.all(
-            "system.pointsemp": empoignade.system.pointsemp,
+          belligerants.map(async belligerant => {
-            "system.ausol": empoignade.system.ausol
+            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 defender = RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneid)
-    const emp = RdDEmpoignade.getEmpoignadeById(defender, empoignade.system.empoignadeid)
+    if (defender) {
-    await defender.deleteEmbeddedDocuments('Item', [emp.id])
+      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)
+    const attacker = RdDEmpoignade.getActorEmpoignade(rollData.attacker.id)
-    let defender = game.actors.get(rollData.defender.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)
+    const attacker = RdDEmpoignade.getActorEmpoignade(rollData.attacker.id)
-    let defender = game.actors.get(rollData.defender.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)
+    const attacker = RdDEmpoignade.getActorEmpoignade(rollData.attacker.id)
-    let defender = game.actors.get(rollData.defender.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
+    const actorDeleteId = (actorId == empoignade.system.empoigneurid) ? empoignade.system.empoigneid : empoignade.system.empoigneurid
-    let actor = game.actors.get(actorDeleteId)
+    const actor = RdDEmpoignade.getActorEmpoignade(actorDeleteId)
-    let emp = this.getEmpoignadeById(actor, empoignade.system.empoignadeid)
+    const empoignadeOpposant = this.getEmpoignadeById(actor, empoignade.system.empoignadeid)
-    if (emp) {
+    if (actor && empoignadeOpposant) {
-      await actor.deleteEmbeddedDocuments('Item', [emp.id])
+      await actor.deleteEmbeddedDocuments('Item', [empoignadeOpposant.id])
     }
   }
 

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

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,
+          id: actor.id,
-            name: actor.name,
+          name: actor.name,
-            selected: true
+          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)
+    await Promise.all(
-      .map(it => game.actors.get(it.id))
+      this.dialogData.actors.filter(it => it.selected)
-      .forEach(async actor => await actor.distribuerStress(compteur, stress, motif));
+        .map(actor => game.actors.get(actor.id))
+        .filter(actor => actor != undefined)
+        .map(actor => actor.distribuerStress(compteur, stress, motif))
+    )
   }
 
   async onSelectActor(event) {

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