Fix remoteActorCall

Reviewed-on: public/foundryvtt-reve-de-dragon#666

changelog.md

@@ -1,5 +1,14 @@
 # v11.0
 
+## v11.0.15 - L'apprentissage de Khrachtchoum
+- Fix: l'expérience ne s'appliquait plus sur certaines réussites particulières (régression depuis la 11.0.7)
+
+## v11.0.14 - Les pincettes de Khrachtchoum le Problémeux
+- Correction du calcul de la place restante lors de l'ajout dans un conteneur
+
+## v11.0.13 - La multiplication de l'eau de Khrachtchoum le Problémeux
+- Correction de la vente depuis un commerce ayant des quantités illimitées
+
 ## v11.0.12 - Les poids de la mesure de Khrachtchoum le Problémeux
 - Correction des malus de surencombrement
 - Le malus armure est correctement affiché dans l'onglet des caractéristiques

module/actor.js

@@ -265,7 +265,7 @@ export class RdDActor extends RdDBaseActor {
   }
   /* -------------------------------------------- */
   getDraconicList() {
-    return this.items.filter(it => it.isCompetencePersonnage() && it.system.categorie == 'draconic')
+    return this.itemTypes[TYPES.competence].filter(it => it.system.categorie == 'draconic')
   }
   /* -------------------------------------------- */
   getBestDraconic() {
@@ -275,13 +275,13 @@ export class RdDActor extends RdDBaseActor {
   }
 
   getDraconicOuPossession() {
-    const possession = this.items.filter(it => it.type == TYPES.competencecreature && it.system.categorie == 'possession')
+    const possession = this.itemTypes[TYPES.competencecreature].filter(it => it.system.categorie == 'possession')
       .sort(Misc.descending(it => it.system.niveau))
       .find(it => true);
     if (possession) {
-      return possession.clone();
+      return possession;
     }
-    const draconics = [...this.getDraconicList().filter(it => it.system.niveau >= 0).map(it => it.clone()),
+    const draconics = [...this.getDraconicList().filter(it => it.system.niveau >= 0),
       POSSESSION_SANS_DRACONIC]
       .sort(Misc.descending(it => it.system.niveau));
     return draconics[0];
@@ -1741,6 +1741,7 @@ export class RdDActor extends RdDBaseActor {
   async consommerNourritureboisson(itemId, choix = { doses: 1, seForcer: false, supprimerSiZero: false }, userId = undefined) {
     if (userId != undefined && userId != game.user.id) {
       RdDBaseActor.remoteActorCall({
+        tokenId: actor.token?.id,
         actorId: this.id,
         method: 'consommerNourritureboisson',
         args: [itemId, choix, userId]
@@ -3121,7 +3122,7 @@ export class RdDActor extends RdDBaseActor {
 
   async onRollTachePremiersSoins(blessureId, rollData) {
     if (!this.isOwner) {
-      return RdDBaseActor.remoteActorCall({ actorId: this.id, method: 'onRollTachePremiersSoins', args: [blessureId, rollData] });
+      return RdDBaseActor.remoteActorCall({ tokenId: actor.token?.id, actorId: this.id, method: 'onRollTachePremiersSoins', args: [blessureId, rollData] });
     }
     const blessure = this.getItem(blessureId, 'blessure')
     console.log('TODO update blessure', this, blessureId, rollData, rollData.tache);
@@ -3151,7 +3152,7 @@ export class RdDActor extends RdDBaseActor {
 
   async onRollSoinsComplets(blessureId, rollData) {
     if (!this.isOwner) {
-      return RdDBaseActor.remoteActorCall({ actorId: this.id, method: 'onRollSoinsComplets', args: [blessureId, rollData] });
+      return RdDBaseActor.remoteActorCall({ tokenId: actor.token?.id, actorId: this.id, method: 'onRollSoinsComplets', args: [blessureId, rollData] });
     }
     const blessure = this.getItem(blessureId, 'blessure')
     if (blessure && blessure.system.premierssoins.done && !blessure.system.soinscomplets.done) {
@@ -3245,6 +3246,7 @@ export class RdDActor extends RdDBaseActor {
     const attackerId = attacker?.id;
     if (ReglesOptionnelles.isUsing('validation-encaissement-gr') && !game.user.isGM) {
       RdDBaseActor.remoteActorCall({
+        tokenId: actor.token?.id,
         actorId: this.id,
         method: 'appliquerEncaissement',
         args: [rollData, show, attackerId]

module/actor/base-actor.js

@@ -50,7 +50,13 @@ export class RdDBaseActor extends Actor {
 
   static onRemoteActorCall(callData, userId) {
     if (userId == game.user.id) {
-      const actor = game.actors.get(callData?.actorId);
+      let actor = game.actors.get(callData?.actorId);
+      if ( callData.tokenId) {
+        let token = canvas.tokens.placeables.find(t => t.id == callData.tokenId)
+        if (token) {
+          actor = token.actor
+        }
+      }
       if (Misc.isOwnerPlayerOrUniqueConnectedGM(actor)) { // Seul le joueur choisi effectue l'appel: le joueur courant si propriétaire de l'actor, ou le MJ sinon
         const args = callData.args;
         console.info(`RdDBaseActor.onRemoteActorCall: pour l'Actor ${callData.actorId}, appel de RdDBaseActor.${callData.method}(`, ...args, ')');
@@ -144,9 +150,10 @@ export class RdDBaseActor extends Actor {
       .forEach(async it => await it.onFinPeriodeTemporel(oldTimestamp, newTimestamp))
   }
 
-  async creerObjetParMJ(object){
+  async creerObjetParMJ(object) {
     if (!Misc.isUniqueConnectedGM()) {
       RdDBaseActor.remoteActorCall({
+        tokenId: this.token?.id,
         actorId: this.id,
         method: 'creerObjetParMJ',
         args: [object]
@@ -220,6 +227,7 @@ export class RdDBaseActor extends Actor {
     if (fromActorId && !game.user.isGM) {
       RdDBaseActor.remoteActorCall({
         userId: Misc.connectedGMOrUser(),
+        tokenId: actor.token?.id,
         actorId: this.id,
         method: 'ajouterSols', args: [sols, fromActorId]
       });
@@ -250,6 +258,7 @@ export class RdDBaseActor extends Actor {
     }
     if (!Misc.isUniqueConnectedGM()) {
       RdDBaseActor.remoteActorCall({
+        tokenId: actor.token?.id,
         actorId: achat.vendeurId ?? achat.acheteurId,
         method: 'achatVente',
         args: [achat]
@@ -262,10 +271,10 @@ export class RdDBaseActor extends Actor {
     const quantite = (achat.choix.nombreLots ?? 1) * (achat.vente.tailleLot);
     const itemVendu = vendeur?.getItem(achat.vente.item._id) ?? game.items.get(achat.vente.item._id);
     if (!itemVendu) {
-      ChatUtility.notifyUser(achat.userId, 'warn', vendeur ? `Le vendeur n'a pas plus de ${achat.vente.item.name} !`: `Impossible de retrouver: ${achat.vente.item.name} !`);
+      ChatUtility.notifyUser(achat.userId, 'warn', vendeur ? `Le vendeur n'a pas plus de ${achat.vente.item.name} !` : `Impossible de retrouver: ${achat.vente.item.name} !`);
       return;
     }
-    if (vendeur && !this.verifierQuantite(itemVendu, quantite)) {
+    if (vendeur && !vendeur.verifierQuantite(itemVendu, quantite)) {
       ChatUtility.notifyUser(achat.userId, 'warn', `Le vendeur n'a pas assez de ${itemVendu.name} !`);
       return
     }
@@ -318,7 +327,7 @@ export class RdDBaseActor extends Actor {
   }
 
   verifierQuantite(item, quantiteDemande) {
-    const disponible = item?.getQuantite();
+    const disponible = this.getQuantiteDisponible(item);
     return disponible == undefined || disponible >= quantiteDemande;
   }
 
@@ -447,62 +456,33 @@ export class RdDBaseActor extends Actor {
 
 
   /* -------------------------------------------- */
-  conteneurPeutContenir(dest, item) {
+  conteneurPeutContenir(dest, moved) {
     if (!dest) {
       return true;
     }
     if (!dest.isConteneur()) {
       return false;
     }
-    const destData = dest
+    if (moved.isConteneurContenu(dest)) {
-    if (this._isConteneurContenu(item, dest)) {
+      ui.notifications.warn(`Impossible de déplacer un conteneur parent (${moved.name}) dans un de ses contenus ${dest.name} !`);
-      ui.notifications.warn(`Impossible de déplacer un conteneur parent (${item.name}) dans un de ses contenus ${destData.name} !`);
+      return false;
-      return false; // Loop detected !
     }
 
     // Calculer le total actuel des contenus
-    let encContenu = this.getRecursiveEnc(dest) - Number(destData.system.encombrement);
+    const encContenu = dest.getEncContenu();
-    let newEnc = this.getRecursiveEnc(item); // Calculer le total actuel du nouvel objet
+    const newEnc = moved.getEncTotal(); // Calculer le total actuel du nouvel objet
+    const placeDisponible = Math.roundDecimals(dest.system.capacite - encContenu - newEnc, 4)
 
     // Teste si le conteneur de destination a suffisament de capacité pour recevoir le nouvel objet
-    if (Number(destData.system.capacite) < encContenu + newEnc) {
+    if (placeDisponible < 0) {
       ui.notifications.warn(
-        `Le conteneur ${dest.name} a une capacité de ${destData.system.capacite}, et contient déjà ${encContenu}.
+        `Le conteneur ${dest.name} a une capacité de ${dest.system.capacite}, et contient déjà ${encContenu}.
-        Impossible d'y ranger: ${item.name} d'encombrement ${newEnc}!`);
+        Impossible d'y ranger: ${moved.name} d'encombrement ${newEnc}!`);
       return false;
     }
     return true;
   }
 
-  /* -------------------------------------------- */
-  _isConteneurContenu(item, conteneur) {
-    if (item?.isConteneur()) { // Si c'est un conteneur, il faut vérifier qu'on ne le déplace pas vers un sous-conteneur lui appartenant
-      for (let id of item.system.contenu) {
-        let subObjet = this.getItem(id);
-        if (subObjet?.id == conteneur.id) {
-          return true; // Loop detected !
-        }
-        if (subObjet?.isConteneur()) {
-          return this._isConteneurContenu(subObjet, conteneur);
-        }
-      }
-    }
-    return false;
-  }
-  /* -------------------------------------------- */
-  getRecursiveEnc(objet) {
-    if (!objet) {
-      return 0;
-    }
-    const tplData = objet.system;
-    if (objet.type != 'conteneur') {
-      return Number(tplData.encombrement) * Number(tplData.quantite);
-    }
-    const encContenus = tplData.contenu.map(idContenu => this.getRecursiveEnc(this.getItem(idContenu)));
-    return encContenus.reduce(Misc.sum(), 0)
-      + Number(tplData.encombrement) /* TODO? Number(tplData.quantite) -- on pourrait avoir plusieurs conteneurs...*/
-  }
-
   /* -------------------------------------------- */
   /** Ajoute un item dans un conteneur, sur la base
    * de leurs ID */

module/actor/commerce.js

@@ -28,6 +28,7 @@ export class RdDCommerce extends RdDBaseActor {
   verifierFortune(cout) {
     return this.system.illimite || super.verifierFortune(cout);
   }
+
   async depenserSols(cout) {
     if (this.system.illimite) {
       return

module/item.js

@@ -395,6 +395,16 @@ export class RdDItem extends Item {
     return Math.max(this.system.encombrement ?? 0, 0);
   }
 
+  getEncContenu() {
+    return this.getContenu()
+      .map(it => it.getRecursiveEnc())
+      .reduce(Misc.sum(), 0);
+  }
+
+  getRecursiveEnc() {
+    return this.getEncTotal() + this.getEncContenu()
+  }
+
   getEncHerbe() {
     switch (this.system.categorie) {
       case 'Repos': case 'Soin': case 'Alchimie':
@@ -404,6 +414,18 @@ export class RdDItem extends Item {
 
   }
 
+  getContenu() {
+    if (this.isConteneur()) {
+      return this.system.contenu.map(idContenu => this.actor.getItem(idContenu));
+    }
+    return []
+  }
+
+  isConteneurContenu(conteneur) {
+    return this.getContenu()
+      .find(it => it.id == conteneur.id || it.isConteneurContenu(conteneur))
+  }
+
   valeurTotale() {
     return (this.isService() ? 1 : this.getQuantite()) * this.valeur()
   }
@@ -675,7 +697,7 @@ export class RdDItem extends Item {
   _armeChatData() {
     return [
       `<b>Compétence</b>: ${this.system.competence}`,
-      `<b>Dommages</b>: ${this.system.dommages} ${this.system.mortalite=='non-mortel'? '(Non mortel)':''}`,
+      `<b>Dommages</b>: ${this.system.dommages} ${this.system.mortalite == 'non-mortel' ? '(Non mortel)' : ''}`,
       `<b>Force minimum</b>: ${this.system.force}`,
       `<b>Resistance</b>: ${this.system.resistance}`,
       ...this._inventaireTemplateChatData()

module/rdd-combat.js

@@ -789,7 +789,7 @@ export class RdDCombat {
     let rollData = {
       passeArme: randomID(16),
       mortalite: arme?.system.mortalite,
-      competence: competence.clone(),
+      competence: competence,
       surprise: this.attacker.getSurprise(true),
       surpriseDefenseur: this.defender.getSurprise(true),
       targetToken: Targets.extractTokenData(this.target),
@@ -1044,7 +1044,7 @@ export class RdDCombat {
       passeArme: attackerRoll.passeArme,
       diffLibre: attackerRoll.diffLibre,
       attackerRoll: attackerRoll,
-      competence: this.defender.getCompetence(competenceParade).clone(),
+      competence: this.defender.getCompetence(competenceParade),
       arme: armeParade,
       surprise: this.defender.getSurprise(true),
       needParadeSignificative: ReglesOptionnelles.isUsing('categorieParade') && RdDItemArme.needParadeSignificative(attackerRoll.arme, armeParade),
@@ -1125,7 +1125,7 @@ export class RdDCombat {
       passeArme: attackerRoll.passeArme,
       diffLibre: attackerRoll.diffLibre,
       attackerRoll: attackerRoll,
-      competence: competence.clone(),
+      competence: competence,
       surprise: this.defender.getSurprise(true),
       surpriseDefenseur: this.defender.getSurprise(true),
       carac: this.defender.system.carac,

module/rdd-empoignade.js

@@ -181,7 +181,7 @@ export class RdDEmpoignade {
     let rollData = {
       mode, empoignade, attacker, defender,
       isEmpoignade: true,
-      competence: attacker.getCompetence("Corps à corps").clone(),
+      competence: attacker.getCompetence("Corps à corps"),
       selectedCarac: attacker.system.carac.melee,
       malusTaille: RdDEmpoignade.getMalusTaille(empoignade, attacker, defender)
     }
@@ -210,7 +210,7 @@ export class RdDEmpoignade {
       mode: "immobilise",
       empoignade, attacker, defender,
       isEmpoignade: true,
-      competence: attacker.getCompetence("Corps à corps").clone()
+      competence: attacker.getCompetence("Corps à corps")
     }
     const msg = await ChatMessage.create({
       whisper: ChatUtility.getWhisperRecipientsAndGMs(attacker.name),
@@ -272,7 +272,7 @@ export class RdDEmpoignade {
       mode, attacker, defender, empoignade, attackerRoll,
       diffLibre: attackerRoll.diffLibre,
       attaqueParticuliere: attackerRoll.particuliere,
-      competence: defender.getCompetence(competenceName).clone(),
+      competence: defender.getCompetence(competenceName),
       surprise: defender.getSurprise(true),
       carac: defender.system.carac,
       selectedCarac: defender.system.carac[carac],

module/rdd-possession.js

@@ -39,7 +39,7 @@ export class RdDPossession {
     let rollData = {
       mode: "attaque",
       isECNIDefender: false,
-      competence: competence.clone(),
+      competence: competence,
       possession: possession,
       attacker: attacker,
       defender: defender,

system.json

@@ -1,14 +1,13 @@
 {
   "id": "foundryvtt-reve-de-dragon",
   "title": "Rêve de Dragon",
-  "version": "11.0.12",
+  "version": "11.0.16",
-  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-11.0.12.zip",
+  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-11.0.16.zip",
   "manifest": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/v11/system.json",
   "changelog": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/branch/v11/changelog.md",
   "compatibility": {
     "minimum": "11",
-    "verified": "11",
+    "verified": "11"
-    "maximum": "11"
   },
   "description": "Rêve de Dragon RPG for FoundryVTT",
   "authors": [