changelog.md

@@ -1,10 +1,4 @@
 # 12.0
-## 12.0.36 - La cartte d'Astrobazzarh
-- Fix: la commande /tmra fonctionne correctement sans paramètres
-
-## 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, ...

module/actor-sheet.js

@@ -12,8 +12,7 @@ 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 } from "./constants.js";
+import { ITEM_TYPES, RdDItem } from "./item.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";
@@ -185,19 +184,22 @@ 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('.action-tache').click(async event => this.actor.rollTache(RdDSheetUtility.getItemId(event)))
+    this.html.find('.tache-label a').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('.action-chant').click(async event => this.actor.rollChant(RdDSheetUtility.getItemId(event)))
+    this.html.find('.chant-label a').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('.danse-label a').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('.musique-label a').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('.oeuvre-label a').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('.jeu-label a').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('.recettecuisine-label a').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) {
@@ -215,12 +217,13 @@ 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('.action-empoignade').click(async event => RdDEmpoignade.onAttaqueEmpoignadeFromItem(RdDSheetUtility.getItem(event, this.actor)))
+    this.html.find('.empoignade-label a').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'))
 
@@ -324,7 +327,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
   /* -------------------------------------------- */
   async selectTypeOeuvreToCreate() {
     let types = RdDItem.getTypesOeuvres();
-    let content = `<span class="generic-label">Selectionnez le type d'oeuvre</span><select class="item-type">`;
+    let content = `<span class="competence-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>`
     }

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 "./constants.js";
+import { ITEM_TYPES } from "./item.js";
 import { RdDBaseActorSang } from "./actor/base-actor-sang.js";
 import { RdDCoeur } from "./coeur/rdd-coeur.js";
 import { DialogChoixXpCarac } from "./dialog-choix-xp-carac.js";
@@ -167,22 +167,28 @@ export class RdDActor extends RdDBaseActorSang {
 
   /* -------------------------------------------- */
   async $perteRevePotionsEnchantees() {
-    const potionUpdates = this.itemTypes[ITEM_TYPES.potion].map(it => it.perteRevePotion())
+    let potions = this.itemTypes[ITEM_TYPES.potion]
-      .filter(it => it != undefined)
+      .filter(it => Grammar.includesLowerCaseNoAccent(it.system.categorie, 'enchanté') && !it.system.prpermanent)
-    if (potionUpdates.length > 0) {
+
-      console.log('perte rêve de potions', potionUpdates)
+    const potionUpdates = await Promise.all(potions.map(async it => {
-      const messageUpdates = await Promise.all(potionUpdates.map(async p => await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-potionenchantee-chateaudormant.html`, {
+      const nouveauReve = Math.max(it.system.pr - 1, 0)
-        pr: foundry.utils.getProperty(p, 'system.pr'),
-        alias: this.getAlias(),
-        potionName: p.name,
-        potionImg: p.img
-      })))
       ChatMessage.create({
         whisper: ChatUtility.getOwners(this),
-        content: messageUpdates.reduce(Misc.joining('<br>'))
+        content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-potionenchantee-chateaudormant.html`, {
+          pr: nouveauReve,
+          alias: this.getAlias(),
+          potionName: it.name,
+          potionImg: it.img
+        })
       })
-      await this.updateEmbeddedDocuments('Item', potionUpdates);
+      return {
-    }
+        _id: it._id,
+        'system.pr': nouveauReve,
+        'system.quantite': nouveauReve > 0 ? it.system.quantite : 0
+      }
+    }))
+
+    await this.updateEmbeddedDocuments('Item', potionUpdates);
   }
 
   /** --------------------------------------------
@@ -239,7 +245,7 @@ export class RdDActor extends RdDBaseActorSang {
   }
 
   async _recuperationSante(message) {
-    const maladiesPoisons = this.getMaladiesPoisons();
+    const maladiesPoisons = this.getMaladiePoisons();
     const isMaladeEmpoisonne = maladiesPoisons.length > 0;
     this._messageRecuperationMaladiePoisons(maladiesPoisons, message);
 
@@ -247,7 +253,7 @@ export class RdDActor extends RdDBaseActorSang {
     await this._recupererVie(message, isMaladeEmpoisonne);
   }
 
-  getMaladiesPoisons() {
+  getMaladiePoisons() {
     return this.items.filter(item => item.type == 'maladie' || (item.type == 'poison' && item.system.active));
   }
 
@@ -407,18 +413,19 @@ export class RdDActor extends RdDBaseActorSang {
 
   /* -------------------------------------------- */
   async remiseANeuf() {
-    await this.update({
+    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 = {
       '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.removeEffects(e => e.id != STATUSES.StatusDemiReve);
+    await this.update(updates);
-    await this.supprimerBlessures(it => true);
-    await ChatMessage.create({
-      whisper: ChatUtility.getOwners(this),
-      content: 'Remise à neuf de ' + this.name
-    });
   }
 
   /* -------------------------------------------- */
@@ -522,7 +529,7 @@ export class RdDActor extends RdDBaseActorSang {
         jet_moral: false,
         value: value
       }
-    })
+    });
   }
 
   /* -------------------------------------------- */
@@ -986,10 +993,13 @@ export class RdDActor extends RdDBaseActorSang {
     }
   }
 
