await ChatMessage.create

ChatMessage.create est async, il faut donc de préférence l'appeler avec un await. Des effets secondaires avaient lieu (ordre de messages, updates ultérieurs parfois pas pris en compte)
2026-05-02 00:42:45 +02:00
parent d15d0989a3
commit 7fb0ee1659
26 changed files with 184 additions and 191 deletions
@@ -256,7 +256,7 @@ export class RdDActor extends RdDBaseActorSang {
      console.log('perte de rêve des enchantements', toUpdate)
      const messageUpdates = await Promise.all(
        toUpdate.map(async it => await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-pertereve-enchantement-chateaudormant.hbs`, it)))
-      ChatMessage.create({
+      await ChatMessage.create({
        whisper: ChatUtility.getOwners(this),
        content: messageUpdates.reduce(Misc.joining('<br>'))
      })
@@ -322,8 +322,7 @@ export class RdDActor extends RdDBaseActorSang {
      await this.setBonusPotionSoin(0);
    }
    await this.resetInfoSommeil()
-    ChatMessage.create(message);
-    setTimeout(() => this.sheet.render(), 20)
+    await ChatMessage.create(message)
  }

  async _recuperationSante(message) {
@@ -364,7 +363,7 @@ export class RdDActor extends RdDBaseActorSang {
    const message = {
      whisper: ChatUtility.getOwners(this),
      content: ""
-    };
+    }

    await this._recuperationSante(message)
    await this._recupereMoralChateauDormant(message)
@@ -375,12 +374,12 @@ export class RdDActor extends RdDBaseActorSang {
    await this.retourSust(message)
    await this.$perteReveEnchantementsChateauDormants()
    await this.$suppressionLancementsSort()
-    await RdDCoeur.applyCoeurChateauDormant(this, message);
+    await RdDCoeur.applyCoeurChateauDormant(this, message)
    if (message.content != "") {
-      message.content = `A la fin Chateau Dormant, ${message.content}<br>Un nouveau jour se lève`;
-      ChatMessage.create(message);
+      message.content = `A la fin Chateau Dormant, ${message.content}<br>Un nouveau jour se lève`
+      await ChatMessage.create(message)
    }
-    await this.resetInfoSommeil();
+    await this.resetInfoSommeil()
  }

  async resetInfoSommeil() {
@@ -536,37 +535,36 @@ export class RdDActor extends RdDBaseActorSang {
    }

    if (!options.grisReve) {
-      ChatMessage.create(message);
+      await ChatMessage.create(message)
    }
    if (options.chateauDormant) {
-      await this.$dormirChateauDormant();
+      await this.$dormirChateauDormant()
    }
-    setTimeout(() => this.sheet.render(), 20)
  }

  async reveilReveDeDragon(message, heures) {
    const restant = Math.max(this.system.sommeil?.heures - heures, 0)
    if (restant > 0) {
-      await this.update({ 'system.sommeil': { heures: restant } });
+      await this.update({ 'system.sommeil': { heures: restant } })
    }
  }

  async $dormirDesHeures(message, heures, options) {
    const dormi = { heures: 0, etat: 'dort', jetsReve: [] };
    for (; dormi.heures < heures && dormi.etat == 'dort'; dormi.heures++) {
-      await this.$recupererEthylisme(message);
+      await this.$recupererEthylisme(message)
      if (options.grisReve) {
-        await this.$recupererFatigue(message);
+        await this.$recupererFatigue(message)
      }
      else if (!this.system.sommeil?.insomnie) {
-        await this.$recupererFatigue(message);
-        await this.$jetRecuperationReve(dormi, message);
+        await this.$recupererFatigue(message)
+        await this.$jetRecuperationReve(dormi, message)
        if (dormi.etat == 'dort' && EffetsDraconiques.isDonDoubleReve(this)) {
-          await this.$jetRecuperationReve(dormi, message);
+          await this.$jetRecuperationReve(dormi, message)
        }
      }
    }
-    return dormi;
+    return dormi
  }

  /* -------------------------------------------- */
@@ -583,7 +581,7 @@ export class RdDActor extends RdDBaseActorSang {
      }
      else {
        if (!ReglesOptionnelles.isUsing("recuperation-reve")) {
-          ChatMessage.create({
+          await ChatMessage.create({
            whisper: ChatUtility.getOwners(this),
            content: `Pas de récupération de rêve (${reve} points ignorés)`
          })
@@ -891,7 +889,7 @@ export class RdDActor extends RdDBaseActorSang {
      await competence.update({ 'system.xp': toXp })
      await ExperienceLog.add(this, XP_TOPIC.XP, fromXp, toXp, competence.name, true)
      if (toXp > fromXp) {
-        RdDUtility.checkThanatosXP(competence)
+        await RdDUtility.checkThanatosXP(competence)
      }
    }
  }
@@ -907,7 +905,7 @@ export class RdDActor extends RdDBaseActorSang {
      await competence.update({ 'system.xp_sort': toXpSort })
      await ExperienceLog.add(this, XP_TOPIC.XPSORT, fromXpSort, toXpSort, competence.name, true)
      if (toXpSort > fromXpSort) {
-        RdDUtility.checkThanatosXP(competence)
+        await RdDUtility.checkThanatosXP(competence)
      }
    }
  }
@@ -997,7 +995,7 @@ export class RdDActor extends RdDBaseActorSang {
      await this.update({ "system.reve.refoulement.value": 0 })
      await this.ajouterSouffle({ chat: true })
    }
-    else{
+    else {
      await this.update({ "system.reve.refoulement.value": refoulement })
    }
    return roll
@@ -1009,7 +1007,7 @@ export class RdDActor extends RdDBaseActorSang {
    //souffle.id = undefined; //TBC
    await this.createEmbeddedDocuments('Item', [souffle])
    if (options.chat) {
-      ChatMessage.create({
+      await ChatMessage.create({
        whisper: ChatUtility.getOwners(this),
        content: this.name + " subit un Souffle de Dragon  : " + souffle.name
      })
@@ -1019,22 +1017,19 @@ export class RdDActor extends RdDBaseActorSang {

  /* -------------------------------------------- */
  async ajouterQueue(options = { chat: false }) {
-    let queue;
-    if (this.system.reve.reve.thanatosused) {
-      queue = await RdDRollTables.getOmbre();
+    const thanatos = this.system.reve.reve.thanatosused;
+    const queue = (thanatos ? await RdDRollTables.getOmbre() : await RdDRollTables.getQueue())
+    if (thanatos) {
      await this.update({ "system.reve.reve.thanatosused": false })
    }
-    else {
-      queue = await RdDRollTables.getQueue();
-    }
-    await this.createEmbeddedDocuments('Item', [queue]);
+    await this.createEmbeddedDocuments('Item', [queue])
    if (options.chat) {
-      ChatMessage.create({
+      await ChatMessage.create({
        whisper: ChatUtility.getOwners(this),
        content: this.name + " subit une Queue de Dragon : " + queue.name
      })
    }
-    return queue;
+    return queue
  }

  /* -------------------------------------------- */
@@ -1098,14 +1093,14 @@ export class RdDActor extends RdDBaseActorSang {
  }
  /* -------------------------------------------- */
  async reinsertionAleatoire(raison, accessible = tmr => true) {
-    const innaccessible = this.buildTMRInnaccessible();
-    let tmr = await TMRUtility.getTMRAleatoire(tmr => accessible(tmr) && !innaccessible.includes(tmr.coord));
-    ChatMessage.create({
+    const innaccessible = this.buildTMRInnaccessible()
+    let tmr = await TMRUtility.getTMRAleatoire(tmr => accessible(tmr) && !innaccessible.includes(tmr.coord))
+    await ChatMessage.create({
      content: `${raison} : ré-insertion aléatoire.`,
      whisper: ChatUtility.getOwners(this)
-    });
-    await this.forcerPositionTMRInconnue(tmr);
-    return tmr;
+    })
+    await this.forcerPositionTMRInconnue(tmr)
+    return tmr
  }

  async forcerPositionTMRInconnue(tmr) {
@@ -1169,7 +1164,7 @@ export class RdDActor extends RdDBaseActorSang {
  async jetEndurance(resteEndurance = undefined) {
    const result = super.jetEndurance(resteEndurance);
    if (result.jetEndurance == 1) {
-      ChatMessage.create({ content: await this._gainXpConstitutionJetEndurance() });
+      await ChatMessage.create({ content: await this._gainXpConstitutionJetEndurance() })
    }
    return result;
  }
@@ -1190,7 +1185,7 @@ export class RdDActor extends RdDBaseActorSang {
    }
    const jetMoral = await this._jetDeMoral(situation, bonmoment)
    const finMessage = (jetMoral.ajustement == 0 ? "Vous gardez votre moral" : jetMoral.ajustement > 0 ? "Vous gagnez du moral" : "Vous perdez du moral");
-    ChatMessage.create({
+    await ChatMessage.create({
      whisper: ChatUtility.getOwners(this),
      content: `${finMessage} - jet ${jetMoral.succes ? "réussi" : "manqué"} en situation ${SITUATION_MORAL[situation] ?? situation} (${jetMoral.jet}/${jetMoral.difficulte}).`
    })
@@ -1494,7 +1489,7 @@ export class RdDActor extends RdDBaseActorSang {
      exaltation: exaltation
    };

-    ChatMessage.create({
+    await ChatMessage.create({
      whisper: ChatUtility.getOwners(this),
      content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-resultat-transformer-stress.hbs`, stressRollData)
    });
