Merge P3

Reviewed-on: public/foundryvtt-reve-de-dragon#621

.gitignore

@@ -3,3 +3,7 @@
 todo.md
 /.vscode
 /ignored/
+/node_modules/
+/jsconfig.json
+/package.json
+/package-lock.json

lang/fr.json

@@ -3,6 +3,7 @@
     "TypePersonnage": "Personnage",
     "TypeCreature": "Créature",
     "TypeEntite": "Entité de cauchemar",
+    "TypeCommerce": "Commerce",
     "TypeVehicule": "Véhicule"
   },
   "ITEM": {
@@ -18,14 +19,17 @@
     "TypeRencontre": "Rencontre TMR",
     "TypeMunition": "Munition",
     "TypeMonnaie": "Monnaie",
-    "TypeHerbe": "Herbe ou plante",
+    "TypeHerbe": "Herbe",
+    "TypePlante": "Plante",
     "TypeIngredient": "Ingrédient",
+    "TypeFaune": "Faune",
     "TypeLivre": "Livre",
     "TypePotion": "Potion",
     "TypeArme": "Arme",
     "TypeArmure": "Armure",
     "TypeConteneur": "Conteneur",
     "TypeNourritureboisson": "Nourriture & boisson",
+    "TypeService": "Service",
     "TypeChant": "Chant",
     "TypeDanse": "Danse",
     "TypeMusique": "Musique",

module/actor-creature-sheet.js

@@ -27,24 +27,17 @@ export class RdDActorCreatureSheet extends RdDActorSheet {
     if (!this.options.editable) return;
 
     // On competence change
-    html.find('.creature-carac').change(async event => {
+    this.html.find('.creature-carac').change(async event => {
       let compName = event.currentTarget.attributes.compname.value;
       this.actor.updateCreatureCompetence(compName, "carac_value", parseInt(event.target.value));
     });
-    html.find('.creature-niveau').change(async event => {
+    this.html.find('.creature-niveau').change(async event => {
       let compName = event.currentTarget.attributes.compname.value;
       this.actor.updateCreatureCompetence(compName, "niveau", parseInt(event.target.value));
     });
-    html.find('.creature-dommages').change(async event => {
+    this.html.find('.creature-dommages').change(async event => {
       let compName = event.currentTarget.attributes.compname.value;
       this.actor.updateCreatureCompetence(compName, "dommages", parseInt(event.target.value));
     });
   }
-
-  /* -------------------------------------------- */
-  /** @override */
-  _updateObject(event, formData) {
-    // Update the Actor
-    return this.object.update(formData);
-  }
 }

module/actor-entite-sheet.js

@@ -3,38 +3,38 @@ import { RdDActorSheet } from "./actor-sheet.js";
 export class RdDActorEntiteSheet extends RdDActorSheet {
 
   /** @override */
-	static get defaultOptions() {
-	  return mergeObject(super.defaultOptions, {
-  	  classes: ["rdd", "sheet", "actor"],
-  	  template: "systems/foundryvtt-reve-de-dragon/templates/actor-entite-sheet.html",
+  static get defaultOptions() {
+    return mergeObject(super.defaultOptions, {
+      classes: ["rdd", "sheet", "actor"],
+      template: "systems/foundryvtt-reve-de-dragon/templates/actor-entite-sheet.html",
       width: 640,
       height: 720,
-      tabs: [{navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac"}],
-      dragDrop: [{dragSelector: ".item-list .item", dropSelector: undefined}]
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }]
     });
   }
 
   /* -------------------------------------------- */
   /** @override */
-	activateListeners(html) {
+  activateListeners(html) {
     super.activateListeners(html);
 
     // Everything below here is only needed if the sheet is editable
     if (!this.options.editable) return;
 
     // On competence change
-    html.find('.creature-carac').change(async event => {
-        let compName = event.currentTarget.attributes.compname.value;
-        this.actor.updateCreatureCompetence( compName, "carac_value", parseInt(event.target.value) );
-      } );    
-    html.find('.creature-niveau').change(async event => {
-        let compName = event.currentTarget.attributes.compname.value;
-        this.actor.updateCreatureCompetence( compName, "niveau", parseInt(event.target.value) );
-      } );    
-      html.find('.creature-dommages').change(async event => {
-        let compName = event.currentTarget.attributes.compname.value;
-        this.actor.updateCreatureCompetence( compName, "dommages", parseInt(event.target.value) );
-      } );    
+    this.html.find('.creature-carac').change(async event => {
+      let compName = event.currentTarget.attributes.compname.value;
+      this.actor.updateCreatureCompetence(compName, "carac_value", parseInt(event.target.value));
+    });
+    this.html.find('.creature-niveau').change(async event => {
+      let compName = event.currentTarget.attributes.compname.value;
+      this.actor.updateCreatureCompetence(compName, "niveau", parseInt(event.target.value));
+    });
+    this.html.find('.creature-dommages').change(async event => {
+      let compName = event.currentTarget.attributes.compname.value;
+      this.actor.updateCreatureCompetence(compName, "dommages", parseInt(event.target.value));
+    });
   }
 
 }

module/actor-sheet.js

@@ -8,16 +8,18 @@ import { RdDCombatManager } from "./rdd-combat.js";
 import { RdDCarac } from "./rdd-carac.js";
 import { DialogSplitItem } from "./dialog-split-item.js";
 import { ReglesOptionelles } from "./settings/regles-optionelles.js";
-import { DialogRepos } from "./dialog-repos.js";
 import { RdDSheetUtility } from "./rdd-sheet-utility.js";
 import { STATUSES } from "./settings/status-effects.js";
+import { MAINS_DIRECTRICES } from "./actor.js";
+import { RdDBaseActorSheet } from "./actor/base-actor-sheet.js";
+import { RdDItem } from "./item.js";
 
 /* -------------------------------------------- */
 /**
  * Extend the basic ActorSheet with some very simple modifications
  * @extends {ActorSheet}
  */
-export class RdDActorSheet extends ActorSheet {
+export class RdDActorSheet extends RdDBaseActorSheet {
 
   /** @override */
   static get defaultOptions() {
@@ -25,7 +27,7 @@ export class RdDActorSheet extends ActorSheet {
     return mergeObject(super.defaultOptions, {
       classes: ["rdd", "sheet", "actor"],
       template: "systems/foundryvtt-reve-de-dragon/templates/actor-sheet.html",
-      width: 640,
+      width: 550,
       tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }],
       dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }],
       showCompNiveauBase: false,
@@ -35,50 +37,38 @@ export class RdDActorSheet extends ActorSheet {
 
   /* -------------------------------------------- */
   async getData() {
+    let formData = await super.getData();
+    mergeObject(formData,
+      {
+        editable: this.isEditable,
+        cssClass: this.isEditable ? "editable" : "locked",
+        effects: this.actor.effects.map(e => foundry.utils.deepClone(e)),
+        limited: this.actor.limited,
+        owner: this.actor.isOwner,
+        biographie: await TextEditor.enrichHTML(this.actor.system.biographie, { async: true }),
+        notes: await TextEditor.enrichHTML(this.actor.system.notes, { async: true }),
+      });
+    mergeObject(formData.calc, {
+      surenc: this.actor.computeMalusSurEncombrement(),
+      surprise: RdDBonus.find(this.actor.getSurprise(false)).descr,
+      resumeBlessures: this.actor.computeResumeBlessure(this.actor.system.blessures),
+      caracTotal: RdDCarac.computeTotal(this.actor.system.carac, this.actor.system.beaute),
+      surEncombrementMessage: this.actor.getMessageSurEncombrement(),
+    })
+
     this.timerRecherche = undefined;
 
-    let formData = {
-      title: this.title,
-      id: this.actor.id,
-      type: this.actor.type,
-      img: this.actor.img,
-      name: this.actor.name,
-      editable: this.isEditable,
-      cssClass: this.isEditable ? "editable" : "locked",
-      system: foundry.utils.deepClone(this.actor.system),
-      effects: this.actor.effects.map(e => foundry.utils.deepClone(e)),
-      limited: this.actor.limited,
-      options: this.options,
-      owner: this.actor.isOwner,
-      description: await TextEditor.enrichHTML(this.object.system.description, {async: true}),
-      biographie: await TextEditor.enrichHTML(this.object.system.biographie, {async: true}),
-      notes: await TextEditor.enrichHTML(this.object.system.notes, {async: true}),
-      notesmj: await TextEditor.enrichHTML(this.object.system.notesmj, {async: true}),
-      calc: {
-        encTotal: await this.actor.computeEncombrementTotalEtMalusArmure(),
-        prixTotalEquipement: this.actor.computePrixTotalEquipement(),
-        surprise: RdDBonus.find(this.actor.getSurprise(false)).descr,
-        resumeBlessures: this.actor.computeResumeBlessure(this.actor.system.blessures),
-        caracTotal: RdDCarac.computeTotal(this.actor.system.carac, this.actor.system.beaute),
-        surEncombrementMessage: this.actor.getMessageSurEncombrement(),
-      },
-    }
-    formData.options.isGM =  game.user.isGM;
-
-    RdDUtility.filterItemsPerTypeForSheet(formData, this.actor.itemTypes);
-    this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.objets);
-    formData.conteneurs = RdDUtility.conteneursRacine(formData.conteneurs);
-
     if (formData.type == 'personnage') {
+      formData.options.mainsDirectrices = MAINS_DIRECTRICES;
       formData.byCateg = Misc.classify(formData.competences, it => it.system.categorie)
-      formData.calc.comptageArchetype =  RdDItemCompetence.computeResumeArchetype(formData.competences);
-      formData.calc.competenceXPTotal= RdDItemCompetence.computeTotalXP(formData.competences);
-      formData.calc.fatigue= RdDUtility.calculFatigueHtml(formData.system.sante.fatigue.value, formData.system.sante.endurance.max);
+      formData.calc.comptageArchetype = RdDItemCompetence.computeResumeArchetype(formData.competences);
+      formData.calc.competenceXPTotal = RdDItemCompetence.computeTotalXP(formData.competences);
+      formData.calc.fatigue = RdDUtility.calculFatigueHtml(formData.system.sante.fatigue.value, formData.system.sante.endurance.max);
 
       formData.competences.forEach(item => {
         item.system.isVisible = this.options.recherche
-        ? RdDItemCompetence.nomContientTexte(item, this.options.recherche.text)
-        : (!this.options.showCompNiveauBase || !RdDItemCompetence.isNiveauBase(item));
+          ? RdDItemCompetence.nomContientTexte(item, this.options.recherche.text)
+          : (!this.options.showCompNiveauBase || !RdDItemCompetence.isNiveauBase(item));
         RdDItemCompetence.levelUp(item, formData.system.compteurs.experience.value);
       });
 
@@ -117,76 +107,18 @@ export class RdDActorSheet extends ActorSheet {
     return formData;
   }
 
-  isCompetenceAffichable(competence) {
-    return !this.options.showCompNiveauBase || !RdDItemCompetence.isNiveauBase(competence);
-  }
-
-  /* -------------------------------------------- */
-  async _onDropActor(event, dragData) {
-    const dropActor = fromUuidSync(dragData.uuid);
-    this.actor.addSubActeur(dropActor);
-    super._onDropActor(event, dragData);
-  }
-
-  /* -------------------------------------------- */
-  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)
-    if (callSuper) {
-      await super._onDropItem(event, dragData)
-    }
-  }
-
-  /* -------------------------------------------- */
-  async createItem(name, type) {
-    await this.actor.createEmbeddedDocuments('Item', [{ name: name, type: type }], { renderSheet: true });
-  }
-
-  /* -------------------------------------------- */
-  async createEmptyTache() {
-    await this.createItem('Nouvelle tache', 'tache');
-  }
-
   /* -------------------------------------------- */  /** @override */
   activateListeners(html) {
     super.activateListeners(html);
 
-    HtmlUtility._showControlWhen($(".appliquerFatigue"), ReglesOptionelles.isUsing("appliquer-fatigue"));
+    HtmlUtility.showControlWhen(this.html.find(".appliquerFatigue"), ReglesOptionelles.isUsing("appliquer-fatigue"));
 
     // Everything below here is only needed if the sheet is editable
     if (!this.options.editable) return;
 
-    html.find('.item-split').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
-      RdDSheetUtility.splitItem(item, this.actor);
-    });
-    html.find('.item-edit').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor)
-      item.sheet.render(true)
-    })
-    html.find('.display-label a').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
-      item.sheet.render(true);
-    });
-    html.find('.item-delete').click(async event => {
-      const li = RdDSheetUtility.getEventElement(event);
-      const item = this.actor.getObjet(li.data("item-id"));
-      RdDUtility.confirmerSuppressionItem(this, item, li);
-    });
-    html.find('.item-vendre').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
-      item?.proposerVente();
-    });
-    html.find('.item-montrer').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
-      item?.postItem();
-    });
-    html.find('.item-action').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor)
-      this.actor.actionItem(item);
-    });
-    html.find('.subacteur-delete').click(async event => {
+    this.html.find('.item-action').click(async event => RdDSheetUtility.getItem(event, this.actor)?.actionPrincipale(this.actor));
+
+    this.html.find('.subacteur-delete').click(async event => {
       const li = RdDSheetUtility.getEventElement(event);
       const actorId = li.data("actor-id");
       if (actorId) {
@@ -194,54 +126,57 @@ export class RdDActorSheet extends ActorSheet {
         RdDUtility.confirmerSuppressionSubacteur(this, subActor, li);
       }
     });
-    html.find('.experiencelog-delete').click(async event => {
-      const li = $(event.currentTarget)?.parents(".experiencelog");
+    this.html.find('.experiencelog-delete').click(async event => {
+      const li = this.html.find(event.currentTarget)?.parents(".experiencelog");
       const key = Number(li.data("key") ?? -1);
       await this.actor.deleteExperienceLog(key, 1);
     });
-    html.find('.experiencelog-delete-previous').click(async event => {
-      const li = $(event.currentTarget)?.parents(".experiencelog");
+    this.html.find('.experiencelog-delete-previous').click(async event => {
+      const li = this.html.find(event.currentTarget)?.parents(".experiencelog");
       const key = Number(li.data("key") ?? -1);
       await this.actor.deleteExperienceLog(0, key + 1);
     });
-    html.find('.encaisser-direct').click(async event => {
+    this.html.find('.encaisser-direct').click(async event => {
       this.actor.encaisser();
     })
-    html.find('.sheet-possession-attack').click(async event => {
+    this.html.find('.sheet-possession-attack').click(async event => {
       const poss = RdDSheetUtility.getItem(event, this.actor)
       this.actor.conjurerPossession(poss)
     })
-    html.find('.remise-a-neuf').click(async event => {
+    this.html.find('.remise-a-neuf').click(async event => {
       if (game.user.isGM) {
         this.actor.remiseANeuf();
       }
     });
-    html.find('.creer-tache').click(async event => {
+    this.html.find('.creer-tache').click(async event => {
       this.createEmptyTache();
     });
-    html.find('.creer-un-objet').click(async event => {
-      RdDUtility.selectObjetType(this);
+    this.html.find('.creer-tache-blessure-legere').click(async event => {
+      this.actor.createTacheBlessure('legere');
     });
-    html.find('.creer-une-oeuvre').click(async event => {
-      RdDUtility.selectTypeOeuvre(this);
+    this.html.find('.creer-tache-blessure-grave').click(async event => {
+      this.actor.createTacheBlessure('grave');
     });
-    html.find('.nettoyer-conteneurs').click(async event => {
-      this.actor.nettoyerConteneurs();
+    this.html.find('.creer-tache-blessure-critique').click(async event => {
+      this.actor.createTacheBlessure('critique');
+    });
+    this.html.find('.creer-une-oeuvre').click(async event => {
+      this.selectTypeOeuvreToCreate();
     });
 
     // Blessure control
-    html.find('.blessure-control').click(async event => {
-      const tr = $(event.currentTarget).parents(".item");
+    this.html.find('.blessure-control').click(async event => {
+      const tr = this.html.find(event.currentTarget).parents(".item");
       let btype = tr.data("blessure-type");
       let index = tr.data('blessure-index');
-      let active = $(event.currentTarget).data('blessure-active');
+      let active = this.html.find(event.currentTarget).data('blessure-active');
       //console.log(btype, index, active);
       await this.actor.manageBlessureFromSheet(btype, index, active);
     });
 
     // Blessure data
-    html.find('.blessure-soins').change(async event => {
-      const tr = $(event.currentTarget).parents(".item");
+    this.html.find('.blessure-soins').change(async event => {
+      const tr = this.html.find(event.currentTarget).parents(".item");
       let btype = tr.data('blessure-type');
       let index = tr.data('blessure-index');
       let psoins = tr.find('.blessure-premiers_soins').val();
@@ -255,57 +190,57 @@ export class RdDActorSheet extends ActorSheet {
     });
 
     // Equip Inventory Item
-    html.find('.item-equip').click(async event => {
+    this.html.find('.item-equip').click(async event => {
       this.actor.equiperObjet(RdDSheetUtility.getItemId(event));
     });
 
     // Roll Carac
-    html.find('.carac-label a').click(async event => {
+    this.html.find('.carac-label a').click(async event => {
       let caracName = event.currentTarget.attributes.name.value;
       this.actor.rollCarac(caracName.toLowerCase());
     });
 
-    html.find('.chance-actuelle').click(async event => {
+    this.html.find('.chance-actuelle').click(async event => {
       this.actor.rollCarac('chance-actuelle');
     });
 
-    html.find('.chance-appel').click(async event => {
+    this.html.find('.chance-appel').click(async event => {
       this.actor.rollAppelChance();
     });
 
-    html.find('#jet-astrologie').click(async event => {
+    this.html.find('[name="jet-astrologie"]').click(async event => {
       this.actor.astrologieNombresAstraux();
     });
 
     // Roll Skill
-    html.find('a.competence-label').click(async event => {
+    this.html.find('a.competence-label').click(async event => {
       this.actor.rollCompetence(RdDSheetUtility.getItemId(event));
     });
-    html.find('.tache-label a').click(async event => {
+    this.html.find('.tache-label a').click(async event => {
       this.actor.rollTache(RdDSheetUtility.getItemId(event));
     });
-    html.find('.meditation-label a').click(async event => {
+    this.html.find('.meditation-label a').click(async event => {
       this.actor.rollMeditation(RdDSheetUtility.getItemId(event));
     });
-    html.find('.chant-label a').click(async event => {
+    this.html.find('.chant-label a').click(async event => {
       this.actor.rollChant(RdDSheetUtility.getItemId(event));
     });
-    html.find('.danse-label a').click(async event => {
+    this.html.find('.danse-label a').click(async event => {
       this.actor.rollDanse(RdDSheetUtility.getItemId(event));
     });
-    html.find('.musique-label a').click(async event => {
+    this.html.find('.musique-label a').click(async event => {
       this.actor.rollMusique(RdDSheetUtility.getItemId(event));
     });
-    html.find('.oeuvre-label a').click(async event => {
+    this.html.find('.oeuvre-label a').click(async event => {
       this.actor.rollOeuvre(RdDSheetUtility.getItemId(event));
     });
-    html.find('.jeu-label a').click(async event => {
+    this.html.find('.jeu-label a').click(async event => {
       this.actor.rollJeu(RdDSheetUtility.getItemId(event));
     });
-    html.find('.recettecuisine-label a').click(async event => {
+    this.html.find('.recettecuisine-label a').click(async event => {
       this.actor.rollRecetteCuisine(RdDSheetUtility.getItemId(event));
     });
-    html.find('.subacteur-label a').click(async event => {
+    this.html.find('.subacteur-label a').click(async event => {
       let actorId = RdDSheetUtility.getEventItemData(event, 'actor-id');
       let actor = game.actors.get(actorId);
       if (actor) {
@@ -314,25 +249,25 @@ export class RdDActorSheet extends ActorSheet {
     });
 
     // Boutons spéciaux MJs
-    html.find('.forcer-tmr-aleatoire').click(async event => {
+    this.html.find('.forcer-tmr-aleatoire').click(async event => {
       this.actor.reinsertionAleatoire("Action MJ");
     });
-    html.find('.afficher-tmr').click(async event => {
+    this.html.find('.afficher-tmr').click(async event => {
       this.actor.changeTMRVisible();
     });
 
     // Points de reve actuel
-    html.find('.ptreve-actuel a').click(async event => {
-      this.actor.rollCarac('reve-actuel');
+    this.html.find('.ptreve-actuel a').click(async event => {
+      this.actor.rollCarac('reve-actuel', true);
     });
 
     // Roll Weapon1
-    html.find('.arme-label a').click(async event => {
+    this.html.find('.arme-label a').click(async event => {
       let arme = this._getEventArmeCombat(event);
       this.actor.rollArme(duplicate(arme));
     });
     // Initiative pour l'arme
-    html.find('.arme-initiative a').click(async event => {
+    this.html.find('.arme-initiative a').click(async event => {
       let combatant = game.combat.combatants.find(c => c.actor.id == this.actor.id);
       if (combatant) {
         let action = this._getEventArmeCombat(event);
@@ -342,88 +277,84 @@ export class RdDActorSheet extends ActorSheet {
       }
     });
     // Display TMR, visualisation
-    html.find('.visu-tmr').click(async event => {
+    this.html.find('.visu-tmr').click(async event => {
       this.actor.displayTMR("visu");
     });
 
     // Display TMR, normal
-    html.find('.monte-tmr').click(async event => {
+    this.html.find('.monte-tmr').click(async event => {
       this.actor.displayTMR("normal");
     });
 
     // Display TMR, fast 
-    html.find('.monte-tmr-rapide').click(async event => {
+    this.html.find('.monte-tmr-rapide').click(async event => {
       this.actor.displayTMR("rapide");
     });
 
-    html.find('.repos').click(async event => {
-      await DialogRepos.create(this.actor);
+    this.html.find('.repos').click(async event => {
+      await this.actor.repos();
     });
-    html.find('.delete-active-effect').click(async event => {
+    this.html.find('.delete-active-effect').click(async event => {
       if (game.user.isGM) {
-        let effect = $(event.currentTarget).parents(".active-effect").data('effect');
+        let effect = this.html.find(event.currentTarget).parents(".active-effect").data('effect');
         this.actor.removeEffect(effect);
       }
     });
-    html.find('.enlever-tous-effets').click(async event => {
+    this.html.find('.enlever-tous-effets').click(async event => {
       if (game.user.isGM) {
         await this.actor.removeEffects();
       }
     });
-    html.find('.conteneur-name a').click(async event => {
-      RdDUtility.toggleAfficheContenu(RdDSheetUtility.getItemId(event));
-      this.render(true);
-    });
-    html.find('.carac-xp-augmenter').click(async event => {
+    this.html.find('.carac-xp-augmenter').click(async event => {
       let caracName = event.currentTarget.name.replace("augmenter.", "");
       this.actor.updateCaracXPAuto(caracName);
     });
-    html.find('.competence-xp-augmenter').click(async event => {
+    this.html.find('.competence-xp-augmenter').click(async event => {
       this.actor.updateCompetenceXPAuto(RdDSheetUtility.getItemId(event));
     });
-    html.find('.competence-stress-augmenter').click(async event => {
+    this.html.find('.competence-stress-augmenter').click(async event => {
       this.actor.updateCompetenceStress(RdDSheetUtility.getItemId(event));
     });
 
     if (this.options.vueDetaillee) {
       // On carac change
-      html.find('.carac-value').change(async event => {
+      this.html.find('.carac-value').change(async event => {
         let caracName = event.currentTarget.name.replace(".value", "").replace("system.carac.", "");
         this.actor.updateCarac(caracName, parseInt(event.target.value));
       });
-      html.find('input.carac-xp').change(async event => {
+      this.html.find('input.carac-xp').change(async event => {
         let caracName = event.currentTarget.name.replace(".xp", "").replace("system.carac.", "");
         this.actor.updateCaracXP(caracName, parseInt(event.target.value));
       });
       // On competence change
-      html.find('.competence-value').change(async event => {
+      this.html.find('.competence-value').change(async event => {
         let compName = event.currentTarget.attributes.compname.value;
         //console.log("Competence changed :", compName);
         this.actor.updateCompetence(compName, parseInt(event.target.value));
       });
       // On competence xp change
-      html.find('input.competence-xp').change(async event => {
+      this.html.find('input.competence-xp').change(async event => {
         let compName = event.currentTarget.attributes.compname.value;
         this.actor.updateCompetenceXP(compName, parseInt(event.target.value));
       });
       // On competence xp change
-      html.find('input.competence-xp-sort').change(async event => {
+      this.html.find('input.competence-xp-sort').change(async event => {
         let compName = event.currentTarget.attributes.compname.value;
         this.actor.updateCompetenceXPSort(compName, parseInt(event.target.value));
       });
       // On competence archetype change
-      html.find('.competence-archetype').change(async event => {
+      this.html.find('.competence-archetype').change(async event => {
         let compName = event.currentTarget.attributes.compname.value;
         this.actor.updateCompetenceArchetype(compName, parseInt(event.target.value));
       });
     }
 
-    html.find('.show-hide-competences').click(async event => {
+    this.html.find('.show-hide-competences').click(async event => {
       this.options.showCompNiveauBase = !this.options.showCompNiveauBase;
       this.render(true);
     });
 
-    html.find('.recherche')
+    this.html.find('.recherche')
       .each((index, field) => {
         if (this.options.recherche) {
           field.focus();
@@ -432,7 +363,7 @@ export class RdDActorSheet extends ActorSheet {
       })
       .keyup(async event => {
         const nouvelleRecherche = this._optionRecherche(event.currentTarget);
-        if (this.options.recherche?.text != nouvelleRecherche?.text){
+        if (this.options.recherche?.text != nouvelleRecherche?.text) {
           this.options.recherche = nouvelleRecherche;
           if (this.timerRecherche) {
             clearTimeout(this.timerRecherche);
@@ -446,94 +377,117 @@ export class RdDActorSheet extends ActorSheet {
       .change(async event =>
         this.options.recherche = this._optionRecherche(event.currentTarget)
       );
-    html.find('.vue-detaillee').click(async event => {
+    this.html.find('.vue-detaillee').click(async event => {
       this.options.vueDetaillee = !this.options.vueDetaillee;
       this.render(true);
     });
 
     // On pts de reve change
-    html.find('.pointsreve-value').change(async event => {
+    this.html.find('.pointsreve-value').change(async event => {
       let reveValue = event.currentTarget.value;
       this.actor.update({ "system.reve.reve.value": reveValue });
     });
 
     // On seuil de reve change
-    html.find('.seuil-reve-value').change(async event => {
+    this.html.find('.seuil-reve-value').change(async event => {
       console.log("seuil-reve-value", event.currentTarget)
       this.actor.setPointsDeSeuil(event.currentTarget.value);
     });
 
-    html.find('#attribut-protection-edit').change(async event => {
-      this.actor.updateAttributeValue(event.currentTarget.attributes.name.value, parseInt(event.target.value));
-    });
-
     // On stress change
-    html.find('.compteur-edit').change(async event => {
+    this.html.find('.compteur-edit').change(async event => {
       let fieldName = event.currentTarget.attributes.name.value;
       this.actor.updateCompteurValue(fieldName, parseInt(event.target.value));
     });
 
-    html.find('#ethylisme').change(async event => {
-      this.actor.setEthylisme(parseInt(event.target.value));
-    });
-    html.find('.stress-test').click(async event => {
+    this.html.find('.stress-test').click(async event => {
       this.actor.transformerStress();
     });
-    html.find('.moral-malheureux').click(async event => {
+    this.html.find('.moral-malheureux').click(async event => {
       this.actor.jetDeMoral('malheureuse');
     });
-    html.find('.moral-neutre').click(async event => {
+    this.html.find('.moral-neutre').click(async event => {
       this.actor.jetDeMoral('neutre');
     });
-    html.find('.moral-heureux').click(async event => {
+    this.html.find('.moral-heureux').click(async event => {
       this.actor.jetDeMoral('heureuse');
     });
-    html.find('.ethylisme-test').click(async event => {
+    this.html.find('.ethylisme-test').click(async event => {
       this.actor.jetEthylisme();
     });
 
-    html.find('.jet-vie').click(async event => {
+    this.html.find('.jet-vie').click(async event => {
       this.actor.jetVie();
     });
-    html.find('.jet-endurance').click(async event => {
+    this.html.find('.jet-endurance').click(async event => {
       this.actor.jetEndurance();
     });
 
-    html.find('.monnaie-plus').click(async event => {
-      this.actor.monnaieIncDec(RdDSheetUtility.getItemId(event), 1);
-    });
-    html.find('.monnaie-moins').click(async event => {
-      this.actor.monnaieIncDec(RdDSheetUtility.getItemId(event), -1);
-    });
-
-    html.find('.vie-plus').click(async event => {
+    this.html.find('.vie-plus').click(async event => {
       this.actor.santeIncDec("vie", 1);
     });
-    html.find('.vie-moins').click(async event => {
+    this.html.find('.vie-moins').click(async event => {
       this.actor.santeIncDec("vie", -1);
     });
-    html.find('.endurance-plus').click(async event => {
+    this.html.find('.endurance-plus').click(async event => {
       this.actor.santeIncDec("endurance", 1);
     });
-    html.find('.endurance-moins').click(async event => {
+    this.html.find('.endurance-moins').click(async event => {
       this.actor.santeIncDec("endurance", -1);
     });
-    html.find('.ptreve-actuel-plus').click(async event => {
+    this.html.find('.ptreve-actuel-plus').click(async event => {
       this.actor.reveActuelIncDec(1);
     });
-    html.find('.ptreve-actuel-moins').click(async event => {
+    this.html.find('.ptreve-actuel-moins').click(async event => {
       this.actor.reveActuelIncDec(-1);
     });
-    html.find('.fatigue-plus').click(async event => {
+    this.html.find('.fatigue-plus').click(async event => {
       this.actor.santeIncDec("fatigue", 1);
     });
-    html.find('.fatigue-moins').click(async event => {
+    this.html.find('.fatigue-moins').click(async event => {
       this.actor.santeIncDec("fatigue", -1);
     });
   }
 
+  isCompetenceAffichable(competence) {
+    return !this.options.showCompNiveauBase || !RdDItemCompetence.isNiveauBase(competence);
+  }
+
+  /* -------------------------------------------- */
+  async _onDropActor(event, dragData) {
+    const dropActor = fromUuidSync(dragData.uuid);
+    this.actor.addSubActeur(dropActor);
+    super._onDropActor(event, dragData);
+  }
+
+  /* -------------------------------------------- */
+  async selectTypeOeuvreToCreate() {
+    let typeObjets = RdDItem.getTypesOeuvres();
+    let content = `<span class="competence-label">Selectionnez le type d'oeuvre</span><select class="item-type">`;
+    for (let typeName of typeObjets) {
+      content += `<option value="${typeName}">${Misc.typeName('Item', typeName)}</option>`
+    }
+    content += '</select>';
+    let dialog = new Dialog({
+      title: "Créer une oeuvre",
+      content: content,
+      buttons: {
+        create: {
+          icon: '<i class="fas fa-check"></i>',
+          label: "Créer l'oeuvre",
+          callback: () => this.actor.createItem($(".item-type").val())
+        }
+      }
+    });
+    dialog.render(true);
+  }
+
+  /* -------------------------------------------- */
+  async createEmptyTache() {
+    await this.actor.createItem('tache', 'Nouvelle tache');
+  }
   _optionRecherche(target) {
-    if (!target.value?.length){
+    if (!target.value?.length) {
       return undefined;
     }
     return {
@@ -544,7 +498,7 @@ export class RdDActorSheet extends ActorSheet {
   }
 
   _getEventArmeCombat(event) {
-    const li = $(event.currentTarget)?.parents(".item");
+    const li = this.html.find(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.system.competence == compName);
@@ -562,8 +516,8 @@ export class RdDActorSheet extends ActorSheet {
     const sheetTabs = this.element.find(".sheet-tabs");
     const sheetBody = this.element.find(".sheet-body");
     let bodyHeight = position.height - sheetHeader[0].clientHeight;
-    if (sheetTabs.length>0) {
-      bodyHeight  -= sheetTabs[0].clientHeight;
+    if (sheetTabs.length > 0) {
+      bodyHeight -= sheetTabs[0].clientHeight;
     }
     sheetBody.css("height", bodyHeight);
     return position;

module/actor-vehicule-sheet.js

@@ -18,5 +18,22 @@ export class RdDActorVehiculeSheet extends RdDActorSheet {
     });
   }
 
+  activateListeners(html) {
+    super.activateListeners(html);
+    if (!this.options.editable) return;
+
+    this.html.find('.resistance-moins').click(async event => {
+      this.actor.vehicleIncDec("resistance", -1);
+    });
+    this.html.find('.resistance-plus').click(async event => {
+      this.actor.vehicleIncDec("resistance", 1);
+    });
+    this.html.find('.structure-moins').click(async event => {
+      this.actor.vehicleIncDec("structure", -1);
+    });
+    this.html.find('.structure-plus').click(async event => {
+      this.actor.vehicleIncDec("structure", 1);
+    });
+  }
 
 }

module/actor/base-actor-sheet.js

@@ -0,0 +1,242 @@
+import { RdDUtility } from "../rdd-utility.js";
+import { Misc } from "../misc.js";
+import { DialogSplitItem } from "../dialog-split-item.js";
+import { RdDSheetUtility } from "../rdd-sheet-utility.js";
+import { Monnaie } from "../item-monnaie.js";
+import { RdDItem } from "../item.js";
+
+/* -------------------------------------------- */
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+export class RdDBaseActorSheet extends ActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+    RdDUtility.initAfficheContenu();
+    return mergeObject(super.defaultOptions, {
+      classes: ["rdd", "sheet", "actor"],
+      template: "systems/foundryvtt-reve-de-dragon/templates/actor-sheet.html",
+      width: 550,
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }],
+      showCompNiveauBase: false,
+      vueDetaillee: false
+    });
+  }
+
+  /* -------------------------------------------- */
+  async getData() {
+    Monnaie.validerMonnaies(this.actor.itemTypes['monnaie']);
+
+    this.actor.recompute();
+    let formData = {
+      title: this.title,
+      id: this.actor.id,
+      type: this.actor.type,
+      img: this.actor.img,
+      name: this.actor.name,
+      system: this.actor.system,
+      description: await TextEditor.enrichHTML(this.actor.system.description, { async: true }),
+      notesmj: await TextEditor.enrichHTML(this.actor.system.notesmj, { async: true }),
+      options: RdDSheetUtility.mergeDocumentRights(this.options, this.actor, this.isEditable)
+    }
+
+    RdDBaseActorSheet.filterItemsPerTypeForSheet(formData, this.actor.itemTypes);
+    formData.calc = {
+      fortune: Monnaie.toSolsDeniers(this.actor.getFortune()),
+      prixTotalEquipement: this.actor.computePrixTotalEquipement(),
+      encTotal: await this.actor.computeEncTotal(),
+    }
+
+    this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.objets);
+    formData.conteneurs = RdDUtility.conteneursRacine(formData.conteneurs);
+
+    return formData;
+  }
+
+  /* -------------------------------------------- */
+  static filterItemsPerTypeForSheet(formData, itemTypes) {
+    formData.recettescuisine = Misc.arrayOrEmpty(itemTypes['recettecuisine']);
+    formData.recettesAlchimiques = Misc.arrayOrEmpty(itemTypes['recettealchimique']);
+    formData.maladies = Misc.arrayOrEmpty(itemTypes['maladie']);
+    formData.poisons = Misc.arrayOrEmpty(itemTypes['poison']);
+    formData.possessions = Misc.arrayOrEmpty(itemTypes['possession']);
+    formData.maladiesPoisons = formData.maladies.concat(formData.poisons);
+    formData.competences = (itemTypes['competence'] ?? []).concat(itemTypes['competencecreature'] ?? []);
+    formData.sortsReserve = Misc.arrayOrEmpty(itemTypes['sortreserve']);
+
+    formData.sorts = Misc.arrayOrEmpty(itemTypes['sort']);
+    formData.rencontres = Misc.arrayOrEmpty(itemTypes['rencontre']);
+    formData.casestmr = Misc.arrayOrEmpty(itemTypes['casetmr']);
+    formData.signesdraconiques = Misc.arrayOrEmpty(itemTypes['signedraconique']);
+    formData.queues = Misc.arrayOrEmpty(itemTypes['queue']);
+    formData.souffles = Misc.arrayOrEmpty(itemTypes['souffle']);
+    formData.ombres = Misc.arrayOrEmpty(itemTypes['ombre']);
+    formData.tetes = Misc.arrayOrEmpty(itemTypes['tete']);
+    formData.taches = Misc.arrayOrEmpty(itemTypes['tache']);
+    formData.meditations = Misc.arrayOrEmpty(itemTypes['meditation']);
+    formData.chants = Misc.arrayOrEmpty(itemTypes['chant']);
+    formData.danses = Misc.arrayOrEmpty(itemTypes['danse']);
+    formData.musiques = Misc.arrayOrEmpty(itemTypes['musique']);
+    formData.oeuvres = Misc.arrayOrEmpty(itemTypes['oeuvre']);
+    formData.jeux = Misc.arrayOrEmpty(itemTypes['jeu']);
+
+    formData.services = Misc.arrayOrEmpty(itemTypes['service']);
+    formData.conteneurs = Misc.arrayOrEmpty(itemTypes['conteneur']);
+    formData.materiel = Misc.arrayOrEmpty(itemTypes['objet']);
+    formData.armes = Misc.arrayOrEmpty(itemTypes['arme']);
+    formData.armures = Misc.arrayOrEmpty(itemTypes['armure']);
+    formData.munitions = Misc.arrayOrEmpty(itemTypes['munition']);
+    formData.livres = Misc.arrayOrEmpty(itemTypes['livre']);
+    formData.potions = Misc.arrayOrEmpty(itemTypes['potion']);
+    formData.plantes = Misc.arrayOrEmpty(itemTypes['plante']);
+    formData.ingredients = Misc.arrayOrEmpty(itemTypes['ingredient']);
+    formData.faunes = Misc.arrayOrEmpty(itemTypes['faune']);
+    formData.herbes = Misc.arrayOrEmpty(itemTypes['herbe']);
+    formData.nourritureboissons = Misc.arrayOrEmpty(itemTypes['nourritureboisson']);
+    formData.gemmes = Misc.arrayOrEmpty(itemTypes['gemme']);
+    formData.monnaie = Misc.arrayOrEmpty(itemTypes['monnaie']).sort(Monnaie.triValeurEntiere());
+
+    formData.objets = RdDItem.getItemTypesInventaire('all')
+      .map(t => Misc.arrayOrEmpty(itemTypes[t]))
+      .reduce((a, b) => a.concat(b), [])
+      .sort(Misc.ascending(it => it.name));
+  }
+
+  /* -------------------------------------------- */  /** @override */
+  activateListeners(html) {
+    super.activateListeners(html);
+    this.html = html;
+
+    this.html.find('.conteneur-name a').click(async event => {
+      RdDUtility.toggleAfficheContenu(this.getItemId(event));
+      this.render(true);
+    });
+    this.html.find('.item-edit').click(async event => this.getItem(event)?.sheet.render(true))
+    this.html.find('.item-montrer').click(async event => this.getItem(event)?.postItemToChat());
+    this.html.find('.actor-montrer').click(async event => this.actor.postActorToChat());
+
+    // Everything below here is only needed if the sheet is editable
+    if (!this.options.editable) return;
+
+    this.html.find('.item-split').click(async event => {
+      const item = this.getItem(event);
+      RdDSheetUtility.splitItem(item, this.actor);
+    });
+    this.html.find('.item-delete').click(async event => RdDUtility.confirmActorItemDelete(this, this.getItem(event)));
+    this.html.find('.item-vendre').click(async event => this.vendre(this.getItem(event)));
+
+    this.html.find('.creer-un-objet').click(async event => {
+      this.selectObjetTypeToCreate();
+    });
+    this.html.find('.nettoyer-conteneurs').click(async event => {
+      this.actor.nettoyerConteneurs();
+    });
+    this.html.find('.monnaie-plus').click(async event => {
+      this.actor.monnaieIncDec(this.getItemId(event), 1);
+    });
+    this.html.find('.monnaie-moins').click(async event => {
+      this.actor.monnaieIncDec(this.getItemId(event), -1);
+    });
+  }
+
+  getItemId(event) {
+    return RdDSheetUtility.getItemId(event);
+  }
+
+  getItem(event) {
+    return RdDSheetUtility.getItem(event, this.actor);
+  }
+
+  /* -------------------------------------------- */
+  _getHeaderButtons() {
+    let buttons = super._getHeaderButtons();
+    buttons.unshift({
+      class: "montrer",
+      icon: "fas fa-comment",
+      onclick: ev => this.actor.postActorToChat()
+    });
+    return buttons
+  }
+
+  /* -------------------------------------------- */
+  async _onDropItem(event, dragData) {
+    const destItemId = this.html.find(event.target)?.closest('.item').attr('data-item-id')
+    const dropParams = await RdDSheetUtility.prepareItemDropParameters(destItemId, this.actor, dragData, this.objetVersConteneur)
+    if (dropParams) {
+      const callSuper = await this.actor.processDropItem(dropParams)
+      if (callSuper) {
+        await super._onDropItem(event, dragData)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  async selectObjetTypeToCreate() {
+    let typeObjets = this.getTypesInventaire().sort(Misc.ascending(type => Misc.typeName('Item', type)));
+    let content = `<span class="competence-label">Selectionnez le type d'équipement</span><select class="item-type">`;
+    for (let typeName of typeObjets) {
+      content += `<option value="${typeName}">${Misc.typeName('Item', typeName)}</option>`
+    }
+    content += '</select>';
+    let d = new Dialog({
+      title: "Créer un équipement",
+      content: content,
+      buttons: {
+        create: {
+          icon: '<i class="fas fa-check"></i>',
+          label: "Créer l'objet",
+          callback: () => this.actor.createItem($(".item-type").val())
+        }
+      }
+    });
+    d.render(true);
+  }
+
+  getTypesInventaire() {
+    return RdDItem.getItemTypesInventaire();
+  }
+
+  /** @override */
+  setPosition(options = {}) {
+    const position = super.setPosition(options);
+    const sheetHeader = this.element.find(".sheet-header");
+    const sheetTabs = this.element.find(".sheet-tabs");
+    const sheetBody = this.element.find(".sheet-body");
+    let bodyHeight = position.height - sheetHeader[0].clientHeight;
+    if (sheetTabs.length > 0) {
+      bodyHeight -= sheetTabs[0].clientHeight;
+    }
+    sheetBody.css("height", bodyHeight);
+    return position;
+  }
+
+
+  /* -------------------------------------------- */
+  /** @override */
+  _updateObject(event, formData) {
+    // Update the Actor
+    return this.actor.update(formData);
+  }
+
+  async splitItem(item) {
+    const dialog = await DialogSplitItem.create(item, (item, split) => this._onSplitItem(item, split));
+    dialog.render(true);
+  }
+
+  async _onSplitItem(item, split) {
+    if (split >= 1 && split < item.system.quantite) {
+      await item.diminuerQuantite(split);
+      const splitItem = duplicate(item);
+      splitItem.system.quantite = split;
+      await this.actor.createEmbeddedDocuments('Item', [splitItem])
+    }
+  }
+
+  vendre(item) {
+    item?.proposerVente(this.actor.getQuantiteDisponible(item));
+  }
+
+}

module/actor/base-actor.js

@@ -0,0 +1,627 @@
+import { ChatUtility } from "../chat-utility.js";
+import { SYSTEM_SOCKET_ID } from "../constants.js";
+import { Monnaie } from "../item-monnaie.js";
+import { Misc } from "../misc.js";
+import { RdDAudio } from "../rdd-audio.js";
+import { RdDUtility } from "../rdd-utility.js";
+import { SystemCompendiums } from "../settings/system-compendiums.js";
+
+export class RdDBaseActor extends Actor {
+
+  static getDefaultImg(itemType) {
+    return game.system.rdd.actorClasses[itemType]?.defaultIcon ?? defaultItemImg[itemType];
+  }
+
+  /* -------------------------------------------- */
+  static init() {
+    Hooks.on("preUpdateItem", (item, change, options, id) => RdDBaseActor.getParentActor(item)?.onPreUpdateItem(item, change, options, id));
+    Hooks.on("createItem", (item, options, id) => RdDBaseActor.getParentActor(item)?.onCreateItem(item, options, id));
+    Hooks.on("deleteItem", (item, options, id) => RdDBaseActor.getParentActor(item)?.onDeleteItem(item, options, id));
+    Hooks.on("updateActor", (actor, change, options, actorId) => actor.onUpdateActor(change, options, actorId));
+  }
+
+
+  static onSocketMessage(sockmsg) {
+    switch (sockmsg.msg) {
+      case "msg_remote_actor_call":
+        return RdDBaseActor.onRemoteActorCall(sockmsg.data, sockmsg.userId);
+      case "msg_reset_nombre_astral":
+        console.log("RESET ASTRAL", game.user.character);
+        game.user.character.resetNombreAstral();
+        return;
+    }
+  }
+
+  static remoteActorCall(callData, userId = undefined) {
+    userId = userId ?? Misc.firstConnectedGMId();
+    if (userId == game.user.id) {
+      RdDBaseActor.onRemoteActorCall(callData, userId);
+      return false;
+    }
+    else {
+      game.socket.emit(SYSTEM_SOCKET_ID, { msg: "msg_remote_actor_call", data: callData, userId: userId });
+      return true;
+    }
+  }
+
+  static onRemoteActorCall(callData, userId) {
+    if (userId == game.user.id) {
+      const actor = game.actors.get(callData?.actorId);
+      if (Misc.isOwnerPlayerOrUniqueConnectedGM(actor)) { // Seul le joueur choisi effectue l'appel: le joueur courant si propriétaire de l'actor, ou le MJ sinon
+        const args = callData.args;
+        console.info(`RdDBaseActor.onRemoteActorCall: pour l'Actor ${callData.actorId}, appel de RdDBaseActor.${callData.method}(`, ...args, ')');
+        actor[callData.method](...args);
+      }
+    }
+  }
+
+  static getParentActor(document) {
+    return document?.parent instanceof Actor ? document.parent : undefined
+  }
+
+  /**
+   * Cet methode surcharge Actor.create() pour ajouter si besoin des Items par défaut:
+   * compétences et monnaies.
+  *
+  * @param {Object} actorData template d'acteur auquel ajouter des informations.
+  * @param {Object} options   optionspour customiser la création
+  */
+  static async create(actorData, options) {
+    // import depuis un compendium
+    if (actorData instanceof Array) {
+      return super.create(actorData, options);
+    }
+    // Création d'un acteur avec des items (uniquement en cas de duplication): pas besoin d'ajouter d'items
+    if (actorData.items) {
+      return await super.create(actorData, options);
+    }
+    actorData.items = [];
+    if (actorData.type == "personnage") {
+      const competences = await SystemCompendiums.getCompetences(actorData.type);
+      actorData.items = actorData.items.concat(competences.map(i => i.toObject()))
+        .concat(Monnaie.monnaiesStandard());
+    }
+    else if (actorData.type == "commerce") {
+      actorData.items = actorData.items.concat(Monnaie.monnaiesStandard());
+    }
+    return super.create(actorData, options);
+  }
+
+  constructor(docData, context = {}) {
+    if (!context.rdd?.ready) {
+      mergeObject(context, { rdd: { ready: true } });
+      const ActorConstructor = game.system.rdd.actorClasses[docData.type];
+      if (ActorConstructor) {
+        if (!docData.img) {
+          docData.img = ActorConstructor.defaultIcon;
+        }
+        return new ActorConstructor(docData, context);
+      }
+    }
+    super(docData, context);
+  }
+
+  isCreatureEntite() { return this.type == 'creature' || this.type == 'entite'; }
+  isCreature() { return this.type == 'creature'; }
+  isEntite() { return this.type == 'entite'; }
+  isPersonnage() { return this.type == 'personnage'; }
+  isVehicule() { return this.type == 'vehicule'; }
+
+  getItem(id, type = undefined) {
+    const item = this.items.get(id);
+    if (type == undefined || (item?.type == type)) {
+      return item;
+    }
+    return undefined;
+  }
+
+  listItems(type = undefined) { return (type ? this.itemTypes[type] : this.items); }
+  filterItems(filter, type = undefined) { return this.listItems(type)?.filter(filter) ?? []; }
+  findItemLike(idOrName, type) {
+    return this.getItem(idOrName, type)
+      ?? Misc.findFirstLike(idOrName, this.listItems(type), { description: Misc.typeName('Item', type) });
+  }
+
+  getMonnaie(id) { return this.findItemLike(id, 'monnaie'); }
+
+  recompute() { }
+
+
+  /* -------------------------------------------- */
+  async onPreUpdateItem(item, change, options, id) { }
+
+  async onCreateItem(item, options, id) { }
+
+  async onDeleteItem(item, options, id) { }
+
+  async onUpdateActor(update, options, actorId) { }
+
+  async onTimeChanging(oldTimestamp, newTimestamp) {
+    this.items.filter(it => it.isFinPeriode(oldTimestamp, newTimestamp))
+      .forEach(async it => await it.onFinPeriodeTemporel(oldTimestamp, newTimestamp))
+  }
+
+  /* -------------------------------------------- */
+  getFortune() {
+    return Monnaie.getFortune(this.itemTypes['monnaie']);
+  }
+
+  /* -------------------------------------------- */
+  async monnaieIncDec(id, value) {
+    let monnaie = this.getMonnaie(id);
+    if (monnaie) {
+      const quantite = Math.max(0, monnaie.system.quantite + value);
+      await this.updateEmbeddedDocuments('Item', [{ _id: monnaie.id, 'system.quantite': quantite }]);
+    }
+  }
+
+  computePrixTotalEquipement() {
+    return this.items.filter(it => it.isInventaire())
+      .filter(it => !it.isMonnaie())
+      .map(it => it.valeurTotale())
+      .reduce(Misc.sum(), 0);
+  }
+
+  async payerSols(depense) {
+    depense = Number(depense);
+    if (depense == 0) {
+      return;
+    }
+    let fortune = this.getFortune();
+    console.log("payer", game.user.character, depense, fortune);
+    let msg = "";
+    if (fortune >= depense) {
+      await Monnaie.optimiserFortune(this, fortune - depense);
+      msg = `Vous avez payé <strong>${depense} Sols</strong>, qui ont été soustraits de votre argent.`;
+      RdDAudio.PlayContextAudio("argent"); // Petit son
+    } else {
+      msg = "Vous n'avez pas assez d'argent pour payer cette somme !";
+    }
+
+    let message = {
+      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+      content: msg
+    };
+    ChatMessage.create(message);
+  }
+
+  async depenserSols(sols) {
+    let reste = this.getFortune() - Number(sols);
+    if (reste >= 0) {
+      await Monnaie.optimiserFortune(this, reste);
+    }
+    return reste;
+  }
+
+  async ajouterSols(sols, fromActorId = undefined) {
+    sols = Number(sols);
+    if (sols == 0) {
+      return;
+    }
+    if (sols < 0) {
+      ui.notifications.error(`Impossible d'ajouter un gain de ${sols} <0`);
+      return;
+    }
+    if (fromActorId && !game.user.isGM) {
+      RdDBaseActor.remoteActorCall({
+        userId: Misc.connectedGMOrUser(),
+        actorId: this.id,
+        method: 'ajouterSols', args: [sols, fromActorId]
+      });
+    }
+    else {
+      const fromActor = game.actors.get(fromActorId)
+      await Monnaie.optimiserFortune(this, sols + this.getFortune());
+
+      RdDAudio.PlayContextAudio("argent"); // Petit son
+      ChatMessage.create({
+        whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+        content: `Vous avez reçu <strong>${sols} Sols</strong> ${fromActor ? " de " + fromActor.name : ''}, qui ont été ajoutés à votre argent.`
+      });
+    }
+  }
+
+  /* -------------------------------------------- */
+
+  getQuantiteDisponible(item) {
+    return item?.isService() ? undefined : item?.getQuantite();
+  }
+
+  /* -------------------------------------------- */
+  async achatVente(achat) {
+    if (achat.vendeurId == achat.acheteurId) {
+      ui.notifications.info("Inutile de se vendre à soi-même");
+      return;
+    }
+    if (!Misc.isUniqueConnectedGM()) {
+      RdDBaseActor.remoteActorCall({
+        actorId: achat.vendeurId ?? achat.acheteurId,
+        method: 'achatVente',
+        args: [achat]
+      });
+      return;
+    }
+
+    const cout = Number(achat.prixTotal ?? 0);
+    const vendeur = achat.vendeurId ? game.actors.get(achat.vendeurId) : undefined;
+    const acheteur = achat.acheteurId ? game.actors.get(achat.acheteurId) : undefined;
+    const vente = achat.vente;
+    const quantite = (achat.choix.nombreLots ?? 1) * (vente.tailleLot);
+    const itemVendu = vendeur?.getItem(vente.item._id);
+    if (!this.verifierQuantite(vendeur, itemVendu, quantite)) {
+      ChatUtility.notifyUser(achat.userId, 'warn', `Le vendeur n'a pas assez de ${itemVendu.name} !`);
+      return
+    }
+    if (acheteur && !acheteur.verifierFortune(cout)) {
+      ChatUtility.notifyUser(achat.userId, 'warn', `Vous n'avez pas assez d'argent pour payer ${Math.ceil(cout / 100)} sols !`);
+      return;
+    }
+    await this.decrementerVente(vendeur, itemVendu, quantite, cout);
+    if (acheteur) {
+      await acheteur.depenserSols(cout);
+      const createdItemId = await acheteur.creerQuantiteItem(vente.item, quantite);
+      await acheteur.consommerNourritureAchetee(achat, vente, createdItemId);
+    }
+    if (cout > 0) {
+      RdDAudio.PlayContextAudio("argent");
+    }
+    const chatAchatItem = duplicate(vente);
+    chatAchatItem.quantiteTotal = quantite;
+    ChatMessage.create({
+      user: achat.userId,
+      speaker: { alias: (acheteur ?? vendeur).name },
+      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+      content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-achat-item.html', chatAchatItem)
+    });
+
+    if (!vente.quantiteIllimite) {
+      if (vente.quantiteNbLots <= achat.choix.nombreLots) {
+        ChatUtility.removeChatMessageId(achat.chatMessageIdVente);
+      }
+      else if (achat.chatMessageIdVente) {
+        vente["properties"] = itemVendu.getProprietes();
+        vente.quantiteNbLots -= achat.choix.nombreLots;
+        vente.jsondata = JSON.stringify(vente.item);
+        const messageVente = game.messages.get(achat.chatMessageIdVente);
+        messageVente.update({ content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-vente-item.html', vente) });
+        messageVente.render(true);
+      }
+    }
+  }
+
+  async decrementerVente(vendeur, itemVendu, quantite, cout) {
+    if (vendeur) {
+      await vendeur.ajouterSols(cout);
+      await vendeur.decrementerQuantiteItem(itemVendu, quantite);
+    }
+  }
+
+  verifierFortune(cout) {
+    return this.getFortune() >= cout;
+  }
+
+  verifierQuantite(vendeur, item, quantiteTotal) {
+    const disponible = vendeur?.getQuantiteDisponible(item);
+    return disponible == undefined || disponible >= quantiteTotal;
+  }
+
+  async consommerNourritureAchetee(achat, vente, createdItemId) {
+    if (achat.choix.consommer && vente.item.type == 'nourritureboisson' && createdItemId != undefined) {
+      achat.choix.doses = achat.choix.nombreLots;
+      await this.consommerNourritureboisson(createdItemId, achat.choix, vente.actingUserId);
+    }
+  }
+
+
+  async decrementerQuantiteItem(item, quantite, options = { supprimerSiZero: true }) {
+    if (item.isService()) {
+      return;
+    }
+    let resteQuantite = (item.system.quantite ?? 1) - quantite;
+    if (resteQuantite <= 0) {
+      if (options.supprimerSiZero) {
+        await this.deleteEmbeddedDocuments("Item", [item.id]);
+      }
+      else {
+        await this.updateEmbeddedDocuments("Item", [{ _id: item.id, 'system.quantite': 0 }]);
+      }
+      if (resteQuantite < 0) {
+        ui.notifications.warn(`La quantité de ${item.name} était insuffisante, l'objet a donc été supprimé`)
+      }
+    }
+    else if (resteQuantite > 0) {
+      await this.updateEmbeddedDocuments("Item", [{ _id: item.id, 'system.quantite': resteQuantite }]);
+    }
+  }
+
+  async creerQuantiteItem(item, quantite) {
+    if (this.canReceive(item)) {
+      const isItemEmpilable = "quantite" in item.system;
+      const baseItem = {
+        type: item.type,
+        img: item.img,
+        name: item.name,
+        system: mergeObject(item.system, { quantite: isItemEmpilable ? quantite : undefined })
+      };
+      const newItems = isItemEmpilable ? [baseItem] : Array.from({ length: quantite }, (_, i) => baseItem);
+      const items = await this.createEmbeddedDocuments("Item", newItems);
+      return items.length > 0 ? items[0].id : undefined;
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeMalusSurEncombrement() {
+    return 0;
+  }
+
+  getEncombrementMax() {
+    return 0;
+  }
+
+  async computeEncTotal() {
+    if (!this.pack) {
+      this.encTotal = this.items.map(it => it.getEncTotal()).reduce(Misc.sum(), 0);
+      return this.encTotal;
+    }
+    return 0;
+  }
+
+  async createItem(type, name = undefined) {
+    if (!name) {
+      name = 'Nouveau ' + Misc.typeName('Item', type);
+    }
+    await this.createEmbeddedDocuments('Item', [{ name: name, type: type }], { renderSheet: true });
+  }
+
+  canReceive(item) {
+    return false;
+  }
+
+  async processDropItem(params) {
+    const targetActorId = this.id;
+    const sourceActorId = params.sourceActorId;
+    const itemId = params.itemId;
+    const destId = params.destId;
+    const srcId = params.srcId;
+    if (sourceActorId && sourceActorId != targetActorId) {
+      console.log("Moving objects", sourceActorId, targetActorId, itemId);
+      this.moveItemsBetweenActors(itemId, sourceActorId);
+      return false;
+    }
+    let result = true;
+    const item = this.getItem(itemId);
+    if (item?.isInventaire('all') && sourceActorId == targetActorId) {
+      // rangement
+      if (srcId != destId && itemId != destId) { // déplacement de l'objet
+        const src = this.getItem(srcId);
+        const dest = this.getItem(destId);
+        const cible = this.getContenantOrParent(dest);
+        const [empilable, message] = item.isInventaireEmpilable(dest);
+        if (empilable) {
+          await dest.empiler(item)
+          result = false;
+        }
+        // changer de conteneur
+        else if (!cible || this.conteneurPeutContenir(cible, item)) {
+          await this.enleverDeConteneur(item, src, params.onEnleverConteneur);
+          await this.ajouterDansConteneur(item, cible, params.onAjouterDansConteneur);
+          if (message && !dest.isConteneur()) {
+            ui.notifications.info(cible
+              ? `${message}<br>${item.name} a été déplacé dans: ${cible.name}`
+              : `${message}<br>${item.name} a été sorti du conteneur`);
+          }
+        }
+      }
+    }
+    await this.computeEncTotal();
+    return result;
+  }
+
+  getContenantOrParent(dest) {
+    if (!dest || dest.isConteneur()) {
+      return dest;
+    }
+    return this.getContenant(dest);
+  }
+
+  getContenant(item) {
+    return this.itemTypes['conteneur'].find(it => it.system.contenu.includes(item.id));
+  }
+
+
+  /* -------------------------------------------- */
+  conteneurPeutContenir(dest, item) {
+    if (!dest) {
+      return true;
+    }
+    if (!dest.isConteneur()) {
+      return false;
+    }
+    const destData = dest
+    if (this._isConteneurContenu(item, dest)) {
+      ui.notifications.warn(`Impossible de déplacer un conteneur parent (${item.name}) dans un de ses contenus ${destData.name} !`);
+      return false; // Loop detected !
+    }
+
+    // Calculer le total actuel des contenus
+    let encContenu = this.getRecursiveEnc(dest) - Number(destData.system.encombrement);
+    let newEnc = this.getRecursiveEnc(item); // Calculer le total actuel du nouvel objet
+
+    // Teste si le conteneur de destination a suffisament de capacité pour recevoir le nouvel objet
+    if (Number(destData.system.capacite) < encContenu + newEnc) {
+      ui.notifications.warn(
+        `Le conteneur ${dest.name} a une capacité de ${destData.system.capacite}, et contient déjà ${encContenu}.
+        Impossible d'y ranger: ${item.name} d'encombrement ${newEnc}!`);
+      return false;
+    }
+    return true;
+  }
+
+  /* -------------------------------------------- */
+  _isConteneurContenu(item, conteneur) {
+    if (item?.isConteneur()) { // Si c'est un conteneur, il faut vérifier qu'on ne le déplace pas vers un sous-conteneur lui appartenant
+      for (let id of item.system.contenu) {
+        let subObjet = this.getItem(id);
+        if (subObjet?.id == conteneur.id) {
+          return true; // Loop detected !
+        }
+        if (subObjet?.isConteneur()) {
+          return this._isConteneurContenu(subObjet, conteneur);
+        }
+      }
+    }
+    return false;
+  }
+  /* -------------------------------------------- */
+  getRecursiveEnc(objet) {
+    if (!objet) {
+      return 0;
+    }
+    const tplData = objet.system;
+    if (objet.type != 'conteneur') {
+      return Number(tplData.encombrement) * Number(tplData.quantite);
+    }
+    const encContenus = tplData.contenu.map(idContenu => this.getRecursiveEnc(this.getItem(idContenu)));
+    return encContenus.reduce(Misc.sum(), 0)
+      + Number(tplData.encombrement) /* TODO? Number(tplData.quantite) -- on pourrait avoir plusieurs conteneurs...*/
+  }
+
+  /* -------------------------------------------- */
+  /** Ajoute un item dans un conteneur, sur la base
+   * de leurs ID */
+  async ajouterDansConteneur(item, conteneur, onAjouterDansConteneur) {
+    if (!conteneur) {
+      // TODO: afficher
+      item.estContenu = false;
+    }
+    else if (conteneur.isConteneur()) {
+      item.estContenu = true;
+      await this.updateEmbeddedDocuments('Item', [{
+        _id: conteneur.id,
+        'system.contenu': [...conteneur.system.contenu, item.id]
+      }]);
+      onAjouterDansConteneur(item.id, conteneur.id);
+    }
+  }
+
+  /* -------------------------------------------- */
+  /** Fonction de remise à plat de l'équipement (ie vide les champs 'contenu') */
+  async nettoyerConteneurs() {
+    RdDConfirm.confirmer({
+      settingConfirmer: "confirmation-vider",
+      content: `<p>Etes vous certain de vouloir vider tous les conteneurs ?</p>`,
+      title: 'Vider les conteneurs',
+      buttonLabel: 'Vider',
+      onAction: async () => {
+        const corrections = [];
+        for (let item of this.items) {
+          if (item.estContenu) {
+            item.estContenu = undefined;
+          }
+          if (item.type == 'conteneur' && item.system.contenu.length > 0) {
+            corrections.push({ _id: item.id, 'system.contenu': [] });
+          }
+        }
+        if (corrections.length > 0) {
+          await this.updateEmbeddedDocuments('Item', corrections);
+        }
+      }
+    });
+  }
+
+  /* -------------------------------------------- */
+  buildSubConteneurObjetList(conteneurId, deleteList) {
+    let conteneur = this.getItem(conteneurId);
+    if (conteneur?.type == 'conteneur') { // Si c'est un conteneur
+      for (let subId of conteneur.system.contenu) {
+        let subObj = this.getItem(subId);
+        if (subObj) {
+          if (subObj.type == 'conteneur') {
+            this.buildSubConteneurObjetList(subId, deleteList);
+          }
+          deleteList.push({ id: subId, conteneurId: conteneurId });
+        }
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  async deleteAllConteneur(itemId, options) {
+    let list = [];
+    list.push({ id: itemId, conteneurId: undefined }); // Init list
+    this.buildSubConteneurObjetList(itemId, list);
+    await this.deleteEmbeddedDocuments('Item', list.map(it => it.id), options);
+  }
+
+  /* -------------------------------------------- */
+  /** Supprime un item d'un conteneur, sur la base
+   * de leurs ID */
+  async enleverDeConteneur(item, conteneur, onEnleverDeConteneur) {
+    if (conteneur?.isConteneur()) {
+      item.estContenu = false;
+      await this.updateEmbeddedDocuments('Item', [{
+        _id: conteneur.id,
+        'system.contenu': conteneur.system.contenu.filter(id => id != item.id)
+      }]);
+      onEnleverDeConteneur();
+    }
+  }
+
+  /* -------------------------------------------- */
+  async moveItemsBetweenActors(itemId, sourceActorId) {
+    let itemsList = []
+    let sourceActor = game.actors.get(sourceActorId);
+    itemsList.push({ id: itemId, conteneurId: undefined }); // Init list
+    sourceActor.buildSubConteneurObjetList(itemId, itemsList); // Get itemId list
+
+    const itemsDataToCreate = itemsList.map(it => sourceActor.getItem(it.id))
+      .map(it => duplicate(it))
+      .map(it => { it.system.contenu = []; return it; });
+    let newItems = await this.createEmbeddedDocuments('Item', itemsDataToCreate);
+
+    let itemMap = this._buildMapOldNewId(itemsList, newItems);
+
+    for (let item of itemsList) { // Second boucle pour traiter la remise en conteneurs
+      // gestion conteneur/contenu
+      if (item.conteneurId) { // l'Objet était dans un conteneur
+        let newConteneurId = itemMap[item.conteneurId]; // Get conteneur
+        let newConteneur = this.getItem(newConteneurId);
+
+        let newItemId = itemMap[item.id]; // Get newItem
+
+        console.log('New conteneur filling!', newConteneur, newItemId, item);
+        let contenu = duplicate(newConteneur.system.contenu);
+        contenu.push(newItemId);
+        await this.updateEmbeddedDocuments('Item', [{ _id: newConteneurId, 'system.contenu': contenu }]);
+      }
+    }
+    for (let item of itemsList) {
+      await sourceActor.deleteEmbeddedDocuments('Item', [item.id]);
+    }
+  }
+
+  _buildMapOldNewId(itemsList, newItems) {
+    let itemMap = {};
+    for (let i = 0; i < itemsList.length; i++) {
+      itemMap[itemsList[i].id] = newItems[i].id; // Pour garder le lien ancien / nouveau
+    }
+    return itemMap;
+  }
+
+  /* -------------------------------------------- */
+  async postActorToChat(modeOverride) {
+    let chatData = {
+      doctype: 'Actor',
+      id: this.id,
+      type: this.type,
+      img: this.img,
+      pack: this.pack,
+      name: this.name,
+      system: { description: this.system.description }
+    }
+    renderTemplate('systems/foundryvtt-reve-de-dragon/templates/post-actor.html', chatData)
+      .then(html => ChatMessage.create(RdDUtility.chatDataSetup(html, modeOverride)));
+  }
+
+
+}

module/actor/commerce-sheet.js

@@ -0,0 +1,95 @@
+import { DialogItemAchat } from "../dialog-item-achat.js";
+import { RdDItem } from "../item.js";
+import { RdDSheetUtility } from "../rdd-sheet-utility.js";
+import { RdDUtility } from "../rdd-utility.js";
+import { RdDBaseActorSheet } from "./base-actor-sheet.js";
+import { RdDCommerce } from "./commerce.js";
+
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+export class RdDCommerceSheet extends RdDBaseActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+    return mergeObject(super.defaultOptions, {
+      classes: ["rdd", "sheet", "actor"],
+      template: "systems/foundryvtt-reve-de-dragon/templates/actor/commerce-actor-sheet.html",
+      width: 600,
+      height: 720,
+      tabs: [],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }]
+    });
+  }
+  get title() {
+    if (this.actor.token && this.actor.token != this.actor.prototypeToken) {
+      return this.actor.token.name;
+    }
+    return super.title
+  }
+
+  async getData() {
+    const formData = await super.getData();
+    if (this.actor.token && this.actor.token != this.actor.prototypeToken) {
+      mergeObject(formData,
+        {
+          title: this.actor.token.name,
+          token: {
+            img: this.actor.token.texture.src
+          }
+        },
+        { overwrite: true });
+
+    }
+    return formData;
+  }
+  /* -------------------------------------------- */
+  /** @override */
+  activateListeners(html) {
+    super.activateListeners(html);
+
+    this.html.find('a.item-acheter').click(async event => await this.vente(this.getItem(event)));
+
+    if (!this.options.editable) return;
+
+    this.html.find('a.item-quantite-moins').click(async event => await this.getItem(event)?.quantiteIncDec(-1, { supprimerSiZero: false }));
+    this.html.find('a.item-quantite-plus').click(async event => await this.getItem(event)?.quantiteIncDec(1));
+    this.html.find('input.item-quantite').change(async event => {
+      const newQuantite = Math.max(0, Number.parseInt(this.html.find(event.currentTarget).val()));
+      await this.getItem(event)?.update({ "system.quantite": newQuantite });
+    })
+    this.html.find('input.item-cout').change(async event => {
+      const newCout = Math.max(0, Number(this.html.find(event.currentTarget).val()));
+      await this.getItem(event)?.update({ "system.cout": newCout });
+    })
+  }
+
+  getTypesInventaire() {
+    return RdDItem.getItemTypesInventaire('all');
+  }
+
+
+  async vente(item) {
+    const acheteur = RdDUtility.getSelectedActor();
+    if (!acheteur) {
+      ui.notifications.warn(`Pas d'acheteur sélectionné`);
+      return;
+    }
+    const disponible = this.actor.getQuantiteDisponible(item)
+    if (disponible == 0) {
+      ui.notifications.warn(`${this.name} n'a plus de ${item.name} en vente`);
+      return;
+    }
+
+    await DialogItemAchat.onAcheter({
+      item,
+      vendeur: this.actor,
+      acheteur,
+      quantiteIllimite: disponible == undefined,
+      nbLots: disponible ?? 1,
+      tailleLot: 1,
+      prixLot: item.calculerPrixCommercant()
+    });
+  }
+}

module/actor/commerce.js

@@ -0,0 +1,53 @@
+import { Misc } from "../misc.js";
+import { RdDBaseActor } from "./base-actor.js";
+
+export class RdDCommerce extends RdDBaseActor {
+
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/services/commerce.webp";
+  }
+
+  prepareData() {
+    super.prepareData();
+  }
+  prepareDerivedData() {
+    super.prepareDerivedData();
+  }
+
+  canReceive(item) {
+    if (item.isInventaire('all')) {
+      return true;
+    }
+    return super.canReceive(item);
+  }
+
+  getQuantiteDisponible(item) {
+    return this.system.illimite || item.isService() ? undefined : item.getQuantite();
+  }
+
+  verifierFortune(cout) {
+    return this.system.illimite || super.verifierFortune(cout);
+  }
+  async depenserSols(cout) {
+    if (this.system.illimite) {
+      return
+    }
+    await super.depenserSols(cout)
+  }
+
+  async consommerNourritureAchetee(achat, vente, createdItemId) {
+    // ne pas consommer pour un commerce
+  }
+
+  async decrementerQuantiteItem(item, quantite) {
+    if (this.system.illimite) {
+      return;
+    }
+    await super.decrementerQuantiteItem(item, quantite, { supprimerSiZero: false });
+  }
+
+  calculerPrix(item) {
+    const pourcentage = this.system.pourcentage ?? 100;
+    return Misc.keepDecimals(Math.ceil(item.system.cout * pourcentage) / 100, 2);
+  }
+}

module/dialog-chronologie.js

@@ -1,5 +1,7 @@
 import { SYSTEM_RDD } from "./constants.js";
 import { Grammar } from "./grammar.js";
+import { HtmlUtility } from "./html-utility.js";
+import { RdDTimestamp } from "./rdd-timestamp.js";
 
 
 const LATEST_USED_JOURNAL_ID = "chronologie-dernier-journal";
@@ -22,32 +24,14 @@ export class DialogChronologie extends Dialog {
       information: "",
       journalId: game.settings.get(SYSTEM_RDD, LATEST_USED_JOURNAL_ID),
       journaux: game.journal.filter(it => it.testUserPermission(game.user, CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER)),
-      dateRdD: game.system.rdd.calendrier.getCalendrier(),
-      heureRdD: game.system.rdd.calendrier.getCurrentHeure(),
+      timestamp: game.system.rdd.calendrier.timestamp,
       dateReel: DialogChronologie.getCurrentDateTime()
     };
     const html = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/dialog-chronologie.html", dialogData);
-    const dialog = new DialogChronologie(html);
+    const dialog = new DialogChronologie(html, dialogData);
     dialog.render(true);
   }
 
-  constructor(html) {
-    const options = {
-      classes: ["DialogChronologie"],
-      width: 500,
-      height: 'fit-content',
-      'z-index': 99999
-    };
-    const conf = {
-      title: "Chronologie",
-      content: html,
-      buttons: {
-        ajout: { label: "Ajouter", callback: it => this.ajouter() },
-      }
-    };
-    super(conf, options);
-  }
-
   static getCurrentDateTime() {
     return new Date().toLocaleString("sv-SE", {
       year: "numeric",
@@ -58,60 +42,105 @@ export class DialogChronologie extends Dialog {
     }).replace(" ", "T");
   }
 
+  constructor(html, dialogData) {
+    const options = {
+      classes: ["DialogChronologie"],
+      width: 500,
+      height: 'fit-content',
+      'z-index': 99999
+    };
+    const timeData = dialogData.timestamp.toCalendrier()
+    const conf = {
+      title: `Chronologie - ${timeData.jourDuMois} ${timeData.mois.label} - Heure  ${timeData.heure.label}`,
+      content: html,
+      buttons: {
+      }
+    };
+    super(conf, options);
+    this.dialogData = dialogData;
+  }
+
   activateListeners(html) {
+    this.html = html;
     super.activateListeners(html);
+    const journalPrecedent = game.journal.get(this.dialogData.journalId);
+    this.showChronologiePreset(!(journalPrecedent?.canUserModify(game.user)))
+
+    this.html.find("a.chronologie-preset-show").click(event => this.showChronologiePreset(true));
+    this.html.find("a.chronologie-preset-hide").click(event => this.showChronologiePreset(false));
+    this.html.find("button.chronologie-ajouter").click(event => this.ajouter());
+  }
+
+  showChronologiePreset(showPreset) {
+    HtmlUtility.showControlWhen(this.html.find(".chronologie-preset-show"), !showPreset);
+    HtmlUtility.showControlWhen(this.html.find(".chronologie-preset-hide"), showPreset);
+    HtmlUtility.showControlWhen(this.html.find(".chronologie-preset"), showPreset);
   }
 
   async ajouter() {
     await this.forceValidation();
     const { journalId, journalEntry } = this.findJournal();
-    // ajouter à la page ou créer une page
-    this.addContentToJournal(journalEntry, await this.prepareChronologieEntry());
+    if (journalEntry?.canUserModify(game.user)) {
+      const journalParameters = this.extractJournalParameters();
 
-    this.storeLatestUsedJournalEntry(journalId);
+      const jour = journalParameters.dateRdD.jour;
+      const mois = journalParameters.dateRdD.mois.label;
+      const annee = journalParameters.dateRdD.annee;
+      const section = `${jour} ${mois} ${annee}`
+      const content = await this.prepareChronologieEntry(journalParameters);
+      // ajouter à la page ou créer une page
+      this.addContentToJournal(journalEntry, section, content);
+      this.storeLatestUsedJournalEntry(journalId);
+      this.close();
+    }
+    else {
+      const journal = this.html.find("form.rdddialogchrono select[name='journalId']").val();
+      ui.notifications.warn(`Le journal ${journal} n'est pas accessible`);
+    }
   }
 
   async forceValidation() {
-    await $("form.rdddialogchrono :input").change();
+    await this.html.find("form.rdddialogchrono :input").change();
   }
 
   findJournal() {
-    const journalId = $("form.rdddialogchrono :input[name='journalId']").val();
+    const journalId = this.html.find("form.rdddialogchrono :input[name='journalId']").val();
     const journalEntry = game.journal.get(journalId);
     return { journalId, journalEntry };
   }
 
-  async prepareChronologieEntry() {
-    return await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/chronologie-entry.html", this.extractJournalParameters());
+  async prepareChronologieEntry(journalParameters) {
+    return await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/chronologie-entry.html", journalParameters);
   }
 
   extractJournalParameters() {
     return {
-      auteur: $("form.rdddialogchrono :input[name='auteur']").val(),
-      information: $("form.rdddialogchrono :input[name='information']").val(),
+      auteur: this.html.find("form.rdddialogchrono :input[name='auteur']").val(),
+      information: this.html.find("form.rdddialogchrono :input[name='information']").val(),
       dateRdD: {
-        jour: $("form.rdddialogchrono :input[name='dateRdD.jour']").val(),
-        moisRdD: $("form.rdddialogchrono :input[name='dateRdD.moisRdD.key']").val(),
-        annee: $("form.rdddialogchrono :input[name='dateRdD.annee']").val()
+        jour: this.html.find("form.rdddialogchrono :input[name='chronologie.jourDuMois']").val(),
+        mois: RdDTimestamp.definition(this.html.find("form.rdddialogchrono :input[name='chronologie.mois']").val()),
+        annee: this.html.find("form.rdddialogchrono :input[name='chronologie.annee']").val(),
+        heure: RdDTimestamp.definition(this.html.find("form.rdddialogchrono :input[name='chronologie.heure']").val()),
+        minute: this.html.find("form.rdddialogchrono :input[name='chronologie.minute']").val(),
       },
-      heureRdD: $("form.rdddialogchrono :input[name='heureRdD']").val(),
-      dateReel: $("form.rdddialogchrono :input[name='dateReel']").val().replace('T', ' ')
+      dateReel: this.html.find("form.rdddialogchrono :input[name='dateReel']").val().replace('T', ' ')
     }
   }
 
-  addContentToJournal(journalEntry, content) {
-    let page = journalEntry.pages.find(p => p.type == 'text' && Grammar.equalsInsensitive(p.name, 'Chronologie'));
+  addContentToJournal(journalEntry, section, content) {
+    let page = journalEntry.pages.find(p => p.type == 'text' && Grammar.equalsInsensitive(p.name, section));
     if (page) {
-      page.update({ 'text.content': content + '\n' + page.text.content });
+      page.update({ 'text.content': page.text.content + '\n' + content });
     }
     else {
-      journalEntry.createEmbeddedDocuments('JournalEntryPage', [this.newPageChronologie(content)]);
+      journalEntry.createEmbeddedDocuments('JournalEntryPage', [this.newPageChronologie(section, content)]);
     }
   }
 
-  newPageChronologie(content) {
+  newPageChronologie(section, content) {
     return new JournalEntryPage({
-      name: 'Chronologie',
+      name: section,
       type: 'text',
       title: { show: true, level: 1 },
       text: { content: content, format: 1 }

module/dialog-create-signedraconique.js

@@ -1,6 +1,6 @@
 import { ChatUtility } from "./chat-utility.js";
 import { HtmlUtility } from "./html-utility.js";
-import { RdDItemSigneDraconique } from "./item-signedraconique.js";
+import { RdDItemSigneDraconique } from "./item/signedraconique.js";
 import { TMRUtility } from "./tmr-utility.js";
 
 export class DialogCreateSigneDraconique extends Dialog {
@@ -35,16 +35,16 @@ export class DialogCreateSigneDraconique extends Dialog {
     super(conf, options);
     this.dialogData = dialogData;
   }
-
+  
   async _onCreerSigneActeurs() {
-    await $("[name='signe.system.ephemere']").change();
-    await $(".signe-xp-sort").change();
+    await this.html.find("[name='signe.system.ephemere']").change();
+    await this.html.find(".signe-xp-sort").change();
     this.validerSigne();
     this.dialogData.actors.filter(it => it.selected)
-      .map(it => game.actors.get(it.id))
-      .forEach(actor => this._createSigneForActor(actor, this.dialogData.signe));
+    .map(it => game.actors.get(it.id))
+    .forEach(actor => this._createSigneForActor(actor, this.dialogData.signe));
   }
-
+  
   async _createSigneForActor(actor, signe) {
     actor.createEmbeddedDocuments("Item", [signe]);
     ChatMessage.create({
@@ -57,19 +57,20 @@ export class DialogCreateSigneDraconique extends Dialog {
   }
 
   validerSigne() {
-    this.dialogData.signe.name = $("[name='signe.name']").val();
-    this.dialogData.signe.system.valeur.norm = $("[name='signe.system.valeur.norm']").val();
-    this.dialogData.signe.system.valeur.sign = $("[name='signe.system.valeur.sign']").val();
-    this.dialogData.signe.system.valeur.part = $("[name='signe.system.valeur.part']").val();
-    this.dialogData.signe.system.difficulte = $("[name='signe.system.difficulte']").val();
-    this.dialogData.signe.system.ephemere = $("[name='signe.system.ephemere']").prop("checked");
-    this.dialogData.signe.system.duree = $("[name='signe.system.duree']").val();
+    this.dialogData.signe.name = this.html.find("[name='signe.name']").val();
+    this.dialogData.signe.system.valeur.norm = this.html.find("[name='signe.system.valeur.norm']").val();
+    this.dialogData.signe.system.valeur.sign = this.html.find("[name='signe.system.valeur.sign']").val();
+    this.dialogData.signe.system.valeur.part = this.html.find("[name='signe.system.valeur.part']").val();
+    this.dialogData.signe.system.difficulte = this.html.find("[name='signe.system.difficulte']").val();
+    this.dialogData.signe.system.ephemere = this.html.find("[name='signe.system.ephemere']").prop("checked");
+    this.dialogData.signe.system.duree = this.html.find("[name='signe.system.duree']").val();
     this.dialogData.signe.system.typesTMR = TMRUtility.buildListTypesTMRSelection(this.dialogData.tmrs);
   }
-
+  
   /* -------------------------------------------- */
   activateListeners(html) {
     super.activateListeners(html);
+    this.html = html;
     this.setEphemere(this.dialogData.signe.system.ephemere);
     html.find(".signe-aleatoire").click(event => this.setSigneAleatoire());
     html.find("[name='signe.system.ephemere']").change((event) => this.setEphemere(event.currentTarget.checked));
@@ -81,27 +82,27 @@ export class DialogCreateSigneDraconique extends Dialog {
   async setSigneAleatoire() {
     const newSigne = await RdDItemSigneDraconique.randomSigneDraconique({ephemere: true});
 
-    $("[name='signe.name']").val(newSigne.name);
-    $("[name='signe.system.valeur.norm']").val(newSigne.system.valeur.norm);
-    $("[name='signe.system.valeur.sign']").val(newSigne.system.valeur.sign);
-    $("[name='signe.system.valeur.part']").val(newSigne.system.valeur.part);
-    $("[name='signe.system.difficulte']").val(newSigne.system.difficulte);
-    $("[name='signe.system.duree']").val(newSigne.system.duree);
-    $("[name='signe.system.ephemere']").prop("checked", newSigne.system.ephemere);
+    this.html.find("[name='signe.name']").val(newSigne.name);
+    this.html.find("[name='signe.system.valeur.norm']").val(newSigne.system.valeur.norm);
+    this.html.find("[name='signe.system.valeur.sign']").val(newSigne.system.valeur.sign);
+    this.html.find("[name='signe.system.valeur.part']").val(newSigne.system.valeur.part);
+    this.html.find("[name='signe.system.difficulte']").val(newSigne.system.difficulte);
+    this.html.find("[name='signe.system.duree']").val(newSigne.system.duree);
+    this.html.find("[name='signe.system.ephemere']").prop("checked", newSigne.system.ephemere);
     this.dialogData.tmrs = TMRUtility.buildSelectionTypesTMR(newSigne.system.typesTMR);
     this.dialogData.tmrs.forEach(t => {
-      $(`[data-tmr-name='${t.name}']`).prop( "checked", t.selected);
+      this.html.find(`[data-tmr-name='${t.name}']`).prop( "checked", t.selected);
     })
     this.setEphemere(newSigne.system.ephemere);
   }
 
   async setEphemere(ephemere) {
     this.dialogData.signe.system.ephemere = ephemere;
-    HtmlUtility._showControlWhen($(".signe-system-duree"), ephemere);
+    HtmlUtility.showControlWhen(this.html.find(".signe-system-duree"), ephemere);
   }
 
   async onSelectActor(event) {
-    const actorId = $(event.currentTarget)?.data("actor-id");
+    const actorId = this.html.find(event.currentTarget)?.data("actor-id");
     const actor = this.dialogData.actors.find(it => it.id == actorId);
     if (actor) {
       actor.selected = event.currentTarget.checked;
@@ -109,7 +110,7 @@ export class DialogCreateSigneDraconique extends Dialog {
   }
 
   onSelectTmr(event) {
-    const tmrName = $(event.currentTarget)?.data("tmr-name");
+    const tmrName = this.html.find(event.currentTarget)?.data("tmr-name");
     const onTmr = this.tmrs.find(it => it.name == tmrName);
     if (onTmr){
       onTmr.selected = event.currentTarget.checked;

module/dialog-fabriquer-potion.js

@@ -13,18 +13,12 @@ export class DialogFabriquerPotion extends Dialog {
     }
     let potionData = DialogFabriquerPotion.prepareData(actor, item);
 
-    let conf = {
-      title: `Fabriquer une potion de ${potionData.system.categorie}`,
-      content: await renderTemplate(dialogConfig.html, potionData),
-      default: potionData.buttonName,
-    };
+    const html = await renderTemplate(dialogConfig.html, potionData);
 
     let options = { classes: ["dialogfabriquerpotion"], width: 600, height: 160, 'z-index': 99999 };
     mergeObject(options, dialogConfig.options ?? {}, { overwrite: true })
 
-    const dialog = new DialogFabriquerPotion(actor, potionData, conf, options);
-    dialog.render(true);
-    return dialog;
+    new DialogFabriquerPotion(actor, potionData, html, options).render(true);
   }
 
   /* -------------------------------------------- */
@@ -40,10 +34,15 @@ export class DialogFabriquerPotion extends Dialog {
   }
 
   /* -------------------------------------------- */
-  constructor(actor, potionData, conf, options) {
-    conf.buttons = {
-      [potionData.buttonName]: {
-        label: potionData.buttonName, callback: it => this.onFabriquer(it)
+  constructor(actor, potionData, html, options) {
+    const conf = {
+      title: `Fabriquer une potion de ${potionData.system.categorie}`,
+      content: html,
+      default: 'fabriquer',
+      buttons: {
+        'fabriquer': {
+          label: potionData.buttonName, callback: it => this.onFabriquer(html)
+        }
       }
     };
 
@@ -53,6 +52,24 @@ export class DialogFabriquerPotion extends Dialog {
     this.potionData = potionData;
   }
 
+  /* -------------------------------------------- */
+  activateListeners(html) {
+    super.activateListeners(html);
+    this.html = html;
+    this.html.find("[name='nbBrins']").change(event => {
+      this.potionData.nbBrins = Misc.toInt(event.currentTarget.value);
+      const brinsManquants = Math.max(0, DialogFabriquerPotion.nombreBrinsOptimal(this.potionData) - this.potionData.nbBrins);
+      this.potionData.herbebonus = Math.max(0, this.potionData.system.niveau - brinsManquants)
+    });
+  }
+
+  /* -------------------------------------------- */
+  async onFabriquer(html) {
+    await this.html.find("[name='nbBrins']").change();
+    this.actor.fabriquerPotion(this.potionData);
+    this.close();
+  }
+
   static nombreBrinsMinimum(herbeData) {
     switch (herbeData.system.categorie ?? '') {
       case "Soin": return 1 + Math.max(0, 12 - 2 * herbeData.system.niveau);
@@ -68,22 +85,4 @@ export class DialogFabriquerPotion extends Dialog {
     }
     return 1;
   }
-
-  /* -------------------------------------------- */
-  activateListeners(html) {
-    super.activateListeners(html);
-
-    html.find("#nbBrins").change(event => {
-      this.potionData.nbBrins = Misc.toInt(event.currentTarget.value);
-      const brinsManquants = Math.max(0, DialogFabriquerPotion.nombreBrinsOptimal(this.potionData) - this.potionData.nbBrins);
-      this.potionData.herbebonus = Math.max(0, this.potionData.system.niveau - brinsManquants)
-    });
-  }
-
-  /* -------------------------------------------- */
-  async onFabriquer(it) {
-    await $("#nbBrins").change();
-    this.actor.fabriquerPotion(this.potionData);
-    this.close();
-  }
 }

module/dialog-item-achat.js

@@ -1,15 +1,13 @@
-
-import { Monnaie } from "./item-monnaie.js";
 import { Misc } from "./misc.js";
 import { RdDUtility } from "./rdd-utility.js";
 
 export class DialogItemAchat extends Dialog {
 
-  static venteData(button) {
-    const vendeurId = button.attributes['data-vendeurId']?.value;
+  static preparerAchat(chatButton) {
+    const vendeurId = chatButton.attributes['data-vendeurId']?.value;
     const vendeur = vendeurId ? game.actors.get(vendeurId) : undefined;
     const acheteur = RdDUtility.getSelectedActor();
-    const json = button.attributes['data-jsondata']?.value;
+    const json = chatButton.attributes['data-jsondata']?.value;
     if (!acheteur && !vendeur) {
       ui.notifications.info("Pas d'acheteur ni de vendeur, aucun changement");
       return undefined;
@@ -19,59 +17,78 @@ export class DialogItemAchat extends Dialog {
       return undefined;
     }
 
-    const prixLot = Monnaie.arrondiDeniers(button.attributes['data-prixLot']?.value ?? 0);
     return {
-      item: json ? JSON.parse(json) : undefined,
-      actingUserId: game.user.id,
-      vendeurId: vendeurId,
-      vendeur: vendeur,
-      acheteur: acheteur,
-      tailleLot: parseInt(button.attributes['data-tailleLot']?.value ?? 1),
-      quantiteIllimite: button.attributes['data-quantiteIllimite']?.value == 'true',
-      quantiteNbLots: parseInt(button.attributes['data-quantiteNbLots']?.value),
-      choix: {
-        nombreLots: 1,
-        seForcer: false,
-        supprimerSiZero: true
-      },
-      prixLot: prixLot,
-      prixTotal: prixLot,
-      isVente: prixLot > 0,
-      chatMessageIdVente: RdDUtility.findChatMessageId(button)
+      item: (json ? JSON.parse(json) : undefined),
+      vendeur,
+      acheteur,
+      nbLots: parseInt(chatButton.attributes['data-quantiteNbLots']?.value),
+      tailleLot: parseInt(chatButton.attributes['data-tailleLot']?.value ?? 1),
+      prixLot: Number(chatButton.attributes['data-prixLot']?.value ?? 0),
+      quantiteIllimite: chatButton.attributes['data-quantiteIllimite']?.value == 'true',
+      chatMessageIdVente: RdDUtility.findChatMessageId(chatButton),
     };
   }
 
-  static async onAcheter(venteData) {
+
+  static async onAcheter({ item, vendeur, acheteur, tailleLot, prixLot, nbLots, quantiteIllimite, chatMessageIdVente }) {
+    const venteData = {
+      item,
+      actingUserId: game.user.id,
+      vendeurId: vendeur?.id,
+      vendeur,
+      acheteur,
+      tailleLot,
+      quantiteIllimite,
+      quantiteNbLots: nbLots,
+      choix: { seForcer: false, supprimerSiZero: true },
+      prixLot,
+      isVente: prixLot > 0,
+      isConsommable: item.type == 'nourritureboisson' && acheteur?.isPersonnage(),
+      chatMessageIdVente
+    };
+
+    DialogItemAchat.changeNombreLots(venteData, 1);
     const html = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/dialog-item-achat.html`, venteData);
-    const dialog = new DialogItemAchat(html, venteData);
-    dialog.render(true);
+    new DialogItemAchat(html, venteData).render(true);
+  }
+
+  static changeNombreLots(venteData, nombreLots) {
+    venteData.choix.nombreLots = nombreLots;
+    venteData.prixTotal = (nombreLots * venteData.prixLot).toFixed(2);
+    if (venteData.isConsommable) {
+      const doses = nombreLots * venteData.tailleLot;
+      venteData.totalSust = Misc.keepDecimals(doses * (venteData.item.system.sust ?? 0), 2);
+      venteData.totalDesaltere = venteData.item.system.boisson
+        ? Misc.keepDecimals(doses * (venteData.item.system.desaltere ?? 0), 2)
+        : 0;
+    }
   }
 
   constructor(html, venteData) {
-    const isConsommable = venteData.item.type == 'nourritureboisson' && venteData.acheteur?.isPersonnage();
     let options = { classes: ["dialogachat"], width: 400, height: 'fit-content', 'z-index': 99999 };
 
     const actionAchat = venteData.prixLot > 0 ? "Acheter" : "Prendre";
     const buttons = {};
-    if (isConsommable) {
+    if (venteData.isConsommable) {
       buttons["consommer"] = { label: venteData.item.system.boisson ? "Boire" : "Manger", callback: it => this.onAchatConsommer() }
     }
     buttons[actionAchat] = { label: actionAchat, callback: it => { this.onAchat(); } };
     buttons["decliner"] = { label: "Décliner", callback: it => { } };
+    const acheteur = venteData.acheteur?.name ?? 'Un acheteur';
+    const vendeur = venteData.vendeur?.name ?? 'Un vendeur';
     let conf = {
-      title: venteData.acheteur ? venteData.acheteur.name + " - " + actionAchat : actionAchat,
+      title: `${acheteur} - ${actionAchat} à ${vendeur}`,
       content: html,
       default: actionAchat,
       buttons: buttons
     };
 
     super(conf, options);
-
     this.venteData = venteData;
   }
 
   async onAchat() {
-    await $(".nombreLots").change();
+    await this.html.find(".nombreLots").change();
     (this.venteData.vendeur ?? this.venteData.acheteur).achatVente({
       userId: game.user.id,
       vendeurId: this.venteData.vendeur?.id,
@@ -91,9 +108,9 @@ export class DialogItemAchat extends Dialog {
   /* -------------------------------------------- */
   activateListeners(html) {
     super.activateListeners(html);
-
-    html.find(".nombreLots").change(event => this.setNombreLots(Number(event.currentTarget.value)));
-    html.find(".se-forcer").change(event => this.setSeForcer(event));
+    this.html = html;
+    this.html.find(".nombreLots").change(event => this.setNombreLots(Number(event.currentTarget.value)));
+    this.html.find(".se-forcer").change(event => this.setSeForcer(event));
   }
 
   setSeForcer(event) {
@@ -101,13 +118,21 @@ export class DialogItemAchat extends Dialog {
   }
 
   setNombreLots(nombreLots) {
-    if (nombreLots > this.venteData.quantiteNbLots) {
-      ui.notifications.warn(`Seulement ${this.venteData.quantiteNbLots} lots disponibles, vous ne pouvez pas en prendre ${nombreLots}`)
+
+    if (!this.venteData.quantiteIllimite) {
+      if (!this.venteData.quantiteIllimite && nombreLots > this.venteData.quantiteNbLots) {
+        ui.notifications.warn(`Seulement ${this.venteData.quantiteNbLots} lots disponibles, vous ne pouvez pas en prendre ${nombreLots}`)
+      }
+      nombreLots = Math.min(nombreLots, this.venteData.quantiteNbLots);
     }
-    this.venteData.choix.nombreLots = Math.min(nombreLots, this.venteData.quantiteNbLots);
-    this.venteData.prixTotal = (nombreLots * this.venteData.prixLot).toFixed(2);
-    $(".nombreLots").val(this.venteData.choix.nombreLots);
-    $(".prixTotal").text(this.venteData.prixTotal);
+
+    DialogItemAchat.changeNombreLots(this.venteData, nombreLots);
+
+    this.html.find(".nombreLots").val(nombreLots);
+    this.html.find(".prixTotal").text(this.venteData.prixTotal);
+    this.html.find("span.total-sust").text(this.venteData.totalSust);
+    this.html.find("span.total-desaltere").text(this.venteData.totalDesaltere);
   }
 
+
 }

module/dialog-item-consommer.js

@@ -2,13 +2,13 @@ import { Misc } from "./misc.js";
 
 export class DialogConsommer extends Dialog {
 
-  static async create(actor, item, onActionItem = async ()=>{}) {
+  static async create(actor, item, onActionItem = async () => { }) {
     const consommerData = DialogConsommer.prepareData(actor, item);
     const html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/dialog-item-consommer.html', consommerData);
     return new DialogConsommer(actor, item, consommerData, html, onActionItem)
   }
 
-  constructor(actor, item, consommerData, html, onActionItem = async ()=>{}) {
+  constructor(actor, item, consommerData, html, onActionItem = async () => { }) {
     const options = { classes: ["dialogconsommer"], width: 350, height: 'fit-content', 'z-index': 99999 };
     let conf = {
       title: consommerData.title,
@@ -17,8 +17,9 @@ export class DialogConsommer extends Dialog {
       buttons: {
         [consommerData.buttonName]: {
           label: consommerData.buttonName, callback: async it => {
-            await this.onConsommer(it);
-            await onActionItem();}
+            await this.onConsommer();
+            await onActionItem();
+          }
         }
       }
     };
@@ -30,17 +31,23 @@ export class DialogConsommer extends Dialog {
     this.consommerData = consommerData;
   }
 
-  async onConsommer(event) {
-    await $(".se-forcer").change();
-    await $(".consommer-doses").change();
+  activateListeners(html) {
+    super.activateListeners(html);
+    this.html = html;
+    this.html.find(".se-forcer").change(event => this.setSeForcer(event));
+    this.html.find(".consommer-doses").change(event => this.selectDoses(event));
+  }
+
+  async onConsommer() {
+    await this.html.find(".se-forcer").change();
+    await this.html.find(".consommer-doses").change();
     await this.actor.consommer(this.item, this.consommerData.choix);
   }
 
   /* -------------------------------------------- */
   static prepareData(actor, item) {
-    item = duplicate(item);
     let consommerData = {
-      item: item,
+      item: duplicate(item),
       cuisine: actor.getCompetence('cuisine'),
       choix: {
         doses: 1,
@@ -48,33 +55,47 @@ export class DialogConsommer extends Dialog {
       }
     }
     switch (item.type) {
+      case 'herbe': case 'faune':
+        consommerData.title = 'Manger une portion crue: ';
+        consommerData.buttonName = "Manger";
+        break;
       case 'nourritureboisson':
-        consommerData.title = item.system.boisson ? `${item.name}: boire une dose` : `${item.name}: manger une portion`;
+        consommerData.title = item.system.boisson ? 'Boire une dose: ' : 'Manger une portion: ';
         consommerData.buttonName = item.system.boisson ? "Boire" : "Manger";
         break;
       case 'potion':
-        consommerData.title = `${item.name}: boire la potion`;
+        consommerData.title = 'Boire la potion: ';
         consommerData.buttonName = "Boire";
         break;
     }
-    DialogConsommer.calculDoses(consommerData, consommerData.choix.doses)
+    consommerData.title += item.name;
+    DialogConsommer.calculDoses(consommerData, item)
     return consommerData;
   }
 
-  static calculDoses(consommer) {
+  static calculDoses(consommer, item) {
     const doses = consommer.choix.doses;
-    consommer.totalSust = Misc.keepDecimals(doses * (consommer.item.system.sust ?? 0), 2);
-    consommer.totalDesaltere = consommer.item.system.boisson
-      ? Misc.keepDecimals(doses * (consommer.item.system.desaltere ?? 0), 2)
-      : 0;
-  }
-
-
-  /* -------------------------------------------- */
-  activateListeners(html) {
-    super.activateListeners(html);
-    html.find(".se-forcer").change(event => this.setSeForcer(event));
-    html.find(".consommer-doses").change(event => this.selectDoses(event));
+    switch (item.type) {
+      case 'herbe': case 'faune':
+        consommer.totalSust = doses;
+        consommer.totalDesaltere = 0;
+        consommer.choix.sust = 1;
+        consommer.choix.quantite = 0;
+        consommer.choix.encombrement = Misc.keepDecimals(consommer.item.system.encombrement / item.system.sust, 2);
+        return;
+      case 'nourritureboisson':
+        consommer.choix.sust = consommer.item.system.sust;
+        consommer.choix.quantite = doses;
+        consommer.choix.encombrement = 0
+        consommer.totalSust = Misc.keepDecimals(doses * (consommer.item.system.sust ?? 0), 2);
+        consommer.totalDesaltere = consommer.item.system.boisson
+          ? Misc.keepDecimals(doses * (consommer.item.system.desaltere ?? 0), 2)
+          : 0;
+        break;
+      case 'potion':
+        consommer.totalSust = 0
+        consommer.totalDesaltere = 0
+    }
   }
 
 
@@ -84,8 +105,8 @@ export class DialogConsommer extends Dialog {
 
   selectDoses(event) {
     this.consommerData.choix.doses = Number(event.currentTarget.value);
-    DialogConsommer.calculDoses(this.consommerData);
-    $(".total-sust").text(this.consommerData.totalSust);
-    $(".total-desaltere").text(this.consommerData.totalDesaltere);
+    DialogConsommer.calculDoses(this.consommerData, this.item);
+    this.html.find(".total-sust").text(this.consommerData.totalSust);
+    this.html.find(".total-desaltere").text(this.consommerData.totalDesaltere);
   }
 }

module/dialog-item-vente.js

@@ -1,23 +1,23 @@
 import { HtmlUtility } from "./html-utility.js";
-import { Misc } from "./misc.js";
 
 export class DialogItemVente extends Dialog {
 
-  static async display(item, callback) {
-    const quantite = item.isConteneur() ? 1 : item.system.quantite;
+  static async display({ item, callback, quantiteMax = undefined }) {
+    const quantite = quantiteMax ?? item.getQuantite() ?? 1;
+    const isOwned = item.parent;
     const venteData = {
       item: item,
       alias: item.actor?.name ?? game.user.name,
       vendeurId: item.actor?.id,
-      prixOrigine: item.system.cout,
-      prixUnitaire: item.system.cout,
-      prixLot: item.system.cout,
+      prixOrigine: item.calculerPrixCommercant(),
+      prixUnitaire: item.calculerPrixCommercant(),
+      prixLot: item.calculerPrixCommercant(),
       tailleLot: 1,
       quantiteNbLots: quantite,
       quantiteMaxLots: quantite,
-      quantiteMax: quantite ,
-      quantiteIllimite: !item.isOwned,
-      isOwned: item.isOwned,
+      quantiteMax: quantite,
+      quantiteIllimite: item.isItemCommerce() ? quantiteMax == undefined : !isOwned,
+      isOwned: isOwned,
     };
     const html = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/dialog-item-vente.html`, venteData);
     return new DialogItemVente(venteData, html, callback).render(true);
@@ -38,57 +38,65 @@ export class DialogItemVente extends Dialog {
     this.venteData = venteData;
   }
 
-  async onProposer(it) {
-    await $(".tailleLot").change();
-    await $(".quantiteNbLots").change();
-    await $(".quantiteIllimite").change();
-    await $(".prixLot").change();
-    this.callback(this.venteData);
-  }
-
-  /* -------------------------------------------- */
   activateListeners(html) {
     super.activateListeners(html);
 
-    HtmlUtility._showControlWhen($(".quantiteNbLots"), !this.venteData.quantiteIllimite)
+    this.html = html;
+    this.html.find(".tailleLot").change(event => this.setTailleLot(Number(event.currentTarget.value)));
+    this.html.find(".quantiteNbLots").change(event => this.setNbLots(Number(event.currentTarget.value)));
+    this.html.find(".quantiteIllimite").change(event => this.setQuantiteIllimite(event.currentTarget.checked));
+    this.html.find(".prixLot").change(event => this.setPrixLot(Number(event.currentTarget.value)));
 
-    html.find(".tailleLot").change(event => this.setTailleLot(Number(event.currentTarget.value)));
-    html.find(".quantiteNbLots").change(event => this.setNbLots(Number(event.currentTarget.value)));
-    html.find(".quantiteIllimite").change(event => this.setQuantiteIllimite(event.currentTarget.checked));
-    html.find(".prixLot").change(event => this.setPrixLot(Number(event.currentTarget.value)));
+    this.setQuantiteIllimite(this.venteData.quantiteIllimite);
   }
 
+  async onProposer(it) {
+    this.updateVente(this.getChoixVente());
+    this.callback(this.venteData);
+  }
+
+  updateVente(update) {
+    mergeObject(this.venteData, update);
+  }
+
+  getChoixVente() {
+    return {
+      quantiteNbLots: Number(this.html.find(".quantiteNbLots").val()),
+      tailleLot: Number(this.html.find(".tailleLot").val()),
+      quantiteIllimite: this.html.find(".quantiteIllimite").is(':checked'),
+      prixLot: Number(this.html.find(".prixLot").val())
+    };
+  }
+
+  /* -------------------------------------------- */
   setPrixLot(prixLot) {
     this.venteData.prixLot = prixLot;
   }
 
   setTailleLot(tailleLot) {
-    // recalculer le prix du lot
-    if (tailleLot != this.venteData.tailleLot) {
-      this.venteData.prixLot = (tailleLot * this.venteData.prixOrigine).toFixed(2);
-      $(".prixLot").val(this.venteData.prixLot);
-    }
-    this.venteData.tailleLot = tailleLot;
-    if (this.venteData.isOwned) {
-      // recalculer le nombre de lots max
-      this.venteData.quantiteMaxLots = Math.floor(this.venteData.quantiteMax / tailleLot);
-      this.venteData.quantiteNbLots = Math.min(this.venteData.quantiteMaxLots, this.venteData.quantiteNbLots);
-      $(".quantiteNbLots").val(this.venteData.quantiteNbLots);
-      $(".quantiteNbLots").attr("max", this.venteData.quantiteMaxLots)
-    }
+    const maxLots = Math.floor(this.venteData.quantiteMax / tailleLot);
+    this.updateVente({
+      tailleLot,
+      quantiteNbLots: Math.min(maxLots, this.venteData.quantiteNbLots),
+      quantiteMaxLots: maxLots,
+      prixLot: (tailleLot * this.venteData.prixOrigine).toFixed(2)
+    });
+
+    this.html.find(".prixLot").val(this.venteData.prixLot);
+    this.html.find(".quantiteNbLots").val(this.venteData.quantiteNbLots);
+    this.html.find(".quantiteNbLots").attr("max", this.venteData.quantiteMaxLots)
   }
 
   setNbLots(nbLots) {
-    if (this.venteData.isOwned) {
-      nbLots = Math.max(0, Math.min(nbLots, this.venteData.quantiteMaxLots));
-    }
-    this.venteData.quantiteNbLots = nbLots;
-    $(".quantiteNbLots").val(this.venteData.quantiteNbLots);
+    this.updateVente({
+      quantiteNbLots: this.venteData.isOwned ? Math.max(0, Math.min(nbLots, this.venteData.quantiteMaxLots)) : nbLots
+    })
+    this.html.find(".quantiteNbLots").val(this.venteData.quantiteNbLots);
   }
 
   setQuantiteIllimite(checked) {
-    this.venteData.quantiteIllimite = checked;
-    $(".label-quantiteIllimite").text(this.venteData.quantiteIllimite ? "Illimités" : "disponibles");
-    HtmlUtility._showControlWhen($(".quantiteNbLots"), !this.venteData.quantiteIllimite)
+    this.updateVente({ quantiteIllimite: checked })
+    this.html.find(".label-quantiteIllimite").text(this.venteData.quantiteIllimite ? "Illimités" : "disponibles");
+    HtmlUtility.showControlWhen(this.html.find(".quantiteNbLots"), !this.venteData.quantiteIllimite)
   }
 }

module/dialog-repos.js

@@ -1,4 +1,3 @@
-import { Misc } from "./misc.js";
 
 export class DialogRepos extends Dialog {
 
@@ -9,7 +8,7 @@ export class DialogRepos extends Dialog {
   }
 
   constructor(html, actor) {
-    let options = { classes: ["DialogCreateSigneDraconiqueActorsActors"], width: 500, height: 400, 'z-index': 99999 };
+    let options = { classes: ["DialogCreateSigneDraconiqueActorsActors"], width: 400, height: 'fit-content', 'z-index': 99999 };
     let conf = {
       title: "Se reposer",
       content: html,
@@ -21,13 +20,19 @@ export class DialogRepos extends Dialog {
     super(conf, options);
     this.actor = actor;
   }
+  activateListeners(html) {
+    super.activateListeners(html);
+    this.html = html;
+  }
+  /* -------------------------------------------- */
 
   async repos() {
-    await $("[name='nb-heures']").change();
-    await $("[name='nb-jours']").change();
-    const selection = await $("[name='repos']:checked").val();
-    const nbHeures = Number.parseInt(await $("[name='nb-heures']").val());
-    const nbJours = Number.parseInt(await $("[name='nb-jours']").val());
+    await this.html.find("[name='nb-heures']").change();
+    await this.html.find("[name='nb-jours']").change();
+    const selection = await this.html.find("[name='repos']:checked").val();
+    const nbHeures = Number.parseInt(await this.html.find("[name='nb-heures']").val());
+    const nbJours = Number.parseInt(await this.html.find("[name='nb-jours']").val());
+    console.log("ACTOR", this.actor)
     switch (selection) {
       case "sieste": {
         await this.actor.dormir(nbHeures);
@@ -35,7 +40,7 @@ export class DialogRepos extends Dialog {
       }
       case "nuit": {
         let heuresDormies = await this.actor.dormir(nbHeures);
-        if (heuresDormies == nbHeures){
+        if (heuresDormies == nbHeures) {
           await this.actor.dormirChateauDormant();
         }
         return;
@@ -49,8 +54,4 @@ export class DialogRepos extends Dialog {
       }
     }
   }
-  /* -------------------------------------------- */
-  activateListeners(html) {
-    super.activateListeners(html);
-  }
 }

module/dialog-select-target.js

@@ -0,0 +1,37 @@
+
+export class DialogSelectTarget extends Dialog {
+  constructor(html, onSelectTarget, targets) {
+    const options = {
+      classes: ["rdd-dialog-select-target"],
+      width: 'fit-content',
+      height: 'fit-content',
+      'max-height': 600,
+      'z-index': 99999
+    };
+    const conf = {
+      title: "Choisir une cible",
+      content: html,
+      buttons: {}
+    };
+    super(conf, options);
+    this.onSelectTarget = onSelectTarget;
+    this.targets = targets;
+  }
+
+  activateListeners(html) {
+    super.activateListeners(html);
+    this.html = html;
+    this.html.find("li.select-target").click((event) => {
+      this.targetSelected(this.html.find(event.currentTarget)?.data("token-id"));
+    });
+  }
+
+
+  targetSelected(tokenId) {
+    const target = this.targets.find(it => it.id == tokenId);
+    this.close();
+    if (target) {
+      this.onSelectTarget(target);
+    }
+  }
+}

module/dialog-split-item.js

@@ -12,40 +12,34 @@ export class DialogSplitItem extends Dialog {
   }
 
   constructor(item, splitData, html, callback) {
-    let options = { classes: ["dialogsplit"], width: 300, height: 160, 'z-index': 99999 };
-
+    let options = { classes: ["dialogsplit"], width: 300, height: 'fit-content', 'z-index': 99999 };
     let conf = {
       title: "Séparer en deux",
       content: html,
       default: "separer",
       buttons: {
-        "separer": {
-          label: "Séparer", callback: it => {
-            this.onSplit();
-          }
-        }
+        "separer": { label: "Séparer", callback: it => this.onSplit() }
       }
     };
-    
     super(conf, options);
-    
+
     this.callback = callback;
     this.item = item;
     this.splitData = splitData;
   }
 
-  async onSplit(){
-    await $(".choix-quantite").change();
-    this.callback(this.item, this.splitData.choix.quantite);
-  }
-
-  /* -------------------------------------------- */
   activateListeners(html) {
     super.activateListeners(html);
-
-    html.find(".choix-quantite").change(event => {
+    this.html = html;
+    this.html.find(".choix-quantite").change(event => {
       this.splitData.choix.quantite = Number(event.currentTarget.value);
     });
   }
 
+  /* -------------------------------------------- */
+  async onSplit() {
+    await this.html.find(".choix-quantite").change();
+    this.callback(this.item, this.splitData.choix.quantite);
+  }
+
 }

module/dialog-stress.js

@@ -37,24 +37,24 @@ export class DialogStress extends Dialog {
     this.dialogData = dialogData;
   }
 
+  activateListeners(html) {
+    super.activateListeners(html);
+    this.html = html;
+    this.html.find("input.select-actor").change((event) => this.onSelectActor(event));
+  }
+
   async onStress() {
-    const motif = $("form.rdddialogstress input[name='motif']").val();
-    const stress = Number($("form.rdddialogstress input[name='stress']").val());
-    const compteur = ($("form.rdddialogstress input[name='immediat']").prop("checked")) ? 'experience' : 'stress';
+    const motif = this.html.find("form.rdddialogstress input[name='motif']").val();
+    const stress = Number(this.html.find("form.rdddialogstress input[name='stress']").val());
+    const compteur = (this.html.find("form.rdddialogstress input[name='immediat']").prop("checked")) ? 'experience' : 'stress';
 
     this.dialogData.actors.filter(it => it.selected)
       .map(it => game.actors.get(it.id))
       .forEach(actor => actor.distribuerStress(compteur, stress, motif));
   }
 
-  /* -------------------------------------------- */
-  activateListeners(html) {
-    super.activateListeners(html);
-    html.find("input.select-actor").change((event) => this.onSelectActor(event));
-  }
-
   async onSelectActor(event) {
-    const actorId = $(event.currentTarget)?.data("actor-id");
+    const actorId = this.html.find(event.currentTarget)?.data("actor-id");
     const actor = this.dialogData.actors.find(it => it.id == actorId);
     if (actor) {
       actor.selected = event.currentTarget.checked;

module/dialog-validation-encaissement.js

@@ -35,7 +35,7 @@ export class DialogValidationEncaissement extends Dialog {
     }
 
     let dialogOptions = {
-      classes: ["rdddialog"],
+      classes: ["rdd-roll-dialog"],
       width: 350,
       height: 290
     }
@@ -55,11 +55,12 @@ export class DialogValidationEncaissement extends Dialog {
   /* -------------------------------------------- */
   activateListeners(html) {
     super.activateListeners(html);
-    html.find('input.encaissement-roll-result').keyup(async event => {
+    this.html = html;
+    this.html.find('input.encaissement-roll-result').keyup(async event => {
       this.forceDiceResult.total = event.currentTarget.value;
       this.encaissement = await RdDUtility.jetEncaissement(this.rollData, this.armure, { showDice: HIDE_DICE, forceDiceResult: this.forceDiceResult});
-      $('label.encaissement-total').text(this.encaissement.total);
-      $('label.encaissement-blessure').text(this.encaissement.blessures)
+      this.html.find('label.encaissement-total').text(this.encaissement.total);
+      this.html.find('label.encaissement-blessure').text(this.encaissement.blessures)
     });
   }
 

module/environnement.js

@@ -0,0 +1,78 @@
+import { SYSTEM_RDD } from "./constants.js";
+import { Grammar } from "./grammar.js";
+import { Misc } from "./misc.js";
+import { CompendiumTableHelpers, CompendiumTable, SystemCompendiums } from "./settings/system-compendiums.js";
+
+
+const COMPENDIUMS_RECHERCHE = 'compendiums-recherche';
+
+export class Environnement {
+  static init() {
+    game.settings.register(SYSTEM_RDD, COMPENDIUMS_RECHERCHE, {
+      name: COMPENDIUMS_RECHERCHE,
+      default: [
+        SystemCompendiums.getCompendium('faune-flore-mineraux'),
+        SystemCompendiums.getCompendium('meditations-et-ecrits'),
+        SystemCompendiums.getCompendium('equipement')
+      ],
+      scope: "world",
+      config: false,
+      type: Object
+    });
+
+    game.system.rdd.environnement = new Environnement();
+    Hooks.once('ready', () => game.system.rdd.environnement.onReady());
+  }
+
+  constructor() {
+    this.compendiums = [];
+    this.compendiumTables = [];
+    this.mapMilieux = {}
+  }
+
+  async onReady() {
+    await this.$prepareCompendiums()
+  }
+
+  async milieux() {
+    return Object.values(this.mapMilieux);
+  }
+
+  async saveCompendiums(compendiumIds) {
+    game.settings.set(SYSTEM_RDD, COMPENDIUMS_RECHERCHE, compendiumIds);
+    await this.$prepareCompendiums();
+  }
+
+  async $prepareCompendiums() {
+    this.compendiums = game.settings.get(SYSTEM_RDD, COMPENDIUMS_RECHERCHE).filter(c => SystemCompendiums.getPack(c));
+
+    this.compendiumTables = this.compendiums.map(it => new CompendiumTable(it, 'Item'));
+    const compendiumItems = await this.getElements(it => 1, it => it.isInventaire());
+    const fromCompendiums = Misc.concat(compendiumItems.map(it => it.getMilieux().filter(m => m)));
+    this.mapMilieux = Misc.indexLowercase(fromCompendiums);
+  }
+
+  async autresMilieux(item) {
+    const milieuxExistants = item.getMilieux().map(it => Grammar.toLowerCaseNoAccent(it));
+    return Object.keys(this.mapMilieux)
+      .filter(it => !milieuxExistants.includes(it))
+      .map(it => this.mapMilieux[it]);
+  }
+
+  async getElements(itemFrequence, filter) {
+    const compendiumsElement = await Promise.all(
+      this.compendiumTables.map(async compTable => await compTable.getContent(itemFrequence, filter))
+    );
+    const elements = compendiumsElement.reduce((a, b) => a.concat(b));
+    elements.sort(Misc.ascending(it => it.name))
+    return elements;
+  }
+
+  async buildTable(itemFrequence, filter = it => true) {
+    if (!itemFrequence) {
+      itemFrequence = it => it.getFrequence()
+    }
+    const elements = await this.getElements(itemFrequence, filter);;
+    return CompendiumTableHelpers.buildTable(elements, itemFrequence);
+  }
+}

module/html-utility.js

@@ -1,10 +1,10 @@
 export class HtmlUtility{
-  static _showControlWhen(control, condition) {
+  static showControlWhen(jQuerySelector, condition) {
     if (condition) {
-      control.show();
+      jQuerySelector.show();
     }
     else {
-      control.hide();
+      jQuerySelector.hide();
     }
   }
 }

module/item-arme.js

@@ -1,5 +1,4 @@
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js"
-import { Misc } from "./misc.js";
 import { RdDCombatManager } from "./rdd-combat.js";
 
 const nomCategorieParade = {
@@ -28,7 +27,7 @@ export class RdDItemArme extends Item {
     switch (arme ? arme.type : '') {
       case 'arme': return arme;
       case 'competencecreature':
-        return RdDItemCompetenceCreature.toActionArme(arme);
+        return RdDItemCompetenceCreature.armeNaturelle(arme);
     }
     return RdDItemArme.mainsNues();
   }
@@ -177,7 +176,7 @@ export class RdDItemArme extends Item {
         equipe: true,
         rapide: true,
         force: 0,
-        dommages: 0,
+        dommages: "0",
         dommagesReels: 0,
         mortalite: 'non-mortel',
         competence: 'Corps à corps',

module/item-competence.js

@@ -8,18 +8,18 @@ const xp_par_niveau = [5, 5, 5, 10, 10, 10, 10, 15, 15, 15, 15, 20, 20, 20, 20,
 const niveau_max = xp_par_niveau.length - 10;
 /* -------------------------------------------- */
 const limitesArchetypes = [
-  { "niveau": 0, "nombreMax": 100, "nombre": 0 },
-  { "niveau": 1, "nombreMax": 10, "nombre": 0 },
-  { "niveau": 2, "nombreMax": 9, "nombre": 0 },
-  { "niveau": 3, "nombreMax": 8, "nombre": 0 },
-  { "niveau": 4, "nombreMax": 7, "nombre": 0 },
-  { "niveau": 5, "nombreMax": 6, "nombre": 0 },
-  { "niveau": 6, "nombreMax": 5, "nombre": 0 },
-  { "niveau": 7, "nombreMax": 4, "nombre": 0 },
-  { "niveau": 8, "nombreMax": 3, "nombre": 0 },
-  { "niveau": 9, "nombreMax": 2, "nombre": 0 },
-  { "niveau": 10, "nombreMax": 1, "nombre": 0 },
-  { "niveau": 11, "nombreMax": 1, "nombre": 0 }
+  { "niveau": 0, "nombreMax": 100, "reste": 100 },
+  { "niveau": 1, "nombreMax": 10, "reste": 10 },
+  { "niveau": 2, "nombreMax": 9, "reste": 9 },
+  { "niveau": 3, "nombreMax": 8, "reste": 8 },
+  { "niveau": 4, "nombreMax": 7, "reste": 7 },
+  { "niveau": 5, "nombreMax": 6, "reste": 6 },
+  { "niveau": 6, "nombreMax": 5, "reste": 5 },
+  { "niveau": 7, "nombreMax": 4, "reste": 4 },
+  { "niveau": 8, "nombreMax": 3, "reste": 3 },
+  { "niveau": 9, "nombreMax": 2, "reste": 2 },
+  { "niveau": 10, "nombreMax": 1, "reste": 1 },
+  { "niveau": 11, "nombreMax": 1, "reste": 1 }
 ];
 
 /* -------------------------------------------- */
@@ -34,13 +34,6 @@ const categorieCompetences = {
   "lancer": { base: -8, label: "Lancer" }
 }
 
-const compendiumCompetences = {
-  "personnage": "foundryvtt-reve-de-dragon.competences",
-  "creature": "foundryvtt-reve-de-dragon.competences-creatures",
-  "entite": "foundryvtt-reve-de-dragon.competences-entites"
-};
-
-
 function _buildCumulXP() {
   let cumulXP = { "-11": 0 };
   let cumul = 0;
@@ -55,12 +48,6 @@ function _buildCumulXP() {
 const competence_xp_cumul = _buildCumulXP();
 
 export class RdDItemCompetence extends Item {
-
-  /* -------------------------------------------- */
-  static actorCompendium(actorType = undefined) {
-    return compendiumCompetences[actorType ?? 'personnage'];
-  }
-
   /* -------------------------------------------- */
   static getCategorieCompetences() {
     return categorieCompetences;
@@ -280,18 +267,47 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   static computeResumeArchetype(competences) {
-    const archetype = RdDItemCompetence.getLimitesArchetypes();
+    const computed = duplicate(limitesArchetypes);
     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;
+      .filter(n => n > 0)
+      .forEach(n => {
+        computed[n] = computed[n] ?? { niveau: n, nombreMax: 0, reste: 0 };
+        computed[n].reste = computed[n].reste - 1;
       });
-    return archetype;
+      return computed.filter(it => it.reste > 0 && it.niveau > 0);
   }
 
   /* -------------------------------------------- */
-  static getLimitesArchetypes() {
-    return duplicate(limitesArchetypes);
+  static triVisible(competences) {
+    return competences.filter(it => it.system.isVisible)
+      .sort((a, b) => RdDItemCompetence.compare(a, b))
+  }
+
+  static $positionTri(comp) {
+    if (comp.name.startsWith("Survie")) {
+      if (comp.name.includes("Cité")) return 0;
+      if (comp.name.includes("Extérieur")) return 1;
+      return 2;
+    }
+    if (comp.system.categorie.startsWith("melee")) {
+      if (comp.name.includes("Corps")) return 0;
+      if (comp.name.includes("Dague")) return 1;
+      if (comp.name.includes("Esquive")) return 2;
+      return 3;
+    }
+    if (comp.system.categorie.startsWith("draconic")) {
+      if (comp.name.includes("Oniros")) return 0;
+      if (comp.name.includes("Hypnos")) return 1;
+      if (comp.name.includes("Narcos")) return 2;
+      if (comp.name.includes("Thanatos")) return 3;
+      return 4;
+    }
+    return 0;
+  }
+
+  static compare(a, b) {
+    const diff = RdDItemCompetence.$positionTri(a) - RdDItemCompetence.$positionTri(b);
+    return diff ? diff : a.name.localeCompare(b.name);
   }
 
 }

module/item-competencecreature.js

@@ -1,4 +1,4 @@
-import { Misc } from "./misc.js";
+
 import { RdDCombatManager } from "./rdd-combat.js";
 
 /* -------------------------------------------- */
@@ -12,12 +12,12 @@ export class RdDItemCompetenceCreature extends Item {
     rollData.competence.system.categorie = "creature"
     rollData.selectedCarac =  rollData.carac.carac_creature
     if (rollData.competence.system.iscombat) {
-      rollData.arme = RdDItemCompetenceCreature.toActionArme(rollData.competence);
+      rollData.arme = RdDItemCompetenceCreature.armeNaturelle(rollData.competence);
     }
   }
 
   /* -------------------------------------------- */
-  static toActionArme(competencecreature) {
+  static armeNaturelle(competencecreature) {
     if (RdDItemCompetenceCreature.isCompetenceAttaque(competencecreature)) {
       // si c'est un Item compétence: cloner pour ne pas modifier lma compétence
       let arme = (competencecreature instanceof Item) ? competencecreature.clone():  competencecreature;

module/item-monnaie.js

@@ -2,27 +2,28 @@ import { Misc } from "./misc.js";
 import { LOG_HEAD } from "./constants.js";
 
 const MONNAIE_ETAIN = {
-  name: "Etain (1 denier)", type: 'monnaie',
+  name: "Denier (étain)", type: 'monnaie',
   img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_etain_poisson.webp",
-  system: { quantite: 0, valeur_deniers: 1, encombrement: 0.001, description: "" }
+  system: { quantite: 0, cout: 0.01, encombrement: 0.001, description: "" }
 };
 const MONNAIE_BRONZE = {
-  name: "Bronze (10 deniers)", type: 'monnaie',
+  name: "Sou (bronze)", type: 'monnaie',
   img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_bronze_epees.webp",
-  system: { quantite: 0, valeur_deniers: 10, encombrement: 0.002, description: "" }
+  system: { quantite: 0, cout: 0.10, encombrement: 0.002, description: "" }
 };
 const MONNAIE_ARGENT = {
-  name: "Argent (1 sol)", type: 'monnaie',
+  name: "Sol (argent)", type: 'monnaie',
   img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_argent_sol.webp",
-  system: { quantite: 0, valeur_deniers: 100, encombrement: 0.003, description: "" }
+  system: { quantite: 0, cout: 1, encombrement: 0.003, description: "" }
 };
 const MONNAIE_OR = {
-  name: "Or (10 sols)", type: 'monnaie',
+  name: "Dragon (or)", type: 'monnaie',
   img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_or_sol.webp",
-  system: { quantite: 0, valeur_deniers: 1000, encombrement: 0.004, description: "" }
+  system: { quantite: 0, cout: 10, encombrement: 0.004, description: "" }
 };
 
 const MONNAIES_STANDARD = [MONNAIE_ETAIN, MONNAIE_BRONZE, MONNAIE_ARGENT, MONNAIE_OR];
+const VALEUR_DENIERS = sols => Math.max(Math.floor((sols ?? 0) * 100), 0);
 
 export class Monnaie {
 
@@ -32,7 +33,7 @@ export class Monnaie {
 
   static monnaiesManquantes(actor) {
     const disponibles = actor.itemTypes['monnaie'];
-    const manquantes = MONNAIES_STANDARD.filter(standard => !disponibles.find(disponible => Monnaie.deValeur(disponible, standard.system?.valeur_deniers)));
+    const manquantes = MONNAIES_STANDARD.filter(standard => !disponibles.find(disponible => Monnaie.deValeur(disponible, standard.system?.cout)));
     if (manquantes.length > 0) {
       console.error(`${LOG_HEAD} monnaiesManquantes pour ${actor.name}`, manquantes, ' avec monnaies', disponibles, MONNAIES_STANDARD);
     }
@@ -40,15 +41,11 @@ export class Monnaie {
   }
 
   static deValeur(monnaie, valeur) {
-    return valeur == monnaie.system.valeur_deniers
+    return VALEUR_DENIERS(valeur) == VALEUR_DENIERS(monnaie.system.cout)
   }
 
-  static arrondiDeniers(sols) {
-    return Number(sols).toFixed(2);
-  }
-
-  static triValeurDenier() {
-    return Misc.ascending(item => item.system.valeur_deniers)
+  static triValeurEntiere() {
+    return Misc.ascending(item => VALEUR_DENIERS(item.system.cout))
   }
 
   static async creerMonnaiesStandard(actor) {
@@ -65,29 +62,52 @@ export class Monnaie {
     return deniers;
   }
 
-  static async optimiser(actor, fortune) {
-    let reste = fortune;
+  static toSolsDeniers(fortune) {
+    return {
+      sols: Math.floor(fortune),
+      deniers: Math.round(100 * (fortune - Math.floor(fortune)))
+    };
+  }
+
+  static getFortune(monnaies) {
+    return (monnaies??[])
+      .map(m => Number(m.system.cout) * Number(m.system.quantite))
+      .reduce(Misc.sum(), 0);
+  }
+
+  static async optimiserFortune(actor, fortune) {
+    let resteEnDeniers = Math.round(fortune * 100);
     let monnaies = actor.itemTypes['monnaie'];
     let updates = [];
-    let parValeur = Misc.classifyFirst(monnaies, it => it.system.valeur_deniers);
-    for (let valeur of  [1000, 100, 10, 1]) {
-      const itemPiece = parValeur[valeur];
+    Monnaie.validerMonnaies(monnaies, actor);
+
+    let parValeur = Misc.classifyFirst(monnaies, it => VALEUR_DENIERS(it.system.cout));
+    for (let valeurDeniers of [1000, 100, 10, 1]) {
+      const itemPiece = parValeur[valeurDeniers];
       if (itemPiece) {
-        const quantite = Math.floor(reste / valeur);
+        const quantite = Math.floor(resteEnDeniers / valeurDeniers);
         if (quantite != itemPiece.system.quantite) {
-          updates.push({ _id: parValeur[valeur].id, 'system.quantite': quantite });
+          updates.push({ _id: parValeur[valeurDeniers].id, 'system.quantite': quantite });
         }
-        reste -= quantite*valeur;
+        resteEnDeniers -= quantite * valeurDeniers;
       }
     }
-    console.log('Monnaie.optimiser', actor.name, 'total', fortune, 'parValeur', parValeur, 'updates', updates, 'reste', reste);
+    console.log('Monnaie.optimiserFortune', actor.name, 'total', fortune, 'parValeur', parValeur, 'updates', updates, 'reste', resteEnDeniers);
     if (updates.length > 0) {
       await actor.updateEmbeddedDocuments('Item', updates);
     }
-    if (reste > 0){
+    if (resteEnDeniers > 0) {
       // créer le reste en deniers fortune en deniers
-      await Monnaie.creerMonnaiesDeniers(actor, reste);
+      await Monnaie.creerMonnaiesDeniers(actor, resteEnDeniers);
     }
   }
 
+  static validerMonnaies(monnaies, actor = undefined) {
+    monnaies.filter(it => VALEUR_DENIERS(it.system.cout) == 0)
+      .map(it => `La  monnaie ${it.name} de l'acteur ${actor?.name ?? 'sélectionné'} a une valeur de 0!`)
+      .forEach(message => {
+        ui.notifications.warn(message);
+        console.warn(message);
+      });
+  }
 }

module/item-sheet.js

@@ -8,40 +8,66 @@ import { HtmlUtility } from "./html-utility.js";
 import { ReglesOptionelles } from "./settings/regles-optionelles.js";
 import { SYSTEM_RDD } from "./constants.js";
 import { RdDSheetUtility } from "./rdd-sheet-utility.js";
+import { SystemCompendiums } from "./settings/system-compendiums.js";
+import { Misc } from "./misc.js";
+import { RdDTimestamp } from "./rdd-timestamp.js";
 
 /**
- * Extend the basic ItemSheet with some very simple modifications
- * @extends {ItemSheet}
+ * Extend the basic ItemSheet for RdD specific items
  */
 export class RdDItemSheet extends ItemSheet {
 
+  static get ITEM_TYPE() {
+    return undefined
+  }
+
+  static defaultTemplate(type) {
+    return type ?
+      `systems/foundryvtt-reve-de-dragon/templates/item-${type}-sheet.html` :
+      "systems/foundryvtt-reve-de-dragon/templates/item-sheet.html";
+  }
+
+  static register(sheetClass) {
+    Items.registerSheet(SYSTEM_RDD, sheetClass, {
+      label: Misc.typeName('Item', sheetClass.ITEM_TYPE),
+      types: [sheetClass.ITEM_TYPE],
+      makeDefault: true
+    })
+  }
+
   /** @override */
   static get defaultOptions() {
     return mergeObject(super.defaultOptions, {
       classes: [SYSTEM_RDD, "sheet", "item"],
-      template: "systems/foundryvtt-reve-de-dragon/templates/item-sheet.html",
+      template: RdDItemSheet.defaultTemplate(RdDItemSheet.ITEM_TYPE),
       width: 550,
       height: 550
     });
   }
 
+  /* -------------------------------------------- */
+  get template() {
+    return RdDItemSheet.defaultTemplate(this.item.type);
+  }
+
+  get title() {
+    return `${Misc.typeName('Item', this.item.type)}: ${this.item.name}`;
+  }
 
   /* -------------------------------------------- */
   _getHeaderButtons() {
     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 this.item.system && this.item.isVideOuNonConteneur()) {
+    if (this.item.isInventaire() && this.item.isVideOuNonConteneur()) {
       buttons.unshift({
         class: "vendre",
         icon: "fas fa-comments-dollar",
-        onclick: ev => this.item.proposerVente()
+        onclick: ev => this.item.proposerVente(1)
       });
     }
     buttons.unshift({
       class: "montrer",
       icon: "fas fa-comment",
-      onclick: ev => this.item.postItem()
+      onclick: ev => this.item.postItemToChat()
     });
     return buttons
   }
@@ -60,180 +86,143 @@ export class RdDItemSheet extends ItemSheet {
   /* -------------------------------------------- */
   async getData() {
     let formData = {
-      id: this.item.id,
       title: this.item.name,
+      id: this.item.id,
       type: this.item.type,
       img: this.item.img,
       name: this.item.name,
       system: this.item.system,
-      isGM: game.user.isGM,
       actorId: this.actor?.id,
-      owner: this.item.isOwner,
-      editable: this.isEditable,
-      cssClass: this.isEditable ? "editable" : "locked",
-      isSoins: false,
-      description:  await TextEditor.enrichHTML(this.object.system.description, {async: true}),
-      descriptionmj:  await TextEditor.enrichHTML(this.object.system.descriptionmj, {async: true})
-
-    }
-    if (this.actor) {
-      formData.isOwned = true;
-      if (this.item.type == 'conteneur') {
-        this.prepareConteneurData(formData);
-      }
+      description: await TextEditor.enrichHTML(this.item.system.description, { async: true }),
+      descriptionmj: await TextEditor.enrichHTML(this.item.system.descriptionmj, { async: true }),
+      isComestible: this.item.getUtilisationCuisine(),
+      options: RdDSheetUtility.mergeDocumentRights(this.options, this.item, this.isEditable)
     }
 
+    const competences = await SystemCompendiums.getCompetences(this.actor?.type);
     formData.categorieCompetences = RdDItemCompetence.getCategorieCompetences()
     if (this.item.type == 'tache' || this.item.type == 'livre' || this.item.type == 'meditation' || this.item.type == 'oeuvre') {
       formData.caracList = duplicate(game.system.model.Actor.personnage.carac)
       formData.caracList["reve-actuel"] = duplicate(game.system.model.Actor.personnage.reve.reve)
-      formData.competences = await RdDUtility.loadItems(it => it.isCompetencePersonnage(), RdDItemCompetence.actorCompendium(this.actor?.type))
+      formData.competences = competences;
     }
     if (this.item.type == 'arme') {
-      formData.competences = await RdDUtility.loadItems(it => RdDItemCompetence.isCompetenceArme(it),  RdDItemCompetence.actorCompendium(this.actor?.type))
+      formData.competences = competences.filter(it => RdDItemCompetence.isCompetenceArme(it));
     }
     if (['sort', 'sortreserve'].includes(this.item.type)) {
-      formData.competences = await RdDUtility.loadItems(it => RdDItemCompetence.isDraconic(it),  RdDItemCompetence.actorCompendium(this.actor?.type))
+      formData.competences = competences.filter(it => RdDItemCompetence.isDraconic(it));
     }
     if (this.item.type == 'recettecuisine') {
-      formData.ingredients = await TextEditor.enrichHTML(this.object.system.ingredients, {async: true})
+      formData.ingredients = await TextEditor.enrichHTML(this.object.system.ingredients, { async: true })
     }
     if (this.item.type == 'extraitpoetique') {
-      formData.extrait = await TextEditor.enrichHTML(this.object.system.extrait, {async: true})
-      formData.texte = await TextEditor.enrichHTML(this.object.system.texte, {async: true})
+      formData.extrait = await TextEditor.enrichHTML(this.object.system.extrait, { async: true })
+      formData.texte = await TextEditor.enrichHTML(this.object.system.texte, { async: true })
     }
     if (this.item.type == 'recettealchimique') {
       RdDAlchimie.processManipulation(this.item, this.actor && this.actor.id);
-      formData.manipulation_update = await TextEditor.enrichHTML(this.object.system.manipulation_update, {async: true})
-      formData.utilisation = await TextEditor.enrichHTML(this.object.system.utilisation, {async: true})
-      formData.enchantement = await TextEditor.enrichHTML(this.object.system.enchantement, {async: true})
-      formData.sureffet = await TextEditor.enrichHTML(this.object.system.sureffet, {async: true})
+      formData.manipulation_update = await TextEditor.enrichHTML(this.object.system.manipulation_update, { async: true })
+      formData.utilisation = await TextEditor.enrichHTML(this.object.system.utilisation, { async: true })
+      formData.enchantement = await TextEditor.enrichHTML(this.object.system.enchantement, { async: true })
+      formData.sureffet = await TextEditor.enrichHTML(this.object.system.sureffet, { async: true })
     }
     if (this.item.type == 'gemme') {
       formData.gemmeTypeList = RdDGemme.getGemmeTypeOptionList();
       RdDGemme.calculDataDerivees(this.item);
     }
     if (this.item.type == 'potion') {
-      if (this.dateUpdated) {
-        formData.system.prdate = this.dateUpdated;
-        this.dateUpdated = undefined;
-      }
-      await RdDHerbes.updatePotionData(formData);
+      await RdDHerbes.addPotionFormData(formData);
     }
-    if (formData.isOwned && this.item.type == 'herbe' && (formData.system.categorie == 'Soin' || formData.system.categorie == 'Repos')) {
+    if (formData.options.isOwned && this.item.type == 'herbe' && (formData.system.categorie == 'Soin' || formData.system.categorie == 'Repos')) {
       formData.isIngredientPotionBase = true;
     }
     if (this.item.type == 'sortreserve') {
       const sortId = this.item.system.sortid;
-      formData.sort = formData.isOwned ? this.item.actor.items.get(sortId) : game.items.get(sortId);
+      formData.sort = formData.options.isOwned ? this.item.actor.items.get(sortId) : game.items.get(sortId);
     }
     formData.bonusCaseList = RdDItemSort.getBonusCaseList(formData, true);
 
     return formData;
   }
 
-  /* -------------------------------------------- */
-  prepareConteneurData(formData) {
-    RdDUtility.filterEquipementParType(formData, this.actor.itemTypes);
-
-    this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.objets);
-    formData.subItems = formData.conteneurs.find(it => it._id == this.item.id)?.subItems;
-
-  }
-
   /* -------------------------------------------- */
   /** @override */
   activateListeners(html) {
     super.activateListeners(html);
+    this.html = html;
 
-    if (this.item.type == 'conteneur') {
-      this.form.ondragstart = (event) => this._onDragStart(event);
-      this.form.ondrop = (event) => this._onDrop(event);
-    }
-
-    let itemSheetDialog = this;
-
-    HtmlUtility._showControlWhen($(".item-cout"), ReglesOptionelles.isUsing('afficher-prix-joueurs') || game.user.isGM || !this.item.isOwned);
-    HtmlUtility._showControlWhen($(".item-magique"), this.item.isMagique());
+    HtmlUtility.showControlWhen(this.html.find(".item-cout"), ReglesOptionelles.isUsing('afficher-prix-joueurs')
+      || game.user.isGM
+      || !this.item.isOwned);
+    HtmlUtility.showControlWhen(this.html.find(".item-magique"), this.item.isMagique());
 
     // Everything below here is only needed if the sheet is editable
     if (!this.options.editable) return;
 
-    // Select competence categorie
-    html.find(".categorie").change(event => this._onSelectCategorie(event));
+    this.form.ondragstart = (event) => this._onDragStart(event);
+    this.form.ondrop = (event) => this._onDrop(event);
 
-    html.find('.sheet-competence-xp').change((event) => {
+    // Select competence categorie
+    this.html.find(".categorie").change(event => this._onSelectCategorie(event));
+
+    this.html.find('.sheet-competence-xp').change((event) => {
       if (this.item.isCompetencePersonnage()) {
         RdDUtility.checkThanatosXP(this.item.name);
       }
     });
+    this.html.find(".item-cout input[name='system.cout']").change(event => {
+      if (this.item.isMonnaie()) {
+        const value = event.currentTarget.value;
+        if (Number(value) == 0) {
+          ui.notifications.error(`${this.actor?.name ?? 'Monnaie'}: La monnaie ${this.item.name} a maintenant une valeur de 0, et ne peut plus être utilisée pour payer!`)
+        }
+      }
+    })
 
-    html.find('.enchanteDate').change((event) => {
-      let jour = Number($('#jourMois').val());
-      let mois = $('#nomMois').val();
-      this.dateUpdated = game.system.rdd.calendrier.getIndexFromDate(jour, mois);
+    this.html.find('.date-enchantement').change((event) => {
+      const jour = Number(this.html.find('input.date-enchantement[name="enchantement.jour"]').val());
+      const mois = RdDTimestamp.definition(this.html.find('select.date-enchantement[name="enchantement.mois"]').val());
+      const indexDate = game.system.rdd.calendrier.getIndexFromDate(jour, mois.heure);
+      this.item.update({ 'system.prdate': indexDate });
+      console.warn(`Date d'enchantement modifiée ${jour}/${mois.heure}: ${indexDate}`)
     });
 
-    html.find('.creer-tache-livre').click((event) => {
-      let actorId = event.currentTarget.attributes['data-actor-id'].value;
-      let actor = game.actors.get(actorId);
-      actor.creerTacheDepuisLivre(this.item);
-    });
-    html.find('.consommer-potion').click((event) => {
-      let actorId = event.currentTarget.attributes['data-actor-id'].value;
-      let actor = game.actors.get(actorId);
-      actor.consommerPotion(this.item);
-    });
-    html.find('.creer-potion-base').click((event) => {
-      let actorId = event.currentTarget.attributes['data-actor-id'].value;
-      let actor = game.actors.get(actorId);
-      actor.dialogFabriquerPotion(this.item);
-    });
+    this.html.find('.creer-tache-livre').click((event) => this._getEventActor(event).creerTacheDepuisLivre(this.item));
+    this.html.find('.consommer-potion').click((event) => this._getEventActor(event).consommerPotion(this.item));
+    this.html.find('.creer-potion-base').click((event) => this._getEventActor(event).dialogFabriquerPotion(this.item));
 
-    html.find('.alchimie-tache a').click((event) => {
-      let actorId = event.currentTarget.attributes['data-actor-id'].value;
-      let recetteId = event.currentTarget.attributes['data-recette-id'].value;
-      let tacheName = event.currentTarget.attributes['data-alchimie-tache'].value;
-      let tacheData = event.currentTarget.attributes['data-alchimie-data'].value;
-      let actor = game.actors.get(actorId);
+    this.html.find('.alchimie-tache a').click((event) => {
+      let actor = this._getEventActor(event);
       if (actor) {
+        let recetteId = event.currentTarget.attributes['data-recette-id'].value;
+        let tacheName = event.currentTarget.attributes['data-alchimie-tache'].value;
+        let tacheData = event.currentTarget.attributes['data-alchimie-data'].value;
         actor.effectuerTacheAlchimie(recetteId, tacheName, tacheData);
       } else {
         ui.notifications.info("Impossible trouver un acteur pour réaliser cette tache Alchimique.");
       }
     });
 
-    html.find('.item-split').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
-      await RdDSheetUtility.splitItem(item, this.actor, async () => itemSheetDialog.render(true));
-    });
-    html.find('.item-edit').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
-      item.sheet.render(true);
-    });
-    html.find('.item-delete').click(async event => {
-      const li = RdDSheetUtility.getEventElement(event);
-      const item = this.actor.getObjet(li.data("item-id"));
-      RdDUtility.confirmerSuppressionItem(this, item, li);
-    });
-    html.find('.item-vendre').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
-      item?.proposerVente();
-    });
-    html.find('.item-montrer').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
-      item?.postItem();
-    });
-    html.find('.item-action').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
-      this.actor.actionItem(item, async () => itemSheetDialog.render(true));
-    });
-    html.find('.conteneur-name a').click(async event => {
-      RdDUtility.toggleAfficheContenu(RdDSheetUtility.getItemId(event));
-      this.render(true);
-    });
+    this.html.find('.item-split').click(async event => RdDSheetUtility.splitItem(RdDSheetUtility.getItem(event, this.actor), this.actor, async () => this.render(true)));
+    this.html.find('.item-edit').click(async event => RdDSheetUtility.getItem(event, this.actor)?.sheet.render(true));
+    this.html.find('.item-delete').click(async event => RdDUtility.confirmActorItemDelete(this, RdDSheetUtility.getItem(event, this.actor)));
+    this.html.find('.item-vendre').click(async event => RdDSheetUtility.getItem(event, this.actor)?.proposerVente());
+    this.html.find('.item-montrer').click(async event => RdDSheetUtility.getItem(event, this.actor)?.postItemToChat());
+    this.html.find('.item-action').click(async event => RdDSheetUtility.getItem(event, this.actor)?.actionPrincipale(this.actor, async () => this.render(true)));
+
+    const updateItemTimestamp = (path, timestamp) => this.item.update({ [path]: duplicate(timestamp) })
+
+    RdDTimestamp.handleTimestampEditor(this.html, 'system.temporel.debut', updateItemTimestamp);
+    RdDTimestamp.handleTimestampEditor(this.html, 'system.temporel.fin', updateItemTimestamp);
   }
 
+  _getEventActor(event) {
+    let actorId = event.currentTarget.attributes['data-actor-id'].value;
+    let actor = game.actors.get(actorId);
+    return actor;
+  }
+
+
   /* -------------------------------------------- */
   async _onSelectCategorie(event) {
     event.preventDefault();
@@ -241,70 +230,56 @@ export class RdDItemSheet extends ItemSheet {
     if (this.item.isCompetence()) {
       let level = RdDItemCompetence.getNiveauBase(event.currentTarget.value);
       this.item.system.base = level;
-      $("#base").val(level);
+      this.html.find('[name="system.base"]').val(level);
     }
   }
 
   /* -------------------------------------------- */
-  get template() {
-    let type = this.item.type
-    return `systems/foundryvtt-reve-de-dragon/templates/item-${type}-sheet.html`;
-  }
-
-  /* -------------------------------------------- */
-
   /** @override */
   _updateObject(event, formData) {
-    // Données de bonus de cases ?
-    formData['system.bonuscase'] = RdDItemSort.buildBonusCaseStringFromFormData(formData.bonusValue, formData.caseValue);
+    if (this.item.type == 'sort') {
+      // Données de bonus de cases ?
+      formData['system.bonuscase'] = RdDItemSort.buildBonusCaseStringFromFormData(formData.bonusValue, formData.caseValue);
+    }
 
     return this.item.update(formData);
   }
 
+  /* -------------------------------------------- */
   async _onDragStart(event) {
-    console.log("_onDragStart", event);
-    if (event.target.classList.contains("entity-link")) return;
-
-    const itemId = event.srcElement?.attributes["data-item-id"].value;
-    const item = this.actor.items.get(itemId);
-    // Create drag data
-    const dragData = {
-      actorId: this.actor.id,
-      type: "Item",
-      data: item.system
-    };
-
-    event.dataTransfer.setData("text/plain", JSON.stringify(dragData));
   }
 
   async _onDrop(event) {
     // Try to extract the dragData
-    let dragData;
-    try {
-      dragData = JSON.parse(event.dataTransfer.getData('text/plain'));
-    } catch (err) {
-      return false;
-    }
-
+    let dragData = RdDItemSheet.$extractDragData(event);
+    if (!dragData) return false;
     const allowed = Hooks.call("dropActorSheetData", this.actor, this, dragData);
-    if (allowed === false) return;
+    if (allowed === false) return false;
 
     // Handle different dragData types
     switch (dragData.type) {
       case "Item":
         return this._onDropItem(event, dragData);
+      case "Actor":
+        return this._onDropActor(event, dragData);
     }
     return super._onDrop(event);
   }
 
-  /* -------------------------------------------- */
-  async _onDropItem(event, dragData) {
-    if (this.actor) {
-      const dropParams = RdDSheetUtility.prepareItemDropParameters(this.item.id, this.actor.id, dragData, this.objetVersConteneur);
-      await this.actor.processDropItem(dropParams);
-      await this.render(true);
-    }
+  static $extractDragData(event) {
+    try {
+      const eventData = event?.dataTransfer?.getData('text/plain');
+      if (eventData) {
+        return JSON.parse(eventData);
+      }
+    } catch (err) { }
+    return undefined;
   }
 
+  async _onDropItem(event, dragData) {
+  }
+
+  async _onDropActor(event, dragData) {
+  }
 
 }

module/item-tache.js

@@ -1,4 +1,18 @@
-export class RdDItemTache extends Item {
-  
+const BASE_TACHE_SOIN_BLESSURE = { type: "tache", img: 'systems/foundryvtt-reve-de-dragon/icons/competence_chirurgie.webp', system: { carac: "dexterite", competence: "Chirurgie", periodicite: "1 round", fatigue: 0, } }
+const TACHES_SOIN_BLESSURE = {
+  'critique': { name: 'Blessure critique', system: { difficulte: -6, points_de_tache: 6 } },
+  'grave': { name: 'Blessure grave', system: { difficulte: -4, points_de_tache: 4 } },
+  'legere': { name: 'Blessure légère', system: { difficulte: -2, points_de_tache: 2 } },
+}
 
+export class RdDItemTache extends Item {
+
+  static prepareTacheSoin(gravite) {
+    const blessure = TACHES_SOIN_BLESSURE[gravite]
+    if (blessure) {
+      return mergeObject(duplicate(BASE_TACHE_SOIN_BLESSURE), blessure)
+    }
+    ui.notifications.warn(`Pas de tâche de soins pour une blessure ${gravite}`)
+    return undefined;
+  }
 }

module/item.js

@@ -1,14 +1,20 @@
 import { DialogItemVente } from "./dialog-item-vente.js";
 import { Grammar } from "./grammar.js";
+import { Misc } from "./misc.js";
 import { RdDHerbes } from "./rdd-herbes.js";
+import { RdDTimestamp } from "./rdd-timestamp.js";
 import { RdDUtility } from "./rdd-utility.js";
+import { SystemCompendiums } from "./settings/system-compendiums.js";
+import { RdDRaretes } from "./item/raretes.js";
 
-const typesObjetsEquipement = [
+const typesInventaireMateriel = [
   "arme",
   "armure",
   "conteneur",
+  "faune",
   "gemme",
   "herbe",
+  "plante",
   "ingredient",
   "livre",
   "monnaie",
@@ -17,11 +23,18 @@ const typesObjetsEquipement = [
   "objet",
   "potion",
 ]
+const typesInventaire = {
+  materiel: typesInventaireMateriel,
+  all: ['service'].concat(typesInventaireMateriel),
+}
+
 const typesObjetsOeuvres = ["oeuvre", "recettecuisine", "musique", "chant", "danse", "jeu"]
 const typesObjetsDraconiques = ["queue", "ombre", "souffle", "tete", "signedraconique", "sortreserve", "rencontre"]
 const typesObjetsConnaissance = ["meditation", "recettealchimique", "sort"]
 const typesObjetsEffet = ["possession", "poison", "maladie"]
 const typesObjetsCompetence = ["competence", "competencecreature"]
+const typesObjetsTemporels = ["poison", "maladie", "queue", "ombre", "souffle", "signedraconique", "rencontre"]
+const typesEnvironnement = typesInventaireMateriel;
 const encBrin = 0.00005; // un brin = 1 décigramme = 1/10g = 1/10000kg = 1/20000 enc
 const encPepin = 0.0007; /* un pépin de gemme = 1/10 cm3 = 1/1000 l = 3.5/1000 kg = 7/2000 kg = 7/1000 enc
 densité 3.5 (~2.3 à 4, parfois plus) -- https://www.juwelo.fr/guide-des-pierres/faits-et-chiffres/ 
@@ -35,6 +48,7 @@ export const defaultItemImg = {
   conteneur: "systems/foundryvtt-reve-de-dragon/icons/objets/sac_a_dos.webp",
   sort: "systems/foundryvtt-reve-de-dragon/icons/competence_oniros.webp",
   herbe: "systems/foundryvtt-reve-de-dragon/icons/botanique/Endorlotte.webp",
+  faune: "systems/foundryvtt-reve-de-dragon/icons/faune/rongeur.webp",
   ingredient: "systems/foundryvtt-reve-de-dragon/icons/objets/sable_poudre.webp",
   livre: "systems/foundryvtt-reve-de-dragon/icons/objets/livre.webp",
   potion: "systems/foundryvtt-reve-de-dragon/icons/objets/liqueur_de_bagdol.webp",
@@ -54,58 +68,149 @@ export const defaultItemImg = {
   poison: "systems/foundryvtt-reve-de-dragon/icons/maladies_venins/venin.webp",
   oeuvre: "systems/foundryvtt-reve-de-dragon/icons/competence_comedie.webp",
   nourritureboisson: "systems/foundryvtt-reve-de-dragon/icons/objets/provision_crue.webp",
+  service: "systems/foundryvtt-reve-de-dragon/icons/services/lit.webp",
   signedraconique: "systems/foundryvtt-reve-de-dragon/icons/tmr/signe_draconique.webp",
   gemme: "systems/foundryvtt-reve-de-dragon/icons/gemmes/almaze.webp",
   possession: "systems/foundryvtt-reve-de-dragon/icons/entites/possession2.webp",
   sortreserve: "systems/foundryvtt-reve-de-dragon/icons/competence_oniros.webp",
   extraitpoetique: "systems/foundryvtt-reve-de-dragon/icons/competence_ecriture.webp",
+  tarot: "systems/foundryvtt-reve-de-dragon/icons/tarots/dos-tarot.webp",
 }
 
 /* -------------------------------------------- */
 export class RdDItem extends Item {
 
-  constructor(itemData, context) {
-    if (!itemData.img) {
-      itemData.img = defaultItemImg[itemData.type];
-    }
-    super(itemData, context);
+  static getDefaultImg(itemType) {
+    return game.system.rdd.itemClasses[itemType]?.defaultIcon ?? defaultItemImg[itemType];
   }
 
-  static getTypesObjetsEquipement() {
-    return typesObjetsEquipement
+  static isFieldInventaireModifiable(type, field) {
+    switch (field) {
+      case 'quantite':
+        if (['conteneur'].includes(type)) {
+          return false;
+        }
+        break;
+      case 'cout':
+        if (['monnaie'].includes(type)) {
+          return game.user.isGM;
+        }
+        break;
+    }
+    return true;
+  }
+
+  static async getCorrespondingItem(itemRef) {
+    if (itemRef.pack) {
+      return await SystemCompendiums.loadDocument(itemRef)
+    }
+    return game.items.get(itemRef.id ?? itemRef._id);
+  }
+
+  static getItemTypesInventaire(mode = 'materiel') {
+    return typesInventaire[mode ?? 'materiel']
+  }
+  static getItemTypesDraconiques() {
+    return typesObjetsDraconiques;
+  }
+  static getItemTypesEnvironnement() {
+    return typesEnvironnement;
   }
 
   static getTypesOeuvres() {
     return typesObjetsOeuvres
   }
 
-  isCompetencePersonnage() {
-    return this.type == 'competence'
+  constructor(docData, context = {}) {
+    if (!context.rdd?.ready) {
+      mergeObject(context, { rdd: { ready: true } });
+      const ItemConstructor = game.system.rdd.itemClasses[docData.type];
+      if (ItemConstructor) {
+        if (!docData.img) {
+          docData.img = ItemConstructor.defaultIcon;
+        }
+        return new ItemConstructor(docData, context);
+      }
+    }
+    if (!docData.img) {
+      docData.img = RdDItem.getDefaultImg(docData.type);
+    }
+    super(docData, context);
   }
-  isCompetence() {
-    return typesObjetsCompetence.includes(this.type)
+
+  static get defaultIcon() {
+    return undefined;
   }
-  isEquipement() {
-    return typesObjetsEquipement.includes(this.type)
+
+  getUniteQuantite() {
+    switch (this.type) {
+      case "monnaie": return "(Pièces)"
+      case "herbe":
+        switch (this.system.categorie) {
+          case 'Alchimie': case 'Repos': case 'Soin':
+            return "(Brins)"
+          case 'Cuisine': return '';
+        }
+        return '';
+      case "ingredient": return "(Pépins ou Brins)"
+    }
+    return '';
   }
-  isOeuvre() {
-    return typesObjetsOeuvres.includes(this.type)
+
+  isCompetencePersonnage() { return this.type == 'competence' }
+  isCompetenceCreature() { return this.type == 'competencecreature' }
+  isConteneur() { return this.type == 'conteneur'; }
+  isMonnaie() { return this.type == 'monnaie'; }
+  isPotion() { return this.type == 'potion'; }
+  isNourritureBoisson() { return this.type == 'nourritureboisson'; }
+  isService() { return this.type == 'service'; }
+
+  isCompetence() { return typesObjetsCompetence.includes(this.type) }
+  isTemporel() { return typesObjetsTemporels.includes(this.type) }
+  isOeuvre() { return typesObjetsOeuvres.includes(this.type) }
+  isDraconique() { return RdDItem.getItemTypesDraconiques().includes(this.type) }
+  isEffet() { return typesObjetsEffet.includes(this.type) }
+  isConnaissance() { return typesObjetsConnaissance.includes(this.type) }
+
+  isInventaire(mode = 'materiel') { return RdDItem.getItemTypesInventaire(mode).includes(this.type); }
+  isBoisson() { return this.isNourritureBoisson() && this.system.boisson; }
+  isAlcool() { return this.isNourritureBoisson() && this.system.boisson && this.system.alcoolise; }
+  isHerbeAPotion() { return this.type == 'herbe' && (this.system.categorie == 'Soin' || this.system.categorie == 'Repos'); }
+
+  isPresentDansMilieux(milieux) {
+    return this.getEnvironnements(milieux).length > 0
   }
-  isDraconique() {
-    return typesObjetsDraconiques.includes(this.type)
+
+  getEnvironnements(milieux = undefined) {
+    const environnements = this.isInventaire() ? this.system.environnement : undefined;
+    if (milieux == undefined || !environnements) {
+      return environnements ?? [];
+    }
+    return environnements.filter(env => milieux.includes(env.milieu))
   }
-  isEffet() {
-    return typesObjetsEffet.includes(this.type)
+
+  getMilieux() {
+    return this.getEnvironnements().map(env => env.milieu);
   }
-  isConnaissance() {
-    return typesObjetsConnaissance.includes(this.type)
+
+  getRaretes(milieux = undefined) {
+    if (this.isInventaire()) {
+      const raretes = this.getEnvironnements(milieux).map(env => RdDRaretes.byCode(env.rarete));
+      if (milieux == undefined && raretes.length == 0) {
+        return [RdDRaretes.rareteFrequente()];
+      }
+      return raretes;
+    }
+    return [RdDRaretes.rareteEgale()];
   }
-  isConteneur() {
-    return this.type == 'conteneur';
+
+  getFrequence(milieux = undefined) {
+    const frequences = this.getEnvironnements(milieux).map(it => it.frequence);
+    return frequences.length == 0 ? 0 : Math.max(...frequences);
   }
 
   getItemGroup() {
-    if (this.isEquipement()) return "equipement";
+    if (this.isInventaire()) return "equipement";
     if (this.isOeuvre()) return "oeuvre";
     if (this.isDraconique()) return "draconique";
     if (this.isConnaissance()) return "connaissance";
@@ -114,27 +219,79 @@ export class RdDItem extends Item {
     return "autres";
   }
 
-  isConteneurNonVide() {
-    return this.isConteneur() && (this.system.contenu?.length ?? 0) > 0;
+  isConteneurNonVide() { return this.isConteneur() && (this.system.contenu?.length ?? 0) > 0; }
+  isConteneurVide() { return this.isConteneur() && (this.system.contenu?.length ?? 0) == 0; }
+  isVideOuNonConteneur() { return !this.isConteneur() || (this.system.contenu?.length ?? 0) == 0; }
+
+  isFinPeriode(oldTimestamp, newTimestamp) {
+    if (!this.isTemporel()) {
+      return false;
+    }
+    const finPeriode = new RdDTimestamp(this.system.temporel.fin);
+    return oldTimestamp.compare(finPeriode) < 0 && finPeriode.compare(newTimestamp) <= 0
   }
 
-  isConteneurVide() {
-    return this.isConteneur() && (this.system.contenu?.length ?? 0) == 0;
+  async onCreateItemTemporel(actor) {
+    if (this.isTemporel()) {
+      const timestampDebut = game.system.rdd.calendrier.timestamp;
+      const timestampFin = await this.calculerFinPeriodeTemporel(timestampDebut);
+      await actor.updateEmbeddedDocuments('Item', [{
+        _id: this.id,
+        'system.temporel.debut': duplicate(timestampDebut),
+        'system.temporel.fin': duplicate(timestampFin),
+      }])
+    }
   }
 
-  isVideOuNonConteneur() {
-    return !this.isConteneur() || (this.system.contenu?.length ?? 0) == 0;
+  async calculerFinPeriodeTemporel(timestampDebut) {
+    return timestampDebut;
   }
 
-  isAlcool() {
-    return this.type == 'nourritureboisson' && this.system.boisson && this.system.alcoolise;
+  async onFinPeriodeTemporel(oldTimestamp, newTimestamp) {
+    if (this.isTemporel() && this.actor) {
+      await this.onFinPeriode(oldTimestamp, newTimestamp);
+    }
   }
-  isHerbeAPotion() {
-    return this.type == 'herbe' && (this.system.categorie == 'Soin' || this.system.categorie == 'Repos');
+
+  async onFinPeriode(oldTimestamp, newTimestamp) {
+    console.log(`${this.actor.name}: l'objet ${this.name} a expiré et été supprimé`);
+    await this.actor?.deleteEmbeddedDocuments('Item', [this.id]);
   }
-  isPotion() {
-    return this.type == 'potion';
+
+  getUtilisation() {
+    switch (this.type) {
+      case 'potion':
+        switch (this.system.categorie) {
+          case 'Alchimie': case 'AlchimieEnchante': case 'AlchimieAutre': return 'alchimie'
+          case 'Cuisine': return 'cuisine'
+          case 'Remede': case 'Repos': case 'ReposEnchante': case 'Soin': case 'SoinEnchante': return 'soins'
+        }
+        return '';
+      case 'nourritureboisson': return 'cuisine';
+      case 'herbe': case 'faune': case 'ingredient': case 'plante':
+        switch (this.system.categorie) {
+          case 'Cuisine': return 'cuisine';
+          case 'Toxique': case 'Poison': return 'poison';
+          case 'Alchimie': return 'alchimie'
+          case 'Soin': case 'Repos': return 'soins'
+        }
+        return this.system.sust > 0 ? 'cuisine' : '';
+    }
+    return '';
   }
+
+  getUtilisationCuisine() {
+    if (this.getUtilisation() == 'cuisine') {
+      switch (this.type) {
+        case 'nourritureboisson':
+          return 'pret';
+        case 'herbe': case 'faune': case 'ingredient': case 'plante':
+          return 'brut';
+      }
+    }
+    return '';
+  }
+
   isCristalAlchimique() {
     return this.type == 'objet' && Grammar.toLowerCaseNoAccent(this.name) == 'cristal alchimique' && this.system.quantite > 0;
   }
@@ -143,35 +300,58 @@ export class RdDItem extends Item {
     return this.system.magique
   }
 
+  isItemCommerce() {
+    return this.parent?.type == 'commerce';
+  }
+
   getQuantite() {
-    return Math.round(this.isConteneur() ? 1 : (this.system.quantite ?? 0))
+    return this.isService() ? undefined : Math.round(this.system.quantite ?? 0)
   }
 
   getEncTotal() {
-    return this.getEnc() * this.getQuantite();
-  }  
+    return (this.isService() ? 0 : this.getQuantite()) * this.getEnc();
+  }
 
   getEnc() {
     switch (this.type) {
+      case 'service':
+        return 0;
       case 'herbe':
-        return encBrin;
+        return this.getEncHerbe();
       case 'gemme':
         return encPepin * this.system.taille;
     }
     return Math.max(this.system.encombrement ?? 0, 0);
   }
 
-  prixTotalDeniers() {
-    return this.getQuantite() * this.valeurDeniers()
+  getEncHerbe() {
+    switch (this.system.categorie) {
+      case 'Repos': case 'Soin': case 'Alchimie':
+        return encBrin;
+    }
+    return this.system.encombrement;
+
   }
 
-  valeurDeniers() {
-    return Math.max(Math.round(this.system.cout ? (this.system.cout * 100) : (this.system.valeur_deniers ?? 0)), 0) 
+  valeurTotale() {
+    return (this.isService() ? 1 : this.getQuantite()) * this.valeur()
+  }
+
+  valeur() {
+    return this.system.cout ?? 0
+  }
+
+  calculerPrixCommercant() {
+    if (this.isItemCommerce()) {
+      // appliquer le pourcentage
+      return this.parent.calculerPrix(this);
+    }
+    return this.system.cout;
   }
 
   prepareDerivedData() {
     super.prepareDerivedData();
-    if (this.isEquipement()) {
+    if (this.isInventaire()) {
       this.system.encTotal = this.getEncTotal();
       if (this.isPotion()) {
         this.prepareDataPotion()
@@ -192,19 +372,43 @@ export class RdDItem extends Item {
   }
 
   getActionPrincipale(options = { warnIfNot: true }) {
-    const warn = options.warnIfNot;
     switch (this.type) {
-      case 'nourritureboisson': return this._actionOrWarnQuantiteZero(this.system.boisson ? 'Boire' : 'Manger', warn);
-      case 'potion': return this._actionOrWarnQuantiteZero('Boire', warn);
-      case 'livre': return this._actionOrWarnQuantiteZero('Lire', warn);
       case 'conteneur': return 'Ouvrir';
-      case 'herbe':  return this.isHerbeAPotion() ? this._actionOrWarnQuantiteZero('Décoction', warn) : undefined;
-      case 'queue': case 'ombre': return this.system.refoulement>0 ? 'Refouler' : undefined;
+    }
+    if (this.actor?.isPersonnage()) {
+      const warn = options.warnIfNot;
+      if (this.getUtilisationCuisine() == 'brut') {
+        return 'Utiliser';
+      }
+      switch (this.type) {
+        case 'nourritureboisson': return this._actionOrWarnQuantiteZero(this.system.boisson ? 'Boire' : 'Manger', warn);
+        case 'potion': return this._actionOrWarnQuantiteZero('Boire', warn);
+        case 'livre': return this._actionOrWarnQuantiteZero('Lire', warn);
+        case 'herbe': return this.isHerbeAPotion() ? this._actionOrWarnQuantiteZero('Décoction', warn) : undefined;
+        case 'queue': case 'ombre': return this.system.refoulement > 0 ? 'Refouler' : undefined;
+      }
     }
     return undefined;
   }
 
-  _actionOrWarnQuantiteZero(actionName, warn){
+  /* -------------------------------------------- */
+  async actionPrincipale(actor, onActionItem = async () => { }) {
+    if (!this.getActionPrincipale()) {
+      return;
+    }
+    if (await actor.actionNourritureboisson(this, onActionItem)) {
+      return;
+    }
+    switch (this.type) {
+      case 'potion': return await actor.consommerPotion(this, onActionItem);
+      case 'livre': return await actor.actionLire(this);
+      case 'conteneur': return await this.sheet.render(true);
+      case 'herbe': return await actor.actionHerbe(this);
+      case 'queue': case 'ombre': return await actor.actionRefoulement(this);
+    }
+  }
+
+  _actionOrWarnQuantiteZero(actionName, warn) {
     if ((this.system.quantite ?? 0) <= 0) {
       if (warn) {
         ui.notifications.warn(`Vous n'avez plus de ${this.name}.`);
@@ -221,7 +425,43 @@ export class RdDItem extends Item {
     await this.quantiteIncDec(-nombre, options);
   }
 
-  async quantiteIncDec(nombre, options = { diminuerQuantite: true, supprimerSiZero: false }) {
+  async onCreateDecoupeComestible(actor) {
+    if (actor && this.getUtilisationCuisine() == 'brut' && this.system.sust != 1) {
+      if (this.system.sust < 1) {
+        await actor.updateEmbeddedDocuments('Item', [{
+          _id: this.id,
+          'system.sust': 0
+        }])
+      }
+      else {
+        const sust = Math.floor(this.system.sust);
+        await actor.updateEmbeddedDocuments('Item', [{
+          _id: this.id,
+          'system.quantite': this.system.quantite * sust,
+          'system.encombrement': Misc.keepDecimals(this.system.encombrement / sust, 2),
+          'system.cout': Misc.keepDecimals(this.system.cout / sust, 2),
+          'system.sust': 1
+        }])
+      }
+    }
+  }
+
+  async empiler(item) {
+    if (this.getUtilisationCuisine() == 'brut') {
+      const sust = this.system.sust + item.system.sust;
+      const encombrement = this.system.encombrement + item.system.encombrement;
+      await this.update({
+        "system.sust": sust,
+        "system.encombrement": encombrement
+      });
+    }
+    else {
+      await this.quantiteIncDec(item.system.quantite);
+    }
+    await item.delete();
+  }
+
+  async quantiteIncDec(nombre, options = { supprimerSiZero: false }) {
     const quantite = Number(this.system.quantite ?? -1);
     if (quantite >= 0) {
       const reste = Math.max(quantite + Number(nombre), 0);
@@ -244,14 +484,13 @@ 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é
-  isEquipementEmpilable(other) {
-    if (!other || !this.isEquipement()) {
+  isInventaireEmpilable(other) {
+    if (!other || !this.isInventaire()) {
       return [false, undefined];
     }
-
     if (this.system.quantite == undefined) {
       return [false, `Impossible de regrouper des ${this.type}, ils ne sont pas empilables`];
-    } 
+    }
     else if (this.type != other.type) {
       return [false, `Impossible de regrouper des ${this.type} avec des ${other.type}`];
     }
@@ -259,8 +498,13 @@ export class RdDItem extends Item {
       return [false, `Impossible de regrouper ${this.name} avec ${other.name}`];
     }
     else {
-      const differences = Object.entries(this.system)
-        .filter(([key, value]) => !['quantite', 'cout', 'encTotal'].includes(key) && value != other.system[key]);
+      const excludedProperties = ['quantite', 'cout', 'encTotal', 'environnement', 'contenu'];
+      if (this.getUtilisationCuisine()) {
+        excludedProperties.push('sust', 'encombrement');
+      }
+      let differences = Object.entries(this.system)
+        .filter(([key, value]) => !excludedProperties.includes(key))
+        .filter(([key, value]) => value != other.system[key])
       if (differences.length > 0) {
         let message = `Impossible de regrouper les ${this.type} ${this.name}: `;
         for (const [key, value] of differences) {
@@ -272,77 +516,88 @@ export class RdDItem extends Item {
     return [true, undefined];
   }
 
-  async proposerVente() {
+  async proposerVente(quantiteMax = undefined) {
     console.log(this);
     if (this.isConteneurNonVide()) {
       ui.notifications.warn(`Votre ${this.name} n'est pas vide, pas possible de le proposer`);
       return;
     }
-    await DialogItemVente.display(this, async (vente) =>  {
-      vente["properties"] = this.getProprietes();
-      if (vente.isOwned) {
-        if (vente.quantiteNbLots * vente.tailleLot > vente.quantiteMax) {
-          ui.notifications.warn(`Vous avez ${vente.quantiteMax} ${vente.item.name}, ce n'est pas suffisant pour vendre ${vente.quantiteNbLots} de ${vente.tailleLot}`)
-          return;
+    await DialogItemVente.display({
+      item: this,
+      quantiteMax,
+      callback: async (vente) => {
+        vente["properties"] = this.getProprietes();
+        if (vente.isOwned) {
+          if (vente.quantiteNbLots * vente.tailleLot > vente.quantiteMax) {
+            ui.notifications.warn(`Vous avez ${vente.quantiteMax} ${vente.item.name}, ce n'est pas suffisant pour vendre ${vente.quantiteNbLots} de ${vente.tailleLot}`)
+            return;
+          }
         }
+        vente.jsondata = JSON.stringify(vente.item);
+
+        let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-vente-item.html', vente);
+        ChatMessage.create(RdDUtility.chatDataSetup(html));
       }
-      vente.jsondata = JSON.stringify(vente.item);
-  
-      console.log(vente);
-      let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-vente-item.html', vente);
-      ChatMessage.create(RdDUtility.chatDataSetup(html));
     });
   }
 
   /* -------------------------------------------- */
   getProprietes() {
-    return this[`_${this.type}ChatData`]();
+    if (this[`_${this.type}ChatData`]) {
+      return this[`_${this.type}ChatData`]().filter(it => it != undefined);
+    }
+    return [];
   }
 
   /* -------------------------------------------- */
-  async postItem(modeOverride) {
+  async postItemToChat(modeOverride) {
     console.log(this);
-    let chatData = duplicate(this);
-    chatData["properties"] = this.getProprietes();
-    if (this.actor) {
-      chatData.actor = { id: this.actor.id };
+    let chatData = {
+      doctype: 'Item',
+      id: this.id,
+      type: this.type,
+      img: this.img,
+      pack: this.pack,
+      name: this.name,
+      actor: this.actor ? { id: this.actor.id } : undefined,
+      system: { description: this.system.description },
+      properties: this.getProprietes(),
     }
-    // JSON object for easy creation
-    chatData.jsondata = JSON.stringify(
-      {
-        compendium: "postedItem",
-        payload: chatData,
-      });
-
-    renderTemplate('systems/foundryvtt-reve-de-dragon/templates/post-item.html', chatData).then(html => {
+    renderTemplate(this.getChatItemTemplate(), chatData).then(html => {
       let chatOptions = RdDUtility.chatDataSetup(html, modeOverride);
       ChatMessage.create(chatOptions)
     });
   }
 
-  static propertyIfDefined(name, val, condition = (it) => true) {
-    return condition ? [`<b>${name}</b>: ${val}`] : [];
+  getChatItemTemplate() {
+    return 'systems/foundryvtt-reve-de-dragon/templates/post-item.html';
   }
 
+  static propertyIfDefined(name, val, condition = true) {
+    return condition ? `<b>${name}</b>: ${val}` : undefined;
+  }
+
+  _inventaireTemplateChatData() {
+    return [
+      RdDItem.propertyIfDefined('Qualité', this.system.qualite, this.system.qualite != 0),
+      RdDItem.propertyIfDefined('Encombrement', this.system.encombrement)
+      // cout et quantité masqués
+    ]
+  }
   /* -------------------------------------------- */
   _objetChatData() {
-    return [].concat(
-      RdDItem.propertyIfDefined('Résistance', this.system.resistance, this.system.resistance),
-      RdDItem.propertyIfDefined('Qualité', this.system.qualite, this.system.qualite),
-      RdDItem.propertyIfDefined('Encombrement', this.system.encombrement),
-    );
+    return this._inventaireTemplateChatData()
   }
 
   /* -------------------------------------------- */
   _nourritureboissonChatData() {
-    return [].concat(
+    return [
       RdDItem.propertyIfDefined('Sustentation', this.system.sust, this.system.sust > 0),
       RdDItem.propertyIfDefined('Désaltère', this.system.desaltere, this.system.boisson),
       RdDItem.propertyIfDefined('Force alcool', this.system.force, this.system.boisson && this.system.alcoolise),
       RdDItem.propertyIfDefined('Exotisme', this.system.exotisme, this.system.exotisme < 0),
-      RdDItem.propertyIfDefined('Qualité', this.system.qualite, this.system.qualite),
-      RdDItem.propertyIfDefined('Encombrement', this.system.encombrement),
-    );
+      ...this._inventaireTemplateChatData()
+    ]
   }
   /* -------------------------------------------- */
   _armeChatData() {
@@ -351,21 +606,19 @@ export class RdDItem extends Item {
       `<b>Dommages</b>: ${this.system.dommages}`,
       `<b>Force minimum</b>: ${this.system.force}`,
       `<b>Resistance</b>: ${this.system.resistance}`,
-      `<b>Encombrement</b>: ${this.system.encombrement}`
+      ...this._inventaireTemplateChatData()
     ]
   }
   /* -------------------------------------------- */
   _conteneurChatData() {
     return [
       `<b>Capacité</b>: ${this.system.capacite} Enc.`,
-      `<b>Encombrement</b>: ${this.system.encombrement}`
+      ...this._inventaireTemplateChatData()
     ]
   }
   /* -------------------------------------------- */
   _munitionChatData() {
-    return [
-      `<b>Encombrement</b>: ${this.system.encombrement}`
-    ]
+    return this._inventaireTemplateChatData()
   }
   /* -------------------------------------------- */
   _armureChatData() {
@@ -373,7 +626,7 @@ export class RdDItem extends Item {
       `<b>Protection</b>: ${this.system.protection}`,
       `<b>Détérioration</b>: ${this.system.deterioration}`,
       `<b>Malus armure</b>: ${this.system.malus}`,
-      `<b>Encombrement</b>: ${this.system.encombrement}`
+      ...this._inventaireTemplateChatData()
     ]
   }
   /* -------------------------------------------- */
@@ -407,16 +660,24 @@ export class RdDItem extends Item {
   _herbeChatData() {
     return [
       `<b>Milieu</b>: ${this.system.milieu}`,
-      `<b>Rareté</b>: ${this.system.rarete}`,
       `<b>Catégorie</b>: ${this.system.categorie}`,
+      ...this._inventaireTemplateChatData()
     ]
   }
   /* -------------------------------------------- */
   _ingredientChatData() {
     return [
       `<b>Milieu</b>: ${this.system.milieu}`,
-      `<b>Rareté</b>: ${this.system.rarete}`,
       `<b>Catégorie</b>: ${this.system.categorie}`,
+      ...this._inventaireTemplateChatData()
+    ]
+  }
+  /* -------------------------------------------- */
+  _fauneChatData() {
+    return [
+      `<b>Sustentation</b>: ${this.system.sust}`,
+      `<b>Milieu</b>: ${this.system.milieu}`,
+      ...this._inventaireTemplateChatData()
     ]
   }
   /* -------------------------------------------- */
@@ -426,12 +687,9 @@ export class RdDItem extends Item {
       `<b>Compétence</b>: ${this.system.competence}`,
       `<b>Périodicité</b>: ${this.system.periodicite}`,
       `<b>Fatigue</b>: ${this.system.fatigue}`,
-      `<b>Difficulté</b>: ${this.system.difficulte}`
-    ].concat([
-      this.system.cacher_points_de_tache ? [] :`<b>Points de Tâche</b>: ${this.system.points_de_tache}`
-    ]).concat([
+      `<b>Difficulté</b>: ${this.system.difficulte}`,
+      RdDItem.propertyIfDefined('Points de Tâche', this.system.points_de_tache, this.system.cacher_points_de_tache),
       `<b>Points de Tâche atteints</b>: ${this.system.points_de_tache_courant}`]
-    );
   }
   /* -------------------------------------------- */
   _livreChatData() {
@@ -439,8 +697,8 @@ export class RdDItem extends Item {
       `<b>Compétence</b>: ${this.system.competence}`,
       `<b>Auteur</b>: ${this.system.auteur}`,
       `<b>Difficulté</b>: ${this.system.difficulte}`,
-      `<b>Points de Tâche</b>: ${this.system.points_de_tache}`,
-      `<b>Encombrement</b>: ${this.system.encombrement}`
+      RdDItem.propertyIfDefined('Points de Tâche', this.system.points_de_tache, this.system.cacher_points_de_tache),
+      ...this._inventaireTemplateChatData()
     ]
   }
   /* -------------------------------------------- */
@@ -448,32 +706,44 @@ export class RdDItem extends Item {
     return [
       `<b>Rareté</b>: ${this.system.rarete}`,
       `<b>Catégorie</b>: ${this.system.categorie}`,
-      `<b>Encombrement</b>: ${this.system.encombrement}`,
+      ...this._inventaireTemplateChatData()
     ]
   }
   /* -------------------------------------------- */
   _queueChatData() {
+    function label(categorie) {
+      switch (categorie) {
+        case 'ideefixe': return 'Idée fixe';
+        case 'lancinant': return 'Désir lancinant';
+      }
+      return ''
+    }
     return [
-      `<b>Refoulement</b>: ${this.system.refoulement}`
+      `<b>Refoulement</b>: ${this.system.refoulement}`,
+      `<b>Catégorie</b>: ${label(this.system.categorie)}`,
+      `<b>Affecte</b>: ${this.system.hautrevant ? 'les haut-rêvants' : 'tout le monde'}`,
     ]
   }
   /* -------------------------------------------- */
   _ombreChatData() {
-    return [
-      `<b>Refoulement</b>: ${this.system.refoulement}`
-    ]
+    return this._queueChatData()
   }
   /* -------------------------------------------- */
   _souffleChatData() {
-    return [];
+    return [
+      `<b>Affecte</b>: ${this.system.hautrevant ? 'les haut-rêvants' : 'tout le monde'}`,
+    ];
   }
   /* -------------------------------------------- */
   _teteChatData() {
-    return [];
+    return [
+      `<b>Affecte</b>: ${this.system.hautrevant ? 'les haut-rêvants' : 'tout le monde'}`,
+    ];
   }
   /* -------------------------------------------- */
   _tarotChatData() {
     return [
+      RdDItem.propertyIfDefined('Carte', RdDUtility.linkCompendium(this.pack, this.id, this.name), this.pack),
       `<b>Concept</b>: ${this.system.concept}`,
       `<b>Aspect</b>: ${this.system.aspect}`,
     ]
@@ -487,10 +757,7 @@ export class RdDItem extends Item {
   }
   /* -------------------------------------------- */
   _monnaieChatData() {
-    return [
-      `<b>Valeur en Deniers</b>: ${this.system.valeur_deniers}`,
-      `<b>Encombrement</b>: ${this.system.encombrement}`
-    ]
+    return this._inventaireTemplateChatData()
   }
   /* -------------------------------------------- */
   _meditationChatData() {
@@ -514,9 +781,9 @@ export class RdDItem extends Item {
       ]
     }
     return [
-      `<b>Force</b>: ${this.system.force}`,
+      `<b>Force</b>: ${this.system.formule}`,
       `<b>Refoulement</b>: ${this.system.refoulement}`,
-      `<b>Présent de cités</b>: ${this.system.presentCite}`,
+      RdDItem.propertyIfDefined('<b>Présent de cités</b>', '', this.system.presentCite),
     ]
   }
   /* -------------------------------------------- */
@@ -531,15 +798,12 @@ export class RdDItem extends Item {
     if (!this.system.identifie) {
       return [`<b>Inconnue</b>`]
     }
-    let properties = [
-        `<b>Malignité</b>: ${this.system.malignite}`,
-        `<b>Périodicité</b>: ${this.system.periodicite}`,
-        `<b>Dommages</b>: ${this.system.dommages}`
-      ]
-    if (this.system.remedesconnus) {
-      properties.push(`<b>Remedes</b>: ${this.system.remedes}`)
-    }
-    return properties;
+    return [
+      `<b>Malignité</b>: ${this.system.malignite}`,
+      `<b>Périodicité</b>: ${this.system.periodicite}`,
+      `<b>Dommages</b>: ${this.system.dommages}`,
+      RdDItem.propertyIfDefined('<b>Remedes</b>', this.system.remedes, this.system.remedesconnus),
+    ]
   }
 
   /* -------------------------------------------- */
@@ -554,9 +818,7 @@ export class RdDItem extends Item {
       `<b>Taille</b>: ${this.system.taille}`,
       `<b>Inertie</b>: ${this.system.inertie}`,
       `<b>Enchantabilité</b>: ${this.system.enchantabilite}`,
-      `<b>Prix</b>: ${this.system.cout}`,
+      ...this._inventaireTemplateChatData()
     ]
   }
-
-
 }

module/item/maladie.js

@@ -0,0 +1,47 @@
+import { RdDItem } from "../item.js";
+import { Misc } from "../misc.js";
+import { RdDTimestamp } from "../rdd-timestamp.js";
+
+export class RdDItemMaladie extends RdDItem {
+
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/maladies_venins/maladie.webp";
+  }
+
+  async calculerFinPeriodeTemporel(debut) {
+    return await debut.addPeriode(this.system.periode.nombre, this.system.periode.unite);
+  }
+
+  async onFinPeriode(oldTimestamp, newTimestamp) {
+    await RdDItemMaladie.notifierMaladiePoison(this, oldTimestamp, newTimestamp)
+  }
+
+  static async notifierMaladiePoison(mal, oldTimestamp, newTimestamp) {
+    if (mal.actor) {
+      const souffrance = mal.system.identifie
+        ? `de ${mal.name}`
+        : `d'un mal inconnu`
+      ChatMessage.create({ content: `${mal.actor.name} souffre ${souffrance} (${Misc.typeName('Item', mal.type)}): vérifiez que les effets ne se sont pas aggravés !` });
+      mal.postItemToChat('gmroll');
+      await RdDItemMaladie.prolongerPeriode(mal,oldTimestamp, newTimestamp);
+    }
+  }
+
+  static async prolongerPeriode(mal, oldTimestamp, newTimestamp) {
+    if (mal.actor) {
+      // TODO: déterminer le nombre de périodes écoulées
+      console.log(`${mal.actor.name}: le mal ${mal.name} a atteint la fin de sa période et été prolongé`);
+      const current = newTimestamp;
+      const finPeriode = new RdDTimestamp(mal.system.temporel.fin)
+      const periodeSuivante = (finPeriode.compare(current) > 0 ? finPeriode : current);
+      const timestampFin = await mal.calculerFinPeriodeTemporel(periodeSuivante);
+
+      await mal.actor.updateEmbeddedDocuments('Item', [{
+        _id: mal.id,
+        'system.temporel.fin': duplicate(timestampFin),
+      }])
+    }
+  }
+
+
+}

module/item/ombre.js

@@ -0,0 +1,11 @@
+import { RdDItem } from "../item.js";
+
+export class RdDItemOmbre extends RdDItem {
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/queue_dragon.webp";
+  }
+
+  async calculerFinPeriodeTemporel(debut) {
+    return await debut.appliquerDuree(this.system.duree, this.parent);
+  }
+}

module/item/poison.js

@@ -0,0 +1,17 @@
+import { RdDItem } from "../item.js";
+import { RdDItemMaladie } from "./maladie.js";
+
+export class RdDItemPoison extends RdDItem {
+
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/maladies_venins/venin.webp";
+  }
+
+  async calculerFinPeriodeTemporel(debut) {
+    return await debut.addPeriode(this.system.periode.nombre, this.system.periode.unite) ;
+  }
+
+  async onFinPeriode(oldTimestamp, newTimestamp) {
+    RdDItemMaladie.notifierMaladiePoison(this, oldTimestamp, newTimestamp)
+  }
+}

module/item/queue.js

@@ -0,0 +1,13 @@
+import { RdDItem } from "../item.js";
+
+export class RdDItemQueue extends RdDItem {
+
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/queue_dragon.webp";
+  }
+
+  async calculerFinPeriodeTemporel(debut) {
+    return await debut.appliquerDuree(this.system.duree, this.parent);
+  }
+
+}

module/item/raretes.js

@@ -0,0 +1,31 @@
+
+const RARETE_COMMUNE = { code: 'Commune', label: 'Commune', frequence: 54, min: 27, max: 108 };
+const RARETE_FREQUENTE = { code: 'Frequente', label: 'Fréquente', frequence: 18, min: 9, max: 36 };
+const RARETE_RARE = { code: 'Rare', label: 'Rare', frequence: 6, min: 3, max: 12 };
+const RARETE_RARISSIME = { code: 'Rarissime', label: 'Rarissime', frequence: 2, min: 1, max: 4 };
+const RARETE_INEXISTANT = { code: 'Inexistant', label: 'Inexistant', frequence: 0, min: 0, max: 0 };
+const RARETE_EGALE = { code: 'eqal', label: 'Egal', frequence: 1, min: 1, max: 1 };
+
+const RARETES = [
+  RARETE_COMMUNE,
+  RARETE_FREQUENTE,
+  RARETE_RARE,
+  RARETE_RARISSIME,
+  RARETE_INEXISTANT,
+]
+
+export class RdDRaretes {
+
+  static rareteFrequente() { return RARETE_FREQUENTE; }
+  static rareteEgale() { return RARETE_EGALE; }
+  static raretes() { return RARETES; }
+
+  static byCode(code = undefined) {
+    return RARETES.find(it => it.code == code) ?? RARETE_FREQUENTE;
+  }
+
+  static getChamp(rarete, field = undefined) {
+    return RdDRaretes.byCode(rarete)[field ?? 'frequence'];
+  }
+
+}

module/item/rencontre.js

@@ -1,4 +1,5 @@
-import { EffetsRencontre } from "./effets-rencontres.js";
+import { EffetsRencontre } from "../tmr/effets-rencontres.js";
+import { RdDItem } from "../item.js";
 
 const tableEffets = [
   { code: "messager", resultat: "succes", description: "Envoie un message à (force) cases", method: EffetsRencontre.messager },
@@ -36,7 +37,11 @@ const tableEffets = [
   // { code: "epart-souffle", resultat: "echec", description: "Souffle de dragon sur échec particulier" },
 ];
 
-export class RdDRencontre {
+export class RdDRencontre extends RdDItem {
+
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/tete_dragon.webp";
+  }
 
   static getEffetsSucces() { return RdDRencontre.getEffets("succes"); }
   static getEffetsEchec() { return RdDRencontre.getEffets("echec"); }
@@ -68,4 +73,8 @@ export class RdDRencontre {
     }
   }
 
+  async calculerFinPeriodeTemporel(debut) {
+    return await debut.nouvelleHeure().addHeures(12);
+  }
+
 }

module/item/service.js

@@ -0,0 +1,17 @@
+import { RdDItem } from "../item.js";
+
+export class RdDItemService extends RdDItem {
+
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/services/lit.webp";
+  }
+
+  isService() { return true; }
+  getProprietes() {
+    return [
+      RdDItem.propertyIfDefined('Qualité', this.system.qualite, this.system.qualite != 0),
+      RdDItem.propertyIfDefined('Moral', 'Situation heureuse', this.system.moral),
+      RdDItem.propertyIfDefined('Coût', `${this.calculerPrixCommercant()} sols`),
+    ];
+  }
+}

module/item/sheet-base-inventaire.js

@@ -0,0 +1,120 @@
+import { HtmlUtility } from "../html-utility.js";
+import { RdDItemSheet } from "../item-sheet.js";
+import { Misc } from "../misc.js";
+import { RdDRaretes } from "./raretes.js";
+
+const TYPE_ITEMS_NATURELS = ["faune", "herbe", "plante", "ingredient"];
+
+export class RdDItemInventaireSheet extends RdDItemSheet {
+
+  static get defaultOptions() {
+    return mergeObject(RdDItemSheet.defaultOptions, {
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "informations" }]
+    });
+  }
+
+  setPosition(options = {}) {
+    const position = super.setPosition(options);
+    const sheetHeader = this.element.find(".sheet-header");
+    const sheetBody = this.element.find(".sheet-body");
+    sheetBody.css("height", position.height - sheetHeader[0].clientHeight)
+    return position;
+  }
+
+  async getData() {
+    const formData = await super.getData();
+    return mergeObject(formData, {
+      milieux: await game.system.rdd.environnement.autresMilieux(this.item)
+    });
+  }
+
+  activateListeners(html) {
+    super.activateListeners(html);
+    HtmlUtility.showControlWhen(this.html.find("div.description-milieu"), TYPE_ITEMS_NATURELS.includes(this.item.type));
+
+    if (!this.options.editable) return;
+    this.html.find("a.preparer-nourriture").click(event => this.preparerNourriture(event));
+    this.html.find("a.manger-nourriture").click(event => this.mangerNourriture(event));
+
+    this.html.find("input.input-selection-milieu").keypress(event => {
+      if (event.keyCode == '13') {
+        this.onAddMilieu(event);
+      }
+      event.stopPropagation();
+    })
+    this.html.find("a.milieu-add").click(event => this.onAddMilieu(event));
+    this.html.find("div.environnement-milieu a.milieu-delete").click(event => this.onDeleteMilieu(event));
+    this.html.find("div.environnement-milieu select.environnement-rarete").change(event => this.onChange(event,
+      updated => this.$changeRarete(event, updated)));
+    this.html.find("div.environnement-milieu input[name='environnement-frequence']").change(event => this.onChange(event,
+      updated => this.$changeFrequence(event, updated)));
+
+
+  }
+
+  async preparerNourriture(event) {
+    if (this.actor && this.item.getUtilisationCuisine() == 'brut') {
+      await this.actor.preparerNourriture(this.item);
+    }
+  }
+
+  async mangerNourriture(event) {
+    if (this.actor && this.item.getUtilisation() == 'cuisine') {
+      await this.actor.mangerNourriture(this.item);
+    }
+  }
+
+  $changeFrequence(event, updated) {
+    updated.frequence = Number(this.html.find(event.currentTarget).val());
+  }
+
+  $changeRarete(event, updated) {
+    const code = this.html.find(event.currentTarget).val();
+    const rarete = RdDRaretes.byCode(code);
+    updated.rarete = rarete.code;
+    updated.frequence = rarete.frequence;
+  }
+
+  async onAddMilieu(event) {
+    const milieu = this.html.find('input.input-selection-milieu').val();
+    if (!milieu) {
+      ui.notifications.warn(`Choisissez le milieu dans lequel se trouve le/la ${this.item.name}`);
+      return
+    }
+    const list = this.item.getEnvironnements();
+    const exists = list.find(it => it.milieu == milieu);
+    if (exists) {
+      ui.notifications.warn(`${this.item.name} a déjà une rareté ${exists.rarete} en ${milieu} (fréquence: ${exists.frequence})`);
+      return
+    }
+    const rarete = RdDRaretes.rareteFrequente();
+    const added = { milieu, rarete: rarete.code, frequence: rarete.frequence };
+    const newList = [added, ...list].sort(Misc.ascending(it => it.milieu))
+    await this.item.update({ 'system.environnement': newList })
+  }
+
+  async onDeleteMilieu(event) {
+    const milieu = this.$getEventMilieu(event);
+    if (milieu != undefined) {
+      const newList = this.item.getEnvironnements().filter(it => it.milieu != milieu)
+        .sort(Misc.ascending(it => it.milieu));
+      await this.item.update({ 'system.environnement': newList });
+    }
+  }
+
+  async onChange(event, doMutation) {
+    const list = this.item.system.environnement;
+    const milieu = this.$getEventMilieu(event);
+    const updated = list.find(it => it.milieu == milieu);
+    if (updated) {
+      doMutation(updated);
+      const newList = [...list.filter(it => it.milieu != milieu), updated]
+        .sort(Misc.ascending(it => it.milieu));
+      await this.item.update({ 'system.environnement': newList });
+    }
+  }
+
+  $getEventMilieu(event) {
+    return this.html.find(event.currentTarget)?.parents("div.environnement-milieu").data("milieu");
+  }
+}

module/item/sheet-conteneur.js

@@ -0,0 +1,62 @@
+import { RdDBaseActorSheet } from "../actor/base-actor-sheet.js";
+import { RdDSheetUtility } from "../rdd-sheet-utility.js";
+import { RdDUtility } from "../rdd-utility.js";
+import { RdDItemInventaireSheet } from "./sheet-base-inventaire.js";
+
+export class RdDConteneurItemSheet extends RdDItemInventaireSheet {
+
+  static get ITEM_TYPE() { return "conteneur" };
+
+  async getData() {
+    const formData = await super.getData();
+    if (this.actor) {
+      this.prepareConteneurData(formData);
+    }
+    return formData;
+  }
+
+  activateListeners(html) {
+    super.activateListeners(html);
+
+    if (!this.options.editable) return;
+
+    this.html.find('.conteneur-name a').click(async event => {
+      RdDUtility.toggleAfficheContenu(RdDSheetUtility.getItemId(event));
+      this.render(true);
+    });
+  }
+
+  /* -------------------------------------------- */
+  prepareConteneurData(formData) {
+    RdDBaseActorSheet.filterItemsPerTypeForSheet(formData, this.actor.itemTypes);
+    this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.objets);
+    formData.subItems = formData.conteneurs.find(it => it._id == this.item.id)?.subItems;
+  }
+
+  async _onDragStart(event) {
+    console.log("_onDragStart", event);
+    if (event.target.classList.contains("entity-link")) return;
+
+    const itemId = event.srcElement?.attributes["data-item-id"].value;
+    const item = this.actor.items.get(itemId);
+    // Create drag data
+    const dragData = {
+      actorId: this.actor.id,
+      type: "Item",
+      data: item.system,
+      uuid: item.uuid
+    };
+
+    event.dataTransfer.setData("text/plain", JSON.stringify(dragData));
+  }
+
+  async _onDropItem(event, dragData) {
+    if (this.actor) {
+      const destItemId = this.html.find(event.target)?.closest('.item').attr('data-item-id') ?? this.item.id
+      const dropParams = await RdDSheetUtility.prepareItemDropParameters(destItemId, this.actor, dragData, this.objetVersConteneur);
+      await this.actor.processDropItem(dropParams);
+      await this.render(true);
+    }
+  }
+
+}

module/item/sheet-faune.js

@@ -0,0 +1,38 @@
+import { RdDItemInventaireSheet } from "./sheet-base-inventaire.js";
+
+export class RdDFauneItemSheet extends RdDItemInventaireSheet {
+
+  static get ITEM_TYPE() { return "faune" };
+
+  activateListeners(html) {
+    super.activateListeners(html);
+
+    if (!this.options.editable) return;
+
+    html.find("a.linked-actor-delete").click(event => this.onDeleteLinkedActor());
+  }
+
+  async _onDropActor(event, dragData) {
+    console.log('faune:dropActor', event, dragData)
+    const linkedActor = fromUuidSync(dragData.uuid);
+    if (linkedActor?.pack) {
+      this.item.update({
+        'system.actor.pack': linkedActor.pack,
+        'system.actor.id': linkedActor._id,
+        'system.actor.name': linkedActor.name
+      });
+    }
+    else {
+      ui.notifications.warn(`${linkedActor.name} ne provient pas d'un compendium.
+        <br>Choisissez une créature du compendium pour représenter un élément de faune générique`)
+    }
+  }
+  async onDeleteLinkedActor() {
+    this.item.update({
+      'system.actor.pack': '',
+      'system.actor.id': '',
+      'system.actor.name': ''
+    });
+  }
+
+}

module/item/sheet-herbe.js

@@ -0,0 +1,6 @@
+import { RdDItemInventaireSheet } from "./sheet-base-inventaire.js";
+
+export class RdDHerbeItemSheet extends RdDItemInventaireSheet {
+
+  static get ITEM_TYPE() { return "herbe" };
+}

module/item/sheet-ingredient.js

@@ -0,0 +1,5 @@
+import { RdDItemInventaireSheet } from "./sheet-base-inventaire.js";
+
+export class RdDIngredientItemSheet extends RdDItemInventaireSheet {
+  static get ITEM_TYPE() { return "ingredient" };
+}

module/item/sheet-plante.js

@@ -0,0 +1,7 @@
+import { RdDItemInventaireSheet } from "./sheet-base-inventaire.js";
+
+export class RdDPlanteItemSheet extends RdDItemInventaireSheet {
+
+  static get ITEM_TYPE() { return "plante" };
+
+}

module/item/sheet-rencontre.js

@@ -1,29 +1,16 @@
-import { RdDRencontre } from "./item-rencontre.js";
+import { RdDRencontre } from "./rencontre.js";
+import { RdDItemSheet } from "../item-sheet.js";
 
-/**
- * Item sheet pour configurer les rencontres
- * @extends {ItemSheet}
- */
-export class RdDRencontreItemSheet extends ItemSheet {
+export class RdDRencontreItemSheet extends RdDItemSheet {
+  
+  static get ITEM_TYPE() { return "rencontre" };
 
-  /** @override */
   static get defaultOptions() {
     return mergeObject(super.defaultOptions, {
-      classes: ["rdd", "sheet", "item"],
-      template: "systems/foundryvtt-reve-de-dragon/templates/item-rencontre-sheet.html",
-      width: 500,
-      height: 500,
       tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }]
     });
   }
 
-  /* -------------------------------------------- */
-  _getHeaderButtons() {
-    let buttons = super._getHeaderButtons();
-    buttons.unshift({ class: "post", icon: "fas fa-comment", onclick: ev => this.item.postItem() });
-    return buttons;
-  }
-
   /* -------------------------------------------- */
   /** @override */
   setPosition(options = {}) {
@@ -34,18 +21,10 @@ export class RdDRencontreItemSheet extends ItemSheet {
     return position;
   }
 
-
   /* -------------------------------------------- */
   async getData() {
-    const formData = duplicate(this.item);
+    const formData = await super.getData();
     mergeObject(formData, {
-      title: formData.name,
-      isGM: game.user.isGM,
-      owner: this.actor?.isOwner,
-      isOwned: this.actor ? true : false,
-      actorId: this.actor?.id,
-      editable: this.isEditable,
-      cssClass: this.isEditable ? "editable" : "locked",
       effets: {
         succes: {
           liste: RdDRencontre.getEffetsSucces(),
@@ -65,15 +44,15 @@ export class RdDRencontreItemSheet extends ItemSheet {
   activateListeners(html) {
     super.activateListeners(html);
     if (!this.options.editable) return;
-    html.find("a.effet-add").click(event => this.onAddEffet(event));
-    html.find("a.effet-delete").click(event => this.onDeleteEffet(event));
+    this.html.find("a.effet-add").click(event => this.onAddEffet(event));
+    this.html.find("a.effet-delete").click(event => this.onDeleteEffet(event));
   }
 
   async onAddEffet(event) {
-    const resultat = $(event.currentTarget)?.data("effet-resultat");
+    const resultat = this.html.find(event.currentTarget)?.data("effet-resultat");
     const keyEffets = `system.${resultat}.effets`;
 
-    const code = $(event.currentTarget)?.data("effet-code");
+    const code = this.html.find(event.currentTarget)?.data("effet-code");
     const liste = RdDRencontre.getListeEffets(this.item, resultat);
     liste.push(code);
 
@@ -81,10 +60,10 @@ export class RdDRencontreItemSheet extends ItemSheet {
   }
 
   async onDeleteEffet(event) {
-    const resultat = $(event.currentTarget)?.data("effet-resultat");
+    const resultat = this.html.find(event.currentTarget)?.data("effet-resultat");
     const keyEffets = `system.${resultat}.effets`;
     
-    const pos = $(event.currentTarget)?.data("effet-pos");
+    const pos = this.html.find(event.currentTarget)?.data("effet-pos");
     const liste = RdDRencontre.getListeEffets(this.item, resultat);
     liste.splice(pos, 1);
     
@@ -96,13 +75,4 @@ export class RdDRencontreItemSheet extends ItemSheet {
     updates[key] = liste;
     this.item.update(updates);
   }
-
-  get template() {
-  /* -------------------------------------------- */
-    return `systems/foundryvtt-reve-de-dragon/templates/item-rencontre-sheet.html`;
-  }
-
-  get title() {
-    return `Rencontre: ${this.object.name}`;
-  }
 }

module/item/sheet-service.js

@@ -0,0 +1,16 @@
+import { RdDItemSheet } from "../item-sheet.js";
+
+export class RdDServiceItemSheet extends RdDItemSheet {
+
+  static get ITEM_TYPE() { return "service" };
+
+  async getData() {
+    const formData = await super.getData();
+    formData.disabled = formData.options.isGM || formData.options.isOwned ? '' : 'disabled';
+    return formData;
+  }
+
+  activateListeners(html) {
+    super.activateListeners(html);
+  }
+}

module/item/sheet-signedraconique.js

@@ -1,29 +1,14 @@
-import { SYSTEM_RDD } from "./constants.js";
-import { RdDItemSigneDraconique } from "./item-signedraconique.js";
-import { TMRUtility } from "./tmr-utility.js";
+import { RdDItemSheet } from "../item-sheet.js";
+import { RdDItemSigneDraconique } from "./signedraconique.js";
+import { TMRUtility } from "../tmr-utility.js";
 
 /**
  * Item sheet pour signes draconiques
- * @extends {ItemSheet}
+ * @extends {RdDItemSheet}
  */
-export class RdDSigneDraconiqueItemSheet extends ItemSheet {
+export class RdDSigneDraconiqueItemSheet extends RdDItemSheet {
 
-  /** @override */
-  static get defaultOptions() {
-    return mergeObject(super.defaultOptions, {
-      classes: [SYSTEM_RDD, "sheet", "item"],
-      template: "systems/foundryvtt-reve-de-dragon/templates/item-signedraconique-sheet.html",
-      width: 550,
-      height: 550
-    });
-  }
-
-  /* -------------------------------------------- */
-  _getHeaderButtons() {
-    let buttons = super._getHeaderButtons();
-    buttons.unshift({ class: "post", icon: "fas fa-comment", onclick: ev => this.item.postItem() });
-    return buttons;
-  }
+  static get ITEM_TYPE() { return "signedraconique" }
 
   /* -------------------------------------------- */
   /** @override */
@@ -38,18 +23,9 @@ export class RdDSigneDraconiqueItemSheet extends ItemSheet {
 
   /* -------------------------------------------- */
   async getData() {
-    const formData = duplicate(this.item);
+    const formData = await super.getData();
     this.tmrs = TMRUtility.buildSelectionTypesTMR(this.item.system.typesTMR);
-    mergeObject(formData, {
-      tmrs: this.tmrs,
-      title: formData.name,
-      isGM: game.user.isGM,
-      owner: this.actor?.isOwner,
-      isOwned: this.actor ? true : false,
-      actorId: this.actor?.id,
-      editable: this.isEditable,
-      cssClass: this.isEditable ? "editable" : "locked",
-    });
+    formData.tmrs = this.tmrs;
     return formData;
   }
 
@@ -61,12 +37,13 @@ export class RdDSigneDraconiqueItemSheet extends ItemSheet {
     if (!this.options.editable) return;
 
     html.find(".signe-aleatoire").click(event => this.setSigneAleatoire());
-    html.find("input.select-tmr").change((event) => this.onSelectTmr(event));
-    html.find(".signe-xp-sort").change((event) => this.onValeurXpSort(event.currentTarget.attributes['data-typereussite']?.value, Number(event.currentTarget.value)));
+    html.find("input.select-tmr").change(event => this.onSelectTmr(event));
+    html.find(".signe-xp-sort").change(event => this.onValeurXpSort(event.currentTarget.attributes['data-typereussite']?.value, Number(event.currentTarget.value)));
   }
 
   async setSigneAleatoire() {
     const newSigne = await RdDItemSigneDraconique.randomSigneDraconique();
+    newSigne.name = this.item.name;
     this.item.update(newSigne);
   }
 
@@ -88,12 +65,4 @@ export class RdDSigneDraconiqueItemSheet extends ItemSheet {
     await this.item.update({ 'system.valeur': newValeur });
   }
 
-  /* -------------------------------------------- */
-  get template() {
-    return `systems/foundryvtt-reve-de-dragon/templates/item-signedraconique-sheet.html`;
-  }
-
-  get title() {
-    return `Signe draconique: ${this.object.name}`;
-  }
 }

module/item/signedraconique.js

@@ -1,8 +1,9 @@
-import { defaultItemImg } from "./item.js";
-import { Misc } from "./misc.js";
-import { RdDDice } from "./rdd-dice.js";
-import { RdDRollTables } from "./rdd-rolltables.js";
-import { TMRType, TMRUtility } from "./tmr-utility.js";
+import { RdDItem, defaultItemImg } from "../item.js";
+import { Misc } from "../misc.js";
+import { RdDDice } from "../rdd-dice.js";
+import { RdDRollTables } from "../rdd-rolltables.js";
+import { RdDTimestamp } from "../rdd-timestamp.js";
+import { TMRType, TMRUtility } from "../tmr-utility.js";
 
 const tableSignesIndicatifs = [
   { rarete: "Très facile", difficulte: 0, xp: 6, nbCases: 14 },
@@ -15,7 +16,17 @@ const tableSignesIndicatifs = [
 
 const DIFFICULTE_LECTURE_SIGNE_MANQUE = +11;
 
-export class RdDItemSigneDraconique {
+export class RdDItemSigneDraconique extends RdDItem {
+
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/tmr/signe_draconique.webp";
+  }
+
+  
+  async calculerFinPeriodeTemporel(debut) {
+    // TODO
+    return RdDTimestamp.formulesDuree().find(it => it.code == "").calcul(debut, this.actor);
+  }
 
   static prepareSigneDraconiqueMeditation(meditation, rolled) {
     return {
@@ -96,6 +107,6 @@ export class RdDItemSigneDraconique {
 
   static async randomSigneDescription() {
     return await RdDRollTables.drawTextFromRollTable("Signes draconiques", false);
-  }
+   }
 
 }

module/item/souffle.js

@@ -0,0 +1,13 @@
+import { RdDItem } from "../item.js";
+
+export class RdDItemSouffle extends RdDItem {
+
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/souffle_dragon.webp";
+  }
+
+  async calculerFinPeriodeTemporel(debut) {
+    return await debut.appliquerDuree(this.system.duree, this.parent);
+  }
+
+}

module/migrations.js

@@ -1,6 +1,10 @@
+import { RdDBaseActor } from "./actor/base-actor.js";
 import { LOG_HEAD, SYSTEM_RDD } from "./constants.js";
 import { Grammar } from "./grammar.js";
-import { Misc } from "./misc.js";
+import { Monnaie } from "./item-monnaie.js";
+import { RdDItem } from "./item.js";
+import { RdDTimestamp } from "./rdd-timestamp.js";
+import { RdDRaretes } from "./item/raretes.js";
 
 class Migration {
   get code() { return "sample"; }
@@ -29,6 +33,39 @@ class Migration {
 
 }
 
+class _1_5_34_migrationPngWebp {
+  get code() { return "migrationPngWebp"; }
+  get version() { return "1.5.34"; }
+  async migrate() {
+
+    const regexOldPngJpg = /(systems\/foundryvtt-reve-de-dragon\/icons\/.*)\.(png|jpg)/;
+    const replaceWithWebp = '$1.webp';
+    function convertImgToWebp(img) {
+      return img.replace(regexOldPngJpg, replaceWithWebp);
+    }
+    function prepareDocumentsImgUpdate(documents) {
+      return documents.filter(it => it.img && it.img.match(regexOldPngJpg))
+        .map(it => {
+          return { _id: it.id, img: convertImgToWebp(it.img) }
+        });
+    }
+
+    const itemsUpdates = prepareDocumentsImgUpdate(game.items);
+    const actorsUpdates = prepareDocumentsImgUpdate(game.actors);
+    //Migrate system png to webp
+    await Item.updateDocuments(itemsUpdates);
+    await Actor.updateDocuments(actorsUpdates);
+    game.actors.forEach(actor => {
+      if (actor.token?.img && actor.token.img.match(regexOldPngJpg)) {
+        actor.update({ "token.img": convertImgToWebp(actor.token.img) });
+      }
+      const actorItemsToUpdate = prepareDocumentsImgUpdate(actor.items);
+      actor.updateEmbeddedDocuments('Item', actorItemsToUpdate);
+    });
+  }
+}
+
+
 class _10_0_16_MigrationSortsReserve extends Migration {
   get code() { return "creation-item-sort-reserve"; }
   get version() { return "10.0.16"; }
@@ -104,7 +141,7 @@ class _10_0_33_MigrationNomsDraconic extends Migration {
   get version() { return "10.0.33"; }
 
   migrationNomDraconic(ancien) {
-    if (typeof ancien == 'string'){
+    if (typeof ancien == 'string') {
       switch (ancien) {
         case 'oniros': case "Voie d'Oniros": return "Voie d'Oniros";
         case 'hypnos': case "Voie d'Hypnos": return "Voie d'Hypnos";
@@ -122,18 +159,278 @@ class _10_0_33_MigrationNomsDraconic extends Migration {
 
     await this.applyItemsUpdates(items => items
       .filter(it => ["sort", "sortreserve"].includes(it.type)
-       && (typeof it.system.draconic == 'string') || (typeof it.system.draconic?.name == 'string'))
-      .map(it => { return { _id: it.id, "system.draconic": this.migrationNomDraconic(it.system.draconic)} }));
+        && (typeof it.system.draconic == 'string') || (typeof it.system.draconic?.name == 'string'))
+      .map(it => { return { _id: it.id, "system.draconic": this.migrationNomDraconic(it.system.draconic) } }));
+  }
+}
+
+class _10_2_5_ArmesTirLancer extends Migration {
+  constructor() {
+    super();
+    this.dagues = { "system.competence": 'Dague', "system.lancer": 'Dague de jet', "system.portee_courte": 3, "system.portee_moyenne": 8, "system.portee_extreme": 15 }
+    this.javelot = { "system.competence": 'Lance', "system.lancer": 'Javelot', "system.portee_courte": 6, "system.portee_moyenne": 12, "system.portee_extreme": 20 }
+    this.fouet = { "system.competence": '', "system.lancer": 'Fouet', "system.portee_courte": 2, "system.portee_moyenne": 2, "system.portee_extreme": 3, "system.penetration": -1 }
+    this.arc = { "system.competence": '', "system.tir": 'Arc' }
+    this.arbalete = { "system.competence": '', "system.tir": 'Arbalète' }
+    this.fronde = { "system.competence": '', "system.tir": 'Fronde' }
+
+    this.mappings = {
+      'dague': { filter: it => true, updates: this.dagues },
+      'dague de jet': { filter: it => true, updates: this.dagues },
+      'javelot': { filter: it => true, updates: this.javelot },
+      'lance': { filter: it => it.name == 'Javeline', updates: this.javelot },
+      'fouet': { filter: it => true, updates: this.fouet },
+      'arc': { filter: it => true, updates: this.arc },
+      'arbalete': { filter: it => true, updates: this.arbalete },
+      'fronde': { filter: it => true, updates: this.fronde },
+    }
+  }
+
+  get code() { return "separation-competences-tir-lancer"; }
+  get version() { return "10.2.5"; }
+
+  migrateArmeTirLancer(it) {
+    let updates = mergeObject({ _id: it.id }, this.getMapping(it).updates);
+    console.log(it.name, updates);
+    return updates;
+  }
+
+  async migrate() {
+    await this.applyItemsUpdates(items => items
+      .filter(it => "arme" == it.type)
+      .filter(it => this.isTirLancer(it))
+      .filter(it => this.getMapping(it).filter(it))
+      .map(it => this.migrateArmeTirLancer(it)));
+  }
+
+
+  isTirLancer(it) {
+    return Object.keys(this.mappings).includes(this.getCompKey(it));
+  }
+
+  getMapping(it) {
+    return this.mappings[this.getCompKey(it)];
+  }
+
+  getCompKey(it) {
+    return Grammar.toLowerCaseNoAccent(it.system.competence);
+  }
+}
+
+class _10_2_10_DesirLancinant_IdeeFixe extends Migration {
+  get code() { return "desir-lancinat-idee-fixe"; }
+  get version() { return "10.2.10"; }
+
+  migrateQueue(it) {
+    let categorie = undefined
+    let name = it.name
+    if (Grammar.toLowerCaseNoAccent(name).includes('desir')) {
+      categorie = 'lancinant';
+      name = it.name.replace('Désir lancinant : ', '');
+
+    }
+    if (Grammar.toLowerCaseNoAccent(name).includes('idee fixe')) {
+      categorie = 'ideefixe';
+      name = it.name.replace('Idée fixe : ', '')
+    }
+    return {
+      _id: it.id, name: name,
+      'system.ideefixe': undefined,
+      'system.lancinant': undefined,
+      'system.categorie': categorie
+    }
+  }
+
+  async migrate() {
+    await this.applyItemsUpdates(items => items
+      .filter(it => ['queue', 'ombre'].includes(it.type))
+      .map(it => this.migrateQueue(it))
+    );
+  }
+}
+
+class _10_3_0_Inventaire extends Migration {
+  get code() { return "migration-equipement-inventaire"; }
+  get version() { return "10.3.0"; }
+
+  async migrate() {
+    await this.applyItemsUpdates(items => {
+      return this._updatesMonnaies(items)
+        .concat(this._updatesNonEquipe(items))
+        .concat(this._updatesObjets(items))
+    });
+  }
+
+  _updatesNonEquipe(items) {
+    return items
+      .filter(it => ['munition'].includes(it.type))
+      .map(it => { return { _id: it.id, 'system.equipe': undefined } });
+  }
+  _updatesObjets(items) {
+    return items
+      .filter(it => ['objet'].includes(it.type))
+      .map(it => { return { _id: it.id, 'system.resistance': undefined, 'system.equipe': undefined } });
+  }
+  _updatesMonnaies(items) {
+    return items
+      .filter(it => ['monnaie'].includes(it.type) && it.system.valeur_deniers != undefined)
+      .map(it => { return { _id: it.id, 'system.cout': it.system.valeur_deniers / 100, 'system.valeur_deniers': undefined } });
+  }
+}
+
+class _10_3_0_FrequenceEnvironnement extends Migration {
+  get code() { return "migration-frequence-resources"; }
+  get version() { return "10.3.0"; }
+
+  async migrate() {
+    await this.applyItemsUpdates(items => items.filter(it => ['herbe', 'ingredient'].includes(it.type))
+      .map(it => this._updatesFrequences(it)));
+  }
+
+  _updatesFrequences(it) {
+    const rarete = RdDRaretes.byCode(it.system.rarete);
+    return {
+      _id: it.id,
+      'system.rarete': undefined,
+      'system.environnement': [{ milieu: it.system.milieu, rarete: rarete.code, frequence: rarete.frequence }]
+    }
+  }
+}
+
+class _10_3_17_Monnaies extends Migration {
+  constructor() {
+    super();
+    this.mapValeur = {
+      "Etain (1 denier)": { name: 'Denier (étain)', system: { cout: 0.01 } },
+      "Bronze (10 deniers)": { name: "Sou (bronze)", system: { cout: 0.1 } },
+      "Argent (1 sol)": { name: "Sol (argent)", system: { cout: 1 } },
+      "Or (10 sols)": { name: "Dragon (or)", system: { cout: 10 } }
+    };
+  }
+  get code() { return "migration-monnaies"; }
+  get version() { return "10.3.17"; }
+
+  async migrate() {
+    await this.applyItemsUpdates(items => this._updatesMonnaies(items));
+  }
+
+  _updatesMonnaies(items) {
+    return items
+      .filter(it => 'monnaie' == it.type)
+      .filter(it => this.mapValeur[it.name] != undefined)
+      .map(it => {
+        const correction = this.mapValeur[it.name];
+        return {
+          _id: it.id,
+          'name': correction.name,
+          'system.cout': correction.system.cout,
+          'system.valeur_deniers': undefined
+        }
+      });
+  }
+}
+
+class _10_4_6_ServicesEnCommerces extends Migration {
+
+  get code() { return "migration-service-acteurs"; }
+  get version() { return "10.4.6"; }
+
+  async migrate() {
+    const servicesToMigrate = game.items.filter(it => it.type == 'service');
+    servicesToMigrate.forEach(async service => {
+      const commerce = await this.convertServiceToCommerce(service);
+      await RdDBaseActor.create(commerce, { renderSheet: false });
+      await service.delete();
+    });
+  }
+
+  async convertServiceToCommerce(service) {
+    return {
+      name: service.name, img: service.img, type: 'commerce',
+      system: {
+        description: service.system.description,
+        notesmj: service.system.descriptionmj,
+        illimite: service.system.illimite
+      },
+      items: await this.transformInventaireCommerce(service)
+    }
+  }
+  async transformInventaireCommerce(service) {
+    const serviceItems = (service.system.items ?? []);
+    const commerceItems = await Promise.all(serviceItems.map(async (it) => { return await this.transformToItemBoutique(it); }));
+    return commerceItems.concat(Monnaie.monnaiesStandard());
+  }
+
+  async transformToItemBoutique(serviceRefItem) {
+    const item = await RdDItem.getCorrespondingItem(serviceRefItem);
+    const itemToCreate = {
+      name: item.name, img: item.img, type: item.type,
+      system: mergeObject({ cout: serviceRefItem.system.cout, quantite: serviceRefItem.system.quantite }, item.system, { overwrite: false })
+    };
+    return itemToCreate;
+  }
+}
+class _10_5_0_UpdatePeriodicite extends Migration {
+  get code() { return "migration-periodicite-poisons-maladies"; }
+  get version() { return "10.5.0"; }
+
+  async migrate() {
+    await this.applyItemsUpdates(items => this._updatePeriodicite(items));
+  }
+
+  _updatePeriodicite(items) {
+    return items.filter(it => ['poison', 'maladie'].includes(it.type))
+      .filter(it => it.system.periodicite != "")
+      .map(it => {
+        let [incubation, periodicite] = this.getPeriodicite(it);
+        const periode = periodicite.split(' ');
+        let unite = periode.length == 2
+          ? RdDTimestamp.formulesPeriode().find(it => Grammar.includesLowerCaseNoAccent(periode[1], it.code))?.code
+          : undefined
+        if (unite && Number(periode[0])) {
+          return {
+            _id: it.id,
+            'system.periodicite': undefined,
+            'system.incubation': incubation,
+            'system.periode.nombre': Number.parseInt(periode[0]),
+            'system.periode.unite': unite
+          };
+        }
+        else {
+          return {
+            _id: it.id,
+            'system.periodicite': undefined,
+            'system.incubation': it.system.periodicite
+          };
+        }
+      }).filter(it => it != undefined);
+  }
+
+  getPeriodicite(it) {
+    let p = it.system.periodicite.split(/[\/\\]/);
+    switch (p.length) {
+      case 2: return [p[0].trim(), p[1].trim()];
+      case 1: return ["", it.system.periodicite.trim()];
+      default: return [it.system.periodicite.trim(), ""];
+    }
   }
 }
 
 export class Migrations {
   static getMigrations() {
     return [
+      new _1_5_34_migrationPngWebp(),
       new _10_0_16_MigrationSortsReserve(),
       new _10_0_17_MigrationCompetenceCreature(),
       new _10_0_21_VehiculeStructureResistanceMax(),
       new _10_0_33_MigrationNomsDraconic(),
+      new _10_2_5_ArmesTirLancer(),
+      new _10_2_10_DesirLancinant_IdeeFixe(),
+      new _10_3_0_Inventaire(),
+      new _10_3_0_FrequenceEnvironnement(),
+      new _10_3_17_Monnaies(),
+      new _10_4_6_ServicesEnCommerces(),
+      new _10_5_0_UpdatePeriodicite(),
     ];
   }
 
@@ -148,20 +445,12 @@ export class Migrations {
   }
 
   migrate() {
-    const currentVersion = game.settings.get(
-      SYSTEM_RDD,
-      "systemMigrationVersion"
-    );
+    const currentVersion = game.settings.get(SYSTEM_RDD, "systemMigrationVersion");
     if (isNewerVersion(game.system.version, currentVersion)) {
+    //if (true) { /* comment previous and uncomment here to test before upgrade  */
       const migrations = Migrations.getMigrations().filter(m => isNewerVersion(m.version, currentVersion));
       if (migrations.length > 0) {
-        migrations.sort((a, b) =>
-          isNewerVersion(a.version, b.version)
-            ? 1
-            : isNewerVersion(b.version, a.version)
-              ? -1
-              : 0
-        );
+        migrations.sort((a, b) => this.compareVersions(a, b));
         migrations.forEach(async (m) => {
           ui.notifications.info(
             `Executing migration ${m.code}: version ${currentVersion} is lower than ${m.version}`
@@ -187,4 +476,8 @@ export class Migrations {
       console.log(LOG_HEAD + `No system version changed`);
     }
   }
+
+  compareVersions(a, b) {
+    return isNewerVersion(a.version, b.version) ? 1 : isNewerVersion(b.version, a.version) ? -1 : 0;
+  }
 }

module/misc.js

@@ -24,7 +24,7 @@ export class Misc {
   }
 
   static sum() {
-    return (a, b) => a + b;
+    return (a, b) => Number(a) + Number(b);
   }
 
   static ascending(orderFunction = x => x) {
@@ -41,6 +41,14 @@ export class Misc {
     return 0;
   }
 
+  static typeName(type, subType) {
+    return subType ? game.i18n.localize(`${type.toUpperCase()}.Type${Misc.upperFirst(subType)}`)
+      : '';
+  }
+
+  static arrayOrEmpty(items) {
+    return items?.length ? items : [];
+  }
   /**
    * Converts the value to an integer, or to 0 if undefined/null/not representing integer
    * @param {*} value value to convert to an integer using parseInt
@@ -68,6 +76,20 @@ export class Misc {
     }
   }
 
+  static indexLowercase(list) {
+    const obj = {};
+    const addToObj = (map, val) => {
+      const key = Grammar.toLowerCaseNoAccent(val);
+      if (key && !map[key]) map[key] = val
+    }
+    list.forEach(it => addToObj(obj, it))
+    return obj;
+  }
+
+  static concat(lists) {
+    return lists.reduce((a, b) => a.concat(b), []);
+  }
+
   static classify(items, classifier = it => it.type) {
     let itemsBy = {}
     Misc.classifyInto(itemsBy, items, classifier)
@@ -102,7 +124,11 @@ export class Misc {
   }
 
   static join(params, separator = '') {
-    return params?.reduce((a, b) => a + separator + b) ?? '';
+    return params?.reduce(Misc.joining(separator)) ?? '';
+  }
+
+  static joining(separator = '') {
+    return (a, b) => a + separator + b;
   }
 
   static connectedGMOrUser(ownerId = undefined) {
@@ -112,20 +138,27 @@ export class Misc {
     return Misc.firstConnectedGM()?.id ?? game.user.id;
   }
 
+  static isRollModeHiddenToPlayer() {
+    switch (game.settings.get("core", "rollMode")) {
+      case CONST.DICE_ROLL_MODES.BLIND:
+      case CONST.DICE_ROLL_MODES.SELF: return true;
+    }
+    return false
+  }
+
   static getActiveUser(id) {
     return game.users.find(u => u.id == id && u.active);
-  }  
+  }
 
   static firstConnectedGM() {
     return game.users.filter(u => u.isGM && u.active).sort(Misc.ascending(u => u.id)).find(u => u.isGM && u.active);
-    
   }
 
-  static isOwnerPlayer(actor, user=undefined) {
+  static isOwnerPlayer(actor, user = undefined) {
     return actor.testUserPermission(user ?? game.user, CONST.DOCUMENT_PERMISSION_LEVELS.OWNER)
   }
 
-  static  isOwnerPlayerOrUniqueConnectedGM(actor, user =undefined){
+  static isOwnerPlayerOrUniqueConnectedGM(actor, user = undefined) {
     return Misc.isOwnerPlayer(actor, user) ?? Misc.isUniqueConnectedGM();
   }
 

module/poetique.txt

@@ -1,44 +0,0 @@
-Le courant du Fleuve
-Te domine et te Porte
-Avant que tu te moeuves
-Combat le, ou il t'emporte
-
-
-
-A vous qui faites ripaille
-sourds aux damnés de la faim
-à vous qui livrez
-une inégale bataille
-à ceux qui vous tendent la main
-
-Ils sont tout près ! - Tenons fermée
-<br>Cette salle, où nous les narguons.
-<br>Quel bruit dehors ! Hideuse armée
-<br>De vampires et de dragons !
-<br>La poutre du toit descellée
-<br>Ploie ainsi qu'une herbe mouillée,
-<br>Et la vieille porte rouillée
-<br>Tremble, à déraciner ses gonds !`),
-
-https://www.poetica.fr/poeme-1423/guy-de-maupassant-le-sommeil-du-mandarin/
-
-
-
-
-Le monde est un rêve de Dragons. Nous
-ne savons pas qui sont les Dragons ni à quoi
-ils ressemblent, en dépit de l’antique iconographie qui les dépeint comme de gigantesques créatures ailées capables de cracher
-feu et flammes. 
-
-
-
-Car parmi les humains, autre nom lui est donné,
-Nom sinistre parmi tous, nom funèbre, c'est la mort!
-Un ami disparu... Thanatos est passé...
-
-
-Messieurs, ne crachez pas de jurons ni d'ordure
-Au visage fardé de cette pauvre impure
-Que déesse Famine a par un soir d'hiver,
-Contrainte à relever ses jupons en plein air.
-

module/rdd-alchimie.js

@@ -8,13 +8,11 @@ export class RdDAlchimie {
 
   /* -------------------------------------------- */
   static processManipulation(recette, actorId = undefined) {
-    //console.log("CALLED", recette, recette.isOwned, actorId );
     let manip = recette.system.manipulation;
     let matchArray = manip.match(matchOperations);
     if (matchArray) {
       for (let matchStr of matchArray) {
         let result = matchStr.match(matchOperationTerms);
-        //console.log("RESULT ", result);
         if (result[1] && result[2]) {
           let commande = Misc.upperFirst(result[1]);
           let replacement = this[`_alchimie${commande}`](recette, result[2], actorId);
@@ -27,20 +25,19 @@ export class RdDAlchimie {
 
   /* -------------------------------------------- */
   static _alchimieCouleur(recette, couleurs, actorId) {
-    if (actorId) {
-      return `<span class="alchimie-tache"><a data-recette-id="${recette._id}" data-actor-id="${actorId}" data-alchimie-tache="couleur" data-alchimie-data="${couleurs}">couleur ${couleurs}</a></span>`;
-    } else {
-      return `<span class="alchimie-tache">couleur ${couleurs} </span>`;
-    }
+    return RdDAlchimie._alchimieLink(recette, couleurs, actorId,  'couleur',  'Température');
   }
 
   /* -------------------------------------------- */
   static _alchimieConsistance(recette, consistances, actorId) {
-    if (actorId) {
-      return `<span class="alchimie-tache"><a data-recette-id="${recette._id}" data-actor-id="${actorId}" data-alchimie-tache="consistance" data-alchimie-data="${consistances}">consistance ${consistances}</a></span>`;
-    } else {
-      return `<span class="alchimie-tache">consistance ${consistances} </span>`;
-    }
+    return RdDAlchimie._alchimieLink(recette, consistances, actorId,  'consistance',  'Consistance');
+  }
+
+  static _alchimieLink(recette, termes, actorId, tacheAlchimie, labelTache) {
+    const difficulte = RdDAlchimie.getDifficulte(termes);
+    const link = actorId ? ` <a data-recette-id="${recette._id}" data-actor-id="${actorId}" data-alchimie-tache="${tacheAlchimie}" data-alchimie-data="${termes}">` : '';
+    const endLink = actorId ? '</a>' : '';
+    return `<span class="alchimie-tache">${link}${labelTache} ${termes} (${difficulte})${endLink}</span>`;
   }
 
   /* -------------------------------------------- */

module/rdd-astrologie-editeur.js

@@ -3,26 +3,37 @@
  * Extend the base Dialog entity by defining a custom window to perform roll.
  * @extends {Dialog}
  */
- export class RdDAstrologieEditeur extends Dialog {
+export class RdDAstrologieEditeur extends Dialog {
 
   /* -------------------------------------------- */
   constructor(html, calendrier, calendrierData) {
 
     let myButtons = {
-        resetButton: { label: "Re-tirer les nombres astraux", callback: html => this.resetNombreAstraux() },
-        saveButton: { label: "Fermer", callback: html => this.fillData() }
-      };
+      resetButton: { label: "Re-tirer les nombres astraux", callback: html => this.resetNombreAstraux() },
+      saveButton: { label: "Fermer", callback: html => {} }
+    };
 
     // Common conf
     let dialogConf = { content: html, title: "Editeur d'Astrologie", buttons: myButtons, default: "saveButton" };
-    let dialogOptions = { classes: ["rdddialog"], width: 600, height: 300, 'z-index': 99999 }  
+    let dialogOptions = {
+      classes: ["rdd-roll-dialog"], width: 600,
+      height: 'fit-content',
+      'max-height': 800,
+      'z-index': 99999
+    }
     super(dialogConf, dialogOptions)
-    
+
     this.calendrier = calendrier;
-    this.updateData( calendrierData );
+    this.updateData(calendrierData);
   }
 
-  /* -------------------------------------------- */  
+  activateListeners(html) {
+    super.activateListeners(html);
+    this.html = html;
+  }
+
+
+  /* -------------------------------------------- */
   async resetNombreAstraux() {
     game.system.rdd.calendrier.resetNombreAstral();
     await game.system.rdd.calendrier.rebuildListeNombreAstral();
@@ -30,24 +41,9 @@
     game.system.rdd.calendrier.showAstrologieEditor();
   }
 
-  /* -------------------------------------------- */  
-  fillData( ) {
-  }
-
   /* -------------------------------------------- */
-  updateData( calendrierData ) {
+  updateData(calendrierData) {
     this.calendrierData = duplicate(calendrierData);
   }
 
-  /* -------------------------------------------- */
-  activateListeners(html) {
-    super.activateListeners(html);
-    
-    let astrologieData = this.astrologieData;
-
-    $(function () {
-    });
-
-  }
-
 }

module/rdd-astrologie-joueur.js

@@ -10,7 +10,7 @@ import { SYSTEM_SOCKET_ID } from "./constants.js";
 export class RdDAstrologieJoueur extends Dialog {
 
   /* -------------------------------------------- */
-  static async create(actor, dialogConfig) {
+  static async create(actor) {
 
     let dialogData = {
       nombres: this.organizeNombres(actor),
@@ -20,33 +20,43 @@ export class RdDAstrologieJoueur extends Dialog {
       astrologie: RdDItemCompetence.findCompetence(actor.items, 'Astrologie')
     }
     const html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/dialog-astrologie-joueur.html', dialogData);
-    let options = { classes: ["rdddialog"], width: 600, height: 500, 'z-index': 99999 };
-    if (dialogConfig.options) {
-      mergeObject(options, dialogConfig.options, { overwrite: true });
-    }
-    return new RdDAstrologieJoueur(html, actor, dialogData);
+
+    const options = { classes: ["rdd-roll-dialog"], width: 600, height: 'fit-content', 'z-index': 99999 };
+    const dialog = new RdDAstrologieJoueur(html, actor, dialogData, options);
+    dialog.render(true);
   }
 
   /* -------------------------------------------- */
-  constructor(html, actor, dialogData) {
-
-    let myButtons = {
-      saveButton: { label: "Fermer", callback: html => this.quitDialog() }
+  constructor(html, actor, dialogData, dialogOptions) {
+    const dialogConf = {
+      title: "Nombres Astraux",
+      content: html,
+      default: "saveButton",
+      buttons: {
+        saveButton: { label: "Fermer", callback: html => {} }
+      },
     };
-
-    // Get all n
-    // Common conf
-    let dialogConf = { content: html, title: "Nombres Astraux", buttons: myButtons, default: "saveButton" };
-    let dialogOptions = { classes: ["rdddialog"], width: 600, height: 300, 'z-index': 99999 };
     super(dialogConf, dialogOptions);
 
     this.actor = actor;
     this.dataNombreAstral = duplicate(dialogData);
   }
 
+  /* -------------------------------------------- */
+  activateListeners(html) {
+    super.activateListeners(html);
+    this.html = html;
+
+    this.html.find("[name='diffConditions']").val(0);
+
+    this.html.find('[name="jet-astrologie"]').click((event) => {
+      this.requestJetAstrologie();
+    });
+  }
+
   /* -------------------------------------------- */
   static organizeNombres(actor) {
-    let itemNombres = actor.listItemsData('nombreastral');
+    let itemNombres = actor.listItems('nombreastral');
     let itemFiltered = {};
     for (let item of itemNombres) {
       if (itemFiltered[item.system.jourindex]) {
@@ -68,8 +78,8 @@ export class RdDAstrologieJoueur extends Dialog {
       carac_vue: this.actor.system.carac['vue'].value,
       etat: this.dataNombreAstral.etat,
       astrologie: this.dataNombreAstral.astrologie,
-      conditions: $("#diffConditions").val(),
-      date: $("#joursAstrologie").val(),
+      conditions: this.html.find('[name="diffConditions"]').val(),
+      date: this.html.find('[name="joursAstrologie"]').val(),
       userId: game.user.id
     }
     if (Misc.isUniqueConnectedGM()) {
@@ -83,21 +93,4 @@ export class RdDAstrologieJoueur extends Dialog {
     this.close();
   }
 
-  /* -------------------------------------------- */
-  quitDialog() {
-  }
-
-  /* -------------------------------------------- */
-  activateListeners(html) {
-    super.activateListeners(html);
-
-    $(function () {
-      $("#diffConditions").val(0);
-    });
-
-    html.find('#jet-astrologie').click((event) => {
-      this.requestJetAstrologie();
-    });
-  }
-
 }

module/rdd-calendrier-editeur.js

@@ -1,4 +1,4 @@
-import { Misc } from "./misc.js";
+import { RdDTimestamp } from "./rdd-timestamp.js";
 
 /**
  * Extend the base Dialog entity by defining a custom window to perform roll.
@@ -12,47 +12,56 @@ export class RdDCalendrierEditeur extends Dialog {
       content: html,
       title: "Editeur de date/heure",
       buttons: {
-          save: { label: "Enregistrer", callback: html => this.fillData() }
-        },
+        save: { label: "Enregistrer", callback: html => this.saveCalendrier() }
+      },
       default: "save"
     };
-    let dialogOptions = { classes: ["rdddialog"], width: 400, height: 'fit-content', 'z-index': 99999 }  
+    let dialogOptions = { classes: ["rdd-dialog-calendar-editor"], width: 400, height: 'fit-content', 'z-index': 99999 }
     super(dialogConf, dialogOptions)
-    
+
     this.calendrier = calendrier;
     this.calendrierData = calendrierData;
   }
 
-  /* -------------------------------------------- */
-  fillData( ) {
-    this.calendrierData.moisKey  = $("#nomMois").val();
-    this.calendrierData.heureKey = $("#nomHeure").val();
-    this.calendrierData.jourMois = $("#jourMois").val();
-    this.calendrierData.minutesRelative = $("#minutesRelative").val();
-    
-    console.log("UPDATE  ", this.calendrierData);
-    this.calendrier.saveEditeur( this.calendrierData )
-  }
-
-  /* -------------------------------------------- */
-  updateData( calendrierData ) {
-    this.calendrierData = duplicate(calendrierData);
-  }
-
-  /* -------------------------------------------- */
   activateListeners(html) {
     super.activateListeners(html);
-    
-    let calendrierData = this.calendrierData;
+    this.html = html;
 
-    $(function () {
-      console.log(calendrierData);
-      $("#nomMois").val(calendrierData.moisKey);
-      $("#nomHeure").val(calendrierData.heureKey);
-      $("#jourMois").val(calendrierData.jourMois);
-      $("#minutesRelative").val(calendrierData.minutesRelative);
+    this.html.find("input[name='calendar.annee']").val(this.calendrierData.annee);
+    this.html.find("select[name='calendar.mois']").val(this.calendrierData.mois.key);
+    this.html.find("select[name='calendar.heure']").val(this.calendrierData.heure.key);
+    RdDCalendrierEditeur.setLimited(this.html.find("input[name='calendar.jourDuMois']"), this.calendrierData.jourDuMois, 1, 28);
+    RdDCalendrierEditeur.setLimited(this.html.find("input[name='calendar.minute']"), this.calendrierData.minute, 0, 119);
+  }
+
+  static setLimited(input, init, min, max) {
+    input.val(init);
+    input.change(event => {
+      const val = Number.parseInt(input.val());
+      if (val < min) {
+        input.val(min);
+      }
+      if (val > max) {
+        input.val(max);
+      }
     });
 
   }
 
+  /* -------------------------------------------- */
+  saveCalendrier() {
+    const annee = Number.parseInt(this.html.find("input[name='calendar.annee']").val());
+    const mois = this.html.find("select[name='calendar.mois']").val();
+    const jour = Number.parseInt(this.html.find("input[name='calendar.jourDuMois']").val());
+    const heure = this.html.find("select[name='calendar.heure']").val();
+    const minute = Number.parseInt(this.html.find("input[name='calendar.minute']").val());
+
+    this.calendrier.setNewTimestamp(RdDTimestamp.timestamp(annee, mois, jour, heure, minute))
+  }
+
+  /* -------------------------------------------- */
+  updateData(calendrierData) {
+    this.calendrierData = duplicate(calendrierData);
+  }
+
 }

module/rdd-calendrier.js

@@ -1,103 +1,33 @@
-/* -------------------------------------------- */
 import { RdDCalendrierEditeur } from "./rdd-calendrier-editeur.js";
 import { RdDAstrologieEditeur } from "./rdd-astrologie-editeur.js";
-import { HtmlUtility } from "./html-utility.js";
 import { RdDResolutionTable } from "./rdd-resolution-table.js";
 import { RdDUtility } from "./rdd-utility.js";
-import { Grammar } from "./grammar.js";
 import { RdDDice } from "./rdd-dice.js";
 import { Misc } from "./misc.js";
 import { HIDE_DICE, SHOW_DICE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
 import { DialogChronologie } from "./dialog-chronologie.js";
+import { RdDTimestamp, WORLD_TIMESTAMP_SETTING } from "./rdd-timestamp.js";
 
-/* -------------------------------------------- */
-const dossierIconesHeures = 'systems/foundryvtt-reve-de-dragon/icons/heures/'
-const heuresList = ["vaisseau", "sirene", "faucon", "couronne", "dragon", "epees", "lyre", "serpent", "poissonacrobate", "araignee", "roseau", "chateaudormant"];
-const heuresDef = {
-  "vaisseau": {key: "vaisseau", label: "Vaisseau", lettreFont: 'v', saison: "printemps", heure: 0, icon: 'hd01.svg' },
-  "sirene": { key: "sirene", label: "Sirène", lettreFont: 'i', saison: "printemps", heure: 1, icon: 'hd02.svg' },
-  "faucon": { key: "faucon", label: "Faucon", lettreFont: 'f', saison: "printemps", heure: 2, icon: 'hd03.svg' },
-  "couronne": { key: "couronne", label: "Couronne", lettreFont: '', saison: "ete", heure: 3, icon: 'hd04.svg' },
-  "dragon": { key: "dragon", label: "Dragon", lettreFont: 'd', saison: "ete", heure: 4, icon: 'hd05.svg' },
-  "epees": { key: "epees", label: "Epées", lettreFont: 'e', saison: "ete", heure: 5, icon: 'hd06.svg' },
-  "lyre": { key: "lyre", label: "Lyre", lettreFont: 'l', saison: "automne", heure: 6, icon: 'hd07.svg' },
-  "serpent": { key: "serpent", label: "Serpent", lettreFont: 's', saison: "automne", heure: 7, icon: 'hd08.svg' },
-  "poissonacrobate": { key: "poissonacrobate", label: "Poisson Acrobate", lettreFont: 'p', saison: "automne", heure: 8, icon: 'hd09.svg' },
-  "araignee": { key: "araignee", label: "Araignée", lettreFont: 'a', saison: "hiver", heure: 9, icon: 'hd10.svg' },
-  "roseau": { key: "roseau", label: "Roseau", lettreFont: 'r', saison: "hiver", heure: 10, icon: 'hd11.svg' },
-  "chateaudormant": { key: "chateaudormant", label: "Château Dormant", lettreFont: 'c', saison: "hiver", heure: 11, icon: 'hd12.svg' }
-};
-const saisonsDef = {
-  "printemps": { label: "Printemps" },
-  "ete": { label: "Eté" },
-  "automne": { label: "Automne" },
-  "hiver": { label: "Hiver" }
-};
-
-const RDD_MOIS_PAR_AN = 12;
-export const RDD_JOUR_PAR_MOIS = 28;
+const RDD_JOUR_PAR_MOIS = 28;
 const RDD_HEURES_PAR_JOUR = 12;
-const RDD_MINUTES_PAR_HEURES = 120;
 const MAX_NOMBRE_ASTRAL = 12;
+const JOURS_DU_MOIS = Array(RDD_JOUR_PAR_MOIS).fill().map((item, index) => 1 + index);
 
 /* -------------------------------------------- */
 export class RdDCalendrier extends Application {
 
+  static get defaultOptions() {
+    return mergeObject(super.defaultOptions, {
+      template: "systems/foundryvtt-reve-de-dragon/templates/calendar-template.html",
+      popOut: false,
+      resizable: false
+    });
+  }
+
   static createCalendrierPos() {
     return { top: 200, left: 200 };
   }
 
-  static getDefSigne(chiffre) {
-    chiffre = chiffre % RDD_MOIS_PAR_AN;
-    return Object.values(heuresDef).find(h => h.heure == chiffre);
-  }
-
-  static getSigneAs(key, value) {
-    const heure = (typeof value == 'string' || typeof value == 'number') && Number.isInteger(Number(value))
-      ? Number(value)
-      : (typeof value == 'string') ? RdDCalendrier.getChiffreFromSigne(value)
-      : undefined
-
-    if (heure != undefined && ['key', 'label', 'lettreFont', 'saison', 'heure', 'icon'].includes(key)) {
-      return RdDCalendrier.getDefSigne(heure)[key]
-    }
-    if (heure != undefined && ['webp'].includes(key)) {
-      return RdDCalendrier.getDefSigne(heure)['icon'].replace('svg', 'webp');
-    }
-    console.error(`Appel à getSigneAs('${key}', ${value}) avec une clé/heure incorrects`);
-    return value;
-
-  }
-  static getChiffreFromSigne(signe) {
-    return heuresList.indexOf(signe);
-  }
-
-  static createCalendrierInitial() {
-    return {
-      heureRdD: 0,
-      minutesRelative: 0,
-      indexJour: 0,
-      annee: 0,
-      moisRdD: 0,
-      moisLabel: heuresDef["vaisseau"].label,
-      jour: 0
-    }
-  }
-
-  getCalendrier(index) {
-    index = index ?? this.getCurrentDayIndex();
-    const mois = Math.floor(index / RDD_JOUR_PAR_MOIS) % RDD_MOIS_PAR_AN;
-    return {
-      heureRdD: 0, // Index dans heuresList / heuresDef[x].heure
-      minutesRelative: 0,
-      indexJour: index,
-      annee: Math.floor(index / (RDD_JOUR_PAR_MOIS * RDD_MOIS_PAR_AN)),
-      moisRdD: RdDCalendrier.getDefSigne(mois).heure,
-      moisLabel: RdDCalendrier.getDefSigne(mois).label,
-      jour: (index % RDD_JOUR_PAR_MOIS) // Le calendrier stocke le jour en 0-27, mais en 1-28 à l'affichage
-    }
-  }
-
   constructor() {
     super();
     // position
@@ -106,477 +36,48 @@ export class RdDCalendrier extends Application {
       this.calendrierPos = RdDCalendrier.createCalendrierPos();
       game.settings.set(SYSTEM_RDD, "calendrier-pos", this.calendrierPos);
     }
-
     // Calendrier
-    this.calendrier = duplicate(game.settings.get(SYSTEM_RDD, "calendrier") ?? RdDCalendrier.createCalendrierInitial());
-    this.calendrier.annee = this.calendrier.annee ?? Math.floor((this.calendrier.moisRdD ?? 0) / RDD_MOIS_PAR_AN);
-    this.calendrier.moisRdD = (this.calendrier.moisRdD ?? 0) % RDD_MOIS_PAR_AN;
+    this.timestamp = RdDTimestamp.getWorldTime();
 
     if (Misc.isUniqueConnectedGM()) { // Uniquement si GM
-      game.settings.set(SYSTEM_RDD, "calendrier", this.calendrier);
-
+      RdDTimestamp.setWorldTime(this.timestamp);
       this.listeNombreAstral = this.getListeNombreAstral();
-      this.rebuildListeNombreAstral(false); // Ensure always up-to-date
+      this.rebuildListeNombreAstral(HIDE_DICE); // Ensure always up-to-date
     }
-    console.log(this.calendrier, this.calendrierPos, this.listeNombreAstral);
+    console.log('RdDCalendrier.constructor()', this.timestamp, this.timestamp.toCalendrier(), this.calendrierPos, this.listeNombreAstral);
+    Hooks.on('updateSetting', async (setting, update, options, id) => this.onUpdateSetting(setting, update, options, id));
   }
 
-  /* -------------------------------------------- */
-  getListeNombreAstral() {
-    return game.settings.get(SYSTEM_RDD, "liste-nombre-astral") ?? [];
-  }
-
-  /* -------------------------------------------- */
-  static get defaultOptions() {
-    return mergeObject(super.defaultOptions, {
-      template: "systems/foundryvtt-reve-de-dragon/templates/calendar-template.html",
-      popOut: false,
-      resizable: false
-    });
-  }
-
-  /* -------------------------------------------- */
-  getDateFromIndex(index) {
-    const dateRdD = this.getCalendrier(index);
-    return (dateRdD.jour + 1) + ' ' + dateRdD.moisLabel;
-  }
-
-  /* -------------------------------------------- */
-  getDayMonthFromIndex(index = undefined) {
-    const dateRdD = this.getCalendrier(index);
-    return {
-      day: dateRdD.jour + 1,
-      month: heuresList[dateRdD.moisRdD]
+  async onUpdateSetting(setting, update, options, id) {
+    if (setting.key == SYSTEM_RDD + '.' + WORLD_TIMESTAMP_SETTING) {
+      this.timestamp = RdDTimestamp.getWorldTime();
+      this.updateDisplay();
     }
   }
 
-  /* -------------------------------------------- */
-  getCurrentHeure() {
-    return heuresList[this.calendrier.heureRdD];
-  }
-
-  /* -------------------------------------------- */
-  getCurrentDayIndex() {
-    return (((this.calendrier.annee ?? 0) * RDD_MOIS_PAR_AN + (this.calendrier.moisRdD ?? 0)) * RDD_JOUR_PAR_MOIS) + (this.calendrier.jour ?? 0);
-  }
-
-  /* -------------------------------------------- */
-  getIndexFromDate(jour, mois) {
-    return (heuresDef[mois].heure * RDD_JOUR_PAR_MOIS) + jour - 1;
-  }
-  /* -------------------------------------------- */
-  getJoursSuivants(num) {
-    let jours = [];
-    let index = this.getCurrentDayIndex();
-    for (let i = 0; i < num; i++) {
-      jours[i] = { label: this.getDateFromIndex(index + i), index: index + i };
-    }
-    return jours;
-  }
-
-  /* -------------------------------------------- */
-  async ajouterNombreAstral(index, showDice = SHOW_DICE) {
-    const nombreAstral = await RdDDice.rollTotal("1dh", { showDice: showDice, rollMode: "selfroll" });
-    const dateFuture = this.getDateFromIndex(index);
-    if (showDice != HIDE_DICE) {
-      ChatMessage.create({
-        whisper: ChatMessage.getWhisperRecipients("GM"),
-        content: `Le chiffre astrologique du ${dateFuture} sera le ${nombreAstral}`
-      });
-    }
-    return {
-      nombreAstral: nombreAstral,
-      valeursFausses: [],
-      index: index
-    }
-  }
-
-  /* -------------------------------------------- */
-  getCurrentNombreAstral() {
-    let indexDate = this.getCurrentDayIndex();
-    return this.getNombreAstral(indexDate);
-  }
-
-  /* -------------------------------------------- */
-  resetNombreAstral() {
-    this.listeNombreAstral = [];
-    game.settings.set(SYSTEM_RDD, "liste-nombre-astral", this.listeNombreAstral);
-
-    game.socket.emit(SYSTEM_SOCKET_ID, {
-      msg: "msg_reset_nombre_astral",
-      data: {}
-    });
-  }
-
-  /* -------------------------------------------- */
-  getNombreAstral(indexDate) {
-    let astralData = this.getListeNombreAstral().find((nombreAstral, i) => nombreAstral.index == indexDate);
-    return astralData?.nombreAstral;
-  }
-
-  /* -------------------------------------------- */
-  async rebuildListeNombreAstral(showDice = SHOW_DICE) {
-    if (Misc.isUniqueConnectedGM()) {
-      console.log("rebuildListeNombreAstral", showDice);
-      let jourCourant = this.getCurrentDayIndex();
-      let newList = [];
-      for (let i = 0; i < MAX_NOMBRE_ASTRAL; i++) {
-        let dayIndex = jourCourant + i;
-        let na = this.listeNombreAstral.find(n => n.index == dayIndex);
-        if (na) {
-          newList[i] = na;
-        } else {
-          newList[i] = await this.ajouterNombreAstral(dayIndex, showDice);
-        }
-      }
-      //console.log("SAVE list", newList, jourCourant);
-      this.listeNombreAstral = newList;
-      game.settings.set(SYSTEM_RDD, "liste-nombre-astral", this.listeNombreAstral);
-    }
-  }
-
-  /* -------------------------------------------- */
-  async onCalendarButton(ev) {
-    ev.preventDefault();
-    const calendarAvance = ev.currentTarget.attributes['data-calendar-avance'];
-    const calendarSet = ev.currentTarget.attributes['data-calendar-set'];
-    if (calendarAvance) {
-      await this.incrementTime(Number(calendarAvance.value));
-    }
-    else if (calendarSet) {
-      this.positionnerHeure(Number(calendarSet.value));
-    }
-    this.updateDisplay();
-  }
-
-  /* -------------------------------------------- */
-  checkMaladie( periode) {
-    for (let actor of game.actors) {
-      if (actor.type == 'personnage') {
-        let maladies = actor.items.filter( item => (item.type == 'maladie' || (item.type == 'poison' && item.system.active) ) && item.system.periodicite.toLowerCase().includes(periode) );
-        for (let maladie of maladies) {
-          if ( maladie.system.identifie) {
-            ChatMessage.create({ content: `${actor.name} souffre de ${maladie.name} (${maladie.type}): vérifiez que les effets ne se sont pas aggravés !` });
-          } else {
-            ChatMessage.create({ content: `${actor.name} souffre d'un mal inconnu (${maladie.type}): vérifiez que les effets ne se sont pas aggravés !` });
-          }
-          let itemMaladie = actor.getObjet(maladie.id)
-          itemMaladie.postItem( 'gmroll');
-        }
-      }
-    }    
-  }
-
-  /* -------------------------------------------- */
-  async incrementTime(minutes = 0) {
-    this.calendrier.minutesRelative += minutes;
-    this.checkMaladie("round");
-    this.checkMaladie("minute");
-    if (this.calendrier.minutesRelative >= RDD_MINUTES_PAR_HEURES) {
-      this.calendrier.minutesRelative -= RDD_MINUTES_PAR_HEURES;
-      this.calendrier.heureRdD += 1;
-      this.checkMaladie("heure");
-      }
-    if (this.calendrier.heureRdD >= RDD_HEURES_PAR_JOUR) {
-      this.calendrier.heureRdD -= RDD_HEURES_PAR_JOUR;
-      await this.incrementerJour();
-      this.checkMaladie("heure");
-      this.checkMaladie("jour");
-    }
-    game.settings.set(SYSTEM_RDD, "calendrier", duplicate(this.calendrier));
-    // Notification aux joueurs // TODO: replace with Hook on game settings update
-    game.socket.emit(SYSTEM_SOCKET_ID, {
-      msg: "msg_sync_time",
-      data: duplicate(this.calendrier)
-    });
-  }
-
-  /* -------------------------------------------- */
-  async incrementerJour() {
-    const index = this.getCurrentDayIndex() + 1;
-    this.calendrier = this.getCalendrier(index);
-    await this.rebuildListeNombreAstral();
-  }
-
-  /* -------------------------------------------- */
-  syncPlayerTime(calendrier) {
-    this.calendrier = duplicate(calendrier); // Local copy update
-    this.updateDisplay();
-  }
-
-  /* -------------------------------------------- */
-  async positionnerHeure(indexHeure) {
-    if (indexHeure <= this.calendrier.heureRdD) {
-      await this.incrementerJour();
-    }
-    this.calendrier.heureRdD = indexHeure;
-    this.calendrier.minutesRelative = 0;
-    game.settings.set(SYSTEM_RDD, "calendrier", duplicate(this.calendrier));
-  }
-
-  /* -------------------------------------------- */
-  fillCalendrierData(formData = {}) {
-    const mois = RdDCalendrier.getDefSigne(this.calendrier.moisRdD);
-    const heure = RdDCalendrier.getDefSigne(this.calendrier.heureRdD);
-    console.log('fillCalendrierData', this.calendrier, mois, heure);
-
-    formData.heureKey = heure.key;
-    formData.moisKey = mois.key;
-    formData.jourMois = this.calendrier.jour + 1;
-    formData.nomMois = mois.label; // heures et mois nommés identiques
-    formData.iconMois = dossierIconesHeures + mois.icon;
-    formData.nomHeure = heure.label;
-    formData.iconHeure = dossierIconesHeures + heure.icon;
-    formData.nomSaison = saisonsDef[mois.saison].label;
-    formData.heureRdD = this.calendrier.heureRdD;
-    formData.minutesRelative = this.calendrier.minutesRelative;
-    formData.isGM = game.user.isGM;
-    return formData;
-  }
-
-  /* -------------------------------------------- */
-  getLectureAstrologieDifficulte(dateIndex) {
-    let indexNow = this.getCurrentDayIndex();
-    let diffDay = dateIndex - indexNow;
-    return - Math.floor(diffDay / 2);
-  }
-
-  /* -------------------------------------------- */
-  async requestNombreAstral(request) {
-    if (Misc.isUniqueConnectedGM()) { // Only once
-      console.log(request);
-      let jourDiff = this.getLectureAstrologieDifficulte(request.date);
-      let niveau = Number(request.astrologie.system.niveau) + Number(request.conditions) + Number(jourDiff) + Number(request.etat);
-      let rollData = {
-        caracValue: request.carac_vue,
-        finalLevel: niveau,
-        showDice: HIDE_DICE,
-        rollMode: "blindroll"
-      };
-      await RdDResolutionTable.rollData(rollData);
-      let nbAstral = this.getNombreAstral(request.date);
-      request.rolled = rollData.rolled;
-      request.isValid = true;
-      if (!request.rolled.isSuccess) {
-        request.isValid = false;
-        nbAstral = await RdDDice.rollTotal("1dhr" + nbAstral, { rollMode: "selfroll" });
-        // Mise à jour des nombres astraux du joueur
-        let astralData = this.listeNombreAstral.find((nombreAstral, i) => nombreAstral.index == request.date);
-        astralData.valeursFausses.push({ actorId: request.id, nombreAstral: nbAstral });
-        game.settings.set(SYSTEM_RDD, "liste-nombre-astral", this.listeNombreAstral);
-      }
-      request.nbAstral = nbAstral;
-      if (Misc.getActiveUser(request.userId)?.isGM) {
-        RdDUtility.responseNombreAstral(request);
-      } else {
-        game.socket.emit(SYSTEM_SOCKET_ID, {
-          msg: "msg_response_nombre_astral",
-          data: request
-        });
-      }
-    }
-  }
-
-  /* -------------------------------------------- */
-  findHeure(heure) {
-    heure = Grammar.toLowerCaseNoAccentNoSpace(heure);
-    let parHeureOuLabel = Object.values(heuresDef).filter(it => (it.heure + 1) == parseInt(heure) || Grammar.toLowerCaseNoAccentNoSpace(it.label) == heure);
-    if (parHeureOuLabel.length == 1) {
-      return parHeureOuLabel[0];
-    }
-    let parLabelPartiel = Object.values(heuresDef).filter(it => Grammar.toLowerCaseNoAccentNoSpace(it.label).includes(heure));
-    if (parLabelPartiel.length > 0) {
-      parLabelPartiel.sort(Misc.ascending(h => h.label.length));
-      return parLabelPartiel[0];
-    }
-    return undefined;
-  }
-  /* -------------------------------------------- */
-  getHeureNumber( hNum) {
-    let heure = Object.values(heuresDef).find(it => (it.heure) == hNum);
-    return heure
-  }
-
-  /* -------------------------------------------- */
-  getHeuresChanceMalchance(heureNaissance) {
-    let heuresChancesMalchances = [];
-    let defHeure = this.findHeure(heureNaissance);
-    if (defHeure) {
-      let hn = defHeure.heure;
-      let chiffreAstral = this.getCurrentNombreAstral() ?? 0;
-      heuresChancesMalchances[0] = { value : "+4", heures: [this.getHeureNumber((hn + chiffreAstral) % RDD_HEURES_PAR_JOUR).label]};
-      heuresChancesMalchances[1] = { value : "+2", heures: [this.getHeureNumber((hn + chiffreAstral+4) % RDD_HEURES_PAR_JOUR).label, 
-        this.getHeureNumber((hn + chiffreAstral + 8) % RDD_HEURES_PAR_JOUR).label ] };
-      heuresChancesMalchances[2] = { value : "-4", heures: [this.getHeureNumber((hn + chiffreAstral+6) % RDD_HEURES_PAR_JOUR).label]};
-      heuresChancesMalchances[3] = { value : "-2", heures: [this.getHeureNumber((hn + chiffreAstral+3) % RDD_HEURES_PAR_JOUR).label, 
-          this.getHeureNumber((hn + chiffreAstral + 9) % RDD_HEURES_PAR_JOUR).label ]};
-    }
-    return heuresChancesMalchances;
-  }
-
-  /* -------------------------------------------- */
-  getAjustementAstrologique(heureNaissance, name = undefined) {
-    let defHeure = this.findHeure(heureNaissance);
-    if (defHeure) {
-      let hn = defHeure.heure;
-      let chiffreAstral = this.getCurrentNombreAstral() ?? 0;
-      let heureCourante = this.calendrier.heureRdD;
-      let ecartChance = (hn + chiffreAstral - heureCourante) % RDD_HEURES_PAR_JOUR;
-      switch (ecartChance) {
-        case 0: return 4;
-        case 4: case 8: return 2;
-        case 6: return -4;
-        case 3: case 9: return -2;
-      }
-    }
-    else if (name) {
-      ui.notifications.warn(name + " n'a pas d'heure de naissance, ou elle est incorrecte : " + heureNaissance);
-    }
-    else {
-      ui.notifications.warn(heureNaissance + " ne correspond pas à une heure de naissance");
-    }
-    return 0;
-  }
-
-  /* -------------------------------------------- */
-  getData() {
-    let formData = super.getData();
-
-    this.fillCalendrierData(formData);
-
-    this.setPos(this.calendrierPos);
-    return formData;
-  }
-
-  /* -------------------------------------------- */
-  setPos(pos) {
-    return new Promise(resolve => {
-      function check() {
-        let elmnt = document.getElementById("calendar-time-container");
-        if (elmnt) {
-          elmnt.style.bottom = undefined;
-          let xPos = (pos.left) > window.innerWidth ? window.innerWidth - 200 : pos.left;
-          let yPos = (pos.top) > window.innerHeight - 20 ? window.innerHeight - 100 : pos.top;
-          elmnt.style.top = (yPos) + "px";
-          elmnt.style.left = (xPos) + "px";
-          resolve();
-        } else {
-          setTimeout(check, 30);
-        }
-      }
-      check();
-    });
-  }
-
-  /* -------------------------------------------- */
-  updateDisplay() {
-    let calendrier = this.fillCalendrierData();
-    // Rebuild text du calendrier
-    let dateHTML = `Jour ${calendrier.jourMois} de ${calendrier.nomMois} (${calendrier.nomSaison})`
-    if (game.user.isGM) {
-      dateHTML = dateHTML + " - NA: " + (this.getCurrentNombreAstral() ?? "indéterminé");
-    }
-    for (let handle of document.getElementsByClassName("calendar-date-rdd")) {
-      handle.innerHTML = dateHTML;
-    }
-    for (let heure of document.getElementsByClassName("calendar-heure-texte")) {
-      heure.innerHTML = calendrier.nomHeure;
-    }
-    for (const minute of document.getElementsByClassName("calendar-time-disp")) {
-      minute.innerHTML = `${calendrier.minutesRelative} minutes`;
-    }
-    for (const heureImg of document.getElementsByClassName("calendar-heure-img")) {
-      heureImg.src = calendrier.iconHeure;
-    }
-  }
-
-  /* -------------------------------------------- */
-  async saveEditeur(calendrierData) {
-    this.calendrier.minutesRelative = Number(calendrierData.minutesRelative);
-    this.calendrier.jour = Number(calendrierData.jourMois) - 1;
-    this.calendrier.moisRdD = RdDCalendrier.getChiffreFromSigne(calendrierData.moisKey);
-    this.calendrier.heureRdD = RdDCalendrier.getChiffreFromSigne(calendrierData.heureKey);
-    game.settings.set(SYSTEM_RDD, "calendrier", duplicate(this.calendrier));
-
-    await this.rebuildListeNombreAstral();
-
-    game.socket.emit(SYSTEM_SOCKET_ID, {
-      msg: "msg_sync_time",
-      data: duplicate(this.calendrier)
-    });
-
-    this.updateDisplay();
-  }
-
-  /* -------------------------------------------- */
-  async showCalendarEditor() {
-    let calendrierData = duplicate(this.fillCalendrierData());
-    if (this.editeur == undefined) {
-      calendrierData.jourMoisOptions = RdDCalendrier.buildJoursMois();
-      calendrierData.heuresOptions = [0, 1];
-      calendrierData.minutesOptions = Array(RDD_MINUTES_PAR_HEURES).fill().map((item, index) => 0 + index);
-      let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/calendar-editor-template.html', calendrierData);
-      this.editeur = new RdDCalendrierEditeur(html, this, calendrierData)
-    }
-    this.editeur.updateData(calendrierData);
-    this.editeur.render(true);
-  }
-
-  static buildJoursMois() {
-    return Array(RDD_JOUR_PAR_MOIS).fill().map((item, index) => 1 + index);
-  }
-
-  /* -------------------------------------------- */
-  async showAstrologieEditor() {
-    let calendrierData = duplicate(this.fillCalendrierData());
-    let astrologieArray = [];
-    this.listeNombreAstral = this.listeNombreAstral || [];
-    for (let astralData of this.listeNombreAstral) {
-      astralData.humanDate = this.getDateFromIndex(astralData.index);
-      for (let vf of astralData.valeursFausses) {
-        let actor = game.actors.get(vf.actorId);
-        vf.actorName = (actor) ? actor.name : "Inconnu";
-      }
-      astrologieArray.push(duplicate(astralData));
-    }
-    let heuresParActeur = {};
-    for (let actor of game.actors) {
-      let heureNaissance = actor.getHeureNaissance();
-      if ( heureNaissance) {
-        heuresParActeur[actor.name] = this.getHeuresChanceMalchance(heureNaissance);
-      }      
-    }
-    //console.log("ASTRO", astrologieArray);
-    calendrierData.astrologieData = astrologieArray;
-    calendrierData.heuresParActeur = heuresParActeur;
-    let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/calendar-astrologie-template.html', calendrierData);
-    let astrologieEditeur = new RdDAstrologieEditeur(html, this, calendrierData)
-    astrologieEditeur.updateData(calendrierData);
-    astrologieEditeur.render(true);
-  }
-
   /* -------------------------------------------- */
   /** @override */
   async activateListeners(html) {
     super.activateListeners(html);
+    this.html = html;
 
     this.updateDisplay();
 
-    html.find('.ajout-chronologie').click(ev => DialogChronologie.create());
+    this.html.find('.ajout-chronologie').click(ev => DialogChronologie.create());
 
-    html.find('.calendar-btn').click(ev => this.onCalendarButton(ev));
+    this.html.find('.calendar-btn').click(ev => this.onCalendarButton(ev));
 
-    html.find('.calendar-btn-edit').click(ev => {
+    this.html.find('.calendar-btn-edit').click(ev => {
       ev.preventDefault();
       this.showCalendarEditor();
     });
 
-    html.find('.astrologie-btn-edit').click(ev => {
+    this.html.find('.astrologie-btn-edit').click(ev => {
       ev.preventDefault();
       this.showAstrologieEditor();
     });
 
-    html.find('#calendar-move-handle').mousedown(ev => {
+    this.html.find('#calendar-move-handle').mousedown(ev => {
       ev.preventDefault();
       ev = ev || window.event;
       let isRightMB = false;
@@ -646,5 +147,359 @@ export class RdDCalendrier extends Application {
       }
     });
   }
+  /* -------------------------------------------- */
+  getListeNombreAstral() {
+    return game.settings.get(SYSTEM_RDD, "liste-nombre-astral") ?? [];
+  }
 
+  /* -------------------------------------------- */
+  dateCourante() {
+    return this.timestamp.formatDate();
+  }
+
+  isAfterIndexDate(indexDate) {
+    // TODO: standardize
+    return indexDate < this.timestamp.indexDate;
+  }
+
+  /* -------------------------------------------- */
+  heureCourante() { return RdDTimestamp.definition(this.timestamp.heure); }
+
+  /* -------------------------------------------- */
+  getCurrentMinute() { return this.timestamp.indexMinute; }
+
+  getTimestampFinChateauDormant(nbJours = 0) {
+    return this.timestamp.nouveauJour().addJour(nbJours);
+  }
+
+  getTimestampFinHeure(nbHeures = 0) {
+    return this.timestamp.nouvelleHeure().addHeures(nbHeures);
+  }
+
+  /* -------------------------------------------- */
+  getIndexFromDate(jour, mois) {
+    const addYear = mois < this.timestamp.mois || (mois == this.timestamp.mois && jour < this.timestamp.jour)
+    const time = RdDTimestamp.timestamp(this.timestamp.annee + (addYear ? 1 : 0), mois, jour);
+    return time.indexDate;
+  }
+
+  /* -------------------------------------------- */
+  getJoursSuivants(count) {
+    let jours = [];
+    let indexDate = this.timestamp.indexDate;
+    for (let i = 0; i < count; i++, indexDate++) {
+      jours[i] = { label: RdDTimestamp.formatIndexDate(indexDate), index: indexDate };
+    }
+    return jours;
+  }
+
+  /* -------------------------------------------- */
+  async ajouterNombreAstral(indexDate, showDice = SHOW_DICE) {
+    const nombreAstral = await RdDDice.rollTotal("1dh", { showDice: showDice, rollMode: "selfroll" });
+    const dateFuture = RdDTimestamp.formatIndexDate(indexDate);
+    if (showDice != HIDE_DICE) {
+      ChatMessage.create({
+        whisper: ChatMessage.getWhisperRecipients("GM"),
+        content: `Le chiffre astrologique du ${dateFuture} sera le ${nombreAstral}`
+      });
+    }
+    return {
+      nombreAstral: nombreAstral,
+      valeursFausses: [],
+      index: indexDate
+    }
+  }
+
+  /* -------------------------------------------- */
+  resetNombreAstral() {
+    this.listeNombreAstral = [];
+    game.settings.set(SYSTEM_RDD, "liste-nombre-astral", []);
+
+    game.socket.emit(SYSTEM_SOCKET_ID, {
+      msg: "msg_reset_nombre_astral",
+      data: {}
+    });
+  }
+
+  /* -------------------------------------------- */
+  /**
+   * 
+   * @param {*} indexDate la date pour laquelle obtenir le nombre astral. Si undefined, on prend la date du jour
+   * @returns le nombre astral pour la date, ou pour la date du jour si la date n'est pas fournie.
+   *  Si aucun nombre astral n'est trouvé, retourne 0 (cas où l'on demanderait un nombre astral en dehors des 12 jours courant et à venir)
+   */
+  getNombreAstral(indexDate = undefined) {
+    if (indexDate == undefined) {
+      indexDate = this.timestamp.indexDate;
+    }
+    const listNombreAstral = this.getListeNombreAstral();
+    let astralData = listNombreAstral.find((nombreAstral, i) => nombreAstral.index == indexDate);
+    return astralData?.nombreAstral ?? 0;
+  }
+
+  /* -------------------------------------------- */
+  async rebuildListeNombreAstral(showDice = HIDE_DICE) {
+    if (Misc.isUniqueConnectedGM()) {
+      let newList = [];
+      for (let i = 0; i < MAX_NOMBRE_ASTRAL; i++) {
+        let dayIndex = this.timestamp.indexDate + i;
+        let na = this.listeNombreAstral.find(n => n.index == dayIndex);
+        if (na) {
+          newList[i] = na;
+        } else {
+          newList[i] = await this.ajouterNombreAstral(dayIndex, showDice);
+        }
+      }
+      this.listeNombreAstral = newList;
+      game.settings.set(SYSTEM_RDD, "liste-nombre-astral", newList);
+    }
+  }
+
+  /* -------------------------------------------- */
+  async setNewTimestamp(newTimestamp) {
+    game.actors.forEach(actor => actor.onTimeChanging(this.timestamp, newTimestamp));
+    RdDTimestamp.setWorldTime(newTimestamp);
+    this.timestamp = newTimestamp;
+    await this.rebuildListeNombreAstral();
+    this.updateDisplay();
+  }
+
+  /* -------------------------------------------- */
+  async onCalendarButton(ev) {
+    ev.preventDefault();
+    const calendarAvance = ev.currentTarget.attributes['data-calendar-avance'];
+    const calendarSet = ev.currentTarget.attributes['data-calendar-set'];
+    if (calendarAvance) {
+      await this.incrementTime(Number(calendarAvance.value));
+    }
+    else if (calendarSet) {
+      this.positionnerHeure(Number(calendarSet.value));
+    }
+    this.updateDisplay();
+  }
+
+  /* -------------------------------------------- */
+  async incrementTime(minutes = 0) {
+    await this.setNewTimestamp(this.timestamp.addMinutes(minutes));
+  }
+
+  /* -------------------------------------------- */
+  async incrementerJour() {
+    await this.setNewTimestamp(this.timestamp.nouveauJour());
+  }
+
+  /* -------------------------------------------- */
+  async positionnerHeure(heure) {
+    const indexDate = this.timestamp.indexDate;
+    const addDay = this.timestamp.heure < heure ? 0 : 1;
+    await this.setNewTimestamp(new RdDTimestamp({
+      indexDate: indexDate + addDay, indexHeure: 0
+    })
+      .addHeures(heure))
+  }
+
+  /* -------------------------------------------- */
+  fillCalendrierData(formData = {}) {
+    mergeObject(formData, this.timestamp.toCalendrier());
+    formData.isGM = game.user.isGM;
+    return formData;
+  }
+
+  /* -------------------------------------------- */
+  getLectureAstrologieDifficulte(dateIndex) {
+    let indexNow = this.timestamp.indexDate;
+    let diffDay = dateIndex - indexNow;
+    return - Math.floor(diffDay / 2);
+  }
+
+  /* -------------------------------------------- */
+  async requestNombreAstral(request) {
+    const actor = game.actors.get(request.id);
+    if (Misc.isUniqueConnectedGM()) { // Only once
+      console.log(request);
+      let jourDiff = this.getLectureAstrologieDifficulte(request.date);
+      let niveau = Number(request.astrologie.system.niveau) + Number(request.conditions) + Number(jourDiff) + Number(request.etat);
+      let rollData = {
+        caracValue: request.carac_vue,
+        finalLevel: niveau,
+        showDice: HIDE_DICE,
+        rollMode: "blindroll"
+      };
+      await RdDResolutionTable.rollData(rollData);
+      request.rolled = rollData.rolled;
+      request.isValid = request.rolled.isSuccess;
+      request.nbAstral = this.getNombreAstral(request.date);
+
+      if (request.rolled.isSuccess) {
+        if (request.rolled.isPart) {
+          // Gestion expérience (si existante)
+          request.competence = actor.getCompetence("astrologie")
+          request.selectedCarac = actor.system.carac["vue"];
+          actor.appliquerAjoutExperience(request, 'hide');
+        }
+      }
+      else {
+        request.nbAstral = await RdDDice.rollTotal("1dhr" + request.nbAstral, {
+          rollMode: "selfroll", showDice: HIDE_DICE
+        });
+        // Mise à jour des nombres astraux du joueur
+        this.addNbAstralIncorect(request.id, request.date, request.nbAstral);
+      }
+
+      if (Misc.getActiveUser(request.userId)?.isGM) {
+        RdDUtility.responseNombreAstral(request);
+      } else {
+        game.socket.emit(SYSTEM_SOCKET_ID, {
+          msg: "msg_response_nombre_astral",
+          data: request
+        });
+      }
+    }
+  }
+
+  addNbAstralIncorect(actorId, date, nbAstral) {
+    let astralData = this.listeNombreAstral.find((nombreAstral, i) => nombreAstral.index == date);
+    astralData.valeursFausses.push({ actorId: actorId, nombreAstral: nbAstral });
+    game.settings.set(SYSTEM_RDD, "liste-nombre-astral", this.listeNombreAstral);
+  }
+
+  static ecartHeureChance(heureNaissance, nombreAstral, heure) {
+    return (heureNaissance + nombreAstral - heure) % RDD_HEURES_PAR_JOUR;
+  }
+
+  /* -------------------------------------------- */
+  getAjustementAstrologique(heureNaissance, name = undefined) {
+    let defHeure = RdDTimestamp.findHeure(heureNaissance);
+    if (defHeure) {
+      return RdDCalendrier.ajustementAstrologiqueHeure(defHeure.heure, this.getNombreAstral(), this.timestamp.heure);
+    }
+    else if (name) {
+      ui.notifications.warn(name + " n'a pas d'heure de naissance, ou elle est incorrecte : " + heureNaissance);
+    }
+    else {
+      ui.notifications.warn(heureNaissance + " ne correspond pas à une heure de naissance");
+    }
+    return 0;
+  }
+
+  static ajustementAstrologiqueHeure(hn, nbAstral, heure) {
+    switch (RdDCalendrier.ecartHeureChance(hn, nbAstral, heure)) {
+      case 0: return 4;
+      case 4: case 8: return 2;
+      case 6: return -4;
+      case 3: case 9: return -2;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getData() {
+    let formData = super.getData();
+    this.fillCalendrierData(formData);
+    this.setPos(this.calendrierPos);
+    return formData;
+  }
+
+  /* -------------------------------------------- */
+  setPos(pos) {
+    return new Promise(resolve => {
+      function check() {
+        let elmnt = document.getElementById("calendar-time-container");
+        if (elmnt) {
+          elmnt.style.bottom = undefined;
+          let xPos = (pos.left) > window.innerWidth ? window.innerWidth - 200 : pos.left;
+          let yPos = (pos.top) > window.innerHeight - 20 ? window.innerHeight - 100 : pos.top;
+          elmnt.style.top = (yPos) + "px";
+          elmnt.style.left = (xPos) + "px";
+          resolve();
+        } else {
+          setTimeout(check, 30);
+        }
+      }
+      check();
+    });
+  }
+
+  /* -------------------------------------------- */
+  updateDisplay() {
+    let calendrier = this.fillCalendrierData();
+    // Rebuild text du calendrier
+    let dateHTML = `${calendrier.jourDuMois} ${calendrier.mois.label} (${calendrier.mois.saison}) de l'année ${calendrier.annee}`
+    if (game.user.isGM) {
+      dateHTML = dateHTML + "<br>Nombre Astral: " + (this.getNombreAstral() ?? "?");
+    }
+    for (let handle of document.getElementsByClassName("calendar-date-rdd")) {
+      handle.innerHTML = dateHTML;
+    }
+    for (let heure of document.getElementsByClassName("calendar-heure-texte")) {
+      heure.innerHTML = calendrier.heure.label;
+    }
+    for (const minute of document.getElementsByClassName("calendar-time-disp")) {
+      minute.innerHTML = `${calendrier.minute} minutes`;
+    }
+    for (const heureImg of document.getElementsByClassName("calendar-heure-img")) {
+      heureImg.src = calendrier.heure.icon;
+    }
+  }
+
+  /* -------------------------------------------- */
+  async saveEditeur(calendrierData) {
+    const newTimestamp = RdDTimestamp.timestamp(
+      Number.parseInt(calendrierData.annee),
+      calendrierData.mois.heure,
+      Number.parseInt(calendrierData.jourMois),
+      calendrierData.heure.heure,
+      Number.parseInt(calendrierData.minutes)
+    );
+    await this.setNewTimestamp(newTimestamp);
+  }
+
+  /* -------------------------------------------- */
+  async showCalendarEditor() {
+    let calendrierData = this.fillCalendrierData();
+    if (this.editeur == undefined) {
+      let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/calendar-editor-template.html', calendrierData);
+      this.editeur = new RdDCalendrierEditeur(html, this, calendrierData)
+    }
+    this.editeur.updateData(calendrierData);
+    this.editeur.render(true);
+  }
+
+  static buildJoursMois() { return JOURS_DU_MOIS; }
+
+  /* -------------------------------------------- */
+  async showAstrologieEditor() {
+    const calendrierData = duplicate(this.fillCalendrierData());
+    this.listeNombreAstral = this.listeNombreAstral || [];
+
+    calendrierData.astrologieData = this.listeNombreAstral.map(astro => {
+      const timestamp = new RdDTimestamp({ indexDate: astro.index });
+      astro.date = { mois: timestamp.mois, jour: timestamp.jour + 1 }
+      for (let vf of astro.valeursFausses) {
+        let actor = game.actors.get(vf.actorId);
+        vf.actorName = (actor) ? actor.name : "Inconnu";
+      }
+      return astro;
+    });
+
+    const nbAstral = this.getNombreAstral()
+    calendrierData.heures = Array.from(Array(RDD_HEURES_PAR_JOUR).keys());
+    calendrierData.ajustementsActeur = game.actors.filter(it => it.isPersonnage() && it.hasPlayerOwner).map(actor => {
+      return {
+        actor,
+        ajustements: calendrierData.heures.map(heure => {
+          const hn = RdDTimestamp.findHeure(actor.getHeureNaissance())?.heure;
+          return {
+            heure,
+            ajustement: RdDCalendrier.ajustementAstrologiqueHeure(hn, nbAstral, heure)
+          }
+        })
+      }
+    });
+
+    let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/calendar-astrologie-template.html', calendrierData);
+    let astrologieEditeur = new RdDAstrologieEditeur(html, this, calendrierData)
+    astrologieEditeur.updateData(calendrierData);
+    astrologieEditeur.render(true);
+  }
 }

module/rdd-carac.js

@@ -39,9 +39,10 @@ const tableCaracDerivee = {
 
 export class RdDCarac {
 
-  static isAgiliteOuDerivee(selectedCarac) {
+  static isAgiliteOuDerobee(selectedCarac) {
     return selectedCarac?.label.match(/(Agilité|Dérobée)/);
   }
+
   static isVolonte(selectedCarac) {
     return selectedCarac?.label == 'Volonté';
   }
@@ -52,6 +53,11 @@ export class RdDCarac {
     return selectedCarac?.label?.toLowerCase()?.match(/r(e|ê)ve(( |-)actuel)?/);
   }
 
+  static isActionPhysique(selectedCarac) {
+    return !selectedCarac ||
+      selectedCarac?.label.match(/(Apparence|Force|Agilité|Dextérité|Vue|Ouïe|Odorat-Goût|Empathie|Dérobée|Mêlée|Tir|Lancer)/);
+  }
+
   static isIgnoreEtatGeneral(rollData) {
     const selectedCarac = rollData.selectedCarac;
     return !selectedCarac ||

module/rdd-combat.js

@@ -1,5 +1,5 @@
 import { ChatUtility } from "./chat-utility.js";
-import { ENTITE_BLURETTE, ENTITE_INCARNE, ENTITE_NONINCARNE, HIDE_DICE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
+import { ENTITE_BLURETTE, 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";
@@ -11,6 +11,7 @@ import { RdDRoll } from "./rdd-roll.js";
 import { RdDRollTables } from "./rdd-rolltables.js";
 import { ReglesOptionelles } from "./settings/regles-optionelles.js";
 import { STATUSES } from "./settings/status-effects.js";
+import { Targets } from "./targets.js";
 
 /* -------------------------------------------- */
 const premierRoundInit = [
@@ -82,7 +83,6 @@ export class RdDCombatManager extends Combat {
     console.log(`${game.system.title} | Combat.rollInitiative()`, ids, formula, messageOptions);
 
     ids = typeof ids === "string" ? [ids] : ids;
-    const currentId = this.combatant._id;
     // calculate initiative
     for (let cId = 0; cId < ids.length; cId++) {
       const combatant = this.combatants.get(ids[cId]);
@@ -101,19 +101,19 @@ export class RdDCombatManager extends Combat {
             const carac = combatant.actor.system.carac[competence.system.defaut_carac].value;
             const niveau = competence.system.niveau;
             const bonusEcaille = (armeCombat?.system.magique) ? armeCombat.system.ecaille_efficacite : 0;
-            rollFormula = RdDCombatManager.formuleInitiative(2,  carac, niveau, bonusEcaille);
+            rollFormula = RdDCombatManager.formuleInitiative(2, carac, niveau, bonusEcaille);
           }
         }
       }
       //console.log("Combatat", c);
       const roll = combatant.getInitiativeRoll(rollFormula);
-      if ( !roll.total) {
-        roll.evaluate( {async: false});
+      if (!roll.total) {
+        roll.evaluate({ async: false });
       }
-      if (roll.total <= 0) roll.total = 0.00;
-      console.log("Compute init for", rollFormula, roll.total, combatant);
+      const total = Math.max(roll.total, 0.00);
+      console.log("Compute init for", rollFormula, roll, total, combatant);
       let id = combatant._id || combatant.id;
-      await this.updateEmbeddedDocuments("Combatant", [{ _id: id, initiative: roll.total }]);
+      await this.updateEmbeddedDocuments("Combatant", [{ _id: id, initiative: total }]);
 
       // Send a chat message
       let rollMode = messageOptions.rollMode || game.settings.get("core", "rollMode");
@@ -151,81 +151,102 @@ export class RdDCombatManager extends Combat {
   }
 
   /* -------------------------------------------- */
-  /** Retourne une liste triée d'actions d'armes avec le split arme1 main / arme 2 main */
+  /** Retourne une liste triée d'actions d'armes avec le split arme1 main / arme 2 main / lancer */
   static listActionsArmes(armes, competences, carac) {
-    // Gestion des armes 1/2 mains
-    let actionsArme = [];
+    let actions = [];
     for (const arme of armes) {
-      let action = duplicate(arme)
-      if (action.system.equipe) {
-        let compData = competences.find(c => c.name == action.system.competence)
-
-        actionsArme.push(action);
-        action.action = 'attaque';
-        action.system.dommagesReels = Number(action.system.dommages);
-        action.system.niveau = compData.system.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 (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 = action.system.competence.replace(" 1 main", " 2 mains"); // Replace !
-          const comp = competences.find(c => c.name == comp2m)
-
-          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 = 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 " + action.name + " ne sont pas corrects (ie sous la forme X/Y)");
-          }
+      if (arme.system.equipe) {
+        const dommages = arme.system.dommages.toString();
+        const tableauDommages = dommages.includes("/") ? dommages.split("/") : [dommages, dommages];
+        if (arme.system.unemain && arme.system.deuxmains && !dommages.includes("/")) {
+          ui.notifications.info("Les dommages de l'arme à 1/2 mains " + arme.name + " ne sont pas corrects (ie sous la forme X/Y)");
+        }
+        if ((arme.system.unemain && arme.system.competence) ||
+          (arme.system.competence.toLowerCase().includes("corps à corps"))) {
+          actions.push(RdDCombatManager.$prepareAttaqueArme({
+            arme: arme,
+            infoMain: "(1 main)",
+            dommagesReel: Number(tableauDommages[0]),
+            competence: arme.system.competence,
+            carac: carac,
+            competences: competences
+          }));
+        }
+        if (arme.system.deuxmains && arme.system.competence) {
+          actions.push(RdDCombatManager.$prepareAttaqueArme({
+            arme: arme,
+            infoMain: "(2 mains)",
+            dommagesReel: Number(tableauDommages[1]),
+            competence: arme.system.competence.replace(" 1 main", " 2 mains"),
+            carac: carac,
+            competences: competences
+          }));
+        }
+        if (arme.system.lancer) {
+          actions.push(RdDCombatManager.$prepareAttaqueArme({
+            arme: arme,
+            infoMain: "(lancer)",
+            dommagesReel: Number(tableauDommages[0]),
+            competence: arme.system.lancer,
+            carac: carac,
+            competences: competences
+          }));
+        }
+        if (arme.system.tir) {
+          actions.push(RdDCombatManager.$prepareAttaqueArme({
+            arme: arme,
+            infoMain: "(tir)",
+            dommagesReel: Number(tableauDommages[0]),
+            competence: arme.system.tir,
+            carac: carac,
+            competences: competences
+          }));
         }
       }
     }
-    return actionsArme.sort(Misc.ascending(armeData => armeData.name + (armeData.system.mainInfo ?? '')));
+    return actions.sort(Misc.ascending(action => action.name + (action.system.infoMain ?? '')));
+  }
+
+  static $prepareAttaqueArme(infoAttaque) {
+    const comp = infoAttaque.competences.find(c => c.name == infoAttaque.competence);
+    const attaque = duplicate(infoAttaque.arme);
+    attaque.action = 'attaque';
+    attaque.system.competence = infoAttaque.competence;
+    attaque.system.dommagesReels = infoAttaque.dommagesReel;
+    attaque.system.infoMain = infoAttaque.infoMain;
+    attaque.system.niveau = comp.system.niveau;
+    attaque.system.initiative = RdDCombatManager.calculInitiative(comp.system.niveau, infoAttaque.carac[comp.system.defaut_carac].value);
+    return attaque;
   }
 
   static listActionsCreature(competences) {
     return competences.filter(it => RdDItemCompetenceCreature.isCompetenceAttaque(it))
-      .map(it => RdDItemCompetenceCreature.toActionArme(it));
+      .map(it => RdDItemCompetenceCreature.armeNaturelle(it));
   }
 
   static listActionsPossessions(actor) {
-    return RdDCombatManager._indexActions(actor.getPossessions().map(p =>
-      {
-        return {
-          name: p.name,
-          action: 'conjurer',
-          system: {
-            competence: p.name,
-            possessionid: p.system.possessionid,
-          }
+    return RdDCombatManager._indexActions(actor.getPossessions().map(p => {
+      return {
+        name: p.name,
+        action: 'conjurer',
+        system: {
+          competence: p.name,
+          possessionid: p.system.possessionid,
         }
-      }));
+      }
+    }));
   }
 
   /* -------------------------------------------- */
   static listActionsCombat(combatant) {
     const actor = combatant.actor;
     let actions = RdDCombatManager.listActionsPossessions(actor);
-    if (actions.length>0) {
+    if (actions.length > 0) {
       return actions;
     }
-    if (actor.isCreature()) {
+    if (actor.isCreatureEntite()) {
       actions = actions.concat(RdDCombatManager.listActionsCreature(actor.itemTypes['competencecreature']));
-    } else {
+    } else if (actor.isPersonnage()) {
       // Recupération des items 'arme'
       const armes = actor.itemTypes['arme'].filter(it => RdDItemArme.isArmeUtilisable(it))
         //.concat(RdDItemArme.empoignade())
@@ -334,7 +355,7 @@ export class RdDCombatManager extends Combat {
       compData = RdDItemCompetence.findCompetence(combatant.actor.items, action.system.competence);
       compNiveau = compData.system.niveau;
       initInfo = action.name + " / " + action.system.competence;
-        
+
       if (combatant.actor.type == 'creature' || combatant.actor.type == 'entite') {
         caracForInit = compData.system.carac_value;
       } else {
@@ -362,7 +383,7 @@ export class RdDCombatManager extends Combat {
     switch (arme.system.cac) {
       case "empoignade":
         return 3;
-      case "pugilat": 
+      case "pugilat":
       case "naturelle":
         return 4;
     }
@@ -373,7 +394,7 @@ export class RdDCombatManager extends Combat {
   static displayInitiativeMenu(html, combatantId) {
     console.log("Combatant ; ", combatantId);
     const combatant = game.combat.combatants.get(combatantId);
-    if (! (combatant?.actor) ) {
+    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;
     }
@@ -448,49 +469,30 @@ export class RdDCombat {
   }
 
   /* -------------------------------------------- */
-  static createUsingTarget(attacker) {
-    const target = RdDCombat.getTarget()
-    if (target == undefined) {
-      ui.notifications.warn((game.user.targets?.size ?? 0) > 1
-        ? "Vous devez choisir <strong>une seule</strong> cible à attaquer!"
-        : "Vous devez choisir une cible à attaquer!");
-    }
-    else {
-      const defender = target?.actor;
-      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)
-      }
-    }
-  }
-
-  /* -------------------------------------------- */
-  static getTarget() {
-    if (game.user.targets && game.user.targets.size == 1) {
-      for (let target of game.user.targets) {
-        return target;
-      }
-    }
-    return undefined;
-  }
-
-  /* -------------------------------------------- */
-  static create(attacker, defender, defenderTokenId, target = undefined) {
+  static rddCombatTarget(target, attacker) {
+    const defender = target?.actor;
+    const defenderTokenId = target?.id;
     return new RdDCombat(attacker, defender, defenderTokenId, target)
   }
 
   /* -------------------------------------------- */
-  static createForAttackerAndDefender(attackerId, defenderTokenId) {
+  static rddCombatForAttackerAndDefender(attackerId, defenderTokenId) {
     const attacker = game.actors.get(attackerId);
-    if (defenderTokenId) {
-      const defenderToken = canvas.tokens.get(defenderTokenId);
-      const defender = defenderToken.actor;
-
-      return RdDCombat.create(attacker, defender, defenderTokenId);
+    let defender = defenderTokenId ? canvas.tokens.get(defenderTokenId)?.actor : undefined;
+    let target = undefined
+    if (!defenderTokenId || !defender) {
+      console.warn(`RdDCombat.rddCombatForAttackerAndDefender: appel avec defenderTokenId ${defenderTokenId} incorrect, ou pas de defender correspondant`);
+      target = Targets.getTarget()
+      if (!target) {
+        return;
+      }
+      defenderTokenId = target.id;
+      defender = target.actor;
+      if (!defenderTokenId || !defender) {
+        return;
+      }
     }
-    return RdDCombat.createUsingTarget(attacker)
+    return new RdDCombat(attacker, defender, defenderTokenId, target)
   }
 
   /* -------------------------------------------- */
@@ -501,7 +503,7 @@ export class RdDCombat {
       let attacker = msg.attackerId ? game.actors.get(msg.attackerId) : undefined;
 
       defender.encaisserDommages(attackerRoll, attacker);
-      const rddCombat = RdDCombat.createForAttackerAndDefender(msg.attackerId, msg.defenderTokenId);
+      const rddCombat = RdDCombat.rddCombatForAttackerAndDefender(msg.attackerId, msg.defenderTokenId);
       rddCombat?.removeChatMessageActionsPasseArme(attackerRoll.passeArme);
     }
   }
@@ -510,7 +512,7 @@ export class RdDCombat {
   static onMsgDefense(msg) {
     let defenderToken = canvas.tokens.get(msg.defenderTokenId);
     if (defenderToken && Misc.isUniqueConnectedGM()) {
-      const rddCombat = RdDCombat.createForAttackerAndDefender(msg.attackerId, msg.defenderTokenId);
+      const rddCombat = RdDCombat.rddCombatForAttackerAndDefender(msg.attackerId, msg.defenderTokenId);
       rddCombat?.removeChatMessageActionsPasseArme(msg.defenderRoll.passeArme);
       rddCombat?._chatMessageDefense(msg.paramChatDefense, msg.defenderRoll);
     }
@@ -537,11 +539,10 @@ export class RdDCombat {
       '#echec-total-attaque',
     ]) {
       html.on("click", button, event => {
-        const rddCombat = RdDCombat.createForAttackerAndDefender(
+        const rddCombat = RdDCombat.rddCombatForAttackerAndDefender(
           event.currentTarget.attributes['data-attackerId']?.value,
           event.currentTarget.attributes['data-defenderTokenId']?.value);
         if (rddCombat) {
-
           rddCombat.onEvent(button, event);
           event.preventDefault();
         }
@@ -568,7 +569,7 @@ export class RdDCombat {
   async onEvent(button, event) {
     const chatMessage = ChatUtility.getChatMessage(event);
     const defenderRoll = ChatUtility.getMessageData(chatMessage, 'defender-roll');
-    const attackerRoll = defenderRoll?.attackerRoll ?? ChatUtility.getMessageData(chatMessage, 'attacker-roll') ;
+    const attackerRoll = defenderRoll?.attackerRoll ?? ChatUtility.getMessageData(chatMessage, 'attacker-roll');
     console.log('RdDCombat', attackerRoll, defenderRoll);
     const defenderTokenId = event.currentTarget.attributes['data-defenderTokenId']?.value;
 
@@ -688,12 +689,13 @@ export class RdDCombat {
   }
 
   /* -------------------------------------------- */
-  async proposerAjustementTirLancer( rollData ) {
+  async proposerAjustementTirLancer(rollData) {
     if (['tir', 'lancer'].includes(rollData.competence.system.categorie)) {
-      if (this.defender.isEntite([ENTITE_BLURETTE])){
-        ChatMessage.create( {
+      if (this.defender.isEntite([ENTITE_BLURETTE])) {
+        ChatMessage.create({
           content: `<strong>La cible est une blurette, l'arme à distance sera perdue dans le blurêve`,
-          whisper: ChatMessage.getWhisperRecipients("GM")})
+          whisper: ChatMessage.getWhisperRecipients("GM")
+        })
       }
       else {
         const defenderToken = canvas.tokens.get(this.defenderTokenId);
@@ -702,7 +704,7 @@ export class RdDCombat {
         const portee = this._ajustementPortee(dist, rollData.arme)
         const taille = this._ajustementTaille(this.defender)
         const activite = this._ajustementMouvement(this.defender)
-        const total = [portee, taille, activite].map(it=>it.diff).filter(d => !Number.isNaN(d)).reduce(Misc.sum(), 0)
+        const total = [portee, taille, activite].map(it => it.diff).filter(d => !Number.isNaN(d)).reduce(Misc.sum(), 0)
         ChatMessage.create({
           content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-info-distance.html', {
             rollData: rollData,
@@ -724,32 +726,32 @@ export class RdDCombat {
   isVisible(token, defenderToken) {
     return canvas.effects.visibility.testVisibility(defenderToken.center, { object: token })
   }
-    
+
   distance(token, defenderToken) {
     return Number(canvas.grid.measureDistances([{ ray: new Ray(token.center, defenderToken.center) }], { gridSpaces: false })).toFixed(1);
   }
 
   _ajustementPortee(dist, arme) {
-    if (dist <= arme.system.portee_courte) return {msg:"courte", diff:0};
-    if (dist <= arme.system.portee_moyenne) return {msg: "moyenne" , diff: -3};
-    if (dist <= arme.system.portee_extreme) return {msg: "extrême", diff:-5};
-    return {msg: "inatteignable", diff: -10};
+    if (dist <= arme.system.portee_courte) return { msg: "courte", diff: 0 };
+    if (dist <= arme.system.portee_moyenne) return { msg: "moyenne", diff: -3 };
+    if (dist <= arme.system.portee_extreme) return { msg: "extrême", diff: -5 };
+    return { msg: "inatteignable", diff: -10 };
   }
 
   _ajustementTaille(actor) {
-    if (actor.isVehicule()) return {msg: "véhicule", diff: 0}
+    if (actor.isVehicule()) return { msg: "véhicule", diff: 0 }
     const taille = actor.getCaracByName('TAILLE')?.value ?? 1;
-    if (taille <= 1) return {msg: "souris", diff: -8};
-    if (taille <= 3) return {msg: "chat", diff: -4};
-    if (taille <= 5) return {msg: "chien", diff: -2};
-    if (taille <= 15) return {msg: "humanoïde", diff: 0};
-    if (taille <= 20) return {msg: "ogre", diff: 2};
-    return {msg: "gigantesque", diff: 4};
+    if (taille <= 1) return { msg: "souris", diff: -8 };
+    if (taille <= 3) return { msg: "chat", diff: -4 };
+    if (taille <= 5) return { msg: "chien", diff: -2 };
+    if (taille <= 15) return { msg: "humanoïde", diff: 0 };
+    if (taille <= 20) return { msg: "ogre", diff: 2 };
+    return { msg: "gigantesque", diff: 4 };
   }
   _ajustementMouvement(defender) {
-    if (defender.getSurprise(true)) return {msg: "immobile (surprise)", diff: 0};
-    if (game.combat?.combatants.find(it => it.actorId == defender.id)) return {msg: "en mouvement (combat)", diff: -4};
-    return {msg: "à déterminer (0 immobile, -3 actif, -4 en mouvement, -5 en zig-zag)", diff: -3};
+    if (defender.getSurprise(true)) return { msg: "immobile (surprise)", diff: 0 };
+    if (game.combat?.combatants.find(it => it.actorId == defender.id)) return { msg: "en mouvement (combat)", diff: -4 };
+    return { msg: "à déterminer (0 immobile, -3 actif, -4 en mouvement, -5 en zig-zag)", diff: -3 };
   }
 
   /* -------------------------------------------- */
@@ -763,7 +765,7 @@ export class RdDCombat {
     //     whisper: ChatMessage.getWhisperRecipients("GM")})
     // }
 
-    if (!await this.accorderEntite('avant-attaque')) {
+    if (!await this.attacker.accorder(this.defender, 'avant-attaque')) {
       return;
     }
     if (arme.system.cac == 'empoignade' && this.attacker.isCombatTouche()) {
@@ -786,23 +788,21 @@ export class RdDCombat {
     await this.proposerAjustementTirLancer(rollData)
 
     const dialog = await RdDRoll.create(this.attacker, rollData,
+      { html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-competence.html' },
       {
-        html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-competence.html',
-        options: { height: 540 }
-      }, {
-      name: 'jet-attaque',
-      label: 'Attaque: ' + (arme?.name ?? competence.name),
-      callbacks: [
-        this.attacker.createCallbackExperience(),
-        this.attacker.createCallbackAppelAuMoral(),
-        { action: r => this.removeChatMessageActionsPasseArme(r.passeArme) },
-        { condition: r => arme && !RdDCombat.isParticuliere(r), action: r => this.attacker.incDecItemUse(arme._id) },
-        { condition: r => (RdDCombat.isReussite(r) && !RdDCombat.isParticuliere(r)), action: r => this._onAttaqueNormale(r) },
-        { condition: RdDCombat.isParticuliere, action: r => this._onAttaqueParticuliere(r) },
-        { condition: RdDCombat.isEchec, action: r => this._onAttaqueEchec(r) },
-        { condition: RdDCombat.isEchecTotal, action: r => this._onAttaqueEchecTotal(r) },
-      ]
-    });
+        name: 'jet-attaque',
+        label: 'Attaque: ' + (arme?.name ?? competence.name),
+        callbacks: [
+          this.attacker.createCallbackExperience(),
+          this.attacker.createCallbackAppelAuMoral(),
+          { action: r => this.removeChatMessageActionsPasseArme(r.passeArme) },
+          { condition: r => arme && !RdDCombat.isParticuliere(r), action: r => this.attacker.incDecItemUse(arme._id) },
+          { condition: r => (RdDCombat.isReussite(r) && !RdDCombat.isParticuliere(r)), action: r => this._onAttaqueNormale(r) },
+          { condition: RdDCombat.isParticuliere, action: r => this._onAttaqueParticuliere(r) },
+          { condition: RdDCombat.isEchec, action: r => this._onAttaqueEchec(r) },
+          { condition: RdDCombat.isEchecTotal, action: r => this._onAttaqueEchecTotal(r) },
+        ]
+      });
     dialog.render(true);
   }
 
@@ -815,10 +815,11 @@ export class RdDCombat {
       competence: competence,
       surprise: this.attacker.getSurprise(true),
       surpriseDefenseur: this.defender.getSurprise(true),
+      targetToken: Targets.extractTokenData(this.target),
       essais: {}
     };
 
-    if (this.attacker.isCreature()) {
+    if (this.attacker.isCreatureEntite()) {
       RdDItemCompetenceCreature.setRollDataCreature(rollData);
     }
     else if (arme) {
@@ -836,7 +837,7 @@ export class RdDCombat {
 
   /* -------------------------------------------- */
   async _onAttaqueParticuliere(rollData) {
-    
+
     const isMeleeDiffNegative = (rollData.competence.type == 'competencecreature' || rollData.selectedCarac.label == "Mêlée") && rollData.diffLibre < 0;
     // force toujours, sauf empoignade
     // finesse seulement en mélée, pour l'empoignade, ou si la difficulté libre est de -1 minimum
@@ -854,7 +855,7 @@ export class RdDCombat {
     else if (!isForce && !isFinesse && isRapide) {
       return await this.choixParticuliere(rollData, "rapidite");
     }
-    
+
     const choixParticuliere = await ChatMessage.create({
       alias: this.attacker.name,
       whisper: ChatUtility.getWhisperRecipientsAndGMs(this.attacker.name),
@@ -883,7 +884,7 @@ export class RdDCombat {
     }
     await RdDResolutionTable.displayRollData(attackerRoll, this.attacker, 'chat-resultat-attaque.html');
 
-    if (!await this.accorderEntite('avant-defense')) {
+    if (!await this.attacker.accorder(this.defender, 'avant-defense')) {
       return;
     }
 
@@ -893,7 +894,7 @@ export class RdDCombat {
   }
 
   /* -------------------------------------------- */
-  isPossession( attackerRoll) {
+  isPossession(attackerRoll) {
     return attackerRoll.selectedCarac.label.toLowerCase() == 'possession';
   }
 
@@ -1036,31 +1037,28 @@ export class RdDCombat {
     const arme = this.defender.getArmeParade(armeParadeId);
     console.log("RdDCombat.parade >>>", attackerRoll, armeParadeId, arme);
     const competence = arme?.system?.competence;
-    if (competence == undefined)
-    {
-      console.error("Pas de compétence de parade associée à ", arme?.name, armeParadeId) ;
+    if (competence == undefined) {
+      console.error("Pas de compétence de parade associée à ", arme?.name, armeParadeId);
       return;
     }
 
     let rollData = this._prepareParade(attackerRoll, arme, competence);
 
     const dialog = await RdDRoll.create(this.defender, rollData,
+      { html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-competence.html' },
       {
-        html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-competence.html',
-        options: { height: 540 }
-      }, {
-      name: 'jet-parade',
-      label: 'Parade: ' + (arme ? arme.name : rollData.competence.name),
-      callbacks: [
-        this.defender.createCallbackExperience(),
-        this.defender.createCallbackAppelAuMoral(),
-        { action: r => this.removeChatMessageActionsPasseArme(r.passeArme) },
-        { condition: r => !RdDCombat.isParticuliere(r), action: r => this.defender.incDecItemUse(armeParadeId) },
-        { condition: RdDCombat.isReussite, action: r => this._onParadeNormale(r) },
-        { condition: RdDCombat.isParticuliere, action: r => this._onParadeParticuliere(r) },
-        { condition: RdDCombat.isEchec, action: r => this._onParadeEchec(r) },
-      ]
-    });
+        name: 'jet-parade',
+        label: 'Parade: ' + (arme ? arme.name : rollData.competence.name),
+        callbacks: [
+          this.defender.createCallbackExperience(),
+          this.defender.createCallbackAppelAuMoral(),
+          { action: r => this.removeChatMessageActionsPasseArme(r.passeArme) },
+          { condition: r => !RdDCombat.isParticuliere(r), action: r => this.defender.incDecItemUse(armeParadeId) },
+          { condition: RdDCombat.isReussite, action: r => this._onParadeNormale(r) },
+          { condition: RdDCombat.isParticuliere, action: r => this._onParadeParticuliere(r) },
+          { condition: RdDCombat.isEchec, action: r => this._onParadeEchec(r) },
+        ]
+      });
     dialog.render(true);
   }
 
@@ -1079,7 +1077,7 @@ export class RdDCombat {
       show: {}
     };
 
-    if (this.defender.isCreature()) {
+    if (this.defender.isCreatureEntite()) {
       RdDItemCompetenceCreature.setRollDataCreature(defenderRoll);
     }
 
@@ -1128,19 +1126,20 @@ export class RdDCombat {
     let rollData = this._prepareEsquive(attackerRoll, esquive);
 
     const dialog = await RdDRoll.create(this.defender, rollData,
-      { html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-competence.html' }, {
-      name: 'jet-esquive',
-      label: 'Esquiver',
-      callbacks: [
-        this.defender.createCallbackExperience(),
-        this.defender.createCallbackAppelAuMoral(),
-        { condition: r => !RdDCombat.isParticuliere(r), action: r => this.defender.incDecItemUse(esquive._id) },
-        { action: r => this.removeChatMessageActionsPasseArme(r.passeArme) },
-        { condition: RdDCombat.isReussite, action: r => this._onEsquiveNormale(r) },
-        { condition: RdDCombat.isParticuliere, action: r => this._onEsquiveParticuliere(r) },
-        { condition: RdDCombat.isEchec, action: r => this._onEsquiveEchec(r) },
-      ]
-    });
+      { html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-competence.html' },
+      {
+        name: 'jet-esquive',
+        label: 'Esquiver',
+        callbacks: [
+          this.defender.createCallbackExperience(),
+          this.defender.createCallbackAppelAuMoral(),
+          { condition: r => !RdDCombat.isParticuliere(r), action: r => this.defender.incDecItemUse(esquive._id) },
+          { action: r => this.removeChatMessageActionsPasseArme(r.passeArme) },
+          { condition: RdDCombat.isReussite, action: r => this._onEsquiveNormale(r) },
+          { condition: RdDCombat.isParticuliere, action: r => this._onEsquiveParticuliere(r) },
+          { condition: RdDCombat.isEchec, action: r => this._onEsquiveEchec(r) },
+        ]
+      });
     dialog.render(true);
   }
 
@@ -1157,7 +1156,7 @@ export class RdDCombat {
       show: {}
     };
 
-    if (this.defender.isCreature()) {
+    if (this.defender.isCreatureEntite()) {
       RdDItemCompetenceCreature.setRollDataCreature(rollData);
     }
     return rollData;
@@ -1318,35 +1317,6 @@ export class RdDCombat {
     this.removeChatMessageActionsPasseArme(attackerRoll.passeArme);
   }
 
-  /* -------------------------------------------- */
-  /* retourne true si on peut continuer, false si on ne peut pas continuer */
-  async accorderEntite(when = 'avant-encaissement') {
-    if (when != game.settings.get(SYSTEM_RDD, "accorder-entite-cauchemar")
-      || this.defender == undefined
-      || !this.defender.isEntite([ENTITE_INCARNE])
-      || this.defender.isEntiteAccordee(this.attacker)) {
-      return true;
-    }
-
-    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>",
-      whisper: ChatMessage.getWhisperRecipients(this.attacker.name)
-    };
-
-    if (rolled.isSuccess) {
-      await this.defender.setEntiteReveAccordee(this.attacker);
-      message.content += this.attacker.name + " s'est accordé avec " + this.defender.name;
-    }
-    else {
-      message.content += this.attacker.name + " n'est pas accordé avec " + this.defender.name;
-    }
-
-    ChatMessage.create(message);
-    return rolled.isSuccess;
-  }
-
   /* -------------------------------------------- */
   static async displayActorCombatStatus(combat, actor) {
     let formData = {

module/rdd-commands.js

@@ -3,7 +3,6 @@
 import { DialogChronologie } from "./dialog-chronologie.js";
 import { DialogCreateSigneDraconique } from "./dialog-create-signedraconique.js";
 import { DialogStress } from "./dialog-stress.js";
-import { Grammar } from "./grammar.js";
 import { RdDItemCompetence } from "./item-competence.js";
 import { Misc } from "./misc.js";
 import { RdDCarac } from "./rdd-carac.js";
@@ -14,7 +13,8 @@ import { RdDResolutionTable } from "./rdd-resolution-table.js";
 import { RdDRollResolutionTable } from "./rdd-roll-resolution-table.js";
 import { RdDRollTables } from "./rdd-rolltables.js";
 import { RdDUtility } from "./rdd-utility.js";
-import { TMRRencontres } from "./tmr-rencontres.js";
+import { CompendiumTableHelpers } from "./settings/system-compendiums.js";
+import { FenetreRechercheTirage } from "./tirage/fenetre-recherche-tirage.js";
 import { TMRUtility } from "./tmr-utility.js";
 
 const rddRollNumeric = /^(\d+)\s*([\+\-]?\d+)?\s*(s)?/;
@@ -23,56 +23,99 @@ const rddRollNumeric = /^(\d+)\s*([\+\-]?\d+)?\s*(s)?/;
 export class RdDCommands {
 
   static init() {
-    if (!game.system.rdd.commands) {
-      const rddCommands = new RdDCommands();
-      rddCommands.registerCommand({ path: ["/aide"], func: (content, msg, params) => rddCommands.help(msg), descr: "Affiche l'aide pour toutes les commandes" });
-      rddCommands.registerCommand({ path: ["/help"], func: (content, msg, params) => rddCommands.help(msg), descr: "Affiche l'aide pour toutes les commandes" });
-      rddCommands.registerCommand({ path: ["/table", "queues"], func: (content, msg, params) => RdDRollTables.getQueue(true), descr: "Tire une Queue de Dragon" });
-      rddCommands.registerCommand({ path: ["/table", "ideefixe"], func: (content, msg, params) => RdDRollTables.getIdeeFixe(true), descr: "Tire une Idée fixe" });
-      rddCommands.registerCommand({ path: ["/table", "desir"], func: (content, msg, params) => RdDRollTables.getDesirLancinant(true), descr: "Tire un Désir Lancinant" });
-      rddCommands.registerCommand({ path: ["/table", "ombre"], func: (content, msg, params) => RdDRollTables.getOmbre(true), descr: "Tire une Ombre de Dragon" });
-      rddCommands.registerCommand({ path: ["/table", "tetehr"], func: (content, msg, params) => RdDRollTables.getTeteHR(true), descr: "Tire une Tête de Dragon pour Hauts Revants" });
-      rddCommands.registerCommand({ path: ["/table", "tete"], func: (content, msg, params) => RdDRollTables.getTete(true), descr: "Tire une Tête de Dragon" });
-      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" });
+    const rddCommands = new RdDCommands();
+    game.system.rdd.commands = rddCommands;
 
-      rddCommands.registerCommand({
-        path: ["/tmr"], func: (content, msg, params) => rddCommands.findTMR(msg, params),
-        descr: `Cherche où se trouve une case des Terres médianes
+    Hooks.on("chatMessage", (html, content, msg) => {
+      if (content[0] == '/') {
+        let regExp = /(\S+)/g;
+        let commands = content.match(regExp);
+        if (rddCommands.processChatCommand(commands, content, msg)) {
+          return false;
+        }
+      }
+      return true;
+    });
+
+  }
+
+  constructor() {
+    this.commandsTable = undefined;
+  }
+
+  _registerCommands() {
+    this.commandsTable = {}
+    this.registerCommand({ path: ["/aide"], func: (content, msg, params) => this.help(msg), descr: "Affiche l'aide pour toutes les commandes" });
+    this.registerCommand({ path: ["/help"], func: (content, msg, params) => this.help(msg), descr: "Affiche l'aide pour toutes les commandes" });
+
+    this.registerCommand({ path: ["/liste", "comp"], func: (content, msg, params) => RdDRollTables.getCompetence('liste'), descr: "Affiche la liste des compétences" });
+
+    this.registerCommand({ path: ["/table", "queue"], func: (content, msg, params) => RdDRollTables.getQueue('liste'), descr: "Affiche la table des Queues de Dragon" });
+    this.registerCommand({ path: ["/table", "ombre"], func: (content, msg, params) => RdDRollTables.getOmbre('liste'), descr: "Affiche la table des Ombres de Thanatos" });
+    this.registerCommand({ path: ["/table", "tetehr"], func: (content, msg, params) => RdDRollTables.getTeteHR('liste'), descr: "Affiche la table des Têtes de Dragon pour Hauts Revants" });
+    this.registerCommand({ path: ["/table", "tete"], func: (content, msg, params) => RdDRollTables.getTete('liste'), descr: "Affiche la table des Tête de Dragon pour tous" });
+    this.registerCommand({ path: ["/table", "souffle"], func: (content, msg, params) => RdDRollTables.getSouffle('liste'), descr: "Affiche la table des Souffles de Dragon" });
+    this.registerCommand({ path: ["/table", "tarot"], func: (content, msg, params) => RdDRollTables.getTarot('liste'), descr: "Affiche la table les cartes du Tarot Draconique" });
+    this.registerCommand({ path: ["/table", "ideefixe"], func: (content, msg, params) => RdDRollTables.getIdeeFixe('liste'), descr: "Affiche la table des Idées fixes" });
+    this.registerCommand({ path: ["/table", "desir"], func: (content, msg, params) => RdDRollTables.getDesirLancinant('liste'), descr: "Affiche la table des Désirs Lancinants" });
+    this.registerCommand({
+      path: ["/table", "rencontre"], func: (content, msg, params) => this.tableRencontres(msg, params),
+      descr: `Affiche la table des Rencontres
+          <br><strong>/table rencontre deso</strong> affiche la table des rencontres en Désolation
+          <br><strong>/table rencontre mauvaise</strong> affiche la table des mauvaises rencontres`
+    });
+
+    this.registerCommand({ path: ["/tirer", "comp"], func: (content, msg, params) => RdDRollTables.getCompetence('chat'), descr: "Tire une compétence au hasard" });
+    this.registerCommand({ path: ["/tirer", "queue"], func: (content, msg, params) => RdDRollTables.getQueue('chat'), descr: "Tire une Queue de Dragon" });
+    this.registerCommand({ path: ["/tirer", "ombre"], func: (content, msg, params) => RdDRollTables.getOmbre('chat'), descr: "Tire une Ombre de Thanatos" });
+    this.registerCommand({ path: ["/tirer", "tetehr"], func: (content, msg, params) => RdDRollTables.getTeteHR('chat'), descr: "Tire une Tête de Dragon pour Hauts Revants" });
+    this.registerCommand({ path: ["/tirer", "tete"], func: (content, msg, params) => RdDRollTables.getTete('chat'), descr: "Tire une Tête de Dragon" });
+    this.registerCommand({ path: ["/tirer", "souffle"], func: (content, msg, params) => RdDRollTables.getSouffle('chat'), descr: "Tire un Souffle de Dragon" });
+    this.registerCommand({ path: ["/tirer", "tarot"], func: (content, msg, params) => RdDRollTables.getTarot('chat'), descr: "Tire une carte du Tarot Draconique" });
+    this.registerCommand({ path: ["/tirer", "ideefixe"], func: (content, msg, params) => RdDRollTables.getIdeeFixe('chat'), descr: "Tire une Idée fixe" });
+    this.registerCommand({ path: ["/tirer", "desir"], func: (content, msg, params) => RdDRollTables.getDesirLancinant('chat'), descr: "Tire un Désir Lancinant" });
+    this.registerCommand({ path: ["/tirer", "rencontre"], func: (content, msg, params) => this.getRencontreTMR(params), descr: `Détermine une rencontre dans les TMR (synonyme de "/tmrr")` });
+    this.registerCommand({ path: ["/tirage"], func: (content, msg, params) => this.tirage(), descr: "Ouvre la fenêtre de recherche et tirage" });
+
+    this.registerCommand({ path: ["/meteo"], func: (content, msg, params) => this.getMeteo(msg, params), descr: "Propose une météo marine" });
+    this.registerCommand({ path: ["/nom"], func: (content, msg, params) => RdDNameGen.getName(msg, params), descr: "Génère un nom aléatoire" });
+
+    this.registerCommand({
+      path: ["/tmr"], func: (content, msg, params) => this.findTMR(msg, params),
+      descr: `Cherche où se trouve une case des Terres médianes
           <br><strong>/tmr sord</strong> indique que la cité Sordide est en D13
-          <br><strong>/tmr foret</strong> donne la liste des TMR dont le nom contient "foret" (donc, toutes les forêts)` });
-      rddCommands.registerCommand({
-        path: ["/tmra"], func: (content, msg, params) => rddCommands.getTMRAleatoire(msg, params),
-        descr: `Tire une case aléatoire des Terres médianes
+          <br><strong>/tmr foret</strong> donne la liste des TMR dont le nom contient "foret" (donc, toutes les forêts)`
+    });
+    this.registerCommand({
+      path: ["/tmra"], func: (content, msg, params) => this.getTMRAleatoire(msg, params),
+      descr: `Tire une case aléatoire des Terres médianes
           <br><strong>/tmra forêt</strong> détermine une 'forêt' aléatoire
-          <br><strong>/tmra</strong> détermine une case aléatoire dans toutes les TMR` });
-      rddCommands.registerCommand({
-        path: ["/tmrr"], func: (content, msg, params) => rddCommands.getRencontreTMR(params),
-        descr: `Détermine une rencontre dans un type de case
+          <br><strong>/tmra</strong> détermine une case aléatoire dans toutes les TMR`
+    });
+    this.registerCommand({
+      path: ["/tmrr"], func: (content, msg, params) => this.getRencontreTMR(params),
+      descr: `Détermine une rencontre dans les TMR
           <br><strong>/tmrr forêt</strong> détermine une rencontre aléatoire en 'forêt'
           <br><strong>/tmrr mauvaise</strong> détermine une mauvaise rencontre aléatoire
           <br><strong>/tmrr for 47</strong> détermine la rencontre en 'forêt' pour un jet de dé de 47`
-      });
+    });
 
-      rddCommands.registerCommand({
-        path: ["/xp", "comp"], func: (content, msg, params) => rddCommands.getCoutXpComp(msg, params),
-        descr: `Détermine le coût d'expérience pour augmenter une compétence. Exemples:
+    this.registerCommand({
+      path: ["/xp", "comp"], func: (content, msg, params) => this.getCoutXpComp(msg, params),
+      descr: `Détermine le coût d'expérience pour augmenter une compétence. Exemples:
         <br>/xp comp -6 1: pour passer de -6 à +1
         <br>/xp comp +4: pour atteindre le niveau 4 (depuis +3)`
-      });
+    });
 
-      rddCommands.registerCommand({
-        path: ["/xp", "carac"], func: (content, msg, params) => rddCommands.getCoutXpCarac(msg, params),
-        descr: `Détermine le coût d'expérience pour augmenter une caractéristique. Exemples:
+    this.registerCommand({
+      path: ["/xp", "carac"], func: (content, msg, params) => this.getCoutXpCarac(msg, params),
+      descr: `Détermine le coût d'expérience pour augmenter une caractéristique. Exemples:
         <br>/xp carac 15: coût pour atteindre 15 (depuis 14)`
-      });
+    });
 
-      rddCommands.registerCommand({
-        path: ["/rdd"], func: (content, msg, params) => rddCommands.rollRdd(msg, params),
-        descr: `Effectue un jet de dés dans la table de résolution. Exemples:
+    this.registerCommand({
+      path: ["/rdd"], func: (content, msg, params) => this.rollRdd(msg, params),
+      descr: `Effectue un jet de dés dans la table de résolution. Exemples:
           <br><strong>/rdd</strong> ouvre la table de résolution
           <br><strong>/rdd 10 3</strong> effectue un jet 10 à +3
           <br><strong>/rdd 15 -2</strong> effectue un jet 15 à -2
@@ -80,52 +123,46 @@ export class RdDCommands {
           <br><strong>/rdd Vue Vigilance -2</strong> effectue un jet de Vue/Vigilance à -2 pour les tokens sélectionnés
           <br><strong>/rdd vol déser +2</strong> effectue un jet de Volonté/Survie en désert à +2 pour les tokens sélectionnés
           `
-      });
-      rddCommands.registerCommand({ path: ["/ddr"], func: (content, msg, params) => rddCommands.rollDeDraconique(msg), descr: "Lance un Dé Draconique" });
+    });
+    this.registerCommand({ path: ["/ddr"], func: (content, msg, params) => this.rollDeDraconique(msg), descr: "Lance un Dé Draconique" });
 
-      rddCommands.registerCommand({
-        path: ["/payer"], func: (content, msg, params) => RdDUtility.afficherDemandePayer(params[0], params[1]),
-        descr: `Demande aux joueurs de payer un montant. Exemples:
+    this.registerCommand({
+      path: ["/payer"], func: (content, msg, params) => RdDUtility.afficherDemandePayer(params[0], params[1]),
+      descr: `Demande aux joueurs de payer un montant. Exemples:
           <br><strong>/payer 5s 10d</strong> permet d'envoyer un message pour payer 5 sols et 10 deniers
           <br><strong>/payer 10d</strong> permet d'envoyer un message pour payer 10 deniers`
-      });
-      rddCommands.registerCommand({
-        path: ["/astro"], func: (content, msg, params) => RdDUtility.afficherHeuresChanceMalchance(Misc.join(params, ' ')),
-        descr: `Affiche les heures de chance et de malchance selon l'heure de naissance donnée en argument. Exemples pour l'heure de la Lyre:
+    });
+    this.registerCommand({
+      path: ["/astro"], func: (content, msg, params) => RdDUtility.afficherHeuresChanceMalchance(Misc.join(params, ' ')),
+      descr: `Affiche les heures de chance et de malchance selon l'heure de naissance donnée en argument. Exemples pour l'heure de la Lyre:
           <br><strong>/astro 7</strong>
           <br><strong>/astro Lyre</strong>
           <br><strong>/astro Lyr</strong>`
-      });
+    });
 
-      rddCommands.registerCommand({
-        path: ["/signe", "+"], func: (content, msg, params) => rddCommands.creerSignesDraconiques(),
-        descr: "Crée un signe draconique et l'ajoute aux haut-rêvants choisis."
-      });
+    this.registerCommand({
+      path: ["/signe", "+"], func: (content, msg, params) => this.creerSignesDraconiques(),
+      descr: "Crée un signe draconique et l'ajoute aux haut-rêvants choisis."
+    });
 
-      rddCommands.registerCommand({
-        path: ["/signe", "-"], func: (content, msg, params) => rddCommands.supprimerSignesDraconiquesEphemeres(),
-        descr: "Supprime les signes draconiques éphémères"
-      });
+    this.registerCommand({
+      path: ["/signe", "-"], func: (content, msg, params) => this.supprimerSignesDraconiquesEphemeres(),
+      descr: "Supprime les signes draconiques éphémères"
+    });
 
-      rddCommands.registerCommand({
-        path: ["/stress"], func: (content, msg, params) => rddCommands.distribuerStress(params),
-        descr: `Distribue du stress aux personnages. Exemples:
+    this.registerCommand({
+      path: ["/stress"], func: (content, msg, params) => this.distribuerStress(params),
+      descr: `Distribue du stress aux personnages. Exemples:
           <br><strong>/stress</strong> : Ouvre une fenêtre pour donner du stress ou de l'expérience à un ensemble de personnages
           <br><strong>/stress 6</strong> : Distribue 6 points des Stress à tout les personnages joueurs, sans raison renseignée
           <br><strong>/stress 6 Tigre</strong> : Distribue 6 points des Stress à tout les personnages joueurs, à cause d'un Tigre (Vert)
           <br><strong>/stress 6 Glou Paulo</strong> : Distribue 6 points de Stress au personnage Paulon ou au personnage joueur Paulo, à cause d'un Glou`
-      });
+    });
 
-      rddCommands.registerCommand({
-        path: ["/chrono"], func: (content, msg, params) => DialogChronologie.create(),
-        descr: `Enregistre une entrée de chronologie dans un article de journal`
-      });
-
-      game.system.rdd.commands = rddCommands;
-    }
-  }
-  constructor() {
-    this.commandsTable = {};
+    this.registerCommand({
+      path: ["/chrono"], func: (content, msg, params) => DialogChronologie.create(),
+      descr: `Enregistre une entrée de chronologie dans un article de journal`
+    });
   }
 
   /* -------------------------------------------- */
@@ -167,18 +204,29 @@ export class RdDCommands {
   processChatCommand(commandLine, content = '', msg = {}) {
     // Setup new message's visibility
     let rollMode = game.settings.get("core", "rollMode");
-    if (["gmroll", "blindroll"].includes(rollMode)) msg["whisper"] = ChatMessage.getWhisperRecipients("GM");
-    if (rollMode === "blindroll") msg["blind"] = true;
+    if (["gmroll", "blindroll"].includes(rollMode)) {
+      msg["whisper"] = ChatMessage.getWhisperRecipients("GM");
+    }
+    if (rollMode === "blindroll") {
+      msg["blind"] = true;
+    }
     msg["type"] = 0;
 
-    let command = commandLine[0].toLowerCase();
-    let params = commandLine.slice(1);
+    if (!this.commandsTable) {
+      this._registerCommands();
+    }
 
-    return this.process(command, params, content, msg);
+    let command = commandLine[0].toLowerCase();
+    if (this._isCommandHandled(command)) {
+      let params = commandLine.slice(1);
+      this._processCommand(this.commandsTable, command, params, content, msg);
+      return true;
+    }
+    return false;
   }
 
-  process(command, params, content, msg) {
-    return this._processCommand(this.commandsTable, command, params, content, msg);
+  _isCommandHandled(command) {
+    return this.commandsTable[command] != undefined;
   }
 
   async _processCommand(commandsTable, name, params, content = '', msg = {}, path = "") {
@@ -186,32 +234,31 @@ export class RdDCommands {
     path = path + name + " ";
     if (command && command.subTable) {
       if (params[0]) {
-        return this._processCommand(command.subTable, params[0], params.slice(1), content, msg, path)
+        this._processCommand(command.subTable, params[0], params.slice(1), content, msg, path)
       }
       else {
         this.help(msg, command.subTable);
-        return true;
       }
+      return true;
     }
     if (command && command.func) {
-      const result =  await command.func(content, msg, params);
-      if (result == false) {
-        RdDCommands._chatAnswer(msg, command.descr);
-      }
+      new Promise(async () => {
+        const result = await command.func(content, msg, params);
+        if (result == false) {
+          RdDCommands._chatAnswer(msg, command.descr);
+        }
+      });
       return true;
     }
     return false;
   }
 
   /* -------------------------------------------- */
-  async help(msg) {
-    this.help(msg, undefined);
-  }
-  async help(msg, table) {
-    let list = []
-    this._buildSubTableHelp(list, table || this.commandsTable);
+  async help(msg, table = undefined) {
+    let commands = []
+    this._buildSubTableHelp(commands, table ?? this.commandsTable);
 
-    let html = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/settings/dialog-aide-commands.html", { commands: list });
+    let html = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/settings/dialog-aide-commands.html", { commands: commands });
     let d = new Dialog(
       {
         title: "Commandes disponibles dans le tchat",
@@ -249,7 +296,7 @@ export class RdDCommands {
   /* -------------------------------------------- */
   async getRencontreTMR(params) {
     if (params.length == 1 || params.length == 2) {
-      return TMRRencontres.rollRencontre(params[0], params[1])
+      return game.system.rdd.rencontresTMR.rollRencontre(params[0], params[1])
     }
     return false;
   }
@@ -281,7 +328,7 @@ export class RdDCommands {
           diff = 0;
         }
         const caracName = params[0];
-        let competence = length > 1 ? actors[0].getCompetence(Misc.join(params.slice(1, length), ' ')) : undefined;
+        let competence = length > 1 ? actors[0].getCompetence(Misc.join(params.slice(1, length), ' ')) : { name: undefined };
         if (competence) {
           for (let actor of actors) {
             await actor.rollCaracCompetence(caracName, competence.name, diff);
@@ -336,6 +383,18 @@ export class RdDCommands {
     return false;
   }
 
+  async tableRencontres(msg, params) {
+    if (params && params.length > 0) {
+      const search = Misc.join(params, ' ');
+      const solvedTerrain = TMRUtility.findTMRLike(search);
+      if (solvedTerrain == undefined) {
+        return RdDCommands._chatAnswer(msg, 'Aucune TMR correspondant à ' + search);
+      }
+      return await game.system.rdd.rencontresTMR.chatTable(solvedTerrain);
+    }
+    return false;
+  }
+
   /* -------------------------------------------- */
   getCoutXpComp(msg, params) {
     if (params && (params.length == 1 || params.length == 2)) {
@@ -360,17 +419,27 @@ export class RdDCommands {
   }
 
   async creerSignesDraconiques() {
-    DialogCreateSigneDraconique.createSigneForActors();
+    if (game.user.isGM) {
+      DialogCreateSigneDraconique.createSigneForActors();
+    }
+    else {
+      ui.notifications.warn("Seul le MJ est autorisé à utiliser la commande /signe");
+    }
     return true;
   }
 
   async supprimerSignesDraconiquesEphemeres() {
-    game.actors.forEach(actor => {
-      const ephemeres = actor.items.filter(item => item.type = 'signedraconique' && item.system.ephemere);
-      if (ephemeres.length > 0) {
-        actor.deleteEmbeddedDocuments("Item", ephemeres.map(item => item.id));
-      }
-    });
+    if (game.user.isGM) {
+      game.actors.forEach(actor => {
+        const ephemeres = actor.items.filter(item => item.type = 'signedraconique' && item.system.ephemere);
+        if (ephemeres.length > 0) {
+          actor.deleteEmbeddedDocuments("Item", ephemeres.map(item => item.id));
+        }
+      });
+    }
+    else {
+      ui.notifications.warn("Seul le MJ est autorisé à utiliser la commande /signe");
+    }
     return true;
   }
 
@@ -413,5 +482,8 @@ export class RdDCommands {
     return await RdDMeteo.getMeteo();
   }
 
+  async tirage() {
+    FenetreRechercheTirage.create();
+  }
 }
 

module/rdd-compendium-organiser.js

@@ -1,8 +1,8 @@
 import { SYSTEM_RDD } from "./constants.js";
 
-export class RddCompendiumOrganiser {
+export class RdDCompendiumOrganiser {
   static init() {
-    Hooks.on('renderCompendium', async (pack, html, compendiumData) => RddCompendiumOrganiser.onRenderCompendium(pack, html, compendiumData))
+    Hooks.on('renderCompendium', async (pack, html, compendiumData) => RdDCompendiumOrganiser.onRenderCompendium(pack, html, compendiumData))
   }
 
   static async onRenderCompendium(compendium, html, compendiumData) {
@@ -10,14 +10,14 @@ export class RddCompendiumOrganiser {
     const pack = compendium.collection
     if (pack.metadata.system === SYSTEM_RDD) {
       html.find('.directory-item').each((i, element) => {
-        RddCompendiumOrganiser.setEntityTypeName(pack, element);
+        RdDCompendiumOrganiser.setEntityTypeName(pack, element);
       });
     }
   }
 
   static async setEntityTypeName(pack, element) {
-    const label = RddCompendiumOrganiser.getEntityTypeLabel(await pack.getDocument(element.dataset.documentId));
-    RddCompendiumOrganiser.insertEntityType(element, label);
+    const label = RdDCompendiumOrganiser.getEntityTypeLabel(await pack.getDocument(element.dataset.documentId));
+    RdDCompendiumOrganiser.insertEntityType(element, label);
   }
 
   static insertEntityType(element, label) {

module/rdd-confirm.js

@@ -45,7 +45,7 @@ export class RdDConfirm {
     return {
       "actionSave": {
         icon: '<i class="fas fa-user-check"></i>',
-        label: "Toujours "+ options.buttonLabel.toLowerCase(),
+        label: options.buttonLabel + "<br>et ne plus demander",
         callback: () => {
           ReglesOptionelles.set(options.settingConfirmer, false);
           options.onAction();