Merge permissions fix

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

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

@@ -40,11 +40,4 @@ export class RdDActorCreatureSheet extends RdDActorSheet {
       this.actor.updateCreatureCompetence(compName, "dommages", parseInt(event.target.value));
     });
   }
-
-  /* -------------------------------------------- */
-  /** @override */
-  _updateObject(event, formData) {
-    // Update the Actor
-    return this.object.update(formData);
-  }
 }

module/actor-sheet.js

@@ -10,15 +10,16 @@ import { DialogSplitItem } from "./dialog-split-item.js";
 import { ReglesOptionelles } from "./settings/regles-optionelles.js";
 import { RdDSheetUtility } from "./rdd-sheet-utility.js";
 import { STATUSES } from "./settings/status-effects.js";
-import { Monnaie } from "./item-monnaie.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() {
@@ -36,42 +37,26 @@ 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: {
-        fortune: Monnaie.getFortune(this.actor),
-        encTotal: await this.actor.computeEncombrementTotalEtMalusArmure(),
-        surenc: this.actor.computeMalusSurEncombrement(),
-        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;
@@ -125,22 +110,14 @@ export class RdDActorSheet extends ActorSheet {
   /* -------------------------------------------- */  /** @override */
   activateListeners(html) {
     super.activateListeners(html);
-    this.html = html;
 
     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;
 
-    this.html.find('.item-split').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
-      RdDSheetUtility.splitItem(item, this.actor);
-    });
-    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.confirmerSuppressionItem(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)?.postItem());
     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");
@@ -174,14 +151,8 @@ export class RdDActorSheet extends ActorSheet {
     this.html.find('.creer-tache').click(async event => {
       this.createEmptyTache();
     });
-    this.html.find('.creer-un-objet').click(async event => {
-      RdDUtility.selectObjetType(this);
-    });
     this.html.find('.creer-une-oeuvre').click(async event => {
-      RdDUtility.selectTypeOeuvre(this);
-    });
-    this.html.find('.nettoyer-conteneurs').click(async event => {
-      this.actor.nettoyerConteneurs();
+      this.selectTypeOeuvreToCreate();
     });
 
     // Blessure control
@@ -325,10 +296,6 @@ export class RdDActorSheet extends ActorSheet {
         await this.actor.removeEffects();
       }
     });
-    this.html.find('.conteneur-name a').click(async event => {
-      RdDUtility.toggleAfficheContenu(RdDSheetUtility.getItemId(event));
-      this.render(true);
-    });
     this.html.find('.carac-xp-augmenter').click(async event => {
       let caracName = event.currentTarget.name.replace("augmenter.", "");
       this.actor.updateCaracXPAuto(caracName);
@@ -418,19 +385,12 @@ export class RdDActorSheet extends ActorSheet {
       this.actor.setPointsDeSeuil(event.currentTarget.value);
     });
 
-    this.html.find('#attribut-protection-edit').change(async event => {
-      this.actor.updateAttributeValue(event.currentTarget.attributes.name.value, parseInt(event.target.value));
-    });
-
     // On stress change
     this.html.find('.compteur-edit').change(async event => {
       let fieldName = event.currentTarget.attributes.name.value;
       this.actor.updateCompteurValue(fieldName, parseInt(event.target.value));
     });
 
-    this.html.find('#ethylisme').change(async event => {
-      this.actor.setEthylisme(parseInt(event.target.value));
-    });
     this.html.find('.stress-test').click(async event => {
       this.actor.transformerStress();
     });
@@ -454,13 +414,6 @@ export class RdDActorSheet extends ActorSheet {
       this.actor.jetEndurance();
     });
 
-    this.html.find('.monnaie-plus').click(async event => {
-      this.actor.monnaieIncDec(RdDSheetUtility.getItemId(event), 1);
-    });
-    this.html.find('.monnaie-moins').click(async event => {
-      this.actor.monnaieIncDec(RdDSheetUtility.getItemId(event), -1);
-    });
-
     this.html.find('.vie-plus').click(async event => {
       this.actor.santeIncDec("vie", 1);
     });
@@ -499,25 +452,30 @@ export class RdDActorSheet extends ActorSheet {
   }
 
   /* -------------------------------------------- */
