Correction du mapping

- gestion des armes une/deux mains/lancées
- dommages des armes une/deux mains
- correction de la voie de draconic
- correction des bonus de cases
- correction des retours à la ligne

module/actor/base-actor.js

@@ -542,7 +542,7 @@ export class RdDBaseActor extends Actor {
     // Calculer le total actuel des contenus
     const encContenu = dest.getEncContenu();
     const newEnc = moved.getEncTotal(); // Calculer le total actuel du nouvel objet
-    const placeDisponible = Math.roundDecimals(dest.system.capacite - encContenu - newEnc, 4)
+    const placeDisponible = Misc.keepDecimals(dest.system.capacite - encContenu - newEnc, 4)
 
     // Teste si le conteneur de destination a suffisament de capacité pour recevoir le nouvel objet
     if (placeDisponible < 0) {

module/actor/export-scriptarium/export-scriptarium.js

@@ -1,4 +1,3 @@
-import { LOG_HEAD } from "../../constants.js"
 import { ACTOR_TYPES } from "../../item.js"
 import { Misc } from "../../misc.js"
 import { EXPORT_CSV_SCRIPTARIUM, OptionsAvancees } from "../../settings/options-avancees.js"
@@ -28,6 +27,7 @@ export class ExportScriptarium {
       callback: target => this.exportActors(this.$getActors(actorDirectory, target), this.$getTargetName(actorDirectory, target))
     })
   }
