Sync system.json

Reviewed-on: #545

module/actor-creature-sheet.js

@@ -27,8 +27,8 @@ export class RdDActorCreatureSheet extends RdDActorSheet {
 
   /* -------------------------------------------- */
   async getData() {
-    let formData = await super.getData();
-    console.log("Creature : ", formData);
+    let formData = await super.getData()
+    //console.log("Creature : ", formData, formData.system)
     formData.calc = {
       caracTotal: RdDCarac.computeTotal(formData.data.carac),
       resumeBlessures: this.actor.computeResumeBlessure(formData.data.blessures),

module/actor-entite-sheet.js

@@ -22,17 +22,10 @@ export class RdDActorEntiteSheet extends ActorSheet {
     });
   }
 
-  /* -------------------------------------------- */  
-  _checkNull(items) {
-    if (items && items.length) {
-      return items;
-    }
-    return [];
-  }
 
   /* -------------------------------------------- */
   async getData() {
-    const objectData = Misc.data(this.object);
+    const objectData = this.object;
     let formData = {
       title: this.title,
       id: objectData.id,
@@ -42,13 +35,13 @@ export class RdDActorEntiteSheet extends ActorSheet {
       //   actor: this.object,
       editable: this.isEditable,
       cssClass: this.isEditable ? "editable" : "locked",
-      data: foundry.utils.deepClone(Misc.templateData(this.object)),
-      effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
+      data: foundry.utils.deepClone(this.actor.system),
+      effects: this.object.effects.map(e => foundry.utils.deepClone(e)),
       //   items: items,
       limited: this.object.limited,
       options: this.options,
       owner: this.document.isOwner,
-      itemsByType: Misc.classify(this.object.items.map(i => foundry.utils.deepClone(i.data))),
+      itemsByType: Misc.classify(this.object.items.map(i => foundry.utils.deepClone(i))),
     };
     
     formData.options.isGM = game.user.isGM;

module/actor-sheet.js

@@ -36,33 +36,31 @@ export class RdDActorSheet extends ActorSheet {
 
   /* -------------------------------------------- */
   async getData() {
-    const objectData = Misc.data(this.object);
-
-    //this.actor.checkMonnaiePresence(this.actor.data.items); // Always check 
-
+    const objectData = this.object.system
+    
+    console.log("New actor", objectData)
     let formData = {
       title: this.title,
-      id: objectData.id,
-      type: objectData.type,
-      img: objectData.img,
-      name: objectData.name,
+      id: this.object.id,
+      type: this.object.type,
+      img: this.object.img,
+      name: this.object.name,
       editable: this.isEditable,
       cssClass: this.isEditable ? "editable" : "locked",
-      data: foundry.utils.deepClone(Misc.templateData(this.object)),
-      effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
+      data: foundry.utils.deepClone(this.actor.system),
+      effects: this.object.effects.map(e => foundry.utils.deepClone(e)),
       limited: this.object.limited,
       options: this.options,
       owner: this.document.isOwner,
-      itemsByType: Misc.classify(this.object.items.map(i => foundry.utils.deepClone(i.data))),
-    };
-
-    RdDUtility.filterItemsPerTypeForSheet(formData);
-
+      itemsByType: Misc.classify(this.object.items.map(i => foundry.utils.deepClone(i))),
+    }
+    RdDUtility.filterItemsPerTypeForSheet(formData)
+  
     formData.options.isGM = game.user.isGM;
 
     if (formData.type == 'creature') return formData; // Shortcut
 
-    formData.competenceByCategory = Misc.classify(formData.competences, it => it.data.categorie);
+    formData.competenceByCategory = Misc.classify(formData.competences, it => it.system.categorie)
 
     formData.calc = {
       comptageArchetype: RdDItemCompetence.computeResumeArchetype(formData.competences),
@@ -78,7 +76,7 @@ export class RdDActorSheet extends ActorSheet {
     };
 
     formData.competences.forEach(item => {
-      item.visible = this.options.cherchercompetence
+      item.system.visible = this.options.cherchercompetence
         ? RdDItemCompetence.nomContientTexte(item, this.options.cherchercompetence)
         : (!this.options.showCompNiveauBase || !RdDItemCompetence.isNiveauBase(item));
       RdDItemCompetence.levelUp(item, formData.data.compteurs.experience.value);
@@ -93,8 +91,8 @@ export class RdDActorSheet extends ActorSheet {
     formData.combat = duplicate(formData.armes ?? []);
     RdDItemArme.computeNiveauArmes(formData.combat, formData.competences);
     RdDItemArme.ajoutCorpsACorps(formData.combat, formData.competences, formData.data.carac);
-    formData.esquives = this.actor.getCompetences("Esquive").map(i => foundry.utils.deepClone(i.data));
-    formData.combat = RdDCombatManager.finalizeArmeList(formData.combat, formData.competences, formData.data.carac);
+    formData.esquives = this.actor.getCompetences("Esquive").map(i => foundry.utils.deepClone(i.system));
+    formData.combat = RdDCombatManager.listActionsArmes(formData.combat, formData.competences, formData.data.carac);
 
     this.armesList = formData.combat;
 
@@ -118,7 +116,7 @@ export class RdDActorSheet extends ActorSheet {
       montures: this.actor.listeMontures(),
       suivants: this.actor.listeSuivants()
     }
-    if (this.actor.getBestDraconic().data.niveau > -11 && !this.actor.isHautRevant()) {
+    if (this.actor.getBestDraconic().system.niveau > -11 && !this.actor.isHautRevant()) {
       ui.notifications.error(`${this.actor.name} a des compétences draconiques, mais pas le don de Haut-Rêve!
         <br>Ajoutez-lui la tête "Don de Haut-Rêve" pour lui permettre d'utiliser ses compétences et d'accéder aux terres médianes du rêve`);
     }
@@ -138,9 +136,9 @@ export class RdDActorSheet extends ActorSheet {
 
   /* -------------------------------------------- */
   async _onDropItem(event, dragData) {
-    const destItemId = $(event.target)?.closest('.item').attr('data-item-id');
-    const dropParams = RdDSheetUtility.prepareItemDropParameters(destItemId, this.actor.id, dragData, this.objetVersConteneur);
-    const callSuper = await this.actor.processDropItem(dropParams);
+    const destItemId = $(event.target)?.closest('.item').attr('data-item-id')
+    const dropParams = RdDSheetUtility.prepareItemDropParameters(destItemId, this.actor.id, dragData, this.objetVersConteneur)
+    const callSuper = await this.actor.processDropItem(dropParams)
     if (callSuper) {
       await super._onDropItem(event, dragData)
     }
@@ -315,7 +313,7 @@ export class RdDActorSheet extends ActorSheet {
 
     // Boutons spéciaux MJs
     html.find('.forcer-tmr-aleatoire').click(async event => {
-      this.actor.cacheTMRetMessage();
+      this.actor.reinsertionAleatoire("Action MJ");
     });
     html.find('.afficher-tmr').click(async event => {
       this.actor.afficheTMRetMessage();
@@ -335,8 +333,8 @@ export class RdDActorSheet extends ActorSheet {
     html.find('.arme-initiative a').click(async event => {
       let combatant = game.combat.data.combatants.find(c => c.actor.data._id == this.actor.data._id);
       if (combatant) {
-        let arme = this._getEventArmeCombat(event);
-        RdDCombatManager.rollInitiativeCompetence(combatant._id, arme);
+        let action = this._getEventArmeCombat(event);
+        RdDCombatManager.rollInitiativeAction(combatant._id, action);
       } else {
         ui.notifications.info("Impossible de lancer l'initiative sans être dans un combat.");
       }
@@ -384,12 +382,12 @@ export class RdDActorSheet extends ActorSheet {
     if (this.options.editCaracComp) {
       // On carac change
       html.find('.carac-value').change(async event => {
-        let caracName = event.currentTarget.name.replace(".value", "").replace("data.carac.", "");
+        let caracName = event.currentTarget.name.replace(".value", "").replace("system.carac.", "");
         //console.log("Value changed :", event, caracName);
         this.actor.updateCarac(caracName, parseInt(event.target.value));
       });
       html.find('.carac-xp').change(async event => {
-        let caracName = event.currentTarget.name.replace(".xp", "").replace("data.carac.", "");
+        let caracName = event.currentTarget.name.replace(".xp", "").replace("system.carac.", "");
         //console.log("Value changed :", event, caracName);
         this.actor.updateCaracXP(caracName, parseInt(event.target.value));
       });
@@ -519,9 +517,9 @@ export class RdDActorSheet extends ActorSheet {
     const li = $(event.currentTarget)?.parents(".item");
     let armeName = li.data("arme-name");
     let compName = li.data('competence-name');
-    const arme = this.armesList.find(a => a.name == armeName && a.data.competence == compName);
+    const arme = this.armesList.find(a => a.name == armeName && a.system.competence == compName);
     if (!arme) {
-      return { name: armeName, data: { competence: compName } };
+      return { name: armeName, system: { competence: compName } };
     }
     return arme;
   }

module/actor-vehicule-sheet.js

@@ -25,17 +25,9 @@ export class RdDActorVehiculeSheet extends ActorSheet {
     });
   }
 
-  /* -------------------------------------------- */
-  _checkNull(items) {
-    if (items && items.length) {
-      return items;
-    }
-    return [];
-  }
-
   /* -------------------------------------------- */
   async getData() {
-    const objectData = Misc.data(this.object);
+    const objectData = this.object
     let formData = {
       title: this.title,
       id: objectData.id,
@@ -44,12 +36,12 @@ export class RdDActorVehiculeSheet extends ActorSheet {
       name: objectData.name,
       editable: this.isEditable,
       cssClass: this.isEditable ? "editable" : "locked",
-      data: foundry.utils.deepClone(Misc.templateData(this.object)),
-      effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
+      data: foundry.utils.deepClone(this.object.system),
+      effects: this.object.effects.map(e => foundry.utils.deepClone(e)),
       limited: this.object.limited,
       options: this.options,
       owner: this.document.isOwner,
-      itemsByType: Misc.classify(this.object.items.map(i => foundry.utils.deepClone(i.data))),
+      itemsByType: Misc.classify(this.object.items.map(i => foundry.utils.deepClone(i))),
     };
 
     RdDUtility.filterItemsPerTypeForSheet(formData);
@@ -90,7 +82,7 @@ export class RdDActorVehiculeSheet extends ActorSheet {
   async monnaieIncDec(id, value) {
     let monnaie = this.getMonnaie(id);
     if (monnaie) {
-      const quantite = Math.max(0, Misc.templateData(monnaie).quantite + value);
+      const quantite = Math.max(0, monnaie.system.quantite + value);
       await this.updateEmbeddedDocuments('Item', [{ _id: monnaie.id, 'data.quantite': quantite }]);
     }
   }

module/chat-utility.js

@@ -58,7 +58,7 @@ export class ChatUtility {
   static onRemoveMessages(data) {
     if (Misc.isUniqueConnectedGM()) {
       if (data.part) {
-        const toDelete = game.messages.filter(it => it.data.content.includes(data.part));
+        const toDelete = game.messages.filter(it => it.content.includes(data.part));
         toDelete.forEach(it => it.delete());
       }
       if (data.messageId) {

module/constants.js

@@ -3,3 +3,7 @@ export const SYSTEM_SOCKET_ID = 'system.foundryvtt-reve-de-dragon';
 
 export const HIDE_DICE = 'hide';
 export const SHOW_DICE = 'show';
+
+export const ENTITE_INCARNE = 'incarne';
+export const ENTITE_NONINCARNE = 'nonincarne';
+export const ENTITE_BLURETTE = 'blurette';

module/dialog-create-signedraconique.js

@@ -12,7 +12,7 @@ export class DialogCreateSigneDraconique extends Dialog {
       signe: signe,
       tmrs: TMRUtility.listSelectedTMR(signe.data.typesTMR ?? []),
       actors: game.actors.filter(actor => actor.isHautRevant()).map(actor => {
-        let actorData = duplicate(Misc.data(actor));
+        let actorData = duplicate(actor);
         actorData.selected = actor.hasPlayerOwner;
         return actorData;
       })
@@ -48,10 +48,10 @@ export class DialogCreateSigneDraconique extends Dialog {
   async _createSigneForActor(actor, signe) {
     actor.createEmbeddedDocuments("Item", [signe]);
     ChatMessage.create({
-      whisper: ChatUtility.getWhisperRecipientsAndGMs(Misc.data(actor).name),
+      whisper: ChatUtility.getWhisperRecipientsAndGMs(actor.name),
       content: await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/chat-signe-draconique-actor.html", {
         signe: signe,
-        alias: Misc.data(actor).name
+        alias: actor.name
       })
     });
   }

module/dialog-fabriquer-potion.js

@@ -24,7 +24,7 @@ export class DialogFabriquerPotion extends Dialog {
 
   /* -------------------------------------------- */
   static prepareData(actor, item) {
-    let potionData = duplicate(Misc.data(item));
+    let potionData = duplicate(item)
     potionData.nbBrinsSelect = RdDUtility.buildListOptions(1, potionData.data.quantite);
     potionData.nbBrins = Math.min(potionData.data.quantite, DialogFabriquerPotion.getNombreBrinOptimal(potionData));
     potionData.buttonName = "Fabriquer";

module/dialog-item-achat.js

@@ -55,12 +55,12 @@ export class DialogItemAchat extends Dialog {
 
   static prepareVenteData(buttonAcheter, vendeurId, vendeur, acheteur) {
     const jsondata = buttonAcheter.attributes['data-jsondata']?.value;
-    const prixLot = buttonAcheter.attributes['data-prixLot']?.value ?? 0;
+    const prixLot = parseInt(buttonAcheter.attributes['data-prixLot']?.value ?? 0);
     let venteData = {
       item: JSON.parse(jsondata),
       vendeurId: vendeurId,
-      vendeur: Misc.data(vendeur),
-      acheteur: Misc.data(acheteur),
+      vendeur: vendeur,
+      acheteur:acheteur,
       tailleLot: parseInt(buttonAcheter.attributes['data-tailleLot']?.value ?? 1),
       quantiteIllimite: buttonAcheter.attributes['data-quantiteIllimite']?.value == 'true',
       quantiteNbLots: parseInt(buttonAcheter.attributes['data-quantiteNbLots']?.value),

module/dialog-item-consommer.js

@@ -38,10 +38,10 @@ export class DialogConsommer extends Dialog {
 
   /* -------------------------------------------- */
   static prepareData(actor, item) {
-    const itemData = duplicate(Misc.data(item));
+    const itemData = duplicate(item);
     let consommerData = {
       item: itemData,
-      cuisine: Misc.data(actor.getCompetence('cuisine')),
+      cuisine: actor.getCompetence('cuisine'),
       choix: {
         doses: 1,
         seForcer: false,

module/dialog-item-vente.js

@@ -4,15 +4,15 @@ import { Misc } from "./misc.js";
 export class DialogItemVente extends Dialog {
 
   static async create(item, callback) {
-    const itemData = Misc.data(item);
-    const quantite = item.isConteneur() ? 1 : itemData.data.quantite;
+    const itemData = item
+    const quantite = item.isConteneur() ? 1 : itemData.system.quantite;
     const venteData = {
       item: itemData,
       alias: item.actor?.name ?? game.user.name,
       vendeurId: item.actor?.id,
-      prixOrigine: itemData.data.cout,
-      prixUnitaire: itemData.data.cout,
-      prixLot: itemData.data.cout,
+      prixOrigine: itemData.system.cout,
+      prixUnitaire: itemData.system.cout,
+      prixLot: itemData.system.cout,
       tailleLot: 1,
       quantiteNbLots: quantite,
       quantiteMaxLots: quantite,

module/dialog-repos.js

@@ -3,7 +3,7 @@ import { Misc } from "./misc.js";
 export class DialogRepos extends Dialog {
 
   static async create(actor) {
-    let actorData = Misc.data(actor)
+    let actorData = actor
     const html = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/dialog-repos.html", actorData);
     new DialogRepos(html, actor).render(true);
   }

module/dialog-split-item.js

@@ -3,7 +3,7 @@ import { Misc } from "./misc.js";
 export class DialogSplitItem extends Dialog {
 
   static async create(item, callback) {
-    const itemData = Misc.data(item);
+    const itemData = item
     const splitData = {
       item: itemData,
       choix: { quantite: 1, max: itemData.data.quantite - 1 }

module/dialog-stress.js

@@ -9,7 +9,7 @@ export class DialogStress extends Dialog {
       immediat: false,
       actors: game.actors.filter(actor => actor.hasPlayerOwner && actor.isPersonnage())
         .map(actor => {
-          let actorData = duplicate(Misc.data(actor));
+          let actorData = duplicate(actor);
           actorData.selected = actor.hasPlayerOwner;
           return actorData;
         })

module/item-arme.js

@@ -20,35 +20,35 @@ const nomCategorieParade = {
 export class RdDItemArme extends Item {
 
   static isArme(itemData) {
-    itemData = Misc.data(itemData);
-    return (itemData.type == 'competencecreature' && itemData.data.iscombat) || itemData.type == 'arme';
+    itemData = itemData
+    return (itemData.type == 'competencecreature' && itemData.system.iscombat) || itemData.type == 'arme';
   }
 
   /* -------------------------------------------- */
   static getArmeData(armeData) {
-    armeData = Misc.data(armeData);
+    armeData = armeData
     switch (armeData ? armeData.type : '') {
       case 'arme': return armeData;
       case 'competencecreature':
-        return RdDItemCompetenceCreature.toArme(armeData);
+        return RdDItemCompetenceCreature.toActionArme(armeData);
     }
     return RdDItemArme.mainsNues();
   }
 
   static computeNiveauArmes(armes, competences) {
     for (const arme of armes) {
-      arme.data.niveau = RdDItemArme.niveauCompetenceArme(arme, competences);
+      arme.system.niveau = RdDItemArme.niveauCompetenceArme(arme, competences);
     }
   }
 
   static niveauCompetenceArme(arme, competences) {
-    const compArme = competences.find(it => it.name == arme.data.competence);
-    return compArme?.data.niveau ?? -8;
+    const compArme = competences.find(it => it.name == arme.system.competence);
+    return compArme?.system.niveau ?? -8;
   }
 
   /* -------------------------------------------- */
   static getNomCategorieParade(arme) {
-    const categorie = arme?.data ? RdDItemArme.getCategorieParade(arme) : arme;
+    const categorie = arme?.system ? RdDItemArme.getCategorieParade(arme) : arme;
     return nomCategorieParade[categorie];
   }
 
@@ -66,21 +66,20 @@ export class RdDItemArme extends Item {
 
   /* -------------------------------------------- */
   static getCategorieParade(armeData) {
-    armeData = Misc.data(armeData);
-    if (armeData.data.categorie_parade) {
-      return armeData.data.categorie_parade;
+    if (armeData.system.categorie_parade) {
+      return armeData.system.categorie_parade;
     }
     // pour compatibilité avec des personnages existants
-    if (armeData.type == 'competencecreature' || armeData.data.categorie == 'creature') {
-      return armeData.data.categorie_parade || (armeData.data.isparade ? 'armes-naturelles' : '');
+    if (armeData.type == 'competencecreature' || armeData.system.categorie == 'creature') {
+      return armeData.system.categorie_parade || (armeData.system.isparade ? 'armes-naturelles' : '');
     }
     if (!armeData.type.match(/arme|competencecreature/)) {
       return '';
     }
-    if (armeData.data.competence == undefined) {
+    if (armeData.system.competence == undefined) {
       return 'competencecreature';
     }
-    let compname = armeData.data.competence.toLowerCase();
+    let compname = armeData.system.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';
@@ -137,22 +136,21 @@ export class RdDItemArme extends Item {
 
   /* -------------------------------------------- */
   static armeUneOuDeuxMains(armeData, aUneMain) {
-    armeData = Misc.data(armeData);
-    if (armeData && !armeData.data.cac) {
-      armeData.data.unemain = armeData.data.unemain || !armeData.data.deuxmains;
-      const uneOuDeuxMains = armeData.data.unemain && armeData.data.deuxmains;
-      const containsSlash = !Number.isInteger(armeData.data.dommages) && armeData.data.dommages.includes("/");
+    if (armeData && !armeData.system.cac) {
+      armeData.system.unemain = armeData.system.unemain || !armeData.system.deuxmains;
+      const uneOuDeuxMains = armeData.system.unemain && armeData.system.deuxmains;
+      const containsSlash = !Number.isInteger(armeData.system.dommages) && armeData.system.dommages.includes("/");
       if (containsSlash) { // Sanity check
         armeData = duplicate(armeData);
 
-        const tableauDegats = armeData.data.dommages.split("/");
+        const tableauDegats = armeData.system.dommages.split("/");
         if (aUneMain)
-          armeData.data.dommagesReels = Number(tableauDegats[0]);
+          armeData.system.dommagesReels = Number(tableauDegats[0]);
         else // 2 mains
-          armeData.data.dommagesReels = Number(tableauDegats[1]);
+          armeData.system.dommagesReels = Number(tableauDegats[1]);
       }
       else {
-        armeData.data.dommagesReels = Number(armeData.data.dommages);
+        armeData.system.dommagesReels = Number(armeData.system.dommages);
       }
 
       if (uneOuDeuxMains != containsSlash) {
@@ -163,14 +161,13 @@ export class RdDItemArme extends Item {
   }
 
   static isArmeUtilisable(itemData) {
-    itemData = Misc.data(itemData);
-    return itemData.type == 'arme' && itemData.data.equipe && (itemData.data.resistance > 0 || itemData.data.portee_courte > 0);
+    return itemData.type == 'arme' && itemData.system.equipe && (itemData.system.resistance > 0 || itemData.system.portee_courte > 0);
   }
 
   static ajoutCorpsACorps(armes, competences, carac) {
-    let corpsACorps = competences.find(it => it.name == 'Corps à corps') ?? { data: { niveau: -6 } };
-    let init = RdDCombatManager.calculInitiative(corpsACorps.data.niveau, carac['melee'].value);
-    armes.push(RdDItemArme.mainsNues({ niveau: corpsACorps.data.niveau, initiative: init }));
+    let corpsACorps = competences.find(it => it.name == 'Corps à corps') ?? { system: { niveau: -6 } };
+    let init = RdDCombatManager.calculInitiative(corpsACorps.system.niveau, carac['melee'].value);
+    armes.push(RdDItemArme.mainsNues({ niveau: corpsACorps.system.niveau, initiative: init }));
     //armes.push(RdDItemArme.empoignade({ niveau: corpsACorps.data.niveau, initiative: init }));
   }
 
@@ -178,7 +175,7 @@ export class RdDItemArme extends Item {
     const corpsACorps = {
       name: 'Corps à corps',
       img: 'systems/foundryvtt-reve-de-dragon/icons/competence_corps_a_corps.webp',
-      data: {
+      system: {
         equipe: true,
         rapide: true,
         force: 0,
@@ -189,24 +186,24 @@ export class RdDItemArme extends Item {
         categorie_parade: 'sans-armes'
       }
     };
-    mergeObject(corpsACorps.data, actorData ??{}, { overwrite: false });
+    mergeObject(corpsACorps.system, actorData ?? {}, { overwrite: false });
     return corpsACorps;
   }
 
   static mainsNues(actorData) {
-    const mainsNues = RdDItemArme.corpsACorps(actorData);
-    mainsNues.name = 'Mains nues';
-    mainsNues.data.cac = 'pugilat';
-    mainsNues.data.baseInit = 4;
+    const mainsNues = RdDItemArme.corpsACorps(actorData)
+    mainsNues.name = 'Mains nues'
+    mainsNues.system.cac = 'pugilat'
+    mainsNues.system.baseInit = 4
     return mainsNues;
   }
   
   static empoignade(actorData) {
-    const empoignade = RdDItemArme.corpsACorps(actorData);
-    empoignade.name = 'Empoignade';
-    empoignade.data.cac = 'empoignade';
-    empoignade.data.baseInit = 3;
-    empoignade.data.mortalite = 'empoignade';
-    return empoignade;
+    const empoignade = RdDItemArme.corpsACorps(actorData)
+    empoignade.name = 'Empoignade'
+    empoignade.system.cac = 'empoignade'
+    empoignade.system.baseInit = 3
+    empoignade.system.mortalite = 'empoignade'
+    return empoignade
   }
 }

module/item-competence.js

@@ -76,10 +76,10 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   static getCategorie(competence) {
-    return Misc.data(competence)?.data.categorie;
+    return competence?.system.categorie;
   }
   static isDraconic(competence) {
-    return Misc.data(competence)?.data.categorie == 'draconic';
+    return competence?.system.categorie == 'draconic';
   }
 
   /* -------------------------------------------- */
@@ -89,9 +89,9 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   static isCompetenceArme(competence) {
-    switch (Misc.templateData(competence).categorie) {
+    switch (competence.system.categorie) {
       case 'melee':
-        return Misc.data(competence).name != 'Esquive';
+        return competence.name != 'Esquive';
       case 'tir':
       case 'lancer':
         return true;
@@ -101,15 +101,15 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   static isArmeUneMain(competence) {
-    return Misc.data(competence)?.name.toLowerCase().includes("1 main");
+    return competence.name.toLowerCase().includes("1 main");
   }
   static isArme2Main(competence) {
-    return Misc.data(competence)?.name.toLowerCase().includes("2 main");
+    return competence.name.toLowerCase().includes("2 main");
   }
 
   /* -------------------------------------------- */
   static isMalusEncombrementTotal(competence) {
-    return Misc.data(competence)?.name.toLowerCase().match(/(natation|acrobatie)/);
+    return competence?.name.toLowerCase().match(/(natation|acrobatie)/) || 0;
   }
 
   /* -------------------------------------------- */
@@ -133,11 +133,10 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   static computeXP(competence) {
-    const itemData = Misc.data(competence);
-    const factor = itemData.name.includes('Thanatos') ? 2 : 1; // Thanatos compte double !
-    const xpNiveau = RdDItemCompetence.computeDeltaXP(itemData.data.base, itemData.data.niveau ?? itemData.data.base);
-    const xp = itemData.data.xp ?? 0;
-    const xpSort = itemData.data.xp_sort ?? 0;
+    const factor = competence.name.includes('Thanatos') ? 2 : 1; // Thanatos compte double !
+    const xpNiveau = RdDItemCompetence.computeDeltaXP(competence.system.base, competence.system.niveau ?? competence.system.base);
+    const xp = competence.system.xp ?? 0;
+    const xpSort = competence.system.xp_sort ?? 0;
     return factor * (xpNiveau + xp) + xpSort;
   }
 
@@ -146,7 +145,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 ?? -11, Math.min(it?.data.niveau ?? -11, 0)))
+        .map(it => RdDItemCompetence.computeDeltaXP(it?.system.base ?? -11, Math.min(it?.system.niveau ?? -11, 0)))
         .sort(Misc.ascending())
         .splice(0, list.length - 1) // prendre toutes les valeurs sauf l'une des plus élevées
         .reduce(Misc.sum(), 0)
@@ -162,11 +161,10 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   static computeCompetenceXPCost(competence) {
-    const compData = Misc.data(competence);
-    let xp = RdDItemCompetence.getDeltaXp(compData.data.base, compData.data.niveau ?? compData.data.base);
-    xp += compData.data.xp ?? 0;
+    let xp = RdDItemCompetence.getDeltaXp(competence.system.base, competence.system.niveau ?? competence.system.base);
+    xp += competence.system.xp ?? 0;
     if (compData.name.includes('Thanatos')) xp *= 2; /// Thanatos compte double !
-    xp += compData.data.xp_sort ?? 0;
+    xp += competence.system.xp_sort ?? 0;
     return xp;
   }
 
@@ -175,10 +173,10 @@ export class RdDItemCompetence extends Item {
     let economie = 0;
     for (let troncList of competenceTroncs) {
       let list = troncList.map(name => RdDItemCompetence.findCompetence(competences, name))
-        .sort(Misc.descending(c => Misc.templateData(c).niveau)); // tri du plus haut au plus bas
+        .sort(Misc.descending(c => this.system.niveau)); // tri du plus haut au plus bas
       list.splice(0, 1); // ignorer la plus élevée
-      list.map(c => Misc.templateData(c)).forEach(tplData => {
-        economie += RdDItemCompetence.getDeltaXp(tplData.base, Math.min(tplData.niveau, 0));
+      list.map(c => c).forEach(c => {
+        economie += RdDItemCompetence.getDeltaXp(c.system.base, Math.min(c.system.niveau, 0))
       });
     }
     return economie;
@@ -186,13 +184,13 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   static levelUp(itemData, stressTransforme) {
-    itemData.data.xpNext = RdDItemCompetence.getCompetenceNextXp(itemData.data.niveau);
-    const xpManquant = itemData.data.xpNext - itemData.data.xp;
-    itemData.data.isLevelUp = xpManquant <= 0;
-    itemData.data.isStressLevelUp = (xpManquant > 0 && stressTransforme >= xpManquant && itemData.data.niveau < itemData.data.niveau_archetype);
-    itemData.data.stressXpMax = 0;
-    if (xpManquant > 0 && stressTransforme > 0 && itemData.data.niveau < itemData.data.niveau_archetype) {
-        itemData.data.stressXpMax = Math.min(xpManquant , stressTransforme);
+    itemData.system.xpNext = RdDItemCompetence.getCompetenceNextXp(itemData.system.niveau);
+    const xpManquant = itemData.system.xpNext - itemData.system.xp;
+    itemData.system.isLevelUp = xpManquant <= 0;
+    itemData.system.isStressLevelUp = (xpManquant > 0 && stressTransforme >= xpManquant && itemData.system.niveau < itemData.system.niveau_archetype);
+    itemData.system.stressXpMax = 0;
+    if (xpManquant > 0 && stressTransforme > 0 && itemData.system.niveau < itemData.system.niveau_archetype) {
+        itemData.system.stressXpMax = Math.min(xpManquant , stressTransforme);
     }
   }
 
@@ -207,13 +205,16 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   static isNiveauBase(itemData) {
-    return Number(itemData.data.niveau) == RdDItemCompetence.getNiveauBase(itemData.data.categorie);
+    return Number(itemData.system.niveau) == RdDItemCompetence.getNiveauBase(itemData.system.categorie);
   }
 
   /* -------------------------------------------- */
   static findCompetence(list, idOrName, options = {}) {
+    if (idOrName == undefined) {
+      return undefined;
+    }
     options = mergeObject(options, {
-      filter: it => RdDItemCompetence.isCompetence(it),
+      preFilter: it => RdDItemCompetence.isCompetence(it),
       description: 'compétence',
     });
     return list.find(it => it.id == idOrName && RdDItemCompetence.isCompetence(it))
@@ -257,7 +258,7 @@ export class RdDItemCompetence extends Item {
   /* -------------------------------------------- */
   static computeResumeArchetype(competences) {
     const archetype = RdDItemCompetence.getLimitesArchetypes();
-    competences.map(it => Math.max(0, Misc.templateData(it).niveau_archetype))
+    competences.map(it => Math.max(0, it.system.niveau_archetype))
       .forEach(niveau => {
         archetype[niveau] = archetype[niveau] ?? { "niveau": niveau, "nombreMax": 0, "nombre": 0 };
         archetype[niveau].nombre = (archetype[niveau]?.nombre ?? 0) + 1;

module/item-competencecreature.js

@@ -5,46 +5,47 @@ export class RdDItemCompetenceCreature extends Item {
 
   /* -------------------------------------------- */
   static setRollDataCreature(rollData) {
-    rollData.competence = Misc.data(rollData.competence);
-    rollData.carac = { "carac_creature": { label: rollData.competence.name, value: rollData.competence.data.carac_value } };
-    rollData.competence.data.defaut_carac = "carac_creature"
-    rollData.competence.data.categorie = "creature"
+    rollData.competence = rollData.competence
+    rollData.carac = { "carac_creature": { label: rollData.competence.name, value: rollData.competence.system.carac_value } }
+    rollData.competence.system.defaut_carac = "carac_creature"
+    rollData.competence.system.categorie = "creature"
     rollData.selectedCarac =  rollData.carac.carac_creature
-    if (rollData.competence.data.iscombat) {
-      rollData.arme = RdDItemCompetenceCreature.toArme(rollData.competence);
+    if (rollData.competence.system.iscombat) {
+      rollData.arme = RdDItemCompetenceCreature.toActionArme(rollData.competence);
     }
   }
 
   /* -------------------------------------------- */
-  static toArme(item) {
+  static toActionArme(item) {
     if (RdDItemCompetenceCreature.isCompetenceAttaque(item)) {
       // si c'est un Item compétence: cloner pour ne pas modifier lma compétence
-      let arme = Misc.data( (item instanceof Item) ? item.clone():  item);
-      mergeObject(arme.data,
+      let arme = (item instanceof Item) ? item.clone():  item;
+      mergeObject(arme.system,
         {
           competence: arme.name,
           resistance: 100,
           equipe: true,
-          dommagesReels: arme.data.dommages,
+          dommagesReels: arme.system.dommages,
           penetration: 0,
           force: 0,
-          rapide: true
+          rapide: true,
+          action: 'attaque'
         });
       return arme;
     }
-    console.error("RdDItemCompetenceCreature.toArme(", item, ") : impossible de transformer l'Item en arme");
+    console.error("RdDItemCompetenceCreature.toActionArme(", item, ") : impossible de transformer l'Item en arme");
     return undefined;
   }
 
   /* -------------------------------------------- */
   static isCompetenceAttaque(itemData) {
-    itemData = Misc.data(itemData);
-    return itemData.type == 'competencecreature' && itemData.data.iscombat;
+    itemData = itemData
+    return itemData.type == 'competencecreature' && itemData.system.iscombat;
   }
   
   /* -------------------------------------------- */
   static isCompetenceParade(itemData) {
-    itemData = Misc.data(itemData);
-    return itemData.type == 'competencecreature' && itemData.data.isparade;
+    itemData = itemData
+    return itemData.type == 'competencecreature' && itemData.system.isparade;
   }
 }  

module/item-meditation.js

@@ -3,7 +3,7 @@ export class RdDItemMeditation {
   static calculDifficulte(rollData) {
     if (rollData.meditation) {
       // Malus permanent éventuel
-      let diff = -rollData.meditation.data.malus ?? 0;
+      let diff = rollData.meditation.system.malus ?? 0;
       if (!rollData.conditionMeditation.isHeure) diff -= 2;
       if (!rollData.conditionMeditation.isVeture) diff -= 2;
       if (!rollData.conditionMeditation.isComportement) diff -= 2;

module/item-monnaie.js

@@ -26,7 +26,7 @@ const monnaiesData = [
 export class Monnaie {
 
   static isSystemMonnaie(item) {
-    let present = monnaiesData.find(monnaie => monnaie.data.valeur_deniers == Misc.data(item)?.data?.valeur_deniers);
+    let present = monnaiesData.find(monnaie => monnaie.system.valeur_deniers == item?.system?.valeur_deniers);
     return present;
   }
 
@@ -35,20 +35,18 @@ export class Monnaie {
   }
 
   static filtrerMonnaies(items) {
-    return items.filter(it => Misc.data(it).type == 'monnaie');
+    return items.filter(it => it.type == 'monnaie');
   }
 
   static monnaiesManquantes(items) {
     const valeurs = Monnaie.filtrerMonnaies(items)
-      .map(it => Misc.templateData(it).valeur_deniers);
-    const manquantes = monnaiesData.filter(monnaie => !valeurs.find(v => v != Misc.templateData(monnaie).valeur_deniers));
-    //const manquantes = monnaiesData.filter(monnaie => !valeurs.find(v => v != Misc.templateData(monnaie).valeur_deniers) );
-    //console.log("Valeurs : ", valeurs, manquantes);
+      .map(it => it.system.valeur_deniers);
+    const manquantes = monnaiesData.filter(monnaie => !valeurs.find(v => v != monnaie.system?.valeur_deniers))
     return []; //manquantes;
   }
 
   static deValeur(monnaie, v) {
-    return v != monnaie.data.valeur_deniers;
+    return v != monnaie.system.valeur_deniers
   }
 
   static arrondiDeniers(sols) {
@@ -56,6 +54,6 @@ export class Monnaie {
   }
 
   static triValeurDenier() {
-    return Misc.ascending(item => Misc.data(item).data.valeur_deniers);
+    return Misc.ascending(item => item.system.valeur_deniers)
   }
 }

module/item-sheet.js

@@ -32,7 +32,7 @@ export class RdDItemSheet extends ItemSheet {
     let buttons = super._getHeaderButtons();
     // Add "Post to chat" button
     // We previously restricted this to GM and editable items only. If you ever find this comment because it broke something: eh, sorry!
-    if ("cout" in Misc.templateData(this.object) && this.object.isVideOuNonConteneur()) {
+    if ("cout" in this.object.system && this.object.isVideOuNonConteneur()) {
       buttons.unshift({
         class: "vendre",
         icon: "fas fa-comments-dollar",
@@ -60,14 +60,13 @@ export class RdDItemSheet extends ItemSheet {
 
   /* -------------------------------------------- */
   async getData() {
-    const objectData = Misc.data(this.object)
     let formData = {
       id: this.object.id,
-      title: objectData.name,
-      type: objectData.type,
-      img: objectData.img,
-      name: objectData.name,
-      data: objectData.data,
+      title: this.object.name,
+      type: this.object.type,
+      img: this.object.img,
+      name: this.object.name,
+      data: this.object.system,
       isGM: game.user.isGM,
       actorId: this.actor?.id,
       owner: this.document.isOwner,
@@ -77,7 +76,7 @@ export class RdDItemSheet extends ItemSheet {
     }
     if (this.actor) {
       formData.isOwned = true;
-      if (objectData.type == 'conteneur') {
+      if (this.object.type == 'conteneur') {
         this.prepareConteneurData(formData);
       }
     }
@@ -116,8 +115,8 @@ export class RdDItemSheet extends ItemSheet {
 
   /* -------------------------------------------- */
   prepareConteneurData(formData) {
-    formData.itemsByType = Misc.classify(this.actor.items.map(i => foundry.utils.deepClone(i.data)));
-    RdDUtility.filterEquipementParType(formData);
+    formData.itemsByType = Misc.classify(this.actor.items.map(i => foundry.utils.deepClone(i)))
+    RdDUtility.filterEquipementParType(formData)
 
     this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.objets);
     formData.subItems = formData.conteneurs.find(it => it._id == this.object.id)?.subItems;
@@ -182,7 +181,7 @@ export class RdDItemSheet extends ItemSheet {
       if (actor) {
         actor.effectuerTacheAlchimie(recetteId, tacheName, tacheData);
       } else {
-        ui.notifications.info("Impossible trouver un actur pour réaliser cette tache Alchimique.");
+        ui.notifications.info("Impossible trouver un acteur pour réaliser cette tache Alchimique.");
       }
     });
 
@@ -222,14 +221,14 @@ export class RdDItemSheet extends ItemSheet {
 
     if (this.object.isCompetence()) {
       let level = RdDItemCompetence.getNiveauBase(event.currentTarget.value);
-      Misc.templateData(this.object).base = level;
+      this.object.system.base = level;
       $("#base").val(level);
     }
   }
 
   /* -------------------------------------------- */
   get template() {
-    let type = this.object.data.type;
+    let type = this.object.type
     return `systems/foundryvtt-reve-de-dragon/templates/item-${type}-sheet.html`;
   }
 

module/item-signedraconique-sheet.js

@@ -40,7 +40,7 @@ export class RdDSigneDraconiqueItemSheet extends ItemSheet {
 
   /* -------------------------------------------- */
   async getData() {
-    const formData = duplicate(Misc.data(this.object));
+    const formData = duplicate(this.object);
     mergeObject(formData, {
       title: formData.name,
       isGM: game.user.isGM,
@@ -80,7 +80,7 @@ export class RdDSigneDraconiqueItemSheet extends ItemSheet {
   async onValeurXpSort(event) {
     const codeReussite = event.currentTarget.attributes['data-typereussite']?.value ?? 0;
     const xp = Number(event.currentTarget.value);
-    const oldValeur = Misc.templateData(this.object).valeur;
+    const oldValeur = this.object.system.valeur;
     const newValeur = RdDItemSigneDraconique.calculValeursXpSort(codeReussite, xp, oldValeur);
     await this.object.update({ 'data.valeur': newValeur });
   }

module/item-signedraconique.js

@@ -13,25 +13,24 @@ const tableSignesIndicatifs = [
 
 ]
 
+const DIFFICULTE_LECTURE_SIGNE_MANQUE = +11;
+
 export class RdDItemSigneDraconique {
 
   static prepareSigneDraconiqueMeditation(meditation, rolled) {
-    if (rolled.isSuccess != undefined) {
-      meditation = Misc.data(meditation);
-      return {
-        name: "de la " + meditation.name,
-        type: "signedraconique",
-        img: meditation.img,
-        data: {
-          typesTMR: [TMRUtility.typeTmrName(meditation.data.tmr)],
-          difficulte: RdDItemSigneDraconique.getDiffSigneMeditation(rolled.code),
-          ephemere: true,
-          duree: "1 round",
-          valeur: { "norm": 3, "sign": 5, "part": 10 }
-        }
-      };
-    }
-    return undefined;
+    meditation = meditation
+    return {
+      name: "de la " + meditation.name,
+      type: "signedraconique",
+      img: meditation.img,
+      data: {
+        typesTMR: [TMRUtility.typeTmrName(meditation.data.tmr)],
+        difficulte: rolled.isSuccess ? RdDItemSigneDraconique.getDiffSigneMeditation(rolled.code) : DIFFICULTE_LECTURE_SIGNE_MANQUE,
+        ephemere: true,
+        duree: "1 round",
+        valeur: rolled.isSuccess ? { "norm": 3, "sign": 5, "part": 10 } : { "norm": 0, "sign": 0, "part": 0 }
+      }
+    };
   }
 
   static getDiffSigneMeditation(code) {
@@ -44,7 +43,7 @@ export class RdDItemSigneDraconique {
   }
 
   static getXpSortSigneDraconique(code, signe) {
-    return Misc.data(signe).data.valeur[code] ?? 0;
+    return Misc.toInt(signe.system.valeur[code] ?? 0);
   }
 
   static calculValeursXpSort(qualite, valeur, avant) {

module/item-sort.js

@@ -18,7 +18,7 @@ export class RdDItemSort extends Item {
   /* -------------------------------------------- */
   static setCoutReveReel(sort){
     if (sort) {
-      sort.data.ptreve_reel = this.isCoutVariable(sort) ? 1 : sort.data.ptreve;
+      sort.system.ptreve_reel = this.isCoutVariable(sort) ? 1 : sort.system.ptreve;
     }
   }
 

module/item.js

@@ -57,61 +57,56 @@ export class RdDItem extends Item {
   }
 
   isCompetence() {
-    return Misc.data(this).type == 'competence';
+    return this.type == 'competence';
   }
 
   isConteneur() {
-    return Misc.data(this).type == 'conteneur';
+    return this.type == 'conteneur';
   }
 
   isConteneurNonVide() {
-    return this.isConteneur() && (Misc.templateData(this).contenu?.length ?? 0) > 0;
+    return this.isConteneur() && (this.system.contenu?.length ?? 0) > 0;
   }
 
   isConteneurVide() {
-    return this.isConteneur() && (Misc.templateData(this).contenu?.length ?? 0) == 0;
+    return this.isConteneur() && (this.system.contenu?.length ?? 0) == 0;
   }
 
   isVideOuNonConteneur() {
-    return !this.isConteneur() || (Misc.templateData(this).contenu?.length ?? 0) == 0;
+    return !this.isConteneur() || (this.system.contenu?.length ?? 0) == 0;
   }
 
   isAlcool() {
-    const itemData = Misc.data(this);
-    return itemData.type == 'nourritureboisson' && itemData.data.boisson && itemData.data.alcoolise;
+    return this.type == 'nourritureboisson' && this.system.boisson && this.system.alcoolise;
   }
   isHerbeAPotion() {
-    const itemData = Misc.data(this);
-    return itemData.type == 'herbe' && (itemData.data.categorie == 'Soin' || itemData.data.categorie == 'Repos');
+    return this.type == 'herbe' && (this.system.categorie == 'Soin' || this.system.categorie == 'Repos');
   }
   isPotion() {
-    return Misc.data(this).type == 'potion';
+    return this.type == 'potion';
   }
 
   isEquipement() {
-    return RdDItem.getTypeObjetsEquipement().includes(Misc.data(this).type);
+    return RdDItem.getTypeObjetsEquipement().includes(this.type)
   }
 
   isCristalAlchimique() {
-    const itemData = Misc.data(this);
-    return itemData.type == 'objet' && Grammar.toLowerCaseNoAccent(itemData.name) == 'cristal alchimique' && itemData.data.quantite > 0;
+    return this.type == 'objet' && Grammar.toLowerCaseNoAccent(this.name) == 'cristal alchimique' && this.system.quantite > 0;
   }
 
   isMagique() {
-    return Misc.templateData(this).magique;
+    return this.system.magique
   }
 
   getEncTotal() {
-    const itemData = Misc.data(this);
-    return Number(itemData.data.encombrement ?? 0) * Number(itemData.data.quantite ?? 1);
+    return Number(this.system.encombrement ?? 0) * Number(this.system.quantite ?? 1)
   }
   getEnc() {
-    const itemData = Misc.data(this);
-    switch (itemData.type) {
+    switch (this.type) {
       case 'herbe':
         return encBrin;
     }
-    return itemData.data.encombrement ?? 0;
+    return this.system.encombrement ?? 0;
   }
 
   prepareDerivedData() {
@@ -122,51 +117,47 @@ export class RdDItem extends Item {
       if (this.isPotion()) {
         this.prepareDataPotion()
       }
-      const itemData = Misc.data(this);
-      itemData.data.actionPrincipale = this.getActionPrincipale({ warnIfNot: false });
+      this.actionPrincipale = this.getActionPrincipale({ warnIfNot: false });
     }
   }
 
   prepareDataPotion() {
-    const tplData = Misc.templateData(this);
-    const categorie = Grammar.toLowerCaseNoAccent(tplData.categorie);
-    tplData.magique = categorie.includes('enchante');
-    if (tplData.magique) {
+    const categorie = Grammar.toLowerCaseNoAccent(this.system.categorie);
+    this.system.magique = categorie.includes('enchante');
+    if (this.system.magique) {
       if (categorie.includes('soin') || categorie.includes('repos')) {
-        tplData.puissance = tplData.herbebonus * tplData.pr;
+        this.system.puissance = this.system.herbebonus * this.system.pr;
       }
     }
   }
 
   _calculsEquipement() {
-    const tplData = Misc.templateData(this);
-    const quantite = this.isConteneur() ? 1 : (tplData.quantite ?? 0);
+    const quantite = this.isConteneur() ? 1 : (this.system.quantite ?? 0);
     const enc = this.getEnc();
     if (enc != undefined) {
-      tplData.encTotal = Math.max(enc, 0) * quantite;
+      this.system.encTotal = Math.max(enc, 0) * quantite;
     }
-    if (tplData.cout != undefined) {
-      tplData.prixTotal = Math.max(tplData.cout, 0) * quantite;
+    if (this.cout != undefined) {
+      this.system.prixTotal = Math.max(this.cout, 0) * quantite;
     }
   }
 
   getActionPrincipale(options = { warnIfNot: true }) {
-    const itemData = Misc.data(this);
-    if (!this.isConteneur() && (itemData.data.quantite ?? 0) <= 0) {
+    if (!this.isConteneur() && (this.system.quantite ?? 0) <= 0) {
       if (options.warnIfNot) {
-        ui.notifications.warn(`Vous n'avez plus de ${itemData.name}.`);
+        ui.notifications.warn(`Vous n'avez plus de ${this.name}.`);
       }
       return undefined;
     }
-    switch (itemData.type) {
-      case 'nourritureboisson': return itemData.data.boisson ? 'Boire' : 'Manger';
+    switch (this.type) {
+      case 'nourritureboisson': return this.boisson ? 'Boire' : 'Manger';
       case 'potion': return 'Boire';
       case 'livre': return 'Lire';
       case 'conteneur': return 'Ouvrir';
     }
     if (this.isHerbeAPotion()) { return 'Décoction'; }
     if (options.warnIfNot) {
-      ui.notifications.warn(`Impossible d'utiliser un ${itemData.name}, aucune action associée définie.`);
+      ui.notifications.warn(`Impossible d'utiliser un ${this.name}, aucune action associée définie.`);
     }
 
     return undefined;
@@ -178,18 +169,17 @@ export class RdDItem extends Item {
   }
 
   async quantiteIncDec(nombre, options = { diminuerQuantite: true, supprimerSiZero: false }) {
-    const itemData = Misc.data(this);
-    const quantite = Number(itemData.data.quantite ?? -1);
+    const quantite = Number(this.system.quantite ?? -1);
     if (quantite >= 0) {
       const reste = Math.max(quantite + Number(nombre), 0);
 
       if (reste == 0) {
         if (options.supprimerSiZero) {
-          ui.notifications.notify(`${itemData.name} supprimé de votre équipement`);
+          ui.notifications.notify(`${this.name} supprimé de votre équipement`);
           await this.delete();
         }
         else {
-          ui.notifications.notify(`Il ne vous reste plus de ${itemData.name}, vous pouvez le supprimer de votre équipement, ou trouver un moyen de vous en procurer.`);
+          ui.notifications.notify(`Il ne vous reste plus de ${this.name}, vous pouvez le supprimer de votre équipement, ou trouver un moyen de vous en procurer.`);
           await this.update({ "data.quantite": 0 });
         }
       }
@@ -202,10 +192,10 @@ export class RdDItem extends Item {
   /* -------------------------------------------- */
   // détermine si deux équipements sont similaires: de même type, et avec les même champs hormis la quantité
   isEquipementSimilaire(other) {
-    const itemData = Misc.data(this);
-    const otherData = Misc.data(other);
-    const tplData = Misc.templateData(this);
-    const otherTplData = Misc.templateData(other);
+    const itemData = this
+    const otherData = other
+    const tplData = this
+    const otherTplData = other
     if (!this.isEquipement()) return false;
     if (itemData.type != otherData.type) return false;
     if (itemData.name != otherData.name) return false;
@@ -251,13 +241,13 @@ export class RdDItem extends Item {
 
   /* -------------------------------------------- */
   getProprietes() {
-    return this[`_${Misc.data(this).type}ChatData`]();
+    return this[`_${this.type}ChatData`]();
   }
 
   /* -------------------------------------------- */
   async postItem(modeOverride) {
     console.log(this);
-    let chatData = duplicate(Misc.data(this));
+    let chatData = duplicate(this);
     const properties = this.getProprietes();
     chatData["properties"] = properties
     if (this.actor) {
@@ -282,7 +272,7 @@ export class RdDItem extends Item {
 
   /* -------------------------------------------- */
   _objetChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [].concat(
       RdDItem.propertyIfDefined('Résistance', tplData.resistance, tplData.resistance),
       RdDItem.propertyIfDefined('Qualité', tplData.qualite, tplData.qualite),
@@ -293,7 +283,7 @@ export class RdDItem extends Item {
 
   /* -------------------------------------------- */
   _nourritureboissonChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [].concat(
       RdDItem.propertyIfDefined('Sustentation', tplData.sust, tplData.sust > 0),
       RdDItem.propertyIfDefined('Désaltère', tplData.desaltere, tplData.boisson),
@@ -306,7 +296,7 @@ export class RdDItem extends Item {
   }
   /* -------------------------------------------- */
   _armeChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [
       `<b>Compétence</b>: ${tplData.competence}`,
       `<b>Dommages</b>: ${tplData.dommages}`,
@@ -318,7 +308,7 @@ export class RdDItem extends Item {
   }
   /* -------------------------------------------- */
   _conteneurChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [
       `<b>Capacité</b>: ${tplData.capacite} Enc.`,
       `<b>Encombrement</b>: ${tplData.encombrement}`
@@ -327,7 +317,7 @@ export class RdDItem extends Item {
   }
   /* -------------------------------------------- */
   _munitionChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [
       `<b>Encombrement</b>: ${tplData.encombrement}`
     ]
@@ -335,7 +325,7 @@ export class RdDItem extends Item {
   }
   /* -------------------------------------------- */
   _armureChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [
       `<b>Protection</b>: ${tplData.protection}`,
       `<b>Détérioration</b>: ${tplData.deterioration}`,
@@ -346,7 +336,7 @@ export class RdDItem extends Item {
   }
   /* -------------------------------------------- */
   _competenceChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [
       `<b>Catégorie</b>: ${tplData.categorie}`,
       `<b>Niveau</b>: ${tplData.niveau}`,
@@ -357,7 +347,7 @@ export class RdDItem extends Item {
   }
   /* -------------------------------------------- */
   _competencecreatureChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [
       `<b>Catégorie</b>: ${tplData.categorie}`,
       `<b>Niveau</b>: ${tplData.niveau}`,
@@ -368,7 +358,7 @@ export class RdDItem extends Item {
   }
   /* -------------------------------------------- */
   _sortChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [
       `<b>Draconic</b>: ${tplData.draconic}`,
       `<b>Difficulté</b>: ${tplData.difficulte}`,
@@ -379,7 +369,7 @@ export class RdDItem extends Item {
   }
   /* -------------------------------------------- */
   _herbeChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [
       `<b>Milieu</b>: ${tplData.milieu}`,
       `<b>Rareté</b>: ${tplData.rarete}`,
@@ -389,7 +379,7 @@ export class RdDItem extends Item {
   }
   /* -------------------------------------------- */
   _ingredientChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [
       `<b>Milieu</b>: ${tplData.milieu}`,
       `<b>Rareté</b>: ${tplData.rarete}`,
@@ -399,7 +389,7 @@ export class RdDItem extends Item {
   }
   /* -------------------------------------------- */
   _tacheChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [
       `<b>Caractéristique</b>: ${tplData.carac}`,
       `<b>Compétence</b>: ${tplData.competence}`,
@@ -415,7 +405,7 @@ export class RdDItem extends Item {
   }
   /* -------------------------------------------- */
   _livreChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [
       `<b>Compétence</b>: ${tplData.competence}`,
       `<b>Auteur</b>: ${tplData.auteur}`,
@@ -427,7 +417,7 @@ export class RdDItem extends Item {
   }
   /* -------------------------------------------- */
   _potionChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [
       `<b>Rareté</b>: ${tplData.rarete}`,
       `<b>Catégorie</b>: ${tplData.categorie}`,
@@ -437,7 +427,7 @@ export class RdDItem extends Item {
   }
   /* -------------------------------------------- */
   _queueChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [
       `<b>Refoulement</b>: ${tplData.refoulement}`
     ]
@@ -445,7 +435,7 @@ export class RdDItem extends Item {
   }
   /* -------------------------------------------- */
   _ombreChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [
       `<b>Refoulement</b>: ${tplData.refoulement}`
     ]
@@ -453,19 +443,19 @@ export class RdDItem extends Item {
   }
   /* -------------------------------------------- */
   _souffleChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [];
     return properties;
   }
   /* -------------------------------------------- */
   _teteChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [];
     return properties;
   }
   /* -------------------------------------------- */
   _tarotChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [
       `<b>Concept</b>: ${tplData.concept}`,
       `<b>Aspect</b>: ${tplData.aspect}`,
@@ -474,7 +464,7 @@ export class RdDItem extends Item {
   }
   /* -------------------------------------------- */
   _nombreastralChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [
       `<b>Valeur</b>: ${tplData.value}`,
       `<b>Jour</b>: ${tplData.jourlabel}`,
@@ -483,7 +473,7 @@ export class RdDItem extends Item {
   }
   /* -------------------------------------------- */
   _monnaieChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [
       `<b>Valeur en Deniers</b>: ${tplData.valeur_deniers}`,
       `<b>Encombrement</b>: ${tplData.encombrement}`
@@ -492,7 +482,7 @@ export class RdDItem extends Item {
   }
   /* -------------------------------------------- */
   _meditationChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [
       `<b>Thème</b>: ${tplData.theme}`,
       `<b>Compétence</b>: ${tplData.competence}`,
@@ -507,7 +497,7 @@ export class RdDItem extends Item {
   }
   /* -------------------------------------------- */
   _casetmrChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [
       `<b>Coordonnée</b>: ${tplData.coord}`,
       `<b>Spécificité</b>: ${tplData.specific}`
@@ -516,7 +506,7 @@ export class RdDItem extends Item {
   }
   /* -------------------------------------------- */
   _maladieChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties
     if (tplData.identifie) {
       properties = [
@@ -541,7 +531,7 @@ export class RdDItem extends Item {
 
   /* -------------------------------------------- */
   _gemmeChatData() {
-    const tplData = Misc.templateData(this);
+    const tplData = this.system
     let properties = [
       `<b>Pureté</b>: ${tplData.purete}`,
       `<b>Taille</b>: ${tplData.taille}`,

module/misc.js

@@ -69,9 +69,9 @@ export class Misc {
   }
 
   static classify(items, classifier = it => it.type) {
-    let itemsBy = {};
-    Misc.classifyInto(itemsBy, items, classifier);
-    return itemsBy;
+    let itemsBy = {}
+    Misc.classifyInto(itemsBy, items, classifier)
+    return itemsBy
   }
 
   static classifyFirst(items, classifier) {
@@ -87,13 +87,13 @@ export class Misc {
 
   static classifyInto(itemsBy, items, classifier = it => it.type) {
     for (const item of items) {
-      const classification = classifier(item);
+      const classification = classifier(item)
       let list = itemsBy[classification];
       if (!list) {
-        list = [];
-        itemsBy[classification] = list;
+        list = []
+        itemsBy[classification] = list
       }
-      list.push(item);
+      list.push(item)
     }
   }
 
@@ -106,20 +106,9 @@ export class Misc {
   }
 
 
-  static data(it) {
-    if (it instanceof Actor || it instanceof Item || it instanceof Combatant) {
-      return it.data;
-    }
-    return it;
-  }
-
-  static templateData(it) {
-    return Misc.data(it)?.data ?? {}
-  }
-
   static getEntityTypeLabel(entity) {
-    const documentName = entity?.documentName;
-    const type = entity?.data.type;
+    const documentName = entity?.documentName
+    const type = entity?.type
     if (documentName === 'Actor' || documentName === 'Item') {
       const label = CONFIG[documentName]?.typeLabels?.[type] ?? type;
       return game.i18n.has(label) ? game.i18n.localize(label) : t;
@@ -192,7 +181,7 @@ export class Misc {
     if (!single) {
       single = subset[0];
       const choices = Misc.join(subset.map(it => options.mapper(it)), '<br>');
-      options.info(`Plusieurs choix de ${options.description}s possibles:<br>${choices}<br>Le premier sera choisi: ${mapToValue(single)}`);
+      options.onMessage(`Plusieurs choix de ${options.description}s possibles:<br>${choices}<br>Le premier sera choisi: ${options.mapper(single)}`);
     }
     return single;
   }
@@ -211,7 +200,7 @@ export class Misc {
     }
     value = Grammar.toLowerCaseNoAccent(value);
     const subset = elements.filter(options.preFilter)
-      .filter(it => Grammar.toLowerCaseNoAccent(options.mapper(it)).includes(value));
+      .filter(it => Grammar.toLowerCaseNoAccent(options.mapper(it))?.includes(value));
     if (subset.length == 0) {
       options.onMessage(`Pas de ${options.description} correspondant à ${value}`);
     }

module/rdd-astrologie-joueur.js

@@ -17,7 +17,7 @@ export class RdDAstrologieJoueur extends Dialog {
       dates: game.system.rdd.calendrier.getJoursSuivants(10),
       etat: actor.getEtatGeneral(),
       ajustementsConditions: CONFIG.RDD.ajustementsConditions,
-      astrologie: RdDItemCompetence.findCompetence(actor.data.items, 'Astrologie')
+      astrologie: RdDItemCompetence.findCompetence(actor.items, 'Astrologie')
     }
     const html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/dialog-astrologie-joueur.html', data);
     let options = { classes: ["rdddialog"], width: 600, height: 500, 'z-index': 99999 };
@@ -49,12 +49,12 @@ export class RdDAstrologieJoueur extends Dialog {
     let itemNombres = actor.listItemsData('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.system.jourindex]) {
+        itemFiltered[item.system.jourindex].listValues.push(item.system.value);
       } else {
-        itemFiltered[item.data.jourindex] = {
-          listValues: [item.data.value],
-          jourlabel: item.data.jourlabel
+        itemFiltered[item.system.jourindex] = {
+          listValues: [item.system.value],
+          jourlabel: item.system.jourlabel
         }
       }
     }
@@ -64,8 +64,8 @@ export class RdDAstrologieJoueur extends Dialog {
   /* -------------------------------------------- */
   requestJetAstrologie() {
     let data = {
-      id: this.actor.data._id,
-      carac_vue: Misc.data(this.actor).data.carac['vue'].value,
+      id: this.actor.id,
+      carac_vue: this.actor.system.carac['vue'].value,
       etat: this.dataNombreAstral.etat,
       astrologie: this.dataNombreAstral.astrologie,
       conditions: $("#diffConditions").val(),

module/rdd-bonus.js

@@ -20,7 +20,7 @@ export class RdDBonus {
 
   static isAjustementAstrologique(rollData) {
     return RdDCarac.isChance(rollData.selectedCarac) ||
-      rollData.selectedSort?.data.isrituel;
+      rollData.selectedSort?.system.isrituel;
   }
   /* -------------------------------------------- */
   static isDefenseAttaqueFinesse(rollData) {
@@ -68,23 +68,23 @@ export class RdDBonus {
     }
     return isCauchemar ? "cauchemar"
       : rollData.dmg?.mortalite
-      ?? rollData.arme?.data.mortalite
+      ?? rollData.arme?.system.mortalite
       ?? "mortel";
   }
 
   /* -------------------------------------------- */
   static _dmgArme(rollData) {
     if ( rollData.arme) {
-      let dmgBase = rollData.arme.data.dommagesReels ?? Number(rollData.arme.data.dommages ?? 0);
+      let dmgBase = rollData.arme.system.dommagesReels ?? Number(rollData.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.data.magique ? rollData.arme.data.ecaille_efficacite : 0);
+      return dmgBase + Math.min(dmgBase, rollData.arme.system.magique ? rollData.arme.system.ecaille_efficacite : 0);
     }
     return 0;
   }
 
   /* -------------------------------------------- */
   static _peneration(rollData) {
-    return parseInt(rollData.arme?.data.penetration ?? 0);
+    return parseInt(rollData.arme?.system.penetration ?? 0);
   }
 
   /* -------------------------------------------- */

module/rdd-calendrier.js

@@ -320,7 +320,7 @@ export class RdDCalendrier extends Application {
     if (Misc.isUniqueConnectedGM()) { // Only once
       console.log(request);
       let jourDiff = this.getLectureAstrologieDifficulte(request.date);
-      let niveau = Number(request.astrologie.data.niveau) + Number(request.conditions) + Number(jourDiff) + Number(request.etat);
+      let niveau = Number(request.astrologie.system.niveau) + Number(request.conditions) + Number(jourDiff) + Number(request.etat);
       let rollData = {
         caracValue: request.carac_vue,
         finalLevel: niveau,

module/rdd-combat.js

@@ -1,5 +1,6 @@
 import { ChatUtility } from "./chat-utility.js";
-import { HIDE_DICE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
+import { ENTITE_INCARNE, ENTITE_NONINCARNE, HIDE_DICE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
+import { Grammar } from "./grammar.js";
 import { RdDItemArme } from "./item-arme.js";
 import { RdDItemCompetence } from "./item-competence.js";
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
@@ -26,7 +27,7 @@ const premierRoundInit = [
   { pattern: 'epeegnome', init: 5.35 },
   { pattern: 'masse', init: 5.30 },
   { pattern: 'gourdin', init: 5.25 },
-  { pattern: 'fléau', init: 5.20 },
+  { pattern: 'fleau', init: 5.20 },
   { pattern: 'dague', init: 5.15 },
   { pattern: 'autre', init: 5.10 },
 ];
@@ -84,28 +85,23 @@ export class RdDCombatManager extends Combat {
     // calculate initiative
     for (let cId = 0; cId < ids.length; cId++) {
       const combatant = this.combatants.get(ids[cId]);
-      //if (!c) return results;
-
-      let rollFormula = formula; // Init per default
-      if (!rollFormula) {
-        let armeCombat, competence;
-        if (combatant.actor.data.type == 'creature' || combatant.actor.data.type == 'entite') {
-          for (const competenceItemData of combatant.actor.data.items) {
-            if (competenceItemData.data.data.iscombat) {
-              competence = duplicate(competenceItemData);
-            }
+      let rollFormula = formula ?? RdDCombatManager.formuleInitiative(2, 10, 0, 0);
+      if (!formula) {
+        if (combatant.actor.type == 'creature' || combatant.actor.type == 'entite') {
+          const competence = combatant.actor.items.find(it => it.system.iscombat)
+          if (competence) {
+            rollFormula = RdDCombatManager.formuleInitiative(2, competence.system.carac_value, competence.system.niveau, 0);
           }
-          rollFormula = "2+( (" + RdDCombatManager.calculInitiative(competence.data.niveau, competence.data.carac_value) + ")/100)";
         } else {
-          for (const itemData of combatant.actor.data.items) {
-            if (itemData.type == "arme" && itemData.data.equipe) {
-              armeCombat = duplicate(itemData);
-            }
+          const armeCombat = combatant.actor.items.find(it => it.type == 'arme' && itemData.system.equipe)
+          const compName = (armeCombat == undefined) ? "Corps à corps" : armeCombat.system.competence;
+          const competence = RdDItemCompetence.findCompetence(combatant.actor.items, compName);
+          if (competence) {
+            const carac = combatant.actor.system.carac[competence.system.defaut_carac].value;
+            const niveau = competence.system.niveau;
+            const bonusEcaille = (armeCombat?.data.magique) ? armeCombat.system.ecaille_efficacite : 0;
+            rollFormula = RdDCombatManager.formuleInitiative(2,  carac, niveau, bonusEcaille);
           }
-          let compName = (armeCombat == undefined) ? "Corps à corps" : armeCombat.data.competence;
-          competence = RdDItemCompetence.findCompetence(combatant.actor.data.items, compName);
-          let bonusEcaille = (armeCombat && armeCombat.data.magique) ? armeCombat.data.ecaille_efficacite : 0;
-          rollFormula = "2+( (" + RdDCombatManager.calculInitiative(competence.data.niveau, Misc.data(combatant.actor).data.carac[competence.data.defaut_carac].value, bonusEcaille) + ")/100)";
         }
       }
       //console.log("Combatat", c);
@@ -142,6 +138,10 @@ export class RdDCombatManager extends Combat {
     return this;
   };
 
+  static formuleInitiative(rang, carac, niveau, bonusMalus) {
+    return `${rang} +( (${RdDCombatManager.calculInitiative(niveau, carac, bonusMalus)} )/100)`;
+  }
+
   /* -------------------------------------------- */
   static calculInitiative(niveau, caracValue, bonusEcaille = 0) {
     let base = niveau + Math.floor(caracValue / 2);
@@ -150,63 +150,77 @@ export class RdDCombatManager extends Combat {
   }
 
   /* -------------------------------------------- */
-  /** Retourne une liste triée d'armes avec le split arme1 main / arme 2 main */
-  static finalizeArmeList(armes, competences, carac) {
+  /** Retourne une liste triée d'actions d'armes avec le split arme1 main / arme 2 main */
+  static listActionsArmes(armes, competences, carac) {
     // Gestion des armes 1/2 mains
-    let armesEquipe = [];
+    let actionsArme = [];
     for (const arme of armes) {
-      let armeData = duplicate(Misc.data(arme));
-      if (armeData.data.equipe) {
-        let compData = competences.map(c => Misc.data(c)).find(c => c.name == armeData.data.competence);
+      let action = duplicate(Misc.data(arme));
+      if (action.system.equipe) {
+        let compData = competences.find(c => c.name == action.system.competence)
 
-        armesEquipe.push(armeData);
-        armeData.data.dommagesReels = Number(armeData.data.dommages);
-        armeData.data.niveau = compData.data.niveau;
-        armeData.data.initiative = RdDCombatManager.calculInitiative(compData.data.niveau, carac[compData.data.defaut_carac].value);
+        actionsArme.push(action);
+        action.action = 'attaque';
+        action.system.dommagesReels = Number(action.system.dommages);
+        action.system.niveau = compData.data.niveau;
+        action.system.initiative = RdDCombatManager.calculInitiative(compData.system.niveau, carac[compData.system.defaut_carac].value);
         // Dupliquer les armes pouvant être à 1 main et 2 mains en patchant la compétence
-        if (armeData.data.unemain && !armeData.data.deuxmains) {
-          armeData.data.mainInfo = "(1m)";
-        } else if (!armeData.data.unemain && armeData.data.deuxmains) {
-          armeData.data.mainInfo = "(2m)";
-        } else if (armeData.data.unemain && armeData.data.deuxmains) {
-          armeData.data.mainInfo = "(1m)";
+        if (action.system.unemain && !action.system.deuxmains) {
+          action.system.mainInfo = "(1m)";
+        } else if (!action.system.unemain && action.system.deuxmains) {
+          action.system.mainInfo = "(2m)";
+        } else if (action.system.unemain && action.system.deuxmains) {
+          action.system.mainInfo = "(1m)";
 
-          const comp2m = armeData.data.competence.replace(" 1 main", " 2 mains"); // Replace !
-          const comp = Misc.data(competences.find(c => c.name == comp2m));
+          const comp2m = action.system.competence.replace(" 1 main", " 2 mains"); // Replace !
+          const comp = competences.find(c => c.name == comp2m)
 
-          const arme2main = duplicate(armeData);
-          arme2main.data.mainInfo = "(2m)";
-          arme2main.data.niveau = comp.data.niveau;
-          arme2main.data.competence = comp2m;
-          arme2main.data.initiative = RdDCombatManager.calculInitiative(arme2main.data.niveau, carac[comp.data.defaut_carac].value);
-          armesEquipe.push(arme2main);
-          const containsSlash = armeData.data.dommages.includes("/");
+          const arme2main = duplicate(action);
+          arme2main.system.mainInfo = "(2m)";
+          arme2main.system.niveau = comp.system.niveau;
+          arme2main.system.competence = comp2m;
+          arme2main.system.initiative = RdDCombatManager.calculInitiative(arme2main.system.niveau, carac[comp.system.defaut_carac].value);
+          actionsArme.push(arme2main);
+          const containsSlash = action.system.dommages.includes("/");
           if (containsSlash) {
-            const tableauDegats = armeData.data.dommages.split("/");
-            armeData.data.dommagesReels = Number(tableauDegats[0]);
-            arme2main.data.dommagesReels = Number(tableauDegats[1]);
+            const tableauDegats = action.system.dommages.split("/");
+            action.system.dommagesReels = Number(tableauDegats[0]);
+            arme2main.system.dommagesReels = Number(tableauDegats[1]);
           }
           else{
-            ui.notifications.info("Les dommages de l'arme à 1/2 mains " + armeData.name + " ne sont pas corrects (ie sous la forme X/Y)");
+            ui.notifications.info("Les dommages de l'arme à 1/2 mains " + action.name + " ne sont pas corrects (ie sous la forme X/Y)");
           }
         }
       }
     }
-    return armesEquipe.sort(Misc.ascending(armeData => armeData.name + (armeData.data.mainInfo ?? '')));
+    return actionsArme.sort(Misc.ascending(armeData => armeData.name + (armeData.system.mainInfo ?? '')));
+  }
+
+  static listActionsPossessions(actor) {
+    return RdDCombatManager._indexActions(actor.getPossessions().map(p =>
+      {
+        return {
+          name: p.name,
+          action: 'conjurer',
+          data: {
+            competence: p.name,
+            possessionid: p.data.data.possessionid,
+          }
+        }
+      }));
   }
 
   /* -------------------------------------------- */
-  static buildListeActionsCombat(combatant) {
-    if (combatant.actor == undefined) {
-      ui.notifications.warn(`Le combatant ${combatant.name} n'est pas associé à un acteur, impossible de déterminer ses actions de combat!`)
-      return [];
+  static listActionsCombat(combatant) {
+    const actor = combatant.actor;
+    let actions = RdDCombatManager.listActionsPossessions(actor);
+    if (actions.length>0) {
+      return actions;
     }
-    const actorData = Misc.data(combatant.actor);
-    let items = combatant.actor.data.items;
-    let actions = []
-    if (combatant.actor.isCreature()) {
+    let items = actor.items;
+    if (actor.isCreature()) {
       actions = actions.concat(items.filter(it => RdDItemCompetenceCreature.isCompetenceAttaque(it))
-        .map(competence => RdDItemCompetenceCreature.toArme(competence)));
+        .map(competence => RdDItemCompetenceCreature.toActionArme(competence)));
     } else {
       // Recupération des items 'arme'
       let armes = items.filter(it => RdDItemArme.isArmeUtilisable(it))
@@ -214,14 +228,17 @@ export class RdDCombatManager extends Combat {
         .concat(RdDItemArme.mainsNues());
 
       let competences = items.filter(it => it.type == 'competence');
-      actions = actions.concat(RdDCombatManager.finalizeArmeList(armes, competences, actorData.data.carac));
+      actions = actions.concat(RdDCombatManager.listActionsArmes(armes, competences, actor.data.data.carac));
 
-      if (actorData.data.attributs.hautrevant.value) {
-        actions.push({ name: "Draconic", data: { initOnly: true, competence: "Draconic" } });
+      if (actor.data.data.attributs.hautrevant.value) {
+        actions.push({ name: "Draconic", action: 'haut-reve', data: { initOnly: true, competence: "Draconic" } });
       }
     }
 
-    actions.push({ name: "Autre action", data: { initOnly: true, competence: "Autre action" } });
+    return RdDCombatManager._indexActions(actions);
+  }
+
+  static _indexActions(actions) {
     for (let index = 0; index < actions.length; index++) {
       actions[index].index = index;
     }
@@ -235,15 +252,15 @@ export class RdDCombatManager extends Combat {
       let initMissing = game.combat.data.combatants.find(it => !it.initiative);
       if (!initMissing) { // Premier round !
         for (let combatant of game.combat.data.combatants) {
-          let arme = combatant.initiativeData?.arme;
+          let action = combatant.initiativeData?.arme;
           //console.log("Parsed !!!", combatant, initDone, game.combat.current, arme);
-          if (arme && arme.type == "arme") {
+          if (action && action.type == "arme") {
             for (let initData of premierRoundInit) {
-              if (arme.data.initpremierround.toLowerCase().includes(initData.pattern)) {
+              if (Grammar.toLowerCaseNoAccentNoSpace(action.data.initpremierround).includes(initData.pattern)) {
                 let msg = `<h4>L'initiative de ${combatant.actor.name} a été modifiée !</h4>
                       <hr>
                       <div>
-                        Etant donné son ${arme.name}, son initative pour ce premier round est désormais de ${initData.init}.
+                        Etant donné son ${action.name}, son initative pour ce premier round est désormais de ${initData.init}.
                       </div>`
                 ChatMessage.create({ content: msg });
                 game.combat.setInitiative(combatant._id, initData.init);
@@ -281,7 +298,7 @@ export class RdDCombatManager extends Combat {
     ].concat(options);
   }
   /* -------------------------------------------- */
-  static rollInitiativeCompetence(combatantId, arme) {
+  static rollInitiativeAction(combatantId, action) {
     const combatant = game.combat.combatants.get(combatantId);
     if (combatant.actor == undefined) {
       ui.notifications.warn(`Le combatant ${combatant.name} n'est pas associé à un acteur, impossible de déterminer ses actions de combat!`)
@@ -299,34 +316,40 @@ export class RdDCombatManager extends Combat {
     } else if (combatant.actor.getSurprise() == "demi") {
       initOffset = 0;
       initInfo = "Demi Surprise"
-    } else if (arme.name == "Autre action") {
+    } else if (action.action == 'conjurer') {
+      initOffset = 10;
+      caracForInit = combatant.actor.getReveActuel();
+      initInfo = "Possession"
+    } else if (action.action == 'autre') {
       initOffset = 2;
       initInfo = "Autre Action"
-    } else if (arme.name == "Draconic") {
+    } else if (action.action == 'haut-reve') {
       initOffset = 9;
       initInfo = "Draconic"
     } else {
-      compData = Misc.data(RdDItemCompetence.findCompetence(combatant.actor.data.items, arme.data.competence));
-      compNiveau = compData.data.niveau;
-      initInfo = arme.name + " / " + arme.data.competence;
-      if (combatant.actor.data.type == 'creature' || combatant.actor.data.type == 'entite') {
-        caracForInit = compData.data.carac_value;
-        if (compData.data.categorie == "lancer") {
-          initOffset = 7;
-        }
-        else {
-          initOffset = 5;
-        }
-      } else {
-        caracForInit = Misc.data(combatant.actor).data.carac[compData.data.defaut_carac].value;
-        initOffset = RdDCombatManager._baseInitOffset(compData.data.categorie, arme);
+      compData = RdDItemCompetence.findCompetence(combatant.actor.items, arme.system.competence);
+      compNiveau = compData.system.niveau;
+        initInfo = action.name + " / " + action.data.competence;
+         
+        if (combatant.actor.type == 'creature' || combatant.actor.type == 'entite') {
+          caracForInit = compData.data.carac_value;
+          if (compData.system.categorie == "lancer") {
+            initOffset = 7;
+          }
+          else {
+            initOffset = 5;
+          }
+        } else {
+          caracForInit = combatant.actor.system.carac[compData.system.defaut_carac].value;
+          initOffset = RdDCombatManager._baseInitOffset(compData.system.categorie, action);
       }
     }
+
     let malus = combatant.actor.getEtatGeneral(); // Prise en compte état général 
     // Cas des créatures et entités vs personnages
-    let rollFormula = initOffset + "+ ( (" + RdDCombatManager.calculInitiative(compNiveau, caracForInit) + " + " + malus + ") /100)";
+    let rollFormula = RdDCombatManager.formuleInitiative(initOffset, caracForInit, compNiveau, malus);
     // Garder la trace de l'arme/compétence utilisée pour l'iniative
-    combatant.initiativeData = { arme: arme } // pour reclasser l'init au round 0
+    combatant.initiativeData = { arme: action } // pour reclasser l'init au round 0
     game.combat.rollInitiative(combatantId, rollFormula, { initInfo: initInfo });
   }
 
@@ -349,16 +372,21 @@ export class RdDCombatManager extends Combat {
   static displayInitiativeMenu(html, combatantId) {
     console.log("Combatant ; ", combatantId);
     const combatant = game.combat.combatants.get(combatantId);
-    let armesList = RdDCombatManager.buildListeActionsCombat(combatant);
+    if (! (combatant?.actor) ) {
+      ui.notifications.warn(`Le combatant ${combatant.name ?? combatantId} n'est pas associé à un acteur, impossible de déterminer ses actions de combat!`)
+      return;
+    }
+
+    let actions = RdDCombatManager.listActionsCombat(combatant);
 
     // Build the relevant submenu
-    if (armesList) {
+    if (actions) {
       let menuItems = [];
-      for (let arme of armesList) {
+      for (let action of actions) {
         menuItems.push({
-          name: arme.data.competence,
+          name: action.data.competence,
           icon: "<i class='fas fa-dice-d6'></i>",
-          callback: target => { RdDCombatManager.rollInitiativeCompetence(combatantId, arme) }
+          callback: target => { RdDCombatManager.rollInitiativeAction(combatantId, action) }
         });
       }
       new ContextMenu(html, ".directory-list", menuItems).render();
@@ -428,8 +456,8 @@ export class RdDCombat {
     }
     else {
       const defender = target?.actor;
-      const defenderTokenId = target?.data._id;
-      if ( defender.type == 'entite' && defender.data.data.definition.typeentite == 'nonincarne') {
+      const defenderTokenId = target?.id;
+      if ( defender.type == 'entite' && defender.system.definition.typeentite == ENTITE_NONINCARNE) {
         ui.notifications.warn("Vous ne pouvez pas cibler une entité non incarnée !!!!");
       } else {
         return this.create(attacker, defender, defenderTokenId, target)
@@ -465,15 +493,15 @@ export class RdDCombat {
   }
 
   /* -------------------------------------------- */
-  static onMsgEncaisser(data) {
-    let defender = canvas.tokens.get(data.defenderTokenId).actor;
+  static onMsgEncaisser(msg) {
+    let defender = canvas.tokens.get(msg.defenderTokenId).actor;
     if (Misc.isOwnerPlayerOrUniqueConnectedGM()) {
-      let attackerRoll = data.attackerRoll;
-      let attacker = data.attackerId ? game.actors.get(data.attackerId) : null;
+      let attackerRoll = msg.attackerRoll;
+      let attacker = msg.attackerId ? game.actors.get(msg.attackerId) : null;
 
       defender.encaisserDommages(attackerRoll, attacker);
-      RdDCombat._deleteDefense(attackerRoll.passeArme);
-      RdDCombat._deleteAttaque(data.attackerId);
+      const rddCombat = RdDCombat.createForAttackerAndDefender(msg.attackerId, msg.defenderTokenId);
+      rddCombat?.removeChatMessageActionsPasseArme(attackerRoll.passeArme);
     }
   }
 
@@ -482,11 +510,8 @@ export class RdDCombat {
     let defenderToken = canvas.tokens.get(msg.defenderTokenId);
     if (defenderToken && Misc.isUniqueConnectedGM()) {
       const rddCombat = RdDCombat.createForAttackerAndDefender(msg.attackerId, msg.defenderTokenId);
-      if (rddCombat) {
-        const defenderRoll = msg.defenderRoll;
-        rddCombat.removeChatMessageActionsPasseArme(defenderRoll.passeArme);
-        rddCombat._chatMessageDefense(msg.paramChatDefense, msg.defenderRoll);
-      }
+      rddCombat?.removeChatMessageActionsPasseArme(msg.defenderRoll.passeArme);
+      rddCombat?._chatMessageDefense(msg.paramChatDefense, msg.defenderRoll);
     }
   }
 
@@ -533,8 +558,8 @@ export class RdDCombat {
     this.attacker = attacker;
     this.defender = defender;
     this.target = target;
-    this.attackerId = this.attacker.data._id;
-    this.defenderId = this.defender.data._id;
+    this.attackerId = this.attacker.id;
+    this.defenderId = this.defender.id;
     this.defenderTokenId = defenderTokenId;
   }
 
@@ -666,7 +691,7 @@ export class RdDCombat {
     if (!await this.accorderEntite('avant-attaque')) {
       return;
     }
-    if (arme.data.cac == 'empoignade' && this.attacker.isCombatTouche()) {
+    if (arme.system.cac == 'empoignade' && this.attacker.isCombatTouche()) {
       ChatMessage.create({
         alias: this.attacker.name,
         whisper: ChatUtility.getWhisperRecipientsAndGMs(this.attacker.name),
@@ -709,7 +734,7 @@ export class RdDCombat {
   _prepareAttaque(competence, arme) {
     let rollData = {
       passeArme: randomID(16),
-      mortalite: arme?.data.mortalite,
+      mortalite: arme?.system.mortalite,
       coupsNonMortels: false,
       competence: competence,
       surprise: this.attacker.getSurprise(true),
@@ -726,8 +751,8 @@ export class RdDCombat {
     }
     else {
       // sans armes: à mains nues
-      const niveau = competence.data.niveau;
-      const init = RdDCombatManager.calculInitiative(niveau, Misc.templateData(this.attacker).carac['melee'].value);
+      const niveau = competence.system.niveau;
+      const init = RdDCombatManager.calculInitiative(niveau, this.attacker.system.carac['melee'].value);
       rollData.arme = RdDItemArme.mainsNues({ niveau: niveau, initiative: init });
     }
     return rollData;
@@ -740,9 +765,9 @@ export class RdDCombat {
     // force toujours, sauf empoignade
     // finesse seulement en mélée, pour l'empoignade, ou si la difficulté libre est de -1 minimum
     // rapidité seulement en mêlée, si l'arme le permet, et si la difficulté libre est de -1 minimum
-    const isForce = !rollData.arme.data.empoignade;
-    const isFinesse = rollData.arme.data.empoignade || isMeleeDiffNegative;
-    const isRapide = !rollData.arme.data.empoignade && isMeleeDiffNegative && rollData.arme.data.rapide;
+    const isForce = !rollData.arme.system.empoignade;
+    const isFinesse = rollData.arme.system.empoignade || isMeleeDiffNegative;
+    const isRapide = !rollData.arme.system.empoignade && isMeleeDiffNegative && rollData.arme.system.rapide;
     // si un seul choix possible, le prendre
     if (isForce && !isFinesse && !isRapide) {
       return await this.choixParticuliere(rollData, "force");
@@ -774,10 +799,10 @@ export class RdDCombat {
   async _onAttaqueNormale(attackerRoll) {
     console.log("RdDCombat.onAttaqueNormale >>>", attackerRoll);
 
-    attackerRoll.dmg = RdDBonus.dmg(attackerRoll, this.attacker.getBonusDegat(), this.defender.isEntiteCauchemar());
+    attackerRoll.dmg = RdDBonus.dmg(attackerRoll, this.attacker.getBonusDegat(), this.defender.isEntite());
     let defenderRoll = { attackerRoll: attackerRoll, passeArme: attackerRoll.passeArme, show: {} }
     attackerRoll.show = {
-      cible: this.target ? this.defender.data.name : 'la cible',
+      cible: this.target ? this.defender.system.name : 'la cible',
       isRecul: (attackerRoll.particuliere == 'force' || attackerRoll.tactique == 'charge')
     }
     await RdDResolutionTable.displayRollData(attackerRoll, this.attacker, 'chat-resultat-attaque.html');
@@ -798,7 +823,7 @@ export class RdDCombat {
 
   /* -------------------------------------------- */
   async _sendMessageDefense(attackerRoll, defenderRoll, essaisPrecedents = undefined) {
-    console.log("RdDCombat._sendMessageDefense", attackerRoll, defenderRoll, essaisPrecedents, " / ", this.attacker, this.target, this.attackerId, attackerRoll.competence.data.categorie);
+    console.log("RdDCombat._sendMessageDefense", attackerRoll, defenderRoll, essaisPrecedents, " / ", this.attacker, this.target, this.attackerId, attackerRoll.competence.system.categorie);
 
     this.removeChatMessageActionsPasseArme(attackerRoll.passeArme);
     if (essaisPrecedents) {
@@ -806,16 +831,16 @@ export class RdDCombat {
     }
 
     // # utilisation esquive
-    const corpsACorps = Misc.data(this.defender.getCompetence("Corps à corps", { onMessage: it => console.info(it, this.defender) }));
-    const esquives = duplicate(this.defender.getCompetences("esquive", { onMessage: it => console.info(it, this.defender) }).map(c => Misc.data(c)));
+    const corpsACorps = this.defender.getCompetence("Corps à corps", { onMessage: it => console.info(it, this.defender) });
+    const esquives = duplicate(this.defender.getCompetences("esquive", { onMessage: it => console.info(it, this.defender) }))
     esquives.forEach(e => e.usages = e?.id ? this.defender.getItemUse(e.id) : 0);
 
     const paramChatDefense = {
       passeArme: attackerRoll.passeArme,
       essais: attackerRoll.essais,
       isPossession: this.isPossession(attackerRoll),
-      defender: Misc.data(this.defender),
-      attacker: Misc.data(this.attacker),
+      defender: this.defender,
+      attacker: this.attacker,
       attackerId: this.attackerId,
       esquives: esquives,
       defenderTokenId: this.defenderTokenId,
@@ -823,7 +848,7 @@ export class RdDCombat {
       armes: this._filterArmesParade(this.defender, attackerRoll.competence, attackerRoll.arme),
       diffLibre: attackerRoll.ajustements?.diffLibre?.value ?? 0,
       attaqueParticuliere: attackerRoll.particuliere,
-      attaqueCategorie: attackerRoll.competence.data.categorie,
+      attaqueCategorie: attackerRoll.competence.system.categorie,
       attaqueArme: attackerRoll.arme,
       surprise: this.defender.getSurprise(true),
       dmg: attackerRoll.dmg,
@@ -855,8 +880,8 @@ export class RdDCombat {
     // envoyer le message au destinataire
     game.socket.emit(SYSTEM_SOCKET_ID, {
       msg: "msg_defense", data: {
-        attackerId: this.attacker?.data._id,
-        defenderId: this.defender?.data._id,
+        attackerId: this.attacker?.id,
+        defenderId: this.defender?.id,
         defenderTokenId: this.defenderTokenId,
         defenderRoll: defenderRoll,
         paramChatDefense: paramChatDefense,
@@ -867,13 +892,12 @@ export class RdDCombat {
 
   /* -------------------------------------------- */
   _filterArmesParade(defender, competence) {
-    let items = defender.data.items;
+    let items = defender.items;
     items = items.filter(it => RdDItemArme.isArmeUtilisable(it) || RdDItemCompetenceCreature.isCompetenceParade(it))
-      .map(Misc.data);
     for (let item of items) {
-      item.data.nbUsage = defender.getItemUse(item._id); // Ajout du # d'utilisation ce round  
+      item.system.nbUsage = defender.getItemUse(item.id); // Ajout du # d'utilisation ce round  
     }
-    switch (competence.data.categorie) {
+    switch (competence.system.categorie) {
       case 'tir':
       case 'lancer':
         return items.filter(item => RdDItemArme.getCategorieParade(item) == 'boucliers')
@@ -892,7 +916,7 @@ export class RdDCombat {
       whisper: ChatUtility.getWhisperRecipientsAndGMs(this.attacker.name),
       content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-demande-attaque-etotal.html', {
         attackerId: this.attackerId,
-        attacker: Misc.data(this.attacker),
+        attacker: this.attacker,
         defenderTokenId: this.defenderTokenId,
         essais: attackerRoll.essais
       })
@@ -905,7 +929,7 @@ export class RdDCombat {
     console.log("RdDCombat._onEchecTotal >>>", rollData);
 
     const arme = rollData.arme;
-    const avecArme = !['', 'sans-armes', 'armes-naturelles'].includes(arme?.data.categorie_parade ?? '');
+    const avecArme = !['', 'sans-armes', 'armes-naturelles'].includes(arme?.system.categorie_parade ?? '');
     const action = (rollData.attackerRoll ? (arme ? "la parade" : "l'esquive") : "l'attaque");
     ChatUtility.createChatWithRollMode(this.defender.name, {
       content: `<strong>Maladresse à ${action}!</strong> ` + await RdDRollTables.getMaladresse({ arme: avecArme })
@@ -924,7 +948,7 @@ export class RdDCombat {
     console.log("RdDCombat.choixParticuliere >>>", rollData, choix);
 
     if (choix != "rapidite") {
-      this.attacker.incDecItemUse(rollData.arme._id);
+      this.attacker.incDecItemUse(rollData.arme.id);
     }
 
     this.removeChatMessageActionsPasseArme(rollData.passeArme);
@@ -936,7 +960,7 @@ export class RdDCombat {
   async parade(attackerRoll, armeParadeId) {
     const arme = this.defender.getArmeParade(armeParadeId);
     console.log("RdDCombat.parade >>>", attackerRoll, armeParadeId, arme);
-    const competence = Misc.templateData(arme)?.competence;
+    const competence = this.system?.competence;
     if (competence == undefined)
     {
       console.error("Pas de compétence de parade associée à ", arme) ;
@@ -971,12 +995,12 @@ export class RdDCombat {
       passeArme: attackerRoll.passeArme,
       diffLibre: attackerRoll.diffLibre,
       attackerRoll: attackerRoll,
-      competence: Misc.data(this.defender.getCompetence(competenceParade)),
+      competence: this.defender.getCompetence(competenceParade),
       arme: armeParade,
       surprise: this.defender.getSurprise(true),
       needParadeSignificative: ReglesOptionelles.isUsing('categorieParade') && RdDItemArme.needParadeSignificative(attackerRoll.arme, armeParade),
       needResist: RdDItemArme.needArmeResist(attackerRoll.arme, armeParade),
-      carac: Misc.templateData(this.defender).carac,
+      carac: this.defender.system.carac,
       show: {}
     };
 
@@ -1005,8 +1029,7 @@ export class RdDCombat {
     await this.computeRecul(defenderRoll);
     await this.computeDeteriorationArme(defenderRoll);
     await RdDResolutionTable.displayRollData(defenderRoll, this.defender, 'chat-resultat-parade.html');
-
-    RdDCombat._deleteDefense(defenderRoll.passeArme);
+    this.removeChatMessageActionsPasseArme(defenderRoll.passeArme);
   }
 
   /* -------------------------------------------- */
@@ -1021,7 +1044,7 @@ export class RdDCombat {
 
   /* -------------------------------------------- */
   async esquive(attackerRoll, compId, compName) {
-    const esquive = Misc.data(this.defender.getCompetence(compId) ?? this.defender.getCompetence(compName));
+    const esquive = this.defender.getCompetence(compId) ?? this.defender.getCompetence(compName)
     if (esquive == undefined) {
       ui.notifications.error(this.defender.name + " n'a pas de compétence " + compName);
       return;
@@ -1055,7 +1078,7 @@ export class RdDCombat {
       competence: competence,
       surprise: this.defender.getSurprise(true),
       surpriseDefenseur: this.defender.getSurprise(true),
-      carac: Misc.templateData(this.defender).carac,
+      carac: this.defender.system.carac,
       show: {}
     };
 
@@ -1077,7 +1100,7 @@ export class RdDCombat {
   async _onEsquiveNormale(defenderRoll) {
     console.log("RdDCombat._onEsquiveNormal >>>", defenderRoll);
     await RdDResolutionTable.displayRollData(defenderRoll, this.defender, 'chat-resultat-esquive.html');
-    RdDCombat._deleteDefense(defenderRoll.passeArme);
+    this.removeChatMessageActionsPasseArme(defenderRoll.passeArme);
   }
 
   /* -------------------------------------------- */
@@ -1105,11 +1128,11 @@ export class RdDCombat {
 
         const dmg = attackerRoll.dmg.dmgArme + attackerRoll.dmg.dmgActor;
         let arme = defenderRoll.arme;
-        let resistance = Misc.toInt(arme.data.resistance);
-        if (arme.data.magique) {
+        let resistance = Misc.toInt(arme.system.resistance);
+        if (arme.system.magique) {
           defenderRoll.show.deteriorationArme = 'resiste'; // Par défaut
-          if (arme.data.resistance_magique == undefined) arme.data.resistance_magique = 0; // Quick fix
-          if (dmg > arme.data.resistance_magique) { // Jet uniquement si dommages supérieur à résistance magique (cf. 274)
+          if (arme.system.resistance_magique == undefined) arme.system.resistance_magique = 0; // Quick fix
+          if (dmg > arme.system.resistance_magique) { // Jet uniquement si dommages supérieur à résistance magique (cf. 274)
             // Jet de résistance de l'arme de parade (p.132)
             let resistRoll = await RdDResolutionTable.rollData({
               caracValue: resistance,
@@ -1117,7 +1140,7 @@ export class RdDCombat {
               showDice: HIDE_DICE
             });
             if (!resistRoll.rolled.isSuccess) {
-              let perteResistance = (dmg - arme.data.resistance_magique)
+              let perteResistance = (dmg - arme.system.resistance_magique)
               resistance -= perteResistance;
               defenderRoll.show.deteriorationArme = resistance <= 0 ? 'brise' : 'perte';
               defenderRoll.show.perteResistance = perteResistance;
@@ -1144,7 +1167,7 @@ export class RdDCombat {
         if (ReglesOptionelles.isUsing('defenseurDesarme') && resistance > 0 && RdDItemArme.getCategorieParade(defenderRoll.arme) != 'boucliers') {
           let desarme = await RdDResolutionTable.rollData({
             caracValue: this.defender.getForce(),
-            finalLevel: Misc.toInt(defenderRoll.competence.data.niveau) - dmg,
+            finalLevel: Misc.toInt(defenderRoll.competence.system.niveau) - dmg,
             showDice: HIDE_DICE
           });
           defenderRoll.show.desarme = desarme.rolled.isEchec;
@@ -1187,7 +1210,7 @@ export class RdDCombat {
   _computeImpactRecul(attaque) {
     const taille = this.defender.getTaille();
     const force = this.attacker.getForce();
-    const dommages = attaque.arme.data.dommagesReels ?? attaque.arme.data.dommages;
+    const dommages = attaque.arme.system.dommagesReels ?? attaque.arme.system.dommages;
     return taille - (force + dommages);
   }
 
@@ -1217,7 +1240,6 @@ export class RdDCombat {
         }
       });
     }
-    RdDCombat._deleteDefense(attackerRoll.passeArme);
     this.removeChatMessageActionsPasseArme(attackerRoll.passeArme);
   }
 
@@ -1226,12 +1248,12 @@ export class RdDCombat {
   async accorderEntite(when = 'avant-encaissement') {
     if (when != game.settings.get(SYSTEM_RDD, "accorder-entite-cauchemar")
       || this.defender == undefined
-      || !this.defender.isEntiteCauchemar()
-      || this.defender.isEntiteCauchemarAccordee(this.attacker)) {
+      || !this.defender.isEntite([ENTITE_INCARNE])
+      || this.defender.isEntiteAccordee(this.attacker)) {
       return true;
     }
 
-    let rolled = await RdDResolutionTable.roll(this.attacker.getReveActuel(), - Number(Misc.templateData(this.defender).carac.niveau.value));
+    let rolled = await RdDResolutionTable.roll(this.attacker.getReveActuel(), - Number(this.defender.system.carac.niveau.value));
 
     let message = {
       content: "Jet de points actuels de rêve à " + rolled.finalLevel + RdDResolutionTable.explain(rolled) + "<br>",
@@ -1259,7 +1281,7 @@ export class RdDCombat {
       isSonne: actor.getSonne(),
       blessuresStatus: actor.computeResumeBlessure(),
       SConst: actor.getSConst(),
-      actorId: actor.data._id,
+      actorId: actor.id,
       isGrave: false,
       isCritique: false
     }

module/rdd-commands.js

@@ -7,6 +7,7 @@ import { RdDItemCompetence } from "./item-competence.js";
 import { Misc } from "./misc.js";
 import { RdDCarac } from "./rdd-carac.js";
 import { RdDDice } from "./rdd-dice.js";
+import { RdDMeteo } from "./rdd-meteo.js";
 import { RdDNameGen } from "./rdd-namegen.js";
 import { RdDResolutionTable } from "./rdd-resolution-table.js";
 import { RdDRollResolutionTable } from "./rdd-roll-resolution-table.js";
@@ -34,6 +35,7 @@ export class RdDCommands {
       rddCommands.registerCommand({ path: ["/table", "souffle"], func: (content, msg, params) => RdDRollTables.getSouffle(true), descr: " Tire un Souffle de Dragon" });
       rddCommands.registerCommand({ path: ["/table", "comp"], func: (content, msg, params) => RdDRollTables.getCompetence(true), descr: "Tire une compétence au hasard" });
       rddCommands.registerCommand({ path: ["/table", "tarot"], func: (content, msg, params) => RdDRollTables.getTarot(true), descr: "Tire une carte du Tarot Draconique" });
+      rddCommands.registerCommand({ path: ["/meteo"], func: (content, msg, params) => rddCommands.getMeteo(msg, params), descr: "Propose une météo marine" });
       rddCommands.registerCommand({ path: ["/nom"], func: (content, msg, params) => RdDNameGen.getName(msg, params), descr: "Génère un nom aléatoire" });
 
       rddCommands.registerCommand({
@@ -274,9 +276,11 @@ export class RdDCommands {
           diff = 0;
         }
         const caracName = params[0];
-        const compName = length > 1 ? Misc.join(params.slice(1, length), ' ') : undefined;
-        for (let actor of actors) {
-          await actor.rollCaracCompetence(caracName, compName, diff);
+        let competence = length > 1 ? actors[0].getCompetence(Misc.join(params.slice(1, length), ' ')) : undefined;
+        if (competence) {
+          for (let actor of actors) {
+            await actor.rollCaracCompetence(caracName, competence.name, diff);
+          }
         }
         return;
       }
@@ -354,7 +358,7 @@ export class RdDCommands {
 
   async supprimerSignesDraconiquesEphemeres() {
     game.actors.forEach(actor => {
-      const ephemeres = actor.filterItems(item => Misc.data(item).type = 'signedraconique' && Misc.data(item).data.ephemere)
+      const ephemeres = actor.filterItems(item => item.type = 'signedraconique' && item.system.ephemere)
         .map(item => item.id);
       if (ephemeres.length > 0) {
         actor.deleteEmbeddedDocuments("Item", ephemeres);
@@ -398,5 +402,8 @@ export class RdDCommands {
     }
     return true;
   }
+  async getMeteo(msg, params) {
+    return await RdDMeteo.getMeteo();
+  }
 }
 

module/rdd-herbes.js

@@ -8,11 +8,11 @@ export class RdDHerbes extends Item {
 
   /* -------------------------------------------- */
   static isHerbeSoin( botaniqueItem ) {
-    return Misc.templateData(botaniqueItem).categorie == 'Soin';
+    return botaniqueItem.categorie == 'Soin';
   }
   /* -------------------------------------------- */
   static isHerbeRepos( botaniqueItem ) {
-    return Misc.templateData(botaniqueItem).categorie == 'Repos';
+    return botaniqueItem.categorie == 'Repos';
   }
 
   /* -------------------------------------------- */
@@ -25,7 +25,7 @@ export class RdDHerbes extends Item {
   static buildHerbesList(listHerbes, max) {
     let list = {}
     for ( let herbe of listHerbes) {
-      let herbeData = Misc.templateData(herbe);
+      let herbeData = herbe.system
       let brins = max - herbeData.niveau;
       list[herbe.data.name] = `${herbe.data.name} (Bonus: ${herbeData.niveau}, Brins: ${brins})`;
     }
@@ -65,7 +65,7 @@ export class RdDHerbes extends Item {
     if ( Number(formData.data.herbebrins) ) {
     let herbe = herbesList.find(item => item.name.toLowerCase() == formData.data.herbe.toLowerCase() );
       if( herbe ) {
-        let herbeData = Misc.templateData(herbe);
+        let herbeData = herbe.system;
         let brinsBase = max - herbeData.niveau;
         //console.log(herbeData, brinsBase, formData.data.herbebrins);
         formData.data.herbebonus = Math.max(herbeData.niveau - Math.max(brinsBase - formData.data.herbebrins, 0), 0);

module/rdd-main.js

@@ -221,19 +221,20 @@ function messageDeBienvenue() {
 // Register world usage statistics
 function registerUsageCount( registerKey ) {
   if ( game.user.isGM ) {
-    game.settings.register(registerKey, "world-key", {
+    game.settings.register("world", "world-key", {
       name: "Unique world key",
       scope: "world",
       config: false,
+      default: "NONE",
       type: String
     });
 
-    let worldKey = game.settings.get(registerKey, "world-key")
+    let worldKey = game.settings.get("world", "world-key")
     if ( worldKey == undefined || worldKey == "" ) {
       worldKey = randomID(32)
-      game.settings.set(registerKey, "world-key", worldKey )
+      game.settings.set("world", "world-key", worldKey )
     }
-    let regURL = `https://www.uberwald.me/fvtt_appcount/count.php?name="${registerKey}"&worldKey="${worldKey}"&version="${game.release.generation}.${game.release.build}"&system="${game.system.id}"&systemversion="${game.system.data.version}"`
+    let regURL = `https://www.uberwald.me/fvtt_appcount/count.php?name="${registerKey}"&worldKey="${worldKey}"&version="${game.release.generation}.${game.release.build}"&system="${game.system.id}"&systemversion="${game.system.version}"`
     $.ajax(regURL)
     /* -------------------------------------------- */
   }

module/rdd-meteo.js

@@ -0,0 +1,134 @@
+
+const vents = [
+  { min: 0, max: 0, valeur: 'Calme' },
+  { min: 1, max: 1, valeur: 'Légère brise' },
+  { min: 2, max: 2, valeur: 'Jolie brise' },
+  { min: 3, max: 3, valeur: 'Bonne brise' },
+  { min: 4, max: 4, valeur: 'Vent frais' },
+  { min: 5, max: 5, valeur: 'Coup de vent' },
+  { min: 6, max: 6, valeur: 'Fort coup de vent' },
+  { min: 7, max: 9, valeur: 'Tempête' },
+  { min: 10, max: 13, valeur: 'Violente tempête' },
+  { min: 14, valeur: 'Ouragan' },
+]
+const mers = [
+  { min: 0, max: 0, valeur: 'Calme' },
+  { min: 1, max: 1, valeur: 'Belle' },
+  { min: 2, max: 2, valeur: 'Peu agitée' },
+  { min: 3, max: 3, valeur: 'Agitée' },
+  { min: 4, max: 4, valeur: 'Forte' },
+  { min: 5, max: 6, valeur: 'Très forte' },
+  { min: 7, max: 9, valeur: 'Grosse' },
+  { min: 10, max: 13, valeur: 'Très grosse' },
+  { min: 14, valeur: 'Énorme' },
+]
+
+const nuages = [
+  { min: 0, max: 3, valeur: 'dégagé' },
+  { min: 4, max: 6, valeur: 'passages nuageux' },
+  { min: 7, max: 9, valeur: 'nuageux',  },
+  { min: 10, max: 10, valeur: 'brouillard' },
+  { min: 11, max: 12, valeur: 'bruine' },
+  { min: 13, valeur: 'très nuageux' },
+]
+
+const pluies = [
+  { min: 0, max: 4, valeur: 'aucune' },
+  { min: 5, max: 5, valeur: 'bruine, crachin, éparse' },
+  { min: 6, max: 7, valeur: 'averses' },
+  { min: 8, max: 10, valeur: 'pluvieux', },
+  { min: 11, max: 13, valeur: 'forte pluie' },
+  { min: 14, valeur: 'déluge' },
+]
+
+const temperatures = [
+  { max: -14, valeur: 'glaciale' },
+  { min: -13, max: -10, valeur: 'Très froide' },
+  { min: -9, max: -7, valeur: 'froide' },
+  { min: -6, max: -4, valeur: 'fraîche' },
+  { min: -3, max: 3, valeur: 'de saison' },
+  { min: 4, max: 6, valeur: 'élevée' },
+  { min: 7, max: 9, valeur: 'chaude' },
+  { min: 10, max: 13, valeur: 'torride' },
+  { min: 14, valeur: 'caniculaire' },
+]
+
+export class RdDMeteo {
+  static async getForce() {
+    const roll = new Roll(`1dr`);
+    await roll.evaluate({ async: true });
+    return roll.total;
+  }
+
+  static async getPluie(nuage) {
+    return nuage <= 3 ? 0 : await RdDMeteo.getForce();
+  }
+
+  static async getTemperature() {
+    const degre = await RdDMeteo.getForce();
+    const rollChaudFroid = new Roll('1d2');
+    await rollChaudFroid.evaluate({ async: true });
+    const chaudFroid = rollChaudFroid.total == 1;
+    return chaudFroid.total ? degre : -degre;
+  }
+
+  static async getDirection(direction) {
+    const roll = new Roll(`1d16`);
+    await roll.evaluate({ async: true });
+    switch (roll.total % 16) {
+      case 0: return 'Nord';
+      case 1: return 'Nord Nord Est';
+      case 2: return 'Nord Est';
+      case 3: return 'Est Nord Est';
+      case 4: return 'Est';
+      case 5: return 'Est Sud Est';
+      case 6: return 'Sud Est';
+      case 7: return 'Sud Sud Est';
+      case 8: return 'Sud';
+      case 9: return 'Sud Sud Ouest';
+      case 10: return 'Sud Ouest';
+      case 11: return 'Ouest Sud Ouest';
+      case 12: return 'Ouest';
+      case 13: return 'Ouest Nord Ouest';
+      case 14: return 'Nord Ouest';
+      case 15: return 'Nord Nord Ouest';
+    }
+    return undefined;
+  }
+
+  static async getMeteo() {
+    const vent = await RdDMeteo.getForce();
+    const mer = await RdDMeteo.getForce();
+    const nuage = await RdDMeteo.getForce();
+    const pluie = await RdDMeteo.getPluie(nuage);
+    const temperature = await RdDMeteo.getTemperature();
+    const meteo = {
+      vent: { force: vent, direction: await RdDMeteo.getDirection(), },
+      mer: { force: mer, direction: await RdDMeteo.getDirection(), },
+      temperature: { force: temperature },
+      nuage: { force: nuage, },
+      pluie: { force: pluie },
+    }
+    meteo.vent.description = RdDMeteo.vent(meteo.vent.force);
+    meteo.mer.description = RdDMeteo.mer(meteo.mer.force),
+    meteo.temperature.description = RdDMeteo.temperature(meteo.temperature.force);
+    meteo.nuage.description = RdDMeteo.nuage(meteo.nuage.force);
+    meteo.pluie.description = RdDMeteo.pluie(meteo.pluie.force);
+
+    ChatMessage.create({
+      content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-resultat-meteo.html', meteo),
+      whisper: ChatMessage.getWhisperRecipients('GM')
+    });
+  }
+
+  static description(liste, force, valeur = it => it.valeur) {
+    let select = liste.find(it => (it.min == undefined || it.min <= force) && (it.max == undefined || force <= it.max));
+    return valeur(select ?? liste[0]);
+  }
+
+  static vent(force) { return this.description(vents, force); }
+  static mer(force) { return this.description(mers, force); }
+  static nuage(force) { return this.description(nuages, force); }
+  static pluie(force) { return this.description(pluies, force); }
+  static temperature(force) { return this.description(temperatures, force); }
+}

module/rdd-namegen.js

@@ -1,19 +1,29 @@
+import { RdDActor } from "./actor.js";
 import { Misc } from "./misc.js";
 import { RdDDice } from "./rdd-dice.js";
 
-const words = [ 'pore', 'pre', 'flor', 'lane', 'turlu', 'pin', 'a', 'alph', 'i', 'onse', 'iane', 'ane', 'zach', 'arri', 'ba', 'bo', 'bi', 
-              'alta', 'par', 'pir', 'zor', 'zir', 'de', 'pol', 'tran', 'no', 'la', 'al' , 'pul', 'one', 'ner', 'nur', 'mac', 'mery',
-              'cat', 'do', 'di', 'der', 'er', 'el', 'far', 'fer', 'go', 'guer', 'hot', 'jor', 'jar', 'ji', 'kri', 'ket', 'lor', 'hur',
-              'lar', 'lir', 'lu', 'pot', 'pro', 'pra', 'pit', 'qua', 'qui', 're', 'ral', 'sal', 'sen', 'ted', 'to', 'ta', 'lars', 'ver',
-              'vin', 'ov', 'wal', 'ry', 'ly', '' ];
+const words = ['pore', 'pre', 'flor', 'lane', 'turlu', 'pin', 'a', 'alph', 'i', 'onse', 'iane', 'ane', 'zach', 'arri', 'ba', 'bo', 'bi',
+  'alta', 'par', 'pir', 'zor', 'zir', 'de', 'pol', 'tran', 'no', 'la', 'al', 'pul', 'one', 'ner', 'nur', 'mac', 'mery',
+  'cat', 'do', 'di', 'der', 'er', 'el', 'far', 'fer', 'go', 'guer', 'hot', 'jor', 'jar', 'ji', 'kri', 'ket', 'lor', 'hur',
+  'lar', 'lir', 'lu', 'pot', 'pro', 'pra', 'pit', 'qua', 'qui', 're', 'ral', 'sal', 'sen', 'ted', 'to', 'ta', 'lars', 'ver',
+  'vin', 'ov', 'wal', 'ry', 'ly', ''];
 
 /* -------------------------------------------- */
 export class RdDNameGen {
 
-  static async getName( msg, params ) {
-    let name = Misc.upperFirst( await RdDDice.rollOneOf(words) + await RdDDice.rollOneOf(words) )
-    //console.log(name);
-    ChatMessage.create( { content: `Nom : ${name}`, whisper: ChatMessage.getWhisperRecipients("GM") } );
+  static async getName(msg, params) {
+    const html = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-command-nom.html`, {
+      nom: Misc.upperFirst(await RdDDice.rollOneOf(words) + await RdDDice.rollOneOf(words))
+    });
+    ChatMessage.create({ content: html, whisper: ChatMessage.getWhisperRecipients("GM") });
   }
 
+  static async onCreerActeur(event) {
+    const button = event.currentTarget;
+    await RdDActor.create({
+        name: button.attributes['data-nom'].value,
+        type: button.attributes['data-type'].value
+      },
+      {renderSheet: true});
+  }
 }

module/rdd-possession.js

@@ -14,100 +14,86 @@ Donc la compétence Possession ne peut être démarrée que par le MJ.
 export class RdDPossession {
 
   /* -------------------------------------------- */
-  static init() {    
+  static init() {
   }
 
   /* -------------------------------------------- */
-  static searchPossessionFromEntite( attacker, defender) {
-    let poss = attacker.data.items.find( poss => poss.type == 'possession' && poss.data.data.possedeid == defender.data._id);
+  static searchPossessionFromEntite(attacker, defender) {
+    let poss = attacker.items.find(poss => poss.type == 'possession' && poss.system.possedeid == defender.id);
     if (!poss) {
-      poss = defender.data.items.find( poss => poss.type == 'possession' && poss.data.data.possedeid == defender.data._id);
+      poss = defender.items.find(poss => poss.type == 'possession' && poss.system.possedeid == defender.id);
     }
     return poss && duplicate(poss) || undefined;
   }
 
   /* -------------------------------------------- */
-  static updateEtatPossession( possession ) {
+  static updateEtatPossession(possession) {
     possession.ptsConjuration = 0
     possession.ptsPossession = 0
     console.log("Possession", possession)
-    if ( possession.data.compteur > 0) {
-      possession.ptsPossession = possession.data.compteur
-    } 
-    if ( possession.data.compteur < 0) {
-      possession.ptsConjuration = Math.abs(possession.data.compteur)
-    } 
+    if (possession.system.compteur > 0) {
+      possession.ptsPossession = possession.system.compteur
+    }
+    if (possession.system.compteur < 0) {
+      possession.ptsConjuration = Math.abs(possession.system.compteur)
+    }
     possession.isPosseder = false
     possession.isConjurer = false
-    if (possession.ptsPossession >= 2 ) {
+    if (possession.ptsPossession >= 2) {
       possession.isPosseder = true
     }
-    if (possession.ptsConjuration >= 2 ) {      
+    if (possession.ptsConjuration >= 2) {
       possession.isConjurer = true
     }
   }
 
   /* -------------------------------------------- */
-  static async resultConjuration( rollData) {
-    let actor = game.actors.get(rollData.possession.data.possedeid)
-    if ( !rollData.rolled.isSuccess ) {
-      if( rollData.isECNIDefender) {
-        rollData.possession.data.compteur--
+  static async resultConjuration(rollData) {
+    let actor = game.actors.get(rollData.possession.system.possedeid)
+    if (!rollData.rolled.isSuccess) {
+      if (rollData.isECNIDefender) {
+        rollData.possession.system.compteur--
       } else {
-        rollData.possession.data.compteur++
+        rollData.possession.system.compteur++
       }
-      let update = { _id: rollData.possession._id, "data.compteur": rollData.possession.data.compteur }
+      let update = { _id: rollData.possession._id, "system.compteur": rollData.possession.system.compteur }
       await actor.updateEmbeddedDocuments('Item', [update])
     }
-      
+
     this.updateEtatPossession(rollData.possession)
     await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-possession.html')
-    if ( rollData.possession.isPosseder || rollData.possession.isConjurer) {
+    if (rollData.possession.isPosseder || rollData.possession.isConjurer) {
       actor.deleteEmbeddedDocuments("Item", [rollData.possession._id])
     }
   }
 
   /* -------------------------------------------- */
-  static async onDefensePossession( attackerId, defenderId, possessionId) {
+  static async onDefensePossession(attackerId, defenderId, possessionId) {
     let attacker = game.actors.get(attackerId)
     let defender = game.actors.get(defenderId)
-
-    let possession = attacker.items.find( item => item.type =='possession' && item.data.data.possessionid == possessionId)
-    if ( !possession ) {    
-      possession = defender.items.find( item => item.type =='possession' && item.data.data.possessionid == possessionId)
-      if ( !possession) {
-        ui.notifications.warn("Une erreur s'est produite : Aucune possession trouvée !!")
-        return
-      }
+    let possession = attacker.getPossession(possessionId) ?? defender.getPossession(possessionId) ;
+    if (!possession) {
+      ui.notifications.warn("Une erreur s'est produite : Aucune possession trouvée !!")
+      return
     }
-    possession = duplicate(possession)
-
     // Update for draconic roll
     let rollData = {
-      possession: possession
+      mode: "conjuration",
+      isECNIDefender: defender.type == "entite",
+      possession: duplicate(possession),
+      attacker: attacker,
+      defender: defender,
+      competence: defender.getDraconicOuPossession(),
+      selectedCarac: defender.system.data.carac.reve,
+      forceCarac: { 'reve-actuel': { label: "Rêve Actuel", value: defender.getReveActuel() } }
     }
-    rollData.actor = defender
-    if ( defender.type == "personnage") {
-      rollData.competence = duplicate(defender.getDraconicOrZero())
-      rollData.competence.data.defaut_carac = 'reve-actuel'
-      rollData.forceCarac = { 'reve-actuel': { label: "Rêve Actuel", value: defender.getReveActuel() } }
-      rollData.selectedCarac = defender.data.data.carac.reve
-      rollData.isECNIDefender = false
-    } else {
-      rollData.competence = duplicate(defender.getCompetence("Possession"))
-      rollData.competence.data.defaut_carac = "reve"
-      rollData.forceCarac = { 'reve': { label: "Rêve", value: defender.data.data.carac.reve.value } }
-      rollData.selectedCarac = defender.data.data.carac.reve
-      rollData.isECNIDefender = true
-      //RdDItemCompetenceCreature.setRollDataCreature( rollData )
-    }
-    rollData.mode =  "conjuration"
-    rollData.possesseur = attacker.name
+    rollData.competence.system.defaut_carac = 'reve-actuel'
+
 
     const dialog = await RdDRoll.create(defender, rollData,
       {
         html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-defense-possession.html',
-        options: { height: 400 }
+        options: { height: 450 }
       },
       {
         name: 'conjurer',
@@ -121,54 +107,38 @@ export class RdDPossession {
   }
 
   /* -------------------------------------------- */
-  static async _onRollPossession( rollData, isSuccess ) {
-    let possession = rollData.possession
-    possession.isSuccess = isSuccess
-    this.updateEtatPossession( possession)
-    await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-possession.html');
-  }
-
-  /* -------------------------------------------- */
-  static async managePossession(attacker, competence, possession=undefined) {    
-    
+  static async onAttaquePossession(attacker, competence, possession = undefined) {
     const target = RdDCombat.getTarget()
     if (target == undefined) {
       ui.notifications.warn((game.user.targets?.size ?? 0) > 1
         ? "Vous devez choisir <strong>une seule</strong> cible à posséder!"
         : "Vous devez choisir une cible à posséder!");
       return;
-    }    
-    
-    const defender = target.actor
-    if ( !possession) {
-      possession = this.searchPossessionFromEntite( attacker, defender)
-      if ( !possession) {
-        possession = await this.createPossession(attacker, defender)
-      }
     }
-    possession = duplicate(possession)
 
+    const defender = target.actor;
+    possession = duplicate(possession ?? this.searchPossessionFromEntite(attacker, defender) ??(await this.createPossession(attacker, defender)));
+    
     this.updateEtatPossession(possession)
     let rollData = {
+      mode: "possession",
+      isECNIDefender: defender.type == "entite",
       competence: competence,
       possession: possession,
-      possede: defender.name,
-      possesseur: attacker.name,
-      attackerId: attacker.data._id,
-      defenderId: defender.data._id,
-      mode: "possession"
+      attacker: attacker,
+      defender: defender
     };
-    if ( attacker.isCreature()) {
+    if (attacker.isCreature()) {
       RdDItemCompetenceCreature.setRollDataCreature(rollData)
     }
 
-    const dialog = await RdDRoll.create( attacker, rollData,
+    const dialog = await RdDRoll.create(attacker, rollData,
       {
         html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-competence.html',
         options: { height: 540 }
       }, {
       name: 'jet-possession',
-      label: 'Possession: ',
+      label: rollData.isECNIDefender ? 'Conjurer la possession' : 'Possession',
       callbacks: [
         { condition: r => (r.rolled.isSuccess), action: async r => await this._onRollPossession(r, true) },
         { condition: r => (r.rolled.isEchec), action: async r => await this._onRollPossession(r, false) },
@@ -178,11 +148,18 @@ export class RdDPossession {
   }
 
   /* -------------------------------------------- */
-  static async createPossession( attacker, defender ) {
+  static async _onRollPossession(rollData, isSuccess) {
+    rollData.possession.isSuccess = isSuccess;
+    this.updateEtatPossession(rollData.possession);
+    await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-possession.html');
+  }
+
+  /* -------------------------------------------- */
+  static async createPossession(attacker, defender) {
     let possessionData = {
       name: "Possession en cours de " + attacker.name, type: 'possession',
       img: "systems/foundryvtt-reve-de-dragon/icons/entites/possession2.webp",
-      data: { description: "", typepossession: attacker.name, possede: false, possessionid: randomID(16), possesseurid: attacker.data._id, possedeid: defender.data._id, date: 0, compteur: 0 }
+      data: { description: "", typepossession: attacker.name, possede: false, possessionid: randomID(16), possesseurid: attacker.id, possedeid: defender.id, date: 0, compteur: 0 }
     }
     // Creates only the possession on the personnage side
     let poss = await defender.createEmbeddedDocuments('Item', [possessionData])

module/rdd-roll-encaisser.js

@@ -1,3 +1,5 @@
+import { ENTITE_BLURETTE, ENTITE_INCARNE, ENTITE_NONINCARNE } from "./constants.js";
+
 /**
  * Extend the base Dialog entity by defining a custom window to perform roll.
  * @extends {Dialog}
@@ -7,15 +9,19 @@ export class RdDEncaisser extends Dialog {
   /* -------------------------------------------- */
   constructor(html, actor) {
     // Common conf
-    const buttonsCreatures = {
-      "mortel": { label: "Mortel", callback: html => this.performEncaisser("mortel") },
-      "non-mortel": { label: "Non-mortel", callback: html => this.performEncaisser("non-mortel") },
-      "sonne": { label: "Sonné", callback: html => this.actor.setSonne() },
-    };
-    const buttonsEntitesCauchemar = {
-      "cauchemar": { label: "cauchemar", callback: html => this.performEncaisser("cauchemar") }
-    };
-    const buttons = actor.isEntiteCauchemar() ? buttonsEntitesCauchemar : buttonsCreatures;
+    let buttons = {};
+    if (!actor.isEntite()){
+      buttons = {
+        "mortel": { label: "Mortel", callback: html => this.performEncaisser("mortel") },
+        "non-mortel": { label: "Non-mortel", callback: html => this.performEncaisser("non-mortel") },
+        "sonne": { label: "Sonné", callback: html => this.actor.setSonne() },
+      };
+    }
+    else if (actor.isEntite([ENTITE_BLURETTE, ENTITE_INCARNE])){
+      buttons = {
+        "cauchemar": { label: "cauchemar", callback: html => this.performEncaisser("cauchemar") }
+      }
+    }
 
     let dialogConf = {
       title: "Jet d'Encaissement",
@@ -24,7 +30,6 @@ export class RdDEncaisser extends Dialog {
       default: "mortel"
     }
 
-
     let dialogOptions = {
       classes: ["rdddialog"],
       width: 320,

module/rdd-roll.js

@@ -38,25 +38,25 @@ export class RdDRoll extends Dialog {
 
   /* -------------------------------------------- */
   static _setDefaultOptions(actor, rollData) {
-    const actorData = Misc.data(actor);
+    const actorData = actor.system
     let defaultRollData = {
       alias: actor.name,
       ajustementsConditions: CONFIG.RDD.ajustementsConditions,
       difficultesLibres: CONFIG.RDD.difficultesLibres,
       etat: actor.getEtatGeneral(),
       moral: actor.getMoralTotal(), /* La valeur du moral pour les jets de volonté */
-      carac: actorData.data.carac,
+      carac: actorData.carac,
       finalLevel: 0,
       diffConditions: 0,
-      diffLibre: rollData.competence?.data.default_diffLibre ?? 0,
+      diffLibre: rollData.competence?.system.default_diffLibre ?? 0,
       malusArmureValue: actor.getMalusArmure(),
-      surencMalusFlag: actor.isPersonnage() ? (actorData.data.compteurs.surenc.value < 0) : false,
+      surencMalusFlag: actor.isPersonnage() ? (actorData.compteurs.surenc.value < 0) : false,
       surencMalusValue: actor.computeMalusSurEncombrement(),
       useMalusSurenc: false,
       useMoral: false,     /* Est-ce que le joueur demande d'utiliser le moral ? Utile si le joueur change plusieurs fois de carac associée. */
       perteMoralEchec: false, /* Pour l'affichage dans le chat */
       use: { libre: true, conditions: true, surenc: false, encTotal: false },
-      isMalusEncombrementTotal: RdDItemCompetence.isMalusEncombrementTotal(rollData.competence),
+      isMalusEncombrementTotal: rollData.competence ? RdDItemCompetence.isMalusEncombrementTotal(rollData.competence) : 0,
       useMalusEncTotal: false,
       encTotal: actor.getEncTotal(),
       ajustementAstrologique: actor.ajustementAstrologique(),
@@ -67,7 +67,7 @@ export class RdDRoll extends Dialog {
     }
     // Mini patch :Ajout du rêve actuel
     if ( actorData.type == "personnage") {
-      defaultRollData.carac["reve-actuel"] = actorData.data.reve.reve
+      defaultRollData.carac["reve-actuel"] = actorData.reve.reve
     }
 
     mergeObject(rollData, defaultRollData, { recursive: true, overwrite: false });
@@ -168,14 +168,14 @@ export class RdDRoll extends Dialog {
       console.log(rollData);
       // Update html, according to data
       if (rollData.competence) {
-        const defaut_carac = Misc.templateData(rollData.competence).defaut_carac;
+        const defaut_carac = rollData.competence.system.defaut_carac
         // Set the default carac from the competence item
         rollData.selectedCarac = rollData.carac[defaut_carac];
         $("#carac").val(defaut_carac);
       }
       if (rollData.selectedSort) {
         dialog.setSelectedSort(rollData.selectedSort);
-        $(".draconic").val(rollData.selectedSort.data.listIndex); // Uniquement a la selection du sort, pour permettre de changer 
+        $(".draconic").val(rollData.selectedSort.system.listIndex); // Uniquement a la selection du sort, pour permettre de changer 
       }
       RdDItemSort.setCoutReveReel(rollData.selectedSort);
       $("#diffLibre").val(Misc.toInt(rollData.diffLibre));
@@ -271,21 +271,21 @@ export class RdDRoll extends Dialog {
 
   async setSelectedSort(sort) {
     this.rollData.selectedSort = sort; // Update the selectedCarac
-    this.rollData.competence = RdDItemCompetence.getVoieDraconic(this.rollData.draconicList, sort.data.draconic);
+    this.rollData.competence = RdDItemCompetence.getVoieDraconic(this.rollData.draconicList, sort.system.draconic);
     this.rollData.bonus = RdDItemSort.getCaseBonus(sort, this.rollData.tmr.coord);
     this.rollData.diffLibre = RdDItemSort.getDifficulte(sort, -7);
     RdDItemSort.setCoutReveReel(sort);
     const htmlSortDescription = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/partial-description-sort.html", { sort: sort });
-    $(".sort-ou-rituel").text(sort.data.isrituel ? "rituel" : "sort");
+    $(".sort-ou-rituel").text(sort.system.isrituel ? "rituel" : "sort");
     $(".bonus-case").text(`${this.rollData.bonus}%`);
     $(".details-sort").remove();
     $(".description-sort").append(htmlSortDescription);
-    $(".roll-draconic").val(sort.data.listIndex);
-    $(".div-sort-difficulte-fixe").text(Misc.toSignedString(sort.data.difficulte));
-    $(".div-sort-ptreve-fixe").text(sort.data.ptreve);
+    $(".roll-draconic").val(sort.system.listIndex);
+    $(".div-sort-difficulte-fixe").text(Misc.toSignedString(sort.system.difficulte));
+    $(".div-sort-ptreve-fixe").text(sort.system.ptreve);
     const diffVariable = RdDItemSort.isDifficulteVariable(sort);
     const coutVariable = RdDItemSort.isCoutVariable(sort);
-    HtmlUtility._showControlWhen($(".div-sort-non-rituel"), !sort.data.isrituel);
+    HtmlUtility._showControlWhen($(".div-sort-non-rituel"), !sort.system.isrituel);
     HtmlUtility._showControlWhen($(".div-sort-difficulte-var"), diffVariable);
     HtmlUtility._showControlWhen($(".div-sort-difficulte-fixe"), !diffVariable);
     HtmlUtility._showControlWhen($(".div-sort-ptreve-var"), coutVariable);
@@ -388,7 +388,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.niveau);
+    const niveau = Misc.toSignedString(rollData.competence.system.niveau)
     if (compName == carac) {
       // cas des créatures
       return carac + " Niveau " + niveau

module/rdd-rolltables.js

@@ -10,21 +10,22 @@ export class RdDRollTables {
       table = await pack.getDocument(entry._id);
     }
     const draw = await table.draw({ displayChat: toChat, rollMode: "gmroll"});
-    console.log("RdDRollTables", tableName, toChat, ":", draw);
+    //console.log("RdDRollTables", tableName, toChat, ":", draw);
     return draw.results.length > 0 ? draw.results[0] : undefined;
   }
 
   /* -------------------------------------------- */
   static async drawItemFromRollTable(tableName, toChat = false) {
     const drawResult = await RdDRollTables.genericGetTableResult(tableName, toChat);
-    const pack = game.packs.get(drawResult.data.collection);
-    return await pack.getDocument(drawResult.data.resultId);
+    const pack = game.packs.get(drawResult.documentCollection)
+    let doc = await pack.getDocument(drawResult.documentId)
+    return doc
   }
   
   /* -------------------------------------------- */
   static async drawTextFromRollTable(tableName, toChat) {
     const drawResult = await RdDRollTables.genericGetTableResult(tableName, toChat);
-    return drawResult.data.text;
+    return drawResult.system.text;
   }
 
   /* -------------------------------------------- */

module/rdd-sheet-utility.js

@@ -21,7 +21,10 @@ export class RdDSheetUtility {
   }
 
   static prepareItemDropParameters(destItemId, actorId, dragData, objetVersConteneur) {
-    const itemId = dragData.id || dragData.data._id;
+    console.log("ID", dragData)
+    const item = fromUuidSync(dragData.uuid)
+    let itemId = item.id
+    //const itemId = dragData.id || dragData.data._id
     return {
       destId: destItemId,
       targetActorId: actorId,
@@ -42,11 +45,11 @@ export class RdDSheetUtility {
   }
 
   static async _onSplitItem(item, split, actor) {
-    if (split >= 1 && split < Misc.data(item).data.quantite) {
+    if (split >= 1 && split < item.system.quantite) {
       await item.diminuerQuantite(split);
-      const itemData = duplicate(Misc.data(item));
+      const itemData = duplicate(item);
       // todo: ajouter dans le même conteneur?
-      itemData.data.quantite = split;
+      itemData.system.quantite = split;
       await actor.createEmbeddedDocuments('Item', [itemData])
     }
   }

module/rdd-tmr-dialog.js

@@ -78,12 +78,12 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   loadCasesSpeciales() {
-    this.casesSpeciales = this.actor.data.items.filter(item => Draconique.isCaseTMR(item));
+    this.casesSpeciales = this.actor.items.filter(item => Draconique.isCaseTMR(item));
   }
 
   /* -------------------------------------------- */
   loadSortsReserve() {
-    this.sortsReserves = Misc.data(this.actor).data.reve.reserve.list;
+    this.sortsReserves = this.actor.system.reve.reserve.list;
   }
 
   /* -------------------------------------------- */
@@ -95,12 +95,15 @@ export class RdDTMRDialog extends Dialog {
   createPixiSprites() {
     EffetsDraconiques.carteTmr.createSprite(this.pixiTMR);
     this.updateTokens();
-    this.demiReve = this._tokenDemiReve();
-    this._updateDemiReve();
+    this.forceDemiRevePositionView();
   }
-
+  
   /* -------------------------------------------- */
   _createTokens() {
+    if (!this.isDemiReveCache()){
+      this.demiReve = this._tokenDemiReve();
+      this._trackToken(this.demiReve);
+    }
     let tokens = this._getTokensCasesTmr()
       .concat(this._getTokensRencontres())
       .concat(this._getTokensSortsReserve());
@@ -141,26 +144,25 @@ export class RdDTMRDialog extends Dialog {
     return EffetsDraconiques.rencontre.token(this.pixiTMR, rencontre, () => rencontre.coord);
   }
   _tokenCaseSpeciale(casetmr) {
-    const caseData = Misc.data(casetmr);
-    const draconique = Draconique.get(caseData.data.specific);
-    return draconique?.token(this.pixiTMR, caseData, () => caseData.data.coord);
+    const caseData = casetmr;
+    const draconique = Draconique.get(caseData.system.specific);
+    return draconique?.token(this.pixiTMR, caseData, () => caseData.system.coord);
   }
   _tokenSortEnReserve(sortEnReserve) {
     return EffetsDraconiques.sortReserve.token(this.pixiTMR, sortEnReserve.sort, () => sortEnReserve.coord);
   }
 
   _tokenDemiReve() {
-    const actorData = Misc.data(this.actor);
-    return EffetsDraconiques.demiReve.token(this.pixiTMR, actorData, () => actorData.data.reve.tmrpos.coord);
+    return EffetsDraconiques.demiReve.token(this.pixiTMR, this.actor.system, () => this.actor.system.reve.tmrpos.coord);
   }
 
-  _updateDemiReve() {
+  forceDemiRevePositionView() {
     this.notifierResonanceSigneDraconique(this._getActorCoord());
-    this._setTokenPosition(this.demiReve);
+    this._trackToken(this.demiReve);
   }
 
   _getActorCoord() {
-    return Misc.data(this.actor).data.reve.tmrpos.coord;
+    return this.actor.system.reve.tmrpos.coord;
   }
 
   /* -------------------------------------------- */
@@ -244,12 +246,11 @@ export class RdDTMRDialog extends Dialog {
   /* -------------------------------------------- */
   async updateValuesDisplay() {
     const coord = this._getActorCoord();
-    const actorData = Misc.data(this.actor);
 
     HtmlUtility._showControlWhen($(".lire-signe-draconique"), this.actor.isResonanceSigneDraconique(coord));
 
     let ptsreve = document.getElementById("tmr-pointsreve-value");
-    ptsreve.innerHTML = actorData.data.reve.reve.value;
+    ptsreve.innerHTML = this.actor.system.reve.reve.value;
 
     let tmrpos = document.getElementById("tmr-pos");
     if (this.isDemiReveCache()) {
@@ -262,12 +263,12 @@ export class RdDTMRDialog extends Dialog {
     etat.innerHTML = this.actor.getEtatGeneral();
 
     let refoulement = document.getElementById("tmr-refoulement-value");
-    refoulement.innerHTML = actorData.data.reve.refoulement.value;
+    refoulement.innerHTML = this.actor.system.reve.refoulement.value;
 
     if (ReglesOptionelles.isUsing("appliquer-fatigue")) {
       let fatigueItem = document.getElementById("tmr-fatigue-table");
       //console.log("Refresh : ", actorData.data.sante.fatigue.value);
-      fatigueItem.innerHTML = "<table class='table-fatigue'>" + RdDUtility.makeHTMLfatigueMatrix(actorData.data.sante.fatigue.value, actorData.data.sante.endurance.max).html() + "</table>";
+      fatigueItem.innerHTML = "<table class='table-fatigue'>" + RdDUtility.makeHTMLfatigueMatrix(this.actor.system.sante.fatigue.value, this.actor.system.sante.endurance.max).html() + "</table>";
     }
   }
 
@@ -336,6 +337,10 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   async choisirCasePortee(coord, portee) {
+    if (this.actor.isTMRCache())
+    {
+      return;
+    }
     // Récupère la liste des cases à portées
     let locList = TMRUtility.getTMRPortee(coord, portee);
     this.colorierZoneRencontre(locList);
@@ -507,7 +512,7 @@ export class RdDTMRDialog extends Dialog {
     const presentCite = this.casesSpeciales.find(c => EffetsDraconiques.presentCites.isCase(c, tmr.coord));
     if (presentCite) {
       this.minimize();
-      const caseData = Misc.data(presentCite);
+      const caseData = presentCite;
       EffetsDraconiques.presentCites.choisirUnPresent(caseData, (type => this._utiliserPresentCite(presentCite, type, tmr, postRencontre)));
     }
     return presentCite;
@@ -589,7 +594,7 @@ export class RdDTMRDialog extends Dialog {
         maitrise: { verbe: 'maîtriser', action: 'Maîtriser le fleuve' }
       }
       rollData.double = EffetsDraconiques.isDoubleResistanceFleuve(this.actor) ? true : undefined,
-      rollData.competence.data.defaut_carac = 'reve-actuel';
+      rollData.competence.system.defaut_carac = 'reve-actuel';
       await this._rollMaitriseCaseHumide(rollData);
     }
   }
@@ -714,7 +719,7 @@ export class RdDTMRDialog extends Dialog {
       forceCarac: { 'reve-actuel': { label: "Rêve Actuel", value: this.actor.getReveActuel() } },
       maitrise: { verbe: 'conquérir', action: options.action }
     };
-    rollData.competence.data.defaut_carac = 'reve-actuel';
+    rollData.competence.system.defaut_carac = 'reve-actuel';
 
     await this._maitriserTMR(rollData, r => this._onResultatConquerir(r, options));
   }
@@ -743,6 +748,7 @@ export class RdDTMRDialog extends Dialog {
   /* -------------------------------------------- */
   async _maitriserTMR(rollData, callbackMaitrise) {
     this.minimize(); // Hide
+    rollData.isTMRCache = rollData.actor.isTMRCache();
     const dialog = await RdDRoll.create(this.actor, rollData,
       {
         html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-maitrise-tmr.html',
@@ -813,7 +819,7 @@ export class RdDTMRDialog extends Dialog {
     //this.updateSortReserve();
     console.log("declencheSortEnReserve", sortReserve)
     this._tellToUserAndGM(`Vous avez déclenché le sort en réserve <strong> ${sortReserve.sort.name}</strong>
-        avec ${sortReserve.sort.data.ptreve_reel} points de Rêve
+        avec ${sortReserve.sort.system.ptreve_reel} points de Rêve
         en ${sortReserve.coord} (${TMRUtility.getTMRLabel(sortReserve.coord)})
         `);
     this.close();
@@ -874,49 +880,62 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   async _onClickTMRPos(clickOddq) {
-    if (this.isDemiReveCache()) {
-      ui.notifications.error(`Vous ne connaissez plus votre position dans les TMR.
-      Vous devez utiliser les boutons de direction pour vous déplacer.
-      Une fois que vous aurez retrouvé votre demi-rêve, demandez au gardien de vérifier et rendre les TMR visibles.
-      `);
-      return;
-    }
-
     let currentOddq = TMRUtility.coordTMRToOddq(this._getActorCoord());
-
-    console.log("deplacerDemiReve >>>>", currentOddq, clickOddq);
-
     let targetCoord = TMRUtility.oddqToCoordTMR(clickOddq);
     let currentCoord = TMRUtility.oddqToCoordTMR(currentOddq);
-
     // Validation de la case de destination (gestion du cas des rencontres qui peuvent téléporter)
     let deplacementType = this._calculDeplacement(targetCoord, currentCoord, currentOddq, clickOddq);
 
-    // Si le deplacement est valide
-    if (deplacementType == 'normal' || deplacementType == 'saut') {
-      await this._deplacerDemiReve(targetCoord, deplacementType);
-    } else if (deplacementType == 'messager') { // Dans ce cas, ouverture du lancement de sort sur la case visée
-      await this._messagerDemiReve(targetCoord);
-    } else {
-      ui.notifications.error("Vous ne pouvez pas vous déplacer que sur des cases adjacentes à votre position ou valides dans le cas d'une rencontre");
-      console.log("STATUS :", this.rencontreState, this.currentRencontre);
+    if (this.isDemiReveCache()) {
+      if (this.isTerreAttache(targetCoord)
+      || (this.isCaseHumide(currentCoord) && this.isCaseHumide(targetCoord))
+      || deplacementType == 'changeur')
+      {
+        // déplacement possible
+        await this.actor.montreTMR();
+      }
+      else
+      {
+        ui.notifications.error(`Vous ne connaissez plus votre position dans les TMR.
+        Vous devez utiliser les boutons de direction pour vous déplacer.
+        Une fois que vous aurez retrouvé votre demi-rêve, demandez au gardien de vérifier et rendre les TMR visibles.
+        `);
+        return;
+      }
     }
+
+    switch (deplacementType){
+      case 'normal':
+        await this._deplacerDemiReve(targetCoord, deplacementType);
+        break;
+      case 'messager':
+        await this._messagerDemiReve(targetCoord);
+        break;
+      case 'changeur':
+      case 'passeur':
+        await this._deplacerDemiReve(targetCoord, deplacementType);
+        break;
+      default:
+          ui.notifications.error("Vous ne pouvez pas vous déplacer que sur des cases adjacentes à votre position ou valides dans le cas d'une rencontre");
+          console.log("STATUS :", this.rencontreState, this.currentRencontre);
+    }
+
     this.checkQuitterTMR();
   }
 
   /* -------------------------------------------- */
   _calculDeplacement(targetCoord, currentCoord, fromOddq, toOddq) {
+
     const isInArea = this.rencontreState == 'aucune'
       ? (this.isTerreAttache(targetCoord) || this.isConnaissanceFleuve(currentCoord, targetCoord) || TMRUtility.distanceOddq(fromOddq, toOddq) <= 1)
       : this.currentRencontre?.locList.find(coord => coord == targetCoord) ?? false
     if (isInArea) {
       switch (this.rencontreState) {
         case 'aucune': return 'normal';
-        case 'messager': return 'messager';
-        case 'passeur': case 'changeur': return 'saut';
+        case 'passeur': case 'changeur': case 'messager': return this.rencontreState;
       }
     }
-    return 'erreur'
+    return 'erreur';
   }
 
   /* -------------------------------------------- */
@@ -932,9 +951,8 @@ export class RdDTMRDialog extends Dialog {
   }
 
   /* -------------------------------------------- */
-  externalRefresh(tmrData) {
+  externalRefresh() {
     this.createPixiSprites();
-    this.forceDemiRevePositionView();
     this.updateValuesDisplay();
     this.updateTokens();
     console.log("TMR REFRESHED !!!");
@@ -946,23 +964,17 @@ export class RdDTMRDialog extends Dialog {
       this.nettoyerRencontre();
     }
     let tmr = TMRUtility.getTMR(targetCoord);
-    //console.log("deplacerDemiReve", tmr, this);
     // Gestion cases spéciales type Trou noir, etc
     tmr = await this.manageTmrInnaccessible(tmr);
 
     await this.actor.updateCoordTMR(tmr.coord);
 
-    this._updateDemiReve();
+    this.forceDemiRevePositionView();
     if (ReglesOptionelles.isUsing("appliquer-fatigue")) {
       this.cumulFatigue += this.fatigueParCase;
     }
     this.updateValuesDisplay();
-    game.socket.emit(SYSTEM_SOCKET_ID, {
-      msg: "msg_tmr_move", data: {
-        actorId: this.actor.data._id,
-        tmrPos: Misc.data(this.actor).data.reve.tmrpos
-      }
-    });
+    this.actor.notifyRefreshTMR();
 
     if (deplacementType == 'normal') { // Pas de rencontres après un saut de type passeur/changeur/...
       await this.manageRencontre(tmr, () => this.postRencontre(tmr));
@@ -995,14 +1007,9 @@ export class RdDTMRDialog extends Dialog {
   }
 
   /* -------------------------------------------- */
-  async forceDemiRevePositionView() {
-    this._updateDemiReve();
-  }
-
-  /* -------------------------------------------- */
-  async forceDemiRevePosition(coord) {
+  async positionnerDemiReve(coord) {
     await this.actor.updateCoordTMR(coord);
-    this._updateDemiReve();
+    this.forceDemiRevePositionView();
     let tmr = TMRUtility.getTMR(coord);
     await this.postRencontre(tmr);
     return tmr;
@@ -1024,15 +1031,7 @@ export class RdDTMRDialog extends Dialog {
   _getCaseRectangleCoord(coord) {
     return this.pixiTMR.getCaseRectangle(TMRUtility.coordTMRToOddq(coord));
   }
-
-  /* -------------------------------------------- */
-  _setTokenPosition(token) {
-    if (this.isDemiReveCache() && this.demiReve === token ) {
-      return;
-    }
-    this.pixiTMR.setPosition(token.sprite, TMRUtility.coordTMRToOddq(token.coordTMR()));
-  }
-
+  
   /* -------------------------------------------- */
   _removeTokens(filter) {
     const tokensToRemove = this.allTokens.filter(filter);
@@ -1040,10 +1039,13 @@ export class RdDTMRDialog extends Dialog {
       this.pixiApp.stage.removeChild(token.sprite);
     }
   }
-
+  
   /* -------------------------------------------- */
   _trackToken(token) {
+    if (this.demiReve === token && this.isDemiReveCache()) {
+      return;
+    }
+    this.pixiTMR.setPosition(token.sprite, TMRUtility.coordTMRToOddq(token.coordTMR()));
     this.allTokens.push(token);
-    this._setTokenPosition(token);
   }
 }

module/rdd-token-hud.js

@@ -22,41 +22,64 @@ export class RdDTokenHud {
 
     let token = canvas.tokens.get(tokenId);
     let actor = token.actor;
-    let combatant = game.combat.combatants.find(c => Misc.data(c).tokenId == tokenId);
+    let combatant = game.combat.combatants.find(c => c.tokenId == tokenId);
+    if (! (combatant?.actor) ) {
+        ui.notifications.warn(`Le combatant ${token.name} n'est pas associé à un acteur, impossible de déterminer ses actions de combat!`)
+        return;
+    }
     app.hasExtension = true;
 
-    let armesList = RdDCombatManager.buildListeActionsCombat(combatant);
+    let actionsCombat = RdDCombatManager.listActionsCombat(combatant);
     const hudData = {
-      combatant: combatant, armes: armesList,
-      commandes: [{ name: 'Initiative +1', command: 'inc', value: 0.01 }, { name: 'Initiative -1', command: 'dec', value: -0.01 }]
+      combatant: combatant,
+      actions: actionsCombat,
+      commandes: [
+        { name: "Autre action", command: 'autre' },
+        { name: 'Initiative +1', command: 'inc', value: 0.01 }, 
+        { name: 'Initiative -1', command: 'dec', value: -0.01 }]
     };
 
     const controlIconCombat = html.find('.control-icon[data-action=combat]');
     // initiative
-    await RdDTokenHud._configureSubMenu(controlIconCombat, 'systems/foundryvtt-reve-de-dragon/templates/hud-actor-init.html', hudData,
+    await RdDTokenHud._configureSubMenu(controlIconCombat,
+      'systems/foundryvtt-reve-de-dragon/templates/hud-actor-init.html',
+      hudData,
       (event) => {
-        let initCommand = event.currentTarget.attributes['data-command'].value;
-        let combatantId = event.currentTarget.attributes['data-combatant-id'].value;
-        if (!initCommand) {
-          let armeIndex = event.currentTarget.attributes['data-arme-id'].value;
-          let arme = armesList[armeIndex];
-          RdDCombatManager.rollInitiativeCompetence(combatantId, arme);
-        } else if (initCommand == 'inc') {
-          RdDCombatManager.incDecInit(combatantId, 0.01);
-        } else if (initCommand == 'dec') {
-          RdDCombatManager.incDecInit(combatantId, -0.01);
-        }
+        let initCommand = event.currentTarget.attributes['data-command']?.value;
+        let combatantId = event.currentTarget.attributes['data-combatant-id']?.value;
+        if (initCommand) {
+          RdDTokenHud._initiativeCommand(initCommand, combatantId);
+        } else {
+          let index = event.currentTarget.attributes['data-action-index'].value;
+          let action = actionsCombat[index];
+          RdDCombatManager.rollInitiativeAction(combatantId, action);
+        } 
       });
 
     const controlIconTarget = html.find('.control-icon[data-action=target]');
     // combat
     await RdDTokenHud._configureSubMenu(controlIconTarget, 'systems/foundryvtt-reve-de-dragon/templates/hud-actor-attaque.html', hudData,
       (event) => {
-        let armeIndex = event.currentTarget.attributes['data-arme-id'].value;
-        actor.rollArme(armesList[armeIndex]);
+        const actionIndex = event.currentTarget.attributes['data-action-index']?.value;
+        const action = actionsCombat[actionIndex];
+        if (action.action == 'conjurer') {
+          actor.conjurerPossession(actor.getPossession(action.data.possessionid));
+        }
+        else {
+          actor.rollArme(action);
+        }
       });
   }
 
+  static _initiativeCommand(initCommand, combatantId) {
+    switch (initCommand) {
+      case 'inc': return RdDCombatManager.incDecInit(combatantId, 0.01);
+      case 'dec': return RdDCombatManager.incDecInit(combatantId, -0.01);
+      case 'autre': return RdDCombatManager.rollInitiativeAction(combatantId, 
+        { name: "Autre action", action: 'autre', data: { initOnly: true, competence: "Autre action" } });
+    }
+  }
+
   /* -------------------------------------------- */
   static async addTokenHudExtensions(app, html, tokenId) {
     const controlIconCombat  = html.find('.control-icon[data-action=combat]');

module/rdd-utility.js

@@ -11,6 +11,7 @@ import { RdDDice } from "./rdd-dice.js";
 import { RdDItem } from "./item.js";
 import { Monnaie } from "./item-monnaie.js";
 import { RdDPossession } from "./rdd-possession.js";
+import { RdDNameGen } from "./rdd-namegen.js";
 
 /* -------------------------------------------- */
 // This table starts at 0 -> niveau -10
@@ -221,8 +222,10 @@ export class RdDUtility {
     ];
 
     Handlebars.registerHelper('upperFirst', str => Misc.upperFirst(str ?? 'Null'));
+    Handlebars.registerHelper('lowerFirst', str => Misc.lowerFirst(str ?? 'Null'));
     Handlebars.registerHelper('upper', str => str?.toUpperCase() ?? 'NULL');
     Handlebars.registerHelper('le', str => Grammar.articleDetermine(str));
+    Handlebars.registerHelper('apostrophe', (article, str) => Grammar.apostrophe(article, str));
     Handlebars.registerHelper('un', str => Grammar.articleIndetermine(str));
     Handlebars.registerHelper('accord', (genre, ...args) => Grammar.accord(genre, args));
     Handlebars.registerHelper('buildConteneur', (objet) => { return new Handlebars.SafeString(RdDUtility.buildConteneur(objet)); });
@@ -240,7 +243,7 @@ export class RdDUtility {
         if (b.name.includes("Extérieur")) return 1;
         return a.name.localeCompare(b.name);
       }
-      if (a.data.categorie.startsWith("melee") && b.data.categorie.startsWith("melee")) {
+      if (a.system.categorie.startsWith("melee") && b.system.categorie.startsWith("melee")) {
         if (a.name.includes("Corps")) return -1;
         if (b.name.includes("Corps")) return 1;
         if (a.name.includes("Dague")) return -1;
@@ -326,8 +329,8 @@ export class RdDUtility {
   }
 
   /* -------------------------------------------- */
-  static checkNull(items) {
-    if (items && items.length) {
+  static arrayOrEmpty(items) {
+    if (items?.length) {
       return items;
     }
     return [];
@@ -360,44 +363,44 @@ export class RdDUtility {
 
     RdDUtility.filterEquipementParType(formData);
 
-    formData.sorts = this.checkNull(formData.itemsByType['sort']);
-    formData.signesdraconiques = this.checkNull(formData.itemsByType['signedraconique']);
-    formData.queues = this.checkNull(formData.itemsByType['queue']);
-    formData.souffles = this.checkNull(formData.itemsByType['souffle']);
-    formData.ombres = this.checkNull(formData.itemsByType['ombre']);
-    formData.tetes = this.checkNull(formData.itemsByType['tete']);
-    formData.taches = this.checkNull(formData.itemsByType['tache']);
-    formData.meditations = this.checkNull(formData.itemsByType['meditation']);
-    formData.chants = this.checkNull(formData.itemsByType['chant']);
-    formData.danses = this.checkNull(formData.itemsByType['danse']);
-    formData.musiques = this.checkNull(formData.itemsByType['musique']);
-    formData.oeuvres = this.checkNull(formData.itemsByType['oeuvre']);
-    formData.jeux = this.checkNull(formData.itemsByType['jeu']);
+    formData.sorts = this.arrayOrEmpty(formData.itemsByType['sort']);
+    formData.signesdraconiques = this.arrayOrEmpty(formData.itemsByType['signedraconique']);
+    formData.queues = this.arrayOrEmpty(formData.itemsByType['queue']);
+    formData.souffles = this.arrayOrEmpty(formData.itemsByType['souffle']);
+    formData.ombres = this.arrayOrEmpty(formData.itemsByType['ombre']);
+    formData.tetes = this.arrayOrEmpty(formData.itemsByType['tete']);
+    formData.taches = this.arrayOrEmpty(formData.itemsByType['tache']);
+    formData.meditations = this.arrayOrEmpty(formData.itemsByType['meditation']);
+    formData.chants = this.arrayOrEmpty(formData.itemsByType['chant']);
+    formData.danses = this.arrayOrEmpty(formData.itemsByType['danse']);
+    formData.musiques = this.arrayOrEmpty(formData.itemsByType['musique']);
+    formData.oeuvres = this.arrayOrEmpty(formData.itemsByType['oeuvre']);
+    formData.jeux = this.arrayOrEmpty(formData.itemsByType['jeu']);
 
-    formData.recettescuisine = this.checkNull(formData.itemsByType['recettecuisine']);
-    formData.recettesAlchimiques = this.checkNull(formData.itemsByType['recettealchimique']);
-    formData.maladies = this.checkNull(formData.itemsByType['maladie']);
-    formData.poisons = this.checkNull(formData.itemsByType['poison']);
-    formData.possessions = this.checkNull(formData.itemsByType['possession']);
+    formData.recettescuisine = this.arrayOrEmpty(formData.itemsByType['recettecuisine']);
+    formData.recettesAlchimiques = this.arrayOrEmpty(formData.itemsByType['recettealchimique']);
+    formData.maladies = this.arrayOrEmpty(formData.itemsByType['maladie']);
+    formData.poisons = this.arrayOrEmpty(formData.itemsByType['poison']);
+    formData.possessions = this.arrayOrEmpty(formData.itemsByType['possession']);
     formData.maladiesPoisons = formData.maladies.concat(formData.poisons);
     formData.competences = (formData.itemsByType.competence ?? []).concat(formData.itemsByType.competencecreature ?? []);
   }
 
   static filterEquipementParType(formData) {
-    formData.conteneurs = this.checkNull(formData.itemsByType['conteneur']);
+    formData.conteneurs = this.arrayOrEmpty(formData.itemsByType['conteneur']);
 
-    formData.materiel = this.checkNull(formData.itemsByType['objet']);
-    formData.armes = this.checkNull(formData.itemsByType['arme']);
-    formData.armures = this.checkNull(formData.itemsByType['armure']);
-    formData.munitions = this.checkNull(formData.itemsByType['munition']);
-    formData.livres = this.checkNull(formData.itemsByType['livre']);
-    formData.potions = this.checkNull(formData.itemsByType['potion']);
-    formData.ingredients = this.checkNull(formData.itemsByType['ingredient']);
-    formData.herbes = this.checkNull(formData.itemsByType['herbe']);
-    formData.monnaie = this.checkNull(formData.itemsByType['monnaie']);
+    formData.materiel = this.arrayOrEmpty(formData.itemsByType['objet']);
+    formData.armes = this.arrayOrEmpty(formData.itemsByType['arme']);
+    formData.armures = this.arrayOrEmpty(formData.itemsByType['armure']);
+    formData.munitions = this.arrayOrEmpty(formData.itemsByType['munition']);
+    formData.livres = this.arrayOrEmpty(formData.itemsByType['livre']);
+    formData.potions = this.arrayOrEmpty(formData.itemsByType['potion']);
+    formData.ingredients = this.arrayOrEmpty(formData.itemsByType['ingredient']);
+    formData.herbes = this.arrayOrEmpty(formData.itemsByType['herbe']);
+    formData.monnaie = this.arrayOrEmpty(formData.itemsByType['monnaie']);
     formData.monnaie.sort(Monnaie.triValeurDenier());
-    formData.nourritureboissons = this.checkNull(formData.itemsByType['nourritureboisson']);
-    formData.gemmes = this.checkNull(formData.itemsByType['gemme']);
+    formData.nourritureboissons = this.arrayOrEmpty(formData.itemsByType['nourritureboisson']);
+    formData.gemmes = this.arrayOrEmpty(formData.itemsByType['gemme']);
 
     formData.objets = formData.conteneurs
       .concat(formData.materiel)
@@ -419,7 +422,7 @@ export class RdDUtility {
     // Attribution des objets aux conteneurs
     for (let conteneur of conteneurs) {
       conteneur.subItems = [];
-      for (let id of conteneur.data.contenu ?? []) {
+      for (let id of conteneur.system.contenu ?? []) {
         let objet = objets.find(objet => (id == objet._id));
         if (objet) {
           objet.estContenu = true; // Permet de filtrer ce qui est porté dans le template
@@ -429,27 +432,26 @@ export class RdDUtility {
       }
     }
     for (let conteneur of conteneurs) {
-      conteneur.data.encTotal = RdDUtility.calculEncContenu(conteneur, objets);
+      conteneur.system.encTotal = RdDUtility.calculEncContenu(conteneur, objets);
     }
     return objetVersConteneur;
   }
 
   /* -------------------------------------------- */
   static calculEncContenu(conteneur, objets) {
-    const itemData = Misc.data(conteneur);
-    const contenuDatas = (itemData.data.contenu ?? []).filter(id => id != undefined)
-      .map(id => Misc.data(objets.find(it => (id == it._id))))
+    const contenuDatas = (conteneur.system.contenu ?? []).filter(id => id != undefined)
+      .map(id => objets.find(it => (id == it._id)))
       .filter(it => it);
-    let enc = Number(itemData.data.encombrement ?? 0) * Number(itemData.data.quantite ?? 1);
+    let enc = Number(conteneur.system.encombrement ?? 0) * Number(conteneur.system.quantite ?? 1);
     for (let itemData of contenuDatas) {
       if (itemData.type == 'conteneur') {
         enc += RdDUtility.calculEncContenu(itemData, objets);
       }
       else {
-        enc += Number(itemData.data.encombrement ?? 0) * Number(itemData.data.quantite ?? 1);
+        enc += Number(itemData.system.encombrement ?? 0) * Number(itemData.system.quantite ?? 1)
       }
     }
-    return enc;
+    return enc
   }
 
   /* -------------------------------------------- */
@@ -666,7 +668,7 @@ export class RdDUtility {
       case "msg_tmr_move":
         let actor = game.actors.get(sockmsg.data.actorId);
         if (actor.isOwner || game.user.isGM) {
-          actor.refreshTMRView(sockmsg.data.tmrPos);
+          actor.refreshTMRView();
         }
         break;
     }
@@ -681,7 +683,7 @@ export class RdDUtility {
       let coord = event.currentTarget.attributes['data-tmr-coord'].value;
       let actorId = event.currentTarget.attributes['data-actor-id'].value;
       let actor = game.actors.get(actorId);
-      actor.tmrApp.forceDemiRevePosition(coord);
+      actor.tmrApp.positionnerDemiReve(coord);
     });
     // Gestion spécifique des sorts en réserve multiples (ie têtes)
     html.on("click", '#sort-reserve', event => {
@@ -692,7 +694,7 @@ export class RdDUtility {
       actor.tmrApp.lancerSortEnReserve(coord, sortId);
     });
 
-    // gestion bouton tchat Acheter
+    // gestion bouton tchat Possession
     html.on("click", '.defense-possession', event => {
       let attackerId = event.currentTarget.attributes['data-attackerId'].value
       let defenderId = event.currentTarget.attributes['data-defenderId'].value
@@ -702,6 +704,7 @@ export class RdDUtility {
 
     // gestion bouton tchat Acheter
     html.on("click", '.button-acheter', event => DialogItemAchat.onButtonAcheter(event));
+    html.on("click", '.button-creer-acteur', event => RdDNameGen.onCreerActeur(event));
 
     // Gestion du bouton payer
     html.on("click", '.payer-button', event => {
@@ -874,7 +877,7 @@ export class RdDUtility {
         label: "Annuler"
       }
     }
-    const docData = Misc.data(objet);
+    const docData = objet
     if (docData.type == 'conteneur' && docData.data.contenu.length > 0) {
       msgTxt += "<br>Ce conteneur n'est pas vide. Choisissez l'option de suppression";
       buttons['deleteall'] = {

module/rolldata-ajustements.js

@@ -19,9 +19,9 @@ import { ReglesOptionelles } from "./regles-optionelles.js";
  */
 export const referenceAjustements = {
   competence: {
-    isUsed: (rollData, actor) => Misc.data(rollData.competence),
-    getLabel: (rollData, actor) => Misc.data(rollData.competence)?.name,
-    getValue: (rollData, actor) => Misc.data(rollData.competence)?.data?.niveau,
+    isUsed: (rollData, actor) => rollData.competence,
+    getLabel: (rollData, actor) => rollData.competence?.name,
+    getValue: (rollData, actor) => rollData.competence?.system?.niveau,
   },
   meditation: {
     isUsed: (rollData, actor) => rollData.meditation,
@@ -33,7 +33,7 @@ export const referenceAjustements = {
     getLabel: (rollData, actor) => rollData.selectedSort?.name ?? rollData.attackerRoll ? 'Imposée' : 'Libre',
     getValue: (rollData, actor) => rollData.selectedSort
       ? RdDItemSort.getDifficulte(rollData.selectedSort, rollData.diffLibre)
-      : rollData.diffLibre ?? Misc.data(rollData.competence)?.data.default_diffLibre ?? 0
+      : rollData.diffLibre ?? rollData.competence?.data.default_diffLibre ?? 0
   },
   diffConditions: {
     isUsed: (rollData, actor) => rollData.diffConditions != undefined,
@@ -95,10 +95,10 @@ export const referenceAjustements = {
     getDescr: (rollData, actor) => rollData.diviseurSignificative > 1 ? `Facteur significative <span class="rdd-diviseur">&times;${Misc.getFractionHtml(rollData.diviseurSignificative)}</span>` : ''
   },
   isEcaille: {
-    isVisible: (rollData, actor) => Misc.data(rollData.arme)?.data.magique && Number(Misc.data(rollData.arme)?.data.ecaille_efficacite) > 0,
-    isUsed: (rollData, actor) => Misc.data(rollData.arme)?.data.magique && Number(Misc.data(rollData.arme)?.data.ecaille_efficacite) > 0,
+    isVisible: (rollData, actor) => rollData.arme?.system.magique && Number(rollData.arme?.system.ecaille_efficacite) > 0,
+    isUsed: (rollData, actor) => rollData.arme?.system.magique && Number(rollData.arme?.system.ecaille_efficacite) > 0,
     getLabel: (rollData, actor) => "Ecaille d'Efficacité: ",
-    getValue: (rollData, actor) => Math.max(Number(Misc.data(rollData.arme)?.data.ecaille_efficacite), 0),
+    getValue: (rollData, actor) => Math.max(Number(rollData.arme?.system.ecaille_efficacite), 0),
   },
   finesse: {
     isUsed: (rollData, actor) => RdDBonus.isDefenseAttaqueFinesse(rollData),

module/tmr-rencontres.js

@@ -8,9 +8,14 @@ import { TMRType } from "./tmr-utility.js";
 const typeRencontres = {
 
   messager: {
-    msgSucces: (rencData) => `Le ${rencData.rencontre.name} vous propose d'emmener le message de votre un sort à ${rencData.rencontre.force} cases ${rencData.tmr.label}.`,
-    msgEchec: (rencData) => `Le ${rencData.rencontre.name} est pressé et continue son chemin d'une traite sans vous accorder un regard.`,
-    postSucces: (tmrDialog, rencData) => {
+    msgSucces: async (rencData) => {
+      if (rencData.actor.isTMRCache()){
+        return `Le ${rencData.rencontre.name} vous propose d'emmener le message de votre un sort,  mais vous ne savez pas où vous êtes.`;
+      }
+      return `Le ${rencData.rencontre.name} vous propose d'emmener le message de votre un sort à ${rencData.rencontre.force} cases ${rencData.tmr.label}.`;
+    },
+    msgEchec: async (rencData)=> `Le ${rencData.rencontre.name} est pressé et continue son chemin d'une traite sans vous accorder un regard.`,
+    postSucces: async (tmrDialog, rencData) => {
       tmrDialog.setStateRencontre(rencData.rencontre.type);
       tmrDialog.choisirCasePortee(rencData.tmr.coord, rencData.rencontre.force);
     },
@@ -28,9 +33,14 @@ const typeRencontres = {
   },
 
   passeur: {
-    msgSucces: (rencData) => `Le ${rencData.rencontre.name} vous propose de vous transporter à ${rencData.rencontre.force} cases des ${rencData.tmr.label}.`,
-    msgEchec: (rencData) => `Le prix que demande le ${rencData.rencontre.name} est trop élevé, vous êtes réduit à poursuivre votre chemin par vos propres moyens.`,
-    postSucces: (tmrDialog, rencData) => {
+    msgSucces: async (rencData) => {
+      if (rencData.actor.isTMRCache()){
+        return `Le ${rencData.rencontre.name} vous propose de vous transporter, mais vous ne savez pas où vous êtes.`;
+      }
+      return `Le ${rencData.rencontre.name} vous propose de vous transporter à ${rencData.rencontre.force} cases des ${rencData.tmr.label}.`;
+    },
+    msgEchec: async (rencData)=> `Le prix que demande le ${rencData.rencontre.name} est trop élevé, vous êtes réduit à poursuivre votre chemin par vos propres moyens.`,
+    postSucces: async (tmrDialog, rencData) => {
       tmrDialog.setStateRencontre(rencData.rencontre.type);
       tmrDialog.choisirCasePortee(rencData.tmr.coord, rencData.rencontre.force);
     },
@@ -49,9 +59,9 @@ const typeRencontres = {
   },
 
   fleur: {
-    msgSucces: (rencData) => `Vous cueillez la ${rencData.rencontre.name}, son parfum vous apporte ${rencData.rencontre.force} points de Rêve.`,
-    msgEchec: (rencData) => `La ${rencData.rencontre.name} se fâne et disparaît entre vos doigts.`,
-    postSucces: (tmrDialog, rencData) => tmrDialog.actor.reveActuelIncDec(rencData.rencontre.force),
+    msgSucces: async (rencData) => `Vous cueillez la ${rencData.rencontre.name}, son parfum vous apporte ${rencData.rencontre.force} points de Rêve.`,
+    msgEchec: async (rencData)=> `La ${rencData.rencontre.name} se fâne et disparaît entre vos doigts.`,
+    postSucces: async (tmrDialog, rencData) => tmrDialog.actor.reveActuelIncDec(rencData.rencontre.force),
     poesieSucces: {
       reference: "L'Ennemi, Charles Baudelaire",
       extrait: `Et qui sait si les fleurs nouvelles que je rêve
@@ -66,9 +76,9 @@ const typeRencontres = {
   },
 
   mangeur: {
-    msgSucces: (rencData) => `Le ${rencData.rencontre.name} claque de sa machoire dans le vide avant de fuir.`,
-    msgEchec: (rencData) => `Le ${rencData.rencontre.name} croque votre Rêve ! Il emporte ${rencData.rencontre.force} de vos points de rêve actuels`,
-    postEchec: (tmrDialog, rencData) => tmrDialog.actor.reveActuelIncDec(-rencData.rencontre.force),
+    msgSucces: async (rencData) => `Le ${rencData.rencontre.name} claque de sa machoire dans le vide avant de fuir.`,
+    msgEchec: async (rencData)=> `Le ${rencData.rencontre.name} croque votre Rêve ! Il emporte ${rencData.rencontre.force} de vos points de rêve actuels`,
+    postEchec: async (tmrDialog, rencData) => tmrDialog.actor.reveActuelIncDec(-rencData.rencontre.force),
     poesieSucces: {
       reference: "Conseil, Victor Hugo",
       extrait: `Rois ! la bure est souvent jalouse du velours.
@@ -85,16 +95,17 @@ const typeRencontres = {
   },
 
   changeur: {
-    msgSucces: (rencData) => `Le ${rencData.rencontre.name} vaincu accepte de vous déplacer sur une autre ${TMRType[rencData.tmr.type].name} de votre choix en échange de sa liberté.`,
-    msgEchec: (rencData) => {
-      rencData.newTMR = TMRUtility.getTMRAleatoire(it => it.type = rencData.tmr.type);
-      return `Le ${rencData.rencontre.name} vous embobine avec des promesses, et vous transporte en ${rencData.newTMR.label} sans attendre votre avis.`;
-    },
-    postSucces: (tmrDialog, rencData) => {
+    msgSucces: async (rencData) => `Le ${rencData.rencontre.name} vaincu accepte de vous déplacer sur une autre ${TMRType[rencData.tmr.type].name} de votre choix en échange de sa liberté.`,
+    msgEchec: async (rencData) => `Le ${rencData.rencontre.name} vous embobine avec des promesses, et vous transporte sur une autre ${TMRType[rencData.tmr.type].name} sans attendre votre avis.`,
+    postSucces: async (tmrDialog, rencData) => {
       tmrDialog.setStateRencontre(rencData.rencontre.type);
       tmrDialog.choisirCaseType(rencData.tmr.type);
     },
-    postEchec: (tmrDialog, rencData) => tmrDialog.forceDemiRevePosition(rencData.newTMR.coord),
+    postEchec: async (tmrDialog, rencData) => {
+      const newTMR = await TMRUtility.getTMRAleatoire(it => it.type == rencData.tmr.type && it.coord != rencData.tmr.coord);
+      await tmrDialog.actor.forcerPositionTMRInconnue(newTMR);
+      tmrDialog.positionnerDemiReve(newTMR.coord);
+    },
     poesieSucces: {
       reference: "Caligula - IIIème chant, Gérard de Nerval",
       extrait: `Allez, que le caprice emporte
@@ -111,9 +122,9 @@ const typeRencontres = {
   },
 
   briseur: {
-    msgSucces: (rencData) => `Le ${rencData.rencontre.name} tente vainement de vous déconcentrer, avant de fuir sans demander son reste.`,
-    msgEchec: (rencData) => `Le ${rencData.rencontre.name} vous déconcentre au point de briser votre demi-rêve.`,
-    postEchec: (tmrDialog, rencData) => tmrDialog.close(),
+    msgSucces: async (rencData) => `Le ${rencData.rencontre.name} tente vainement de vous déconcentrer, avant de fuir sans demander son reste.`,
+    msgEchec: async (rencData)=> `Le ${rencData.rencontre.name} vous déconcentre au point de briser votre demi-rêve.`,
+    postEchec: async (tmrDialog, rencData) => tmrDialog.close(),
     poesieSucces: {
       reference: "Rêve de Dragon, Denis Gerfaud",
       extrait: `La légende affirme que ce sont les Gnomes qui furent
@@ -134,8 +145,8 @@ const typeRencontres = {
   },
 
   reflet: {
-    msgSucces: (rencData) => `Le ${rencData.rencontre.name} s'estompe dans l'oubli.`,
-    msgEchec: (rencData) => `Vous êtes submergé par un ${rencData.rencontre.name}, les souvenirs vous retiennent tant qu'il ne sera pas vaincu!`,
+    msgSucces: async (rencData) => `Le ${rencData.rencontre.name} s'estompe dans l'oubli.`,
+    msgEchec: async (rencData)=> `Vous êtes submergé par un ${rencData.rencontre.name}, les souvenirs vous retiennent tant qu'il ne sera pas vaincu!`,
     poesieSucces: {
       reference: "Une charogne, Charles Baudelaire",
       extrait: `Les formes s'effaçaient et n'étaient plus qu'un rêve,
@@ -152,9 +163,9 @@ const typeRencontres = {
   },
 
   passeurfou: {
-    msgSucces: (rencData) => `Le ${rencData.rencontre.name} tente vainement de découvrir où vous avez caché vos réserves. Vous le chassez, et en déroute il part harceler un autre voyageur du rêve.`,
-    msgEchec: (rencData) => TMRRencontres.msgEchecPasseurFou(rencData),
-    postEchec: (tmrDialog, rencData) => TMRRencontres.postEchecPasseurFou(tmrDialog, rencData),
+    msgSucces: async (rencData) => `Le ${rencData.rencontre.name} tente vainement de découvrir où vous avez caché vos réserves. Vous le chassez, et en déroute il part harceler un autre voyageur du rêve.`,
+    msgEchec: async (rencData)=> TMRRencontres.msgEchecPasseurFou(rencData),
+    postEchec: async (tmrDialog, rencData) => TMRRencontres.postEchecPasseurFou(tmrDialog, rencData),
     poesieSucces: {
       reference: "Un Fou et un Sage, Jean de La Fontaine",
       extrait: `Certain Fou poursuivait à coups de pierre un Sage.
@@ -174,9 +185,9 @@ const typeRencontres = {
   },
 
   tbblanc: {
-    msgSucces: (rencData) => `Le ${rencData.rencontre.name} souleve une poussière blanche, vous tenez bon, et il tourbillonne en s'éloignant.`,
-    msgEchec: (rencData) => `Le souffle du ${rencData.rencontre.name} vous déstabilise et vous emmène dans un nuage de poussière.`,
-    postEchec: (tmrDialog, rencData) => TMRRencontres.onPostEchecTourbillon(tmrDialog, rencData, 1),
+    msgSucces: async (rencData) => `Le ${rencData.rencontre.name} souleve une poussière blanche, vous tenez bon, et il tourbillonne en s'éloignant.`,
+    msgEchec: async (rencData)=> `Le souffle du ${rencData.rencontre.name} vous déstabilise et vous emmène dans un nuage de poussière.`,
+    postEchec: async (tmrDialog, rencData) => TMRRencontres.onPostEchecTourbillon(tmrDialog, rencData, 1),
     poesieSucces: {
       reference: "Rêve de Dragon, Denis Gerfaud",
       extrait: `Le Premier Âge fut appelé l'Âge des Dragons. Ce fut le commencement
@@ -191,9 +202,9 @@ const typeRencontres = {
   },
 
   tbnoir: {
-    msgSucces: (rencData) => `Le ${rencData.rencontre.name} orageux vous enveloppe de fureur et d'éclairs, vous tenez bon face à la tempête qui s'éloigne sans vous éloigner de votre chemin.`,
-    msgEchec: (rencData) => `Le ${rencData.rencontre.name} furieux vous secoue tel un fichu de paille malmené par les vents, et vous emporte dans la tourmente.`,
-    postEchec: (tmrDialog, rencData) => TMRRencontres.onPostEchecTourbillon(tmrDialog, rencData, 2),
+    msgSucces: async (rencData) => `Le ${rencData.rencontre.name} orageux vous enveloppe de fureur et d'éclairs, vous tenez bon face à la tempête qui s'éloigne sans vous éloigner de votre chemin.`,
+    msgEchec: async (rencData)=> `Le ${rencData.rencontre.name} furieux vous secoue tel un fichu de paille malmené par les vents, et vous emporte dans la tourmente.`,
+    postEchec: async (tmrDialog, rencData) => TMRRencontres.onPostEchecTourbillon(tmrDialog, rencData, 2),
     poesieSucces: {
       reference: "Rêve de Dragon, Denis Gerfaud",
       extrait: `Car le Second Âge fut bel et bien celui des Magiciens. Durant cette période, les
@@ -207,9 +218,9 @@ const typeRencontres = {
   },
 
   tbrouge: {
-    msgSucces: (rencData) => `Le ${rencData.rencontre.name} s'abat avec violence mais vous êtes plus rapide et parvenez à lui échapper.`,
-    msgEchec: (rencData) => `Le ${rencData.rencontre.name} vous frappe de milliers de morsure et vous malmène à travers les terres médianes.`,
-    postEchec: (tmrDialog, rencData) => TMRRencontres.onPostEchecTourbillonRouge(tmrDialog, rencData),
+    msgSucces: async (rencData) => `Le ${rencData.rencontre.name} s'abat avec violence mais vous êtes plus rapide et parvenez à lui échapper.`,
+    msgEchec: async (rencData)=> `Le ${rencData.rencontre.name} vous frappe de milliers de morsure et vous malmène à travers les terres médianes.`,
+    postEchec: async (tmrDialog, rencData) => TMRRencontres.onPostEchecTourbillonRouge(tmrDialog, rencData),
     poesieSucces: {
       reference: "Qu'est-ce de votre vie ? une bouteille molle, Jean-Baptiste Chassignet",
       extrait: `Qu'est-ce de votre vie ? un tourbillon rouant
@@ -228,10 +239,10 @@ const typeRencontres = {
   },
 
   rdd: {
-    msgSucces: (rencData) => `A tout seigneur, tout honneur, vous faites face à un ${rencData.rencontre.name}. Vous le maîtrisez et récupérez ses rêves. Vous gagnez ses ${rencData.rencontre.force} points de rêve`,
-    msgEchec: (rencData) => `A tout seigneur, tout honneur, vous faites face à un ${rencData.rencontre.name}. La rencontre tourne au cauchemar, dans la lutte épique, vous subissez ${rencData.rolled.isETotal ? 'deux queues' : 'une queue'} de dragon!`,
-    postSucces: (tmrDialog, rencData) => TMRRencontres.onPostSuccessReveDeDragon(tmrDialog, rencData),
-    postEchec: (tmrDialog, rencData) => TMRRencontres.onPostEchecReveDeDragon(tmrDialog, rencData),
+    msgSucces: async (rencData) => `A tout seigneur, tout honneur, vous faites face à un ${rencData.rencontre.name}. Vous le maîtrisez et récupérez ses rêves. Vous gagnez ses ${rencData.rencontre.force} points de rêve`,
+    msgEchec: async (rencData)=> `A tout seigneur, tout honneur, vous faites face à un ${rencData.rencontre.name}. La rencontre tourne au cauchemar, dans la lutte épique, vous subissez ${rencData.rolled.isETotal ? 'deux queues' : 'une queue'} de dragon!`,
+    postSucces: async (tmrDialog, rencData) => TMRRencontres.onPostSuccessReveDeDragon(tmrDialog, rencData),
+    postEchec: async (tmrDialog, rencData) => TMRRencontres.onPostEchecReveDeDragon(tmrDialog, rencData),
     poesieSucces: {
       reference: "Rêve de Dragon, Denis Gerfaud",
       extrait: `Le monde est Rêve de Dragons, mais nous ne savons
@@ -404,7 +415,7 @@ export class TMRRencontres {
   static async gererRencontre(tmrDialog, rencData) {
     let gestion = TMRRencontres.getGestionRencontre(rencData.rencontre.type);
     if (rencData.rolled.isSuccess) {
-      rencData.message = gestion.msgSucces(rencData);
+      rencData.message = await gestion.msgSucces(rencData);
       if (rencData.nbRounds > 1) {
         rencData.message += ` Au total, vous avez passé ${rencData.nbRounds} rounds à vous battre!`;
       }
@@ -412,7 +423,7 @@ export class TMRRencontres {
       return gestion.postSucces;
     }
 
-    rencData.message = gestion.msgEchec(rencData);
+    rencData.message = await gestion.msgEchec(rencData);
     if (rencData.nbRounds > 1) {
       rencData.message += ` Vous avez passé ${rencData.nbRounds} rounds à lutter!`;
     }
@@ -422,7 +433,7 @@ export class TMRRencontres {
 
   /* -------------------------------------------- */
   static async msgEchecPasseurFou(tmrData) {
-    tmrData.sortReserve = Misc.templateData(tmrData.actor).reve.reserve.list[0];
+    tmrData.sortReserve = tmrData.actor.system.reve.reserve.list[0];
     if (tmrData.sortReserve) {
       // Passeur fou positionne sur la case d'un ort en réserve // TODO : Choisir le sort le plus loin ou au hasard
       tmrData.newTMR = TMRUtility.getTMR(tmrData.sortReserve.coord);
@@ -444,7 +455,7 @@ export class TMRRencontres {
     if (tmrData.sortReserve) {
       await tmrDialog.processSortReserve(tmrData.sortReserve);
     }
-    await tmrDialog.forceDemiRevePosition(tmrData.newTMR.coord);
+    await tmrDialog.positionnerDemiReve(tmrData.newTMR.coord);
     if (tmrData.sortReserve) {
       tmrDialog.close();
     }
@@ -465,11 +476,11 @@ export class TMRRencontres {
 
   /* -------------------------------------------- */
   static async _toubillonner(tmrDialog, actor, cases) {
-    let coord = Misc.templateData(actor).reve.tmrpos.coord;
+    let coord = actor.system.reve.tmrpos.coord;
     for (let i = 0; i < cases; i++) {
       coord = await TMRUtility.deplaceTMRAleatoire(actor, coord).coord;
     }
-    await tmrDialog.forceDemiRevePosition(coord)
+    await tmrDialog.positionnerDemiReve(coord)
   }
 
   /* -------------------------------------------- */

module/tmr-utility.js

@@ -2,7 +2,6 @@ import { TMRRencontres } from "./tmr-rencontres.js";
 import { Misc } from "./misc.js";
 import { Grammar } from "./grammar.js";
 import { RdDDice } from "./rdd-dice.js";
-import { tmrConstants } from "./tmr-constants.js";
 
 /* -------------------------------------------- */
 const TMRMapping = {
@@ -12,7 +11,7 @@ const TMRMapping = {
   D1: { type: "fleuve", label: "Fleuve de l'Oubli" },
   E1: { type: "monts", label: "Monts de Kanaï" },
   F1: { type: "cite", label: "Cité Glauque" },
-  G1: { type: "desolation", label: "Désolation de Demain" },
+  G1: { type: "desolation", label: "Désolation de Jamais" },
   H1: { type: "lac", label: "Lac d’Anticalme" },
   I1: { type: "plaines", label: "Plaines Grises" },
   J1: { type: "monts", label: "Monts Fainéants" },
@@ -70,7 +69,7 @@ const TMRMapping = {
   F5: { type: "cite", label: "Cité de Panople" },
   G5: { type: "pont", label: "Pont d’Ik" },
   H5: { type: "desert", label: "Désert de Krane" },
-  I5: { type: "desolation", label: "Désolation de Demain" },
+  I5: { type: "desolation", label: "Désolation de Toujours" },
   J5: { type: "marais", label: "Marais de Jab" },
   K5: { type: "fleuve", label: "Fleuve de l'Oubli" },
   L5: { type: "collines", label: "Collines Suaves" },
@@ -86,9 +85,9 @@ const TMRMapping = {
   H6: { type: "monts", label: "Monts Gurdes" },
   I6: { type: "necropole", label: "Nécropole de Xotar" },
   J6: { type: "lac", label: "Lac d’Iaupe" },
-  K6: { type: "desolation", label: "Désolation de Demain" },
+  K6: { type: "desolation", label: "Désolation de Poor" },
   L6: { type: "foret", label: "Forêt Gueuse" },
-  M6: { type: "desolation", label: "Désolation de Demain" },
+  M6: { type: "desolation", label: "Désolation de Presque" },
 
   A7: { type: "plaines", label: "Plaines de l’Arc" },
   B7: { type: "marais", label: "Marais Bluants" },
@@ -124,7 +123,7 @@ const TMRMapping = {
   D9: { type: "pont", label: "Pont d’Orx" },
   E9: { type: "fleuve", label: "Fleuve de l'Oubli" },
   F9: { type: "plaines", label: "Plaines de Foe" },
-  G9: { type: "desolation", label: "Désolation de Demain" },
+  G9: { type: "desolation", label: "Désolation de Sel" },
   H9: { type: "collines", label: "Collines de Noirseul" },
   I9: { type: "fleuve", label: "Fleuve de l'Oubli" },
   J9: { type: "marais", label: "Marais Gronchants" },
@@ -146,10 +145,10 @@ const TMRMapping = {
   L10: { type: "desert", label: "Désert de Nicrop" },
   M10: { type: "foret", label: "Forêt de Jajou" },
 
-  A11: { type: "desolation", label: "Désolation de Demain" },
+  A11: { type: "desolation", label: "Désolation d’Hier" },
   B11: { type: "cite", label: "Cité de Brilz" },
   C11: { type: "pont", label: "Pont de Roï" },
-  D11: { type: "desolation", label: "Désolation de Demain" },
+  D11: { type: "desolation", label: "Désolation de Partout" },
   E11: { type: "lac", label: "Lac de Glinster" },
   F11: { type: "cite", label: "Cité de Noape" },
   G11: { type: "fleuve", label: "Fleuve de l'Oubli" },
@@ -170,7 +169,7 @@ const TMRMapping = {
   H12: { type: "collines", label: "Collines de Tooth" },
   I12: { type: "gouffre", label: "Gouffre Abimeux" },
   J12: { type: "cite", label: "Cité Folle" },
-  K12: { type: "desolation", label: "Désolation de Demain" },
+  K12: { type: "desolation", label: "Désolation d’Amour" },
   L12: { type: "plaines", label: "Plaines Venteuses" },
   M12: { type: "collines", label: "Collines Révulsantes" },
 
@@ -181,7 +180,7 @@ const TMRMapping = {
   E13: { type: "plaines", label: "Plaines de Xnez" },
   F13: { type: "foret", label: "Forêt des Cris" },
   G13: { type: "plaines", label: "Plaines Calcaires" },
-  H13: { type: "desolation", label: "Désolation de Demain" },
+  H13: { type: "desolation", label: "Désolation de Rien" },
   I13: { type: "monts", label: "Monts Bigleux" },
   J13: { type: "gouffre", label: "Gouffre de Gromph" },
   K13: { type: "foret", label: "Forêt de Kluth" },
@@ -200,8 +199,8 @@ const TMRMapping = {
   J14: { type: "desert", label: "Désert de Sank" },
   K14: { type: "necropole", label: "Nécropole d’Antinéar" },
   L14: { type: "plaines", label: "Plaines de Jislith" },
-  M14: { type: "desolation", label: "Désolation de Demain" },
-
+  M14: { type: "desolation", label: "Désolation d’Après" },
+  
   A15: { type: "cite", label: "Cité de Mielh" },
   C15: { type: "plaines", label: "Plaines de Toué" },
   E15: { type: "foret", label: "Forêt des Furies" },

module/tmr/conquete.js

@@ -32,14 +32,14 @@ export class Conquete extends Draconique {
   }
 
   async _creerConquete(actor, queue) {
-    let existants = actor.data.items.filter(it => this.isCase(it)).map(it => Misc.data(it).data.coord);
+    let existants = actor.items.filter(it => this.isCase(it)).map(it => it.system.coord);
     let possibles = TMRUtility.filterTMR(tmr => !TMRUtility.isCaseHumide(tmr) && !existants.includes(tmr.coord));
     let conquete = await RdDDice.rollOneOf(possibles);
     await this.createCaseTmr(actor, 'Conquête: ' + conquete.label, conquete, queue.id);
   }
 
   async onActorDeleteCaseTmr(actor, casetmr) {
-    await actor.deleteEmbeddedDocuments('Item', [casetmr.data.sourceid]);
+    await actor.deleteEmbeddedDocuments('Item', [casetmr.system.sourceid]);
   }
 
 }

module/tmr/debordement.js

@@ -13,7 +13,7 @@ export class Debordement extends Draconique {
   match(item) { return Draconique.isSouffleDragon(item) && Grammar.toLowerCaseNoAccent(item.name).includes('debordement'); }
   manualMessage() { return false }
   async onActorCreateOwned(actor, souffle) {
-    const existants = actor.data.items.filter(it => this.isCase(it)).map(it => it.data.coord);
+    const existants = actor.items.filter(it => this.isCase(it)).map(it => it.system.coord);
     const tmr = await TMRUtility.getTMRAleatoire(it => !(TMRUtility.isCaseHumide(it) || existants.includes(it.coord)));
     await this.createCaseTmr(actor, 'Debordement: ' + tmr.label, tmr, souffle.id);
   }

module/tmr/desorientation.js

@@ -22,7 +22,7 @@ export class Desorientation extends Draconique {
   }
 
   _typesPossibles(actor) {
-    const dejaDesorientes = Misc.distinct(actor.data.items.filter(it => this.isCase(it)).map(it => it.type));
+    const dejaDesorientes = Misc.distinct(actor.items.filter(it => this.isCase(it)).map(it => it.type));
     return Object.keys(TMRType).filter(it => !dejaDesorientes.includes(it));
   }
 
@@ -42,7 +42,7 @@ export class Desorientation extends Draconique {
   }
 
   async _creerCasesTmr(actor, type, souffle) {
-    const existants = actor.data.items.filter(it => this.isCase(it)).map(it => it.data.coord);
+    const existants = actor.items.filter(it => this.isCase(it)).map(it => it.system.coord);
     let tmrs = TMRUtility.filterTMR(it => it.type == type && !existants.includes(it.coord));
     for (let tmr of tmrs) {
       await this.createCaseTmr(actor, 'Désorientation: ' + tmr.label, tmr, souffle.id);

module/tmr/draconique.js

@@ -15,7 +15,7 @@ export class Draconique {
   static isTeteDragon(itemData) { return itemData.type == 'tete'; }
   static isQueueSouffle(itemData) { return Draconique.isQueueDragon(itemData) || Draconique.isSouffleDragon(itemData); }
 
-  tmrLabel(linkData) { return TMRUtility.getTMRLabel(linkData.data.coord); }
+  tmrLabel(linkData) { return TMRUtility.getTMRLabel(linkData.system.coord); }
 
   static register(draconique) {
     registeredEffects[draconique.code()] = draconique;
@@ -38,7 +38,7 @@ export class Draconique {
    * @returns true si l'item correspond
    */
   match(item) {
-    const itemData = Misc.data(item);
+    const itemData = item;
     return Draconique.isQueueDragon(itemData) || Draconique.isSouffleDragon(itemData) || Draconique.isTeteDragon(itemData);
   }
 
@@ -94,9 +94,8 @@ export class Draconique {
     token[type ?? this.code()] = linkData;
     pixiTMR.addTooltip(token.sprite, this.tooltip(linkData));
     return token;
-
-    return sprite;
   }
+
   /**
    * factory d'élément graphique PIXI correpsondant à l'objet draconique
    * @param {*} pixiTMR instance de PixiTMR qui gère les tooltips, les méthodes de création de sprite standard, les clicks.
@@ -116,34 +115,32 @@ export class Draconique {
    * @param {*} coord les coordonnées d'une case. Si undefined toute case du type correspondra, 
    */
   isCase(item, coord = undefined) {
-    const itemData = Misc.data(item);
-    return Draconique.isCaseTMR(itemData) && itemData.data.specific == this.code() && (coord ? itemData.data.coord == coord : true);
+    return Draconique.isCaseTMR(item) && item.system.specific == this.code() && (coord ? item.system.coord == coord : true);
   }
   
   find(list, coord = undefined) {
-    return list.find(c => this.isCase(Misc.data(c), coord));
+    return list.find(c => this.isCase(c, coord));
   }
   
   async createCaseTmr(actor, label, tmr, sourceId = undefined) {
     const casetmrData = {
       name: label, type: 'casetmr', img: this.img(),
-      data: { coord: tmr.coord, specific: this.code(), sourceid: sourceId }
+      system: { coord: tmr.coord, specific: this.code(), sourceid: sourceId }
     };
     await actor.createEmbeddedDocuments('Item', [casetmrData]);
   }
   
   async deleteCasesTmr(actor, draconique) {
-    let caseTmrs = actor.data.items.filter(it => this.isCaseForSource(it, draconique));
+    let caseTmrs = actor.items.filter(it => this.isCaseForSource(it, draconique));
     await actor.deleteEmbeddedDocuments('Item', caseTmrs.map(it => it.id));
   }
   
   isCaseForSource(item, draconique) {
-    const itemData = Misc.data(item);
-    return Draconique.isCaseTMR(itemData) && itemData.data.specific == this.code() && itemData.data.sourceid == draconique.id;
+    return Draconique.isCaseTMR(item) && item.system.specific == this.code() && item.system.sourceid == draconique.id;
   }
 
   async onVisiteSupprimer(actor, tmr, onRemoveToken) {
-    let existants = actor.data.items.filter(it => this.isCase(it, tmr.coord));
+    let existants = actor.items.filter(it => this.isCase(it, tmr.coord));
     await actor.deleteEmbeddedDocuments('Item', existants.map(it => it.id));
     for (let casetmr of existants) {
       onRemoveToken(tmr, casetmr);

module/tmr/effets-draconiques.js

@@ -95,7 +95,7 @@ export class EffetsDraconiques {
 
   /* -------------------------------------------- */
   static isSortImpossible(actor) {
-    return actor.data.items.find(it =>
+    return actor.items.find(it =>
       EffetsDraconiques.conquete.match(it) ||
       EffetsDraconiques.periple.match(it) ||
       EffetsDraconiques.urgenceDraconique.match(it) ||
@@ -104,7 +104,7 @@ export class EffetsDraconiques {
   }
 
   static isSortReserveImpossible(actor) {
-    return actor.data.items.find(it =>
+    return actor.items.find(it =>
       EffetsDraconiques.conquete.match(it) ||
       EffetsDraconiques.periple.match(it) ||
       EffetsDraconiques.pelerinage.match(it)
@@ -112,7 +112,7 @@ export class EffetsDraconiques {
   }
 
   static filterItems(actor, filter, name) {
-    return actor.data.items.filter(filter)
+    return actor.filter(filter)
       .filter(it => Grammar.includesLowerCaseNoAccent(it.name, name));
   }
 
@@ -150,11 +150,11 @@ export class EffetsDraconiques {
   }
 
   static isPontImpraticable(actor) {
-    return actor.data.items.find(it => EffetsDraconiques.pontImpraticable.match(it));
+    return actor.items.find(it => EffetsDraconiques.pontImpraticable.match(it));
   }
 
   static isUrgenceDraconique(actor) {
-    return actor.data.items.find(it => EffetsDraconiques.urgenceDraconique.match(it));
+    return actor.items.find(it => EffetsDraconiques.urgenceDraconique.match(it));
   }
 
   static isPeage(actor) {

module/tmr/fermeture-cites.js

@@ -30,7 +30,7 @@ export class FermetureCites extends Draconique {
   }
 
   async _fermerLesCites(actor, souffle) {
-    let existants = actor.data.items.filter(it => this.isCase(it)).map(it => it.data.coord);
+    let existants = actor.items.filter(it => this.isCase(it)).map(it => it.system.coord);
     let ouvertes = TMRUtility.filterTMR(it => it.type == 'cite' && !existants.includes(it.coord));
     for (let tmr of ouvertes) {
       await this.createCaseTmr(actor, 'Fermeture: ' + tmr.label, tmr, souffle.id);

module/tmr/pelerinage.js

@@ -33,7 +33,7 @@ export class Pelerinage extends Draconique {
   }
   
   async onActorDeleteCaseTmr(actor, casetmr) {
-    await actor.deleteEmbeddedDocuments('Item', [casetmr.data.sourceid]);
+    await actor.deleteEmbeddedDocuments('Item', [casetmr.system.sourceid]);
   }
 
 }

module/tmr/pixi-tmr.js

@@ -25,7 +25,7 @@ export class PixiTMR {
     for (const [name, img] of Object.entries(PixiTMR.textures)) {
       loader = loader.add(name, img);
     }
-    loader.onLoad.add((error, resaon) => { console.log("ERROR", error, resaon) });
+    loader.onLoad.add((error, reason) => { console.log("ERROR", error, reason) });
     loader.load( (loader, resources) =>  {
       onLoad(loader, resources);
       for (let onAnimate of this.callbacksOnAnimate) {

module/tmr/present-cites.js

@@ -30,7 +30,7 @@ export class PresentCites extends Draconique {
   }
 
   async _ajouterPresents(actor, tete) {
-    let existants = actor.data.items.filter(it => this.isCase(it)).map(it => it.data.coord);
+    let existants = actor.items.filter(it => this.isCase(it)).map(it => it.system.coord);
     if (existants.length > 0) {
       ChatMessage.create({
         whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),

module/tmr/reserve-extensible.js

@@ -12,8 +12,8 @@ export class ReserveExtensible extends Draconique {
   match(item) { return Draconique.isTeteDragon(item) && Grammar.toLowerCaseNoAccent(item.name).includes("reserve extensible"); }
   manualMessage() { return "Vous pouvez re-configurer votre Réserve extensible" }
   async onActorCreateOwned(actor, tete) {
-    const existants = actor.data.items.filter(it => this.isCase(it)).map(it => it.data.coord);
-    const tmr = await TMRUtility.getTMRAleatoire(it => !(it.type == 'fleuve' || existants.includes(it.coord)));
+    const existants = actor.items.filter(it => this.isCase(it)).map(it => it.system.coord);
+    const tmr = await TMRUtility.getTMRAleatoire(it => !(it.type == 'fleuve' || existants.includes(it.system.coord)));
     await this.createCaseTmr(actor, "Nouvelle Réserve extensible", tmr, tete.id);
   }
 

module/tmr/trou-noir.js

@@ -13,8 +13,8 @@ export class TrouNoir extends Draconique {
   manualMessage() { return false }
 
   async onActorCreateOwned(actor, souffle) {
-    const existants = actor.data.items.filter(it => this.isCase(it)).map(it => it.data.coord);
-    const tmr = await TMRUtility.getTMRAleatoire(it => !(TMRUtility.isCaseHumide(it) || existants.includes(it.coord)));
+    const existants = actor.items.filter(it => this.isCase(it)).map(it => it.system.coord);
+    const tmr = await TMRUtility.getTMRAleatoire(it => !(TMRUtility.isCaseHumide(it) || existants.includes(it.system.coord)));
     await this.createCaseTmr(actor, 'Trou noir: ' + tmr.label, tmr, souffle.id);
   }
 

module/tmr/urgence-draconique.js

@@ -16,7 +16,7 @@ export class UrgenceDraconique extends Draconique {
   match(item) { return Draconique.isQueueDragon(item) && Grammar.toLowerCaseNoAccent(item.name).includes('urgence draconique'); }
   manualMessage() { return false }
   async onActorCreateOwned(actor, queue) {
-    const coordSortsReserve = (Misc.templateData(actor).reve.reserve?.list.map(it => it.coord)) ?? [];
+    const coordSortsReserve = (actor.system.reve.reserve?.list.map(it => it.coord)) ?? [];
     if (coordSortsReserve.length == 0) {
       // La queue se transforme en idée fixe
       const ideeFixe = await RdDRollTables.getIdeeFixe();

system.json

@@ -1,38 +1,43 @@
 {
-  "name": "foundryvtt-reve-de-dragon",
+  "id": "foundryvtt-reve-de-dragon",
   "title": "Rêve de Dragon",
   "description": "Rêve de Dragon RPG for FoundryVTT",
-  "author": "LeRatierBretonnien",
   "authors": [
     {
-      "name": "LeRatierBretonnien"
+      "name": "LeRatierBretonnien",
+      "flags": {}
     },
     {
-      "name": "VincentVK"
+      "name": "VincentVK",
+      "flags": {}
     },
     {
-      "name": "Grendel"
+      "name": "Grendel",
+      "flags": {}
     },
     {
-      "name": "Michael Nonne"
+      "name": "Michael Nonne",
+      "flags": {}
     },
     {
-      "name": "Mandar"
+      "name": "Mandar",
+      "flags": {}
     },
     {
-      "name": "Fred"
+      "name": "Fred",
+      "flags": {}
     },
     {
-      "name": "Fab"
+      "name": "Fab",
+      "flags": {}
     }
   ],
   "url": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/",
   "license": "LICENSE.txt",
-  "flags": {},
-  "version": "1.5.75",
-  "minimumCoreVersion": "0.8.0",
-  "compatibleCoreVersion": "9",
-  "scripts": [],
+  "version": "10.0.6",
+  "compatibility": {
+    "minimum": "10"
+  },
   "esmodules": [
     "module/rdd-main.js"
   ],
@@ -44,12 +49,13 @@
       "lang": "en",
       "name": "English",
       "path": "lang/fr.json",
-      "unreal": "this is a trick"
+      "flags": {}
     },
     {
       "lang": "fr",
       "name": "Français",
-      "path": "lang/fr.json"
+      "path": "lang/fr.json",
+      "flags": {}
     }
   ],
   "packs": [
@@ -57,453 +63,278 @@
       "name": "competences",
       "label": "Compétences",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/competences.db",
+      "path": "packs/competences.db",
       "type": "Item",
-      "tags": [
-        "item",
-        "compétences"
-      ],
-      "entity": "Item",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "arts-et-divertissements",
       "label": "Arts et Divertissements",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/arts-et-divertissements.db",
+      "path": "packs/arts-et-divertissements.db",
       "type": "Item",
-      "tags": [
-        "recette",
-        "cuisine",
-        "danse",
-        "musique",
-        "chant",
-        "jeux"
-      ],
-      "entity": "Item",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "competences-creatures",
       "label": "Compétences de Créatures",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/competences-creatures.db",
+      "path": "packs/competences-creatures.db",
       "type": "Item",
-      "tags": [
-        "item",
-        "compétences",
-        "créatures"
-      ],
-      "entity": "Item",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "competences-entites",
       "label": "Compétences des Entités",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/competences-entites.db",
+      "path": "packs/competences-entites.db",
       "type": "Item",
-      "tags": [
-        "item",
-        "compétences",
-        "entités"
-      ],
-      "entity": "Item",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "sorts-oniros",
       "label": "Sorts d'Oniros",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/sorts-oniros.db",
+      "path": "packs/sorts-oniros.db",
       "type": "Item",
-      "tags": [
-        "item",
-        "sorts"
-      ],
-      "entity": "Item",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "sorts-hypnos",
       "label": "Sorts d'Hypnos",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/sorts-hypnos.db",
+      "path": "packs/sorts-hypnos.db",
       "type": "Item",
-      "tags": [
-        "item",
-        "sorts"
-      ],
-      "entity": "Item",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "sorts-narcos",
       "label": "Sorts de Narcos",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/sorts-narcos.db",
+      "path": "packs/sorts-narcos.db",
       "type": "Item",
-      "tags": [
-        "item",
-        "sorts"
-      ],
-      "entity": "Item",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "sorts-thanatos",
       "label": "Sorts de Thanatos",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/sorts-thanatos.db",
+      "path": "packs/sorts-thanatos.db",
       "type": "Item",
-      "tags": [
-        "item",
-        "sorts"
-      ],
-      "entity": "Item",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "equipement",
       "label": "Equipement",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/equipement.db",
+      "path": "packs/equipement.db",
       "type": "Item",
-      "tags": [
-        "item",
-        "équipement",
-        "objet"
-      ],
-      "entity": "Item",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "maladies-et-poisons",
       "label": "Maladies & Poisons",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/maladies-et-poisons.db",
+      "path": "packs/maladies-et-poisons.db",
       "type": "Item",
-      "tags": [
-        "maladie",
-        "poison"
-      ],
-      "entity": "Item",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "rappel-des-regles",
       "label": "Rappels des Règles",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/rappel-des-regles.db",
+      "path": "packs/rappel-des-regles.db",
       "type": "JournalEntry",
-      "tags": [
-        "journal",
-        "règles"
-      ],
-      "entity": "JournalEntry",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "queues-de-dragon",
       "label": "Queues de Dragon",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/queues-de-dragon.db",
+      "path": "packs/queues-de-dragon.db",
       "type": "Item",
-      "tags": [
-        "item",
-        "queue"
-      ],
-      "entity": "Item",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "ombres-de-thanatos",
       "label": "Ombres de Thanatos",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/ombres-de-thanatos.db",
+      "path": "packs/ombres-de-thanatos.db",
       "type": "Item",
-      "tags": [
-        "item",
-        "ombre"
-      ],
-      "entity": "Item",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "souffles-de-dragon",
       "label": "Souffles de Dragon",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/souffles-de-dragon.db",
+      "path": "packs/souffles-de-dragon.db",
       "type": "Item",
-      "tags": [
-        "item",
-        "souffle"
-      ],
-      "entity": "Item",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "tarot-draconique",
       "label": "Tarot Draconique",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/tarot-draconique.db",
+      "path": "packs/tarot-draconique.db",
       "type": "Item",
-      "tags": [
-        "item",
-        "tarot"
-      ],
-      "entity": "Item",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "tetes-de-dragon-pour-haut-revants",
       "label": "Têtes de Dragon (Hauts-Rêvants)",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/tetes-de-dragon-pour-haut-revants.db",
+      "path": "packs/tetes-de-dragon-pour-haut-revants.db",
       "type": "Item",
-      "tags": [
-        "item",
-        "tête"
-      ],
-      "entity": "Item",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "tetes-de-dragon-pour-tous-personnages",
       "label": "Têtes de Dragon (Tous Personnages)",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/tetes-de-dragon-pour-tous-personnages.db",
+      "path": "packs/tetes-de-dragon-pour-tous-personnages.db",
       "type": "Item",
-      "tags": [
-        "item",
-        "tête"
-      ],
-      "entity": "Item",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "tables-diverses",
       "label": "Tables Diverses",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/tables-diverses.db",
+      "path": "packs/tables-diverses.db",
       "type": "RollTable",
-      "tags": [
-        "table",
-        "tables"
-      ],
-      "entity": "RollTable",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "animaux",
       "label": "Animaux",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/animaux.db",
+      "path": "packs/animaux.db",
       "type": "Actor",
-      "tags": [
-        "animaux",
-        "creature"
-      ],
-      "entity": "Actor",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "voyageurs",
       "label": "Voyageurs",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/voyageurs.db",
+      "path": "packs/voyageurs.db",
       "type": "Actor",
-      "tags": [
-        "voyageur",
-        "profils"
-      ],
-      "entity": "Actor",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "vehicules",
       "label": "Véhicules",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/vehicules.db",
+      "path": "packs/vehicules.db",
       "type": "Actor",
-      "tags": [
-        "vehicule",
-        "bateau",
-        "charett",
-        "chariot",
-        "carriole",
-        "barque"
-      ],
-      "entity": "Actor",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "archetypes",
       "label": "Archetypes PNJs",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/archetypes.db",
+      "path": "packs/archetypes.db",
       "type": "Actor",
-      "tags": [
-        "archetype",
-        "pnj"
-      ],
-      "entity": "Actor",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "humanoides",
       "label": "Humanoïdes",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/humanoides.db",
+      "path": "packs/humanoides.db",
       "type": "Actor",
-      "tags": [
-        "humanoides",
-        "pnj"
-      ],
-      "entity": "Actor",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "entites",
       "label": "Entités de Cauchemar",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/entites-de-cauchemar.db",
+      "path": "packs/entites-de-cauchemar.db",
       "type": "Actor",
-      "tags": [
-        "entités",
-        "entite",
-        "cauchemar",
-        "ecni",
-        "eni"
-      ],
-      "entity": "Actor",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "invocations",
       "label": "Invocation d'Hypnos",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/invocations.db",
+      "path": "packs/invocations.db",
       "type": "Actor",
-      "tags": [
-        "hypnos",
-        "invocation"
-      ],
-      "entity": "Actor",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "botanique",
       "label": "Botanique",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/botanique.db",
+      "path": "packs/botanique.db",
       "type": "Item",
-      "tags": [
-        "plantes",
-        "champignons",
-        "herbes"
-      ],
-      "entity": "Item",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "taches-courantes",
       "label": "Tâches courantes",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/taches-courantes.db",
+      "path": "packs/taches-courantes.db",
       "type": "Item",
-      "tags": [
-        "taches"
-      ],
-      "entity": "Item",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "meditations-et-ecrits",
       "label": "Méditations et Ecrits",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/meditations-et-ecrits.db",
+      "path": "packs/meditations-et-ecrits.db",
       "type": "Item",
-      "tags": [
-        "meditations",
-        "méditations",
-        "livres",
-        "livre",
-        "méditation",
-        "écrits",
-        "écrit"
-      ],
-      "entity": "Item",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "recettes-alchimiques",
       "label": "Recettes Alchimiques",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/recettes-alchimiques.db",
+      "path": "packs/recettes-alchimiques.db",
       "type": "Item",
-      "tags": [
-        "recettes",
-        "recette",
-        "alchimie",
-        "alchimique",
-        "potion"
-      ],
-      "entity": "Item",
-      "private": false
+      "private": false,
+      "flags": {}
     },
     {
       "name": "scenes-rdd",
       "label": "Scenes Reve de Dragon",
       "system": "foundryvtt-reve-de-dragon",
-      "module": "foundryvtt-reve-de-dragon",
-      "path": "./packs/scenes-rdd.db",
+      "path": "packs/scenes-rdd.db",
       "type": "Scene",
-      "tags": [
-        "ecran",
-        "scene"
-      ],
-      "entity": "Scene",
-      "private": false
+      "private": false,
+      "flags": {}
     }
   ],
-  "system": [],
-  "dependencies": [],
   "socket": true,
-  "manifest": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/v1.5/system.json",
-  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-1.5.75.zip",
-  "protected": false,
+  "manifest": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/v10/system.json",
+  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-10.0.6.zip",
   "gridDistance": 1,
   "gridUnits": "m",
   "primaryTokenAttribute": "sante.vie",
   "secondaryTokenAttribute": "sante.endurance"
-}
+}

templates/actor-creature-sheet.html

@@ -44,18 +44,17 @@
             {{#each data.carac as |carac key|}}
             <li class="flexrow list-item" data-attribute="{{key}}">
               {{#if (eq key 'taille')}}
-              <span class="carac-label flexrow" name="data.carac.{{key}}.label">{{carac.label}}</span>
+              <span class="carac-label flexrow" name="system.carac.{{key}}.label">{{carac.label}}</span>
               {{else}}
-              <span class="carac-label flexrow" name="data.carac.{{key}}.label"><a
+              <span class="carac-label flexrow" name="system.carac.{{key}}.label"><a
                   name={{key}}>{{carac.label}}</a></span>
               {{/if}}
-              <input class="competence-value flexrow" type="text" name="data.carac.{{key}}.value"
+              <input class="competence-value flexrow" type="text" name="system.carac.{{key}}.value"
                 value="{{carac.value}}" data-dtype="{{carac.type}}" />
             </li>
             {{/each}}
             <li class="flexrow">
               <span class="carac-label" name="carac-total">Total Caractéristiques</span>
-              {{log 'data-actor-creature' this}}
               <span class="competence-value" name="carac-total-value">{{calc.caracTotal}}</span>
             </li>
           </ol>
@@ -64,26 +63,26 @@
           <ol class="carac-list alterne-list">
             {{#each data.attributs as |attr key|}}
             <li class="flexrow list-item" data-attribute="{{key}}">
-              <span class="carac-label" name="data.attributs.{{key}}.label">{{attr.label}}</span>
-              <input type="text" name="data.attributs.{{key}}.value" value="{{attr.value}}" data-dtype="{{attr.type}}" />
+              <span class="carac-label" name="system.attributs.{{key}}.label">{{attr.label}}</span>
+              <input type="text" name="system.attributs.{{key}}.value" value="{{attr.value}}" data-dtype="{{attr.type}}" />
             </li>
             {{/each}}
             <li class="flexrow list-item" data-attribute="vie">
               <span class="competence-label" name="data.sante.vie.label">Vie</span>
               <span class="flexrow" >
-                <input type="text" name="data.sante.vie.value" value="{{data.sante.vie.value}}" data-dtype="Number" /> / 
-                <input type="text" name="data.sante.vie.max" value="{{data.sante.vie.max}}" data-dtype="Number" />
+                <input type="text" name="system.sante.vie.value" value="{{data.sante.vie.value}}" data-dtype="Number" /> / 
+                <input type="text" name="system.sante.vie.max" value="{{data.sante.vie.max}}" data-dtype="Number" />
               </span>
             </li>
             <li class="flexrow list-item" data-attribute="endurance">
-              <span class="competence-label" name="data.sante.endurance.label">Endurance</span>
+              <span class="competence-label" name="system.sante.endurance.label">Endurance</span>
               <span class="flexrow" >
-                <input type="text" name="data.sante.endurance.value" value="{{data.sante.endurance.value}}" data-dtype="Number" /> / 
-                <input type="text" name="data.sante.endurance.max" value="{{data.sante.endurance.max}}" data-dtype="Number" />
+                <input type="text" name="system.sante.endurance.value" value="{{data.sante.endurance.value}}" data-dtype="Number" /> / 
+                <input type="text" name="system.sante.endurance.max" value="{{data.sante.endurance.max}}" data-dtype="Number" />
               </span>
             </li>
             <li class="flexrow list-item" data-attribute="etat">
-              <span class="competence-label" name="data.compteurs.etat.label">Etat Général</span>
+              <span class="competence-label" name="system.compteurs.etat.label">Etat Général</span>
               <input type="text" value="{{data.compteurs.etat.value}}" disabled />
             </li>
           </ol>
@@ -103,11 +102,11 @@
                 <span class="competence-label">{{comp.name}}</span>
               </a>
                 <input class="competence-value creature-carac" type="text" compname="{{comp.name}}"
-                value="{{comp.data.carac_value}}" data-dtype="number" />
+                value="{{comp.system.carac_value}}" data-dtype="number" />
               <input class="competence-value creature-niveau" type="text" compname="{{comp.name}}"
-                value="{{numberFormat comp.data.niveau decimals=0 sign=true}}" data-dtype="number" />
+                value="{{numberFormat comp.system.niveau decimals=0 sign=true}}" data-dtype="number" />
               <input class="competence-value creature-dommages" type="text" compname="{{comp.name}}"
-                value="{{numberFormat comp.data.dommages decimals=0 sign=true}}" data-dtype="number" />
+                value="{{numberFormat comp.system.dommages decimals=0 sign=true}}" data-dtype="number" />
               <div class="item-controls">
                 <a class="item-control item-edit" title="Edit Item"><i class="fas fa-edit"></i></a>
                 <a class="item-control item-delete" title="Delete Item"><i class="fas fa-trash"></i></a>
@@ -163,12 +162,12 @@
 
       <div class="form-group">
         <span class="item-name"><h4>Race</h4></span>
-        <input type="text" name="data.race" value="{{data.race}}" data-dtype="String" />
+        <input type="text" name="system.race" value="{{data.race}}" data-dtype="String" />
       </div>
 
-      <div class="form-group editor">
+      <div class="form-group editor">        
         <span class="item-name"><h4>Description</h4>          
-        {{editor content=data.description target="data.description" button=true owner=owner editable=editable}}
+        {{editor data.description target="system.description" button=true owner=owner editable=true}}
       </div>
 
       {{>"systems/foundryvtt-reve-de-dragon/templates/actor-sheet-editor-notes-mj.html"}}

templates/actor-entite-sheet.html

@@ -28,7 +28,7 @@
 
     {{!-- Carac Tab --}}
     <div class="tab items" data-group="primary" data-tab="carac">
-      
+
       <div class="grid grid-2col">
         <div class="flex-group-left flexcol">
           <ol class="carac-list alterne-list">
@@ -65,6 +65,7 @@
                 {{#select data.definition.typeentite}}
                 <option value="incarne">Incarnée</option>
                 <option value="nonincarne">Non Incarnée</option>
+                <option value="blurette">Blurete</option>
                 {{/select}}
               </select>
             </li>
@@ -89,9 +90,7 @@
     
     {{!-- Compétences Tab --}}
     <div class="tab competences" data-group="primary" data-tab="competences">
-
       <div class="flexcol">
-
         <div class="flex-group-left flexcol competence-column">
           <ol class="item-list alterne-list">
             {{#each competences as |comp key|}}
@@ -111,34 +110,31 @@
             </li>
             {{/each}}
           </ol>
-
-          <div class="flex-group-left flexcol competence-column">
-            <ol class="item-list alterne-list">
-              {{#each possessions as |possession key|}}
-              <li class="item flexrow list-item" data-item-id="{{possession._id}}">
-                <img class="sheet-competence-img" src="{{possession.img}}" />
-                <span class="competence-label">{{possession.name}}</span>
-                <div class="item-controls">
-                  <a class="item-control item-edit" title="Edit Item"><i class="fas fa-edit"></i></a>
-                  <a class="item-control item-delete" title="Delete Item"><i class="fas fa-trash"></i></a>
-                </div>
-              </li>
-              {{/each}}
-            </ol>
-  
+        </div>
+        <div class="flex-group-left flexcol competence-column">
+          <ol class="item-list alterne-list">
+            {{#each possessions as |possession key|}}
+            <li class="item flexrow list-item" data-item-id="{{possession._id}}">
+              <img class="sheet-competence-img" src="{{possession.img}}" />
+              <span class="competence-label">{{possession.name}}</span>
+              <div class="item-controls">
+                <a class="item-control item-edit" title="Edit Item"><i class="fas fa-edit"></i></a>
+                <a class="item-control item-delete" title="Delete Item"><i class="fas fa-trash"></i></a>
+              </div>
+            </li>
+            {{/each}}
+          </ol>
         </div>
       </div>
     </div>
-      
+
     {{!-- Biography Tab --}}
     <div class="tab description" data-group="primary" data-tab="description">
       <div class="form-group editor">
-        {{editor content=data.description target="data.description" button=true owner=owner editable=editable}}
+        {{editor data.description target="system.description" button=true owner=owner editable=true}}
       </div>
       {{>"systems/foundryvtt-reve-de-dragon/templates/actor-sheet-editor-notes-mj.html"}}
     </div>
-    
-    </div>
 
   </section>
 </form>

templates/actor-sheet-competence-partial.html

@@ -1,45 +1,45 @@
 {{#if visible}}
-  <li class="item flexrow list-item {{#if data.isLevelUp}}xp-level-up tooltip{{/if}}" data-item-id="{{_id}}">
+  <li class="item flexrow list-item {{#if system.isLevelUp}}xp-level-up tooltip{{/if}}" data-item-id="{{_id}}">
     <a class="competence-label" name="{{name}}">
       <img class="sheet-competence-img" src="{{img}}"/>
       <span class="competence-label">{{name}}</span>
     </a>
 
-    {{#if data.isLevelUp}}
-    <span class="tooltiptext ttt-xp">Vous pouvez dépenser {{data.xpNext}} points d'Experience pour augmenter de 1 votre compétence {{name}}</span>
+    {{#if system.isLevelUp}}
+    <span class="tooltiptext ttt-xp">Vous pouvez dépenser {{system.xpNext}} points d'Experience pour augmenter de 1 votre compétence {{name}}</span>
     <a class="item-control competence-xp-augmenter" compname="{{name}}" title="Augmenter">
       <i class="fas fa-arrow-alt-circle-up"></i>
     </a>
     {{/if}}
 
     <input class="competence-value" type="text" compname="{{name}}" name="comp-value-{{name}}"
-          value="{{numberFormat data.niveau decimals=0 sign=true}}" data-dtype="number"
+          value="{{numberFormat system.niveau decimals=0 sign=true}}" data-dtype="number"
           {{#unless @root.options.editCaracComp}}disabled{{/unless}} />
     
     <span class="competence-xp tooltip">
       <input class="competence-xp " type="text" compname="{{name}}" name="comp-xp-{{name}}"
-          value="{{numberFormat data.xp decimals=0 sign=false}}" data-dtype="number"
+          value="{{numberFormat system.xp decimals=0 sign=false}}" data-dtype="number"
           {{#unless @root.options.editCaracComp}}disabled{{/unless}} />
-      <span class="tooltiptext left-competence ttt-xp">Vous devez acquérir {{data.xpNext}} points d'Experience pour augmenter de 1 votre compétence {{name}}</span>      
+      <span class="tooltiptext left-competence ttt-xp">Vous devez acquérir {{system.xpNext}} points d'Experience pour augmenter de 1 votre compétence {{name}}</span>      
     </span>
 
-    {{#if (eq data.categorie 'draconic')}}
+    {{#if (eq system.categorie 'draconic')}}
     <input class="competence-xp-sort" type="text" compname="{{name}}" name="comp-xp-sort-{{name}}"
-          value="{{numberFormat data.xp_sort decimals=0 sign=false}}" data-dtype="number"
+          value="{{numberFormat system.xp_sort decimals=0 sign=false}}" data-dtype="number"
           {{#unless @root.options.editCaracComp}}disabled{{/unless}}/>
     {{/if}}
     {{#if @root.options.vueDetaillee}}
     <div class="item-controls">
-      {{#if data.stressXpMax}}
+      {{#if system.stressXpMax}}
       <a class="item-control competence-stress-augmenter" compname="{{name}}" 
-            title="Dépenser {{data.stressXpMax}} points de stress {{#if data.isStressLevelUp}} pour augmenter d'un niveau {{/if}}">
-            <i class="fas fa-arrow-alt-circle-up allouer-stress{{#if data.isStressLevelUp}}-level-up{{/if}}"></i>
+            title="Dépenser {{system.stressXpMax}} points de stress {{#if system.isStressLevelUp}} pour augmenter d'un niveau {{/if}}">
+            <i class="fas fa-arrow-alt-circle-up allouer-stress{{#if system.isStressLevelUp}}-level-up{{/if}}"></i>
       </a>
       {{else}}
       <i class="far fa-circle"></i>
       {{/if}}
       <input class="competence-archetype niveau-archetype" type="text" compname="{{name}}" name="comp-archetype-{{name}}"
-            value="{{numberFormat data.niveau_archetype decimals=0 sign=true}}" data-dtype="number"
+            value="{{numberFormat system.niveau_archetype decimals=0 sign=true}}" data-dtype="number"
             {{#unless @root.options.editCaracComp}}disabled{{/unless}} />
       <a class="item-control item-edit" title="Modifier"><i class="fas fa-edit"></i></a>
       {{#if @root.options.isGM}}

templates/actor-sheet-editor-notes-mj.html

@@ -1,6 +1,6 @@
 {{#if options.isGM}}
 <h3>Notes du MJ : </h3>
 <div class="form-group editor">
-  {{editor content=data.notesmj target="data.notesmj" button=true owner=owner editable=editable}}
+  {{editor system.notesmj target="system.notesmj" button=true owner=owner editable=editable}}
 </div>
 {{/if}}

templates/actor-sheet-inventaire-conteneur.html

@@ -6,27 +6,27 @@
   {{else}}
   <span class="item-name flex-grow">{{item.name}}</span>
   {{/if}}
-  <span class="item-quantite">{{item.data.quantite}}
-    {{#if (gt item.data.quantite 1)}}
+  <span class="item-quantite">{{item.system.quantite}}
+    {{#if (gt item.system.quantite 1)}}
     <a class="item-control item-split" title="Séparer"><i class="fas fa-unlink"></i></a>
     {{/if}}
   </span>
-  <span class="item-quantite">{{numberFormat item.data.encTotal decimals=2}}</span>
+  <span class="item-quantite">{{numberFormat item.system.encTotal decimals=2}}</span>
   <div class="item-controls flex-grow">
     {{#unless item.estContenu}}
     {{#if (ne item.type 'conteneur')}}
-    <a class="item-control item-equip" title="Equiper">{{#if item.data.equipe}}<i class="fas fa-hand-rock"></i>{{else}}<i class="far fa-hand-paper"></i>{{/if}}</a>
+    <a class="item-control item-equip" title="Equiper">{{#if item.system.equipe}}<i class="fas fa-hand-rock"></i>{{else}}<i class="far fa-hand-paper"></i>{{/if}}</a>
     {{/if}}
     {{/unless}}
     <a class="item-control item-edit" title="Editer"><i class="fas fa-edit"></i></a>
     <a class="item-control item-delete" title="Supprimer"><i class="fas fa-trash"></i></a>
-    {{#if (or (eq item.type 'arme') (eq item.type 'conteneur') item.data.quantite)}}
+    {{#if (or (eq item.type 'arme') (eq item.type 'conteneur') item.system.quantite)}}
     &nbsp;
     <a class="item-control item-vendre" title="Vendre ou donner"><i class="fas fa-comments-dollar"></i></a>
     {{/if}}
     <a class="item-control item-montrer" title="Montrer"><i class="fas fa-comment"></i></a>
-    {{#if item.data.actionPrincipale}}
-    <a class="item-name item-action">{{item.data.actionPrincipale}}</a>
+    {{#if item.system.actionPrincipale}}
+    <a class="item-name item-action">{{item.system.actionPrincipale}}</a>
     {{/if}}
   </div>
 </li>

templates/actor-sheet-inventaire-monnaie.html

@@ -4,7 +4,7 @@
   <li class="item flexrow list-item" data-item-id="{{piece._id}}">
     <img class="sheet-competence-img" src="{{piece.img}}" title="{{piece.name}}"/>
     <span class="competence-title competence-label">{{piece.name}}</span>
-    <span class="competence-title competence-label">{{piece.data.quantite}}</span>
+    <span class="competence-title competence-label">{{piece.system.quantite}}</span>
     <span class="competence-title">
       <a class="monnaie-plus plus-moins">+</a>
       <a class="monnaie-moins plus-moins">-</a>

templates/actor-sheet-oeuvre-partial.html

@@ -1,7 +1,7 @@
 <li class="item flexrow list-item" data-item-id="{{oeuvre._id}}">
   <span>{{upperFirst typeOeuvre}}</span>
   <span class="competence-title {{classOeuvre}}">
-    <a>{{oeuvre.name}} (niveau {{oeuvre.data.niveau}})</a>
+    <a>{{oeuvre.name}} (niveau {{oeuvre.system.niveau}})</a>
   </span>
   <div class="item-controls">
     <a class="item-control item-edit" title="Edit Item"><i class="fas fa-edit"></i></a>

templates/actor-sheet.html

@@ -286,7 +286,7 @@
               </li>
             {{#each combat as |arme key|}}
               <li class="item flexrow list-item" data-item-id="{{arme._id}}"
-                  data-arme-name="{{arme.name}}" data-competence-name="{{arme.data.competence}}" >
+                  data-arme-name="{{arme.name}}" data-competence-name="{{arme.system.competence}}" >
                   <span class="arme-label">
                     <a>
                       {{#if arme.img}}
@@ -295,10 +295,10 @@
                       <span>{{arme.name}}</span>
                     </a>
                   </span>
-                  <span class="arme-initiative"><a>{{arme.data.initiative}}</a></span>
-                  <span class="competence-label">{{arme.data.competence}}</span>
-                  <span class="competence-value">{{numberFormat arme.data.niveau decimals=0 sign=true}}</span>
-                  <span class="competence-value">{{numberFormat arme.data.dommagesReels decimals=0 sign=true}}</span>
+                  <span class="arme-initiative"><a>{{arme.system.initiative}}</a></span>
+                  <span class="competence-label">{{arme.system.competence}}</span>
+                  <span class="competence-value">{{numberFormat arme.system.niveau decimals=0 sign=true}}</span>
+                  <span class="competence-value">{{numberFormat arme.system.dommagesReels decimals=0 sign=true}}</span>
               </li>
             {{/each}}
             {{#each esquives as |esq key|}}
@@ -307,7 +307,6 @@
                   <a class="competence-label" name="{{esq.name}}">
                     <img class="sheet-competence-img" src="{{esq.img}}"/>
                     <span>{{esq.name}}</span>
-                    {{log esq}}
                   </a>
                 </span>
                 <span class="arme-initiative"></span>
@@ -322,6 +321,7 @@
         {{!-- Liste de blessures --}}
         {{> "systems/foundryvtt-reve-de-dragon/templates/actor-liste-blessures-partial.html" this}}
 
+        {{#if maladiesPoisons.length}}
         {{!-- Maladies & Poison --}}
         <h3 class="blessures-title">Maladies & Poisons:</h3>
         <ul class="item-list alterne-list">
@@ -355,28 +355,30 @@
           </li>
           {{/each}}
           </ul>
+        {{/if}}
 
-          {{!-- Possession --}}
-          <h3 class="blessures-title">Possession:</h3>
-          <ul class="item-list alterne-list">
-            <li class="competence-header flexrow">
-              <span class="competence-title flex-grow competence-label">Nom</span>
-              <span class="competence-title competence-label">Type</span>
-            </li>
+        {{#if possessions.length}}
+        {{!-- Possession --}}
+        <h3 class="blessures-title">Possession:</h3>
+        <ul class="item-list alterne-list">
+          <li class="competence-header flexrow">
+            <span class="competence-title flex-grow competence-label">Nom</span>
+            <span class="competence-title competence-label">Type</span>
+          </li>
           {{#each possessions as |possession  key|}}
-            <li class="item flexrow list-item" data-item-id="{{possession._id}}">
-                <span class="competence-label">
-                  <a class="sheet-possession-attack">{{possession.name}} (Conjurer)</a>
-                </span>
-                <span class="competence-label">{{possession.data.type}}</span>
-                <div class="item-controls">
-                  <a class="item-control item-edit" title="Modifier"><i class="fas fa-edit"></i></a>
-                  <a class="item-control item-delete" title="Supprimer"><i class="fas fa-trash"></i></a>
-                </div>          
-            </li>
-            {{/each}}
-            </ul>
-  
+          <li class="item flexrow list-item" data-item-id="{{possession._id}}">
+              <span class="competence-label">
+                <a class="sheet-possession-attack">{{possession.name}} (Conjurer)</a>
+              </span>
+              <span class="competence-label">{{possession.system.type}}</span>
+              <div class="item-controls">
+                <a class="item-control item-edit" title="Modifier"><i class="fas fa-edit"></i></a>
+                <a class="item-control item-delete" title="Supprimer"><i class="fas fa-trash"></i></a>
+              </div>          
+          </li>
+          {{/each}}
+          </ul>
+        {{/if}}
       </div>
 
       {{!-- Connaissances Tab --}}
@@ -385,9 +387,9 @@
         <ul class="item-list alterne-list">
           {{#each taches as |tache id|}}
           <li class="item flexrow list-item" data-item-id="{{tache._id}}"><span class="competence-title tache-label"><a>{{tache.name}}
-            ({{tache.data.points_de_tache_courant}}{{#if
-               (or @root.options.isGM (not tache.data.cacher_points_de_tache))
-            }}/{{tache.data.points_de_tache}}{{/if}})</a></span>
+            ({{tache.system.points_de_tache_courant}}{{#if
+               (or @root.options.isGM (not tache.system.cacher_points_de_tache))
+            }}/{{tache.system.points_de_tache}}{{/if}})</a></span>
             <div class="item-controls flex-shrink">
               <a class="item-control item-edit" title="Edit Item"><i class="fas fa-edit"></i></a>
               <a class="item-control item-delete" title="Delete Item"><i class="fas fa-trash"></i></a>
@@ -408,7 +410,7 @@
           {{> "systems/foundryvtt-reve-de-dragon/templates/actor-sheet-oeuvre-partial.html" oeuvre=danse typeOeuvre="Danse" classOeuvre="danse-label"}}
           {{/each}}
           {{#each oeuvres as |oeuvre id|}}
-          {{> "systems/foundryvtt-reve-de-dragon/templates/actor-sheet-oeuvre-partial.html" oeuvre=oeuvre typeOeuvre=oeuvre.data.competence classOeuvre="oeuvre-label"}}
+          {{> "systems/foundryvtt-reve-de-dragon/templates/actor-sheet-oeuvre-partial.html" oeuvre=oeuvre typeOeuvre=oeuvre.system.competence classOeuvre="oeuvre-label"}}
           {{/each}}
           {{#each recettescuisine as |recette id|}}
           {{> "systems/foundryvtt-reve-de-dragon/templates/actor-sheet-oeuvre-partial.html" oeuvre=recette typeOeuvre="Recette de cuisine" classOeuvre="recettecuisine-label"}}
@@ -417,7 +419,7 @@
         <h3>Jeux :</h3>
         <ul class="item-list alterne-list">
           {{#each jeux as |jeu id|}}
-          <li class="item flexrow list-item" data-item-id="{{jeu._id}}"><span class="competence-title jeu-label"><a>{{jeu.name}} (base {{jeu.data.base}})</a></span>
+          <li class="item flexrow list-item" data-item-id="{{jeu._id}}"><span class="competence-title jeu-label"><a>{{jeu.name}} (base {{jeu.system.base}})</a></span>
             <div class="item-controls flex-shrink">
               <a class="item-control item-edit" title="Edit Item"><i class="fas fa-edit"></i></a>
               <a class="item-control item-delete" title="Delete Item"><i class="fas fa-trash"></i></a>
@@ -509,65 +511,8 @@
           </ul>
         </div>
         <hr>
-        {{#if data.attributs.hautrevant.value}}
-        {{#if options.isGM}}
-        <h3>Signes draconiques</h3>
-        <ul class="item-list alterne-list">
-          {{#each signesdraconiques as |signe key|}}
-          <li class="item list-item flexrow" data-item-id="{{signe._id}}" data-attribute="{{key}}">
-            <span class="display-label flex-grow"> <a data-item-id="{{signe._id}}">{{signe.name}}</a></span> 
-            <span class="flex-shrink">{{signe.data.difficulte}}</span>
-            <div class="item-controls flex-shrink">
-              <a class="item-control item-delete" title="Supprimer"><i class="fas fa-trash"></i></a>
-            </div>
-          </li>
-          {{/each}}
-        </ul>
-        {{/if}}
-        <h3>Sorts:</h3>
-        <ul class="item-list alterne-list">
-          {{#each sorts as |sort key|}}
-          <li class="item list-item flexrow" data-item-id="{{sort._id}}" data-attribute="{{key}}">
-            <span class="display-label flex-grow"> <a data-item-id="{{sort._id}}">{{sort.name}}</a></span> 
-            <span>{{sort.data.draconic}} / {{sort.data.difficulte}}</span>
-            <div class="item-controls flex-shrink">
-              <a class="item-control item-delete" title="Supprimer"><i class="fas fa-trash"></i></a>
-            </div>
-          </li>
-          {{/each}}
-        </ul>
-        
-        <h3>Sorts en Réserve:</h3>
-        <ul class="item-list alterne-list">
-          {{#each hautreve.sortsReserve as |reserve key|}}
-          <li class="item list-item flexrow" data-item-id="{{reserve._id}}" data-attribute="{{key}}">
-            <img class="sheet-competence-img" src="{{reserve.sort.img}}" />
-            <span class="display-label flex-grow">{{reserve.sort.name}}</span> 
-            <span class="flex-shrink">r{{reserve.sort.data.ptreve_reel}}</span> 
-            <span class="flex-shrink">{{reserve.coord}}</span> 
-            <span>{{caseTmr-label reserve.coord}}</span> 
-            <div class="item-controls flex-shrink">
-              <a class="item-control item-delete flex-shrink" title="Supprimer"><i class="fas fa-trash"></i></a>
-            </div>
-          </li>
-          {{/each}}
-        </ul>
-        
-        <h3>Méditations:</h3>
-        <ul class="item-list">
-          {{#each meditations as |meditation key|}}
-          <li class="item flexrow" data-item-id="{{meditation._id}}" data-attribute="{{key}}">
-            <span class="meditation-label flex-grow"><a data-item-id="{{meditation._id}}">{{meditation.name}} - {{meditation.data.competence}}</a></span> 
-            <div class="item-controls flex-shrink">
-              <a class="item-control item-edit" title="Editer"><i class="fas fa-edit"></i></a>
-              <a class="item-control item-delete" title="Supprimer"><i class="fas fa-trash"></i></a>
-            </div>
-          </li>
-          {{/each}}
-        </ul>
-        <hr>
-        {{/if}}
         {{!-- Queues, Souffles, Tetes, Ombre --}}
+        {{#if queues.length}}
         <h3>Queues:</h3>
         <ul class="flex-group-left">
           {{#each queues as |queue key|}}
@@ -579,28 +524,8 @@
           </li>
           {{/each}}
         </ul>
-        <h3>Souffles:</h3>
-        <ul class="item-list">
-          {{#each souffles as |souffle key|}}
-          <li class="item flexrow" data-attribute={{key}} data-item-id="{{souffle._id}}">
-            <span class="display-label flex-grow"><a data-item-id="{{souffle._id}}">{{souffle.name}}</a></span>
-            <div class="item-controls flex-shrink">
-              <a class="item-control item-delete" title="Delete Item"><i class="fas fa-trash"></i></a>
-            </div>
-          </li>
-          {{/each}}                 
-        </ul>
-        <h3>Tetes:</h3>
-        <ul class="item-list">
-          {{#each tetes as |tete key|}}
-          <li class="item flexrow" data-attribute={{key}} data-item-id="{{tete._id}}">
-            <span class="display-label flex-grow"><a data-item-id="{{tete._id}}">{{tete.name}}</a></span>
-            <div class="item-controls flex-shrink">
-              <a class="item-control item-delete" title="Delete Item"><i class="fas fa-trash"></i></a>
-            </div>
-          </li>
-          {{/each}}
-        </ul>
+        {{/if}}
+        {{#if ombres.length}}
         <h3>Ombres de Thanatos:</h3>
         <ul class="item-list">
           {{#each ombres as |ombre key|}}
@@ -612,35 +537,128 @@
           </li>
           {{/each}}
         </ul>
+        {{/if}}
+        {{#if souffles.length}}
+        <h3>Souffles:</h3>
+        <ul class="item-list">
+          {{#each souffles as |souffle key|}}
+          <li class="item flexrow" data-attribute={{key}} data-item-id="{{souffle._id}}">
+            <span class="display-label flex-grow"><a data-item-id="{{souffle._id}}">{{souffle.name}}</a></span>
+            <div class="item-controls flex-shrink">
+              <a class="item-control item-delete" title="Delete Item"><i class="fas fa-trash"></i></a>
+            </div>
+          </li>
+          {{/each}}
+        </ul>
+        {{/if}}
+        {{#if tetes.length}}
+        <h3>Tetes:</h3>
+        <ul class="item-list">
+          {{#each tetes as |tete key|}}
+          <li class="item flexrow" data-attribute={{key}} data-item-id="{{tete._id}}">
+            <span class="display-label flex-grow"><a data-item-id="{{tete._id}}">{{tete.name}}</a></span>
+            <div class="item-controls flex-shrink">
+              <a class="item-control item-delete" title="Delete Item"><i class="fas fa-trash"></i></a>
+            </div>
+          </li>
+          {{/each}}
+        </ul>
+        {{/if}}
         {{#if data.attributs.hautrevant.value}}
+          {{#if (and options.isGM signesdraconiques.length)}}
+            <h3>Signes draconiques</h3>
+            <ul class="item-list alterne-list">
+              {{#each signesdraconiques as |signe key|}}
+              <li class="item list-item flexrow" data-item-id="{{signe._id}}" data-attribute="{{key}}">
+                <span class="display-label flex-grow"> <a data-item-id="{{signe._id}}">{{signe.name}}</a></span> 
+                <span class="flex-shrink">{{signe.data.difficulte}}</span>
+                <div class="item-controls flex-shrink">
+                  <a class="item-control item-delete" title="Supprimer"><i class="fas fa-trash"></i></a>
+                </div>
+              </li>
+              {{/each}}
+            </ul>
+          {{/if}}
+
+          {{#if hautreve.rencontres.length}}
+            <h3>Rencontres présentes:</h3>
+            <ul class="item-list">
+              {{#each hautreve.rencontres as |rencontre key|}}
+              <li class="item flexrow" data-item-id="{{key}}" data-attribute="{{key}}">
+                <span class="display-label"><a data-item-id="{{key}}">{{rencontre.name}} r{{rencontre.force}}</a></span> 
+                <span class="flex-shrink">{{rencontre.coord}} - {{caseTmr-label rencontre.coord}}</span> 
+                {{#if rencontre.date}}
+                <span>{{upperFirst rencontre.heure}}, le {{rencontre.date}}</span> 
+                {{/if}}
+                <div class="item-controls flex-shrink">
+                  <a class="item-control rencontre-delete" title="Supprimer"><i class="fas fa-trash"></i></a>
+                </div>
+              </li>
+              {{/each}}
+            </ul>
+          {{/if}}
+          {{#if hautreve.sortsReserve.length}}
+            <h3>Sorts en Réserve:</h3>
+            <ul class="item-list alterne-list">
+              {{#each hautreve.sortsReserve as |reserve key|}}
+              <li class="item list-item flexrow" data-item-id="{{reserve._id}}" data-attribute="{{key}}">
+                <img class="sheet-competence-img" src="{{reserve.sort.img}}" />
+                <span class="display-label">{{reserve.sort.name}} r{{reserve.sort.system.ptreve_reel}}</span> 
+                <span>{{reserve.coord}} - {{caseTmr-label reserve.coord}}</span> 
+                <div class="item-controls flex-shrink">
+                  <a class="item-control item-delete flex-shrink" title="Supprimer"><i class="fas fa-trash"></i></a>
+                </div>
+              </li>
+              {{/each}}
+            </ul>
+          {{/if}}
+
+          <hr>
+
+          <h3>Sorts:</h3>
+          <ul class="item-list alterne-list">
+            {{#each sorts as |sort key|}}
+            <li class="item list-item flexrow" data-item-id="{{sort._id}}" data-attribute="{{key}}">
+              <span class="display-label flex-grow">
+                <a data-item-id="{{sort._id}}">{{sort.name}}
+                  - {{#if sort.system.caseTMRspeciale}}{{sort.system.caseTMRspeciale}}{{else}}{{upperFirst sort.system.caseTMR}}{{/if}}
+                </a>
+              </span> 
+              <span>{{sort.system.draconic}} / {{sort.system.difficulte}}</span>
+              <div class="item-controls flex-shrink">
+                <a class="item-control item-delete" title="Supprimer"><i class="fas fa-trash"></i></a>
+              </div>
+            </li>
+            {{/each}}
+          </ul>
+
+          <h3>Méditations:</h3>
+          <ul class="item-list">
+            {{#each meditations as |meditation key|}}
+            <li class="item flexrow" data-item-id="{{meditation._id}}" data-attribute="{{key}}">
+              <span class="meditation-label flex-grow"><a data-item-id="{{meditation._id}}">{{meditation.name}} - {{meditation.system.competence}}</a></span> 
+              <div class="item-controls flex-shrink">
+                <a class="item-control item-edit" title="Editer"><i class="fas fa-edit"></i></a>
+                <a class="item-control item-delete" title="Supprimer"><i class="fas fa-trash"></i></a>
+              </div>
+            </li>
+            {{/each}}
+          </ul>
         <hr>
-        <h3>Rencontres présentes:</h3>
-        <ul class="item-list">
-          {{#each hautreve.rencontres as |rencontre key|}}
-          <li class="item flexrow" data-item-id="{{key}}" data-attribute="{{key}}">
-            <span class="display-label"><a data-item-id="{{key}}">{{rencontre.name}} - {{rencontre.coord}}</a></span> 
-            <span class="flex-shrink">{{caseTmr-label rencontre.coord}}</span> 
-            {{#if rencontre.date}}
-            <span>Le {{rencontre.date}} à {{rencontre.heure}}</span> 
-            {{/if}}
-            <div class="item-controls flex-shrink">
-              <a class="item-control rencontre-delete" title="Supprimer"><i class="fas fa-trash"></i></a>
-            </div>
-          </li>
-          {{/each}}
-        </ul>
-        <hr>
-        <h3>Cases Spéciales:</h3>
-        <ul class="item-list">
-          {{#each hautreve.casesTmr as |casetmr key|}}
-          <li class="item flexrow" data-item-id="{{casetmr._id}}" data-attribute="{{key}}">
-            <span class="display-label"><a data-item-id="{{casetmr._id}}">{{casetmr.name}}</a></span> 
-            <div class="item-controls flex-shrink">
-              <a class="item-control item-delete" title="Supprimer"><i class="fas fa-trash"></i></a>
-            </div>
-          </li>
-          {{/each}}
-        </ul>
+          {{#if hautreve.casesTmr}}
+            <h3>Cases Spéciales:</h3>
+            <ul class="item-list">
+              {{#each hautreve.casesTmr as |casetmr key|}}
+              <li class="item flexrow" data-item-id="{{casetmr._id}}" data-attribute="{{key}}">
+                <span class="display-label"><a data-item-id="{{casetmr._id}}">{{casetmr.name}}</a></span>
+                <span>{{casetmr.system.coord}} - {{caseTmr-label casetmr.system.coord}}</span> 
+                <div class="item-controls flex-shrink">
+                  <a class="item-control item-delete" title="Supprimer"><i class="fas fa-trash"></i></a>
+                </div>
+              </li>
+              {{/each}}
+            </ul>
+          {{/if}}
         <br><br>
         {{/if}}
       </div>
@@ -780,11 +798,11 @@
         <article class="flexcol">
           <h3>Biographie : </h3>
           <div class="form-group editor">
-            {{editor content=data.biographie target="data.biographie" button=true owner=owner editable=editable}}
+            {{editor data.biographie target="system.biographie" button=true owner=owner editable=editable}}
           </div>
           <h3>Notes : </h3>
           <div class="form-group editor">
-            {{editor content=data.notes target="data.notes" button=true owner=owner editable=editable}}
+            {{editor data.notes target="system.notes" button=true owner=owner editable=editable}}
           </div>
           <h3>Journal d'Experience</h3>
           <div class="form-group editor">

templates/chat-command-nom.html

@@ -0,0 +1,16 @@
+
+<h4>Proposition de nom: {{nom}}</h4>
+<span class="chat-card-button-area">
+  <a class="button-creer-acteur chat-card-button"
+    data-nom='{{nom}}'
+    data-type='personnage'
+    >
+  Créer un Personnage</a>
+</span>
+<span class="chat-card-button-area">
+  <a class="button-creer-acteur chat-card-button"
+    data-nom='{{nom}}'
+    data-type='creature'>
+  Créer une créature</a>
+</span>
+

templates/chat-fabriquer-potion-base.html

@@ -1,6 +1,6 @@
 <img class="chat-icon" src="{{herbe.img}}" alt="fabrication" />
 <h4>
-  {{alias}} a fabriqué une potion de {{herbe.data.categorie}} de {{herbe.name}}, avec {{herbe.nbBrins}} brins.
+  {{alias}} a fabriqué une potion de {{herbe.system.categorie}} de {{herbe.name}}, avec {{herbe.nbBrins}} brins.
 </h4>
 <hr>
 <div>

templates/chat-resultat-chant.html

@@ -1,6 +1,6 @@
-<img class="chat-icon" src="{{competence.img}}" alt="{{oeuvre.data.competence}}" />
+<img class="chat-icon" src="{{competence.img}}" alt="{{oeuvre.system.competence}}" />
 <h4>
-  {{alias}} tente de chanter : {{oeuvre.name}} (niveau {{oeuvre.data.niveau}})
+  {{alias}} tente de chanter : {{oeuvre.name}} (niveau {{oeuvre.system.niveau}})
 </h4>
 {{> "systems/foundryvtt-reve-de-dragon/templates/chat-infojet.html"}}
 <hr>
@@ -12,4 +12,4 @@
   {{/if}}
   {{> "systems/foundryvtt-reve-de-dragon/templates/chat-info-appel-au-moral.html"}}
 </div>
-{{> "systems/foundryvtt-reve-de-dragon/templates/chat-description.html" oeuvre.data}}
+{{> "systems/foundryvtt-reve-de-dragon/templates/chat-description.html" oeuvre.system}}

templates/chat-resultat-danse.html

@@ -1,6 +1,6 @@
-<img class="chat-icon" src="{{competence.img}}" alt="{{oeuvre.data.competence}}" />
+<img class="chat-icon" src="{{competence.img}}" alt="{{oeuvre.system.competence}}" />
 <h4>
-  {{alias}} tente de danser : {{oeuvre.name}} (niveau {{oeuvre.data.niveau}})
+  {{alias}} tente de danser : {{oeuvre.name}} (niveau {{oeuvre.system.niveau}})
 </h4>
 {{> "systems/foundryvtt-reve-de-dragon/templates/chat-infojet.html"}}
 <hr>
@@ -12,4 +12,4 @@
   {{/if}}
   {{> "systems/foundryvtt-reve-de-dragon/templates/chat-info-appel-au-moral.html"}}
 </div>
-{{> "systems/foundryvtt-reve-de-dragon/templates/chat-description.html" oeuvre.data}}
+{{> "systems/foundryvtt-reve-de-dragon/templates/chat-description.html" oeuvre.system}}

templates/chat-resultat-jeu.html

@@ -1,4 +1,4 @@
-<img class="chat-icon" src="{{competence.img}}" alt="{{oeuvre.data.competence}}" />
+<img class="chat-icon" src="{{competence.img}}" alt="{{oeuvre.system.competence}}" />
 <h4>
   {{alias}} joue à : {{oeuvre.name}}
 </h4>
@@ -12,4 +12,4 @@
   {{/if}}
   {{> "systems/foundryvtt-reve-de-dragon/templates/chat-info-appel-au-moral.html"}}
 </div>
-{{> "systems/foundryvtt-reve-de-dragon/templates/chat-description.html" oeuvre.data}}
+{{> "systems/foundryvtt-reve-de-dragon/templates/chat-description.html" oeuvre.system}}

templates/chat-resultat-maitrise-tmr.html

@@ -1,6 +1,11 @@
 <img class="chat-icon" src="{{competence.img}}" alt="{{competence.name}}"/>
 <h4 data-categorie="tmr" data-actor-id="{{actor._id}}">
-  {{alias}} tente de {{maitrise.verbe}} {{le tmr.genre}} {{tmr.label}} ({{tmr.coord}})
+  {{alias}} tente de {{maitrise.verbe}} {{le tmr.genre}}
+  {{#if isTMRCache}}
+    {{caseTmr-type tmr.coord}}
+  {{else}}
+    {{tmr.label}} ({{tmr.coord}})
+  {{/if}}
 </h4>
 {{#if previous}}
   {{#with previous}}
@@ -11,15 +16,20 @@
 {{> "systems/foundryvtt-reve-de-dragon/templates/chat-infojet.html"}}
 <hr>
 <span>
-{{#if rolled.isSuccess}}
-  {{alias}} parvient à {{maitrise.verbe}} {{le tmr.genre}} {{tmr.label}} !
+  {{alias}}
+  {{#if rolled.isSuccess}}parvient à{{else}}échoue à{{/if}}
+  {{maitrise.verbe}} {{le tmr.genre}}
+  {{#if isTMRCache}}
+    {{caseTmr-type tmr.coord}}
   {{else}}
-  {{alias}} échoue à {{maitrise.verbe}} {{le tmr.genre}} {{tmr.label}}.
-  {{alias}} <strong>quitte les Terres Médianes</strong> !
-  {{#if souffle}}
-    <br>De plus, son échec total lui fait subir un Souffle de Dragon : {{souffle.name}}
+    {{tmr.label}} ({{tmr.coord}})
+  {{/if}}!
+  {{#if rolled.isEchec}}
+    {{alias}} <strong>quitte les Terres Médianes</strong> !
+    {{#if souffle}}
+      <br>De plus, son échec total lui fait subir un Souffle de Dragon : {{souffle.name}}
+    {{/if}}
   {{/if}}
-{{/if}}
 </span>
 {{#if poesie}}
 <hr>

templates/chat-resultat-meditation.html

@@ -6,7 +6,7 @@
 <hr>
 <div>
   {{#if rolled.isSuccess}}
-  {{alias}} aperçoit un signe draconique éphémère, qu'il faut aller lire en <strong>{{typeTmr-name meditation.data.tmr}}</strong>.
+  {{alias}} aperçoit un signe draconique éphémère, qu'il faut aller lire en <strong>{{typeTmr-name meditation.system.tmr}}</strong>.
   {{else}}
   La méditation de {{alias}} ne porte pas ses fruits, il ne distingue aucun signe Draconique.
   {{/if}}

templates/chat-resultat-meteo.html

@@ -0,0 +1,9 @@
+<img class="chat-icon" src="icons/svg/lightning.svg" alt="Météo" />
+<h4>Météo aléatoire</h4>
+<ul>
+  <li>Vent: {{lowerFirst vent.description}} {{apostrophe 'de' vent.direction}}, force {{vent.force}}</li>
+  <li>Mer {{lowerFirst mer.description}}, {{apostrophe 'de' mer.direction}}, force {{mer.force}}</li>
+  <li>Température {{lowerFirst temperature.description}} ({{numberFormat temperature.force decimals=0 sign=true}})</li>
+  <li>Couverture nuageuse: {{lowerFirst nuage.description}}</li>
+  <li>Pluie: {{lowerFirst pluie.description}}</li>
+</div>

templates/chat-resultat-musique.html

@@ -1,6 +1,6 @@
-<img class="chat-icon" src="{{competence.img}}" alt="{{oeuvre.data.competence}}" />
+<img class="chat-icon" src="{{competence.img}}" alt="{{oeuvre.system.competence}}" />
 <h4>
-  {{alias}} tente de jouer le morceau : {{oeuvre.name}} (niveau {{oeuvre.data.niveau}})
+  {{alias}} tente de jouer le morceau : {{oeuvre.name}} (niveau {{oeuvre.system.niveau}})
 </h4>
 {{> "systems/foundryvtt-reve-de-dragon/templates/chat-infojet.html"}}
 <hr>
@@ -12,4 +12,4 @@
   {{/if}}
   {{> "systems/foundryvtt-reve-de-dragon/templates/chat-info-appel-au-moral.html"}}
 </div>
-{{> "systems/foundryvtt-reve-de-dragon/templates/chat-description.html" oeuvre.data}}
+{{> "systems/foundryvtt-reve-de-dragon/templates/chat-description.html" oeuvre.system}}

templates/chat-resultat-oeuvre.html

@@ -1,6 +1,6 @@
-<h4><img class="chat-icon" src="{{competence.img}}" alt="{{oeuvre.data.competence}}" />
+<h4><img class="chat-icon" src="{{competence.img}}" alt="{{oeuvre.system.competence}}" />
 
-  {{alias}} tente d'interpréter {{oeuvre.name}} (niveau {{oeuvre.data.niveau}})
+  {{alias}} tente d'interpréter {{oeuvre.name}} (niveau {{oeuvre.system.niveau}})
 </h4>
 <br>{{upperFirst oeuvre.data.default_carac}} / {{oeuvre.data.competence}}
 {{> "systems/foundryvtt-reve-de-dragon/templates/chat-infojet.html"}}
@@ -13,4 +13,4 @@
   {{/if}}
   {{> "systems/foundryvtt-reve-de-dragon/templates/chat-info-appel-au-moral.html"}}
 </div>
-{{> "systems/foundryvtt-reve-de-dragon/templates/chat-description.html" oeuvre.data}}
+{{> "systems/foundryvtt-reve-de-dragon/templates/chat-description.html" oeuvre.system}}

templates/chat-resultat-possession.html

@@ -1,40 +1,47 @@
 <img class="chat-icon" src="{{competence.img}}" />
 <h4>
   {{#if (eq mode "possession")}}
-    {{alias}} tente de posséder {{possede}}
+    {{attacker.name}} tente de {{#if isECNIDefender}}conjurer la possession de{{else}}posséder{{/if}} {{defender.name}}
   {{else}}
-    {{alias}} tente de conjurer la possession de {{possesseur}}
+    {{defender.name}} tente de {{#if isECNIDefender}}résister à{{else}}conjurer la possession de{{/if}} {{attacker.name}}
   {{/if}}
 </h4>
 {{> "systems/foundryvtt-reve-de-dragon/templates/chat-infojet.html"}}
 
 <hr>
-
 <div>
   <span class='chat-card-button-area'>
     <br>
     {{#if (eq mode "possession")}}
       {{#if possession.isSuccess}}
-        <a class='defense-possession chat-card-button' data-attackerId='{{attackerId}}'
-                data-defenderId='{{defenderId}}' data-possessionId='{{possession.data.possessionid}}'>Résister à la possession</a>
-              </a>
+        <a class='defense-possession chat-card-button'
+            data-attackerId='{{attacker.id}}'
+            data-defenderId='{{defender.id}}'
+            data-possessionId='{{possession.system.possessionid}}'>
+            {{#if isECNIDefender}}
+            Résister à la conjuration
+            {{else}}
+            Résister à la possession
+            {{/if}}
+        </a>
       {{else}}
-        La Tentative de Possession a échouée !
+        La Tentative de {{#if isECNIDefender}}conjuration{{else}}possession{{/if}} a échoué !
       {{/if}}
     {{else}}
       {{#if rolled.isSuccess}}
-        La Tentative de Possession a été conjurée ! {{alias}} résiste à la tentative de possession.
-      {{else}}
-        La Tentative de Possession n'a pas pu être conjurée !
+        La tentative de {{#if isECNIDefender}}conjuration a été repoussée{{else}}possession a été conjurée{{/if}}!
+        {{defender.name}} a résisté.
+        {{else}}
+        La tentative de {{#if isECNIDefender}}conjuration a réussi{{else}}possession n'a pas pu être conjurée{{/if}}!
       {{/if}}
     {{/if}}
     <br>Points de Possession: {{possession.ptsPossession}}
     <br>Points de Conjuration: {{possession.ptsConjuration}}
 
     {{#if possession.isPosseder}}
-    <br><strong>Vous êtes été possédé par {{possession.data.typepossession}} ! La possession en cours a été supprimée.</strong>
+    <br><strong>Vous êtes été possédé par {{possession.system.typepossession}} ! La possession en cours a été supprimée.</strong>
     {{/if}}
     {{#if possession.isConjurer}}
-    <br><strong>Vous avez conjuré {{possession.data.typepossession}} ! La possession en cours a été supprimée.</strong>
+    <br><strong>Vous avez conjuré {{possession.system.typepossession}} ! La possession en cours a été supprimée.</strong>
     {{/if}}
 </div>

templates/chat-resultat-recettecuisine.html

@@ -1,6 +1,6 @@
-<img class="chat-icon" src="{{competence.img}}" alt="{{oeuvre.data.competence}}" />
+<img class="chat-icon" src="{{competence.img}}" alt="{{oeuvre.system.competence}}" />
 <h4>
-  {{alias}} tente de cuisiner la recette : {{oeuvre.name}} (niveau {{oeuvre.data.niveau}})
+  {{alias}} tente de cuisiner la recette : {{oeuvre.name}} (niveau {{oeuvre.system.niveau}})
 </h4>
 {{> "systems/foundryvtt-reve-de-dragon/templates/chat-infojet.html"}}
 <hr>
@@ -21,4 +21,4 @@
   {{/if}}
 </span>
 {{> "systems/foundryvtt-reve-de-dragon/templates/chat-info-appel-au-moral.html"}}
-{{> "systems/foundryvtt-reve-de-dragon/templates/chat-description.html" oeuvre.data}}
+{{> "systems/foundryvtt-reve-de-dragon/templates/chat-description.html" oeuvre.system}}

templates/chat-resultat-sort.html

@@ -16,7 +16,7 @@
     {{#if rolled.isETotal}}Echec TOTAL
     {{else if rolled.isEchec}}Echec
     {{else}}Réussite{{/if}}
-    du {{#if selectedSort.data.isrituel}}rituel{{else}}sort{{/if}},
+    du {{#if selectedSort.system.isrituel}}rituel{{else}}sort{{/if}},
     {{#if (eq depenseReve 0)}}pas de dépense de rêve
     {{else if (eq depenseReve 1)}}1 point de rêve a été dépensé
     {{else}}{{depenseReve}} points de rêve ont été dépensés
@@ -25,5 +25,5 @@
 </div>
 <hr>
 <div class="poesie-extrait poesie-overflow">
-  {{{selectedSort.data.description}}}
+  {{{selectedSort.system.description}}}
 </div>

templates/chat-resultat-tache.html

@@ -8,11 +8,11 @@
 <div>
   {{alias}} a obtenu {{rolled.ptTache}} point{{~#unless (eq rolled.ptTache 1)}}s{{/unless}} de tâche,
    son avancement est de
-   <span class="rdd-roll-{{#if (gt tache.data.points_de_tache_courant 0)}}norm{{else}}etotal{{/if}}">{{tache.data.points_de_tache_courant}}
-     {{#unless tache.data.cacher_points_de_tache}} sur {{tache.data.points_de_tache}}{{/unless}}</span>
-   point{{~#unless (eq tache.data.points_de_tache_courant 1)}}s{{/unless}} de tâche
-   ({{~#unless (eq tache.data.tentatives 1)}}{{tache.data.tentatives}} tentatives{{else}}première tentative{{/unless~}}).
-  {{#if (and tache.data.fatigue appliquerFatigue)}}<br><span>Il s'est fatigué de {{tache.data.fatigue}} case{{~#if (gt tache.data.fatigue 1)}}s{{/if}}.</span>{{/if}}
+   <span class="rdd-roll-{{#if (gt tache.system.points_de_tache_courant 0)}}norm{{else}}etotal{{/if}}">{{tache.system.points_de_tache_courant}}
+     {{#unless tache.system.cacher_points_de_tache}} sur {{tache.system.points_de_tache}}{{/unless}}</span>
+   point{{~#unless (eq tache.system.points_de_tache_courant 1)}}s{{/unless}} de tâche
+   ({{~#unless (eq tache.system.tentatives 1)}}{{tache.system.tentatives}} tentatives{{else}}première tentative{{/unless~}}).
+  {{#if (and tache.system.fatigue appliquerFatigue)}}<br><span>Il s'est fatigué de {{tache.system.fatigue}} case{{~#if (gt tache.system.fatigue 1)}}s{{/if}}.</span>{{/if}}
   {{#if rolled.isETotal}}<br><span>Son échec total augmente de 1 la difficulté de la tâche!</span>{{/if~}}
   {{> "systems/foundryvtt-reve-de-dragon/templates/chat-info-appel-au-moral.html"}}
 </div>

templates/chat-vente-item.html

@@ -3,7 +3,7 @@
   {{#if item.img}}
   <img class="chat-icon" src="{{item.img}}" title="{{item.name}}" alt="{{item.name}}" />
   {{/if}}
-  <div class="poesie-extrait poesie-overflow card-content">{{{item.data.description}}}</div>
+  <div class="poesie-extrait poesie-overflow card-content">{{{item.system.description}}}</div>
   <p>
     {{#each properties as |property p|}}
     <span>{{{property}}}</span><br>

templates/dialog-roll-defense-possession.html

@@ -1,11 +1,15 @@
 <form class="skill-roll-dialog">
-  <h2>Conjuration d'une Possession {{possession.name}}!</h2>
+  <h2>
+    {{defender.name}} tente de
+    {{#if isECNIDefender}}maintenir{{else}}résister à{{/if}}
+    la possession de {{attacker.name}}
+  </h2>
   <div class="grid grid-2col">
     <div class="flex-group-left">
       <img class="chat-icon" src="{{competence.img}}" alt="{{competence.name}}"/>
       <div class="grid grid-2col">
         <label for="carac">Rêve actuel:</label><label class="flex-grow" name="carac">{{selectedCarac.value}}</label>
-        <label for="competence">{{competence.name}}:</label><label class="flex-grow" name="competence">{{numberFormat competence.data.niveau decimals=0 sign=true}}</label>
+        <label for="competence">{{competence.name}}:</label><label class="flex-grow" name="competence">{{numberFormat competence.system.niveau decimals=0 sign=true}}</label>
       </div>
     </div>
     <div class="flex-group-left">

templates/dialog-roll-jeu.html

@@ -5,10 +5,10 @@
     <div class="flex-group-left">
       <img class="chat-icon" src="{{competence.img}}" alt="{{competence.name}}"/>
       <div class="grid grid-2col">
-        <label>Type:</label><label class="flex-grow">{{oeuvre.data.type}}</label>
+        <label>Type:</label><label class="flex-grow">{{oeuvre.system.type}}</label>
         <label for="carac">Caractéristique:</label>{{>"systems/foundryvtt-reve-de-dragon/templates/partial-select-carac.html"}}
-        <label>{{competence.name}}:</label><label class="flex-grow">{{numberFormat competence.data.niveauReel decimals=0 sign=true}}</label></label>
-        <label>Niveau de base:</label><label class="flex-grow">{{oeuvre.data.base}}</label>
+        <label>{{competence.name}}:</label><label class="flex-grow">{{numberFormat competence.system.niveauReel decimals=0 sign=true}}</label></label>
+        <label>Niveau de base:</label><label class="flex-grow">{{oeuvre.system.base}}</label>
       </div>
     </div>
     <div class="flex-group-left">

templates/dialog-roll-maitrise-tmr.html

@@ -1,5 +1,10 @@
 <form class="skill-roll-dialog">
-  <h2>Maîtrise {{tmr.label}} ({{tmr.coord}})</h2>
+  <h2>Maîtrise {{#if isTMRCache}}
+    {{tmr.type}}
+  {{else}}
+    {{tmr.label}} ({{tmr.coord}})
+  {{/if}}
+  </h2>
   <div class="grid grid-2col">
     <div class="flex-group-left">
       <img class="chat-icon" src="{{competence.img}}" alt="{{competence.name}}"/>

templates/dialog-roll-meditation.html

@@ -4,14 +4,14 @@
     <div class="flex-group-left">
       <img class="chat-icon" src="{{competence.img}}" alt="{{competence.name}}" />
       <div class="flexcol">
-        <label><strong>{{meditation.data.theme}}</strong></label>
+        <label><strong>{{meditation.system.theme}}</strong></label>
         <hr>
-        <label>Support: <strong>{{upperFirst meditation.data.support}}</strong></label>
-        <label>Case TMR: <strong>{{typeTmr-name meditation.data.tmr}}</strong></label>
+        <label>Support: <strong>{{upperFirst meditation.system.support}}</strong></label>
+        <label>Case TMR: <strong>{{typeTmr-name meditation.system.tmr}}</strong></label>
         <label>Durée: 60 minutes</label>
         <hr>
         <label>Intellect / {{competence.name}}:
-          {{numberFormat carac.intellect.value decimals=0 sign=false}} / {{numberFormat competence.data.niveau decimals=0 sign=true}}</label>
+          {{numberFormat carac.intellect.value decimals=0 sign=false}} / {{numberFormat competence.system.niveau decimals=0 sign=true}}</label>
       </div>
     </div>
     <div class="flex-group-left">
@@ -19,19 +19,19 @@
         <label><strong>Conditions Optionnelles : </strong></label>
       </div>
       <div class="flexrow">
-        <label>Comportement antérieur : {{upperFirst meditation.data.comportement}}</label>
+        <label>Comportement antérieur : {{upperFirst meditation.system.comportement}}</label>
         <input class="attribute-value conditionMeditation" type="checkbox" id="isComportement" {{#if conditionMeditation.isComportement}}checked{{/if}} />
       </div>
       <div class="flexrow">
-        <label>Heure : {{upperFirst meditation.data.heure}}</label>
+        <label>Heure : {{upperFirst meditation.system.heure}}</label>
         <input class="attribute-value conditionMeditation" type="checkbox" id="isHeure" {{#if conditionMeditation.isHeure}}checked{{/if}} />
       </div>
       <div class="flexrow">
-        <label>Purification : {{upperFirst meditation.data.purification}}</label>
+        <label>Purification : {{upperFirst meditation.system.purification}}</label>
         <input class="attribute-value conditionMeditation" type="checkbox" id="isPurification" {{#if conditionMeditation.isPurification}}checked{{/if}} />
       </div>
       <div class="flexrow">
-        <label>Vêture : {{upperFirst meditation.data.veture}}</label>
+        <label>Vêture : {{upperFirst meditation.system.veture}}</label>
         <input class="attribute-value conditionMeditation" type="checkbox" id="isVeture" {{#if conditionMeditation.isVeture}}checked{{/if}} />
       </div>
       <hr>

templates/dialog-roll-musique.html

@@ -6,7 +6,7 @@
       <img class="chat-icon" src="{{competence.img}}" alt="{{competence.name}}" />
       <div class="grid grid-2col">
         <label>Caractéristique: </label><label class="flex-grow">{{selectedCarac.label}}</label>
-        <label>{{competence.name}}:</label><label class="flex-grow">{{numberFormat competence.data.niveau decimals=0 sign=true}}</label></label>
+        <label>{{competence.name}}:</label><label class="flex-grow">{{numberFormat competence.system.niveau decimals=0 sign=true}}</label></label>
       </div>
       {{> "systems/foundryvtt-reve-de-dragon/templates/partial-description-overflow.html" oeuvre.data}}
     </div>

templates/dialog-roll-oeuvre.html

@@ -7,9 +7,9 @@
       <div class="grid grid-2col">
         <label>Caractéristique: </label><label class="flex-grow">{{selectedCarac.label}}
         </label>
-        <label>{{competence.name}}:</label><label class="flex-grow">{{numberFormat competence.data.niveau decimals=0 sign=true}}</label></label>
+        <label>{{competence.name}}:</label><label class="flex-grow">{{numberFormat competence.system.niveau decimals=0 sign=true}}</label></label>
       </div>
-      {{> "systems/foundryvtt-reve-de-dragon/templates/partial-description-overflow.html" oeuvre.data}}
+      {{> "systems/foundryvtt-reve-de-dragon/templates/partial-description-overflow.html" oeuvre.system}}
     </div>
     <div class="flex-group-left">
       {{>"systems/foundryvtt-reve-de-dragon/templates/partial-roll-diffFixe.html"}}

templates/dialog-roll-signedraconique.html

@@ -1,4 +1,3 @@
-{{log 'lecture signe draconique' this}}
 <form class="dialog-roll-sort">
   <h2>Lire le signe draconique
     <select name="signe-draconique" class="roll-signedraconique flex-grow" data-dtype="String">

templates/hud-actor-attaque.html

@@ -1,10 +1,13 @@
 <div class="control-icon rdd-combat ">
   <img class="rdd-hud-togglebutton" src="systems/foundryvtt-reve-de-dragon/icons/heures/hd06.svg" width="36" height="36" title="Attaque"/>
   <div class="rdd-hud-list tokenhudext left">
-    {{#each armes as |arme key|}}
-    {{#unless arme.data.initOnly}}
-    <div class="control-icon tokenhudicon rdd-hud-menu rdd-attaque" data-combatant-id="{{../combatant.id}}" data-arme-id="{{arme.index}}"  title="{{arme.name}}">
-      <label>C:{{arme.name}}  {{arme.data.mainInfo}}</label>
+    {{#each actions as |action key|}}
+    {{#unless action.data.initOnly}}
+    <div class="control-icon tokenhudicon rdd-hud-menu rdd-attaque"
+        data-combatant-id="{{../combatant.id}}"
+        data-action-index="{{action.index}}"
+        title="{{action.name}}">
+      <label>{{action.name}}  {{action.data.mainInfo}}</label>
     </div>
     {{/unless}}
     {{/each}}

templates/hud-actor-init.html

@@ -1,14 +1,22 @@
 <div class="control-icon rdd-initiative ">
   <img class="rdd-hud-togglebutton" src="icons/svg/sword.svg" width="36" height="36" title="Initiative" />
   <div class="rdd-hud-list tokenhudext right">
-    {{#each armes as |arme key|}}
-    <div class="control-icon tokenhudicon rdd-hud-menu" data-command="{{arme.command}}" data-combatant-id="{{../combatant.id}}" data-arme-id="{{arme.index}}" title="{{arme.name}}">
-      <label>I:{{arme.name}} {{arme.data.mainInfo}}</label>
+    {{#each actions as |action key|}}
+    {{log 'action-hud-init' action}}
+    <div class="control-icon tokenhudicon rdd-hud-menu"
+        data-combatant-id="{{../combatant.id}}"
+        data-action-index="{{action.index}}"
+        title="{{action.name}}">
+      <label>init: {{action.name}} {{action.data.mainInfo}}</label>
     </div>
     {{/each}}
     {{#each commandes as |commande key|}}
-    <div class="control-icon tokenhudicon rdd-hud-menu" data-command="{{commande.command}}" data-combatant-id="{{../combatant.id}}" data-arme-id="{{commande.index}}" title="{{commande.name}}">
-      <label>I:{{commande.name}}</label>
+    <div class="control-icon tokenhudicon rdd-hud-menu"
+        data-command="{{commande.command}}" 
+        data-combatant-id="{{../combatant.id}}"
+        data-action-index="{{commande.index}}"
+        title="{{commande.name}}">
+      <label>{{commande.name}}</label>
     </div>
     {{/each}}    
   </div>

templates/item-monnaie-sheet.html

@@ -10,19 +10,19 @@
     <section class="sheet-body">
       <div class="form-group">
         <label for="xp">Quantité</label>
-        <input class="attribute-value" type="text" name="data.quantite" value="{{data.quantite}}" data-dtype="Number"/>
+        <input class="attribute-value" type="text" name="system.quantite" value="{{data.quantite}}" data-dtype="Number"/>
       </div>
       <div class="form-group">
         <label for="xp">Valeur en Deniers</label>
         {{#if isGM}}
-        <input class="attribute-value" type="text" name="data.valeur_deniers" value="{{data.valeur_deniers}}" data-dtype="Number"/>
+        <input class="attribute-value" type="text" name="system.valeur_deniers" value="{{data.valeur_deniers}}" data-dtype="Number"/>
         {{else}}
         <label for="xp">{{data.valeur_deniers}}</label>
         {{/if}}
       </div>
       <div class="form-group">
         <label for="xp">Encombrement</label>
-        <input class="attribute-value" type="text" name="data.encombrement" value="{{data.encombrement}}" data-dtype="Number"/>
+        <input class="attribute-value" type="text" name="system.encombrement" value="{{data.encombrement}}" data-dtype="Number"/>
       </div>
 
       {{>"systems/foundryvtt-reve-de-dragon/templates/partial-item-description.html"}}

templates/item-munition-sheet.html

@@ -10,19 +10,19 @@
     <section class="sheet-body">
       <div class="form-group">
         <label for="xp">Encombrement </label>
-        <input class="attribute-value" type="text" name="data.encombrement" value="{{data.encombrement}}" data-dtype="Number"/>
+        <input class="attribute-value" type="text" name="system.encombrement" value="{{data.encombrement}}" data-dtype="Number"/>
       </div>
       <div class="form-group">
         <label>Quantité </label>
-        <input class="attribute-value" type="text" name="data.quantite" value="{{data.quantite}}" data-dtype="Number" />
+        <input class="attribute-value" type="text" name="system.quantite" value="{{data.quantite}}" data-dtype="Number" />
       </div>      
       <div class="form-group">
         <label for="xp">Qualité</label>
-        <input class="attribute-value" type="text" name="data.qualite" value="{{data.qualite}}" data-dtype="Number"/>
+        <input class="attribute-value" type="text" name="system.qualite" value="{{data.qualite}}" data-dtype="Number"/>
       </div>
       <div class="form-group item-cout">
         <label for="xp">Prix (sols) </label>
-        <input class="attribute-value" type="text" name="data.cout" value="{{data.cout}}" data-dtype="Number"/>
+        <input class="attribute-value" type="text" name="system.cout" value="{{data.cout}}" data-dtype="Number"/>
       </div>
 
       {{>"systems/foundryvtt-reve-de-dragon/templates/partial-item-description.html"}}

templates/item-musique-sheet.html

@@ -10,11 +10,11 @@
     <section class="sheet-body">
       <div class="form-group">
         <label class="alchimie-title" for="xp">Niveau</label>
-        <input class="attribute-value" type="text" name="data.niveau" value="{{data.niveau}}" data-dtype="Number"/>
+        <input class="attribute-value" type="text" name="system.niveau" value="{{data.niveau}}" data-dtype="Number"/>
       </div>
       <div class="form-group">
         <label>Référence / Auteur</label>
-        <input class="attribute-value" type="text" name="data.reference" value="{{data.reference}}" data-dtype="String"/>
+        <input class="attribute-value" type="text" name="system.reference" value="{{data.reference}}" data-dtype="String"/>
       </div>
 
       {{>"systems/foundryvtt-reve-de-dragon/templates/partial-item-description.html"}}

templates/item-nombreastral-sheet.html

@@ -10,19 +10,19 @@
     <section class="sheet-body">
       <div class="form-group">
         <label for="xp">Nombre</label>
-        <input class="attribute-value" type="text" name="data.value" value="{{data.value}}" data-dtype="Number"/>
+        <input class="attribute-value" type="text" name="system.value" value="{{data.value}}" data-dtype="Number"/>
       </div>
       <div class="form-group">
         <label for="xp">Nombre valide ? </label>
-        <input class="attribute-value" type="checkbox" name="data.istrue"  {{#if data.istrue}}checked{{/if}}/>
+        <input class="attribute-value" type="checkbox" name="system.istrue"  {{#if data.istrue}}checked{{/if}}/>
       </div>
       <div class="form-group">
         <label for="xp">Index du jour concerné</label>
-        <input class="attribute-value" type="text" name="data.jourindex" value="{{data.jourindex}}" data-dtype="Number"/>
+        <input class="attribute-value" type="text" name="system.jourindex" value="{{data.jourindex}}" data-dtype="Number"/>
       </div>
       <div class="form-group">
         <label for="xp">Label du jour</label>
-        <input class="attribute-value" type="text" name="data.jourlabel" value="{{data.jourlabel}}" data-dtype="String"/>
+        <input class="attribute-value" type="text" name="system.jourlabel" value="{{data.jourlabel}}" data-dtype="String"/>
       </div>
 
     </section>

templates/item-nourritureboisson-sheet.html

@@ -10,48 +10,48 @@
   <section class="sheet-body">
     <div class="form-group">
       <label for="data.sust">Sustentation</label>
-      <input class="attribute-value" type="text" name="data.sust" value="{{data.sust}}" data-dtype="Number" />
+      <input class="attribute-value" type="text" name="system.sust" value="{{data.sust}}" data-dtype="Number" />
     </div>
     <div class="form-group">
       <label for="data.boisson">Boisson</label>
-      <input class="attribute-value" type="checkbox" name="data.boisson" {{#if data.boisson}}checked{{/if}} />
+      <input class="attribute-value" type="checkbox" name="system.boisson" {{#if data.boisson}}checked{{/if}} />
     </div>
     {{#if data.boisson}}
       <div class="form-group">
         <label for="data.desaltere">Désaltère de</label>
-        <input class="attribute-value" type="text" name="data.desaltere" value="{{data.desaltere}}" data-dtype="Number" />
+        <input class="attribute-value" type="text" name="system.desaltere" value="{{data.desaltere}}" data-dtype="Number" />
       </div>
       <div class="form-group">
         <label for="data.alcoolise">Alcoolisée</label>
-        <input class="attribute-value" type="checkbox" name="data.alcoolise" {{#if data.alcoolise}}checked{{/if}} />
+        <input class="attribute-value" type="checkbox" name="system.alcoolise" {{#if data.alcoolise}}checked{{/if}} />
       </div>
       {{#if data.alcoolise}}
       <div class="form-group">
         <label>Force de l'alcool par dose</label>
-        <input class="attribute-value" type="text" name="data.force" value="{{data.force}}" data-dtype="Number" />
+        <input class="attribute-value" type="text" name="system.force" value="{{data.force}}" data-dtype="Number" />
       </div>
       {{/if}}
     {{/if}}
     <div class="form-group">
         <label for="data.qualite">Qualité</label>
-        <input class="attribute-value" type="text" name="data.qualite" value="{{data.qualite}}" data-dtype="Number" />
+        <input class="attribute-value" type="text" name="dasystemta.qualite" value="{{data.qualite}}" data-dtype="Number" />
     </div>
     <div class="form-group">
       <label for="data.exotisme">Exotisme</label>
-      <input class="attribute-value" type="text" name="data.exotisme" value="{{data.exotisme}}" data-dtype="Number" />
+      <input class="attribute-value" type="text" name="system.exotisme" value="{{data.exotisme}}" data-dtype="Number" />
     </div>
     <div class="form-group">
       <label for="data.encombrement">Encombrement</label>
-      <input class="attribute-value" type="text" name="data.encombrement" value="{{data.encombrement}}"
+      <input class="attribute-value" type="text" name="system.encombrement" value="{{data.encombrement}}"
         data-dtype="Number" />
     </div>
     <div class="form-group">
       <label for="data.quantite">Quantité</label>
-      <input class="attribute-value" type="text" name="data.quantite" value="{{data.quantite}}" data-dtype="Number" />
+      <input class="attribute-value" type="text" name="system.quantite" value="{{data.quantite}}" data-dtype="Number" />
     </div>
     <div class="form-group item-cout">
       <label for="data.cout">Prix (sols) </label>
-      <input class="attribute-value" type="text" name="data.cout" value="{{data.cout}}" data-dtype="Number" />
+      <input class="attribute-value" type="text" name="system.cout" value="{{data.cout}}" data-dtype="Number" />
     </div>
 
     {{>"systems/foundryvtt-reve-de-dragon/templates/partial-item-description.html"}}

templates/item-objet-sheet.html

@@ -10,23 +10,23 @@
     <section class="sheet-body">
       <div class="form-group">
         <label for="xp">Encombrement </label>
-        <input class="attribute-value" type="text" name="data.encombrement" value="{{data.encombrement}}" data-dtype="Number"/>
+        <input class="attribute-value" type="text" name="system.encombrement" value="{{data.encombrement}}" data-dtype="Number"/>
       </div>
       <div class="form-group">
         <label>Quantité </label>
-        <input class="attribute-value" type="text" name="data.quantite" value="{{data.quantite}}" data-dtype="Number" />
+        <input class="attribute-value" type="text" name="system.quantite" value="{{data.quantite}}" data-dtype="Number" />
       </div>
       <div class="form-group">
         <label for="xp">Résistance</label>
-        <input class="attribute-value" type="text" name="data.resistance" value="{{data.resistance}}" data-dtype="Number"/>
+        <input class="attribute-value" type="text" name="system.resistance" value="{{data.resistance}}" data-dtype="Number"/>
       </div>
       <div class="form-group">
         <label for="xp">Qualité</label>
-        <input class="attribute-value" type="text" name="data.qualite" value="{{data.qualite}}" data-dtype="Number"/>
+        <input class="attribute-value" type="text" name="system.qualite" value="{{data.qualite}}" data-dtype="Number"/>
       </div>
       <div class="form-group item-cout">
         <label for="xp">Prix (sols) </label>
-        <input class="attribute-value" type="text" name="data.cout" value="{{data.cout}}" data-dtype="Number"/>
+        <input class="attribute-value" type="text" name="system.cout" value="{{data.cout}}" data-dtype="Number"/>
       </div>
 
       {{>"systems/foundryvtt-reve-de-dragon/templates/partial-item-description.html"}}

templates/item-oeuvre-sheet.html

@@ -10,7 +10,7 @@
     <section class="sheet-body">
       <div class="form-group">
         <label>Caractéristique</label>
-        <select name="data.default_carac" id="default_carac" data-dtype="String">
+        <select name="system.default_carac" id="default_carac" data-dtype="String">
           {{#select data.default_carac}}
           {{>"systems/foundryvtt-reve-de-dragon/templates/competence-carac-defaut.html"}}
           {{/select}}
@@ -18,7 +18,7 @@
       </div>
       <div class="form-group">
         <label>Compétence</label>
-        <select name="data.competence" id="competenceselect" data-dtype="String">
+        <select name="system.competence" id="competenceselect" data-dtype="String">
           {{#select data.competence}}
           {{#each competences as |competence key|}}
           <option value="{{competence.name}}">{{competence.name}}</option>
@@ -28,11 +28,11 @@
       </div>
       <div class="form-group">
         <label>Référence / Auteur</label>
-        <input class="attribute-value" type="text" name="data.reference" value="{{data.reference}}" data-dtype="String"/>
+        <input class="attribute-value" type="text" name="system.reference" value="{{data.reference}}" data-dtype="String"/>
       </div>
       <div class="form-group">
         <label>Niveau</label>
-        <input class="attribute-value" type="text" name="data.niveau" value="{{data.niveau}}" data-dtype="Number"/>
+        <input class="attribute-value" type="text" name="system.niveau" value="{{data.niveau}}" data-dtype="Number"/>
       </div>
 
       {{>"systems/foundryvtt-reve-de-dragon/templates/partial-item-description.html"}}

templates/item-ombre-sheet.html

@@ -10,7 +10,7 @@
     <section class="sheet-body">
       <div class="form-group">
         <label for="xp">Refoulement</label>
-        <input class="attribute-value" type="text" name="data.refoulement" value="{{data.refoulement}}" data-dtype="Number"/>
+        <input class="attribute-value" type="text" name="system.refoulement" value="{{data.refoulement}}" data-dtype="Number"/>
       </div>
 
       {{>"systems/foundryvtt-reve-de-dragon/templates/partial-item-description.html"}}