-  async _onDropItem(event, dragData) {
-    const destItemId = this.html.find(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 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>`
     }
-  }
-
-  /* -------------------------------------------- */
-  async createItem(name, type) {
-    await this.actor.createEmbeddedDocuments('Item', [{ name: name, type: type }], { renderSheet: true });
+    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.createItem('Nouvelle tache', 'tache');
+    await this.actor.createItem('tache', 'Nouvelle tache');
   }
 
   _optionRecherche(target) {

module/actor.js

@@ -13,7 +13,6 @@ import { RdDItemSort } from "./item-sort.js";
 import { Grammar } from "./grammar.js";
 import { RdDEncaisser } from "./rdd-roll-encaisser.js";
 import { RdDCombat } from "./rdd-combat.js";
-import { RdDAudio } from "./rdd-audio.js";
 import { RdDItemCompetence } from "./item-competence.js";
 import { RdDItemArme } from "./item-arme.js";
 import { RdDAlchimie } from "./rdd-alchimie.js";
@@ -24,19 +23,17 @@ import { ReglesOptionelles } from "./settings/regles-optionelles.js";
 import { EffetsDraconiques } from "./tmr/effets-draconiques.js";
 import { Draconique } from "./tmr/draconique.js";
 import { RdDCarac } from "./rdd-carac.js";
-import { Monnaie } from "./item-monnaie.js";
 import { DialogConsommer } from "./dialog-item-consommer.js";
 import { DialogFabriquerPotion } from "./dialog-fabriquer-potion.js";
 import { RollDataAjustements } from "./rolldata-ajustements.js";
-import { RdDItem } from "./item.js";
 import { RdDPossession } from "./rdd-possession.js";
-import { ENTITE_BLURETTE, ENTITE_INCARNE, ENTITE_NONINCARNE, HIDE_DICE, SHOW_DICE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
+import { ENTITE_BLURETTE, ENTITE_INCARNE, ENTITE_NONINCARNE, SHOW_DICE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
 import { RdDConfirm } from "./rdd-confirm.js";
 import { DialogValidationEncaissement } from "./dialog-validation-encaissement.js";
 import { RdDRencontre } from "./item-rencontre.js";
-import { SystemCompendiums } from "./settings/system-compendiums.js";
 import { Targets } from "./targets.js";
 import { DialogRepos } from "./dialog-repos.js";
+import { RdDBaseActor } from "./actor/base-actor.js";
 
 const POSSESSION_SANS_DRACONIC = {
   img: 'systems/foundryvtt-reve-de-dragon/icons/entites/possession.webp',
@@ -56,88 +53,7 @@ export const MAINS_DIRECTRICES = ['Droitier', 'Gaucher', 'Ambidextre']
  * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
  * @extends {Actor}
  */
-export class RdDActor extends Actor {
-  /* -------------------------------------------- */
-  static init() {
-    Hooks.on("preUpdateItem", (item, change, options, id) => RdDActor.getParentActor(item)?.onPreUpdateItem(item, change, options, id));
-    // TODO: replace with pre-hooks?
-    Hooks.on("createItem", (item, options, id) => RdDActor.getParentActor(item)?.onCreateItem(item, options, id));
-    Hooks.on("deleteItem", (item, options, id) => RdDActor.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 RdDActor.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) {
-      RdDActor.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(`RdDActor.onRemoteActorCall: pour l'Actor ${callData.actorId}, appel de RdDActor.${callData.method}(`, ...args, ')');
-        actor[callData.method](...args);
-      }
-    }
-  }
-
-  /* -------------------------------------------- */
-  static getParentActor(document) {
-    return document?.parent instanceof Actor ? document.parent : undefined
-  }
-
-  /* -------------------------------------------- */
-  /**
-   * Override the create() function to provide additional RdD functionality.
-   *
-   * This overrided create() function adds initial items
-   * Namely: Basic skills, money,
-   *
-   * @param {Object} actorData Barebones actor template data which this function adds onto.
-   * @param {Object} options   Additional options which customize the creation workflow.
-   *
-   */
-  static async create(actorData, options) {
-    // Case of compendium global import
-    if (actorData instanceof Array) {
-      return super.create(actorData, options);
-    }
-
-    const isPersonnage = actorData.type == "personnage";
-    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
-    if (actorData.items) {
-      return await super.create(actorData, options);
-    }
-
-    if (isPersonnage) {
-      const competences = await SystemCompendiums.getCompetences(actorData.type);
-      actorData.items = competences.map(i => i.toObject())
-        .concat(Monnaie.monnaiesStandard());
-    }
-    else {
-      actorData.items = [];
-    }
-    return super.create(actorData, options);
-  }
+export class RdDActor extends RdDBaseActor {
 
   /* -------------------------------------------- */
   prepareData() {
@@ -145,6 +61,8 @@ export class RdDActor extends Actor {
 
     // Dynamic computing fields
     this.encTotal = 0;
+    // TODO: separate derived/base data preparation
+    // TODO: split by actor class
 
     // Make separate methods for each Actor type (character, npc, etc.) to keep
     // things organized.
@@ -156,12 +74,12 @@ export class RdDActor extends Actor {
 
   /* -------------------------------------------- */
   _prepareCreatureData(actorData) {
-    this.computeEncombrementTotalEtMalusArmure();
+    this.computeEncTotal();
   }
 
   /* -------------------------------------------- */
   _prepareVehiculeData(actorData) {
-    this.computeEncombrementTotalEtMalusArmure();
+    this.computeEncTotal();
   }
 
   /* -------------------------------------------- */
@@ -173,14 +91,15 @@ export class RdDActor extends Actor {
     RdDCarac.computeCarac(actorData.system)
     this.computeIsHautRevant();
     await this.cleanupConteneurs();
-    await this.computeEncombrementTotalEtMalusArmure();
+    await this.computeEncTotal();
+    await this.computeMalusArmure();
   }
 
   /* -------------------------------------------- */
   async cleanupConteneurs() {
-    let updates = this.listItemsData('conteneur')
-      .filter(c => c.system.contenu.filter(id => this.getObjet(id) == undefined).length > 0)
-      .map(c => { return { _id: c._id, 'system.contenu': c.system.contenu.filter(id => this.getObjet(id) != undefined) } });
+    let updates = this.listItems('conteneur')
+      .filter(c => c.system.contenu.filter(id => this.getItem(id) == undefined).length > 0)
+      .map(c => { return { _id: c._id, 'system.contenu': c.system.contenu.filter(id => this.getItem(id) != undefined) } });
     if (updates.length > 0) {
       await this.updateEmbeddedDocuments("Item", updates)
     }
@@ -188,17 +107,17 @@ export class RdDActor extends Actor {
 
   canReceive(item) {
     if (this.isCreature()) {
-      return item.type == 'competencecreature' || RdDItem.isItemInventaire(item);
+      return item.type == 'competencecreature' || item.isInventaire();
     }
     if (this.isEntite()) {
       return item.type == 'competencecreature';
     }
     if (this.isVehicule()) {
-      return RdDItem.isItemInventaire(item);
+      return item.isInventaire();
     }
     if (this.isPersonnage()) {
       switch (item.type) {
-        case 'competencecreature': case 'tarot':
+        case 'competencecreature': case 'tarot': case 'service':
           return false;
       }
       return true;
@@ -206,23 +125,6 @@ export class RdDActor extends Actor {
     return false;
   }
 
-  /* -------------------------------------------- */
-  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';
-  }
   /* -------------------------------------------- */
   isHautRevant() {
     return this.isPersonnage() && this.system.attributs.hautrevant.value != ""
@@ -330,50 +232,29 @@ export class RdDActor extends Actor {
   }
 
   /* -------------------------------------------- */
-  getObjet(id) {
-    return this.getEmbeddedDocument('Item', id);
-  }
-
-  listItemsData(type) {
-    return this.itemTypes[type];
-  }
-
-  filterItems(filter) {
-    return this.items.filter(filter);
-  }
-
-  getItemOfType(idOrName, type) {
-    return this.items.find(it => it.id == idOrName && it.type == type)
-      ?? Misc.findFirstLike(idOrName, this.items, { filter: it => it.type == type, description: type });
-  }
-
-  getMonnaie(id) {
-    return this.getItemOfType(id, 'monnaie');
-  }
-
   getTache(id) {
-    return this.getItemOfType(id, 'tache');
+    return this.findItemLike(id, 'tache');
   }
   getMeditation(id) {
-    return this.getItemOfType(id, 'meditation');
+    return this.findItemLike(id, 'meditation');
   }
   getChant(id) {
-    return this.getItemOfType(id, 'chant');
+    return this.findItemLike(id, 'chant');
   }
   getDanse(id) {
-    return this.getItemOfType(id, 'danse');
+    return this.findItemLike(id, 'danse');
   }
   getMusique(id) {
-    return this.getItemOfType(id, 'musique');
+    return this.findItemLike(id, 'musique');
   }
   getOeuvre(id, type = 'oeuvre') {
-    return this.getItemOfType(id, type);
+    return this.findItemLike(id, type);
   }
   getJeu(id) {
-    return this.getItemOfType(id, 'jeu');
+    return this.findItemLike(id, 'jeu');
   }
   getRecetteCuisine(id) {
-    return this.getItemOfType(id, 'recettecuisine');
+    return this.findItemLike(id, 'recettecuisine');
   }
   /* -------------------------------------------- */
   getDraconicList() {
@@ -461,7 +342,7 @@ export class RdDActor extends Actor {
       selectedCaracName: 'apparence',
       competences: this.itemTypes['competence']
     };
-  
+
     const dialog = await RdDRoll.create(this, rollData,
       { html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll.html' },
       {
@@ -476,8 +357,9 @@ export class RdDActor extends Actor {
     );
     dialog.render(true);
   }
+
   async repos() {
-    await DialogRepos.create(this.actor);
+    await DialogRepos.create(this);
   }
 
   /* -------------------------------------------- */
@@ -1105,237 +987,7 @@ export class RdDActor extends Actor {
     await this.update({ [`system.attributs.${fieldName}.value`]: fieldValue });
   }
 
-  /* -------------------------------------------- */
-  _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.getObjet(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.getObjet(idContenu)));
-    return encContenus.reduce(Misc.sum(), 0)
-      + Number(tplData.encombrement) /* TODO? Number(tplData.quantite) -- on pourrait avoir plusieurs conteneurs...*/
-  }
-
-  /* -------------------------------------------- */
-  buildSubConteneurObjetList(conteneurId, deleteList) {
-    let conteneur = this.getObjet(conteneurId);
-    if (conteneur?.type == 'conteneur') { // Si c'est un conteneur
-      for (let subId of conteneur.system.contenu) {
-        let subObj = this.getObjet(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();
-    }
-  }
-
-  /* -------------------------------------------- */
-  /** 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);
-        }
-      }
-    });
-  }
-
-  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.getObjet(itemId);
-    if (item?.isInventaire() && sourceActorId == targetActorId) {
-      // rangement
-      if (srcId != destId && itemId != destId) { // déplacement de l'objet
-        const src = this.getObjet(srcId);
-        const dest = this.getObjet(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.computeEncombrementTotalEtMalusArmure();
-    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;
-
-  }
-
-  /* -------------------------------------------- */
-  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.getObjet(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.getObjet(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;
-  }
 
   isSurenc() {
     return this.isPersonnage() ? (this.computeMalusSurEncombrement() < 0) : false
@@ -1377,17 +1029,7 @@ export class RdDActor extends Actor {
 
   hasItemNamed(type, name) {
     name = Grammar.toLowerCaseNoAccent(name);
-    return this.listItemsData(type).find(it => Grammar.toLowerCaseNoAccent(it.name) == name);
-  }
-
-  /* -------------------------------------------- */
-  async computeEncombrementTotalEtMalusArmure() {
-    if (!this.pack) {
-      await this.computeMalusArmure();
-      this.encTotal = this.items.map(it => it.getEncTotal()).reduce(Misc.sum(), 0);
-      return this.encTotal;
-    }
-    return 0;
+    return this.listItems(type).find(it => Grammar.toLowerCaseNoAccent(it.name) == name);
   }
 
   /* -------------------------------------------- */
@@ -1403,14 +1045,6 @@ export class RdDActor extends Actor {
     }
   }
 
-  /* -------------------------------------------- */
-  computePrixTotalEquipement() {
-    const valeur = this.items.filter(it => it.isInventaire())
-      .map(it => it.valeurTotale())
-      .reduce(Misc.sum(), 0);
-    return valeur;
-  }
-
   /* -------------------------------------------- */
   computeResumeBlessure(blessures = undefined) {
     blessures = blessures ?? this.system.blessures;
@@ -1443,6 +1077,10 @@ export class RdDActor extends Actor {
     }
   }
 
+  recompute() {
+    this.computeEtatGeneral();
+  }
+
   /* -------------------------------------------- */
   computeEtatGeneral() {
     // Pas d'état général pour les entités forçage à 0
@@ -2026,7 +1664,7 @@ export class RdDActor extends Actor {
   /* -------------------------------------------- */
   async consommerNourritureboisson(itemId, choix = { doses: 1, seForcer: false, supprimerSiZero: false }, userId = undefined) {
     if (userId != undefined && userId != game.user.id) {
-      RdDActor.remoteActorCall({
+      RdDBaseActor.remoteActorCall({
         actorId: this.id,
         method: 'consommerNourritureboisson',
         args: [itemId, choix, userId]
@@ -2034,7 +1672,7 @@ export class RdDActor extends Actor {
         userId)
       return;
     }
-    const item = this.getObjet(itemId)
+    const item = this.getItem(itemId)
     if (!item.isComestible()) {
       return;
     }
@@ -2791,7 +2429,7 @@ export class RdDActor extends Actor {
   /* -------------------------------------------- */
   async rollDanse(id) {
     const artData = { art: 'danse', verbe: 'Danser', forceCarac: {} };
-    const oeuvre = duplicate(this.getItemOfType(id, artData.art));
+    const oeuvre = duplicate(this.findItemLike(id, artData.art));
     if (oeuvre.system.agilite) {
       artData.forceCarac['agilite'] = duplicate(this.system.carac.agilite);
     }
@@ -2813,7 +2451,7 @@ export class RdDActor extends Actor {
   /* -------------------------------------------- */
   async rollMusique(id) {
     const artData = { art: 'musique', verbe: 'Jouer' };
-    const oeuvre = this.getItemOfType(id, artData.art);
+    const oeuvre = this.findItemLike(id, artData.art);
     await this._rollArt(artData, "ouie", oeuvre);
   }
 
@@ -2910,7 +2548,7 @@ export class RdDActor extends Actor {
 
   async rollOeuvre(id) {
     const artData = { art: 'oeuvre', verbe: 'Interpréter' }
-    const oeuvre = duplicate(this.getItemOfType(id, artData.art))
+    const oeuvre = duplicate(this.findItemLike(id, artData.art))
     await this._rollArt(artData, oeuvre.system.default_carac, oeuvre)
   }
 
@@ -2962,7 +2600,7 @@ export class RdDActor extends Actor {
   /* -------------------------------------------- */
   _getSignesDraconiques(coord) {
     const type = TMRUtility.getTMRType(coord);
-    return this.listItemsData("signedraconique").filter(it => it.system.typesTMR.includes(type));
+    return this.listItems("signedraconique").filter(it => it.system.typesTMR.includes(type));
   }
 
   /* -------------------------------------------- */
@@ -3173,39 +2811,37 @@ export class RdDActor extends Actor {
 
   /* -------------------------------------------- */
   async resetNombreAstral() {
-    let toDelete = this.listItemsData('nombreastral');
+    let toDelete = this.listItems('nombreastral');
     const deletions = toDelete.map(it => it._id);
     await this.deleteEmbeddedDocuments("Item", deletions);
   }
 
   /* -------------------------------------------- */
   async ajouteNombreAstral(callData) {
-    // Gestion expérience (si existante)
-    callData.competence = this.getCompetence("astrologie")
-    callData.selectedCarac = this.system.carac["vue"];
-    this.appliquerAjoutExperience(callData, 'hide');
-
     // Ajout du nombre astral
     const item = {
       name: "Nombre Astral", type: "nombreastral", system:
         { value: callData.nbAstral, istrue: callData.isvalid, jourindex: Number(callData.date), jourlabel: game.system.rdd.calendrier.getDateFromIndex(Number(callData.date)) }
     };
     await this.createEmbeddedDocuments("Item", [item]);
-
-    // Suppression des anciens nombres astraux
-    let toDelete = this.listItemsData('nombreastral').filter(it => it.system.jourindex < game.system.rdd.calendrier.getCurrentDayIndex());
-    const deletions = toDelete.map(it => it._id);
-    await this.deleteEmbeddedDocuments("Item", deletions);
-
     // Affichage Dialog
     this.astrologieNombresAstraux();
   }
 
+  async supprimerAnciensNombresAstraux() {
+    const toDelete = this.listItems('nombreastral')
+      .filter(it => it.system.jourindex < game.system.rdd.calendrier.getCurrentDayIndex())
+      .map(it => it._id);
+    await this.deleteEmbeddedDocuments("Item", toDelete);
+  }
+
   /* -------------------------------------------- */
   async astrologieNombresAstraux() {
+    // Suppression des anciens nombres astraux
+    await this.supprimerAnciensNombresAstraux();
+
     // Afficher l'interface spéciale
-    const astrologieDialog = await RdDAstrologieJoueur.create(this, {});
-    astrologieDialog.render(true);
+    await RdDAstrologieJoueur.create(this);
   }
 
   /* -------------------------------------------- */
@@ -3255,7 +2891,7 @@ export class RdDActor extends Actor {
 
   /* -------------------------------------------- */
   getSortList() {
-    return this.listItemsData("sort");
+    return this.listItems("sort");
   }
 
   /* -------------------------------------------- */
@@ -3318,7 +2954,7 @@ export class RdDActor extends Actor {
       fatigue: RdDUtility.calculFatigueHtml(fatigue, endurance),
       draconic: this.getDraconicList(),
       sort: this.getSortList(),
-      signes: this.listItemsData("signedraconique"),
+      signes: this.listItems("signedraconique"),
       caracReve: this.system.carac.reve.value,
       pointsReve: this.getReveActuel(),
       isRapide: isRapide,
@@ -3391,7 +3027,7 @@ export class RdDActor extends Actor {
     if (item && ['arme', 'armure'].includes(item.type)) {
       const isEquipe = !item.system.equipe;
       await this.updateEmbeddedDocuments('Item', [{ _id: item.id, "system.equipe": isEquipe }]);
-      this.computeEncombrementTotalEtMalusArmure(); // Mise à jour encombrement
+      this.computeEncTotal(); // Mise à jour encombrement
       if (isEquipe)
         this.verifierForceMin(item);
     }
@@ -3469,7 +3105,7 @@ export class RdDActor extends Actor {
 
   async validerEncaissement(rollData, show) {
     if (ReglesOptionelles.isUsing('validation-encaissement-gr') && !game.user.isGM) {
-      RdDActor.remoteActorCall({
+      RdDBaseActor.remoteActorCall({
         actorId: this.id,
         method: 'validerEncaissement',
         args: [rollData, show]
@@ -3684,181 +3320,9 @@ export class RdDActor extends Actor {
     return;
   }
 
-  /* -------------------------------------------- */
-  async payerSols(depense) {
-    depense = Number(depense);
-    if (depense == 0) {
-      return;
-    }
-    let fortune = Monnaie.getFortune(this);
-    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 = Monnaie.getFortune(this) - 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) {
-      RdDActor.remoteActorCall({
-        userId: Misc.connectedGMOrUser(),
-        actorId: this.id,
-        method: 'ajouterSols', args: [sols, fromActorId]
-      });
-    }
-    else {
-      const fromActor = game.actors.get(fromActorId)
-      await Monnaie.optimiserFortune(this, sols + Monnaie.getFortune(this));
-
-      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.`
-      });
-    }
-  }
-
-  /* -------------------------------------------- */
-  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 }]);
-    }
-  }
-
-  /* -------------------------------------------- */
-  async achatVente(achat) {
-    if (achat.vendeurId == achat.acheteurId) {
-      ui.notifications.info("Inutile de se vendre à soi-même");
-      return;
-    }
-    if (!Misc.isUniqueConnectedGM()) {
-      RdDActor.remoteActorCall({
-        actorId: achat.vendeurId ?? achat.acheteurId,
-        method: 'achatVente',
-        args: [achat]
-      });
-      return;
-    }
-
-    const cout = Number(achat.prixTotal ?? 0);
-    const vente = achat.vente;
-    const acheteur = achat.acheteurId ? game.actors.get(achat.acheteurId) : undefined;
-    const vendeur = achat.vendeurId ? game.actors.get(achat.vendeurId) : undefined;
-    let itemVendu = vendeur?.getObjet(vente.item._id);
-
-    if (vendeur && (itemVendu?.getQuantite() ?? 0) < achat.quantiteTotal) {
-      ChatUtility.notifyUser(achat.userId, 'warn', `Le vendeur n'a plus assez de ${vente.item.name} !`);
-      return;
-    }
-    if (Monnaie.getFortune(acheteur) < Number(cout)) {
-      ChatUtility.notifyUser(achat.userId, 'warn', `Vous n'avez pas assez d'argent pour payer ${Math.ceil(cout / 100)} sols !`);
-      return;
-    }
-
-    achat.quantiteTotal = (achat.choix.nombreLots ?? 1) * (vente.tailleLot);
-    if (vendeur) {
-      await vendeur.ajouterSols(cout);
-      await vendeur.decrementerQuantiteItem(itemVendu, achat.quantiteTotal,);
-    }
-    if (acheteur) {
-      await acheteur.depenserSols(cout);
-      let createdItemId = await acheteur.creerQuantiteItem(vente.item, achat.quantiteTotal);
-      await acheteur.consommerNourritureAchetee(achat, vente, createdItemId);
-    }
-    if (cout > 0) {
-      RdDAudio.PlayContextAudio("argent");
-    }
-    const chatAchatItem = duplicate(vente);
-    chatAchatItem.quantiteTotal = achat.quantiteTotal;
-    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 {
-        vente["properties"] = new RdDItem(vente.item).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 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) {
-    let resteQuantite = (item.system.quantite ?? 1) - quantite;
-    if (resteQuantite <= 0) {
-      await this.deleteEmbeddedDocuments("Item", [item.id]);
-      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) {
-    const items = await this.createEmbeddedDocuments("Item", RdDActor.$prepareListeAchat(item, quantite));
-    return items.length > 0 ? items[0].id : undefined;
-  }
-
-  static $prepareListeAchat(item, quantite) {
-    const isItemEmpilable = "quantite" in item.system;
-    const achatData = {
-      type: item.type,
-      img: item.img,
-      name: item.name,
-      system: mergeObject(item.system, { quantite: isItemEmpilable ? quantite : undefined }),
-    };
-    return isItemEmpilable ? [achatData] : Array.from({ length: quantite }, (_, i) => achatData);
-  }
-
   /* -------------------------------------------- */
   async effectuerTacheAlchimie(recetteId, tacheAlchimie, texteTache) {
-    let recetteData = this.getItemOfType(recetteId, 'recettealchimique');
+    let recetteData = this.findItemLike(recetteId, 'recettealchimique');
     if (recetteData) {
       if (tacheAlchimie != "couleur" && tacheAlchimie != "consistance") {
         ui.notifications.warn(`L'étape alchimique ${tacheAlchimie} - ${texteTache} est inconnue`);
@@ -4128,7 +3592,7 @@ export class RdDActor extends Actor {
 
   /* -------------------------------------------- */
   async diminuerQuantiteObjet(id, nb, options = { supprimerSiZero: false }) {
-    const item = this.getObjet(id);
+    const item = this.getItem(id);
     if (item) {
       await item.diminuerQuantite(nb, options);
     }

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,615 @@
+import { ChatUtility } from "../chat-utility.js";
+import { SYSTEM_SOCKET_ID } from "../constants.js";
+import { Monnaie } from "../item-monnaie.js";
+import { RdDItem } from "../item.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) { }
+
+  /* -------------------------------------------- */
+  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 (itemVendu.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(itemVendu, quantite) {
+    if (this.system.illimite) {
+      return;
+    }
+    await super.decrementerQuantiteItem(itemVendu, quantite, { supprimerSiZero: false });
+  }
+
+  calculerPrix(item) {
+    const pourcentage = this.system.pourcentage ?? 100;
+    return Misc.keepDecimals(Math.ceil(item.system.cout * pourcentage) / 100, 2);
+  }
+}

module/dialog-item-achat.js

@@ -1,12 +1,13 @@
+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;
@@ -16,46 +17,67 @@ 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);
     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
@@ -96,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);
-    this.html.find(".nombreLots").val(this.venteData.choix.nombreLots);
+
+    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-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.isOwned;
     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: !isOwned || quantiteMax == undefined,
+      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);
@@ -54,7 +55,7 @@ export class DialogItemVente extends Dialog {
     await this.html.find(".quantiteIllimite").change();
     await this.html.find(".prixLot").change();
     this.callback(this.venteData);
-  }  
+  }
 
   /* -------------------------------------------- */
   setPrixLot(prixLot) {
@@ -68,13 +69,11 @@ export class DialogItemVente extends Dialog {
       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);
-      this.html.find(".quantiteNbLots").val(this.venteData.quantiteNbLots);
-      this.html.find(".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) {

module/dialog-repos.js

@@ -32,6 +32,7 @@ export class DialogRepos extends Dialog {
     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);

module/item-conteneur-sheet.js

@@ -51,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-monnaie.js

@@ -62,21 +62,17 @@ export class Monnaie {
     return deniers;
   }
 
-  static getFortune(actor) {
-    if (actor) {
-      Monnaie.validerMonnaies(actor);
-      return actor.itemTypes['monnaie']
-        .map(m => Number(m.system.cout) * Number(m.system.quantite))
-        .reduce(Misc.sum(), 0);
-    }
-    return 0;
+  static getFortune(monnaies) {
+    return (monnaies??[])
+      .map(m => Number(m.system.cout) * Number(m.system.quantite))
+      .reduce(Misc.sum(), 0);
   }
 
   static async optimiserFortune(actor, fortune) {
     let resteEnDeniers = Math.round(fortune * 100);
     let monnaies = actor.itemTypes['monnaie'];
     let updates = [];
-    Monnaie.validerMonnaies(actor);
+    Monnaie.validerMonnaies(monnaies, actor);
 
     let parValeur = Misc.classifyFirst(monnaies, it => VALEUR_DENIERS(it.system.cout));
     for (let valeurDeniers of [1000, 100, 10, 1]) {
@@ -99,9 +95,9 @@ export class Monnaie {
     }
   }
 
-  static validerMonnaies(actor) {
-    actor.itemTypes['monnaie'].filter(it => VALEUR_DENIERS(it.system.cout) == 0)
-      .map(it => `La  monnaie ${it.name} de l'acteur ${actor.name} a une valeur de 0!`)
+  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-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-service.js

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

module/item-sheet.js

@@ -60,13 +60,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
   }
@@ -209,9 +209,9 @@ export class RdDItemSheet extends ItemSheet {
 
     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.confirmerSuppressionItem(this, RdDSheetUtility.getItem(event, this.actor)));
+    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)?.postItem());
+    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)));
   }
 

module/item.js

@@ -3,15 +3,16 @@ import { Grammar } from "./grammar.js";
 import { Misc } from "./misc.js";
 import { RdDHerbes } from "./rdd-herbes.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,6 +20,11 @@ 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"]
@@ -57,6 +63,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 +76,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 +95,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,32 +146,17 @@ export class RdDItem extends Item {
     return '';
   }
 
-  constructor(itemData, context) {
-    if (!itemData.img) {
-      itemData.img = RdDItem.getDefaultImg(itemData.type);
-    }
-    super(itemData, context);
-  }
-
-  static getItemTypesInventaire() {
-    return typesObjetsInventaire
-  }
-
-  static getTypesOeuvres() {
-    return typesObjetsOeuvres
-  }
-
-  isCompetencePersonnage() {
-    return this.type == 'competence'
-  }
-  isCompetenceCreature() {
-    return this.type == 'competencecreature'
-  }
+  isCompetencePersonnage() { return this.type == 'competence' }
+  isCompetenceCreature() { return this.type == 'competencecreature' }
+  isConteneur() { return this.type == 'conteneur'; }
+  isMonnaie() { return this.type == 'monnaie'; }
+  isNourritureBoisson() { return this.type == 'nourritureboisson'; }
+  isService() { return this.type == 'service'; }
   isCompetence() {
     return typesObjetsCompetence.includes(this.type)
   }
-  isInventaire() {
-    return RdDItem.isItemInventaire(this)
+  isInventaire(mode = 'materiel') {
+    return RdDItem.getItemTypesInventaire(mode).includes(this.type);
   }
   isOeuvre() {
     return typesObjetsOeuvres.includes(this.type)
@@ -146,12 +170,6 @@ export class RdDItem extends Item {
   isConnaissance() {
     return typesObjetsConnaissance.includes(this.type)
   }
-  isConteneur() {
-    return this.type == 'conteneur';
-  }
-  isMonnaie() {
-    return this.type == 'monnaie';
-  }
 
   getItemGroup() {
     if (this.isInventaire()) return "equipement";
@@ -175,10 +193,6 @@ export class RdDItem extends Item {
     return !this.isConteneur() || (this.system.contenu?.length ?? 0) == 0;
   }
 
-  isNourritureBoisson() {
-    return this.type == 'nourritureboisson';
-  }
-
   isComestible() {
     switch (this.type) {
       case 'nourritureboisson': return 'pret';
@@ -209,15 +223,17 @@ export class RdDItem extends Item {
   }
 
   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':
@@ -236,13 +252,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.parent?.type == 'commerce') {
+      // appliquer le pourcentage
+      return this.parent.calculerPrix(this);
+    }
+    return this.system.cout;
+  }
+
   prepareDerivedData() {
     super.prepareDerivedData();
     if (this.isInventaire()) {
@@ -284,7 +308,7 @@ export class RdDItem extends Item {
     }
     return undefined;
   }
-  
+
   /* -------------------------------------------- */
   async actionPrincipale(actor, onActionItem = async () => { }) {
     if (!this.getActionPrincipale()) {
@@ -355,7 +379,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);
@@ -392,7 +416,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');
       }
@@ -410,54 +434,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;
   }
@@ -706,5 +739,4 @@ export class RdDItem extends Item {
       ...this._inventaireTemplateChatData()
     ]
   }
-
 }

module/migrations.js

@@ -1,6 +1,9 @@
+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";
 
 class Migration {
   get code() { return "sample"; }
@@ -29,6 +32,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"; }
@@ -292,10 +328,51 @@ class _10_3_17_Monnaies extends Migration {
   }
 }
 
+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;
+  }
+}
 
 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(),
@@ -304,7 +381,8 @@ export class Migrations {
       new _10_2_10_DesirLancinant_IdeeFixe(),
       new _10_3_0_Inventaire(),
       new _10_3_0_FrequenceEnvironnement(),
-      new _10_3_17_Monnaies()
+      new _10_3_17_Monnaies(),
+      new _10_4_6_ServicesEnCommerces(),
     ];
   }
 
@@ -321,16 +399,10 @@ 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  */
+    //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}`
@@ -356,4 +428,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-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,15 +20,14 @@ 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: ["rdd-roll-dialog"], 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) {
+  constructor(html, actor, dialogData, dialogOptions) {
     const dialogConf = {
       title: "Nombres Astraux",
       content: html,
@@ -37,7 +36,6 @@ export class RdDAstrologieJoueur extends Dialog {
         saveButton: { label: "Fermer", callback: html => this.quitDialog() }
       },
     };
-    const dialogOptions = { classes: ["rdd-roll-dialog"], width: 600, height: 300, 'z-index': 99999 };
     super(dialogConf, dialogOptions);
 
     this.actor = actor;
@@ -49,9 +47,7 @@ export class RdDAstrologieJoueur extends Dialog {
     super.activateListeners(html);
     this.html = html;
 
-    this.html.find(function () {
-      this.html.find("[name='diffConditions']").val(0);
-    });
+    this.html.find("[name='diffConditions']").val(0);
 
     this.html.find('[name="jet-astrologie"]').click((event) => {
       this.requestJetAstrologie();
@@ -60,7 +56,7 @@ export class RdDAstrologieJoueur extends Dialog {
 
   /* -------------------------------------------- */
   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]) {

module/rdd-calendrier-editeur.js

@@ -29,7 +29,7 @@ export class RdDCalendrierEditeur extends Dialog {
     this.html.find("input[name='nomMois']").val(this.calendrierData.moisKey);
     this.html.find("select[name='nomHeure']").val(this.calendrierData.heureKey);
     this.html.find("select[name='jourMois']").val(this.calendrierData.jourMois);
-    this.html.find("select[name='minutesRelative']").val(calendrierData.minutesRelative);
+    this.html.find("select[name='minutesRelative']").val(this.calendrierData.minutesRelative);
     this.html.find("select[name='annee']").val(this.calendrierData.annee);
   }
 

module/rdd-calendrier.js

@@ -14,7 +14,7 @@ import { DialogChronologie } from "./dialog-chronologie.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' },
+  "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' },
@@ -64,7 +64,7 @@ export class RdDCalendrier extends Application {
     const heure = (typeof value == 'string' || typeof value == 'number') && Number.isInteger(Number(value))
       ? Number(value)
       : (typeof value == 'string') ? RdDCalendrier.getChiffreFromSigne(value)
-      : undefined
+        : undefined
 
     if (heure != undefined && ['key', 'label', 'lettreFont', 'saison', 'heure', 'icon'].includes(key)) {
       return RdDCalendrier.getDefSigne(heure)[key]
@@ -340,21 +340,21 @@ export class RdDCalendrier extends Application {
   }
 
   /* -------------------------------------------- */
-  checkMaladie( periode) {
+  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) );
+        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) {
+          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');
+          let itemMaladie = actor.getItem(maladie.id)
+          itemMaladie.postItem('gmroll');
         }
       }
-    }    
+    }
   }
 
   /* -------------------------------------------- */
@@ -366,7 +366,7 @@ export class RdDCalendrier extends Application {
       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();
@@ -434,6 +434,7 @@ export class RdDCalendrier extends Application {
 
   /* -------------------------------------------- */
   async requestNombreAstral(request) {
+    const actor = game.actors.get(request.id);
     if (Misc.isUniqueConnectedGM()) { // Only once
       console.log(request);
       let jourDiff = this.getLectureAstrologieDifficulte(request.date);
@@ -445,18 +446,26 @@ export class RdDCalendrier extends Application {
         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.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');
+        }
       }
-      request.nbAstral = nbAstral;
+      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 {
@@ -468,6 +477,12 @@ export class RdDCalendrier extends Application {
     }
   }
 
+  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);
+  }
+
   /* -------------------------------------------- */
   findHeure(heure) {
     heure = Grammar.toLowerCaseNoAccentNoSpace(heure);
@@ -483,7 +498,7 @@ export class RdDCalendrier extends Application {
     return undefined;
   }
   /* -------------------------------------------- */
-  getHeureNumber( hNum) {
+  getHeureNumber(hNum) {
     let heure = Object.values(heuresDef).find(it => (it.heure) == hNum);
     return heure
   }
@@ -495,12 +510,16 @@ export class RdDCalendrier extends Application {
     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 ]};
+      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;
   }
@@ -634,9 +653,9 @@ export class RdDCalendrier extends Application {
     let heuresParActeur = {};
     for (let actor of game.actors) {
       let heureNaissance = actor.getHeureNaissance();
-      if ( heureNaissance) {
+      if (heureNaissance) {
         heuresParActeur[actor.name] = this.getHeuresChanceMalchance(heureNaissance);
-      }      
+      }
     }
     //console.log("ASTRO", astrologieArray);
     calendrierData.astrologieData = astrologieArray;

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())

module/rdd-hotbar-drop.js

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

module/rdd-main.js

@@ -1,13 +1,3 @@
-/**
- * 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";
@@ -44,302 +34,295 @@ import { Environnement } from "./environnement.js";
 import { RdDIngredientItemSheet } from "./item-ingredient-sheet.js";
 import { RdDFauneItemSheet } from "./item-faune-sheet.js";
 import { RdDConteneurItemSheet } from "./item-conteneur-sheet.js";
+import { RdDServiceItemSheet } from "./item-service-sheet.js";
+import { RdDItemService } from "./item-service.js";
+import { RdDBaseActor } from "./actor/base-actor.js";
+import { RdDCommerceSheet } from "./actor/commerce-sheet.js";
+import { RdDCommerce } from "./actor/commerce.js";
 
-/* -------------------------------------------- */
-/*  Foundry VTT Initialization                  */
-/* -------------------------------------------- */
+/**
+ * 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
+    }
+    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
+    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, "calendrier", {
+      name: "calendrier",
+      scope: "world",
+      config: false,
+      default: RdDCalendrier.createCalendrierInitial(),
+      type: Object
+    });
+
+    /* -------------------------------------------- */
+    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-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-utility.js

@@ -16,6 +16,7 @@ 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 { RdDCommerce } from "./actor/commerce.js";
 
 /* -------------------------------------------- */
 // This table starts at 0 -> niveau -10
@@ -170,6 +171,8 @@ 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',
@@ -178,31 +181,6 @@ export class RdDUtility {
       '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',
       // partial enums
       'systems/foundryvtt-reve-de-dragon/templates/enum-caracteristiques.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-base-competence.html',
@@ -295,8 +273,9 @@ 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));
@@ -314,63 +293,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 = ""
@@ -431,6 +360,7 @@ export class RdDUtility {
     formData.oeuvres = this.arrayOrEmpty(itemTypes['oeuvre']);
     formData.jeux = this.arrayOrEmpty(itemTypes['jeu']);
 
+    formData.services = this.arrayOrEmpty(itemTypes['service']);
     formData.recettescuisine = this.arrayOrEmpty(itemTypes['recettecuisine']);
     formData.recettesAlchimiques = this.arrayOrEmpty(itemTypes['recettealchimique']);
     formData.maladies = this.arrayOrEmpty(itemTypes['maladie']);
@@ -520,29 +450,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)}'>`;
     for (let subItem of objet.subItems) {
-      strContenu += this.buildConteneur(subItem, profondeur + 1);
+      strContenu += this.buildConteneur(subItem, profondeur + 1, templateItem, options);
     }
     return strContenu + "</ul>";
   }
@@ -814,7 +749,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);
       }
@@ -830,6 +765,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) {
@@ -947,7 +894,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(),

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);

packs/sorts-narcos.db

@@ -7,9 +7,9 @@
 {"_id":"FpwaK1qJxKGs9HgS","name":"Permanence *","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-narcos.FpwaK1qJxKGs9HgS"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_narcos.webp","effects":[],"system":{"description":"<p>C'est par ce rituel que le haut-rêvant stabilise les points de rêve d'une potion ou d'un objet, afin d'en prévenir l'évaporation quotidienne. Facultatif pour les potions, le rituel de Permanence est obligatoire pour tous les autres objets magiques.&nbsp; Son accomplissement diminue de 1 point le seuil de rêve du haut-rêvant.</p>","descriptionmj":"","draconic":"Voie de Narcos","duree":"Instantanée","JR":"","cible":"","difficulte":"-5","portée":"","caseTMR":"sanctuaire","caseTMRspeciale":"","ptreve":"5","xp":0,"bonuscase":"","isrituel":true,"coutseuil":1,"portee":""},"ownership":{"default":0,"6ibmdmaeRSMTjU4c":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.32","coreVersion":"10.288","createdTime":1667259638599,"modifiedTime":1667260043444,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
 {"_id":"KW2VZhuEGJGglGcW","name":"Restauration *","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-narcos.KW2VZhuEGJGglGcW"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_narcos.webp","effects":[],"system":{"description":"<p>Restauration est un rituel secondaire nullement obligatoire. Son seul usage est de redonner des points de rêve actifs à une amulette de protection. Il est en effet impossible d'utiliser le simple Enchantement une fois le rituel de Permanence accompli. Restauration fonctionne de façon semblable à un Enchantement, sauf que son accomplissement coûte chaque fois un point de seuil. On peut&nbsp; restaurer les points de rêve d'une amulette en plusieurs fois en intercalant un rituel de Purifcation entre chaque rituel de Restauration (qui coûte chaque fois un point de seuil). Il est possible de redonner plus de points de rêve actifs à l'objet qu'il n'en avait au départ, jusqu'à concurrence du maximum possible. Le nombre maximum de points de rêve actifs qu'un objet puisse posséder est égal à 7 fois l'enchantabilité de sa gemme.</p>","descriptionmj":"","draconic":"Voie de Narcos","duree":"Instantanée","JR":"Aucun","cible":"","difficulte":"-6","portée":"","caseTMR":"cite","caseTMRspeciale":"","ptreve":"1+","xp":0,"bonuscase":"","isrituel":true,"coutseuil":1,"portee":""},"ownership":{"default":0,"6ibmdmaeRSMTjU4c":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.32","coreVersion":"10.288","createdTime":1667259638599,"modifiedTime":1667260043444,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
 {"name":"Annulation de magie","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-narcos.BibuJdKmaQJm3kFw"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_vigilance.webp","effects":[],"system":{"description":"<p>Ce rituel permet d&rsquo;annuler un effet magique, que celui-ci ait &eacute;t&eacute; accompli par soi-m&ecirc;me ou par un autre haut-r&ecirc;vant. On peut annuler l&rsquo;effet d&rsquo;un sort, de zone ou individuel, d&rsquo;un rituel d&rsquo;enchantement, d&rsquo;une invocation, etc.</p>\n<p>Le haut-r&ecirc;vant doit se trouver dans la case <em>sp&eacute;cifique </em>des TMR d&rsquo;o&ugrave; la magie a &eacute;t&eacute; accomplie. Le jet de R&Ecirc;VE qu&rsquo;il doit r&eacute;ussir a alors la m&ecirc;me difficult&eacute; que celui ayant permis la magie, avec une d&eacute;pense de points de r&ecirc;ve pareillement identique.</p>\n<p>Pour annuler une invocation, le rituel d&rsquo;Annulation doit &ecirc;tre cibl&eacute; sur la cr&eacute;ature invoqu&eacute;e. Quand la magie est le r&eacute;sultat conjoint de plusieurs rituels, ce qui est notamment le cas des objets magiques, chacun doit &ecirc;tre annul&eacute; tour &agrave; tour, en commen&ccedil;ant toujours par le dernier &agrave; avoir &eacute;t&eacute; accompli chronologiquement. D&rsquo;une mani&egrave;re g&eacute;n&eacute;rale, ce sont les m&ecirc;mes op&eacute;rations qui doivent &ecirc;tre r&eacute;p&eacute;t&eacute;es &agrave; l&rsquo;envers. Quand un rituel co&ucirc;te des points de seuil, son annulation en co&ucirc;te &eacute;galement (le m&ecirc;me nombre). Annulation de Magie sert &eacute;galement &agrave; exorciser les entit&eacute;s de cauchemar non incarn&eacute;es. La difficult&eacute; d&rsquo;un exorcisme est toujours R-7, et le co&ucirc;t en points de r&ecirc;ve &eacute;gal au R&Ecirc;VE de l&rsquo;entit&eacute;. Le ciblage doit &ecirc;tre fait sur la cr&eacute;ature poss&eacute;d&eacute;e.</p>\n<p>Avant d&rsquo;accomplir une Annulation de Magie, les param&egrave;tres de la magie &agrave; annuler (case des TMR, R-, r) peuvent &ecirc;tre d&eacute;couverts au moyen du rituel Lecture d&rsquo;Aura.</p>\n<p>Pour la synth&egrave;se d&rsquo;Annulation de Magie, consid&eacute;rer que ce rituel est de difficult&eacute; R-7. Il peut &ecirc;tre utilis&eacute; indiff&eacute;remment par Oniros, Hypnos ou Narcos (mais jamais Thanatos), quelle que soit la voie ayant servi &agrave; accomplir la magie &agrave; annuler.</p>","descriptionmj":"","draconic":"Voie de Narcos","duree":"Instantanée","JR":"Aucun","cible":"Effet magique","difficulte":"variable","portée":"","caseTMR":"special","caseTMRspeciale":"variable","ptreve":"variable","xp":0,"bonuscase":"","isrituel":true,"coutseuil":0,"portee":""},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.32","coreVersion":"10.288","createdTime":1667259638598,"modifiedTime":1667260043440,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"_id":"MM7Qe6gDaeuIggIR","folder":null,"sort":0,"ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3}}
-{"name":"Détection d'aura","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-narcos.xOicgRMCUxJNmVzF"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_vigilance.webp","effects":[],"system":{"description":"<p>Les rituels de D&eacute;tection d&rsquo;Aura peuvent indiff&eacute;remment &ecirc;tre accomplis par n&rsquo;importe laquelle des quatre voies.</p>\n<p>Toutes les cr&eacute;atures vivantes anim&eacute;es (humains, humano&iuml;des, animaux) ont une caract&eacute;ristique R&Ecirc;VE. Les objets enchant&eacute;s poss&egrave;dent des points de r&ecirc;ve, de m&ecirc;me que les produits de magie naturelle, comme certaines pierres de chance. Les entit&eacute;s de cauchemar, incarn&eacute;es ou non, en ont &eacute;galement. Quelle qu&rsquo;elle soit, la pr&eacute;sence de r&ecirc;ve &eacute;met une aura, laquelle est d&eacute;tectable par D&eacute;tection d&rsquo;Aura. Parall&egrave;lement, toute cible d&rsquo;un sort ou d&rsquo;un rituel, &eacute;met une aura propre, quand bien m&ecirc;me ladite cible ne poss&egrave;de pas de points de r&ecirc;ve (centre de zone, objet ou plante soumis &agrave; une illusion d&rsquo;Hypnos). Cette aura est &eacute;galement d&eacute;tectable par D&eacute;tection d&rsquo;Aura.</p>\n<p>L&rsquo;aura de pr&eacute;sence de r&ecirc;ve se traduit par un halo bleut&eacute; constant ; l&rsquo;aura r&eacute;sultant d&rsquo;un effet magique par un halo parcouru de pulsations. Quand les deux auras sont pr&eacute;sentes conjointement, le halo est pulsatif et d&rsquo;un bleu plus fonc&eacute;. On peut toujours effectuer D&eacute;tection d&rsquo;Aura sans aucun risque, il y a toujours une r&eacute;ponse. Soit une aura est per&ccedil;ue, constante ou pulsative, et l&rsquo;on peut tenter une Lecture d&rsquo;Aura pour en savoir plus ; soit aucune aura n&rsquo;est per&ccedil;ue et il s&rsquo;agit de mati&egrave;re inerte, sans r&ecirc;ve, non soumise &agrave; un sort.</p>","descriptionmj":"","draconic":"Voie de Narcos","duree":"Instantanée","JR":"Aucun","cible":"","difficulte":"-3","portée":"","caseTMR":"sanctuaire","caseTMRspeciale":"","ptreve":"1","xp":0,"bonuscase":"","isrituel":false,"coutseuil":0,"portee":""},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.32","coreVersion":"10.288","createdTime":1667259638601,"modifiedTime":1667260043441,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"_id":"NVGQJp4lPcMxnpaT","folder":null,"sort":0,"ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3}}
+{"name":"Détection d'aura","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-narcos.xOicgRMCUxJNmVzF"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_vigilance.webp","effects":[],"system":{"description":"<p>Les rituels de D&eacute;tection d&rsquo;Aura peuvent indiff&eacute;remment &ecirc;tre accomplis par n&rsquo;importe laquelle des quatre voies.</p>\n<p>Toutes les cr&eacute;atures vivantes anim&eacute;es (humains, humano&iuml;des, animaux) ont une caract&eacute;ristique R&Ecirc;VE. Les objets enchant&eacute;s poss&egrave;dent des points de r&ecirc;ve, de m&ecirc;me que les produits de magie naturelle, comme certaines pierres de chance. Les entit&eacute;s de cauchemar, incarn&eacute;es ou non, en ont &eacute;galement. Quelle qu&rsquo;elle soit, la pr&eacute;sence de r&ecirc;ve &eacute;met une aura, laquelle est d&eacute;tectable par D&eacute;tection d&rsquo;Aura. Parall&egrave;lement, toute cible d&rsquo;un sort ou d&rsquo;un rituel, &eacute;met une aura propre, quand bien m&ecirc;me ladite cible ne poss&egrave;de pas de points de r&ecirc;ve (centre de zone, objet ou plante soumis &agrave; une illusion d&rsquo;Hypnos). Cette aura est &eacute;galement d&eacute;tectable par D&eacute;tection d&rsquo;Aura.</p>\n<p>L&rsquo;aura de pr&eacute;sence de r&ecirc;ve se traduit par un halo bleut&eacute; constant ; l&rsquo;aura r&eacute;sultant d&rsquo;un effet magique par un halo parcouru de pulsations. Quand les deux auras sont pr&eacute;sentes conjointement, le halo est pulsatif et d&rsquo;un bleu plus fonc&eacute;. On peut toujours effectuer D&eacute;tection d&rsquo;Aura sans aucun risque, il y a toujours une r&eacute;ponse. Soit une aura est per&ccedil;ue, constante ou pulsative, et l&rsquo;on peut tenter une Lecture d&rsquo;Aura pour en savoir plus ; soit aucune aura n&rsquo;est per&ccedil;ue et il s&rsquo;agit de mati&egrave;re inerte, sans r&ecirc;ve, non soumise &agrave; un sort.</p>","descriptionmj":"","draconic":"Voie de Narcos","duree":"Instantanée","JR":"Aucun","cible":"","difficulte":"-3","portée":"","caseTMR":"sanctuaire","caseTMRspeciale":"","ptreve":"1","xp":0,"bonuscase":"","isrituel":true,"coutseuil":0,"portee":""},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.4.3","coreVersion":"10.291","createdTime":1667259638601,"modifiedTime":1672364107129,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"_id":"NVGQJp4lPcMxnpaT","folder":null,"sort":0,"ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3}}
 {"_id":"P9jMT8pl4pgKEoEW","name":"Écailles de Protection contre le feu *","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-narcos.P9jMT8pl4pgKEoEW"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_narcos.webp","effects":[],"system":{"description":"<p>Chaque écaille de protection diminue de 1 point le jet d'encaissement de tout dommage dû au feu, jouant le rôle d'une \"armure ignifugée\". Soit un personnage possédant une telle amulette dotée de 5 écailles, et se retrouvant dans une zone d'Air en Feu. Au lieu de jouer un jet d'encaissement à +10, il ne la joue qu'à +5. La protection de l'amulette est <em>en plus </em>de la protection physique qu'il peut avoir, laquelle ne peut être - rappelons-le - que d'un maximum de 2 points.</p>\n<p>Une amulette peut avoir n'importe quelle forme, mais ne fonctionne que si elle est en contact avec la peau nue de son possesseur. Si c'est le cas, elle fonctionne spontanément en face du danger pour lequel elle est conçue, même si le possesseur n'a aucune idée de son pouvoir. Pour fonctionner, l'amulette a besoin de points de rêve actifs. Ces points doivent être des points de rêve conférés par le rituel d'Enchantement en plus des points inertes. Autrement dit, voulant fabriquer une amulette, le haut-rêvant ne s'arrête pas d'enchanter quand il atteint un nombre de points de rêve égal à l'inertie totale de l'objet, mais continue à en rajouter. Le nombre maximum de points actifs qu'une amulette puisse posséder est égal à 7 fois l'enchantabilité de sa gemme ; et, comme pour les écailles d'efficacité, le nombre d'écailles de protection qu'elle puisse posséder est égal à l'enchantabilité de celle-ci avec un maximum de 7. Des amulettes plus puissantes ne pourraient être obtenues que par de spécifiques Grandes Écailles de Narcos.</p>\n<p><em>Soit une gemme de taille 6 et de pureté 5, ayant donc une inertie de 2 et une enchantabilité de 4. Elle peut posséder jusqu'à 4 écailles de protection (=enchantabilité) et un maximum de 28 points de rêve actifs (7&nbsp; &nbsp;x 4 = 28).</em></p>\n<p>Chaque fois qu'une amulette de protection fonctionne, elle dépense un de ses points de rêve actifs quel que soit le nombre d'écailles. Le possesseur, lui, n'en dépense qu'un par heure, quel que soit le nombre de fonctionnements de l'amulette au cours de cette heure. Quand une amulette n'a plus de points actifs, elle cesse de fonctionner. On ne peut lui en redonner que par le rituel de Restauration. Les écailles de protection peuvent être posées progressivement, comme celles d'efficacité, même si l'amulette fonctionne entre temps. Mêmes règles d'application. Une gemme donnée ne peut recevoir que des écailles de protection d'un même type, mais grâce à Individualité, plusieurs gemmes d'une même amulette peuvent offrir des protections différentes. La pose de chaque écaille de protection coûte un point de seuil.</p>\n<p>&nbsp;</p>","descriptionmj":"","draconic":"Voie de Narcos","duree":"Instantanée","JR":"Aucun","cible":"","difficulte":"-6","portée":"","caseTMR":"desert","caseTMRspeciale":"","ptreve":"4","xp":0,"bonuscase":"","isrituel":true,"coutseuil":1,"portee":""},"ownership":{"default":0,"6ibmdmaeRSMTjU4c":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.32","coreVersion":"10.288","createdTime":1667259638599,"modifiedTime":1667260043441,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"name":"Lecture d'aura","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-narcos.Y4r9kTN2brWC2N0n"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_vigilance.webp","effects":[],"system":{"description":"<p>Les rituels de Lecture d&rsquo;Aura peuvent indiff&eacute;remment &ecirc;tre accomplis par n&rsquo;importe laquelle des quatre voies.</p>\n<p>Ce rituel permet d&rsquo;approfondir les informations fournies par D&eacute;tection d&rsquo;Aura. Pratiquer Lecture d&rsquo;Aura quand il n&rsquo;y a pas d&rsquo;aura revient &agrave; demander une magie impossible et cr&eacute;e imm&eacute;diatement une d&eacute;chirure du r&ecirc;ve.</p>\n<p>Lecture d&rsquo;Aura est effectu&eacute;e en plusieurs &eacute;tapes, toutes &eacute;tant de difficult&eacute; R-3 et co&ucirc;tant 3 points de r&ecirc;ve. La premi&egrave;re a toujours lieu dans un sanctuaire et ne fait que r&eacute;v&eacute;ler dans quel(s) autre(s) genre(s) de case(s) le haut-r&ecirc;vant doit se rendre pour continuer sa lecture. L&agrave;, il apprend quel genre de magie a &eacute;t&eacute; produit ou &agrave; quel type de r&ecirc;ve il a affaire, de m&ecirc;me que les cases sp&eacute;cifiques concern&eacute;es. Enfin dans les cases sp&eacute;cifiques, le haut-r&ecirc;vant peut apprendre la force du r&ecirc;ve ou de la magie en cours, c&rsquo;est-&agrave;-dire pratiquement la difficult&eacute; et le nombre de points de r&ecirc;ve impliqu&eacute;s, information indispensable dans l&rsquo;optique d&rsquo;une annulation de magie.</p>\n<p>Lecture d&rsquo;Aura r&eacute;v&egrave;le &eacute;galement la couleur de l&rsquo;aura (fixe ou pulsative) comme D&eacute;tection d&rsquo;Aura. Pour les cr&eacute;atures vivantes, on peut donc sauter l&rsquo;&eacute;tape de D&eacute;tection d&rsquo;Aura et commencer directement par la lecture, puisqu&rsquo;on est s&ucirc;r de trouver une aura. Dans les autres cas, il est plus prudent de commencer par la d&eacute;tection si, en l&rsquo;absence finale d&rsquo;une aura, on ne veut pas cr&eacute;er de magie impossible. Effectu&eacute;e sur une cr&eacute;ature non soumise &agrave; un effet magique ni sous l&rsquo;emprise d&rsquo;une entit&eacute;, Lecture d&rsquo;Aura indique toujours le Fleuve. L&agrave;, dans n&rsquo;importe quelle case du Fleuve, le haut-r&ecirc;vant se contente d&rsquo;apprendre qu&rsquo;il a affaire &agrave; une cr&eacute;ature vivante et dou&eacute;e de r&ecirc;ve.</p>","descriptionmj":"","draconic":"Voie de Narcos","duree":"Instantanée","JR":"Aucun","cible":"","difficulte":"-3","portée":"","caseTMR":"special","caseTMRspeciale":"Sanctuaire / variable","ptreve":"3","xp":0,"bonuscase":"","isrituel":false,"coutseuil":0,"portee":""},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.32","coreVersion":"10.288","createdTime":1667259638600,"modifiedTime":1667260043443,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"_id":"QvAyeJIIEssOhJoV","folder":null,"sort":0,"ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3}}
+{"name":"Lecture d'aura","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-narcos.Y4r9kTN2brWC2N0n"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_vigilance.webp","effects":[],"system":{"description":"<p>Les rituels de Lecture d&rsquo;Aura peuvent indiff&eacute;remment &ecirc;tre accomplis par n&rsquo;importe laquelle des quatre voies.</p>\n<p>Ce rituel permet d&rsquo;approfondir les informations fournies par D&eacute;tection d&rsquo;Aura. Pratiquer Lecture d&rsquo;Aura quand il n&rsquo;y a pas d&rsquo;aura revient &agrave; demander une magie impossible et cr&eacute;e imm&eacute;diatement une d&eacute;chirure du r&ecirc;ve.</p>\n<p>Lecture d&rsquo;Aura est effectu&eacute;e en plusieurs &eacute;tapes, toutes &eacute;tant de difficult&eacute; R-3 et co&ucirc;tant 3 points de r&ecirc;ve. La premi&egrave;re a toujours lieu dans un sanctuaire et ne fait que r&eacute;v&eacute;ler dans quel(s) autre(s) genre(s) de case(s) le haut-r&ecirc;vant doit se rendre pour continuer sa lecture. L&agrave;, il apprend quel genre de magie a &eacute;t&eacute; produit ou &agrave; quel type de r&ecirc;ve il a affaire, de m&ecirc;me que les cases sp&eacute;cifiques concern&eacute;es. Enfin dans les cases sp&eacute;cifiques, le haut-r&ecirc;vant peut apprendre la force du r&ecirc;ve ou de la magie en cours, c&rsquo;est-&agrave;-dire pratiquement la difficult&eacute; et le nombre de points de r&ecirc;ve impliqu&eacute;s, information indispensable dans l&rsquo;optique d&rsquo;une annulation de magie.</p>\n<p>Lecture d&rsquo;Aura r&eacute;v&egrave;le &eacute;galement la couleur de l&rsquo;aura (fixe ou pulsative) comme D&eacute;tection d&rsquo;Aura. Pour les cr&eacute;atures vivantes, on peut donc sauter l&rsquo;&eacute;tape de D&eacute;tection d&rsquo;Aura et commencer directement par la lecture, puisqu&rsquo;on est s&ucirc;r de trouver une aura. Dans les autres cas, il est plus prudent de commencer par la d&eacute;tection si, en l&rsquo;absence finale d&rsquo;une aura, on ne veut pas cr&eacute;er de magie impossible. Effectu&eacute;e sur une cr&eacute;ature non soumise &agrave; un effet magique ni sous l&rsquo;emprise d&rsquo;une entit&eacute;, Lecture d&rsquo;Aura indique toujours le Fleuve. L&agrave;, dans n&rsquo;importe quelle case du Fleuve, le haut-r&ecirc;vant se contente d&rsquo;apprendre qu&rsquo;il a affaire &agrave; une cr&eacute;ature vivante et dou&eacute;e de r&ecirc;ve.</p>","descriptionmj":"","draconic":"Voie de Narcos","duree":"Instantanée","JR":"Aucun","cible":"","difficulte":"-3","portée":"","caseTMR":"special","caseTMRspeciale":"Sanctuaire / variable","ptreve":"3","xp":0,"bonuscase":"","isrituel":true,"coutseuil":0,"portee":""},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.4.3","coreVersion":"10.291","createdTime":1667259638600,"modifiedTime":1672364101034,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"_id":"QvAyeJIIEssOhJoV","folder":null,"sort":0,"ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3}}
 {"_id":"SUrdOuvvelLtiZMy","name":"Écailles de Protection contre les projectiles *","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-narcos.SUrdOuvvelLtiZMy"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_narcos.webp","effects":[],"system":{"description":"<p>Chaque écaille de protection diminue de 1 point le jet d'encaissement de tout dommage dû à un projectile, flèche, carreau, pierre de fronde, dague, javelot, fouet. La protection de l'amulette est <em>en plus </em>de l'armure véritable du personnage. Soit un personnage vêtu de cuir épais (prot. 3), possédant une amulette de 3 écailles, et recevant une flèche (+dom +2). Face à une flèche, le cuir épais ne vaut plus que 1, mais on y rajoute les 3 écailles de l'amulette, pour un jet d'encaissement final de -2 au lieu de +1.</p>\n<p>Une amulette peut avoir n'importe quelle forme, mais ne fonctionne que si elle est en contact avec la peau nue de son possesseur. Si c'est le cas, elle fonctionne spontanément en face du danger pour lequel elle est conçue, même si le possesseur n'a aucune idée de son pouvoir. Pour fonctionner, l'amulette a besoin de points de rêve actifs. Ces points doivent être des points de rêve conférés par le rituel d'Enchantement en plus des points inertes. Autrement dit, voulant fabriquer une amulette, le haut-rêvant ne s'arrête pas d'enchanter quand il atteint un nombre de points de rêve égal à l'inertie totale de l'objet, mais continue à en rajouter. Le nombre maximum de points actifs qu'une amulette puisse posséder est égal à 7 fois l'enchantabilité de sa gemme ; et, comme pour les écailles d'efficacité, le nombre d'écailles de protection qu'elle puisse posséder est égal à l'enchantabilité de celle-ci avec un maximum de 7. Des amulettes plus puissantes ne pourraient être obtenues que par de spécifiques Grandes Écailles de Narcos.</p>\n<p><em>Soit une gemme de taille 6 et de pureté 5, ayant donc une inertie de 2 et une enchantabilité de 4. Elle peut posséder jusqu'à 4 écailles de protection (=enchantabilité) et un maximum de 28 points de rêve actifs (7&nbsp; &nbsp;x 4 = 28).</em></p>\n<p>Chaque fois qu'une amulette de protection fonctionne, elle dépense un de ses points de rêve actifs quel que soit le nombre d'écailles. Le possesseur, lui, n'en dépense qu'un par heure, quel que soit le nombre de fonctionnements de l'amulette au cours de cette heure. Quand une amulette n'a plus de points actifs, elle cesse de fonctionner. On ne peut lui en redonner que par le rituel de Restauration. Les écailles de protection peuvent être posées progressivement, comme celles d'efficacité, même si l'amulette fonctionne entre temps. Mêmes règles d'application. Une gemme donnée ne peut recevoir que des écailles de protection d'un même type, mais grâce à Individualité, plusieurs gemmes d'une même amulette peuvent offrir des protections différentes. La pose de chaque écaille de protection coûte un point de seuil.</p>\n<p>&nbsp;</p>","descriptionmj":"","draconic":"Voie de Narcos","duree":"Instantanée","JR":"Aucun","cible":"","difficulte":"-8","portée":"","caseTMR":"gouffre","caseTMRspeciale":"","ptreve":"6","xp":0,"bonuscase":"","isrituel":true,"coutseuil":1,"portee":""},"ownership":{"default":0,"6ibmdmaeRSMTjU4c":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.32","coreVersion":"10.288","createdTime":1667259638599,"modifiedTime":1667260043442,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
 {"_id":"TSDY6o00ri2ktlVM","name":"Puits de rêve *","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-narcos.TSDY6o00ri2ktlVM"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_narcos.webp","effects":[],"system":{"description":"<p>Le Puits de rêve permet de stocker des points de rêve et de les y puiser à volonté, c'est en quelque sorte une tirelire de points de rêve. Le Puits de rêve peut avoir la forme de n'importe quel objet et même se contenter d'être une gemme seule. Pour y stocker des points de rêve, l'utilisateur doit le tenir dans sa main nue et se concentrer pendant un round. Il perd autant de points de rêve que souhaité, points qui sont instantanément transvasés dans le Puits de rêve. Aucune montée en TMR ni jets de dés ne sont nécessaires. Pareillement, pour puiser des points de rêve dans le Puits, il suffit de le tenir dans sa main nue au moment de lancer un sort. Au lieu de dépenser ses propres points, l'utilisateur les puise dans le Puits de rêve. Les points puisés ne peuvent avoir qu'un seul usage : alimenter un sort, lancé naturellement ou via une écaille d'activité, ou alimenter un rituel. Rien d'autre. Il ne peuvent pas servir à payer un coût de maîtrise ni un coût d'objet efficace, ni un coût d'amulette de protection. La dépense de points de rêve doit provenir intégralement de l'une ou l'autre source, utilisateur ou Puits de rêve, on ne peut pas partager. On ne peut pas non plus les récupérer pour les \"remettre dans sa tête\".</p>\n<p>La gemme destinée à recevoir un Puits de rêve n'a pas besoin de points actifs ; si elle en a lors de l'accomplissement de Permanence, ils sont purement et simplement ignorés (annulés). La gemme peut recevoir autant de Grandes Écailles de Puits de rêve que son enchantibilité jusqu'à un maximum de 7. Chaque Grande Écaille permet de stocker jusqu'à 7 points de rêve. <em>Soit une gemme d'enchantabilité 6 possédant 6 Grandes Écailles de Puits de rêve, on peut y stocker jusqu'à 42 points de rêve.</em> Un Puits de rêve n'a jamais besoin d'être entièrement plein et peut pareillement rester vide sans en souffrir. Face à une grosse dépense, on peut le vider entièrement d'un seul coup.</p>\n<p>Un Puits de rêve peut être posé (avec Individualité) sur une seconde gemme d'un objet possédant une écaille d'activité. Lors de l'utilisation de l'objet, les points de rêve de coût de sort pourront être dépensés par le Puits de rêve ou par l'utilisateur au choix de ce dernier. Un Puits de rêve changeant de main doit être maîtrisé selon la règle normale. La maîtrise a lieu soit au moment où l'on stocke, soit où l'on puise, le premier des deux, et coûte 1 point de rêve par Grande Écaille. <em>Note&nbsp;</em> : les points dépensés pour la maîtrise ne <em>vont pas</em> dans le Puis de rêve, sils ont perdus.</p>","descriptionmj":"","draconic":"Voie de Narcos","duree":"Instantanée","JR":"Aucun","cible":"","difficulte":"-8","portée":"","caseTMR":"lac","caseTMRspeciale":"","ptreve":"8","xp":0,"bonuscase":"","isrituel":true,"coutseuil":1,"portee":""},"ownership":{"default":0,"6ibmdmaeRSMTjU4c":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.32","coreVersion":"10.288","createdTime":1667259638599,"modifiedTime":1667260043444,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
 {"_id":"TjhnUMh6UL04k0k8","name":"Purification","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-narcos.TjhnUMh6UL04k0k8"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_narcos.webp","effects":[],"system":{"description":"<p>Purification est un rituel secondaire, mais néanmoins obligatoire. A moins de disposer d'une énorme quantité de points de rêve, il est vain d'espérer enchanter l'objet en une seule fois. Purifcation doit toujours s'intercaler entre deux rituels identiques : entre deux Enchantements, mais également entre deux écailles, d'activité ou de protection. Sauter cette étape aboutit à un cas de <em>magie impossible</em>.</p>","descriptionmj":"","draconic":"Voie de Narcos","duree":"Instantanée","JR":"Aucun","cible":"","difficulte":"-4","portée":"","caseTMR":"necropole","caseTMRspeciale":"","ptreve":"4","xp":0,"bonuscase":"","isrituel":true,"coutseuil":0,"portee":""},"ownership":{"default":0,"6ibmdmaeRSMTjU4c":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.32","coreVersion":"10.288","createdTime":1667259638599,"modifiedTime":1667260043444,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}

packs/sorts-thanatos.db

@@ -2,10 +2,10 @@
 {"_id":"3SUbeB9OBaxbRwwy","name":"Dague de meurtre","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-thanatos.3SUbeB9OBaxbRwwy"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_thanatos.webp","effects":[],"system":{"description":"<p>Ayant élaboré une dague magique au moyen des rituels normaux de la voie de Narcos, le haut-rêvant peut y poser la Grande Griffe de Thanatos <em>Dague de meurtre</em>. Lors du lancer, le haut-rêvant doit paramétrer le nom d'une victime précise ou d'un type de victime, par exemple : <em>Uhn Telh</em> (nom d'un personnage unique), <em>le roi de Parissy</em> (n'importe quel personnage occupant successivement cette fonction), <em>une fille blonde</em> (toute personne correspondant à cette description). La dague peut être normale hormis la Grande Griffe, ou avoir reçu en outre des écailles d'efficacité de Narcos. Ceci fait, le haut-rêvant de Thanatos n'a plus qu'à s'arranger pour que la dague se trouve un nouveau propriétaire.</p>\n<p>Le seul fait de toucher à la dague, même à travers un gant ou une étoffe, déclenche le pouvoir de la Dague de meutre. La maîtrise de la Grande Griffe opère, coûtant 1 point de rêve au personnage (coût d'une écaille), qui doit aussi jouer un JR standard r-8. JR réussi, le personnage n'est pas affecté et peut utiliser la dague à son gré ; JR échoué, le personnage est atteint de l'équivalent d'un envoûtement de Tâche, et doit accomplir le meutre paramétré dans les plus brefs délais. Parallèlement, le personnage fait tout pour protéger la dague dont il se croit le possesseur (alors que c'est l'inverse). Dès que le meutre est accompli, le meurtrier joue un second JR r-8. Réussi, il laisse tomber la dague et s'en détourne horrifié ; échoué, il la retourne contre son propre sein et se suicide. Cela dit,&nbsp; et dans le cas où la victime paramétrée n'est pas une personne unique, la dague est prête à se trouver une nouvelle main pour continuer son oeuvre de mort.</p>","descriptionmj":"","draconic":"Voie de Thanatos","duree":"Permanente","JR":"r-8","cible":"","difficulte":"-13","portée":"","caseTMR":"desolation","caseTMRspeciale":"Désolation de Sel G9","ptreve":"13","xp":0,"bonuscase":"","isrituel":true,"coutseuil":2,"portee":""},"folder":null,"sort":0,"ownership":{"default":0},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.32","coreVersion":"10.288","createdTime":1667259843440,"modifiedTime":1667260048926,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
 {"_id":"5U7KXTsxph9wmbXH","name":"Invocation des entités de cauchemar non incarnées","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-thanatos.5U7KXTsxph9wmbXH"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_thanatos.webp","effects":[],"system":{"description":"<p>INVOCATION D'UN DÉSESPOIR (Désolation) R-7 r7</p>\n<p>INVOCATION D'UNE HAINE (Marais) R-7 r7</p>\n<p>INVOCATION D'UNE PEUR (Gouffre) R-7 r7</p>\n<p>Ayant ciblé l'effet de son rituel sur un objet entièrement noir, le haut-rêvant de Thanatos invoque une entité de cauchemar non incarnée (ECNI) à se présenter devant lui. L'entité n'est pas créée magiquement, le rituel ne fait qu'appeler l'entité l aplus proche, qui se met aussitôt en route pour se présenter devant le haut-rêvant. Si, par rapport au scénario, on sait où se trouve l'entité la plus proche, il suffit de calculer le temps mis pour venir, sachant qu'elle parcourt 6 m par round. Dans le cas contraire, on la suppose arriver au bout de 1d7 heures. Sur son chemin vers le haut-rêvant, elle n'attaque personne, même si on lui barre le chemin, elle se contente de passer. Puis, dès qu'elle se retrouve en présence de son invocateur, elle l'attaque, cherchant à le posséder. Si ce dernier la combat par Thanatos et sort vainqueur, il peut alors la contrôler. A moins qu'on ne sache spécifiquement le nombre de points de rêve de l'entité la plus proche, les entités invoquées peuvent avoir de 4 à 24 points de rêve (4d6).</p>\n<p>&nbsp;</p>","descriptionmj":"","draconic":"Voie de Thanatos","duree":"Spéciale","JR":"Aucun","cible":"Un objet noir","difficulte":"","portée":"","caseTMR":"special","caseTMRspeciale":"","ptreve":"","xp":0,"bonuscase":"","isrituel":true,"coutseuil":0,"portee":""},"ownership":{"default":0,"6ibmdmaeRSMTjU4c":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.32","coreVersion":"10.288","createdTime":1667259843440,"modifiedTime":1667260048927,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
 {"_id":"8hCVBWM48GNb8e6P","name":"Faire parler un crâne","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-thanatos.8hCVBWM48GNb8e6P"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_thanatos.webp","effects":[],"system":{"description":"<p>Ce rituel permet de faire parler un crâne d'humanoïde. Le haut-rêvant de Thanatos doit le toucher et lui poser des questions, le crâne ne répondant qu'aux questions posées. Il peut parler de tout ce dont il a été témoin, aussi bien durant sa vie que depuis qu'il est mort, c'est-à-dire de ce dont, en tant qu'objet abandonné quelque part, il a pu être témoin. La durée de communication est de 1 round par point de rêve dépensé.</p>","descriptionmj":"","draconic":"Voie de Thanatos","duree":"Selon r dépensé","JR":"Aucun","cible":"Un crâne","difficulte":"-6","portée":"","caseTMR":"desert","caseTMRspeciale":"","ptreve":"1+","xp":0,"bonuscase":"","isrituel":true,"coutseuil":0,"portee":""},"ownership":{"default":0,"6ibmdmaeRSMTjU4c":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.32","coreVersion":"10.288","createdTime":1667259843440,"modifiedTime":1667260048926,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"name":"Lecture d'aura","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-narcos.Y4r9kTN2brWC2N0n"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_vigilance.webp","effects":[],"system":{"description":"<p>Les rituels de Lecture d&rsquo;Aura peuvent indiff&eacute;remment &ecirc;tre accomplis par n&rsquo;importe laquelle des quatre voies.</p>\n<p>Ce rituel permet d&rsquo;approfondir les informations fournies par D&eacute;tection d&rsquo;Aura. Pratiquer Lecture d&rsquo;Aura quand il n&rsquo;y a pas d&rsquo;aura revient &agrave; demander une magie impossible et cr&eacute;e imm&eacute;diatement une d&eacute;chirure du r&ecirc;ve.</p>\n<p>Lecture d&rsquo;Aura est effectu&eacute;e en plusieurs &eacute;tapes, toutes &eacute;tant de difficult&eacute; R-3 et co&ucirc;tant 3 points de r&ecirc;ve. La premi&egrave;re a toujours lieu dans un sanctuaire et ne fait que r&eacute;v&eacute;ler dans quel(s) autre(s) genre(s) de case(s) le haut-r&ecirc;vant doit se rendre pour continuer sa lecture. L&agrave;, il apprend quel genre de magie a &eacute;t&eacute; produit ou &agrave; quel type de r&ecirc;ve il a affaire, de m&ecirc;me que les cases sp&eacute;cifiques concern&eacute;es. Enfin dans les cases sp&eacute;cifiques, le haut-r&ecirc;vant peut apprendre la force du r&ecirc;ve ou de la magie en cours, c&rsquo;est-&agrave;-dire pratiquement la difficult&eacute; et le nombre de points de r&ecirc;ve impliqu&eacute;s, information indispensable dans l&rsquo;optique d&rsquo;une annulation de magie.</p>\n<p>Lecture d&rsquo;Aura r&eacute;v&egrave;le &eacute;galement la couleur de l&rsquo;aura (fixe ou pulsative) comme D&eacute;tection d&rsquo;Aura. Pour les cr&eacute;atures vivantes, on peut donc sauter l&rsquo;&eacute;tape de D&eacute;tection d&rsquo;Aura et commencer directement par la lecture, puisqu&rsquo;on est s&ucirc;r de trouver une aura. Dans les autres cas, il est plus prudent de commencer par la d&eacute;tection si, en l&rsquo;absence finale d&rsquo;une aura, on ne veut pas cr&eacute;er de magie impossible. Effectu&eacute;e sur une cr&eacute;ature non soumise &agrave; un effet magique ni sous l&rsquo;emprise d&rsquo;une entit&eacute;, Lecture d&rsquo;Aura indique toujours le Fleuve. L&agrave;, dans n&rsquo;importe quelle case du Fleuve, le haut-r&ecirc;vant se contente d&rsquo;apprendre qu&rsquo;il a affaire &agrave; une cr&eacute;ature vivante et dou&eacute;e de r&ecirc;ve.</p>","descriptionmj":"","draconic":"Voie de Thanatos","duree":"Instantanée","JR":"Aucun","cible":"","difficulte":"-3","portée":"","caseTMR":"special","caseTMRspeciale":"Sanctuaire / variable","ptreve":"3","xp":0,"bonuscase":"","isrituel":false,"coutseuil":0,"portee":""},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.32","coreVersion":"10.288","createdTime":1667259638600,"modifiedTime":1667260048927,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"_id":"AYmxbu3HzeNU9l2A","folder":null,"sort":0,"ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3}}
+{"name":"Lecture d'aura","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-narcos.Y4r9kTN2brWC2N0n"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_vigilance.webp","effects":[],"system":{"description":"<p>Les rituels de Lecture d&rsquo;Aura peuvent indiff&eacute;remment &ecirc;tre accomplis par n&rsquo;importe laquelle des quatre voies.</p>\n<p>Ce rituel permet d&rsquo;approfondir les informations fournies par D&eacute;tection d&rsquo;Aura. Pratiquer Lecture d&rsquo;Aura quand il n&rsquo;y a pas d&rsquo;aura revient &agrave; demander une magie impossible et cr&eacute;e imm&eacute;diatement une d&eacute;chirure du r&ecirc;ve.</p>\n<p>Lecture d&rsquo;Aura est effectu&eacute;e en plusieurs &eacute;tapes, toutes &eacute;tant de difficult&eacute; R-3 et co&ucirc;tant 3 points de r&ecirc;ve. La premi&egrave;re a toujours lieu dans un sanctuaire et ne fait que r&eacute;v&eacute;ler dans quel(s) autre(s) genre(s) de case(s) le haut-r&ecirc;vant doit se rendre pour continuer sa lecture. L&agrave;, il apprend quel genre de magie a &eacute;t&eacute; produit ou &agrave; quel type de r&ecirc;ve il a affaire, de m&ecirc;me que les cases sp&eacute;cifiques concern&eacute;es. Enfin dans les cases sp&eacute;cifiques, le haut-r&ecirc;vant peut apprendre la force du r&ecirc;ve ou de la magie en cours, c&rsquo;est-&agrave;-dire pratiquement la difficult&eacute; et le nombre de points de r&ecirc;ve impliqu&eacute;s, information indispensable dans l&rsquo;optique d&rsquo;une annulation de magie.</p>\n<p>Lecture d&rsquo;Aura r&eacute;v&egrave;le &eacute;galement la couleur de l&rsquo;aura (fixe ou pulsative) comme D&eacute;tection d&rsquo;Aura. Pour les cr&eacute;atures vivantes, on peut donc sauter l&rsquo;&eacute;tape de D&eacute;tection d&rsquo;Aura et commencer directement par la lecture, puisqu&rsquo;on est s&ucirc;r de trouver une aura. Dans les autres cas, il est plus prudent de commencer par la d&eacute;tection si, en l&rsquo;absence finale d&rsquo;une aura, on ne veut pas cr&eacute;er de magie impossible. Effectu&eacute;e sur une cr&eacute;ature non soumise &agrave; un effet magique ni sous l&rsquo;emprise d&rsquo;une entit&eacute;, Lecture d&rsquo;Aura indique toujours le Fleuve. L&agrave;, dans n&rsquo;importe quelle case du Fleuve, le haut-r&ecirc;vant se contente d&rsquo;apprendre qu&rsquo;il a affaire &agrave; une cr&eacute;ature vivante et dou&eacute;e de r&ecirc;ve.</p>","descriptionmj":"","draconic":"Voie de Thanatos","duree":"Instantanée","JR":"Aucun","cible":"","difficulte":"-3","portée":"","caseTMR":"special","caseTMRspeciale":"Sanctuaire / variable","ptreve":"3","xp":0,"bonuscase":"","isrituel":true,"coutseuil":0,"portee":""},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.4.3","coreVersion":"10.291","createdTime":1667259638600,"modifiedTime":1672364213966,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"_id":"AYmxbu3HzeNU9l2A","folder":null,"sort":0,"ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3}}
 {"_id":"B7gtpMz81LZIv450","name":"Maladie","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-thanatos.B7gtpMz81LZIv450"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_thanatos.webp","effects":[],"system":{"description":"<p>Quand la victime est entièrement possédée de corps, le haut-rêvant de Thanatos peut commencer l'envoûtement de Maladie. Chaque ensemble de 5 points de rêve dépensés (5r), fait perdre 1 point de vie à la victime. Dès qu'elle dépasse son seuil négatif, elle meurt. La maladie semble être une maladie de langueur, une inexplicable faiblesse. Aucune médecine, aucune herbe ne parvient à la soigner, pas même une potion enchantée. Annuler la possession brise en même temps l'envoûtement de Maladie, et la victime recouvre instantanément tous ses points de vie.</p>","descriptionmj":"","draconic":"Voie de Thanatos","duree":"Illimitée","JR":"Aucun","cible":"Relique","difficulte":"-11","portée":"","caseTMR":"desolation","caseTMRspeciale":"","ptreve":"5+","xp":0,"bonuscase":"","isrituel":false,"coutseuil":0,"portee":""},"ownership":{"default":0,"6ibmdmaeRSMTjU4c":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.32","coreVersion":"10.288","createdTime":1667259843440,"modifiedTime":1667260048927,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
 {"_id":"ChIxJ7jOvpJgctMz","name":"Interdiction","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-thanatos.ChIxJ7jOvpJgctMz"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_thanatos.webp","effects":[],"system":{"description":"<p>Quand la victime est entièrement possédée d'esprit, le haut-rêvant de Thanatos peut lancer sur elle un interdit, et la victime ne pourra en aucun cas contrevenir à cette interdiction. Cette dernière doit pouvoir être obéie par la VOLONTÉ normale de la victime : l'interdiction de vivre ou de respirer est impossible. L'interdiction doit être formulée très exactement ; en cas de doute sur son interprétation, c'est au gardien des rêves de statuer. L'interdiction ne peut comporter qu'un seul verbe, à l'impératif, et par définition à la forme négative :<em> ne fais pas</em>. Il ne peut comporter qu'un seul complément d'objet direct ou indirect, et ce dernier ne prut avoir qu'un seul qualificatif ou autre complément. <em>Exemples : n'ouvre pas les yeux, ne prend pas tes armes, ne parle à personne, ne touche pas à la pierre noire, ne préviens pas les gardes du palais, etc.</em> La contrainte de l'interdiction dure jusqu'à la fin de l'heure de naissnace de la vitime. Le haut-rêvant peut renouveler l'interdiction de jour en jour ou en apporter une nouvelle, mais ne peut pas en faire coexister deux simultanément. Annuler la possession brise en même temps l'envoûtement d'Interdiction, et la victime recouvre instantanément toute sa liberté.</p>","descriptionmj":"","draconic":"Voie de Thanatos","duree":"HN de la victime","JR":"Aucun","cible":"Relique","difficulte":"-7","portée":"","caseTMR":"desert","caseTMRspeciale":"","ptreve":"7","xp":0,"bonuscase":"","isrituel":false,"coutseuil":0,"portee":""},"ownership":{"default":0,"6ibmdmaeRSMTjU4c":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.32","coreVersion":"10.288","createdTime":1667259843440,"modifiedTime":1667260048927,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"name":"Détection d'aura","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-narcos.xOicgRMCUxJNmVzF"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_vigilance.webp","effects":[],"system":{"description":"<p>Les rituels de D&eacute;tection d&rsquo;Aura peuvent indiff&eacute;remment &ecirc;tre accomplis par n&rsquo;importe laquelle des quatre voies.</p>\n<p>Toutes les cr&eacute;atures vivantes anim&eacute;es (humains, humano&iuml;des, animaux) ont une caract&eacute;ristique R&Ecirc;VE. Les objets enchant&eacute;s poss&egrave;dent des points de r&ecirc;ve, de m&ecirc;me que les produits de magie naturelle, comme certaines pierres de chance. Les entit&eacute;s de cauchemar, incarn&eacute;es ou non, en ont &eacute;galement. Quelle qu&rsquo;elle soit, la pr&eacute;sence de r&ecirc;ve &eacute;met une aura, laquelle est d&eacute;tectable par D&eacute;tection d&rsquo;Aura. Parall&egrave;lement, toute cible d&rsquo;un sort ou d&rsquo;un rituel, &eacute;met une aura propre, quand bien m&ecirc;me ladite cible ne poss&egrave;de pas de points de r&ecirc;ve (centre de zone, objet ou plante soumis &agrave; une illusion d&rsquo;Hypnos). Cette aura est &eacute;galement d&eacute;tectable par D&eacute;tection d&rsquo;Aura.</p>\n<p>L&rsquo;aura de pr&eacute;sence de r&ecirc;ve se traduit par un halo bleut&eacute; constant ; l&rsquo;aura r&eacute;sultant d&rsquo;un effet magique par un halo parcouru de pulsations. Quand les deux auras sont pr&eacute;sentes conjointement, le halo est pulsatif et d&rsquo;un bleu plus fonc&eacute;. On peut toujours effectuer D&eacute;tection d&rsquo;Aura sans aucun risque, il y a toujours une r&eacute;ponse. Soit une aura est per&ccedil;ue, constante ou pulsative, et l&rsquo;on peut tenter une Lecture d&rsquo;Aura pour en savoir plus ; soit aucune aura n&rsquo;est per&ccedil;ue et il s&rsquo;agit de mati&egrave;re inerte, sans r&ecirc;ve, non soumise &agrave; un sort.</p>","descriptionmj":"","draconic":"Voie de Thanatos","duree":"Instantanée","JR":"Aucun","cible":"","difficulte":"-3","portée":"","caseTMR":"sanctuaire","caseTMRspeciale":"","ptreve":"1","xp":0,"bonuscase":"","isrituel":false,"coutseuil":0,"portee":""},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.32","coreVersion":"10.288","createdTime":1667259638601,"modifiedTime":1667260048926,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"_id":"GHsNBFq6uFOzAwK5","folder":null,"sort":0,"ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3}}
+{"name":"Détection d'aura","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-narcos.xOicgRMCUxJNmVzF"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_vigilance.webp","effects":[],"system":{"description":"<p>Les rituels de D&eacute;tection d&rsquo;Aura peuvent indiff&eacute;remment &ecirc;tre accomplis par n&rsquo;importe laquelle des quatre voies.</p>\n<p>Toutes les cr&eacute;atures vivantes anim&eacute;es (humains, humano&iuml;des, animaux) ont une caract&eacute;ristique R&Ecirc;VE. Les objets enchant&eacute;s poss&egrave;dent des points de r&ecirc;ve, de m&ecirc;me que les produits de magie naturelle, comme certaines pierres de chance. Les entit&eacute;s de cauchemar, incarn&eacute;es ou non, en ont &eacute;galement. Quelle qu&rsquo;elle soit, la pr&eacute;sence de r&ecirc;ve &eacute;met une aura, laquelle est d&eacute;tectable par D&eacute;tection d&rsquo;Aura. Parall&egrave;lement, toute cible d&rsquo;un sort ou d&rsquo;un rituel, &eacute;met une aura propre, quand bien m&ecirc;me ladite cible ne poss&egrave;de pas de points de r&ecirc;ve (centre de zone, objet ou plante soumis &agrave; une illusion d&rsquo;Hypnos). Cette aura est &eacute;galement d&eacute;tectable par D&eacute;tection d&rsquo;Aura.</p>\n<p>L&rsquo;aura de pr&eacute;sence de r&ecirc;ve se traduit par un halo bleut&eacute; constant ; l&rsquo;aura r&eacute;sultant d&rsquo;un effet magique par un halo parcouru de pulsations. Quand les deux auras sont pr&eacute;sentes conjointement, le halo est pulsatif et d&rsquo;un bleu plus fonc&eacute;. On peut toujours effectuer D&eacute;tection d&rsquo;Aura sans aucun risque, il y a toujours une r&eacute;ponse. Soit une aura est per&ccedil;ue, constante ou pulsative, et l&rsquo;on peut tenter une Lecture d&rsquo;Aura pour en savoir plus ; soit aucune aura n&rsquo;est per&ccedil;ue et il s&rsquo;agit de mati&egrave;re inerte, sans r&ecirc;ve, non soumise &agrave; un sort.</p>","descriptionmj":"","draconic":"Voie de Thanatos","duree":"Instantanée","JR":"Aucun","cible":"","difficulte":"-3","portée":"","caseTMR":"sanctuaire","caseTMRspeciale":"","ptreve":"1","xp":0,"bonuscase":"","isrituel":true,"coutseuil":0,"portee":""},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.4.3","coreVersion":"10.291","createdTime":1667259638601,"modifiedTime":1672364217190,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"_id":"GHsNBFq6uFOzAwK5","folder":null,"sort":0,"ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3}}
 {"_id":"H4K9R6zq7nyC9Qkf","name":"Cauchemar","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-thanatos.H4K9R6zq7nyC9Qkf"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_thanatos.webp","effects":[],"system":{"description":"<p>Quand la victime est entièrement possédée d'esprit, le haut-rêvant de Thanataos peut peupler de cauchemars ses rêves accomplis dans les Basses Terres du Rêve. Les cauchemars durent depuis le moment où est lancé le sort d'envoûtement jusqu'à l'heure du Châteu Dormant. Le sommeil de la victime en est à tel point empoisonné qu'elle ne récupère qu'une case de fatigue par heure au lieu d'un segment. Si la règle du Moral est utilisée, la victime en perd automatiquement 2 points au réveil au lieu de jouer normalement le jet de Moral journalier. Si elle est déjà à -3, elle prend 2 points de dissolution. Annuler la possession brise en même temps l'envoûtement de Cauchemar, et la victime recouvre instantanément son sommeil normal.</p>","descriptionmj":"","draconic":"Voie de Thanatos","duree":"Fin de la nuit en cours","JR":"Aucun","cible":"Relique","difficulte":"-5","portée":"","caseTMR":"monts","caseTMRspeciale":"","ptreve":"5","xp":0,"bonuscase":"","isrituel":false,"coutseuil":0,"portee":""},"ownership":{"default":0,"6ibmdmaeRSMTjU4c":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.32","coreVersion":"10.288","createdTime":1667259843441,"modifiedTime":1667260048926,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
 {"_id":"IfVWI1LIk2PcT89J","name":"Autométamorphose en bête","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-thanatos.IfVWI1LIk2PcT89J"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_thanatos.webp","effects":[],"system":{"description":"<p>Par l'usage de ce sort, le haut-rêvant de Thanatos se transforme lui-même en l'animal de son choix. La métamorphose est instantanée, et correspond dans son résultat à une métamorphose de corps uniquement, et non d'esprit. Le haut-rêvant&nbsp; peut choisir n'importe quelle forme animale d'une TAILLE maximale égale à la sienne, et minimale de 1 (souris). Seul son corps est affecté, pas ses vêtements ni son équipement. Il peut continuer à monter en TMR et lancer des sorts sous cette forme.</p>\n<p>Ses caractéristiques physiques deviennent celles de l'animal choisi, c'est à dire TAILLE, CONSTITUTION, FORCE, PERCEPTION. Les seules qu'il conserve sont INTELLECT, VOLONTÉ, RÊVE. Son Endurance et ses points de vie sont calculés d'après les caractéristiques de l'animal et selon les règles de cacul de ces dernières (Endurance = Vie + CONSTITUTION). Les notions d'Apparence et de Chance disparaissent. Dextérite et Agilité (ou leur équivalent) sont directement inclues dans les compétences de l'animal. Le haut-rêvant n'acquiert que les caractéristiques physiques de l'animal, pas ses caractéristiques spéciales ou magiques. Ainsi un haut-rêvant de Thanatos métamorphosé en sirène, ne pourra pas obtenir les illusions dont ces créatures sont capables, ni d'avoir un chant irrésistible. Transformé en oiseau-oracle, il pourra toujours parler, mais son discours ne reflétera pas automatiquement la vérité. Pour déterminer les caractéristiques physiques des animaux, se fonder sur les modèles présentés dans le Livre III.</p>\n<p>La caractéristique VOLONTÉ reste la sienne. Mais toutes les heures d'autométamorphose et chaque fois que survient un incident pouvant faire réagir l'instinct de l'animal (proie ou prédateur, partenaire de l'autre sexe, etc), tirer un jet de VOLONTÉ à zéro.</p>\n<p><em>Toute réussite. </em>Le haut-rêvant garde ou reprend le contrôle de l'animal et à la prochaine occasion, le jet de VOLONTÉ sera à nouveau à zéro.</p>\n<p>Echec et Ech.P. L'instinct de l'animal l'emporte et la VOLONTÉ du haut-rêvant s'obscurcit. En termes de jeu, l'animal passe sous le contrôle du gardien des rêves pour la durée du round. Au round suivant, rejouer VOLONTÉ à -1, et ainsi de suite de round en round, avec des ajustements cumulatifs de -1 jusqu'à la réussite ou l'échec total.</p>\n<p>Ech.T. La VOLONTÉ du haut-rêvant est définitivement annihilée. A partir de cet instant, l'animal passe entièrement sous le contrôle du gardien des rêves jusqu'à la fin de la durée de l'autométamorphose. Redevenu humain, le haut-rêvant de Thanatos n'a aucun souvenir de ce qu'il a vécu sous forme animale. Qui plus est, son esprit est toujours celui de l'animal, exactement comme s'il était envoûté de métamorphose d'esprit. Il doit alors jouer un jet de VOLONTÉ toutes les heures. Le premier jet à une difficulté de zéro, mais chaque nouvel échec s'incrémente d'un maus de -1. Dès qu'une réussite survient, le haut-rêvant recouvre son mental. Dès qu'un échec total survient, son esprit est définitivement animal, comme s'il avait été envoûté et métamorphosé d'esprit. Seule une Annulation de Magie accomplie par un tiers pourra le délivrer.</p>\n<p>Les points de vie perdus et les blessures sont conservés dans les deux sens, c'est-à-dire au passage de l'humain à l'animal et inversement. Lors du passage à l'état animal, soustraire les points d'endurance dus aux blessures existantes sur l'humain en retirant les jets comme si ces blessures venaient tout juste d'être reçues. Les blessures elles-mêmes figureront sur l'animal. Lors du retour à l'humain, l'endurance est celles qu'il restait à l'animal (jusqu'à concurrence de l'endurance de l'humain), de même que ses éventuelles blessures.</p>","descriptionmj":"","draconic":"Voie de Thanatos","duree":"HN","JR":"Aucun","cible":"Soi-même","difficulte":"-7","portée":"","caseTMR":"foret","caseTMRspeciale":"","ptreve":"7","xp":0,"bonuscase":"","isrituel":false,"coutseuil":0,"portee":""},"ownership":{"default":0,"6ibmdmaeRSMTjU4c":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.32","coreVersion":"10.288","createdTime":1667259843441,"modifiedTime":1667260048926,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
 {"_id":"Ix0zKfupAloZoUCK","name":"Faire parler un mort","type":"sort","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.sorts-thanatos.Ix0zKfupAloZoUCK"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_thanatos.webp","effects":[],"system":{"description":"<p>Ce rituel permet de faire parler un cadavre dont il reste au moins la tête, peu importe son degré de décomposition. Le haut-rêvant de Thanatos doit le toucher et lui poser des questions, le mort ne répondant qu'aux questions posées. Les seuls souvenirs qu'il peut communiquer sont ceux de la dernière heure de sa vie. La durée de la communication est de 1 round par point de rêve dépensé.</p>","descriptionmj":"","draconic":"Voie de Thanatos","duree":"Selon r dépensé","JR":"Aucun","cible":"Un cadavre","difficulte":"-4","portée":"","caseTMR":"pont","caseTMRspeciale":"","ptreve":"1+","xp":0,"bonuscase":"","isrituel":true,"coutseuil":0,"portee":""},"ownership":{"default":0,"6ibmdmaeRSMTjU4c":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.32","coreVersion":"10.288","createdTime":1667259843441,"modifiedTime":1667260048926,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}

styles/simple.css

@@ -599,7 +599,7 @@ input:is(.blessure-premiers_soins, .blessure-soins_complets) {
 .editor {
   border: 2;
   height: fit-content;
-  min-height: 8rem;
+  min-height: 5rem;
   padding: 0 3px;
 }
 
@@ -611,7 +611,7 @@ input:is(.blessure-premiers_soins, .blessure-soins_complets) {
 
 .small-editor {
   border: 2;
-  min-height: 4rem;
+  min-height: 2rem;
   padding: 0 3px;
 }
 
@@ -771,11 +771,41 @@ div.placeholder-resolution span.table-proba-reussite{
     input[type="date"],
     input[type="time"]) {
   color: rgba(255, 255, 255, 0.75);
-  background: rgba(255, 255, 255, 0.05);
+  background: rgba(255, 255, 255, 0.1);
   border: 0 none;
   margin-bottom: 0.2rem;
 }
 
+input[type="number"] {
+  text-align: right;
+  padding-right: 0.5rem;
+  max-width: 7rem;
+}
+
+select:is(.number-x,.number-x2,.number-x3,.number-x4,.number-x5) {
+  padding-right: 0.2rem;
+  text-align: center;
+}
+input:is(.number,.number-x,.number-x2,.number-x3,.number-x4,.number-x5) {
+  padding-right: 0.2rem;
+  text-align: right;
+}
+:is(input,select).number-x {
+  max-width: 1.4rem;
+}
+:is(input,select).number-x2 {
+  max-width: 2.4rem;
+}
+:is(input,select).number-x3 {
+  max-width: 3.4rem;
+}
+:is(input,select).number-x4 {
+  max-width: 4.4rem;
+}
+:is(input,select).number-x5 {
+  max-width: 4.4rem;
+}
+
 form.rdddialogchrono input[type=datetime-local] {
   min-width: 20px;
   padding: 0;
@@ -818,7 +848,21 @@ section.sheet-body:after {
   display: block;
   clear: both;
 }
-
+a.rdd-world-content-link i {
+  color: var(--color-text-dark-inactive);
+  margin-right: 0.25em;
+}
+a.rdd-world-content-link {
+  background: hsla(280, 50%, 50%, 0.1);
+  padding: 1px 4px;
+  border: 1px solid var(--color-border-dark-tertiary);
+  border-radius: 2px;
+  white-space: nowrap;
+  word-break: break-all;
+}
+a.content-link {
+  background: hsla(45, 100%, 80%, 0.2);
+}
 
 li label.compteur {
   display: inline-block;

system.json

@@ -1,8 +1,8 @@
 {
   "id": "foundryvtt-reve-de-dragon",
   "title": "Rêve de Dragon",
-  "version": "10.3.17",
-  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-10.3.17.zip",
+  "version": "10.4.7",
+  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-10.4.7.zip",
   "manifest": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/v10/system.json",
   "compatibility": {
     "minimum": "10",

template.json

@@ -1,6 +1,6 @@
 {
   "Actor": {
-    "types": ["personnage", "creature", "entite", "vehicule"],
+    "types": ["personnage", "creature", "entite", "commerce", "vehicule"],
     "templates": {
       "description": {
         "description": "Description ...",
@@ -554,6 +554,11 @@
     },
     "vehicule": {
       "templates": [ "vehicule", "description" ]
+    },
+    "commerce":{
+      "templates": [ "description" ],
+      "pourcentage": 100,
+      "illimite": false
     }
   },
   "Item": {
@@ -562,6 +567,7 @@
         "recettealchimique", "musique", "chant", "danse", "jeu", "recettecuisine", "oeuvre",
         "objet", "arme", "armure", "conteneur", "herbe", "ingredient", "faune", "livre", "potion", "munition",
         "monnaie", "nourritureboisson", "gemme",
+        "service",
         "meditation", "rencontre", "queue", "ombre", "souffle", "tete", "casetmr", "signedraconique", "sort", "sortreserve",
         "nombreastral", "tache", "maladie", "poison", "possession",
         "tarot", "extraitpoetique"
@@ -578,7 +584,7 @@
         "encombrement": 0,
         "quantite": 1,
         "qualite": 0,
-        "cout": 0
+        "cout": 0.0
       },
       "environnement": {
         "milieu": "",
@@ -741,6 +747,10 @@
       "prpermanent": false,
       "prdate": 0
     },
+    "service": {
+      "templates": [ "description", "inventaire" ],
+      "moral": false
+    },
     "musique": {
       "templates": [ "description" ],
       "niveau": "",

templates/actor-creature-sheet.html

@@ -60,6 +60,7 @@
 
     {{!-- Equipment Tab --}}
     <div class="tab items" data-group="primary" data-tab="items">
+      {{> "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-monnaie.html"}}
       {{> "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire.html"}}
     </div>
 

templates/actor-sheet.html

@@ -21,88 +21,90 @@
 
     {{!-- Sheet Tab Navigation --}}
     <nav class="sheet-tabs tabs" data-group="primary">
-        <a class="item" data-tab="carac">Carac.</a>
-        <a class="item" data-tab="competences">Compétences</a>
-        <a class="item" data-tab="combat">Combat</a>
-        <a class="item" data-tab="connaissances">Savoirs&Taches</a>
-        <a class="item" data-tab="hautreve">Haut-Rêve</a>
-        <a class="item" data-tab="items">Équipement</a>
-        <a class="item" data-tab="description">Description</a>
-      </nav>
+      {{#if options.isObserver}}
+      <a class="item" data-tab="carac">Carac.</a>
+      <a class="item" data-tab="competences">Compétences</a>
+      <a class="item" data-tab="combat">Combat</a>
+      <a class="item" data-tab="connaissances">Savoirs&Taches</a>
+      <a class="item" data-tab="hautreve">Haut-Rêve</a>
+      {{/if}}
+      <a class="item" data-tab="items">Équipement</a>
+      <a class="item" data-tab="description">Description</a>
+    </nav>
 
-      {{!-- Sheet Body --}}
-      <section class="sheet-body">
-        
-        {{!-- Carac Tab --}}
-        <div class="tab items" data-group="primary" data-tab="carac">
-          <div class="flexrow">
-            {{>"systems/foundryvtt-reve-de-dragon/templates/actor/vue-detaillee.html"}}
+    {{!-- Sheet Body --}}
+    <section class="sheet-body">
+      {{#if options.isObserver}}{{!-- Carac Tab --}}
+      <div class="tab items" data-group="primary" data-tab="carac">
+        <div class="flexrow">
+          {{>"systems/foundryvtt-reve-de-dragon/templates/actor/vue-detaillee.html"}}
+        </div>
+        <div class="grid grid-2col">
+          <div class="flex-group-left flexcol">
+            {{>"systems/foundryvtt-reve-de-dragon/templates/actor/carac-main.html"}}
+            {{>"systems/foundryvtt-reve-de-dragon/templates/actor/carac-total.html"}}
           </div>
-          <div class="grid grid-2col">
-            <div class="flex-group-left flexcol">
-              {{>"systems/foundryvtt-reve-de-dragon/templates/actor/carac-main.html"}}
-              {{>"systems/foundryvtt-reve-de-dragon/templates/actor/carac-total.html"}}
-            </div>
-            <div class="flex-group-left flexcol" >
-              {{>"systems/foundryvtt-reve-de-dragon/templates/actor/carac-derivee.html"}}
-            </div>
+          <div class="flex-group-left flexcol" >
+            {{>"systems/foundryvtt-reve-de-dragon/templates/actor/carac-derivee.html"}}
           </div>
         </div>
-
-        {{!-- Compétences Tab --}}
-        <div class="tab competences" data-group="primary" data-tab="competences">
-          <div class="flexrow">
-            {{>"systems/foundryvtt-reve-de-dragon/templates/actor/vue-detaillee.html"}}
-            <span class="flexrow"><a class="show-hide-competences">
-              {{#if options.showCompNiveauBase}}
-              <i class="fa-regular fa-filter-slash"></i> Montrer tout
-              {{else}}
-              <i class="fa-regular fa-filter"></i> Filtrer
-              {{/if}}
-            </a></span>
-            <span>
-              <input class="recherche flex-grow" type="text" value="{{options.recherche.text}}" name="recherche" size="8" data-dtype="String" placeholder=""/>
-            </span>
-            <span>
-            </span>
+      </div>
+      {{/if}}
+      {{#if options.isObserver}}{{!-- Compétences Tab --}}
+      <div class="tab competences" data-group="primary" data-tab="competences">
+        <div class="flexrow">
+          {{>"systems/foundryvtt-reve-de-dragon/templates/actor/vue-detaillee.html"}}
+          <span class="flexrow"><a class="show-hide-competences">
+            {{#if options.showCompNiveauBase}}
+            <i class="fa-regular fa-filter-slash"></i> Montrer tout
+            {{else}}
+            <i class="fa-regular fa-filter"></i> Filtrer
+            {{/if}}
+          </a></span>
+          <span>
+            <input class="recherche flex-grow" type="text" value="{{options.recherche.text}}" name="recherche" size="8" data-dtype="String" placeholder=""/>
+          </span>
+          <span>
+          </span>
+        </div>
+        <div class="grid grid-2col">
+          <div class="competence-column">
+            {{> "systems/foundryvtt-reve-de-dragon/templates/actor/competence-categorie.html" competences=(filtreTriCompetences byCateg.generale) categorie="Compétences générales"}}
+            {{> "systems/foundryvtt-reve-de-dragon/templates/actor/competence-categorie.html" competences=(filtreTriCompetences byCateg.particuliere) categorie="Compétences Particulières"}}
+            {{> "systems/foundryvtt-reve-de-dragon/templates/actor/competence-categorie.html" competences=(filtreTriCompetences byCateg.specialisee) categorie="Compétences Spécialisées"}}
           </div>
-          <div class="grid grid-2col">
-            <div class="competence-column">
-              {{> "systems/foundryvtt-reve-de-dragon/templates/actor/competence-categorie.html" competences=(filtreTriCompetences byCateg.generale) categorie="Compétences générales"}}
-              {{> "systems/foundryvtt-reve-de-dragon/templates/actor/competence-categorie.html" competences=(filtreTriCompetences byCateg.particuliere) categorie="Compétences Particulières"}}
-              {{> "systems/foundryvtt-reve-de-dragon/templates/actor/competence-categorie.html" competences=(filtreTriCompetences byCateg.specialisee) categorie="Compétences Spécialisées"}}
-            </div>
-            <div class="competence-column">
-              {{> "systems/foundryvtt-reve-de-dragon/templates/actor/xp-competences.html"}}
-              {{> "systems/foundryvtt-reve-de-dragon/templates/actor/competence-categorie.html" competences=(filtreTriCompetences byCateg.melee) categorie="Compétences de Mêlée"}}
-              {{> "systems/foundryvtt-reve-de-dragon/templates/actor/competence-categorie.html" competences=(filtreTriCompetences byCateg.tir) categorie="Compétences de Tir"}}
-              {{> "systems/foundryvtt-reve-de-dragon/templates/actor/competence-categorie.html" competences=(filtreTriCompetences byCateg.lancer) categorie="Compétences de Lancer"}}
-              {{> "systems/foundryvtt-reve-de-dragon/templates/actor/competence-categorie.html" competences=(filtreTriCompetences byCateg.connaissance) categorie="Connaissances"}}
-              {{#if (or system.attributs.hautrevant.value options.vueDetaillee)}}
-              {{> "systems/foundryvtt-reve-de-dragon/templates/actor/competence-categorie.html" competences=(filtreTriCompetences byCateg.draconic) categorie="Draconic"}}
-              {{/if}}
-            </div>
+          <div class="competence-column">
+            {{> "systems/foundryvtt-reve-de-dragon/templates/actor/xp-competences.html"}}
+            {{> "systems/foundryvtt-reve-de-dragon/templates/actor/competence-categorie.html" competences=(filtreTriCompetences byCateg.melee) categorie="Compétences de Mêlée"}}
+            {{> "systems/foundryvtt-reve-de-dragon/templates/actor/competence-categorie.html" competences=(filtreTriCompetences byCateg.tir) categorie="Compétences de Tir"}}
+            {{> "systems/foundryvtt-reve-de-dragon/templates/actor/competence-categorie.html" competences=(filtreTriCompetences byCateg.lancer) categorie="Compétences de Lancer"}}
+            {{> "systems/foundryvtt-reve-de-dragon/templates/actor/competence-categorie.html" competences=(filtreTriCompetences byCateg.connaissance) categorie="Connaissances"}}
+            {{#if (or system.attributs.hautrevant.value options.vueDetaillee)}}
+            {{> "systems/foundryvtt-reve-de-dragon/templates/actor/competence-categorie.html" competences=(filtreTriCompetences byCateg.draconic) categorie="Draconic"}}
+            {{/if}}
           </div>
         </div>
-
-        {{!-- Combat Tab --}}
-        <div class="tab combat" data-group="primary" data-tab="combat">
+      </div>
+      {{/if}}
+      {{#if options.isObserver}}{{!-- Combat Tab --}}
+      <div class="tab combat" data-group="primary" data-tab="combat">
         {{> "systems/foundryvtt-reve-de-dragon/templates/actor/combat.html"}}<hr>
         {{> "systems/foundryvtt-reve-de-dragon/templates/actor/blessures.html"}}
         {{> "systems/foundryvtt-reve-de-dragon/templates/actor/maladies-poisons.html"}}
         {{> "systems/foundryvtt-reve-de-dragon/templates/actor/possessions.html"}}
-        
       </div>
-      
-      {{!-- Connaissances Tab --}}
+      {{/if}}
+
+      {{#if options.isObserver}}{{!-- Connaissances Tab --}}
       <div class="tab connaissances" data-group="primary" data-tab="connaissances">
+        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/astrologie.html"}}
         {{> "systems/foundryvtt-reve-de-dragon/templates/actor/taches.html"}}
         {{> "systems/foundryvtt-reve-de-dragon/templates/actor/oeuvres.html"}}
         {{> "systems/foundryvtt-reve-de-dragon/templates/actor/jeux.html"}}
         {{> "systems/foundryvtt-reve-de-dragon/templates/actor/alchimie.html"}}
       </div>
-      
-      {{!-- hautreve Tab --}}
+      {{/if}}
+      {{#if options.isObserver}}{{!-- hautreve Tab --}}
       <div class="tab hautreve " data-group="primary" data-tab="hautreve" style="height:200px">
         <div>
           {{#if system.attributs.hautrevant.value}}
@@ -116,10 +118,11 @@
           <br><br>
         </div>
       </div>
+      {{/if}}
 
       {{!-- Equipment Tab --}}
       <div class="tab items" data-group="primary" data-tab="items">
-        
+        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-monnaie.html"}}
         {{> "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire.html"}}
         {{> "systems/foundryvtt-reve-de-dragon/templates/actor/liens-animaux.html"}}
         {{> "systems/foundryvtt-reve-de-dragon/templates/actor/liens-suivants.html"}}
@@ -155,8 +158,10 @@
           <ul class="item-list alterne-list">
             <li class="item flexrow list-item">
               <label for="system.main">Main directrice :</label>
-              <input type="text" class="selection-main-directrice" name="system.main" value="{{system.main}}" data-dtype="String"/>
-              {{>'systems/foundryvtt-reve-de-dragon/templates/scripts/autocomplete.hbs' proposals=options.mainsDirectrices className='selection-main-directrice'}}
+              <div class="autocomplete">
+                <input type="text" class="selection-main-directrice" name="system.main" value="{{system.main}}" data-dtype="String"/>
+                {{>'systems/foundryvtt-reve-de-dragon/templates/scripts/autocomplete.hbs' proposals=options.mainsDirectrices className='selection-main-directrice'}}
+              </div>
             </li>
             <li class="item flexrow list-item">
               <label for="system.heure">Heure de naissance :</label>
@@ -184,7 +189,7 @@
         <article class="flexcol">
           <h3>Biographie : </h3>
           <div class="form-group large-editor">
-            {{editor biographie target="system.biographie" button=true owner=owner editable=true engine="prosemirror"}}
+            {{editor biographie target="system.biographie" button=true owner=options.owner editable=true engine="prosemirror"}}
           </div>
           <h3>Notes : </h3>
           <div class="form-group large-editor">

templates/actor-vehicule-sheet.html

@@ -91,6 +91,7 @@
 
     {{!-- Equipment Tab --}}
     <div class="tab items" data-group="primary" data-tab="items">
+      {{> "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-monnaie.html"}}
       {{> "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire.html"}}
     </div>
 

templates/actor/carac-derivee.html

@@ -9,7 +9,7 @@
     <label class="flexrow derivee-label">{{system.compteurs.stress.label}}
       <a class="stress-test" title="Transformer le stress"><i class="fa-regular fa-moon"></i></a>
     </label>
-    <input class="derivee-value" type="text" name="{{system.compteurs.stress.value}}" value="{{system.compteurs.stress.value}}" data-dtype="number"/>
+    <input class="derivee-value" type="text" name="system.compteurs.stress.value" value="{{system.compteurs.stress.value}}" data-dtype="number"/>
   </li>
   <li class="caracteristique flexrow list-item">
     <label class="derivee-label">{{system.compteurs.moral.label}}
@@ -24,9 +24,9 @@
   </li>
   <li class="caracteristique flexrow list-item">
     <label class="derivee-label">{{system.compteurs.exaltation.label}}</label>
-    <input class="derivee-value" type="text" name="{{system.compteurs.exaltation.value}}" value="{{system.compteurs.exaltation.value}}" data-dtype="number"/>
+    <input class="derivee-value" type="text" name="system.compteurs.exaltation.value" value="{{system.compteurs.exaltation.value}}" data-dtype="number"/>
     <label class="derivee-label">{{system.compteurs.dissolution.label}}</label>
-    <input class="derivee-value" type="text" name="{{system.compteurs.dissolution.value}}" value="{{system.compteurs.dissolution.value}}" data-dtype="number"/>
+    <input class="derivee-value" type="text" name="system.compteurs.dissolution.value" value="{{system.compteurs.dissolution.value}}" data-dtype="number"/>
   </li>
   <li class="caracteristique flexrow list-item">
     <label class="derivee-label chance-actuelle"><a>Chance actuelle</a></label>

templates/actor/commerce-actor-sheet.html

@@ -0,0 +1,79 @@
+<form class="{{cssClass}}" autocomplete="off">
+
+  {{!-- Sheet Header --}}
+  <header class="sheet-header">
+    <div class="header-fields">
+      <div class="flexrow">
+        <img class="profile-img" src="{{img}}" data-edit="img" title="{{name}}" />
+        <div class="flexcol">
+          <h1 class="charname"><input name="name" type="text" value="{{name}}" placeholder="Name" /></h1>
+          {{#if @root.options.isObserver}}
+          <div class="form-group">
+            <input {{@root.disabled}} class="attribute-value" type="checkbox" name="system.illimite" {{#if system.illimite}}checked{{/if}}/>
+            <label for="system.illimite">Quantité illimitée en vente</label>
+          </div>
+          <div class="form-group">
+            <span>
+              <label for="system.pourcentage">Appliquer un pourcentage sur les prix</label>
+              <input {{@root.disabled}} class="attribute-value" type="number" data-dtype="Number" 
+                name="system.pourcentage" value="{{system.pourcentage}}"
+                min="20" max="500" step="5"/>
+            </span>
+          </div>
+          {{/if}}
+        </div>
+      </div>
+    </div>
+  </header>
+
+  {{!-- Sheet Body --}}
+  <section class="sheet-body">
+    <div class="flexcol form-group medium-editor">
+      {{editor description target="system.description" button=true owner=options.owner editable=options.isOwner engine="prosemirror"}}
+    </div>
+    <hr>
+    {{> "systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire.html"}}
+    {{#unless system.illimite}}
+    {{#if @root.options.isObserver}}
+      <hr>
+      {{> "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-monnaie.html"}}
+    {{/if}}
+    {{/unless}}
+    {{!--
+      <br>
+      <div class="flexcol">
+        <ul class="item-list alterne-list">
+          <li class="item flexrow list-item">
+            <label class="flex-grow">Service</label>
+            <label>Moral</label>
+            <label>Qualité</label>
+            <label>Prix (sols)</label>
+            <label>
+              {{#unless disabled}}
+              <a class="service-add"><i class="fas fa-plus-circle"></i></a>
+              {{/unless}}
+            </label>
+          </li>
+          {{#each system.services as |service key|}}
+          <li class="item flexrow list-item" data-key="{{key}}">
+            <input {{@root.disabled}} type="text" name="services[{{key}}].name" value="{{service.name}}" data-dtype="String" />
+            <input {{@root.disabled}} type="checkbox" name="services[{{key}}].system.moral" {{#if service.system.moral}}checked{{/if}} />
+            <input {{@root.disabled}} type="number" name="services[{{key}}].system.qualite" value="{{service.system.qualite}}" data-dtype="Number" min="-10" max="10"/>
+            <input {{@root.disabled}} type="number" class="input-prix" name="services[{{key}}].system.cout" value="{{numberFormat service.system.cout decimals=2 sign=false}}" data-dtype="Number" min="0" />
+            <div class="item-controls">
+              <a class="service-acheter" title="Acheter"><i class="fa-sharp fa-solid fa-coins"></i></a>
+              {{#unless @root.disabled}}
+              <a class="service-vendre" title="Proposer"><i class="fas fa-comments-dollar"></i></a>
+              <a class="service-delete" title="Supprimer"><i class="fas fa-trash"></i></a>
+              {{/unless}}
+            </div>
+          </li>
+          {{/each}}
+        </ul>
+      </div>
+    --}}
+    <br>
+    {{> "systems/foundryvtt-reve-de-dragon/templates/actor/editor-notes-mj.html"}}
+    <br>
+  </section>
+</form>

templates/actor/commerce-inventaire-item.html

@@ -0,0 +1,64 @@
+{{#if (ne item.type 'monnaie')}}
+<li class="item flexrow list-item" data-item-id="{{item._id}}" draggable="true">
+  <span class="equipement-nom {{#if (eq item.type 'conteneur')}}conteneur-name{{/if}} ">
+    <a{{#if (and (ne item.type 'conteneur') options.isObserver)}} class="item-edit"{{/if}} >
+    {{#if (eq item.type 'conteneur')}}
+      <i class="{{~#if vide}}far fa-square
+      {{else if ouvert}}far fa-minus-square
+      {{else}}far fa-plus-square
+      {{/if~}}"></i>
+    {{/if}}
+      <img class="sheet-competence-img" src="{{item.img}}" title="{{item.name}}"/>
+      <span>{{item.name}}</span>
+    </a>
+  </span>
+  {{log 'item-inventaire' this}}
+  {{#unless item.parent.system.illimite}}
+  <span class="equipement-detail flexrow">
+    {{#unless (or (eq item.type 'service') (and (eq item.type 'conteneur') (not vide)))}}
+      {{#if options.isOwner}}
+      <a class="item-quantite-moins"><i class="fas fa-minus-square"></i></a>
+      {{/if}}
+      <input {{#unless options.isOwner}}disabled{{/unless}} type="number" data-dtype="Number" 
+        class="item-quantite" name="items[{{key}}].system.quantite"
+        value="{{item.system.quantite}}" />
+      {{#if options.isOwner}}
+      <a class="item-quantite-plus"><i class="fas fa-plus-square"></i></a>
+      {{/if}}
+    {{/unless}}
+  </span>
+  {{/unless}}
+  <span class="equipement-detail">
+    {{#unless (and (eq item.type 'conteneur') (not vide))}}
+    <input {{#unless options.isOwner}}disabled{{/unless}} type="number" data-dtype="Number" 
+      class="input-prix number-x3 item-cout" name="items[{{key}}].system.cout"
+      {{#if options.isObserver}}
+      value="{{numberFormat item.system.cout decimals=2 sign=false}}"
+      {{else}}
+      value="{{numberFormat (calculerPrixCommercant item) decimals=2 sign=false}}"
+      {{/if}} />
+    {{/unless}}
+  </span>
+  <span class="equipement-actions item-controls">
+    {{#if options.isOwner}}
+      {{#if (and (eq item.type 'conteneur') (not vide))}}
+        <a class="item-edit" title="Editer"><i class="fas fa-edit"></i></a>
+      {{else}}
+        <a class="item-edit" title="Editer"><i class="fas fa-edit"></i></a>
+        <a class="item-delete" title="Supprimer"><i class="fas fa-trash"></i></a>
+        {{#if (or item.parent.system.illimite (ne item.system.quantite 0))}}
+        <a class="item-vendre" title="Vendre"><i class="fas fa-comments-dollar"></i></a>
+        {{/if}}
+        {{#if (gt item.system.quantite 0)}}
+        <a class="item-acheter" title="Acheter"><i class="fa-regular fa-coins"></i></a>
+        {{/if}}
+      {{/if}}
+    {{else}}
+      {{#if (or item.parent.system.illimite (gt item.system.quantite 0))}}
+      <a class="item-acheter" title="Acheter"><i class="fa-regular fa-coins"></i></a>
+      {{/if}}
+    {{/if}}
+    <a class="item-montrer" title="Montrer"><i class="fas fa-comment"></i></a>
+  </span>
+</li>
+{{/if}}

templates/actor/commerce-inventaire.html

@@ -0,0 +1,36 @@
+<h4>Boutique</h4>
+<span class="item-name">
+  {{#if options.isGM}}
+  <a class="chat-card-button creer-un-objet">Nouvel objet</a>
+  <a class="chat-card-button nettoyer-conteneurs">Tout vider</a>
+  {{/if}}
+
+  {{#unless system.illimite}}
+  {{#if calc.surEncombrementMessage}}<b>{{calc.surEncombrementMessage}}</b> &hyphen;{{/if}}
+  Encombrement: {{numberFormat calc.encTotal decimals=2}}
+  {{#if (regle-optionnelle 'afficher-prix-joueurs')}}
+  &hyphen; Valeur: {{numberFormat calc.prixTotalEquipement decimals=2}} Sols
+  {{/if}}
+  {{/unless}}
+</span>
+<ul class="item-list alterne-list">
+  <li class="competence-header flexrow">
+    <span class="equipement-nom">Nom</span>
+    {{#unless system.illimite}}
+    <span class="equipement-detail">Quantité</span>
+    {{/unless}}
+    <span class="equipement-detail">Prix (sols)</span>
+    <span class="equipement-actions">Actions</span>
+  </li>
+  {{#each objets as |item id|}}
+    {{#unless item.estContenu}}
+    {{#if (ne item.type 'conteneur')}}
+    {{> "systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire-item.html"
+      item=item vide=true ouvert=true options=../options}}
+    {{/if}}
+    {{/unless}}
+  {{/each}}
+  {{#each conteneurs as |conteneur id|}}
+    {{buildConteneur conteneur 'actor/commerce-inventaire-item.html' ../options}}
+  {{/each}}
+</ul>

templates/actor/header-hautreve.html

@@ -1,10 +1,14 @@
 {{#if system.attributs.hautrevant.value}}
   <div class="tmr-buttons">
     <span class="monte-tmr">
-      <a title="Montée dans les Terres M&eacute;dianes !" {{#if hautreve.isDemiReve}}disabled{{/if}}><img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-normal.svg" alt="Montée dans les Terres M&eacute;dianes !"/></a>
+      <a title="Montée dans les Terres M&eacute;dianes !" {{#if hautreve.isDemiReve}}disabled{{/if}}>
+        <img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-normal.svg" alt="Montée dans les Terres M&eacute;dianes !"/>
+      </a>
     </span>
     <span class="monte-tmr-rapide">
-      <a title="Montée accélérée dans les Terres M&eacute;dianes !" {{#if hautreve.isDemiReve}}disabled{{/if}}><img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-rapide.svg" alt="Montée accélérée dans les Terres M&eacute;dianes !"/></a>
+      <a title="Montée accélérée dans les Terres M&eacute;dianes !" {{#if hautreve.isDemiReve}}disabled{{/if}}>
+        <img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-rapide.svg" alt="Montée accélérée dans les Terres M&eacute;dianes !"/>
+      </a>
     </span>
     <span class="visu-tmr">
       <a title="Regarder les Terres M&eacute;dianes"><img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-view.svg" alt="Regarder les Terres M&eacute;dianes"/></a>

templates/actor/inventaire-item.html

@@ -1,3 +1,4 @@
+{{#if (or @root.options.isObserver (ne item.type 'monnaie'))}}
 <li class="item flexrow list-item" data-item-id="{{item._id}}" draggable="true">
   <span class="equipement-nom {{#if (eq item.type 'conteneur')}}conteneur-name{{/if}} ">
     {{#if (eq item.type 'conteneur')}}
@@ -20,6 +21,7 @@
   </span>
   <span class="equipement-detail">{{numberFormat item.system.encTotal decimals=2}}</span>
   <span class="equipement-actions item-controls">
+    {{#if @root.options.isOwner}}
     {{#unless item.estContenu}}
     {{#if (or (eq item.type 'arme') (eq item.type 'armure') )}}
     <a class="item-equip" title="Equiper">{{#if item.system.equipe}}<i class="fas fa-hand-rock"></i>{{else}}<i class="far fa-hand-paper"></i>{{/if}}</a>
@@ -31,10 +33,13 @@
     {{#if (ne item.system.quantite 0)}}
     <a class="item-vendre" title="Vendre ou donner"><i class="fas fa-comments-dollar"></i></a>
     {{/if}}
+    {{/if}}
     <a class="item-montrer" title="Montrer"><i class="fas fa-comment"></i></a>
+    {{#if @root.options.isOwner}}
     {{#if item.system.actionPrincipale}}
     <a class="item-action">{{item.system.actionPrincipale}}</a>
     {{/if}}
+    {{/if}}
   </span>
 </li>
-
+{{/if}}

templates/actor/inventaire-monnaie.html

@@ -1,4 +1,5 @@
-<span class="item-name"><h4>Argent et Monnaies (fortune: {{calc.fortune}} sols)</h4></span>
+{{#if @root.options.isObserver}}
+<span class="item-name"><h4>Argent et Monnaies (fortune: {{calc.fortune.sols}} sols {{calc.fortune.deniers}} deniers)</h4></span>
 <ul class="item-list alterne-list">
   {{#each monnaie as |piece id|}}
   <li class="item flexrow list-item" data-item-id="{{piece._id}}">
@@ -7,19 +8,26 @@
     <span class="equipement-valeur {{#unless (gt piece.system.cout 0)}}field-error{{/unless}}">
       ({{piece.system.cout}} Sols)
     </span>
+    {{#if @root.options.isOwner}}
     <span class="equipement-button item-controls">
       <a class="monnaie-moins"><i class="fas fa-minus-square"></i></a>
     </span>
+    {{/if}}
     <span class="equipement-detail">
       <span>{{piece.system.quantite}}</span>
     </span>
+    {{#if @root.options.isOwner}}
     <span class="equipement-button item-controls">
       <a class="monnaie-plus"><i class="fas fa-plus-square"></i></a>
     </span>
-    <span class="equipement-actions  item-controls">
+    {{/if}}
+    <span class="equipement-actions item-controls">
+      {{#if @root.options.isOwner}}
       <a class="item-edit" title="Editer"><i class="fas fa-edit"></i></a>
       <a class="item-delete" title="Supprimer"><i class="fas fa-trash"></i></a>
+      {{/if}}
     </span>
   </li>
   {{/each}}
 </ul>
+{{/if}}

templates/actor/inventaire.html

@@ -1,5 +1,3 @@
-{{> "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-monnaie.html" monnaie=monnaie}}
-
 <h4>Equipement</h4>
 <span class="item-name">
   <a class="chat-card-button creer-un-objet">Nouvel objet</a>
@@ -22,11 +20,11 @@
   {{#each objets as |item id|}}
     {{#unless item.estContenu}}
     {{#if (ne item.type 'conteneur')}}
-      {{> "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-item.html" item=item vide=true ouvert=true }}
+      {{> "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-item.html" item=item vide=true ouvert=true options=@root.options}}
     {{/if}}
     {{/unless}}
   {{/each}}
   {{#each conteneurs as |conteneur id|}}
-    {{buildConteneur this}}
+    {{buildConteneur this 'actor/inventaire-item.html' @root.options}}
   {{/each}}
 </ul>

templates/chat-vente-item.html

@@ -19,7 +19,7 @@
     {{/if}}
     {{#if (ne prixLot 0)}}
     <span><strong>Prix {{#if (gt tailleLot 1)}}du lot {{else}}unitaire{{/if}}:
-      <span class="prixLot">{{prixLot}}</span> Sols</strong></span><br>
+      <span class="prixLot">{{numberFormat prixLot decimals=2 sign=false}}</span> Sols</strong></span><br>
     {{/if}}
   </p>
   {{#if (or (gt quantiteNbLots 0) quantiteIllimite)}}

templates/common/compendium-link.hbs

@@ -1 +1,14 @@
-<a class="content-link" draggable="true" data-pack="{{pack}}" data-uuid="Compendium.{{pack}}.{{id}}" data-id="{{id}}"><i class="fas fa-suitcase"></i>{{name}}</a>
+{{#if pack}}
+{{!-- draggable="true"  --}}
+<a class="content-link" 
+  data-uuid="Compendium.{{pack}}.{{id}}" 
+  data-pack="{{pack}}" 
+  {{#if doctype}}data-doctype="{{doctype}}"{{/if}}
+  data-id="{{id}}"
+><i class="fas fa-suitcase"></i>{{name}}</a>
+{{else}}
+<a class="rdd-world-content-link"
+  {{#if doctype}}data-doctype="{{doctype}}"{{/if}}
+  data-id="{{id}}"
+><i class="fas fa-suitcase"></i>{{name}}</a>
+{{/if}}

templates/dialog-astrologie-joueur.html

@@ -16,7 +16,7 @@
   <label>&nbsp;&nbsp;Jours</label>
   <select name="joursAstrologie" data-dtype="Number">
       {{#select joursSuivants}}
-      {{#each dates  as |date key|}}
+      {{#each dates as |date key|}}
       <option value={{date.index}}>{{date.label}}</option>
       {{/each}}
       {{/select}}

templates/dialog-item-achat.html

@@ -8,9 +8,9 @@
         <img class="chat-icon" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/icon_echoppe.webp" title="Un commerçant" alt="Vendeur MJ" />
         {{/if}}
       </div>
-      <div><i class="fas fa-sign-out-alt"></i></div>
+      <div><i class="fa-solid fa-arrow-right-long"></i></div>
       <div><img class="chat-icon" src="{{item.img}}" title="{{item.name}}" alt="{{item.name}}" /></div>
-      <div><i class="fas fa-sign-in-alt"></i></div>
+      <div><i class="fa-solid fa-arrow-right-long"></i></div>
       <div>
         {{#if acheteur}}
         <img class="chat-icon" src="{{acheteur.img}}" title="{{acheteur.name}}" alt="{{acheteur.name}}" />
@@ -40,8 +40,10 @@
       {{else}}Quantité{{/if}}
     </label>
     <div class="flexrow">
-      <input name="nombreLots" class="nombreLots flex-shrink" type="number" min="1" max="{{quantiteNbLots}}"
-        value="{{choix.nombreLots}}" data-dtype="Number" />
+      <input name="nombreLots" class="nombreLots flex-shrink number-x2" type="number" min="1"
+        {{#unless quantiteIllimite}} max="{{quantiteNbLots}}" {{/unless}}
+        value="{{choix.nombreLots}}"
+        data-dtype="Number" />
     </div>
   </div>
 
@@ -50,8 +52,7 @@
 
     {{#if item.system.sust}}
       <p>Cette {{#if item.system.boisson}}boisson{{else}}nourriture{{/if}} vous apportera
-        <span class="total-sust">{{totalSust}}</span>
-        de sustantation.</p>
+        <span class="total-sust">{{totalSust}}</span> de sustantation.</p>
     {{/if}}
     {{#if item.system.boisson}}
       <p>
@@ -82,13 +83,13 @@
   {{#if isVente}}
   <div class="flexrow flex-group-left">
     <label>Prix {{#if (gt tailleLot 1)}}du lot{{else}}unitaire{{/if}}</label>
-    <label>{{prixLot}} Sols</label>
+    <label>{{numberFormat prixLot decimals=2 sign=false}} Sols</label>
   </div>
   <div class="flexrow flex-group-left">
     <label>Prix total</label>
-    <span class="flexrow">
-      <span class="prixTotal">{{prixTotal}}</span>
-      <span>Sols</span>
+    <span>
+      <span class="prixTotal">{{numberFormat prixTotal decimals=2 sign=false}}</span>
+      Sols
     </span>
   </div>
   {{/if}}

templates/dialog-item-consommer.html

@@ -3,7 +3,7 @@
   <h4>{{item.name}}</h4>
   <div class="flexrow">
     <label class="flex-grow">Quantité à {{#if item.system.boisson}}boire{{else}}manger{{/if}}</label>
-    <input class="attribute-value consommer-doses flex-shrink" type="number" name="doses" value="{{choix.doses}}"
+    <input class="attribute-value consommer-doses flex-shrink number-x2" type="number" name="doses" value="{{choix.doses}}"
       min="0" max="{{item.system.quantite}}" data-dtype="Number" />
   </div>
   {{#if item.system.sust}}

templates/dialog-item-split.html

@@ -4,7 +4,7 @@
   <label>Quantité totale : {{item.system.quantite}}</label>
   <div class="flexrow">
     <label class="flex-grow">Quantité à séparer</label>
-    <input class="attribute-value choix-quantite flex-shrink" type="number" name="choix.quantite" value="{{choix.quantite}}"
+    <input class="attribute-value choix-quantite flex-shrink number-x2" type="number" name="choix.quantite" value="{{choix.quantite}}"
       min="1" max="{{choix.max}}" data-dtype="Number" />
   </div>
 </form>

templates/dialog-item-vente.html

@@ -16,23 +16,23 @@
           quantiteIllimite}}checked{{/if}} />
         <label class="label-quantiteIllimite flex-shrink">Illimités</label>
         {{/unless}}
-        <input name="quantiteNbLots" class="quantiteNbLots flex-shrink" type="number" min="1"
+        <input name="quantiteNbLots" class="quantiteNbLots flex-shrink number-x2" type="number" min="1"
           max="{{quantiteMaxLots}}" value="{{quantiteNbLots}}" data-dtype="Number" />
       </div>
     </div>
     <div class="flexrow flex-group-left">
       <label for="tailleLot">Taille d'un lot</label>
-      <input name="tailleLot" class="tailleLot flex-shrink" type="number" min="1"
+      <input name="tailleLot" class="tailleLot flex-shrink number-x2" type="number" min="1"
         max="{{quantiteMax}}" value="{{tailleLot}}" data-dtype="Number" />
     </div>
     <div class="flexrow flex-group-left">
-      <label>Valeur unitaire</label>
-      <label>{{prixOrigine}} Sols</label>
+      <label>Prix unitaire</label>
+      <label>{{numberFormat prixOrigine decimals=2 sign=false}} Sols</label>
     </div>
     <div class="flexrow flex-group-left">
       <label for="prixLot">Prix du lot</label>
       <span class="flexrow">
-        <input name="prixLot" class="prixLot flex-shrink" type="number" value="{{prixLot}}"
+        <input name="prixLot" class="prixLot flex-shrink" type="number" value="{{numberFormat prixLot decimals=2 sign=false}}"
           data-dtype="Number" />
         <label>Sols</label>
       </span>

templates/item-service-sheet.html

@@ -0,0 +1,24 @@
+<form class="{{cssClass}}" autocomplete="off">
+  {{>"systems/foundryvtt-reve-de-dragon/templates/header-item.html"}}
+
+  <section class="sheet-body">
+    <div class="form-group">
+      <span for="system.moral">Jet de moral en situation heureuse</span>
+      <input {{@root.disabled}} class="attribute-value" type="checkbox" name="system.moral" {{#if system.moral}}checked{{/if}}/>
+    </div>
+
+    <div class="form-group">
+      <label for="system.qualite">Qualité</label>
+      <input class="attribute-value number-x3" type="number" name="system.qualite" value="{{system.qualite}}" data-dtype="Number"
+        {{#unless (isFieldInventaireModifiable type 'qualite')}}disabled{{/unless}}/>
+    </div>
+
+    <div class="form-group item-cout">
+      <label for="system.cout">Prix (sols)</label>
+      <input class="input-prix attribute-value number-x3" type="number" name="system.cout" value="{{numberFormat system.cout decimals=2 sign=false}}" data-dtype="Number"
+        {{#unless (isFieldInventaireModifiable type 'cout')}}disabled{{/unless}}/>
+    </div>
+    
+    {{>"systems/foundryvtt-reve-de-dragon/templates/partial-item-description.html"}}
+  </section>
+</form>

templates/item/partial-environnement.html

@@ -10,24 +10,26 @@
   <div class="form-group">
     <label>Ajouter un fréquence</label>
     <span class="flexrow">
-      <input type="text" class="input-selection-milieu" placeholder="Milieu" data-dtype="String"/>
-      {{>'systems/foundryvtt-reve-de-dragon/templates/scripts/autocomplete.hbs' proposals=milieux className='input-selection-milieu'}}
+      <div class="autocomplete">
+        <input name="saisie-nouveau-milieu" type="text" class="input-selection-milieu" placeholder="Milieu" data-dtype="String"/>
+        {{>'systems/foundryvtt-reve-de-dragon/templates/scripts/autocomplete.hbs' proposals=milieux className='input-selection-milieu'}}
+      </div>
       <a class="milieu-add"><i class="fas fa-plus-circle"></i></a>
     </span>
   </div>
-  {{#each system.environnement as |env|}}
+  {{#each system.environnement as |env key|}}
   <div class="form-group environnement-milieu" data-milieu="{{env.milieu}}">
     <label>
       {{env.milieu}}
       <a class="milieu-delete" title="Supprimer {{env.milieu}}"><i class="fas fa-trash"></i></a>
     </label>
     <span class="flexrow">
-      <select class="environnement-rarete" class="flex-shrink" data-dtype="String">
+      <select name="milieu-{{key}}-rarete" class="environnement-rarete" class="flex-shrink" data-dtype="String">
         {{#select env.rarete}}
         {{>"systems/foundryvtt-reve-de-dragon/templates/enum-rarete.html"}}
         {{/select}}
       </select>
-      {{rangePicker name="environnement-frequence" value=env.frequence min=(getFrequenceRarete env.rarete 'min') max=(getFrequenceRarete env.rarete 'max') step=1}}
+      {{rangePicker name="milieu-{{key}}-frequence" value=env.frequence min=(getFrequenceRarete env.rarete 'min') max=(getFrequenceRarete env.rarete 'max') step=1}}
       <label>[{{getFrequenceRarete env.rarete 'min'}}-{{getFrequenceRarete env.rarete 'max'}}]</label>
     </span>
   </div>

templates/item/partial-inventaire.html

@@ -1,25 +1,25 @@
 <div class="form-group">
   <label for="system.qualite">Qualité</label>
-  <input class="attribute-value" type="text" name="system.qualite" value="{{system.qualite}}" data-dtype="Number"
+  <input class="attribute-value number-x3" type="number" name="system.qualite" value="{{system.qualite}}" data-dtype="Number"
     {{#unless (isFieldInventaireModifiable type 'qualite')}}disabled{{/unless}}/>
 </div>
 <div class="form-group">
   <label for="system.encombrement">Encombrement</label>
-  <input class="attribute-value" type="text" name="system.encombrement" value="{{system.encombrement}}" data-dtype="Number"
+  <input class="attribute-value number-x3" type="number" name="system.encombrement" value="{{system.encombrement}}" data-dtype="Number"
     {{#unless (isFieldInventaireModifiable type 'encombrement')}}disabled{{/unless}}/>
 </div>
 <div class="form-group">
   <label for="system.quantite">Quantité {{uniteQuantite id actorId}}</label>
-  <input class="attribute-value" type="text" name="system.quantite" value="{{system.quantite}}" data-dtype="Number"
+  <input class="attribute-value number-x3" type="number" name="system.quantite" value="{{system.quantite}}" data-dtype="Number"
   {{#unless (isFieldInventaireModifiable type 'quantite')}}disabled{{/unless}}/>
 </div>
 <div class="form-group item-cout">
   <label for="system.cout">Prix (sols)</label>
   {{#if (or (ne type 'monnaie') (gt system.cout 0))}}
-  <input class="attribute-value" type="text" name="system.cout" value="{{system.cout}}" data-dtype="Number"
+  <input class="input-prix attribute-value number-x3" type="number" name="system.cout" value="{{numberFormat system.cout decimals=2 sign=false}}" data-dtype="Number"
     {{#unless (isFieldInventaireModifiable type 'cout')}}disabled{{/unless}}/>
   {{else}}
-    <input class="attribute-value field-error" type="text" name="system.cout" value="{{system.cout}}" data-dtype="Number"
+    <input class="input-prix attribute-value field-error number-x3" type="number" name="system.cout" value="{{numberFormat system.cout decimals=2 sign=false}}" data-dtype="Number"
     {{#unless (isFieldInventaireModifiable type 'cout')}}disabled{{/unless}}/>
   {{/if}}
 </div>

templates/post-actor.html

@@ -0,0 +1,7 @@
+<div class="post-item">
+  {{#if img}}
+  <img class="chat-icon" src="{{img}}" title="{{name}}" />
+  {{/if}}
+  <p>{{> 'systems/foundryvtt-reve-de-dragon/templates/common/compendium-link.hbs' pack=pack id=id name=name doctype=doctype}}</p>
+  <p class="card-content">{{{system.description}}}</p>
+</div>

templates/post-item-service.html

@@ -0,0 +1,8 @@
+<div class="post-item">
+  {{#if img}}
+  <img class="chat-icon" src="{{img}}" title="{{name}}" />
+  {{/if}}
+  <p>{{> 'systems/foundryvtt-reve-de-dragon/templates/common/compendium-link.hbs' pack=pack id=id name=name docType=docType}}</p>
+  <p class="card-content">{{{system.description}}}</p>
+
+</div>

templates/post-item.html

@@ -1,4 +1,4 @@
-<div class="post-item" data-transfer="{{transfer}}">
+<div class="post-item">
   <h3><b>{{name}}</b></h3>
   {{#if img}}
   <img class="chat-icon" src="{{img}}" title="{{name}}" />
@@ -10,5 +10,4 @@
     <span>{{{property}}}</span><br>
     {{/each}}
   </p>
-
 </div>

templates/settings/system-compendiums.html

@@ -1,6 +1,4 @@
 <form autocomplete="off" onsubmit="event.preventDefault();">
-  {{log 'systemCompendiums'systemCompendiums}}
-  {{log 'availableCompendiums' availableCompendiums}}
   <ul>
     {{#each systemCompendiums as |definition key|}}
     <li class="flexrow">