Merge pull request '12.0.37 - Les enchantements d'Astrobazzarh' (#742 ) from VincentVk/foundryvtt-reve-de-dragon:v11 into v11

Reviewed-on: #742
Enchantement des gemmes et potions
2025-01-21 09:37:15 +01:00 · 2025-01-21 03:11:47 +01:00 · 2025-01-21 03:08:11 +01:00 · 2025-01-21 03:08:11 +01:00 · 2025-01-19 09:50:20 +01:00 · 2025-01-19 01:21:12 +01:00
200 changed files with 1693 additions and 1192 deletions
--- a/changelog.md
+++ b/changelog.md
@ -1,4 +1,27 @@
 # 12.0
+## 12.0.37 - Les enchantements d'Astrobazzarh
+- les potions ont un état, seules les potions liquides sont enchantables
+- les lancements de sorts du jour sont conservés jusqu'à chateau dormant
+- lorsqu'un joueur souhaite enchanter une potion, les sorts d'enchantements/purification/permanence doivent avoir été lancés auparavant
+- on peut enchanter des gemmes exactement comme des potions
+
+## 12.0.36 - L'alchimie d'Astrobazzarh
+- Nouveautés
+  - ajout d'un bouton pour enchanter les potions
+  - standardisation des boutons d'actions sur les items
+  - utilisations d'icones pour les actions de l'inventaire
+- Corrections:
+  - la commande /tmra sans paramètres fonctionne
+  - les jets d'encaissement depuis le tchat fonctionnent
+  - affichage de la vie/endurance en cas de blessures et remise à neuf
+  - les queues durant 12 heures ajoutées début Vaisseau ne durent plus 24 heures
+- Compendiums
+  - Corrections des remedes enchantables
+  - Corrections de descriptions pour proposer les jet de dés
+
+## 12.0.35 - La Solution d'Astrobazzarh
+- Fix problème d'initialisation des feuilles d'items
+
 ## 12.0.34 - la tête d'Astrobazzarh
 - support de liens "jets de dés"
  - on peut ajouter des liens "jet de dés" dans les journaux, descriptions, notes, maladresses, ...
--- a/module/actor-sheet.js
+++ b/module/actor-sheet.js
@ -12,13 +12,13 @@ import { RdDSheetUtility } from "./rdd-sheet-utility.js";
 import { STATUSES } from "./settings/status-effects.js";
 import { MAINS_DIRECTRICES } from "./actor.js";
 import { RdDBaseActorReveSheet } from "./actor/base-actor-reve-sheet.js";
-import { ITEM_TYPES, RdDItem } from "./item.js";
+import { ITEM_TYPES } from "./constants.js";
+import { RdDItem } from "./item.js";
 import { RdDItemBlessure } from "./item/blessure.js";
 import { RdDEmpoignade } from "./rdd-empoignade.js";
 import { RdDBaseActorSangSheet } from "./actor/base-actor-sang-sheet.js";
 import { RdDCoeur } from "./coeur/rdd-coeur.js";
 import { AppPersonnageAleatoire } from "./actor/random/app-personnage-aleatoire.js";
-import { RdDItemRace } from "./item/race.js";
 import { RdDTextEditor } from "./apps/rdd-text-roll-editor.js";

 /* -------------------------------------------- */
@ -184,22 +184,19 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
      await blessure?.setSoinsBlessure({ soinscomplets: { bonus: Number(event.currentTarget.value) } })
    });

-    // Equip Inventory Item
-    this.html.find('.item-equip').click(async event => this.actor.equiperObjet(RdDSheetUtility.getItemId(event)))
    this.html.find('.roll-chance-actuelle').click(async event => this.actor.rollCarac('chance-actuelle'))
-
    this.html.find('.button-appel-chance').click(async event => this.actor.rollAppelChance())

    this.html.find('[name="jet-astrologie"]').click(async event => this.actor.astrologieNombresAstraux())
-    this.html.find('.tache-label a').click(async event => this.actor.rollTache(RdDSheetUtility.getItemId(event)))
+    this.html.find('.action-tache').click(async event => this.actor.rollTache(RdDSheetUtility.getItemId(event)))
    this.html.find('.meditation-label a').click(async event => this.actor.rollMeditation(RdDSheetUtility.getItemId(event)))

-    this.html.find('.chant-label a').click(async event => this.actor.rollChant(RdDSheetUtility.getItemId(event)))
-    this.html.find('.danse-label a').click(async event => this.actor.rollDanse(RdDSheetUtility.getItemId(event)))
-    this.html.find('.musique-label a').click(async event => this.actor.rollMusique(RdDSheetUtility.getItemId(event)))
-    this.html.find('.oeuvre-label a').click(async event => this.actor.rollOeuvre(RdDSheetUtility.getItemId(event)))
-    this.html.find('.jeu-label a').click(async event => this.actor.rollJeu(RdDSheetUtility.getItemId(event)))
-    this.html.find('.recettecuisine-label a').click(async event => this.actor.rollRecetteCuisine(RdDSheetUtility.getItemId(event)))
+    this.html.find('.action-chant').click(async event => this.actor.rollChant(RdDSheetUtility.getItemId(event)))
+    this.html.find('.action-danse').click(async event => this.actor.rollDanse(RdDSheetUtility.getItemId(event)))
+    this.html.find('.action-musique').click(async event => this.actor.rollMusique(RdDSheetUtility.getItemId(event)))
+    this.html.find('.action-oeuvre').click(async event => this.actor.rollOeuvre(RdDSheetUtility.getItemId(event)))
+    this.html.find('.action-jeu').click(async event => this.actor.rollJeu(RdDSheetUtility.getItemId(event)))
+    this.html.find('.action-recettecuisine').click(async event => this.actor.rollRecetteCuisine(RdDSheetUtility.getItemId(event)))

    this.html.find('.description-aleatoire').click(async event => new AppPersonnageAleatoire(this.actor).render(true))
    if (game.user.isGM) {
@ -217,13 +214,12 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
      // Boutons spéciaux MJs
      this.html.find('.forcer-tmr-aleatoire').click(async event => this.actor.reinsertionAleatoire("Action MJ"))
      this.html.find('.don-de-haut-reve').click(async event => this.actor.addDonDeHautReve())
-      this.html.find('.sortreserve-add').click(async event => this.actor.addSortReserve(RdDSheetUtility.getItemId(event)))
      this.html.find('.afficher-tmr').click(async event => this.actor.changeTMRVisible())
    }

    // Points de reve actuel
    this.html.find('.roll-reve-actuel').click(async event => this.actor.rollCarac('reve-actuel', {resistance:true}))
-    this.html.find('.empoignade-label a').click(async event => RdDEmpoignade.onAttaqueEmpoignadeFromItem(RdDSheetUtility.getItem(event, this.actor)))
+    this.html.find('.action-empoignade').click(async event => RdDEmpoignade.onAttaqueEmpoignadeFromItem(RdDSheetUtility.getItem(event, this.actor)))

    this.html.find('.roll-arme').click(async event => this.actor.rollArme(foundry.utils.duplicate(this._getEventArmeCombat(event)), 'competence'))

@ -327,7 +323,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
  /* -------------------------------------------- */
  async selectTypeOeuvreToCreate() {
    let types = RdDItem.getTypesOeuvres();
-    let content = `<span class="competence-label">Selectionnez le type d'oeuvre</span><select class="item-type">`;
+    let content = `<span class="generic-label">Selectionnez le type d'oeuvre</span><select class="item-type">`;
    for (let typeName of types) {
      content += `<option value="${typeName}">${Misc.typeName('Item', typeName)}</option>`
    }
--- a/module/actor.js
+++ b/module/actor.js
@ -32,7 +32,7 @@ import { RdDItemBlessure } from "./item/blessure.js";
 import { AppAstrologie } from "./sommeil/app-astrologie.js";
 import { RdDEmpoignade } from "./rdd-empoignade.js";
 import { ExperienceLog, XP_TOPIC } from "./actor/experience-log.js";
-import { ITEM_TYPES } from "./item.js";
+import { ITEM_TYPES } from "./constants.js";
 import { RdDBaseActorSang } from "./actor/base-actor-sang.js";
 import { RdDCoeur } from "./coeur/rdd-coeur.js";
 import { DialogChoixXpCarac } from "./dialog-choix-xp-carac.js";
@ -166,29 +166,30 @@ export class RdDActor extends RdDBaseActorSang {
  }

  /* -------------------------------------------- */
-  async $perteRevePotionsEnchantees() {
-    let potions = this.itemTypes[ITEM_TYPES.potion]
-      .filter(it => Grammar.includesLowerCaseNoAccent(it.system.categorie, 'enchanté') && !it.system.prpermanent)
+  async $perteReveEnchantementsChateauDormants() {
+    const toUpdate = this.items.filter(it => [ITEM_TYPES.potion, ITEM_TYPES.gemme].includes(it.type))
+      .map(it => it.perteReveChateauDormant())
+      .filter(it => it != undefined)

-    const potionUpdates = await Promise.all(potions.map(async it => {
-      const nouveauReve = Math.max(it.system.pr - 1, 0)
+    if (toUpdate.length > 0) {
+      console.log('perte de rêve des enchantements', toUpdate)
+      const messageUpdates = await Promise.all(
+        toUpdate.map(async it => await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-pertereve-enchantement-chateaudormant.hbs`, it)))
      ChatMessage.create({
        whisper: ChatUtility.getOwners(this),
-        content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-potionenchantee-chateaudormant.html`, {
-          pr: nouveauReve,
-          alias: this.getAlias(),
-          potionName: it.name,
-          potionImg: it.img
-        })
+        content: messageUpdates.reduce(Misc.joining('<br>'))
      })
-      return {
-        _id: it._id,
-        'system.pr': nouveauReve,
-        'system.quantite': nouveauReve > 0 ? it.system.quantite : 0
-      }
-    }))
+      await this.updateEmbeddedDocuments('Item', toUpdate.map(it => it.update));
+    }
+  }

-    await this.updateEmbeddedDocuments('Item', potionUpdates);
+  async $suppressionLancementsSort() {
+    const updates = this.itemTypes[ITEM_TYPES.sort]
+      .filter(it => it.system.lancements.length > 0)
+      .map(it => { return { _id: it.id, 'system.lancements': [] } })
+    if (updates.length > 0) {
+      await this.updateEmbeddedDocuments('Item', updates)
+    }
  }

  /** --------------------------------------------
@ -245,7 +246,7 @@ export class RdDActor extends RdDBaseActorSang {
  }

  async _recuperationSante(message) {
-    const maladiesPoisons = this.getMaladiePoisons();
+    const maladiesPoisons = this.getMaladiesPoisons();
    const isMaladeEmpoisonne = maladiesPoisons.length > 0;
    this._messageRecuperationMaladiePoisons(maladiesPoisons, message);

@ -253,7 +254,7 @@ export class RdDActor extends RdDBaseActorSang {
    await this._recupererVie(message, isMaladeEmpoisonne);
  }

-  getMaladiePoisons() {
+  getMaladiesPoisons() {
    return this.items.filter(item => item.type == 'maladie' || (item.type == 'poison' && item.system.active));
  }

@ -283,13 +284,14 @@ export class RdDActor extends RdDBaseActorSang {
      };

      await this._recuperationSante(message)
-      await this._recupereMoralChateauDormant(message);
-      await this._recupereChance();
-      await this.transformerStress();
-      await this.retourSeuilDeReve(message);
-      await this.setBonusPotionSoin(0);
-      await this.retourSust(message);
-      await this.$perteRevePotionsEnchantees();
+      await this._recupereMoralChateauDormant(message)
+      await this._recupereChance()
+      await this.transformerStress()
+      await this.retourSeuilDeReve(message)
+      await this.setBonusPotionSoin(0)
+      await this.retourSust(message)
+      await this.$perteReveEnchantementsChateauDormants()
+      await this.$suppressionLancementsSort()
      await RdDCoeur.applyCoeurChateauDormant(this, message)
      if (message.content != "") {
        message.content = `A la fin Chateau Dormant, ${message.content}<br>Un nouveau jour se lève`;
@ -413,19 +415,18 @@ export class RdDActor extends RdDBaseActorSang {

  /* -------------------------------------------- */
  async remiseANeuf() {
-    ChatMessage.create({
-      whisper: ChatUtility.getOwners(this),
-      content: 'Remise à neuf de ' + this.name
-    });
-    await this.supprimerBlessures(it => true);
-    await this.removeEffects(e => e.id != STATUSES.StatusDemiReve);
-    const updates = {
+    await this.update({
      'system.sante.endurance.value': this.system.sante.endurance.max,
      'system.sante.vie.value': this.system.sante.vie.max,
      'system.sante.fatigue.value': 0,
      'system.compteurs.ethylisme': { value: 1, nb_doses: 0, jet_moral: false }
-    };
-    await this.update(updates);
+    })
+    await this.removeEffects(e => e.id != STATUSES.StatusDemiReve);
+    await this.supprimerBlessures(it => true);
+    await ChatMessage.create({
+      whisper: ChatUtility.getOwners(this),
+      content: 'Remise à neuf de ' + this.name
+    });
  }

  /* -------------------------------------------- */
@ -529,7 +530,7 @@ export class RdDActor extends RdDBaseActorSang {
        jet_moral: false,
        value: value
      }
-    });
+    })
  }

  /* -------------------------------------------- */
@ -993,13 +994,10 @@ export class RdDActor extends RdDBaseActorSang {
    }
  }

