67 changed files with 423 additions and 616 deletions
--- a/assets/scenes/9fmf9lcb3L9XO3bJ-thumb.png
+++ b/assets/scenes/9fmf9lcb3L9XO3bJ-thumb.png
--- a/changelog.md
+++ b/changelog.md
@ -1,71 +1,3 @@
-# 12.0
-## 12.0.8 - La quincaillerie d'Astrobazzarh
- le propriétaire est indiqué dans les feuilles d'équipements/compétences/...
- Ecaille d'efficacité
-  - l'écaille d'efficacité est prise en compte même si on n'utilise pas le ciblage en combat
-  - l'écaille d'efficacité est prise en compte pour l'initiative
- Corrections
-  - l'état général est pris en compte pour les initiatives
-  - le tooltip de l'initiative affiche correctement l'initiative
-
-## 12.0.7 - La propriété d'Astrobazzarh
- correction des opérations faites à la création d'un Item:
-  - la durée des queues/rencontres/souffles
-  - les effets draconiques d'un souffle/queue
-  - mise à jour des points de tâche des blessures lors des soins
- pas d'expérience sur les particulières quand aucun MJ n'est connecté
- Le drag&drop d'un acteur depuis la liste des acteurs sur la fiche
-  d'une entité incarnée permet d'accorder le personnage
- Les messages pour résister aux possessions/conjuration sont envoyées
-  au défenseur
- Les messages pour résister aux empoignades sont envoyées au défenseur
- la commande /voyage affiche maintenant le total de fatigue pour chaque voyageur
- la commande /voyage affiche maintenant les compétences liées au terrain
-
-## 12.0.6 - Le bazar d'Astrobazzarh
- Corrections de l'inventaire en bazar:
-  - un problème pouvait survenir en déplaçant les objets 
-    l'inventaire, qui fait qu'un conteneur se retrouve récursivement dans son
-    propre contenu, ce qui empêche d'ouvrir la feuille d'acteur.
-  - un objet non-conteneur pouvait dans certains cas avoir un pseudo contenu
-  - un objet pouvait être considéré comme contenu, sans être présent dans un
-    conteneur (et donc non affiché)
-  - vider les conteneurs supprime correctement toutes les informations liées
-    aux conteneurs/contenus
- Les messages pour les tirages dans le compendium utilisent le "roll mode" 
-  courant pour leur visibilité
- Fix: restaurer la compatibilité Foundry 11
-
-## 12.0.5 - Les mauvais jours d'Astrobazzarh
- Fix: on peut de nouveau ouvrir l'édition de calendrier
- Fix: on ne peut plus ouvrir plusieurs fenêtres de lancer de sort
- Fix: Failed to execute 'getComputedStyle' on 'Window'
-
-## 12.0.4 - La plaie d'Astrobazzarh
- **Support V12**
-  - Fix: les boutons d'encaissement dans le tchat fonctionnent de nouveau
-  - Fix warnings sur "Die" et AudioHelper
-
-## 12.0.3 - L'hémorragie d'Astrobazzarh
- **Support V12**
-  - On peut de nouveau ouvrir un acteur blessé après redémarrage du monde
-  - On peut de nouveau ouvrir les Items avec une rareté par environnement
-  - Le choix de ne plus afficher les demandes de suppression est bien pris en compte
-
-## 12.0.2 - Les pluies d'Astrobazzarh
- **Support V12**
-  - correction des actions techniques déleguées au MJ qui bloquaient les fenêtre de lancer de dés des joueurs (et plein d'autres)
-  - la fenêtre de calendrier s'ouvre correctement
-  - les dés draconiques peuvent de nouveau faire plus que 0
-  - adaptation de la fenêtre de recherche
-  - correction des comparaisons de version pour les migrations automatiques
-  - correction des roll.eveluate: l'option async est maintenant standard
-  - correction des templates liés aux selections
-  - correction de l'ajustement de luminosité de la scène selon l'heure
-  - correction des images d'effets sur les tokens
-  - correction de la vente par le tchat: seul le premier acheteur pouvait acheter
-  - correction d'erreurs intempestives 'User ... lacks permission to update ...'
-
 # 11.2
 ## 11.2.21 - Le questionnement d'Akarlikarlikar
 - Une confirmation spécifique est demandée pour monter dans les terres médianes en cas de rencontre en attente
--- a/icons/heures/.directory
+++ b/icons/heures/.directory
@ -1,4 +0,0 @@
-[Dolphin]
-Timestamp=2024,5,29,20,57,41.954
-Version=4
-VisibleRoles=Details_text,Details_size,Details_modificationtime,Details_creationtime,CustomizedDetails
--- a/module/achat-vente/chat-vente.js
+++ b/module/achat-vente/chat-vente.js
@ -1,65 +0,0 @@
-import { SYSTEM_RDD } from "../constants.js";
-import { RdDUtility } from "../rdd-utility.js";
-
-const DETAIL_VENTE = 'detailVente';
-const NB_LOTS = 'nbLotss';
-
-export class ChatVente {
-
-  static getDetailVente(chatMessageId) {
-    const chatMessage = game.messages.get(chatMessageId)
-    if (!chatMessage) {
-      return undefined;
-    }
-    const nbLots = chatMessage.getFlag(SYSTEM_RDD, NB_LOTS)
-    const detail = foundry.utils.duplicate(chatMessage.getFlag(SYSTEM_RDD, DETAIL_VENTE))
-    if (!detail.item) {
-      ui.notifications.warn("Impossible d'acheter: informations sur l'objet manquantes")
-      return undefined;
-    }
-
-    const vendeur = detail.vendeurId ? game.actors.get(detail.vendeurId) : undefined;
-    return foundry.utils.mergeObject(detail,
-      {
-        alias: vendeur?.name ?? game.user.name,
-        vendeur,
-        nbLots: nbLots,
-        chatMessageIdVente: chatMessageId
-      })
-  }
-
-  static getDetailAchatVente(chatMessageId) {
-    const acheteur = RdDUtility.getSelectedActor()
-    const detail = ChatVente.getDetailVente(chatMessageId)
-    if (!acheteur && !detail.vendeur) {
-      ui.notifications.info("Pas d'acheteur ni de vendeur, aucun changement");
-      return undefined;
-    }
-    return foundry.utils.mergeObject(detail, { acheteur })
-  }
-
-  static async diminuerQuantiteAchatVente(chatMessageId, quantite) {
-    const chatMessage = game.messages.get(chatMessageId)
-    const vente = ChatVente.getDetailVente(chatMessageId)
-    vente.nbLots = Math.max(0, vente.nbLots - quantite)
-    await chatMessage.setFlag(SYSTEM_RDD, NB_LOTS, vente.nbLots)
-
-    const html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-vente-item.html', vente);
-    chatMessage.update({ content: html });
-    chatMessage.render(true);
-  }
-
-  static async displayAchatVente(vente) {
-    const html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-vente-item.html', vente);
-    const chatMessage = await ChatMessage.create(RdDUtility.chatDataSetup(html))
-    await chatMessage.setFlag(SYSTEM_RDD, NB_LOTS, vente.nbLots)
-    await chatMessage.setFlag(SYSTEM_RDD, DETAIL_VENTE, {
-      item: vente.item,
-      properties: vente.item.getProprietes(),
-      vendeurId: vente.vendeurId,
-      tailleLot: vente.tailleLot,
-      quantiteIllimite: vente.quantiteIllimite,
-      prixLot: vente.prixLot
-    })
-  }
-}
--- a/module/actor-sheet.js
+++ b/module/actor-sheet.js
@ -32,13 +32,14 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
      width: 550,
      showCompNiveauBase: false,
      vueArchetype: false,
-    }, { inplace: false });
+    });
  }

  /* -------------------------------------------- */
  async getData() {
    let formData = await super.getData();
-    foundry.utils.mergeObject(formData, {
+    foundry.utils.mergeObject(formData,
+      {
        editable: this.isEditable,
        cssClass: this.isEditable ? "editable" : "locked",
        limited: this.actor.limited,
--- a/module/actor.js
+++ b/module/actor.js
@ -902,7 +902,7 @@ export class RdDActor extends RdDBaseActorSang {
  async ajouterRefoulement(value = 1, refouler) {
    let refoulement = this.system.reve.refoulement.value + value;
    const roll = new Roll("1d20");
-    await roll.evaluate();
+    await roll.evaluate({ async: true });
    await roll.toMessage({ flavor: `${this.name} refoule ${refouler} pour ${value} points de refoulement (total: ${refoulement})` });
    if (roll.total <= refoulement) {
      refoulement = 0;
@ -991,7 +991,9 @@ export class RdDActor extends RdDBaseActorSang {

  /* -------------------------------------------- */
  buildTMRInnaccessible() {
-    return this.items.filter(it => it.type == TYPES.casetmr).filter(it => EffetsDraconiques.isInnaccessible(it)).map(it => it.system.coord)
+    return this.items[TYPES.casetmr]
+      .filter(it => EffetsDraconiques.isInnaccessible(it))
+      .map(it => it.system.coord)
  }

  /* -------------------------------------------- */
@ -1146,7 +1148,8 @@ export class RdDActor extends RdDBaseActorSang {
      diffNbDoses: -Number(this.system.compteurs.ethylisme.nb_doses || 0),
      finalLevel: 0,
      diffConditions: 0,
-      ajustementsForce: CONFIG.RDD.difficultesLibres
+      ajustementsForce: CONFIG.RDD.difficultesLibres,
+      config: game.system.rdd.config
    }
    let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/dialog-roll-ethylisme.html', rollData);
    new RdDRollDialogEthylisme(html, rollData, this, r => this.saouler(r.forceAlcool)).render(true);
@ -1548,9 +1551,6 @@ export class RdDActor extends RdDBaseActorSang {

  /* -------------------------------------------- */
  async appliquerAjoutExperience(rollData, hideChatMessage = 'show') {
-    if (!Misc.firstConnectedGM()){
-      return
-    }
    hideChatMessage = hideChatMessage == 'hide' || (Misc.isRollModeHiddenToPlayer() && !game.user.isGM)
    let xpData = await this._appliquerExperience(rollData.rolled, rollData.selectedCarac.label, rollData.competence, rollData.jetResistance);
    if (xpData.length) {
@ -2346,7 +2346,7 @@ export class RdDActor extends RdDBaseActorSang {

  async _xpCaracDerivee(xpData) {
    const caracs = RdDActor._getComposantsCaracDerivee(xpData.caracName)
-      .map(c => foundry.utils.mergeObject(this.system.carac[c], { isMax: this.isCaracMax(c) }, { inplace: false }))
+      .map(c => foundry.utils.mergeObject(this.system.carac[c], { isMax: this.isCaracMax(c) }))
    switch (caracs.filter(it => !it.isMax).length) {
      case 0:
        xpData.caracRepartitionManuelle = true;
@ -2628,13 +2628,13 @@ export class RdDActor extends RdDBaseActorSang {

  /* -------------------------------------------- */
  async resetItemUse() {
+    await this.unsetFlag(SYSTEM_RDD, 'itemUse');
    await this.setFlag(SYSTEM_RDD, 'itemUse', {});
  }

  /* -------------------------------------------- */
  async incDecItemUse(itemId, inc = 1) {
-    const currentItemUse = this.getFlag(SYSTEM_RDD, 'itemUse');
-    let itemUse = currentItemUse ? foundry.utils.duplicate(currentItemUse) : {};
+    let itemUse = foundry.utils.duplicate(this.getFlag(SYSTEM_RDD, 'itemUse') ?? {});
    itemUse[itemId] = (itemUse[itemId] ?? 0) + inc;
    await this.setFlag(SYSTEM_RDD, 'itemUse', itemUse);
    console.log("ITEM USE INC", inc, itemUse);
--- a/module/actor/base-actor-reve.js
+++ b/module/actor/base-actor-reve.js
@ -286,12 +286,12 @@ export class RdDBaseActorReve extends RdDBaseActor {

  getCarac() {
    // TODO: le niveau d'une entité de cauchemar devrait être exclu...
-    return foundry.utils.mergeObject(this.system.carac,
+    const carac = foundry.utils.mergeObject(foundry.utils.duplicate(this.system.carac),
      {
        'reve-actuel': this.getCaracReveActuel(),
        'chance-actuelle': this.getCaracChanceActuelle()
-      },
-      { inplace: false })
+      });
+    return carac;
  }

  /* -------------------------------------------- */
@ -318,10 +318,10 @@ export class RdDBaseActorReve extends RdDBaseActor {
  }

  /* -------------------------------------------- */
-  async rollCompetence(idOrName, options = { tryTarget: true, arme: undefined }) {
+  async rollCompetence(idOrName, options = { tryTarget: true }) {
    RdDEmpoignade.checkEmpoignadeEnCours(this)
    const competence = this.getCompetence(idOrName);
-    let rollData = { carac: this.system.carac, competence: competence, arme: options.arme }
+    let rollData = { carac: this.system.carac, competence: competence }
    if (competence.type == TYPES.competencecreature) {
      const arme = RdDItemCompetenceCreature.armeCreature(competence)
      if (arme && options.tryTarget && Targets.hasTargets()) {
@ -361,7 +361,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
   * @returns 
   */
  rollArme(arme, categorieArme = "competence") {
-    const compToUse = this.$getCompetenceArme(arme, categorieArme)
+    let compToUse = this.$getCompetenceArme(arme, categorieArme)
    if (!RdDItemArme.isArmeUtilisable(arme)) {
      ui.notifications.warn(`Arme inutilisable: ${arme.name} a une résistance de 0 ou moins`)
      return
@ -375,7 +375,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
        title: 'Ne pas utiliser les automatisation de combat',
        buttonLabel: "Pas d'automatisation",
        onAction: async () => {
-          this.rollCompetence(compToUse, { tryTarget: false, arme: arme })
+          this.rollCompetence(compToUse, { tryTarget: false })
        }
      });
      return
@ -508,8 +508,8 @@ export class RdDBaseActorReve extends RdDBaseActor {

  isEntiteAccordee(attacker) { return true }

-  async setEntiteReveAccordee(actor) {
-    ui.notifications.error("Impossible de s'accorder à " + this.name + ": ce n'est pas une entité incarnée");
+  async setEntiteReveAccordee(attacker) {
+    ui.notifications.error("Impossible de s'accorder à " + this.name + ": ce n'est pas une entite de cauchemer/rêve");
  }

 }
--- a/module/actor/base-actor-sheet.js
+++ b/module/actor/base-actor-sheet.js
@ -20,7 +20,7 @@ export class RdDBaseActorSheet extends ActorSheet {
      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }],
      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }],
      vueDetaillee: false
-    }, { inplace: false })
+    });
  }

  /* -------------------------------------------- */
@ -38,7 +38,8 @@ export class RdDBaseActorSheet extends ActorSheet {
      description: await TextEditor.enrichHTML(this.actor.system.description, { async: true }),
      notesmj: await TextEditor.enrichHTML(this.actor.system.notesmj, { async: true }),
      options: RdDSheetUtility.mergeDocumentRights(this.options, this.actor, this.isEditable),
-      effects: this.actor.effects
+      effects: this.actor.effects,
+      config: game.system.rdd.config
    }

    RdDBaseActorSheet.filterItemsPerTypeForSheet(formData, this.actor.itemTypes);
--- a/module/actor/base-actor.js
+++ b/module/actor/base-actor.js
@ -1,4 +1,3 @@
-import { ChatVente } from "../achat-vente/chat-vente.js";
 import { ChatUtility } from "../chat-utility.js";
 import { SYSTEM_SOCKET_ID } from "../constants.js";
 import { Grammar } from "../grammar.js";
@ -32,10 +31,10 @@ export class RdDBaseActor extends Actor {
  }

  static init() {
-    Hooks.on("preUpdateItem", (item, change, options, id) => Misc.documentIfResponsible(item.parent)?.onPreUpdateItem(item, change, options, id))
-    Hooks.on("createItem", (item, options, id) => Misc.documentIfResponsible(item.parent)?.onCreateItem(item, options, id))
-    Hooks.on("deleteItem", (item, options, id) => Misc.documentIfResponsible(item.parent)?.onDeleteItem(item, options, id))
-    Hooks.on("updateActor", (actor, change, options, actorId) => Misc.documentIfResponsible(actor)?.onUpdateActor(change, options, actorId))
+    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) {
@ -82,6 +81,10 @@ export class RdDBaseActor extends Actor {

  static extractActorMin = (actor) => { return { id: actor?.id, type: actor?.type, name: actor?.name, img: actor?.img }; };

+  static getParentActor(document) {
+    return document?.parent instanceof Actor ? document.parent : undefined
+  }
+
  /**
   * Cette methode surcharge Actor.create() pour ajouter si besoin des Items par défaut:
   * compétences et monnaies.
@ -121,7 +124,6 @@ export class RdDBaseActor extends Actor {
        return new ActorConstructor(docData, context);
      }
    }
-    context.rdd = undefined
    super(docData, context);
  }

@ -232,7 +234,6 @@ export class RdDBaseActor extends Actor {

  /* -------------------------------------------- */
  async cleanupConteneurs() {
-    if (Misc.isOwnerPlayerOrUniqueConnectedGM(this)) {
    let updates = this.itemTypes['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) } });
@ -240,7 +241,6 @@ export class RdDBaseActor extends Actor {
      await this.updateEmbeddedDocuments("Item", updates)
    }
  }
-  }

  /* -------------------------------------------- */
  getFortune() {
@ -360,9 +360,12 @@ export class RdDBaseActor extends Actor {
      ChatUtility.notifyUser(achat.userId, 'warn', `Vous n'avez pas assez d'argent pour payer ${Math.ceil(cout / 100)} sols !`);
      return;
    }
-    await vendeur?.vendre(itemVendu, quantite, cout);
-    await acheteur?.acheter(itemVendu, quantite, cout, achat)
-
+    await this.decrementerVente(vendeur, itemVendu, quantite, cout);
+    if (acheteur) {
+      await acheteur.depenserSols(cout);
+      const createdItemId = await acheteur.creerQuantiteItem(itemVendu, quantite);
+      await acheteur.consommerNourritureAchetee(achat, achat.vente, createdItemId);
+    }
    if (cout > 0) {
      RdDAudio.PlayContextAudio("argent");
    }
@ -376,26 +379,24 @@ export class RdDBaseActor extends Actor {
    });

    if (!achat.vente.quantiteIllimite) {
-      if (achat.vente.nbLots <= achat.choix.nombreLots) {
+      if (achat.vente.quantiteNbLots <= achat.choix.nombreLots) {
        ChatUtility.removeChatMessageId(achat.chatMessageIdVente);
      }
      else if (achat.chatMessageIdVente) {
-        await ChatVente.diminuerQuantiteAchatVente(achat.chatMessageIdVente, achat.choix.nombreLots)
+        achat.vente.properties = itemVendu.getProprietes();
+        achat.vente.quantiteNbLots -= achat.choix.nombreLots;
+        achat.vente.jsondata = JSON.stringify(achat.vente.item);
+        const messageVente = game.messages.get(achat.chatMessageIdVente);
+        messageVente.update({ content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-vente-item.html', achat.vente) });
+        messageVente.render(true);
      }
    }
  }

-  async vendre(item, quantite, cout) {
-    await this.ajouterSols(cout);
-    await this.decrementerQuantiteItem(item, quantite);
-  }
-
-  async acheter(item, quantite, cout, achat) {
-    await this.depenserSols(cout)
-    const createdItemId = await this.creerQuantiteItem(item, quantite)
-    if (achat.choix.consommer && item.type == 'nourritureboisson' && createdItemId != undefined) {
-      achat.choix.doses = achat.choix.nombreLots;
-      await this.consommerNourritureboisson(createdItemId, achat.choix, achat.vente.actingUserId);
+  async decrementerVente(vendeur, itemVendu, quantite, cout) {
+    if (vendeur) {
+      await vendeur.ajouterSols(cout);
+      await vendeur.decrementerQuantiteItem(itemVendu, quantite);
    }
  }

@ -408,28 +409,31 @@ export class RdDBaseActor extends Actor {
    return disponible == undefined || disponible >= quantiteDemande;
  }

-  async consommerNourritureboisson(itemId, choix, userId) { }
+  async consommerNourritureAchetee(achat, vente, createdItemId) {
+    if (achat.choix.consommer && vente.item.type == 'nourritureboisson' && createdItemId != undefined) {
+      achat.choix.doses = achat.choix.nombreLots;
+      await this.consommerNourritureboisson(createdItemId, achat.choix, vente.actingUserId);
+    }
+  }
+

  async decrementerQuantiteItem(item, quantite, options = { supprimerSiZero: true }) {
    if (item.isService()) {
      return;
    }
-    const itemId = item.id;
    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: itemId, 'system.quantite': 0 }]);
+        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) {
-      const realItem = this.getItem(item.id)
-      realItem.update({ 'system.quantite': resteQuantite });
      await this.updateEmbeddedDocuments("Item", [{ _id: item.id, 'system.quantite': resteQuantite }]);
    }
  }
@ -441,7 +445,7 @@ export class RdDBaseActor extends Actor {
        type: item.type,
        img: item.img,
        name: item.name,
-        system: foundry.utils.mergeObject(item.system, { quantite: isItemEmpilable ? quantite : undefined }, { inplace: false })
+        system: foundry.utils.mergeObject(item.system, { quantite: isItemEmpilable ? quantite : undefined })
      };
      const newItems = isItemEmpilable ? [baseItem] : Array.from({ length: quantite }, (_, i) => baseItem);
      const items = await this.createEmbeddedDocuments("Item", newItems);
@ -557,15 +561,15 @@ export class RdDBaseActor extends Actor {
  /* -------------------------------------------- */
  /** Ajoute un item dans un conteneur, sur la base de leurs ID */
  async ajouterDansConteneur(item, conteneur, onAjouterDansConteneur) {
-    if (conteneur?.isConteneur()) {
+    if (!conteneur) {
+      // TODO: afficher
+      item.estContenu = false;
+    }
+    else if (conteneur.isConteneur()) {
      item.estContenu = true;
      const nouveauContenu = [...conteneur.system.contenu, item.id];
      await conteneur.update({ 'system.contenu': nouveauContenu });
-      onAjouterDansConteneur(item.id, conteneur.id)
-    }
-    else {
-      item.estContenu = false;
-      await conteneur?.update({ 'system.-=contenu': undefined })
+      onAjouterDansConteneur(item.id, conteneur.id);
    }
  }

@ -583,14 +587,9 @@ export class RdDBaseActor extends Actor {
          if (item.estContenu) {
            item.estContenu = undefined;
          }
-          if (item.system.contenu != undefined) {
-            if (item.type == 'conteneur') {
+          if (item.type == 'conteneur' && item.system.contenu.length > 0) {
            corrections.push({ _id: item.id, 'system.contenu': [] });
          }
-            else {
-              corrections.push({ _id: item.id, 'system.-=contenu': undefined });
-            }
-          }
        }
        if (corrections.length > 0) {
          await this.updateEmbeddedDocuments('Item', corrections);
@ -624,21 +623,15 @@ export class RdDBaseActor extends Actor {
  }

  /* -------------------------------------------- */
-  /**
-   * Supprime un item d'un conteneur, sur la base de leurs ID
-   */
+  /** Supprime un item d'un conteneur, sur la base
+   * de leurs ID */
  async enleverDeConteneur(item, conteneur, onEnleverDeConteneur) {
-    if (conteneur) {
-      if (conteneur.isConteneur()) {
+    if (conteneur?.isConteneur()) {
+      item.estContenu = false;
      const contenu = conteneur.system.contenu.filter(id => id != item.id);
      await conteneur.update({ 'system.contenu': contenu });
      onEnleverDeConteneur();
    }
-      else {
-        await conteneur.update({ 'system.-=contenu': undefined })
-      }
-    }
-    item.estContenu = false;
  }

  /* -------------------------------------------- */
--- a/module/actor/commerce-sheet.js
+++ b/module/actor/commerce-sheet.js
@ -1,4 +1,4 @@
-import { DialogItemAchat } from "../achat-vente/dialog-item-achat.js";
+import { DialogItemAchat } from "../dialog-item-achat.js";
 import { RdDItem } from "../item.js";
 import { RdDUtility } from "../rdd-utility.js";
 import { RdDBaseActorSheet } from "./base-actor-sheet.js";
@ -15,7 +15,7 @@ export class RdDCommerceSheet extends RdDBaseActorSheet {
      template: "systems/foundryvtt-reve-de-dragon/templates/actor/commerce-actor-sheet.html",
      width: 600, height: 720,
      tabs: []
-    }, { inplace: false })
+    });
  }
  get title() {
    if (this.actor.token && this.actor.token != this.actor.prototypeToken) {
--- a/module/actor/commerce.js
+++ b/module/actor/commerce.js
@ -25,7 +25,8 @@ export class RdDCommerce extends RdDBaseActor {
    }
    await super.depenserSols(cout)
  }
-  async consommerNourritureboisson(itemId, choix, userId) { 
+
+  async consommerNourritureAchetee(achat, vente, createdItemId) {
    // ne pas consommer pour un commerce
  }

--- a/module/actor/creature-sheet.js
+++ b/module/actor/creature-sheet.js
@ -12,7 +12,7 @@ export class RdDCreatureSheet extends RdDBaseActorSangSheet {
    return foundry.utils.mergeObject(RdDBaseActorSangSheet.defaultOptions, {
      template: "systems/foundryvtt-reve-de-dragon/templates/actor-creature-sheet.html",
      width: 640, height: 720
-    }, { inplace: false })
+    });
  }

  /* -------------------------------------------- */
--- a/module/actor/creature.js
+++ b/module/actor/creature.js
@ -33,4 +33,27 @@ export class RdDCreature extends RdDBaseActorSang {
    }
  }

+  isEntiteAccordee(attacker) {
+    if (this.isEntite([ENTITE_INCARNE])) {
+      let resonnance = this.system.sante.resonnance
+      return (resonnance.actors.find(it => it == attacker.id))
+    }
+    return true
+  }
+
+  /* -------------------------------------------- */
+  async setEntiteReveAccordee(attacker) {
+    if (this.isEntite([ENTITE_INCARNE])) {
+      let resonnance = foundry.utils.duplicate(this.system.sante.resonnance);
+      if (resonnance.actors.find(it => it == attacker.id)) {
+        // déjà accordé
+        return;
+      }
+      await this.update({ "system.sante.resonnance": [...resonnance, attacker.id] });
+    }
+    else {
+      super.setEntiteReveAccordee(attacker)
+    }
+  }
+
 }
--- a/module/actor/entite-sheet.js
+++ b/module/actor/entite-sheet.js
@ -9,7 +9,7 @@ export class RdDActorEntiteSheet extends RdDBaseActorReveSheet {
    return foundry.utils.mergeObject(RdDBaseActorReveSheet.defaultOptions, {
      template: "systems/foundryvtt-reve-de-dragon/templates/actor-entite-sheet.html",
      width: 640, height: 720,
-    }, { inplace: false })
+    });
  }

  async getData() {
@ -54,12 +54,6 @@ export class RdDActorEntiteSheet extends RdDBaseActorReveSheet {
    });
  }

-  async _onDropActor(event, dragData) {
-    const dropActor = fromUuidSync(dragData.uuid)
-    await this.actor.setEntiteReveAccordee(dropActor)
-    super._onDropActor(event, dragData)
-  }
-
  async deleteSubActeur(actorId) {
    let newResonances = this.actor.system.sante.resonnance.actors.filter(id => id != actorId);
    await this.actor.update({ 'system.sante.resonnance.actors': newResonances }, { renderSheet: false });
--- a/module/actor/entite.js
+++ b/module/actor/entite.js
@ -91,16 +91,20 @@ export class RdDEntite extends RdDBaseActorReve {
  }

  /* -------------------------------------------- */
-  async setEntiteReveAccordee(actor) {
+  async setEntiteReveAccordee(attacker) {
    if (this.isEntite([ENTITE_INCARNE])) {
-      if (this.system.sante.resonnance.actors.find(it => it == actor.id)) {
+      let resonnance = foundry.utils.duplicate(this.system.sante.resonnance);
+      if (resonnance.actors.find(it => it == attacker.id)) {
        // déjà accordé
-        return
+        return;
      }
-      await this.update({ "system.sante.resonnance.actors": [...this.system.sante.resonnance.actors, actor.id] })
+      resonnance.actors.push(attacker.id);
+      await this.update({ "system.sante.resonnance": resonnance });
    }
    else {
-      super.setEntiteReveAccordee(actor)
+      super.setEntiteReveAccordee(attacker)
    }
  }
+
+
 }
--- a/module/actor/vehicule-sheet.js
+++ b/module/actor/vehicule-sheet.js
@ -9,7 +9,7 @@ export class RdDActorVehiculeSheet extends RdDBaseActorSheet {
    return foundry.utils.mergeObject(RdDBaseActorSheet.defaultOptions, {
      template: "systems/foundryvtt-reve-de-dragon/templates/actor-vehicule-sheet.html",
      width: 640, height: 720,
-    }, { inplace: false })
+    });
  }

  /* -------------------------------------------- */
--- a/module/chat-utility.js
+++ b/module/chat-utility.js
@ -149,13 +149,14 @@ export class ChatUtility {
  }

  static async setMessageData(chatMessage, key, flag) {
-    if (flag && chatMessage.isAuthor) {
-      await chatMessage.setFlag(SYSTEM_RDD, key, flag)
+    if (flag) {
+      await chatMessage.setFlag(SYSTEM_RDD, key, JSON.stringify(flag));
    }
  }

  static getMessageData(chatMessage, key) {
-    return chatMessage.getFlag(SYSTEM_RDD, key);
+    const json = chatMessage.getFlag(SYSTEM_RDD, key);
+    return json ? JSON.parse(json) : undefined;
  }

  static getChatMessage(event) {
@ -174,8 +175,6 @@ export class ChatUtility {
  }

  static async onCreateChatMessage(chatMessage, options, id) {
-    if (chatMessage.isAuthor) {
    await chatMessage.setFlag(SYSTEM_RDD, 'rdd-timestamp', game.system.rdd.calendrier.getTimestamp());
  }
-  }
 }
--- a/module/coeur/rdd-coeur.js
+++ b/module/coeur/rdd-coeur.js
@ -117,8 +117,8 @@ export class RdDCoeur {
    }
    ChatUtility.removeChatMessageId(infoCoeur.chatMessageId)

-    infoCoeur.target.jetTendre = (await (new Roll('1d6').evaluate())).total
-    infoCoeur.source.jetTendre = (await (new Roll('1d6').evaluate())).total
+    infoCoeur.target.jetTendre = (await (new Roll('1d6').evaluate({ async: true }))).total
+    infoCoeur.source.jetTendre = (await (new Roll('1d6').evaluate({ async: true }))).total
    const diff = Math.abs(infoCoeur.source.jetTendre - infoCoeur.target.jetTendre)
    for (let amoureux of [infoCoeur.source, infoCoeur.target]) {
      const actorAmoureux = game.actors.get(amoureux.actor.id);
--- a/module/constants.js
+++ b/module/constants.js
@ -29,25 +29,5 @@ export const RDD_CONFIG = {
    "incarne": "Incarnée",
    "nonincarne": "Non Incarnée",
    "blurette": "Blurette"
-  },
-  heuresRdD : [
-    {value : "vaisseau", label: "Vaisseau", img: "modules/foundryvtt-reve-de-dragon/icons/heures/hd01.webp"},
-    {value : "sirene", label: "Sirène", img: "modules/foundryvtt-reve-de-dragon/icons/heures/hd02.webp"},
-    {value : "faucon", label: "Faucon", img: "modules/foundryvtt-reve-de-dragon/icons/heures/hd03.webp"},
-    {value : "couronne", label: "Couronne", img: "modules/foundryvtt-reve-de-dragon/icons/heures/hd04.webp"},
-    {value : "dragon", label: "Dragon", img: "modules/foundryvtt-reve-de-dragon/icons/heures/hd05.webp"},
-    {value : "epees", label: "Epées", img: "modules/foundryvtt-reve-de-dragon/icons/heures/hd06.webp"},
-    {value : "lyre", label: "Lyre", img: "modules/foundryvtt-reve-de-dragon/icons/heures/hd07.webp"},
-    {value : "serpent", label: "Serpent", img: "modules/foundryvtt-reve-de-dragon/icons/heures/hd08.webp"},
-    {value : "poissonacrobate", label: "Poisson Acrobate", img: "modules/foundryvtt-reve-de-dragon/icons/heures/hd09.webp"},
-    {value : "araignee", label: "Araignée", img: "modules/foundryvtt-reve-de-dragon/icons/heures/hd10.webp"},
-    {value : "roseau", label: "Roseau", img: "modules/foundryvtt-reve-de-dragon/icons/heures/hd11.webp"},
-    {value : "chateaudormant", label: "Chateau Dormant", img: "modules/foundryvtt-reve-de-dragon/icons/heures/hd12.webp"}    
-  ],
-  raretes: [
-    {value: "Commune", label: "Commune"},
-    {value: "Frequente", label: "Fréquente"},
-    {value: "Rare", label: "Rare"},
-    {value: "Rarissime", label: "Rarissime"}
-  ]
+  }
 }
--- a/module/achat-vente/dialog-item-achat.js
+++ b/module/achat-vente/dialog-item-achat.js
@ -1,12 +1,34 @@
-import { Misc } from "../misc.js";
-import { RdDUtility } from "../rdd-utility.js";
-import { ChatVente } from "./chat-vente.js";
+import { Misc } from "./misc.js";
+import { RdDUtility } from "./rdd-utility.js";

 export class DialogItemAchat extends Dialog {

  static preparerAchat(chatButton) {
-    return ChatVente.getDetailAchatVente(RdDUtility.findChatMessageId(chatButton))
+    const vendeurId = chatButton.attributes['data-vendeurId']?.value;
+    const vendeur = vendeurId ? game.actors.get(vendeurId) : undefined;
+    const acheteur = RdDUtility.getSelectedActor();
+    const json = chatButton.attributes['data-jsondata']?.value;
+    if (!acheteur && !vendeur) {
+      ui.notifications.info("Pas d'acheteur ni de vendeur, aucun changement");
+      return undefined;
    }
+    if (!json) {
+      ui.notifications.warn("Impossible d'acheter: informations sur l'objet manquantes")
+      return undefined;
+    }
+
+    return {
+      item: JSON.parse(json),
+      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({ item, vendeur, acheteur, tailleLot, prixLot, nbLots, quantiteIllimite, chatMessageIdVente }) {
    const venteData = {
@ -16,21 +38,17 @@ export class DialogItemAchat extends Dialog {
      acheteur,
      tailleLot,
      quantiteIllimite,
-      nbLots,
+      quantiteNbLots: nbLots,
      choix: { seForcer: false, supprimerSiZero: true },
      prixLot,
      isVente: prixLot > 0,
      isConsommable: item.type == 'nourritureboisson' && acheteur?.isPersonnage(),
      chatMessageIdVente
-    }
-    if (venteData.vendeur?.id == venteData.acheteur?.id) {
-      ui.notifications.info("Inutile de se vendre à soi-même")
-      return
-    }
+    };

-    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)
+    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) {
@ -98,18 +116,18 @@ export class DialogItemAchat extends Dialog {
    this.venteData.choix.seForcer = event.currentTarget.checked;
  }

-  setNombreLots(nbLots) {
+  setNombreLots(nombreLots) {

    if (!this.venteData.quantiteIllimite) {
-      if (!this.venteData.quantiteIllimite && nbLots > this.venteData.nbLots) {
-        ui.notifications.warn(`Seulement ${this.venteData.nbLots} lots disponibles, vous ne pouvez pas en prendre ${nbLots}`)
+      if (!this.venteData.quantiteIllimite && nombreLots > this.venteData.quantiteNbLots) {
+        ui.notifications.warn(`Seulement ${this.venteData.quantiteNbLots} lots disponibles, vous ne pouvez pas en prendre ${nombreLots}`)
      }
-      nbLots = Math.min(nbLots, this.venteData.nbLots);
+      nombreLots = Math.min(nombreLots, this.venteData.quantiteNbLots);
    }

-    DialogItemAchat.changeNombreLots(this.venteData, nbLots);
+    DialogItemAchat.changeNombreLots(this.venteData, nombreLots);

-    this.html.find(".nombreLots").val(nbLots);
+    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);
--- a/module/achat-vente/dialog-item-vente.js
+++ b/module/achat-vente/dialog-item-vente.js
@ -1,30 +1,29 @@
-import { HtmlUtility } from "../html-utility.js";
-import { RdDUtility } from "../rdd-utility.js";
-import { ChatVente } from "./chat-vente.js";
+import { HtmlUtility } from "./html-utility.js";

 export class DialogItemVente extends Dialog {

-  static async display({ item, quantiteMax = undefined }) {
+  static async display({ item, callback, quantiteMax = undefined }) {
    const quantite = quantiteMax ?? item.getQuantite() ?? 1;
+    const isOwned = item.parent;
    const venteData = {
      item: item,
      alias: item.actor?.name ?? game.user.name,
-      vendeurId: item.actor.id,
+      vendeurId: item.actor?.id,
      prixOrigine: item.calculerPrixCommercant(),
      prixUnitaire: item.calculerPrixCommercant(),
      prixLot: item.calculerPrixCommercant(),
      tailleLot: 1,
-      nbLots: quantite,
-      maxLots: quantite,
+      quantiteNbLots: quantite,
+      quantiteMaxLots: quantite,
      quantiteMax: quantite,
-      quantiteIllimite: item.isItemCommerce() ? quantiteMax == undefined : !item.parent,
-      isOwned:  item.parent,
-    }
+      quantiteIllimite: item.isItemCommerce() ? quantiteMax == undefined : !isOwned,
+      isOwned: isOwned,
+    };
    const html = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/dialog-item-vente.html`, venteData);
-    return new DialogItemVente(venteData, html).render(true);
+    return new DialogItemVente(venteData, html, callback).render(true);
  }

-  constructor(venteData, html) {
+  constructor(venteData, html, callback) {
    let options = { classes: ["dialogvente"], width: 400, height: 'fit-content', 'z-index': 99999 };

    let conf = {
@ -35,6 +34,7 @@ export class DialogItemVente extends Dialog {
    };

    super(conf, options);
+    this.callback = callback;
    this.venteData = venteData;
  }

@ -43,7 +43,7 @@ export class DialogItemVente extends Dialog {

    this.html = html;
    this.html.find(".tailleLot").change(event => this.setTailleLot(Number(event.currentTarget.value)));
-    this.html.find(".nbLots").change(event => this.setNbLots(Number(event.currentTarget.value)));
+    this.html.find(".quantiteNbLots").change(event => this.setNbLots(Number(event.currentTarget.value)));
    this.html.find(".quantiteIllimite").change(event => this.setQuantiteIllimite(event.currentTarget.checked));
    this.html.find(".prixLot").change(event => this.setPrixLot(Number(event.currentTarget.value)));

@ -52,15 +52,7 @@ export class DialogItemVente extends Dialog {

  async onProposer(it) {
    this.updateVente(this.getChoixVente());
-
-    this.venteData["properties"] = this.venteData.item.getProprietes();
-    if (this.venteData.isOwned) {
-      if (this.venteData.nbLots * this.venteData.tailleLot > this.venteData.quantiteMax) {
-        ui.notifications.warn(`Vous avez ${this.venteData.quantiteMax} ${this.venteData.item.name}, ce n'est pas suffisant pour vendre ${this.venteData.nbLots} de ${this.venteData.tailleLot}`)
-        return;
-      }
-    }
-    await ChatVente.displayAchatVente(this.venteData)
+    this.callback(this.venteData);
  }

  updateVente(update) {
@ -69,7 +61,7 @@ export class DialogItemVente extends Dialog {

  getChoixVente() {
    return {
-      nbLots: Number(this.html.find(".nbLots").val()),
+      quantiteNbLots: Number(this.html.find(".quantiteNbLots").val()),
      tailleLot: Number(this.html.find(".tailleLot").val()),
      quantiteIllimite: this.html.find(".quantiteIllimite").is(':checked'),
      prixLot: Number(this.html.find(".prixLot").val())
@ -85,26 +77,26 @@ export class DialogItemVente extends Dialog {
    const maxLots = Math.floor(this.venteData.quantiteMax / tailleLot);
    this.updateVente({
      tailleLot,
-      nbLots: Math.min(maxLots, this.venteData.nbLots),
-      maxLots: maxLots,
+      quantiteNbLots: Math.min(maxLots, this.venteData.quantiteNbLots),
+      quantiteMaxLots: maxLots,
      prixLot: (tailleLot * this.venteData.prixOrigine).toFixed(2)
    });

    this.html.find(".prixLot").val(this.venteData.prixLot);
-    this.html.find(".nbLots").val(this.venteData.nbLots);
-    this.html.find(".nbLots").attr("max", this.venteData.maxLots)
+    this.html.find(".quantiteNbLots").val(this.venteData.quantiteNbLots);
+    this.html.find(".quantiteNbLots").attr("max", this.venteData.quantiteMaxLots)
  }

  setNbLots(nbLots) {
    this.updateVente({
-      nbLots: this.venteData.isOwned ? Math.max(0, Math.min(nbLots, this.venteData.maxLots)) : nbLots
+      quantiteNbLots: this.venteData.isOwned ? Math.max(0, Math.min(nbLots, this.venteData.quantiteMaxLots)) : nbLots
    })
-    this.html.find(".nbLots").val(this.venteData.nbLots);
+    this.html.find(".quantiteNbLots").val(this.venteData.quantiteNbLots);
  }

  setQuantiteIllimite(checked) {
    this.updateVente({ quantiteIllimite: checked })
    this.html.find(".label-quantiteIllimite").text(this.venteData.quantiteIllimite ? "Illimités" : "disponibles");
-    HtmlUtility.showControlWhen(this.html.find(".nbLots"), !this.venteData.quantiteIllimite)
+    HtmlUtility.showControlWhen(this.html.find(".quantiteNbLots"), !this.venteData.quantiteIllimite)
  }
 }
--- a/module/item-competence.js
+++ b/module/item-competence.js
@ -199,7 +199,7 @@ export class RdDItemCompetence extends Item {
    if (idOrName == undefined || idOrName == "") {
      return RdDItemCompetence.sansCompetence();
    }
-    options = foundry.utils.mergeObject(options, { preFilter: it => it.isCompetence(), description: 'compétence' }, { overwrite: false, inplace: false });
+    options = foundry.utils.mergeObject(options, { preFilter: it => it.isCompetence(), description: 'compétence' }, { overwrite: false });
    return RdDItemCompetence.findFirstItem(list, idOrName, options);
  }

--- a/module/item-competencecreature.js
+++ b/module/item-competencecreature.js
@ -33,7 +33,8 @@ export class RdDItemCompetenceCreature extends Item {
    if (categorieAttaque != undefined) {
      // si c'est un Item compétence: cloner pour ne pas modifier la compétence
      let arme = item.clone();
-      return foundry.utils.mergeObject(arme, {
+      foundry.utils.mergeObject(arme,
+        {
          action: item.isCompetencePossession() ? 'possession' : 'attaque',
          system: {
            competence: arme.name,
@ -47,7 +48,8 @@ export class RdDItemCompetenceCreature extends Item {
            force: 0,
            rapide: true,
          }
-        }, { inplace: false });
+        });
+      return arme;
    }
    return undefined;
  }
--- a/module/item-sheet.js
+++ b/module/item-sheet.js
@ -44,7 +44,7 @@ export class RdDItemSheet extends ItemSheet {
      template: RdDItemSheet.defaultTemplate(RdDItemSheet.ITEM_TYPE),
      width: 550,
      height: 550
-    }, { inplace: false });
+    });
  }

  /* -------------------------------------------- */
@ -53,8 +53,7 @@ export class RdDItemSheet extends ItemSheet {
  }

  get title() {
-    const owner = (this.item.parent instanceof Actor) ? `(${this.item.parent.name})` : '';
-    return `${Misc.typeName('Item', this.item.type)}: ${this.item.name} ${owner}`;
+    return `${Misc.typeName('Item', this.item.type)}: ${this.item.name}`;
  }

  /* -------------------------------------------- */
@ -99,7 +98,7 @@ export class RdDItemSheet extends ItemSheet {
      description: await TextEditor.enrichHTML(this.item.system.description, { async: true }),
      descriptionmj: await TextEditor.enrichHTML(this.item.system.descriptionmj, { async: true }),
      isComestible: this.item.getUtilisationCuisine(),
-      options: RdDSheetUtility.mergeDocumentRights(this.options, this.item, this.isEditable),
+      options: RdDSheetUtility.mergeDocumentRights(this.options, this.item, this.isEditable)
    }
    if (this.item.type == TYPES.competencecreature) {
      formData.isparade = RdDItemCompetenceCreature.isParade(this.item)
@ -109,8 +108,8 @@ export class RdDItemSheet extends ItemSheet {
    const competences = await SystemCompendiums.getCompetences('personnage');
    formData.categories = this.item.getCategories()
    if (this.item.type == 'tache' || this.item.type == 'livre' || this.item.type == 'meditation' || this.item.type == 'oeuvre') {
-      formData.caracList = foundry.utils.duplicate(game.model.Actor.personnage.carac)
-      formData.caracList["reve-actuel"] = foundry.utils.duplicate(game.model.Actor.personnage.reve.reve)
+      formData.caracList = foundry.utils.duplicate(game.system.model.Actor.personnage.carac)
+      formData.caracList["reve-actuel"] = foundry.utils.duplicate(game.system.model.Actor.personnage.reve.reve)
      formData.competences = competences;
    }
    if (this.item.type == 'arme') {
--- a/module/item.js
+++ b/module/item.js
@ -1,4 +1,4 @@
-import { DialogItemVente } from "./achat-vente/dialog-item-vente.js";
+import { DialogItemVente } from "./dialog-item-vente.js";
 import { Grammar } from "./grammar.js";
 import { Misc } from "./misc.js";
 import { RdDHerbes } from "./rdd-herbes.js";
@ -189,7 +189,6 @@ export class RdDItem extends Item {
    if (!docData.img) {
      docData.img = RdDItem.getDefaultImg(docData.type);
    }
-    context.rdd = undefined
    super(docData, context);
  }

@ -234,7 +233,7 @@ export class RdDItem extends Item {
  }

  isCompetenceArme() {
-    return this.isCompetence() && ['melee', 'tir', 'lancer'].includes(this.system.categorie)
+    return this.isCompetence() && [ 'melee','tir', 'lancer'].includes(this.system.categorie)
  }

  isCompetencePossession() { return TYPES.competencecreature == this.type && this.system.categorie == "possession" }
@ -539,7 +538,7 @@ export class RdDItem extends Item {
          _id: this.id,
          'system.quantite': this.system.quantite * sust,
          'system.encombrement': Misc.keepDecimals(this.system.encombrement / sust, 2),
-          'system.cout': Math.max(0, Misc.keepDecimals(this.system.cout / sust, 2)),
+          'system.cout': Misc.keepDecimals(this.system.cout / sust, 2),
          'system.sust': 1
        }])
      }
@ -622,7 +621,23 @@ export class RdDItem extends Item {
      ui.notifications.warn(`Votre ${this.name} n'est pas vide, pas possible de le proposer`);
      return;
    }
-    await DialogItemVente.display({ item: this, quantiteMax })
+    await DialogItemVente.display({
+      item: this,
+      quantiteMax,
+      callback: async (vente) => {
+        vente["properties"] = this.getProprietes();
+        if (vente.isOwned) {
+          if (vente.quantiteNbLots * vente.tailleLot > vente.quantiteMax) {
+            ui.notifications.warn(`Vous avez ${vente.quantiteMax} ${vente.item.name}, ce n'est pas suffisant pour vendre ${vente.quantiteNbLots} de ${vente.tailleLot}`)
+            return;
+          }
+        }
+        vente.jsondata = JSON.stringify(vente.item);
+
+        let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-vente-item.html', vente);
+        ChatMessage.create(RdDUtility.chatDataSetup(html));
+      }
+    });
  }

  /* -------------------------------------------- */
--- a/module/item/blessure.js
+++ b/module/item/blessure.js
@ -39,7 +39,7 @@ export class RdDItemBlessure extends RdDItem {
      ui.notifications.warn(`Pas de tâche de soins pour une blessure ${gravite}`)
      return undefined;
    }
-    return foundry.utils.mergeObject(BASE_TACHE_SOIN_BLESSURE, tache, { inplace: false })
+    return foundry.utils.mergeObject(foundry.utils.duplicate(BASE_TACHE_SOIN_BLESSURE), tache)
  }

  static async applyFullBlessure(actor, gravite) {
@ -48,7 +48,7 @@ export class RdDItemBlessure extends RdDItem {
    let lostEndurance = 0
    let lostVie = 0
    if (definition.endurance) {
-      lostEndurance = await new Roll(definition.endurance).roll().total;
+      lostEndurance = new Roll(definition.endurance).roll({async: false}).total;
      actor.santeIncDec("endurance", -Number(lostEndurance));
    }
    if (definition.vie) {
@ -106,12 +106,12 @@ export class RdDItemBlessure extends RdDItem {
  }

  async setSoinsBlessure(systemUpdate = {}) {
-    systemUpdate = foundry.utils.mergeObject(systemUpdate, this.system, { overwrite: false })
+    systemUpdate = foundry.utils.mergeObject(systemUpdate, this.system, { overwrite: false }),
      systemUpdate.soinscomplets.done = systemUpdate.premierssoins.done && systemUpdate.soinscomplets.done
    await this.update({
      img: this.getImgSoins(systemUpdate.gravite, systemUpdate.soinscomplets.done),
      system: systemUpdate
-    })
+    });
  }

  async recuperationBlessure({ actor, timestamp, message, isMaladeEmpoisonne, blessures }) {
--- a/module/item/sheet-base-inventaire.js
+++ b/module/item/sheet-base-inventaire.js
@ -10,7 +10,7 @@ export class RdDItemInventaireSheet extends RdDItemSheet {
  static get defaultOptions() {
    return foundry.utils.mergeObject(RdDItemSheet.defaultOptions, {
      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "informations" }]
-    }, { inplace: false })
+    });
  }

  setPosition(options = {}) {
@ -23,10 +23,9 @@ export class RdDItemInventaireSheet extends RdDItemSheet {

  async getData() {
    const formData = await super.getData();
-    foundry.utils.mergeObject(formData, {
+    return foundry.utils.mergeObject(formData, {
      milieux: await game.system.rdd.environnement.autresMilieux(this.item)
-    })
-    return formData
+    });
  }

  activateListeners(html) {
--- a/module/item/sheet-rencontre.js
+++ b/module/item/sheet-rencontre.js
@ -8,7 +8,7 @@ export class RdDRencontreItemSheet extends RdDItemSheet {
  static get defaultOptions() {
    return foundry.utils.mergeObject(super.defaultOptions, {
      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }]
-    }, { inplace: false })
+    });
  }

  /* -------------------------------------------- */
@ -35,7 +35,7 @@ export class RdDRencontreItemSheet extends RdDItemSheet {
          select: RdDRencontre.mapEffets(this.item.system.echec.effets)
        }
      }
-    })
+    });
    return formData;
  }

--- a/module/migrations.js
+++ b/module/migrations.js
@ -567,9 +567,9 @@ export class Migrations {
    if (currentVersion.startsWith("v")) {
      currentVersion = currentVersion.substring(1)
    }
-    if (foundry.utils.isNewerVersion(game.system.version, currentVersion)) {
+    if (isNewerVersion(game.system.version, currentVersion)) {
      // if (true) { /* comment previous and uncomment here to test before upgrade  */
-      const migrations = Migrations.getMigrations().filter(m => foundry.utils.isNewerVersion(m.version, currentVersion));
+      const migrations = Migrations.getMigrations().filter(m => isNewerVersion(m.version, currentVersion));
      if (migrations.length > 0) {
        migrations.sort((a, b) => this.compareVersions(a, b));
        migrations.forEach(async (m) => {
--- a/module/misc.js
+++ b/module/misc.js
@ -166,47 +166,15 @@ export class Misc {
  }

  static firstConnectedGM() {
-    if (foundry.utils.isNewerVersion(game.release.version, '12.0')) {
-      return game.users.activeGM
-    } 
-    return game.users.find(u => u.isGM && u.active);
+    return game.users.filter(u => u.isGM && u.active).sort(Misc.ascending(u => u.id)).find(u => u.isGM && u.active);
  }

-  static connectedGMs() {
-    return game.users.filter(u => u.isGM && u.active);
+  static isOwnerPlayer(actor, user = undefined) {
+    return actor.testUserPermission(user ?? game.user, CONST.DOCUMENT_PERMISSION_LEVELS.OWNER)
  }

-  /**
-   * This helper method allows to get the docuument, for a single user (either first connected GM, or the owner
-   * if there is no connected GMs), or else return undefined.
-   * 
-   * This allows for example update hooks that should apply modifications to actors to be called only for one
-   * user (preventing the "User ... lacks permission to update Item" that was occuring on hooks when Item updates
-   * were triggering other changes)
-   * 
-   * @param {*} document the Document with is potentially an Actor
-   * @returns the actor if either the game.user is the first connected GM, or if the game.user is the owner
-   *  and there is no connected GM
-   */
-  static documentIfResponsible(document) {
-    if (foundry.utils.isNewerVersion(game.release.version, '12.0')) {
-      if (game.users.activeGM || (Misc.connectedGMs().length == 0 && Misc.isOwnerPlayer(document)))
-      {
-        return document
-      }
-    }
-    else if (Misc.isUniqueConnectedGM() || (Misc.connectedGMs().length == 0 && Misc.isOwnerPlayer(document))) {
-      return document
-    }
-    return undefined
-  }
-
-  static isOwnerPlayer(document) {
-    return document.testUserPermission && document.testUserPermission(game.user, CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER)
-  }
-
-  static isOwnerPlayerOrUniqueConnectedGM(actor) {
-    return Misc.isOwnerPlayer(actor) ?? Misc.isUniqueConnectedGM();
+  static isOwnerPlayerOrUniqueConnectedGM(actor, user = undefined) {
+    return Misc.isOwnerPlayer(actor, user) ?? Misc.isUniqueConnectedGM();
  }

  /**
--- a/module/rdd-audio.js
+++ b/module/rdd-audio.js
@ -15,7 +15,7 @@ export class RdDAudio {
      if ( audioData ) {
        let audioPath = "systems/foundryvtt-reve-de-dragon/sounds/" + audioData.file;
        console.log(`foundryvtt-reve-de-dragon | Playing Sound: ${audioPath}`)
-        foundry.audio.AudioHelper.play({ src: audioPath }, audioData.isGlobal);
+        AudioHelper.play({ src: audioPath }, audioData.isGlobal);
      }
    }
  }
--- a/module/rdd-combat.js
+++ b/module/rdd-combat.js
@ -75,12 +75,6 @@ export class RdDCombatManager extends Combat {
      }
    }
  }
-  static calculAjustementInit(actor, arme) {
-    const efficacite = (arme?.system.magique) ? arme.system.ecaille_efficacite : 0
-    const etatGeneral = actor.getEtatGeneral() ?? 0
-    return efficacite + etatGeneral
-
-  }

  /************************************************************************************/
  async rollInitiative(ids, formula = undefined, messageOptions = {}) {
@ -90,14 +84,12 @@ export class RdDCombatManager extends Combat {
    // calculate initiative
    for (let cId = 0; cId < ids.length; cId++) {
      const combatant = this.combatants.get(ids[cId]);
-      const ajustement = RdDCombatManager.calculAjustementInit(combatant.actor, undefined);
-      let rollFormula = formula ?? RdDCombatManager.formuleInitiative(2, 10, 0, ajustement);
-
+      let rollFormula = formula ?? RdDCombatManager.formuleInitiative(2, 10, 0, 0);
      if (!formula) {
        if (combatant.actor.type == 'creature' || combatant.actor.type == 'entite') {
          const competence = combatant.actor.items.find(it => RdDItemCompetenceCreature.isCompetenceAttaque(it))
          if (competence) {
-            rollFormula = RdDCombatManager.formuleInitiative(2, competence.system.carac_value, competence.system.niveau, etatGeneral);
+            rollFormula = RdDCombatManager.formuleInitiative(2, competence.system.carac_value, competence.system.niveau, 0);
          }
        } else {
          const armeCombat = combatant.actor.itemTypes['arme'].find(it => it.system.equipe)
@ -117,9 +109,8 @@ export class RdDCombatManager extends Combat {
          if (competence && competence.system.defaut_carac) {
            const carac = combatant.actor.system.carac[competence.system.defaut_carac].value;
            const niveau = competence.system.niveau;
-
-            const ajustement = RdDCombatManager.calculAjustementInit(combatant.actor, armeCombat)
-            rollFormula = RdDCombatManager.formuleInitiative(2, carac, niveau, ajustement);
+            const bonusEcaille = (armeCombat?.system.magique) ? armeCombat.system.ecaille_efficacite : 0;
+            rollFormula = RdDCombatManager.formuleInitiative(2, carac, niveau, bonusEcaille);
          } else {
            ui.notifications.warn(`Votre arme ${armeCombat.name} n'a pas de compétence renseignée`);
          }
@ -128,7 +119,7 @@ export class RdDCombatManager extends Combat {
      //console.log("Combatat", c);
      const roll = combatant.getInitiativeRoll(rollFormula);
      if (!roll.total) {
-        await roll.evaluate();
+        roll.evaluate({ async: false });
      }
      const total = Math.max(roll.total, 0.00);
      console.log("Compute init for", rollFormula, roll, total, combatant);
@ -137,7 +128,8 @@ export class RdDCombatManager extends Combat {

      // Send a chat message
      let rollMode = messageOptions.rollMode || game.settings.get("core", "rollMode");
-      let messageData = foundry.utils.mergeObject({
+      let messageData = foundry.utils.mergeObject(
+        {
          speaker: {
            scene: canvas.scene._id,
            actor: combatant.actor?._id,
@ -145,9 +137,12 @@ export class RdDCombatManager extends Combat {
            alias: combatant.token.name,
            sound: CONFIG.sounds.dice,
          },
-        flavor: `${combatant.token.name} a fait son jet d'Initiative (${messageOptions.initInfo})<br>`,
+          flavor: `${combatant.token.name} a fait son jet d'Initiative (${messageOptions.initInfo})
+          <br>
+          `,
        },
-        messageOptions);
+        messageOptions
+      );
      roll.toMessage(messageData, { rollMode, create: true });

      RdDCombatManager.processPremierRoundInit();
@ -223,16 +218,13 @@ export class RdDCombatManager extends Combat {

  static $prepareAttaqueArme(infoAttaque) {
    const comp = infoAttaque.competences.find(c => c.name == infoAttaque.competence);
-    const arme = infoAttaque.arme;
-    const attaque = foundry.utils.duplicate(arme);
+    const attaque = foundry.utils.duplicate(infoAttaque.arme);
    attaque.action = 'attaque';
    attaque.system.competence = infoAttaque.competence;
    attaque.system.dommagesReels = infoAttaque.dommagesReel;
    attaque.system.infoMain = infoAttaque.infoMain;
    attaque.system.niveau = comp.system.niveau;
-
-    const ajustement = (arme?.parent?.getEtatGeneral() ?? 0) + (arme?.system.magique) ? arme.system.ecaille_efficacite : 0;
-    attaque.system.initiative = RdDCombatManager.calculInitiative(comp.system.niveau, infoAttaque.carac[comp.system.defaut_carac].value, ajustement);
+    attaque.system.initiative = RdDCombatManager.calculInitiative(comp.system.niveau, infoAttaque.carac[comp.system.defaut_carac].value);
    return attaque;
  }

@ -347,6 +339,7 @@ export class RdDCombatManager extends Combat {
      ui.notifications.warn(`Le combatant ${combatant.name} n'est pas associé à un acteur, impossible de déterminer ses actions de combat!`)
      return [];
    }
+
    let initInfo = "";
    let initOffset = 0;
    let caracForInit = 0;
@ -381,9 +374,9 @@ export class RdDCombatManager extends Combat {
      initOffset = RdDCombatManager._baseInitOffset(compData.system.categorie, action);
    }

+    let malus = combatant.actor.getEtatGeneral(); // Prise en compte état général 
    // Cas des créatures et entités vs personnages
-    const ajustement = RdDCombatManager.calculAjustementInit(combatant.actor, action)
-    let rollFormula = RdDCombatManager.formuleInitiative(initOffset, caracForInit, compNiveau, ajustement);
+    let rollFormula = RdDCombatManager.formuleInitiative(initOffset, caracForInit, compNiveau, malus);
    // Garder la trace de l'arme/compétence utilisée pour l'iniative
    combatant.initiativeData = { arme: action } // pour reclasser l'init au round 0
    game.combat.rollInitiative(combatantId, rollFormula, { initInfo: initInfo });
@ -798,7 +791,7 @@ export class RdDCombat {
  /* -------------------------------------------- */
  _prepareAttaque(competence, arme) {
    let rollData = {
-      passeArme: foundry.utils.randomID(16),
+      passeArme: randomID(16),
      mortalite: arme?.system.mortalite,
      competence: competence,
      surprise: this.attacker.getSurprise(true),
--- a/module/rdd-confirm.js
+++ b/module/rdd-confirm.js
@ -1,11 +1,9 @@
+import { Grammar } from "./grammar.js";
 import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";

 export class RdDConfirm {
  /* -------------------------------------------- */
  static confirmer(options, autresActions) {
-    if (options.settingConfirmer && !ReglesOptionnelles.isSet(options.settingConfirmer)) {
-      return options.onAction()
-    }
    let buttons = {
      "action": RdDConfirm._createButtonAction(options),
      "cancel": RdDConfirm._createButtonCancel()
@ -14,7 +12,7 @@ export class RdDConfirm {
      buttons = foundry.utils.mergeObject(RdDConfirm._createButtonActionSave(options), buttons);
    }
    if (autresActions) {
-      buttons = foundry.utils.mergeObject(autresActions, buttons, { inplace: false });
+      buttons = foundry.utils.mergeObject(autresActions, buttons);
    }
    const dialogDetails = {
      title: options.title,
--- a/module/rdd-dice.js
+++ b/module/rdd-dice.js
@ -36,8 +36,8 @@ export class DeTMR extends Die {
    super(termData);
  }

-  async evaluate(options) {
-    await super.evaluate(options);
+  async evaluate() {
+    super.evaluate();
    this.explode("x=8");
    return this;
  }
@ -73,8 +73,8 @@ export class DeDraconique extends Die {
    super(termData);
  }

-  async evaluate(options) {
-    await super.evaluate(options);
+  async evaluate() {
+    super.evaluate();
    this.explode("x=7");
    return this;
  }
@ -138,7 +138,7 @@ export class RdDDice {

  static async roll(formula, options = { showDice: SHOW_DICE, rollMode: undefined }) {
    const roll = new Roll(RdDDice._formulaOrFake(formula, options));
-    await roll.evaluate();
+    await roll.evaluate({ async: true });
    await this.showDiceSoNice(roll, options);
    return roll;
  }
@ -216,7 +216,7 @@ export class RdDDice {

  static async fakeD10(faces) {
    let roll = new Roll(`1d${faces}`);
-    await roll.evaluate();
+    await roll.evaluate({ async: true });
    return roll.total;
  }

--- a/module/rdd-empoignade.js
+++ b/module/rdd-empoignade.js
@ -248,7 +248,7 @@ export class RdDEmpoignade {
    if (rollData.rolled.isPart) {
      rollData.particuliere = "finesse";
    }
-    let msg = await RdDResolutionTable.displayRollData(rollData, defender, 'chat-empoignade-resultat.html');
+    let msg = await RdDResolutionTable.displayRollData(rollData, attacker, 'chat-empoignade-resultat.html');
    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
  }

@ -427,7 +427,7 @@ export class RdDEmpoignade {
      name: "Empoignade en cours de " + attacker.name + ' sur ' + defender.name,
      type: 'empoignade',
      img: "systems/foundryvtt-reve-de-dragon/icons/entites/possession2.webp",
-      system: { description: "", empoignadeid: foundry.utils.randomID(16), compteempoigne: 0, empoigneurid: attacker.id, empoigneid: defender.id, ptsemp: 0, empoigneurname: attacker.name, empoignename: defender.name }
+      system: { description: "", empoignadeid: randomID(16), compteempoigne: 0, empoigneurid: attacker.id, empoigneid: defender.id, ptsemp: 0, empoigneurname: attacker.name, empoignename: defender.name }
    },
      {
        temporary: true
--- a/module/rdd-main.js
+++ b/module/rdd-main.js
@ -80,7 +80,6 @@ export class SystemReveDeDragon {
  }

  constructor() {
-    this.config = RDD_CONFIG; 
    this.RdDUtility = RdDUtility;
    this.RdDHotbar = RdDHotbar;
    this.itemClasses = {
@ -109,6 +108,7 @@ export class SystemReveDeDragon {
  /* -------------------------------------------- */
  async onInit() {
    game.system.rdd = this;
+    game.system.rdd.config = RDD_CONFIG; 
    this.AppAstrologie = AppAstrologie;    


--- a/module/rdd-meteo.js
+++ b/module/rdd-meteo.js
@ -56,7 +56,7 @@ const temperatures = [
 export class RdDMeteo {
  static async getForce() {
    const roll = new Roll(`1dr`);
-    await roll.evaluate();
+    await roll.evaluate({ async: true });
    return roll.total;
  }

@ -67,14 +67,14 @@ export class RdDMeteo {
  static async getTemperature() {
    const degre = await RdDMeteo.getForce();
    const rollChaudFroid = new Roll('1d2');
-    await rollChaudFroid.evaluate();
+    await rollChaudFroid.evaluate({ async: true });
    const chaudFroid = rollChaudFroid.total == 1;
    return chaudFroid.total ? degre : -degre;
  }

  static async getDirection(direction) {
    const roll = new Roll(`1d16`);
-    await roll.evaluate();
+    await roll.evaluate({ async: true });
    switch (roll.total % 16) {
      case 0: return 'Nord';
      case 1: return 'Nord Nord Est';
--- a/module/rdd-possession.js
+++ b/module/rdd-possession.js
@ -131,7 +131,7 @@ export class RdDPossession {
    }
    const possession = (rollData.isECNIDefender ? rollData.attacker : rollData.defender).getPossession(rollData.possession.system.possessionid)
    RdDPossession.storePossessionAttaque(possession, rollData)
-    await RdDResolutionTable.displayRollData(rollData, rollData.defender, 'chat-resultat-possession.html');
+    await RdDResolutionTable.displayRollData(rollData, rollData.attacker, 'chat-resultat-possession.html');
  }

  /* -------------------------------------------- */
@ -171,7 +171,7 @@ export class RdDPossession {
    rollData.possession = possession
    RdDPossession.$updateEtatPossession(rollData.possession)

-    await RdDResolutionTable.displayRollData(rollData, rollData.attacker, 'chat-resultat-possession.html')
+    await RdDResolutionTable.displayRollData(rollData, rollData.defender, 'chat-resultat-possession.html')
    if (rollData.possession.isPosseder || rollData.possession.isConjurer) {
      // conjuration
      victime.deleteEmbeddedDocuments("Item", [rollData.possession._id])
@ -230,7 +230,7 @@ export class RdDPossession {
      system: {
        description: "", typepossession: attacker.name,
        possede: false,
-        possessionid: foundry.utils.randomID(16),
+        possessionid: randomID(16),
        entite: { actorid: attacker.id },
        victime: { actorid: defender.id },
        compteur: 0
--- a/module/rdd-resolution-table.js
+++ b/module/rdd-resolution-table.js
@ -97,7 +97,7 @@ export class RdDResolutionTable {
  }

  static actorChatName(actor) {
-    return actor?.name ?? game.user.name;
+    return actor?.userName ?? game.user.name;
  }

  /* -------------------------------------------- */
--- a/module/rdd-tmr-dialog.js
+++ b/module/rdd-tmr-dialog.js
@ -129,7 +129,7 @@ export class RdDTMRDialog extends Dialog {
    this.html.find('form.tmr-dialog *').click(event => this.subdialog?.bringToTop());

    // Roll Sort
-    this.html.find('.lancer-sort').click(event => this.lancerUnSort());
+    this.html.find('.lancer-sort').click(event => this.actor.rollUnSort(this._getCoordActor()));
    this.html.find('.lire-signe-draconique').click(event => this.actor.rollLireSigneDraconique(this._getCoordActor()));

    this.html.find('img.tmr-move').click(event => this.deplacementTMR(this.html.find(event.currentTarget)?.data('move')));
@ -142,13 +142,6 @@ export class RdDTMRDialog extends Dialog {
    this.updateValuesDisplay();
  }

-  lancerUnSort() {
-    if (this.subdialog) {
-      return this.forceTMRContinueAction();
-    }
-    return this.actor.rollUnSort(this._getCoordActor());
-  }
-
  async onDeplacement() {
    await this.manageRencontre(TMRUtility.getTMR(this._getCoordActor()));
  }
@ -171,25 +164,23 @@ export class RdDTMRDialog extends Dialog {
  async forceTMRDisplay() {
    if (this.rendered) {
      this.bringToTop()
-      this.bringSubDialogToTop();
-    }
-  }
-
-  bringSubDialogToTop() {
-    if (this.subdialog?.bringToTop && this.subdialog?.element[0]) {
+      if (this.subdialog?.bringToTop) {
        this.subdialog.bringToTop();
      }
    }
+  }

  async restoreTMRAfterAction() {
    this.subdialog = undefined
-    await this.maximize()
-    this.bringToTop()
+    await this.maximize();
+    this.bringToTop();
  }

  forceTMRContinueAction() {
    ui.notifications.warn('Vous devez finir votre action avant de continuer dans les TMR');
-    this.bringSubDialogToTop();
+    if (this.subdialog?.bringToTop) {
+      this.subdialog.bringToTop();
+    }
    return;
  }

--- a/module/rdd-utility.js
+++ b/module/rdd-utility.js
@ -4,7 +4,7 @@ import { RdDCombat } from "./rdd-combat.js";
 import { Misc } from "./misc.js";
 import { Grammar } from "./grammar.js";
 import { TMRUtility } from "./tmr-utility.js";
-import { DialogItemAchat } from "./achat-vente/dialog-item-achat.js";
+import { DialogItemAchat } from "./dialog-item-achat.js";
 import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
 import { RdDDice } from "./rdd-dice.js";
 import { RdDItem } from "./item.js";
@ -19,7 +19,6 @@ import { RdDEmpoignade } from "./rdd-empoignade.js";
 import { ExperienceLog } from "./actor/experience-log.js";
 import { RdDCoeur } from "./coeur/rdd-coeur.js";
 import { APP_ASTROLOGIE_REFRESH } from "./sommeil/app-astrologie.js";
-import { RDD_CONFIG } from "./constants.js";

 /* -------------------------------------------- */
 // This table starts at 0 -> niveau -10
@ -263,6 +262,8 @@ export class RdDUtility {
    ];

    Handlebars.registerHelper('either', (a, b) => a ?? b);
+    Handlebars.registerHelper('computeResolutionScore', (row, col) => RdDResolutionTable.computePercentage(row, col));
+    Handlebars.registerHelper('computeResolutionChances', (row, col) => RdDResolutionTable.computeChances(row, col));
    Handlebars.registerHelper('upperFirst', str => Misc.upperFirst(str ?? 'Null'));
    Handlebars.registerHelper('lowerFirst', str => Misc.lowerFirst(str ?? 'Null'));
    Handlebars.registerHelper('upper', str => str?.toUpperCase() ?? '');
@ -271,10 +272,6 @@ 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('RDD_CONFIG', path => RDD_CONFIG[path])
-    Handlebars.registerHelper('computeResolutionScore', (row, col) => RdDResolutionTable.computePercentage(row, col));
-    Handlebars.registerHelper('computeResolutionChances', (row, col) => RdDResolutionTable.computeChances(row, col));
    Handlebars.registerHelper('buildLigneInventaire', (item, options) => { return new Handlebars.SafeString(RdDUtility.buildLigneInventaire(item, options)); });
    Handlebars.registerHelper('buildInventaireConteneur', (actorId, itemId, options) => { return new Handlebars.SafeString(RdDUtility.buildInventaireConteneur(actorId, itemId, options)); });
    Handlebars.registerHelper('buildContenuConteneur', (item, options) => { return new Handlebars.SafeString(RdDUtility.buildContenuConteneur(item, options)); });
@ -303,14 +300,6 @@ export class RdDUtility {
    Handlebars.registerHelper('plusMoins', diff => (diff > 0 ? '+' : '') + Math.round(diff))
    Handlebars.registerHelper('experienceLog-topic', topic => ExperienceLog.labelTopic(topic));

-    // Handle v12 removal of this helper
-    Handlebars.registerHelper('select', function (selected, options) {
-      const escapedValue = RegExp.escape(Handlebars.escapeExpression(selected));
-      const rgx = new RegExp(' value=[\"\']' + escapedValue + '[\"\']');
-      const html = options.fn(this);
-      return html.replace(rgx, "$& selected");
-    });
-
    return loadTemplates(templatePaths);
  }

@ -358,18 +347,16 @@ export class RdDUtility {
    let objetVersConteneur = {};
    // Attribution des objets aux conteneurs
    for (let conteneur of conteneurs) {
-      if (conteneur.isConteneur()) {
      conteneur.subItems = [];
      for (let id of conteneur.system.contenu ?? []) {
        let objet = inventaires.find(objet => (id == objet._id));
        if (objet) {
-            objet.estContenu = true;
+          objet.estContenu = true; // Permet de filtrer ce qui est porté dans le template
          objetVersConteneur[id] = conteneur._id;
          conteneur.subItems.push(objet);
        }
      }
    }
-    }
    for (let conteneur of conteneurs) {
      conteneur.system.encTotal = RdDUtility.calculEncContenu(conteneur, inventaires);
    }
@ -637,7 +624,7 @@ export class RdDUtility {
  /* -------------------------------------------- */
  static async _evaluatePerte(formula, over20) {
    let perte = new Roll(formula, { over20: over20 });
-    await perte.evaluate();
+    await perte.evaluate({ async: true });
    return perte.total;
  }

@ -769,7 +756,7 @@ export class RdDUtility {
  /* -------------------------------------------- */
  static createMonnaie(name, cout, img = "", enc = 0.01) {
    let piece = {
-      name: name, type: 'monnaie', img: img, _id: foundry.utils.randomID(16),
+      name: name, type: 'monnaie', img: img, _id: randomID(16),
      dasystemta: {
        quantite: 0,
        cout: cout,
--- a/module/rolldata-ajustements.js
+++ b/module/rolldata-ajustements.js
@ -111,7 +111,7 @@ export const referenceAjustements = {
    isVisible: (rollData, actor) => rollData.arme?.system.magique && Number(rollData.arme?.system.ecaille_efficacite) > 0,
    isUsed: (rollData, actor) => rollData.arme?.system.magique && Number(rollData.arme?.system.ecaille_efficacite) > 0,
    getLabel: (rollData, actor) => "Ecaille d'Efficacité: ",
-    getValue: (rollData, actor) => rollData.arme?.system.magique ? Math.max(Number(rollData.arme?.system.ecaille_efficacite), 0) : 0,
+    getValue: (rollData, actor) => Math.max(Number(rollData.arme?.system.ecaille_efficacite), 0),
  },
  finesse: {
    isUsed: (rollData, actor) => RdDBonus.isDefenseAttaqueFinesse(rollData),
--- a/module/settings/regles-optionnelles.js
+++ b/module/settings/regles-optionnelles.js
@ -71,7 +71,8 @@ export class ReglesOptionnelles extends FormApplication {
  }

  static get defaultOptions() {
-    return foundry.utils.mergeObject(super.defaultOptions, {
+    const options = super.defaultOptions;
+    foundry.utils.mergeObject(options, {
      id: "regles-optionnelles",
      template: "systems/foundryvtt-reve-de-dragon/templates/settings/regles-optionnelles.html",
      height: 650,
@ -79,7 +80,8 @@ export class ReglesOptionnelles extends FormApplication {
      minimizable: false,
      closeOnSubmit: true,
      title: "Règles optionnelles"
-    }, { inplace: false })
+    });
+    return options;
  }

  getData() {
--- a/module/settings/system-compendiums.js
+++ b/module/settings/system-compendiums.js
@ -1,4 +1,3 @@
-import { ChatUtility } from "../chat-utility.js";
 import { HIDE_DICE, SYSTEM_RDD } from "../constants.js";
 import { RdDItem } from "../item.js";
 import { Misc } from "../misc.js";
@ -153,7 +152,7 @@ export class SystemCompendiums extends FormApplication {

  getData() {
    const systemCompendiums = Object.values(CONFIGURABLE_COMPENDIUMS)
-      .map(it => foundry.utils.mergeObject(it, { value: SystemCompendiums.getCompendium(it.compendium) }, { inplace: false }))
+      .map(it => foundry.utils.mergeObject(it, { value: SystemCompendiums.getCompendium(it.compendium) }));
    const availableCompendiums = game.packs.map(pack => {
      return {
        name: pack.collection,
@ -164,7 +163,7 @@ export class SystemCompendiums extends FormApplication {
    return foundry.utils.mergeObject(super.getData(), {
      systemCompendiums: systemCompendiums,
      availableCompendiums: availableCompendiums
-    }, { inplace: false })
+    });
  }

  activateListeners(html) {
@ -291,7 +290,7 @@ export class CompendiumTableHelpers {
      sound: CONFIG.sounds.dice,
      content: flavorContent
    };
-    await ChatUtility.createChatWithRollMode(game.user.id, messageData)
+    ChatMessage.create(messageData, { rollMode: "gmroll" });
  }

  /* -------------------------------------------- */
@ -307,7 +306,7 @@ export class CompendiumTableHelpers {
      whisper: game.user.id,
      content: flavorContent
    };
-    await ChatUtility.createChatWithRollMode(game.user.id, messageData)
+    ChatMessage.create(messageData, { rollMode: "gmroll" });
  }

 }
--- a/module/sommeil/app-astrologie.js
+++ b/module/sommeil/app-astrologie.js
@ -25,7 +25,7 @@ export class AppAstrologie extends Application {
      classes: ['calendar-astrologie'],
      popOut: true,
      resizable: false
-    }, { inplace: false })
+    });
  }

  constructor(actor, options = {}) {
@ -49,7 +49,7 @@ export class AppAstrologie extends Application {
        signeNaissance: RdDTimestamp.definition(0)
      }
    })
-    return this.appData
+    return this.appData;
  }

  getActorAstrologie() {
--- a/module/time/auto-adjust-darkness.js
+++ b/module/time/auto-adjust-darkness.js
@ -17,7 +17,7 @@ export class AutoAdjustDarkness {
  static async adjust(darkness) {
    if (AutoAdjustDarkness.isAuto()) {
      const scene = game.scenes.viewed;
-      if (scene?.environment?.globalLight?.enabled && scene?.tokenVision) {
+      if (scene?.globalLight && scene?.tokenVision) {
        await scene.update({ darkness });
      }
    }
--- a/module/time/rdd-calendrier.js
+++ b/module/time/rdd-calendrier.js
@ -43,7 +43,7 @@ export class RdDCalendrier extends Application {
      resizable: false,
      width: 'fit-content',
      height: 'fit-content',
-    }, { inplace: false })
+    });
  }

  constructor() {
@ -123,9 +123,9 @@ export class RdDCalendrier extends Application {
  /* -------------------------------------------- */
  fillCalendrierData(formData = {}) {
    foundry.utils.mergeObject(formData, this.timestamp.toCalendrier());
-    formData.isGM = game.user.isGM
+    formData.isGM = game.user.isGM;
    formData.heures = RdDTimestamp.definitions()
-    formData.horlogeAnalogique = this.horlogeAnalogique
+    formData.horlogeAnalogique = this.horlogeAnalogique;
    formData.autoDarkness = AutoAdjustDarkness.isAuto()
    return formData;
  }
--- a/module/tirage/fenetre-recherche-tirage.js
+++ b/module/tirage/fenetre-recherche-tirage.js
@ -125,7 +125,7 @@ export class FenetreRechercheTirage extends Application {
      popOut: true,
      dragDrop: [{ dragSelector: "a.content-link" }],
      resizable: true
-    }, { inplace: false })
+    });
  }

  static async create() {
--- a/module/voyage/dialog-fatigue-voyage.js
+++ b/module/voyage/dialog-fatigue-voyage.js
@ -1,7 +1,6 @@
 import { TYPES } from "../item.js"
 import { RdDItemCompetence } from "../item-competence.js"
 import { ChatUtility } from "../chat-utility.js"
-import { Misc } from "../misc.js"

 const CODES_COMPETENCES_VOYAGE = ['Extérieur', 'Forêt', 'Montagne', 'Marais', 'Glace', 'Equitation']
 const TABLEAU_FATIGUE_MARCHE = [
@ -37,7 +36,7 @@ export class DialogFatigueVoyage extends Dialog {
      const parameters = {
        tableauFatigueMarche: TABLEAU_FATIGUE_MARCHE,
        playerActors: game.actors.filter(actor => actor.isPersonnageJoueur())
-          .map(actor => DialogFatigueVoyage.prepareActorParameters(actor)),
+          .map(actor => DialogFatigueVoyage.prepareActor(actor)),
        nombreHeures: 1,
      }
      DialogFatigueVoyage.setModeDeplacement(parameters, undefined, undefined)
@ -54,37 +53,21 @@ export class DialogFatigueVoyage extends Dialog {
    parameters.typeTerrain = ligneFatigueMarche
    parameters.vitesseDeplacement = rythme.vitesse
    parameters.fatigueHoraire = rythme.fatigue
-    parameters.playerActors.forEach(voyageur =>
-      DialogFatigueVoyage.selectSurvie(voyageur, parameters.typeTerrain.code)
-    )
  }

-  static prepareActorParameters(actor) {
-    const actorParameters = {
-      id: actor.id,
+  static prepareActor(actor) {
+    const competencesVoyage = {}
+    CODES_COMPETENCES_VOYAGE.forEach(codeSurvie =>
+      competencesVoyage[codeSurvie] = RdDItemCompetence.findCompetence(actor.itemTypes[TYPES.competence], codeSurvie, { onMessage: () => { } })
+    )
+    return {
      actor: actor,
      selected: true,
      ajustementFatigue: 0,
-      survies: {}
+      competencesVoyage: competencesVoyage
    }
-    const competencesVoyage = {}
-    CODES_COMPETENCES_VOYAGE.forEach(codeSurvie => {
-      competencesVoyage[codeSurvie] = RdDItemCompetence.findCompetence(actor.itemTypes[TYPES.competence], codeSurvie, { onMessage: () => { } })
-    })
-    TABLEAU_FATIGUE_MARCHE.forEach(terrain => {
-      actorParameters.survies[terrain.code] = Misc.join(
-        terrain.survies.map(survie => {
-          const niveau = competencesVoyage[survie]?.system.niveau
-          return `${survie}: ${niveau}`
-        }),
-        ', ')
-    })
-    return actorParameters
  }

-  static selectSurvie(actorParameters, code) {
-    actorParameters.survieCourante = actorParameters.survies[code]
-  }

  constructor(html, parameters) {
    const options = {
@ -114,7 +97,6 @@ export class DialogFatigueVoyage extends Dialog {
    this.html.find('select[name="code-terrain"]').change(event => this.changeParameters())
    this.html.find('select[name="vitesse-deplacement"]').change(event => this.changeParameters())
    this.html.find('input[name="nombre-heures"]').change(event => this.changeParameters())
-    this.html.find('.list-item input[name="ajustement-fatigue"]').change(event => this.changeParameters())
    this.html.find('button[name="appliquer-fatigue"]').click(event => this.appliquerFatigue())
  }

@ -136,10 +118,6 @@ export class DialogFatigueVoyage extends Dialog {
        selectVitesseDeplacement.append(await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/voyage/option-vitesse-fatigue.hbs', rythme))
      })
      selectVitesseDeplacement.val(this.parameters.vitesseDeplacement).change()
-
-      Promise.all(this.getActorRows()
-        .map(async row => row.find('label.voyage-liste-survies').text(this.$extractActorParameters(row).survieCourante)
-        ))
    }
  }

@ -154,61 +132,44 @@ export class DialogFatigueVoyage extends Dialog {
  }

  async setFatigue() {
-    const baseFatigue = this.parameters.nombreHeures * this.parameters.fatigueHoraire
-    this.html.find('input[name="base-fatigue"]').val(baseFatigue)
-    this.updateActorTotalFatigue(baseFatigue)
-  }
-
-  async updateActorTotalFatigue(baseFatigue) {
-    Promise.all(this.getActorRows()
-      .map(async row => {
-        const actor = this.$extractActorParameters(row)
-        row.find('input[name="total-fatigue"]').val(actor.ajustement + baseFatigue)
-      }))
+    this.html.find('input[name="base-fatigue"]').val(this.parameters.nombreHeures * this.parameters.fatigueHoraire)
  }

  async appliquerFatigue() {
    const fatigueBase = parseInt(this.html.find('input[name="base-fatigue"]').val() ?? 0)
-    this.getActorRows()
-      .map(row => this.$extractActorParameters(row))
-      .filter(it => it.selected)
+    const actors = jQuery.map(
+      this.html.find('div.fatigue-actors-list li.list-item'),
+      it => this.$extractActor(this.html.find(it))
+    )
+    actors.filter(it => it.selected)
    .forEach(async it => {
        const perteFatigue = fatigueBase + it.ajustement
        ChatMessage.create({
          whisper: ChatUtility.getWhisperRecipientsAndGMs(it.actor.name),
          content: await renderTemplate(
-            'systems/foundryvtt-reve-de-dragon/templates/voyage/chat-fatigue_voyage.hbs',
-            foundry.utils.mergeObject(it,
+            'systems/foundryvtt-reve-de-dragon/templates/voyage/chat-fatigue_voyage.hbs', foundry.utils.mergeObject(it,
              {
                parameters: this.parameters,
                fatigueBase: fatigueBase,
                perteFatigue: perteFatigue,
                isVoyage: fatigueBase == this.parameters.nombreHeures * this.parameters.fatigueHoraire
-              }, { inplace: false })
+              })
          ),
        })
        await it.actor.santeIncDec("fatigue", perteFatigue)
      })
  }

-  getActorRows() {
-    return jQuery.map(
-      this.html.find('div.fatigue-actors-list li.list-item'),
-      it => this.html.find(it))
-  }
-
-
-  $extractActorParameters(actorRow) {
-    const actorId = actorRow.data('actor-id')
-    const actorParameters = this.parameters.playerActors.find(it => it.id == actorId)
-    const actor = game.actors.get(actorId)
+  $extractActor(actorRow) {
+    const actor = game.actors.get(actorRow.data('actor-id'))
    if (!actor) {
      ui.notifications.warn(`Acteur ${it.actorId} introuvable`)
-      return {}
    }
-    actorParameters.ajustement = parseInt(actorRow.find('input[name="ajustement-fatigue"]').val() ?? 0)
-    actorParameters.selected = actor && actorRow.find('input[name="selectionner-acteur"]').is(':checked')
-    return actorParameters
+    return {
+      actor: actor,
+      ajustement: parseInt(actorRow.find('input[name="ajustement-fatigue"]').val() ?? 0),
+      selected: actor && actorRow.find('input[name="selectionner-acteur"]').is(':checked')
+    }
  }

  async close() {
--- a/styles/simple.css
+++ b/styles/simple.css
@ -1374,7 +1374,7 @@ table.table-nombres-astraux tr:hover {
  flex-direction: column;
  position: absolute;
  top: 4.6rem;
-  left: -19rem;
+  right: 3.5rem;
 }
 .token-hud-ext.soins {
  flex-direction: column;
--- a/system.json
+++ b/system.json
@ -1,13 +1,13 @@
 {
  "id": "foundryvtt-reve-de-dragon",
  "title": "Rêve de Dragon",
-  "version": "12.0.8",
-  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-12.0.8.zip",
+  "version": "11.2.21",
+  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-11.2.21.zip",
  "manifest": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/v11/system.json",
  "changelog": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/branch/v11/changelog.md",
  "compatibility": {
    "minimum": "11",
-    "verified": "12"
+    "verified": "11"
  },
  "description": "Rêve de Dragon RPG for FoundryVTT",
  "authors": [
--- a/templates/actor/carac-derivee.html
+++ b/templates/actor/carac-derivee.html
@ -55,7 +55,7 @@
  <li class="caracteristique flexrow list-item"  data-tooltip="Niveau d'éthylisme">
    <label class="derivee-label" for="system.compteurs.ethylisme.value">{{system.compteurs.ethylisme.label}}</label>
    <select class="derivee-value" name="system.compteurs.ethylisme.value" data-dtype="Number">
-      {{selectOptions (RDD_CONFIG 'niveauEthylisme')  selected=system.compteurs.ethylisme.value valueAttr="value" nameAttr="value" labelAttr="label"}} 
+      {{selectOptions @root.config.niveauEthylisme selected=system.compteurs.ethylisme.value valueAttr="value" nameAttr="value" labelAttr="label"}} 
    </select>  
  </li>  

--- a/templates/actor/carac-entitee.html
+++ b/templates/actor/carac-entitee.html
@ -2,13 +2,13 @@
  <li class="caracteristique flexrow list-item">
    <span class="carac-label" name="catEntite">Catégorie : </span>
    <select name="system.definition.categorieentite" value="{{system.definition.categorieentite}}" data-dtype="String" {{#unless @root.options.vueDetaillee}}disabled{{/unless}}>
-      {{selectOptions (RDD_CONFIG 'categorieEntite') selected=system.definition.categorieentite}}
+      {{selectOptions @root.config.categorieEntite selected=system.definition.categorieentite}}
    </select>
  </li>
  <li class="caracteristique flexrow list-item">
    <span class="carac-label" name="typeEntite">Type d'entité : </span>
    <select name="system.definition.typeentite" value="{{system.definition.typeentite}}" data-dtype="String" {{#unless @root.options.vueDetaillee}}disabled{{/unless}}>
-      {{selectOptions (RDD_CONFIG 'typeEntite') selected=system.definition.typeentite}}
+      {{selectOptions @root.config.typeEntite selected=system.definition.typeentite}}
    </select>
  </li>
  {{#each system.attributs as |attr key|}}
--- a/templates/actor/combat.html
+++ b/templates/actor/combat.html
@ -25,7 +25,7 @@
    <span class="competence-value">{{plusMoins arme.system.niveau}}</span>
    <span class="competence-value">{{plusMoins arme.system.dommagesReels}}</span>
    <span class="competence-value"></span>
-    <span class="initiative-value arme-initiative"><a data-tooltip="{{arme.name}}: initiative {{arme.system.initiative}}">{{arme.system.initiative}}</a></span>
+    <span class="initiative-value arme-initiative"><a data-tooltip="{{arme.name}}: initiative {{plusMoins arme.system.initiative}}">{{arme.system.initiative}}</a></span>
  </li>
  {{/each}}
  {{#each esquives as |esq key|}}
--- a/templates/actor/header-effects.html
+++ b/templates/actor/header-effects.html
@ -2,7 +2,7 @@
  {{#if effects}}
    {{#each effects as |effect key|}}
    <span class="active-effect" data-effect="{{effect.id}}">
-      <img class="button-effect-img {{#if @root.options.isGM}}delete-active-effect{{/if}}" src="{{effect.img}}" data-tooltip="{{localize effect.name}}" width="24" height="24" />
+      <img class="button-effect-img {{#if @root.options.isGM}}delete-active-effect{{/if}}" src="{{effect.icon}}" data-tooltip="{{localize effect.name}}" width="24" height="24" />
    </span>
    {{/each}}
    {{#if calc.surprise}}<span>{{calc.surprise}}!</span>{{/if}}
--- a/templates/chat-vente-item.html
+++ b/templates/chat-vente-item.html
@ -1,4 +1,3 @@
-{{log 'chat-vente-item' this}}
 <div class="post-item" data-transfer="{{transfer}}">
  <h3>{{#if alias}}{{alias}} propose: {{else}}Acheter {{/if}}{{item.name}}</h3>
  {{#if item.img}}
@ -13,7 +12,7 @@
  <hr>
  <p>
    {{#unless quantiteIllimite}}
-    <span>Lots disponibles: {{nbLots}}</span><br>
+    <span>Lots disponibles: <span class="quantiteNbLots">{{quantiteNbLots}}</span></span><br>
    {{/unless}}
    {{#if (gt tailleLot 1)}}
    <span>Lots de: <span class="tailleLot">{{tailleLot}}</span></span><br>
@ -23,9 +22,15 @@
      <span class="prixLot">{{numberFormat prixLot decimals=2 sign=false}}</span> Sols</strong></span><br>
    {{/if}}
  </p>
-  {{#if (or (gt nbLots 0) quantiteIllimite)}}
+  {{#if (or (gt quantiteNbLots 0) quantiteIllimite)}}
  <span class="chat-card-button-area">
-    <a class="button-acheter chat-card-button">
+    <a class="button-acheter chat-card-button"
+      data-jsondata='{{jsondata}}'
+      {{#if vendeurId}}data-vendeurId='{{vendeurId}}'{{/if}}
+      data-tailleLot="{{tailleLot}}"
+      data-quantiteNbLots="{{quantiteNbLots}}"
+      data-quantiteIllimite="{{#if quantiteIllimite}}true{{else}}false{{/if}}"
+      data-prixLot="{{prixLot}}">
    {{#if (eq prixLot 0)}}Prendre{{else}}Acheter{{/if}}</a>
  </span>
  {{/if}}
--- a/templates/common/compendium-link.hbs
+++ b/templates/common/compendium-link.hbs
@ -1,20 +1,22 @@
-<span draggable="true">
-  <a class="{{#if pack}}content-link{{else}}rdd-world-content-link{{/if}}"
-    data-id="{{id}}"
-    data-link=""
-    {{#if doctype}}
-    data-doctype="{{doctype}}"
-    data-type="{{doctype}}"
-    {{/if}}
+  <span draggable="true">
  {{#if pack}}
-    data-pack="{{pack}}"
+  {{!-- draggable="true"  --}}
+  <a class="content-link"
    data-uuid="Compendium.{{pack}}.{{id}}" 
-    {{/if}} >
+    data-pack="{{pack}}" 
+    {{#if doctype}}data-doctype="{{doctype}}"{{/if}}
+    data-id="{{id}}"
+  >
+  {{else}}
+  <a class="rdd-world-content-link"
+    {{#if doctype}}data-doctype="{{doctype}}"{{/if}}
+    data-id="{{id}}"
+  >
+  {{/if}}
  {{#if img}}
  <img class="in-text-img" src="{{img}}" data-tooltip="{{name}}" />
  {{else}}
  <i class="fas fa-suitcase"></i>
  {{/if}}
-    {{name}}
-  </a>
+  {{name}}</a>
 </span>
--- a/templates/common/periodicite.hbs
+++ b/templates/common/periodicite.hbs
@ -2,6 +2,8 @@
 <div class="flexrow">
  <input type="number" name="{{path}}.nombre" value="{{nombre}}" data-dtype="Number"/>
  <select name="{{path}}.unite" data-dtype="String" >
-    {{selectOptions (timestamp-formulesPeriode) selected=unite labelAttr="label" nameAttr="code" valueAttr="code"}}
+    {{#select unite}}
+    {{>"systems/foundryvtt-reve-de-dragon/templates/enum-periode.html"}}
+    {{/select}}
  </select>
 </div>
--- a/templates/common/timestamp.hbs
+++ b/templates/common/timestamp.hbs
@ -6,7 +6,9 @@
        type="number" data-dtype="Number" min="1" max="28"
        name="{{path}}.jourDuMois" value="{{jourDuMois}}" />
    <select {{#if disabled}}{{disabled}}{{/if}} name="{{path}}.mois" class="calendar-signe-heure" data-dtype="String">
-    {{selectOptions (RDD_CONFIG 'heuresRdD') selected=mois.key labelAttr="label" nameAttr="value" valueAttr="value"}}
+      {{#select mois.key}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/enum-heures.html"}}
+      {{/select}}
    </select>
    {{timestamp-imgSigne mois}}
    <input {{#if disabled}}{{disabled}}{{/if}} type="number" class="number-x2" name="{{path}}.annee" value="{{annee}}" data-dtype="Number"/>
@ -15,7 +17,9 @@
    <label></label>
    <label>heure</label>
    <select {{#if disabled}}{{disabled}}{{/if}} name="{{path}}.heure" class="calendar-signe-heure" data-dtype="String">
-    {{selectOptions (RDD_CONFIG 'heuresRdD') selected=heure.key labelAttr="label" nameAttr="value" valueAttr="value"}}
+      {{#select heure.key}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/enum-heures.html"}}
+      {{/select}}
    </select>
    {{timestamp-imgSigne heure}}
    <input {{#if disabled}}{{disabled}}{{/if}} type="number" class="number-x2" name="{{path}}.minute" value="{{minute}}" data-dtype="Number"/>
--- a/templates/dialog-item-achat.html
+++ b/templates/dialog-item-achat.html
@ -31,7 +31,7 @@
    <label>{{#if quantiteIllimite}}
      pas de limite
      {{else}}
-      {{nbLots}}
+      {{quantiteNbLots}}
      {{/if}}</label>
  </div>
  <div class="flexrow flex-group-left">
@ -41,7 +41,7 @@
    </label>
    <div class="flexrow">
      <input name="nombreLots" class="nombreLots flex-shrink number-x2" type="number" min="1"
-        {{#unless quantiteIllimite}} max="{{nbLots}}" {{/unless}}
+        {{#unless quantiteIllimite}} max="{{quantiteNbLots}}" {{/unless}}
        value="{{choix.nombreLots}}"
        data-dtype="Number" />
    </div>
--- a/templates/dialog-item-vente.html
+++ b/templates/dialog-item-vente.html
@ -18,8 +18,8 @@
          quantiteIllimite}}checked{{/if}} />
        <label class="label-quantiteIllimite flex-shrink">disponibles</label>
        {{/unless}}
-        <input name="nbLots" class="nbLots flex-shrink number-x2" type="number" min="1"
-          max="{{maxLots}}" value="{{nbLots}}" data-dtype="Number" />
+        <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">
--- a/templates/item/partial-environnement.html
+++ b/templates/item/partial-environnement.html
@ -18,7 +18,6 @@
      <a class="milieu-add"><i class="fas fa-plus-circle"></i></a>
    </span>
  </div>
-  
  {{#each system.environnement as |env key|}}
  <div class="form-group environnement-milieu" data-milieu="{{env.milieu}}">
    <label>
@ -27,7 +26,9 @@
    </label>
    <span class="flexrow">
      <select name="milieu-{{key}}-rarete" class="environnement-rarete flex-shrink" data-dtype="String">
-        {{selectOptions (RDD_CONFIG 'raretes') selected=env.rarete labelAttr="label" valueAttr="value" nameAttr="value"}}
+        {{#select env.rarete}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/enum-rarete.html"}}
+        {{/select}}
      </select>
      {{rangePicker name="milieu-{{key}}-frequence" value=env.frequence min=(rarete-getChamp env.rarete 'min') max=(rarete-getChamp env.rarete 'max') step=1}}
      <label>[{{rarete-getChamp env.rarete 'min'}}-{{rarete-getChamp env.rarete 'max'}}]</label>
--- a/templates/settings/status-effects.html
+++ b/templates/settings/status-effects.html
@ -7,7 +7,7 @@
      {{else}}
      <input class="resource-content select-effect" type="checkbox" name="{{effect.id}}" {{#if effect.active}}checked{{/if}}/>
      {{/if}}
-      <img class="button-effect-img" height="16" width="16" src="{{effect.img}}" data-tooltip="{{localize effect.name}}" />
+      <img class="button-effect-img" height="16" width="16" src="{{effect.icon}}" data-tooltip="{{localize effect.name}}" />
      <label>{{localize effect.name}}</label>
    </li>
    {{/each}}
--- a/templates/sommeil/astrologie-joueur.hbs
+++ b/templates/sommeil/astrologie-joueur.hbs
@ -1,11 +1,19 @@
 <div>
  <label>Conditions</label>
  <select name="diffConditions" data-dtype="Number">
-    {{selectOptions actorAstrologie.ajustements selected='0'}}
+    {{#select '0'}}
+    {{#each actorAstrologie.ajustements as |ajustement|}}
+    <option value={{ajustement}}>{{ajustement}}</option>
+    {{/each}}
+    {{/select}}
  </select>
  <label>&nbsp;&nbsp;Jours</label>
  <select name="joursAstrologie" data-dtype="Number">
-    {{selectOptions dates selected='' labelAttr='label' valueAttr='index' nameAttr='index'}}
+    {{#select ''}}
+    {{#each dates as |date|}}
+    <option value={{date.index}}>{{date.label}}</option>
+    {{/each}}
+    {{/select}}
  </select>
  <label>
    &nbsp;&nbsp;Etat Général: {{actorAstrologie.etat}}
--- a/templates/voyage/dialog-fatigue-voyage.hbs
+++ b/templates/voyage/dialog-fatigue-voyage.hbs
@ -42,8 +42,7 @@
        <li class="competence-header flexrow">
          <span class="flex-grow-2">Personnage</span>
          <span class="flex-grow-2">Survies</span>
-          <span class="flex-grow-1" data-tooltip="Ajustements à appliquer (par exemple, repos à cheval)">Ajustements</span>
-          <span class="flex-grow-1" data-tooltip="Total de fatigue pour le voyageur">Total</span>
+          <span class="flex-grow-1" data-tooltip="Ajustements à appliquer pour les personnages se reposant (par exemple, à cheval)">Ajustements</span>
        </li>
        {{#each playerActors as |selected|}}
        {{>'systems/foundryvtt-reve-de-dragon/templates/voyage/fatigue-actor.hbs' voyageur=selected survies=@root.typeTerrain.survies}}
--- a/templates/voyage/fatigue-actor.hbs
+++ b/templates/voyage/fatigue-actor.hbs
@ -8,13 +8,16 @@
  </span>
  <span class="flex-grow-2">
    <div class="flexcol ">
-      <label class="voyage-liste-survies">{{voyageur.survieCourante}}</label>
+      <label class="voyage-liste-survies">
+      {{#each voyageur.competencesVoyage as |comp key|}}
+      {{#if (array-includes ../survies key)}}
+        {{key}} {{comp.system.niveau}},
+      {{/if}}
+      {{/each}}
+      </label>
    </div>
  </span>
  <span class="flex-grow-1">
    <input type="number" name="ajustement-fatigue" class="number-x2 ajustement-fatigue" data-dtype="Number" value="{{voyageur.ajustementFatigue}}" min="-6" max="6"/>
  </span>
-  <span class="flex-grow-1">
-    <input type="number" name="total-fatigue" class="number-x2 total-fatigue" data-dtype="Number" value="1" min="0" max="24" disabled/>
-  </span>
 </li>