-  async addSortReserve(item) {
+  async addSortReserve(itemId) {
-    if (item?.type == ITEM_TYPES.sort && !item.system.isrituel) {
+    if (itemId) {
-      this.$createSortReserve(item)
+      const item = this.items.get(itemId)
-      return
+      if (item.type == ITEM_TYPES.sort && !item.system.isrituel) {
+        this.$createSortReserve(item)
+        return
+      }
     }
     const selectSortReserve = {
       title: "Créer un sort en réserve",
@@ -1193,6 +1203,42 @@ 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);
   }
@@ -1845,8 +1891,8 @@ export class RdDActor extends RdDBaseActorSang {
     }
     rollData.tache.system.tentatives = rollData.tache.system.nb_jet_succes + rollData.tache.system.nb_jet_echec;
 
-    await this.updateEmbeddedDocuments('Item', [rollData.tache]);
+    this.updateEmbeddedDocuments('Item', [rollData.tache]);
-    await this.santeIncDec("fatigue", rollData.tache.system.fatigue);
+    this.santeIncDec("fatigue", rollData.tache.system.fatigue);
 
     await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-tache.html');
     if (options?.onRollAutomate) {
@@ -2524,7 +2570,8 @@ export class RdDActor extends RdDBaseActorSang {
   }
 
   /* -------------------------------------------- */
-  async equiperObjet(item) {
+  async equiperObjet(itemID) {
+    let item = this.getEmbeddedDocument('Item', itemID);
     if (item?.isEquipable()) {
       const isEquipe = !item.system.equipe;
       await item.update({ "system.equipe": isEquipe });
@@ -2543,7 +2590,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") {
-        await armure.deteriorerArmure(dmg)
+        armure.deteriorerArmure(dmg);
         dmg = 0;
       }
     }

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 "../constants.js";
+import { ITEM_TYPES } from "../item.js";
 import { RdDSheetUtility } from "../rdd-sheet-utility.js";
 import { RdDBaseActorSheet } from "./base-actor-sheet.js";
 

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 "../constants.js";
+import { ITEM_TYPES } from "../item.js";
 import { RdDItemCompetence } from "../item-competence.js";
 import { RdDItemCompetenceCreature } from "../item-competencecreature.js";
 import { RdDItemArme } from "../item-arme.js";

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 "../constants.js";
+import { ITEM_TYPES } from "../item.js";
 import { RdDBaseActorReve } from "./base-actor-reve.js";
 import { RdDDice } from "../rdd-dice.js";
 import { RdDItemBlessure } from "../item/blessure.js";

module/actor/base-actor-sheet.js

@@ -3,11 +3,9 @@ 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 { ITEM_TYPES } from "../constants.js";
+import { RdDItem, ITEM_TYPES } from "../item.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";
 
 /* -------------------------------------------- */
 /**
@@ -28,7 +26,7 @@ export class RdDBaseActorSheet extends ActorSheet {
 
   /* -------------------------------------------- */
   async getData() {
-    Monnaie.validerMonnaies(this.actor)
+    Monnaie.validerMonnaies(this.actor.itemTypes['monnaie']);
 
     this.actor.computeEtatGeneral();
     let formData = {
@@ -44,7 +42,7 @@ export class RdDBaseActorSheet extends ActorSheet {
       effects: this.actor.effects
     }
 
-    RdDUtility.filterItemsPerTypeForSheet(formData, this.actor.itemTypes);
+    RdDBaseActorSheet.filterItemsPerTypeForSheet(formData, this.actor.itemTypes);
     formData.calc = {
       fortune: Monnaie.toSolsDeniers(this.actor.getFortune()),
       prixTotalEquipement: this.actor.computePrixTotalEquipement(),
@@ -56,7 +54,6 @@ 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;
   }
 
@@ -80,37 +77,95 @@ 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))
+      RdDUtility.toggleAfficheContenu(this.getItemId(event));
-      this.render(true)
+      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))
+      .change(async event => this._rechercherKeyup(event));
-
+    this.html.find('.recherche').prop("disabled", false);
-    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-equip-armure').click(async event => this.actor.equiperObjet(this.getItem(event)))
+    this.html.find('.item-action').click(async event => {
-    this.html.find('.item-delete').click(async event => RdDUtility.confirmActorItemDelete(this.getItem(event), this.actor));
+      const item = RdDSheetUtility.getItem(event, this.actor);
-    this.html.find('.item-split').click(async event => RdDSheetUtility.splitItem(this.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-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();
@@ -125,11 +180,6 @@ 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);
@@ -196,7 +246,7 @@ export class RdDBaseActorSheet extends ActorSheet {
   /* -------------------------------------------- */
   async selectObjetTypeToCreate() {
     let types = this.getTypesInventaire().sort(Misc.ascending(type => Misc.typeName('Item', type)));
-    let content = `<span class="generic-label">Selectionnez le type d'équipement</span><select class="item-type">`;
+    let content = `<span class="competence-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>`
     }

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 "../constants.js";
+import { ITEM_TYPES } from "../item.js";
 import { Misc } from "../misc.js";
 import { RdDAudio } from "../rdd-audio.js";
 import { RdDConfirm } from "../rdd-confirm.js";
@@ -737,20 +737,25 @@ 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]

module/actor/commerce-sheet.js

@@ -45,7 +45,6 @@ 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;
 

module/actor/creature.js

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

module/actor/entite.js

@@ -1,5 +1,5 @@
 import { ENTITE_INCARNE, ENTITE_NONINCARNE } from "../constants.js";
-import { ITEM_TYPES } from "../constants.js";
+import { ITEM_TYPES } from "../item.js";
 import { Misc } from "../misc.js";
 import { RdDCarac } from "../rdd-carac.js";
 import { RdDEncaisser } from "../rdd-roll-encaisser.js";

module/actor/export-scriptarium/actor-encart-sheet.js

@@ -6,8 +6,8 @@ import { ExportScriptarium } from "./export-scriptarium.js";
 import { CATEGORIES_COMPETENCES, CATEGORIES_DRACONIC, Mapping } from "./mapping.js";
 
 export class RdDActorExportSheet extends RdDActorSheet {
-  static init() {
+  static async init() {
-    loadTemplates([
+    await loadTemplates([
       "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/arme.hbs",
       "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessure.hbs",
       "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessures.hbs",
@@ -23,7 +23,6 @@ export class RdDActorExportSheet extends RdDActorSheet {
     ])
     Actors.registerSheet(SYSTEM_RDD, RdDActorExportSheet, { types: ["personnage"], makeDefault: false, label: "Feuille simplifiée" })
   }
-
   static get defaultOptions() {
     return foundry.utils.mergeObject(RdDActorSheet.defaultOptions, {
       template: "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/actor-encart-sheet.hbs",

module/actor/export-scriptarium/export-scriptarium.js

@@ -1,4 +1,4 @@
-import { ACTOR_TYPES } from "../../constants.js"
+import { ACTOR_TYPES } from "../../item.js"
 import { Misc } from "../../misc.js"
 import { EXPORT_CSV_SCRIPTARIUM, OptionsAvancees } from "../../settings/options-avancees.js"
 import { Mapping } from "./mapping.js"

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 "../../constants.js"
+import { ITEM_TYPES } from "../../item.js"
 import { Misc } from "../../misc.js"
 import { RdDTimestamp } from "../../time/rdd-timestamp.js"
 import { RdDBonus } from "../../rdd-bonus.js"

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 "../constants.js";
+import { ITEM_TYPES } from "../item.js";
 
 const WHITESPACES = "\\s+"
 const NUMERIC = "[\\+\\-]?\\d+"

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 "../constants.js";
+import { ACTOR_TYPES } from "../item.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";

module/apps/textroll/text-roll-alchimie.js

@@ -1,5 +1,5 @@
 import "../xregexp-all.js";
-import { ACTOR_TYPES, ITEM_TYPES } from "../../constants.js";
+import { ACTOR_TYPES, ITEM_TYPES } from "../../item.js";
 import { RdDCarac } from "../../rdd-carac.js";
 import { RdDUtility } from "../../rdd-utility.js";
 import { RdDAlchimie } from "../../rdd-alchimie.js";

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('formula')
+    const rollFormula = node.data('roll-formula')
     if (rollFormula) {
       const roll = new Roll(rollFormula)
       await roll.evaluate()

module/constants.js

@@ -50,59 +50,4 @@ 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',
-}

module/item-arme.js

@@ -1,6 +1,6 @@
 import { Grammar } from "./grammar.js";
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js"
-import { ITEM_TYPES } from "./constants.js";
+import { ITEM_TYPES } from "./item.js";
 import { BASE_CORPS_A_CORPS } from "./item/base-items.js";
 import { RdDCombatManager } from "./rdd-combat.js";
 

module/item-competencecreature.js

@@ -1,5 +1,5 @@
 
-import { ITEM_TYPES } from "./constants.js";
+import { ITEM_TYPES } from "./item.js";
 import { RdDCombatManager } from "./rdd-combat.js";
 
 export const CATEGORIES_COMPETENCES_CREATURES = {

module/item-monnaie.js

@@ -1,5 +1,5 @@
 import { Misc } from "./misc.js";
-import { ITEM_TYPES, LOG_HEAD } from "./constants.js";
+import { LOG_HEAD } from "./constants.js";
 
 const MONNAIE_ETAIN = {
   name: "Denier (étain)", type: 'monnaie',
@@ -70,17 +70,18 @@ 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);
-    const updates = []
+    let monnaies = actor.itemTypes['monnaie'];
+    let updates = [];
+    Monnaie.validerMonnaies(monnaies, actor);
 
-    const  parValeur = Misc.classifyFirst(actor.itemTypes[ITEM_TYPES.monnaie], it => VALEUR_DENIERS(it.system.cout));
+    let parValeur = Misc.classifyFirst(monnaies, it => VALEUR_DENIERS(it.system.cout));
     for (let valeurDeniers of [1000, 100, 10, 1]) {
       const itemPiece = parValeur[valeurDeniers];
       if (itemPiece) {
@@ -101,11 +102,8 @@ export class Monnaie {
     }
   }
 
-  static validerMonnaies(actor) {
+  static validerMonnaies(monnaies, actor = undefined) {
-    if (!actor) {
+    monnaies.filter(it => VALEUR_DENIERS(it.system.cout) == 0)
-      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);

module/item-sheet.js

@@ -1,7 +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";
@@ -11,10 +11,9 @@ 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 { RdDItem } from "./item.js";
+import { ACTOR_TYPES, ITEM_TYPES, 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";
 
 /**
  * Extend the basic ItemSheet for RdD specific items
@@ -27,8 +26,8 @@ export class RdDItemSheet extends ItemSheet {
 
   static defaultTemplate(type) {
     return type ?
-      `systems/foundryvtt-reve-de-dragon/templates/item/${type}-sheet.hbs` :
+      `systems/foundryvtt-reve-de-dragon/templates/item-${type}-sheet.html` :
-      "systems/foundryvtt-reve-de-dragon/templates/item/item-sheet.hbs";
+      "systems/foundryvtt-reve-de-dragon/templates/item-sheet.html";
   }
 
   static register(sheetClass) {
@@ -137,7 +136,9 @@ export class RdDItemSheet extends ItemSheet {
       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;
@@ -192,7 +193,16 @@ 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('input[name="system.cacher_points_de_tache"]').change(async event => await this.item.update({ 'system.cacher_points_de_tache': event.currentTarget.checked }));
 
@@ -200,14 +210,12 @@ export class RdDItemSheet extends ItemSheet {
     this.html.find('.chat-roll-text').click(async event => await RdDTextEditor.chatRollText(event))
 
     if (this.actor) {
-      // TODO
+      this.html.find('.item-split').click(async event => RdDSheetUtility.splitItem(RdDSheetUtility.getItem(event, this.actor), this.actor, this.getActionRenderItem()));
-      this.html.find('.actionItem').click(event => ItemAction.onActionItem(event, this.actor, this.options))
-
-      this.html.find('.item-potion-consommer').click(event => this.itemActionConsommer(event))
-
-      this.html.find('.item-split').click( event => this.itemActionSplit(event))
       this.html.find('.item-edit').click(async event => RdDSheetUtility.getItem(event, this.actor)?.sheet.render(true));
-      this.html.find('.item-delete').click(async event => this.itemActionDelete(event));
+      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('.item-quantite-plus').click(async event => {
         await this.actor.itemQuantiteIncDec(RdDSheetUtility.getItemId(event), 1)
@@ -225,24 +233,13 @@ export class RdDItemSheet extends ItemSheet {
     RdDTimestamp.handleTimestampEditor(this.html, 'system.temporel.fin', updateItemTimestamp);
   }
 
-  itemActionDelete(event) {
+  getActionRenderItem() {
-    const item = RdDSheetUtility.getItem(event, this.actor)
+    return async () => {
-    return RdDUtility.confirmActorItemDelete(item, this.actor)
+      let item = this.item;
-  }
+      while (item) {
-
+        await item.sheet?.render()
-  async itemActionConsommer(event) {
+        item = this.actor.getContenant(item)
-    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)
     }
   }
 

module/item-sort.js

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

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,7 +9,61 @@ 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";
-import { ITEM_ACTIONS, DEFAULT_ACTIONS, COMMON_ACTIONS } from "./item/item-actions.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',
+}
 
 const typesInventaireMateriel = [
   ITEM_TYPES.arme,
@@ -46,41 +100,41 @@ densité 3.5 (~2.3 à 4, parfois plus) -- https://www.juwelo.fr/guide-des-pierre
    */
 
 export const defaultItemImg = {
-  arme: "systems/foundryvtt-reve-de-dragon/icons/armes_armures/epee_gnome.webp",
-  armure: "systems/foundryvtt-reve-de-dragon/icons/armes_armures/armure_plaques.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",
+  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",
-  danse: "systems/foundryvtt-reve-de-dragon/icons/arts/danse_0.webp",
+  sort: "systems/foundryvtt-reve-de-dragon/icons/competence_oniros.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",
+  faune: "systems/foundryvtt-reve-de-dragon/icons/faune/rongeur.webp",
   ingredient: "systems/foundryvtt-reve-de-dragon/icons/objets/sable_poudre.webp",
-  jeu: "systems/foundryvtt-reve-de-dragon/icons/arts/jeux_petasse.webp",
   livre: "systems/foundryvtt-reve-de-dragon/icons/objets/livre.webp",
-  maladie: "systems/foundryvtt-reve-de-dragon/icons/maladies_venins/maladie.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",
+  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",
+  danse: "systems/foundryvtt-reve-de-dragon/icons/arts/danse_0.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",
+  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",
+  nourritureboisson: "systems/foundryvtt-reve-de-dragon/icons/objets/provision_crue.webp",
   service: "systems/foundryvtt-reve-de-dragon/icons/services/lit.webp",
   signedraconique: "systems/foundryvtt-reve-de-dragon/icons/tmr/signe_draconique.webp",
-  sort: "systems/foundryvtt-reve-de-dragon/icons/competence_oniros.webp",
+  gemme: "systems/foundryvtt-reve-de-dragon/icons/gemmes/almaze.webp",
+  possession: "systems/foundryvtt-reve-de-dragon/icons/entites/possession2.webp",
   sortreserve: "systems/foundryvtt-reve-de-dragon/icons/competence_oniros.webp",
-  souffle: "systems/foundryvtt-reve-de-dragon/icons/souffle_dragon.webp",
+  extraitpoetique: "systems/foundryvtt-reve-de-dragon/icons/competence_ecriture.webp",
   tarot: "systems/foundryvtt-reve-de-dragon/icons/tarots/dos-tarot.webp",
-  tete: "systems/foundryvtt-reve-de-dragon/icons/tete_dragon.webp",
+  empoignade: "systems/foundryvtt-reve-de-dragon/icons/competence_corps_a_corps.webp"
 }
 
 /* -------------------------------------------- */
@@ -302,6 +356,13 @@ 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) {
@@ -410,51 +471,68 @@ 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()
+      this.system.encTotal = this.getEncTotal();
+      if (this.isPotion()) {
+        this.prepareDataPotion()
+      }
+      this.system.actionPrincipale = this.getActionPrincipale({ warnIfNot: false });
     }
-    this.equipable = this.isEquipable()
+    this.equipable = this.isEquipable();
   }
 
-  itemActions() {
+  prepareDataPotion() {
-    return COMMON_ACTIONS.concat(this.itemSpecificActions()).concat(DEFAULT_ACTIONS)
+    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);
+      }
+    }
   }
 
-  itemSpecificActions() {
+  getActionPrincipale(options = { warnIfNot: true }) {
-    const actions = ITEM_ACTIONS[this.type] ?? []
-    // const actorTypes = actions.actorTypes ?? [ACTOR_TYPES.personnage]
-    // if (!actorTypes.includes(this.actor?.type)) {
-    //   return []
-    // }
-    return actions
-  }
-
-  isActionAllowed(code) {
     switch (this.type) {
-      case ITEM_TYPES.possession:
+      case ITEM_TYPES.conteneur: return 'Ouvrir';
-      case ITEM_TYPES.empoignade:
+    }
-      case ITEM_TYPES.rencontre:
+    if (this.actor?.isPersonnage()) {
-      case ITEM_TYPES.signedraconique:
+      const warn = options.warnIfNot;
-        switch (code) {
+      if (this.getUtilisationCuisine() == 'brut') {
-          case 'item-edit':
+        return 'Cuisiner';
-          case 'item-delete':
+      }
-            return game.user.isGM
+      switch (this.type) {
-        }
+        case ITEM_TYPES.nourritureboisson: return this._actionOrWarnQuantiteZero(this.system.boisson ? 'Boire' : 'Manger', warn);
-      case ITEM_TYPES.maladie:
+        case ITEM_TYPES.potion: return this._actionOrWarnQuantiteZero('Consommer', warn);
-      case ITEM_TYPES.poison:
+        case ITEM_TYPES.livre: return this._actionOrWarnQuantiteZero('Lire', warn);
-        return game.user.isGM
+        case ITEM_TYPES.herbe: return this.isHerbeAPotion() ? this._actionOrWarnQuantiteZero('Décoction', warn) : undefined;
-      case ITEM_TYPES.casetmr:
+        case ITEM_TYPES.queue: case ITEM_TYPES.ombre: return this.system.refoulement > 0 ? 'Refouler' : undefined;
-        switch (code) {
+      }
-          case 'item-delete':
+    }
-            return game.user.isGM
+    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;
     }
-    return true
   }
 
   async diminuerQuantite(nombre, options = { diminuerQuantite: true, supprimerSiZero: false }) {
@@ -727,6 +805,14 @@ 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) {

module/item/armure.js

@@ -1,5 +1,4 @@
-import { ITEM_TYPES } from "../constants.js";
+import { ITEM_TYPES, RdDItem } from "../item.js";
-import { RdDItem } from "../item.js";
 import { Misc } from "../misc.js";
 import { ReglesOptionnelles } from "../settings/regles-optionnelles.js";
 
@@ -11,7 +10,7 @@ export class RdDItemArmure extends RdDItem {
     return "systems/foundryvtt-reve-de-dragon/icons/armes_armures/armure_plaques.webp";
   }
 
-  async deteriorerArmure(dmg) {
+  deteriorerArmure(dmg) {
     if (!ReglesOptionnelles.isUsing('deteriorationArmure') || this.system.protection == '0') {
       return;
     }
@@ -23,10 +22,12 @@ 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}` });
     }
-    await this.update({
+    this.update({
-      'system.deterioration': deterioration,
+      system: {
-      'system.protection': protection
+        deterioration: deterioration,
-    })
+        protection: protection
+      }
+    });
   }
 
   calculProtectionDeterioree() {

module/item/blessure.js

@@ -30,7 +30,7 @@ export class RdDItemBlessure extends RdDItem {
 
   prepareDerivedData() {
     super.prepareDerivedData();
-    this.system.label = RdDItemBlessure.getLabelGravite(this.system.gravite)
+    this.system.label = this.getLabelGravite()
   }
 
   static prepareTacheSoin(gravite) {
@@ -43,32 +43,29 @@ export class RdDItemBlessure extends RdDItem {
   }
 
   static async applyFullBlessure(actor, gravite) {
-    const definition = foundry.utils.duplicate(RdDItemBlessure.getDefinition(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));
+    }
     if (definition.vie) {
-      await actor.santeIncDec("vie", definition.vie)
+      lostVie = definition.vie
-    }
+      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({
-      //TODO: hbs
+      content: `Blessure ${definition.label} appliquée à ${actor.name}`+
-      content: `Blessure ${definition.label} appliquée à ${actor.name}<br>Perte d'endurance : ${lostEndurance} (${definition.endurance})<br>Perte de Vie : ${definition.vie}`,
+        `<br>Perte d'endurance : ${lostEndurance}`+
+        `<br>Perte de Vie : ${lostVie}`,
       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) {
@@ -128,10 +125,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 gravite = this.system.gravite;
-      const graviteMoindre = gravite - 2
+      const graviteMoindre = gravite - 2;
       const moindres = blessures.filter(it => it.system.gravite == graviteMoindre, 'blessures').length
-      const label = RdDItemBlessure.getLabelGravite(this.system.gravite)
+      const label = this.getLabelGravite();
 
       let rolled = await actor.jetRecuperationConstitution(this.system.soinscomplets.bonus, message);
 
@@ -161,7 +158,7 @@ export class RdDItemBlessure extends RdDItem {
   }
 
   peutRetrograder(graviteMoindre, moindres) {
-    return moindres < RdDItemBlessure.maxBlessures(graviteMoindre)
+    return moindres < RdDItemBlessure.getDefinition(graviteMoindre).max
   }
 
   async calculerFinPeriodeTemporel(debut) {
@@ -185,16 +182,16 @@ export class RdDItemBlessure extends RdDItem {
     return `systems/foundryvtt-reve-de-dragon/icons/sante/${soins ? 'blessure-soins' : img}.webp`
   }
 
-  static getLabelGravite(gravite) {
+  getLabelGravite() {
-    return definitionsBlessures.find(it => it.gravite >= gravite).label
+    return RdDItemBlessure.getDefinition(this.system.gravite).label
   }
 
   static getDefinition(gravite) {
-    return definitionsBlessures.find(it => it.gravite >= gravite)
+    return definitionsBlessures.sort(Misc.ascending(it => it.gravite))
+      .find(it => it.gravite >= gravite);
   }
-
   static maxBlessures(gravite) {
-    return definitionsBlessures.find(it => it.gravite >= gravite).max
+    return RdDItemBlessure.getDefinition(gravite).max
   }
 
   isContusion() {
@@ -219,7 +216,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>: ${this.system.label}`,
+      `<b>Gravité</b>: ${RdDItemBlessure.getDefinition(this.system.gravite).label}`,
       `<b>Difficulté des soins</b>: ${this.system.difficulte}`,
       (this.system.soinscomplets.done ?
         `<b>Bonus soins complets</b>: ${this.system.soinscomplets.bonus}` :

module/item/item-actions.js

@@ -1,154 +0,0 @@
-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 _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.actionHerbe(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 _CONSOMMER_POTION = {
-  code: 'item-potion-consommer', label: 'Consommer', icon: it => 'fa-solid fa-vial',
-  optionsFilter: options => options.editable,
-  action: (item, actor) => actor.consommerPotion(item)
-}
-
-const _ENCHANTER = {
-  code: 'item-enchanter', label: 'Enchanter', icon: it => 'fa-solid fa-sparkles',
-  filter: it => it.isEnchantable(),
-  optionsFilter: options => options.editable,
-  action: (item, actor) => item.enchanterPotion()
-}
-
-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, _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],
-  potion: [_CONSOMMER_POTION, _ENCHANTER],
-  queue: [_REFOULER],
-  sort: [_SORT_RESERVE],
-  service: [_ACHAT_SERVICE]
-}
-
-
-export class ItemAction {
-
-  static applies(action, item, options) {
-    return action
-      && 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)
-    }
-  }
-}

module/item/potion.js

@@ -1,154 +0,0 @@
-import { ITEM_TYPES } from "../constants.js";
-import { Grammar } from "../grammar.js";
-import { RdDItem } from "../item.js";
-import { SystemCompendiums } from "../settings/system-compendiums.js";
-import { ITEM_ACTIONS } from "./item-actions.js";
-import { DialogEnchanter } from "./potion/dialog-enchanter.js";
-
-const POTION_MAGIQUE = ['AlchimieEnchante', 'ReposEnchante', 'SoinEnchante', 'AutreEnchante']
-const POTION_ENCHANTABLE = ['Alchimie', 'Repos', 'Soin', 'Autre']
-  .concat(POTION_MAGIQUE)
-
-const MAP_CATEGORIE_ENCHANTEMENT = [
-  { basique: 'Alchimie', enchante: 'AlchimieEnchante' },
-  { basique: 'Repos', enchante: 'ReposEnchante' },
-  { basique: 'Soin', enchante: 'SoinEnchante' },
-  { basique: 'Autre', enchante: 'AutreEnchante' }]
-
-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"
-  }
-
-  prepareDerivedData() {
-    super.prepareDerivedData()
-    this.system.puissance = this.system.magique ? this.calculPuissance() : 0
-  }
-
-  isPotion() { return true }
-  isEnchantable() { return POTION_ENCHANTABLE.includes(this.system.categorie) }
-  isMagique() { return POTION_MAGIQUE.includes(this.system.categorie) }
-
-  itemSpecificActions() {
-    return ITEM_ACTIONS[ITEM_TYPES.potion]
-  }
-
-  getActions(options = { warnIfNot: true }) {
-    const actionConsommer = this.prepareAction('Consommer', options.warnIfNot);
-    if (this.isEnchantable()) {
-      return [
-        actionConsommer,
-        this.prepareAction('Enchanter', options.warnIfNot)
-      ]
-    }
-    return [
-      actionConsommer
-    ]
-  }
-  // TDOD: purifier?
-  getUtilisation() {
-    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 ''
-  }
-
-  _potionChatData() {
-    return [
-      `<b>Rareté</b>: ${this.system.rarete}`,
-      `<b>Catégorie</b>: ${this.system.categorie}`,
-      ...this._inventaireTemplateChatData()
-    ]
-  }
-
-  async enchanterPotion() {
-    const actor = this.parent;
-    if (actor && (!actor.isPersonnage() || !actor.isHautRevant())) {
-      ui.notifications.info('Seul un haut rêvant peut enchanter une potion')
-      return
-    }
-    const dailog = await DialogEnchanter.create(this, actor, (updates) => this.$onEnchanterPotion(updates));
-    dailog.render(true)
-  }
-
-  perteRevePotion() {
-    if (this.system.magique && !this.system.prpermanent && this.system.pr > 0) {
-      const nouveauReve = Math.max(this.system.pr - 1, 0)
-      return {
-        _id: this.id,
-        name: this.name,
-        img: this.img,
-        'system.pr': nouveauReve,
-        'system.quantite': nouveauReve > 0 ? this.system.quantite : 0,
-        'system.magique': nouveauReve > 0
-      }
-    }
-    return undefined
-  }
-
-  async $onEnchanterPotion(enchanter) {
-    if (enchanter.nouveaupr == 0) {
-      await this.update({
-        'system.pr': 0,
-        'system.purifie': false,
-        'system.magique': false,
-        'system.categorie': this.categorieEnchantement().basique,
-        'system.prpermanent': false,
-        'system.prdate': 0,
-        'system.quantite': this.parent ? 0 : this.system.quantite
-      })
-    }
-    else {
-      await this.update({
-        'system.pr': enchanter.nouveaupr,
-        'system.purifie': enchanter.purifier,
-        'system.magique': true,
-        'system.categorie': this.categorieEnchantement().enchante,
-        'system.prpermanent': enchanter.prpermanent,
-        'system.prdate': RdDItemPotion.dateEnchantement()
-      })
-    }
-    this.sheet?.render(true)
-  }
-
-  calculPuissance() { return this.system.herbebonus * this.system.pr }
-
-  categorieEnchantement() {
-    const categorie = this.system.categorie
-    const categorieEnchantement = MAP_CATEGORIE_ENCHANTEMENT.find(it => [it.basique, it.enchante].includes(categorie))
-    return categorieEnchantement ?? { basique: categorie, enchante: categorie }
-  }
-
-  static dateEnchantement() {
-    return game.system.rdd.calendrier.getTimestamp().debutJournee().indexDate
-  }
-
-  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;
-  }
-
-}

module/item/potion/dialog-enchanter.js

@@ -1,46 +0,0 @@
-
-export class DialogEnchanter extends Dialog {
-
-  static async create(item, actor, callback) {
-    const enchanter = {
-      actor: actor,
-      item: item,
-      nouveaupr: item.system.pr,
-      prpermanent: item.system.prpermanent,
-      purifier: false
-    }
-    const html = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/item/potion/dialog-enchanter.hbs`, enchanter)
-    return new DialogEnchanter(enchanter, html, callback)
-  }
-
-  constructor(enchanter, html, callback) {
-    let options = { classes: ["dialog-enchanter"], width: 400, height: 'fit-content', 'z-index': 99999 }
-    let conf = {
-      title: "Enchanter une potion",
-      content: html,
-      default: "enchanter",
-      buttons: {
-        "enchanter": { label: "Enchanter", callback: it => this.onEnchanter() }
-      }
-    };
-    super(conf, options)
-
-    this.callback = callback
-    this.enchanter = enchanter
-  }
-
-  activateListeners(html) {
-    super.activateListeners(html)
-    this.html = html
-    this.html.find("input.nouveaupr").change(event => this.enchanter.nouveaupr = Number(event.currentTarget.value))
-    this.html.find("input.purifier").change(event => this.enchanter.purifier = event.currentTarget.checked)
-    this.html.find("input.prpermanent").change(event => this.enchanter.prpermanent = event.currentTarget.checked)
-  }
-
-
-  async onEnchanter() {
-    await this.html.find(".nouveaupr").change()
-    this.callback(this.enchanter);
-  }
-
-}

module/item/race.js

@@ -1,5 +1,4 @@
-import { ITEM_TYPES } from "../constants.js";
+import { ITEM_TYPES, RdDItem } from "../item.js";
-import { RdDItem } from "../item.js";
 import { Misc } from "../misc.js";
 import { LIST_CARAC_PERSONNAGE, RdDCarac } from "../rdd-carac.js";
 

module/item/sheet-conteneur.js

@@ -1,5 +1,5 @@
 import { RdDBaseActorSheet } from "../actor/base-actor-sheet.js";
-import { ITEM_TYPES } from "../constants.js";
+import { ITEM_TYPES } from "../item.js";
 import { RdDSheetUtility } from "../rdd-sheet-utility.js";
 import { RdDUtility } from "../rdd-utility.js";
 import { RdDItemInventaireSheet } from "./sheet-base-inventaire.js";
@@ -29,10 +29,9 @@ export class RdDConteneurItemSheet extends RdDItemInventaireSheet {
 
   /* -------------------------------------------- */
   prepareConteneurData(formData) {
-    RdDUtility.filterItemsPerTypeForSheet(formData, this.actor.itemTypes);
+    RdDBaseActorSheet.filterItemsPerTypeForSheet(formData, this.actor.itemTypes);
     this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.inventaires);
-    const subItems = formData.conteneurs.find(it => it._id == this.item.id)?.subItems;
+    formData.subItems = formData.conteneurs.find(it => it._id == this.item.id)?.subItems;
-    formData.subItems = subItems
   }
 
   async _onDragStart(event) {

module/item/sheet-potion.js

@@ -1,58 +0,0 @@
-import { ITEM_TYPES } from "../constants.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);
-      }
-    }
-  }
-  get potion(){ return this.item }
-
-  async getData() {
-    const formData = await super.getData()
-    formData.enchantable = this.potion.isEnchantable()
-    const enchantement = this.potion.categorieEnchantement()
-    formData.isSoins = enchantement.basique == 'Soin'
-    formData.isRepos = enchantement.basique == '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.potion.system.prdate)
-    return formData
-  }
-
-  activateListeners(html) {
-    super.activateListeners(html);
-
-    this.html.find('.item-enchanter').click((event) => this.potion.enchanterPotion())
-
-    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.potion.update({ 'system.prdate': indexDate })
-      console.warn(`Date d'enchantement modifiée ${jour}/${mois.heure}: ${indexDate}`)
-    });
-
-  }
-}

module/item/tete.js

@@ -1,6 +1,5 @@
-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"

module/migrations.js

@@ -2,8 +2,7 @@ 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 { ITEM_TYPES, ACTOR_TYPES } from "./constants.js";
+import { RdDItem, ITEM_TYPES, ACTOR_TYPES } from "./item.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";

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 '.encaisser-button': return this.encaisser(attackerRoll, defenderRoll);
+      case '0encaisser-button': return this.encaisser(attackerRoll, defenderRoll);
       case '.echec-total-attaque': return this._onEchecTotal(attackerRoll);
 
       case '.appel-chance-attaque': return this.attacker.rollAppelChance(

module/rdd-commands.js

@@ -361,14 +361,13 @@ export class RdDCommands {
   async getTMRAleatoire(msg, params) {
     if (params.length < 2) {
       let type = params[0]
-      const solvedTerrain = type ? TMRUtility.findTMRLike(type)?.type : undefined
+      const solvedTerrain = TMRUtility.findTMRLike(type)?.type
-      const filter = solvedTerrain ? (it => it.type == solvedTerrain) : (it => true)
+      if (solvedTerrain){
-      if (type == undefined || solvedTerrain != undefined) {
+        const tmr = await TMRUtility.getTMRAleatoire(type ? (it => it.type == solvedTerrain) : (it => true))
-        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) {

module/rdd-empoignade.js

@@ -4,7 +4,8 @@ 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 { ITEM_TYPES } from "./constants.js";
+import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
+import { ITEM_TYPES } from "./item.js";
 
 /* -------------------------------------------- */
 
@@ -428,6 +429,7 @@ 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 }
     },
       {

module/rdd-herbes.js

@@ -0,0 +1,73 @@
+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);
+      }
+    }
+  }
+
+}  

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 "./constants.js";
+import { ITEM_TYPES } from "./item.js";
 
 export class RdDHotbar {
 

module/rdd-main.js

@@ -18,6 +18,7 @@ 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"
@@ -75,8 +76,7 @@ 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 { RdDPotionItemSheet } from "./item/sheet-potion.js"
+import { RdDTextEditor } from "./apps/rdd-text-roll-editor.js"
-import { RdDItemPotion } from "./item/potion.js"
 
 /**
  * RdD system
@@ -87,9 +87,9 @@ export class SystemReveDeDragon {
 
   static start() {
     const system = new SystemReveDeDragon()
-    Hooks.once('init', () => system.onInit())
+    Hooks.once('init', async () => await system.onInit())
     Hooks.once('diceSoNiceReady', (dice3d) => RdDDice.diceSoNiceReady(dice3d))
-    Hooks.once('ready', () => system.onReady())
+    Hooks.once('ready', async () => await system.onReady())
   }
 
   constructor() {
@@ -105,7 +105,6 @@ export class SystemReveDeDragon {
       poison: RdDItemPoison,
       queue: RdDItemQueue,
       tete: RdDItemTete,
-      potion: RdDItemPotion,
       race: RdDItemRace,
       rencontre: RdDRencontre,
       service: RdDItemService,
@@ -124,14 +123,14 @@ export class SystemReveDeDragon {
   /* -------------------------------------------- */
   /*  Foundry VTT Initialization                  */
   /* -------------------------------------------- */
-  onInit() {
+  async onInit() {
     game.system.rdd = this
     this.AppAstrologie = AppAstrologie
 
     console.log(`Initializing Reve de Dragon System Settings`)
 
     // preload handlebars templates
-    RdDUtility.preloadHandlebarsTemplates()
+    await RdDUtility.preloadHandlebarsTemplates()
     AppPersonnageAleatoire.preloadHandlebars()
     RdDItemSort.preloadHandlebars()
 
@@ -188,7 +187,7 @@ export class SystemReveDeDragon {
     Actors.registerSheet(SYSTEM_RDD, RdDActorVehiculeSheet, { types: ["vehicule"], makeDefault: true })
     Actors.registerSheet(SYSTEM_RDD, RdDActorEntiteSheet, { types: ["entite"], makeDefault: true })
     Items.unregisterSheet("core", ItemSheet)
-    RdDActorExportSheet.init()
+    await RdDActorExportSheet.init()
 
     RdDItemSheet.register(RdDSigneDraconiqueItemSheet)
     RdDItemSheet.register(RdDRencontreItemSheet)
@@ -196,7 +195,6 @@ export class SystemReveDeDragon {
     RdDItemSheet.register(RdDHerbeItemSheet)
     RdDItemSheet.register(RdDFauneItemSheet)
     RdDItemSheet.register(RdDPlanteItemSheet)
-    RdDItemSheet.register(RdDPotionItemSheet)
     RdDItemSheet.register(RdDIngredientItemSheet)
     RdDItemSheet.register(RdDServiceItemSheet)
     RdDItemSheet.register(RdDBlessureItemSheet)
@@ -204,10 +202,9 @@ export class SystemReveDeDragon {
 
     Items.registerSheet(SYSTEM_RDD, RdDItemInventaireSheet, {
       types: [
-        "objet", "arme", "armure", "livre", "munition",
+        "objet", "arme", "armure", "livre", "potion", "munition",
         "monnaie", "nourritureboisson", "gemme",
-      ],
+      ], makeDefault: true
-      makeDefault: true
     })
     Items.registerSheet(SYSTEM_RDD, RdDItemSheet, {
       types: [
@@ -217,8 +214,7 @@ export class SystemReveDeDragon {
         "queue", "ombre", "souffle", "tete", "casetmr", "sort", "sortreserve",
         "nombreastral", "tache", "maladie", "poison", "possession",
         "tarot", "extraitpoetique", "empoignade"
-      ],
+      ], makeDefault: true
-      makeDefault: true
     })
 
     // préparation des différents modules
@@ -320,6 +316,7 @@ export class SystemReveDeDragon {
     }
 
     StatusEffects.onReady()
+    RdDHerbes.onReady()
     RdDDice.onReady()
 
     RdDStatBlockParser.parseStatBlock()

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 "./constants.js";
+import { ITEM_TYPES } from "./item.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
-      await victime.deleteEmbeddedDocuments("Item", [rollData.possession._id])
+      victime.deleteEmbeddedDocuments("Item", [rollData.possession._id])
     }
   }
 

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 "./constants.js";
+import { ACTOR_TYPES } from "./item.js";
 
 /**
  * Extend the base Dialog entity to select roll parameters
@@ -137,11 +137,7 @@ 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(
+      this.html.find("[name='carac']").val(RdDCarac.caracDetails(this.rollData.selectedCarac.label).code)
-        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);

module/rdd-sheet-utility.js

@@ -70,7 +70,7 @@ export class RdDSheetUtility {
       await RdDSheetUtility._onSplitItem(item, split, actor);
       onSplit();
     });
-    dialog.render(true)
+    dialog.render(true);
   }
 
   static async _onSplitItem(item, split, actor) {
@@ -82,11 +82,4 @@ export class RdDSheetUtility {
       await actor.createEmbeddedDocuments('Item', [splitItem])
     }
   }
-
-  static async renderItemBranch(actor, item) {
-    while (item) {
-      await item.sheet?.render()
-      item = actor.getContenant(item)
-    }
-  }
 }

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 "./constants.js";
+import { ITEM_TYPES } from "./item.js";
 import { Misc } from "./misc.js";
 
 const TMR_DISPLAY_SIZE = {
@@ -212,7 +212,7 @@ export class RdDTMRDialog extends Dialog {
   }
 
   getSortsReserve(coord) {
-    return this.sortsReserve.filter(// Reserve sur une case fleuve ou normale
+    return this.actor.itemTypes[ITEM_TYPES.sortreserve].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,7 +271,8 @@ export class RdDTMRDialog extends Dialog {
   }
 
   _getTokensSortsReserve() {
-    return Misc.concat(this.sortsReserve.map(sortReserve =>
+    const sortsReserve = this.actor.itemTypes[ITEM_TYPES.sortreserve];
+    return Misc.concat(sortsReserve.map(sortReserve =>
       EffetsDraconiques.sortReserve.tokens(this.pixiTMR, sortReserve, () => sortReserve.system.coord)))
   }
 
@@ -907,8 +908,8 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   lancerSortEnReserve(coord, sortId) {
-    const sort = this.getSortsReserve(coord)
+    let sorts = this.getSortsReserve(coord);
-      .find(it => it.id == sortId);
+    let sort = sorts.find(it => it.id == sortId);
     if (sort) {
       this.processSortReserve(sort);
     } else {

module/rdd-utility.js

@@ -19,12 +19,10 @@ 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 { ITEM_TYPES, RDD_CONFIG } from "./constants.js";
+import { 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
@@ -109,7 +107,7 @@ export class RdDUtility {
   }
 
   /* -------------------------------------------- */
-  static preloadHandlebarsTemplates() {
+  static async preloadHandlebarsTemplates() {
     const templatePaths = [
       //Character Sheets
       'systems/foundryvtt-reve-de-dragon/templates/actor-sheet.html',
@@ -117,7 +115,6 @@ 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',
@@ -132,47 +129,48 @@ 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.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/comp-creature.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/comp-possession.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/comp-possession.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/carac-total.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/competence.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/competence.html',
       '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.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/maladies-poisons.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/possessions.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/possessions.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/resonances.hbs',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/taches.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/taches.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/oeuvres.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/taches.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/oeuvre.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/oeuvres.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/jeus.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/oeuvre.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/alchimie.hbs',
+      '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/astrologie.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/chirurgie.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/chirurgie.html',
       '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.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/dragon-queue.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/dragon-souffles.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/dragon-souffles.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/dragon-tetes.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/dragon-tetes.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-signes-draconiques.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-signes-draconiques.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-rencontres.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-rencontres.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-sorts.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-sorts.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-sorts-reserve.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-sorts-reserve.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-meditations.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-meditations.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-casetmrs.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/hr-casestmr.html',
       '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.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-item.html',
-      "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-monnaie.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-monnaie.html",
       '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.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire-item.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire-item.html',
       //Items
       'systems/foundryvtt-reve-de-dragon/templates/scripts/autocomplete-script.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/scripts/autocomplete.hbs',
@@ -182,9 +180,8 @@ 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',
@@ -192,7 +189,7 @@ 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/item/potion-enum-categorie.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-potion.html',
       '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',
@@ -266,7 +263,7 @@ export class RdDUtility {
       '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));
@@ -281,7 +278,7 @@ export class RdDUtility {
       const html = options.fn(this);
       return html.replace(rgx, "$& selected");
     })
-
+    
     // logic
     Handlebars.registerHelper('either', (a, b) => a ?? b);
     // string manipulation
@@ -297,9 +294,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
@@ -337,8 +334,6 @@ 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))
 
     // TMRs
     Handlebars.registerHelper('caseTmr-label', coord => TMRUtility.getTMRLabel(coord));
@@ -346,7 +341,7 @@ export class RdDUtility {
     Handlebars.registerHelper('typeTmr-name', type => TMRUtility.typeTmrName(type));
     Handlebars.registerHelper('effetRencontre-name', coord => TMRUtility.typeTmrName(coord));
 
-    loadTemplates(templatePaths);
+    await loadTemplates(templatePaths);
   }
 
   static getItem(itemId, actorId = undefined) {
@@ -440,8 +435,8 @@ export class RdDUtility {
     };
     if (!optionsArbre.templateItem) {
       optionsArbre.templateItem = item.parent?.type == 'commerce'
-        ? "systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire-item.hbs"
+        ? "systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire-item.html"
-        : "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-item.hbs";
+        : "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-item.html";
     }
     item.niveau = optionsArbre.profondeur;
   }
@@ -469,38 +464,13 @@ 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?.type == ITEM_TYPES.conteneur) {
+    if (item) {
-      const formData = {}
+      return RdDUtility.buildContenuConteneur(item, options, { ouvert: true, profondeur: 1 });
-      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))
   }
 
   /* -------------------------------------------- */
@@ -902,7 +872,7 @@ export class RdDUtility {
   }
 
   /* -------------------------------------------- */
-  static async confirmActorItemDelete(item, actor) {
+  static async confirmActorItemDelete(sheet, item, htmlToDelete) {
     const itemId = item.id;
     const confirmationSuppression = {
       settingConfirmer: "confirmation-supprimer-" + item.getItemGroup(),
@@ -911,7 +881,8 @@ export class RdDUtility {
       buttonLabel: "Supprimer",
       onAction: () => {
         console.log('Delete : ', itemId);
-        actor.deleteEmbeddedDocuments('Item', [itemId], { renderSheet: false });
+        sheet.actor.deleteEmbeddedDocuments('Item', [itemId], { renderSheet: false });
+        RdDUtility.slideOnDelete(sheet, htmlToDelete);
       }
     };
     if (item.isConteneurNonVide()) {
@@ -924,7 +895,8 @@ export class RdDUtility {
             label: "Supprimer conteneur et contenu",
             callback: () => {
               console.log("Delete : ", itemId);
-              actor.deleteAllConteneur(itemId, { renderSheet: false });
+              sheet.actor.deleteAllConteneur(itemId, { renderSheet: false });
+              RdDUtility.slideOnDelete(sheet, htmlToDelete);
             }
           }
         });

module/time/rdd-timestamp.js

@@ -334,10 +334,6 @@ 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);

module/tmr-rencontres.js

@@ -26,7 +26,7 @@ export class TMRRencontres {
    * @param {*} forcedRoll 
    */
   async rollRencontre(terrain, forcedRoll) {
-    const tmrType = TMRUtility.findTMRLike(terrain, { inclusMauvaise: true })?.type
+    const tmrType = TMRUtility.findTMRLike(terrain)?.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;

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", generique: 'fleuve' },
+  Fleuve: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
   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: false }) {
+  static findTMRLike(type, options = { inclusMauvaise: true }) {
     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.map(it => it.name).reduce(Misc.joining(', '))}`);
+      ui.notifications.warn(`Un type de TMR doit être indiqué, '${type}' n'est pas trouvé dans ${choix}`);
       return undefined
     }
     if (selection.length > 1) {
-      ui.notifications.warn(`Plusieurs types de TMR pourraient correspondre à '${type}': ${selection.map(it => it.name).reduce(Misc.joining(', '))}`);
+      ui.notifications.warn(`Plusieurs types de TMR pourraient correspondre à '${type}': ${selection.map(it => it.name)}`);
       return undefined;
     }
     return selection[0]
@@ -357,7 +357,7 @@ export class TMRUtility {
   }
 
   static filterTMR(filter) {
-    return Object.values(TMRMapping).filter(it => !it.generique && filter(it))
+    return Object.values(TMRMapping).filter(filter);
   }
 
   static getCasesType(type) {

module/tmr/draconique.js

@@ -1,4 +1,4 @@
-import { ITEM_TYPES } from "../constants.js";
+import { ITEM_TYPES } from "../item.js";
 import { TMRUtility } from "../tmr-utility.js";
 import { PixiTMR } from "./pixi-tmr.js";
 

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 "../constants.js";
+import { ITEM_TYPES } from "../item.js";
 
 export class EffetsDraconiques {
   static carteTmr = new CarteTmr();

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 "../constants.js";
+import { ITEM_TYPES } from "../item.js";
 import { TMRAnimations } from "./animation.js";
 
 export class UrgenceDraconique extends Draconique {

module/voyage/dialog-fatigue-voyage.js

@@ -1,4 +1,4 @@
-import { ITEM_TYPES } from "../constants.js"
+import { ITEM_TYPES } from "../item.js"
 import { RdDItemCompetence } from "../item-competence.js"
 import { ChatUtility } from "../chat-utility.js"
 import { Misc } from "../misc.js"

packs_src/animaux/creature_Brolute_rieuse_twCuK1GjVBTUFGXF.yml

@@ -300,7 +300,7 @@ system:
     déchirure. Celle-là se contente de chercher à fuir en
     cas d’agression, ou attaque toutes griffes dehors si elle se sent
     acculée. Pour la distinguer (visuellement) de la rieuse,
-    réussir @roll[VUE/Zoologie/-5]. Les caractéristiques de
+    réussir VUE/Zoologie à -5. Les caractéristiques de
     combat indiquées ne s’appliquent qu’à la
     pointue.</p>
   race: ''

packs_src/animaux/creature_Cheval_76I21ASdWYBqsg8I.yml

@@ -215,7 +215,7 @@ system:
     souffrir ses premiers malus à la course et au saut. La vitesse
     indiquée correspond à une allure plutôt lente.
     Contrairement aux autres animaux pour qui la vitesse de base est fixe, le
-    gardien des rêves peut rajouter jusqu’à @roll[3d6] points
+    gardien des rêves peut rajouter jusqu’à 3d6 points
     à la vitesse de course de chaque individu. Cette nouvelle vitesse de
     course est rajoutée une fois pour toutes, mais peut être
     modul&eacute;e par un jet de course sur la table de Course animale.</p>

packs_src/archetypes/commerce_Liste_d__quipement_1Nng9d8r6lrPHCaJ.yml

@@ -3897,7 +3897,7 @@ items:
           indexDate: -1
           indexMinute: 0
       rarete: ''
-      categorie: Alchimie
+      categorie: Remede
       herbe: ''
       herbebrins: 0
       herbebonus: 0
@@ -5349,7 +5349,7 @@ items:
           indexDate: -1
           indexMinute: 0
       rarete: ''
-      categorie: Alchimie
+      categorie: Remede
       herbe: ''
       herbebrins: 0
       herbebonus: 0
@@ -5605,7 +5605,7 @@ items:
           indexDate: -1
           indexMinute: 0
       rarete: ''
-      categorie: Alchimie
+      categorie: Remede
       herbe: ''
       herbebrins: 0
       herbebonus: 0
@@ -5765,7 +5765,7 @@ items:
           indexDate: -1
           indexMinute: 0
       rarete: ''
-      categorie: Alchimie
+      categorie: Remede
       herbe: ''
       herbebrins: 0
       herbebonus: 0
@@ -6437,7 +6437,7 @@ items:
           indexDate: -1
           indexMinute: 0
       rarete: ''
-      categorie: Alchimie
+      categorie: Remede
       herbe: ''
       herbebrins: 0
       herbebonus: 0
@@ -7610,7 +7610,7 @@ items:
           indexDate: -1
           indexMinute: 0
       rarete: ''
-      categorie: Alchimie
+      categorie: Remede
       herbe: ''
       herbebrins: 0
       herbebonus: 0
@@ -8010,7 +8010,7 @@ items:
         poussant dans les lieux frais et humides : marais ombragés,
         certaines forêts, et parfois vallées de montagne. Un peu
         moins rare est la fausse endebrume, qui lui ressemble physiquement, mais
-        n'a aucune vertu. <br /><em>@roll[VUE/Botanique/-1] pour savoir
+        n'a aucune vertu. <br /><em>VUE/Botanique &agrave; -1 pour savoir
         &agrave; quelle esp&egrave;ce on a affaire (jet obligatoire &agrave;
         chaque cueillette).</em></p>
 
@@ -8782,7 +8782,7 @@ items:
     system:
       description: |-
         <p>Poudre brune apparaissant sur les parois des grottes.</p>
-        <p>@roll[VUE/Alchimie/-1].</p>
+        <p>VUE/Alchimie &agrave; -1.</p>
       descriptionmj: ''
       encombrement: 0.001
       quantite: 1
@@ -8818,7 +8818,7 @@ items:
         <p>Poudre blanche apparaissant sous l&rsquo;&eacute;corce de nombreux
         arbres,</p>
 
-        <p>@roll[VUE/Alchimie/0].</p>
+        <p>VUE/Alchimie &agrave; 0.</p>
       descriptionmj: ''
       encombrement: 0.001
       quantite: 1
@@ -8854,7 +8854,7 @@ items:
         <p>Poudre rouge obtenue par disruption alchimique de la
         <em>chramaele</em>, minerai ayant l&rsquo;apparence de la glaise.</p>
 
-        <p>@roll[VUE/Alchimie/-4]</p>
+        <p>VUE/Alchimie &agrave; -4</p>
       descriptionmj: ''
       encombrement: 0.001
       quantite: 1
@@ -8899,7 +8899,7 @@ items:
         <p>Poudre noire obtenue par disruption alchimique du minerai
         appel&eacute; <em>narthalide</em>, sorte de marne.</p>
 
-        <p>@roll[VUE/Alchimie/-3]</p>
+        <p>VUE/Alchimie &agrave; -3</p>
       descriptionmj: ''
       encombrement: 0.001
       quantite: 1
@@ -8941,7 +8941,7 @@ items:
         <p>Poudre bleu&acirc;tre obtenue par disruption alchimique du minerai
         appel&eacute; <em>obbadine</em>, &nbsp;sorte de tourbe.</p>
 
-        <p>@roll[VUE/Alchimie/-2]</p>
+        <p>VUE/Alchimie &agrave; -2</p>
       descriptionmj: ''
       encombrement: 0.001
       quantite: 1
@@ -8983,7 +8983,7 @@ items:
         <p>Plus rare que le vert, poudre gris&acirc;tre apparaissant le long de
         certaines lianes des marais.</p>
 
-        <p>@roll[VUE/Alchimie/-4]</p>
+        <p>VUE/Alchimie &agrave; -4</p>
       descriptionmj: ''
       encombrement: 0.001
       quantite: 1
@@ -9019,7 +9019,7 @@ items:
         <p>Poudre verd&acirc;tre apparaissant sur les tiges de certains
         roseaux.</p>
 
-        <p>@roll[VUE/Alchimie/-2]</p>
+        <p>VUE/Alchimie &agrave; -2</p>
       descriptionmj: ''
       encombrement: 0.001
       quantite: 1

packs_src/equipement/potion_Elixir_des_gnomes_JXMef7FXVOG1XYWO.yml

@@ -30,7 +30,7 @@ system:
       indexDate: -1
       indexMinute: 0
   rarete: ''
-  categorie: Alchimie
+  categorie: Remede
   herbe: ''
   herbebrins: 0
   herbebonus: 0

packs_src/equipement/potion_Huile_de_S_likanthe_LkE8EjPfao9m6Rn7.yml

@@ -30,7 +30,7 @@ system:
       indexDate: -1
       indexMinute: 0
   rarete: ''
-  categorie: Alchimie
+  categorie: Remede
   herbe: ''
   herbebrins: 0
   herbebonus: 0

packs_src/equipement/potion_Lait_de_lune_A3jx5dPkk5IeXSXn.yml

@@ -30,7 +30,7 @@ system:
       indexDate: -1
       indexMinute: 0
   rarete: ''
-  categorie: Alchimie
+  categorie: Remede
   herbe: ''
   herbebrins: 0
   herbebonus: 0

packs_src/equipement/potion_Liqueur_de_Bagdol_PrnJrG50u1UPdlJN.yml

@@ -28,7 +28,7 @@ system:
       indexDate: -1
       indexMinute: 0
   rarete: ''
-  categorie: Alchimie
+  categorie: Remede
   herbe: ''
   herbebrins: 0
   herbebonus: 0

packs_src/equipement/potion_Mirobolant_keLCmhsbxHK39UIy.yml

@@ -30,7 +30,7 @@ system:
       indexDate: -1
       indexMinute: 0
   rarete: ''
-  categorie: Alchimie
+  categorie: Remede
   herbe: ''
   herbebrins: 0
   herbebonus: 0

packs_src/equipement/potion_Teinture_d_Erozonne_bA0JDA7awoWhu0vO.yml

@@ -30,7 +30,7 @@ system:
       indexDate: -1
       indexMinute: 0
   rarete: ''
-  categorie: Alchimie
+  categorie: Remede
   herbe: ''
   herbebrins: 0
   herbebonus: 0

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>@roll[VUE/Alchimie/-1].</p>
+    <p>VUE/Alchimie &agrave; -1.</p>
   descriptionmj: ''
   encombrement: 0.001
   quantite: 1

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>@roll[VUE/Alchimie/0].</p>
+    <p>VUE/Alchimie &agrave; 0.</p>
   descriptionmj: ''
   encombrement: 0.001
   quantite: 1

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>@roll[VUE/Alchimie/-4]</p>
+    <p>VUE/Alchimie &agrave; -4</p>
   descriptionmj: ''
   encombrement: 0.001
   quantite: 1

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>@roll[VUE/Alchimie/-3]</p>
+    <p>VUE/Alchimie &agrave; -3</p>
   descriptionmj: ''
   encombrement: 0.001
   quantite: 1

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>@roll[VUE/Alchimie/-2]</p>
+    <p>VUE/Alchimie &agrave; -2</p>
   descriptionmj: ''
   encombrement: 0.001
   quantite: 1

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>@roll[VUE/Alchimie/-4]</p>
+    <p>VUE/Alchimie &agrave; -4</p>
   descriptionmj: ''
   encombrement: 0.001
   quantite: 1

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>@roll[VUE/Alchimie/-2]</p>
+    <p>VUE/Alchimie &agrave; -2</p>
   descriptionmj: ''
   encombrement: 0.001
   quantite: 1

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 @roll[3d6] points de fatigue.</p>
+  description: <p>Prise immédiate de 3d6 points de fatigue.</p>
   descriptionmj: ''
   temporel:
     debut:

packs_src/queues-de-dragon/queue_Casser_3d6_oeufs_en_les_jetant___terre_OjG8XRbeYtq2jcgB.yml

@@ -1,5 +1,5 @@
 _id: OjG8XRbeYtq2jcgB
-name: Casser @roll[3d6] oeufs en les jetant à terre
+name: Casser 3d6 oeufs en les jetant à terre
 type: queue
 img: systems/foundryvtt-reve-de-dragon/icons/queues/desir_lancinant.webp
 effects: []

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 @roll[3d6] points de fatigue.</p>
+  description: <p>Prise immédiate de 3d6 points de fatigue.</p>
   descriptionmj: ''
   temporel:
     debut:

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 @roll[3d6] kilos de cailloux
+name: Garder sur soi 3d6 kilos de cailloux
 type: queue
 img: systems/foundryvtt-reve-de-dragon/icons/queues/idee_fixe.webp
 effects: []

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

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 @roll[3d6] oeufs en les jetant à terre'
+    text: 'Désir lancinant : Casser 3d6 oeufs en les jetant à terre'
     img: systems/foundryvtt-reve-de-dragon/icons/queues/desir_lancinant.webp
     weight: 1
     range:

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 @roll[3d6] kilos de cailloux'
+    text: 'Idée fixe : Garder sur soi 3d6 kilos de cailloux'
     img: systems/foundryvtt-reve-de-dragon/icons/queues/idee_fixe.webp
     weight: 1
     range:

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 @roll[2d6+4].
+    text: Reflet d’ancien rêve 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 @roll[2d6+4].
+    text: Tourbillon blanc 2d6+4.
     img: systems/foundryvtt-reve-de-dragon/icons/heures/hd06.webp
     weight: 1
     range:

styles/simple.css

@@ -67,8 +67,7 @@
 
 /* =================== 3. some constants ============ */
   --color-controls:rgba(0, 0, 0, 0.9);
-  --color-controls-light:hsla(0, 0%, 20%, 0.8);
+  --color-controls-hover:rgba(255, 255, 128, 0.7);
-  --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));
@@ -392,7 +391,9 @@ table {border: 1px solid #7a7971;}
   grid-template-columns: repeat(12, minmax(0, 1fr));
 }
 
-.flex-group-center {
+.flex-group-center,
+.flex-group-left,
+.flex-group-right {
   -webkit-box-pack: center;
   -ms-flex-pack: center;
   justify-content: center;
@@ -404,11 +405,8 @@ 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;
 }
@@ -419,11 +417,8 @@ 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;
 }
@@ -445,9 +440,9 @@ table {border: 1px solid #7a7971;}
 }
 .flex-shrink {
   flex: 'flex-shrink' ;
-  flex-shrink: 0;
+  flex-shrink: 2;
 }
-.flex-grow, .flex-grow-3 {
+:is(.flex-grow, .flex-grow-3) {
   flex-grow: 3;
 }
 .flex-grow-2 {
@@ -498,13 +493,12 @@ span.equipement-detail-buttons {
   justify-content: center;
   text-align: center;
 }
-.item-actions-controls,
 .equipement-actions {
   margin: 0;
   flex-grow: 2;
-  align-items: end;
+  align-items: center;
-  justify-content: flex-end;
+  justify-content: center;
-  text-align: right;
+  text-align: left;
 }
 
 .blessure-control {
@@ -819,21 +813,16 @@ 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-light);
+  color: var(--color-controls);
 }
-.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;
 }
@@ -1061,10 +1050,6 @@ 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 {
@@ -1099,29 +1084,25 @@ li label.compteur {
   padding: 0.25rem;
 }
 
-.window-app.sheet .window-content .carac-value,
+.window-app.sheet .window-content .carac-value, .window-app.sheet .window-content .competence-xp {
-.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 .carac-value, .window-app.sheet .window-content .competence-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 .carac-value, .window-app.sheet .window-content .competence-archetype {
-.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 .carac-value, .window-app.sheet .window-content .competence-xp-sort {
-.window-app.sheet .window-content .competence-xp-sort {
   flex-grow: 0;
   margin: 0.05rem;
   flex-basis: 2rem;
@@ -1211,9 +1192,6 @@ 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;
 }
@@ -1330,11 +1308,21 @@ div.competence-column div.categorie-competence{
   font-weight: bold;
   flex-grow: 0;
 }
-.astrologie-label,
+.arme-label,
 .generic-label,
+.competence-label,
+.astrologie-label,
+.tache-label,
 .subacteur-label,
-.list-item-label,
+.chant-label,
-.list-title-label {
+.musique-label,
+.oeuvre-label,
+.chant-label,
+.danse-label,
+.recette-label,
+.jeu-label,
+.recettecuisine-label,
+.description-label {
   flex-grow: 2;
 }
 .attribut-value,

system.json

@@ -1,9 +1,9 @@
 {
   "id": "foundryvtt-reve-de-dragon",
   "title": "Rêve de Dragon",
-  "version": "12.0.35",
+  "version": "12.0.34",
-  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/releases/download/12.0.35/rddsystem.zip",
+  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/releases/download/12.0.34/rddsystem.zip",
-  "manifest": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/releases/download/12.0.35/system.json",
+  "manifest": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/releases/download/12.0.34/system.json",
   "changelog": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/branch/v11/changelog.md",
   "compatibility": {
     "minimum": "11",

template.json

@@ -802,9 +802,7 @@
       "herbebrins": 0,
       "herbebonus": 0,
       "reposalchimique": false,
-      "magique": false,
       "pr": 0,
-      "purifie": false,
       "prpermanent": false,
       "prdate": 0
     },

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.hbs"}}
+          {{>"systems/foundryvtt-reve-de-dragon/templates/actor/comp-creature.html"}}
         </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.hbs"}}
+      {{> "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-monnaie.html"}}
       {{> "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire.html"}}
     </div>
 

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.hbs"}}
+            {{>"systems/foundryvtt-reve-de-dragon/templates/actor/comp-creature.html"}}
-            {{>"systems/foundryvtt-reve-de-dragon/templates/actor/comp-possession.hbs"}}
+            {{>"systems/foundryvtt-reve-de-dragon/templates/actor/comp-possession.html"}}
           </div>
           <div>
             {{>"systems/foundryvtt-reve-de-dragon/templates/actor/resonances.hbs"}}

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.hbs"}}
+        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/maladies-poisons.html"}}
-        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/possessions.hbs"}}
+        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/possessions.html"}}
       </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.hbs"}}
+        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/taches.html"}}
-        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/chirurgie.hbs"}}
+        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/chirurgie.html"}}
-        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/oeuvres.hbs"}}
+        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/oeuvres.html"}}
-        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/jeus.hbs"}}
+        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/jeux.html"}}
-        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/alchimie.hbs"}}
+        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/alchimie.html"}}
       </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.hbs"}}
+        {{> "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-monnaie.html"}}
         {{> "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire.html"}}
         {{> "systems/foundryvtt-reve-de-dragon/templates/actor/liens-animaux.hbs"}}
         {{> "systems/foundryvtt-reve-de-dragon/templates/actor/liens-vehicules.hbs"}}

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.hbs"}}
+      {{> "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-monnaie.html"}}
       {{> "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire.html"}}
     </div>
 

templates/actor/alchimie.hbs

@@ -1,11 +0,0 @@
-{{#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}}

templates/actor/alchimie.html

@@ -0,0 +1,15 @@
+{{#if recettesAlchimiques.length}}
+<h3>Recettes Alchimiques</h3>
+<ul class="item-list alterne-list">
+  {{#each (trier recettesAlchimiques) as |recette id|}}
+  <li class="item flexrow list-item" data-item-id="{{recette._id}}"><span class="competence-title recette-label item-edit"><a>{{recette.name}}</a></span>
+    <div class="item-controls">
+      <a class="item-edit" data-tooltip="Modifier"><i class="fas fa-edit"></i></a>
+      <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
+      &nbsp;
+      <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
+  </div>
+  </li>
+  {{/each}}
+</ul>
+{{/if}}

templates/actor/armures.hbs

@@ -3,7 +3,7 @@
 <li class="caracteristique item flexrow list-item" data-item-id="{{armure.id}}">
   <span class="flex-grow">
     <img class="sheet-competence-img subacteur-open" src="{{armure.img}}" data-tooltip="{{armure.name}}"/>
-    <a class="item-equip-armure" data-tooltip="Equiper">{{#if armure.system.equipe}}<i class="fas fa-hand-rock"></i>{{else}}<i class="far fa-hand-paper"></i>{{/if}}</a>
+    <a class="item-equip" data-tooltip="Equiper">{{#if armure.system.equipe}}<i class="fas fa-hand-rock"></i>{{else}}<i class="far fa-hand-paper"></i>{{/if}}</a>
     <a>{{armure.name}}</a>
     {{#if armure.system.malus}}
     <span class="derivee-value">({{armure.system.malus}})</span>

templates/actor/blessure.hbs

@@ -33,5 +33,10 @@
   {{#if system.origine}}<span>Par {{system.origine}}</span>{{/if}}
   {{#if system.localisation}}<span>{{system.localisation}}</span>{{/if}}
   </span>
-  {{>'systems/foundryvtt-reve-de-dragon/templates/actor/item-action-controls.hbs' item=this options=@root.options}}
+  <span class="item-controls">
+    <a class="item-edit" data-tooltip="Editer"><i class="fas fa-edit"></i></a>
+    <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
+    &nbsp;
+    <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
+  </span>
 </li>

templates/actor/chirurgie.html

@@ -10,9 +10,14 @@
     <li class="item flexrow list-item" data-item-id="{{tache._id}}"
       data-tooltip="Premiers soins: {{tache.name}} ({{tache.system.points_de_tache_courant}}/{{tache.system.points_de_tache}})">
       <img class="sheet-competence-img" src="{{tache.img}}"/>
-      <span class="list-item-label"><a class="action-tache">{{tache.name}}
+      <span class="competence-title tache-label"><a>{{tache.name}}
         ({{tache.system.points_de_tache_courant}}/{{tache.system.points_de_tache}})</a></span>
-      {{>'systems/foundryvtt-reve-de-dragon/templates/actor/item-action-controls.hbs' item=tache options=@root.options}}
+      <div class="item-controls">
+        <a class="item-edit" data-tooltip="Modifier"><i class="fas fa-edit"></i></a>
+        <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
+        &nbsp;
+        <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
+      </div>
     </li>
     {{/if}}
   {{/each}}

templates/actor/combat.html

@@ -1,10 +1,10 @@
 <ul class="item-list alterne-list">
   <li class="competence-header flexrow">
-    <span class="generic-label">Armes et Défenses</span>
+    <span class="competence-title competence-label">Armes et Défenses</span>
-    <span class="competence-value">Niveau</span>
+    <span class="competence-title competence-value">Niveau</span>
-    <span class="competence-value">+dom</span>
+    <span class="competence-title competence-value">+dom</span>
-    <span class="competence-value"></span>
+    <span class="competence-title competence-value"></span>
-    <span class="initiative-value">Initiative</span>
+    <span class="competence-title initiative-value">Initiative</span>
   </li>
 {{#each combat as |arme key|}}
   <li class="item flexrow list-item"
@@ -12,7 +12,7 @@
       data-arme-name="{{arme.name}}"
       data-competence-name="{{arme.system.competence}}" 
       data-tooltip="{{arme.name}}: niveau {{plusMoins arme.system.niveau}}">
-    <span class="list-item-label">
+    <span class="arme-label">
       <a class="roll-arme">
         {{#if arme.img}}
         <img class="sheet-competence-img" src="{{arme.img}}" data-tooltip="{{arme.name}}"/>
@@ -31,7 +31,7 @@
   {{#each esquives as |esq key|}}
   <li class="item flexrow list-item" data-item-id="{{esq._id}}"
     data-tooltip="{{esq.name}}: niveau {{plusMoins esq.system.niveau}}">
-    <span class="list-item-label">
+    <span class="competence-label">
       <a class="roll-competence" name="{{esq.name}}">
         <img class="sheet-competence-img" src="{{esq.img}}" />
         <span>{{esq.name}}</span>
@@ -47,20 +47,26 @@
 
 <ul class="item-list alterne-list">
   <li class="competence-header flexrow">
-    <span class="flex-grow-3">Empoignades</span>
+    <span class="competence-title competence-label">Empoignades</span>
-    <span class="flex-group-right">Points d'Emp</span>
+    <span class="competence-title competence-value">Points d'Emp</span>
-    <span class="item-controls"></span>
   </li>
   {{#each empoignades as |emp key|}}
   <li class="item flexrow list-item"
       data-item-id="{{emp._id}}" data-arme-name="{{emp.name}}"
-      data-tooltip="{{emp.name}}: niveau {{plusMoins emp.system.pointsemp}}">
+      data-tooltip="{{emp.name}}: niveau {{plusMoins emp.system.niveau}}">
-    <a class="flex-grow-3 action-empoignade">
+      <span class="empoignade-label">
-      <img class="sheet-competence-img" src="{{emp.img}}"/>
+      <a>
-      <span>{{emp.name}}</span>
+        {{#if emp.img}}
-    </a>
+        <img class="sheet-competence-img" src="{{emp.img}}"/>
-    <span class="flex-grow-0-5 flex-group-right">{{emp.system.pointsemp}}</span>
+        {{/if}}
-    {{>'systems/foundryvtt-reve-de-dragon/templates/actor/item-action-controls.hbs' item=emp options=@root.options}}
+        <span>{{emp.name}}</span>
+      </a>
+    </span>
+    <span class="competence-value">{{emp.system.pointsemp}}</span>
+    <div class="item-controls">
+      <a class="item-edit" data-tooltip="Modifier"><i class="fas fa-edit"></i></a>
+      <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
+    </div>
   </li>
   {{/each}}
 </ul>

templates/actor/commerce-actor-sheet.html

@@ -39,13 +39,46 @@
       {{editor description target="system.description" button=true owner=options.isOwner editable=options.isOwner engine="prosemirror"}}
     </div>
     <hr>
-    {{> "systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire.hbs"}}
+    {{> "systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire.html"}}
     {{#unless system.illimite}}
     {{#if @root.options.isObserver}}
       <hr>
-      {{> "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-monnaie.hbs"}}
+      {{> "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-monnaie.html"}}
     {{/if}}
     {{/unless}}
+    {{!--
+      <br>
+      <div class="flexcol">
+        <ul class="item-list alterne-list">
+          <li class="item flexrow list-item">
+            <label class="flex-grow">Service</label>
+            <label>Moral</label>
+            <label>Qualité</label>
+            <label>Prix (sols)</label>
+            <label>
+              {{#unless disabled}}
+              <a class="service-add"><i class="fas fa-plus-circle"></i></a>
+              {{/unless}}
+            </label>
+          </li>
+          {{#each (trier system.services) as |service key|}}
+          <li class="item flexrow list-item" data-key="{{key}}">
+            <input {{@root.disabled}} type="text" name="services[{{key}}].name" value="{{service.name}}" data-dtype="String" />
+            <input {{@root.disabled}} type="checkbox" name="services[{{key}}].system.moral" {{#if service.system.moral}}checked{{/if}} />
+            <input {{@root.disabled}} type="number" name="services[{{key}}].system.qualite" value="{{service.system.qualite}}" data-dtype="Number" min="-10" max="10"/>
+            <input {{@root.disabled}} type="number" class="input-prix" name="services[{{key}}].system.cout" value="{{numberFormat service.system.cout decimals=2 sign=false}}" data-dtype="Number" min="0" />
+            <div class="item-controls">
+              <a class="service-acheter" data-tooltip="Acheter"><i class="fa-sharp fa-solid fa-coins"></i></a>
+              {{#unless @root.disabled}}
+              <a class="service-vendre" data-tooltip="Proposer"><i class="fas fa-comments-dollar"></i></a>
+              <a class="service-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
+              {{/unless}}
+            </div>
+          </li>
+          {{/each}}
+        </ul>
+      </div>
+    --}}
     <br>
     {{> "systems/foundryvtt-reve-de-dragon/templates/actor/editor-notes-mj.html"}}
     <br>

templates/actor/commerce-inventaire-item.html

@@ -39,7 +39,23 @@
       {{/if}} />
     {{/unless}}
   </span>
-  {{>'systems/foundryvtt-reve-de-dragon/templates/actor/item-action-controls.hbs' item=item options=@root.options}}
+  <span class="equipement-actions item-controls">
+    {{#if options.isOwner}}
+      <a class="item-edit" data-tooltip="Editer"><i class="fas fa-edit"></i></a>
+      {{#unless (and (eq item.type 'conteneur') (not vide))}}
+        <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
+        {{#if (or item.parent.system.illimite (ne item.system.quantite 0))}}
+        <a class="item-vendre" data-tooltip="Vendre"><i class="fas fa-comments-dollar"></i></a>
+        {{/if}}
+      {{/unless}}
+    {{/if}}
+    {{#unless (and (eq item.type 'conteneur') (not vide))}}
+      {{#if (or item.parent.system.illimite (gt item.system.quantite 0))}}
+      <a class="item-acheter" data-tooltip="Acheter"><i class="fa-regular fa-coins"></i></a>
+      {{/if}}
+      <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
+    {{/unless}}
+  </span>
 </li>
 {{/if}}
 {{/unless}}

templates/actor/comp-creature.html

@@ -4,7 +4,7 @@
 <ul class="item-list alterne-list">
   {{#each (trier competences) as |comp key|}}
   <li class="item flexrow list-item" data-item-id="{{comp._id}}">
-    <a class="list-item-label roll-competence">
+    <a class="competence-label roll-competence">
       <img class="sheet-competence-img" src="{{comp.img}}" data-tooltip="{{comp.name}}"/>
       <span>{{comp.name}}</span>
     </a>
@@ -23,7 +23,12 @@
         {{#unless @root.options.vueDetaillee}}disabled{{/unless}}
       {{else}}disabled{{/if}}
       />
-    {{>'systems/foundryvtt-reve-de-dragon/templates/actor/item-action-controls.hbs' item=comp options=@root.options}}
+    {{#if @root.options.vueDetaillee}}
+    <div class="item-controls">
+      <a class="item-edit" data-tooltip="Modifier"><i class="fas fa-edit"></i></a>
+      <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
+    </div>
+    {{/if}}
   </li>
   {{/each}}
 </ul>

templates/actor/comp-possession.html

@@ -4,8 +4,11 @@
     {{#each possessions as |possession key|}}
     <li class="item flexrow list-item" data-item-id="{{possession._id}}">
       <img class="sheet-competence-img" src="{{possession.img}}" data-tooltip="{{possession.name}}"/>
-      <span class="list-item-label">{{possession.name}}</span>
+      <span class="competence-label">{{possession.name}}</span>
-      {{>'systems/foundryvtt-reve-de-dragon/templates/actor/item-action-controls.hbs' item=possession options=@root.options}}
+      <div class="item-controls">
+        <a class="item-edit" data-tooltip="Modifier"><i class="fas fa-edit"></i></a>
+        <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
+      </div>
     </li>
     {{/each}}
   </ol>

templates/actor/competence-categorie.html

@@ -14,17 +14,17 @@
       <span class="competence-xp-sort">sort</span>
       {{/if}}
       <div class="item-controls">
-        <i class="fa-regular fa-arrow-alt-circle-up"></i>
+        <i class="far fa-arrow-alt-circle-up"></i>
         <span class="competence-archetype">Arch.</span>
-        <i class="fa-regular fa-edit"></i>
+        <i class="far fa-edit"></i>
         {{#if @root.options.isGM}}
-        <i class="fa-regular fa-trash"></i>
+        <i class="far fa-trash"></i>
         {{/if}}
       </div>
       {{/if}}
     </li>
     {{#each competences as |comp key|}}
-    {{> "systems/foundryvtt-reve-de-dragon/templates/actor/competence.hbs" comp}}
+    {{> "systems/foundryvtt-reve-de-dragon/templates/actor/competence.html" comp}}
     {{/each}}
     <li></li>
   </ul>

templates/actor/competence.html

@@ -1,7 +1,7 @@
 {{#unless system.isHidden}}
   <li class="item flexrow list-item {{#if system.isLevelUp}}xp-level-up{{/if}}" data-item-id="{{_id}}">
     <span class="tooltip">
-      <a class="list-item-label roll-competence" name="{{name}}" data-tooltip="Niveau {{plusMoins system.niveau}} en {{name}}">
+      <a class="competence-label roll-competence" name="{{name}}" data-tooltip="Niveau {{plusMoins system.niveau}} en {{name}}">
         <img class="sheet-competence-img" src="{{img}}"/>
         <span>{{name}}</span>
       </a>
@@ -46,8 +46,13 @@
       <input class="competence-archetype niveau-archetype" type="text" compname="{{name}}" name="comp-archetype-{{name}}"
             value="{{plusMoins system.niveau_archetype}}" data-dtype="number" data-tooltip="Niveau d'archétype {{plusMoins system.niveau_archetype}}"
             {{#if (not @root.options.vueArchetype)}}disabled{{/if}} />
+      <a class="item-edit" data-tooltip="Modifier"><i class="fas fa-edit"></i></a>
+      {{#if @root.options.isGM}}
+      <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
+      {{/if}}
+      &nbsp;
+      <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
     </div>
-    {{>'systems/foundryvtt-reve-de-dragon/templates/actor/item-action-controls.hbs' item=this options=@root.options}}
     {{/if}}
 </li>
 {{/unless}}

templates/actor/dragon-queue.html

@@ -7,5 +7,11 @@
     {{/if}}
     <a>{{queue.name}}</a>
   </span>
-  {{>'systems/foundryvtt-reve-de-dragon/templates/actor/item-action-controls.hbs' item=queue options=@root.options}}
+  <div class="item-controls">
+    <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
+    <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
+    {{#if queue.system.refoulement}}
+    <a class="item-action">Refouler</a>
+    {{/if}}
+  </div>
 </li>

templates/actor/dragon-queues.html

@@ -6,10 +6,10 @@
 </h3>
 <ul class="item-list">
   {{#each queues as |queue key|}}
-  {{> "systems/foundryvtt-reve-de-dragon/templates/actor/dragon-queue.hbs" queue=queue key=key}}
+  {{> "systems/foundryvtt-reve-de-dragon/templates/actor/dragon-queue.html" queue=queue key=key}}
   {{/each}}
   {{#each ombres as |ombre key|}}
-  {{> "systems/foundryvtt-reve-de-dragon/templates/actor/dragon-queue.hbs" queue=ombre key=key}}
+  {{> "systems/foundryvtt-reve-de-dragon/templates/actor/dragon-queue.html" queue=ombre key=key}}
   {{/each}}
 </ul>
 {{/if}}

templates/actor/dragon-souffles.html

@@ -5,7 +5,10 @@
   <li class="item flexrow" data-attribute={{key}} data-item-id="{{souffle._id}}" data-tooltip="Souffle: {{souffle.name}}">
     <img class="sheet-competence-img" src="{{souffle.img}}"/>
     <span class="item-edit flex-grow"><a>{{souffle.name}}</a></span>
-    {{>'systems/foundryvtt-reve-de-dragon/templates/actor/item-action-controls.hbs' item=souffle options=@root.options}}
+    <div class="item-controls">
+      <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
+      <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
+    </div>
   </li>
   {{/each}}
 </ul>