-  async addSortReserve(itemId) {
-    if (itemId) {
-      const item = this.items.get(itemId)
-      if (item.type == ITEM_TYPES.sort && !item.system.isrituel) {
-        this.$createSortReserve(item)
-        return
-      }
+  async addSortReserve(item) {
+    if (item?.type == ITEM_TYPES.sort && !item.system.isrituel) {
+      this.$createSortReserve(item)
+      return
    }
    const selectSortReserve = {
      title: "Créer un sort en réserve",
@ -1203,42 +1201,6 @@ export class RdDActor extends RdDBaseActorSang {
    new RdDRollDialogEthylisme(html, rollData, this, r => this.saouler(r.forceAlcool)).render(true);
  }

-  async actionPrincipale(item, onActionItem = async () => { }) {
-    let result = await super.actionPrincipale(item, onActionItem)
-    if (result) { return result }
-
-    result = await this.actionNourritureboisson(item, onActionItem)
-    if (result) { return result }
-
-    switch (item.type) {
-      case ITEM_TYPES.potion: return await this.consommerPotion(item, onActionItem);
-      case ITEM_TYPES.livre: return await this.actionLire(item);
-      case ITEM_TYPES.conteneur: return await item.sheet.render(true);
-      case ITEM_TYPES.herbe: return await this.actionHerbe(item, onActionItem);
-      case ITEM_TYPES.queue: case ITEM_TYPES.ombre: return await this.actionRefoulement(item);
-    }
-    return undefined
-  }
-
-  async actionNourritureboisson(item, onActionItem) {
-    switch (item.getUtilisationCuisine()) {
-      case 'brut': {
-        const utilisation = new Dialog({
-          title: "Nourriture brute",
-          content: `Que faire de votre ${item.name}`,
-          buttons: {
-            'cuisiner': { icon: '<i class="fa-solid fa-utensils"></i>', label: 'Cuisiner', callback: async () => await this.preparerNourriture(item) },
-            'manger': { icon: '<i class="fa-solid fa-drumstick-bite"></i>', label: 'Manger cru', callback: async () => await this.mangerNourriture(item, onActionItem) }
-          }
-        });
-        return utilisation.render(true);
-      }
-      case 'pret':
-        return await this.mangerNourriture(item, onActionItem);
-    }
-    return undefined;
-  }
-
  async mangerNourriture(item, onActionItem) {
    return (await DialogConsommer.create(this, item, onActionItem)).render(true);
  }
@ -1250,9 +1212,9 @@ export class RdDActor extends RdDBaseActorSang {
    }
  }

-  async actionHerbe(item, onActionItem = async () => { }) {
+  async fabriquerDecoctionHerbe(item) {
    if (item.isHerbeAPotion()) {
-      return DialogFabriquerPotion.create(this, item, onActionItem);
+      return DialogFabriquerPotion.create(this, item);
    }
    return;
  }
@ -1772,6 +1734,17 @@ export class RdDActor extends RdDBaseActorSang {
        if (rollData.isSortReserve) {
          await this.sortMisEnReserve(selectedSort, rollData.competence, rollData.tmr.coord, Number(selectedSort.system.ptreve_reel));
        }
+        else {
+          console.log('lancement de sort', rollData.selectedSort)
+          const precedents = rollData.selectedSort.system.lancements ?? []
+          const lancements = [...precedents, {
+            timestamp: game.system.rdd.calendrier.getTimestamp(),
+            reve: rollData.selectedSort.system.ptreve_reel
+          }]
+          await this.updateEmbeddedDocuments('Item',
+            [{ _id: rollData.selectedSort._id, 'system.lancements': lancements }]
+          )
+        }
      }
      else {
        rollData.depenseReve = 0;
@ -1891,8 +1864,8 @@ export class RdDActor extends RdDBaseActorSang {
    }
    rollData.tache.system.tentatives = rollData.tache.system.nb_jet_succes + rollData.tache.system.nb_jet_echec;

-    this.updateEmbeddedDocuments('Item', [rollData.tache]);
-    this.santeIncDec("fatigue", rollData.tache.system.fatigue);
+    await this.updateEmbeddedDocuments('Item', [rollData.tache]);
+    await this.santeIncDec("fatigue", rollData.tache.system.fatigue);

    await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-tache.html');
    if (options?.onRollAutomate) {
@ -2570,8 +2543,7 @@ export class RdDActor extends RdDBaseActorSang {
  }

  /* -------------------------------------------- */
-  async equiperObjet(itemID) {
-    let item = this.getEmbeddedDocument('Item', itemID);
+  async equiperObjet(item) {
    if (item?.isEquipable()) {
      const isEquipe = !item.system.equipe;
      await item.update({ "system.equipe": isEquipe });
@ -2590,7 +2562,7 @@ export class RdDActor extends RdDBaseActorSang {
    for (const armure of armures) {
      protection += await RdDDice.rollTotal(armure.system.protection.toString());
      if (dmg > 0 && attackerRoll.dmg.encaisserSpecial != "noarmure") {
-        armure.deteriorerArmure(dmg);
+        await armure.deteriorerArmure(dmg)
        dmg = 0;
      }
    }
@ -2896,12 +2868,13 @@ export class RdDActor extends RdDBaseActorSang {

  /* -------------------------------------------- */
  async fabriquerPotion(herbeData) {
-    let newPotion = {
+    const newPotion = {
      name: `Potion de ${herbeData.system.categorie} (${herbeData.name})`, type: 'potion',
      img: "systems/foundryvtt-reve-de-dragon/icons/objets/fiole_verre.webp",
      system: {
        quantite: 1, cout: 0, encombrement: 0.1,
        categorie: herbeData.system.categorie,
+        etat: 'Liquide',
        herbe: herbeData.name,
        rarete: herbeData.system.rarete,
        herbebrins: herbeData.nbBrins,
@ -2909,29 +2882,23 @@ export class RdDActor extends RdDBaseActorSang {
        description: ""
      }
    }
-    await this.createEmbeddedDocuments('Item', [newPotion], { renderSheet: true });
-
-    let newQuantite = herbeData.system.quantite - herbeData.nbBrins;
-    let messageData = {
-      alias: this.getAlias(),
-      nbBrinsReste: newQuantite,
-      potion: newPotion,
-      herbe: herbeData
-    }
-    this.diminuerQuantiteObjet(herbeData._id, herbeData.nbBrins);
+    await this.createEmbeddedDocuments('Item', [newPotion])
+    await this.diminuerQuantiteObjet(herbeData._id, herbeData.nbBrins)

    ChatMessage.create({
      whisper: ChatUtility.getOwners(this),
-      content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-fabriquer-potion-base.html`, messageData)
-    });
+      content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-fabriquer-potion-base.html`, {
+        alias: this.getAlias(),
+        nbBrinsReste: herbeData.system.quantite - herbeData.nbBrins,
+        potion: newPotion,
+        herbe: herbeData
+      })
+    })
  }

  /* -------------------------------------------- */
  async diminuerQuantiteObjet(id, nb, options = { supprimerSiZero: false }) {
-    const item = this.getItem(id);
-    if (item) {
-      await item.diminuerQuantite(nb, options);
-    }
+    await this.getItem(id)?.diminuerQuantite(nb, options);
  }

  /* -------------------------------------------- */
--- a/module/actor/base-actor-reve-sheet.js
+++ b/module/actor/base-actor-reve-sheet.js
@ -1,6 +1,6 @@
 import { RdDTextEditor } from "../apps/rdd-text-roll-editor.js";
 import { Grammar } from "../grammar.js";
-import { ITEM_TYPES } from "../item.js";
+import { ITEM_TYPES } from "../constants.js";
 import { RdDSheetUtility } from "../rdd-sheet-utility.js";
 import { RdDBaseActorSheet } from "./base-actor-sheet.js";

--- a/module/actor/base-actor-reve.js
+++ b/module/actor/base-actor-reve.js
@ -7,7 +7,7 @@ import { RdDRoll } from "../rdd-roll.js";
 import { RdDUtility } from "../rdd-utility.js";
 import { ReglesOptionnelles } from "../settings/regles-optionnelles.js";
 import { RdDBaseActor } from "./base-actor.js";
-import { ITEM_TYPES } from "../item.js";
+import { ITEM_TYPES } from "../constants.js";
 import { RdDItemCompetence } from "../item-competence.js";
 import { RdDItemCompetenceCreature } from "../item-competencecreature.js";
 import { RdDItemArme } from "../item-arme.js";
--- a/module/actor/base-actor-sang.js
+++ b/module/actor/base-actor-sang.js
@ -1,7 +1,7 @@
 import { RdDUtility } from "../rdd-utility.js";
 import { ReglesOptionnelles } from "../settings/regles-optionnelles.js";
 import { STATUSES } from "../settings/status-effects.js";
-import { ITEM_TYPES } from "../item.js";
+import { ITEM_TYPES } from "../constants.js";
 import { RdDBaseActorReve } from "./base-actor-reve.js";
 import { RdDDice } from "../rdd-dice.js";
 import { RdDItemBlessure } from "../item/blessure.js";
--- a/module/actor/base-actor-sheet.js
+++ b/module/actor/base-actor-sheet.js
@ -3,9 +3,11 @@ import { Misc } from "../misc.js";
 import { DialogSplitItem } from "../dialog-split-item.js";
 import { RdDSheetUtility } from "../rdd-sheet-utility.js";
 import { Monnaie } from "../item-monnaie.js";
-import { RdDItem, ITEM_TYPES } from "../item.js";
+import { ITEM_TYPES } from "../constants.js";
+import { RdDItem } from "../item.js";
 import { RdDItemCompetenceCreature } from "../item-competencecreature.js";
 import { RdDTextEditor } from "../apps/rdd-text-roll-editor.js";
+import { ItemAction } from "../item/item-actions.js";

 /* -------------------------------------------- */
 /**
@ -26,7 +28,7 @@ export class RdDBaseActorSheet extends ActorSheet {

  /* -------------------------------------------- */
  async getData() {
-    Monnaie.validerMonnaies(this.actor.itemTypes['monnaie']);
+    Monnaie.validerMonnaies(this.actor)

    this.actor.computeEtatGeneral();
    let formData = {
@ -42,7 +44,7 @@ export class RdDBaseActorSheet extends ActorSheet {
      effects: this.actor.effects
    }

-    RdDBaseActorSheet.filterItemsPerTypeForSheet(formData, this.actor.itemTypes);
+    RdDUtility.filterItemsPerTypeForSheet(formData, this.actor.itemTypes);
    formData.calc = {
      fortune: Monnaie.toSolsDeniers(this.actor.getFortune()),
      prixTotalEquipement: this.actor.computePrixTotalEquipement(),
@ -54,6 +56,7 @@ export class RdDBaseActorSheet extends ActorSheet {
    formData.conteneurs = RdDUtility.conteneursRacine(formData.conteneurs);
    formData.competences.filter(it => it.type == ITEM_TYPES.competencecreature)
      .forEach(it => it.isdommages = RdDItemCompetenceCreature.isDommages(it))
+
    return formData;
  }

@ -77,95 +80,36 @@ export class RdDBaseActorSheet extends ActorSheet {
    }
  }

-  /* -------------------------------------------- */
-  static filterItemsPerTypeForSheet(formData, itemTypes) {
-    formData.blessures = Misc.arrayOrEmpty(itemTypes['blessure']);
-    formData.recettescuisine = Misc.arrayOrEmpty(itemTypes['recettecuisine']);
-    formData.recettesAlchimiques = Misc.arrayOrEmpty(itemTypes['recettealchimique']);
-    formData.maladies = Misc.arrayOrEmpty(itemTypes['maladie']);
-    formData.poisons = Misc.arrayOrEmpty(itemTypes['poison']);
-    formData.possessions = Misc.arrayOrEmpty(itemTypes['possession']);
-    formData.maladiesPoisons = formData.maladies.concat(formData.poisons);
-    formData.competences = (itemTypes['competence'] ?? []).concat(itemTypes['competencecreature'] ?? []);
-    formData.sortsReserve = Misc.arrayOrEmpty(itemTypes['sortreserve']);
-
-    formData.sorts = Misc.arrayOrEmpty(itemTypes['sort']);
-    formData.rencontres = Misc.arrayOrEmpty(itemTypes['rencontre']);
-    formData.casestmr = Misc.arrayOrEmpty(itemTypes['casetmr']);
-    formData.signesdraconiques = Misc.arrayOrEmpty(itemTypes['signedraconique']);
-    formData.queues = Misc.arrayOrEmpty(itemTypes['queue']);
-    formData.souffles = Misc.arrayOrEmpty(itemTypes['souffle']);
-    formData.ombres = Misc.arrayOrEmpty(itemTypes['ombre']);
-    formData.tetes = Misc.arrayOrEmpty(itemTypes['tete']);
-    formData.taches = Misc.arrayOrEmpty(itemTypes['tache']);
-    formData.meditations = Misc.arrayOrEmpty(itemTypes['meditation']);
-    formData.chants = Misc.arrayOrEmpty(itemTypes['chant']);
-    formData.danses = Misc.arrayOrEmpty(itemTypes['danse']);
-    formData.musiques = Misc.arrayOrEmpty(itemTypes['musique']);
-    formData.oeuvres = Misc.arrayOrEmpty(itemTypes['oeuvre']);
-    formData.jeux = Misc.arrayOrEmpty(itemTypes['jeu']);
-
-    formData.services = Misc.arrayOrEmpty(itemTypes['service']);
-    formData.conteneurs = Misc.arrayOrEmpty(itemTypes['conteneur']);
-    formData.materiel = Misc.arrayOrEmpty(itemTypes['objet']);
-    formData.armes = Misc.arrayOrEmpty(itemTypes['arme']);
-    formData.armures = Misc.arrayOrEmpty(itemTypes['armure']);
-    formData.munitions = Misc.arrayOrEmpty(itemTypes['munition']);
-    formData.livres = Misc.arrayOrEmpty(itemTypes['livre']);
-    formData.potions = Misc.arrayOrEmpty(itemTypes['potion']);
-    formData.plantes = Misc.arrayOrEmpty(itemTypes['plante']);
-    formData.ingredients = Misc.arrayOrEmpty(itemTypes['ingredient']);
-    formData.faunes = Misc.arrayOrEmpty(itemTypes['faune']);
-    formData.herbes = Misc.arrayOrEmpty(itemTypes['herbe']);
-    formData.nourritureboissons = Misc.arrayOrEmpty(itemTypes['nourritureboisson']);
-    formData.gemmes = Misc.arrayOrEmpty(itemTypes['gemme']);
-    formData.monnaies = Misc.arrayOrEmpty(itemTypes['monnaie']).sort(Monnaie.triValeurEntiere());
-    formData.objets = Misc.arrayOrEmpty(itemTypes['objet'])
-
-    formData.inventaires = RdDItem.getItemTypesInventaire('all')
-      .map(t => Misc.arrayOrEmpty(itemTypes[t]))
-      .reduce((a, b) => a.concat(b), [])
-      .sort(Misc.ascending(it => it.name));
-  }
-
  /* -------------------------------------------- */  /** @override */
  activateListeners(html) {
    super.activateListeners(html);
    this.html = html;

+    this.html.find('.actionItem').click(event => ItemAction.onActionItem(event, this.actor, this.options))
+    this.html.find('.item-edit').click(async event => this.itemActionEdit(event))
    this.html.find('.conteneur-name a').click(async event => {
-      RdDUtility.toggleAfficheContenu(this.getItemId(event));
-      this.render(true);
-    });
+      RdDUtility.toggleAfficheContenu(this.getItemId(event))
+      this.render(true)
+    })
+
    this.html.find('.actor-montrer').click(async event => this.actor.postActorToChat());
-    this.html.find('.item-edit').click(async event => this.getItem(event)?.sheet.render(true))
-    this.html.find('.item-montrer').click(async event => this.getItem(event)?.postItemToChat());

    this.html.find('.recherche')
      .each((index, field) => {
        this._rechercheSelectArea(field);
      })
      .keyup(async event => this._rechercherKeyup(event))
-      .change(async event => this._rechercherKeyup(event));
-    this.html.find('.recherche').prop("disabled", false);
+      .change(async event => this._rechercherKeyup(event))
+
+    this.html.find('.recherche').prop("disabled", false)

    // Everything below here is only needed if the sheet is editable
    if (!this.options.editable) return;

-    this.html.find('.item-action').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
-      item?.actionPrincipale(this.actor, async () => this.render())
-    });
-
-
-    this.html.find('.item-split').click(async event => {
-      const item = this.getItem(event);
-      RdDSheetUtility.splitItem(item, this.actor);
-    });
+    this.html.find('.item-equip-armure').click(async event => this.actor.equiperObjet(this.getItem(event)))
+    this.html.find('.item-delete').click(async event => RdDUtility.confirmActorItemDelete(this.getItem(event), this.actor));
    this.html.find('.item-quantite-plus').click(async event => this.actor.itemQuantiteIncDec(this.getItemId(event), 1));
    this.html.find('.item-quantite-moins').click(async event => this.actor.itemQuantiteIncDec(this.getItemId(event), -1));
-    this.html.find('.item-delete').click(async event => RdDUtility.confirmActorItemDelete(this, this.getItem(event)));
-    this.html.find('.item-vendre').click(async event => this.vendre(this.getItem(event)));

    this.html.find('.creer-un-objet').click(async event => {
      this.selectObjetTypeToCreate();
@ -180,6 +124,11 @@ export class RdDBaseActorSheet extends ActorSheet {
    });
  }

+  itemActionEdit(event) {
+    const item = this.getItem(event);
+    return item?.sheet.render(true);
+  }
+
  _rechercherKeyup(event) {
    const currentTarget = event.currentTarget;
    const nouvelleRecherche = this._optionRecherche(currentTarget);
@ -246,7 +195,7 @@ export class RdDBaseActorSheet extends ActorSheet {
  /* -------------------------------------------- */
  async selectObjetTypeToCreate() {
    let types = this.getTypesInventaire().sort(Misc.ascending(type => Misc.typeName('Item', type)));
-    let content = `<span class="competence-label">Selectionnez le type d'équipement</span><select class="item-type">`;
+    let content = `<span class="generic-label">Selectionnez le type d'équipement</span><select class="item-type">`;
    for (let typeName of types) {
      content += `<option value="${typeName}">${Misc.typeName('Item', typeName)}</option>`
    }
--- a/module/actor/base-actor.js
+++ b/module/actor/base-actor.js
@ -3,7 +3,7 @@ import { ChatUtility } from "../chat-utility.js";
 import { SYSTEM_SOCKET_ID } from "../constants.js";
 import { Grammar } from "../grammar.js";
 import { Monnaie } from "../item-monnaie.js";
-import { ITEM_TYPES } from "../item.js";
+import { ITEM_TYPES } from "../constants.js";
 import { Misc } from "../misc.js";
 import { RdDAudio } from "../rdd-audio.js";
 import { RdDConfirm } from "../rdd-confirm.js";
@ -737,25 +737,20 @@ export class RdDBaseActor extends Actor {

  actionImpossible(action) {
    ui.notifications.info(`${this.getAlias()} ne peut pas faire cette action: ${action}`)
-
  }

  async jetEthylisme() { this.actionImpossible("jet d'éthylisme") }
  async rollAppelChance() { this.actionImpossible("appel à la chance") }
  async jetDeMoral() { this.actionImpossible("jet de moral") }

-  async actionPrincipale(item, onActionItem = async () => { }) {
-    switch (item.type) {
-      case ITEM_TYPES.conteneur: return await item.sheet.render(true);
-    }
-    return undefined
-  }
  async resetItemUse() { }
  async incDecItemUse(itemId, inc = 1) { }
  getItemUse(itemId) { return 0; }
+
  async finDeRound(options = { terminer: false }) { }
  isActorCombat() { return false }
  getCaracInit(competence) { return 0 }
+
  listActionsCombat() { return [] }
  listActionsPossessions() {
    return this.itemTypes[ITEM_TYPES.possession]
--- a/module/actor/commerce-sheet.js
+++ b/module/actor/commerce-sheet.js
@ -45,6 +45,7 @@ export class RdDCommerceSheet extends RdDBaseActorSheet {
    super.activateListeners(html);

    this.html.find('a.item-acheter').click(async event => await this.vente(this.getItem(event)));
+    this.html.find('.service-acheter').click(async event => await this.vente(this.getItem(event)));

    if (!this.options.editable) return;

--- a/module/actor/creature.js
+++ b/module/actor/creature.js
@ -1,5 +1,5 @@
 import { Grammar } from "../grammar.js";
-import { ITEM_TYPES } from "../item.js";
+import { ITEM_TYPES } from "../constants.js";
 import { LIST_CARAC_AUTRES } from "../rdd-carac.js";
 import { RdDBaseActorSang } from "./base-actor-sang.js";

--- a/module/actor/entite.js
+++ b/module/actor/entite.js
@ -1,5 +1,5 @@
 import { ENTITE_INCARNE, ENTITE_NONINCARNE } from "../constants.js";
-import { ITEM_TYPES } from "../item.js";
+import { ITEM_TYPES } from "../constants.js";
 import { Misc } from "../misc.js";
 import { RdDCarac } from "../rdd-carac.js";
 import { RdDEncaisser } from "../rdd-roll-encaisser.js";
--- a/module/actor/export-scriptarium/export-scriptarium.js
+++ b/module/actor/export-scriptarium/export-scriptarium.js
@ -1,4 +1,4 @@
-import { ACTOR_TYPES } from "../../item.js"
+import { ACTOR_TYPES } from "../../constants.js"
 import { Misc } from "../../misc.js"
 import { EXPORT_CSV_SCRIPTARIUM, OptionsAvancees } from "../../settings/options-avancees.js"
 import { Mapping } from "./mapping.js"
--- a/module/actor/export-scriptarium/mapping.js
+++ b/module/actor/export-scriptarium/mapping.js
@ -2,7 +2,7 @@ import { Grammar } from "../../grammar.js"
 import { RdDItemArme } from "../../item-arme.js"
 import { RdDItemCompetence } from "../../item-competence.js"
 import { RdDItemSort } from "../../item-sort.js"
-import { ITEM_TYPES } from "../../item.js"
+import { ITEM_TYPES } from "../../constants.js"
 import { Misc } from "../../misc.js"
 import { RdDTimestamp } from "../../time/rdd-timestamp.js"
 import { RdDBonus } from "../../rdd-bonus.js"
--- a/module/apps/rdd-import-stats.js
+++ b/module/apps/rdd-import-stats.js
@ -6,7 +6,7 @@ import { Grammar } from "../grammar.js";
 import { Misc } from "../misc.js";
 import { ENTITE_INCARNE, ENTITE_NONINCARNE } from "../constants.js";
 import { RdDItemTete } from "../item/tete.js";
-import { ITEM_TYPES } from "../item.js";
+import { ITEM_TYPES } from "../constants.js";

 const WHITESPACES = "\\s+"
 const NUMERIC = "[\\+\\-]?\\d+"
--- a/module/apps/rdd-text-roll-editor.js
+++ b/module/apps/rdd-text-roll-editor.js
@ -1,6 +1,6 @@
 import "./xregexp-all.js";
 import { SystemCompendiums } from "../settings/system-compendiums.js";
-import { ACTOR_TYPES } from "../item.js";
+import { ACTOR_TYPES } from "../constants.js";
 import { TextRollAlchimie } from "./textroll/text-roll-alchimie.js";
 import { TextRollCaracCompetence } from "./textroll/text-roll-carac-competence.js";
 import { TextRollFormula } from "./textroll/text-roll-formula.js";
--- a/module/apps/textroll/text-roll-alchimie.js
+++ b/module/apps/textroll/text-roll-alchimie.js
@ -1,5 +1,5 @@
 import "../xregexp-all.js";
-import { ACTOR_TYPES, ITEM_TYPES } from "../../item.js";
+import { ACTOR_TYPES, ITEM_TYPES } from "../../constants.js";
 import { RdDCarac } from "../../rdd-carac.js";
 import { RdDUtility } from "../../rdd-utility.js";
 import { RdDAlchimie } from "../../rdd-alchimie.js";
--- a/module/apps/textroll/text-roll-formula.js
+++ b/module/apps/textroll/text-roll-formula.js
@ -18,7 +18,7 @@ export class TextRollFormula {

  async onRollText(event, actor) {
    const node = TextRollManager.getNode(event)
-    const rollFormula = node.data('roll-formula')
+    const rollFormula = node.data('formula')
    if (rollFormula) {
      const roll = new Roll(rollFormula)
      await roll.evaluate()
--- a/module/constants.js
+++ b/module/constants.js
@ -50,4 +50,59 @@ export const RDD_CONFIG = {
    {value: "Rare", label: "Rare"},
    {value: "Rarissime", label: "Rarissime"}
  ]
-}
+}
+
+export const ACTOR_TYPES = {
+  personnage: 'personnage',
+  creature: 'creature',
+  entite: 'entite',
+  commerce: 'commerce',
+  vehicule: 'vehicule'
+}
+
+export const ITEM_TYPES = {
+  competence: 'competence',
+  competencecreature: 'competencecreature',
+  empoignade: 'empoignade',
+  possession: 'possession',
+  blessure: 'blessure',
+  maladie: 'maladie',
+  poison: 'poison',
+  arme: 'arme',
+  armure: 'armure',
+  conteneur: 'conteneur',
+  objet: 'objet',
+  monnaie: 'monnaie',
+  gemme: 'gemme',
+  munition: 'munition',
+  nourritureboisson: 'nourritureboisson',
+  herbe: 'herbe',
+  plante: 'plante',
+  ingredient: 'ingredient',
+  faune: 'faune',
+  livre: 'livre',
+  potion: 'potion',
+  service: 'service',
+  musique: 'musique',
+  danse: 'danse',
+  chant: 'chant',
+  jeu: 'jeu',
+  race: 'race',
+  recettecuisine: 'recettecuisine',
+  oeuvre: 'oeuvre',
+  recettealchimique: 'recettealchimique',
+  tache: 'tache',
+  sort: 'sort',
+  sortreserve: 'sortreserve',
+  rencontre: 'rencontre',
+  queue: 'queue',
+  ombre: 'ombre',
+  souffle: 'souffle',
+  tete: 'tete',
+  casetmr: 'casetmr',
+  meditation: 'meditation',
+  signedraconique: 'signedraconique',
+  tarot: 'tarot',
+  nombreastral: 'nombreastral',
+  extraitpoetique: 'extraitpoetique',
+}
--- a/module/dialog-fabriquer-potion.js
+++ b/module/dialog-fabriquer-potion.js
@ -1,88 +1,79 @@
-import { Grammar } from "./grammar.js";
 import { Misc } from "./misc.js";
 import { RdDUtility } from "./rdd-utility.js";

 export class DialogFabriquerPotion extends Dialog {

  /* -------------------------------------------- */
-  static async create(actor, item, onActionItem) {
-    const min = DialogFabriquerPotion.nombreBrinsMinimum(item);
-    if (item.system.quantite < min) {
-      ui.notifications.warn(`Vous avez ${item.system.quantite} brins de ${item.name}, il en faut au moins ${min} pour faire une potion!`);
-      return;
+  static async create(actor, item) {
+    const brinsMinimum = DialogFabriquerPotion.nombreBrinsMinimum(item)
+    if (item.system.quantite < brinsMinimum) {
+      ui.notifications.warn(`Vous avez ${item.system.quantite} brins de ${item.name}, il en faut au moins ${brinsMinimum} pour faire une potion!`)
+      return
    }
-    let potionData = DialogFabriquerPotion.prepareData(actor, item);
+    const potionData = DialogFabriquerPotion.prepareData(item, brinsMinimum)
+    const options = { classes: ["dialogfabriquerpotion"], width: 600, height: 160, 'z-index': 99999 }
+    const html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/dialog-fabriquer-potion-base.html', potionData)

-    const html = await renderTemplate( 'systems/foundryvtt-reve-de-dragon/templates/dialog-fabriquer-potion-base.html', potionData);
-
-    let options = { classes: ["dialogfabriquerpotion"], width: 600, height: 160, 'z-index': 99999 };
-    new DialogFabriquerPotion(actor, potionData, onActionItem, html, options).render(true);
+    new DialogFabriquerPotion(actor, potionData, html, options).render(true)
  }

  /* -------------------------------------------- */
-  static prepareData(actor, item) {
-    let potionData = foundry.utils.duplicate(item)
-    potionData.nbBrinsSelect = RdDUtility.buildListOptions(
-      DialogFabriquerPotion.nombreBrinsMinimum(item),
-      DialogFabriquerPotion.nombreBrinsOptimal(item));
-    potionData.nbBrins = Math.min(potionData.system.quantite, DialogFabriquerPotion.nombreBrinsOptimal(potionData));
-    potionData.herbebonus = item.system.niveau;
-    potionData.buttonName = "Fabriquer";
-    return potionData;
+  static prepareData(item, brinsMinimum) {
+    const brinsOptimal = DialogFabriquerPotion.nombreBrinsOptimal(item)
+    return foundry.utils.mergeObject(foundry.utils.duplicate(item), {
+      nbBrinsSelect: RdDUtility.buildListOptions(brinsMinimum, brinsOptimal),
+      nbBrins: Math.min(item.system.quantite, brinsOptimal),
+      herbebonus: item.system.niveau
+    })
  }

  /* -------------------------------------------- */
-  constructor(actor, potionData, onActionItem, html, options) {
+  constructor(actor, potionData, html, options) {
    const conf = {
      title: `Fabriquer une potion de ${potionData.system.categorie}`,
      content: html,
      default: 'fabriquer',
      buttons: {
-        'fabriquer': {
-          label: potionData.buttonName, callback: it => this.onFabriquer()
-        }
+        'fabriquer': { label: "Fabriquer", callback: it => this.onFabriquer() }
      }
-    };
+    }
+    super(conf, options)

-    super(conf, options);
-
-    this.actor = actor;
-    this.potionData = potionData;
-    this.onActionItem = onActionItem;
+    this.actor = actor
+    this.potionData = potionData
  }

  /* -------------------------------------------- */
  activateListeners(html) {
-    super.activateListeners(html);
-    this.html = html;
+    super.activateListeners(html)
+    this.html = html
    this.html.find("[name='nbBrins']").change(event => {
-      this.potionData.nbBrins = Misc.toInt(event.currentTarget.value);
-      const brinsManquants = Math.max(0, DialogFabriquerPotion.nombreBrinsOptimal(this.potionData) - this.potionData.nbBrins);
+      this.potionData.nbBrins = Misc.toInt(event.currentTarget.value)
+      const brinsManquants = Math.max(0, DialogFabriquerPotion.nombreBrinsOptimal(this.potionData) - this.potionData.nbBrins)
      this.potionData.herbebonus = Math.max(0, this.potionData.system.niveau - brinsManquants)
-    });
+    })
  }

  /* -------------------------------------------- */
  async onFabriquer() {
-    await this.html.find("[name='nbBrins']").change();
-    await this.actor.fabriquerPotion(this.potionData);
-    this.close();
-    await this.onActionItem()
+    await this.html.find("[name='nbBrins']").change()
+    await this.actor.fabriquerPotion(this.potionData)
+    this.close()
  }

  static nombreBrinsMinimum(herbeData) {
    switch (herbeData.system.categorie ?? '') {
-      case "Soin": return 1 + Math.max(0, 12 - 2 * herbeData.system.niveau);
-      case "Repos": return 1 + Math.max(0, 7 - 2 * herbeData.system.niveau);
+      case "Soin": return 1 + Math.max(0, 12 - 2 * herbeData.system.niveau)
+      case "Repos": return 1 + Math.max(0, 7 - 2 * herbeData.system.niveau)
    }
-    return 1;
+    return 1
  }

  static nombreBrinsOptimal(herbeData) {
    switch (herbeData.system.categorie ?? '') {
-      case "Soin": return 12 - herbeData.system.niveau;
-      case "Repos": return 7 - herbeData.system.niveau;
+      case "Soin": return 12 - herbeData.system.niveau
+      case "Repos": return 7 - herbeData.system.niveau
    }
-    return 1;
+    return 1
  }
 }
--- a/module/enchantement/dialog-enchanter.js
+++ b/module/enchantement/dialog-enchanter.js
@ -0,0 +1,177 @@
+import { ITEM_TYPES } from "../constants.js"
+import { RdDItemSort } from "../item-sort.js"
+import { Misc } from "../misc.js"
+
+export const ACTION_ITEM_ENCHANTER =  {
+  code: 'item-enchanter', label: 'Enchanter', icon: it => 'fa-solid fa-sparkles',
+  filter: it => game.user.isGM || DialogEnchanter.isEnchantable(it),
+  optionsFilter: options => options.editable,
+  action: (item, actor) => DialogEnchanter.enchanter(item)
+}
+
+export class DialogEnchanter extends Dialog {
+
+  static isEnchantable(item) {
+    if (!item.isEnchantementPossible) {
+      return false
+    }
+    if (game.user.isGM) {
+      return true
+    }
+    if (item.system.prpermanent) {
+      return false
+    }
+    if (!item.parent?.isHautRevant()) {
+      return false
+    }
+    return RdDItemSort.lancements(RdDItemSort.findEnchantement(item.parent)) > 0
+      || RdDItemSort.lancements(RdDItemSort.findPurification(item.parent)) > 0
+      || RdDItemSort.lancements(RdDItemSort.findPermanence(item.parent)) > 0
+  }
+
+  static dateEnchantement() {
+    return game.system.rdd.calendrier.getTimestamp().debutJournee().indexDate
+  }
+
+  static async enchanter(item) {
+    const actor = item.parent
+    const sorts = {
+      enchantement: RdDItemSort.findEnchantement(actor),
+      purification: RdDItemSort.findPurification(actor),
+      permanence: RdDItemSort.findPermanence(actor)
+    }
+    const nouveauxpr = (sorts.enchantement?.system.lancements ?? []).map(it => it.reve)
+    const purification = (sorts.purification?.system.lancements ?? []).find(it => true)
+    const permanence = (sorts.permanence?.system.lancements ?? []).find(it => true)
+
+    const enchanter = {
+      type: item.type == ITEM_TYPES.potion ? 'potion' : Misc.typeName('Item', item.type),
+      actor: actor,
+      item: item,
+      reve: item.system.pr,
+      sorts: sorts,
+      nouveauxpr: nouveauxpr,
+      purification: purification != undefined,
+      permanence: permanence != undefined,
+      options: { isGM: game.user.isGM }
+    }
+    if (!item.isEnchantementPossible) {
+      ui.notifications.info("Seuls les liquides et les gemmes sont enchantables")
+      return
+    }
+    if (item.system.prpermanent) {
+      ui.notifications.info(`La ${enchanter.type} est permanente`)
+      return
+    }
+    if (!game.user.isGM) {
+      if (!(actor?.isPersonnage() || actor?.isHautRevant())) {
+        ui.notifications.info(`Seul un haut rêvant peut enchanter une ${enchanter.type}`)
+        return
+      }
+      if (item.system.quantite != 1) {
+        ui.notifications.info(`Impossible d'enchanter ${item.system.quantite} ${enchanter.type}s ${item.system.quantite > 1 ? 'en une seule fois' : ''}`)
+        return
+      }
+      if (!(nouveauxpr.length > 0 || purification || permanence)) {
+        ui.notifications.info("Le haut-rêvant n'a lancé de rituel d'enchantement")
+        return
+      }
+      if (item.system.magique && item.system.purifie && !purification && !permanence) {
+        ui.notifications.info(`La ${enchanter.type} est déjà enchantée et doit être purifiée`)
+        return
+      }
+    }
+
+    const html = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/enchantement/dialog-enchanter.hbs`, enchanter)
+    const dialog = new DialogEnchanter(enchanter, html)
+    dialog.render(true)
+  }
+
+  constructor(enchanter, html) {
+    let options = { classes: ["dialog-enchanter"], width: 400, height: 'fit-content', 'z-index': 99999 }
+    let conf = {
+      title: `Enchanter une ${enchanter.type}`,
+      content: html,
+      default: "enchanter",
+      buttons: {
+        "enchanter": { label: "Enchanter", callback: it => this.onEnchanter() }
+      }
+    };
+    super(conf, options)
+    this.html = html
+    this.enchanter = enchanter
+    this.item = enchanter.item
+  }
+
+  activateListeners(html) {
+    super.activateListeners(html)
+    this.html = html
+    this.html.find("input.enchantement").change(event => this.$onSelectEnchantement(event))
+    this.html.find("input.reve").change(event => this.$onForceReve(event))
+  }
+
+  $onSelectEnchantement(event) {
+    const addReve = $(event.currentTarget).data('reve')
+    this.enchanter.idx = $(event.currentTarget).data('idx')
+    this.enchanter.reve = this.item.system.pr + Number(addReve)
+    this.html.find("input.reve").val(this.enchanter.reve)
+    for (let idx = 0; idx < this.enchanter.nouveauxpr.length; idx++) {
+      if (idx != this.enchanter.idx) {
+        this.html.find(`.enchantement[data-idx='${idx}']`).prop("checked", false)
+      }
+    }
+  }
+
+  $onForceReve(event) {
+    const newReve = Number(event.currentTarget.value)
+    if (this.enchanter.reve != newReve) {
+      this.enchanter.idx = undefined
+    }
+    this.enchanter.reve = newReve
+  }
+
+  async onEnchanter() {
+    foundry.utils.mergeObject(this.enchanter,
+      {
+        rendrepurifie: this.html.find("input.rendrepurifie").prop("checked"),
+        rendrepermanent: this.html.find("input.rendrepermanent").prop("checked"),
+        addreve: this.enchanter.reve != this.item.system.pr
+      },
+      { inplace: true })
+    const item = this.enchanter.item
+    const actor = this.enchanter.actor
+
+    if (this.enchanter.reve == 0) {
+      await item.update({
+        'system.pr': 0,
+        'system.magique': false,
+        'system.purifie': false,
+        'system.prpermanent': false,
+        'system.prdate': 0
+      })
+    }
+    else {
+      const isPurifiee = this.enchanter.addreve
+        ? (this.enchanter.rendrepurifie && (item.item.system.pr == 0 ? true : item.system.purifie))
+        : (this.enchanter.rendrepurifie || item.system.purifie)
+      await item.update({
+        'system.pr': this.enchanter.reve,
+        'system.magique': true,
+        'system.purifie': isPurifiee,
+        'system.prpermanent': item.system.prpermanent || this.enchanter.rendrepermanent,
+        'system.prdate': DialogEnchanter.dateEnchantement()
+      })
+      if (actor) {
+        if (this.enchanter.rendrepurifie) {
+          await RdDItemSort.changeLancementsSort(this.enchanter.sorts.purification, it => it.slice(1));
+        }
+        if (this.enchanter.rendrepermanent) {
+          await RdDItemSort.changeLancementsSort(this.enchanter.sorts.permanence, it => it.slice(1));
+        }
+        if (this.enchanter.addreve && this.enchanter.idx != undefined) {
+          await RdDItemSort.changeLancementsSort(RdDItemSort.findEnchantement(actor), it => it.toSpliced(this.enchanter.idx, 1))
+        }
+      }
+    }
+  }
+}
--- a/module/item-arme.js
+++ b/module/item-arme.js
@ -1,6 +1,6 @@
 import { Grammar } from "./grammar.js";
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js"
-import { ITEM_TYPES } from "./item.js";
+import { ITEM_TYPES } from "./constants.js";
 import { BASE_CORPS_A_CORPS } from "./item/base-items.js";
 import { RdDCombatManager } from "./rdd-combat.js";

--- a/module/item-competencecreature.js
+++ b/module/item-competencecreature.js
@ -1,5 +1,5 @@

-import { ITEM_TYPES } from "./item.js";
+import { ITEM_TYPES } from "./constants.js";
 import { RdDCombatManager } from "./rdd-combat.js";

 export const CATEGORIES_COMPETENCES_CREATURES = {
--- a/module/item-monnaie.js
+++ b/module/item-monnaie.js
@ -1,5 +1,5 @@
 import { Misc } from "./misc.js";
-import { LOG_HEAD } from "./constants.js";
+import { ITEM_TYPES, LOG_HEAD } from "./constants.js";

 const MONNAIE_ETAIN = {
  name: "Denier (étain)", type: 'monnaie',
@ -70,18 +70,17 @@ export class Monnaie {
  }

  static getFortune(monnaies) {
-    return (monnaies??[])
+    return (monnaies ?? [])
      .map(m => Number(m.system.cout) * Number(m.system.quantite))
      .reduce(Misc.sum(), 0);
  }

  static async optimiserFortune(actor, fortune) {
+    Monnaie.validerMonnaies(actor)
    let resteEnDeniers = Math.round(fortune * 100);
-    let monnaies = actor.itemTypes['monnaie'];
-    let updates = [];
-    Monnaie.validerMonnaies(monnaies, actor);
+    const updates = []

-    let parValeur = Misc.classifyFirst(monnaies, it => VALEUR_DENIERS(it.system.cout));
+    const  parValeur = Misc.classifyFirst(actor.itemTypes[ITEM_TYPES.monnaie], it => VALEUR_DENIERS(it.system.cout));
    for (let valeurDeniers of [1000, 100, 10, 1]) {
      const itemPiece = parValeur[valeurDeniers];
      if (itemPiece) {
@ -102,8 +101,11 @@ export class Monnaie {
    }
  }

-  static validerMonnaies(monnaies, actor = undefined) {
-    monnaies.filter(it => VALEUR_DENIERS(it.system.cout) == 0)
+  static validerMonnaies(actor) {
+    if (!actor) {
+      return
+     }
+    actor.itemTypes[ITEM_TYPES.monnaie]?.filter(it => VALEUR_DENIERS(it.system.cout) == 0)
      .map(it => `La  monnaie ${it.name} de l'acteur ${actor?.name ?? 'sélectionné'} a une valeur de 0!`)
      .forEach(message => {
        ui.notifications.warn(message);
--- a/module/item-sheet.js
+++ b/module/item-sheet.js
@ -1,8 +1,7 @@
+import { ACTOR_TYPES, ITEM_TYPES } from "./constants.js";
 import { RdDItemSort } from "./item-sort.js";
 import { RdDUtility } from "./rdd-utility.js";
 import { RdDItemCompetence } from "./item-competence.js";
-import { RdDHerbes } from "./rdd-herbes.js";
-import { RdDGemme } from "./rdd-gemme.js";
 import { HtmlUtility } from "./html-utility.js";
 import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
 import { SYSTEM_RDD } from "./constants.js";
@ -11,9 +10,11 @@ import { SystemCompendiums } from "./settings/system-compendiums.js";
 import { Misc } from "./misc.js";
 import { RdDTimestamp } from "./time/rdd-timestamp.js";
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
-import { ACTOR_TYPES, ITEM_TYPES, RdDItem } from "./item.js";
+import { RdDItem } from "./item.js";
 import { FLEUVE_COORD, TMRUtility } from "./tmr-utility.js";
 import { RdDTextEditor } from "./apps/rdd-text-roll-editor.js";
+import { ItemAction } from "./item/item-actions.js";
+import { RdDItemGemme } from "./item/gemme.js";

 /**
 * Extend the basic ItemSheet for RdD specific items
@ -26,8 +27,8 @@ export class RdDItemSheet extends ItemSheet {

  static defaultTemplate(type) {
    return type ?
-      `systems/foundryvtt-reve-de-dragon/templates/item-${type}-sheet.html` :
-      "systems/foundryvtt-reve-de-dragon/templates/item-sheet.html";
+      `systems/foundryvtt-reve-de-dragon/templates/item/${type}-sheet.hbs` :
+      "systems/foundryvtt-reve-de-dragon/templates/item/item-sheet.hbs";
  }

  static register(sheetClass) {
@ -132,13 +133,7 @@ export class RdDItemSheet extends ItemSheet {
      formData.enchantement = await RdDTextEditor.enrichHTML(this.item.system.enchantement, this.item)
      formData.sureffet = await RdDTextEditor.enrichHTML(this.item.system.sureffet, this.item)
    }
-    if (this.item.type == ITEM_TYPES.gemme) {
-      formData.gemmeTypeList = RdDGemme.getGemmeTypeOptionList();
-      RdDGemme.calculDataDerivees(this.item)
-    }
-    if (this.item.type == ITEM_TYPES.potion) {
-      RdDHerbes.calculFormData(formData, this.item)
-    }
+
    if (this.item.type == ITEM_TYPES.herbe) {
      if (formData.options.isOwned && ['Soin', 'Repos'].includes(formData.system.categorie)) {
        formData.isIngredientPotionBase = true;
@ -165,7 +160,7 @@ export class RdDItemSheet extends ItemSheet {
    HtmlUtility.showControlWhen(this.html.find(".item-cout"), ReglesOptionnelles.isUsing('afficher-prix-joueurs')
      || game.user.isGM
      || !this.item.isOwned);
-    HtmlUtility.showControlWhen(this.html.find(".item-magique"), this.item.isMagique());
+    HtmlUtility.showControlWhen(this.html.find(".item-magique"), this.item.isMagique);

    // Everything below here is only needed if the sheet is editable
    if (!this.options.editable) return;
@ -193,38 +188,27 @@ export class RdDItemSheet extends ItemSheet {
      this.supprimerBonusCase(event.currentTarget.attributes['data-deleteCoord'].value)
    })

-    this.html.find('.date-enchantement').change((event) => {
-      const jour = Number(this.html.find('input.date-enchantement[name="enchantement.jour"]').val());
-      const mois = RdDTimestamp.definition(this.html.find('select.date-enchantement[name="enchantement.mois"]').val());
-      const indexDate = game.system.rdd.calendrier.getIndexFromDate(jour, mois.heure);
-      this.item.update({ 'system.prdate': indexDate });
-      console.warn(`Date d'enchantement modifiée ${jour}/${mois.heure}: ${indexDate}`)
-    });
-
    this.html.find('.creer-tache-livre').click((event) => this._getEventActor(event).creerTacheDepuisLivre(this.item));
-    this.html.find('.consommer-potion').click((event) => this._getEventActor(event).consommerPotion(this.item, this.getActionRenderItem()));
-    this.html.find('.creer-potion-base').click((event) => this._getEventActor(event).actionHerbe(this.item));
+    this.html.find('.creer-potion-base').click((event) => this._getEventActor(event).fabriquerDecoctionHerbe(this.item))
    this.html.find('input[name="system.cacher_points_de_tache"]').change(async event => await this.item.update({ 'system.cacher_points_de_tache': event.currentTarget.checked }));

    this.html.find('.roll-text').click(async event => await RdDTextEditor.rollText(event, this.actor))
    this.html.find('.chat-roll-text').click(async event => await RdDTextEditor.chatRollText(event))

    if (this.actor) {
-      this.html.find('.item-split').click(async event => RdDSheetUtility.splitItem(RdDSheetUtility.getItem(event, this.actor), this.actor, this.getActionRenderItem()));
-      this.html.find('.item-edit').click(async event => RdDSheetUtility.getItem(event, this.actor)?.sheet.render(true));
-      this.html.find('.item-delete').click(async event => RdDUtility.confirmActorItemDelete(this, RdDSheetUtility.getItem(event, this.actor)));
-      this.html.find('.item-vendre').click(async event => RdDSheetUtility.getItem(event, this.actor)?.proposerVente());
-      this.html.find('.item-montrer').click(async event => RdDSheetUtility.getItem(event, this.actor)?.postItemToChat());
-      this.html.find('.item-action').click(async event => RdDSheetUtility.getItem(event, this.actor)?.actionPrincipale(this.actor, this.getActionRenderItem()));
+      this.html.find('.actionItem').click(event => ItemAction.onActionItem(event, this.actor, this.options))
+      
+      // TODO: utiliser un itemAction?
+      this.html.find('.item-potion-consommer').click(event => this.itemActionConsommer(event))

      this.html.find('.item-quantite-plus').click(async event => {
        await this.actor.itemQuantiteIncDec(RdDSheetUtility.getItemId(event), 1)
-        this.render();
-      });
+        this.render()
+      })
      this.html.find('.item-quantite-moins').click(async event => {
        await this.actor.itemQuantiteIncDec(RdDSheetUtility.getItemId(event), -1)
-        this.render();
-      });
+        this.render()
+      })
    }

    const updateItemTimestamp = (path, timestamp) => this.item.update({ [path]: foundry.utils.duplicate(timestamp) })
@ -233,13 +217,24 @@ export class RdDItemSheet extends ItemSheet {
    RdDTimestamp.handleTimestampEditor(this.html, 'system.temporel.fin', updateItemTimestamp);
  }

-  getActionRenderItem() {
-    return async () => {
-      let item = this.item;
-      while (item) {
-        await item.sheet?.render()
-        item = this.actor.getContenant(item)
-      }
+  itemActionDelete(event) {
+    const item = RdDSheetUtility.getItem(event, this.actor)
+    return RdDUtility.confirmActorItemDelete(item, this.actor)
+  }
+
+  async itemActionConsommer(event) {
+    const item = RdDSheetUtility.getItem(event, this.actor)
+    if (item) {
+      await actor.consommerPotion(item)
+      await RdDSheetUtility.renderItemBranch(this.actor, item)
+    }
+  }
+
+  async itemActionSplit(event) {
+    const item = RdDSheetUtility.getItem(event, this.actor)
+    if (item) {
+      await RdDSheetUtility.splitItem(item, this.actor)
+      await RdDSheetUtility.renderItemBranch(this.actor, item)
    }
  }

--- a/module/item-sort.js
+++ b/module/item-sort.js
@ -1,6 +1,6 @@
 import { Grammar } from "./grammar.js";
 import { RdDItemCompetence } from "./item-competence.js";
-import { ITEM_TYPES } from "./item.js";
+import { ITEM_TYPES } from "./constants.js";
 import { Misc } from "./misc.js";
 import { FLEUVE_COORD, TMRUtility } from "./tmr-utility.js";

@ -22,7 +22,21 @@ export class RdDItemSort extends Item {
  }

  static addSpaceToNonNumeric(value) {
-    return Number.isNumeric(value) || ['-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'].includes( String(value).charAt[0]) ? value : ' ' + RdDItemSort.toVar(value)
+    return Number.isNumeric(value) || ['-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'].includes(String(value).charAt[0]) ? value : ' ' + RdDItemSort.toVar(value)
+  }
+
+  static lancements(sort) { return sort?.system.lancements.length ?? 0 }
+
+  static findEnchantement(actor) { return RdDItemSort.findSort(actor, 'Enchantement', ['Narcos', 'N']) }
+  static findPermanence(actor) { return RdDItemSort.findSort(actor, 'Permanence', ['Narcos', 'N']) }
+  static findPurification(actor) { return RdDItemSort.findSort(actor, 'Purification', ['Narcos', 'N']) }
+
+  static findSort(actor, name, draconics) {
+    return actor.itemTypes[ITEM_TYPES.sort].find(it => Grammar.includesLowerCaseNoAccent(it.name, name)
+      && (draconics == undefined || draconics.includes(it.system.draconic)))
+  }
+  static async changeLancementsSort(sort, changement) {
+    await sort?.update({ 'system.lancements': changement(sort.system.lancements) });
  }

  static toVar(value) {
@ -151,5 +165,4 @@ export class RdDItemSort extends Item {
      .map(it => it.split(':'))
      .map(it => { return { case: it[0], bonus: it[1] } });
  }
-
 }
--- a/module/item.js
+++ b/module/item.js
@ -1,7 +1,7 @@
+import { ITEM_TYPES } from "./constants.js";
 import { DialogItemVente } from "./achat-vente/dialog-item-vente.js";
 import { Grammar } from "./grammar.js";
 import { Misc } from "./misc.js";
-import { RdDHerbes } from "./rdd-herbes.js";
 import { RdDTimestamp } from "./time/rdd-timestamp.js";
 import { RdDUtility } from "./rdd-utility.js";
 import { SystemCompendiums } from "./settings/system-compendiums.js";
@ -9,61 +9,7 @@ import { RdDRaretes } from "./item/raretes.js";
 import { CATEGORIES_COMPETENCES } from "./item-competence.js";
 import { CATEGORIES_COMPETENCES_CREATURES } from "./item-competencecreature.js";
 import { BASE_CORPS_A_CORPS, BASE_ESQUIVE } from "./item/base-items.js";
-
-export const ACTOR_TYPES = {
-  personnage: 'personnage',
-  creature: 'creature',
-  entite: 'entite',
-  commerce: 'commerce',
-  vehicule: 'vehicule'
-}
-
-export const ITEM_TYPES = {
-  competence: 'competence',
-  competencecreature: 'competencecreature',
-  empoignade: 'empoignade',
-  possession: 'possession',
-  blessure: 'blessure',
-  maladie: 'maladie',
-  poison: 'poison',
-  arme: 'arme',
-  armure: 'armure',
-  conteneur: 'conteneur',
-  objet: 'objet',
-  monnaie: 'monnaie',
-  gemme: 'gemme',
-  munition: 'munition',
-  nourritureboisson: 'nourritureboisson',
-  herbe: 'herbe',
-  plante: 'plante',
-  ingredient: 'ingredient',
-  faune: 'faune',
-  livre: 'livre',
-  potion: 'potion',
-  service: 'service',
-  musique: 'musique',
-  danse: 'danse',
-  chant: 'chant',
-  jeu: 'jeu',
-  race: 'race',
-  recettecuisine: 'recettecuisine',
-  oeuvre: 'oeuvre',
-  recettealchimique: 'recettealchimique',
-  tache: 'tache',
-  sort: 'sort',
-  sortreserve: 'sortreserve',
-  rencontre: 'rencontre',
-  queue: 'queue',
-  ombre: 'ombre',
-  souffle: 'souffle',
-  tete: 'tete',
-  casetmr: 'casetmr',
-  meditation: 'meditation',
-  signedraconique: 'signedraconique',
-  tarot: 'tarot',
-  nombreastral: 'nombreastral',
-  extraitpoetique: 'extraitpoetique',
-}
+import { ITEM_ACTIONS, DEFAULT_ACTIONS, COMMON_ACTIONS } from "./item/item-actions.js";

 const typesInventaireMateriel = [
  ITEM_TYPES.arme,
@ -95,51 +41,47 @@ const typesObjetsTemporels = [ITEM_TYPES.blessure, ITEM_TYPES.poison, ITEM_TYPES
 const typesObjetsEquipable = [ITEM_TYPES.arme, ITEM_TYPES.armure, ITEM_TYPES.objet];
 const typesEnvironnement = typesInventaireMateriel;
 const encBrin = 0.00005; // un brin = 1 décigramme = 1/10g = 1/10000kg = 1/20000 enc
-const encPepin = 0.0007; /* un pépin de gemme = 1/10 cm3 = 1/1000 l = 3.5/1000 kg = 7/2000 kg = 7/1000 enc
-densité 3.5 (~2.3 à 4, parfois plus) -- https://www.juwelo.fr/guide-des-pierres/faits-et-chiffres/ 
-   */

 export const defaultItemImg = {
-  competence: "systems/foundryvtt-reve-de-dragon/icons/competence_defaut.webp",
-  competencecreature: "systems/foundryvtt-reve-de-dragon/icons/competence_defaut.webp",
  arme: "systems/foundryvtt-reve-de-dragon/icons/armes_armures/epee_gnome.webp",
  armure: "systems/foundryvtt-reve-de-dragon/icons/armes_armures/armure_plaques.webp",
-  conteneur: "systems/foundryvtt-reve-de-dragon/icons/objets/sac_a_dos.webp",
-  sort: "systems/foundryvtt-reve-de-dragon/icons/competence_oniros.webp",
-  herbe: "systems/foundryvtt-reve-de-dragon/icons/botanique/Endorlotte.webp",
-  faune: "systems/foundryvtt-reve-de-dragon/icons/faune/rongeur.webp",
-  ingredient: "systems/foundryvtt-reve-de-dragon/icons/objets/sable_poudre.webp",
-  livre: "systems/foundryvtt-reve-de-dragon/icons/objets/livre.webp",
-  potion: "systems/foundryvtt-reve-de-dragon/icons/objets/liqueur_de_bagdol.webp",
-  rencontre: "systems/foundryvtt-reve-de-dragon/icons/tete_dragon.webp",
-  queue: "systems/foundryvtt-reve-de-dragon/icons/queue_dragon.webp",
-  ombre: "systems/foundryvtt-reve-de-dragon/icons/queue_dragon.webp",
-  souffle: "systems/foundryvtt-reve-de-dragon/icons/souffle_dragon.webp",
-  tete: "systems/foundryvtt-reve-de-dragon/icons/tete_dragon.webp",
-  meditation: "systems/foundryvtt-reve-de-dragon/icons/meditations_ecrits/meditation_alchimie.webp",
-  recettealchimique: "systems/foundryvtt-reve-de-dragon/icons/competence_alchimie.webp",
  chant: "systems/foundryvtt-reve-de-dragon/icons/arts/chant_0.webp",
+  competence: "systems/foundryvtt-reve-de-dragon/icons/competence_defaut.webp",
+  competencecreature: "systems/foundryvtt-reve-de-dragon/icons/competence_defaut.webp",
+  conteneur: "systems/foundryvtt-reve-de-dragon/icons/objets/sac_a_dos.webp",
  danse: "systems/foundryvtt-reve-de-dragon/icons/arts/danse_0.webp",
+  empoignade: "systems/foundryvtt-reve-de-dragon/icons/empoignade.webp",
+  extraitpoetique: "systems/foundryvtt-reve-de-dragon/icons/competence_ecriture.webp",
+  faune: "systems/foundryvtt-reve-de-dragon/icons/faune/rongeur.webp",
+  gemme: "systems/foundryvtt-reve-de-dragon/icons/gemmes/almaze.webp",
+  herbe: "systems/foundryvtt-reve-de-dragon/icons/botanique/Endorlotte.webp",
+  ingredient: "systems/foundryvtt-reve-de-dragon/icons/objets/sable_poudre.webp",
  jeu: "systems/foundryvtt-reve-de-dragon/icons/arts/jeux_petasse.webp",
-  recettecuisine: "systems/foundryvtt-reve-de-dragon/icons/arts/recette_cuisine_1.webp",
-  musique: "systems/foundryvtt-reve-de-dragon/icons/arts/chant_0.webp",
+  livre: "systems/foundryvtt-reve-de-dragon/icons/objets/livre.webp",
  maladie: "systems/foundryvtt-reve-de-dragon/icons/maladies_venins/maladie.webp",
-  poison: "systems/foundryvtt-reve-de-dragon/icons/maladies_venins/venin.webp",
-  oeuvre: "systems/foundryvtt-reve-de-dragon/icons/competence_comedie.webp",
+  meditation: "systems/foundryvtt-reve-de-dragon/icons/meditations_ecrits/meditation_alchimie.webp",
+  musique: "systems/foundryvtt-reve-de-dragon/icons/arts/chant_0.webp",
  nourritureboisson: "systems/foundryvtt-reve-de-dragon/icons/objets/provision_crue.webp",
+  oeuvre: "systems/foundryvtt-reve-de-dragon/icons/competence_comedie.webp",
+  ombre: "systems/foundryvtt-reve-de-dragon/icons/queue_dragon.webp",
+  poison: "systems/foundryvtt-reve-de-dragon/icons/maladies_venins/venin.webp",
+  possession: "systems/foundryvtt-reve-de-dragon/icons/entites/possession2.webp",
+  potion: "systems/foundryvtt-reve-de-dragon/icons/objets/liqueur_de_bagdol.webp",
+  queue: "systems/foundryvtt-reve-de-dragon/icons/queue_dragon.webp",
+  recettealchimique: "systems/foundryvtt-reve-de-dragon/icons/competence_alchimie.webp",
+  recettecuisine: "systems/foundryvtt-reve-de-dragon/icons/arts/recette_cuisine_1.webp",
+  rencontre: "systems/foundryvtt-reve-de-dragon/icons/tete_dragon.webp",
  service: "systems/foundryvtt-reve-de-dragon/icons/services/lit.webp",
  signedraconique: "systems/foundryvtt-reve-de-dragon/icons/tmr/signe_draconique.webp",
-  gemme: "systems/foundryvtt-reve-de-dragon/icons/gemmes/almaze.webp",
-  possession: "systems/foundryvtt-reve-de-dragon/icons/entites/possession2.webp",
+  sort: "systems/foundryvtt-reve-de-dragon/icons/competence_oniros.webp",
  sortreserve: "systems/foundryvtt-reve-de-dragon/icons/competence_oniros.webp",
-  extraitpoetique: "systems/foundryvtt-reve-de-dragon/icons/competence_ecriture.webp",
+  souffle: "systems/foundryvtt-reve-de-dragon/icons/souffle_dragon.webp",
  tarot: "systems/foundryvtt-reve-de-dragon/icons/tarots/dos-tarot.webp",
-  empoignade: "systems/foundryvtt-reve-de-dragon/icons/competence_corps_a_corps.webp"
+  tete: "systems/foundryvtt-reve-de-dragon/icons/tete_dragon.webp",
 }

 /* -------------------------------------------- */
 export class RdDItem extends Item {
-
  static get defaultIcon() {
    return undefined;
  }
@ -238,7 +180,6 @@ export class RdDItem extends Item {
  isCompetenceCreature() { return this.type == ITEM_TYPES.competencecreature }
  isConteneur() { return this.type == ITEM_TYPES.conteneur; }
  isMonnaie() { return this.type == ITEM_TYPES.monnaie; }
-  isPotion() { return this.type == ITEM_TYPES.potion; }
  isNourritureBoisson() { return this.type == ITEM_TYPES.nourritureboisson; }
  isService() { return this.type == ITEM_TYPES.service; }

@ -277,6 +218,12 @@ export class RdDItem extends Item {
    return this.getEnvironnements(milieux).length > 0
  }

+  get nameDisplay() {
+    return this.isMagique ? (this.name + ' <i class="fa-solid fa-sparkles"></i>') : this.name
+  }
+
+  get isEnchantementPossible() { return false }
+
  getEnvironnements(milieux = undefined) {
    const environnements = this.isInventaire() ? this.system.environnement : undefined;
    if (milieux == undefined || !environnements) {
@ -356,13 +303,6 @@ export class RdDItem extends Item {

  getUtilisation() {
    switch (this.type) {
-      case ITEM_TYPES.potion:
-        switch (this.system.categorie) {
-          case 'Alchimie': case 'AlchimieEnchante': case 'AlchimieAutre': return 'alchimie'
-          case 'Cuisine': return 'cuisine'
-          case 'Remede': case 'Repos': case 'ReposEnchante': case 'Soin': case 'SoinEnchante': return 'soins'
-        }
-        return '';
      case ITEM_TYPES.nourritureboisson: return 'cuisine';
      case ITEM_TYPES.herbe: case ITEM_TYPES.faune: case ITEM_TYPES.ingredient: case ITEM_TYPES.plante:
        switch (this.system.categorie) {
@ -392,7 +332,7 @@ export class RdDItem extends Item {
    return this.type == ITEM_TYPES.objet && Grammar.includesLowerCaseNoAccent(this.name, 'cristal alchimique') && this.system.quantite > 0;
  }

-  isMagique() {
+  get isMagique() {
    return this.system.magique
  }

@ -403,6 +343,7 @@ export class RdDItem extends Item {
  isNomLike(texte) {
    return Grammar.includesLowerCaseNoAccent(this.name, texte)
  }
+
  isNomTypeLike(texte) {
    return this.isNomLike(texte) || Grammar.includesLowerCaseNoAccent(Misc.typeName(this.type, 'Item'), texte)
  }
@ -421,8 +362,6 @@ export class RdDItem extends Item {
        return 0;
      case ITEM_TYPES.herbe:
        return this.getEncHerbe();
-      case ITEM_TYPES.gemme:
-        return encPepin * this.system.taille;
    }
    return Math.max(this.system.encombrement ?? 0, 0);
  }
@ -471,68 +410,47 @@ export class RdDItem extends Item {
      // appliquer le pourcentage
      return this.parent.calculerPrix(this);
    }
-    return this.system.cout;
+    return this.system.cout
  }

  prepareDerivedData() {
    super.prepareDerivedData();
    if (this.isInventaire()) {
-      this.system.encTotal = this.getEncTotal();
-      if (this.isPotion()) {
-        this.prepareDataPotion()
-      }
-      this.system.actionPrincipale = this.getActionPrincipale({ warnIfNot: false });
+      this.system.encTotal = this.getEncTotal()
    }
-    this.equipable = this.isEquipable();
+    this.equipable = this.isEquipable()
  }

-  prepareDataPotion() {
-    const categorie = Grammar.toLowerCaseNoAccent(this.system.categorie);
-    this.system.magique = categorie.includes('enchante');
-    if (this.system.magique) {
-      if (categorie.includes('soin') || categorie.includes('repos')) {
-        // TODO: utiliser calculPointsRepos / calculPointsGuerison
-        this.system.puissance = RdDHerbes.calculPuissancePotion(this);
-      }
-    }
+  itemActions() {
+    return COMMON_ACTIONS.concat(this.itemSpecificActions()).concat(DEFAULT_ACTIONS)
  }

-  getActionPrincipale(options = { warnIfNot: true }) {
+  itemSpecificActions() {
+    const actions = ITEM_ACTIONS[this.type] ?? []
+    return actions
+  }
+
+  isActionAllowed(code) {
    switch (this.type) {
-      case ITEM_TYPES.conteneur: return 'Ouvrir';
-    }
-    if (this.actor?.isPersonnage()) {
-      const warn = options.warnIfNot;
-      if (this.getUtilisationCuisine() == 'brut') {
-        return 'Cuisiner';
-      }
-      switch (this.type) {
-        case ITEM_TYPES.nourritureboisson: return this._actionOrWarnQuantiteZero(this.system.boisson ? 'Boire' : 'Manger', warn);
-        case ITEM_TYPES.potion: return this._actionOrWarnQuantiteZero('Consommer', warn);
-        case ITEM_TYPES.livre: return this._actionOrWarnQuantiteZero('Lire', warn);
-        case ITEM_TYPES.herbe: return this.isHerbeAPotion() ? this._actionOrWarnQuantiteZero('Décoction', warn) : undefined;
-        case ITEM_TYPES.queue: case ITEM_TYPES.ombre: return this.system.refoulement > 0 ? 'Refouler' : undefined;
-      }
-    }
-    return undefined;
-  }
-
-  /* -------------------------------------------- */
-  async actionPrincipale(actor, onActionItem = async () => { }) {
-    if (!this.getActionPrincipale()) { return }
-    await actor?.actionPrincipale(this, onActionItem);
-  }
-
-  _actionOrWarnQuantiteZero(actionName, warn) {
-    if ((this.system.quantite ?? 0) <= 0) {
-      if (warn) {
-        ui.notifications.warn(`Vous n'avez plus de ${this.name}.`);
-      }
-      return undefined;
-    }
-    else {
-      return actionName;
+      case ITEM_TYPES.possession:
+      case ITEM_TYPES.empoignade:
+      case ITEM_TYPES.rencontre:
+      case ITEM_TYPES.signedraconique:
+        switch (code) {
+          case 'item-edit':
+          case 'item-delete':
+            return game.user.isGM
+        }
+      case ITEM_TYPES.maladie:
+      case ITEM_TYPES.poison:
+        return game.user.isGM
+      case ITEM_TYPES.casetmr:
+        switch (code) {
+          case 'item-delete':
+            return game.user.isGM
+        }
    }
+    return true
  }

  async diminuerQuantite(nombre, options = { diminuerQuantite: true, supprimerSiZero: false }) {
@ -805,14 +723,6 @@ export class RdDItem extends Item {
    ]
  }
  /* -------------------------------------------- */
-  _potionChatData() {
-    return [
-      `<b>Rareté</b>: ${this.system.rarete}`,
-      `<b>Catégorie</b>: ${this.system.categorie}`,
-      ...this._inventaireTemplateChatData()
-    ]
-  }
-  /* -------------------------------------------- */
  _queueChatData() {
    function label(categorie) {
      switch (categorie) {
--- a/module/item/armure.js
+++ b/module/item/armure.js
@ -1,4 +1,5 @@
-import { ITEM_TYPES, RdDItem } from "../item.js";
+import { ITEM_TYPES } from "../constants.js";
+import { RdDItem } from "../item.js";
 import { Misc } from "../misc.js";
 import { ReglesOptionnelles } from "../settings/regles-optionnelles.js";

@ -10,7 +11,7 @@ export class RdDItemArmure extends RdDItem {
    return "systems/foundryvtt-reve-de-dragon/icons/armes_armures/armure_plaques.webp";
  }

-  deteriorerArmure(dmg) {
+  async deteriorerArmure(dmg) {
    if (!ReglesOptionnelles.isUsing('deteriorationArmure') || this.system.protection == '0') {
      return;
    }
@ -22,12 +23,10 @@ export class RdDItemArmure extends RdDItem {
      protection = this.calculProtectionDeterioree();
      ChatMessage.create({ content: `Votre armure ${this.name} s'est détériorée, elle protège maintenant de ${protection}` });
    }
-    this.update({
-      system: {
-        deterioration: deterioration,
-        protection: protection
-      }
-    });
+    await this.update({
+      'system.deterioration': deterioration,
+      'system.protection': protection
+    })
  }

  calculProtectionDeterioree() {
--- a/module/item/blessure.js
+++ b/module/item/blessure.js
@ -30,7 +30,7 @@ export class RdDItemBlessure extends RdDItem {

  prepareDerivedData() {
    super.prepareDerivedData();
-    this.system.label = this.getLabelGravite()
+    this.system.label = RdDItemBlessure.getLabelGravite(this.system.gravite)
  }

  static prepareTacheSoin(gravite) {
@ -43,29 +43,32 @@ export class RdDItemBlessure extends RdDItem {
  }

  static async applyFullBlessure(actor, gravite) {
-    const definition = RdDItemBlessure.getDefinition(gravite)
-    
-    let lostEndurance = 0
-    let lostVie = 0
-    if (definition.endurance) {
-      lostEndurance = new Roll(definition.endurance)
-      await lostEndurance.roll();
-      actor.santeIncDec("endurance", -Number(lostEndurance.total));
-    }
+    const definition = foundry.utils.duplicate(RdDItemBlessure.getDefinition(gravite))
+
    if (definition.vie) {
-      lostVie = definition.vie
-      actor.santeIncDec("vie", definition.vie)
+      await actor.santeIncDec("vie", definition.vie)
+    }
+    const lostEndurance = await RdDItemBlessure.rollLostEndurance(definition.endurance)
+    if (lostEndurance) {
+      await actor.santeIncDec("endurance", -Number(lostEndurance));
    }
-    
    await this.createBlessure(actor, gravite)

    ChatMessage.create({
-      content: `Blessure ${definition.label} appliquée à ${actor.name}`+
-        `<br>Perte d'endurance : ${lostEndurance}`+
-        `<br>Perte de Vie : ${lostVie}`,
+      //TODO: hbs
+      content: `Blessure ${definition.label} appliquée à ${actor.name}<br>Perte d'endurance : ${lostEndurance} (${definition.endurance})<br>Perte de Vie : ${definition.vie}`,
      whisper: ChatUtility.getOwners(actor)
    });
+    actor.sheet?.render()
+  }

+  static async rollLostEndurance(formula) {
+    if (formula) {
+      const roll = new Roll(formula)
+      await roll.evaluate()
+      return roll.total
+    }
+    return 0
  }

  static async createBlessure(actor, gravite, localisation = '', attackerToken) {
@ -125,10 +128,10 @@ export class RdDItemBlessure extends RdDItem {
    }
    if (this.system.gravite > 0) {
      const update = { system: { premierssoins: { bonus: 0 }, soinscomplets: { bonus: 0 } } }
-      const gravite = this.system.gravite;
-      const graviteMoindre = gravite - 2;
+      const gravite = this.system.gravite
+      const graviteMoindre = gravite - 2
      const moindres = blessures.filter(it => it.system.gravite == graviteMoindre, 'blessures').length
-      const label = this.getLabelGravite();
+      const label = RdDItemBlessure.getLabelGravite(this.system.gravite)

      let rolled = await actor.jetRecuperationConstitution(this.system.soinscomplets.bonus, message);

@ -158,11 +161,11 @@ export class RdDItemBlessure extends RdDItem {
  }

  peutRetrograder(graviteMoindre, moindres) {
-    return moindres < RdDItemBlessure.getDefinition(graviteMoindre).max
+    return moindres < RdDItemBlessure.maxBlessures(graviteMoindre)
  }

  async calculerFinPeriodeTemporel(debut) {
-    return await debut.nouveauJour().addJours(this.system.gravite);
+    return debut.nouveauJour().addJours(this.system.gravite);
  }

  async onFinPeriode(oldTimestamp, newTimestamp) {
@ -182,16 +185,16 @@ export class RdDItemBlessure extends RdDItem {
    return `systems/foundryvtt-reve-de-dragon/icons/sante/${soins ? 'blessure-soins' : img}.webp`
  }

-  getLabelGravite() {
-    return RdDItemBlessure.getDefinition(this.system.gravite).label
+  static getLabelGravite(gravite) {
+    return definitionsBlessures.find(it => it.gravite >= gravite).label
  }

  static getDefinition(gravite) {
-    return definitionsBlessures.sort(Misc.ascending(it => it.gravite))
-      .find(it => it.gravite >= gravite);
+    return definitionsBlessures.find(it => it.gravite >= gravite)
  }
+
  static maxBlessures(gravite) {
-    return RdDItemBlessure.getDefinition(gravite).max
+    return definitionsBlessures.find(it => it.gravite >= gravite).max
  }

  isContusion() {
@ -216,7 +219,7 @@ export class RdDItemBlessure extends RdDItem {
      `<b>Heure et Date</b>: ${new RdDTimestamp(this.system.temporel.debut).formatDateHeure()}`,
      RdDItem.propertyIfDefined('Blessé', this.parent?.name, this.parent),
      `<b>Localisation</b>: ${this.system.localisation}`,
-      `<b>Gravité</b>: ${RdDItemBlessure.getDefinition(this.system.gravite).label}`,
+      `<b>Gravité</b>: ${this.system.label}`,
      `<b>Difficulté des soins</b>: ${this.system.difficulte}`,
      (this.system.soinscomplets.done ?
        `<b>Bonus soins complets</b>: ${this.system.soinscomplets.bonus}` :
--- a/module/item/gemme.js
+++ b/module/item/gemme.js
@ -0,0 +1,112 @@
+import { RdDItem } from "../item.js";
+import { ACTION_ITEM_ENCHANTER } from "../enchantement/dialog-enchanter.js";
+
+const tableGemmes = {
+  "almaze": { label: "Almaze", couleur: "Blanc" },
+  "aquafane": { label: "Aquafane", couleur: "Vert Profond" },
+  "asterite": { label: "Astérite", couleur: "Bleu, Violet ou Blanc" },
+  "cyanolithe": { label: "Cyanolithe", couleur: "Bleu Intense" },
+  "larmededragon": { label: "Larme de Dragon", couleur: "Rouge Intense" },
+  "muska": { label: "Muska", couleur: "Violet Profond" },
+  "nebuleuse": { label: "Nébuleuse", couleur: "Brouillard Intense" },
+  "nebuleuse": { label: "Nébuleuse", couleur: "Brouillard Intense, Rose, Vert ou Bleu Pâle" },
+  "oeildetigre": { label: "Oeil de Tigre", couleur: "Jaune" },
+  "scarlatine": { label: "Scarlatine", couleur: "Rouge Clair ou Orangé" },
+  "seliphane": { label: "Séliphane", couleur: "Vert Lumineux" },
+  "tournelune": { label: "Tournelune", couleur: "Violet ou Bleu" },
+  "zebraide": { label: "Zebraïde", couleur: "Bandes Bicolores, toutes couleurs" }
+}
+
+/**
+ * un pépin de gemme = 1/10 cm3 = 1/1000 l = 3.5/1000 kg = 7/2000 kg = 7/1000 enc
+ * densité 3.5 (~2.3 à 4, parfois plus) -- https://www.juwelo.fr/guide-des-pierres/faits-et-chiffres/ 
+ */
+const encPepin = 0.0007;
+
+/**
+ * Item pour gérer les gemmes
+ */
+export class RdDItemGemme extends RdDItem {
+
+  static getGemmeTypeOptionList() {
+    // TODO: look how to map object key-value pairs
+    let options = ""
+    for (let gemmeKey in tableGemmes) {
+      options += `<option value="${gemmeKey}">${tableGemmes[gemmeKey].label}</option>`
+    }
+    return options;
+  }
+
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/gemmes/almaze.webp"
+  }
+
+  get isEnchantementPossible() {
+    return this.enchantabilite > 0
+  }
+
+  get inertie() { return 7 - Number(this.system.purete) }
+  get enchantabilite() { return this.system.taille - this.inertie }
+
+  getEnc() {
+    return encPepin * this.system.taille;
+  }
+
+  itemSpecificActions() {
+    return [ACTION_ITEM_ENCHANTER]
+  }
+
+  prepareDerivedData() {
+    super.prepareDerivedData()
+    this.system.cout = (this.system.taille * this.system.purete) + this.system.qualite
+    this.system.inertie = this.inertie
+    this.system.enchantabilite = this.enchantabilite
+  }
+
+  getUtilisation() {
+    switch (this.system.categorie) {
+      case 'Alchimie': case 'Autre': case 'AlchimieAutre':
+        // TODO: distinguer les remèdes alchimiques enchantables/non
+        return 'alchimie'
+      case 'Cuisine':
+        return 'cuisine'
+      case 'Remede': case 'Repos': case 'Soin':
+        return 'soins'
+    }
+    return ''
+  }
+
+  getProprietes() {
+    const proprietes = [
+      `<b>Taille</b>: ${this.system.taille}`,
+      `<b>Pureté</b>: ${this.system.purete}`,
+      `<b>Inertie</b>: ${this.system.inertie}`,
+      `<b>Enchantabilité</b>: ${this.system.enchantabilite}`
+    ]
+    const proprietesMagiques = this.system.magique ? [
+      `<b>Enchantée</b> <i class="fa-solid fa-sparkles"></i> ${this.system.purifie ? ', purifiée' : ''} ${this.system.prpermanent ? 'permanente' : ''} `,
+      `<b>Points de rêve</b>: ${this.system.pr}`,
+      `<b>Puissance</b>: ${this.system.puissance}`,
+    ] : []
+    return proprietes
+      .concat(proprietesMagiques)
+      .concat(this._inventaireTemplateChatData())
+      .filter(it => it != undefined)
+  }
+
+  perteReveChateauDormant() {
+    if (this.system.magique && !this.system.prpermanent && this.system.pr > 0) {
+      const nouveauReve = Math.max(this.system.pr - 1, 0)
+      return {
+        alias: this.parent.getAlias(),
+        item: this,
+        update: {
+          _id: this.id,
+          'system.pr': nouveauReve,
+          'system.magique': nouveauReve > 0
+        }
+      }
+    }
+    return undefined
+  }
+}
--- a/module/item/item-actions.js
+++ b/module/item/item-actions.js
@ -0,0 +1,146 @@
+import { Misc } from "../misc.js"
+import { RdDSheetUtility } from "../rdd-sheet-utility.js"
+import { RdDUtility } from "../rdd-utility.js"
+
+
+
+/**
+ * TODO:
+ * options.editable ?
+ * 
+ */
+const _SPACEHOLDER = { placeholder: true }
+
+const _VENDRE = {
+  code: 'item-vendre', label: 'Vendre ou donner', icon: it => 'fa-solid fa-comments-dollar',
+  filter: it => Misc.toInt(it.system.quantite) > 0,
+  optionsFilter: options => options.editable,
+  action: (item, actor) => item.proposerVente()
+}
+const _ACHAT_SERVICE = {
+  code: 'item-service-acheter', label: 'Acheter', icon: it => 'fa-regular fa-coins',
+  //filter: it => Misc.toInt(it.system.quantite) > 0,
+  //optionsFilter: options => options.editable,
+  //action: (item, actor) => item.proposerVente()
+}
+const _MONTRER = {
+  code: 'item-montrer', label: 'Montrer', icon: it => 'fa-solid fa-comment',
+  action: (item, actor) => item.postItemToChat()
+}
+const _SPLIT = {
+  code: 'item-split', label: 'Séparer le goupe', icon: it => 'fa-solid fa-unlink',
+  filter: it => Misc.toInt(it.system.quantite) > 1,
+  action: (item, actor) => RdDSheetUtility.splitItem(item, actor)
+}
+
+const _EDIT = {
+  code: 'item-edit', label: 'Editer', icon: it => 'fa-solid fa-edit',
+  action: (item, actor) => item.sheet.render(true)
+}
+const _DELETE = {
+  code: 'item-delete', label: 'Supprimer', icon: it => 'fa-solid fa-trash',
+  optionsFilter: options => options.editable && options.isOwner,
+  action: (item, actor) => RdDUtility.confirmActorItemDelete(item, actor)
+}
+const _EQUIPER = {
+  code: 'item-equip', label: 'Equiper', icon: it => it.system.equipe ? 'fa-solid fa-hand-rock' : 'fa-regular fa-hand-paper',
+  filter: it => !it.estContenu && it.isEquipable(),
+  action: (item, actor) => actor.equiperObjet(item)
+}
+
+const _CUISINER = {
+  code: 'item-cuisiner', label: 'Cuisiner', icon: it => 'fa-solid fa-utensils',
+  filter: it => it.getUtilisation() == 'cuisine' && it.system.sust > 0,
+  optionsFilter: options => options.editable,
+  action: (item, actor) => actor.preparerNourriture(item)
+}
+const _MANGER_CRU = {
+  code: 'item-manger-cru', label: 'Manger cru', icon: it => 'fa-solid fa-drumstick-bite',
+  filter: it => it.getUtilisation() == 'cuisine' && it.system.sust > 0,
+  optionsFilter: options => options.editable,
+  action: (item, actor) => actor.mangerNourriture(item)
+}
+const _MANGER = {
+  code: 'item-manger', label: 'Manger', icon: it => 'fa-solid fa-utensils',
+  filter: it => !(it.system.boisson),
+  optionsFilter: options => options.editable,
+  action: (item, actor) => actor.mangerNourriture(item)
+}
+const _BOIRE = {
+  code: 'item-boire', label: 'Boire', icon: it => 'fa-solid fa-glass-water',
+  filter: it => it.system.boisson,
+  optionsFilter: options => options.editable,
+  action: (item, actor) => actor.mangerNourriture(item)
+}
+const _DECOCTION = {
+  code: 'item-decoction', label: 'Décoction', icon: it => 'fa-solid fa-flask-vial',
+  optionsFilter: options => options.editable,
+  action: (item, actor) => actor.fabriquerDecoctionHerbe(item)
+}
+const _OUVRIR = {
+  code: 'item-edit', label: 'Ouvrir', icon: it => 'fa-solid fa-eye',
+  action: (item, actor) => item.sheet.render(true)
+}
+
+const _LIRE = {
+  code: 'item-lire', label: 'Lire', icon: it => 'fa-solid fa-book-open',
+  optionsFilter: options => options.editable,
+  action: (item, actor) => actor.actionLire(item)
+}
+
+const _REFOULER = {
+  code: 'item-refouler', label: 'Refouler', icon: it => 'fa-solid fa-burst',
+  filter: it => it.system.refoulement > 0,
+  optionsFilter: options => options.editable,
+  action: (item, actor) => actor.actionRefoulement(item)
+}
+
+const _SORT_RESERVE = {
+  code: 'item-sortreserve-add', label: 'Ajouter en réserve', icon: it => 'fa-solid fa-sparkles',
+  filter: it => game.user.isGM && !it.system.isrituel,
+  action: (item, actor) => actor.addSortReserve(item)
+}
+
+export const COMMON_ACTIONS = [_EQUIPER]
+export const DEFAULT_ACTIONS = [_SPACEHOLDER, _SPLIT, _VENDRE, _MONTRER, _EDIT, _DELETE]
+
+export const ITEM_ACTIONS = {
+  faune: [_CUISINER, _MANGER_CRU],
+  ingredient: [_CUISINER, _MANGER_CRU],
+  conteneur: [_OUVRIR],
+  herbe: [_DECOCTION, _CUISINER, _MANGER_CRU],
+  livre: [_LIRE],
+  nourritureboisson: [_MANGER, _BOIRE],
+  ombre: [_REFOULER],
+  plante: [_CUISINER, _MANGER_CRU],
+  queue: [_REFOULER],
+  sort: [_SORT_RESERVE],
+  service: [_ACHAT_SERVICE]
+}
+
+
+export class ItemAction {
+
+  static applies(action, item, options) {
+    return action && item
+      && item.isActionAllowed(action.code)
+      && (!action.filter || action.filter(item))
+      && (!action.optionsFilter || action.optionsFilter(options))
+  }
+
+  static icon(action, item) {
+    if (action && action.icon) {
+      return action.icon(item)
+    }
+    return undefined
+  }
+
+  static onActionItem(event, actor, options) {
+    const item = RdDSheetUtility.getItem(event, actor)
+    const code = $(event.currentTarget).data('code')
+    const action = item?.itemActions().find(it => it.code == code)
+    if (action && (!action.optionsFilter || action.optionsFilter(options))) {
+      action.action(item, actor)
+    }
+  }
+}
--- a/module/item/maladie.js
+++ b/module/item/maladie.js
@ -10,7 +10,7 @@ export class RdDItemMaladie extends RdDItem {
  }

  async calculerFinPeriodeTemporel(debut) {
-    return await debut.addPeriode(this.system.periode.nombre, this.system.periode.unite);
+    return debut.addPeriode(this.system.periode.nombre, this.system.periode.unite);
  }

  async onFinPeriode(oldTimestamp, newTimestamp) {
--- a/module/item/ombre.js
+++ b/module/item/ombre.js
@ -1,11 +1,8 @@
-import { RdDItem } from "../item.js";
+import { RdDItemQueue } from "./queue.js";
+
+export class RdDItemOmbre extends RdDItemQueue {

-export class RdDItemOmbre extends RdDItem {
  static get defaultIcon() {
    return "systems/foundryvtt-reve-de-dragon/icons/queue_dragon.webp";
  }
-
-  async calculerFinPeriodeTemporel(debut) {
-    return await debut.appliquerDuree(this.system.duree, this.parent);
-  }
 }
--- a/module/item/poison.js
+++ b/module/item/poison.js
@ -8,7 +8,7 @@ export class RdDItemPoison extends RdDItem {
  }

  async calculerFinPeriodeTemporel(debut) {
-    return await debut.addPeriode(this.system.periode.nombre, this.system.periode.unite) ;
+    return debut.addPeriode(this.system.periode.nombre, this.system.periode.unite) ;
  }

  async onFinPeriode(oldTimestamp, newTimestamp) {
--- a/module/item/potion.js
+++ b/module/item/potion.js
@ -0,0 +1,105 @@
+import { Grammar } from "../grammar.js";
+import { RdDItem } from "../item.js";
+import { SystemCompendiums } from "../settings/system-compendiums.js";
+import { ACTION_ITEM_ENCHANTER } from "../enchantement/dialog-enchanter.js";
+
+// --- Actions sur les "potions"
+const _CONSOMMER_POTION = {
+  code: 'item-potion-consommer', label: 'Consommer', icon: it => 'fa-solid fa-vial',
+  optionsFilter: options => options.editable,
+  action: (item, actor) => actor.consommerPotion(item)
+}
+
+/**
+ * Item pour gérer les potions
+ */
+export class RdDItemPotion extends RdDItem {
+
+  static async herbesSoins() {
+    return await RdDItemPotion.$listHerbes(it => Grammar.equalsInsensitive(it.system.categorie, 'Soin') && it.system.niveau > 0)
+  }
+  static async herbesRepos() {
+    return await RdDItemPotion.$listHerbes(it => Grammar.equalsInsensitive(it.system.categorie, 'Repos') && it.system.niveau > 0)
+  }
+
+  static async $listHerbes(filter) {
+    const herbes = await SystemCompendiums.getWorldOrCompendiumItems('herbe', 'faune-flore-mineraux');
+    return herbes.filter(filter)
+  }
+
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/objets/liqueur_de_bagdol.webp"
+  }
+
+  get isEnchantementPossible() {
+    return this.system.etat == 'Liquide'
+  }
+
+  itemSpecificActions() {
+    return [_CONSOMMER_POTION, ACTION_ITEM_ENCHANTER]
+  }
+
+  prepareDerivedData() {
+    super.prepareDerivedData()
+    this.system.puissance = this.system.magique ? this.calculPuissance() : 0
+  }
+
+  getUtilisation() {
+    switch (this.system.categorie) {
+      case 'Alchimie': case 'Autre': case 'AlchimieAutre':
+        // TODO: distinguer les remèdes alchimiques enchantables/non
+        return 'alchimie'
+      case 'Cuisine':
+        return 'cuisine'
+      case 'Remede': case 'Repos': case 'Soin':
+        return 'soins'
+    }
+    return ''
+  }
+
+  getProprietes() {
+    const proprietes = [
+      `<b>Rareté</b>: ${this.system.rarete} `,
+      `<b>Catégorie</b>: ${this.system.categorie}`,
+      `<b>Etat</b>: ${this.system.etat}`
+    ]
+    const proprietesMagiques = this.system.magique ? [
+      `<b>Enchantée</b> <i class="fa-solid fa-sparkles"></i> ${this.system.purifie ? ', purifiée' : ''} ${this.system.prpermanent ? 'permanente' : ''} `,
+      `<b>Points de rêve</b>: ${this.system.pr}`,
+    ] : []
+    return proprietes
+      .concat(proprietesMagiques)
+      .concat(this._inventaireTemplateChatData())
+      .filter(it => it != undefined)
+  }
+
+  perteReveChateauDormant() {
+    if (this.system.magique && !this.system.prpermanent && this.system.pr > 0) {
+      const nouveaupr = Math.max(this.system.pr - 1, 0)
+      return {
+        alias: this.parent.getAlias(),
+        item: this,
+        nouveaupr: nouveaupr,
+        update: {
+          _id: this.id,
+          'system.pr': nouveaupr,
+          'system.magique': nouveaupr > 0
+        }
+      }
+    }
+    return undefined
+  }
+
+  calculPuissance() { return this.system.herbebonus * this.system.pr }
+
+  static buildHerbesList(listeHerbes, max) {
+    let list = {}
+    for (let herbe of listeHerbes) {
+      let brins = max - herbe.system.niveau;
+      list[herbe.name] = `${herbe.name} (Bonus: ${herbe.system.niveau}, Brins: ${brins})`;
+    }
+    list['Autre'] = 'Autre (Bonus: variable, Brins: variable)'
+    return list;
+  }
+
+}
--- a/module/item/queue.js
+++ b/module/item/queue.js
@ -6,8 +6,9 @@ export class RdDItemQueue extends RdDItem {
    return "systems/foundryvtt-reve-de-dragon/icons/queue_dragon.webp";
  }

-  async calculerFinPeriodeTemporel(debut) {
+  async calculerFinPeriodeTemporel(timestamp) {
+    // décaller le début pour calcul correct si la queue dure 12h
+    const debut = timestamp.addMinutes(timestamp.indexMinute == 0 ? -1 : 0);
    return await debut.appliquerDuree(this.system.duree, this.parent);
  }
-
 }
--- a/module/item/race.js
+++ b/module/item/race.js
@ -1,4 +1,5 @@
-import { ITEM_TYPES, RdDItem } from "../item.js";
+import { ITEM_TYPES } from "../constants.js";
+import { RdDItem } from "../item.js";
 import { Misc } from "../misc.js";
 import { LIST_CARAC_PERSONNAGE, RdDCarac } from "../rdd-carac.js";

--- a/module/item/rencontre.js
+++ b/module/item/rencontre.js
@ -74,7 +74,7 @@ export class RdDRencontre extends RdDItem {
  }

  async calculerFinPeriodeTemporel(debut) {
-    return await debut.nouvelleHeure().addHeures(12);
+    return debut.nouvelleHeure().addHeures(12);
  }

 }
--- a/module/item/sheet-conteneur.js
+++ b/module/item/sheet-conteneur.js
@ -1,5 +1,5 @@
 import { RdDBaseActorSheet } from "../actor/base-actor-sheet.js";
-import { ITEM_TYPES } from "../item.js";
+import { ITEM_TYPES } from "../constants.js";
 import { RdDSheetUtility } from "../rdd-sheet-utility.js";
 import { RdDUtility } from "../rdd-utility.js";
 import { RdDItemInventaireSheet } from "./sheet-base-inventaire.js";
@ -29,9 +29,10 @@ export class RdDConteneurItemSheet extends RdDItemInventaireSheet {

  /* -------------------------------------------- */
  prepareConteneurData(formData) {
-    RdDBaseActorSheet.filterItemsPerTypeForSheet(formData, this.actor.itemTypes);
+    RdDUtility.filterItemsPerTypeForSheet(formData, this.actor.itemTypes);
    this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.inventaires);
-    formData.subItems = formData.conteneurs.find(it => it._id == this.item.id)?.subItems;
+    const subItems = formData.conteneurs.find(it => it._id == this.item.id)?.subItems;
+    formData.subItems = subItems
  }

  async _onDragStart(event) {
--- a/module/item/sheet-gemme.js
+++ b/module/item/sheet-gemme.js
@ -0,0 +1,38 @@
+import { ITEM_TYPES } from "../constants.js";
+import { DialogEnchanter } from "../enchantement/dialog-enchanter.js";
+import { RdDTimestamp } from "../time/rdd-timestamp.js";
+import { RdDItemGemme } from "./gemme.js";
+import { RdDItemInventaireSheet } from "./sheet-base-inventaire.js";
+
+export class RdDGemmeItemSheet extends RdDItemInventaireSheet {
+
+  static get ITEM_TYPE() { return ITEM_TYPES.gemme };
+
+  async getData() {
+    const formData = foundry.utils.mergeObject(await super.getData(),
+      {
+        inertie: this.item.inertie,
+        enchantabilite: this.item.enchantabilite,
+        isEnchantementPossible: this.item.isEnchantementPossible,
+        gemmeTypeList: RdDItemGemme.getGemmeTypeOptionList(),
+        dateActuelle: game.system.rdd.calendrier.dateCourante(),
+        enchantement: RdDTimestamp.splitIndexDate(this.item.system.prdate)
+      })
+    return formData
+  }
+
+  activateListeners(html) {
+    super.activateListeners(html);
+
+    this.html.find('.item-enchanter').click((event) => DialogEnchanter.enchanter(this.item))
+
+    this.html.find('.date-enchantement').change((event) => {
+      const jour = Number(this.html.find('input.date-enchantement[name="enchantement.jour"]').val())
+      const mois = RdDTimestamp.definition(this.html.find('select.date-enchantement[name="enchantement.mois"]').val())
+      const indexDate = game.system.rdd.calendrier.getIndexFromDate(jour, mois.heure)
+      this.item.update({ 'system.prdate': indexDate })
+      console.warn(`Date d'enchantement modifiée ${jour}/${mois.heure}: ${indexDate}`)
+    });
+
+  }
+}
--- a/module/item/sheet-potion.js
+++ b/module/item/sheet-potion.js
@ -0,0 +1,57 @@
+import { ITEM_TYPES } from "../constants.js";
+import { DialogEnchanter } from "../enchantement/dialog-enchanter.js";
+import { RdDTimestamp } from "../time/rdd-timestamp.js";
+import { RdDItemPotion } from "./potion.js";
+import { RdDItemInventaireSheet } from "./sheet-base-inventaire.js";
+
+
+export class RdDPotionItemSheet extends RdDItemInventaireSheet {
+
+  static get ITEM_TYPE() { return ITEM_TYPES.potion };
+
+  static $calculBonusHerbe(formData, herbesList, max) {
+    if (Number(formData.system.herbebrins)) {
+      let herbe = herbesList.find(h => h.name.toLowerCase() == formData.system.herbe.toLowerCase());
+      if (herbe) {
+        const brinsRequis = max - herbe.system.niveau;
+        const brinsManquants = Math.max(brinsRequis - formData.system.herbebrins, 0);
+        formData.system.herbebonus = Math.max(herbe.system.niveau - brinsManquants, 0);
+      }
+    }
+  }
+
+  async getData() {
+    const formData = await super.getData()
+    formData.isEnchantementPossible = this.item.isEnchantementPossible
+    formData.isSoins = this.item.categorie == 'Soin'
+    formData.isRepos = this.item.categorie == 'Repos'
+    if (formData.isSoins) {
+      const herbesSoins = await RdDItemPotion.herbesSoins()
+      RdDPotionItemSheet.$calculBonusHerbe(formData, herbesSoins, 12);
+      formData.herbesSoins = RdDItemPotion.buildHerbesList(herbesSoins, 12)
+    }
+    if (formData.isRepos) {
+      const herbesRepos = await RdDItemPotion.herbesRepos()
+      RdDPotionItemSheet.$calculBonusHerbe(formData, herbesRepos, 7);
+      formData.herbesRepos = RdDItemPotion.buildHerbesList(herbesRepos, 7)
+    }
+    formData.dateActuelle = game.system.rdd.calendrier.dateCourante()
+    formData.enchantement = RdDTimestamp.splitIndexDate(this.item.system.prdate)
+    return formData
+  }
+
+  activateListeners(html) {
+    super.activateListeners(html);
+
+    this.html.find('.item-enchanter').click((event) => DialogEnchanter.enchanter(this.item))
+
+    this.html.find('.date-enchantement').change((event) => {
+      const jour = Number(this.html.find('input.date-enchantement[name="enchantement.jour"]').val())
+      const mois = RdDTimestamp.definition(this.html.find('select.date-enchantement[name="enchantement.mois"]').val())
+      const indexDate = game.system.rdd.calendrier.getIndexFromDate(jour, mois.heure)
+      this.item.update({ 'system.prdate': indexDate })
+      console.warn(`Date d'enchantement modifiée ${jour}/${mois.heure}: ${indexDate}`)
+    });
+
+  }
+}
--- a/module/item/tete.js
+++ b/module/item/tete.js
@ -1,5 +1,6 @@
+import { ITEM_TYPES } from "../constants.js";
+import { RdDItem } from "../item.js";
 import { Grammar } from "../grammar.js"
-import { ITEM_TYPES, RdDItem } from "../item.js"
 import { SystemCompendiums } from "../settings/system-compendiums.js"

 const DON_HAUT_REVE = "Don de Haut-Rêve"
--- a/module/migrations.js
+++ b/module/migrations.js
@ -2,7 +2,8 @@ import { RdDBaseActor } from "./actor/base-actor.js";
 import { LOG_HEAD, SYSTEM_RDD } from "./constants.js";
 import { Grammar } from "./grammar.js";
 import { Monnaie } from "./item-monnaie.js";
-import { RdDItem, ITEM_TYPES, ACTOR_TYPES } from "./item.js";
+import { ITEM_TYPES, ACTOR_TYPES } from "./constants.js";
+import { RdDItem } from "./item.js";
 import { RdDTimestamp } from "./time/rdd-timestamp.js";
 import { RdDRaretes } from "./item/raretes.js";
 import { VOIES_DRACONIC } from "./item-sort.js";
@ -588,6 +589,42 @@ class _12_0_32_MigrationRaces extends Migration {
  }
 }

+class _12_0_37_MigrationAlchimieEtat extends Migration {
+  get code() { return "migration-alchimie-etat" }
+  get version() { return "12.0.37" }
+
+  async migrate() {
+    await this.applyItemsUpdates(items => items
+      .filter(it => [ITEM_TYPES.potion].includes(it.type))
+      .map(it => this.migratePotion(it))
+    )
+  }
+
+  mappingCategorie(categorie) {
+    switch (categorie) {
+      case 'AlchimieEnchante': return 'Alchimie'
+      case 'ReposEnchante': return 'Repos'
+      case 'SoinEnchante': return 'Soin'
+      case 'AutreEnchante': return 'Autre'
+    }
+    return categorie
+  }
+
+  mappingEtat(categorie) {
+    return ['Alchimie', 'Repos', 'Soin', 'Autre'].includes(categorie) ? 'Liquide' : 'Autre'
+  }
+
+  async migratePotion(potion) {
+    const newCategorie = this.mappingCategorie(potion.system.categorie)
+    return {
+      _id: potion.id,
+      'system.etat': this.mappingEtat(potion.system.categorie),
+      'system.magique': potion.system.pr > 0,
+      'system.categorie': newCategorie
+    }
+  }
+}
+
 export class Migrations {
  static getMigrations() {
    return [
@ -609,6 +646,7 @@ export class Migrations {
      new _11_2_20_MigrationAstrologie(),
      new _12_0_26_MigrationVoieSorts(),
      new _12_0_32_MigrationRaces(),
+      new _12_0_37_MigrationAlchimieEtat(),
    ];
  }

--- a/module/rdd-combat.js
+++ b/module/rdd-combat.js
@ -542,7 +542,7 @@ export class RdDCombat {
      case '.particuliere-attaque': return await this.choixParticuliere(attackerRoll, event.currentTarget.attributes['data-mode'].value);
      case '.parer-button': return this.parade(attackerRoll, armeParadeId);
      case '.esquiver-button': return this.esquive(attackerRoll, compId, competence);
-      case '0encaisser-button': return this.encaisser(attackerRoll, defenderRoll);
+      case '.encaisser-button': return this.encaisser(attackerRoll, defenderRoll);
      case '.echec-total-attaque': return this._onEchecTotal(attackerRoll);

      case '.appel-chance-attaque': return this.attacker.rollAppelChance(
--- a/module/rdd-commands.js
+++ b/module/rdd-commands.js
@ -361,13 +361,14 @@ export class RdDCommands {
  async getTMRAleatoire(msg, params) {
    if (params.length < 2) {
      let type = params[0]
-      const solvedTerrain = TMRUtility.findTMRLike(type)?.type
-      if (solvedTerrain){
-        const tmr = await TMRUtility.getTMRAleatoire(type ? (it => it.type == solvedTerrain) : (it => true))
+      const solvedTerrain = type ? TMRUtility.findTMRLike(type)?.type : undefined
+      const filter = solvedTerrain ? (it => it.type == solvedTerrain) : (it => true)
+      if (type == undefined || solvedTerrain != undefined) {
+        const tmr = await TMRUtility.getTMRAleatoire(filter)
        return RdDCommands._chatAnswer(msg, `Case aléatoire: ${tmr.coord} - ${tmr.label}`)
      }
    }
-    return false;
+    return false
  }

  async findTMR(msg, params) {
--- a/module/rdd-empoignade.js
+++ b/module/rdd-empoignade.js
@ -4,8 +4,7 @@ import { RdDRoll } from "./rdd-roll.js";
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
 import { ChatUtility } from "./chat-utility.js";
 import { STATUSES } from "./settings/status-effects.js";
-import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
-import { ITEM_TYPES } from "./item.js";
+import { ITEM_TYPES } from "./constants.js";

 /* -------------------------------------------- */

@ -429,7 +428,6 @@ export class RdDEmpoignade {
    return await Item.create({
      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 }
    },
      {
--- a/module/rdd-gemme.js
+++ b/module/rdd-gemme.js
@ -1,36 +0,0 @@
-
-const tableGemmes = {
-  "almaze": { label: "Almaze", couleur: "Blanc"},
-  "aquafane": { label: "Aquafane", couleur: "Vert Profond"},
-  "asterite": { label: "Astérite", couleur: "Bleu, Violet ou Blanc"},
-  "cyanolithe": { label: "Cyanolithe", couleur: "Bleu Intense"},
-  "larmededragon": { label: "Larme de Dragon", couleur: "Rouge Intense"},
-  "muska": { label: "Muska", couleur: "Violet Profond"},
-  "nebuleuse": { label: "Nébuleuse", couleur: "Brouillard Intense"},
-  "nebuleuse": { label: "Nébuleuse", couleur: "Brouillard Intense, Rose, Vert ou Bleu Pâle"},
-  "oeildetigre": { label: "Oeil de Tigre", couleur: "Jaune"},
-  "scarlatine": { label: "Scarlatine", couleur: "Rouge Clair ou Orangé"},
-  "seliphane": { label: "Séliphane", couleur: "Vert Lumineux"},
-  "tournelune": { label: "Tournelune", couleur: "Violet ou Bleu"},
-  "zebraide": { label: "Zebraïde", couleur: "Bandes Bicolores, toutes couleurs"}
-}
-
-export class RdDGemme extends Item {
-
-  static getGemmeTypeOptionList() {
-    // TODO: look how to map object key-value pairs
-    let options = ""
-    for (let gemmeKey in tableGemmes) {
-      options += `<option value="${gemmeKey}">${tableGemmes[gemmeKey].label}</option>`
-    }
-    return options;
-  }
-
-
-  static calculDataDerivees(gemme) {
-    gemme.system.cout = (gemme.system.taille * gemme.system.purete) + gemme.system.qualite;
-    gemme.system.inertie = 7 - gemme.system.purete;
-    gemme.system.enchantabilite = gemme.system.taille - gemme.system.inertie;
-  }
-
-}
--- a/module/rdd-herbes.js
+++ b/module/rdd-herbes.js
@ -1,73 +0,0 @@
-import { Grammar } from "./grammar.js";
-import { SystemCompendiums } from "./settings/system-compendiums.js";
-import { RdDTimestamp } from "./time/rdd-timestamp.js";
-
-/* -------------------------------------------- */
-export class RdDHerbes extends Item {
-
-  /* -------------------------------------------- */
-  static async onReady() {
-    this.herbesSoins = await RdDHerbes.listCategorieHerbes('Soin');
-    this.herbesRepos = await RdDHerbes.listCategorieHerbes('Repos');
-  }
-
-  static async listCategorieHerbes(categorie) {
-    const herbes = await SystemCompendiums.getWorldOrCompendiumItems('herbe', 'faune-flore-mineraux');
-    return herbes.filter(it => Grammar.equalsInsensitive(it.system.categorie, categorie));
-  }
-
-  /* -------------------------------------------- */
-  static buildHerbesList(listeHerbes, max) {
-    let list = {}
-    for (let herbe of listeHerbes) {
-      let brins = max - herbe.system.niveau;
-      list[herbe.name] = `${herbe.name} (Bonus: ${herbe.system.niveau}, Brins: ${brins})`;
-    }
-    list['Autre'] = 'Autre (Bonus: variable, Brins: variable)'
-    return list;
-  }
-
-  /* -------------------------------------------- */
-  static calculFormData(formData, item) {
-    formData.isSoins = item.system.categorie.includes('Soin');
-    formData.isRepos = item.system.categorie.includes('Repos');
-    if (formData.isSoins) {
-      RdDHerbes.calculBonusHerbe(formData, this.herbesSoins, 12);
-    }
-    if (formData.isRepos) {
-      RdDHerbes.calculBonusHerbe(formData, this.herbesRepos, 7);
-    }
-    formData.herbesSoins = RdDHerbes.buildHerbesList(this.herbesSoins, 12);
-    formData.herbesRepos = RdDHerbes.buildHerbesList(this.herbesRepos, 7);
-    formData.dateActuelle = game.system.rdd.calendrier.dateCourante();
-    formData.enchantement = RdDTimestamp.splitIndexDate(item.system.prdate);
-  }
-
-  /* -------------------------------------------- */
-  static calculPuissancePotion(potion) {
-    return potion.system.herbebonus * potion.system.pr;
-  }
-
-  /* -------------------------------------------- */
-  static calculPointsRepos(potion) {
-    return potion.system.herbebonus * potion.system.pr;
-  }
-
-  /* -------------------------------------------- */
-  static calculPointsGuerison(potion) {
-    return potion.system.herbebonus * potion.system.pr;
-  }
-
-  /* -------------------------------------------- */
-  static calculBonusHerbe(formData, herbesList, max) {
-    if (Number(formData.system.herbebrins)) {
-      let herbe = herbesList.find(item => item.name.toLowerCase() == formData.system.herbe.toLowerCase());
-      if (herbe) {
-        const brinsRequis = max - herbe.system.niveau;
-        const brinsManquants = Math.max(brinsRequis - formData.system.herbebrins, 0);
-        formData.system.herbebonus = Math.max(herbe.system.niveau - brinsManquants, 0);
-      }
-    }
-  }
-
-}  
--- a/module/rdd-hotbar-drop.js
+++ b/module/rdd-hotbar-drop.js
@ -1,6 +1,6 @@
 import { RdDItemArme } from "./item-arme.js";
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
-import { ITEM_TYPES } from "./item.js";
+import { ITEM_TYPES } from "./constants.js";

 export class RdDHotbar {

--- a/module/rdd-main.js
+++ b/module/rdd-main.js
@ -18,7 +18,6 @@ import { RdDCompendiumOrganiser } from "./rdd-compendium-organiser.js"
 import { ReglesOptionnelles } from "./settings/regles-optionnelles.js"
 import { RdDHotbar } from "./rdd-hotbar-drop.js"
 import { EffetsDraconiques } from "./tmr/effets-draconiques.js"
-import { RdDHerbes } from "./rdd-herbes.js"
 import { RdDDice } from "./rdd-dice.js"
 import { RdDPossession } from "./rdd-possession.js"
 import { Misc } from "./misc.js"
@ -76,7 +75,10 @@ import { AppPersonnageAleatoire } from "./actor/random/app-personnage-aleatoire.
 import { RdDActorExportSheet } from "./actor/export-scriptarium/actor-encart-sheet.js"
 import { RdDStatBlockParser } from "./apps/rdd-import-stats.js"
 import { RdDJournalSheet } from "./journal/journal-sheet.js"
-import { RdDTextEditor } from "./apps/rdd-text-roll-editor.js"
+import { RdDPotionItemSheet } from "./item/sheet-potion.js"
+import { RdDItemPotion } from "./item/potion.js"
+import { RdDItemGemme } from "./item/gemme.js"
+import { RdDGemmeItemSheet } from "./item/sheet-gemme.js"

 /**
 * RdD system
@ -100,16 +102,18 @@ export class SystemReveDeDragon {
    this.itemClasses = {
      armure: RdDItemArmure,
      blessure: RdDItemBlessure,
+      gemme: RdDItemGemme,
      maladie: RdDItemMaladie,
      ombre: RdDItemOmbre,
      poison: RdDItemPoison,
+      potion: RdDItemPotion,
      queue: RdDItemQueue,
-      tete: RdDItemTete,
      race: RdDItemRace,
      rencontre: RdDRencontre,
      service: RdDItemService,
      signedraconique: RdDItemSigneDraconique,
      souffle: RdDItemSouffle,
+      tete: RdDItemTete,
    }
    this.actorClasses = {
      commerce: RdDCommerce,
@ -189,22 +193,12 @@ export class SystemReveDeDragon {
    Items.unregisterSheet("core", ItemSheet)
    RdDActorExportSheet.init()

-    RdDItemSheet.register(RdDSigneDraconiqueItemSheet)
-    RdDItemSheet.register(RdDRencontreItemSheet)
-    RdDItemSheet.register(RdDConteneurItemSheet)
-    RdDItemSheet.register(RdDHerbeItemSheet)
-    RdDItemSheet.register(RdDFauneItemSheet)
-    RdDItemSheet.register(RdDPlanteItemSheet)
-    RdDItemSheet.register(RdDIngredientItemSheet)
-    RdDItemSheet.register(RdDServiceItemSheet)
-    RdDItemSheet.register(RdDBlessureItemSheet)
-    RdDJournalSheet.register()
-
    Items.registerSheet(SYSTEM_RDD, RdDItemInventaireSheet, {
      types: [
-        "objet", "arme", "armure", "livre", "potion", "munition",
-        "monnaie", "nourritureboisson", "gemme",
-      ], makeDefault: true
+        "objet", "arme", "armure", "livre", "munition",
+        "monnaie", "nourritureboisson",
+      ],
+      makeDefault: true
    })
    Items.registerSheet(SYSTEM_RDD, RdDItemSheet, {
      types: [
@ -214,8 +208,22 @@ export class SystemReveDeDragon {
        "queue", "ombre", "souffle", "tete", "casetmr", "sort", "sortreserve",
        "nombreastral", "tache", "maladie", "poison", "possession",
        "tarot", "extraitpoetique", "empoignade"
-      ], makeDefault: true
+      ],
+      makeDefault: true
    })
+    
+    RdDItemSheet.register(RdDBlessureItemSheet)
+    RdDItemSheet.register(RdDConteneurItemSheet)
+    RdDItemSheet.register(RdDFauneItemSheet)
+    RdDItemSheet.register(RdDGemmeItemSheet)
+    RdDItemSheet.register(RdDHerbeItemSheet)
+    RdDItemSheet.register(RdDIngredientItemSheet)
+    RdDItemSheet.register(RdDPlanteItemSheet)
+    RdDItemSheet.register(RdDPotionItemSheet)
+    RdDItemSheet.register(RdDRencontreItemSheet)
+    RdDItemSheet.register(RdDServiceItemSheet)
+    RdDItemSheet.register(RdDSigneDraconiqueItemSheet)
+    RdDJournalSheet.register()

    // préparation des différents modules
    console.log(`Initializing Reve de Dragon Hooks and handlers`)
@ -316,7 +324,6 @@ export class SystemReveDeDragon {
    }

    StatusEffects.onReady()
-    RdDHerbes.onReady()
    RdDDice.onReady()

    RdDStatBlockParser.parseStatBlock()
--- a/module/rdd-possession.js
+++ b/module/rdd-possession.js
@ -3,7 +3,7 @@ import { RdDResolutionTable } from "./rdd-resolution-table.js";
 import { RdDRoll } from "./rdd-roll.js";
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
 import { Targets } from "./targets.js";
-import { ITEM_TYPES } from "./item.js";
+import { ITEM_TYPES } from "./constants.js";

 /* -------------------------------------------- */
 /* On part du principe qu'une entité démarre tjs 
@ -174,7 +174,7 @@ export class RdDPossession {
    await RdDResolutionTable.displayRollData(rollData, rollData.attacker, 'chat-resultat-possession.html')
    if (rollData.possession.isPosseder || rollData.possession.isConjurer) {
      // conjuration
-      victime.deleteEmbeddedDocuments("Item", [rollData.possession._id])
+      await victime.deleteEmbeddedDocuments("Item", [rollData.possession._id])
    }
  }

--- a/module/rdd-roll.js
+++ b/module/rdd-roll.js
@ -8,7 +8,7 @@ import { RdDCarac } from "./rdd-carac.js";
 import { RdDResolutionTable } from "./rdd-resolution-table.js";
 import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
 import { Grammar } from "./grammar.js";
-import { ACTOR_TYPES } from "./item.js";
+import { ACTOR_TYPES } from "./constants.js";

 /**
 * Extend the base Dialog entity to select roll parameters
@ -137,7 +137,11 @@ export class RdDRoll extends Dialog {
      this.rollData.selectedCarac = this.rollData.carac[this.actor.mapCarac(this.rollData.competence.system.defaut_carac)]
    }
    if (this.rollData.selectedCarac) {
-      this.html.find("[name='carac']").val(RdDCarac.caracDetails(this.rollData.selectedCarac.label).code)
+      this.html.find("[name='carac']").val(
+        this.actor?.type == ACTOR_TYPES.personnage
+          ? RdDCarac.caracDetails(this.rollData.selectedCarac.label).code
+          : this.rollData.selectedCarac.label
+      )
    }
    if (this.rollData.selectedSort) {
      this.setSelectedSort(this.rollData.selectedSort);
--- a/module/rdd-rolltables.js
+++ b/module/rdd-rolltables.js
@ -1,4 +1,3 @@
-import { RdDTextEditor } from "./apps/rdd-text-roll-editor.js";
 import { CompendiumTable, CompendiumTableHelpers, SystemCompendiums } from "./settings/system-compendiums.js";

 export class RdDRollTables {
--- a/module/rdd-sheet-utility.js
+++ b/module/rdd-sheet-utility.js
@ -66,11 +66,13 @@ export class RdDSheetUtility {
  }

  static async splitItem(item, actor, onSplit = () => { }) {
-    const dialog = await DialogSplitItem.create(item, async (item, split) => {
+    const _onSplit = async (item, split) => {
      await RdDSheetUtility._onSplitItem(item, split, actor);
      onSplit();
-    });
-    dialog.render(true);
+      await RdDSheetUtility.renderItemBranch(actor, item)
+    }
+    const dialog = await DialogSplitItem.create(item, _onSplit)
+    dialog.render(true)
  }

  static async _onSplitItem(item, split, actor) {
@ -82,4 +84,11 @@ export class RdDSheetUtility {
      await actor.createEmbeddedDocuments('Item', [splitItem])
    }
  }
+
+  static async renderItemBranch(actor, item) {
+    while (item) {
+      await item.sheet?.render()
+      item = actor.getContenant(item)
+    }
+  }
 }
--- a/module/rdd-tmr-dialog.js
+++ b/module/rdd-tmr-dialog.js
@ -16,7 +16,7 @@ import { RdDDice } from "./rdd-dice.js";
 import { STATUSES } from "./settings/status-effects.js";
 import { RdDRencontre } from "./item/rencontre.js";
 import { RdDTimestamp } from "./time/rdd-timestamp.js";
-import { ITEM_TYPES } from "./item.js";
+import { ITEM_TYPES } from "./constants.js";
 import { Misc } from "./misc.js";

 const TMR_DISPLAY_SIZE = {
@ -212,7 +212,7 @@ export class RdDTMRDialog extends Dialog {
  }

  getSortsReserve(coord) {
-    return this.actor.itemTypes[ITEM_TYPES.sortreserve].filter(// Reserve sur une case fleuve ou normale
+    return this.sortsReserve.filter(// Reserve sur une case fleuve ou normale
      TMRUtility.getTMR(coord).type == 'fleuve'
        ? it => TMRUtility.getTMR(it.system.coord).type == 'fleuve'
        : it => it.system.coord == coord
@ -241,7 +241,7 @@ export class RdDTMRDialog extends Dialog {
    this._getTokensRencontres().forEach(t => this._trackToken(t))
    this._getTokensSortsReserve().forEach(t => this._trackToken(t))
  }
-  
+
  /* -------------------------------------------- */
  updateTokens() {
    this._removeTokens(t => true);
@ -271,8 +271,7 @@ export class RdDTMRDialog extends Dialog {
  }

  _getTokensSortsReserve() {
-    const sortsReserve = this.actor.itemTypes[ITEM_TYPES.sortreserve];
-    return Misc.concat(sortsReserve.map(sortReserve =>
+    return Misc.concat(this.sortsReserve.map(sortReserve =>
      EffetsDraconiques.sortReserve.tokens(this.pixiTMR, sortReserve, () => sortReserve.system.coord)))
  }

@ -908,8 +907,8 @@ export class RdDTMRDialog extends Dialog {

  /* -------------------------------------------- */
  lancerSortEnReserve(coord, sortId) {
-    let sorts = this.getSortsReserve(coord);
-    let sort = sorts.find(it => it.id == sortId);
+    const sort = this.getSortsReserve(coord)
+      .find(it => it.id == sortId);
    if (sort) {
      this.processSortReserve(sort);
    } else {
--- a/module/rdd-utility.js
+++ b/module/rdd-utility.js
@ -19,10 +19,12 @@ 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";
+import { ITEM_TYPES, RDD_CONFIG } from "./constants.js";
 import { RdDBaseActor } from "./actor/base-actor.js";
 import { RdDCarac } from "./rdd-carac.js";
 import { RdDTextEditor } from "./apps/rdd-text-roll-editor.js";
+import { Monnaie } from "./item-monnaie.js";
+import { ItemAction } from "./item/item-actions.js";

 /* -------------------------------------------- */
 // This table starts at 0 -> niveau -10
@ -115,6 +117,7 @@ export class RdDUtility {
      'systems/foundryvtt-reve-de-dragon/templates/actor-entite-sheet.html',
      'systems/foundryvtt-reve-de-dragon/templates/actor-vehicule-sheet.html',
      // sous-parties de feuilles de personnages
+      'systems/foundryvtt-reve-de-dragon/templates/actor/item-action-controls.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/actor/header-buttons.html',
      'systems/foundryvtt-reve-de-dragon/templates/actor/header-etat.html',
      'systems/foundryvtt-reve-de-dragon/templates/actor/header-compteurs.html',
@ -129,48 +132,47 @@ export class RdDUtility {
      'systems/foundryvtt-reve-de-dragon/templates/actor/carac-derivee.html',
      'systems/foundryvtt-reve-de-dragon/templates/actor/carac-creature.html',
      'systems/foundryvtt-reve-de-dragon/templates/actor/carac-entitee.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/comp-creature.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/comp-possession.html',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/comp-creature.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/comp-possession.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/actor/carac-total.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/competence.html',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/competence.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/actor/competence-categorie.html',
      'systems/foundryvtt-reve-de-dragon/templates/actor/xp-competences.html',
      'systems/foundryvtt-reve-de-dragon/templates/actor/combat.html',
      'systems/foundryvtt-reve-de-dragon/templates/actor/blessures.html',
      'systems/foundryvtt-reve-de-dragon/templates/actor/blessure.hbs',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/maladies-poisons.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/possessions.html',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/maladies-poisons.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/possessions.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/actor/resonances.hbs',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/taches.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/taches.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/oeuvres.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/oeuvre.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/jeux.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/alchimie.html',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/taches.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/oeuvres.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/oeuvre.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/jeus.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/alchimie.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/actor/astrologie.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/chirurgie.html',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/chirurgie.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/actor/non-haut-revant.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/actor/haut-revant.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/actor/dragon-queues.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/dragon-queue.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/dragon-souffles.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/dragon-tetes.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-signes-draconiques.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-rencontres.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-sorts.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-sorts-reserve.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-meditations.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-casestmr.html',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/dragon-queue.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/dragon-souffles.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/dragon-tetes.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-signes-draconiques.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-rencontres.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-sorts.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-sorts-reserve.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-meditations.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-casetmrs.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/actor/xp-journal.html',
      'systems/foundryvtt-reve-de-dragon/templates/actor/editor-notes-mj.html',
      'systems/foundryvtt-reve-de-dragon/templates/actor/inventaire.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-item.html',
-      "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-monnaie.html",
+      'systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-item.hbs',
+      "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-monnaie.hbs",
      'systems/foundryvtt-reve-de-dragon/templates/actor/liens-animaux.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/actor/liens-suivants.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/actor/liens-vehicules.hbs',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire-item.html',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire-item.hbs',
      //Items
      'systems/foundryvtt-reve-de-dragon/templates/scripts/autocomplete-script.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/scripts/autocomplete.hbs',
@ -180,8 +182,9 @@ export class RdDUtility {
      'systems/foundryvtt-reve-de-dragon/templates/item/partial-inventaire.html',
      'systems/foundryvtt-reve-de-dragon/templates/item/partial-environnement.html',
      'systems/foundryvtt-reve-de-dragon/templates/item/partial-tab-environnement.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-queue-sheet.html',
      'systems/foundryvtt-reve-de-dragon/templates/header-item.html',
+
+      'systems/foundryvtt-reve-de-dragon/templates/item/queue-sheet.hbs',
      // partial enums
      'systems/foundryvtt-reve-de-dragon/templates/enum-aspect-tarot.html',
      'systems/foundryvtt-reve-de-dragon/templates/enum-base-competence.html',
@ -189,7 +192,8 @@ export class RdDUtility {
      'systems/foundryvtt-reve-de-dragon/templates/enum-categories.html',
      'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-ingredient.html',
      'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-parade.html',
-      'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-potion.html',
+      'systems/foundryvtt-reve-de-dragon/templates/item/enum-categorie-alchimie.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/item/enum-etat-alchimie.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-queue.html',
      'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-vehicule.html',
      'systems/foundryvtt-reve-de-dragon/templates/enum-competence.html',
@ -203,6 +207,7 @@ export class RdDUtility {
      'systems/foundryvtt-reve-de-dragon/templates/enum-tmr-effet.html',
      'systems/foundryvtt-reve-de-dragon/templates/enum-tmr-type.html',
      // Partials
+      'systems/foundryvtt-reve-de-dragon/templates/enchantement/partial-enchantement.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/coeur/chat-effet-tendre-moment.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/coeur/afficher-coeur.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/tirage/liste-resultats-recherche.hbs',
@ -259,11 +264,10 @@ export class RdDUtility {
      'systems/foundryvtt-reve-de-dragon/templates/chat-actor-turn-sante.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/chat-actor-competence-xp.html',
      'systems/foundryvtt-reve-de-dragon/templates/chat-actor-carac-xp.html',
-      'systems/foundryvtt-reve-de-dragon/templates/chat-potionenchantee-chateaudormant.html',
      'systems/foundryvtt-reve-de-dragon/templates/chat-fabriquer-potion-base.html',
      'systems/foundryvtt-reve-de-dragon/templates/chat-signe-draconique-actor.html'
    ];
-    
+
    // foundry et options
    Handlebars.registerHelper('RDD_CONFIG', path => RDD_CONFIG[path])
    Handlebars.registerHelper('linkCompendium', (pack, id, name) => RdDUtility.linkCompendium(pack, id, name));
@ -278,7 +282,7 @@ export class RdDUtility {
      const html = options.fn(this);
      return html.replace(rgx, "$& selected");
    })
-    
+
    // logic
    Handlebars.registerHelper('either', (a, b) => a ?? b);
    // string manipulation
@ -294,9 +298,9 @@ export class RdDUtility {

    // math
    Handlebars.registerHelper('min', (...args) => Math.min(...args.slice(0, -1)));
-    Handlebars.registerHelper('repeat', function(n, block) {
+    Handlebars.registerHelper('repeat', function (n, block) {
      let accum = '';
-      for(let i = 0; i < n; ++i){
+      for (let i = 0; i < n; ++i) {
        accum += block.fn(i)
      }
      return accum
@ -334,6 +338,9 @@ export class RdDUtility {
    Handlebars.registerHelper('isFieldInventaireModifiable', (type, field) => RdDItem.isFieldInventaireModifiable(type, field));
    // Items
    Handlebars.registerHelper('rarete-getChamp', (rarete, field) => RdDRaretes.getChamp(rarete, field));
+    Handlebars.registerHelper('item-action-applies', (action, item, options) => ItemAction.applies(action, item, options))
+    Handlebars.registerHelper('item-action-icon', (action, item) => ItemAction.icon(action, item))
+    Handlebars.registerHelper('item-name', (item) =>  item.nameDisplay)

    // TMRs
    Handlebars.registerHelper('caseTmr-label', coord => TMRUtility.getTMRLabel(coord));
@ -435,8 +442,8 @@ export class RdDUtility {
    };
    if (!optionsArbre.templateItem) {
      optionsArbre.templateItem = item.parent?.type == 'commerce'
-        ? "systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire-item.html"
-        : "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-item.html";
+        ? "systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire-item.hbs"
+        : "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-item.hbs";
    }
    item.niveau = optionsArbre.profondeur;
  }
@ -464,13 +471,38 @@ export class RdDUtility {
    return ligneObjet;
  }

+  static filterItemsPerTypeForSheet(formData, itemTypes) {
+    Object.values(ITEM_TYPES).forEach(t => {
+      formData[t + 's'] = Misc.arrayOrEmpty(itemTypes[t])
+      itemTypes[t].forEach(item => item.actions = item.itemActions())
+    })
+
+    formData.maladiesPoisons = formData.maladies.concat(formData.poisons)
+    formData.competences = formData.competences.concat(formData.competencecreatures)
+    formData.monnaies = formData.monnaies.sort(Monnaie.triValeurEntiere())
+
+    formData.inventaires = RdDUtility.prepareInventaire(itemTypes)
+  }
+
  static buildInventaireConteneur(actorId, itemId, options) {
    const actor = game.actors.get(actorId)
    const item = actor?.items.get(itemId)
-    if (item) {
-      return RdDUtility.buildContenuConteneur(item, options, { ouvert: true, profondeur: 1 });
+    if (item?.type == ITEM_TYPES.conteneur) {
+      const formData = {}
+      RdDUtility.filterItemsPerTypeForSheet(formData, actor.itemTypes);
+      RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.inventaires);
+      item.subItems = formData.conteneurs.find(it => it._id == itemId)?.subItems;
+
+      return RdDUtility.buildContenuConteneur(item, options, { ouvert: true, profondeur: 1 })
    }
-    return '';
+    return ''
+  }
+
+  static prepareInventaire(itemTypes) {
+    return RdDItem.getItemTypesInventaire('all')
+      .map(t => Misc.arrayOrEmpty(itemTypes[t]))
+      .reduce((a, b) => a.concat(b), [])
+      .sort(Misc.ascending(it => it.name))
  }

  /* -------------------------------------------- */
@ -872,7 +904,7 @@ export class RdDUtility {
  }

  /* -------------------------------------------- */
-  static async confirmActorItemDelete(sheet, item, htmlToDelete) {
+  static async confirmActorItemDelete(item, actor) {
    const itemId = item.id;
    const confirmationSuppression = {
      settingConfirmer: "confirmation-supprimer-" + item.getItemGroup(),
@ -881,8 +913,7 @@ export class RdDUtility {
      buttonLabel: "Supprimer",
      onAction: () => {
        console.log('Delete : ', itemId);
-        sheet.actor.deleteEmbeddedDocuments('Item', [itemId], { renderSheet: false });
-        RdDUtility.slideOnDelete(sheet, htmlToDelete);
+        actor.deleteEmbeddedDocuments('Item', [itemId], { renderSheet: false });
      }
    };
    if (item.isConteneurNonVide()) {
@ -895,8 +926,7 @@ export class RdDUtility {
            label: "Supprimer conteneur et contenu",
            callback: () => {
              console.log("Delete : ", itemId);
-              sheet.actor.deleteAllConteneur(itemId, { renderSheet: false });
-              RdDUtility.slideOnDelete(sheet, htmlToDelete);
+              actor.deleteAllConteneur(itemId, { renderSheet: false });
            }
          }
        });
--- a/module/time/rdd-timestamp.js
+++ b/module/time/rdd-timestamp.js
@ -334,6 +334,10 @@ export class RdDTimestamp {
    return this.nouvelleHeure().addHeures((12 + heure - this.heure) % 12);
  }

+  debutJournee() {
+    return RdDTimestamp.timestamp(this.annee, this.mois, this.jour)
+  }
+
  async appliquerDuree(duree, actor) {
    const formule = FORMULES_DUREE.find(it => it.code == duree) ?? FORMULES_DUREE.find(it => it.code == "");
    return await formule.calcul(this, actor);
--- a/module/tmr-rencontres.js
+++ b/module/tmr-rencontres.js
@ -26,7 +26,7 @@ export class TMRRencontres {
   * @param {*} forcedRoll 
   */
  async rollRencontre(terrain, forcedRoll) {
-    const tmrType = TMRUtility.findTMRLike(terrain)?.type
+    const tmrType = TMRUtility.findTMRLike(terrain, { inclusMauvaise: true })?.type
    if (tmrType == undefined) {
      return undefined;
    }
@ -38,7 +38,7 @@ export class TMRRencontres {
    const frequence = it => it.system.frequence[tmrType];
    const row = await this.table.getRandom(frequence, filtreMauvaise, forcedRoll);
    if (row) {
-      await CompendiumTableHelpers.tableRowToChatMessage(row, 'Item', {showSource: false});
+      await CompendiumTableHelpers.tableRowToChatMessage(row, 'Item', { showSource: false });
    }

    return row?.document;
--- a/module/tmr-utility.js
+++ b/module/tmr-utility.js
@ -22,7 +22,7 @@ export const TMRType = {
 export const FLEUVE_COORD = 'Fleuve'

 const TMRMapping = {
-  Fleuve: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  Fleuve: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli", generique: 'fleuve' },
  A1: { type: TMRType.cite.type, label: "Cité Vide" },
  B1: { type: TMRType.plaines.type, label: "Plaines d’Assorh" },
  C1: { type: TMRType.necropole.type, label: "Nécropole de Kroak" },
@ -281,18 +281,18 @@ export class TMRUtility {
    return Grammar.articleDetermine(tmr.type) + ' ' + tmr.label;
  }

-  static findTMRLike(type, options = { inclusMauvaise: true }) {
+  static findTMRLike(type, options = { inclusMauvaise: false }) {
    const choix = [...Object.values(TMRType)]
    if (options.inclusMauvaise) {
      choix.push({ name: 'Mauvaise', type: 'mauvaise'});
    }
    const selection = Misc.findAllLike(type, choix)
    if (selection.length == 0) {
-      ui.notifications.warn(`Un type de TMR doit être indiqué, '${type}' n'est pas trouvé dans ${choix}`);
+      ui.notifications.warn(`Un type de TMR doit être indiqué, '${type}' n'est pas trouvé dans ${choix.map(it => it.name).reduce(Misc.joining(', '))}`);
      return undefined
    }
    if (selection.length > 1) {
-      ui.notifications.warn(`Plusieurs types de TMR pourraient correspondre à '${type}': ${selection.map(it => it.name)}`);
+      ui.notifications.warn(`Plusieurs types de TMR pourraient correspondre à '${type}': ${selection.map(it => it.name).reduce(Misc.joining(', '))}`);
      return undefined;
    }
    return selection[0]
@ -357,7 +357,7 @@ export class TMRUtility {
  }

  static filterTMR(filter) {
-    return Object.values(TMRMapping).filter(filter);
+    return Object.values(TMRMapping).filter(it => !it.generique && filter(it))
  }

  static getCasesType(type) {
--- a/module/tmr/draconique.js
+++ b/module/tmr/draconique.js
@ -1,4 +1,4 @@
-import { ITEM_TYPES } from "../item.js";
+import { ITEM_TYPES } from "../constants.js";
 import { TMRUtility } from "../tmr-utility.js";
 import { PixiTMR } from "./pixi-tmr.js";

--- a/module/tmr/effets-draconiques.js
+++ b/module/tmr/effets-draconiques.js
@ -18,7 +18,7 @@ import { Periple } from "./periple.js";
 import { UrgenceDraconique } from "./urgence-draconique.js";
 import { Grammar } from "../grammar.js";
 import { AugmentationSeuil } from "./augmentation-seuil.js";
-import { ITEM_TYPES } from "../item.js";
+import { ITEM_TYPES } from "../constants.js";

 export class EffetsDraconiques {
  static carteTmr = new CarteTmr();
--- a/module/tmr/urgence-draconique.js
+++ b/module/tmr/urgence-draconique.js
@ -5,7 +5,7 @@ import { RdDRollTables } from "../rdd-rolltables.js";
 import { TMRUtility } from "../tmr-utility.js";
 import { tmrTokenZIndex } from "../tmr-constants.js";
 import { Draconique } from "./draconique.js";
-import { ITEM_TYPES } from "../item.js";
+import { ITEM_TYPES } from "../constants.js";
 import { TMRAnimations } from "./animation.js";

 export class UrgenceDraconique extends Draconique {
--- a/module/voyage/dialog-fatigue-voyage.js
+++ b/module/voyage/dialog-fatigue-voyage.js
@ -1,4 +1,4 @@
-import { ITEM_TYPES } from "../item.js"
+import { ITEM_TYPES } from "../constants.js"
 import { RdDItemCompetence } from "../item-competence.js"
 import { ChatUtility } from "../chat-utility.js"
 import { Misc } from "../misc.js"
--- a/packs_src/animaux/creature_Brolute_rieuse_twCuK1GjVBTUFGXF.yml
+++ b/packs_src/animaux/creature_Brolute_rieuse_twCuK1GjVBTUFGXF.yml
@ -300,7 +300,7 @@ system:
    d&eacute;chirure. Celle-l&agrave; se contente de chercher &agrave; fuir en
    cas d&rsquo;agression, ou attaque toutes griffes dehors si elle se sent
    accul&eacute;e. Pour la distinguer (visuellement) de la rieuse,
-    r&eacute;ussir VUE/Zoologie &agrave; -5. Les caract&eacute;ristiques de
+    r&eacute;ussir @roll[VUE/Zoologie/-5]. Les caract&eacute;ristiques de
    combat indiqu&eacute;es ne s&rsquo;appliquent qu&rsquo;&agrave; la
    pointue.</p>
  race: ''
--- a/packs_src/animaux/creature_Cheval_76I21ASdWYBqsg8I.yml
+++ b/packs_src/animaux/creature_Cheval_76I21ASdWYBqsg8I.yml
@ -215,7 +215,7 @@ system:
    souffrir ses premiers malus &agrave; la course et au saut. La vitesse
    indiqu&eacute;e correspond &agrave; une allure plut&ocirc;t lente.
    Contrairement aux autres animaux pour qui la vitesse de base est fixe, le
-    gardien des r&ecirc;ves peut rajouter jusqu&rsquo;&agrave; 3d6 points
+    gardien des r&ecirc;ves peut rajouter jusqu&rsquo;&agrave; @roll[3d6] points
    &agrave; la vitesse de course de chaque individu. Cette nouvelle vitesse de
    course est rajout&eacute;e une fois pour toutes, mais peut &ecirc;tre
    modul&eacute;e par un jet de course sur la table de Course animale.</p>
--- a/packs_src/archetypes/commerce_Liste_d__quipement_1Nng9d8r6lrPHCaJ.yml
+++ b/packs_src/archetypes/commerce_Liste_d__quipement_1Nng9d8r6lrPHCaJ.yml
@ -2358,6 +2358,7 @@ items:
          indexMinute: 0
      rarete: ''
      categorie: Remede
+      etat: Epais
      herbe: ''
      herbebrins: 0
      herbebonus: 0
@ -3898,6 +3899,7 @@ items:
          indexMinute: 0
      rarete: ''
      categorie: Remede
+      etat: Liquide
      herbe: ''
      herbebrins: 0
      herbebonus: 0
@ -4919,6 +4921,7 @@ items:
          indexMinute: 0
      rarete: ''
      categorie: Remede
+      etat: Epais
      herbe: ''
      herbebrins: 0
      herbebonus: 0
@ -5350,6 +5353,7 @@ items:
          indexMinute: 0
      rarete: ''
      categorie: Remede
+      etat: Liquide
      herbe: ''
      herbebrins: 0
      herbebonus: 0
@ -5606,6 +5610,7 @@ items:
          indexMinute: 0
      rarete: ''
      categorie: Remede
+      etat: Liquide
      herbe: ''
      herbebrins: 0
      herbebonus: 0
@ -5766,6 +5771,7 @@ items:
          indexMinute: 0
      rarete: ''
      categorie: Remede
+      etat: Liquide
      herbe: ''
      herbebrins: 0
      herbebonus: 0
@ -6438,6 +6444,7 @@ items:
          indexMinute: 0
      rarete: ''
      categorie: Remede
+      etat: Liquide
      herbe: ''
      herbebrins: 0
      herbebonus: 0
@ -6672,6 +6679,7 @@ items:
          indexMinute: 0
      rarete: ''
      categorie: Remede
+      etat: Solide
      herbe: ''
      herbebrins: 0
      herbebonus: 0
@ -7157,6 +7165,7 @@ items:
          indexMinute: 0
      rarete: ''
      categorie: Remede
+      etat: Poudre
      herbe: ''
      herbebrins: 0
      herbebonus: 0
@ -7611,6 +7620,7 @@ items:
          indexMinute: 0
      rarete: ''
      categorie: Remede
+      etat: Liquide
      herbe: ''
      herbebrins: 0
      herbebonus: 0
@ -7690,6 +7700,7 @@ items:
          indexMinute: 0
      rarete: ''
      categorie: Remede
+      etat: Solide
      herbe: ''
      herbebrins: 0
      herbebonus: 0
@ -7768,6 +7779,7 @@ items:
          indexMinute: 0
      rarete: ''
      categorie: Remede
+      etat: Epais
      herbe: ''
      herbebrins: 0
      herbebonus: 0
@ -8010,7 +8022,7 @@ items:
        poussant dans les lieux frais et humides : marais ombrag&eacute;s,
        certaines for&ecirc;ts, et parfois vall&eacute;es de montagne. Un peu
        moins rare est la fausse endebrume, qui lui ressemble physiquement, mais
-        n'a aucune vertu. <br /><em>VUE/Botanique &agrave; -1 pour savoir
+        n'a aucune vertu. <br /><em>@roll[VUE/Botanique/-1] pour savoir
        &agrave; quelle esp&egrave;ce on a affaire (jet obligatoire &agrave;
        chaque cueillette).</em></p>

@ -8782,7 +8794,7 @@ items:
    system:
      description: |-
        <p>Poudre brune apparaissant sur les parois des grottes.</p>
-        <p>VUE/Alchimie &agrave; -1.</p>
+        <p>@roll[VUE/Alchimie/-1].</p>
      descriptionmj: ''
      encombrement: 0.001
      quantite: 1
@ -8818,7 +8830,7 @@ items:
        <p>Poudre blanche apparaissant sous l&rsquo;&eacute;corce de nombreux
        arbres,</p>

-        <p>VUE/Alchimie &agrave; 0.</p>
+        <p>@roll[VUE/Alchimie/0].</p>
      descriptionmj: ''
      encombrement: 0.001
      quantite: 1
@ -8854,7 +8866,7 @@ items:
        <p>Poudre rouge obtenue par disruption alchimique de la
        <em>chramaele</em>, minerai ayant l&rsquo;apparence de la glaise.</p>

-        <p>VUE/Alchimie &agrave; -4</p>
+        <p>@roll[VUE/Alchimie/-4]</p>
      descriptionmj: ''
      encombrement: 0.001
      quantite: 1
@ -8899,7 +8911,7 @@ items:
        <p>Poudre noire obtenue par disruption alchimique du minerai
        appel&eacute; <em>narthalide</em>, sorte de marne.</p>

-        <p>VUE/Alchimie &agrave; -3</p>
+        <p>@roll[VUE/Alchimie/-3]</p>
      descriptionmj: ''
      encombrement: 0.001
      quantite: 1
@ -8941,7 +8953,7 @@ items:
        <p>Poudre bleu&acirc;tre obtenue par disruption alchimique du minerai
        appel&eacute; <em>obbadine</em>, &nbsp;sorte de tourbe.</p>

-        <p>VUE/Alchimie &agrave; -2</p>
+        <p>@roll[VUE/Alchimie/-2]</p>
      descriptionmj: ''
      encombrement: 0.001
      quantite: 1
@ -8983,7 +8995,7 @@ items:
        <p>Plus rare que le vert, poudre gris&acirc;tre apparaissant le long de
        certaines lianes des marais.</p>

-        <p>VUE/Alchimie &agrave; -4</p>
+        <p>@roll[VUE/Alchimie/-4]</p>
      descriptionmj: ''
      encombrement: 0.001
      quantite: 1
@ -9019,7 +9031,7 @@ items:
        <p>Poudre verd&acirc;tre apparaissant sur les tiges de certains
        roseaux.</p>

-        <p>VUE/Alchimie &agrave; -2</p>
+        <p>@roll[VUE/Alchimie/-2]</p>
      descriptionmj: ''
      encombrement: 0.001
      quantite: 1
--- a/packs_src/equipement/potion_Bitume_de_Camphre_9cLkTDugz84gpHUB.yml
+++ b/packs_src/equipement/potion_Bitume_de_Camphre_9cLkTDugz84gpHUB.yml
@ -29,6 +29,7 @@ system:
      indexMinute: 0
  rarete: ''
  categorie: Remede
+  etat: Epais
  herbe: ''
  herbebrins: 0
  herbebonus: 0
--- a/packs_src/equipement/potion_Elixir_des_gnomes_JXMef7FXVOG1XYWO.yml
+++ b/packs_src/equipement/potion_Elixir_des_gnomes_JXMef7FXVOG1XYWO.yml
@ -31,6 +31,7 @@ system:
      indexMinute: 0
  rarete: ''
  categorie: Remede
+  etat: Liquide
  herbe: ''
  herbebrins: 0
  herbebonus: 0
--- a/packs_src/equipement/potion_Gel_e_royale_kFUh4027jnAdqbyK.yml
+++ b/packs_src/equipement/potion_Gel_e_royale_kFUh4027jnAdqbyK.yml
@ -29,6 +29,7 @@ system:
      indexMinute: 0
  rarete: ''
  categorie: Remede
+  etat: Epais
  herbe: ''
  herbebrins: 0
  herbebonus: 0
--- a/packs_src/equipement/potion_Huile_de_S_likanthe_LkE8EjPfao9m6Rn7.yml
+++ b/packs_src/equipement/potion_Huile_de_S_likanthe_LkE8EjPfao9m6Rn7.yml
@ -31,6 +31,7 @@ system:
      indexMinute: 0
  rarete: ''
  categorie: Remede
+  etat: Liquide
  herbe: ''
  herbebrins: 0
  herbebonus: 0
--- a/packs_src/equipement/potion_Lait_de_lune_A3jx5dPkk5IeXSXn.yml
+++ b/packs_src/equipement/potion_Lait_de_lune_A3jx5dPkk5IeXSXn.yml
@ -31,6 +31,7 @@ system:
      indexMinute: 0
  rarete: ''
  categorie: Remede
+  etat: Liquide
  herbe: ''
  herbebrins: 0
  herbebonus: 0
--- a/packs_src/equipement/potion_Liqueur_de_Bagdol_PrnJrG50u1UPdlJN.yml
+++ b/packs_src/equipement/potion_Liqueur_de_Bagdol_PrnJrG50u1UPdlJN.yml
@ -29,6 +29,7 @@ system:
      indexMinute: 0
  rarete: ''
  categorie: Remede
+  etat: Liquide
  herbe: ''
  herbebrins: 0
  herbebonus: 0
--- a/packs_src/equipement/potion_Mirobolant_keLCmhsbxHK39UIy.yml
+++ b/packs_src/equipement/potion_Mirobolant_keLCmhsbxHK39UIy.yml
@ -31,6 +31,7 @@ system:
      indexMinute: 0
  rarete: ''
  categorie: Remede
+  etat: Liquide
  herbe: ''
  herbebrins: 0
  herbebonus: 0
--- a/packs_src/equipement/potion_Perles_de_Bjwal_OYWzXiQUFsjU5AF2.yml
+++ b/packs_src/equipement/potion_Perles_de_Bjwal_OYWzXiQUFsjU5AF2.yml
@ -29,6 +29,7 @@ system:
      indexMinute: 0
  rarete: ''
  categorie: Remede
+  etat: Solide
  herbe: ''
  herbebrins: 0
  herbebonus: 0
--- a/packs_src/equipement/potion_Sable_Poudre_ElweMV283IUpqaik.yml
+++ b/packs_src/equipement/potion_Sable_Poudre_ElweMV283IUpqaik.yml
@ -29,6 +29,7 @@ system:
      indexMinute: 0
  rarete: ''
  categorie: Remede
+  etat: Poudre
  herbe: ''
  herbebrins: 0
  herbebonus: 0
--- a/packs_src/equipement/potion_Teinture_d_Erozonne_bA0JDA7awoWhu0vO.yml
+++ b/packs_src/equipement/potion_Teinture_d_Erozonne_bA0JDA7awoWhu0vO.yml
@ -31,6 +31,7 @@ system:
      indexMinute: 0
  rarete: ''
  categorie: Remede
+  etat: Liquide
  herbe: ''
  herbebrins: 0
  herbebonus: 0
--- a/packs_src/equipement/potion_Topazo_ne_FH3mSvdebfhIL2Af.yml
+++ b/packs_src/equipement/potion_Topazo_ne_FH3mSvdebfhIL2Af.yml
@ -29,6 +29,7 @@ system:
      indexMinute: 0
  rarete: ''
  categorie: Remede
+  etat: Solide
  herbe: ''
  herbebrins: 0
  herbebonus: 0
--- a/packs_src/equipement/potion_Tournegraisse_4GeV81qoJrjHIgzR.yml
+++ b/packs_src/equipement/potion_Tournegraisse_4GeV81qoJrjHIgzR.yml
@ -29,6 +29,7 @@ system:
      indexMinute: 0
  rarete: ''
  categorie: Remede
+  etat: Epais
  herbe: ''
  herbebrins: 0
  herbebonus: 0
--- a/packs_src/faune-flore-mineraux/ingredient_Boralm_kbWKsR0HovidPw6d.yml
+++ b/packs_src/faune-flore-mineraux/ingredient_Boralm_kbWKsR0HovidPw6d.yml
@ -5,7 +5,7 @@ effects: []
 system:
  description: |-
    <p>Poudre brune apparaissant sur les parois des grottes.</p>
-    <p>VUE/Alchimie &agrave; -1.</p>
+    <p>@roll[VUE/Alchimie/-1].</p>
  descriptionmj: ''
  encombrement: 0.001
  quantite: 1
--- a/packs_src/faune-flore-mineraux/ingredient_Candique_FjfZ789LlkzUUSMU.yml
+++ b/packs_src/faune-flore-mineraux/ingredient_Candique_FjfZ789LlkzUUSMU.yml
@ -7,7 +7,7 @@ system:
    <p>Poudre blanche apparaissant sous l&rsquo;&eacute;corce de nombreux
    arbres,</p>

-    <p>VUE/Alchimie &agrave; 0.</p>
+    <p>@roll[VUE/Alchimie/0].</p>
  descriptionmj: ''
  encombrement: 0.001
  quantite: 1
--- a/packs_src/faune-flore-mineraux/ingredient_Chramaelium_NNTl6CAdRZcylrU1.yml
+++ b/packs_src/faune-flore-mineraux/ingredient_Chramaelium_NNTl6CAdRZcylrU1.yml
@ -7,7 +7,7 @@ system:
    <p>Poudre rouge obtenue par disruption alchimique de la <em>chramaele</em>,
    minerai ayant l&rsquo;apparence de la glaise.</p>

-    <p>VUE/Alchimie &agrave; -4</p>
+    <p>@roll[VUE/Alchimie/-4]</p>
  descriptionmj: ''
  encombrement: 0.001
  quantite: 1
--- a/packs_src/faune-flore-mineraux/ingredient_Nartha_SiFtJoydPawJaMKA.yml
+++ b/packs_src/faune-flore-mineraux/ingredient_Nartha_SiFtJoydPawJaMKA.yml
@ -7,7 +7,7 @@ system:
    <p>Poudre noire obtenue par disruption alchimique du minerai appel&eacute;
    <em>narthalide</em>, sorte de marne.</p>

-    <p>VUE/Alchimie &agrave; -3</p>
+    <p>@roll[VUE/Alchimie/-3]</p>
  descriptionmj: ''
  encombrement: 0.001
  quantite: 1
--- a/packs_src/faune-flore-mineraux/ingredient_Obbadion_f4TPpX03pJuyBkuX.yml
+++ b/packs_src/faune-flore-mineraux/ingredient_Obbadion_f4TPpX03pJuyBkuX.yml
@ -7,7 +7,7 @@ system:
    <p>Poudre bleu&acirc;tre obtenue par disruption alchimique du minerai
    appel&eacute; <em>obbadine</em>, &nbsp;sorte de tourbe.</p>

-    <p>VUE/Alchimie &agrave; -2</p>
+    <p>@roll[VUE/Alchimie/-2]</p>
  descriptionmj: ''
  encombrement: 0.001
  quantite: 1
--- a/packs_src/faune-flore-mineraux/ingredient_Obyssum_gris_m9ONkzH9KwLk3P3i.yml
+++ b/packs_src/faune-flore-mineraux/ingredient_Obyssum_gris_m9ONkzH9KwLk3P3i.yml
@ -7,7 +7,7 @@ system:
    <p>Plus rare que le vert, poudre gris&acirc;tre apparaissant le long de
    certaines lianes des marais.</p>

-    <p>VUE/Alchimie &agrave; -4</p>
+    <p>@roll[VUE/Alchimie/-4]</p>
  descriptionmj: ''
  encombrement: 0.001
  quantite: 1
--- a/packs_src/faune-flore-mineraux/ingredient_Obyssum_vert_HTtgzxpvUvMHilqx.yml
+++ b/packs_src/faune-flore-mineraux/ingredient_Obyssum_vert_HTtgzxpvUvMHilqx.yml
@ -5,7 +5,7 @@ effects: []
 system:
  description: |-
    <p>Poudre verd&acirc;tre apparaissant sur les tiges de certains roseaux.</p>
-    <p>VUE/Alchimie &agrave; -2</p>
+    <p>@roll[VUE/Alchimie/-2]</p>
  descriptionmj: ''
  encombrement: 0.001
  quantite: 1
--- a/packs_src/ombres-de-thanatos/ombre_Coup_de_barre_PMz7SaB6sRxhwrWw.yml
+++ b/packs_src/ombres-de-thanatos/ombre_Coup_de_barre_PMz7SaB6sRxhwrWw.yml
@ -4,7 +4,7 @@ type: ombre
 img: systems/foundryvtt-reve-de-dragon/icons/queue_dragon.webp
 effects: []
 system:
-  description: <p>Prise immédiate de 3d6 points de fatigue.</p>
+  description: <p>Prise immédiate de @roll[3d6] points de fatigue.</p>
  descriptionmj: ''
  temporel:
    debut:
--- a/packs_src/queues-de-dragon/queue_Casser_3d6_oeufs_en_les_jetant___terre_OjG8XRbeYtq2jcgB.yml
+++ b/packs_src/queues-de-dragon/queue_Casser_3d6_oeufs_en_les_jetant___terre_OjG8XRbeYtq2jcgB.yml
@ -1,5 +1,5 @@
 _id: OjG8XRbeYtq2jcgB
-name: Casser 3d6 oeufs en les jetant à terre
+name: Casser @roll[3d6] oeufs en les jetant à terre
 type: queue
 img: systems/foundryvtt-reve-de-dragon/icons/queues/desir_lancinant.webp
 effects: []
--- a/packs_src/queues-de-dragon/queue_Coup_de_barre_Qgj5eSMpQ0IDHwZX.yml
+++ b/packs_src/queues-de-dragon/queue_Coup_de_barre_Qgj5eSMpQ0IDHwZX.yml
@ -4,7 +4,7 @@ type: queue
 img: systems/foundryvtt-reve-de-dragon/icons/queue_dragon.webp
 effects: []
 system:
-  description: <p>Prise immédiate de 3d6 points de fatigue.</p>
+  description: <p>Prise immédiate de @roll[3d6] points de fatigue.</p>
  descriptionmj: ''
  temporel:
    debut:
--- a/packs_src/queues-de-dragon/queue_Garder_sur_soi_3d6_kilos_de_cailloux_F8G3rdU1nfJzYwYR.yml
+++ b/packs_src/queues-de-dragon/queue_Garder_sur_soi_3d6_kilos_de_cailloux_F8G3rdU1nfJzYwYR.yml
@ -1,5 +1,5 @@
 _id: F8G3rdU1nfJzYwYR
-name: Garder sur soi 3d6 kilos de cailloux
+name: Garder sur soi @roll[3d6] kilos de cailloux
 type: queue
 img: systems/foundryvtt-reve-de-dragon/icons/queues/idee_fixe.webp
 effects: []
--- a/packs_src/recettes-alchimiques/recettealchimique_Bitume_de_Camphre_RXQcnXK88LjMICB5.yml
+++ b/packs_src/recettes-alchimiques/recettealchimique_Bitume_de_Camphre_RXQcnXK88LjMICB5.yml
@ -9,7 +9,7 @@ system:
    <p><strong>L&rsquo;huile de pierre</strong> (p&eacute;trole brut) se trouve
    naturellement &agrave; la surface de certains marais.</p>

-    <p>VUE/Alchimie &agrave; z&eacute;ro pour l&rsquo;identifier.</p>
+    <p>@roll[VUE/Alchimie/0] pour l&rsquo;identifier.</p>

    <p>&nbsp;</p>

--- a/packs_src/tables-diverses/tables_D_sirs_lancinants_sVWhyr4wPnieuPP8.yml
+++ b/packs_src/tables-diverses/tables_D_sirs_lancinants_sVWhyr4wPnieuPP8.yml
@ -252,7 +252,7 @@ results:
  - _id: 5AHjNXDrQL5TqLjv
    flags: {}
    type: pack
-    text: 'Désir lancinant : Casser 3d6 oeufs en les jetant à terre'
+    text: 'Désir lancinant : Casser @roll[3d6] oeufs en les jetant à terre'
    img: systems/foundryvtt-reve-de-dragon/icons/queues/desir_lancinant.webp
    weight: 1
    range:
--- a/packs_src/tables-diverses/tables_Id_es_fixes_nbH4v630P7ARaAHk.yml
+++ b/packs_src/tables-diverses/tables_Id_es_fixes_nbH4v630P7ARaAHk.yml
@ -64,7 +64,7 @@ results:
  - _id: P0eaJjtQQfpNIL9I
    flags: {}
    type: pack
-    text: 'Idée fixe : Garder sur soi 3d6 kilos de cailloux'
+    text: 'Idée fixe : Garder sur soi @roll[3d6] kilos de cailloux'
    img: systems/foundryvtt-reve-de-dragon/icons/queues/idee_fixe.webp
    weight: 1
    range:
--- a/packs_src/tables-diverses/tables_Table_sp_ciale_de_rencontres_66ye0OOxBO9LEjdd.yml
+++ b/packs_src/tables-diverses/tables_Table_sp_ciale_de_rencontres_66ye0OOxBO9LEjdd.yml
@ -37,7 +37,7 @@ results:
  - _id: wpUaRAW4HVRM8eOs
    flags: {}
    type: text
-    text: Reflet d’ancien rêve 2d6+4.
+    text: Reflet d’ancien rêve @roll[2d6+4].
    img: systems/foundryvtt-reve-de-dragon/icons/heures/hd06.webp
    weight: 1
    range:
@ -53,7 +53,7 @@ results:
  - _id: tPwuPqShKzWo5jkG
    flags: {}
    type: text
-    text: Tourbillon blanc 2d6+4.
+    text: Tourbillon blanc @roll[2d6+4].
    img: systems/foundryvtt-reve-de-dragon/icons/heures/hd06.webp
    weight: 1
    range:
--- a/packs_src/voyageurs/personnage_le_Haut_R_vant_Erudit_AZBxORb7IYgXaOfb.yml
+++ b/packs_src/voyageurs/personnage_le_Haut_R_vant_Erudit_AZBxORb7IYgXaOfb.yml
@ -3344,7 +3344,8 @@ items:
          indexDate: -1
          indexMinute: 0
      rarete: ''
-      categorie: Alchimie
+      categorie: Remede
+      etat: Liquide
      herbe: ''
      herbebrins: 0
      herbebonus: 0
--- a/styles/simple.css
+++ b/styles/simple.css
@ -67,7 +67,8 @@

 /* =================== 3. some constants ============ */
  --color-controls:rgba(0, 0, 0, 0.9);
-  --color-controls-hover:rgba(255, 255, 128, 0.7);
+  --color-controls-light:hsla(0, 0%, 20%, 0.8);
+  --color-controls-hover:hsla(60, 100%, 75%, 0.7);
  --color-control-border-hover:rgba(255, 128, 0, 0.8);
  --color-gold: rgba(191, 149, 63, 0.8);
  --gradient-gold: linear-gradient(30deg, rgba(191, 149, 63, 0.3), rgba(252, 246, 186, 0.3), rgba(179, 135, 40, 0.3), rgba(251, 245, 183, 0.3), rgba(170, 119, 28, 0.3));
@ -391,9 +392,7 @@ table {border: 1px solid #7a7971;}
  grid-template-columns: repeat(12, minmax(0, 1fr));
 }

-.flex-group-center,
-.flex-group-left,
-.flex-group-right {
+.flex-group-center {
  -webkit-box-pack: center;
  -ms-flex-pack: center;
  justify-content: center;
@ -405,8 +404,11 @@ table {border: 1px solid #7a7971;}
 }

 .flex-group-left {
+  -webkit-box-align: start;
  -webkit-box-pack: start;
+  -ms-flex-align: start;
  -ms-flex-pack: start;
+  align-items: start;
  justify-content: flex-start;
  text-align: left;
 }
@ -417,8 +419,11 @@ table {border: 1px solid #7a7971;}
 }

 .flex-group-right {
+  -webkit-box-align: end;
  -webkit-box-pack: end;
+  -ms-flex-align: end;
  -ms-flex-pack: end;
+  align-items: end;
  justify-content: flex-end;
  text-align: right;
 }
@ -440,9 +445,9 @@ table {border: 1px solid #7a7971;}
 }
 .flex-shrink {
  flex: 'flex-shrink' ;
-  flex-shrink: 2;
+  flex-shrink: 0;
 }
-:is(.flex-grow, .flex-grow-3) {
+.flex-grow, .flex-grow-3 {
  flex-grow: 3;
 }
 .flex-grow-2 {
@ -462,7 +467,7 @@ table {border: 1px solid #7a7971;}
  text-align: left;
 }
 .equipement-nom {
-  flex-grow : 4;
+  flex-grow : 3;
  margin: 0;
  justify-content: center;
  text-align: left;
@ -493,12 +498,13 @@ span.equipement-detail-buttons {
  justify-content: center;
  text-align: center;
 }
+.item-actions-controls,
 .equipement-actions {
  margin: 0;
  flex-grow: 2;
-  align-items: center;
-  justify-content: center;
-  text-align: left;
+  align-items: end;
+  justify-content: flex-end;
+  text-align: right;
 }

 .blessure-control {
@ -813,16 +819,21 @@ input:is(.blessure-premiers_soins, .blessure-soins_complets) {
  margin: 0;
 }

-.competence-list .item-controls {
+.competence-list .item-controls,
+.competence-list .item-actions-controls {
  display: contents !important;
 }
+.competence-list .item-actions-controls.hidden-controls,
 .competence-list .item-controls.hidden-controls {
  display: none !important;
 }
+
+.item-actions-controls a.actionItem i:is(.fas, .fa, .fa-solid, .fa-regular),
 .item-controls i:is(.fas, .fa, .fa-solid, .fa-regular) {
  font-size: 0.8em;
-  color: var(--color-controls);
+  color: var(--color-controls-light);
 }
+.item-actions-controls a.actionItem i:is(.fas, .fa, .fa-solid, .fa-regular):hover,
 .item-controls i:is(.fas, .far, .fa-solid, .fa-regular):hover {
  opacity: 0.6;
 }
@ -1050,6 +1061,10 @@ a.content-link {
  white-space: nowrap;
  word-break: break-all;
 }
+a.roll-text i.fas{
+  color: var(--color-text-dark-inactive);
+  margin-right: 0.25em;
+}


 li label.compteur {
@ -1084,25 +1099,29 @@ li label.compteur {
  padding: 0.25rem;
 }

-.window-app.sheet .window-content .carac-value, .window-app.sheet .window-content .competence-xp {
+.window-app.sheet .window-content .carac-value,
+.window-app.sheet .window-content .competence-xp {
  flex-grow: 0;
  margin: 0.05rem;
  flex-basis: 2rem;
  text-align: center;
 }
-.window-app.sheet .window-content .carac-value, .window-app.sheet .window-content .competence-value {
+.window-app.sheet .window-content .carac-value,
+.window-app.sheet .window-content .competence-value {
  flex-grow: 0;
  margin: 0.05rem;
  flex-basis: 2rem;
  text-align: center;
 }
-.window-app.sheet .window-content .carac-value, .window-app.sheet .window-content .competence-archetype {
+.window-app.sheet .window-content .carac-value,
+.window-app.sheet .window-content .competence-archetype {
  flex-grow: 0;
  margin: 0.05rem;
  flex-basis: 2rem;
  text-align: center;
 }
-.window-app.sheet .window-content .carac-value, .window-app.sheet .window-content .competence-xp-sort {
+.window-app.sheet .window-content .carac-value,
+.window-app.sheet .window-content .competence-xp-sort {
  flex-grow: 0;
  margin: 0.05rem;
  flex-basis: 2rem;
@ -1192,6 +1211,9 @@ ul.chat-list li:nth-child(odd) {
 .item-controls i.fas.allouer-stress.level-up {
  color: var(--color-gold);
 }
+.item-action-controls i.fa-solid.allouer-stress.level-up {
+  color: var(--color-gold);
+}
 .blessures-list ul {
  display: flex;
 }
@ -1308,21 +1330,11 @@ div.competence-column div.categorie-competence{
  font-weight: bold;
  flex-grow: 0;
 }
-.arme-label,
-.generic-label,
-.competence-label,
 .astrologie-label,
-.tache-label,
+.generic-label,
 .subacteur-label,
-.chant-label,
-.musique-label,
-.oeuvre-label,
-.chant-label,
-.danse-label,
-.recette-label,
-.jeu-label,
-.recettecuisine-label,
-.description-label {
+.list-item-label,
+.list-title-label {
  flex-grow: 2;
 }
 .attribut-value,
--- a/template.json
+++ b/template.json
@ -589,6 +589,13 @@
          }
        }
      },
+      "enchantable": {
+        "magique": false,
+        "pr": 0,
+        "purifie": false,
+        "prpermanent": false,
+        "prdate": 0
+      },
      "equipement": {
        "equipe": false
      },
@ -739,7 +746,7 @@
      "templates": ["description", "inventaire"]
    },
    "gemme": {
-      "templates": ["description", "inventaire"],
+      "templates": ["description", "enchantable", "inventaire", "temporel"],
      "type": "",
      "taille": 0,
      "purete": 0,
@ -795,16 +802,14 @@
      "niveau_maximum": 0
    },
    "potion": {
-      "templates": ["description", "inventaire", "temporel"],
+      "templates": ["description", "enchantable", "inventaire", "temporel"],
      "rarete": "",
      "categorie": "",
+      "etat": "",
      "herbe": "",
      "herbebrins": 0,
      "herbebonus": 0,
-      "reposalchimique": false,
-      "pr": 0,
-      "prpermanent": false,
-      "prdate": 0
+      "reposalchimique": false
    },
    "service": {
      "templates": ["description", "inventaire"],
@ -901,7 +906,7 @@
          "value": 0
        }
      },
-      "attributs":{
+      "attributs": {
        "protection": {
          "value": 0
        }
@ -948,7 +953,8 @@
      "xp": 0,
      "bonuscase": "",
      "isrituel": false,
-      "coutseuil": 0
+      "coutseuil": 0,
+      "lancements": []
    },
    "sortreserve": {
      "sortid": "",
--- a/templates/actor-creature-sheet.html
+++ b/templates/actor-creature-sheet.html
@ -53,7 +53,7 @@
          </ul>
        </div>
        <div class="flex-group-left flexcol competence-column">
-          {{>"systems/foundryvtt-reve-de-dragon/templates/actor/comp-creature.html"}}
+          {{>"systems/foundryvtt-reve-de-dragon/templates/actor/comp-creature.hbs"}}
        </div>
      </div>

@ -62,7 +62,7 @@

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

--- a/templates/actor-entite-sheet.html
+++ b/templates/actor-entite-sheet.html
@ -40,8 +40,8 @@
        </div>
        <div class="flex-group-left flexcol">
          <div class="flex-group-left flexcol competence-column">
-            {{>"systems/foundryvtt-reve-de-dragon/templates/actor/comp-creature.html"}}
-            {{>"systems/foundryvtt-reve-de-dragon/templates/actor/comp-possession.html"}}
+            {{>"systems/foundryvtt-reve-de-dragon/templates/actor/comp-creature.hbs"}}
+            {{>"systems/foundryvtt-reve-de-dragon/templates/actor/comp-possession.hbs"}}
          </div>
          <div>
            {{>"systems/foundryvtt-reve-de-dragon/templates/actor/resonances.hbs"}}
--- a/templates/actor-sheet.html
+++ b/templates/actor-sheet.html
@ -111,19 +111,19 @@
      <div class="tab combat" data-group="primary" data-tab="combat">
        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/combat.html"}}<hr>
        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/blessures.html"}}
-        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/maladies-poisons.html"}}
-        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/possessions.html"}}
+        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/maladies-poisons.hbs"}}
+        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/possessions.hbs"}}
      </div>
      {{/if}}

      {{#if options.isObserver}}{{!-- Connaissances Tab --}}
      <div class="tab connaissances" data-group="primary" data-tab="connaissances">
        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/astrologie.html"}}
-        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/taches.html"}}
-        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/chirurgie.html"}}
-        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/oeuvres.html"}}
-        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/jeux.html"}}
-        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/alchimie.html"}}
+        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/taches.hbs"}}
+        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/chirurgie.hbs"}}
+        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/oeuvres.hbs"}}
+        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/jeus.hbs"}}
+        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/alchimie.hbs"}}
      </div>
      {{/if}}
      {{#if options.isObserver}}{{!-- hautreve Tab --}}
@ -143,7 +143,7 @@

      {{!-- Equipment Tab --}}
      <div class="tab items" data-group="primary" data-tab="items">
-        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-monnaie.html"}}
+        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-monnaie.hbs"}}
        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire.html"}}
        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/liens-animaux.hbs"}}
        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/liens-vehicules.hbs"}}
--- a/templates/actor-vehicule-sheet.html
+++ b/templates/actor-vehicule-sheet.html
@ -91,7 +91,7 @@

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

--- a/templates/actor/alchimie.hbs
+++ b/templates/actor/alchimie.hbs
@ -0,0 +1,11 @@
+{{#if recettealchimiques.length}}
+<h3>Recettes Alchimiques</h3>
+<ul class="item-list alterne-list">
+  {{#each (trier recettealchimiques) as |recette id|}}
+  <li class="item flexrow list-item" data-item-id="{{recette._id}}">
+    <span class="list-item-label"><a class="item-edit">{{recette.name}}</a></span>
+    {{>'systems/foundryvtt-reve-de-dragon/templates/actor/item-action-controls.hbs' item=recette options=@root.options}}
+  </li>
+  {{/each}}
+</ul>
+{{/if}}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
uberwald	24518642a7	Merge pull request '12.0.37 - Les enchantements d'Astrobazzarh' (#742 ) from VincentVk/foundryvtt-reve-de-dragon:v11 into v11 All checks were successful Release Creation / build (release) Successful in 1m38s Details Reviewed-on: #742	2025-01-21 09:37:15 +01:00
Vincent Vandemeulebrouck	d917f80e88	Enchantement des gemmes et potions	2025-01-21 03:11:47 +01:00
Vincent Vandemeulebrouck	b29027c61a	Cleanup	2025-01-21 03:08:11 +01:00
Vincent Vandemeulebrouck	6083dd41fa	Amélioration du split Bouton split géré avec itemActions Ajout d'un bouton pour augmenter les piles (pour le MJ)	2025-01-21 03:08:11 +01:00
uberwald	8969d5e0ed	Merge pull request '12.0.36 - L'alchimie d'Astrobazzarh' (#740 ) from VincentVk/foundryvtt-reve-de-dragon:v11 into v11 All checks were successful Release Creation / build (release) Successful in 1m22s Details Reviewed-on: #740	2025-01-19 09:50:20 +01:00
Vincent Vandemeulebrouck	7d135a214f	Version 12.0.36	2025-01-19 01:21:12 +01:00
Vincent Vandemeulebrouck	9d66a479c4	Heures des Queues lors de la nuit L'heure des queues ajoutées à fin chateau dormant sont maintenant décalées d'une minute dans le passé pour s'appliquer correctement 12 heures draconiques à partir de vaisseau (et non pas	2025-01-19 01:17:57 +01:00
Vincent Vandemeulebrouck	800b4a2f32	Remove unused import	2025-01-19 00:49:58 +01:00
Vincent Vandemeulebrouck	9fc21e6d97	Gestion des actions sur les items - dans la liste d'équipement, liste d'actions fournie par code - support d'actions multiples - listener générique Utilisation du mécanisme pour tous les items, standardisation de l'apparence des boutons d'items	2025-01-19 00:38:24 +01:00
Vincent Vandemeulebrouck	ce7f5381ca	Fix update endurance/vie Dans certains cas, les valeurs de vie/endurance n'étaient pas mises à jour	2025-01-18 23:13:40 +01:00
Vincent Vandemeulebrouck	48acdaaca6	Fix bouton tchat jet encaissement	2025-01-18 23:13:40 +01:00
Vincent Vandemeulebrouck	425c6af672	Correction ouverture feuille de conteneur	2025-01-18 14:49:44 +01:00
Vincent Vandemeulebrouck	4281f76dfb	Simplification des actionPrincipales Préparation pour supporter une liste d'actions sur les items	2025-01-18 14:49:44 +01:00
Vincent Vandemeulebrouck	8ebd6ec771	Normalisation des listes d'items Utiliser le type d'Item + 's'	2025-01-18 14:49:44 +01:00
Vincent Vandemeulebrouck	14391daa0b	Simplification monnaies Note: bug étrange causé par la 12.0.34, mais le code était bon	2025-01-18 14:49:43 +01:00
Vincent Vandemeulebrouck	ac29e1410e	Correction de remedes enchantables Les remedes ne sont pas enchantable, changement en Alchimie	2025-01-18 14:49:43 +01:00
Vincent Vandemeulebrouck	442ffe9b3a	Ajout de jets aux descriptions	2025-01-18 14:49:43 +01:00
Vincent Vandemeulebrouck	d922e4fdd5	Move type constants Prevent problems of circular dependencies when sepating actions from items & sheets	2025-01-18 14:49:42 +01:00
Vincent Vandemeulebrouck	a8dc07b4db	Enchanter des Potions	2025-01-18 14:49:42 +01:00
Vincent Vandemeulebrouck	40a47ee8a2	Ajout du symbole d20, pour les roll de formule	2025-01-14 22:24:20 +01:00
Vincent Vandemeulebrouck	c5633a9fc5	Fix commande /tmra	2025-01-14 22:23:35 +01:00