Merge branch 'v1.5-fixes' into 'v1.5'

Divers fixes

See merge request LeRatierBretonnien/foundryvtt-reve-de-dragon!318

module/actor-sheet.js

@@ -132,7 +132,7 @@ export class RdDActorSheet extends ActorSheet {
   /* -------------------------------------------- */
   async _onDropActor(event, dragData) {
     console.log("_onDropActor", this.actor.id, dragData);
-    this.actor.addSubacteur(dragData.id || dragData.data._id);
+    this.actor.addSubActeur(dragData.id || dragData.data._id);
     super._onDropActor(event, dragData);
   }
 
@@ -337,7 +337,7 @@ export class RdDActorSheet extends ActorSheet {
         ui.notifications.info("Impossible de lancer l'initiative sans être dans un combat.");
       }
     });
-    // Display TMR, visuualisation
+    // Display TMR, visualisation
     html.find('.visu-tmr').click(async event => {
       this.actor.displayTMR("visu");
     });

module/actor-vehicule-sheet.js

@@ -112,6 +112,19 @@ export class RdDActorVehiculeSheet extends ActorSheet {
       const li = RdDSheetUtility.getEventElement(event);
       RdDUtility.confirmerSuppression(this, li);
     });
+    html.find('.item-vendre').click(async event => {
+      const item = RdDSheetUtility.getItem(event, this.actor);
+      item?.proposerVente();
+    });
+    html.find('.item-montrer').click(async event => {
+      const item = RdDSheetUtility.getItem(event, this.actor);
+      item?.postItem();
+    });
+
+    html.find('.item-action').click(async event => {
+      const item = RdDSheetUtility.getItem(event, this.actor);
+      this.actor.actionItem(item);
+    });
 
     html.find('.creer-un-objet').click(async event => {
       RdDUtility.selectObjetType(this);

module/actor.js

@@ -1251,17 +1251,12 @@ export class RdDActor extends Actor {
     itemsList.push({ id: itemId, conteneurId: undefined }); // Init list
     sourceActor.buildSubConteneurObjetList(itemId, itemsList); // Get itemId list
 
-    let itemMap = {};
     const itemsDataToCreate = itemsList.map(it => sourceActor.getObjet(it.id))
       .map(it => duplicate(Misc.data(it)))
       .map(it => { it.data.contenu = []; return it; });
     let newItems = await this.createEmbeddedDocuments('Item', itemsDataToCreate);
-    for (let i = 0; i < itemsList.length; i++) {
+
-      const srcItem = itemsList[i];
+    let itemMap = this._buildMapOldNewId(itemsList, newItems);
-      const newItem = newItems[i];
-      console.log('New object', newItem, srcItem);
-      itemMap[srcItem.id] = newItem._id; // Pour garder le lien ancien / nouveau
-    }
 
     for (let item of itemsList) { // Second boucle pour traiter la remise en conteneurs
       // gestion conteneur/contenu
@@ -1282,6 +1277,14 @@ export class RdDActor extends Actor {
     }
   }
 
+  _buildMapOldNewId(itemsList, newItems) {
+    let itemMap = {};
+    for (let i = 0; i < itemsList.length; i++) {
+      itemMap[itemsList[i].id] = newItems[i].id; // Pour garder le lien ancien / nouveau
+    }
+    return itemMap;
+  }
+
   async regrouperEquipementsSimilaires(item, dest) {
     await dest.quantiteIncDec(Misc.templateData(item).quantite);
     await item.delete();
@@ -2370,14 +2373,13 @@ export class RdDActor extends Actor {
   /* -------------------------------------------- */
   isRencontreSpeciale() { // Gestion queue/souffle 'Mauvaise Rencontre en Perpective'
     let addMsg = "";
-    let rencSpecial = this.data.items.find(item => EffetsDraconiques.isMauvaiseRencontre(item));
+    let rencSpecial = EffetsDraconiques.mauvaiseRencontre(this);
     if (rencSpecial) {
-      rencSpecial = Misc.data(rencSpecial); // To keep it
       if (rencSpecial.type != 'souffle') {
-        this.deleteEmbeddedDocuments('Item', [rencSpecial._id]); // Suppression dans la liste des queues
+        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 manuellement.";
+        addMsg = " Vous devez gérer manuellement le décompte de mauvaises rencontres.";
       }
       ChatMessage.create({
         content: "Vous êtes sous le coup d'une Mauvaise Rencontre en Persective." + addMsg,
@@ -3135,7 +3137,7 @@ export class RdDActor extends Actor {
 
   /* -------------------------------------------- */
   countMonteeLaborieuse() { // Return +1 par queue/ombre/souffle Montée Laborieuse présente
-    let countMonteeLaborieuse = this.filterItemsData(it => EffetsDraconiques.isMonteeLaborieuse(it)).length;
+    let countMonteeLaborieuse = EffetsDraconiques.countMonteeLaborieuse(this);
     if (countMonteeLaborieuse > 0) {
       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.`,
@@ -3895,10 +3897,10 @@ export class RdDActor extends Actor {
   }
 
   /* -------------------------------------------- */
-  addSubacteur(subActorId) {
+  addSubActeur(subActorId) {
     let subActor = game.actors.get(subActorId);
     //console.log("Ajout acteur : ", actor, this);
-    if (subActor && subActor.owner) {
+    if (subActor && !subActor.owner) {
       const actorData = Misc.data(this);
       if (subActor.data.type == 'vehicule') {
         this.pushSubacteur(subActor, actorData.data.subacteurs.vehicules, 'data.subacteurs.vehicules', 'Ce Véhicule');

module/rdd-combat.js

@@ -429,9 +429,7 @@ export class RdDCombat {
     else {
       const defender = target?.actor;
       const defenderTokenId = target?.data._id;
-      if ( defender.data._id == attacker.data._id) {
+      if ( defender.type == 'entite' && defender.data.data.definition.typeentite == 'nonincarne') {
-        ui.notifications.warn("Vous vous attaquez vous-même !!!!");
-      } else if ( defender.type == 'entite' && defender.data.data.definition.typeentite == 'nonincarne') {
         ui.notifications.warn("Vous ne pouvez pas cibler une entité non incarnée !!!!");
       } else {
         return this.create(attacker, defender, defenderTokenId, target)

module/rdd-tmr-dialog.js

@@ -589,7 +589,7 @@ export class RdDTMRDialog extends Dialog {
         maitrise: { verbe: 'maîtriser', action: 'Maîtriser le fleuve' }
       }
       rollData.double = EffetsDraconiques.isDoubleResistanceFleuve(this.actor) ? true : undefined,
-        rollData.competence.data.defaut_carac = 'reve-actuel';
+      rollData.competence.data.defaut_carac = 'reve-actuel';
       await this._rollMaitriseCaseHumide(rollData);
     }
   }

module/tmr/effets-draconiques.js

@@ -92,43 +92,10 @@ export class EffetsDraconiques {
   static isPresentCite(caseTMR, coord) {
     return EffetsDraconiques.presentCites.isCase(caseTMR, coord);
   }
-  /* -------------------------------------------- */
-  static isMauvaiseRencontre(item) {
-    return EffetsDraconiques.isMatching(item, it => Draconique.isQueueSouffle(it) && it.name.toLowerCase().includes('mauvaise rencontre'));
-  }
-
-  static isMonteeLaborieuse(item) {
-    return EffetsDraconiques.isMatching(item, it => Draconique.isQueueSouffle(it) && it.name.toLowerCase().includes('montée laborieuse'));
-  }
 
   /* -------------------------------------------- */
-  static isFermetureCite(item) {
+  static isSortImpossible(actor) {
-    return EffetsDraconiques.isMatching(item, it => EffetsDraconiques.fermetureCites.match(it));
+    return actor.data.items.find(it =>
-  }
-
-  static isPontImpraticable(item) {
-    return EffetsDraconiques.isMatching(item, it => EffetsDraconiques.pontImpraticable.match(it));
-  }
-
-  static isDoubleResistanceFleuve(item) {
-    return EffetsDraconiques.isMatching(item, it => Draconique.isSouffleDragon(it) && it.name.toLowerCase().includes('résistance du fleuve'));
-  }
-
-  static isPeage(item) {
-    return EffetsDraconiques.isMatching(item, it => Draconique.isSouffleDragon(it) && it.name.toLowerCase().includes('péage'));
-  }
-
-  static isPeriple(item) {
-    return EffetsDraconiques.isMatching(item, it => EffetsDraconiques.periple.match(it));
-  }
-
-  static isDesorientation(item) {
-    return EffetsDraconiques.isMatching(item, it => EffetsDraconiques.desorientation.match(it));    // TODO
-  }
-
-  /* -------------------------------------------- */
-  static isSortImpossible(item) {
-    return EffetsDraconiques.isMatching(item, it =>
       EffetsDraconiques.conquete.match(it) ||
       EffetsDraconiques.periple.match(it) ||
       EffetsDraconiques.urgenceDraconique.match(it) ||
@@ -136,57 +103,57 @@ export class EffetsDraconiques {
     );
   }
 
-  static isSortReserveImpossible(item) {
+  static isSortReserveImpossible(actor) {
-    return EffetsDraconiques.isMatching(item, it =>
+    return actor.data.items.find(it =>
       EffetsDraconiques.conquete.match(it) ||
       EffetsDraconiques.periple.match(it) ||
       EffetsDraconiques.pelerinage.match(it)
     );
   }
 
-  static isConquete(item) {
+  static isDonDoubleReve(actor) {
-    return EffetsDraconiques.isMatching(item, it => EffetsDraconiques.conquete.match(it));
+    return actor.data.items.find(it => Draconique.isTeteDragon(it) && it.name == 'Don de double-rêve');
   }
 
-  static isPelerinage(item) {
+  static isConnaissanceFleuve(actor) {
-    return EffetsDraconiques.isMatching(item, it => EffetsDraconiques.pelerinage.match(it));
+    return actor.data.items.find(it => Draconique.isTeteDragon(it) && it.name.toLowerCase().includes('connaissance du fleuve'));
   }
 
-  static countInertieDraconique(item) {
+  static isReserveEnSecurite(actor) {
-    return EffetsDraconiques.count(item, it => Draconique.isQueueDragon(it) && it.name.toLowerCase().includes('inertie draconique'));
+    return actor.data.items.find(it => Draconique.isTeteDragon(it) && it.name.toLowerCase().includes(' en sécurité'));
   }
 
-  static isUrgenceDraconique(item) {
+  static isDeplacementAccelere(actor) {
-    return EffetsDraconiques.isMatching(item, it => EffetsDraconiques.urgenceDraconique.match(it));
+    return actor.data.items.find(it => Draconique.isTeteDragon(it) && it.name.toLowerCase().includes(' déplacement accéléré'));
   }
 
-  /* -------------------------------------------- */
+  static isDoubleResistanceFleuve(actor) {
-  static isDonDoubleReve(item) {
+    return actor.data.items.find(it => Draconique.isSouffleDragon(it) && it.name.toLowerCase().includes('résistance du fleuve'));
-    return EffetsDraconiques.isMatching(item, it => Draconique.isTeteDragon(it) && it.name == 'Don de double-rêve');
   }
 
-  static isConnaissanceFleuve(item) {
+  static countInertieDraconique(actor) {
-    return EffetsDraconiques.isMatching(item, it => Draconique.isTeteDragon(it) && it.name.toLowerCase().includes('connaissance du fleuve'));
+    return actor.data.items.filter(it => Draconique.isQueueDragon(it) && it.name.toLowerCase().includes('inertie draconique')).length;
   }
 
-  static isReserveEnSecurite(item) {
+  static countMonteeLaborieuse(actor) {
-    return EffetsDraconiques.isMatching(item, it => Draconique.isTeteDragon(it) && it.name.toLowerCase().includes(' en sécurité'));
+    return actor.data.items.filter(it => Draconique.isQueueSouffle(it) && it.name.toLowerCase().includes('montée laborieuse')).length;
   }
 
-  static isDeplacementAccelere(item) {
+  static mauvaiseRencontre(actor) {
-    item = Misc.data(item);
+    return actor.data.items.find(it => Draconique.isQueueSouffle(it) && it.name.toLowerCase().includes('mauvaise rencontre'));
-    return EffetsDraconiques.isMatching(item, it => Draconique.isTeteDragon(it) && it.name.toLowerCase().includes(' déplacement accéléré'));
   }
 
-  static isMatching(item, matcher) {
+  static isPontImpraticable(actor) {
-    return EffetsDraconiques.toItems(item).find(matcher);
+    return actor.data.items.find(it => EffetsDraconiques.pontImpraticable.match(it));
-  }
-  static count(item, matcher) {
-    return EffetsDraconiques.toItems(item).filter(matcher).length;
   }
 
-  static toItems(item) {
+  static isUrgenceDraconique(actor) {
-    return (item?.documentName === 'Actor') ? item.data.items : (item?.documentName === 'Item') ? [Misc.data(item)] : [];
+    return actor.data.items.find(it => EffetsDraconiques.urgenceDraconique.match(it));
   }
 
+  static isPeage(actor) {
+    return actor.data.items.find(it => Draconique.isSouffleDragon(it) && it.name.toLowerCase().includes('péage'));
+  }
+
+
 }