Ajout du StatusEffect surencombré

module/actor/base-actor-reve-sheet.js

@@ -56,13 +56,15 @@ export class RdDBaseActorReveSheet extends RdDBaseActorSheet {
     if (this.options.vueDetaillee) {
       // On carac change
       this.html.find('.carac-value').change(async event => {
-        let caracName = event.currentTarget.name.replace(".value", "").replace("system.carac.", "")
-        await this.actor.updateCarac(caracName, parseInt(event.target.value))
-      });
+        if (event.currentTarget.name.includes("carac.")) {
+          let caracName = event.currentTarget.name.replace("carac.", "")
+          await this.actor.updateCarac(caracName, parseInt(event.currentTarget.value))
+        }
+      })
       // On competence change
       this.html.find('.competence-value').change(async event => {
         let compName = event.currentTarget.attributes.compname.value
-        await this.actor.updateCompetence(compName, parseInt(event.target.value))
+        await this.actor.updateCompetence(compName, parseInt(event.currentTarget.value))
       });
     }
   }

module/actor/base-actor-reve.js

@@ -89,7 +89,6 @@ export class RdDBaseActorReve extends RdDBaseActor {
   getSConst() { return 0 }
 
   /* -------------------------------------------- */
-  isSurenc() { return false }
   computeMalusSurEncombrement() { return 0 }
 
   ajustementAstrologique() { return 0 }
@@ -126,7 +125,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
   async remiseANeuf() { }
   async appliquerAjoutExperience(rollData, hideChatMessage = 'show') { }
 
-  computeResumeBlessure() {}
+  computeResumeBlessure() { }
   countBlessures(filter = it => !it.isContusion()) { return 0 }
   async santeIncDec(name, inc, isCritique = false) { }
 
@@ -230,49 +229,9 @@ export class RdDBaseActorReve extends RdDBaseActor {
     }
   }
 
-  /* -------------------------------------------- */
-  isEffectAllowed(effectId) { return false }
-
-  getEffects(filter = e => true, forceRequise = undefined) {
-    const effects = this.getEmbeddedCollection("ActiveEffect")
-    const selected = effects.filter(filter)
-    if (forceRequise && this.isForceInsuffisante(forceRequise)) {
-      selected.push(StatusEffects.prepareActiveEffect(STATUSES.StatusForceWeak))
-    }
-    return selected
-  }
-
-  getEffectByStatus(statusId) {
-    return this.getEffects().find(it => it.statuses.has(statusId));
-  }
-
-  async setEffect(statusId, status) {
-    if (this.isEffectAllowed(statusId)) {
-      const effect = this.getEffectByStatus(statusId)
-      if (!status && effect) {
-        await this.deleteEmbeddedDocuments('ActiveEffect', [effect.id], { render: true })
-      }
-      if (status && !effect) {
-        await this.createEmbeddedDocuments("ActiveEffect", [StatusEffects.prepareActiveEffect(statusId)], { render: true })
-      }
-    }
-  }
-
-  async removeEffect(id) {
-    this.removeEffects(it => it.id == id)
-  }
-
-  async removeEffects(filter = e => true) {
-    if (game.user.isGM) {
-      const effectsToRemove = this.getEffects(filter);
-      const ids = effectsToRemove.map(it => it.id);
-      await this.deleteEmbeddedDocuments('ActiveEffect', ids);
-    }
-  }
-
   /* -------------------------------------------- */
   isDemiReve() {
-    return this.getEffectByStatus(STATUSES.StatusDemiReve) != undefined
+    return this.getEffectsByStatus(STATUSES.StatusDemiReve).length > 0
   }
 
   getSurprise(isCombat = undefined, forceRequise = undefined) {

module/actor/base-actor-sang.js

@@ -186,6 +186,7 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
         await this.changeBleedingState()
         break
     }
+    await super.onCreateItem(item, options, id)
   }
 
   async onUpdateItem(item, options, id) {
@@ -194,6 +195,7 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
         await this.changeBleedingState()
         break
     }
+    await super.onUpdateItem(item, options, id)
   }
 
   async changeBleedingState() {
@@ -313,7 +315,7 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
   }
 
   isSonne() {
-    return this.getEffectByStatus(STATUSES.StatusStunned)
+    return this.getEffectsByStatus(STATUSES.StatusStunned).length > 0
   }
 
   isEffectAllowed(effectId) { return true }

module/actor/base-actor-sheet.js

@@ -49,7 +49,7 @@ export class RdDBaseActorSheet extends foundry.appv1.sheets.ActorSheet {
     formData.calc = {
       fortune: Monnaie.toSolsDeniers(this.actor.getFortune()),
       prixTotalEquipement: this.actor.computePrixTotalEquipement(),
-      encTotal: await this.actor.computeEncTotal(),
+      encTotal: this.actor.getEncTotal(),
     }
 
     this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.inventaires);
@@ -229,14 +229,6 @@ export class RdDBaseActorSheet extends foundry.appv1.sheets.ActorSheet {
     return position;
   }
 
