Merge pull request 'Fix: migration automatique de calendrier quand l'heure est à Vaisseau+0 minutes' (#605) from VincentVk/foundryvtt-reve-de-dragon:v10 into v10

Reviewed-on: #605

.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": {
@@ -27,6 +28,7 @@
     "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() {
@@ -35,51 +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;
-    this.actor.computeEtatGeneral();
-
-    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);
       });
 
@@ -118,58 +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, dragData, this.objetVersConteneur)
-    if (dropParams) {
-      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 => RdDSheetUtility.getItem(event, this.actor)?.sheet.render(true))
-    html.find('.item-delete').click(async event => RdDUtility.confirmerSuppressionItem(this, RdDSheetUtility.getItem(event, this.actor)));
-    html.find('.item-vendre').click(async event => RdDSheetUtility.getItem(event, this.actor)?.proposerVente());
-    html.find('.item-montrer').click(async event => RdDSheetUtility.getItem(event, this.actor)?.postItem());
-    html.find('.item-action').click(async event => RdDSheetUtility.getItem(event, this.actor)?.actionPrincipale(this.actor));
-    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) {
@@ -177,54 +126,48 @@ 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);
-    });
-    html.find('.creer-une-oeuvre').click(async event => {
-      RdDUtility.selectTypeOeuvre(this);
-    });
-    html.find('.nettoyer-conteneurs').click(async event => {
-      this.actor.nettoyerConteneurs();
+    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();
@@ -238,57 +181,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) {
@@ -297,25 +240,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.html.find('.ptreve-actuel a').click(async event => {
       this.actor.rollCarac('reve-actuel');
     });
 
     // 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);
@@ -325,88 +268,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();
@@ -415,7 +354,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);
@@ -429,94 +368,118 @@ 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 {
@@ -527,7 +490,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);
@@ -545,8 +508,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

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

module/actor/base-actor-sheet.js

@@ -0,0 +1,260 @@
+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();
+    const userRightLevel = game.user.isGM ? CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER : this.actor.getUserLevel(game.user)
+    const options = duplicate(this.options);
+    mergeObject(options, {
+      isGM: game.user.isGM,
+      editable: this.isEditable,
+      cssClass: this.isEditable ? "editable" : "locked",
+      isLimited: userRightLevel >= CONST.DOCUMENT_OWNERSHIP_LEVELS.LIMITED,
+      isObserver: userRightLevel >= CONST.DOCUMENT_OWNERSHIP_LEVELS.OBSERVER,
+      isOwner: userRightLevel >= CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER,
+      owner: this.actor.isOwner,
+    });
+
+    let formData = {
+      title: this.title,
+      id: this.actor.id,
+      type: this.actor.type,
+      img: this.actor.img,
+      name: this.actor.name,
+      system: foundry.utils.deepClone(this.actor.system),
+      description: await TextEditor.enrichHTML(this.actor.system.description, { async: true }),
+      notesmj: await TextEditor.enrichHTML(this.actor.system.notesmj, { async: true }),
+      options: options,
+    }
+    this.filterItemsPerTypeForSheet(formData, this.actor.itemTypes);
+    formData.calc = {
+      fortune: this.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;
+  }
+
+  toSolsDeniers(fortune) {
+    return {
+      sols: Math.floor(fortune),
+      deniers: Math.round(100 * (fortune - Math.floor(fortune)))
+    };
+  }
+
+  /* -------------------------------------------- */
+  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.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,619 @@
+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;
+    }
+  }
+
+  /* -------------------------------------------- */
+  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,74 @@
+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 }]
+    });
+  }
+
+  /* -------------------------------------------- */
+  /** @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,6 @@
 import { SYSTEM_RDD } from "./constants.js";
 import { Grammar } from "./grammar.js";
+import { RdDTimestamp } from "./rdd-timestamp.js";
 
 
 const LATEST_USED_JOURNAL_ID = "chronologie-dernier-journal";
@@ -16,16 +17,13 @@ export class DialogChronologie extends Dialog {
     });
   }
   static async create() {
-    const dateRdD = game.system.rdd.calendrier.getCalendrier();
     const dialogData = {
       auteur: game.user.name,
       isGM: game.user.isGM,
       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: dateRdD,
-      jourRdD: dateRdD.jour +1,
-      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);
@@ -62,6 +60,7 @@ export class DialogChronologie extends Dialog {
 
   activateListeners(html) {
     super.activateListeners(html);
+    this.html = html;
   }
 
   async ajouter() {
@@ -74,11 +73,11 @@ export class DialogChronologie extends Dialog {
   }
 
   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 };
   }
@@ -89,15 +88,16 @@ export class DialogChronologie extends Dialog {
 
   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='jourRdD']").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', ' ')
     }
   }
 

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/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,14 +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;
@@ -18,59 +17,78 @@ export class DialogItemAchat extends Dialog {
       return undefined;
     }
 
-    const prixLot = Number(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,
@@ -90,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) {
@@ -100,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

@@ -17,7 +17,7 @@ export class DialogConsommer extends Dialog {
       buttons: {
         [consommerData.buttonName]: {
           label: consommerData.buttonName, callback: async it => {
-            await this.onConsommer(it);
+            await this.onConsommer();
             await onActionItem();
           }
         }
@@ -31,9 +31,16 @@ 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);
   }
 
@@ -92,14 +99,6 @@ export class DialogConsommer extends Dialog {
   }
 
 
-  /* -------------------------------------------- */
-  activateListeners(html) {
-    super.activateListeners(html);
-    html.find(".se-forcer").change(event => this.setSeForcer(event));
-    html.find(".consommer-doses").change(event => this.selectDoses(event));
-  }
-
-
   setSeForcer(event) {
     this.consommerData.choix.seForcer = event.currentTarget.checked;
   }
@@ -107,7 +106,7 @@ export class DialogConsommer extends Dialog {
   selectDoses(event) {
     this.consommerData.choix.doses = Number(event.currentTarget.value);
     DialogConsommer.calculDoses(this.consommerData, this.item);
-    $(".total-sust").text(this.consommerData.totalSust);
-    $(".total-desaltere").text(this.consommerData.totalDesaltere);
+    this.html.find(".total-sust").text(this.consommerData.totalSust);
+    this.html.find(".total-desaltere").text(this.consommerData.totalDesaltere);
   }
 }

module/dialog-item-vente.js

@@ -2,21 +2,22 @@ import { HtmlUtility } from "./html-utility.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,
+      vendeurId: item.actor?.id ,
+      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);
@@ -37,26 +38,25 @@ export class DialogItemVente extends Dialog {
     this.venteData = venteData;
   }
 
+  activateListeners(html) {
+    super.activateListeners(html);
+    this.html = html;
+    this.setQuantiteIllimite(this.venteData.quantiteIllimite);
+    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)));
+  }
+
   async onProposer(it) {
-    await $(".tailleLot").change();
-    await $(".quantiteNbLots").change();
-    await $(".quantiteIllimite").change();
-    await $(".prixLot").change();
+    await this.html.find(".tailleLot").change();
+    await this.html.find(".quantiteNbLots").change();
+    await this.html.find(".quantiteIllimite").change();
+    await this.html.find(".prixLot").change();
     this.callback(this.venteData);
   }
 
   /* -------------------------------------------- */
-  activateListeners(html) {
-    super.activateListeners(html);
-
-    HtmlUtility._showControlWhen($(".quantiteNbLots"), !this.venteData.quantiteIllimite)
-
-    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)));
-  }
-
   setPrixLot(prixLot) {
     this.venteData.prixLot = prixLot;
   }
