Nettoyage de data

* séparation de options, calc, ...
* extraction de méthodes pour clarifier ce qui est fait dans getData
* fix de la feuille: utiliser data.data
* fix d'Actor:  update({ data.data

module/item-competence.js

@@ -1,3 +1,4 @@
+import { RdDUtility } from "./rdd-utility.js";
 
 const competenceTroncs = [["Esquive", "Dague", "Corps à corps"],
 ["Epée à 1 main", "Epée à 2 mains", "Hache à 1 main", "Hache à 2 mains", "Lance", "Masse à 1 main", "Masse à 2 mains"]];
@@ -55,33 +56,70 @@ export class RdDItemCompetence extends Item {
     }
     return false;
   }
+
   /* -------------------------------------------- */
-  static computeCompetenceXPCost(competence) {
-    let xp = RdDItemCompetence.getDeltaXp(competence.data.base, competence.data.niveau ?? competence.data.base);
-    xp += competence.data.xp ?? 0;
-    if ( competence.name.includes('Thanatos') ) xp *= 2; /// Thanatos compte double !
-    xp += competence.data.xp_sort ?? 0;
-    return xp;
+  static computeTotalXP(competences) {
+    const total = competences.map(c => RdDItemCompetence.computeXP(c))
+      .reduce((a, b) => a + b, 0);
+    const economieTronc = RdDItemCompetence.computeEconomieXPTronc(competences);
+    return total - economieTronc;
   }
 
   /* -------------------------------------------- */
-  static computeEconomieCompetenceTroncXP(competences) {
-    let economie = 0;
-    for (let troncList of competenceTroncs) {
-      let list = troncList.map(name => RdDItemCompetence.findCompetence(competences, name))
-        .sort( (c1, c2) => c2.data.niveau - c1.data.niveau); // tri du plus haut au plus bas
-      list.splice(0,1); // ignorer la plus élevée
-      list.forEach(c => {
-        economie += RdDItemCompetence.getDeltaXp(c.data.base, Math.min(c.data.niveau, 0) );
-      });
-    }
-    return economie;
+  static computeXP(competence) {
+    // Thanatos compte double !
+    const factor = competence.name.includes('Thanatos') ? 2 : 1
+    const xpNiveau = RdDItemCompetence.computeDeltaXP(competence.data.base, competence.data.niveau ?? competence.data.base);
+    const xp = competence.data.xp ?? 0;
+    const xpSort = competence.data.xp_sort ?? 0;
+    return factor * (xpNiveau + xp) + xpSort;
+  }
+
+  /* -------------------------------------------- */
+  static computeEconomieXPTronc(competences) {
+    return competenceTroncs.map(
+      list => list.map(name => RdDItemCompetence.findCompetence(competences, name))
+        // calcul du coût xp jusqu'au niveau 0 maximum
+        .map(it => RdDItemCompetence.computeDeltaXP(it.data.base, Math.min(it.data.niveau, 0)))
+        .sort((a, b) => b - a) // tri descendant
+        .splice(0, 1) // ignorer le coût xp le plus élevé
+        .reduce((a, b) => a + b, 0)
+    ).reduce((a, b) => a + b, 0);
+  }
+
+  static setLevelUp(competences) {
+    competences.forEach(it => {
+      it.data.xpNext = RdDItemCompetence.getCompetenceNextXp(it.data.niveau);
+      it.data.isLevelUp = it.data.xp >= it.data.xpNext;
+    });
+  }
+
+  static computeResumeArchetype(competences) {
+    const archetype = RdDUtility.getLimitesArchetypes();
+    competences.forEach(item => {
+      let niveau = (item.data.niveau_archetype < 0) ? 0 : item.data.niveau_archetype;
+      archetype[niveau] = archetype[niveau] ?? { "niveau": niveau, "nombreMax": 0, "nombre": 0 };
+      archetype[niveau].nombre = (archetype[niveau]?.nombre ?? 0) + 1;
+    });
+    return archetype;
+  }
+
+  static isVisible(competence) {
+    return Number(competence.data.niveau) != RdDUtility.getCategorieNiveauBase(competence.data.categorie);
+  }
+
+  static isNiveauBase(competence) {
+    return Number(competence.data.niveau) == RdDUtility.getCategorieNiveauBase(competence.data.categorie);
   }
 
   /* -------------------------------------------- */
   static findCompetence(list, name) {
     name = name.toLowerCase();
-    return list.find(item => item.name.toLowerCase() == name && (item.type == "competence" || item.type == "competencecreature"))
+    return list.find(it => it.name.toLowerCase() == name && (it.type == "competence" || it.type == "competencecreature"))
+  }
+
+  static getEsquive(competences) {
+    return { name: "Esquive", niveau: RdDItemCompetence.findCompetence(competences, 'Esquive')?.data.niveau ?? -6 };
   }
 
   /* -------------------------------------------- */
@@ -96,14 +134,14 @@ export class RdDItemCompetence extends Item {
   }
 
   /* -------------------------------------------- */
-  static getDeltaXp(from, to) {
+  static computeDeltaXP(from, to) {
     RdDItemCompetence._valideNiveau(from);
     RdDItemCompetence._valideNiveau(to);
     return competence_xp_cumul[to] - competence_xp_cumul[from];
   }
 
   /* -------------------------------------------- */
-  static _valideNiveau(niveau){
+  static _valideNiveau(niveau) {
     if (niveau < -11 || niveau > competence_niveau_max) {
       console.warn("Niveau en dehors des niveaux de compétences: [-11, " + competence_niveau_max + "]", niveau)
     }