+
   $getTargetName(actorDirectory, target) {
     const li = target.closest(".directory-item")
     const folderId = li.data("folderId")
@@ -36,6 +36,7 @@ export class ExportScriptarium {
       ? game.actors.get(actorId).name
       : actorDirectory.folders.find(it => it.id == folderId).name
   }
+
   $getActors(actorDirectory, target) {
     const li = target.closest(".directory-item")
     const folderId = li.data("folderId")
@@ -49,7 +50,7 @@ export class ExportScriptarium {
   }
 
   exportActors(actors, targetName) {
-    const eol = '\n\r'
+    const eol = '\n'
     const header = Misc.join(this.getHeaderLine(), ';')
     const actorLines = actors.map(actor => Misc.join(this.getActorLine(actor), ';'))
     const data = Misc.join([header, ...actorLines], eol)
@@ -64,6 +65,7 @@ export class ExportScriptarium {
   getActorLine(actor) {
     const context = Mapping.prepareContext(actor)
     return this.mapping.map(it => it.getter(actor, context))
+      //.map(it => JSON.stringify(it))
       .map(it => this.$escapeQuotes(it))
       .map(it => it.replaceAll("\n", " ").replaceAll("\r", ""))
   }

module/actor/export-scriptarium/mapping.js

@@ -5,8 +5,8 @@ import { RdDItemSort } from "../../item-sort.js"
 import { ITEM_TYPES } from "../../item.js"
 import { Misc } from "../../misc.js"
 import { RdDTimestamp } from "../../time/rdd-timestamp.js"
-import { TMRConstants } from "../../tmr-constants.js"
+import { RdDBonus } from "../../rdd-bonus.js"
-import { TMRUtility } from "../../tmr-utility.js"
+
 
 const CATEGORIES_COMPETENCES = [
   "generale",
@@ -80,8 +80,7 @@ const MAPPING_BASE = [
   { column: "armure", getter: (actor, context) => Mapping.getArmure(actor, context) },
   { column: "protection", getter: (actor, context) => Mapping.getProtectionArmure(actor, context) },
   { column: "malus-armure", getter: (actor, context) => Mapping.getMalusArmure(actor, context) },
-  { column: "esquive", getter: (actor, context) => Mapping.getEsquive(actor, context) },
+  { column: "esquive", getter: (actor, context) => Mapping.getEsquiveNiveau(context) },
-  { column: "esquive-niv", getter: (actor, context) => Mapping.getEsquiveNiveau(context) },
   { column: "competences", getter: (actor, context) => Mapping.getCompetences(actor, CATEGORIES_COMPETENCES) },
   { column: "draconic", getter: (actor, context) => Mapping.getCompetences(actor, CATEGORIES_DRACONIC) },
 ]
@@ -89,7 +88,7 @@ const MAPPING_BASE = [
 const MAPPING_ARMES = TABLEAU_ARMES.map(i => ColumnMappingFactory.createMappingArme('name', i))
   .concat(TABLEAU_ARMES.map(i => ColumnMappingFactory.createMappingArme('niveau', i)))
   .concat(TABLEAU_ARMES.map(i => ColumnMappingFactory.createMappingArme('init', i)))
-  .concat(TABLEAU_ARMES.map(i => ColumnMappingFactory.createMappingArme('dom', i)))
+  .concat(TABLEAU_ARMES.map(i => ColumnMappingFactory.createMappingArme('dommages', i)))
 const MAPPING_SORTS = TABLEAU_SORTS.map(i => ColumnMappingFactory.createMappingSort('voie', i))
   .concat(TABLEAU_SORTS.map(i => ColumnMappingFactory.createMappingSort('description', i)))
   .concat(TABLEAU_SORTS.map(i => ColumnMappingFactory.createMappingSort('bonus', i)))
@@ -113,29 +112,36 @@ export class Mapping {
   }
 
   static prepareArmes(actor) {
-    return actor.items.filter(it => it.type == ITEM_TYPES.arme)
+    const armes = actor.items.filter(it => it.type == ITEM_TYPES.arme)
-      .map(arme => {
+    return armes.map(arme =>
-        // TODO: gestion armes 1 ou 2 mains
+      [
-        const compToUse = RdDItemArme.getCompetenceArme(arme, 'competence');
+        arme.system.tir != "" ? Mapping.prepareArme(actor, arme, 'tir') : undefined,
-        const comp = actor.getCompetence(compToUse);
+        arme.system.lancer = "" ? Mapping.prepareArme(actor, arme, 'lancer') : undefined,
-        const bonusDom = Mapping.calculBonusDom(comp, actor)
+        arme.system.unemain ? Mapping.prepareArme(actor, arme, 'unemain') : undefined,
-        return {
+        arme.system.deuxmains ? Mapping.prepareArme(actor, arme, 'deuxmains') : undefined,
-          name: arme.name,
+        !(arme.system.unemain || arme.system.deuxmains) ? Mapping.prepareArme(actor, arme, 'competence') : undefined
-          niveau: comp.system.niveau,
+      ]
-          init: Mapping.calculBaseInit(actor, comp.system.categorie) + comp.system.niveau,
+        .filter(it => it != undefined)
-          dom: Number(arme.system.dommages) + bonusDom
+    ).reduce((a, b) => a.concat(b), [])
-        };
-      });
   }
 
-  static calculBonusDom(comp, actor) {
+  static prepareArme(actor, arme, maniement) {
-    // TODO: reuse dmg calc?
+    const nameCompArme = RdDItemArme.getCompetenceArme(arme, maniement)
-    const appliesBonusDom = ['melee', 'lancer'].includes(comp.system.categorie)
+    const competence = actor.getCompetence(nameCompArme)
-    return appliesBonusDom ? Number(actor.system.attributs.plusdom.value) : 0
+    if (RdDItemCompetence.isNiveauBase(competence)) {
+      return undefined
+    }
+    const dmgArme = RdDItemArme.dommagesReels(arme, maniement)
+    const dommages = dmgArme + RdDBonus.bonusDmg(actor, maniement, dmgArme)
+    return {
+      name: arme.name,
+      niveau: Misc.toSignedString(competence.system.niveau),
+      init: Mapping.calculBaseInit(actor, competence.system.categorie) + competence.system.niveau,
+      dommages: Misc.toSignedString(dommages)
+    }
   }
 
   static calculBaseInit(actor, categorie) {
-    // TODO: reuse init calc?
     const mapping = MAPPING_BASE.find(it => it.column == categorie)
     if (mapping) {
       switch (categorie) {
@@ -175,20 +181,22 @@ export class Mapping {
       const esquive = esquives[0]
       return {
         name: esquive.name,
-        niveau: esquive.system.niveau
+        niveau: Misc.toSignedString(esquive.system.niveau)
       }
     }
     return undefined
   }
 
   static prepareSorts(actor) {
-    return actor.itemTypes[ITEM_TYPES.sort].map(it => {
+    return actor.itemTypes[ITEM_TYPES.sort].map(it => Mapping.prepareSort(it))
-      return {
+  }
-        voie: RdDItemSort.getCodeDraconic(it),
+
-        description: Mapping.descriptionSort(it),
+  static prepareSort(sort) {
-        bonus: Mapping.bonusCase(it)
+    return {
-      }
+      voie: RdDItemSort.getCodeDraconic(sort),
-    })
+      description: Mapping.descriptionSort(sort),
+      bonus: Mapping.bonusCase(sort)
+    }
   }
 
   static descriptionSort(sort) {
@@ -198,11 +206,12 @@ export class Mapping {
   }
 
   static bonusCase(sort) {
-    const list = RdDItemSort.buildBonusCaseList(sort.system.bonuscase, false).sort(Misc.descending(it => it.bonus))
+    const list = RdDItemSort.bonuscaseStringToList(sort.system.bonuscase).sort(Misc.descending(it => it.bonus))
     if (list.length > 0) {
       const bonus = list[0]
       return `+${bonus.bonus}% en ${bonus.case}`
     }
+    return ''
   }
 
   static getDescription(actor) {
@@ -233,10 +242,6 @@ export class Mapping {
     return context?.armure?.malus ?? 0
   }
 
-  static getEsquive(actor, context) {
-    return context.esquive?.name ?? ''
-  }
-
   static getEsquiveNiveau(context) {
     if (context.esquive) {
       const niveau = context.esquive.niveau + context.armure.malus
@@ -260,9 +265,8 @@ export class Mapping {
         }
         const txtCategorieByNiveau = niveaux.map(niveau => {
           const names = Misc.join(byNiveau[niveau].map(it => it.name).sort(Misc.ascending()), ', ')
-          return names + ': ' + Misc.toSignedString(niveau)
+          return names + ' ' + Misc.toSignedString(niveau)
-        }
+        })
-        )
         const txtCategorie = Misc.join(txtCategorieByNiveau, ' / ')
         return txtCategorie
       }).filter(it => it != '')

module/item-arme.js

@@ -33,12 +33,12 @@ export class RdDItemArme extends Item {
     return RdDItemArme.mainsNues();
   }
 
-  static getCompetenceArme(arme, competenceName) {
+  static getCompetenceArme(arme, maniement) {
     switch (arme.type) {
       case ITEM_TYPES.competencecreature:
         return arme.name
       case ITEM_TYPES.arme:
-        switch (competenceName) {
+        switch (maniement) {
           case 'competence': return arme.system.competence;
           case 'unemain': return RdDItemArme.competence1Mains(arme);
           case 'deuxmains': return RdDItemArme.competence2Mains(arme);
@@ -148,30 +148,32 @@ export class RdDItemArme extends Item {
     return true;
   }
 
-  /* -------------------------------------------- */
+  static dommagesReels(arme, maniement) {
-  static armeUneOuDeuxMains(armeData, aUneMain) {
+    switch (maniement) {
-    if (armeData && !armeData.system.cac) {
+      case 'tir':
-      armeData.system.unemain = armeData.system.unemain || !armeData.system.deuxmains;
+      case 'lancer':
-      const uneOuDeuxMains = armeData.system.unemain && armeData.system.deuxmains;
+      case 'competence':
-      const containsSlash = !Number.isInteger(armeData.system.dommages) && armeData.system.dommages.includes("/");
+        return Number(arme.system.dommages)
-      if (containsSlash) { // Sanity check
-        armeData = foundry.utils.duplicate(armeData);
-
-        const tableauDegats = armeData.system.dommages.split("/");
-        if (aUneMain)
-          armeData.system.dommagesReels = Number(tableauDegats[0]);
-        else // 2 mains
-          armeData.system.dommagesReels = Number(tableauDegats[1]);
-      }
-      else {
-        armeData.system.dommagesReels = Number(armeData.system.dommages);
-      }
-
-      if (uneOuDeuxMains != containsSlash) {
-        ui.notifications.info("Les dommages de l'arme à 1/2 mains " + armeData.name + " ne sont pas corrects (ie sous la forme X/Y)");
-      }
     }
-    return armeData;
+    if (arme.system.unemain && arme.system.deuxmains) {
+      const containsSlash = !Number.isInteger(arme.system.dommages) && arme.system.dommages.includes("/")
+      if (!containsSlash) {
+        ui.notifications.info("Les dommages de l'arme à 1/2 mains " + arme.name + " ne sont pas corrects (ie sous la forme X/Y)");
+        return Number(arme.system.dommages)
+      }
+      const tableauDegats = arme.system.dommages.split("/");
+      return Number(tableauDegats[maniement == 'unemain' ? 0 : 1])
+    }
+    return Number(arme.system.dommages);
+  }
+
+  /* -------------------------------------------- */
+  static armeUneOuDeuxMains(arme, aUneMain) {
+    if (arme && !arme.system.cac) {
+      arme = foundry.utils.duplicate(arme);
+      arme.system.dommagesReels = RdDItemArme.dommagesReels(arme, aUneMain ? 'unemain' : 'deuxmains')
+    }
+    return arme;
   }
 
   static competence1Mains(arme) {
@@ -197,7 +199,7 @@ export class RdDItemArme extends Item {
 
   static corpsACorps(actor) {
     let competence = actor?.getCompetenceCorpsACorps() ?? { system: { niveau: -6 } };
-    let melee = actor? actor.system.carac['melee'].value : 0
+    let melee = actor ? actor.system.carac['melee'].value : 0
     return {
       _id: competence?.id,
       name: 'Corps à corps',

module/item-sort.js

@@ -5,11 +5,11 @@ import { Misc } from "./misc.js";
 import { TMRUtility } from "./tmr-utility.js";
 
 const VOIES_DRACONIC = [
-  { code: 'O', label: "Voie d'Oniros", short: 'Oniros'},
+  { code: 'O', label: "Voie d'Oniros", short: 'Oniros' },
-  { code: 'H', label: "Voie d'Hypnos" , short:'Hypnos' },
+  { code: 'H', label: "Voie d'Hypnos", short: 'Hypnos' },
   { code: 'N', label: "Voie de Narcos", short: 'Narcos' },
-  { code: 'T', label: "Voie de Thanatos", short:'Thanatos' },
+  { code: 'T', label: "Voie de Thanatos", short: 'Thanatos' },
-  { code: 'O/H/N/T', label: "Oniros/Hypnos/Narcos/Thanatos", short:'Oniros/Hypnos/Narcos/Thanatos' },
+  { code: 'O/H/N/T', label: "Oniros/Hypnos/Narcos/Thanatos", short: 'Oniros/Hypnos/Narcos/Thanatos' },
   { code: 'O/H/N', label: "Oniros/Hypnos/Narcos" }
 ]
 
@@ -65,9 +65,9 @@ export class RdDItemSort extends Item {
 
   /* -------------------------------------------- */
   static buildBonusCaseList(bonuscase, newCase) {
-    const list = RdDItemSort._bonuscaseStringToList(bonuscase)
+    const list = RdDItemSort.bonuscaseStringToList(bonuscase)
     if (newCase) {
-      return list.concat({ case: "Nouvelle", bonus: 0 });
+       list.push({ case: "Nouvelle", bonus: 0 })
     }
     return list;
   }
@@ -138,8 +138,11 @@ export class RdDItemSort extends Item {
       .sort(Misc.ascending())
       .join(',');
   }
-  static _bonuscaseStringToList(bonuscase) {
+  static bonuscaseStringToList(bonuscase) {
-    return (bonuscase ?? '').split(',').map(it => {
+    if (bonuscase == undefined || bonuscase == '') {
+      return []
+    }
+    return bonuscase.split(',').map(it => {
       const b = it.split(':');
       return { case: b[0], bonus: b[1] };
     });

module/rdd-bonus.js

@@ -31,8 +31,8 @@ export class RdDBonus {
   }
 
   /* -------------------------------------------- */
-  static dmg(rollData, dmgActor, isEntiteIncarnee = false) {
+  static dmg(rollData, actor, isEntiteIncarnee = false) {
-    const dmgArme = RdDBonus._dmgArme(rollData)
+    const dmgArme = RdDBonus.dmgArme(rollData.arme)
     let dmg = {
       total: 0,
       dmgArme: dmgArme,
@@ -41,7 +41,7 @@ export class RdDBonus {
       dmgParticuliere: RdDBonus._dmgParticuliere(rollData),
       dmgSurprise: RdDBonus.dmgBonus(rollData.ajustements?.attaqueDefenseurSurpris.used),
       mortalite: RdDBonus._calculMortalite(rollData, isEntiteIncarnee),
-      dmgActor: RdDBonus._dmgPerso(dmgActor, rollData.selectedCarac?.label, dmgArme)
+      dmgActor: RdDBonus.bonusDmg(actor, rollData.selectedCarac?.label.toLowerCase(), dmgArme)
     }
     dmg.total = dmg.dmgSurprise + dmg.dmgTactique + dmg.dmgArme + dmg.dmgActor + dmg.dmgParticuliere;
     return dmg;
@@ -71,11 +71,11 @@ export class RdDBonus {
   }
 
   /* -------------------------------------------- */
-  static _dmgArme(rollData) {
+  static dmgArme(arme) {
-    if (rollData.arme) {
+    if (arme) {
-      let dmgBase = rollData.arme.system.dommagesReels ?? Number(rollData.arme.system.dommages ?? 0);
+      let dmgBase = arme.system.dommagesReels ?? Number(arme.system.dommages ?? 0);
       //Le bonus dégats magiques ne peut pas faire dépasser le bonus de l'arme (cf p.278)
-      return dmgBase + Math.min(dmgBase, rollData.arme.system.magique ? rollData.arme.system.ecaille_efficacite : 0);
+      return dmgBase + Math.min(dmgBase, arme.system.magique ? arme.system.ecaille_efficacite : 0);
     }
     return 0;
   }
@@ -86,13 +86,14 @@ export class RdDBonus {
   }
 
   /* -------------------------------------------- */
-  static _dmgPerso(dmgActor, categorie, dmgArme) {
+  static bonusDmg(actor, categorie, dmgArme) {
+    const dmgActor = actor.getBonusDegat()
     if (categorie == undefined) {
       return 0
     }
     switch (categorie) {
-      case "Tir": return 0;
+      case "tir": return 0;
-      case "Lancer": return Math.max(0, Math.min(dmgArme, dmgActor));
+      case "lancer": return Math.max(0, Math.min(dmgArme, dmgActor));
     }
     return dmgActor;
   }

module/rdd-combat.js

@@ -864,7 +864,7 @@ export class RdDCombat {
   async _onAttaqueNormale(attackerRoll) {
     console.log("RdDCombat.onAttaqueNormale >>>", attackerRoll);
 
-    attackerRoll.dmg = RdDBonus.dmg(attackerRoll, this.attacker.getBonusDegat(), this.defender.isEntite());
+    attackerRoll.dmg = RdDBonus.dmg(attackerRoll, this.attacker, this.defender.isEntite());
     let defenderRoll = { attackerRoll: attackerRoll, passeArme: attackerRoll.passeArme, show: {} }
     attackerRoll.show = {
       cible: this.target ? this.defender.name : 'la cible',

module/rdd-roll.js

@@ -307,7 +307,7 @@ export class RdDRoll extends Dialog {
   async updateRollResult(html) {
     const rollData = this.rollData;
 
-    rollData.dmg = rollData.attackerRoll?.dmg ?? RdDBonus.dmg(rollData, this.actor.getBonusDegat())
+    rollData.dmg = rollData.attackerRoll?.dmg ?? RdDBonus.dmg(rollData, this.actor)
     rollData.caracValue = parseInt(rollData.selectedCarac.value)
     rollData.dmg.mortalite = rollData.dmg.mortalite ?? 'mortel';
     rollData.use.appelAuMoral = this.actor.isPersonnage() && RdDCarac.isActionPhysique(rollData.selectedCarac);