module/actor.js

@@ -521,16 +521,17 @@ export class RdDActor extends RdDBaseActor {
   /* -------------------------------------------- */
   async _recuperationBlessures(message, isMaladeEmpoisonne) {
     const timestamp = game.system.rdd.calendrier.getTimestamp()
-    const blessures = this.filterItems(it => it.gravite > 0, 'blessure').sort(Misc.ascending(it => it.system.gravite))
+    const blessures = this.filterItems(it => it.system.gravite > 0, 'blessure').sort(Misc.ascending(it => it.system.gravite))
 
-    Promise.all(blessures.map(b => b.recuperationBlessure({
+    await Promise.all(blessures.map(b => b.recuperationBlessure({
       actor: this,
       timestamp,
       message,
       isMaladeEmpoisonne,
       blessures
     })));
-    await this.supprimerBlessures(filterToDelete);
+
+    await this.supprimerBlessures(it => it.system.gravite <= 0);
   }
 
   async supprimerBlessures(filterToDelete) {
@@ -548,7 +549,7 @@ export class RdDActor extends RdDBaseActor {
     }
     let vieManquante = tData.sante.vie.max - tData.sante.vie.value;
     if (vieManquante > 0) {
-      let rolled = await this.jetRecuperationConstitution(bonusSoins, message)
+      let rolled = await this.jetRecuperationConstitution(0, message)
       if (!isMaladeEmpoisonne && rolled.isSuccess) {
         const gain = Math.min(rolled.isPart ? 2 : 1, vieManquante);
         message.content += " -- récupération de vie: " + gain;
@@ -566,7 +567,7 @@ export class RdDActor extends RdDBaseActor {
 
   /* -------------------------------------------- */
   async jetRecuperationConstitution(bonusSoins, message = undefined) {
-    let difficulte = Misc.toInt(bonusSoins) + Math.min(0, this.system.sante.vie.value - this.system.sante.vie.max);
+    let difficulte = Math.min(0, this.system.sante.vie.value - this.system.sante.vie.max) + bonusSoins + this.system.sante.bonusPotion;
     let rolled = await RdDResolutionTable.roll(this.system.carac.constitution.value, difficulte);
     if (message) {
       message.content = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/roll/explain.hbs", {
@@ -1532,7 +1533,7 @@ export class RdDActor extends RdDBaseActor {
   _computeEnduranceMax() {
     const diffVie = this.system.sante.vie.max - this.system.sante.vie.value;
     const maxEndVie = this.system.sante.endurance.max - (diffVie * 2);
-    const nbGraves = this.countBlessures(it => it.isGraves()) > 0
+    const nbGraves = this.countBlessures(it => it.isGrave()) > 0
     const nbCritiques = this.countBlessures(it => it.isCritique()) > 0
     const maxEndGraves = Math.floor(this.system.sante.endurance.max / (2 * nbGraves));
     const maxEndCritiques = nbCritiques > 0 ? 1 : this.system.sante.endurance.max;

module/item/blessure.js

@@ -89,30 +89,34 @@ export class RdDItemBlessure extends RdDItem {
 
   async recuperationBlessure({ actor, timestamp, message, isMaladeEmpoisonne, blessures }) {
     if (this.parent != actor || actor == undefined) {
-      return;
+      return
     }
-    if (new RdDTimestamp(this.system.fin).isAfterIndexDate(timestamp)) {
+    if (new RdDTimestamp(this.system.temporel.fin).compare(timestamp) > 0) {
       // attente periode
       return
     }
     if (this.system.gravite > 0) {
-      const update = { premierssoins: { bonus: 0 }, soinscomplets: { bonus: 0 } }
+      const update = { system: { premierssoins: { bonus: 0 }, soinscomplets: { bonus: 0 } } }
       const gravite = this.system.gravite;
       const graviteMoindre = gravite - 2;
       const moindres = blessures.filter(it => it.system.gravite == graviteMoindre, 'blessures').length
-      const labelGravite = RdDItemBlessure.getLabelGravite(gravite);
+      const labelGravite = this.getLabelGravite();
 
-      let rolled = await actor.jetRecuperationConstitution(Misc.toInt(this.system.soinscomplets.bonus) + actor.system.sante.bonusPotion, message);
+      let rolled = await actor.jetRecuperationConstitution(this.system.soinscomplets.bonus, message);
 
       if (rolled.isETotal) {
-        message.content += ` -- une blessure ${labelGravite} s'infecte (temps de guérison augmenté de ${definition.facteur} jours, perte de vie)`;
+        message.content += ` -- une blessure ${labelGravite} s'infecte (temps de guérison augmenté de ${gravite} jours, perte de vie)`;
-        mergeObject(update, { fin: { indexDate: timestamp.addJours(gravite).indexDate } });
         await actor.santeIncDec("vie", -1);
+        mergeObject(update, {
+          system: { fin: { indexDate: timestamp.addJours(gravite).indexDate } }
+        });
       }
       else {
         if (!isMaladeEmpoisonne && rolled.isSuccess && this.peutRetrograder(graviteMoindre, moindres)) {
           message.content += ` -- une blessure ${labelGravite} cicatrise`;
-          mergeObject(update, { gravite: graviteMoindre, fin: { indexDate: timestamp.addJours(graviteMoindre).indexDate } });
+          mergeObject(update, {
+            system: { gravite: graviteMoindre, fin: { indexDate: timestamp.addJours(graviteMoindre).indexDate } }
+          });
         }
         else {
           message.content += ` -- une blessure ${labelGravite} reste stable`;

module/rdd-combat.js

@@ -1295,7 +1295,7 @@ export class RdDCombat {
       blessuresStatus: actor.computeResumeBlessure(),
       SConst: actor.getSConst(),
       actorId: actor.id,
-      isGrave: actor.countBlessures(it => it.isGraves()) > 0,
+      isGrave: actor.countBlessures(it => it.isGrave()) > 0,
       isCritique: actor.countBlessures(it => it.isCritique()) > 0
     }
 

system.json

@@ -1,8 +1,8 @@
 {
   "id": "foundryvtt-reve-de-dragon",
   "title": "Rêve de Dragon",
-  "version": "10.7.1",
+  "version": "10.7.2",
-  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-10.7.1.zip",
+  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-10.7.2.zip",
   "manifest": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/v10/system.json",
   "compatibility": {
     "minimum": "10",