@@ -65,16 +65,14 @@ export class DialogItemVente extends Dialog {
     // 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.html.find(".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)
-    }
+    // 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);
+    this.html.find(".quantiteNbLots").val(this.venteData.quantiteNbLots);
+    this.html.find(".quantiteNbLots").attr("max", this.venteData.quantiteMaxLots)
   }
 
   setNbLots(nbLots) {
@@ -82,12 +80,12 @@ export class DialogItemVente extends Dialog {
       nbLots = Math.max(0, Math.min(nbLots, this.venteData.quantiteMaxLots));
     }
     this.venteData.quantiteNbLots = nbLots;
-    $(".quantiteNbLots").val(this.venteData.quantiteNbLots);
+    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.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

@@ -20,8 +20,9 @@ export class DialogSelectTarget extends Dialog {
 
   activateListeners(html) {
     super.activateListeners(html);
-    html.find("li.select-target").click((event) => {
-      this.targetSelected($(event.currentTarget)?.data("token-id"));
+    this.html = html;
+    this.html.find("li.select-target").click((event) => {
+      this.targetSelected(this.html.find(event.currentTarget)?.data("token-id"));
     });
   }
 

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

@@ -147,29 +147,29 @@ export class EnvironmentSheetHelper {
     });
   }
 
-  static activateListeners(sheet, html) {
+  static activateListeners(sheet) {
     if (!sheet.options.editable) return;
 
-    html.find("input.input-selection-milieu").keypress(event => {
+    sheet.html.find("input.input-selection-milieu").keypress(event => {
       if (event.keyCode == '13') {
-        EnvironmentSheetHelper.onAddMilieu(html, sheet, event);
+        EnvironmentSheetHelper.onAddMilieu(sheet, event);
       }
       event.stopPropagation();
     })
-    html.find("a.milieu-add").click(event => EnvironmentSheetHelper.onAddMilieu(html, sheet, event));
-    html.find("div.environnement-milieu a.milieu-delete").click(event => EnvironmentSheetHelper.onDeleteMilieu(sheet, event));
-    html.find("div.environnement-milieu select.environnement-rarete").change(event => EnvironmentSheetHelper.onChange(sheet, event,
-      updated => EnvironmentSheetHelper.$changeRarete(event, updated)));
-    html.find("div.environnement-milieu input[name='environnement-frequence']").change(event => EnvironmentSheetHelper.onChange(sheet, event,
-      updated => EnvironmentSheetHelper.$changeFrequence(updated, event)));
+    sheet.html.find("a.milieu-add").click(event => EnvironmentSheetHelper.onAddMilieu(sheet, event));
+    sheet.html.find("div.environnement-milieu a.milieu-delete").click(event => EnvironmentSheetHelper.onDeleteMilieu(sheet, event));
+    sheet.html.find("div.environnement-milieu select.environnement-rarete").change(event => EnvironmentSheetHelper.onChange(sheet, event,
+      updated => EnvironmentSheetHelper.$changeRarete(sheet, event, updated)));
+    sheet.html.find("div.environnement-milieu input[name='environnement-frequence']").change(event => EnvironmentSheetHelper.onChange(sheet, event,
+      updated => EnvironmentSheetHelper.$changeFrequence(sheet, event, updated)));
   }
 
-  static $changeFrequence(updated, event) {
-    updated.frequence = Number($(event.currentTarget).val());
+  static $changeFrequence(sheet, event, updated) {
+    updated.frequence = Number(sheet.html.find(event.currentTarget).val());
   }
 
-  static $changeRarete(event, updated) {
-    const name = $(event.currentTarget).val();
+  static $changeRarete(sheet, event, updated) {
+    const name = sheet.html.find(event.currentTarget).val();
     const rarete = Environnement.getRarete(name);
     updated.rarete = rarete.name;
     updated.frequence = rarete.frequence;
@@ -178,8 +178,8 @@ export class EnvironmentSheetHelper {
     //   rarete.max);
   }
 
-  static async onAddMilieu(html, sheet, event) {
-    const milieu = html.find('input.input-selection-milieu').val();
+  static async onAddMilieu(sheet, event) {
+    const milieu = sheet.html.find('input.input-selection-milieu').val();
     if (!milieu) {
       ui.notifications.warn(`Choisissez le milieu dans lequel se trouve le/la ${sheet.item.name}`);
       return
@@ -196,7 +196,7 @@ export class EnvironmentSheetHelper {
   }
 
   static async onDeleteMilieu(sheet, event) {
-    const milieu = EnvironmentSheetHelper.$getEventMilieu(event);
+    const milieu = EnvironmentSheetHelper.$getEventMilieu(sheet, event);
     if (milieu != undefined) {
       const newList = sheet.item.system.environnement.filter(it => it.milieu != milieu)
         .sort(Misc.ascending(it => it.milieu));
@@ -206,7 +206,7 @@ export class EnvironmentSheetHelper {
 
   static async onChange(sheet, event, doMutation) {
     const list = sheet.item.system.environnement;
-    const milieu = EnvironmentSheetHelper.$getEventMilieu(event);
+    const milieu = EnvironmentSheetHelper.$getEventMilieu(sheet, event);
     const updated = list.find(it => it.milieu == milieu);
     if (updated) {
       doMutation(updated);
@@ -216,8 +216,8 @@ export class EnvironmentSheetHelper {
     }
   }
 
-  static $getEventMilieu(event) {
-    return $(event.currentTarget)?.parents("div.environnement-milieu").data("milieu");
+  static $getEventMilieu(sheet, event) {
+    return sheet.html.find(event.currentTarget)?.parents("div.environnement-milieu").data("milieu");
   }
 
 }

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-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 }
 ];
 
 /* -------------------------------------------- */
@@ -267,23 +267,20 @@ 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))
+      .sort((a, b) => RdDItemCompetence.compare(a, b))
   }
 
   static $positionTri(comp) {
@@ -308,7 +305,7 @@ export class RdDItemCompetence extends Item {
     return 0;
   }
 
-  static compare(a,b) {
+  static compare(a, b) {
     const diff = RdDItemCompetence.$positionTri(a) - RdDItemCompetence.$positionTri(b);
     return diff ? diff : a.name.localeCompare(b.name);
   }

module/item-conteneur-sheet.js

@@ -16,9 +16,10 @@ export class RdDConteneurItemSheet extends RdDItemSheet {
 
   activateListeners(html) {
     super.activateListeners(html);
+
     if (!this.options.editable) return;
 
-    html.find('.conteneur-name a').click(async event => {
+    this.html.find('.conteneur-name a').click(async event => {
       RdDUtility.toggleAfficheContenu(RdDSheetUtility.getItemId(event));
       this.render(true);
     });
@@ -50,7 +51,7 @@ export class RdDConteneurItemSheet extends RdDItemSheet {
 
   async _onDropItem(event, dragData) {
     if (this.actor) {
-      const dropParams = RdDSheetUtility.prepareItemDropParameters(this.item.id, this.actor, dragData, this.objetVersConteneur);
+      const dropParams = await RdDSheetUtility.prepareItemDropParameters(this.item.id, this.actor, dragData, this.objetVersConteneur);
       await this.actor.processDropItem(dropParams);
       await this.render(true);
     }

module/item-faune-sheet.js

@@ -23,7 +23,7 @@ export class RdDFauneItemSheet extends RdDItemSheet {
     super.activateListeners(html);
     if (!this.options.editable) return;
 
-    EnvironmentSheetHelper.activateListeners(this, html);
+    EnvironmentSheetHelper.activateListeners(this);
 
     html.find("a.linked-actor-delete").click(event => this.onDeleteLinkedActor());
     html.find("a.preparer-nourriture").click(event => this.preparerNourriture(event));

module/item-herbe-sheet.js

@@ -20,6 +20,6 @@ export class RdDHerbeItemSheet extends RdDItemSheet {
 
   activateListeners(html) {
     super.activateListeners(html);
-    EnvironmentSheetHelper.activateListeners(this, html);
+    EnvironmentSheetHelper.activateListeners(this);
   }
 }

module/item-ingredient-sheet.js

@@ -20,6 +20,6 @@ export class RdDIngredientItemSheet extends RdDItemSheet {
 
   activateListeners(html) {
     super.activateListeners(html);
-    EnvironmentSheetHelper.activateListeners(this, html);
+    EnvironmentSheetHelper.activateListeners(this);
   }
 }

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, 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, 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, cout: 1, encombrement: 0.003, description: "" }
 };
 const MONNAIE_OR = {
-  name: "Or (10 sols)", type: 'monnaie',
+  name: "Dreagon (or)", type: 'monnaie',
   img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_or_sol.webp",
   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 {
 
@@ -40,15 +41,11 @@ export class Monnaie {
   }
 
   static deValeur(monnaie, valeur) {
-    return Monnaie.valEntiere(valeur) == Monnaie.valEntiere(monnaie.system.cout)
-  }
-
-  static valEntiere(sols) {
-    return Math.max(Math.floor((sols??0)*100), 0);
+    return VALEUR_DENIERS(valeur) == VALEUR_DENIERS(monnaie.system.cout)
   }
 
   static triValeurEntiere() {
-    return Misc.ascending(item => Monnaie.valEntiere(item.system.cout))
+    return Misc.ascending(item => VALEUR_DENIERS(item.system.cout))
   }
 
   static async creerMonnaiesStandard(actor) {
@@ -65,29 +62,45 @@ export class Monnaie {
     return deniers;
   }
 
+  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 resteEnDeniers = Math.round(fortune * 100);
     let monnaies = actor.itemTypes['monnaie'];
     let updates = [];
-    let parValeur = Misc.classifyFirst(monnaies, it => Monnaie.valEntiere(it.system.cout));
-    for (let valeurDeniers of  [1000, 100, 10, 1]) {
+    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(resteEnDeniers / valeurDeniers);
         if (quantite != itemPiece.system.quantite) {
           updates.push({ _id: parValeur[valeurDeniers].id, 'system.quantite': quantite });
         }
-        resteEnDeniers -= quantite*valeurDeniers;
+        resteEnDeniers -= quantite * valeurDeniers;
       }
     }
     console.log('Monnaie.optimiserFortune', actor.name, 'total', fortune, 'parValeur', parValeur, 'updates', updates, 'reste', resteEnDeniers);
     if (updates.length > 0) {
       await actor.updateEmbeddedDocuments('Item', updates);
     }
-    if (resteEnDeniers > 0){
+    if (resteEnDeniers > 0) {
       // créer le reste en deniers fortune en deniers
       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-rencontre-sheet.js

@@ -1,4 +1,4 @@
-import { RdDRencontre } from "./item-rencontre.js";
+import { RdDRencontre } from "./item/item-rencontre.js";
 import { RdDItemSheet } from "./item-sheet.js";
 
 export class RdDRencontreItemSheet extends RdDItemSheet {
@@ -23,15 +23,8 @@ export class RdDRencontreItemSheet extends RdDItemSheet {
 
   /* -------------------------------------------- */
   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(),
@@ -51,15 +44,15 @@ export class RdDRencontreItemSheet extends RdDItemSheet {
   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);
 
@@ -67,10 +60,10 @@ export class RdDRencontreItemSheet extends RdDItemSheet {
   }
 
   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);
     

module/item-service-sheet.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.isGM || formData.isOwned ? '' : 'disabled';
+    return formData;
+  }
+
+  activateListeners(html) {
+    super.activateListeners(html);
+  }
+}

module/item-sheet.js

@@ -10,6 +10,7 @@ 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 for RdD specific items
@@ -60,13 +61,13 @@ export class RdDItemSheet extends ItemSheet {
       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
   }
@@ -135,11 +136,7 @@ export class RdDItemSheet extends ItemSheet {
       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')) {
       formData.isIngredientPotionBase = true;
@@ -157,36 +154,47 @@ export class RdDItemSheet extends ItemSheet {
   /** @override */
   activateListeners(html) {
     super.activateListeners(html);
-    let itemSheetDialog = this;
+    this.html = html;
 
-    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;
+
     this.form.ondragstart = (event) => this._onDragStart(event);
     this.form.ondrop = (event) => this._onDrop(event);
 
     // Select competence categorie
-    html.find(".categorie").change(event => this._onSelectCategorie(event));
+    this.html.find(".categorie").change(event => this._onSelectCategorie(event));
 
-    html.find('.sheet-competence-xp').change((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) => this._getEventActor(event).creerTacheDepuisLivre(this.item));
-    html.find('.consommer-potion').click((event) => this._getEventActor(event).consommerPotion(this.item));
-    html.find('.creer-potion-base').click((event) => this._getEventActor(event).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) => {
+    this.html.find('.alchimie-tache a').click((event) => {
       let actor = this._getEventActor(event);
       if (actor) {
         let recetteId = event.currentTarget.attributes['data-recette-id'].value;
@@ -198,12 +206,17 @@ export class RdDItemSheet extends ItemSheet {
       }
     });
 
-    html.find('.item-split').click(async event => RdDSheetUtility.splitItem(RdDSheetUtility.getItem(event, this.actor), this.actor, async () => itemSheetDialog.render(true)));
-    html.find('.item-edit').click(async event => RdDSheetUtility.getItem(event, this.actor)?.sheet.render(true));
-    html.find('.item-delete').click(async event => RdDUtility.confirmerSuppressionItem(this, RdDSheetUtility.getItem(event, this.actor)));
-    html.find('.item-vendre').click(async event => RdDSheetUtility.getItem(event, this.actor)?.proposerVente());
-    html.find('.item-montrer').click(async event => RdDSheetUtility.getItem(event, this.actor)?.postItem());
-    html.find('.item-action').click(async event => RdDSheetUtility.getItem(event, this.actor)?.actionPrincipale(this.actor, async () => itemSheetDialog.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) {
@@ -212,6 +225,7 @@ export class RdDItemSheet extends ItemSheet {
     return actor;
   }
 
+
   /* -------------------------------------------- */
   async _onSelectCategorie(event) {
     event.preventDefault();
@@ -219,7 +233,7 @@ 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);
     }
   }
 

module/item-signedraconique-sheet.js

@@ -1,5 +1,5 @@
 import { RdDItemSheet } from "./item-sheet.js";
-import { RdDItemSigneDraconique } from "./item-signedraconique.js";
+import { RdDItemSigneDraconique } from "./item/item-signedraconique.js";
 import { TMRUtility } from "./tmr-utility.js";
 
 /**
@@ -23,18 +23,9 @@ export class RdDSigneDraconiqueItemSheet extends RdDItemSheet {
 
   /* -------------------------------------------- */
   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;
   }
 

module/item.js

@@ -2,16 +2,18 @@ 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";
 
-const typesObjetsInventaire = [
+const typesInventaireMateriel = [
   "arme",
   "armure",
   "conteneur",
+  "faune",
   "gemme",
   "herbe",
   "ingredient",
-  "faune",
   "livre",
   "monnaie",
   "munition",
@@ -19,11 +21,17 @@ const typesObjetsInventaire = [
   "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 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/ 
@@ -57,6 +65,7 @@ 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",
@@ -69,11 +78,7 @@ export const defaultItemImg = {
 export class RdDItem extends Item {
 
   static getDefaultImg(itemType) {
-    return defaultItemImg[itemType];
-  }
-
-  static isItemInventaire(newLocal) {
-    return typesObjetsInventaire.includes(newLocal.type);
+    return game.system.rdd.itemClasses[itemType]?.defaultIcon ?? defaultItemImg[itemType];
   }
 
   static isFieldInventaireModifiable(type, field) {
@@ -92,6 +97,42 @@ export class RdDItem extends Item {
     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 getTypesOeuvres() {
+    return typesObjetsOeuvres
+  }
+
+  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);
+  }
+
+  static get defaultIcon() {
+    return undefined;
+  }
+
   getUniteQuantite() {
     switch (this.type) {
       case "monnaie": return "(Pièces)"
@@ -107,48 +148,24 @@ export class RdDItem extends Item {
     return '';
   }
 
-  constructor(itemData, context) {
-    if (!itemData.img) {
-      itemData.img = RdDItem.getDefaultImg(itemData.type);
-    }
-    super(itemData, context);
-  }
+  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'; }
 
-  static getItemTypesInventaire() {
-    return typesObjetsInventaire
-  }
+  isCompetence() { return typesObjetsCompetence.includes(this.type) }
+  isTemporel() { return typesObjetsTemporels.includes(this.type) }
+  isOeuvre() { return typesObjetsOeuvres.includes(this.type) }
+  isDraconique() { return typesObjetsDraconiques.includes(this.type) }
+  isEffet() { return typesObjetsEffet.includes(this.type) }
+  isConnaissance() { return typesObjetsConnaissance.includes(this.type) }
 
-  static getTypesOeuvres() {
-    return typesObjetsOeuvres
-  }
-
-  isCompetencePersonnage() {
-    return this.type == 'competence'
-  }
-  isCompetenceCreature() {
-    return this.type == 'competencecreature'
-  }
-  isCompetence() {
-    return typesObjetsCompetence.includes(this.type)
-  }
-  isInventaire() {
-    return RdDItem.isItemInventaire(this)
-  }
-  isOeuvre() {
-    return typesObjetsOeuvres.includes(this.type)
-  }
-  isDraconique() {
-    return typesObjetsDraconiques.includes(this.type)
-  }
-  isEffet() {
-    return typesObjetsEffet.includes(this.type)
-  }
-  isConnaissance() {
-    return typesObjetsConnaissance.includes(this.type)
-  }
-  isConteneur() {
-    return this.type == 'conteneur';
-  }
+  isInventaire(mode = 'materiel') { return RdDItem.getItemTypesInventaire(mode).includes(this.type); }
+  isAlcool() { return this.isNourritureBoisson() && this.system.boisson && this.system.alcoolise; }
+  isHerbeAPotion() { return this.type == 'herbe' && (this.system.categorie == 'Soin' || this.system.categorie == 'Repos'); }
 
   getItemGroup() {
     if (this.isInventaire()) return "equipement";
@@ -160,20 +177,43 @@ 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;
   }
 
-  isNourritureBoisson() {
-    return this.type == 'nourritureboisson';
+  async onFinPeriodeTemporel(oldTimestamp, newTimestamp) {
+    if (this.isTemporel() && this.actor) {
+      await this.onFinPeriode(oldTimestamp, newTimestamp);
+    }
+  }
+
+  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]);
   }
 
   isComestible() {
@@ -187,16 +227,6 @@ export class RdDItem extends Item {
     return '';
   }
 
-  isAlcool() {
-    return this.isNourritureBoisson() && this.system.boisson && this.system.alcoolise;
-  }
-
-  isHerbeAPotion() {
-    return this.type == 'herbe' && (this.system.categorie == 'Soin' || this.system.categorie == 'Repos');
-  }
-  isPotion() {
-    return this.type == 'potion';
-  }
   isCristalAlchimique() {
     return this.type == 'objet' && Grammar.toLowerCaseNoAccent(this.name) == 'cristal alchimique' && this.system.quantite > 0;
   }
@@ -205,16 +235,22 @@ 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 this.getEncHerbe();
       case 'gemme':
@@ -233,13 +269,21 @@ export class RdDItem extends Item {
   }
 
   valeurTotale() {
-    return this.getQuantite() * this.valeur()
+    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.isInventaire()) {
@@ -281,7 +325,7 @@ export class RdDItem extends Item {
     }
     return undefined;
   }
-  
+
   /* -------------------------------------------- */
   async actionPrincipale(actor, onActionItem = async () => { }) {
     if (!this.getActionPrincipale()) {
@@ -352,7 +396,7 @@ export class RdDItem extends Item {
     await item.delete();
   }
 
-  async quantiteIncDec(nombre, options = { diminuerQuantite: true, supprimerSiZero: false }) {
+  async quantiteIncDec(nombre, options = { supprimerSiZero: false }) {
     const quantite = Number(this.system.quantite ?? -1);
     if (quantite >= 0) {
       const reste = Math.max(quantite + Number(nombre), 0);
@@ -389,7 +433,7 @@ export class RdDItem extends Item {
       return [false, `Impossible de regrouper ${this.name} avec ${other.name}`];
     }
     else {
-      const excludedProperties = ['quantite', 'cout', 'encTotal'];
+      const excludedProperties = ['quantite', 'cout', 'encTotal', 'environnement'];
       if (this.isComestible()) {
         excludedProperties.push('sust', 'encombrement');
       }
@@ -407,54 +451,63 @@ 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);
+        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));
+        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`]().filter(it => it != undefined);
+    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)
     });
   }
 
+  getChatItemTemplate() {
+    return 'systems/foundryvtt-reve-de-dragon/templates/post-item.html';
+  }
+
   static propertyIfDefined(name, val, condition = true) {
     return condition ? `<b>${name}</b>: ${val}` : undefined;
   }
@@ -703,5 +756,4 @@ export class RdDItem extends Item {
       ...this._inventaireTemplateChatData()
     ]
   }
-
 }

module/item/item-rencontre.js

@@ -1,4 +1,5 @@
-import { EffetsRencontre } from "./effets-rencontres.js";
+import { EffetsRencontre } from "../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/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/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/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/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 { Environnement } from "./environnement.js";
 import { Grammar } from "./grammar.js";
+import { Monnaie } from "./item-monnaie.js";
+import { RdDItem } from "./item.js";
+import { RdDTimestamp } from "./rdd-timestamp.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"; }
@@ -236,7 +273,7 @@ class _10_3_0_Inventaire extends Migration {
   }
   _updatesMonnaies(items) {
     return items
-      .filter(it => ['monnaie'].includes(it.type) && it.system.cout == undefined)
+      .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 } });
   }
 }
@@ -259,9 +296,129 @@ class _10_3_0_FrequenceEnvironnement extends Migration {
   }
 }
 
+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(),
@@ -269,7 +426,10 @@ export class Migrations {
       new _10_2_5_ArmesTirLancer(),
       new _10_2_10_DesirLancinant_IdeeFixe(),
       new _10_3_0_Inventaire(),
-      new _10_3_0_FrequenceEnvironnement()
+      new _10_3_0_FrequenceEnvironnement(),
+      new _10_3_17_Monnaies(),
+      new _10_4_6_ServicesEnCommerces(),
+      new _10_5_0_UpdatePeriodicite(),
     ];
   }
 
@@ -284,18 +444,12 @@ export class Migrations {
   }
 
   migrate() {
-    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 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}`
@@ -321,4 +475,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

@@ -46,6 +46,9 @@ export class Misc {
       : '';
   }
 
+  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
@@ -135,11 +138,11 @@ export class Misc {
   }
 
   static isRollModeHiddenToPlayer() {
-      switch (game.settings.get("core", "rollMode")) {
-        case CONST.DICE_ROLL_MODES.BLIND:
-        case CONST.DICE_ROLL_MODES.SELF: return true;
-      }
-      return false
+    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) {
@@ -150,11 +153,11 @@ export class Misc {
     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/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 => this.fillData() }
+    };
 
     // 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,13 @@
     game.system.rdd.calendrier.showAstrologieEditor();
   }
 
-  /* -------------------------------------------- */  
-  fillData( ) {
+  /* -------------------------------------------- */
+  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 => this.quitDialog() }
+      },
     };
-
-    // 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()) {
@@ -87,17 +97,4 @@ export class RdDAstrologieJoueur extends Dialog {
   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,7 +12,7 @@ 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"
     };
@@ -23,16 +23,40 @@ export class RdDCalendrierEditeur extends Dialog {
     this.calendrierData = calendrierData;
   }
 
-  /* -------------------------------------------- */
-  fillData() {
-    this.calendrierData.annee = $("input[name='annee']").val();
-    this.calendrierData.moisKey = $("select[name='nomMois']").val();
-    this.calendrierData.heureKey = $("select[name='nomHeure']").val();
-    this.calendrierData.jourMois = $("select[name='jourMois']").val();
-    this.calendrierData.minutesRelative = $("select[name='minutesRelative']").val();
+  activateListeners(html) {
+    super.activateListeners(html);
+    this.html = html;
 
-    console.log("UPDATE  ", this.calendrierData);
-    this.calendrier.saveEditeur(this.calendrierData)
+    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))
   }
 
   /* -------------------------------------------- */
@@ -40,21 +64,4 @@ export class RdDCalendrierEditeur extends Dialog {
     this.calendrierData = duplicate(calendrierData);
   }
 
-  /* -------------------------------------------- */
-  activateListeners(html) {
-    super.activateListeners(html);
-
-    let calendrierData = this.calendrierData;
-
-    $(function () {
-      console.log(calendrierData);
-      $("input[name='nomMois']").val(calendrierData.moisKey);
-      $("select[name='nomHeure']").val(calendrierData.heureKey);
-      $("select[name='jourMois']").val(calendrierData.jourMois);
-      $("select[name='minutesRelative']").val(calendrierData.minutesRelative);
-      $("select[name='annee']").val(calendrierData.annee);
-    });
-
-  }
-
 }

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,478 +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(HIDE_DICE); // Ensure always up-to-date
     }
-    console.log('RdDCalendrier.constructor()', 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) {
-    const listNombreAstral = this.getListeNombreAstral();
-    let astralData = listNombreAstral.find((nombreAstral, i) => nombreAstral.index == indexDate);
-    return astralData?.nombreAstral;
-  }
-
-  /* -------------------------------------------- */
-  async rebuildListeNombreAstral(showDice = HIDE_DICE) {
-    if (Misc.isUniqueConnectedGM()) {
-      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);
-        }
-      }
-      game.settings.set(SYSTEM_RDD, "liste-nombre-astral", newList);
-      this.listeNombreAstral = newList;
-    }
-  }
-
-  /* -------------------------------------------- */
-  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.annee = this.calendrier.annee;
-    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 = `${calendrier.jourMois} ${calendrier.nomMois} ${calendrier.annee} (${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.annee = Number(calendrierData.annee);
-    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;
@@ -647,5 +147,355 @@ 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
+    }
+  }
+
+  /* -------------------------------------------- */
+  getCurrentNombreAstral() {
+    return this.getNombreAstral(this.timestamp.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) {
+    const listNombreAstral = this.getListeNombreAstral();
+    let astralData = listNombreAstral.find((nombreAstral, i) => nombreAstral.index == indexDate);
+    return astralData?.nombreAstral;
+  }
+
+  /* -------------------------------------------- */
+  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(indexHeure) {
+    await this.setNewTimestamp(new RdDTimestamp({ indexDate: this.timestamp.indexDate + (this.timestamp.heure < indexHeure ? 0 : 1) }).addHeures(indexHeure))
+  }
+
+  /* -------------------------------------------- */
+  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);
+  }
+
+  getHeureChance(heure) {
+    return heure + (this.getCurrentNombreAstral() ?? 1) - 1;
+  }
+
+  /* -------------------------------------------- */
+  getHeuresChanceMalchance(heureNaissance) {
+    let defHeure = RdDTimestamp.findHeure(heureNaissance);
+    if (defHeure) {
+      const signe = h => h % RDD_HEURES_PAR_JOUR;
+      const chance = this.getHeureChance(defHeure.heure);
+      return [
+        { ajustement: "+4", heures: [signe(chance)] },
+        { ajustement: "+2", heures: [signe(chance + 4), signe(chance + 8)] },
+        { ajustement: "-4", heures: [signe(chance + 6)] },
+        { ajustement: "-2", heures: [signe(chance + 3), signe(chance + 9)] }
+      ];
+    }
+    return [];
+  }
+
+  /* -------------------------------------------- */
+  getAjustementAstrologique(heureNaissance, name = undefined) {
+    let defHeure = RdDTimestamp.findHeure(heureNaissance);
+    if (defHeure) {
+      const chance = this.getHeureChance(defHeure.heure);
+      const ecartChance = (chance - this.timestamp.heure) % 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 = `${calendrier.jourDuMois} ${calendrier.mois.label} ${calendrier.annee} (${calendrier.mois.saison})`
+    if (game.user.isGM) {
+      dateHTML = dateHTML + " - NA: " + (this.getCurrentNombreAstral() ?? "?");
+    }
+    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;
+    });
+
+    calendrierData.heuresParActeur = {};
+    game.actors.filter(it => it.isPersonnage() && it.hasPlayerOwner).forEach(actor => {
+      let heureNaissance = actor.getHeureNaissance();
+      if (heureNaissance) {
+        calendrierData.heuresParActeur[actor.name] = this.getHeuresChanceMalchance(heureNaissance);
+      }
+    })
+    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-combat.js

@@ -162,7 +162,6 @@ export class RdDCombatManager extends Combat {
         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)");
         }
-        console.log(">>>>", arme)
         if ((arme.system.unemain && arme.system.competence) ||
           (arme.system.competence.toLowerCase().includes("corps à corps"))) {
           actions.push(RdDCombatManager.$prepareAttaqueArme({
@@ -248,7 +247,7 @@ export class RdDCombatManager extends Combat {
     }
     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())
@@ -767,7 +766,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()) {
@@ -886,7 +885,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;
     }
 
@@ -1319,35 +1318,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

@@ -206,16 +206,16 @@ export class RdDCommands {
     let rollMode = game.settings.get("core", "rollMode");
     if (["gmroll", "blindroll"].includes(rollMode)) {
       msg["whisper"] = ChatMessage.getWhisperRecipients("GM");
-    } 
-    if (rollMode === "blindroll"){
+    }
+    if (rollMode === "blindroll") {
       msg["blind"] = true;
-    } 
+    }
     msg["type"] = 0;
 
     if (!this.commandsTable) {
       this._registerCommands();
     }
-  
+
     let command = commandLine[0].toLowerCase();
     if (this._isCommandHandled(command)) {
       let params = commandLine.slice(1);
@@ -225,7 +225,7 @@ export class RdDCommands {
     return false;
   }
 
-  _isCommandHandled(command){
+  _isCommandHandled(command) {
     return this.commandsTable[command] != undefined;
   }
 
@@ -331,7 +331,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);
@@ -448,17 +448,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;
   }
 

module/rdd-herbes.js

@@ -1,7 +1,6 @@
-import { RdDUtility } from "./rdd-utility.js";
-import { RdDCalendrier } from "./rdd-calendrier.js";
 import { Grammar } from "./grammar.js";
 import { SystemCompendiums } from "./settings/system-compendiums.js";
+import { RdDTimestamp } from "./rdd-timestamp.js";
 
 /* -------------------------------------------- */
 export class RdDHerbes extends Item {
@@ -29,7 +28,7 @@ export class RdDHerbes extends Item {
   }
 
   /* -------------------------------------------- */
-  static async updatePotionData(formData) {
+  static async addPotionFormData(formData) {
     formData.isSoins = formData.system.categorie.includes('Soin');
     formData.isRepos = formData.system.categorie.includes('Repos');
     if (formData.isSoins) {
@@ -40,9 +39,8 @@ export class RdDHerbes extends Item {
     }
     formData.herbesSoins = RdDHerbes.buildHerbesList(this.herbesSoins, 12);
     formData.herbesRepos = RdDHerbes.buildHerbesList(this.herbesRepos, 7);
-    formData.jourMoisOptions = RdDCalendrier.buildJoursMois();
-    formData.dateActuelle = game.system.rdd.calendrier.getDateFromIndex();
-    formData.splitDate = game.system.rdd.calendrier.getDayMonthFromIndex(formData.system.prdate);
+    formData.dateActuelle = game.system.rdd.calendrier.dateCourante();
+    formData.enchantement = RdDTimestamp.splitIndexDate(formData.system.prdate);
   }
 
   /* -------------------------------------------- */

module/rdd-hotbar-drop.js

@@ -1,4 +1,3 @@
-import { Misc } from "./misc.js";
 
 export class RdDHotbar {
 

module/rdd-main.js

@@ -1,20 +1,6 @@
-/**
- * RdD system
- * Author: LeRatierBretonnien
- * Software License: GNU GPLv3
- */
-
-/* -------------------------------------------- */
-
-/* -------------------------------------------- */
-// Import Modules
 import { SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
 import { RdDActor } from "./actor.js";
-import { RdDItemSheet } from "./item-sheet.js";
-import { RdDActorSheet } from "./actor-sheet.js";
-import { RdDActorCreatureSheet } from "./actor-creature-sheet.js";
-import { RdDActorVehiculeSheet } from "./actor-vehicule-sheet.js";
-import { RdDActorEntiteSheet } from "./actor-entite-sheet.js";
+import { RdDItem } from "./item.js";
 import { RdDUtility } from "./rdd-utility.js";
 import { TMRUtility } from "./tmr-utility.js";
 import { RdDCalendrier } from "./rdd-calendrier.js";
@@ -29,317 +15,323 @@ import { ReglesOptionelles } from "./settings/regles-optionelles.js";
 import { RdDHotbar } from "./rdd-hotbar-drop.js"
 import { EffetsDraconiques } from "./tmr/effets-draconiques.js";
 import { RdDHerbes } from "./rdd-herbes.js";
-import { RdDItem } from "./item.js";
 import { RdDDice } from "./rdd-dice.js";
 import { RdDPossession } from "./rdd-possession.js";
-import { RdDSigneDraconiqueItemSheet } from "./item-signedraconique-sheet.js";
 import { Misc } from "./misc.js";
 import { Migrations } from './migrations.js';
 import { DialogChronologie } from "./dialog-chronologie.js";
 import { SystemCompendiums } from "./settings/system-compendiums.js";
-import { RdDRencontreItemSheet } from "./item-rencontre-sheet.js";
-import { TMRRencontres } from "./tmr-rencontres.js";
-import { RdDHerbeItemSheet } from "./item-herbe-sheet.js";
 import { Environnement } from "./environnement.js";
+import { RdDItemService } from "./item/item-service.js";
+import { RdDBaseActor } from "./actor/base-actor.js";
+import { RdDCommerceSheet } from "./actor/commerce-sheet.js";
+import { RdDCommerce } from "./actor/commerce.js";
+import { RdDTimestamp } from "./rdd-timestamp.js";
+import { RdDItemMaladie } from "./item/maladie.js";
+import { RdDItemPoison } from "./item/poison.js";
+import { RdDItemSigneDraconique } from "./item/item-signedraconique.js";
+import { RdDItemQueue } from "./item/queue.js";
+import { RdDItemOmbre } from "./item/ombre.js";
+import { RdDItemSouffle } from "./item/souffle.js";
+import { RdDRencontre } from "./item/item-rencontre.js";
+
+import { RdDActorSheet } from "./actor-sheet.js";
+import { RdDActorCreatureSheet } from "./actor-creature-sheet.js";
+import { RdDActorVehiculeSheet } from "./actor-vehicule-sheet.js";
+import { RdDActorEntiteSheet } from "./actor-entite-sheet.js";
+import { RdDItemSheet } from "./item-sheet.js";
+import { RdDServiceItemSheet } from "./item-service-sheet.js";
+import { RdDHerbeItemSheet } from "./item-herbe-sheet.js";
+import { RdDRencontreItemSheet } from "./item-rencontre-sheet.js";
 import { RdDIngredientItemSheet } from "./item-ingredient-sheet.js";
 import { RdDFauneItemSheet } from "./item-faune-sheet.js";
 import { RdDConteneurItemSheet } from "./item-conteneur-sheet.js";
+import { RdDSigneDraconiqueItemSheet } from "./item-signedraconique-sheet.js";
 
-/* -------------------------------------------- */
-/*  Foundry VTT Initialization                  */
-/* -------------------------------------------- */
+import { TMRRencontres } from "./tmr-rencontres.js";
 
+/**
+ * RdD system
+ * Author: LeRatierBretonnien
+ * Software License: GNU GPLv3
+ */
+export class SystemReveDeDragon {
 
-
-/************************************************************************************/
-Hooks.once("init", async function () {
-  console.log(`Initializing Reve de Dragon System`);
-
-  // preload handlebars templates
-  RdDUtility.preloadHandlebarsTemplates();
-  // Create useful storage space
-  game.system.rdd = {
-    TMRUtility,
-    RdDUtility,
-    RdDHotbar,
-    RdDPossession,
+  static start() {
+    const system = new SystemReveDeDragon();
+    Hooks.once('init', async () => await system.onInit());
+    Hooks.once('diceSoNiceReady', (dice3d) => RdDDice.diceSoNiceReady(dice3d));
   }
 
-  /* -------------------------------------------- */
-  game.settings.register(SYSTEM_RDD, "accorder-entite-cauchemar", {
-    name: "Accorder le rêve aux entités",
-    hint: "A quel moment les personnages doivent accorder leur rêve aux entités de cauchemar",
-    scope: "world",
-    config: true,
-    type: String,
-    choices: {           // If choices are defined, the resulting setting will be a select menu
-      "avant-attaque": "Avant l'attaque",
-      "avant-defense": "Avant la défense",
-      "avant-encaissement": "Avant l'encaissement",
-    },
-    default: "avant-encaissement"
-  });
-
-  /* -------------------------------------------- */
-  game.settings.register(SYSTEM_RDD, "calendrier", {
-    name: "calendrier",
-    scope: "world",
-    config: false,
-    default: RdDCalendrier.createCalendrierInitial(),
-    type: Object
-  });
-
-  /* -------------------------------------------- */
-  game.settings.register(SYSTEM_RDD, "migration-png-webp-1.5.34", {
-    name: "calendrier",
-    scope: "world",
-    config: false,
-    default: false,
-    type: Boolean
-  });
-
-  /* -------------------------------------------- */
-  game.settings.register(SYSTEM_RDD, "liste-nombre-astral", {
-    name: "liste-nombre-astral",
-    scope: "world",
-    config: false,
-    default: [],
-    type: Object
-  });
-
-  /* -------------------------------------------- */
-  game.settings.register(SYSTEM_RDD, "calendrier-pos", {
-    name: "calendrierPos",
-    scope: "client",
-    config: false,
-    default: RdDCalendrier.createCalendrierPos(),
-    type: Object
-  });
-
-
-  /* -------------------------------------------- */
-  game.settings.register(SYSTEM_RDD, "supprimer-dialogues-combat-chat", {
-    name: "Supprimer les dialogues de combat",
-    hint: "Si désactivée, tous les dialogues de combat sont conservés dans la conversation",
-    scope: "world",
-    config: true,
-    default: true,
-    type: Boolean
-  });
-  /* -------------------------------------------- */
-  game.settings.register(SYSTEM_RDD, "activer-sons-audio", {
-    name: "Activer les bruitages intégrés",
-    hint: "Si activé, certaines actions en jeu déclenchent un son d'ambiance",
-    scope: "world",
-    config: true,
-    default: true,
-    type: Boolean
-  });
-  /* -------------------------------------------- */
-  game.settings.register(SYSTEM_RDD, "appliquer-famine-soif", {
-    name: "Notifier de la famine et la soif pour",
-    hint: "Indique si les cas de famine et de soif seront indiqués durant Château Dormant",
-    scope: "world",
-    config: true,
-    type: String,
-    choices: {
-      "aucun": "ni la famine, ni la soif",
-      "famine": "seulement la famine",
-      "famine-soif": "la famine et la soif",
-    },
-    default: "aucun"
-  });
-
-  /* -------------------------------------------- */
-  // Set an initiative formula for the system 
-  CONFIG.Combat.initiative = {
-    formula: "1+(1d6/10)",
-    decimals: 2
-  };
-
-  /* -------------------------------------------- */
-  game.socket.on(SYSTEM_SOCKET_ID, async (sockmsg) => {
-    console.log(">>>>> MSG RECV", sockmsg);
-    try {
-      RdDUtility.onSocketMessage(sockmsg);
-      RdDCombat.onSocketMessage(sockmsg);
-      ChatUtility.onSocketMessage(sockmsg);
-      RdDActor.onSocketMessage(sockmsg);
-    } catch (e) {
-      console.error('game.socket.on(SYSTEM_SOCKET_ID) Exception: ', sockmsg, ' => ', e)
+  constructor() {
+    this.RdDUtility = RdDUtility;
+    this.RdDHotbar = RdDHotbar;
+    this.itemClasses = {
+      service: RdDItemService,
+      maladie: RdDItemMaladie,
+      poison: RdDItemPoison,
+      queue: RdDItemQueue,
+      ombre: RdDItemOmbre,
+      souffle: RdDItemSouffle,
+      signedraconique: RdDItemSigneDraconique,
+      rencontre: RdDRencontre
+    }
+    this.actorClasses = {
+      creature: RdDActor,
+      entite: RdDActor,
+      personnage: RdDActor,
+      vehicule: RdDActor,
+      commerce: RdDCommerce,
     }
-  });
-
-  /* -------------------------------------------- */
-  // Define custom Entity classes
-  CONFIG.Actor.documentClass = RdDActor;
-  CONFIG.Item.documentClass = RdDItem;
-  CONFIG.RDD = {
-    resolutionTable: RdDResolutionTable.resolutionTable,
-    carac_array: RdDUtility.getCaracArray(),
-    ajustementsConditions: RdDUtility.getAjustementsConditions(),
-    difficultesLibres: RdDUtility.getDifficultesLibres()
   }
 
   /* -------------------------------------------- */
-  // Register sheet application classes
-  Actors.unregisterSheet("core", ActorSheet);
-  Actors.registerSheet(SYSTEM_RDD, RdDActorSheet, { types: ["personnage"], makeDefault: true });
-  Actors.registerSheet(SYSTEM_RDD, RdDActorCreatureSheet, { types: ["creature"], makeDefault: true });
-  Actors.registerSheet(SYSTEM_RDD, RdDActorVehiculeSheet, { types: ["vehicule"], makeDefault: true });
-  Actors.registerSheet(SYSTEM_RDD, RdDActorEntiteSheet, { types: ["entite"], makeDefault: true });
-  Items.unregisterSheet("core", ItemSheet);
+  /*  Foundry VTT Initialization                  */
+  /* -------------------------------------------- */
+  async onInit() {
+    game.system.rdd = this;
 
-  RdDItemSheet.register(RdDSigneDraconiqueItemSheet);
-  RdDItemSheet.register(RdDRencontreItemSheet);
-  RdDItemSheet.register(RdDConteneurItemSheet);
-  RdDItemSheet.register(RdDHerbeItemSheet);
-  RdDItemSheet.register(RdDFauneItemSheet);
-  RdDItemSheet.register(RdDIngredientItemSheet);
+    console.log(`Initializing Reve de Dragon System`);
 
-  Items.registerSheet(SYSTEM_RDD, RdDItemSheet, {
-    types: [
-      "competence", "competencecreature",
-      "recettealchimique", "musique", "chant", "danse", "jeu", "recettecuisine", "oeuvre",
-      "objet", "arme", "armure", "livre", "potion", "munition",
-      "monnaie", "nourritureboisson", "gemme",
-      "meditation", "queue", "ombre", "souffle", "tete", "casetmr", "sort", "sortreserve",
-      "nombreastral", "tache", "maladie", "poison", "possession",
-      "tarot", "extraitpoetique"
-    ], makeDefault: true
-  });
-  CONFIG.Combat.documentClass = RdDCombatManager;
+    // preload handlebars templates
+    RdDUtility.preloadHandlebarsTemplates();
 
-  // préparation des différents modules
-  SystemCompendiums.init();
-  DialogChronologie.init();
-  ReglesOptionelles.init();
-  RdDUtility.init();
-  RdDDice.init();
-  RdDCommands.init();
-  RdDCombat.init();
-  RdDCombatManager.init();
-  RdDTokenHud.init();
-  RdDActor.init();
-  RddCompendiumOrganiser.init();
-  EffetsDraconiques.init()
-  TMRUtility.init();
-  RdDHotbar.initDropbar();
-  RdDPossession.init();
-  TMRRencontres.init();
-  Environnement.init();
-});
+    /* -------------------------------------------- */
+    this.initSystemSettings();
 
-/* -------------------------------------------- */
-function messageDeBienvenue() {
-  if (game.user.isGM) {
-    ChatUtility.removeChatMessageContaining('<div id="message-bienvenue-rdd">');
-    ChatMessage.create({
-      user: game.user.id,
-      content: `<div id="message-bienvenue-rdd"><span class="rdd-roll-part">Bienvenue dans le Rêve des Dragons !</span>
+    /* -------------------------------------------- */
+    // Set an initiative formula for the system 
+    CONFIG.Combat.initiative = {
+      formula: "1+(1d6/10)",
+      decimals: 2
+    };
+
+    /* -------------------------------------------- */
+    game.socket.on(SYSTEM_SOCKET_ID, async (sockmsg) => {
+      console.log(">>>>> MSG RECV", sockmsg);
+      try {
+        RdDUtility.onSocketMessage(sockmsg);
+        RdDCombat.onSocketMessage(sockmsg);
+        ChatUtility.onSocketMessage(sockmsg);
+        RdDBaseActor.onSocketMessage(sockmsg);
+      } catch (e) {
+        console.error('game.socket.on(SYSTEM_SOCKET_ID) Exception: ', sockmsg, ' => ', e)
+      }
+    });
+
+    /* -------------------------------------------- */
+    // Define custom Entity classes
+    CONFIG.Actor.documentClass = RdDBaseActor;
+    CONFIG.Item.documentClass = RdDItem;
+    CONFIG.RDD = {
+      resolutionTable: RdDResolutionTable.resolutionTable,
+      carac_array: RdDUtility.getCaracArray(),
+      ajustementsConditions: RdDUtility.getAjustementsConditions(),
+      difficultesLibres: RdDUtility.getDifficultesLibres()
+    }
+
+    /* -------------------------------------------- */
+    // Register sheet application classes
+    Actors.unregisterSheet("core", ActorSheet);
+    Actors.registerSheet(SYSTEM_RDD, RdDCommerceSheet, { types: ["commerce"], makeDefault: true });
+    Actors.registerSheet(SYSTEM_RDD, RdDActorSheet, { types: ["personnage"], makeDefault: true });
+    Actors.registerSheet(SYSTEM_RDD, RdDActorCreatureSheet, { types: ["creature"], makeDefault: true });
+    Actors.registerSheet(SYSTEM_RDD, RdDActorVehiculeSheet, { types: ["vehicule"], makeDefault: true });
+    Actors.registerSheet(SYSTEM_RDD, RdDActorEntiteSheet, { types: ["entite"], makeDefault: true });
+    Items.unregisterSheet("core", ItemSheet);
+
+    RdDItemSheet.register(RdDSigneDraconiqueItemSheet);
+    RdDItemSheet.register(RdDRencontreItemSheet);
+    RdDItemSheet.register(RdDConteneurItemSheet);
+    RdDItemSheet.register(RdDHerbeItemSheet);
+    RdDItemSheet.register(RdDFauneItemSheet);
+    RdDItemSheet.register(RdDIngredientItemSheet);
+    RdDItemSheet.register(RdDServiceItemSheet);
+
+    Items.registerSheet(SYSTEM_RDD, RdDItemSheet, {
+      types: [
+        "competence", "competencecreature",
+        "recettealchimique", "musique", "chant", "danse", "jeu", "recettecuisine", "oeuvre",
+        "objet", "arme", "armure", "livre", "potion", "munition",
+        "monnaie", "nourritureboisson", "gemme",
+        "meditation", "queue", "ombre", "souffle", "tete", "casetmr", "sort", "sortreserve",
+        "nombreastral", "tache", "maladie", "poison", "possession",
+        "tarot", "extraitpoetique"
+      ], makeDefault: true
+    });
+    CONFIG.Combat.documentClass = RdDCombatManager;
+
+    // préparation des différents modules
+    RdDTimestamp.init();
+    SystemCompendiums.init();
+    DialogChronologie.init();
+    ReglesOptionelles.init();
+    RdDUtility.init();
+    RdDDice.init();
+    RdDCommands.init();
+    RdDCombat.init();
+    RdDCombatManager.init();
+    RdDTokenHud.init();
+    RdDBaseActor.init();
+    RddCompendiumOrganiser.init();
+    EffetsDraconiques.init()
+    TMRUtility.init();
+    RdDHotbar.initDropbar();
+    RdDPossession.init();
+    TMRRencontres.init();
+    Environnement.init();
+
+    Hooks.once('ready', () => this.onReady());
+  }
+
+  initSystemSettings() {
+    game.settings.register(SYSTEM_RDD, "accorder-entite-cauchemar", {
+      name: "Accorder le rêve aux entités",
+      hint: "A quel moment les personnages doivent accorder leur rêve aux entités de cauchemar",
+      scope: "world",
+      config: true,
+      type: String,
+      choices: {
+        "avant-attaque": "Avant l'attaque",
+        "avant-defense": "Avant la défense",
+        "avant-encaissement": "Avant l'encaissement",
+      },
+      default: "avant-encaissement"
+    });
+
+    /* -------------------------------------------- */
+    game.settings.register(SYSTEM_RDD, "liste-nombre-astral", {
+      name: "liste-nombre-astral",
+      scope: "world",
+      config: false,
+      default: [],
+      type: Object
+    });
+
+    /* -------------------------------------------- */
+    game.settings.register(SYSTEM_RDD, "calendrier-pos", {
+      name: "calendrierPos",
+      scope: "client",
+      config: false,
+      default: RdDCalendrier.createCalendrierPos(),
+      type: Object
+    });
+
+
+    /* -------------------------------------------- */
+    game.settings.register(SYSTEM_RDD, "supprimer-dialogues-combat-chat", {
+      name: "Supprimer les dialogues de combat",
+      hint: "Si désactivée, tous les dialogues de combat sont conservés dans la conversation",
+      scope: "world",
+      config: true,
+      default: true,
+      type: Boolean
+    });
+
+    /* -------------------------------------------- */
+    game.settings.register(SYSTEM_RDD, "activer-sons-audio", {
+      name: "Activer les bruitages intégrés",
+      hint: "Si activé, certaines actions en jeu déclenchent un son d'ambiance",
+      scope: "world",
+      config: true,
+      default: true,
+      type: Boolean
+    });
+    /* -------------------------------------------- */
+    game.settings.register(SYSTEM_RDD, "appliquer-famine-soif", {
+      name: "Notifier de la famine et la soif pour",
+      hint: "Indique si les cas de famine et de soif seront indiqués durant Château Dormant",
+      scope: "world",
+      config: true,
+      type: String,
+      choices: {
+        "aucun": "ni la famine, ni la soif",
+        "famine": "seulement la famine",
+        "famine-soif": "la famine et la soif",
+      },
+      default: "aucun"
+    });
+  }
+
+  async onReady() {
+
+    /* -------------------------------------------- */
+    /*  Foundry VTT Initialization                  */
+    /* -------------------------------------------- */
+    // CSS patch for v9
+    if (game.version) {
+      let sidebar = document.getElementById("sidebar");
+      sidebar.style.width = "min-content";
+    }
+  
+    if (Misc.isUniqueConnectedGM()) {
+      new Migrations().migrate();
+    }
+
+    StatusEffects.onReady();
+    RdDHerbes.initializeHerbes();
+    RdDDice.onReady();
+    /* -------------------------------------------- */
+    /* Affiche/Init le calendrier */
+    let calendrier = new RdDCalendrier();
+    let templatePath = "systems/foundryvtt-reve-de-dragon/templates/calendar-template.html";
+    let templateData = {};
+    renderTemplate(templatePath, templateData).then(html => {
+      calendrier.render(true);
+    });
+    game.system.rdd.calendrier = calendrier; // Reference;
+
+    // Avertissement si joueur sans personnage
+    if (!game.user.isGM && game.user.character == undefined) {
+      ui.notifications.info("Attention ! Vous n'êtes connecté à aucun personnage !");
+      ChatMessage.create({
+        content: "<b>ATTENTION</b> Le joueur " + game.user.name + " n'est connecté à aucun personnage !",
+        user: game.user.id
+      });
+    }
+    if (Misc.isUniqueConnectedGM()) {
+      this.messageDeBienvenue();
+      this.registerUsageCount(SYSTEM_RDD);
+    }
+  }
+  
+  /* -------------------------------------------- */
+   messageDeBienvenue() {
+    if (game.user.isGM) {
+      ChatUtility.removeChatMessageContaining('<div id="message-bienvenue-rdd">');
+      ChatMessage.create({
+        user: game.user.id,
+        content: `<div id="message-bienvenue-rdd"><span class="rdd-roll-part">Bienvenue dans le Rêve des Dragons !</span>
       <br>Vous trouverez quelques informations pour démarrer dans ce document : @Compendium[foundryvtt-reve-de-dragon.rappel-des-regles.7uGrUHGdPu0EmIu2]{Documentation MJ/Joueurs}
       <br>La commande <code>/aide</code> dans le chat permet de voir les commandes spécifiques à Rêve de Dragon.</div>
       ` });
-  }
-}
-
-/* -------------------------------------------- */
-// Register world usage statistics
-function registerUsageCount(registerKey) {
-  if (game.user.isGM) {
-    game.settings.register("world", "world-key", {
-      name: "Unique world key",
-      scope: "world",
-      config: false,
-      default: "NONE",
-      type: String
-    });
-
-    let worldKey = game.settings.get("world", "world-key")
-    if (worldKey == undefined || worldKey == "") {
-      worldKey = randomID(32)
-      game.settings.set("world", "world-key", worldKey)
     }
-    let regURL = `https://www.uberwald.me/fvtt_appcount/count.php?name="${registerKey}"&worldKey="${worldKey}"&version="${game.release.generation}.${game.release.build}"&system="${game.system.id}"&systemversion="${game.system.version}"`
-    $.ajax(regURL)
-    /* -------------------------------------------- */
-  }
-}
-
-/* -------------------------------------------- */
-/*  Foundry VTT Initialization                  */
-/* -------------------------------------------- */
-Hooks.once("ready", async function () {
-  await migrationPngWebp_1_5_34()
-  if (Misc.isUniqueConnectedGM()) {
-    new Migrations().migrate();
   }
 
-  StatusEffects.onReady();
-  RdDHerbes.initializeHerbes();
-  RdDDice.onReady();
   /* -------------------------------------------- */
-  /* Affiche/Init le calendrier */
-  let calendrier = new RdDCalendrier();
-  let templatePath = "systems/foundryvtt-reve-de-dragon/templates/calendar-template.html";
-  let templateData = {};
-  renderTemplate(templatePath, templateData).then(html => {
-    calendrier.render(true);
-  });
-  game.system.rdd.calendrier = calendrier; // Reference;
+  // Register world usage statistics
+  async registerUsageCount(registerKey) {
+    if (game.user.isGM) {
+      game.settings.register("world", "world-key", {
+        name: "Unique world key",
+        scope: "world",
+        config: false,
+        default: "NONE",
+        type: String
+      });
 
-  // Avertissement si joueur sans personnage
-  if (!game.user.isGM && game.user.character == undefined) {
-    ui.notifications.info("Attention ! Vous n'êtes connecté à aucun personnage !");
-    ChatMessage.create({
-      content: "<b>ATTENTION</b> Le joueur " + game.user.name + " n'est connecté à aucun personnage !",
-      user: game.user.id
-    });
-  }
-  if (Misc.isUniqueConnectedGM()) {
-    messageDeBienvenue();
-    registerUsageCount(SYSTEM_RDD);
-  }
-});
-
-async function migrationPngWebp_1_5_34() {
-  if (!game.settings.get(SYSTEM_RDD, "migration-png-webp-1.5.34")) {
-    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) });
+      let worldKey = game.settings.get("world", "world-key")
+      if (worldKey == undefined || worldKey == "") {
+        worldKey = randomID(32)
+        game.settings.set("world", "world-key", worldKey)
       }
-      const actorItemsToUpdate = prepareDocumentsImgUpdate(actor.items);
-      actor.updateEmbeddedDocuments('Item', actorItemsToUpdate);
-    });
-    game.settings.set(SYSTEM_RDD, "migration-png-webp-1.5.34", true)
-  }
-
-  // CSS patch for v9
-  if (game.version) {
-    let sidebar = document.getElementById("sidebar");
-    sidebar.style.width = "min-content";
+      let regURL = `https://www.uberwald.me/fvtt_appcount/count.php?name="${registerKey}"&worldKey="${worldKey}"&version="${game.release.generation}.${game.release.build}"&system="${game.system.id}"&systemversion="${game.system.version}"`
+      $.ajax(regURL)
+      /* -------------------------------------------- */
+    }
   }
 
 }
 
-/* -------------------------------------------- */
-/*  Dice-so-nice ready                          */
-/* -------------------------------------------- */
-Hooks.once('diceSoNiceReady', (dice3d) => RdDDice.diceSoNiceReady(dice3d));
+SystemReveDeDragon.start();
 

module/rdd-namegen.js

@@ -1,4 +1,4 @@
-import { RdDActor } from "./actor.js";
+import { RdDBaseActor } from "./actor/base-actor.js";
 import { Misc } from "./misc.js";
 import { RdDDice } from "./rdd-dice.js";
 
@@ -20,7 +20,7 @@ export class RdDNameGen {
 
   static async onCreerActeur(event) {
     const button = event.currentTarget;
-    await RdDActor.create({
+    await RdDBaseActor.create({
         name: button.attributes['data-nom'].value,
         type: button.attributes['data-type'].value
       },

module/rdd-resolution-table.js

@@ -14,7 +14,7 @@ const levelDown = [
   { level: -15, score: 1, norm: 1, sign: 0, part: 0, epart: 2, etotal: 10 },
   { level: -16, score: 1, norm: 1, sign: 0, part: 0, epart: 0, etotal: 2 }
 ];
-const levelImpossible = { score: 0, norm:0, sign: 0, part: 0, epart: 0, etotal: 1 };
+const levelImpossible = { score: 0, norm: 0, sign: 0, part: 0, epart: 0, etotal: 1 };
 
 const reussites = [
   { code: "etotal", isPart: false, isSign: false, isSuccess: false, isEchec: true, isEPart: true, isETotal: true, ptTache: -4, ptQualite: -6, quality: "Echec total", condition: (target, roll) => roll >= target.etotal && roll <= 100 },
@@ -42,6 +42,44 @@ export class RdDResolutionTable {
     return table;
   }
 
+  /* -------------------------------------------- */
+  static computeChances(carac, level) {
+    if (level < -16) {
+      return levelImpossible;
+    }
+    if (level < -10) {
+      return levelDown.find(it => it.level == level);
+    }
+    const percentage = RdDResolutionTable.computePercentage(carac, level);
+    return this._computeCell(level, percentage);
+  }
+
+
+  /* -------------------------------------------- */
+  static _computeRow(caracValue) {
+    let dataRow = [
+      this._computeCell(-10, Math.max(Math.floor(caracValue / 4), 1)),
+      this._computeCell(-9, Math.max(Math.floor(caracValue / 2), 1))
+    ]
+    for (var diff = -8; diff <= 22; diff++) {
+      dataRow[diff + 10] = this._computeCell(diff, RdDResolutionTable.computePercentage(caracValue, diff));
+    }
+    return dataRow;
+  }
+
+  /* -------------------------------------------- */
+  static _computeCell(niveau, percentage) {
+    return {
+      niveau: niveau,
+      score: percentage,
+      norm: Math.min(99, percentage),
+      sign: this._reussiteSignificative(percentage),
+      part: this._reussitePart(percentage),
+      epart: this._echecParticulier(percentage),
+      etotal: this._echecTotal(percentage)
+    };
+  }
+
   /* -------------------------------------------- */
   static getResultat(code) {
     let resultat = reussites.find(r => code == r.code);
@@ -51,17 +89,6 @@ export class RdDResolutionTable {
     return resultat;
   }
 
-  /* -------------------------------------------- */
-  static explain(rolled) {
-    let message = "<br>Jet : <strong>" + rolled.roll + "</strong> sur " + rolled.score + "% ";
-    if (rolled.caracValue != undefined && rolled.finalLevel != undefined) {
-      message += (rolled.diviseurSignificative > 1 ? `(1/${rolled.diviseurSignificative} de ` : "(")
-        + rolled.caracValue + " à " + Misc.toSignedString(rolled.finalLevel) + ") ";
-    }
-    message += '<strong>' + rolled.quality + '</strong>'
-    return message;
-  }
-
   /* -------------------------------------------- */
   static async displayRollData(rollData, actor = undefined, template = 'chat-resultat-general.html') {
     return await ChatUtility.createChatWithRollMode(actor?.userName ?? game.user.name, {
@@ -82,8 +109,8 @@ export class RdDResolutionTable {
   }
 
   /* -------------------------------------------- */
-  static async roll(caracValue, finalLevel, rollData = {}){
-    let chances = this.computeChances(caracValue, finalLevel);
+  static async roll(caracValue, finalLevel, rollData = {}) {
+    let chances = duplicate(this.computeChances(caracValue, finalLevel));
     this._updateChancesWithBonus(chances, rollData.bonus, finalLevel);
     this._updateChancesFactor(chances, rollData.diviseurSignificative);
     chances.showDice = rollData.showDice;
@@ -95,7 +122,7 @@ export class RdDResolutionTable {
     rolled.bonus = rollData.bonus;
     rolled.factorHtml = Misc.getFractionHtml(rollData.diviseurSignificative);
 
-    if (ReglesOptionelles.isUsing("afficher-colonnes-reussite")){
+    if (ReglesOptionelles.isUsing("afficher-colonnes-reussite")) {
       rolled.niveauNecessaire = this.findNiveauNecessaire(caracValue, rolled.roll);
       rolled.ajustementNecessaire = rolled.niveauNecessaire - finalLevel;
     }
@@ -103,13 +130,24 @@ export class RdDResolutionTable {
   }
 
   /* -------------------------------------------- */
-  static findNiveauNecessaire(caracValue, rollValue) {
-    for (let cell of this.resolutionTable[caracValue]) {
-      if ( rollValue <= cell.norm) {
-        return cell.niveau;
-      }
+  static findNiveauNecessaire(carac, rolled) {
+    if (carac == 0) {
+      return NaN;
     }
-    return 16; // Dummy default
+    if (rolled >= carac){
+      const upper = Math.ceil(rolled/carac);
+      return 2*upper -10
+    }
+    if (rolled > Math.floor(carac/2)) {
+      return -8
+    }
+    if (rolled > Math.floor(carac/4)) {
+      return -9
+    }
+    if (rolled > 1) {
+      return -10
+    }
+    return -11;
   }
 
   /* -------------------------------------------- */
@@ -122,7 +160,7 @@ export class RdDResolutionTable {
 
   /* -------------------------------------------- */
   static _updateChancesWithBonus(chances, bonus, finalLevel) {
-    if (bonus && finalLevel>-11) {
+    if (bonus && finalLevel > -11) {
       let newScore = Number(chances.score) + bonus;
       mergeObject(chances, this._computeCell(undefined, newScore), { overwrite: true });
     }
@@ -142,21 +180,19 @@ export class RdDResolutionTable {
 
   /* -------------------------------------------- */
   static async rollChances(chances, diviseur, forceDiceResult = -1) {
-    chances.forceDiceResult = forceDiceResult <= 0 || forceDiceResult > 100 ? undefined : {total: forceDiceResult};
-    chances.roll = await RdDDice.rollTotal( "1d100", chances);
+    chances.forceDiceResult = forceDiceResult <= 0 || forceDiceResult > 100 ? undefined : { total: forceDiceResult };
+    chances.roll = await RdDDice.rollTotal("1d100", chances);
     mergeObject(chances, this.computeReussite(chances, chances.roll, diviseur), { overwrite: true });
     return chances;
   }
 
   /* -------------------------------------------- */
-  static computeChances(caracValue, difficulte) {
-    if (difficulte < -16) {
-      return duplicate(levelImpossible);
-    }
-    if (difficulte < -10) {
-      return duplicate(levelDown.find(levelData => levelData.level == difficulte));
-    }
-    return duplicate(RdDResolutionTable.resolutionTable[caracValue][difficulte + 10]);
+  static computePercentage(carac, diff) {
+    if (diff < -16) return 0
+    if (diff < -10) return 1
+    if (diff == -10) return Math.max(Math.floor(carac / 4), 1)
+    if (diff == -9) return Math.max(Math.floor(carac / 2), 1)
+    return Math.max(Math.floor(carac * (diff + 10) / 2), 1);
   }
 
   /* -------------------------------------------- */
@@ -213,31 +249,6 @@ export class RdDResolutionTable {
     return reussite;
   }
 
-  /* -------------------------------------------- */
-  static _computeRow(caracValue) {
-    let dataRow = [
-      this._computeCell(-10, Math.max(Math.floor(caracValue / 4), 1)),
-      this._computeCell(-9, Math.max(Math.floor(caracValue / 2), 1))
-    ]
-    for (var diff = -8; diff <= 22; diff++) {
-      dataRow[diff + 10] = this._computeCell(diff, Math.max(Math.floor(caracValue * (diff + 10) / 2), 1));
-    }
-    return dataRow;
-  }
-
-  /* -------------------------------------------- */
-  static _computeCell(niveau, percentage) {
-    return {
-      niveau: niveau,
-      score: percentage,
-      norm: Math.min(99, percentage),
-      sign: this._reussiteSignificative(percentage),
-      part: this._reussitePart(percentage),
-      epart: this._echecParticulier(percentage),
-      etotal: this._echecTotal(percentage)
-    };
-  }
-
   /* -------------------------------------------- */
   static _reussiteSignificative(percentage) {
     return Math.floor(percentage / 2);
@@ -261,92 +272,34 @@ export class RdDResolutionTable {
   }
 
   /* -------------------------------------------- */
-  static buildHTMLResults(caracValue, levelValue) {
-    if (caracValue == undefined || isNaN(caracValue)) caracValue = 10;
-    if (levelValue == undefined || isNaN(levelValue)) levelValue = 0;
-
-    let cell = this.computeChances(caracValue, levelValue);
-    cell.epart = cell.epart > 99 ? 'N/A' : cell.epart;
-    cell.etotal = cell.etotal > 100 ? 'N/A' : cell.etotal;
-    cell.score = Math.min(cell.score, 99);
-
-    return `
-    <span class="table-proba-reussite competence-label">
-    Particulière: <span class="rdd-roll-part">${cell.part}</span>
-    - Significative: <span class="rdd-roll-sign">${cell.sign}</span>
-    - Réussite: <span class="rdd-roll-norm">${cell.score}</span>
-    - Echec Particulier: <span class="rdd-roll-epart">${cell.epart}</span>
-    - Echec Total: <span class="rdd-roll-etotal">${cell.etotal}</span>
-    </span>
-    `
+  static subTable(carac, level, delta = { carac: 2, level: 5}) {
+    return {
+      carac,
+      level,
+      minCarac: carac - (delta?.carac ?? 2),
+      maxCarac: carac + (delta?.carac ?? 2),
+      minLevel: level - (delta?.level ?? 5),
+      maxLevel: level + (delta?.level ?? 5)
+    };
   }
 
   /* -------------------------------------------- */
-  static buildHTMLTableExtract(caracValue, levelValue) {
-    return this.buildHTMLTable(caracValue, levelValue, caracValue - 2, caracValue + 2, levelValue - 5, levelValue + 5)
-  }
-
-  static buildHTMLTable(caracValue, levelValue, minCarac = 1, maxCarac = 21, minLevel = -10, maxLevel = 11) {
-    return this._buildHTMLTable(caracValue, levelValue, minCarac, maxCarac, minLevel, maxLevel)
-  }
-
-  /* -------------------------------------------- */
-  static _buildHTMLTable(caracValue, levelValue, minCarac, maxCarac, minLevel, maxLevel) {
-    let countColonnes = maxLevel - minLevel;
+  static async buildHTMLTable({ carac: carac, level: level, minCarac = 1, maxCarac = 21, minLevel = -10, maxLevel = 11 }) {
+    let colonnes = maxLevel - minLevel;
     minCarac = Math.max(minCarac, 1);
-    maxCarac = Math.min(maxCarac, caracMaximumResolution);
+    maxCarac = Math.min(maxCarac, minCarac + 20);
     minLevel = Math.max(minLevel, -10);
-    maxLevel = Math.max(Math.min(maxLevel, 22), minLevel + countColonnes);
-
-    let table = $("<table class='table-resolution'/>")
-      .append(this._buildHTMLHeader(RdDResolutionTable.resolutionTable[0], minLevel, maxLevel));
-
-    for (var rowIndex = minCarac; rowIndex <= maxCarac; rowIndex++) {
-      table.append(this._buildHTMLRow(RdDResolutionTable.resolutionTable[rowIndex], rowIndex, caracValue, levelValue, minLevel, maxLevel));
-    }
-    table.append("</table>");
-    return table;
+    maxLevel = Math.max(Math.min(maxLevel, 30), minLevel + colonnes);
+    return await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/resolution-table.html', {
+      carac: carac,
+      difficulte: level,
+      min: minLevel,
+      rows: RdDResolutionTable.incrementalArray(minCarac, maxCarac),
+      cols: RdDResolutionTable.incrementalArray(minLevel, maxLevel)
+    });
   }
-
-  /* -------------------------------------------- */
-  static _buildHTMLHeader(dataRow, minLevel, maxLevel) {
-    let tr = $("<tr/>");
-
-    if (minLevel > -8) {
-      tr.append($("<th class='table-resolution-level'/>").text("-8"))
-    }
-    if (minLevel > -7) {
-      tr.append($("<th class='table-resolution-level'/>").text("..."));
-    }
-    for (let difficulte = minLevel; difficulte <= maxLevel; difficulte++) {
-      tr.append($("<th class='table-resolution-level'/>").text(Misc.toSignedString(difficulte)));
-    }
-    return tr;
-  }
-
-  /* -------------------------------------------- */
-  static _buildHTMLRow(dataRow, rowIndex, caracValue, levelValue, minLevel, maxLevel) {
-    let tr = $("<tr/>");
-    let max = maxLevel;
-
-    if (minLevel > -8) {
-      let score = dataRow[-8 + 10].score;
-      tr.append($("<td class='table-resolution-carac'/>").text(score))
-    }
-    if (minLevel > -7) {
-      tr.append($("<td/>"))
-    }
-    for (let difficulte = minLevel; difficulte <= max; difficulte++) {
-      let td = $("<td/>");
-      let score = dataRow[difficulte + 10].score;
-      if (rowIndex == caracValue && levelValue == difficulte) {
-        td.addClass('table-resolution-target');
-      } else if (difficulte == -8) {
-        td.addClass('table-resolution-carac');
-      }
-      tr.append(td.text(score));
-    }
-    return tr;
+  static incrementalArray(min, max) {
+    return Array.from(Array(max-min+1).keys()).map(i=>i+min)
   }
 
 }

module/rdd-roll-encaisser.js

@@ -1,4 +1,5 @@
-import { ENTITE_BLURETTE, ENTITE_INCARNE} from "./constants.js";
+import { ENTITE_BLURETTE, ENTITE_INCARNE } from "./constants.js";
+import { RdDUtility } from "./rdd-utility.js";
 
 /**
  * Extend the base Dialog entity by defining a custom window to perform roll.
@@ -6,32 +7,37 @@ import { ENTITE_BLURETTE, ENTITE_INCARNE} from "./constants.js";
  */
 export class RdDEncaisser extends Dialog {
 
+  static async encaisser(actor) {
+    let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/dialog-roll-encaisser.html',
+      { ajustementsEncaissement: RdDUtility.getAjustementsEncaissement() }
+    );
+    new RdDEncaisser(html, actor).render(true);
+  }
+
   /* -------------------------------------------- */
   constructor(html, actor) {
-    // Common conf
-    let buttons = {};
-    if (!actor.isEntite()){
-      buttons = {
+    let dialogConf = {
+      title: "Jet d'Encaissement",
+      content: html,
+    }
+
+    if (!actor.isEntite()) {
+      dialogConf.default = "mortel";
+      dialogConf.buttons = {
         "mortel": { label: "Mortel", callback: html => this.performEncaisser("mortel") },
         "non-mortel": { label: "Non-mortel", callback: html => this.performEncaisser("non-mortel") },
         "sonne": { label: "Sonné", callback: html => this.actor.setSonne() },
       };
     }
-    else if (actor.isEntite([ENTITE_BLURETTE, ENTITE_INCARNE])){
-      buttons = {
-        "cauchemar": { label: "cauchemar", callback: html => this.performEncaisser("cauchemar") }
+    else if (actor.isEntite([ENTITE_BLURETTE, ENTITE_INCARNE])) {
+      dialogConf.default = "cauchemar"
+      dialogConf.buttons = {
+        "cauchemar": { label: "Cauchemar", callback: html => this.performEncaisser("cauchemar") }
       }
     }
 
-    let dialogConf = {
-      title: "Jet d'Encaissement",
-      content: html,
-      buttons: buttons,
-      default: "mortel"
-    }
-
     let dialogOptions = {
-      classes: ["rdddialog"],
+      classes: ["rdd-roll-dialog"],
       width: 320,
       height: 'fit-content'
     }
@@ -44,7 +50,18 @@ export class RdDEncaisser extends Dialog {
     this.encaisserSpecial = "aucun";
   }
 
+  activateListeners(html) {
+    super.activateListeners(html);
+    this.html = html;
 
+    this.html.find('[name="modificateurDegats"]').val("0");
+    this.html.find('[name="modificateurDegats"]').change((event) => {
+      this.modifier = event.currentTarget.value; // Update the selected bonus/malus
+    });
+    this.html.find('[name="encaisserSpecial"]').change((event) => {
+      this.encaisserSpecial = event.currentTarget.value; // Update the selected bonus/malus
+    });
+  }
 
   /* -------------------------------------------- */
   performEncaisser(mortalite) {
@@ -58,22 +75,4 @@ export class RdDEncaisser extends Dialog {
       }
     });
   }
-
-  /* -------------------------------------------- */
-  activateListeners(html) {
-    super.activateListeners(html);
-
-    // Setup everything onload
-    $(function () {
-      $("#modificateurDegats").val("0");
-    });
-
-    html.find('#modificateurDegats').change((event) => {
-      this.modifier = event.currentTarget.value; // Update the selected bonus/malus
-    });
-    html.find('#encaisserSpecial').change((event) => {
-      this.encaisserSpecial = event.currentTarget.value; // Update the selected bonus/malus
-    });
-  }
-
 }

module/rdd-roll-ethylisme.js

@@ -13,47 +13,33 @@ export class RdDRollDialogEthylisme extends Dialog {
       title: "Test d'éthylisme",
       content: html,
       default: "rollButton",
-      buttons: { "rollButton": { label: "Test d'éthylisme", callback: html => this.onButton(html) } }
+      buttons: { "rollButton": { label: "Test d'éthylisme", callback: html => onRoll(this.rollData) } }
     };
-    let dialogOptions = { classes: ["rdddialog"], width: 400, height: 'fit-content', 'z-index': 99999 }
+    let dialogOptions = { classes: ["rdd-roll-dialog"], width: 400, height: 'fit-content', 'z-index': 99999 }
     super(dialogConf, dialogOptions)
 
-    //console.log("ETH", rollData);
-    this.onRoll = onRoll;
     this.rollData = rollData;
     this.actor = actor;
   }
 
-  async onButton(html) {
-    this.onRoll(this.rollData);
+  activateListeners(html) {
+    super.activateListeners(html);
+    this.html = html;
+    this.bringToTop();
+
+    this.html.find(".force-alcool").change((event) => {
+      this.rollData.forceAlcool = Misc.toInt(event.currentTarget.value);
+      this.updateRollResult();
+    });
+
+    this.html.find(".force-alcool").val(Misc.toInt(this.rollData.forceAlcool));
+    this.updateRollResult();
   }
 
   /* -------------------------------------------- */
-  activateListeners(html) {
-    super.activateListeners(html);
-
-    this.bringToTop(); // Ensure top level
-    // Get the rollData stuff
-    var rollData = this.rollData;
-    var dialog = this;
-
-    // Setup everything onload
-    $(function () {
-      $("#forceAlcool").val(Misc.toInt(rollData.forceAlcool));
-      dialog.updateRollResult();
-    });
-
-    // Update !
-    html.find('#forceAlcool').change((event) => {
-      rollData.forceAlcool = Misc.toInt(event.currentTarget.value); // Update the selected bonus/malus
-      dialog.updateRollResult();
-    });
-  }
   async updateRollResult() {
-    
-    // Mise à jour valeurs
-    $("#roll-param").text(this.rollData.vie + " / " + Misc.toSignedString(Number(this.rollData.etat) + Number(this.rollData.forceAlcool) + this.rollData.diffNbDoses));
-    $(".table-resolution").remove();
+    this.html.find(".roll-ethylisme").text(this.rollData.vie + " / " + Misc.toSignedString(Number(this.rollData.etat) + Number(this.rollData.forceAlcool) + this.rollData.diffNbDoses));
+    this.html.find(".table-resolution").remove();
   }
 
 }

module/rdd-roll-resolution-table.js

@@ -9,12 +9,19 @@ const titleTableDeResolution = 'Table de résolution';
 /* -------------------------------------------- */
 export class RdDRollResolutionTable extends Dialog {
 
+  static resolutionTable = undefined;
   /* -------------------------------------------- */
-  static async open(rollData = {}) {
-    RdDRollResolutionTable._setDefaultOptions(rollData);
-    let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/dialog-roll-resolution.html', rollData);
-    const dialog = new RdDRollResolutionTable(rollData, html);
-    dialog.render(true);
+  static async open() {
+    if (RdDRollResolutionTable.resolutionTable == undefined) {
+      const rollData = {}
+      RdDRollResolutionTable._setDefaultOptions(rollData);
+      let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/dialog-roll-resolution.html', rollData);
+      RdDRollResolutionTable.resolutionTable = new RdDRollResolutionTable(rollData, html);
+      RdDRollResolutionTable.resolutionTable.render(true);
+    }
+    else{
+      RdDRollResolutionTable.resolutionTable.bringToTop();
+    }
   }
 
   /* -------------------------------------------- */
@@ -53,11 +60,40 @@ export class RdDRollResolutionTable extends Dialog {
         'lancer-fermer': { label: 'Lancer les dés et fermer', callback: html => this.onLancerFermer() }
       }
     };
-    super(conf, { classes: ["rdddialog"], width: 800, height: 'fit-content', 'z-index': 99999 });
+    super(conf, { classes: ["rdd-roll-dialog"], top: 50, width: 'fit-content', height: 'fit-content', 'z-index': 99999 });
 
     this.rollData = rollData;
   }
 
+  activateListeners(html) {
+    super.activateListeners(html);
+    this.html = html;
+    this.bringToTop();
+
+
+    this.html.find("[name='diffLibre']").val(Misc.toInt(this.rollData.diffLibre));
+    this.html.find("[name='diffConditions']").val(Misc.toInt(this.rollData.diffConditions));
+    this.updateRollResult();
+
+    this.html.find('.lancer-table-resolution').click((event) => {
+      this.onLancer();
+    });
+    // Update !
+    this.html.find("[name='diffLibre']").change((event) => {
+      this.rollData.diffLibre = Misc.toInt(event.currentTarget.value);
+      this.updateRollResult();
+    });
+    this.html.find("[name='diffConditions']").change((event) => {
+      this.rollData.diffConditions = Misc.toInt(event.currentTarget.value);
+      this.updateRollResult();
+    });
+    this.html.find("[name='carac']").change((event) => {
+      let caracKey = event.currentTarget.value;
+      this.rollData.selectedCarac = this.rollData.carac[caracKey];
+      this.updateRollResult();
+    });
+  }
+
   /* -------------------------------------------- */
   async onLancer() {
     await RdDResolutionTable.rollData(this.rollData);
@@ -72,65 +108,36 @@ export class RdDRollResolutionTable extends Dialog {
     await RdDResolutionTable.displayRollData(this.rollData);
   }
 
-  /* -------------------------------------------- */
-  activateListeners(html) {
-    super.activateListeners(html);
-
-    this.bringToTop();
-
-    var dialog = this;
-
-    // Setup everything onload
-    function onLoad(){
-      $("#diffLibre").val(Misc.toInt(dialog.rollData.diffLibre));
-      $("#diffConditions").val(Misc.toInt(dialog.rollData.diffConditions));
-      dialog.updateRollResult();
-    }
-    $(function () { onLoad();});
-    html.find('#lancer').click((event) => {
-      this.onLancer();
-    });
-    // Update !
-    html.find('#diffLibre').change((event) => {
-      this.rollData.diffLibre = Misc.toInt(event.currentTarget.value);
-      this.updateRollResult();
-    });
-    html.find('#diffConditions').change((event) => {
-      this.rollData.diffConditions = Misc.toInt(event.currentTarget.value);
-      this.updateRollResult();
-    });
-    html.find('#carac').change((event) => {
-      let caracKey = event.currentTarget.value;
-      this.rollData.selectedCarac = this.rollData.carac[caracKey];
-      this.updateRollResult();
-    });
-  }
-
   /* -------------------------------------------- */
   async updateRollResult() {
     let rollData = this.rollData;
     rollData.caracValue = parseInt(rollData.selectedCarac.value)
     rollData.finalLevel = this._computeFinalLevel(rollData);
 
+    const htmlTable = await RdDResolutionTable.buildHTMLTable({
+      carac: rollData.caracValue,
+      level: rollData.finalLevel,
+      maxCarac: 20,
+      maxLevel: 10
+    });
+
     // Mise à jour valeurs
-    $("#carac").val(rollData.caracValue);
-    $("#roll-param").text(rollData.selectedCarac.value + " / " + Misc.toSignedString(rollData.finalLevel));
-    $(".table-resolution").remove();
-    $(".table-proba-reussite").remove();
-    $("#tableResolution").append(RdDResolutionTable.buildHTMLTable(rollData.caracValue, rollData.finalLevel));
-    $("#tableProbaReussite").append(RdDResolutionTable.buildHTMLResults(rollData.caracValue, rollData.finalLevel));
+    this.html.find("[name='carac']").val(rollData.caracValue);
+    this.html.find(".roll-param-resolution").text(rollData.selectedCarac.value + " / " + Misc.toSignedString(rollData.finalLevel));
+    this.html.find("div.placeholder-resolution").empty().append(htmlTable)
+
   }
 
   /* -------------------------------------------- */
   _computeFinalLevel(rollData) {
     const diffConditions = Misc.toInt(rollData.diffConditions);
-    const diffLibre = this._computeDiffLibre(rollData);
+    const diffLibre = Misc.toInt(rollData.diffLibre);
 
     return diffLibre + diffConditions;
   }
 
-  /* -------------------------------------------- */
-  _computeDiffLibre(rollData) {
-    return Misc.toInt(rollData.diffLibre);
+  async close() {
+    await super.close();
+    RdDRollResolutionTable.resolutionTable = undefined;
   }
 }

module/rdd-roll.js

@@ -16,24 +16,17 @@ import { ReglesOptionelles } from "./settings/regles-optionelles.js";
 export class RdDRoll extends Dialog {
 
   /* -------------------------------------------- */
-  static async create(actor, rollData, dialogConfig, ...actions) {
-
-    if (actor.isRollWindowsOpened()) {
-      ui.notifications.warn("Vous avez déja une fenêtre de Test ouverte, il faut la fermer avant d'en ouvrir une autre.")
-      return;
-    }
-    actor.setRollWindowsOpened(true);
-
-    RdDRoll._ensureCorrectActions(actions);
+  static async create(actor, rollData, dialogConfig, action) {
+    RdDRoll._ensureCorrectAction(action);
     RdDRoll._setDefaultOptions(actor, rollData);
 
     const html = await renderTemplate(dialogConfig.html, rollData);
 
-    let options = { classes: ["rdddialog"], width: 600, height: 'fit-content', 'z-index': 99999 };
-    if (dialogConfig.options) {
-      mergeObject(options, dialogConfig.options, { overwrite: true })
+    let options = { classes: ["rdd-roll-dialog"], width: 600, height: 'fit-content', 'z-index': 99999, close: html => {} };
+    if (dialogConfig.close) {
+      options.close = dialogConfig.close;
     }
-    return new RdDRoll(actor, rollData, html, options, actions, dialogConfig.close);
+    return new RdDRoll(actor, rollData, html, options, action);
   }
 
   /* -------------------------------------------- */
@@ -67,7 +60,7 @@ export class RdDRoll extends Dialog {
       forceDiceResult: -1
     }
     // Mini patch :Ajout du rêve actuel
-    if ( actor.system.type == "personnage") {
+    if (actor.system.type == "personnage") {
       defaultRollData.carac["reve-actuel"] = actor.system.reve.reve
     }
 
@@ -79,6 +72,7 @@ export class RdDRoll extends Dialog {
 
     RollDataAjustements.calcul(rollData, actor);
   }
+
   /* -------------------------------------------- */
   static getDiviseurSignificative(rollData) {
     let facteurSign = 1;
@@ -97,171 +91,132 @@ export class RdDRoll extends Dialog {
     return facteurSign;
   }
 
-
   /* -------------------------------------------- */
-  static _ensureCorrectActions(actions) {
-    if (actions.length == 0) {
-      throw 'No action defined';
+  static _ensureCorrectAction(action) {
+    if (action.callbacks == undefined) {
+      console.warn('No callback defined for ', action.name);
+      action.callbacks = [{ action: r => console.warn(action.name, r) }];
     }
-    actions.forEach(action => {
-      if (action.callbacks == undefined) {
-        action.callbacks = [{ action: r => console.log(action.name, r) }];
-      }
-    });
   }
 
   /* -------------------------------------------- */
-  constructor(actor, rollData, html, options, actions, close = undefined) {
+  constructor(actor, rollData, html, options, action) {
     let conf = {
-      title: actions[0].label,
+      title: action.label,
       content: html,
-      buttons: {},
-      default: actions[0].name,
-      close: close
-    };
-    for (let action of actions) {
-      conf.buttons[action.name] = {
-        label: action.label, callback: html => {
-          this.rollData.canClose = true;
-          this.onAction(action, html)
+      buttons: {
+        "onAction": {
+          label: action.label, callback: html => {
+            this.rollData.canClose = true;
+            this.onAction(action)
+          }
         }
-      };
-    }
-
+      },
+      default: "onAction",
+      close: options.close
+    };
     super(conf, options);
 
     this.actor = actor;
     this.rollData = rollData;
   }
 
-  close() {
-    if (this.rollData.canClose) {
-      this.actor.setRollWindowsOpened(false);
-      return super.close();
-    }
-    ui.notifications.info("Vous devez faire ce jet de dés!");
-  }
-
-
-  /* -------------------------------------------- */
-  async onAction(action, html) {
-    this.rollData.forceDiceResult = Number.parseInt($('#force-dice-result').val()) ?? -1;
-    await RdDResolutionTable.rollData(this.rollData);
-    console.log("RdDRoll -=>", this.rollData, this.rollData.rolled);
-    this.actor.setRollWindowsOpened(false);
-    if (action.callbacks)
-      for (let callback of action.callbacks) {
-        if (callback.condition == undefined || callback.condition(this.rollData)) {
-          await callback.action(this.rollData);
-        }
-      }
-  }
-
-  /* -------------------------------------------- */
   activateListeners(html) {
     super.activateListeners(html);
-
+    this.html = html;
     this.bringToTop();
 
-    var dialog = this;
+    console.log('RdDRoll.activateListeners', this.rollData);
 
-    function onLoad() {
-      let rollData = dialog.rollData;
-      console.log('Ouverture RdDRoll', rollData);
-      // Update html, according to rollData
-      if (rollData.competence) {
-        const defaut_carac = rollData.competence.system.defaut_carac
-        // Set the default carac from the competence item
-        rollData.selectedCarac = rollData.carac[defaut_carac];
-        $("#carac").val(defaut_carac);
-      }
-      if (rollData.selectedSort) {
-        dialog.setSelectedSort(rollData.selectedSort);
-        $(".draconic").val(rollData.selectedSort.system.listIndex); // Uniquement a la selection du sort, pour permettre de changer 
-      }
-      RdDItemSort.setCoutReveReel(rollData.selectedSort);
-      $("#diffLibre").val(Misc.toInt(rollData.diffLibre));
-      $("#diffConditions").val(Misc.toInt(rollData.diffConditions));
-      dialog.updateRollResult();
+    // Update html, according to rollData
+    if (this.rollData.competence) {
+      const defaut_carac = this.rollData.competence.system.defaut_carac
+      // Set the default carac from the competence item
+      this.rollData.selectedCarac = this.rollData.carac[defaut_carac];
+      this.html.find("[name='carac']").val(defaut_carac);
     }
+    if (this.rollData.selectedSort) {
+      this.setSelectedSort(this.rollData.selectedSort);
+      this.html.find(".draconic").val(this.rollData.selectedSort.system.listIndex); // Uniquement a la selection du sort, pour permettre de changer 
+    }
+    RdDItemSort.setCoutReveReel(this.rollData.selectedSort);
+    this.html.find("[name='diffLibre']").val(Misc.toInt(this.rollData.diffLibre));
+    this.html.find("[name='diffConditions']").val(Misc.toInt(this.rollData.diffConditions));
+    this.updateRollResult(html);
 
-    // Setup everything onload
-    $(function () { onLoad(); });
-
-    // Update !
-    html.find('#diffLibre').change((event) => {
+    this.html.find("[name='diffLibre']").change((event) => {
       this.rollData.diffLibre = Misc.toInt(event.currentTarget.value); // Update the selected bonus/malus
-      this.updateRollResult();
+      this.updateRollResult(html);
     });
-    html.find('#diffConditions').change((event) => {
+    this.html.find("[name='diffConditions']").change((event) => {
       this.rollData.diffConditions = Misc.toInt(event.currentTarget.value); // Update the selected bonus/malus
-      this.updateRollResult();
+      this.updateRollResult(html);
     });
-    html.find('#force-dice-result').change((event) => {
+    this.html.find("[name='force-dice-result']").change((event) => {
       this.rollData.forceDiceResult = Misc.toInt(event.currentTarget.value);
     });
-    html.find('#carac').change((event) => {
+    this.html.find("[name='carac']").change((event) => {
       let caracKey = event.currentTarget.value;
       this.rollData.selectedCarac = this.rollData.carac[caracKey]; // Update the selectedCarac
-      this.updateRollResult();
+      this.updateRollResult(html);
     });
-    html.find('.roll-draconic').change((event) => {
+    this.html.find('.roll-draconic').change((event) => {
       let draconicKey = Misc.toInt(event.currentTarget.value);
       this.rollData.competence = this.rollData.draconicList[draconicKey]; // Update the selectedCarac
-      this.updateRollResult();
+      this.updateRollResult(html);
     });
-    html.find('.roll-sort').change((event) => {
+    this.html.find('.roll-sort').change((event) => {
       let sortKey = Misc.toInt(event.currentTarget.value);
       this.setSelectedSort(this.rollData.sortList[sortKey]);
-      this.updateRollResult();
-      $("#diffLibre").val(this.rollData.diffLibre);
+      this.updateRollResult(html);
+      this.html.find("[name='diffLibre']").val(this.rollData.diffLibre);
     });
-    html.find('.roll-carac-competence').change((event) => {
+    this.html.find('.roll-carac-competence').change((event) => {
       const competence = event.currentTarget.value;
       this.rollData.competence = this.rollData.competences.find(it => it.name == competence);
-      this.updateRollResult();
+      this.updateRollResult(html);
     });
-    html.find('.roll-signedraconique').change((event) => {
+    this.html.find('.roll-signedraconique').change((event) => {
       let sortKey = Misc.toInt(event.currentTarget.value);
       this.setSelectedSigneDraconique(this.rollData.signes[sortKey]);
-      this.updateRollResult();
+      this.updateRollResult(html);
     });
-    html.find('#ptreve-variable').change((event) => {
+    this.html.find("[name='ptreve-variable']").change((event) => {
       let ptreve = Misc.toInt(event.currentTarget.value);
       this.rollData.selectedSort.system.ptreve_reel = ptreve;
       console.log("RdDRollSelectDialog - Cout reve", ptreve);
-      this.updateRollResult();
+      this.updateRollResult(html);
     });
-    html.find("[name='coupsNonMortels']").change((event) => {
+    this.html.find("[name='coupsNonMortels']").change((event) => {
       this.rollData.dmg.mortalite = event.currentTarget.checked ? "non-mortel" : "mortel";
-      this.updateRollResult();
+      this.updateRollResult(html);
     });
-    html.find('.cuisine-proportions').change((event) => {
+    this.html.find('.cuisine-proportions').change((event) => {
       this.rollData.proportions = Number(event.currentTarget.value);
-      this.updateRollResult();
+      this.updateRollResult(html);
     });
-    html.find('.select-by-name').change((event) => {
+    this.html.find('.select-by-name').change((event) => {
       const attribute = event.currentTarget.attributes['name'].value;
       this.rollData[attribute] = event.currentTarget.value;
-      this.updateRollResult();
+      this.updateRollResult(html);
     });
-    html.find('.checkbox-by-name').change((event) => {
+    this.html.find('.checkbox-by-name').change((event) => {
       const attribute = event.currentTarget.attributes['name'].value;
       this.rollData[attribute] = event.currentTarget.checked;
-      this.updateRollResult();
+      this.updateRollResult(html);
     });
-    html.find('input.use-encTotal').change((event) => {
+    this.html.find('input.use-encTotal').change((event) => {
       this.rollData.use.encTotal = event.currentTarget.checked;
-      this.updateRollResult();
+      this.updateRollResult(html);
     });
-    html.find('input.use-surenc').change((event) => {
+    this.html.find('input.use-surenc').change((event) => {
       this.rollData.use.surenc = event.currentTarget.checked;
-      this.updateRollResult();
+      this.updateRollResult(html);
     });
-    html.find('.appel-moral').click((event) => { /* l'appel au moral, qui donne un bonus de +1 */
+    this.html.find('.appel-moral').click((event) => { /* l'appel au moral, qui donne un bonus de +1 */
       this.rollData.use.moral = !this.rollData.use.moral;
-      const appelMoral = html.find('.icon-appel-moral')[0];
-      const tooltip = html.find('.tooltipAppelAuMoralText')[0];
+      const appelMoral = this.html.find('.icon-appel-moral')[0];
+      const tooltip = this.html.find('.tooltipAppelAuMoralText')[0];
       if (this.rollData.use.moral) {
         if (this.rollData.moral > 0) {
           tooltip.innerHTML = "Appel au moral";
@@ -274,16 +229,36 @@ export class RdDRoll extends Dialog {
         tooltip.innerHTML = "Sans appel au moral";
         appelMoral.src = "/systems/foundryvtt-reve-de-dragon/icons/moral-neutre.svg";
       }
-      this.updateRollResult();
+      this.updateRollResult(html);
     });
     // Section Méditation
-    html.find('.conditionMeditation').change((event) => {
-      let condition = event.currentTarget.attributes['id'].value;
+    this.html.find('.conditionMeditation').change((event) => {
+      let condition = event.currentTarget.attributes['name'].value;
       this.rollData.conditionMeditation[condition] = event.currentTarget.checked;
-      this.updateRollResult();
+      this.updateRollResult(html);
     });
   }
 
+  /* -------------------------------------------- */
+  close() {
+    if (this.rollData.canClose) {
+      return super.close();
+    }
+    ui.notifications.info("Vous devez faire ce jet de dés!");
+  }
+
+  async onAction(action) {
+    this.rollData.forceDiceResult = Number.parseInt(this.html.find("[name='force-dice-result']").val()) ?? -1;
+    await RdDResolutionTable.rollData(this.rollData);
+    console.log("RdDRoll -=>", this.rollData, this.rollData.rolled);
+    if (action.callbacks)
+      for (let callback of action.callbacks) {
+        if (callback.condition == undefined || callback.condition(this.rollData)) {
+          await callback.action(this.rollData);
+        }
+      }
+  }
+
   async setSelectedSort(sort) {
     this.rollData.selectedSort = sort; // Update the selectedCarac
     this.rollData.competence = RdDItemCompetence.getVoieDraconic(this.rollData.draconicList, sort.system.draconic);
@@ -291,31 +266,31 @@ export class RdDRoll extends Dialog {
     this.rollData.diffLibre = RdDItemSort.getDifficulte(sort, -7);
     RdDItemSort.setCoutReveReel(sort);
     const htmlSortDescription = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/partial-description-sort.html", { sort: sort });
-    $(".sort-ou-rituel").text(sort.system.isrituel ? "rituel" : "sort");
-    $(".bonus-case").text(`${this.rollData.bonus}%`);
-    $(".details-sort").remove();
-    $(".description-sort").append(htmlSortDescription);
-    $(".roll-draconic").val(sort.system.listIndex);
-    $(".div-sort-difficulte-fixe").text(Misc.toSignedString(sort.system.difficulte));
-    $(".div-sort-ptreve-fixe").text(sort.system.ptreve);
+    this.html.find(".sort-ou-rituel").text(sort.system.isrituel ? "rituel" : "sort");
+    this.html.find(".bonus-case").text(`${this.rollData.bonus}%`);
+    this.html.find(".placeholder-description-sort").children().remove();
+    this.html.find(".placeholder-description-sort").append(htmlSortDescription);
+    this.html.find(".roll-draconic").val(sort.system.listIndex);
+    this.html.find(".div-sort-difficulte-fixe").text(Misc.toSignedString(sort.system.difficulte));
+    this.html.find(".div-sort-ptreve-fixe").text(sort.system.ptreve);
     const diffVariable = RdDItemSort.isDifficulteVariable(sort);
     const coutVariable = RdDItemSort.isCoutVariable(sort);
 
-    HtmlUtility._showControlWhen($(".div-sort-non-rituel"), !sort.system.isrituel);
-    HtmlUtility._showControlWhen($(".div-sort-difficulte-var"), diffVariable);
-    HtmlUtility._showControlWhen($(".div-sort-difficulte-fixe"), !diffVariable);
-    HtmlUtility._showControlWhen($(".div-sort-ptreve-var"), coutVariable);
-    HtmlUtility._showControlWhen($(".div-sort-ptreve-fixe"), !coutVariable);
+    HtmlUtility._showControlWhen(this.html.find(".div-sort-non-rituel"), !sort.system.isrituel);
+    HtmlUtility._showControlWhen(this.html.find(".div-sort-difficulte-var"), diffVariable);
+    HtmlUtility._showControlWhen(this.html.find(".div-sort-difficulte-fixe"), !diffVariable);
+    HtmlUtility._showControlWhen(this.html.find(".div-sort-ptreve-var"), coutVariable);
+    HtmlUtility._showControlWhen(this.html.find(".div-sort-ptreve-fixe"), !coutVariable);
   }
 
-  async setSelectedSigneDraconique(signe){
+  async setSelectedSigneDraconique(signe) {
     this.rollData.signe = signe;
     this.rollData.diffLibre = signe.system.difficulte,
-    $(".signe-difficulte").text(Misc.toSignedString(this.rollData.diffLibre));
+      $(".signe-difficulte").text(Misc.toSignedString(this.rollData.diffLibre));
   }
 
   /* -------------------------------------------- */
-  async updateRollResult() {
+  async updateRollResult(html) {
     let rollData = this.rollData;
 
     rollData.dmg = rollData.attackerRoll?.dmg ?? RdDBonus.dmg(rollData, this.actor.getBonusDegat())
@@ -325,39 +300,35 @@ export class RdDRoll extends Dialog {
     rollData.use.appelAuMoral = this.actor.isPersonnage() && RdDCarac.isActionPhysique(rollData.selectedCarac);
     let dmgText = Misc.toSignedString(rollData.dmg.total);
 
-    switch (rollData.mortalite){
-      case 'non-mortel':  dmgText = `(${dmgText}) non-mortel`; break;
-      case 'empoignade':  dmgText = `empoignade`; break;
+    switch (rollData.mortalite) {
+      case 'non-mortel': dmgText = `(${dmgText}) non-mortel`; break;
+      case 'empoignade': dmgText = `empoignade`; break;
     }
 
     RollDataAjustements.calcul(rollData, this.actor);
     rollData.finalLevel = this._computeFinalLevel(rollData);
 
-    HtmlUtility._showControlWhen($(".use-encTotal"), rollData.ajustements.encTotal.visible && RdDCarac.isAgiliteOuDerivee(rollData.selectedCarac));
-    HtmlUtility._showControlWhen($(".use-surenc"), rollData.ajustements.surenc.visible && RdDCarac.isActionPhysique(rollData.selectedCarac));
-    HtmlUtility._showControlWhen($(".utilisation-moral"), rollData.use.appelAuMoral);
-    HtmlUtility._showControlWhen($(".diffMoral"), rollData.ajustements.moralTotal.used);
-    HtmlUtility._showControlWhen($(".divAppelAuMoral"), rollData.use.appelAuMoral);
-    HtmlUtility._showControlWhen($("#etat-general"), !RdDCarac.isIgnoreEtatGeneral(rollData));
-    HtmlUtility._showControlWhen($("#ajust-astrologique"), RdDResolutionTable.isAjustementAstrologique(rollData));
+    const resolutionTable = await RdDResolutionTable.buildHTMLTable(RdDResolutionTable.subTable(rollData.caracValue, rollData.finalLevel))
+    const adjustements = await this.buildAjustements(rollData);
+
+    HtmlUtility._showControlWhen(this.html.find(".use-encTotal"), rollData.ajustements.encTotal.visible && RdDCarac.isAgiliteOuDerivee(rollData.selectedCarac));
+    HtmlUtility._showControlWhen(this.html.find(".use-surenc"), rollData.ajustements.surenc.visible && RdDCarac.isActionPhysique(rollData.selectedCarac));
+    HtmlUtility._showControlWhen(this.html.find(".utilisation-moral"), rollData.use.appelAuMoral);
+    HtmlUtility._showControlWhen(this.html.find(".diffMoral"), rollData.ajustements.moralTotal.used);
+    HtmlUtility._showControlWhen(this.html.find(".divAppelAuMoral"), rollData.use.appelAuMoral);
 
     // Mise à jour valeurs
-    $(".dialog-roll-title").text(this._getTitle(rollData));
-    $("[name='coupsNonMortels']").prop('checked', rollData.mortalite == 'non-mortel');
-    $(".dmg-arme-actor").text(dmgText);
-    $('.table-ajustement').remove();
-    $(".table-resolution").remove();
-    $(".table-proba-reussite").remove();
-    $("#tableAjustements").append(await this.buildAjustements(rollData));
-    $("#tableResolution").append(RdDResolutionTable.buildHTMLTableExtract(rollData.caracValue, rollData.finalLevel));
-    $("#tableProbaReussite").append(RdDResolutionTable.buildHTMLResults(rollData.caracValue, rollData.finalLevel));
+    this.html.find(".dialog-roll-title").text(this._getTitle(rollData));
+    this.html.find("[name='coupsNonMortels']").prop('checked', rollData.mortalite == 'non-mortel');
+    this.html.find(".dmg-arme-actor").text(dmgText);
+    this.html.find("div.placeholder-ajustements").empty().append(adjustements);
+    this.html.find("div.placeholder-resolution").empty().append(resolutionTable)
   }
 
 
   /* -------------------------------------------- */
   async buildAjustements(rollData) {
-    const html = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/partial-roll-ajustements.html`, rollData);
-    return html;
+    return await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/partial-roll-ajustements.html`, rollData);
   }
 
   /* -------------------------------------------- */
@@ -375,23 +346,11 @@ export class RdDRoll extends Dialog {
     return 0;
   }
 
-  /* -------------------------------------------- */
-  _computeDiffLibre(rollData) {
-    let diffLibre = Misc.toInt(rollData.diffLibre);
-    if (rollData.draconicList && rollData.selectedSort) {
-      return RdDItemSort.getDifficulte(rollData.selectedSort, diffLibre);
-    }
-    return diffLibre;
-  }
-
   /* -------------------------------------------- */
   _computeMalusArmure(rollData) {
     let malusArmureValue = 0;
     if (rollData.malusArmureValue && (rollData.selectedCarac.label == "Agilité" || rollData.selectedCarac.label == "Dérobée")) {
-      $("#addon-message").text("Malus armure appliqué : " + rollData.malusArmureValue);
       malusArmureValue = rollData.malusArmureValue;
-    } else {
-      $("#addon-message").text("");
     }
     return malusArmureValue;
   }

module/rdd-rolltables.js

@@ -95,8 +95,9 @@ export class RdDRollTables {
     const row = await table.getRandom(itemFrequence, filter);
     if (row) {
       await CompendiumTableHelpers.tableRowToChatMessage(row, type);
+      return row.document;
     }
-    return row;
+    return undefined;
   }
 
   /* -------------------------------------------- */

module/rdd-sheet-utility.js

@@ -1,4 +1,6 @@
 import { DialogSplitItem } from "./dialog-split-item.js";
+import { RdDItem } from "./item.js";
+import { SystemCompendiums } from "./settings/system-compendiums.js";
 
 export class RdDSheetUtility {
 
@@ -19,8 +21,11 @@ export class RdDSheetUtility {
     return $(event.currentTarget)?.parents(".item");
   }
 
-  static prepareItemDropParameters(destItemId, actor, dragData, objetVersConteneur) {
-    const item = fromUuidSync(dragData.uuid)
+  static async prepareItemDropParameters(destItemId, actor, dragData, objetVersConteneur) {
+    let item = fromUuidSync(dragData.uuid);
+    if (item.pack && !item.system){
+      item = await RdDItem.getCorrespondingItem(item);
+    }
     if (actor.canReceive(item)) {
       return {
         destId: destItemId,

module/rdd-timestamp.js

@@ -0,0 +1,306 @@
+import { SHOW_DICE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
+import { Grammar } from "./grammar.js";
+import { Misc } from "./misc.js";
+import { RdDDice } from "./rdd-dice.js";
+
+export const WORLD_TIMESTAMP_SETTING = "calendrier";
+
+const RDD_MOIS_PAR_AN = 12;
+const RDD_JOURS_PAR_MOIS = 28;
+const RDD_JOURS_PAR_AN = 336; //RDD_JOURS_PAR_MOIS * RDD_MOIS_PAR_AN;
+const RDD_HEURES_PAR_JOUR = 12;
+const RDD_MINUTES_PAR_HEURES = 120;
+const RDD_MINUTES_PAR_JOUR = 1440; //RDD_HEURES_PAR_JOUR * RDD_MINUTES_PAR_HEURES;
+const ROUNDS_PAR_MINUTE = 10;
+
+const DEFINITION_HEURES = [
+  { key: "vaisseau", label: "Vaisseau", lettreFont: 'v', saison: "Printemps" },
+  { key: "sirene", label: "Sirène", lettreFont: 'i', saison: "Printemps" },
+  { key: "faucon", label: "Faucon", lettreFont: 'f', saison: "Printemps" },
+  { key: "couronne", label: "Couronne", lettreFont: '', saison: "Eté" },
+  { key: "dragon", label: "Dragon", lettreFont: 'd', saison: "Eté" },
+  { key: "epees", label: "Epées", lettreFont: 'e', saison: "Eté" },
+  { key: "lyre", label: "Lyre", lettreFont: 'l', saison: "Automne" },
+  { key: "serpent", label: "Serpent", lettreFont: 's', saison: "Automne" },
+  { key: "poissonacrobate", label: "Poisson Acrobate", lettreFont: 'p', saison: "Automne" },
+  { key: "araignee", label: "Araignée", lettreFont: 'a', saison: "Hiver" },
+  { key: "roseau", label: "Roseau", lettreFont: 'r', saison: "Hiver" },
+  { key: "chateaudormant", label: "Château Dormant", lettreFont: 'c', saison: "Hiver" },
+]
+
+const FORMULES_DUREE = [
+  { code: "", label: "", calcul: async (t, actor) => t.addJours(100 * RDD_JOURS_PAR_AN) },
+  { code: "jour", label: "1 jour", calcul: async (t, actor) => t.nouveauJour().addJours(1) },
+  { code: "1d7jours", label: "1d7 jour", calcul: async (t, actor) => t.nouveauJour().addJours(await RdDDice.rollTotal('1d7', { showDice: SHOW_DICE })) },
+  { code: "1ddr", label: "Un dé draconique jours", calcul: async (t, actor) => t.nouveauJour().addJours(await RdDDice.rollTotal('1dr+7', { showDice: SHOW_DICE })) },
+  { code: "hn", label: "Fin de l'Heure de Naissance", calcul: async (t, actor) => t.finHeure(actor.getHeureNaissance()) },
+  // { code: "1h", label: "Une heure", calcul: async (t, actor) => t.nouvelleHeure().addHeures(1) },
+  // { code: "12h", label: "12 heures", calcul: async (t, actor) => t.nouvelleHeure().addHeures(12) },
+  // { code: "chateaudormant", label: "Fin Chateau dormant", calcul: async (t, actor) => t.nouveauJour() },
+  // { code: "special", label: "Spéciale", calcul: async (t, actor) => t.addJours(100 * RDD_JOURS_PAR_AN) },
+]
+const FORMULES_PERIODE = [
+  { code: 'round', label: "Rounds", calcul: async (t, nombre) => t.addMinutes(nombre / 10) },
+  { code: 'minute', label: "Minutes", calcul: async (t, nombre) => t.addMinutes(nombre) },
+  { code: 'heure', label: "Heures", calcul: async (t, nombre) => t.addHeures(nombre) },
+  { code: 'jour', label: "Jours", calcul: async (t, nombre) => t.addJours(nombre) },
+]
+
+export class RdDTimestamp {
+
+  static iconeHeure(heure) {
+    return `systems/foundryvtt-reve-de-dragon/icons/heures/hd${heure < 9 ? '0' : ''}${heure + 1}.svg`;
+  }
+
+  static init() {
+    game.settings.register(SYSTEM_RDD, WORLD_TIMESTAMP_SETTING, {
+      name: WORLD_TIMESTAMP_SETTING,
+      scope: "world",
+      config: false,
+      default: { indexDate: 0, indexMinute: 0 },
+      type: Object
+    });
+
+    for (let i = 0; i < DEFINITION_HEURES.length; i++) {
+      DEFINITION_HEURES[i].heure = i;
+      DEFINITION_HEURES[i].icon = RdDTimestamp.iconeHeure(i);
+      DEFINITION_HEURES[i].webp = DEFINITION_HEURES[i].icon.replace(".svg", ".webp");
+    }
+  }
+
+  /**
+   * @param signe 
+   * @returns L'entrée de DEFINITION_HEURES correspondant au signe
+   */
+  static definition(signe) {
+    if (Number.isInteger(signe)) {
+      return DEFINITION_HEURES[signe % RDD_HEURES_PAR_JOUR];
+    }
+    let definition = DEFINITION_HEURES.find(it => it.key == signe);
+    if (!definition) {
+      definition = Misc.findFirstLike(signe, DEFINITION_HEURES, { mapper: it => it.label, description: 'signe' });
+    }
+    return definition
+  }
+
+  static formulesDuree() {
+    return FORMULES_DUREE
+  }
+
+  static formulesPeriode() {
+    return FORMULES_PERIODE
+  }
+
+  static imgSigneHeure(heure) {
+    return RdDTimestamp.imgSigne(RdDTimestamp.definition(heure));
+  }
+
+  static imgSigne(signe) {
+    return `<img class="img-signe-heure" src="${signe.webp}" alt="${signe.label}"/>`
+  }
+
+  static handleTimestampEditor(html, path, consumeTimestamp = async (path, timestamp) => { }) {
+    const fields = {
+      annee: html.find(`input[name="${path}.annee"]`),
+      mois: html.find(`select[name="${path}.mois"]`),
+      jourDuMois: html.find(`input[name="${path}.jourDuMois"]`),
+      heure: html.find(`select[name="${path}.heure"]`),
+      minute: html.find(`input[name="${path}.minute"]`)
+    };
+
+    async function onChangeTimestamp(fields, path) {
+      const annee = Number(fields.annee.val());
+      const mois = fields.mois.val();
+      const jour = Number(fields.jourDuMois.val());
+      const heure = fields.heure.val();
+      const minute = Number(fields.minute.val());
+      await consumeTimestamp(path, RdDTimestamp.timestamp(annee, mois, jour, heure, minute));
+    }
+
+    fields.annee.change(async (event) => await onChangeTimestamp(fields, path));
+    fields.mois.change(async (event) => await onChangeTimestamp(fields, path));
+    fields.jourDuMois.change(async (event) => await onChangeTimestamp(fields, path));
+    fields.heure.change(async (event) => await onChangeTimestamp(fields, path));
+    fields.minute.change(async (event) => await onChangeTimestamp(fields, path));
+  }
+
+
+  static findHeure(heure) {
+    heure = Grammar.toLowerCaseNoAccentNoSpace(heure);
+    let parHeureOuLabel = DEFINITION_HEURES.filter(it => (it.heure) == parseInt(heure) % RDD_HEURES_PAR_JOUR || Grammar.toLowerCaseNoAccentNoSpace(it.label) == heure);
+    if (parHeureOuLabel.length == 1) {
+      return parHeureOuLabel[0];
+    }
+    let parLabelPartiel = DEFINITION_HEURES.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;
+  }
+
+  /** 
+   * @param indexDate: la date (depuis le jour 0)
+   * @return la version formattée de la date 
+  */
+  static formatIndexDate(indexDate) {
+    return new RdDTimestamp({ indexDate }).formatDate()
+  }
+
+  static splitIndexDate(indexDate) {
+    const timestamp = new RdDTimestamp({ indexDate });
+    return {
+      jour: timestamp.jour + 1,
+      mois: RdDTimestamp.definition(timestamp.mois).key
+    }
+  }
+
+  static getWorldTime() {
+    let worldTime = game.settings.get(SYSTEM_RDD, WORLD_TIMESTAMP_SETTING);
+    if (worldTime.indexJour != undefined && worldTime.heureRdD != undefined) {
+      // Migration
+      worldTime = {
+        indexDate: worldTime.indexJour,
+        indexMinute: worldTime.heureRdD * 120 + worldTime.minutesRelative
+      };
+      RdDTimestamp.setWorldTime(new RdDTimestamp(worldTime))
+    }
+    return new RdDTimestamp(worldTime);
+  }
+
+  static setWorldTime(timestamp) {
+    game.settings.set(SYSTEM_RDD, WORLD_TIMESTAMP_SETTING, duplicate(timestamp));
+  }
+
+  /** construit un RdDTimestamp à partir de l'année/mois/jour/heure?/minute? */
+  static timestamp(annee, mois, jour, heure = 0, minute = 0) {
+    mois = this.definition(mois)?.heure
+    heure = this.definition(heure)?.heure
+    return new RdDTimestamp({
+      indexDate: (jour - 1) + (mois + annee * RDD_MOIS_PAR_AN) * RDD_JOURS_PAR_MOIS,
+      indexMinute: heure * RDD_MINUTES_PAR_HEURES + minute
+    })
+  }
+
+  /**
+   * Constructeur d'un timestamp.
+   * Selon les paramètres, l'objet construit se base su:
+   * - le timestamp
+   * - la date numérique + minute (dans la journée)
+   * @param indexDate: la date à utiliser pour ce timestamp
+   * @param indexMinute: la minute de la journée à utiliser pour ce timestamp
+   * 
+  */
+  constructor({ indexDate, indexMinute = undefined }) {
+    this.indexDate = indexDate
+    this.indexMinute = indexMinute ?? 0
+  }
+
+
+  /**
+   * Convertit le timestamp en une structure avec les informations utiles
+   * pour afficher la date et l'heure
+  */
+  toCalendrier() {
+    return {
+      timestamp: this,
+      annee: this.annee,
+      mois: RdDTimestamp.definition(this.mois),
+      jour: this.jour,
+      jourDuMois: this.jour + 1,
+      heure: RdDTimestamp.definition(this.heure),
+      minute: this.minute
+    };
+  }
+
+  get annee() { return Math.floor(this.indexDate / RDD_JOURS_PAR_AN) }
+  get mois() { return Math.floor((this.indexDate % RDD_JOURS_PAR_AN) / RDD_JOURS_PAR_MOIS) }
+  get jour() { return (this.indexDate % RDD_JOURS_PAR_AN) % RDD_JOURS_PAR_MOIS }
+  get heure() { return Math.floor(this.indexMinute / RDD_MINUTES_PAR_HEURES) }
+  get minute() { return this.indexMinute % RDD_MINUTES_PAR_HEURES }
+  get round() { return ROUNDS_PAR_MINUTE * (this.indexMinute - Math.floor(this.indexMinute)) }
+
+  formatDate() {
+    const jour = this.jour + 1;
+    const mois = RdDTimestamp.definition(this.mois).label;
+    const annee = this.annee ?? '';
+    return `${jour} ${mois}` + (annee ? ' ' + annee : '');
+  }
+
+  nouveauJour() { return new RdDTimestamp({ indexDate: this.indexDate + 1, indexMinute: 0 }) }
+
+  nouvelleHeure() {
+    return this.heure >= RDD_HEURES_PAR_JOUR ? this.nouveauJour() : new RdDTimestamp({
+      indexDate: this.indexDate,
+      indexMinute: (this.heure + 1) * RDD_MINUTES_PAR_HEURES
+    })
+  }
+
+  addJours(jours) {
+    return jours == 0 ? this : new RdDTimestamp({
+      indexDate: this.indexDate + jours,
+      indexMinute: this.indexMinute
+    })
+  }
+
+  addHeures(heures) {
+    if (heures == 0) {
+      return this
+    }
+    const heure = this.heure + heures;
+    return new RdDTimestamp({
+      indexDate: this.indexDate + Math.floor(heure / RDD_HEURES_PAR_JOUR),
+      indexMinute: (this.indexMinute + (heure % RDD_HEURES_PAR_JOUR)) % (RDD_MINUTES_PAR_JOUR)
+    })
+  }
+
+  addMinutes(minutes) {
+    if (minutes == 0) {
+      return this;
+    }
+    const indexMinute = this.indexMinute + minutes;
+    const jours = Math.floor(indexMinute / RDD_MINUTES_PAR_JOUR)
+    return new RdDTimestamp({
+      indexDate: this.indexDate + jours,
+      indexMinute: indexMinute - (jours * RDD_MINUTES_PAR_JOUR)
+    })
+  }
+
+  addPeriode(nombre, unite) {
+    const formule = FORMULES_PERIODE.find(it => it.code == unite);
+    if (formule) {
+      return formule.calcul(this, nombre);
+    }
+    else {
+      ui.notifications.info(`Pas de période pour ${unite ?? 'Aucune uinité définie'}`)
+    }
+    return this;
+  }
+
+  finHeure(heure) {
+    return this.nouvelleHeure().addHeures((12 + heure - this.heure) % 12);
+  }
+
+  async appliquerDuree(duree, actor) {
+    const formule = FORMULES_DUREE.find(it => it.code == duree) ?? FORMULES_DUREE.find(it => it.code == "");
+    return await formule.calcul(this, actor);
+  }
+
+  compare(timestamp) {
+    let diff = this.indexDate - timestamp.indexDate
+    if (diff == 0) {
+      diff = this.indexMinute - timestamp.indexMinute
+    }
+    return diff < 0 ? -1 : diff > 0 ? 1 : 0;
+  }
+
+  difference(timestamp) {
+    const jours = this.indexDate - timestamp.indexDate;
+    const minutes = this.indexMinute - timestamp.indexMinute;
+    return {
+      jours: jours,
+      heures: Math.floor(minutes / RDD_MINUTES_PAR_HEURES),
+      minutes: minutes % RDD_MINUTES_PAR_HEURES
+    }
+  }
+}

module/rdd-tmr-dialog.js

@@ -5,7 +5,6 @@ import { TMRUtility } from "./tmr-utility.js";
 import { tmrConstants } from "./tmr-constants.js";
 import { RdDResolutionTable } from "./rdd-resolution-table.js";
 import { RdDTMRRencontreDialog } from "./rdd-tmr-rencontre-dialog.js";
-import { TMRRencontres } from "./tmr-rencontres.js";
 import { ChatUtility } from "./chat-utility.js";
 import { RdDRoll } from "./rdd-roll.js";
 import { Poetique } from "./poetique.js";
@@ -16,8 +15,9 @@ import { HtmlUtility } from "./html-utility.js";
 import { ReglesOptionelles } from "./settings/regles-optionelles.js";
 import { RdDDice } from "./rdd-dice.js";
 import { STATUSES } from "./settings/status-effects.js";
-import { RdDRencontre } from "./item-rencontre.js";
+import { RdDRencontre } from "./item/item-rencontre.js";
 import { RdDCalendrier } from "./rdd-calendrier.js";
+import { RdDTimestamp } from "./rdd-timestamp.js";
 
 /* -------------------------------------------- */
 
@@ -198,32 +198,33 @@ export class RdDTMRDialog extends Dialog {
   /* -------------------------------------------- */
   async activateListeners(html) {
     super.activateListeners(html);
+    this.html = html;
 
     document.getElementById("tmrrow1").insertCell(0).append(this.pixiApp.view);
 
     if (this.viewOnly) {
-      html.find('.lancer-sort').remove();
-      html.find('.lire-signe-draconique').remove();
+      this.html.find('.lancer-sort').remove();
+      this.html.find('.lire-signe-draconique').remove();
       return;
     }
 
-    HtmlUtility._showControlWhen($(".appliquerFatigue"), ReglesOptionelles.isUsing("appliquer-fatigue"));
-    HtmlUtility._showControlWhen($(".lire-signe-draconique"), this.actor.isResonanceSigneDraconique(this._getActorCoord()));
+    HtmlUtility._showControlWhen(this.html.find(".appliquerFatigue"), ReglesOptionelles.isUsing("appliquer-fatigue"));
+    HtmlUtility._showControlWhen(this.html.find(".lire-signe-draconique"), this.actor.isResonanceSigneDraconique(this._getActorCoord()));
 
     // Roll Sort
-    html.find('.lancer-sort').click((event) => {
+    this.html.find('.lancer-sort').click((event) => {
       this.actor.rollUnSort(this._getActorCoord());
     });
-    html.find('.lire-signe-draconique').click((event) => {
+    this.html.find('.lire-signe-draconique').click((event) => {
       this.actor.rollLireSigneDraconique(this._getActorCoord());
     });
 
-    html.find('#dir-top').click((event) => this.moveFromKey("top"));
-    html.find('#dir-top-left').click((event) => this.moveFromKey("top-left"));
-    html.find('#dir-top-right').click((event) => this.moveFromKey("top-right"));
-    html.find('#dir-bottom-left').click((event) => this.moveFromKey("bottom-left"));
-    html.find('#dir-bottom-right').click((event) => this.moveFromKey("bottom-right"));
-    html.find('#dir-bottom').click((event) => this.moveFromKey("bottom"));
+    this.html.find('#dir-top').click((event) => this.moveFromKey("top"));
+    this.html.find('#dir-top-left').click((event) => this.moveFromKey("top-left"));
+    this.html.find('#dir-top-right').click((event) => this.moveFromKey("top-right"));
+    this.html.find('#dir-bottom-left').click((event) => this.moveFromKey("bottom-left"));
+    this.html.find('#dir-bottom-right').click((event) => this.moveFromKey("bottom-right"));
+    this.html.find('#dir-bottom').click((event) => this.moveFromKey("bottom"));
 
     // Gestion du cout de montée en points de rêve
     let reveCout = ((this.tmrdata.isRapide && !EffetsDraconiques.isDeplacementAccelere(this.actor)) ? -2 : -1) - this.actor.countMonteeLaborieuse();
@@ -245,7 +246,7 @@ export class RdDTMRDialog extends Dialog {
     }
     const coord = this._getActorCoord();
 
-    HtmlUtility._showControlWhen($(".lire-signe-draconique"), this.actor.isResonanceSigneDraconique(coord));
+    HtmlUtility._showControlWhen(this.html.find(".lire-signe-draconique"), this.actor.isResonanceSigneDraconique(coord));
 
     let ptsreve = document.getElementById("tmr-pointsreve-value");
     ptsreve.innerHTML = this.actor.system.reve.reve.value;
@@ -280,7 +281,7 @@ export class RdDTMRDialog extends Dialog {
       }
       await this.actor.santeIncDec("fatigue", this.cumulFatigue)
     }
-    await super.close(); // moving 1 cell costs 1 fatigue
+    await super.close();
   }
 
   /* -------------------------------------------- */
@@ -405,6 +406,8 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   async _tentativeMaitrise(rencData) {
+    this.rencontreState = 'normal';
+
     rencData.reve = this.actor.getReveActuel();
     rencData.etat = this.actor.getEtatGeneral();
 
@@ -450,7 +453,6 @@ export class RdDTMRDialog extends Dialog {
       this._tentativeMaitrise(rencData);
       this._deleteTmrMessages(rencData.actor, rencData.nbRounds);
     }, 2000);
-    this.rencontreState == 'normal';
   }
 
   formatMessageRencontre(rencData, template) {
@@ -460,14 +462,14 @@ export class RdDTMRDialog extends Dialog {
         messageDuree = ` Au total, vous avez passé ${rencData.nbRounds} rounds à vous battre!`;
       }
       else {
-        messageDuree  = ` Vous avez passé ${rencData.nbRounds} rounds à lutter!`;
+        messageDuree = ` Vous avez passé ${rencData.nbRounds} rounds à lutter!`;
       }
     }
     try {
       const compiled = Handlebars.compile(template);
-      return compiled(rencData) + messageDuree ;
+      return compiled(rencData) + messageDuree;
     } catch (error) {
-      return template + messageDuree ;
+      return template + messageDuree;
     }
   }
 
@@ -520,7 +522,7 @@ export class RdDTMRDialog extends Dialog {
     }
     this.currentRencontre = await this._jetDeRencontre(tmr);
     if (this.currentRencontre) {
-      if (this.rencontresExistantes.find(it => it.id == this.currentRencontre.id)){
+      if (this.rencontresExistantes.find(it => it.id == this.currentRencontre.id)) {
         // rencontre en attente suite à dérobade
         await this.maitriserRencontre();
       }
@@ -550,7 +552,7 @@ export class RdDTMRDialog extends Dialog {
     this.currentRencontre = present.clone({
       'system.force': await RdDDice.rollTotal(present.system.formule),
       'system.coord': tmr.coord
-    }, {save: false});
+    }, { save: false });
 
     await EffetsDraconiques.presentCites.ouvrirLePresent(this.actor, presentCite);
     this.removeToken(tmr, presentCite);
@@ -839,7 +841,7 @@ export class RdDTMRDialog extends Dialog {
   async processSortReserve(sortReserve) {
     await this.actor.deleteEmbeddedDocuments('Item', [sortReserve.id]);
     console.log("declencheSortEnReserve", sortReserve);
-    const heureCible = RdDCalendrier.getSigneAs('label', sortReserve.system.heurecible);
+    const heureCible = RdDTimestamp.definition(sortReserve.system.heurecible).label;
     this._tellToUserAndGM(`Vous avez déclenché 
         ${sortReserve.system.echectotal ? "<strong>l'échec total!</strong>" : "le sort"}
         en réserve <strong>${sortReserve.name}</strong>

module/rdd-utility.js

@@ -12,9 +12,10 @@ import { Monnaie } from "./item-monnaie.js";
 import { RdDPossession } from "./rdd-possession.js";
 import { RdDNameGen } from "./rdd-namegen.js";
 import { RdDConfirm } from "./rdd-confirm.js";
-import { RdDCalendrier } from "./rdd-calendrier.js";
 import { Environnement } from "./environnement.js";
 import { RdDItemCompetence } from "./item-competence.js";
+import { RdDResolutionTable } from "./rdd-resolution-table.js";
+import { RdDTimestamp } from "./rdd-timestamp.js";
 
 /* -------------------------------------------- */
 // This table starts at 0 -> niveau -10
@@ -125,6 +126,7 @@ export class RdDUtility {
       'systems/foundryvtt-reve-de-dragon/templates/actor/header-compteurs-creature.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/header-compteurs-entitee.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/header-effects.html',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/header-hautreve.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/vue-detaillee.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/carac-main.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/carac-derivee.html',
@@ -168,39 +170,18 @@ export class RdDUtility {
       'systems/foundryvtt-reve-de-dragon/templates/actor/liens-animaux.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/liens-suivants.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/liens-vehicules.html',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire.html',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire-item.html',
       //Items
       'systems/foundryvtt-reve-de-dragon/templates/scripts/autocomplete-script.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/scripts/autocomplete.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/item/boutons-comestible.html',
+      'systems/foundryvtt-reve-de-dragon/templates/item/temporel.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/item/partial-inventaire.html',
       'systems/foundryvtt-reve-de-dragon/templates/item/partial-environnement.html',
       'systems/foundryvtt-reve-de-dragon/templates/item/partial-tab-environnement.html',
-      'systems/foundryvtt-reve-de-dragon/templates/header-item.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-competence-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-competencecreature-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-arme-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-armure-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-objet-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-conteneur-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-sort-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-herbe-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-ingredient-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-faune-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-livre-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-tache-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-potion-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-rencontre-sheet.html',
       'systems/foundryvtt-reve-de-dragon/templates/item-queue-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-souffle-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-tarot-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-tete-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-ombre-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-monnaie-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-meditation-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-nourritureboisson-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-signedraconique-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-possession-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-extraitpoetique-sheet.html',
+      'systems/foundryvtt-reve-de-dragon/templates/header-item.html',
       // partial enums
       'systems/foundryvtt-reve-de-dragon/templates/enum-caracteristiques.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-base-competence.html',
@@ -211,7 +192,6 @@ export class RdDUtility {
       'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-potion.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-vehicule.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-competence.html',
-      'systems/foundryvtt-reve-de-dragon/templates/enum-herbesoin-ingredient.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-heures.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-initpremierround.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-niveau-ethylisme.html',
@@ -219,8 +199,12 @@ export class RdDUtility {
       'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-queue.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-draconic.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-tmr-type.html',
+      'systems/foundryvtt-reve-de-dragon/templates/enum-periode.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-tmr-effet.html',
       // Partials
+      'systems/foundryvtt-reve-de-dragon/templates/common/timestamp.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/common/periodicite.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/common/enum-duree.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/common/compendium-link.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/partial-description-overflow.html',
       'systems/foundryvtt-reve-de-dragon/templates/partial-description-sort.html',
@@ -237,6 +221,8 @@ export class RdDUtility {
       'systems/foundryvtt-reve-de-dragon/templates/partial-item-hautrevant.html',
       'systems/foundryvtt-reve-de-dragon/templates/partial-item-frequence.html',
       'systems/foundryvtt-reve-de-dragon/templates/partial-item-description.html',
+      'systems/foundryvtt-reve-de-dragon/templates/roll/explain.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/resolution-table.html',
       // Dialogs
       'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-resolution.html',
       'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-competence.html',
@@ -282,6 +268,8 @@ export class RdDUtility {
     ];
 
     Handlebars.registerHelper('either', (a, b) => a ?? b);
+    Handlebars.registerHelper('computeResolutionScore', (row, col) => RdDResolutionTable.computePercentage(row, col));
+    Handlebars.registerHelper('computeResolutionChances', (row, col) => RdDResolutionTable.computeChances(row, col));
     Handlebars.registerHelper('upperFirst', str => Misc.upperFirst(str ?? 'Null'));
     Handlebars.registerHelper('lowerFirst', str => Misc.lowerFirst(str ?? 'Null'));
     Handlebars.registerHelper('upper', str => str?.toUpperCase() ?? 'NULL');
@@ -289,13 +277,20 @@ export class RdDUtility {
     Handlebars.registerHelper('apostrophe', (article, str) => Grammar.apostrophe(article, str));
     Handlebars.registerHelper('un', str => Grammar.articleIndetermine(str));
     Handlebars.registerHelper('accord', (genre, ...args) => Grammar.accord(genre, args));
-    Handlebars.registerHelper('buildConteneur', (objet) => { return new Handlebars.SafeString(RdDUtility.buildConteneur(objet)); });
+    Handlebars.registerHelper('buildConteneur', (objet, templateItem, options) => { return new Handlebars.SafeString(RdDUtility.buildConteneur(objet, 1, templateItem, options)); });
     Handlebars.registerHelper('buildContenu', (objet) => { return new Handlebars.SafeString(RdDUtility.buildContenu(objet, 1, true)); });
+    Handlebars.registerHelper('calculerPrixCommercant', item => item.calculerPrixCommercant());
     Handlebars.registerHelper('caseTmr-label', coord => TMRUtility.getTMRLabel(coord));
     Handlebars.registerHelper('caseTmr-type', coord => TMRUtility.getTMRType(coord));
     Handlebars.registerHelper('typeTmr-name', type => TMRUtility.typeTmrName(type));
     Handlebars.registerHelper('effetRencontre-name', coord => TMRUtility.typeTmrName(coord));
-    Handlebars.registerHelper('signeHeure', (key, heure)  => RdDCalendrier.getSigneAs(key, heure));
+
+    Handlebars.registerHelper('timestamp-imgSigneHeure', (heure) => { return new Handlebars.SafeString(RdDTimestamp.imgSigneHeure(heure)) });
+    Handlebars.registerHelper('timestamp-imgSigne', (heure) => { return new Handlebars.SafeString(RdDTimestamp.imgSigne(heure)) });
+    Handlebars.registerHelper('timestamp-extract', timestamp => new RdDTimestamp(timestamp).toCalendrier());
+    Handlebars.registerHelper('timestamp-formulesDuree', () => RdDTimestamp.formulesDuree());
+    Handlebars.registerHelper('timestamp-formulesPeriode', () => RdDTimestamp.formulesPeriode());
+
     Handlebars.registerHelper('min', (...args) => Math.min(...args.slice(0, -1)));
     Handlebars.registerHelper('regle-optionnelle', (option) => ReglesOptionelles.isUsing(option));
     Handlebars.registerHelper('trier', list => list.sort((a, b) => a.name.localeCompare(b.name)));
@@ -308,63 +303,13 @@ export class RdDUtility {
   }
 
   static getItem(itemId, actorId = undefined) {
-    return actorId ? game.actors.get(actorId)?.getObjet(itemId) : game.items.get(itemId);
+    return actorId ? game.actors.get(actorId)?.getItem(itemId) : game.items.get(itemId);
   }
 
   static linkCompendium(pack, id, name) {
     return `@Compendium[${pack}.${id}]{${name}}`;
   }
 
-  /* -------------------------------------------- */
-  static async creerObjet(actorSheet) {
-    let itemType = $(".item-type").val();
-    await actorSheet.createItem('Nouveau ' + itemType, itemType);
-  }
-
-  /* -------------------------------------------- */
-  static async selectObjetType(actorSheet) {
-    let typeObjets = RdDItem.getItemTypesInventaire();
-    let options = `<span class="competence-label">Selectionnez le type d'équipement</span><select class="item-type">`;
-    for (let typeName of typeObjets) {
-      options += `<option value="${typeName}">${typeName}</option>`
-    }
-    options += '</select>';
-    let d = new Dialog({
-      title: "Créer un équipement",
-      content: options,
-      buttons: {
-        one: {
-          icon: '<i class="fas fa-check"></i>',
-          label: "Créer l'objet",
-          callback: () => this.creerObjet(actorSheet)
-        }
-      }
-    });
-    d.render(true);
-  }
-
-  /* -------------------------------------------- */
-  static async selectTypeOeuvre(actorSheet) {
-    let typeObjets = RdDItem.getTypesOeuvres();
-    let options = `<span class="competence-label">Selectionnez le type d'oeuvre</span><select class="item-type">`;
-    for (let typeName of typeObjets) {
-      options += `<option value="${typeName}">${typeName}</option>`
-    }
-    options += '</select>';
-    let d = new Dialog({
-      title: "Créer un équipement",
-      content: options,
-      buttons: {
-        one: {
-          icon: '<i class="fas fa-check"></i>',
-          label: "Créer l'objet",
-          callback: () => this.creerObjet(actorSheet)
-        }
-      }
-    });
-    d.render(true);
-  }
-
   /* -------------------------------------------- */
   static buildListOptions(min, max) {
     let options = ""
@@ -404,68 +349,6 @@ export class RdDUtility {
     return undefined;
   }
 
-  /* -------------------------------------------- */
-  static filterItemsPerTypeForSheet(formData, itemTypes) {
-
-    RdDUtility.filterEquipementParType(formData, itemTypes);
-
-    formData.sorts = this.arrayOrEmpty(itemTypes['sort']);
-    formData.rencontres = this.arrayOrEmpty(itemTypes['rencontre']);
-    formData.casestmr = this.arrayOrEmpty(itemTypes['casetmr']);
-    formData.signesdraconiques = this.arrayOrEmpty(itemTypes['signedraconique']);
-    formData.queues = this.arrayOrEmpty(itemTypes['queue']);
-    formData.souffles = this.arrayOrEmpty(itemTypes['souffle']);
-    formData.ombres = this.arrayOrEmpty(itemTypes['ombre']);
-    formData.tetes = this.arrayOrEmpty(itemTypes['tete']);
-    formData.taches = this.arrayOrEmpty(itemTypes['tache']);
-    formData.meditations = this.arrayOrEmpty(itemTypes['meditation']);
-    formData.chants = this.arrayOrEmpty(itemTypes['chant']);
-    formData.danses = this.arrayOrEmpty(itemTypes['danse']);
-    formData.musiques = this.arrayOrEmpty(itemTypes['musique']);
-    formData.oeuvres = this.arrayOrEmpty(itemTypes['oeuvre']);
-    formData.jeux = this.arrayOrEmpty(itemTypes['jeu']);
-
-    formData.recettescuisine = this.arrayOrEmpty(itemTypes['recettecuisine']);
-    formData.recettesAlchimiques = this.arrayOrEmpty(itemTypes['recettealchimique']);
-    formData.maladies = this.arrayOrEmpty(itemTypes['maladie']);
-    formData.poisons = this.arrayOrEmpty(itemTypes['poison']);
-    formData.possessions = this.arrayOrEmpty(itemTypes['possession']);
-    formData.maladiesPoisons = formData.maladies.concat(formData.poisons);
-    formData.competences = (itemTypes['competence'] ?? []).concat(itemTypes['competencecreature'] ?? []);
-    formData.sortsReserve = this.arrayOrEmpty(itemTypes['sortreserve']);
-  }
-
-  static filterEquipementParType(formData, itemTypes) {
-    formData.conteneurs = this.arrayOrEmpty(itemTypes['conteneur']);
-
-    formData.materiel = this.arrayOrEmpty(itemTypes['objet']);
-    formData.armes = this.arrayOrEmpty(itemTypes['arme']);
-    formData.armures = this.arrayOrEmpty(itemTypes['armure']);
-    formData.munitions = this.arrayOrEmpty(itemTypes['munition']);
-    formData.livres = this.arrayOrEmpty(itemTypes['livre']);
-    formData.potions = this.arrayOrEmpty(itemTypes['potion']);
-    formData.ingredients = this.arrayOrEmpty(itemTypes['ingredient']);
-    formData.faunes = this.arrayOrEmpty(itemTypes['faune']);
-    formData.herbes = this.arrayOrEmpty(itemTypes['herbe']);
-    formData.monnaie = this.arrayOrEmpty(itemTypes['monnaie']).sort(Monnaie.triValeurEntiere());
-    formData.nourritureboissons = this.arrayOrEmpty(itemTypes['nourritureboisson']);
-    formData.gemmes = this.arrayOrEmpty(itemTypes['gemme']);
-
-    formData.objets = formData.conteneurs
-      .concat(formData.materiel)
-      .concat(formData.armes)
-      .concat(formData.armures)
-      .concat(formData.munitions)
-      .concat(formData.livres)
-      .concat(formData.potions)
-      .concat(formData.ingredients)
-      .concat(formData.herbes)
-      .concat(formData.faunes)
-      .concat(formData.monnaie)
-      .concat(formData.nourritureboissons)
-      .concat(formData.gemmes);
-  }
-
   /* -------------------------------------------- */
   static buildArbreDeConteneurs(conteneurs, objets) {
     let objetVersConteneur = {};
@@ -514,29 +397,34 @@ export class RdDUtility {
   /** Construit la structure récursive des conteneurs, avec imbrication potentielle
    * 
    */
-  static buildConteneur(objet, profondeur) {
+  static buildConteneur(objet, profondeur, templateItem, options) {
     if (!profondeur) profondeur = 1;
+    if (!templateItem) templateItem = 'actor/inventaire-item.html'
     objet.niveau = profondeur;
+
     const isConteneur = objet.type == 'conteneur';
     const isOuvert = isConteneur && this.getAfficheContenu(objet._id);
     const isVide = isConteneur && objet.system.contenu.length == 0;
-    const conteneur = Handlebars.partials['systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-item.html']({
+    const conteneur = Handlebars.partials[`systems/foundryvtt-reve-de-dragon/templates/${templateItem}`]({
       item: objet,
       vide: isVide,
-      ouvert: isOuvert
+      ouvert: isOuvert,
+      options: options
     });
-    const contenu = isConteneur ? RdDUtility.buildContenu(objet, profondeur, isOuvert) : '';
+    const contenu = isConteneur ? RdDUtility.buildContenu(objet, profondeur, isOuvert, templateItem, options) : '';
     return conteneur + contenu;
   }
 
   /* -------------------------------------------- */
-  static buildContenu(objet, profondeur, afficherContenu) {
+  static buildContenu(objet, profondeur, afficherContenu, templateItem, options) {
     if (!profondeur) profondeur = 1;
+    if (!templateItem) templateItem = 'actor/inventaire-item.html'
     objet.niveau = profondeur;
+
     const display = afficherContenu ? 'item-display-show' : 'item-display-hide';
-    let strContenu = `<ul class='item-list alterne-list ${display} list-item-margin${Math.min(profondeur,6)}'>`;
+    let strContenu = `<ul class='item-list alterne-list ${display} list-item-margin${Math.min(profondeur, 6)}'>`;
     for (let subItem of objet.subItems) {
-      strContenu += this.buildConteneur(subItem, profondeur + 1);
+      strContenu += this.buildConteneur(subItem, profondeur + 1, templateItem, options);
     }
     return strContenu + "</ul>";
   }
@@ -688,7 +576,7 @@ export class RdDUtility {
 
     return await RdDUtility.prepareEncaissement(rollData, roll, armure);
   }
-  
+
   /* -------------------------------------------- */
   static async prepareEncaissement(rollData, roll, armure) {
     const jetTotal = roll.total + rollData.dmg.total - armure;
@@ -704,11 +592,11 @@ export class RdDUtility {
     encaissement.endurance = await RdDUtility._evaluatePerte(encaissement.endurance, over20);
     encaissement.penetration = rollData.arme?.system.penetration ?? 0;
     encaissement.blessures = (
-      encaissement.critiques> 0 ? "Critique":
-      encaissement.graves> 0 ? "Grave":
-      encaissement.legeres> 0 ? "Légère":
-      encaissement.eraflures>0 ? "Contusions/Eraflures":
-      'Aucune'
+      encaissement.critiques > 0 ? "Critique" :
+        encaissement.graves > 0 ? "Grave" :
+          encaissement.legeres > 0 ? "Légère" :
+            encaissement.eraflures > 0 ? "Contusions/Eraflures" :
+              'Aucune'
     );
     return encaissement;
   }
@@ -762,8 +650,6 @@ export class RdDUtility {
     switch (sockmsg.msg) {
       case "msg_gm_chat_message":
         return ChatUtility.handleGMChatMessage(sockmsg.data);
-      case "msg_sync_time":
-        return game.system.rdd.calendrier.syncPlayerTime(sockmsg.data);
       case "msg_request_nombre_astral":
         return game.system.rdd.calendrier.requestNombreAstral(sockmsg.data);
       case "msg_response_nombre_astral":
@@ -808,7 +694,7 @@ export class RdDUtility {
 
     // gestion bouton tchat Acheter
     html.on("click", '.button-acheter', event => {
-      const venteData = DialogItemAchat.venteData(event.currentTarget);
+      const venteData = DialogItemAchat.preparerAchat(event.currentTarget);
       if (venteData) {
         DialogItemAchat.onAcheter(venteData);
       }
@@ -824,6 +710,18 @@ export class RdDUtility {
         ChatUtility.removeChatMessageId(RdDUtility.findChatMessageId(event.currentTarget));
       }
     });
+    html.on("click", '.rdd-world-content-link', async event => {
+      const htmlElement = html.find(event.currentTarget);
+      const id = htmlElement?.data("id");
+      const doctype = htmlElement?.data("doctype");
+      switch (doctype ?? 'Item') {
+        case 'Actor':
+          return game.actors.get(id)?.sheet.render(true);
+        case 'Item':
+        default:
+          return game.items.get(id)?.sheet.render(true);
+      }
+    });
   }
 
   static findChatMessageId(current) {
@@ -899,7 +797,7 @@ export class RdDUtility {
     if (p2[2] == 'd') deniers += Number(p2[1]);
     if (p2[2] == 's') sols += Number(p2[1]);
 
-    let sommeAPayer = sols + deniers/100;
+    let sommeAPayer = sols + deniers / 100;
     let msgPayer = `La somme de ${sols} Sols et ${deniers} Deniers est à payer<br>
       <a class='payer-button chat-card-button' data-somme-a-payer='${sommeAPayer}'>Payer</a>`
     ChatMessage.create({ content: msgPayer });
@@ -941,7 +839,7 @@ export class RdDUtility {
   }
 
   /* -------------------------------------------- */
-  static async confirmerSuppressionItem(sheet, item, htmlToDelete) {
+  static async confirmActorItemDelete(sheet, item, htmlToDelete) {
     const itemId = item.id;
     const confirmationSuppression = {
       settingConfirmer: "confirmation-supprimer-" + item.getItemGroup(),
@@ -982,10 +880,10 @@ export class RdDUtility {
   /* -------------------------------------------- */
   static afficherHeuresChanceMalchance(heureNaissance) {
     if (game.user.isGM) {
-      let heure = game.system.rdd.calendrier.findHeure(heureNaissance);
+      const heure = RdDTimestamp.findHeure(heureNaissance - 1);
       if (heureNaissance && heure) {
         let ajustement = game.system.rdd.calendrier.getAjustementAstrologique(heureNaissance);
-        const current = game.system.rdd.calendrier.findHeure(game.system.rdd.calendrier.getCurrentHeure());
+        const current = game.system.rdd.calendrier.heureCourante();
         ChatMessage.create({
           content: `A l'heure de <strong>${current.label}</strong>, le modificateur de Chance/Malchance est de <strong>${Misc.toSignedString(ajustement)}</strong> pour l'heure de naissance <strong>${heure.label}</strong>.`,
           whisper: ChatMessage.getWhisperRecipients("GM")

module/settings/system-compendiums.js

@@ -87,6 +87,11 @@ export class SystemCompendiums extends FormApplication {
     return items;
   }
 
+  static async loadDocument(document) {
+    const pack = game.packs.get(document.pack);
+    return await pack.getDocument(document.id ?? document._id);
+  }
+
   static async getItems(compendium, itemType = undefined) {
     const items = await SystemCompendiums.getPackContent(compendium, 'Item');
     return (itemType ? items.filter(it => it.type == itemType) : items);

module/tmr-rencontres.js

@@ -1,6 +1,7 @@
 import { Grammar } from "./grammar.js";
 import { Misc } from "./misc.js";
 import { RdDDice } from "./rdd-dice.js";
+import { RdDUtility } from "./rdd-utility.js";
 import { SystemCompendiums, CompendiumTable, CompendiumTableHelpers } from "./settings/system-compendiums.js";
 import { TMRUtility } from "./tmr-utility.js";
 
@@ -11,10 +12,10 @@ export class TMRRencontres {
   static init() {
     const tmrRencontre = new TMRRencontres();
     game.system.rdd.rencontresTMR = tmrRencontre;
-    
+
   }
 
-  constructor(){
+  constructor() {
     this.table = new CompendiumTable('rencontres', 'Item', 'rencontre', Misc.ascending(it => it.system.ordreTri));
   }
 
@@ -58,24 +59,16 @@ export class TMRRencontres {
     return rencontre.clone({
       'system.force': await RdDDice.rollTotal(rencontre.system.formule),
       'system.coord': tmr?.coord,
-      'system.date': game.system.rdd.calendrier.getDateFromIndex(),
-      'system.heure': game.system.rdd.calendrier.getCurrentHeure()
+      'system.date': game.system.rdd.calendrier.dateCourante(),
+      'system.heure': game.system.rdd.calendrier.heureCourante().key
     }, { save: false });
   }
 
   async calculRencontre(rencontre, tmr = undefined) {
-    if (rencontre.system.coord == "") {
-      rencontre.system.coord = tmr?.coord;
-    }
-    if (rencontre.system.force == 0) {
-      rencontre.system.force = await RdDDice.rollTotal(rencontre.system.formule);
-    }
-    if (rencontre.system.date == "") {
-      rencontre.system.date = game.system.rdd.calendrier.getDateFromIndex();
-    }
-    if (rencontre.system.heure == "") {
-      rencontre.system.heure = game.system.rdd.calendrier.getCurrentHeure();
-    }
+    rencontre.system.coord = rencontre.system.coord ?? tmr?.coord;
+    rencontre.system.force = rencontre.system.force ?? await RdDDice.rollTotal(rencontre.system.formule);
+    rencontre.system.date = rencontre.system.date ?? game.system.rdd.calendrier.dateCourante();
+    rencontre.system.heure = rencontre.system.heure ?? game.system.rdd.calendrier.heureCourante().key;
     return rencontre;
   }
 
@@ -100,19 +93,21 @@ export class TMRRencontres {
 
     const row = await this.table.getRandom(frequence, filtreMauvaise);
     if (row) {
-      row.document = this.createRencontre(row.document, tmr);
-      await this.$chatRolledRencontre(row, tmr);
+      const rencontre = await this.createRencontre(row.document, tmr);
+      await this.$chatRolledRencontre(row, rencontre, tmr);
+      return rencontre;
     }
-    return row?.document;
+    return undefined;
   }
 
 
   /* -------------------------------------------- */
-  async $chatRolledRencontre(row, tmr) {
+  async $chatRolledRencontre(row, rencontre, tmr) {
     const flavorContent = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-compendium-table-roll-rencontre.html',
       {
         roll: row.roll,
-        rencontre: row?.document,
+        rencontre,
+        row,
         percentages: (row.total == 100) ? '%' : '',
         tmr,
         isGM: game.user.isGM,

packs/armes-et-armures.db

@@ -1,32 +0,0 @@
-{"name":"Arme d’hast","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"","quantite":1,"encombrement":4,"equipe":false,"dommages":"4","force":"12","resistance":8,"competence":"Arme d'hast","cout":10,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":false,"deuxmains":true,"unemain":false},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/hast.webp","effects":[],"_id":"U6qli6TPbzj8tUdH"}
-{"name":"Bâton","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"","quantite":1,"encombrement":2,"equipe":false,"dommages":"1","force":"9","resistance":8,"competence":"Masse à 2 mains","cout":0.5,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":false,"deuxmains":true,"unemain":false},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/baton.webp","effects":[],"_id":"wyiy7aLaP8jnzkFn"}
-{"name":"Bouclier léger","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"","quantite":1,"encombrement":1,"equipe":false,"dommages":"0","force":"8","resistance":13,"competence":"Bouclier","cout":4,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":false,"deuxmains":false,"unemain":false},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/bouclier_petit.webp","effects":[],"_id":"eK28jEeQiJdd93L3"}
-{"name":"Bouclier lourd","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"","quantite":1,"encombrement":3,"equipe":false,"dommages":"0","force":"13","resistance":20,"competence":"Bouclier","cout":8,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":false,"deuxmains":false,"unemain":false},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/bouclier_grand.webp","effects":[],"_id":"7B9sKLf4ipRyyEjF"}
-{"name":"Bouclier moyen","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"","quantite":1,"encombrement":2,"equipe":false,"dommages":"0","force":"11","resistance":15,"competence":"Bouclier","cout":6,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":false,"deuxmains":false,"unemain":false},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/bouclier_moyen.webp","effects":[],"_id":"1O7IJiQSDYxJ5VsD"}
-{"name":"Cuir / Metal","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"armure","data":{"description":"<p>Cuir épais clouté, ou petites plaquettes, écailles ou anneaux de fer cousus sur le cuir. Pectoral ou cotte de cuir/métal + jupon ou cuissards de cuir / métal sur culottes de cuir souple + bottes de cuir / métal + casque de métal.</p>\n<p>&nbsp;</p>","quantite":1,"encombrement":4,"equipe":false,"protection":4,"deterioration":0,"malus":-2,"cout":20},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/cuir_metal.webp","effects":[],"_id":"fDwsTMuug0Z5BdaA"}
-{"name":"Cuir Epais","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"armure","data":{"description":"<p>Cuir très épais comme le cuir de botte. Pectoral de cuir épais + jupon de bandes ou de tresses de cuir ou cuissards de cuir épais sur culottes de cuir souple + bottes dures + casque de cuir.</p>\n<p>&nbsp;</p>","quantite":1,"encombrement":2,"equipe":false,"protection":3,"deterioration":0,"malus":-1,"cout":10},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/cuir_epais.webp","effects":[],"_id":"szOThadvQvFcS79R"}
-{"name":"Cuir Souple","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"armure","data":{"description":"<p>Même épaisseur que nos modernes blousons de cuir. Pourpoint ou cotte de cuir souple + culottes de cuir souple + bottes de cuir souple.</p>\n<p>&nbsp;</p>","quantite":1,"encombrement":0,"equipe":false,"protection":2,"deterioration":0,"malus":0,"cout":6},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/cuir_souple.webp","effects":[],"_id":"b0f08L5CDeFIMluC"}
-{"name":"Dague","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"","quantite":1,"encombrement":0.5,"equipe":false,"dommages":"1","force":"7","resistance":8,"competence":"Dague","cout":3,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":true,"deuxmains":false,"unemain":true},"flags":{"core":{"sheetClass":""}},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/dague.webp","effects":[],"_id":"CGYOJbaKtYvF2qa9"}
-{"name":"Double dragonne","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"<p>Apparue vers la fin du Second &Acirc;ge, c&rsquo;&eacute;tait<em> une grande &eacute;p&eacute;e &agrave; deux mains</em>. Encombrante et prohibant le bouclier, c&rsquo;&eacute;tait avant tout une &eacute;p&eacute;e de duel et de frime.</p>","quantite":1,"encombrement":4,"equipe":false,"dommages":"5","force":"13","resistance":13,"competence":"Epée à 2 mains","cout":50,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":false,"deuxmains":true,"unemain":false},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/double_dragonne.webp","effects":[],"_id":"6s5QjArwz9w9JIGL"}
-{"name":"Drap Matelassé","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"armure","data":{"description":"<p>Deux épaisseurs de drap surpiquées, avec rembourrage de laine.</p>\n<p>Pourpoint ou cotte de drap matelassé + culottes de drap matelassé + bottes de cuir souple. Le pourpoint est une sorte de veste ; la cotte est une sorte de tunique, lacée sur la poitrine, et descendant jusqu’aux genoux, façon Robin des Bois.</p>\n<p>&nbsp;</p>","quantite":1,"encombrement":0,"equipe":false,"protection":1,"deterioration":0,"malus":0,"cout":4},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/drap_matelasse.webp","effects":[],"_id":"vQ494sD9FgFI08kZ"}
-{"name":"Épée bâtarde","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"<p>Comme son nom l&rsquo;indique, c&rsquo;est une <em>b&acirc;tarde </em>de l'&eacute;p&eacute;e longue et de l'&eacute;p&eacute;e sorde, &agrave; la fois longue et large, pouvant s&rsquo;utiliser &agrave; une ou deux mains.</p>","quantite":1,"encombrement":3,"equipe":false,"dommages":"4/5","force":"13/12","resistance":14,"competence":"Epée à 1 main","cout":30,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":false,"deuxmains":true,"unemain":true},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/epee_batarde.webp","effects":[],"_id":"KmfftnkUsPQD6fV0"}
-{"name":"Épée cyane","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"<p>Long <em>cimeterre </em>&agrave; l&rsquo;acier bleut&eacute;, exclusivement fabriqu&eacute; par les Cyans ou Hommes bleus.</p>","quantite":1,"encombrement":2,"equipe":false,"dommages":"3","force":"11","resistance":12,"competence":"Epée à 1 main","cout":25,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":true,"deuxmains":false,"unemain":true},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/epee_cyane.webp","effects":[],"_id":"ijCebH1Pr3LmzdOj"}
-{"name":"Épée demi-dragonne","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":null,"quantite":1,"encombrement":1.5,"equipe":false,"dommages":"2","force":"10","resistance":10,"competence":"Epée à 1 main","cout":15,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":true,"deuxmains":false,"unemain":true},"flags":{"core":{"sourceId":"Item.ErwaSLcGryAbYjkm"}},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/demi_dragonne.webp","effects":[],"_id":"IlA16EWR1x5ZBckA"}
-{"name":"Épée dragonne","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"<p>C&rsquo;est une &eacute;p&eacute;e <em>longue</em>, plus robuste que l&rsquo;esparlongue, pouvant &eacute;galement frapper de taille.</p>","quantite":1,"encombrement":2,"equipe":false,"dommages":"3","force":"11","resistance":12,"competence":"Epée à 1 main","cout":20,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":true,"deuxmains":false,"unemain":true},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/epee_dragonne.webp","effects":[],"_id":"3Wk5dzp3M7Das6wh"}
-{"name":"Épée gnome","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"<p>C&rsquo;est une &eacute;p&eacute;e <em>courte</em>, essentiellement fabriqu&eacute;e et port&eacute;e par les Gnomes au Second &Acirc;ge.</p>","quantite":1,"encombrement":1,"equipe":false,"dommages":"2","force":"8","resistance":12,"competence":"Epée à 1 main","cout":12,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":true,"deuxmains":false,"unemain":true},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/epee_gnome.webp","effects":[],"_id":"WurdjqJ8zMiXNdiW"}
-{"name":"Épée sorde","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"<p>C&rsquo;est une &eacute;p&eacute;e plus courte que la dragonne, mais plus <em>large</em>. Elle peut s&rsquo;utiliser &agrave; une ou deux mains. Sa grande solidit&eacute; en fait l&rsquo;&eacute;p&eacute;e de pr&eacute;dilection des gardes et des soldats.</p>\n<p>C&rsquo;est probablement &agrave; elle que le <em>Guerrier Sorde</em> doit son nom (&agrave; moins que ce ne soit l&rsquo;inverse).</p>","quantite":1,"encombrement":2,"equipe":false,"dommages":"3/4","force":"12/11","resistance":15,"competence":"Epée à 1 main","cout":20,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":false,"deuxmains":true,"unemain":true},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/epee_sord.webp","effects":[],"_id":"cFnFQrQIPgyZRWdo"}
-{"name":"Esparlongue","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"<p>C&rsquo;est une &eacute;p&eacute;e semblable &agrave; la <em>rapi&egrave;re</em>, longue et ne frappant uniquement d&rsquo;estoc. Elle doit son nom &agrave; ce qu&rsquo;elle &eacute;tait particuli&egrave;rement en vogue, au Second &Acirc;ge, dans la cit&eacute; d&rsquo;Esparlongue. En ce d&eacute;but du Troisi&egrave;me &Acirc;ge, toutefois, on lui substitue le plus souvent la <strong>demi-dragonne</strong>, &eacute;p&eacute;e tr&egrave;s voisine, ne frappant pareillement que d&rsquo;estoc, mais plus r&eacute;sistante (r&eacute;sistance 10) et moins co&ucirc;teuse (15 sols) ; son bonus aux dommages (+2) est identique.</p>","quantite":1,"encombrement":1.5,"equipe":false,"dommages":"2","force":"10","resistance":9,"competence":"Epée à 1 main","cout":20,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":true,"deuxmains":false,"unemain":true},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/esparlongue.webp","effects":[],"_id":"t3LZDSaQ6AiloImA"}
-{"name":"Fléau léger","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"","quantite":1,"encombrement":2,"equipe":false,"dommages":"3","force":"12","resistance":10,"competence":"Fléau","cout":12,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":false,"deuxmains":false,"unemain":true},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/fleau_leger.webp","effects":[],"_id":"J4PpWO4OZ6JPaAUB"}
-{"name":"Fléau lourd","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"","quantite":1,"encombrement":3,"equipe":false,"dommages":"4","force":"13","resistance":10,"competence":"Fléau","cout":15,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":false,"deuxmains":false,"unemain":true},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/fleau_lourd.webp","effects":[],"_id":"HRLrRhAF4Hkfbqjh"}
-{"name":"Gourdin","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"","quantite":1,"encombrement":1,"equipe":false,"dommages":"1","force":"7","resistance":8,"competence":"Masse à 1 main","cout":0,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":true,"deuxmains":false,"unemain":true},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/gourdin.webp","effects":[],"_id":"PoTI2z0Wr4hxiLpQ"}
-{"name":"Grande hache","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"","quantite":1,"encombrement":3,"equipe":false,"dommages":"4","force":"13","resistance":8,"competence":"Hache à 2 mains","cout":15,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":false,"deuxmains":true,"unemain":false},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/grande_hache.webp","effects":[],"_id":"hVgd4APvAW8sbXf0"}
-{"name":"Hache de bataille","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"","quantite":1,"encombrement":2,"equipe":false,"dommages":"3/4","force":"12/11","resistance":8,"competence":"Hache à 1 main","cout":15,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":false,"deuxmains":true,"unemain":true},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/hache_bataille.webp","effects":[],"_id":"9jbjDpbddL2Ep09s"}
-{"name":"Hachette","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"","quantite":1,"encombrement":1,"equipe":false,"dommages":"2","force":"8","resistance":6,"competence":"Hache à 1 main","cout":4,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":true,"deuxmains":false,"unemain":true},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/systems/foundryvtt-reve-de-dragon/icons/objets/hachette.webp","effects":[],"_id":"TKyv5S3VNaOLOWJw"}
-{"name":"Javeline","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"","quantite":1,"encombrement":1,"equipe":false,"dommages":"1","force":"7","resistance":5,"competence":"Lance","cout":1,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":true,"deuxmains":false,"unemain":true},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/javeline.webp","effects":[],"_id":"Ri5QtS98FTfgHk2N"}
-{"name":"Lance courte","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"","quantite":1,"encombrement":2,"equipe":false,"dommages":"2","force":"8","resistance":5,"competence":"Lance","cout":3,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":true,"deuxmains":false,"unemain":true},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/lance.webp","effects":[],"_id":"viHilj5hAHZqWuli"}
-{"name":"Mailles de Fer","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"armure","data":{"description":"<p>Grand haubert de mailles avec capuche À enfiler sur une cotte de cuir souple ou de drap matelassé) + bottes de cuir / métal.</p>\n<p>&nbsp;</p>","quantite":1,"encombrement":6,"equipe":false,"protection":5,"deterioration":null,"malus":-4,"cout":50},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/mailles.webp","effects":[],"_id":"KQZIK8ltQ3sQiDGe"}
-{"name":"Marteau","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"","quantite":1,"encombrement":0.3,"equipe":false,"dommages":"2","force":"7","resistance":8,"competence":"Masse à 1 main","cout":1,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":true,"deuxmains":false,"unemain":true},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/systems/foundryvtt-reve-de-dragon/icons/objets/marteau.webp","effects":[],"_id":"i26px61PjvPlOiJW"}
-{"name":"Masse lourde","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"","quantite":1,"encombrement":3,"equipe":false,"dommages":"3/4","force":"12/11","resistance":10,"competence":"Masse à 1 main","cout":4,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":false,"deuxmains":true,"unemain":true},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/masse_lourde.webp","effects":[],"_id":"7xFe41JZIVNMLv1U"}
-{"name":"Massette","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"","quantite":1,"encombrement":1,"equipe":false,"dommages":"2","force":"9","resistance":8,"competence":"Masse à 1 main","cout":2,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":true,"deuxmains":false,"unemain":true},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/massette.webp","effects":[],"_id":"wK5sGduzSvY3XxMF"}
-{"name":"Plaques de Fer","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"armure","data":{"description":"<p>L'armure classique du chevalier. Armure complète de plaques (heaume, cuirasse, épaulières, cubitières, ventrière, cuissards, jambières).</p>\n<p>&nbsp;</p>","quantite":1,"encombrement":8,"equipe":false,"protection":6,"deterioration":0,"malus":-6,"cout":100},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/armure_plaques.webp","effects":[],"_id":"S3bLtbXe6BzEFCjt"}
-{"name":"Rasoir","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"arme","data":{"description":"","quantite":1,"encombrement":0.1,"equipe":false,"dommages":"1","force":"0","resistance":0,"competence":"Dague","cout":2,"portee_courte":0,"portee_moyenne":0,"portee_extreme":0,"rapide":true,"deuxmains":false,"unemain":true},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/armes_armures/systems/foundryvtt-reve-de-dragon/icons/objets/rasoir.webp","effects":[],"_id":"9UFxKeFJv79QSzhz"}

packs/arts-et-divertissements.db

@@ -1,49 +1,49 @@
-{"name":"Moussecaille","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"recettecuisine","data":{"niveau":6,"ingredients":"<ul>\n<li>4 grosses cailles (1 sust chaque)</li>\n<li>3 livres de mousseroles</li>\n<li>4 &eacute;chalotes</li>\n<li>1 racine de r&eacute;f&egrave;ble</li>\n<li>1 schouillat de miel</li>\n<li>10 schouillats de beurre</li>\n<li>2 doigts d&rsquo;huile</li>\n<li>5 schouillats de farine de bl&eacute;di&egrave;ze</li>\n<li>eau</li>\n<li>sel</li>\n<li>4 brins de klampine</li>\n<li>4 brins de luciane</li>\n<li>1 brin de mentharde</li>\n<li>4 brins de p&egrave;pre</li>\n</ul>","duree":"80 minutes","sust":8,"description":"<p>Civet de cailles aux mousseroles.</p>\n<p>La mousserole est un petit champignon rose, tr&egrave;s abondant apr&egrave;s la pluie (commun). Pratiquement, cette recette peut s&rsquo;appliquer &agrave; tout gibier &agrave; plume pr&eacute;par&eacute; aux champignons.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/recette_cuisine_6.webp","effects":[],"_id":"240HPtZsgZQERFMF"}
-{"name":"Panaris et Phlegmon","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"chant","data":{"niveau":7,"description":"<p>Romance sur la fatalit&eacute; qui s&eacute;pare deux amants et que seule la mort r&eacute;unit.</p>\n<p>&Agrave; la fin, la belle Panaris est transform&eacute;e en carafe et le gentil Phlegmon en bouchon de cristal. L&rsquo;empereur, &agrave; qui &eacute;choit le flacon, les rassemble symboliquement.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_7.webp","effects":[],"_id":"36YGDFJBxekzEvBw"}
-{"name":"La danse des sept rêves","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"danse","data":{"type":"soliste","agilite":false,"apparence":true,"niveau":6,"description":"<p>V&eacute;ritable ballet, la danse des sept r&ecirc;ves est une chor&eacute;graphie dramatique &eacute;labor&eacute;e.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_sol_8.webp","effects":[],"_id":"4mhiTAEhwDh7S3i0"}
-{"name":"Les fléchettes","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"jeu","data":{"type":"adressehasard","base":-6,"caraccomp":"Lancer","description":"<p>Jeu d&rsquo;adresse consistant &agrave; viser une cible avec des fl&eacute;chettes.</p>\n<p>Pour simuler une partie, faire tirer &agrave; chaque participant 5 jets de Lancer/Jeu &agrave; z&eacute;ro et additionner les points de t&acirc;che obtenus. Le plus grand nombre gagne.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_flechettes.webp","effects":[],"_id":"8jOKQkuS6RJyM3uD"}
-{"name":"La peccadille","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"danse","data":{"type":"recreative","agilite":false,"apparence":true,"niveau":2,"description":"<p>La peccadille se danse &agrave; deux, comme la valse ou le tango. Plus lente et moins rythm&eacute;e&nbsp; que les deux premi&egrave;res, elle comporte quatre figures :</p>\n<p>1) les cavaliers se tiennent par les mains</p>\n<p>2) ils se tiennent par la taille</p>\n<p>3) figure libre, improvis&eacute;e par celui ou celle qui a invit&eacute; l&rsquo;autre</p>\n<p>4) les deux visages doivent se rapprocher de fa&ccedil;on &agrave; se toucher par le bout du nez &agrave; l&rsquo;exclusion de toute autre partie du corps.</p>\n<p>Et l&rsquo;on recommence.</p>\n<p>L&rsquo;int&eacute;r&ecirc;t de cette danse r&eacute;side dans sa figure libre, sobre ou os&eacute;e, et sa difficult&eacute; dans le nez &agrave; nez.</p>\n<p>Il arrive lors de cette figure que, emport&eacute;s par le mouvement, les visages se heurtent violemment, ce qui produit toujours une mauvaise impression chez le partenaire.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_2.webp","effects":[],"_id":"8p4pMXbgY4S5fZjJ"}
-{"name":"Les dragons","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"jeu","data":{"type":"reflexion","base":-8,"caraccomp":"Intellect","description":"<p>Les dragons sont les &eacute;checs draconics.</p>\n<p>Plus complexes et soumis &agrave; beaucoup plus de variantes que nos &eacute;checs, les dragons se jouent sur un plateau de 7 x 7 cases. Chaque joueur poss&egrave;de 14 pi&egrave;ces : le voyageur, le haut-r&ecirc;vant, la pucelle, le groin, le m&eacute;nestrel, l&rsquo;archer, la maison, et 7 arbres.</p>\n<p>Les arbres sont l&rsquo;&eacute;quivalent des pions et servent &agrave; constituer les for&ecirc;ts. Les joueurs ne jouent pas l&rsquo;un en face de l&rsquo;autre, mais c&ocirc;te &agrave; c&ocirc;te, avec l&rsquo;&eacute;chiquier devant eux. Il y a ainsi le joueur de droite qui plante la for&ecirc;t dite dextriote, et le joueur de gauche qui plante la for&ecirc;t sinistrante. Quelle que soit la variante jou&eacute;e, l&rsquo;&eacute;chiquier commence vide, les joueurs introduisant leurs pi&egrave;ces, arbres ou autres, l&rsquo;un apr&egrave;s l&rsquo;autre.</p>\n<p>Selon les variantes, les pi&egrave;ces ne se d&eacute;placent pas de la m&ecirc;me fa&ccedil;on. Les arbres ne prennent ni ne se d&eacute;placent jamais. Ils servent d&rsquo;obstacle aux lignes de d&eacute;placement des autres pi&egrave;ces. Seuls les haut-r&ecirc;vants peuvent les prendre dans certaines variantes.</p>\n<p>Les maisons, &eacute;galement fixes, ne peuvent &ecirc;tre prises que quand elles sont vides. Selon les variantes, elles peuvent contenir de deux &agrave; quatre autres pi&egrave;ces (qui coexistent sur la m&ecirc;me case), sauf des arbres. Dans la maison les pi&egrave;ces sont prot&eacute;g&eacute;es, on ne peut les prendre. Une variante permet d&rsquo;agrandir la maison en sacrifiant un arbre.</p>\n<p>Selon une autre, les archers peuvent augmenter leur nombre de fl&egrave;ches en sacrifiant &eacute;galement un arbre.</p>\n<p>Dans la variante traditionnelle, la plus ancienne, le but du jeu est d&rsquo;investir la maison adverse. Cela suppose qu&rsquo;elle soit vide. Il faut pr&eacute;alablement &eacute;liminer ou neutraliser les pi&egrave;ces en dehors, jusqu&rsquo;&agrave; obliger les occupants de la maison &agrave; sortir (comme aux &eacute;checs, on ne peut passer son coup, on doit effectuer un mouvement).</p>\n<p>Dans des variantes plus r&eacute;centes, plus faciles, le but est de capturer une certaine pi&egrave;ce adverse, g&eacute;n&eacute;ralement le groin ou la pucelle (qui joue l&rsquo;&eacute;quivalent du roi de nos &eacute;checs). Une variante tr&egrave;s populaire oblige que ce soit le groin qui capture la pucelle.</p>\n<p>La dur&eacute;e d&rsquo;une partie de dragons est en moyenne d&rsquo;une heure.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_calculs.webp","effects":[],"_id":"AVAMD5C2mxuOfwV4"}
-{"name":"La mort d’Amarak","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"chant","data":{"niveau":6,"description":"<p>&Eacute;pop&eacute;e &agrave; gros budget et effets sp&eacute;ciaux spectaculaires.</p>\n<p>Amarak, ayant bu une potion de gigantisme, meurt en se cognant la t&ecirc;te dans la lune.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_6.webp","effects":[],"_id":"C5smOdHzrDHlrrZq"}
-{"name":"La princesse endormie","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"chant","data":{"niveau":7,"description":"<p>Ballade sur une princesse qui se pique le doigt et dort tr&egrave;s longtemps suite &agrave; un mal&eacute;fice.</p>\n<p>Les derniers couplets sont malheureusement oubli&eacute;s, de sorte que la chanson ne finit pas.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_7.webp","effects":[],"_id":"CBpwK9udfdzlWbfb"}
-{"name":"Le mal rêvé","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"chant","data":{"niveau":4,"description":"<p>Complainte sur la destin&eacute;e mis&eacute;rable d&rsquo;un homme qui avait les oreilles &agrave; la place des genoux.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_4.webp","effects":[],"_id":"FcTMJE5Wfd02axxd"}
-{"name":"La plumette","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"jeu","data":{"type":"adressehasard","base":-4,"caraccomp":"Dextérité / Volonté","description":"<p>Jeu d&rsquo;adresse et de volont&eacute;, la plumette se joue &agrave; deux, chacun chatouillant le visage de l&rsquo;autre avec une plume. Les visages doivent rester imperturbables.</p>\n<p>Le premier qui trahit un signe quelconque (rire, &eacute;ternuement, grimace) a perdu.</p>\n<p>Pour simuler une partie, utiliser les r&egrave;gles de combat, chacun &agrave; tour de r&ocirc;le attaquant ou tentant de parer l&rsquo;adversaire.</p>\n<p>Pour attaquer, utiliser DEXT&Eacute;RIT&Eacute;/Jeu difficult&eacute; libre et pour parer VOLONT&Eacute;/Jeu &agrave; la difficult&eacute; de l&rsquo;attaque. Le vainqueur est le premier &agrave; r&eacute;ussir une attaque non par&eacute;e.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_plumette.webp","effects":[],"_id":"HyOXCAtpaP7eaHGj"}
-{"name":"La bergamasque","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"danse","data":{"type":"recreative","agilite":false,"apparence":true,"niveau":5,"description":"<p>La bergamasque reprend le principe de la sarabande, mais sur un rythme plus vif et des figures plus compliqu&eacute;es.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_5.webp","effects":[],"_id":"KJ0Ck2G2t4lYIKJH"}
-{"name":"Les calculs","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"jeu","data":{"type":"reflexion","base":-6,"caraccomp":"Intellect","description":"<p>Ce jeu se pratique avec des calculs, c&rsquo;est &agrave;-dire des petits cailloux, que l&rsquo;on pose alternativement sur une surface grill&eacute;e.</p>\n<p>La strat&eacute;gie est &agrave; mi-chemin entre le go et le morpion.</p>\n<p>Tr&egrave;s pratiqu&eacute;, ce jeu peut &ecirc;tre facilement improvis&eacute; en tra&ccedil;ant la grille &agrave; la craie sur une table, ou &agrave; l&rsquo;ext&eacute;rieur, sur du sable lisse.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_calculs.webp","effects":[],"_id":"MixMWkfRpEN51QuP"}
-{"name":"La serpentine","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"danse","data":{"type":"soliste","agilite":false,"apparence":true,"niveau":1,"description":"<p>Danse basique, lente ou vive, ondulante et serpentine.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_sol_1.webp","effects":[],"_id":"N7bgcR8OEh6MpfiF"}
-{"name":"Rêve de Dragon","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"chant","data":{"niveau":8,"description":"<p>R&eacute;citatif, dont la moralit&eacute; se r&eacute;sume ainsi : puisque tout n&rsquo;est qu&rsquo;un r&ecirc;ve, allons dormir.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_8.webp","effects":[],"_id":"OTRi9mHhIANUnPA7"}
-{"name":"Choucroume","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"recettecuisine","data":{"niveau":2,"ingredients":"<ul>\n<li>1 livre de chou &eacute;minc&eacute;</li>\n<li>2 doigts d&rsquo;huile</li>\n<li>1 pinte de bi&egrave;re</li>\n<li>sel</li>\n<li>8 brins d&rsquo;aromates (b&eacute;jaune, luciane)</li>\n</ul>\n<p>&nbsp;</p>\n<p>Une variante appel&eacute;e choucroume liquide utilise le double de bi&egrave;re (2 pintes) et se consomme froide.</p>","duree":"30 minutes","sust":8,"description":"<p>Vari&eacute;t&eacute; de bloutade au chou, cuite dans de la bi&egrave;re.</p>\n<p>&Eacute;mincer finement le chou et le faire revenir dans l&rsquo;huile.</p>\n<p>Ajouter la bi&egrave;re, le sel, les aromates, puis cuire sans cesser de touiller comme pour une bloutade ordinaire.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/recette_cuisine_2.webp","effects":[],"_id":"POuOV6xoPnO0b9OQ"}
-{"name":"La turlutaine","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"danse","data":{"type":"recreative","agilite":false,"apparence":true,"niveau":3,"description":"<p>Sarabande simplifi&eacute;e dans&eacute;e par les villageois, moins lente et moins guind&eacute;e que cette derni&egrave;re.</p>\n<p>On danse tant&ocirc;t en groupe, tant&ocirc;t par couples, avec changements de partenaire.</p>\n<p>Au moment de la s&eacute;paration pour reformer le groupe, les partenaires s&rsquo;envoient des baisers du bout des doigts.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_3.webp","effects":[],"_id":"Q5Lx4WWKWGFjF9cX"}
-{"name":"Le bourrichon","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"danse","data":{"type":"recreative","agilite":true,"apparence":true,"niveau":0,"description":"<p>Le bourrichon est une sorte de farandole joyeuse et rythm&eacute;e o&ugrave; un grand nombre de danseurs &eacute;voluent en se tenant par la main. Les figures sont libres, l&rsquo;essentiel &eacute;tant de garder le rythme.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_0.webp","effects":[],"_id":"QvMNog5MF3vDIBGR"}
-{"name":"Grabuge","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"recettecuisine","data":{"niveau":3,"ingredients":"<ul>\n<li>1 livre de tomari</li>\n<li>1 livre de poisson (mer ou eau douce)</li>\n<li>2 poireaux</li>\n<li>6 oignons</li>\n<li>1 laitue</li>\n<li>2 schouillats de beurre</li>\n<li>2 doigts d&rsquo;huile</li>\n<li>1 doigt de vinaigre</li>\n<li>eau</li>\n<li>sel</li>\n<li>6 brins de luciane</li>\n<li>6 brins de klampine</li>\n<li>8 brins de pif-paf</li>\n</ul>","duree":"60 minutes","sust":12,"description":"<p>Plat de tomari, de plures et de poisson mijot&eacute; au pif-paf.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/recette_cuisine_3.webp","effects":[],"_id":"RvsPbA1ehQgRvGu6"}
-{"name":"La danse du feu","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"danse","data":{"type":"soliste","agilite":false,"apparence":true,"niveau":5,"description":"<p>La danse du feu se danse usuellement de nuit et pr&egrave;s d&rsquo;un feu.</p>\n<p>Lente, aux mouvements plus sugg&eacute;r&eacute;s que marqu&eacute;s, elle est imitative des flammes, comme si le danseur avait le feu pour partenaire.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_sol_5.webp","effects":[],"_id":"UBVYoQmilTmkqppd"}
-{"name":"La danse du voile","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"danse","data":{"type":"soliste","agilite":false,"apparence":true,"niveau":6,"description":"<p>De caract&egrave;re libre, tant&ocirc;t alti&egrave;re comme la souveraine ou d&eacute;hanch&eacute;e comme la callipyge, cette danse utilise un voile comme accessoire (pi&egrave;ce de tissu, ch&acirc;le, &eacute;charpe, etc.).</p>\n<p>Son int&eacute;r&ecirc;t r&eacute;side dans les mouvements du voile avec lesquels s&rsquo;harmonisent ceux de la danseuse.</p>\n<p>Peu pratiqu&eacute;e par les hommes.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_sol_6.webp","effects":[],"_id":"Ui1bMMBBdxMb2AZ2"}
-{"name":"Fleur de haut-rêve","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"chant","data":{"niveau":1,"description":"<p>Romance &agrave; l&rsquo;eau de rose sur les malheurs d&rsquo;une jeune haut-r&ecirc;vante.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_1.webp","effects":[],"_id":"Y5rAtXL0WxOqqbZs"}
-{"name":"La souveraine","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"danse","data":{"type":"soliste","agilite":false,"apparence":true,"niveau":4,"description":"<p>Danse tr&egrave;s lente, sobre, hi&eacute;ratique, plus caract&eacute;ris&eacute;e par ses poses que par ses mouvements.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_sol_4.webp","effects":[],"_id":"Y791UctCHALnBgjO"}
-{"name":"Bras de fer","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"jeu","data":{"type":"adressehasard","base":-4,"caraccomp":"Force","description":"<p>Pour attaquer, utiliser Force/Jeu difficult&eacute; libre.&nbsp; Pour parer, l'opposant joue pareillement&nbsp; Force/Jeu &agrave; la difficult&eacute; de l&rsquo;attaque.</p>\n<p>Le vainqueur est le premier &agrave; r&eacute;ussir une attaque non par&eacute;e.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_brasdefer.webp","effects":[],"_id":"ZJvL0e5hjuws7mIH"}
-{"name":"La chèvre rose","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"chant","data":{"niveau":3,"description":"<p>Ballade comique sur une ch&egrave;vre de la couleur en question, qui s&rsquo;av&egrave;re finalement &ecirc;tre une princesse m&eacute;tamorphos&eacute;e par un mal&eacute;fice.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_3.webp","effects":[],"_id":"aB78Io55m2kXDjwQ"}
-{"name":"Tripotée","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"recettecuisine","data":{"niveau":2,"ingredients":"<ul>\n<li>1/2 livre de cosses</li>\n<li>1/2 livre de porte-p&eacute;pins</li>\n<li>1/2 livre de racines</li>\n<li>eau</li>\n<li>5 schouillats de farine de bl&eacute;di&egrave;ze</li>\n<li>3 schouillats de farine de bloute</li>\n<li>4 brins de b&eacute;jaune</li>\n<li>2 brins de muscaline</li>\n<li>2 brins de p&egrave;pre</li>\n</ul>","duree":"40 minutes","sust":6,"description":"<p>Soupe v&eacute;g&eacute;tarienne comprenant des l&eacute;gumes de chacune des trois sortes. Selon les l&eacute;gumes utilis&eacute;s, la tripot&eacute;e peut avoir de multiples variantes, la plus courante &eacute;tant pois-quaroce-turneps.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/recette_cuisine_2.webp","effects":[],"_id":"aWfeLfT1kM2cCrNn"}
-{"name":"Tiens, v’là les Groins !","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"chant","data":{"niveau":0,"description":"<p>Chanson de marche peu rafin&eacute;e, comme en t&eacute;moigne le refrain :</p>\n<blockquote>\n<p>&laquo; Tiens, v&rsquo;l&agrave; les Groins !</p>\n<p>&Ccedil;a y&rsquo;en a eux qui faire du foin !</p>\n<p>Quand y&rsquo;en a pr&egrave;s, y&rsquo;en a pas loin !</p>\n<p>Tiens, v&rsquo;l&agrave; les Groins ! &raquo;</p>\n</blockquote>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_0.webp","effects":[],"_id":"dwSY0ImswRHUSuRQ"}
-{"name":"La volée","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"danse","data":{"type":"recreative","agilite":true,"apparence":true,"niveau":6,"description":"<p>Danse villageoise, la vol&eacute;e est une farandole rapide incluant des sauts et des figures quasi acrobatiques, ainsi que des moments rapproch&eacute;s &agrave; deux (comme la peccadille). Elle est &eacute;videmment r&eacute;serv&eacute;e aux bons danseurs, et particuli&egrave;rement ext&eacute;nuante.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_6.webp","effects":[],"_id":"ehAslJ16qKJDrTqt"}
-{"_id":"jOL4buV3m3nHr8v7","name":"Le doublon","type":"jeu","img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_doublon.webp","data":{"type":"de","base":0,"caraccomp":"Chance","reference":"","description":"<p>Jeu de pur hasard consistant &agrave; obtenir un double avec deux d&eacute;s.</p>\n<p>Si plusieurs joueurs y parviennent, le plus haut gagne ; si aucun n&rsquo;y parvient, le coup est nul et les mises restent au pot.</p>\n<p>Pour simuler une partie de doublon, faire simplement tirer des jets de CHANCE &agrave; z&eacute;ro (ajust&eacute;s astrologiquement), mais sans comp&eacute;tence, pas m&ecirc;me Jeu, et comparer les r&eacute;sultats (&eacute;chec, r&eacute;ussite normale, significative, etc.) : le meilleur gagne. &Agrave; &eacute;galit&eacute; de r&eacute;ussites, le coup est nul.</p>"},"effects":[],"folder":null,"sort":0,"permission":{"default":0,"rYShh2P1DNavdoBD":3},"flags":{}}
-{"name":"Le rossignol d’Ostarlath","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"chant","data":{"niveau":8,"description":"<p>Romance o&ugrave; les paroles, peu importantes, sont essentiellement un exercice de vocalises.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_8.webp","effects":[],"_id":"jUsy5PTDwBgDrRnq"}
-{"name":"Le roi des ours","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"chant","data":{"niveau":3,"description":"<p>Sanglante &eacute;pop&eacute;e sur un th&egrave;me identique* : mal&eacute;fice, m&eacute;tamorphose et superbe vengeance finale.</p>\n<p>&nbsp;</p>\n<p><em>*voir \"La ch&egrave;vre rose\"</em></p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_3.webp","effects":[],"_id":"jUxckTsggDZBgn2W"}
-{"name":"La route est longue","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"chant","data":{"niveau":0,"description":"<p>Chanson de marche aux couplets r&eacute;p&eacute;titifs.</p>\n<blockquote>\n<p>&laquo; Une lieue sans cheval, &ccedil;a use, &ccedil;a use</p>\n<p>Une lieue sans cheval, &ccedil;a use les sandales !&raquo;</p>\n</blockquote>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_0.webp","effects":[],"_id":"jyPBU95uPhIhsdpa"}
-{"name":"La danse du couteau","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"danse","data":{"type":"soliste","agilite":false,"apparence":true,"niveau":6,"description":"<p>Plus masculine que f&eacute;minine, cette danse utilise un couteau (dague) comme accessoire.</p>\n<p>Elle est imitative d&rsquo;un combat.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_sol_6.webp","effects":[],"_id":"k9EELSV0DrurUt1e"}
-{"name":"L’amour est morte","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"chant","data":{"niveau":5,"description":"<p>Romance sentimentale d&rsquo;une tristesse &agrave; faire pleurer les cailloux.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_5.webp","effects":[],"_id":"kCU7A8fMczERjizY"}
-{"name":"Amandjara","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"chant","data":{"niveau":2,"description":"<p>S&eacute;r&eacute;nade sur la l&eacute;gendaire cit&eacute; d&rsquo;Amandjara,</p>\n<p>&laquo; Perle du d&eacute;sert bleu, sur qui la lune fait les doux yeux ... &raquo;</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_2.webp","effects":[],"_id":"kiIlPL5XANy5OgYn"}
-{"name":"Bloutade","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"recettecuisine","data":{"niveau":1,"ingredients":"<ul>\n<li>1 livre de farine de bloute*</li>\n<li>1/2 livre de viande de porc ou de padongre coup&eacute;e en petits morceaux</li>\n<li>2 doigts d&rsquo;huile</li>\n<li>eau,</li>\n<li>sel</li>\n<li>8 brins d&rsquo;aromates (b&eacute;jaune, luciane)</li>\n</ul>","duree":"30 minutes","sust":8,"description":"<p>Pur&eacute;e de farine de bloute.</p>\n<p>&nbsp;</p>\n<p><strong>Bloute</strong></p>\n<p>Avec le tomari ou le bl&eacute;di&egrave;ze, la bloute est &agrave; la base de l&rsquo;alimentation dans un grand nombre d&rsquo;endroits. C&rsquo;est un tubercule de forme et de couleur voisins de notre manioc, &agrave; la chair g&eacute;latineuse et fade. Totalement immangeables telles quelles, les bloutes sont mises &agrave; s&eacute;cher sur des claies, puis broy&eacute;es en farine. Ce n&rsquo;est qu&rsquo;ainsi qu&rsquo;on peut les consommer. La farine de bloute entre dans la confection des brouets et des rago&ucirc;ts, notamment de la bloutade. Ainsi cuite, elle ressemble &agrave; du tapioca.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/recette_cuisine_1.webp","effects":[],"_id":"lv6AiGYIjtqHhn7u"}
-{"name":"Le tisonnier","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"jeu","data":{"type":"carte","base":-4,"caraccomp":"Chance / Empathie","description":"<p>On commence par se mettre d&rsquo;accord sur la valeur hi&eacute;rarchique des symboles et des combinaisons possibles, puis le jeu consiste, &agrave; chaque distribution de cartes, &agrave; miser selon un syst&egrave;me de surench&egrave;res jusqu&rsquo;&agrave; ce que les cartes soient d&eacute;voil&eacute;es.</p>\n<p>La combinaison la plus forte emporte alors les mises.</p>\n<p>Le jeu demande de la chance, sans laquelle il est difficile de gagner &agrave; long terme, mais tout autant de l&rsquo;empathie pour bluffer lors des surench&egrave;res.</p>\n<p>Pour simuler une partie, jouer un jet de CHANCE &agrave; z&eacute;ro (ajust&eacute; astrologiquement), suivi d&rsquo;un jet d&rsquo;EMPATHIE/Jeu &agrave; z&eacute;ro, et additionner les points de t&acirc;che obtenus par les deux jets. Le vainqueur est celui qui en totalise le plus.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_tisonnier.webp","effects":[],"_id":"mRzHzrubRkyqHUTC"}
-{"name":"Plume de zyglute","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"chant","data":{"niveau":4,"description":"<p>S&eacute;r&eacute;nade.</p>\n<p>Belle musique, mais paroles d&rsquo;une rare stupidit&eacute; :</p>\n<blockquote>\n<p>&laquo; Coin-coin, glou-glou, c&rsquo;est qui ? c&rsquo;est vous ? &raquo;</p>\n</blockquote>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_4.webp","effects":[],"_id":"nCFFhbL54WXU0FFi"}
-{"name":"L’auberge noire","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"chant","data":{"niveau":5,"description":"<p>Complainte macabre sur un aubergiste qui assassine ses clients avec la r&acirc;pe &agrave; fromage.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_5.webp","effects":[],"_id":"srNKj5s0TOw7VDQ4"}
-{"name":"Ma chope est vide !","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"chant","data":{"niveau":0,"description":"<p>Chanson &agrave; boire peu raffin&eacute;e.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_0.webp","effects":[],"_id":"uGVOeSq2ZKMG8VjU"}
-{"name":"La callipyge","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"danse","data":{"type":"soliste","agilite":false,"apparence":true,"niveau":2,"description":"<p>Comme la serpentine, avec des effets plus marqu&eacute;s, essentiellement bas&eacute;e sur les mouvements du bassin. La callipyge n&rsquo;est g&eacute;n&eacute;ralement dans&eacute;e que par les femmes.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_sol_2.webp","effects":[],"_id":"uf7a9D5RYw7gOi36"}
-{"name":"La gambade","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"danse","data":{"type":"recreative","agilite":true,"apparence":true,"niveau":1,"description":"<p>Gigue endiabl&eacute;e, proche du bourrichon, mais avec des figures un peu moins sommaires.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_1.webp","effects":[],"_id":"uxdljYU7TlC2F6oA"}
-{"name":"Trompe de padongre à la mentharde","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"recettecuisine","data":{"niveau":4,"ingredients":"<ul>\n<li>1 belle trompe de padongre (10 sust)</li>\n<li>25 schouillats de miel</li>\n<li>1 livre de beurre</li>\n<li>1 pinte de lait</li>\n<li>20 brins de mentharde</li>\n<li>sel</li>\n</ul>","duree":"90 minutes","sust":12,"description":"<p>Enduite de miel, de beurre et entour&eacute;e de feuilles de mentharde fra&icirc;ches, la trompe de padongre doit &ecirc;tre cuite au four et arros&eacute;e r&eacute;guli&egrave;rement de lait. Toute la difficult&eacute; r&eacute;side dans la cuisson.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/recette_cuisine_4.webp","effects":[],"_id":"uzSivEs6SFEGVoI0"}
-{"name":"La triplette","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"jeu","data":{"type":"de","base":0,"caraccomp":"Chance","description":"<p>Autre jeu de hasard, la triplette est un jeu de d&eacute;s de combinaisons se jouant avec trois d&eacute;s (sorte de 421).</p>\n<p>Pour simuler une partie de triplette, d&eacute;terminer l&rsquo;ordre dans lequel jouent les participants. Le premier &agrave; jouer peut tenter de un &agrave; trois jets de CHANCE &agrave; z&eacute;ro (ajust&eacute;s astrologiquement comme pour le doublon), et additionner les points de t&acirc;che obtenus.</p>\n<p>Attention aux &eacute;checs qui donnent des points n&eacute;gatifs ! Il peut &ecirc;tre plus judicieux de se contenter d&rsquo;un seul jet bien r&eacute;ussi.</p>\n<p>Les joueurs suivants, en effet, pourront &agrave; leur tour tenter le m&ecirc;me nombre de jets de CHANCE ou moins, mais pas davantage. Le plus grand nombre de points gagne finalement.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_doublon.webp","effects":[],"_id":"vYPjOjd3vSAvjL76"}
-{"name":"Le voyageur","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"chant","data":{"niveau":1,"description":"<p>Ballade sur les tribulations d&rsquo;un voyageur.</p>\n<p>Interminable, cette chanson poss&egrave;de plus de cent couplets.</p>\n<p>&nbsp;</p>\n<p><em>D&eacute;terminer en tirant 1d100 le nombre de couplets connus.</em></p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_1.webp","effects":[],"_id":"vlqX5BC9recz2kM2"}
-{"name":"La pétasse","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"jeu","data":{"type":"adressehasard","base":-6,"caraccomp":"Lancer","description":"<p>Jeu d&rsquo;adresse combinant boules et quilles.</p>\n<p>Chaque joueur dispose de plusieurs quilles, appel&eacute;es p&eacute;tasses, et de boules de bois, appel&eacute;es tronchets. Le jeu conna&icirc;t de nombreuses variantes, mais le principe g&eacute;n&eacute;ral est le m&ecirc;me : culbuter les p&eacute;tasses des adversaires en &eacute;vitant de se faire troncher les siennes.</p>\n<p>Pour simuler une partie, faire tirer &agrave; chaque participant 5 jets de Lancer/Jeu &agrave; z&eacute;ro et additionner les points de t&acirc;che obtenus. Le plus grand nombre gagne.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_petasse.webp","effects":[],"_id":"vo8GoXIBNWp1GY12"}
-{"name":"La sarabande","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"danse","data":{"type":"recreative","agilite":false,"apparence":true,"niveau":4,"description":"<p>Peu pratiqu&eacute;e dans les villages, la sarabande est une danse de cour, lente et solennelle, alternant groupe et couples, comme la turlutaine dont elle est une version &laquo;s&eacute;rieuse&raquo;.</p>\n<p>Les changements de partenaire s&rsquo;accompagnent de profondes r&eacute;v&eacute;rences.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_4.webp","effects":[],"_id":"wf1jpIZmrB5LfK93"}
-{"name":"Le retour du baron gris","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"chant","data":{"niveau":2,"description":"<p>&Eacute;pop&eacute;e pleine de cavalcades, de trahisons, de batailles et de cervelles &eacute;clat&eacute;es.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_2.webp","effects":[],"_id":"xjITZoom3Azu9NQa"}
-{"name":"L’heure de la Lyre","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"chant","data":{"niveau":1,"description":"<p>Berceuse sur le th&egrave;me de la nuit qui descend.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_1.webp","effects":[],"_id":"yLcvnrbqIKS4ezj7"}
-{"name":"Le cavalier de sombre neige","permission":{"default":0,"rYShh2P1DNavdoBD":3},"type":"chant","data":{"niveau":6,"description":"<p>&Eacute;pop&eacute;e pleine de suspense et de terreur, o&ugrave; le soleil est rouge, la lune violette et la neige noire.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_6.webp","effects":[],"_id":"zRQ5WnPI483CKm9Q"}
+{"name":"Moussecaille","type":"recettecuisine","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.240HPtZsgZQERFMF"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/recette_cuisine_6.webp","effects":[],"_id":"240HPtZsgZQERFMF","system":{"description":"<p>Civet de cailles aux mousseroles.</p>\n<p>La mousserole est un petit champignon rose, tr&egrave;s abondant apr&egrave;s la pluie (commun). Pratiquement, cette recette peut s&rsquo;appliquer &agrave; tout gibier &agrave; plume pr&eacute;par&eacute; aux champignons.</p>","descriptionmj":"","niveau":6,"ingredients":"<ul>\n<li>4 grosses cailles (1 sust chaque)</li>\n<li>3 livres de mousseroles</li>\n<li>4 &eacute;chalotes</li>\n<li>1 racine de r&eacute;f&egrave;ble</li>\n<li>1 schouillat de miel</li>\n<li>10 schouillats de beurre</li>\n<li>2 doigts d&rsquo;huile</li>\n<li>5 schouillats de farine de bl&eacute;di&egrave;ze</li>\n<li>eau</li>\n<li>sel</li>\n<li>4 brins de klampine</li>\n<li>4 brins de luciane</li>\n<li>1 brin de mentharde</li>\n<li>4 brins de p&egrave;pre</li>\n</ul>","duree":"80 minutes","sust":8,"exotisme":0,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870029,"modifiedTime":1671048281603,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Panaris et Phlegmon","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.36YGDFJBxekzEvBw"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_7.webp","effects":[],"_id":"36YGDFJBxekzEvBw","system":{"description":"<p>Romance sur la fatalit&eacute; qui s&eacute;pare deux amants et que seule la mort r&eacute;unit.</p>\n<p>&Agrave; la fin, la belle Panaris est transform&eacute;e en carafe et le gentil Phlegmon en bouchon de cristal. L&rsquo;empereur, &agrave; qui &eacute;choit le flacon, les rassemble symboliquement.</p>","descriptionmj":"","niveau":7,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870029,"modifiedTime":1671048281603,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La danse des sept rêves","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.4mhiTAEhwDh7S3i0"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_sol_8.webp","effects":[],"_id":"4mhiTAEhwDh7S3i0","system":{"description":"<p>V&eacute;ritable ballet, la danse des sept r&ecirc;ves est une chor&eacute;graphie dramatique &eacute;labor&eacute;e.</p>","descriptionmj":"","type":"soliste","agilite":false,"apparence":true,"niveau":6,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870030,"modifiedTime":1671048281604,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Les fléchettes","type":"jeu","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.8jOKQkuS6RJyM3uD"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_flechettes.webp","effects":[],"_id":"8jOKQkuS6RJyM3uD","system":{"description":"<p>Jeu d&rsquo;adresse consistant &agrave; viser une cible avec des fl&eacute;chettes.</p>\n<p>Pour simuler une partie, faire tirer &agrave; chaque participant 5 jets de Lancer/Jeu &agrave; z&eacute;ro et additionner les points de t&acirc;che obtenus. Le plus grand nombre gagne.</p>","descriptionmj":"","type":"adressehasard","base":-6,"caraccomp":"Lancer","reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870030,"modifiedTime":1671048281604,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La peccadille","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.8p4pMXbgY4S5fZjJ"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_2.webp","effects":[],"_id":"8p4pMXbgY4S5fZjJ","system":{"description":"<p>La peccadille se danse &agrave; deux, comme la valse ou le tango. Plus lente et moins rythm&eacute;e&nbsp; que les deux premi&egrave;res, elle comporte quatre figures :</p>\n<p>1) les cavaliers se tiennent par les mains</p>\n<p>2) ils se tiennent par la taille</p>\n<p>3) figure libre, improvis&eacute;e par celui ou celle qui a invit&eacute; l&rsquo;autre</p>\n<p>4) les deux visages doivent se rapprocher de fa&ccedil;on &agrave; se toucher par le bout du nez &agrave; l&rsquo;exclusion de toute autre partie du corps.</p>\n<p>Et l&rsquo;on recommence.</p>\n<p>L&rsquo;int&eacute;r&ecirc;t de cette danse r&eacute;side dans sa figure libre, sobre ou os&eacute;e, et sa difficult&eacute; dans le nez &agrave; nez.</p>\n<p>Il arrive lors de cette figure que, emport&eacute;s par le mouvement, les visages se heurtent violemment, ce qui produit toujours une mauvaise impression chez le partenaire.</p>","descriptionmj":"","type":"recreative","agilite":false,"apparence":true,"niveau":2,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870030,"modifiedTime":1671048281604,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Les dragons","type":"jeu","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.AVAMD5C2mxuOfwV4"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_calculs.webp","effects":[],"_id":"AVAMD5C2mxuOfwV4","system":{"description":"<p>Les dragons sont les &eacute;checs draconics.</p>\n<p>Plus complexes et soumis &agrave; beaucoup plus de variantes que nos &eacute;checs, les dragons se jouent sur un plateau de 7 x 7 cases. Chaque joueur poss&egrave;de 14 pi&egrave;ces : le voyageur, le haut-r&ecirc;vant, la pucelle, le groin, le m&eacute;nestrel, l&rsquo;archer, la maison, et 7 arbres.</p>\n<p>Les arbres sont l&rsquo;&eacute;quivalent des pions et servent &agrave; constituer les for&ecirc;ts. Les joueurs ne jouent pas l&rsquo;un en face de l&rsquo;autre, mais c&ocirc;te &agrave; c&ocirc;te, avec l&rsquo;&eacute;chiquier devant eux. Il y a ainsi le joueur de droite qui plante la for&ecirc;t dite dextriote, et le joueur de gauche qui plante la for&ecirc;t sinistrante. Quelle que soit la variante jou&eacute;e, l&rsquo;&eacute;chiquier commence vide, les joueurs introduisant leurs pi&egrave;ces, arbres ou autres, l&rsquo;un apr&egrave;s l&rsquo;autre.</p>\n<p>Selon les variantes, les pi&egrave;ces ne se d&eacute;placent pas de la m&ecirc;me fa&ccedil;on. Les arbres ne prennent ni ne se d&eacute;placent jamais. Ils servent d&rsquo;obstacle aux lignes de d&eacute;placement des autres pi&egrave;ces. Seuls les haut-r&ecirc;vants peuvent les prendre dans certaines variantes.</p>\n<p>Les maisons, &eacute;galement fixes, ne peuvent &ecirc;tre prises que quand elles sont vides. Selon les variantes, elles peuvent contenir de deux &agrave; quatre autres pi&egrave;ces (qui coexistent sur la m&ecirc;me case), sauf des arbres. Dans la maison les pi&egrave;ces sont prot&eacute;g&eacute;es, on ne peut les prendre. Une variante permet d&rsquo;agrandir la maison en sacrifiant un arbre.</p>\n<p>Selon une autre, les archers peuvent augmenter leur nombre de fl&egrave;ches en sacrifiant &eacute;galement un arbre.</p>\n<p>Dans la variante traditionnelle, la plus ancienne, le but du jeu est d&rsquo;investir la maison adverse. Cela suppose qu&rsquo;elle soit vide. Il faut pr&eacute;alablement &eacute;liminer ou neutraliser les pi&egrave;ces en dehors, jusqu&rsquo;&agrave; obliger les occupants de la maison &agrave; sortir (comme aux &eacute;checs, on ne peut passer son coup, on doit effectuer un mouvement).</p>\n<p>Dans des variantes plus r&eacute;centes, plus faciles, le but est de capturer une certaine pi&egrave;ce adverse, g&eacute;n&eacute;ralement le groin ou la pucelle (qui joue l&rsquo;&eacute;quivalent du roi de nos &eacute;checs). Une variante tr&egrave;s populaire oblige que ce soit le groin qui capture la pucelle.</p>\n<p>La dur&eacute;e d&rsquo;une partie de dragons est en moyenne d&rsquo;une heure.</p>","descriptionmj":"","type":"reflexion","base":-8,"caraccomp":"Intellect","reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870030,"modifiedTime":1671048281605,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La mort d’Amarak","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.C5smOdHzrDHlrrZq"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_6.webp","effects":[],"_id":"C5smOdHzrDHlrrZq","system":{"description":"<p>&Eacute;pop&eacute;e &agrave; gros budget et effets sp&eacute;ciaux spectaculaires.</p>\n<p>Amarak, ayant bu une potion de gigantisme, meurt en se cognant la t&ecirc;te dans la lune.</p>","descriptionmj":"","niveau":6,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870030,"modifiedTime":1671048281605,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La princesse endormie","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.CBpwK9udfdzlWbfb"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_7.webp","effects":[],"_id":"CBpwK9udfdzlWbfb","system":{"description":"<p>Ballade sur une princesse qui se pique le doigt et dort tr&egrave;s longtemps suite &agrave; un mal&eacute;fice.</p>\n<p>Les derniers couplets sont malheureusement oubli&eacute;s, de sorte que la chanson ne finit pas.</p>","descriptionmj":"","niveau":7,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870030,"modifiedTime":1671048281605,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Le mal rêvé","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.FcTMJE5Wfd02axxd"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_4.webp","effects":[],"_id":"FcTMJE5Wfd02axxd","system":{"description":"<p>Complainte sur la destin&eacute;e mis&eacute;rable d&rsquo;un homme qui avait les oreilles &agrave; la place des genoux.</p>","descriptionmj":"","niveau":4,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870031,"modifiedTime":1671048281605,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La plumette","type":"jeu","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.HyOXCAtpaP7eaHGj"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_plumette.webp","effects":[],"_id":"HyOXCAtpaP7eaHGj","system":{"description":"<p>Jeu d&rsquo;adresse et de volont&eacute;, la plumette se joue &agrave; deux, chacun chatouillant le visage de l&rsquo;autre avec une plume. Les visages doivent rester imperturbables.</p>\n<p>Le premier qui trahit un signe quelconque (rire, &eacute;ternuement, grimace) a perdu.</p>\n<p>Pour simuler une partie, utiliser les r&egrave;gles de combat, chacun &agrave; tour de r&ocirc;le attaquant ou tentant de parer l&rsquo;adversaire.</p>\n<p>Pour attaquer, utiliser DEXT&Eacute;RIT&Eacute;/Jeu difficult&eacute; libre et pour parer VOLONT&Eacute;/Jeu &agrave; la difficult&eacute; de l&rsquo;attaque. Le vainqueur est le premier &agrave; r&eacute;ussir une attaque non par&eacute;e.</p>","descriptionmj":"","type":"adressehasard","base":-4,"caraccomp":"Dextérité / Volonté","reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870032,"modifiedTime":1671048281605,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La bergamasque","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.KJ0Ck2G2t4lYIKJH"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_5.webp","effects":[],"_id":"KJ0Ck2G2t4lYIKJH","system":{"description":"<p>La bergamasque reprend le principe de la sarabande, mais sur un rythme plus vif et des figures plus compliqu&eacute;es.</p>","descriptionmj":"","type":"recreative","agilite":false,"apparence":true,"niveau":5,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870032,"modifiedTime":1671048281606,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Les calculs","type":"jeu","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.MixMWkfRpEN51QuP"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_calculs.webp","effects":[],"_id":"MixMWkfRpEN51QuP","system":{"description":"<p>Ce jeu se pratique avec des calculs, c&rsquo;est &agrave;-dire des petits cailloux, que l&rsquo;on pose alternativement sur une surface grill&eacute;e.</p>\n<p>La strat&eacute;gie est &agrave; mi-chemin entre le go et le morpion.</p>\n<p>Tr&egrave;s pratiqu&eacute;, ce jeu peut &ecirc;tre facilement improvis&eacute; en tra&ccedil;ant la grille &agrave; la craie sur une table, ou &agrave; l&rsquo;ext&eacute;rieur, sur du sable lisse.</p>","descriptionmj":"","type":"reflexion","base":-6,"caraccomp":"Intellect","reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870032,"modifiedTime":1671048281606,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La serpentine","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.N7bgcR8OEh6MpfiF"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_sol_1.webp","effects":[],"_id":"N7bgcR8OEh6MpfiF","system":{"description":"<p>Danse basique, lente ou vive, ondulante et serpentine.</p>","descriptionmj":"","type":"soliste","agilite":false,"apparence":true,"niveau":1,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870032,"modifiedTime":1671048281606,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Rêve de Dragon","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.OTRi9mHhIANUnPA7"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_8.webp","effects":[],"_id":"OTRi9mHhIANUnPA7","system":{"description":"<p>R&eacute;citatif, dont la moralit&eacute; se r&eacute;sume ainsi : puisque tout n&rsquo;est qu&rsquo;un r&ecirc;ve, allons dormir.</p>","descriptionmj":"","niveau":8,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870033,"modifiedTime":1671048281607,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Choucroume","type":"recettecuisine","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.POuOV6xoPnO0b9OQ"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/recette_cuisine_2.webp","effects":[],"_id":"POuOV6xoPnO0b9OQ","system":{"description":"<p>Vari&eacute;t&eacute; de bloutade au chou, cuite dans de la bi&egrave;re.</p>\n<p>&Eacute;mincer finement le chou et le faire revenir dans l&rsquo;huile.</p>\n<p>Ajouter la bi&egrave;re, le sel, les aromates, puis cuire sans cesser de touiller comme pour une bloutade ordinaire.</p>","descriptionmj":"","niveau":2,"ingredients":"<ul>\n<li>1 livre de chou &eacute;minc&eacute;</li>\n<li>2 doigts d&rsquo;huile</li>\n<li>1 pinte de bi&egrave;re</li>\n<li>sel</li>\n<li>8 brins d&rsquo;aromates (b&eacute;jaune, luciane)</li>\n</ul>\n<p>&nbsp;</p>\n<p>Une variante appel&eacute;e choucroume liquide utilise le double de bi&egrave;re (2 pintes) et se consomme froide.</p>","duree":"30 minutes","sust":8,"exotisme":0,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870033,"modifiedTime":1671048281607,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La turlutaine","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.Q5Lx4WWKWGFjF9cX"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_3.webp","effects":[],"_id":"Q5Lx4WWKWGFjF9cX","system":{"description":"<p>Sarabande simplifi&eacute;e dans&eacute;e par les villageois, moins lente et moins guind&eacute;e que cette derni&egrave;re.</p>\n<p>On danse tant&ocirc;t en groupe, tant&ocirc;t par couples, avec changements de partenaire.</p>\n<p>Au moment de la s&eacute;paration pour reformer le groupe, les partenaires s&rsquo;envoient des baisers du bout des doigts.</p>","descriptionmj":"","type":"recreative","agilite":false,"apparence":true,"niveau":3,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870033,"modifiedTime":1671048281607,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Le bourrichon","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.QvMNog5MF3vDIBGR"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_0.webp","effects":[],"_id":"QvMNog5MF3vDIBGR","system":{"description":"<p>Le bourrichon est une sorte de farandole joyeuse et rythm&eacute;e o&ugrave; un grand nombre de danseurs &eacute;voluent en se tenant par la main. Les figures sont libres, l&rsquo;essentiel &eacute;tant de garder le rythme.</p>","descriptionmj":"","type":"recreative","agilite":true,"apparence":true,"niveau":0,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870033,"modifiedTime":1671048281607,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Grabuge","type":"recettecuisine","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.RvsPbA1ehQgRvGu6"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/recette_cuisine_3.webp","effects":[],"_id":"RvsPbA1ehQgRvGu6","system":{"description":"<p>Plat de tomari, de plures et de poisson mijot&eacute; au pif-paf.</p>","descriptionmj":"","niveau":3,"ingredients":"<ul>\n<li>1 livre de tomari</li>\n<li>1 livre de poisson (mer ou eau douce)</li>\n<li>2 poireaux</li>\n<li>6 oignons</li>\n<li>1 laitue</li>\n<li>2 schouillats de beurre</li>\n<li>2 doigts d&rsquo;huile</li>\n<li>1 doigt de vinaigre</li>\n<li>eau</li>\n<li>sel</li>\n<li>6 brins de luciane</li>\n<li>6 brins de klampine</li>\n<li>8 brins de pif-paf</li>\n</ul>","duree":"60 minutes","sust":12,"exotisme":0,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870033,"modifiedTime":1671048281608,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La danse du feu","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.UBVYoQmilTmkqppd"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_sol_5.webp","effects":[],"_id":"UBVYoQmilTmkqppd","system":{"description":"<p>La danse du feu se danse usuellement de nuit et pr&egrave;s d&rsquo;un feu.</p>\n<p>Lente, aux mouvements plus sugg&eacute;r&eacute;s que marqu&eacute;s, elle est imitative des flammes, comme si le danseur avait le feu pour partenaire.</p>","descriptionmj":"","type":"soliste","agilite":false,"apparence":true,"niveau":5,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870034,"modifiedTime":1671048281608,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La danse du voile","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.Ui1bMMBBdxMb2AZ2"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_sol_6.webp","effects":[],"_id":"Ui1bMMBBdxMb2AZ2","system":{"description":"<p>De caract&egrave;re libre, tant&ocirc;t alti&egrave;re comme la souveraine ou d&eacute;hanch&eacute;e comme la callipyge, cette danse utilise un voile comme accessoire (pi&egrave;ce de tissu, ch&acirc;le, &eacute;charpe, etc.).</p>\n<p>Son int&eacute;r&ecirc;t r&eacute;side dans les mouvements du voile avec lesquels s&rsquo;harmonisent ceux de la danseuse.</p>\n<p>Peu pratiqu&eacute;e par les hommes.</p>","descriptionmj":"","type":"soliste","agilite":false,"apparence":true,"niveau":6,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870034,"modifiedTime":1671048281608,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Fleur de haut-rêve","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.Y5rAtXL0WxOqqbZs"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_1.webp","effects":[],"_id":"Y5rAtXL0WxOqqbZs","system":{"description":"<p>Romance &agrave; l&rsquo;eau de rose sur les malheurs d&rsquo;une jeune haut-r&ecirc;vante.</p>","descriptionmj":"","niveau":1,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870034,"modifiedTime":1671048281609,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La souveraine","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.Y791UctCHALnBgjO"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_sol_4.webp","effects":[],"_id":"Y791UctCHALnBgjO","system":{"description":"<p>Danse tr&egrave;s lente, sobre, hi&eacute;ratique, plus caract&eacute;ris&eacute;e par ses poses que par ses mouvements.</p>","descriptionmj":"","type":"soliste","agilite":false,"apparence":true,"niveau":4,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870034,"modifiedTime":1671048281609,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Bras de fer","type":"jeu","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.ZJvL0e5hjuws7mIH"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_brasdefer.webp","effects":[],"_id":"ZJvL0e5hjuws7mIH","system":{"description":"<p>Pour attaquer, utiliser Force/Jeu difficult&eacute; libre.&nbsp; Pour parer, l'opposant joue pareillement&nbsp; Force/Jeu &agrave; la difficult&eacute; de l&rsquo;attaque.</p>\n<p>Le vainqueur est le premier &agrave; r&eacute;ussir une attaque non par&eacute;e.</p>","descriptionmj":"","type":"adressehasard","base":-4,"caraccomp":"Force","reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870034,"modifiedTime":1671048281609,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La chèvre rose","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.aB78Io55m2kXDjwQ"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_3.webp","effects":[],"_id":"aB78Io55m2kXDjwQ","system":{"description":"<p>Ballade comique sur une ch&egrave;vre de la couleur en question, qui s&rsquo;av&egrave;re finalement &ecirc;tre une princesse m&eacute;tamorphos&eacute;e par un mal&eacute;fice.</p>","descriptionmj":"","niveau":3,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870034,"modifiedTime":1671048281609,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Tripotée","type":"recettecuisine","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.aWfeLfT1kM2cCrNn"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/recette_cuisine_2.webp","effects":[],"_id":"aWfeLfT1kM2cCrNn","system":{"description":"<p>Soupe v&eacute;g&eacute;tarienne comprenant des l&eacute;gumes de chacune des trois sortes. Selon les l&eacute;gumes utilis&eacute;s, la tripot&eacute;e peut avoir de multiples variantes, la plus courante &eacute;tant pois-quaroce-turneps.</p>","descriptionmj":"","niveau":2,"ingredients":"<ul>\n<li>1/2 livre de cosses</li>\n<li>1/2 livre de porte-p&eacute;pins</li>\n<li>1/2 livre de racines</li>\n<li>eau</li>\n<li>5 schouillats de farine de bl&eacute;di&egrave;ze</li>\n<li>3 schouillats de farine de bloute</li>\n<li>4 brins de b&eacute;jaune</li>\n<li>2 brins de muscaline</li>\n<li>2 brins de p&egrave;pre</li>\n</ul>","duree":"40 minutes","sust":6,"exotisme":0,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870035,"modifiedTime":1671048281609,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Tiens, v’là les Groins !","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.dwSY0ImswRHUSuRQ"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_0.webp","effects":[],"_id":"dwSY0ImswRHUSuRQ","system":{"description":"<p>Chanson de marche peu rafin&eacute;e, comme en t&eacute;moigne le refrain :</p>\n<blockquote>\n<p>&laquo; Tiens, v&rsquo;l&agrave; les Groins !</p>\n<p>&Ccedil;a y&rsquo;en a eux qui faire du foin !</p>\n<p>Quand y&rsquo;en a pr&egrave;s, y&rsquo;en a pas loin !</p>\n<p>Tiens, v&rsquo;l&agrave; les Groins ! &raquo;</p>\n</blockquote>","descriptionmj":"","niveau":0,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870035,"modifiedTime":1671048281609,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La volée","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.ehAslJ16qKJDrTqt"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_6.webp","effects":[],"_id":"ehAslJ16qKJDrTqt","system":{"description":"<p>Danse villageoise, la vol&eacute;e est une farandole rapide incluant des sauts et des figures quasi acrobatiques, ainsi que des moments rapproch&eacute;s &agrave; deux (comme la peccadille). Elle est &eacute;videmment r&eacute;serv&eacute;e aux bons danseurs, et particuli&egrave;rement ext&eacute;nuante.</p>","descriptionmj":"","type":"recreative","agilite":true,"apparence":true,"niveau":6,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870035,"modifiedTime":1671048281609,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"jOL4buV3m3nHr8v7","name":"Le doublon","type":"jeu","img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_doublon.webp","effects":[],"folder":null,"sort":0,"flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.jOL4buV3m3nHr8v7"}},"system":{"description":"<p>Jeu de pur hasard consistant &agrave; obtenir un double avec deux d&eacute;s.</p>\n<p>Si plusieurs joueurs y parviennent, le plus haut gagne ; si aucun n&rsquo;y parvient, le coup est nul et les mises restent au pot.</p>\n<p>Pour simuler une partie de doublon, faire simplement tirer des jets de CHANCE &agrave; z&eacute;ro (ajust&eacute;s astrologiquement), mais sans comp&eacute;tence, pas m&ecirc;me Jeu, et comparer les r&eacute;sultats (&eacute;chec, r&eacute;ussite normale, significative, etc.) : le meilleur gagne. &Agrave; &eacute;galit&eacute; de r&eacute;ussites, le coup est nul.</p>","descriptionmj":"","type":"de","base":0,"caraccomp":"Chance","reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870036,"modifiedTime":1671048281609,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Le rossignol d’Ostarlath","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.jUsy5PTDwBgDrRnq"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_8.webp","effects":[],"_id":"jUsy5PTDwBgDrRnq","system":{"description":"<p>Romance o&ugrave; les paroles, peu importantes, sont essentiellement un exercice de vocalises.</p>","descriptionmj":"","niveau":8,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870037,"modifiedTime":1671048281610,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Le roi des ours","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.jUxckTsggDZBgn2W"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_3.webp","effects":[],"_id":"jUxckTsggDZBgn2W","system":{"description":"<p>Sanglante &eacute;pop&eacute;e sur un th&egrave;me identique* : mal&eacute;fice, m&eacute;tamorphose et superbe vengeance finale.</p>\n<p>&nbsp;</p>\n<p><em>*voir \"La ch&egrave;vre rose\"</em></p>","descriptionmj":"","niveau":3,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870037,"modifiedTime":1671048281610,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La route est longue","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.jyPBU95uPhIhsdpa"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_0.webp","effects":[],"_id":"jyPBU95uPhIhsdpa","system":{"description":"<p>Chanson de marche aux couplets r&eacute;p&eacute;titifs.</p>\n<blockquote>\n<p>&laquo; Une lieue sans cheval, &ccedil;a use, &ccedil;a use</p>\n<p>Une lieue sans cheval, &ccedil;a use les sandales !&raquo;</p>\n</blockquote>","descriptionmj":"","niveau":0,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870037,"modifiedTime":1671048281610,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La danse du couteau","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.k9EELSV0DrurUt1e"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_sol_6.webp","effects":[],"_id":"k9EELSV0DrurUt1e","system":{"description":"<p>Plus masculine que f&eacute;minine, cette danse utilise un couteau (dague) comme accessoire.</p>\n<p>Elle est imitative d&rsquo;un combat.</p>","descriptionmj":"","type":"soliste","agilite":false,"apparence":true,"niveau":6,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870037,"modifiedTime":1671048281610,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"L’amour est morte","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.kCU7A8fMczERjizY"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_5.webp","effects":[],"_id":"kCU7A8fMczERjizY","system":{"description":"<p>Romance sentimentale d&rsquo;une tristesse &agrave; faire pleurer les cailloux.</p>","descriptionmj":"","niveau":5,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870037,"modifiedTime":1671048281610,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Amandjara","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.kiIlPL5XANy5OgYn"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_2.webp","effects":[],"_id":"kiIlPL5XANy5OgYn","system":{"description":"<p>S&eacute;r&eacute;nade sur la l&eacute;gendaire cit&eacute; d&rsquo;Amandjara,</p>\n<p>&laquo; Perle du d&eacute;sert bleu, sur qui la lune fait les doux yeux ... &raquo;</p>","descriptionmj":"","niveau":2,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870038,"modifiedTime":1671048281611,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Bloutade","type":"recettecuisine","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.lv6AiGYIjtqHhn7u"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/recette_cuisine_1.webp","effects":[],"_id":"lv6AiGYIjtqHhn7u","system":{"description":"<p>Pur&eacute;e de farine de bloute.</p>\n<p>&nbsp;</p>\n<p><strong>Bloute</strong></p>\n<p>Avec le tomari ou le bl&eacute;di&egrave;ze, la bloute est &agrave; la base de l&rsquo;alimentation dans un grand nombre d&rsquo;endroits. C&rsquo;est un tubercule de forme et de couleur voisins de notre manioc, &agrave; la chair g&eacute;latineuse et fade. Totalement immangeables telles quelles, les bloutes sont mises &agrave; s&eacute;cher sur des claies, puis broy&eacute;es en farine. Ce n&rsquo;est qu&rsquo;ainsi qu&rsquo;on peut les consommer. La farine de bloute entre dans la confection des brouets et des rago&ucirc;ts, notamment de la bloutade. Ainsi cuite, elle ressemble &agrave; du tapioca.</p>","descriptionmj":"","niveau":1,"ingredients":"<ul>\n<li>1 livre de farine de bloute*</li>\n<li>1/2 livre de viande de porc ou de padongre coup&eacute;e en petits morceaux</li>\n<li>2 doigts d&rsquo;huile</li>\n<li>eau,</li>\n<li>sel</li>\n<li>8 brins d&rsquo;aromates (b&eacute;jaune, luciane)</li>\n</ul>","duree":"30 minutes","sust":8,"exotisme":0,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870038,"modifiedTime":1671048281611,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Le tisonnier","type":"jeu","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.mRzHzrubRkyqHUTC"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_tisonnier.webp","effects":[],"_id":"mRzHzrubRkyqHUTC","system":{"description":"<p>On commence par se mettre d&rsquo;accord sur la valeur hi&eacute;rarchique des symboles et des combinaisons possibles, puis le jeu consiste, &agrave; chaque distribution de cartes, &agrave; miser selon un syst&egrave;me de surench&egrave;res jusqu&rsquo;&agrave; ce que les cartes soient d&eacute;voil&eacute;es.</p>\n<p>La combinaison la plus forte emporte alors les mises.</p>\n<p>Le jeu demande de la chance, sans laquelle il est difficile de gagner &agrave; long terme, mais tout autant de l&rsquo;empathie pour bluffer lors des surench&egrave;res.</p>\n<p>Pour simuler une partie, jouer un jet de CHANCE &agrave; z&eacute;ro (ajust&eacute; astrologiquement), suivi d&rsquo;un jet d&rsquo;EMPATHIE/Jeu &agrave; z&eacute;ro, et additionner les points de t&acirc;che obtenus par les deux jets. Le vainqueur est celui qui en totalise le plus.</p>","descriptionmj":"","type":"carte","base":-4,"caraccomp":"Chance / Empathie","reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870038,"modifiedTime":1671048281611,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Plume de zyglute","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.nCFFhbL54WXU0FFi"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_4.webp","effects":[],"_id":"nCFFhbL54WXU0FFi","system":{"description":"<p>S&eacute;r&eacute;nade.</p>\n<p>Belle musique, mais paroles d&rsquo;une rare stupidit&eacute; :</p>\n<blockquote>\n<p>&laquo; Coin-coin, glou-glou, c&rsquo;est qui ? c&rsquo;est vous ? &raquo;</p>\n</blockquote>","descriptionmj":"","niveau":4,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870038,"modifiedTime":1671048281611,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"L’auberge noire","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.srNKj5s0TOw7VDQ4"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_5.webp","effects":[],"_id":"srNKj5s0TOw7VDQ4","system":{"description":"<p>Complainte macabre sur un aubergiste qui assassine ses clients avec la r&acirc;pe &agrave; fromage.</p>","descriptionmj":"","niveau":5,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870038,"modifiedTime":1671048281611,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Ma chope est vide !","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.uGVOeSq2ZKMG8VjU"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_0.webp","effects":[],"_id":"uGVOeSq2ZKMG8VjU","system":{"description":"<p>Chanson &agrave; boire peu raffin&eacute;e.</p>","descriptionmj":"","niveau":0,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870039,"modifiedTime":1671048281611,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La callipyge","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.uf7a9D5RYw7gOi36"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_sol_2.webp","effects":[],"_id":"uf7a9D5RYw7gOi36","system":{"description":"<p>Comme la serpentine, avec des effets plus marqu&eacute;s, essentiellement bas&eacute;e sur les mouvements du bassin. La callipyge n&rsquo;est g&eacute;n&eacute;ralement dans&eacute;e que par les femmes.</p>","descriptionmj":"","type":"soliste","agilite":false,"apparence":true,"niveau":2,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870039,"modifiedTime":1671048281612,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La gambade","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.uxdljYU7TlC2F6oA"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_1.webp","effects":[],"_id":"uxdljYU7TlC2F6oA","system":{"description":"<p>Gigue endiabl&eacute;e, proche du bourrichon, mais avec des figures un peu moins sommaires.</p>","descriptionmj":"","type":"recreative","agilite":true,"apparence":true,"niveau":1,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870039,"modifiedTime":1671048281612,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Trompe de padongre à la mentharde","type":"recettecuisine","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.uzSivEs6SFEGVoI0"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/recette_cuisine_4.webp","effects":[],"_id":"uzSivEs6SFEGVoI0","system":{"description":"<p>Enduite de miel, de beurre et entour&eacute;e de feuilles de mentharde fra&icirc;ches, la trompe de padongre doit &ecirc;tre cuite au four et arros&eacute;e r&eacute;guli&egrave;rement de lait. Toute la difficult&eacute; r&eacute;side dans la cuisson.</p>","descriptionmj":"","niveau":4,"ingredients":"<ul>\n<li>1 belle trompe de padongre (10 sust)</li>\n<li>25 schouillats de miel</li>\n<li>1 livre de beurre</li>\n<li>1 pinte de lait</li>\n<li>20 brins de mentharde</li>\n<li>sel</li>\n</ul>","duree":"90 minutes","sust":12,"exotisme":0,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870039,"modifiedTime":1671048281613,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La triplette","type":"jeu","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.vYPjOjd3vSAvjL76"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_doublon.webp","effects":[],"_id":"vYPjOjd3vSAvjL76","system":{"description":"<p>Autre jeu de hasard, la triplette est un jeu de d&eacute;s de combinaisons se jouant avec trois d&eacute;s (sorte de 421).</p>\n<p>Pour simuler une partie de triplette, d&eacute;terminer l&rsquo;ordre dans lequel jouent les participants. Le premier &agrave; jouer peut tenter de un &agrave; trois jets de CHANCE &agrave; z&eacute;ro (ajust&eacute;s astrologiquement comme pour le doublon), et additionner les points de t&acirc;che obtenus.</p>\n<p>Attention aux &eacute;checs qui donnent des points n&eacute;gatifs ! Il peut &ecirc;tre plus judicieux de se contenter d&rsquo;un seul jet bien r&eacute;ussi.</p>\n<p>Les joueurs suivants, en effet, pourront &agrave; leur tour tenter le m&ecirc;me nombre de jets de CHANCE ou moins, mais pas davantage. Le plus grand nombre de points gagne finalement.</p>","descriptionmj":"","type":"de","base":0,"caraccomp":"Chance","reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870040,"modifiedTime":1671048281613,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Le voyageur","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.vlqX5BC9recz2kM2"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_1.webp","effects":[],"_id":"vlqX5BC9recz2kM2","system":{"description":"<p>Ballade sur les tribulations d&rsquo;un voyageur.</p>\n<p>Interminable, cette chanson poss&egrave;de plus de cent couplets.</p>\n<p>&nbsp;</p>\n<p><em>D&eacute;terminer en tirant 1d100 le nombre de couplets connus.</em></p>","descriptionmj":"","niveau":1,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870040,"modifiedTime":1671048281613,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La pétasse","type":"jeu","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.vo8GoXIBNWp1GY12"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_petasse.webp","effects":[],"_id":"vo8GoXIBNWp1GY12","system":{"description":"<p>Jeu d&rsquo;adresse combinant boules et quilles.</p>\n<p>Chaque joueur dispose de plusieurs quilles, appel&eacute;es p&eacute;tasses, et de boules de bois, appel&eacute;es tronchets. Le jeu conna&icirc;t de nombreuses variantes, mais le principe g&eacute;n&eacute;ral est le m&ecirc;me : culbuter les p&eacute;tasses des adversaires en &eacute;vitant de se faire troncher les siennes.</p>\n<p>Pour simuler une partie, faire tirer &agrave; chaque participant 5 jets de Lancer/Jeu &agrave; z&eacute;ro et additionner les points de t&acirc;che obtenus. Le plus grand nombre gagne.</p>","descriptionmj":"","type":"adressehasard","base":-6,"caraccomp":"Lancer","reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870040,"modifiedTime":1671048281613,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La sarabande","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.wf1jpIZmrB5LfK93"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_4.webp","effects":[],"_id":"wf1jpIZmrB5LfK93","system":{"description":"<p>Peu pratiqu&eacute;e dans les villages, la sarabande est une danse de cour, lente et solennelle, alternant groupe et couples, comme la turlutaine dont elle est une version &laquo;s&eacute;rieuse&raquo;.</p>\n<p>Les changements de partenaire s&rsquo;accompagnent de profondes r&eacute;v&eacute;rences.</p>","descriptionmj":"","type":"recreative","agilite":false,"apparence":true,"niveau":4,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870042,"modifiedTime":1671048281613,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Le retour du baron gris","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.xjITZoom3Azu9NQa"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_2.webp","effects":[],"_id":"xjITZoom3Azu9NQa","system":{"description":"<p>&Eacute;pop&eacute;e pleine de cavalcades, de trahisons, de batailles et de cervelles &eacute;clat&eacute;es.</p>","descriptionmj":"","niveau":2,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870042,"modifiedTime":1671048281614,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"L’heure de la Lyre","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.yLcvnrbqIKS4ezj7"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_1.webp","effects":[],"_id":"yLcvnrbqIKS4ezj7","system":{"description":"<p>Berceuse sur le th&egrave;me de la nuit qui descend.</p>","descriptionmj":"","niveau":1,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870043,"modifiedTime":1671048281614,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Le cavalier de sombre neige","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.zRQ5WnPI483CKm9Q"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_6.webp","effects":[],"_id":"zRQ5WnPI483CKm9Q","system":{"description":"<p>&Eacute;pop&eacute;e pleine de suspense et de terreur, o&ugrave; le soleil est rouge, la lune violette et la neige noire.</p>","descriptionmj":"","niveau":6,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870043,"modifiedTime":1671048281614,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}

packs/competences-creatures.db

@@ -1,29 +1,29 @@
-{"_id":"0zRL8bOpCXNQnIR4","name":"Ruade","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.0zRL8bOpCXNQnIR4"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-pietinement.webp","effects":[],"system":{"categorie_parade":"","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":true,"isparade":false,"ispossession":false,"dommages":4,"description":null,"descriptionmj":"","categorie":"melee","isnaturelle":true},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702692,"modifiedTime":1663625011172,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"4GmpkphbsmQjvVVK","name":"Escalade","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.4GmpkphbsmQjvVVK"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_escalade.webp","effects":[],"system":{"categorie_parade":"","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":false,"isparade":false,"ispossession":false,"dommages":0,"description":"","descriptionmj":""},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702692,"modifiedTime":1663625011172,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"6DK46pyO0hzEuuUg","name":"Morsure","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.6DK46pyO0hzEuuUg"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-morsure.webp","effects":[],"system":{"categorie_parade":"","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":true,"isparade":false,"ispossession":false,"dommages":1,"description":"","descriptionmj":"","categorie":"generale","isnaturelle":true},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702692,"modifiedTime":1663625011172,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"name":"Possession","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.c0I93Q53i4ZmxpyT"}},"img":"systems/foundryvtt-reve-de-dragon/icons/entites/possession.webp","effects":[],"system":{"categorie_parade":"","niveau":2,"default_diffLibre":0,"carac_value":14,"iscombat":true,"isparade":false,"ispossession":true,"dommages":0,"description":"<p>L'entit&eacute; tente de prendre possession du corps de sa victime.</p>","descriptionmj":"","categorie":"melee"},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624948267,"modifiedTime":1663625011162,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"_id":"9u16zxXRurCtxuOX","folder":null,"sort":0,"ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3}}
-{"_id":"BjqRrGtHtTzuNpZB","name":"Griffes et Crocs","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.BjqRrGtHtTzuNpZB"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-griffes.webp","effects":[],"system":{"categorie_parade":"","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":true,"isparade":false,"ispossession":false,"dommages":1,"description":"","descriptionmj":"","categorie":"melee","isnaturelle":true},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702692,"modifiedTime":1663625011172,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"CYpxxf1uTa78NWR9","name":"Esquive","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.CYpxxf1uTa78NWR9"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_esquive.webp","effects":[],"system":{"categorie_parade":"","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":false,"isparade":false,"ispossession":false,"dommages":0,"description":"","descriptionmj":""},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702692,"modifiedTime":1663625011173,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"JTuBQCPdumw3DfxH","name":"Crête","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.JTuBQCPdumw3DfxH"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-crete.webp","effects":[],"system":{"categorie_parade":"","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":true,"isparade":false,"ispossession":false,"dommages":3,"description":"","descriptionmj":"","categorie":"melee","isnaturelle":true},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702693,"modifiedTime":1663625011173,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"Kt7WlB5Ui97X211z","name":"Vol","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.Kt7WlB5Ui97X211z"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-vol.webp","effects":[],"system":{"categorie_parade":"","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":false,"isparade":false,"ispossession":false,"dommages":0,"description":"","descriptionmj":""},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702693,"modifiedTime":1663625011173,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"LWQHz5ymNBzh6ZEr","name":"Cornes","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.LWQHz5ymNBzh6ZEr"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-corne.webp","effects":[],"system":{"categorie_parade":"","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":true,"isparade":false,"ispossession":false,"dommages":2,"description":"","descriptionmj":"","categorie":"melee","isnaturelle":true},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702693,"modifiedTime":1663625011173,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"NctG7suzvGE7ZZzj","name":"Bras-bouches","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.NctG7suzvGE7ZZzj"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-brasbouche.webp","effects":[],"system":{"categorie_parade":"epees-lourdes","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":true,"isparade":true,"ispossession":false,"dommages":2,"description":"","descriptionmj":"","categorie":"melee","isnaturelle":true},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702693,"modifiedTime":1663625011173,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"OzHBowOMADRwcVXR","name":"Pierre Tenue","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.OzHBowOMADRwcVXR"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-pierretenue.webp","effects":[],"system":{"categorie_parade":"","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":true,"isparade":false,"ispossession":false,"dommages":2,"description":"","descriptionmj":"","categorie":"melee","isnaturelle":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702693,"modifiedTime":1663625011173,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"PCwbR6lghjydTj93","name":"Grande morsure","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.PCwbR6lghjydTj93"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-morsure.webp","effects":[],"system":{"categorie_parade":"","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":true,"isparade":false,"ispossession":false,"dommages":2,"description":"","descriptionmj":"","categorie":"melee","isnaturelle":true},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702693,"modifiedTime":1663625011173,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"PrVuVpwuYaZtwRUi","name":"Piétinement","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.PrVuVpwuYaZtwRUi"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-pietinement.webp","effects":[],"system":{"categorie_parade":"","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":true,"isparade":false,"ispossession":false,"dommages":4,"description":null,"descriptionmj":"","categorie":"melee","isnaturelle":true},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702693,"modifiedTime":1663625011173,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"RAnasKnoA3OQgwfv","name":"Pinces","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.RAnasKnoA3OQgwfv"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-pinces.webp","effects":[],"system":{"categorie_parade":"epees-lourdes","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":true,"isparade":true,"ispossession":false,"dommages":3,"description":"","descriptionmj":"","categorie":"melee","isnaturelle":true},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702694,"modifiedTime":1663625011173,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"XgfRxSj8Ty1d3JFM","name":"Mandibules","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.XgfRxSj8Ty1d3JFM"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-mandibules.webp","effects":[],"system":{"categorie_parade":"","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":true,"isparade":false,"ispossession":false,"dommages":2,"description":"","descriptionmj":"","carac-value":null,"categorie":"generale","isnaturelle":true},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702694,"modifiedTime":1663625011173,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"Zpl2Bi451vB3r91W","name":"Coup de pied","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.Zpl2Bi451vB3r91W"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-coup_de_pied.webp","effects":[],"system":{"categorie_parade":"","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":true,"isparade":false,"ispossession":false,"dommages":3,"description":null,"descriptionmj":"","categorie":"melee","isnaturelle":true},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702694,"modifiedTime":1663625011173,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"0zRL8bOpCXNQnIR4","name":"Ruade","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.0zRL8bOpCXNQnIR4"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-pietinement.webp","effects":[],"system":{"description":null,"descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":4,"isparade":false},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702692,"modifiedTime":1671048288982,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"4GmpkphbsmQjvVVK","name":"Escalade","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.4GmpkphbsmQjvVVK"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_escalade.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":false,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702692,"modifiedTime":1671048288983,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"6DK46pyO0hzEuuUg","name":"Morsure","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.6DK46pyO0hzEuuUg"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-morsure.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"generale","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":1,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702692,"modifiedTime":1671048288983,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Possession","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.c0I93Q53i4ZmxpyT"}},"img":"systems/foundryvtt-reve-de-dragon/icons/entites/possession.webp","effects":[],"system":{"description":"<p>L'entit&eacute; tente de prendre possession du corps de sa victime.</p>","descriptionmj":"","categorie_parade":"","niveau":2,"default_diffLibre":0,"categorie":"draconic","carac_value":14,"iscombat":true,"isnaturelle":true,"ispossession":true,"dommages":0,"isparade":false},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624976822,"modifiedTime":1671048288983,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"_id":"9u16zxXRurCtxuOX","folder":null,"sort":0,"ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3}}
+{"_id":"BjqRrGtHtTzuNpZB","name":"Griffes et Crocs","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.BjqRrGtHtTzuNpZB"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-griffes.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":1,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702692,"modifiedTime":1671048288983,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"CYpxxf1uTa78NWR9","name":"Esquive","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.CYpxxf1uTa78NWR9"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_esquive.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":false,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702692,"modifiedTime":1671048288983,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"JTuBQCPdumw3DfxH","name":"Crête","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.JTuBQCPdumw3DfxH"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-crete.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":3,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702693,"modifiedTime":1671048288983,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"Kt7WlB5Ui97X211z","name":"Vol","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.Kt7WlB5Ui97X211z"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-vol.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":false,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702693,"modifiedTime":1671048288983,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"LWQHz5ymNBzh6ZEr","name":"Cornes","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.LWQHz5ymNBzh6ZEr"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-corne.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":2,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702693,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"NctG7suzvGE7ZZzj","name":"Bras-bouches","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.NctG7suzvGE7ZZzj"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-brasbouche.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"epees-lourdes","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":2,"isparade":true},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702693,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"OzHBowOMADRwcVXR","name":"Pierre Tenue","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.OzHBowOMADRwcVXR"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-pierretenue.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":false,"ispossession":false,"dommages":2,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702693,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"PCwbR6lghjydTj93","name":"Grande morsure","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.PCwbR6lghjydTj93"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-morsure.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":2,"isparade":false},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702693,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"PrVuVpwuYaZtwRUi","name":"Piétinement","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.PrVuVpwuYaZtwRUi"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-pietinement.webp","effects":[],"system":{"description":null,"descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":4,"isparade":false},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702693,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"RAnasKnoA3OQgwfv","name":"Pinces","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.RAnasKnoA3OQgwfv"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-pinces.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"epees-lourdes","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":3,"isparade":true},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702694,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"XgfRxSj8Ty1d3JFM","name":"Mandibules","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.XgfRxSj8Ty1d3JFM"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-mandibules.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"generale","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":2,"isparade":false,"carac-value":null},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702694,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"Zpl2Bi451vB3r91W","name":"Coup de pied","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.Zpl2Bi451vB3r91W"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-coup_de_pied.webp","effects":[],"system":{"description":null,"descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":3,"isparade":false},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702694,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
 {"name":"Possession","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.c0I93Q53i4ZmxpyT"}},"img":"systems/foundryvtt-reve-de-dragon/icons/entites/possession.webp","effects":[],"system":{"categorie_parade":"","niveau":2,"default_diffLibre":0,"carac_value":14,"iscombat":true,"isparade":false,"ispossession":true,"dommages":0,"description":"<p>L'entit&eacute; tente de prendre possession du corps de sa victime.</p>","descriptionmj":"","categorie":"draconic"},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624976822,"modifiedTime":1663625011162,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"_id":"duVgxI3Cdko0KzAj","folder":null,"sort":0,"ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3}}
-{"_id":"efl1HdDSKpBfImQ1","name":"Pierre Lancée","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.efl1HdDSKpBfImQ1"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-pierrelancee.webp","effects":[],"system":{"categorie_parade":"","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":true,"isparade":false,"ispossession":false,"dommages":1,"description":"","descriptionmj":"","categorie":"lancer","isnaturelle":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702694,"modifiedTime":1663625011173,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"h9ASt4vrvEgxfj7j","name":"Tronçonneuse","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.h9ASt4vrvEgxfj7j"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-tronconneuse.webp","effects":[],"system":{"categorie_parade":"","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":true,"isparade":false,"ispossession":false,"dommages":10,"description":"","descriptionmj":"","categorie":"melee","isnaturelle":true},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702694,"modifiedTime":1663625011173,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"jhua9kkCs55OV7Yl","name":"Grandes griffes","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.jhua9kkCs55OV7Yl"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-griffes.webp","effects":[],"system":{"categorie_parade":"sans-armes","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":true,"isparade":true,"ispossession":false,"dommages":2,"description":"","descriptionmj":"","categorie":"melee","isnaturelle":true},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702694,"modifiedTime":1663625011173,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"lzEdMrKXbOYrWG5S","name":"Vigilance","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.lzEdMrKXbOYrWG5S"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_vigilance.webp","effects":[],"system":{"categorie_parade":"","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":false,"isparade":false,"ispossession":false,"dommages":0,"description":"","descriptionmj":""},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702694,"modifiedTime":1663625011173,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"ndNshntOYb1JFNqi","name":"Serres","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.ndNshntOYb1JFNqi"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-serres.webp","effects":[],"system":{"categorie_parade":"","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":true,"isparade":false,"ispossession":false,"dommages":2,"description":"","descriptionmj":"","categorie":"melee","isnaturelle":true},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702694,"modifiedTime":1663625011173,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"os88Rsp7mBkahqmh","name":"Bec","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.os88Rsp7mBkahqmh"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-beak.webp","effects":[],"system":{"categorie_parade":"","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":true,"isparade":false,"ispossession":false,"dommages":0,"description":"","descriptionmj":"","categorie":"melee","isnaturelle":true},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702695,"modifiedTime":1663625011173,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"qilRzXpVaGceNmQp","name":"Dague","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.qilRzXpVaGceNmQp"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_dague.webp","effects":[],"system":{"categorie_parade":"dagues","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":true,"isparade":true,"ispossession":false,"dommages":1,"description":"","descriptionmj":"","categorie":"melee","isnaturelle":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702695,"modifiedTime":1663625011173,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"qrd9AoZzFgyzFBxz","name":"Griffes","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.qrd9AoZzFgyzFBxz"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-griffes.webp","effects":[],"system":{"categorie_parade":"sans-armes","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":true,"isparade":true,"ispossession":false,"dommages":1,"description":"","descriptionmj":"","categorie":"melee","isnaturelle":true},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702695,"modifiedTime":1663625011173,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"sUdXhpuVVOAlcVpo","name":"Pickpocket","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.sUdXhpuVVOAlcVpo"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_pickpocket.webp","effects":[],"system":{"categorie_parade":"","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":false,"isparade":false,"ispossession":false,"dommages":0,"description":"","descriptionmj":""},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702695,"modifiedTime":1663625011174,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"shsUV8UpU18c0RJK","name":"Course","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.shsUV8UpU18c0RJK"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_course.webp","effects":[],"system":{"categorie_parade":"","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":false,"isparade":false,"ispossession":false,"dommages":0,"description":"","descriptionmj":""},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702695,"modifiedTime":1663625011174,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"yBUVTjTXYfwvzusb","name":"Saut","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.yBUVTjTXYfwvzusb"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_saut.webp","effects":[],"system":{"categorie_parade":"","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":false,"isparade":false,"ispossession":false,"dommages":0,"description":"","descriptionmj":"","categorie":"generale"},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702695,"modifiedTime":1663625011174,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"yDHZfK4RmwQW4YaW","name":"Discrétion","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.yDHZfK4RmwQW4YaW"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_discretion.webp","effects":[],"system":{"categorie_parade":"","niveau":0,"default_diffLibre":0,"carac_value":0,"iscombat":false,"isparade":false,"ispossession":false,"dommages":0,"description":"","descriptionmj":""},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624702695,"modifiedTime":1663625011174,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"efl1HdDSKpBfImQ1","name":"Pierre Lancée","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.efl1HdDSKpBfImQ1"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-pierrelancee.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"lancer","carac_value":0,"iscombat":true,"isnaturelle":false,"ispossession":false,"dommages":1,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702694,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"h9ASt4vrvEgxfj7j","name":"Tronçonneuse","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.h9ASt4vrvEgxfj7j"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-tronconneuse.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":10,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702694,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"jhua9kkCs55OV7Yl","name":"Grandes griffes","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.jhua9kkCs55OV7Yl"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-griffes.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"sans-armes","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":2,"isparade":true},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702694,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"lzEdMrKXbOYrWG5S","name":"Vigilance","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.lzEdMrKXbOYrWG5S"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_vigilance.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":false,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702694,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"ndNshntOYb1JFNqi","name":"Serres","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.ndNshntOYb1JFNqi"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-serres.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":2,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702694,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"os88Rsp7mBkahqmh","name":"Bec","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.os88Rsp7mBkahqmh"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-beak.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702695,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"qilRzXpVaGceNmQp","name":"Dague","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.qilRzXpVaGceNmQp"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_dague.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"dagues","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":false,"ispossession":false,"dommages":1,"isparade":true},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702695,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"qrd9AoZzFgyzFBxz","name":"Griffes","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.qrd9AoZzFgyzFBxz"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-griffes.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"sans-armes","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":1,"isparade":true},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702695,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"sUdXhpuVVOAlcVpo","name":"Pickpocket","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.sUdXhpuVVOAlcVpo"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_pickpocket.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":false,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702695,"modifiedTime":1671048288985,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"shsUV8UpU18c0RJK","name":"Course","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.shsUV8UpU18c0RJK"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_course.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":false,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702695,"modifiedTime":1671048288985,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"yBUVTjTXYfwvzusb","name":"Saut","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.yBUVTjTXYfwvzusb"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_saut.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"generale","carac_value":0,"iscombat":false,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":false},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702695,"modifiedTime":1671048288985,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"yDHZfK4RmwQW4YaW","name":"Discrétion","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.yDHZfK4RmwQW4YaW"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_discretion.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":false,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702695,"modifiedTime":1671048288985,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}

packs/competences-entites.db

@@ -1,15 +1,15 @@
-{"_id":"0Ms9iKxqigNNpZEx","name":"Esquive","permission":{"default":0,"Q4cUvqxCxMoTJXDL":3},"type":"competencecreature","data":{"niveau":0,"carac_value":0,"iscombat":false,"dommages":0,"description":"","categorie_parade":"","isparade":false},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_esquive.webp","effects":[]}
-{"_id":"18wcei5hlEInsBFO","name":"Attaque","permission":{"default":0,"Q4cUvqxCxMoTJXDL":3},"type":"competencecreature","data":{"niveau":0,"carac_value":0,"iscombat":true,"dommages":0,"description":"","carac-value":null,"categorie_parade":"","isparade":false},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-griffes.webp","effects":[]}
-{"_id":"3Crwg8cx2JOb697T","name":"Parade","permission":{"default":0,"Q4cUvqxCxMoTJXDL":3},"type":"competencecreature","data":{"niveau":0,"carac_value":0,"iscombat":false,"dommages":0,"description":"","carac-value":null,"categorie_parade":"","isparade":false},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_saut.webp","effects":[]}
-{"_id":"6eWCVDYLXXO1Z48D","name":"Grandes griffes","permission":{"default":0,"Q2G6GTdrotKzYGUC":3},"type":"competencecreature","data":{"categorie_parade":"sans-armes","niveau":0,"carac_value":0,"iscombat":true,"isparade":false,"dommages":2,"description":""},"flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.BjqRrGtHtTzuNpZB"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-griffes.webp","effects":[]}
-{"_id":"9Y83OsQgeyR5oCdH","name":"Griffes","permission":{"default":0,"Q4cUvqxCxMoTJXDL":3},"type":"competencecreature","data":{"niveau":0,"carac_value":0,"iscombat":true,"dommages":1,"description":"","carac-value":null,"categorie_parade":"sans-armes","isparade":false},"flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.BjqRrGtHtTzuNpZB"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-griffes.webp","effects":[]}
-{"_id":"D9cBJ3EJPYLnABiJ","name":"Tentacules","permission":{"default":0,"Q2G6GTdrotKzYGUC":3},"type":"competencecreature","data":{"categorie_parade":"boucliers","niveau":0,"carac_value":0,"iscombat":true,"isparade":true,"dommages":2,"description":"<p>Attaque ou parade avec un tentacule.</p>"},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-tentacule.webp","effects":[]}
-{"_id":"QGULMUoC9JXFze0r","name":"Bouclier Lourd","permission":{"default":0,"Q4cUvqxCxMoTJXDL":3},"type":"competencecreature","data":{"niveau":0,"carac_value":0,"iscombat":true,"dommages":0,"description":"","carac-value":null,"categorie_parade":"boucliers","isparade":true},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_bouclier.webp","effects":[]}
-{"_id":"WsYnwR8GcOxfuCI0","name":"Bras-Galet","permission":{"default":0,"Q4cUvqxCxMoTJXDL":3},"type":"competencecreature","data":{"niveau":0,"carac_value":0,"iscombat":true,"dommages":1,"description":"","carac-value":null,"categorie_parade":"","isparade":false},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_course.webp","effects":[]}
-{"_id":"c0I93Q53i4ZmxpyT","name":"Corps à Corps","permission":{"default":0,"Q4cUvqxCxMoTJXDL":3},"type":"competencecreature","data":{"niveau":0,"carac_value":0,"iscombat":true,"dommages":0,"description":"","categorie_parade":"sans-armes","isparade":true},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_corps_a_corps.webp","effects":[]}
-{"_id":"d5SZ09sFaG3cL2Rg","name":"Bec","permission":{"default":0,"Q4cUvqxCxMoTJXDL":3},"type":"competencecreature","data":{"niveau":0,"carac_value":0,"iscombat":true,"dommages":0,"description":"","categorie_parade":"","isparade":false},"flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.os88Rsp7mBkahqmh"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-beak.webp","effects":[]}
-{"_id":"db8E8HwROw1ZcwRR","name":"Crocs","permission":{"default":0,"Q4cUvqxCxMoTJXDL":3},"type":"competencecreature","data":{"niveau":0,"carac_value":0,"iscombat":true,"dommages":1,"description":"","carac-value":null,"categorie_parade":"","isparade":false},"flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.NctG7suzvGE7ZZzj"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-brasbouche.webp","effects":[]}
-{"_id":"gPOQd9NI7AFH0whX","name":"Epée Bâtarde","permission":{"default":0,"Q4cUvqxCxMoTJXDL":3},"type":"competencecreature","data":{"niveau":0,"carac_value":0,"iscombat":true,"dommages":4,"description":"","carac-value":null,"categorie_parade":"epees-lourdes","isparade":true},"flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-humanoides.YTKld5ggDsHqwYoR"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_epee_1_main.webp","effects":[]}
-{"_id":"j1xHCzfIeYKgXxoH","name":"Morsure","permission":{"default":0,"Q4cUvqxCxMoTJXDL":3},"type":"competencecreature","data":{"niveau":0,"carac_value":0,"iscombat":true,"dommages":1,"description":"","categorie_parade":"","isparade":false},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-morsure.webp","effects":[]}
-{"_id":"lDZ3qUPKN35ob5TH","name":"Grande morsure","permission":{"default":0,"Q2G6GTdrotKzYGUC":3},"type":"competencecreature","data":{"categorie_parade":"","niveau":0,"carac_value":0,"iscombat":true,"isparade":false,"dommages":2,"description":""},"flags":{},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-morsure.webp","effects":[]}
-{"name":"Possession","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.c0I93Q53i4ZmxpyT"}},"img":"systems/foundryvtt-reve-de-dragon/icons/entites/possession.webp","effects":[],"system":{"categorie_parade":"","niveau":2,"default_diffLibre":-4,"categorie":"melee","carac_value":14,"iscombat":true,"isnaturelle":true,"ispossession":true,"dommages":0,"description":"<p>L'entit&eacute; tente de prendre possession du corps de sa victime.</p>","descriptionmj":"","isparade":false},"ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.22","coreVersion":"10.286","createdTime":1663624976822,"modifiedTime":1664918524164,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"wDHR5UHWq568lfGa"}
+{"_id":"0Ms9iKxqigNNpZEx","name":"Esquive","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.0Ms9iKxqigNNpZEx"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_esquive.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":false,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895714,"modifiedTime":1671048307066,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"18wcei5hlEInsBFO","name":"Attaque","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.18wcei5hlEInsBFO"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-griffes.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":0,"carac-value":null,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895715,"modifiedTime":1671048307066,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"3Crwg8cx2JOb697T","name":"Parade","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.3Crwg8cx2JOb697T"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_saut.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":false,"isnaturelle":true,"ispossession":false,"dommages":0,"carac-value":null,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895715,"modifiedTime":1671048307066,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"6eWCVDYLXXO1Z48D","name":"Grandes griffes","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.BjqRrGtHtTzuNpZB"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-griffes.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"sans-armes","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":2,"isparade":false},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895715,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"9Y83OsQgeyR5oCdH","name":"Griffes","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.BjqRrGtHtTzuNpZB"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-griffes.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"sans-armes","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":1,"carac-value":null,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895715,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"D9cBJ3EJPYLnABiJ","name":"Tentacules","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.D9cBJ3EJPYLnABiJ"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-tentacule.webp","effects":[],"system":{"description":"<p>Attaque ou parade avec un tentacule.</p>","descriptionmj":"","categorie_parade":"boucliers","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":2,"isparade":true},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895716,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"QGULMUoC9JXFze0r","name":"Bouclier Lourd","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.QGULMUoC9JXFze0r"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_bouclier.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"boucliers","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":0,"carac-value":null,"isparade":true},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895716,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"WsYnwR8GcOxfuCI0","name":"Bras-Galet","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.WsYnwR8GcOxfuCI0"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_course.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":1,"carac-value":null,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895716,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"c0I93Q53i4ZmxpyT","name":"Corps à Corps","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.c0I93Q53i4ZmxpyT"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_corps_a_corps.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"sans-armes","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":true},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895716,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"d5SZ09sFaG3cL2Rg","name":"Bec","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.os88Rsp7mBkahqmh"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-beak.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895716,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"db8E8HwROw1ZcwRR","name":"Crocs","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.NctG7suzvGE7ZZzj"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-brasbouche.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":1,"carac-value":null,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895716,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"gPOQd9NI7AFH0whX","name":"Epée Bâtarde","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-humanoides.YTKld5ggDsHqwYoR"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_epee_1_main.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"epees-lourdes","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":4,"carac-value":null,"isparade":true},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895717,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"j1xHCzfIeYKgXxoH","name":"Morsure","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.j1xHCzfIeYKgXxoH"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-morsure.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":1,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895717,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"lDZ3qUPKN35ob5TH","name":"Grande morsure","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.lDZ3qUPKN35ob5TH"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-morsure.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":2,"isparade":false},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895717,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Possession","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.c0I93Q53i4ZmxpyT"}},"img":"systems/foundryvtt-reve-de-dragon/icons/entites/possession.webp","effects":[],"system":{"description":"<p>L'entit&eacute; tente de prendre possession du corps de sa victime.</p>","descriptionmj":"","categorie_parade":"","niveau":2,"default_diffLibre":-4,"categorie":"melee","carac_value":14,"iscombat":true,"isnaturelle":true,"ispossession":true,"dommages":0,"isparade":false},"ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624976822,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"wDHR5UHWq568lfGa"}