-
-  /* -------------------------------------------- */
-  /** @override */
-  _updateObject(event, formData) {
-    // Update the Actor
-    return this.actor.update(formData);
-  }
-
   async splitItem(item) {
     const dialog = await DialogSplitItem.create(item, (item, split) => this._onSplitItem(item, split));
     dialog.render(true);

module/actor/base-actor.js

@@ -10,7 +10,7 @@ import { RdDConfirm } from "../rdd-confirm.js";
 import { RdDUtility } from "../rdd-utility.js";
 import { SystemCompendiums } from "../settings/system-compendiums.js";
 import { RdDItem } from "../item.js";
-import { STATUSES } from "../settings/status-effects.js";
+import { StatusEffects, STATUSES } from "../settings/status-effects.js";
 
 export class RdDBaseActor extends Actor {
 
@@ -243,18 +243,68 @@ export class RdDBaseActor extends Actor {
 
   getMonnaie(id) { return this.findItemLike(id, 'monnaie'); }
   getEncombrementMax() { return 0 }
+  isSurenc() { return false }
+
+  /* -------------------------------------------- */
+  isEffectAllowed(effectId) { return false }
+
+  getEffects(filter = e => true, forceRequise = undefined) {
+    const effects = this.getEmbeddedCollection("ActiveEffect")
+    const selected = effects.filter(filter)
+    if (forceRequise && this.isForceInsuffisante(forceRequise)) {
+      selected.push(StatusEffects.prepareActiveEffect(STATUSES.StatusForceWeak))
+    }
+    return selected
+  }
+
+  getEffectsByStatus(effectId) {
+    return this.getEffects().filter(it => it.statuses.has(effectId))
+  }
+
+  async setEffect(effectId, status) {
+    if (this.isEffectAllowed(effectId)) {
+      const effects = this.getEffectsByStatus(effectId)
+      if (!status && effects.length > 0) {
+        await this.deleteEmbeddedDocuments('ActiveEffect', effects.map(it => it.id), { render: true })
+      }
+      if (status && effects.length == 0) {
+        await this.createEmbeddedDocuments("ActiveEffect", [StatusEffects.prepareActiveEffect(effectId)], { render: true })
+      }
+    }
+  }
+
+  async removeEffect(id) {
+    this.removeEffects(it => it.id == id)
+  }
+
+  async removeEffects(filter = e => true) {
+    if (game.user.isGM) {
+      const effectsToRemove = this.getEffects(filter);
+      const ids = effectsToRemove.map(it => it.id);
+      await this.deleteEmbeddedDocuments('ActiveEffect', ids);
+    }
+  }
 
   /* -------------------------------------------- */
   async updateCarac(caracName, to) {
   }
+
+  async onUpdateActor(change, options, actorId) {
+    const updatedCarac = change?.system?.carac
+    if (updatedCarac && (updatedCarac.force || updatedCarac.reve || updatedCarac.taille)) {
+      console.log(' onUpdateActor', change, options, actorId)
+      await this.setEffect(STATUSES.StatusSurEnc, this.isSurenc())
+    }
+  }
+
   /* -------------------------------------------- */
   async onPreUpdateItem(item, change, options, id) { }
 
-  async onCreateItem(item, options, id) { }
+  async onCreateItem(item, options, id) {
+  }
 
-  async onUpdateItem(item, options, id) { }
-
-  async onUpdateActor(update, options, actorId) { }
+  async onUpdateItem(item, options, id) {
+  }
 
   async onDeleteItem(item, options, id) {
     if (item.isInventaire()) {
@@ -262,6 +312,7 @@ export class RdDBaseActor extends Actor {
     }
   }
 
+
   async _removeItemFromConteneur(item) {
     const updates = this.items.filter(it => it.isConteneur() && it.system.contenu.includes(item.id))
       .map(conteneur => {
@@ -510,16 +561,22 @@ export class RdDBaseActor extends Actor {
 
   /* -------------------------------------------- */
   async computeEncTotal() {
-    if (!this.pack) {
+    if (this.pack) {
+      this.encTotal = 0
+    }
+    else {
+      const wasSurenc = this.isSurenc()
       this.encTotal = this.items.filter(it => RdDItem.getItemTypesInventaire().includes(it.type))
         .map(it => it.getEncTotal()).reduce(Misc.sum(), 0)
-      return this.encTotal;
+      const isSurenc = this.isSurenc()
+      if (isSurenc != wasSurenc) {
+        await this.setEffect(STATUSES.StatusSurEnc, isSurenc)
+      }
     }
-    return 0;
   }
 
   getEncTotal() {
-    return Math.floor(this.encTotal ?? 0);
+    return Math.floor(this.encTotal ?? 0)
   }
 
   async createItem(type, name = undefined) {
@@ -570,7 +627,7 @@ export class RdDBaseActor extends Actor {
         }
       }
     }
-    await this.computeEncTotal();
+    await this.computeEncTotal()
     return result;
   }
 

module/actor/experience-log.js

@@ -29,7 +29,7 @@ export class ExperienceLog {
     };
     console.log('ExperienceLog.add', newXpLog)
     const newExperienceLog = (actor.system.experiencelog ?? []).concat([newXpLog]);
-    await actor.update({ [`system.experiencelog`]: newExperienceLog });
+    await actor.update({ [`system.experiencelog`]: newExperienceLog }, { noHook: true });
   }
 
   static labelTopic(topic) {