@@ -1561,7 +1556,7 @@ export class RdDActor extends RdDBaseActorSang {
          xp: carac.xp
        }
        if (display) {
-          ChatMessage.create({
+          await ChatMessage.create({
            whisper: ChatUtility.getOwners(this),
            content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-carac-xp.hbs`, checkXp)
          });
@@ -1596,7 +1591,7 @@ export class RdDActor extends RdDBaseActorSang {
        ChatUtility.blindMessageToGM({ content: content })
      }
      else {
-        ChatMessage.create({
+        await ChatMessage.create({
          whisper: ChatUtility.getOwners(this),
          content: content
        });
@@ -1700,22 +1695,22 @@ export class RdDActor extends RdDBaseActorSang {
  }

  /* -------------------------------------------- */
-  isMauvaiseRencontre() { // Gestion queue/souffle 'Mauvaise Rencontre en Perpective'
-    let addMsg = "";
-    let rencSpecial = EffetsDraconiques.mauvaiseRencontre(this);
+  async isMauvaiseRencontre() { // Gestion queue/souffle 'Mauvaise Rencontre en Perpective'
+    let addMsg = ""
+    let rencSpecial = EffetsDraconiques.mauvaiseRencontre(this)
    if (rencSpecial) {
      if (rencSpecial.type != 'souffle') {
-        this.deleteEmbeddedDocuments('Item', [rencSpecial.id]); // Suppression dans la liste des queues
-        addMsg = " La queue a été supprimée de votre fiche automatiquement";
+        await this.deleteEmbeddedDocuments('Item', [rencSpecial.id]) // Suppression dans la liste des queues
+        addMsg = " La queue a été supprimée de votre fiche automatiquement"
      } else {
-        addMsg = " Vous devez gérer manuellement le décompte de mauvaises rencontres.";
+        addMsg = " Vous devez gérer manuellement le décompte de mauvaises rencontres."
      }
-      ChatMessage.create({
+      await ChatMessage.create({
        content: "Vous êtes sous le coup d'une Mauvaise Rencontre en Persective." + addMsg,
        whisper: ChatUtility.getOwners(this)
-      });
+      })
    }
-    return rencSpecial;
+    return rencSpecial
  }

  /* -------------------------------------------- */
@@ -1725,7 +1720,7 @@ export class RdDActor extends RdDBaseActorSang {
      ChatMessage.create({
        content: `Vous êtes sous le coup d'Inertie Draconique : vous perdrez ${countInertieDraconique + 1} cases de Fatigue par déplacement au lieu d'une.`,
        whisper: ChatUtility.getOwners(this)
-      });
+      })
    }
    return countInertieDraconique + 1;
  }
@@ -1733,11 +1728,11 @@ export class RdDActor extends RdDBaseActorSang {
  /* -------------------------------------------- */
  async checkSoufflePeage(tmr) {
    if ((tmr.type == 'pont' || tmr.type == 'cite') && EffetsDraconiques.isPeage(this)) {
-      await this.reveActuelIncDec(-1);
-      ChatMessage.create({
+      await this.reveActuelIncDec(-1)
+      await ChatMessage.create({
        content: "Vous êtes sous le coup d'un Péage : l'entrée sur cette case vous a coûté 1 Point de Rêve (déduit automatiquement).",
        whisper: ChatUtility.getOwners(this)
-      });
+      })
    }
  }

@@ -1763,7 +1758,7 @@ export class RdDActor extends RdDBaseActorSang {
      }
      if (reveActuel > rollData.depenseReve) {
        // Incrémenter/gére le bonus de case
-        RdDItemSort.incrementBonusCase(this, selectedSort, rollData.tmr.coord)
+        await RdDItemSort.incrementBonusCase(this, selectedSort, rollData.tmr.coord)

        if (rollData.isSortReserve) {
          await this.sortMisEnReserve(selectedSort, rollData.competence, rollData.tmr.coord, Number(selectedSort.system.ptreve_reel))
@@ -1796,7 +1791,7 @@ export class RdDActor extends RdDBaseActorSang {
    await RdDRollResult.displayRollData(rollData, this, 'chat-resultat-sort.hbs')

    if (reveActuel == 0) { // 0 points de reve
-      ChatMessage.create({ content: this.name + " est réduit à 0 Points de Rêve, et tombe endormi !" })
+      await ChatMessage.create({ content: this.name + " est réduit à 0 Points de Rêve, et tombe endormi !" })
    }
    if (!rollData.isSortReserve || !rolled.isSuccess) {
      this.tmrApp?.close()
@@ -2159,7 +2154,7 @@ export class RdDActor extends RdDBaseActorSang {
  async appelDestinee(onSuccess = () => { }, onEchec = () => { }) {
    let destinee = this.system.compteurs.destinee?.value ?? 0;
    if (destinee > 0) {
-      ChatMessage.create({ content: `<span class="rdd-roll-part">${this.name} a fait appel à la Destinée !</span>` });
+      await ChatMessage.create({ content: `<span class="rdd-roll-part">${this.name} a fait appel à la Destinée !</span>` });
      await this.update({ 'system.compteurs.destinee.value ': destinee - 1 })
      onSuccess()
    }
@@ -2194,10 +2189,10 @@ export class RdDActor extends RdDBaseActorSang {
    }
    if (this.checkDesirLancinant()) {
      // Cas de désir lancinant, pas d'expérience sur particulière
-      ChatMessage.create({
+      await ChatMessage.create({
        content: `Vous souffrez au moins d'un Désir Lancinant, vous ne pouvez pas gagner d'expérience sur une Particulière tant que le désir n'est pas assouvi`,
        whisper: ChatUtility.getOwners(this)
-      });
+      })
      return []
    }

