Nettoyage feuilles acteurs

- template partial pour les compétences
- séparation des options/calculs/données
- extraction de méthodes pour les calculs (total xp, total carac, ...)

- déplacement de code de RdDUtility vers RdDItemCompetence / RdDCarac

module/item-competence.js

@@ -1,9 +1,23 @@
-
 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"]];
 
 const competence_xp_par_niveau = [5, 5, 5, 10, 10, 10, 10, 15, 15, 15, 15, 20, 20, 20, 20, 30, 30, 40, 40, 60, 60, 100, 100, 100, 100, 100, 100, 100, 100, 100];
 const competence_niveau_max = competence_xp_par_niveau.length - 10;
+/* -------------------------------------------- */
+const limitesArchetypes = [
+  { "niveau": 0, "nombreMax": 100, "nombre": 0 },
+  { "niveau": 1, "nombreMax": 10, "nombre": 0 },
+  { "niveau": 2, "nombreMax": 9, "nombre": 0 },
+  { "niveau": 3, "nombreMax": 8, "nombre": 0 },
+  { "niveau": 4, "nombreMax": 7, "nombre": 0 },
+  { "niveau": 5, "nombreMax": 6, "nombre": 0 },
+  { "niveau": 6, "nombreMax": 5, "nombre": 0 },
+  { "niveau": 7, "nombreMax": 4, "nombre": 0 },
+  { "niveau": 8, "nombreMax": 3, "nombre": 0 },
+  { "niveau": 9, "nombreMax": 2, "nombre": 0 },
+  { "niveau": 10, "nombreMax": 1, "nombre": 0 },
+  { "niveau": 11, "nombreMax": 1, "nombre": 0 }
+];
 
 /* -------------------------------------------- */
 const categorieCompetences = {
@@ -35,10 +49,10 @@ export class RdDItemCompetence extends Item {
   static getCategorieCompetences() {
     return categorieCompetences;
   }
-  static getLevelCategory(category) {
+  static getNiveauBase(category) {
     return categorieCompetences[category].level;
   }
-  static getLabelCategory(category) {
+  static getLabelCategorie(category) {
     return categorieCompetences[category].label;
   }
 
@@ -77,6 +91,44 @@ export class RdDItemCompetence extends Item {
     }
     return false;
   }
+
+  /* -------------------------------------------- */
+  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 computeXP(competence) {
+    const factor = competence.name.includes('Thanatos') ? 2 : 1; // Thanatos compte double !
+    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 ?? -11, Math.min(it?.data.niveau ?? -11, 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 computeDeltaXP(from, to) {
+    RdDItemCompetence._valideNiveau(from);
+    RdDItemCompetence._valideNiveau(to);
+    return competence_xp_cumul[to] - competence_xp_cumul[from];
+  }
+
+
   /* -------------------------------------------- */
   static computeCompetenceXPCost(competence) {
     let xp = RdDItemCompetence.getDeltaXp(competence.data.base, competence.data.niveau ?? competence.data.base);
@@ -100,6 +152,20 @@ export class RdDItemCompetence extends Item {
     return economie;
   }
 
+  static levelUp(item) {
+    item.data.xpNext = RdDItemCompetence.getCompetenceNextXp(item.data.niveau);
+    item.data.isLevelUp = item.data.xp >= item.data.xpNext;
+  }
+
+  static isVisible(item) {
+    return Number(item.data.niveau) != RdDItemCompetence.getNiveauBase(item.data.categorie);
+  }
+  
+  /* -------------------------------------------- */
+  static isNiveauBase(item) {
+    return Number(item.data.niveau) == RdDItemCompetence.getNiveauBase(item.data.categorie);
+  }
+
   /* -------------------------------------------- */
   static findCompetence(list, name) {
     name = name.toLowerCase();
@@ -127,8 +193,24 @@ export class RdDItemCompetence extends Item {
   /* -------------------------------------------- */
   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)
+      console.warn(`Niveau ${niveau} en dehors des niveaux de compétences: [-11, ${competence_niveau_max} ]`);
     }
   }
+  
+  /* -------------------------------------------- */
+  static computeResumeArchetype(competences) {
+    const archetype = RdDItemCompetence.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 getLimitesArchetypes() {
+      return duplicate(limitesArchetypes);
+    }
+  
 }