Toujours lutter sur les data

2021-03-09 00:27:09 +01:00
parent ebf4e08766
commit fcec20ed2e
33 changed files with 299 additions and 570 deletions
--- a/module/actor-creature-sheet.js
+++ b/module/actor-creature-sheet.js
@@ -27,23 +27,15 @@ export class RdDActorCreatureSheet extends RdDActorSheet {


  /* -------------------------------------------- */
-  getData() {
-    let sheetData = super.getData();
+  async getData() {
+    let sheetData = await super.getData();
    console.log("Creature : ", sheetData);
-
-    sheetData.itemsByType = Misc.classify(sheetData.items);
    sheetData.calc = {
      caracTotal: RdDCarac.computeTotal(sheetData.data.data.carac),
      resumeBlessures: sheetData.actor.computeResumeBlessure(sheetData.data.data.blessures),
    }
-    // Compute current carac sum
-    sheetData.data.data.carac.taille.isTaille = true; // To avoid button link;
-
-
-    sheetData.data.data.competencecreature = sheetData.itemsByType["competencecreature"];

    this.actor.computeEncombrementTotalEtMalusArmure();
-    RdDUtility.filterItemsPerTypeForSheet(sheetData);
    RdDUtility.buildArbreDeConteneur(this, sheetData);

    console.log("Creature : ", this.objetVersConteneur, sheetData);
--- a/module/actor-entite-sheet.js
+++ b/module/actor-entite-sheet.js
@@ -23,6 +23,7 @@ export class RdDActorEntiteSheet extends ActorSheet {
  /* -------------------------------------------- */
  getData() {
    let sheetData = super.getData();
+    sheetData.items = Misc.classify(sheetData.items);
    
    sheetData.data.competencecreature = sheetData.itemsByType["competencecreature"];

--- a/module/actor-sheet.js
+++ b/module/actor-sheet.js
@@ -36,27 +36,28 @@ export class RdDActorSheet extends ActorSheet {
    // Partie commune
    let sheetData = await super.getData();

-    sheetData.options = this.options;
-    sheetData.itemsByType = Misc.classify(sheetData.items);
-    sheetData.options.isGM = game.user.isGM;
+    sheetData.items = Misc.classify(sheetData.items);
+    RdDUtility.filterItemsPerTypeForSheet(sheetData);

-    const carac = sheetData.data.data.carac;
+    sheetData.options.isGM = game.user.isGM;
+    sheetData.carac = sheetData.data.data.carac
    // la taille est la taille: on ne peut pas l'utiliser pour un jet
-    carac.taille.isTaille = true;
+    sheetData.carac.taille.isTaille = true;
+
+    sheetData.competences = (sheetData.items.competence??[]).concat(sheetData.items.competencecreature??[]);

    if (sheetData.actor.type == 'creature') return sheetData; // Shortcut

    /* -- partie spécifique aux personnages -- */
-
-    const competences = sheetData.itemsByType.competence;
+    const competences = sheetData.competences;
    // toujours avoir une liste d'armes (pour mettre esquive et corps à corps)
-    sheetData.itemsByType.arme = sheetData.itemsByType.arme ?? [];
+    sheetData.items.arme = sheetData.items.arme ?? [];
    sheetData.competenceByCategory = Misc.classify(competences, comp => comp.data.categorie);

    sheetData.calc = {
      comptageArchetype: RdDItemCompetence.computeResumeArchetype(competences),
      competenceXPTotal: RdDItemCompetence.computeTotalXP(competences),
-      caracTotal: RdDCarac.computeTotal(carac, sheetData.data.data.beaute),
+      caracTotal: RdDCarac.computeTotal(sheetData.carac, sheetData.data.data.beaute),
      // Mise à jour de l'encombrement total et du prix de l'équipement
      encTotal: await sheetData.actor.computeEncombrementTotalEtMalusArmure(),
      prixTotalEquipement: await sheetData.actor.computePrixTotalEquipement(),
@@ -71,23 +72,20 @@ export class RdDActorSheet extends ActorSheet {

    competences.forEach(it => it.visible = this.isCompetenceAffichable(it));
    RdDItemCompetence.setLevelUp(competences);
-    RdDCarac.setLevelUp(carac);
+    RdDCarac.setLevelUp(sheetData.carac);

-    sheetData.armes = duplicate(sheetData.itemsByType.arme);
+    sheetData.armes = duplicate(sheetData.items.arme);
    RdDItemArme.computeNiveauArmes(sheetData.armes, competences);
-    RdDItemArme.ajoutCorpsACorps(sheetData.armes, competences, carac);
+    RdDItemArme.ajoutCorpsACorps(sheetData.armes, competences, sheetData.carac);
    sheetData.esquive = RdDItemCompetence.getEsquive(competences);
-    sheetData.armes = RdDCombatManager.finalizeArmeList(sheetData.armes, competences, carac);
+    sheetData.armes = RdDCombatManager.finalizeArmeList(sheetData.armes, competences, sheetData.carac);

    sheetData.data.data.compteurs.chance.isChance = true;

-
-    RdDUtility.filterItemsPerTypeForSheet(sheetData);
-
    sheetData.tmr = {
      sortsReserve: sheetData.data.data.reve.reserve.list,
      rencontres: sheetData.data.data.reve.rencontre.list,
-      caseSpeciales: sheetData.itemsByType.casetmr
+      caseSpeciales: sheetData.items.casetmr
    }

    RdDUtility.buildArbreDeConteneur(this, sheetData);
@@ -124,13 +122,13 @@ export class RdDActorSheet extends ActorSheet {

  /* -------------------------------------------- */
  async createEmptyTache() {
-    await this.actor.createEmbeddedDocuments('Item', [{ name: 'Nouvelle tache', type: 'tache' }], { renderSheet: true });
+    await this.object.createEmbeddedDocuments('Item', [{ name: 'Nouvelle tache', type: 'tache' }], { renderSheet: true });
  }

  /* -------------------------------------------- */
  async creerObjet() {
    let itemType = $("#creer-equipement").val();
-    await this.actor.createEmbeddedDocuments('Item', [{ name: `Nouveau ${itemType}`, type: itemType }], { renderSheet: true });
+    await this.object.createEmbeddedDocuments('Item', [{ name: `Nouveau ${itemType}`, type: itemType }], { renderSheet: true });
  }

  /* -------------------------------------------- */
@@ -167,20 +165,31 @@ export class RdDActorSheet extends ActorSheet {
      this.options.showCompNiveauBase = !this.options.showCompNiveauBase;
      this.render(true);
    });
+    html.find('.show-hide-archetype').click((event) => {
+      this.options.montrerArchetype = !this.options.montrerArchetype;
+      this.render(true);
+    });

    // Everything below here is only needed if the sheet is editable
    if (!this.options.editable) return;

+    // Gestion du bouton lock/unlock
+    html.find('.lock-unlock-sheet').click((event) => {
+      this.options.editCaracComp = !this.options.editCaracComp;
+      this.render(true);
+    });
+
+    
    html.find('.item-edit').click(ev => {
      const li = $(ev.currentTarget).parents(".item");
-      const item = this.actor.items.get(li.data("item-id"));
+      const item = this.object.items.get(li.data("item-id"));
      item.sheet.render(true);
    });
    // Update Inventory Item
    html.find('.rencontre-delete').click(ev => {
      const li = $(ev.currentTarget).parents(".item");
      const rencontreKey = li.data("item-id");
-      this.actor.deleteTMRRencontre(rencontreKey);
+      this.object.deleteTMRRencontre(rencontreKey);
    });

    // Delete Inventory Item
@@ -194,12 +203,12 @@ export class RdDActorSheet extends ActorSheet {
    });

    html.find('.encaisser-direct').click(ev => {
-      this.actor.encaisser();
+      this.object.encaisser();
    });

    html.find('.remise-a-neuf').click(ev => {
      if (game.user.isGM) {
-        this.actor.remiseANeuf();
+        this.object.remiseANeuf();
        ev.preventDefault();
      }
    });
@@ -210,7 +219,7 @@ export class RdDActorSheet extends ActorSheet {
      this.selectObjetType();
    });
    html.find('#nettoyer-conteneurs').click(ev => {
-      this.actor.nettoyerConteneurs();
+      this.object.nettoyerConteneurs();
    });

    // Blessure control
@@ -220,7 +229,7 @@ export class RdDActorSheet extends ActorSheet {
      let index = li.data('blessure-index');
      let active = $(ev.currentTarget).data('blessure-active');
      //console.log(btype, index, active);
-      this.actor.manageBlessureFromSheet(btype, index, active).then(this.render(true));
+      this.object.manageBlessureFromSheet(btype, index, active).then(this.render(true));
    });

    // Blessure data
@@ -233,78 +242,77 @@ export class RdDActorSheet extends ActorSheet {
      let jours = li.find('input[name=jours]').val();
      let loc = li.find('input[name=localisation]').val();
      //console.log(btype, index, psoins, pcomplets, jours, loc);
-      this.actor.setDataBlessureFromSheet(btype, index, psoins, pcomplets, jours, loc).then(this.render(true));
+      this.object.setDataBlessureFromSheet(btype, index, psoins, pcomplets, jours, loc).then(this.render(true));
    });

    // Equip Inventory Item
    html.find('.item-equip').click(ev => {
      const li = $(ev.currentTarget).parents(".item");
-      this.actor.equiperObjet(li.data("item-id"));
-      this.render(true);
+      this.object.equiperObjet(li.data("item-id"));
    });

    // Roll Carac
    html.find('.carac-label a').click((event) => {
      let caracName = event.currentTarget.attributes.name.value;
-      this.actor.rollCarac(caracName.toLowerCase());
+      this.object.rollCarac(caracName.toLowerCase());
    });

    html.find('.chance-actuelle').click((event) => {
-      this.actor.rollCarac('chance-actuelle');
+      this.object.rollCarac('chance-actuelle');
    });

    html.find('.chance-appel').click((event) => {
-      this.actor.rollAppelChance();
+      this.object.rollAppelChance();
    });

    html.find('.jet-astrologie').click((event) => {
-      this.actor.astrologieNombresAstraux();
+      this.object.astrologieNombresAstraux();
    });

    // Roll Skill
    html.find('.competence-label a').click((event) => {
      let compName = event.currentTarget.text;
-      this.actor.rollCompetence(compName);
+      this.object.rollCompetence(compName);
    });
    html.find('.tache-label a').click((event) => {
      const li = $(event.currentTarget).parents(".item");
      let tacheId = li.data('item-id');
-      this.actor.rollTache(tacheId);
+      this.object.rollTache(tacheId);
    });
    html.find('.meditation-label a').click((event) => {
      const li = $(event.currentTarget).parents(".item");
      let meditationId = li.data('item-id');
-      this.actor.rollMeditation(meditationId);
+      this.object.rollMeditation(meditationId);
    });
    html.find('.chant-label a').click((event) => {
      const li = $(event.currentTarget).parents(".item");
      let chantId = li.data('item-id');
-      this.actor.rollChant(chantId);
+      this.object.rollChant(chantId);
    });
    html.find('.danse-label a').click((event) => {
      const li = $(event.currentTarget).parents(".item");
      let danseId = li.data('item-id');
-      this.actor.rollDanse(danseId);
+      this.object.rollDanse(danseId);
    });
    html.find('.musique-label a').click((event) => {
      const li = $(event.currentTarget).parents(".item");
      let musiqueId = li.data('item-id');
-      this.actor.rollMusique(musiqueId);
+      this.object.rollMusique(musiqueId);
    });
    html.find('.oeuvre-label a').click((event) => {
      const li = $(event.currentTarget).parents(".item");
      let oeuvreId = li.data('item-id');
-      this.actor.rollOeuvre(oeuvreId);
+      this.object.rollOeuvre(oeuvreId);
    });
    html.find('.jeu-label a').click((event) => {
      const li = $(event.currentTarget).parents(".item");
      let jeuId = li.data('item-id');
-      this.actor.rollJeu(jeuId);
+      this.object.rollJeu(jeuId);
    });
    html.find('.recettecuisine-label a').click((event) => {
      const li = $(event.currentTarget).parents(".item");
      let recetteId = li.data('item-id');
-      this.actor.rollRecetteCuisine(recetteId);
+      this.object.rollRecetteCuisine(recetteId);
    });
    html.find('.subacteur-label a').click((event) => {
      const li = $(event.currentTarget).parents(".item");
@@ -317,18 +325,18 @@ export class RdDActorSheet extends ActorSheet {

    // Points de reve actuel
    html.find('.ptreve-actuel a').click((event) => {
-      this.actor.rollCarac('reve-actuel');
+      this.object.rollCarac('reve-actuel');
    });

    // Roll Weapon1
    html.find('.arme-label a').click((event) => {
      let armeName = event.currentTarget.text;
      let competenceName = event.currentTarget.attributes['data-competence-name'].value;
-      this.actor.rollArme(competenceName, armeName);
+      this.object.rollArme(competenceName, armeName);
    });
    // Initiative pour l'arme
    html.find('.arme-initiative a').click((event) => {
-      let combatant = game.combat.data.combatants.find(c => c.actor.data._id == this.actor.data._id);
+      let combatant = game.combat.data.combatants.find(c => c.actor.data._id == this.object.data._id);
      if (combatant) {
        let armeName = event.currentTarget.attributes['data-arme-name'].value;
        let arme = this.armesList.find(a => a.name == armeName);
@@ -339,44 +347,44 @@ export class RdDActorSheet extends ActorSheet {
    });
    // Display TMR, visuualisation
    html.find('.visu-tmr').click((event) => {
-      this.actor.displayTMR("visu");
+      this.object.displayTMR("visu");
    });

    // Display TMR, normal
    html.find('.monte-tmr').click((event) => {
-      this.actor.displayTMR("normal");
+      this.object.displayTMR("normal");
    });

    // Display TMR, fast 
    html.find('.monte-tmr-rapide').click((event) => {
-      this.actor.displayTMR("rapide");
+      this.object.displayTMR("rapide");
    });

    html.find('.dormir-une-heure').click((event) => {
-      this.actor.dormir(1);
+      this.object.dormir(1);
    });
    html.find('.dormir-chateau-dormant').click((event) => {
-      this.actor.dormirChateauDormant();
+      this.object.dormirChateauDormant();
    });
    html.find('.enlever-tous-effets').click((event) => {
-      this.actor.enleverTousLesEffets();
+      this.object.enleverTousLesEffets();
    });
    // Display info about queue
    html.find('.queuesouffle-label a').click((event) => {
      let myID = event.currentTarget.attributes['data-item-id'].value;
-      const item = this.actor.items.get(myID);
+      const item = this.object.items.get(myID);
      item.sheet.render(true);
    });
    // Info sort
    html.find('.sort-label a').click((event) => {
      let myID = event.currentTarget.attributes['data-id'].value;
-      const item = this.actor.items.get(myID);
+      const item = this.object.items.get(myID);
      item.sheet.render(true);
    });
    // Info sort
    html.find('.case-label a').click((event) => {
      let myID = event.currentTarget.attributes['data-id'].value;
-      const item = this.actor.items.get(myID);
+      const item = this.object.items.get(myID);
      item.sheet.render(true);
    });

@@ -384,152 +392,123 @@ export class RdDActorSheet extends ActorSheet {
    html.find('.conteneur-name a').click((event) => {
      let myID = event.currentTarget.attributes['data-item-id'].value;
      RdDUtility.toggleAfficheContenu(myID);
-      this.render(true);
    });

    if (this.options.editCaracComp) {
      // On carac change
      html.find('.carac-value').change((event) => {
        let caracName = event.currentTarget.name.replace(".value", "").replace("data.carac.", "");
-        this.actor.updateCarac(caracName, parseInt(event.target.value));
+        this.object.updateCarac(caracName, parseInt(event.target.value));
      });
      html.find('.carac-xp').change((event) => {
        let caracName = event.currentTarget.name.replace(".xp", "").replace("data.carac.", "");
-        this.actor.updateCaracXP(caracName, parseInt(event.target.value));
+        this.object.updateCaracXP(caracName, parseInt(event.target.value));
      });
      // On competence change
      html.find('.competence-value').change((event) => {
        let compName = event.currentTarget.attributes.compname.value;
        //console.log("Competence changed :", compName);
-        this.actor.updateCompetence(compName, parseInt(event.target.value));
+        this.object.updateCompetence(compName, parseInt(event.target.value));
      });
      // On competence xp change
      html.find('.competence-xp').change((event) => {
        let compName = event.currentTarget.attributes.compname.value;
-        this.actor.updateCompetenceXP(compName, parseInt(event.target.value));
+        this.object.updateCompetenceXP(compName, parseInt(event.target.value));
      });
      // On competence xp change
      html.find('.competence-xp-sort').change((event) => {
        let compName = event.currentTarget.attributes.compname.value;
-        this.actor.updateCompetenceXPSort(compName, parseInt(event.target.value));
+        this.object.updateCompetenceXPSort(compName, parseInt(event.target.value));
      });
      // On competence archetype change
      html.find('.competence-archetype').change((event) => {
        let compName = event.currentTarget.attributes.compname.value;
-        this.actor.updateCompetenceArchetype(compName, parseInt(event.target.value));
+        this.object.updateCompetenceArchetype(compName, parseInt(event.target.value));
      });
    }

-    // Gestion du bouton lock/unlock
-    html.find('.lock-unlock-sheet').click((event) => {
-      this.options.editCaracComp = !this.options.editCaracComp;
-      this.render(true);
-    });
-    html.find('.show-hide-archetype').click((event) => {
-      this.options.montrerArchetype = !this.options.montrerArchetype;
-      this.render(true);
-    });
-
    // On pts de reve change
    html.find('.pointsreve-value').change((event) => {
-      this.actor.update({ "data.reve.reve.value": parseInt(event.currentTarget.value) });
+      this.object.update({ "data.reve.reve.value": parseInt(event.currentTarget.value) });
    });

    // On seuil de reve change
    html.find('.seuil-reve-value').change((event) => {
      console.log("seuil-reve-value", event.currentTarget)
-      this.actor.setPointsDeSeuil(parseInt(event.currentTarget.value));
+      this.object.setPointsDeSeuil(parseInt(event.currentTarget.value));
    });

    html.find('.attribut-protection-edit').change((event) => {
-      this.actor.updateAttribut(event.currentTarget.attributes.name.value, parseInt(event.target.value));
+      this.object.updateAttribut(event.currentTarget.attributes.name.value, parseInt(event.target.value));
    });

    // On stress change
    html.find('.compteur-edit').change((event) => {
      let fieldName = event.currentTarget.attributes.name.value;
-      this.actor.updateCompteur(fieldName, parseInt(event.target.value));
+      this.object.updateCompteur(fieldName, parseInt(event.target.value));
    });

    html.find('.ethylisme').change((event) => {
-      this.actor.setEthylisme(parseInt(event.target.value));
+      this.object.setEthylisme(parseInt(event.target.value));
    });
    html.find('.stress-test').click((event) => {
-      this.actor.transformerStress();
-      this.render(true);
+      this.object.transformerStress();
    });
    html.find('.moral-malheureux').click((event) => {
-      this.actor.jetDeMoral('malheureuse');
-      this.render(true);
-    });
+      this.object.jetDeMoral('malheureuse');
+      });
    html.find('.moral-neutre').click((event) => {
-      this.actor.jetDeMoral('neutre');
-      this.render(true);
+      this.object.jetDeMoral('neutre');
    });
    html.find('.moral-heureux').click((event) => {
-      this.actor.jetDeMoral('heureuse');
-      this.render(true);
+      this.object.jetDeMoral('heureuse');
    });
    html.find('.ethylisme-test').click((event) => {
-      this.actor.ethylismeTest();
-      this.render(true);
+      this.object.ethylismeTest();
    });

    html.find('.jet-vie').click((event) => {
-      this.actor.jetVie();
-      this.render(true);
+      this.object.jetVie();
    });
    html.find('.jet-endurance').click((event) => {
-      this.actor.jetEndurance();
-      this.render(true);
+      this.object.jetEndurance();
    });

    html.find('.monnaie-plus').click((event) => {
      const li = $(event.currentTarget).parents(".item");
-      this.actor.monnaieIncDec(li.data("item-id"), 1);
-      this.render(true);
+      this.object.monnaieIncDec(li.data("item-id"), 1);
    });
    html.find('.monnaie-moins').click((event) => {
      const li = $(event.currentTarget).parents(".item");
-      this.actor.monnaieIncDec(li.data("item-id"), -1);
-      this.render(true);
+      this.object.monnaieIncDec(li.data("item-id"), -1);
    });

    html.find('.vie-plus').click((event) => {
-      this.actor.santeIncDec("vie", 1);
-      this.render(true);
+      this.object.santeIncDec("vie", 1);
    });
    html.find('.vie-moins').click((event) => {
-      this.actor.santeIncDec("vie", -1);
-      this.render(true);
+      this.object.santeIncDec("vie", -1);
    });
    html.find('.endurance-plus').click((event) => {
-      this.actor.santeIncDec("endurance", 1);
-      this.render(true);
+      this.object.santeIncDec("endurance", 1);
    });
    html.find('.endurance-moins').click((event) => {
-      this.actor.santeIncDec("endurance", -1);
-      this.render(true);
+      this.object.santeIncDec("endurance", -1);
    });
    html.find('.data-sante-sonne').click((event) => {
-      this.actor.setSonne(event.currentTarget.checked);
-      this.render(true);
+      this.object.setSonne(event.currentTarget.checked);
    });
    html.find('.ptreve-actuel-plus').click((event) => {
-      this.actor.reveActuelIncDec(1);
-      this.render(true);
+      this.object.reveActuelIncDec(1);
    });
    html.find('.ptreve-actuel-moins').click((event) => {
-      this.actor.reveActuelIncDec(-1);
-      this.render(true);
+      this.object.reveActuelIncDec(-1);
    });
    html.find('.fatigue-plus').click((event) => {
-      this.actor.santeIncDec("fatigue", 1);
-      this.render(true);
+      this.object.santeIncDec("fatigue", 1);
    });
    html.find('.fatigue-moins').click((event) => {
-      this.actor.santeIncDec("fatigue", -1);
-      this.render(true);
+      this.object.santeIncDec("fatigue", -1);
    });
  }

--- a/module/actor-vehicule-sheet.js
+++ b/module/actor-vehicule-sheet.js
@@ -25,8 +25,8 @@ export class RdDActorVehiculeSheet extends ActorSheet {
  }

  /* -------------------------------------------- */
-  getData() {
-    let sheetData = super.getData();
+  async getData() {
+    let sheetData = await super.getData();
    sheetData.options = {
      isGM: game.user.isGM
    };
@@ -36,13 +36,11 @@ export class RdDActorVehiculeSheet extends ActorSheet {
    RdDUtility.filterItemsPerTypeForSheet(sheetData);
    RdDUtility.buildArbreDeConteneur(this, sheetData);

-    this.actor.computeEncombrementTotalEtMalusArmure();    
    sheetData.calc = {
-      surEncombrementMessage: (this.encTotal > sheetData.capacite_encombrement) ? "Sur-Encombrement!" : ""
+      surEncombrementMessage: (this.encTotal > sheetData.capacite_encombrement) ? "Sur-Encombrement!" : "",
+      encTotal: await sheetData.actor.computeEncombrementTotalEtMalusArmure()
    }

-    console.log("DATA", sheetData);
-
    return sheetData;
  }
  
--- a/module/actor.js
+++ b/module/actor.js
@@ -253,10 +253,6 @@ export class RdDActor extends Actor {
    return Misc.toInt(this.data.data.compteurs.surenc?.value);
  }
  /* -------------------------------------------- */
-  loadCompendiumNames() {
-    return this.data.items.filter((item) => item.data.type == 'competence');
-  }
-  /* -------------------------------------------- */
  getCompetence(name) {
    return RdDItemCompetence.findCompetence(this.data.items, name);
  }
@@ -964,19 +960,19 @@ export class RdDActor extends Actor {
    let malusArmureData = (this.data.data.attributs && this.data.data.attributs.malusarmure) ? duplicate(this.data.data.attributs.malusarmure) : {};
    let newMalusArmure = 0;
    for (const item of this.data.items) {
-      if (item.type == 'armure' && item.data.equipe) {  // Armure équipée, intégration du malus armure total
-        newMalusArmure += item.data.malus;
+      if (item.type == 'armure' && item.data.data.equipe) {  // Armure équipée, intégration du malus armure total
+        newMalusArmure += item.data.data.malus;
      }
      // Calcul encombrement
-      if (item.data && item.data.encombrement != undefined) {
-        if (!Number(item.data.encombrement)) item.data.encombrement = 0; // Auto-fix
-        if (item.data.quantite == undefined) item.data.quantite = 1; // Auto-fix
-        if (item.data.quantite < 0) item.data.quantite = 0; // Auto-fix
-        item.data.encTotal = Number(item.data.encombrement) * Number(item.data.quantite);
-        //console.log("Enc:", item.name, item.data.encombrement, item.data.quantite, item.data.encTotal);
-        encTotal += item.data.encTotal;
-      } else {
-        item.data.encTotal = 0; // Force default enc
+      if (item.data && item.data.data.encombrement != undefined) {
+        if (!Number(item.data.data.encombrement)) item.data.data.encombrement = 0; // Auto-fix
+        item.data.data.quantite = item.data.data.quantite ??1; // Auto-fix
+        if (item.data.data.quantite < 0) item.data.data.quantite = 0; // Auto-fix
+        item.data.data.encTotal = Number(item.data.data.encombrement) * Number(item.data.data.quantite);
+        //console.log("Enc:", item.name, item.data.data.encombrement, item.data.data.quantite, item.data.data.encTotal);
+        encTotal += item.data.data.encTotal;
+      // } else {
+      //   item.data.data.encTotal = 0; // Force default enc
      }
    }
    // Mise à jour valeur totale et états
@@ -996,11 +992,11 @@ export class RdDActor extends Actor {

    // prix total de l'équipement est la somme du cout de chaque équipement multiplié par sa quantité.
    for (const item of this.data.items) {
-      if (item.data.data && item.data.cout != undefined) {
-        if (!Number(item.data.cout)) item.data.cout = 0; // Auto-fix
-        if (item.data.quantite == undefined) item.data.quantite = 1; // Auto-fix
-        if (item.data.cout < 0) item.data.cout = 0; // Auto-fix
-        prixTotalEquipement += Number(item.data.cout) * Number(item.data.quantite);
+      if (item.data.data && item.data.data.cout != undefined) {
+        if (!Number(item.data.data.cout)) item.data.data.cout = 0; // Auto-fix
+        if (item.data.data.quantite == undefined) item.data.data.quantite = 1; // Auto-fix
+        if (item.data.data.cout < 0) item.data.data.cout = 0; // Auto-fix
+        prixTotalEquipement += Number(item.data.data.cout) * Number(item.data.data.quantite);
      }
    }
    // Mise à jour valeur totale de l'équipement
@@ -1717,7 +1713,7 @@ export class RdDActor extends Actor {
    let bestDraconic = this.getBestDraconic();
    for (let sort of sortList) {
      let voie = sort.data.draconic.toLowerCase();
-      let draconic = draconicList.find(item => item.data.categorie == 'draconic' && item.name.toLowerCase().includes(voie));
+      let draconic = draconicList.find(item => item.data.data.categorie == 'draconic' && item.name.toLowerCase().includes(voie));
      if (sort.name.toLowerCase().includes('aura')) {
        draconic = bestDraconic;
      }
@@ -1961,13 +1957,13 @@ export class RdDActor extends Actor {
      data: {
        carac: 'intellect',
        competence: 'Ecriture',
-        difficulte: item.data.difficulte,
+        difficulte: item.data.data.difficulte,
        periodicite: "60 minutes",
        fatigue: 2,
-        points_de_tache: item.data.points_de_tache,
+        points_de_tache: item.data.data.points_de_tache,
        points_de_tache_courant: 0,
        description: "Lecture du livre " + item.name +
-          " - XP : " + item.data.xp + " - Compétences : " + item.data.competence
+          " - XP : " + item.data.data.xp + " - Compétences : " + item.data.data.competence
      }
    }
    await this.createEmbeddedDocuments('Item', [tache], { renderSheet: true });
@@ -2307,7 +2303,7 @@ export class RdDActor extends Actor {
    );

    // Suppression des anciens nombres astraux
-    let toDelete = this.data.items.filter((item) => item.data.jourindex < game.system.rdd.calendrier.getCurrentDayIndex());
+    let toDelete = this.data.items.filter((item) => item.data.data.jourindex < game.system.rdd.calendrier.getCurrentDayIndex());
    await this.deleteEmbeddedDocuments('Item', toDelete.map(i => i._id));

    // Affichage Dialog
@@ -2366,7 +2362,7 @@ export class RdDActor extends Actor {

  /* -------------------------------------------- */
  getDraconicList() {
-    return this.data.items.filter(item => item.data.categorie == 'draconic')
+    return this.data.items.filter(item => item.data.data.categorie == 'draconic')
  }

  /* -------------------------------------------- */
@@ -2450,10 +2446,10 @@ export class RdDActor extends Actor {

  /* -------------------------------------------- */
  verifierForceMin(item) {
-    if (item.data.type == 'arme' && item.data.force > this.data.data.carac.force.value) {
+    if (item.data.type == 'arme' && item.data.data.force > this.data.data.carac.force.value) {
      ChatMessage.create({
        content: `<strong>${this.name} s'est équipé(e) de l'arme ${item.name}, mais n'a pas une force suffisante pour l'utiliser normalement </strong>
-                             (${item.data.force} nécessaire pour une Force de ${this.data.data.carac.force.value})`
+                             (${item.data.data.force} nécessaire pour une Force de ${this.data.data.carac.force.value})`
      });
    }
  }
@@ -2462,11 +2458,11 @@ export class RdDActor extends Actor {
  async equiperObjet(itemID) {
    let item = this.items.get(itemID);
    if (item && item.data.data) {
-      let update = { _id: item._id, "data.equipe": !item.data.equipe };
+      let update = { _id: item._id, "data.equipe": !item.data.data.equipe };
      await this.updateEmbeddedDocuments('Item', [update]);
-      this.computeEncombrementTotalEtMalusArmure(); // Mise à jour encombrement
+      await this.computeEncombrementTotalEtMalusArmure(); // Mise à jour encombrement
      this.computePrixTotalEquipement(); // Mis à jour du prix total de l'équipement
-      if (item.data.equipe)
+      if (item.data.data.equipe)
        this.verifierForceMin(item.data.data);
    }
  }
@@ -2478,7 +2474,7 @@ export class RdDActor extends Actor {
    let protection = 0;
    const armures = this.data.items.filter(it => it.type == "armure" && it.data.equipe);
    for (const item of armures) {
-      protection += new Roll(item.data.protection.toString()).roll().total;
+      protection += new Roll(item.data.data.protection.toString()).roll().total;
      if (dmg > 0) {
        this._deteriorerArmure(item, dmg);
        dmg = 0;
@@ -2779,25 +2775,25 @@ export class RdDActor extends Actor {
    let nbEtain = deniers - (nbBronze * 10);

    //    console.log("ARGENT", nbOr, nbArgent, nbBronze, nbEtain);
-    let piece = this.data.items.find(item => item.type == 'monnaie' && item.data.valeur_deniers == 1000);
+    let piece = this.data.items.find(item => item.type == 'monnaie' && item.data.data.valeur_deniers == 1000);
    if (piece) {
      let update = { _id: piece._id, 'data.quantite': nbOr };
      const updated = await this.updateEmbeddedEntity("OwnedItem", update);
    }

-    piece = this.data.items.find(item => item.type == 'monnaie' && item.data.valeur_deniers == 100);
+    piece = this.data.items.find(item => item.type == 'monnaie' && item.data.data.valeur_deniers == 100);
    if (piece) {
      let update = { _id: piece._id, 'data.quantite': nbArgent };
      const updated = await this.updateEmbeddedEntity("OwnedItem", update);
    }

-    piece = this.data.items.find(item => item.type == 'monnaie' && item.data.valeur_deniers == 10);
+    piece = this.data.items.find(item => item.type == 'monnaie' && item.data.data.valeur_deniers == 10);
    if (piece) {
      let update = { _id: piece._id, 'data.quantite': nbBronze };
      const updated = await this.updateEmbeddedEntity("OwnedItem", update);
    }

-    piece = this.data.items.find(item => item.type == 'monnaie' && item.data.valeur_deniers == 1);
+    piece = this.data.items.find(item => item.type == 'monnaie' && item.data.data.valeur_deniers == 1);
    if (piece) {
      let update = { _id: piece._id, 'data.quantite': nbEtain };
      const updated = await this.updateEmbeddedEntity("OwnedItem", update);
--- a/module/item-arme.js
+++ b/module/item-arme.js
@@ -18,7 +18,7 @@ const nomCategorieParade = {
 export class RdDItemArme extends Item {

  static isArme(item) {
-    return (item.data.type == 'competencecreature' && item.data.iscombat) || item.data.type == 'arme';
+    return (item.data.type == 'competencecreature' && item.data.data.iscombat) || item.data.type == 'arme';
  }

  /* -------------------------------------------- */
@@ -51,20 +51,20 @@ export class RdDItemArme extends Item {

  /* -------------------------------------------- */
  static getCategorieParade(arme) {
-    if (arme.data.categorie_parade) {
-      return arme.data.categorie_parade;
+    if (arme.data.data.categorie_parade) {
+      return arme.data.data.categorie_parade;
    }
    // pour compatibilité avec des personnages existants
-    if (arme.type == 'competencecreature' ||  arme.data.categorie == 'creature' ) {
-      return arme.data.categorie_parade || (arme.data.isparade ? 'sans-armes' : '');
+    if (arme.type == 'competencecreature' ||  arme.data.data.categorie == 'creature' ) {
+      return arme.data.data.categorie_parade || (arme.data.data.isparade ? 'sans-armes' : '');
    }
    if (!arme.type.match(/arme|competencecreature/)) {
      return '';
    }
-    if (arme.data.competence == undefined) {
+    if (arme.data.data.competence == undefined) {
      return 'competencecreature';
    }
-    let compname = arme.data.competence.toLowerCase();
+    let compname = arme.data.data.competence.toLowerCase();
    if (compname.match(/^(dague de jet|javelot|fouet|arc|arbalête|fronde|hache de jet|fléau)$/)) return '';

    if (compname.match('hache')) return 'haches';
@@ -122,20 +122,20 @@ export class RdDItemArme extends Item {
  /* -------------------------------------------- */
  static armeUneOuDeuxMains(arme, aUneMain) {
    if (arme) {
-      arme.data.unemain = arme.data.unemain || !arme.data.deuxmains;
-      const uneOuDeuxMains = arme.data.unemain && arme.data.deuxmains;
-      const containsSlash = !Number.isInteger(arme.data.dommages) && arme.data.dommages.includes("/");
+      arme.data.data.unemain = arme.data.data.unemain || !arme.data.data.deuxmains;
+      const uneOuDeuxMains = arme.data.data.unemain && arme.data.data.deuxmains;
+      const containsSlash = !Number.isInteger(arme.data.data.dommages) && arme.data.data.dommages.includes("/");
      if (containsSlash) { // Sanity check
        arme = duplicate(arme);

-        const tableauDegats = arme.data.dommages.split("/");
+        const tableauDegats = arme.data.data.dommages.split("/");
        if (aUneMain)
-          arme.data.dommagesReels = Number(tableauDegats[0]);
+          arme.data.data.dommagesReels = Number(tableauDegats[0]);
        else // 2 mains
-          arme.data.dommagesReels = Number(tableauDegats[1]);
+          arme.data.data.dommagesReels = Number(tableauDegats[1]);
      }
      else {
-        arme.data.dommagesReels = Number(arme.data.dommages);
+        arme.data.data.dommagesReels = Number(arme.data.data.dommages);
      }

      if (uneOuDeuxMains != containsSlash) {
@@ -146,12 +146,13 @@ export class RdDItemArme extends Item {
  }

  static isArmeUtilisable(item) {
-    return item.data.type == 'arme' && (item.data.resistance > 0 || item.data.portee_courte>0);
+    return item.data.type == 'arme' && (item.data.data.resistance > 0 || item.data.data.portee_courte>0);
  }

  static mainsNues(actorData={}) {
    const mainsNues = {
      name: 'Mains nues',
+      img: "systems/foundryvtt-reve-de-dragon/icons/competence_corps_a_corps.webp",
      data: {
        equipe: true,
        rapide: true,
@@ -183,8 +184,8 @@ export class RdDItemArme extends Item {
    }
  }

-  static computeNiveauArme(arme, competences) {
-    const compName = arme.data.competence;
+  static computeNiveauArme(armeData, competences) {
+    const compName = armeData.data.competence;
    const compArme = competences.find(it => it.name == compName);
    return compArme?.data.niveau ?? -8;
  }
--- a/module/item-competence.js
+++ b/module/item-competence.js
@@ -27,7 +27,7 @@ const competence_xp_cumul = _buildCumulXP();

 export class RdDItemCompetence extends Item {

-  static compendium(actorType){
+  static compendium(actorType) {
    return compendiumCompetences[actorType] ?? '';
  }
  /* -------------------------------------------- */
@@ -89,7 +89,7 @@ export class RdDItemCompetence extends Item {
    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)))
+        .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)
--- a/module/item-sheet.js
+++ b/module/item-sheet.js
@@ -50,14 +50,14 @@ export class RdDItemSheet extends ItemSheet {
    let sheetData = super.getData();

    sheetData.categorieCompetences = RdDUtility.getCategorieCompetences();
-    if ( sheetData.item.data.type == 'tache' || sheetData.item.data.type == 'livre' || sheetData.item.data.type == 'meditation' || sheetData.item.data.type == 'oeuvre') {
+    if ( sheetData.data.type == 'tache' || sheetData.data.type == 'livre' || sheetData.data.type == 'meditation' || sheetData.data.type == 'oeuvre') {
      sheetData.caracList = duplicate(game.system.model.Actor.personnage.carac);
-      sheetData.competences = await RdDUtility.loadCompendiumNames( 'foundryvtt-reve-de-dragon.competences' );
+      sheetData.competences = await RdDUtility.loadCompendium( 'foundryvtt-reve-de-dragon.competences' );
    }
-    if (sheetData.item.data.type == 'arme') {
+    if (sheetData.data.type == 'arme') {
      sheetData.competences = await RdDUtility.loadCompendium( 'foundryvtt-reve-de-dragon.competences', it => RdDItemCompetence.isCompetenceArme(it));
    }
-    if ( sheetData.item.data.type == 'recettealchimique' ) {
+    if ( sheetData.data.type == 'recettealchimique' ) {
      RdDAlchimie.processManipulation(sheetData.item, this.actor && this.actor.id );
    }
    if ( this.actor ) {
--- a/module/misc.js
+++ b/module/misc.js
@@ -40,21 +40,22 @@ export class Misc {
  }

  static classify(items, classifier = item => item.type, transform = it => it) {
-    let itemsBy = {};
-    Misc.classifyInto(itemsBy, items, classifier, transform);
-    return itemsBy;
+    return Misc.classifyInto({}, items, classifier, transform);
  }

  static classifyInto(itemsBy, items, classifier = item => item.type, transform = it => it) {
-    for (const item of items) {
-      const classification = classifier(item);
-      let list = itemsBy[classification];
-      if (!list) {
-        list = [];
-        itemsBy[classification] = list;
+    if (items) {
+      for (const item of items) {
+        const classification = classifier(item);
+        let list = itemsBy[classification];
+        if (!list) {
+          list = [];
+          itemsBy[classification] = list;
+        }
+        list.push(transform(item));
      }
-      list.push(transform(item));
    }
+    return itemsBy;
  }

  static rollOneOf(array) {
--- a/module/rdd-astrologie-joueur.js
+++ b/module/rdd-astrologie-joueur.js
@@ -46,12 +46,12 @@ export class RdDAstrologieJoueur extends Dialog {
    let itemNombres = actor.data.items.filter( (item) => item.data.type == 'nombreastral');
    let itemFiltered = {};
    for ( let item of itemNombres) {
-      if ( itemFiltered[item.data.jourindex] ) {
-        itemFiltered[item.data.jourindex].listValues.push(item.data.value);
+      if ( itemFiltered[item.data.data.jourindex] ) {
+        itemFiltered[item.data.data.jourindex].listValues.push(item.data.data.value);
      } else {
-        itemFiltered[item.data.jourindex] = {
-          listValues: [ item.data.value ],
-          jourlabel: item.data.jourlabel
+        itemFiltered[item.data.data.jourindex] = {
+          listValues: [ item.data.data.value ],
+          jourlabel: item.data.data.jourlabel
        }
      }
    }
--- a/module/rdd-calendrier.js
+++ b/module/rdd-calendrier.js
@@ -58,15 +58,16 @@ export class RdDCalendrier extends Application {
    }
    // nombre astral
    if ( game.user.isGM) {
-      this.listeNombreAstral = this._loadListNombreAstral(); 
+      this.listeNombreAstral = this._loadListeNombreAstral(); 
      this.rebuildListeNombreAstral(); // Ensure always up-to-date
    }
    console.log(this.calendrier, this.calendrierPos, this.listeNombreAstral);
  }
  
  /* -------------------------------------------- */
-  _loadListNombreAstral() {
-    return Object.values(game.settings.get("foundryvtt-reve-de-dragon", "liste-nombre-astral"));
+  _loadListeNombreAstral() {
+    const settingListeNombreAstral = game.settings.get("foundryvtt-reve-de-dragon", "liste-nombre-astral");
+    return Object.values(settingListeNombreAstral);
  }

  /* -------------------------------------------- */
@@ -124,7 +125,7 @@ export class RdDCalendrier extends Application {

  /* -------------------------------------------- */
  getNombreAstral( indexDate ) {
-    const liste = this.listeNombreAstral ?? this._loadListNombreAstral();
+    const liste = this.listeNombreAstral ?? this._loadListeNombreAstral();
    let astralData = liste.find( (nombreAstral, i) => nombreAstral.index == indexDate );
    if (! astralData?.nombreAstral ) {
      this.rebuildListeNombreAstral();
@@ -145,6 +146,7 @@ export class RdDCalendrier extends Application {
        }
      }
    }
+    this.listeNombreAstral = newList;
    game.settings.set("foundryvtt-reve-de-dragon", "liste-nombre-astral", this.listeNombreAstral );
  }

--- a/module/rdd-combat.js
+++ b/module/rdd-combat.js
@@ -141,6 +141,7 @@ export class RdDCombatManager extends Combat {
      if (arme.data.equipe) {
        armesEquipe.push(arme);
        let comp = competences.find(c => c.name == arme.data.competence);
+        arme.data.niveau = comp.data.niveau;
        arme.data.initiative = RdDCombatManager.calculInitiative(arme.data.niveau, carac[comp.data.defaut_carac].value);
        // Dupliquer les armes pouvant être à 1 main et 2 mains en patchant la compétence
        if (arme.data.unemain && !arme.data.deuxmains) {
--- a/module/rdd-compendium-organiser.js
+++ b/module/rdd-compendium-organiser.js
@@ -36,15 +36,15 @@ export class RddCompendiumOrganiser {
    Hooks.on('renderCompendium', async (pack, html, data) => RddCompendiumOrganiser.onRenderCompendium(pack, html, data))
  }

-  static async onRenderCompendium(pack, html, data) {
-    console.log('onRenderCompendium', pack, html, data);
+  static async onRenderCompendium(compendium, html, data) {
+    console.log('onRenderCompendium', compendium, html, data);
+    let pack = compendium.collection
    if (pack.metadata.system === 'foundryvtt-reve-de-dragon') {
      const content = await pack.getContent();
-
+      
      html.find('.directory-item').each((i, element) => {
-        let entity = content.find(it => it._id === element.dataset.entryId);
-
-        if (entity?.entity === 'Actor' || entity?.entity === 'Item') {
+        let entity = pack.get(element.dataset.documentId);
+        if (entity?.entity === 'Item') {
          const typeName = typeDisplayName[entity.data.type] ?? Misc.upperFirst(entity.data.type);
          RddCompendiumOrganiser.insertEntityType(element, typeName);
        }
--- a/module/rdd-roll.js
+++ b/module/rdd-roll.js
@@ -142,8 +142,8 @@ export class RdDRoll extends Dialog {
      // Update html, according to data
      if (rollData.competence) {
        // Set the default carac from the competence item
-        rollData.selectedCarac = rollData.carac[rollData.competence.data.data.defaut_carac];
-        $("#carac").val(rollData.competence.data.data.defaut_carac);
+        rollData.selectedCarac = rollData.carac[rollData.competence.data.defaut_carac];
+        $("#carac").val(rollData.competence.data.defaut_carac);
      }
      if (rollData.selectedSort) {
        $("#draconic").val(rollData.selectedSort.data.listIndex); // Uniquement a la selection du sort, pour permettre de changer 
@@ -296,10 +296,10 @@ export class RdDRoll extends Dialog {
  /* -------------------------------------------- */
  _computeDiffCompetence(rollData) {
    if (rollData.competence) {
-      return Misc.toInt(rollData.competence.data.data.niveau);
+      return Misc.toInt(rollData.competence.data.niveau);
    }
    if (rollData.draconicList) {
-      return Misc.toInt(rollData.competence.data.data.niveau);
+      return Misc.toInt(rollData.competence.data.niveau);
    }
    return 0;
  }
@@ -336,7 +336,7 @@ export class RdDRoll extends Dialog {
      return compName + " - " + rollData.selectedSort.name;
    }
    // If a weapon is there, add it in the title
-    const niveau = Misc.toSignedString(rollData.competence.data.data.niveau);
+    const niveau = Misc.toSignedString(rollData.competence.data.niveau);
    if (compName == carac) {
      // cas des créatures
      return carac + " " + niveau
--- a/module/rdd-utility.js
+++ b/module/rdd-utility.js
@@ -294,38 +294,39 @@ export class RdDUtility {

  /* -------------------------------------------- */
  static filterItemsPerTypeForSheet(sheetData) {
-    sheetData.data.materiel = this.checkNull(sheetData.itemsByType['objet']);
-    sheetData.data.conteneurs = this.checkNull(sheetData.itemsByType['conteneur']);
-    sheetData.data.armes = this.checkNull(sheetData.itemsByType['arme']);
-    sheetData.data.armures = this.checkNull(sheetData.itemsByType['armure']);
-    sheetData.data.livres = this.checkNull(sheetData.itemsByType['livre']);
-    sheetData.data.potions = this.checkNull(sheetData.itemsByType['potion']);
-    sheetData.data.ingredients = this.checkNull(sheetData.itemsByType['ingredient']);
-    sheetData.data.munitions = this.checkNull(sheetData.itemsByType['munition']);
-    sheetData.data.herbes = this.checkNull(sheetData.itemsByType['herbe']);
-    sheetData.data.sorts = this.checkNull(sheetData.itemsByType['sort']);
-    sheetData.data.queues = this.checkNull(sheetData.itemsByType['queue']);
-    sheetData.data.souffles = this.checkNull(sheetData.itemsByType['souffle']);
-    sheetData.data.ombres = this.checkNull(sheetData.itemsByType['ombre']);
-    sheetData.data.tetes = this.checkNull(sheetData.itemsByType['tete']);
-    sheetData.data.taches = this.checkNull(sheetData.itemsByType['tache']);
-    sheetData.data.monnaie = this.checkNull(sheetData.itemsByType['monnaie']);
-    sheetData.data.meditations = this.checkNull(sheetData.itemsByType['meditation']);
-    sheetData.data.chants = this.checkNull(sheetData.itemsByType['chant']);
-    sheetData.data.danses = this.checkNull(sheetData.itemsByType['danse']);
-    sheetData.data.musiques = this.checkNull(sheetData.itemsByType['musique']);
-    sheetData.data.oeuvres = this.checkNull(sheetData.itemsByType['oeuvre']);
-    sheetData.data.jeux = this.checkNull(sheetData.itemsByType['jeu']);
-    sheetData.data.recettescuisine = this.checkNull(sheetData.itemsByType['recettecuisine']);
-    sheetData.data.recettesAlchimiques = this.checkNull(sheetData.itemsByType['recettealchimique']);
-    sheetData.data.objets = sheetData.data.conteneurs.concat(sheetData.data.materiel)
-      .concat(sheetData.data.armes)
-      .concat(sheetData.data.armures)
-      .concat(sheetData.data.munitions)
-      .concat(sheetData.data.livres)
-      .concat(sheetData.data.potions)
-      .concat(sheetData.data.herbes)
-      .concat(sheetData.data.ingredients);
+
+    sheetData.items.materiel = this.checkNull(sheetData.items['objet']);
+    sheetData.items.conteneurs = this.checkNull(sheetData.items['conteneur']);
+    sheetData.items.armes = this.checkNull(sheetData.items['arme']);
+    sheetData.items.armures = this.checkNull(sheetData.items['armure']);
+    sheetData.items.livres = this.checkNull(sheetData.items['livre']);
+    sheetData.items.potions = this.checkNull(sheetData.items['potion']);
+    sheetData.items.ingredients = this.checkNull(sheetData.items['ingredient']);
+    sheetData.items.munitions = this.checkNull(sheetData.items['munition']);
+    sheetData.items.herbes = this.checkNull(sheetData.items['herbe']);
+    sheetData.items.sorts = this.checkNull(sheetData.items['sort']);
+    sheetData.items.queues = this.checkNull(sheetData.items['queue']);
+    sheetData.items.souffles = this.checkNull(sheetData.items['souffle']);
+    sheetData.items.ombres = this.checkNull(sheetData.items['ombre']);
+    sheetData.items.tetes = this.checkNull(sheetData.items['tete']);
+    sheetData.items.taches = this.checkNull(sheetData.items['tache']);
+    sheetData.items.monnaie = this.checkNull(sheetData.items['monnaie']);
+    sheetData.items.meditations = this.checkNull(sheetData.items['meditation']);
+    sheetData.items.chants = this.checkNull(sheetData.items['chant']);
+    sheetData.items.danses = this.checkNull(sheetData.items['danse']);
+    sheetData.items.musiques = this.checkNull(sheetData.items['musique']);
+    sheetData.items.oeuvres = this.checkNull(sheetData.items['oeuvre']);
+    sheetData.items.jeux = this.checkNull(sheetData.items['jeu']);
+    sheetData.items.recettescuisine = this.checkNull(sheetData.items['recettecuisine']);
+    sheetData.items.recettesAlchimiques = this.checkNull(sheetData.items['recettealchimique']);
+    sheetData.items.objets = sheetData.items.conteneurs.concat(sheetData.items.materiel)
+      .concat(sheetData.items.armes)
+      .concat(sheetData.items.armures)
+      .concat(sheetData.items.munitions)
+      .concat(sheetData.items.livres)
+      .concat(sheetData.items.potions)
+      .concat(sheetData.items.herbes)
+      .concat(sheetData.items.ingredients);
  }

  /* -------------------------------------------- */
@@ -359,13 +360,13 @@ export class RdDUtility {
  static buildArbreDeConteneur(actorSheet, sheetData) {
    actorSheet.objetVersConteneur = {}; // Table de hash locale pour recupération rapide du conteneur parent (si existant)    
    // Attribution des objets aux conteneurs
-    for (let conteneur of sheetData.data.conteneurs) {
+    for (let conteneur of sheetData.items.conteneurs) {
      conteneur.subItems = [];
      if (!conteneur.data.encTotal) conteneur.data.encTotal = 0;
      //conteneur.data.encTotal = ; Deja calculé
      if (conteneur.data.contenu) {
        for (let id of conteneur.data.contenu) {
-          let objet = sheetData.data.objets.find(objet => (id == objet._id));
+          let objet = sheetData.items.objets.find(objet => (id == objet._id));
          if (objet) {
            if (!objet.data.encombrement) objet.data.encombrement = 0; // Auto-fix
            objet.estContenu = true; // Permet de filtrer ce qifui est porté dans le template
@@ -377,8 +378,8 @@ export class RdDUtility {
      }
    }
    // Construit la liste des conteneurs de niveau 1 (c'est à dire non contenu eux-même dans un conteneur)
-    let newConteneurs = sheetData.data.conteneurs.filter(function (conteneur, index, arr) { return !conteneur.estContenu });
-    sheetData.data.conteneurs = newConteneurs;
+    let newConteneurs = sheetData.items.conteneurs.filter(function (conteneur, index, arr) { return !conteneur.estContenu });
+    sheetData.items.conteneurs = newConteneurs;
    //console.log(newConteneurs);
  }

@@ -601,27 +602,16 @@ export class RdDUtility {
  }

  /* -------------------------------------------- */
-  static async loadCompendiumNames(compendium) {
+  static async loadCompendiumData(compendium) {
    const pack = game.packs.get(compendium);
-    let competences;
-    await pack.getIndex().then(index => competences = index);
+    let competences = pack.index;
    return competences;
  }

  /* -------------------------------------------- */
  static async loadCompendium(compendium, filter = item => true) {
-    let compendiumItems = await RdDUtility.loadCompendiumNames(compendium);
-    const pack = game.packs.get(compendium);
-    let list = [];
-    for (let compendiumItem of compendiumItems) {
-      await pack.getDocument(compendiumItem._id).then(it => {
-        const item = it.data;
-        if (filter(item)) {
-          list.push(item);
-        }
-      });
-    };
-    return list;
+    let compendiumData = await RdDUtility.loadCompendiumData(compendium);
+    return compendiumData.filter(filter);
  }

  /* -------------------------------------------- */
--- a/module/rolldata-ajustements.js
+++ b/module/rolldata-ajustements.js
@@ -20,7 +20,9 @@ export const referenceAjustements = {
  competence: {
    isUsed: (rollData, actor) => rollData.competence,
    getLabel: (rollData, actor) => rollData.competence?.name,
-    getValue: (rollData, actor) => rollData.competence?.data?.data.niveau,
+    getValue: (rollData, actor) => {
+      return rollData.competence?.data.niveau;
+    },
  },
  meditation: {
    isUsed: (rollData, actor) => rollData.meditation,