Merge branch 'v1.4' of https://gitlab.com/LeRatierBretonnien/foundryvtt-reve-de-dragon into v1.4

module/actor.js

@@ -57,39 +57,38 @@ export class RdDActor extends Actor {
    * This overrided create() function adds initial items 
    * Namely: Basic skills, money, 
    *
-   * @param {Object} data        Barebones actor data which this function adds onto.
+   * @param {Object} actorData        Barebones actor data which this function adds onto.
    * @param {Object} options     (Unused) Additional options which customize the creation workflow.
    *
    */
 
-  static async create(data, options) {
+  static async create(actorData, options) {
     // Case of compendium global import
-    if (data instanceof Array) {
-      return super.create(data, options);
+    if (actorData instanceof Array) {
+      return super.create(actorData, options);
     }
 
-    const isPersonnage = data.type == "personnage";
+    const isPersonnage = actorData.type == "personnage";
     // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
-    if (data.items) {
-      let actor = super.create(data, options);
+    if (actorData.items) {
+      let actor = super.create(actorData, options);
       if (isPersonnage) {
-        await actor.checkMonnaiePresence(data.items);
+        await actor.checkMonnaiePresence(actorData.items);
       }
       return actor;
     }
 
-    const competences = await RdDUtility.loadCompendium(RdDItemCompetence.actorCompendium(data.type));
-    data.items = competences.map(it => Misc.data(it));
+    const competences = await RdDUtility.loadCompendium(RdDItemCompetence.actorCompendium(actorData.type));
+    actorData.items = competences.map(it => Misc.data(it));
     if (isPersonnage) {
-      data.items = data.items.concat(Monnaie.monnaiesData());
+      actorData.items = actorData.items.concat(Monnaie.monnaiesData());
     }
-    return super.create(data, options);
+    return super.create(actorData, options);
   }
 
   /* -------------------------------------------- */
   prepareData() {
     super.prepareData();
-
     const actorData = this.data;
 
     // Dynamic computing fields
@@ -138,6 +137,7 @@ export class RdDActor extends Actor {
   async _prepareCharacterData(actorData) {
     // Initialize empty items
     RdDCarac.computeCarac(actorData.data);
+    this.computeIsHautRevant();
     this.computeEncombrementTotalEtMalusArmure();
     this.computePrixTotalEquipement();
     this.computeEtatGeneral();
@@ -232,7 +232,7 @@ export class RdDActor extends Actor {
     return Math.floor(this.encTotal ?? 0);
   }
   getPrixTotalEquipement() {
-    return Math.floor(this.prixTotalEquipement ?? 0);
+    return Math.floor(Misc.templateData(this).prixTotalEquipement ?? 0);
   }
   getSurenc() {
     return Misc.toInt(Misc.templateData(this).compteurs.surenc?.value);
@@ -245,8 +245,14 @@ export class RdDActor extends Actor {
   getObjet(id) {
     return id ? this.data.items.find(it => it.id == id) : undefined;
   }
+  listItemsData(type) {
+    return this.filterItemsData(it => it.type == type);
+  }
+  filterItemsData(filter) {
+    return this.data.items.map(it => Misc.data(it)).filter(filter);
+  }
   getItemOfType(id, type) {
-    return id ? this.data.items.find(it => it.id == id && it.type == type) : undefined;
+    return id ? this.data.items.find(it => it.id == id && Misc.data(it).type == type) : undefined;
   }
   getMonnaie(id) {
     return this.getItemOfType(id, 'monnaie');
@@ -343,13 +349,11 @@ export class RdDActor extends Actor {
 
   async _recupereChance() {
     // On ne récupère un point de chance que si aucun appel à la chance dans la journée
-    if (this.getFlag('foundryvtt-reve-de-dragon', 'utilisationChance')) {
-      // Nouveau jour, suppression du flag
-      await this.unsetFlag('foundryvtt-reve-de-dragon', 'utilisationChance');
-    }
-    else {
+    if (this.getChanceActuel() < this.getChance() && !this.getFlag('foundryvtt-reve-de-dragon', 'utilisationChance')) {
       await this.chanceActuelleIncDec(1);
     }
+    // Nouveau jour, suppression du flag
+    await this.unsetFlag('foundryvtt-reve-de-dragon', 'utilisationChance');
   }
 
   /* -------------------------------------------- */
@@ -651,14 +655,14 @@ export class RdDActor extends Actor {
         return;
       }
     }
-    const actorData = Misc.data(this);
+    const tplData = Misc.templateData(this);
     if (caracName == "reve") {
-      if (caracValue > Misc.toInt(actorData.data.reve.seuil.value)) {
+      if (caracValue > Misc.toInt(tplData.reve.seuil.value)) {
         this.setPointsDeSeuil(caracValue);
       }
     }
     if (caracName == "chance") {
-      if (caracValue > Misc.toInt(actorData.data.compteurs.chance.value)) {
+      if (caracValue > Misc.toInt(tplData.compteurs.chance.value)) {
         this.setPointsDeChance(caracValue);
       }
     }
@@ -927,7 +931,7 @@ export class RdDActor extends Actor {
       // gestion conteneur/contenu
       if (item.conteneurId) { // l'Objet était dans un conteneur
         let newConteneurId = itemMap[item.conteneurId]; // Get conteneur
-        let newConteneur = this.data.items.find(subItem => subItem._id == newConteneurId);
+        let newConteneur = this.getObjet(newConteneurId);
 
         let newItemId = itemMap[item.id]; // Get newItem
 
@@ -944,62 +948,67 @@ export class RdDActor extends Actor {
 
   /* -------------------------------------------- */
   detectSurEncombrement() {
-    let maxEnc = 0;
-    if (this.data.type == 'vehicule')
-      maxEnc = Misc.templateData(this).capacite_encombrement;
-    else
-      maxEnc = Misc.templateData(this).attributs.encombrement.value;
-    let diffEnc = Number(this.data.encTotal) - Number(maxEnc);
-    return Math.max(0, Math.ceil(diffEnc));
+    return Math.max(0, Math.ceil(Number(this.data.encTotal) - this.getEncombrementMax()));
+  }
+  getEncombrementMax() {
+    return (this.data.type == 'vehicule')
+      ? Misc.templateData(this).capacite_encombrement
+      : Misc.templateData(this).attributs.encombrement.value;
+  }
+
+  /* -------------------------------------------- */
+  async computeIsHautRevant() {
+    const tplData = Misc.templateData(this);
+    tplData.attributs.hautrevant.value = this.listItemsData('tete').find(it => Grammar.toLowerCaseNoAccent(it.name) == 'don de haut-reve')
+      ? "Haut rêvant"
+      : "";
   }
 
   /* -------------------------------------------- */
   async computeEncombrementTotalEtMalusArmure() {
-    let encTotal = 0;
-    let newMalusArmure = 0;
-    for (const item of this.data.items.filter(it => Misc.templateData(it).encombrement != undefined)) {
-      let itemData = item.data; // v0.8 normalization
-      if (itemData.type == 'armure' && itemData.data.equipe) {  // Armure équipée, intégration du malus armure total
-        newMalusArmure += itemData.data.malus;
-      }
-      // Calcul encombrement
-      if (itemData.data && itemData.data.encombrement != undefined) {
-        if (!Number(itemData.data.encombrement)) itemData.data.encombrement = 0; // Auto-fix
-        if (itemData.data.quantite == undefined) itemData.data.quantite = 1; // Auto-fix
-        if (itemData.data.quantite < 0) itemData.data.quantite = 0; // Auto-fix
-        itemData.data.encTotal = Number(itemData.data.encombrement) * Number(itemData.data.quantite);
-        encTotal += itemData.data.encTotal;
-      } else {
-        itemData.data.encTotal = 0; // Force default enc
-      }
-    }
-    // Mise à jour valeur totale et états
-    this.data.encTotal = encTotal;
-    this.detectSurEncombrement();
+    await this.computeMalusArmure();
+    return this.computeEncombrement();
+  }
 
+  /* -------------------------------------------- */
+  computeEncombrement() {
+    Misc.templateData(this).encTotal = this.filterItemsData(it => it.data.encombrement)
+      .map(it => this._calcEncItem(it))
+      .reduce(Misc.sum(), 0);
+    return Misc.templateData(this).encTotal;
+  }
+
+  _calcEncItem(it) {
+    it.data.encombrement = Number(it.data.encombrement ?? 0);
+    it.data.quantite = Math.min(1, Number(it.data.quantite ?? 1));
+    it.data.encTotal = it.data.encombrement * it.data.quantite;
+    return it.data.encTotal;
+  }
+
+  /* -------------------------------------------- */
+  async computeMalusArmure() {
+    const newMalusArmure = this.filterItemsData(it => it.type == 'armure' && it.data.equipe)
+      .map(it => it.data.malus ?? 0)
+      .reduce(Misc.sum(), 0);
     // Mise à jour éventuelle du malus armure
     if (newMalusArmure && Misc.templateData(this).attributs?.malusarmure?.value != newMalusArmure) {
       await this.updateAttributeValue("malusarmure", newMalusArmure);
     }
-    return encTotal;
+    return newMalusArmure;
   }
 
   /* -------------------------------------------- */
-  async computePrixTotalEquipement() {
+  computePrixTotalEquipement() {
     let prixTotalEquipement = 0;
 
     // prix total de l'équipement est la somme du cout de chaque équipement multiplié par sa quantité.
-    for (const item of this.data.items) {
-      let itemData = item.data; // v0.8 normalization
-      if (itemData.data && itemData.data.cout != undefined) {
-        if (!Number(itemData.data.cout)) itemData.data.cout = 0; // Auto-fix
-        if (itemData.data.quantite == undefined) itemData.data.quantite = 1; // Auto-fix
-        if (itemData.data.cout < 0) itemData.data.cout = 0; // Auto-fix
-        prixTotalEquipement += Number(itemData.data.cout) * Number(itemData.data.quantite);
-      }
+    for (const itemData of this.filterItemsData(it => it?.data.cout)) {
+      const cout = Math.min(Number(itemData.data.cout ?? 0), 0);
+      const quantite = Math.min(Number(itemData.data?.quantite ?? 1), 1);
+      prixTotalEquipement += cout * quantite;
     }
     // Mise à jour valeur totale de l'équipement
-    this.prixTotalEquipement = prixTotalEquipement;
+    Misc.templateData(this).prixTotalEquipement = prixTotalEquipement;
     return prixTotalEquipement;
   }
 
@@ -1115,7 +1124,7 @@ export class RdDActor extends Actor {
   }
 
   buildTMRInnaccessible() {
-    const tmrInnaccessibles = this.data.items.filter(it => Draconique.isCaseTMR(it) &&
+    const tmrInnaccessibles = this.filterItemsData(it => Draconique.isCaseTMR(it) &&
       EffetsDraconiques.isInnaccessible(it));
     return tmrInnaccessibles.map(it => it.data.coord);
   }
@@ -1435,22 +1444,21 @@ export class RdDActor extends Actor {
 
   /* -------------------------------------------- */
   async moralIncDec(ajustementMoral) {
-    let actorData
+    let tplData = Misc.templateData(this);
     if (ajustementMoral != 0) {
-      actorData = Misc.data(this);
-      let moral = Misc.toInt(actorData.data.compteurs.moral.value) + ajustementMoral
+      let moral = Misc.toInt(tplData.compteurs.moral.value) + ajustementMoral
       if (moral > 3) { // exaltation
-        const exaltation = Misc.toInt(actorData.data.compteurs.exaltation.value) + moral - 3;
+        const exaltation = Misc.toInt(tplData.compteurs.exaltation.value) + moral - 3;
         await this.updateCompteurValue('exaltation', exaltation);
       }
       if (moral < -3) { // dissolution
-        const dissolution = Misc.toInt(actorData.data.compteurs.dissolution.value) + 3 - moral;
+        const dissolution = Misc.toInt(tplData.compteurs.dissolution.value) + 3 - moral;
         await this.updateCompteurValue('dissolution', dissolution);
       }
       moral = Math.max(-3, Math.min(moral, 3));
       await this.updateCompteurValue('moral', moral);
     }
-    return actorData.data.compteurs.moral.value;
+    return tplData.compteurs.moral.value;
   }
 
   /* -------------------------------------------- */
@@ -1667,7 +1675,7 @@ export class RdDActor extends Actor {
 
   /* -------------------------------------------- */
   async checkCompetenceXP(compName, newXP = undefined) {
-    let competence = RdDItemCompetence.findCompetence(this.data.items, compName);
+    let competence = this.getCompetence(compName);
     if (competence && newXP && newXP == competence.data.xp) { // Si édition, mais sans changement XP
       return;
     }
@@ -1834,7 +1842,7 @@ export class RdDActor extends Actor {
     let addMsg = "";
     let rencSpecial = this.data.items.find(item => EffetsDraconiques.isMauvaiseRencontre(item));
     if (rencSpecial) {
-      rencSpecial = duplicate(rencSpecial); // To keep it
+      rencSpecial = Misc.data(rencSpecial); // To keep it
       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";
@@ -2261,9 +2269,6 @@ export class RdDActor extends Actor {
   /* -------------------------------------------- */
   async rollAppelChance(onSuccess = () => { }, onEchec = () => { }) {
     // Stocke si utilisation de la chance
-    await this.unsetFlag('foundryvtt-reve-de-dragon', 'utilisationChance');
-    await this.setFlag('foundryvtt-reve-de-dragon', 'utilisationChance', true);
-
     let rollData = { selectedCarac: this.getCaracByName('chance-actuelle'), surprise: '' };
     const dialog = await RdDRoll.create(this, rollData,
       { html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-carac.html' },
@@ -2283,6 +2288,7 @@ export class RdDActor extends Actor {
   async _appelChanceResult(rollData, onSuccess = () => { }, onEchec = () => { }) {
     await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-appelchance.html')
     if (rollData.rolled.isSuccess) {
+      await this.setFlag('foundryvtt-reve-de-dragon', 'utilisationChance', true);
       await this.chanceActuelleIncDec(-1);
       onSuccess();
     }
@@ -2292,11 +2298,8 @@ export class RdDActor extends Actor {
   }
 
   /* -------------------------------------------- */
-  async chanceActuelleIncDec(value, limit = true) {
-    chance = Math.max(Misc.templateData(this).compteurs.chance.value + value, 0);
-    if (limit) {
-      chance = Math.min(chance.value, this.getChance())
-    }
+  async chanceActuelleIncDec(value) {
+    const chance = Math.min(this.getChance(), Math.max(this.getChanceActuel() + value, 0));
     await this.updateCompteurValue("chance", chance);
   }
 
@@ -2326,7 +2329,8 @@ export class RdDActor extends Actor {
   }
   /* -------------------------------------------- */
   checkDesirLancinant() {
-    let queue = this.data.items.filter((item) => item.name.toLowerCase().includes('lancinant'));
+    let queue = this.filterItemsData(it => it.type == 'queue' || it.type == 'ombre')
+      .filter(it => Grammar.toLowerCaseNoAccent(it.name).includes('desir lancinant'));
     return (queue.length > 0);
   }
 
@@ -2376,7 +2380,7 @@ export class RdDActor extends Actor {
   /* -------------------------------------------- */
   async ajouteNombreAstral(data) {
     // Gestion expérience (si existante)
-    data.competence = RdDItemCompetence.findCompetence(this.data.items, "astrologie");
+    data.competence = this.getCompetence("astrologie");
     data.selectedCarac = Misc.templateData(this).carac["vue"];
     this._appliquerAjoutExperience(data);
 
@@ -2388,7 +2392,7 @@ export class RdDActor extends Actor {
     await this.createEmbeddedDocuments("Item", [item]);
 
     // Suppression des anciens nombres astraux
-    let toDelete = this.data.items.filter(it => it.data.jourindex < game.system.rdd.calendrier.getCurrentDayIndex());
+    let toDelete = this.listItemsData('nombreastral').filter(it => it.data.jourindex < game.system.rdd.calendrier.getCurrentDayIndex());
     const deletions = toDelete.map(it => it._id);
     await this.deleteEmbeddedDocuments("Item", deletions);
 
@@ -2451,12 +2455,12 @@ export class RdDActor extends Actor {
 
   /* -------------------------------------------- */
   getSortList() {
-    return this.data.items.filter(it => it.data.type == "sort");
+    return this.listItemsData("sort");
   }
 
   /* -------------------------------------------- */
   countMonteeLaborieuse() { // Return +1 par queue/ombre/souffle Montée Laborieuse présente
-    let countMonteeLaborieuse = this.data.items.filter(it => EffetsDraconiques.isMonteeLaborieuse(it)).length;
+    let countMonteeLaborieuse = this.filterItemsData(it => EffetsDraconiques.isMonteeLaborieuse(it)).length;
     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.`,
@@ -2510,7 +2514,7 @@ export class RdDActor extends Actor {
 
   /* -------------------------------------------- */
   rollArme(compName, armeName = undefined) {
-    let arme = armeName ? this.data.items.find(it => it.name == armeName && RdDItemArme.isArme(it)) : undefined;
+    let arme = armeName ? this.data.items.find(it => Misc.data(it).name == armeName && RdDItemArme.isArme(it)) : undefined;
     let competence = this.getCompetence(compName);
 
     if (arme || armeName || (competence.type == 'competencecreature' && competence.data.iscombat)) {
@@ -2532,7 +2536,7 @@ export class RdDActor extends Actor {
 
   /* -------------------------------------------- */
   getArmeParade(armeParadeId) {
-    const item = armeParadeId ? this.getEmbeddedDocuments('Item', armeParadeId) : undefined;
+    const item = armeParadeId ? this.getEmbeddedDocument('Item', armeParadeId) : undefined;
     return RdDItemArme.getArmeData(item);
   }
 
@@ -2549,9 +2553,9 @@ export class RdDActor extends Actor {
 
   /* -------------------------------------------- */
   async equiperObjet(itemID) {
-    let item = this.getEmbeddedDocuments('Item', itemID);
-    if (item?.data?.data) {
-      let itemData = Misc.itemData(item);
+    let item = this.getEmbeddedDocument('Item', itemID);
+    let itemData = Misc.data(item);
+    if (itemData?.data) {
       const isEquipe = !itemData.data.equipe;
       let update = { _id: item._id, "data.equipe": isEquipe };
       await this.updateEmbeddedDocuments('Item', [update]);
@@ -2567,7 +2571,8 @@ export class RdDActor extends Actor {
     let dmg = (attackerRoll.dmg.dmgArme ?? 0) + (attackerRoll.dmg.dmgActor ?? 0);
     let armeData = attackerRoll.arme;
     let protection = 0;
-    const armures = this.data.items.filter(it => it.type == "armure" && it.data.equipe);
+    const armures = this.items.map(it => Misc.data(it))
+      .filter(it => it.type == "armure" && it.data.equipe);
     for (const itemData of armures) {
       protection += new Roll(itemData.data.protection.toString()).roll().total;
       if (dmg > 0) {
@@ -2575,7 +2580,7 @@ export class RdDActor extends Actor {
         dmg = 0;
       }
     }
-    const penetration = armeData ? Misc.toInt(armeData.data.penetration) : 0;
+    const penetration = Misc.toInt(armeData?.data.penetration ?? 0);
     protection = Math.max(protection - penetration, 0);
     protection += this.getProtectionNaturelle();
     // Gestion des cas particuliers sur la fenêtre d'encaissement
@@ -2865,7 +2870,7 @@ export class RdDActor extends Actor {
     }
     let updates = []
     for (const [valeur, nombre] of Object.entries(fortune)) {
-      updates.push( { _id: parValeur[valeur]._id, 'data.quantite': nombre });
+      updates.push({ _id: parValeur[valeur]._id, 'data.quantite': nombre });
     }
     await this.updateEmbeddedDocuments('Item', updates);
   }
@@ -2922,10 +2927,10 @@ export class RdDActor extends Actor {
 
   /* -------------------------------------------- */
   async effectuerTacheAlchimie(recetteId, alchimieName, alchimieData) {
-    let recette = this.data.items.find(item => item.type == 'recettealchimique' && item.id == recetteId);
+    let recette = this.getItemOfType(recetteId, 'recettealchimique');
     const actorData = Misc.data(this);
     if (recette) {
-      let competence = this.data.items.find(item => item.type == 'competence' && item.name.toLowerCase() == "alchimie");
+      let competence = this.getCompetence("alchimie");
       let diffAlchimie = RdDAlchimie.getDifficulte(alchimieData);
       let rollData = {
         recette: recette,
@@ -3149,7 +3154,7 @@ export class RdDActor extends Actor {
     }
   }
 
-  async onPreUpdateItem(item, change, options, id)  {
+  async onPreUpdateItem(item, change, options, id) {
     const itemData = Misc.data(item);
     if (itemData.type == 'competence' && itemData.data.defaut_carac && itemData.data.xp) {
       await this.checkCompetenceXP(itemData.name, itemData.data.xp);