@@ -2325,15 +2320,15 @@ export class RdDActor extends RdDBaseActorSang {
  }

  /* -------------------------------------------- */
-  countMonteeLaborieuse() { // Return +1 par queue/ombre/souffle Montée Laborieuse présente
+  async countMonteeLaborieuse() { // Return +1 par queue/ombre/souffle Montée Laborieuse présente
    let countMonteeLaborieuse = EffetsDraconiques.countMonteeLaborieuse(this);
    if (countMonteeLaborieuse > 0) {
-      ChatMessage.create({
+      await ChatMessage.create({
        content: `Vous êtes sous le coup d'une Montée Laborieuse : vos montées en TMR coûtent ${countMonteeLaborieuse} Point de Rêve de plus.`,
        whisper: ChatUtility.getOwners(this)
      });
    }
-    return countMonteeLaborieuse;
+    return countMonteeLaborieuse
  }

  /* -------------------------------------------- */
@@ -2376,9 +2371,9 @@ export class RdDActor extends RdDBaseActorSang {
  async _doDisplayTMR(mode) {
    let isRapide = mode == "rapide";
    if (mode != "visu") {
-      let minReveValue = (isRapide && !EffetsDraconiques.isDeplacementAccelere(this) ? 3 : 2) + this.countMonteeLaborieuse();
+      let minReveValue = (isRapide && !EffetsDraconiques.isDeplacementAccelere(this) ? 3 : 2) + (await this.countMonteeLaborieuse())
      if (this.getReveActuel() < minReveValue) {
-        ChatMessage.create({
+        await ChatMessage.create({
          content: `Vous n'avez les ${minReveValue} Points de Reve nécessaires pour monter dans les Terres Médianes`,
          whisper: ChatUtility.getOwners(this)
        });
@@ -2420,15 +2415,16 @@ export class RdDActor extends RdDBaseActorSang {
      if (!viewOnly) {
        await this.supprimerSignesDraconiques(it => it.system.ephemere && it.system.duree == '1 round', { render: false })
        await this.setEffect(STATUSES.StatusDemiReve, false)
-        ChatUtility.tellToUserAndGM(message)
+        await ChatUtility.tellToUserAndGM(message)
      }
    }
  }

  async supprimerSignesDraconiques(filter = it => true, options = { render: true }) {
-    const signes = this.itemTypes[ITEM_TYPES.signedraconique].filter(filter)
-    if (signes.length > 0) {
-      this.deleteEmbeddedDocuments("Item", signes.map(item => item.id), options)
+    const ids = this.itemTypes[ITEM_TYPES.signedraconique].filter(filter)
+      .map(it => it.id)
+    if (ids.length > 0) {
+      await this.deleteEmbeddedDocuments("Item", ids, options)
    }
  }

@@ -2466,9 +2462,9 @@ export class RdDActor extends RdDBaseActorSang {
  }

  /* -------------------------------------------- */
-  verifierForceMin(item) {
+  async verifierForceMin(item) {
    if (item.type == 'arme' && item.system.force > parseInt(this.system.carac.force.value)) {
-      ChatMessage.create({
+      await ChatMessage.create({
        content: `<strong>${this.name} s'est équipé(e) de l'arme ${item.name}, mais n'a pas une force suffisante pour l'utiliser normalement </strong>
                  (${item.system.force} nécessaire pour une Force de ${this.system.carac.force.value})`
      });
@@ -2482,7 +2478,7 @@ export class RdDActor extends RdDBaseActorSang {
      await item.update({ "system.equipe": isEquipe })
      this.computeEncTotal()
      if (isEquipe)
-        this.verifierForceMin(item)
+        await this.verifierForceMin(item)
    }
  }

@@ -2744,25 +2740,25 @@ export class RdDActor extends RdDBaseActorSang {

  /* -------------------------------------------- */
  async consommerPotionSoin(potion) {
-    potion.alias = this.name;
-    potion.supprimer = true;
+    potion.alias = this.name
+    potion.supprimer = true

    if (potion.system.magique) {
      // Gestion de la résistance:
-      potion.rolled = await RdDResolutionTable.roll(this.getReveActuel(), -8);
+      potion.rolled = await RdDResolutionTable.roll(this.getReveActuel(), -8)
      if (potion.rolled.isEchec) {
        await this.reveActuelIncDec(-1);
-        potion.guerisonData = await this.buildPotionGuerisonList(potion.system.puissance);
-        potion.guerisonMinutes = potion.guerisonData.pointsConsommes * 5;
+        potion.guerisonData = await this.buildPotionGuerisonList(potion.system.puissance)
+        potion.guerisonMinutes = potion.guerisonData.pointsConsommes * 5
      }
    }
    if (!potion.system.magique || potion.rolled.isSuccess) {
-      await this.setBonusPotionSoin(potion.system.herbebonus);
+      await this.setBonusPotionSoin(potion.system.herbebonus)
    }
-    ChatMessage.create({
+    await ChatMessage.create({
      whisper: ChatUtility.getOwners(this),
      content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-consommer-potion-soin.hbs`, potion)
-    });
+    })
  }

  async setBonusPotionSoin(bonus) {
@@ -2796,10 +2792,10 @@ export class RdDActor extends RdDBaseActorSang {
    if (!potion.system.magique || potion.rolled.isSuccess) {
      this.bonusRepos = potion.system.herbebonus;
    }
-    ChatMessage.create({
+    await ChatMessage.create({
      whisper: ChatUtility.getOwners(this),
      content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-consommer-potion-repos.hbs`, potion)
-    });
+    })
  }

  /* -------------------------------------------- */
@@ -2821,7 +2817,7 @@ export class RdDActor extends RdDBaseActorSang {
    await this.createEmbeddedDocuments('Item', [newPotion])
    await this.diminuerQuantiteObjet(herbeData._id, herbeData.nbBrins)

-    ChatMessage.create({
+    await ChatMessage.create({
      whisper: ChatUtility.getOwners(this),
      content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-fabriquer-potion-base.hbs`, {
        alias: this.getAlias(),
@@ -2839,19 +2835,19 @@ export class RdDActor extends RdDBaseActorSang {

  /* -------------------------------------------- */
  async consommerPotionGenerique(potion) {
-    potion.alias = this.name;
+    potion.alias = this.name

    if (potion.system.magique) {
      // Gestion de la résistance:
      potion.rolled = await RdDResolutionTable.roll(this.getReveActuel(), -8);
      if (potion.rolled.isEchec) {
-        await this.reveActuelIncDec(-1);
+        await this.reveActuelIncDec(-1)
      }
    }
-    ChatMessage.create({
+    await ChatMessage.create({
      whisper: ChatUtility.getOwners(this),
      content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-consommer-potion-generique.hbs`, potion)
-    });
+    })
  }

  /* -------------------------------------------- */
@@ -2914,7 +2910,7 @@ export class RdDActor extends RdDBaseActorSang {
      let draconique = Draconique.all().find(it => it.match(item));
      if (draconique) {
        await draconique.onActorCreateOwned(this, item)
-        this.notifyGestionTeteSouffleQueue(item, draconique.manualMessage());
+        await this.notifyGestionTeteSouffleQueue(item, draconique.manualMessage());
      }
      await this.setInfoSommeilInsomnie();
    }
@@ -2970,8 +2966,8 @@ export class RdDActor extends RdDBaseActorSang {
  }

  /* -------------------------------------------- */
-  notifyGestionTeteSouffleQueue(item, manualMessage = true) {
-    ChatMessage.create({
+  async notifyGestionTeteSouffleQueue(item, manualMessage = true) {
+    await ChatMessage.create({
      whisper: ChatUtility.getOwners(this),
      content: `${this.name} a reçu un/une ${item.type}: ${item.name}, qui ${manualMessage ? "n'est pas" : "est"} géré(e) automatiquement. ${manualMessage ? manualMessage : ''}`
    });