Merge pull request 'v10.7.20 - la cuirasse de Sémolosse' (#662) from VincentVk/foundryvtt-reve-de-dragon:v10 into v10

Reviewed-on: #662

.gitignore

@@ -1,5 +1,10 @@
 .vscode/settings.json
 .idea
+.history
 todo.md
 /.vscode
 /ignored/
+/node_modules/
+/jsconfig.json
+/package.json
+/package-lock.json

changelog.md

@@ -1,10 +1,298 @@
-==================================================================
+# v10.7 - L'os de Sémolosse
-v0.9.2 - 05/09/2020
 
-Erreur de calcul sur points de vie
+## v10.7.20 - la poigne de Sémolosse
-Gestion différente des compétences "troncs"
+- correction de méthodes qui filtrent les items
+  - recherche de cases TMR
+  - recherche de tâches de lecture
+  - recherche d'armure (pour le malus armure)
+  - recherche de potions
 
-==================================================================
+## v10.7.20 - la poigne de Sémolosse
-v0.9.1 - 03/09/2020
+- correction de l'empoignade
+  - les items d'empoignade sont ajoutés par le MJ quand nécessaire
+  - seul le joueur propriétaire du personnage peut effectuer ses choix et actions d'empoignade
+  - les caractéristiques du défenseur sont utilisées pour la défense
+  - la difficulté d'attaque est imposée au défenseur
+  - les attaques particulières sont en finesse (p133)
+  - on peut entraîner au sol dès 2 points d'empoignade
+  - les actions liée à l'immobilisation sont proposées en fin de round
 
-Initial official release
+## v10.7.19 - les fantômes de Sémolosse
+- les créatures ont maintenant le droit d'avoir des compétences de tir, lancer, mêlée, armes naturelles, parade.
+- les créatures armées utilisent la bonne phase d'initiative
+- correction des possessions
+  - la difficulté de la défense est imposée par l'attaque
+  - une attaque particulière de possession est en finesse
+  - le rêve actuel des personnages est bien utilisé
+- correction des achats par le MJ sans acteur sélectionné
+
+## v10.7.18 - le repos de Sémolosse
+- correction des dates de blessures qui ne marchaient plus
+
+## v10.7.17 - le doigt du destin de Sémolosse
+- correction de la validation d'encaissement par le MJ
+
+## v10.7.16 - la morsure de Sémolosse
+- correction de l'affichage des objets suite à confusion
+- correction de liens dans la liste des équipements
+
+## v10.7.14 - l'expérience de Sémolosse
+- Affichage des personnages accordés sur les fiches des entités
+- Refonte du journal d'expérience
+  - disponible pour les personnages des joueurs
+  - explication "comptable" des changements (dépense ou ajout, changements de niveaux, ...)
+- tri alphabétique des différentes listes (sorts, recettes, oeuvres, ...)
+
+## v10.7.13 - l'armure de Sémolosse
+- Fix: en cas d'armure variable, la détérioration diminue le dé d'armure
+
+## v10.7.12
+- Fix: si le MJ gère les changements de jours, l'option "sieste" de la fenêtre de repos est prise par défaut si chateau dormant n'est pas passé
+
+## v10.7.11 - Le Pugilat de Sémolosse
+- Fix sur la projection au sol.
+
+## v10.7.10 - Le Pugilat de Sémolosse
+- Gestion de l'empoignade
+- Corrections sur l'initiative
+- Correction sur l'equipement des vêtements et bijoux
+
+##  v10.7.9 - Le Pugilat de Sémolosse
+
+- Gestion assistée de l'empoignade
+  1. On selectionne sa cible (ie le token qui va être empoigné)
+  2. On lance une attaque avec l'"arme" _Empoignade_
+  3. A ce stade, si la victime a une arme, on rappelle le point de règle d'engagement 
+    (page 134), et un bouton permet de confirmer l'empoignade
+  4. L'empoigneur fait son jet
+  5. Si réussite, l'empoigné peut se défendre, avec gestion du premier round d'engagement
+    (ie Esquive autorisée ou pas)
+    - 4 bis. et 5 bis. L'empoigné, à son tour, peut tenter de se libérer, toujours en cliquant sur l'action "Empoignade"
+  6. Selon le résultat, incrément/décrément des points d'emp
+  7. Retour en 4., ou si 2 points d'Emp, alors 8.
+  8. Affichage des options disponibles pour l'empoigneur : perte d'endurance, projection au
+    sol ou entrainer au sol. Ces 3 options sont gérées automatiquement ensuite, selon le
+    bouton cliqué par l'empoigneur.
+
+  Les empoignades sont des "items" supprimées à la fin d'un combat, qui peuvent aussi être
+  gérés par le MJ au cas ou. Hors combat, penser à les supprimer (ou commencer et
+  arrêter un combat).
+
+## v10.7.7 - Les bobos de Sémolosse
+- Mise à jour du texte de l'heure pour les joueurs
+- L'horloge n'empêche plus de sélectionner les tokens dessous
+- _Lecture & Détection d'Aura_ sous Hypnos sont des rituels
+- _Lire les étoiles_ pour les joueurs de nouveau fonctionnel
+- Ajout de logs pour comprendre un cas d'échec des achatVente
+
+## v10.7.6 - L'origine des maux de Sémolosse
+- Calendrier
+  - fix du ré-affichage de l'horloge qui ne marchait pas pour les joueurs
+  - l'horloge ne se ferme plus sur Escape
+  - amélioration d'affichage
+  - couleurs jour/nuit plus marquées
+- Divers
+  - correction de l'affichage de quantités diminuées d'herbes dans les contenants ouvert
+  - ajout d'un bouton pour diminuer les quantités dans l'équipement (si quantité > 1)
+  - ajout de la signature de l'acteur sur les blessures qu'il a causées
+
+- Magie
+  - correction des bonus de cases pour les sorts en Fleuve
+
+## v10.7.5 - La montre-gousset de Sémolosse
+- Amélioration de la fenêtre calendrier
+  * plus compacte
+  * horloge analogique (optionnelle)
+  * minimizable (juste la barre de titre)
+  * normalement compatible pop-out
+
+## v10.7.4 - Les ligatures de Sémolosse
+- Corrections diverses
+  - Correction des boutons pour déclencher un sort en réserve avec réserve en sécurité ou réserve extensible
+  - le lien pour les jets de vie suite à une blessure critique est remplacé par un bouton
+  - déplacement des tâches et boutons de chirurgie dans l'onglet savoirs et tâches
+  - correction de l'affichage des bonus de cases des sorts
+  - corrections des queues non-refoulables dans le compendium
+
+## v10.7.3 - Les tisanes de Sémolosse
+- Soins
+  - on peut de nouveau boire une potion de soins enchantée
+  - les potions non enchantées donnent de nouveau un bonus au prochain jet de récupération
+  - Une fois les soins complets faits, le bonus aux soins complets fournis par les premiers soins est masqué
+
+- Horloge
+  - A l'heure de Couronne pile, les aiguilles des heures et des minutes pointent sur couronne (comme une montre) au lieu d'avoir l'aiguille des heures 15° à gauche
+
+## v10.7.2 - les maux de dents de Sémolosse
+- correction des récupérations de blessures
+- la fin de château dormant se passe normalement
+
+## v10.7.1 - L'os de Sémolosse
+- Fix rapide sur les jets de carac qui n'étaient plus possibles
+
+## v10.7.0 - L'os de Sémolosse
+- gestion des blessures en items
+- soins du token ciblé par menu contextuel (comme le combat)
+- automatisation des soins et de l'affichage de l'avancement des soins
+- support des changements d'opérants
+
+ --- 
+# v10.6 - Les recherches de Pralinor le Goûteux
+
+## v10.6.25 - Fix sur l'astrologie
+
+## v10.6.22 - le nuage de lait dans le thé de Pralinor
+- Amélioration de l'affichage de l'horloge
+- Fix: affichage des points de guérison dans les potions
+
+## v10.6.21 - La théière de Pralinor
+- Astrologie
+  - le thème astral est directement dans la fenêtre d'astrologie
+  - la roue des heures sert d'horloge
+  - sélectionner un personnage ajuste le thème astral pour son heure de naissance
+  - sélectionner le nombre astral d'un jour ajuste le thème astral
+
+- Fix: les PNJs peuvent de nouveau dormir
+
+## v10.6.20 - Les Oracles de Pralinor: vous mangerez à Couronne
+- Ajout de la fenêtre pour effectuer un thème astral
+
+## v10.6.19 - La cerise de Pralinor
+- les joueurs peuvent chercher dans les commerces avec un droit limité/observateur
+- simplifications des fins de tours et nombre d'utilisations
+- ajout du _Haubert d'Oniros_ dans le compendium de sorts
+
+## v10.6.17 - Les désordres de Pralinor
+- le contenu des casseroles et autres contenants est maintenant trié dans l'ordre alphabétique
+- les objets dupliqués du compendium d'équipement sont de nouveaux uniques
+
+## v0.6.16 - Le pardon de Pralinor
+- Ajout d'un commerce _Liste d'équipement_ dans les archétypes de PNJs
+- Séparations d'équipements groupés et corrections de quelques objets & herbes
+- On peut éditer les armes stockées dans un commerce
+
+## v10.6.15 - les digestifs de Pralinor
+- amélioration des messages de sommeil (nombre d'heure dormies, uniquement les
+  récupérations de rêve en dessous du seuil, affichage de la récupération d'endurance
+  qui avait disparu, meilleur message sur le jet de moral)
+- les insomnies ne durent bien que 12h draconique à partir du prochain
+  Chateau Dormant (elles pouvaient durer 3 nuits suite à une erreur).
+- la recherche dans l'équipement affiche correctement les conteneurs dans lesquels les
+  objets trouvés sont rangés
+
+## v10.6.14 - la digestion de Pralinor
+- Chateau dormant
+  - la situation du jet de moral peut être choisie lorsque l'on dort
+  - les queues de dragon "insomnie" empêchent de dormir, et de rêver
+  - ajout d'une option pour meilleure gestion de Chateau Dormant par le MJ
+  - avec cette option, à la fin Chateau Dormant, une fenêtre permet au gardien de
+    positionner pour chaque joueur:
+    - le stress de la journée
+    - les heures de sommeil
+    - la situation du jet de moral (neutre/heureux/malheureux)
+
+- l'affichage des heures Chateau Dormant et Poisson Acrobate est correct
+- le jet de moral en situation neutre fait maintenant retourner le moral vers 0, et 
+  n'affecte plus un moral à 0.
+## v10.6.13 - la cave de Pralinor
+- on peut maintenant chercher dans l'inventaire des commerces
+- l'inventaire est correctement affiché en entier après suppression de la recherche
+- le message de chateau dormant reflète correctement un jet de moral neutre qui passe le moral de 0 à +1
+
+## v10.6.12 - l'index de Pralinor
+- On peut désormais chercher dans l'inventaire comme dans les compétences
+
+## v10.6.11 - l'empoisonnement de Pralinor
+- La récupération est bloquée par les maladies. Pas de récupération de vie ou de blessures possibles sous l'effet d'un poison ou d'une maladie
+- ajout d'un "poison" pour bloquer la récupération sous Griffe Morbide de Thanatos.
+  Ajout du lien vers l'objet du compendium dans la description MJ,, qui pourra donc
+  ajouter ce "poison" à la victime pour empêcher ses guérisons de vie ou blessure.
+
+## v10.6.10 
+- Correction de l'édition des description
+- Amélioration des descriptions d'alchimie:
+  - difficulté calculée automatiquement
+  - Température pour les couleurs
+- La sustentation n'est plus concaténée dans certains cas (ce qui donnait 2+2=22)
+
+## v10.6.8 : les bon mots de Pralinor
+- Dans la fenêtre de _recherche et tirages_, possibilité de chercher sur le nom des objets en plus des autres critères
+
+## v10.6.7 : les grumelés de Pralinor
+- les objets peuvent être utilisés depuis la fenêtre d'un conteneur
+- dans les fenêtres de contenants, le contenu est correctement indenté
+- la présentation du contenu d'un sac est améliorée
+- le bouton Nouvel Objet n'est affiché que si on est propriétaire de l'acteur
+- la fenêtre de vente permet de nouveau de choisir les quantités à vendre
+
+## v10.6.6
+- Corrections d'armes rudimentaires
+- Inversion: Taille puis poids
+- Suppression d'une ligne de caractéristique vide (causée par la beauté)
+- Les messages liés aux compétences troncs deviennent des notifications
+## v10.6.5
+- Le +dom est de nouveau affiché
+- L'édition de caractéristiques des créatures fonctionne de nouveau
+
+## v10.6.4 - La sénilité de Pralinor
+- Fenêtre _Recherches et tirages_
+  - les résultats de recherches sur plusieurs compendiums sont triés
+  - lors de recherches avec un ou des milieux sélectionnés:
+    - le filtre sur la rareté utilise la rareté dans ces milieux
+    - les tirages se basent sur la fréquence la plus élevées dans ces milieux
+  - les filtres par utilisation prennent les potions en compte
+  - les remèdes ont une catégorie de potion 'Remède' (et correspondent à une utilisation médicale)
+  - ajout d'un filtre d'utilisation 'cuisine'
+
+
+# Divers
+- fix du cas où la transformation de 0 points de stress était concaténé, (passage de 29 à 290 avec 0 points transformés)
+- suppression du compendium de taches courantes, désormais inutile
+
+## v10.6.3 - le baba-brandevin de Pralinor
+- les tâches de Soins sont maintenant déplacées à côté des blessures
+- on peut créer les tâches de soins directement avec un bouton par gravité.
+
+- le round n'est plus bloqué si un acteur est sonné
+- un rare cas d'initiative négative pouvait empêcher de faire une initiative (à cause de l'état général)
+- dans une circonstance inconnue, une rencontre pouvait disparaître lors de la maîtrise. Ajout d'un message pour essayer d'obtenir des détails sur ce cas, et ajout d'une sécurité pour retrouver la rencontre (qui est conservée par la fenêtre de choix d'action).
+- les objets temporels (queues, souffles, poisons, maladies...) créés avant la gestion temporelle ne pouvaient pas être édités.
+- les particulières sur les jets de résistance de rêve actuel ne rapportent qu'un point d'expérience (p191)
+- pour lutter contre l'alcoolisme, les jets d'éthylisme sont considérés comme des jets de résistance, et n'apportent qu'un point d'expérience.
+## v10.6.2 - Le méli-mélo de Pralinor
+- Fenêtre _Recherches et tirages_
+  - support de la recherche dans les compendiums choisis
+  - suppression des commandes `/table milieu` et `/tirer milieu` (remplacées par la fenêtre de recherche)
+  - ajout de fréquences à tous les équipements
+## v10.6.1 - Les recherches de Pralinor
+- Fenêtre _Recherches et tirages_
+  - Amélioration des filtres de cuisine/utilisation
+  - Ajout de catégories pour les poisons, urtiquants, ...
+  - Bouton "Effacer les filtres" plus clair
+  - Drag&drop depuis la recherche
+  - Reprise du compendium
+      - pour les plantes vénéneuses
+      - pour les plantes venimeuses
+      - ajout de sust pour les champignons et autres plantes comestibles
+
+- Affichage de l'image du token pour les commerces non liés
+- Les pièces d'or sont appelées 'Dragon'
+
+## v10.6.0 - Les recherches de Pralinor le Goûteux
+- Fenêtre _Recherches et tirages_
+  - ajout de la fenêtre _Recherches et tirages_ avec filtres paramétrables
+  - ouverture de la fenêtre: commande `/tirage` ou macro disponible dans les macros du système
+  - support des équipements, faune & flore (depuis les compendiums configurés par défaut)
+  - nombreux choix à activer
+  - possibilité de montrer les objets correspondant à la sélection
+  - possibilité de faire un tirage parmi ces objets (en prenant en compte la fréquence)
+
+- Plantes & pèche
+  - séparation des ingrédients et plantes comestibles
+  - retour des poissons dans les compendiums
+  - ajout d'un lien depuis les plantes toxiques/dangereuses vers la maladie/poison correspondante
+
+- On peut de nouveau ouvrir les conteneurs dans une fenêtre séparée
+- Les jets de volontés d'éthylisme calculent correctement la difficulté liée au moral (ie: 0 au lieu de -22)
+- si le journal de chronologie est supprimée, on peut en choisir un autre
+- la taille du calendrier est ajustée pour éviter une présentation bancale quand le nom du mois est court

lang/fr.json

@@ -3,47 +3,52 @@
     "TypePersonnage": "Personnage",
     "TypeCreature": "Créature",
     "TypeEntite": "Entité de cauchemar",
+    "TypeCommerce": "Commerce",
     "TypeVehicule": "Véhicule"
   },
   "ITEM": {
-    "TypeObjet": "Objet",
-    "TypeGemme": "Gemme",
-    "TypeCompetence": "Compétence",
-    "TypeCompetencecreature": "Compétence de créature",
-    "TypeMaladie": "Maladie",
-    "TypePoison": "Poison",
-    "TypeNombreastral": "Nombre astral",
-    "TypeTarot": "Carte de tarot",
-    "TypeCasetmr": "TMR spéciale",
-    "TypeRencontre": "Rencontre TMR",
-    "TypeMunition": "Munition",
-    "TypeMonnaie": "Monnaie",
-    "TypeHerbe": "Herbe ou plante",
-    "TypeIngredient": "Ingrédient",
-    "TypeLivre": "Livre",
-    "TypePotion": "Potion",
     "TypeArme": "Arme",
     "TypeArmure": "Armure",
-    "TypeConteneur": "Conteneur",
+    "TypeBlessure": "Blessure",
-    "TypeNourritureboisson": "Nourriture & boisson",
+    "TypeCasetmr": "TMR spéciale",
     "TypeChant": "Chant",
+    "TypeCompetence": "Compétence",
+    "TypeCompetencecreature": "Compétence de créature",
+    "TypeConteneur": "Conteneur",
     "TypeDanse": "Danse",
-    "TypeMusique": "Musique",
+    "TypeExtraitpoetique": "Extrait poetique",
-    "TypeOeuvre": "Oeuvre",
+    "TypeFaune": "Faune",
-    "TypeTache": "Tâche",
+    "TypeGemme": "Gemme",
+    "TypeHerbe": "Herbe",
+    "TypeIngredient": "Ingrédient",
     "TypeJeu": "Jeu",
+    "TypeLivre": "Livre",
+    "TypeMaladie": "Maladie",
+    "TypeMeditation": "Méditation",
+    "TypeMonnaie": "Monnaie",
+    "TypeMunition": "Munition",
+    "TypeMusique": "Musique",
+    "TypeNombreastral": "Nombre astral",
+    "TypeNourritureboisson": "Nourriture & boisson",
+    "TypeObjet": "Objet",
+    "TypeOeuvre": "Oeuvre",
+    "TypeOmbre": "Ombre de Thanatos",
+    "TypePlante": "Plante",
+    "TypePoison": "Poison",
+    "TypePossession": "Possession",
+    "TypePotion": "Potion",
+    "TypeQueue": "Queue de Dragon",
     "TypeRecettealchimique": "Recette alchimique",
     "TypeRecettecuisine": "Recette de cuisine",
-    "TypeSort": "Sort",
+    "TypeRencontre": "Rencontre TMR",
-    "TypeMeditation": "Méditation",
+    "TypeService": "Service",
     "TypeSignedraconique": "Signe draconique",
-    "TypeQueue": "Queue de Dragon",
+    "TypeSort": "Sort",
-    "TypeOmbre": "Ombre de Thanatos",
-    "TypeSouffle": "Souffle de Dragon",
-    "TypeTete": "Tête de Dragon",
-    "TypePossession": "Possession",
     "TypeSortreserve": "Sort en réserve",
-    "TypeExtraitpoetique": "Extrait poetique"
+    "TypeSouffle": "Souffle de Dragon",
+    "TypeTache": "Tâche",
+    "TypeTarot": "Carte de tarot",
+    "TypeTete": "Tête de Dragon"
   },
   "EFFECT": {
     "StatusStunned": "Sonné",

module/actor-creature-sheet.js

@@ -27,24 +27,17 @@ export class RdDActorCreatureSheet extends RdDActorSheet {
     if (!this.options.editable) return;
 
     // On competence change
-    html.find('.creature-carac').change(async event => {
+    this.html.find('.creature-carac').change(async event => {
       let compName = event.currentTarget.attributes.compname.value;
       this.actor.updateCreatureCompetence(compName, "carac_value", parseInt(event.target.value));
     });
-    html.find('.creature-niveau').change(async event => {
+    this.html.find('.creature-niveau').change(async event => {
       let compName = event.currentTarget.attributes.compname.value;
       this.actor.updateCreatureCompetence(compName, "niveau", parseInt(event.target.value));
     });
-    html.find('.creature-dommages').change(async event => {
+    this.html.find('.creature-dommages').change(async event => {
       let compName = event.currentTarget.attributes.compname.value;
       this.actor.updateCreatureCompetence(compName, "dommages", parseInt(event.target.value));
     });
   }
-
-  /* -------------------------------------------- */
-  /** @override */
-  _updateObject(event, formData) {
-    // Update the Actor
-    return this.object.update(formData);
-  }
 }

module/actor-entite-sheet.js

@@ -1,4 +1,6 @@
 import { RdDActorSheet } from "./actor-sheet.js";
+import { RdDSheetUtility } from "./rdd-sheet-utility.js";
+import { RdDUtility } from "./rdd-utility.js";
 
 export class RdDActorEntiteSheet extends RdDActorSheet {
 
@@ -9,10 +11,16 @@ export class RdDActorEntiteSheet extends RdDActorSheet {
       template: "systems/foundryvtt-reve-de-dragon/templates/actor-entite-sheet.html",
       width: 640,
       height: 720,
-      tabs: [{navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac"}],
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }],
-      dragDrop: [{dragSelector: ".item-list .item", dropSelector: undefined}]
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }]
     });
   }
+  async getData() {
+    let formData = await super.getData();
+    formData.resonances = this.actor.system.sante.resonnance.actors.map(actorId => game.actors.get(actorId))
+      .map(actor => { return { id: actor.id, name: actor.name, img: actor.img } })
+    return formData
+  }
 
   /* -------------------------------------------- */
   /** @override */
@@ -23,18 +31,35 @@ export class RdDActorEntiteSheet extends RdDActorSheet {
     if (!this.options.editable) return;
 
     // On competence change
-    html.find('.creature-carac').change(async event => {
+    this.html.find('.creature-carac').change(async event => {
       let compName = event.currentTarget.attributes.compname.value;
-        this.actor.updateCreatureCompetence( compName, "carac_value", parseInt(event.target.value) );
+      this.actor.updateCreatureCompetence(compName, "carac_value", parseInt(event.target.value));
-      } );    
+    });
-    html.find('.creature-niveau').change(async event => {
+    this.html.find('.creature-niveau').change(async event => {
       let compName = event.currentTarget.attributes.compname.value;
-        this.actor.updateCreatureCompetence( compName, "niveau", parseInt(event.target.value) );
+      this.actor.updateCreatureCompetence(compName, "niveau", parseInt(event.target.value));
-      } );    
+    });
-      html.find('.creature-dommages').change(async event => {
+    this.html.find('.creature-dommages').change(async event => {
       let compName = event.currentTarget.attributes.compname.value;
-        this.actor.updateCreatureCompetence( compName, "dommages", parseInt(event.target.value) );
+      this.actor.updateCreatureCompetence(compName, "dommages", parseInt(event.target.value));
-      } );    
+    });
+    this.html.find('.resonance-delete').click(async event => {
+      const li = RdDSheetUtility.getEventElement(event);
+      const actorId = li.data("actor-id");
+      if (actorId) {
+        const actorResonance = game.actors.get(actorId);
+        RdDUtility.confirmerSuppressionSubacteur(this, actorResonance, li, () => {
+          console.log('Delete : ', actorId);
+          this.removeSubacteur(actorId);
+          RdDUtility.slideOnDelete(this, li);
+        });
+      }
+    });
+  }
+
+  async removeSubacteur(actorId) {
+    let newResonances = this.actor.system.sante.resonnance.actors.filter(id => id != actorId);
+    await this.actor.update({ 'system.sante.resonnance.actors': newResonances }, { renderSheet: false });
   }
 
 }

module/actor-sheet.js

@@ -8,16 +8,20 @@ import { RdDCombatManager } from "./rdd-combat.js";
 import { RdDCarac } from "./rdd-carac.js";
 import { DialogSplitItem } from "./dialog-split-item.js";
 import { ReglesOptionelles } from "./settings/regles-optionelles.js";
-import { DialogRepos } from "./dialog-repos.js";
 import { RdDSheetUtility } from "./rdd-sheet-utility.js";
 import { STATUSES } from "./settings/status-effects.js";
+import { MAINS_DIRECTRICES } from "./actor.js";
+import { RdDBaseActorSheet } from "./actor/base-actor-sheet.js";
+import { RdDItem } from "./item.js";
+import { RdDItemBlessure } from "./item/blessure.js";
+import { RdDEmpoignade } from "./rdd-empoignade.js";
 
 /* -------------------------------------------- */
 /**
  * Extend the basic ActorSheet with some very simple modifications
  * @extends {ActorSheet}
  */
-export class RdDActorSheet extends ActorSheet {
+export class RdDActorSheet extends RdDBaseActorSheet {
 
   /** @override */
   static get defaultOptions() {
@@ -35,51 +39,38 @@ export class RdDActorSheet extends ActorSheet {
 
   /* -------------------------------------------- */
   async getData() {
-    this.timerRecherche = undefined;
+    let formData = await super.getData();
-    this.actor.computeEtatGeneral();
+    mergeObject(formData,
-
+      {
-    let formData = {
-      title: this.title,
-      id: this.actor.id,
-      type: this.actor.type,
-      img: this.actor.img,
-      name: this.actor.name,
         editable: this.isEditable,
         cssClass: this.isEditable ? "editable" : "locked",
-      system: foundry.utils.deepClone(this.actor.system),
         effects: this.actor.effects.map(e => foundry.utils.deepClone(e)),
         limited: this.actor.limited,
-      options: this.options,
         owner: this.actor.isOwner,
-      description: await TextEditor.enrichHTML(this.object.system.description, {async: true}),
+        biographie: await TextEditor.enrichHTML(this.actor.system.biographie, { async: true }),
-      biographie: await TextEditor.enrichHTML(this.object.system.biographie, {async: true}),
+        notes: await TextEditor.enrichHTML(this.actor.system.notes, { async: true }),
-      notes: await TextEditor.enrichHTML(this.object.system.notes, {async: true}),
+      });
-      notesmj: await TextEditor.enrichHTML(this.object.system.notesmj, {async: true}),
+    mergeObject(formData.calc, {
-      calc: {
+      surenc: this.actor.computeMalusSurEncombrement(),
-        encTotal: await this.actor.computeEncombrementTotalEtMalusArmure(),
-        prixTotalEquipement: this.actor.computePrixTotalEquipement(),
       surprise: RdDBonus.find(this.actor.getSurprise(false)).descr,
       resumeBlessures: this.actor.computeResumeBlessure(this.actor.system.blessures),
       caracTotal: RdDCarac.computeTotal(this.actor.system.carac, this.actor.system.beaute),
       surEncombrementMessage: this.actor.getMessageSurEncombrement(),
-      },
+    })
-    }
-    formData.options.isGM =  game.user.isGM;
 
-    RdDUtility.filterItemsPerTypeForSheet(formData, this.actor.itemTypes);
+    this.timerRecherche = undefined;
-    this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.objets);
-    formData.conteneurs = RdDUtility.conteneursRacine(formData.conteneurs);
 
     if (formData.type == 'personnage') {
+      formData.options.mainsDirectrices = MAINS_DIRECTRICES;
       formData.byCateg = Misc.classify(formData.competences, it => it.system.categorie)
       formData.calc.comptageArchetype = RdDItemCompetence.computeResumeArchetype(formData.competences);
-      formData.calc.competenceXPTotal= RdDItemCompetence.computeTotalXP(formData.competences);
+      formData.calc.competenceXPTotal = RdDItemCompetence.computeTotalXP(formData.competences);
-      formData.calc.fatigue= RdDUtility.calculFatigueHtml(formData.system.sante.fatigue.value, formData.system.sante.endurance.max);
+      formData.calc.fatigue = RdDUtility.calculFatigueHtml(formData.system.sante.fatigue.value, formData.system.sante.endurance.max);
 
       formData.competences.forEach(item => {
-        item.system.isVisible = this.options.recherche
+        item.system.isHidden = this.options.recherche
-        ? RdDItemCompetence.nomContientTexte(item, this.options.recherche.text)
+          ? !item.isNomLike(this.options.recherche.text)
-        : (!this.options.showCompNiveauBase || !RdDItemCompetence.isNiveauBase(item));
+          : (this.options.showCompNiveauBase && RdDItemCompetence.isNiveauBase(item));
         RdDItemCompetence.levelUp(item, formData.system.compteurs.experience.value);
       });
 
@@ -93,6 +84,7 @@ export class RdDActorSheet extends ActorSheet {
       RdDItemArme.ajoutCorpsACorps(formData.combat, formData.competences, formData.system.carac);
       formData.esquives = this.actor.getCompetences("Esquive");
       formData.combat = RdDCombatManager.listActionsArmes(formData.combat, formData.competences, formData.system.carac);
+      formData.empoignades = this.actor.getEmpoignades();
 
       this.armesList = formData.combat;
 
@@ -118,6 +110,339 @@ export class RdDActorSheet extends ActorSheet {
     return formData;
   }
 
+  /* -------------------------------------------- */  /** @override */
+  activateListeners(html) {
+    super.activateListeners(html);
+
+    HtmlUtility.showControlWhen(this.html.find(".appliquerFatigue"), ReglesOptionelles.isUsing("appliquer-fatigue"));
+
+    // Everything below here is only needed if the sheet is editable
+    if (!this.options.editable) return;
+
+    this.html.find('.item-action').click(async event => {
+      const item = RdDSheetUtility.getItem(event, this.actor);
+      item?.actionPrincipale(this.actor, async () => this.render())
+    });
+
+    this.html.find('.subacteur-delete').click(async event => {
+      const li = RdDSheetUtility.getEventElement(event);
+      const actorId = li.data("actor-id");
+      if (actorId) {
+        const subActor = game.actors.get(actorId);
+        RdDUtility.confirmerSuppressionSubacteur(this, subActor, li, () => {
+          console.log('Delete : ', subActor.id);
+          this.actor.removeSubacteur(subActor.id);
+          RdDUtility.slideOnDelete(this, li);
+        });
+      }
+    });
+    this.html.find('.experiencelog-delete').click(async event => {
+      const li = this.html.find(event.currentTarget)?.parents(".experiencelog");
+      const key = Number(li.data("key") ?? -1);
+      await this.actor.deleteExperienceLog(key, 1);
+    });
+    this.html.find('.experiencelog-delete-previous').click(async event => {
+      const li = this.html.find(event.currentTarget)?.parents(".experiencelog");
+      const key = Number(li.data("key") ?? -1);
+      await this.actor.deleteExperienceLog(0, key + 1);
+    });
+    this.html.find("input.derivee-value[name='system.compteurs.stress.value']").change(async event => {
+      this.actor.updateCompteurValue("stress", parseInt(event.target.value));
+    });
+    this.html.find("input.derivee-value[name='system.compteurs.experience.value']").change(async event => {
+      this.actor.updateCompteurValue("experience", parseInt(event.target.value));
+    });
+
+    this.html.find('.encaisser-direct').click(async event => {
+      this.actor.encaisser();
+    })
+    this.html.find('.sheet-possession-attack').click(async event => {
+      const poss = RdDSheetUtility.getItem(event, this.actor)
+      this.actor.conjurerPossession(poss)
+    })
+    this.html.find('.remise-a-neuf').click(async event => {
+      if (game.user.isGM) {
+        this.actor.remiseANeuf();
+      }
+    });
+    this.html.find('.creer-tache').click(async event => {
+      this.createEmptyTache();
+    });
+    this.html.find('.creer-tache-blessure-legere').click(async event => RdDItemBlessure.createTacheSoinBlessure(this.actor, 2));
+    this.html.find('.creer-tache-blessure-grave').click(async event => RdDItemBlessure.createTacheSoinBlessure(this.actor, 4));
+    this.html.find('.creer-tache-blessure-critique').click(async event => RdDItemBlessure.createTacheSoinBlessure(this.actor, 6));
+    this.html.find('.creer-blessure-legere').click(async event => RdDItemBlessure.createBlessure(this.actor, 2));
+    this.html.find('.creer-blessure-grave').click(async event => RdDItemBlessure.createBlessure(this.actor, 4));
+    this.html.find('.creer-blessure-critique').click(async event => RdDItemBlessure.createBlessure(this.actor, 6));
+    this.html.find('.creer-une-oeuvre').click(async event => {
+      this.selectTypeOeuvreToCreate();
+    });
+
+    this.html.find('.blessure-premierssoins-done').change(async event => {
+      const blessure = this.getBlessure(event);
+      await blessure?.setSoinsBlessure({ premierssoins: { done: event.currentTarget.checked } });
+    });
+    this.html.find('.blessure-soinscomplets-done').change(async event => {
+      const blessure = this.getBlessure(event);
+      await blessure?.setSoinsBlessure({ soinscomplets: { done: event.currentTarget.checked } })
+    });
+    this.html.find('.blessure-premierssoins-bonus').change(async event => {
+      const blessure = this.getBlessure(event);
+      await blessure?.setSoinsBlessure({ premierssoins: { bonus: Number(event.currentTarget.value) } })
+    });
+    this.html.find('.blessure-soinscomplets-bonus').change(async event => {
+      const blessure = this.getBlessure(event);
+      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));
+    });
+
+    // Roll Carac
+    this.html.find('.carac-label a').click(async event => {
+      let caracName = event.currentTarget.attributes.name.value;
+      this.actor.rollCarac(caracName.toLowerCase());
+    });
+
+    this.html.find('.chance-actuelle').click(async event => {
+      this.actor.rollCarac('chance-actuelle');
+    });
+
+    this.html.find('.chance-appel').click(async event => {
+      this.actor.rollAppelChance();
+    });
+
+    this.html.find('[name="jet-astrologie"]').click(async event => {
+      this.actor.astrologieNombresAstraux();
+    });
+
+    // Roll Skill
+    this.html.find('a.competence-label').click(async event => {
+      this.actor.rollCompetence(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('.chant-label a').click(async event => {
+      this.actor.rollChant(RdDSheetUtility.getItemId(event));
+    });
+    this.html.find('.danse-label a').click(async event => {
+      this.actor.rollDanse(RdDSheetUtility.getItemId(event));
+    });
+    this.html.find('.musique-label a').click(async event => {
+      this.actor.rollMusique(RdDSheetUtility.getItemId(event));
+    });
+    this.html.find('.oeuvre-label a').click(async event => {
+      this.actor.rollOeuvre(RdDSheetUtility.getItemId(event));
+    });
+    this.html.find('.jeu-label a').click(async event => {
+      this.actor.rollJeu(RdDSheetUtility.getItemId(event));
+    });
+    this.html.find('.recettecuisine-label a').click(async event => {
+      this.actor.rollRecetteCuisine(RdDSheetUtility.getItemId(event));
+    });
+    this.html.find('.subacteur-label a').click(async event => {
+      let actorId = RdDSheetUtility.getEventItemData(event, 'actor-id');
+      let actor = game.actors.get(actorId);
+      if (actor) {
+        actor.sheet.render(true);
+      }
+    });
+
+    // Boutons spéciaux MJs
+    this.html.find('.forcer-tmr-aleatoire').click(async event => {
+      this.actor.reinsertionAleatoire("Action MJ");
+    });
+    this.html.find('.afficher-tmr').click(async event => {
+      this.actor.changeTMRVisible();
+    });
+
+    // Points de reve actuel
+    this.html.find('.ptreve-actuel a').click(async event => {
+      this.actor.rollCarac('reve-actuel', true);
+    });
+
+    // Suite empoignade
+    this.html.find('.empoignade-label a').click(async event => {
+      let emp = RdDSheetUtility.getItem(event, this.actor)
+      RdDEmpoignade.onAttaqueEmpoignadeFromItem(emp)
+    });
+    // Roll Weapon1
+    this.html.find('.arme-label a').click(async event => {
+      let arme = this._getEventArmeCombat(event);
+      this.actor.rollArme(duplicate(arme));
+    });
+    // Initiative pour l'arme
+    this.html.find('.arme-initiative a').click(async event => {
+      let combatant = game.combat.combatants.find(c => c.actor.id == this.actor.id);
+      if (combatant) {
+        let action = this._getEventArmeCombat(event);
+        RdDCombatManager.rollInitiativeAction(combatant._id, action);
+      } else {
+        ui.notifications.info("Impossible de lancer l'initiative sans être dans un combat.");
+      }
+    });
+    // Display TMR, visualisation
+    this.html.find('.visu-tmr').click(async event => {
+      this.actor.displayTMR("visu");
+    });
+
+    // Display TMR, normal
+    this.html.find('.monte-tmr').click(async event => {
+      this.actor.displayTMR("normal");
+    });
+
+    // Display TMR, fast 
+    this.html.find('.monte-tmr-rapide').click(async event => {
+      this.actor.displayTMR("rapide");
+    });
+
+    this.html.find('.repos').click(async event => {
+      await this.actor.repos();
+    });
+    this.html.find('.delete-active-effect').click(async event => {
+      if (game.user.isGM) {
+        let effect = this.html.find(event.currentTarget).parents(".active-effect").data('effect');
+        this.actor.removeEffect(effect);
+      }
+    });
+    this.html.find('.enlever-tous-effets').click(async event => {
+      if (game.user.isGM) {
+        await this.actor.removeEffects();
+      }
+    });
+    this.html.find('.carac-xp-augmenter').click(async event => {
+      let caracName = event.currentTarget.name.replace("augmenter.", "");
+      this.actor.updateCaracXPAuto(caracName);
+    });
+    this.html.find('.competence-xp-augmenter').click(async event => {
+      this.actor.updateCompetenceXPAuto(RdDSheetUtility.getItemId(event));
+    });
+    this.html.find('.competence-stress-augmenter').click(async event => {
+      this.actor.updateCompetenceStress(RdDSheetUtility.getItemId(event));
+    });
+
+    if (this.options.vueDetaillee) {
+      // On carac change
+      this.html.find('.carac-value').change(async event => {
+        let caracName = event.currentTarget.name.replace(".value", "").replace("system.carac.", "");
+        this.actor.updateCarac(caracName, parseInt(event.target.value));
+      });
+      this.html.find('input.carac-xp').change(async event => {
+        let caracName = event.currentTarget.name.replace(".xp", "").replace("system.carac.", "");
+        this.actor.updateCaracXP(caracName, parseInt(event.target.value));
+      });
+      // On competence change
+      this.html.find('.competence-value').change(async event => {
+        let compName = event.currentTarget.attributes.compname.value;
+        //console.log("Competence changed :", compName);
+        this.actor.updateCompetence(compName, parseInt(event.target.value));
+      });
+      // On competence xp change
+      this.html.find('input.competence-xp').change(async event => {
+        let compName = event.currentTarget.attributes.compname.value;
+        this.actor.updateCompetenceXP(compName, parseInt(event.target.value));
+      });
+      // On competence xp change
+      this.html.find('input.competence-xp-sort').change(async event => {
+        let compName = event.currentTarget.attributes.compname.value;
+        this.actor.updateCompetenceXPSort(compName, parseInt(event.target.value));
+      });
+      // On competence archetype change
+      this.html.find('.competence-archetype').change(async event => {
+        let compName = event.currentTarget.attributes.compname.value;
+        this.actor.updateCompetenceArchetype(compName, parseInt(event.target.value));
+      });
+    }
+
+    this.html.find('.show-hide-competences').click(async event => {
+      this.options.showCompNiveauBase = !this.options.showCompNiveauBase;
+      this.render(true);
+    });
+
+    this.html.find('.vue-detaillee').click(async event => {
+      this.options.vueDetaillee = !this.options.vueDetaillee;
+      this.render(true);
+    });
+
+    // On pts de reve change
+    this.html.find('.pointsreve-value').change(async event => {
+      let reveValue = event.currentTarget.value;
+      this.actor.update({ "system.reve.reve.value": reveValue });
+    });
+
+    // On seuil de reve change
+    this.html.find('.seuil-reve-value').change(async event => {
+      console.log("seuil-reve-value", event.currentTarget)
+      this.actor.setPointsDeSeuil(event.currentTarget.value);
+    });
+
+    // On stress change
+    this.html.find('.compteur-edit').change(async event => {
+      let fieldName = event.currentTarget.attributes.name.value;
+      this.actor.updateCompteurValue(fieldName, parseInt(event.target.value));
+    });
+
+    this.html.find('.stress-test').click(async event => {
+      this.actor.transformerStress();
+    });
+    this.html.find('.moral-malheureux').click(async event => {
+      this.actor.jetDeMoral('malheureuse');
+    });
+    this.html.find('.moral-neutre').click(async event => {
+      this.actor.jetDeMoral('neutre');
+    });
+    this.html.find('.moral-heureux').click(async event => {
+      this.actor.jetDeMoral('heureuse');
+    });
+    this.html.find('.ethylisme-test').click(async event => {
+      this.actor.jetEthylisme();
+    });
+
+    this.html.find('.jet-vie').click(async event => {
+      this.actor.jetVie();
+    });
+    this.html.find('.jet-endurance').click(async event => {
+      this.actor.jetEndurance();
+    });
+
+    this.html.find('.vie-plus').click(async event => {
+      this.actor.santeIncDec("vie", 1);
+    });
+    this.html.find('.vie-moins').click(async event => {
+      this.actor.santeIncDec("vie", -1);
+    });
+    this.html.find('.endurance-plus').click(async event => {
+      this.actor.santeIncDec("endurance", 1);
+    });
+    this.html.find('.endurance-moins').click(async event => {
+      this.actor.santeIncDec("endurance", -1);
+    });
+    this.html.find('.ptreve-actuel-plus').click(async event => {
+      this.actor.reveActuelIncDec(1);
+    });
+    this.html.find('.ptreve-actuel-moins').click(async event => {
+      this.actor.reveActuelIncDec(-1);
+    });
+    this.html.find('.fatigue-plus').click(async event => {
+      this.actor.santeIncDec("fatigue", 1);
+    });
+    this.html.find('.fatigue-moins').click(async event => {
+      this.actor.santeIncDec("fatigue", -1);
+    });
+  }
+
+  getBlessure(event) {
+    const itemId = this.html.find(event.currentTarget).parents(".item-blessure").data('item-id');
+    const blessure = this.actor.getItem(itemId, 'blessure');
+    return blessure;
+  }
+
   isCompetenceAffichable(competence) {
     return !this.options.showCompNiveauBase || !RdDItemCompetence.isNiveauBase(competence);
   }
@@ -130,422 +455,34 @@ export class RdDActorSheet extends ActorSheet {
   }
 
   /* -------------------------------------------- */
-  async _onDropItem(event, dragData) {
+  async selectTypeOeuvreToCreate() {
-    const destItemId = $(event.target)?.closest('.item').attr('data-item-id')
+    let types = RdDItem.getTypesOeuvres();
-    const dropParams = RdDSheetUtility.prepareItemDropParameters(destItemId, this.actor.id, dragData, this.objetVersConteneur)
+    let content = `<span class="competence-label">Selectionnez le type d'oeuvre</span><select class="item-type">`;
-    const callSuper = await this.actor.processDropItem(dropParams)
+    for (let typeName of types) {
-    if (callSuper) {
+      content += `<option value="${typeName}">${Misc.typeName('Item', typeName)}</option>`
-      await super._onDropItem(event, dragData)
+    }
+    content += '</select>';
+    let dialog = new Dialog({
+      title: "Créer une oeuvre",
+      content: content,
+      buttons: {
+        create: {
+          icon: '<i class="fas fa-check"></i>',
+          label: "Créer l'oeuvre",
+          callback: () => this.actor.createItem($(".item-type").val())
         }
       }
-
+    });
-  /* -------------------------------------------- */
+    dialog.render(true);
-  async createItem(name, type) {
-    await this.actor.createEmbeddedDocuments('Item', [{ name: name, type: type }], { renderSheet: true });
   }
 
   /* -------------------------------------------- */
   async createEmptyTache() {
-    await this.createItem('Nouvelle tache', 'tache');
+    await this.actor.createItem('tache', 'Nouvelle tache');
-  }
-
-  /* -------------------------------------------- */  /** @override */
-  activateListeners(html) {
-    super.activateListeners(html);
-
-    HtmlUtility._showControlWhen($(".appliquerFatigue"), ReglesOptionelles.isUsing("appliquer-fatigue"));
-
-    // Everything below here is only needed if the sheet is editable
-    if (!this.options.editable) return;
-
-    html.find('.item-split').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
-      RdDSheetUtility.splitItem(item, this.actor);
-    });
-    html.find('.item-edit').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor)
-      item.sheet.render(true)
-    })
-    html.find('.display-label a').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
-      item.sheet.render(true);
-    });
-    html.find('.item-delete').click(async event => {
-      const li = RdDSheetUtility.getEventElement(event);
-      const item = this.actor.getObjet(li.data("item-id"));
-      RdDUtility.confirmerSuppressionItem(this, item, li);
-    });
-    html.find('.item-vendre').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
-      item?.proposerVente();
-    });
-    html.find('.item-montrer').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
-      item?.postItem();
-    });
-    html.find('.item-action').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor)
-      this.actor.actionItem(item);
-    });
-    html.find('.subacteur-delete').click(async event => {
-      const li = RdDSheetUtility.getEventElement(event);
-      const actorId = li.data("actor-id");
-      if (actorId) {
-        const subActor = game.actors.get(actorId);
-        RdDUtility.confirmerSuppressionSubacteur(this, subActor, li);
-      }
-    });
-    html.find('.experiencelog-delete').click(async event => {
-      const li = $(event.currentTarget)?.parents(".experiencelog");
-      const key = Number(li.data("key") ?? -1);
-      await this.actor.deleteExperienceLog(key, 1);
-    });
-    html.find('.experiencelog-delete-previous').click(async event => {
-      const li = $(event.currentTarget)?.parents(".experiencelog");
-      const key = Number(li.data("key") ?? -1);
-      await this.actor.deleteExperienceLog(0, key + 1);
-    });
-    html.find('.encaisser-direct').click(async event => {
-      this.actor.encaisser();
-    })
-    html.find('.sheet-possession-attack').click(async event => {
-      const poss = RdDSheetUtility.getItem(event, this.actor)
-      this.actor.conjurerPossession(poss)
-    })
-    html.find('.remise-a-neuf').click(async event => {
-      if (game.user.isGM) {
-        this.actor.remiseANeuf();
-      }
-    });
-    html.find('.creer-tache').click(async event => {
-      this.createEmptyTache();
-    });
-    html.find('.creer-un-objet').click(async event => {
-      RdDUtility.selectObjetType(this);
-    });
-    html.find('.creer-une-oeuvre').click(async event => {
-      RdDUtility.selectTypeOeuvre(this);
-    });
-    html.find('.nettoyer-conteneurs').click(async event => {
-      this.actor.nettoyerConteneurs();
-    });
-
-    // Blessure control
-    html.find('.blessure-control').click(async event => {
-      const tr = $(event.currentTarget).parents(".item");
-      let btype = tr.data("blessure-type");
-      let index = tr.data('blessure-index');
-      let active = $(event.currentTarget).data('blessure-active');
-      //console.log(btype, index, active);
-      await this.actor.manageBlessureFromSheet(btype, index, active);
-    });
-
-    // Blessure data
-    html.find('.blessure-soins').change(async event => {
-      const tr = $(event.currentTarget).parents(".item");
-      let btype = tr.data('blessure-type');
-      let index = tr.data('blessure-index');
-      let psoins = tr.find('.blessure-premiers_soins').val();
-      let pcomplets = tr.find('.blessure-soins_complets').val();
-      let jours = tr.find('.blessure-jours').val();
-      let loc = tr.find('.blessure-localisation').val();
-      let psdone = tr.find('.blessure-psdone:checked').val();
-      let scdone = tr.find('.blessure-scdone:checked').val();
-      console.log(btype, index, psoins, pcomplets, jours, loc, psdone, scdone);
-      await this.actor.setDataBlessureFromSheet(btype, index, psoins, pcomplets, jours, loc, psdone, scdone);
-    });
-
-    // Equip Inventory Item
-    html.find('.item-equip').click(async event => {
-      this.actor.equiperObjet(RdDSheetUtility.getItemId(event));
-    });
-
-    // Roll Carac
-    html.find('.carac-label a').click(async event => {
-      let caracName = event.currentTarget.attributes.name.value;
-      this.actor.rollCarac(caracName.toLowerCase());
-    });
-
-    html.find('.chance-actuelle').click(async event => {
-      this.actor.rollCarac('chance-actuelle');
-    });
-
-    html.find('.chance-appel').click(async event => {
-      this.actor.rollAppelChance();
-    });
-
-    html.find('#jet-astrologie').click(async event => {
-      this.actor.astrologieNombresAstraux();
-    });
-
-    // Roll Skill
-    html.find('a.competence-label').click(async event => {
-      this.actor.rollCompetence(RdDSheetUtility.getItemId(event));
-    });
-    html.find('.tache-label a').click(async event => {
-      this.actor.rollTache(RdDSheetUtility.getItemId(event));
-    });
-    html.find('.meditation-label a').click(async event => {
-      this.actor.rollMeditation(RdDSheetUtility.getItemId(event));
-    });
-    html.find('.chant-label a').click(async event => {
-      this.actor.rollChant(RdDSheetUtility.getItemId(event));
-    });
-    html.find('.danse-label a').click(async event => {
-      this.actor.rollDanse(RdDSheetUtility.getItemId(event));
-    });
-    html.find('.musique-label a').click(async event => {
-      this.actor.rollMusique(RdDSheetUtility.getItemId(event));
-    });
-    html.find('.oeuvre-label a').click(async event => {
-      this.actor.rollOeuvre(RdDSheetUtility.getItemId(event));
-    });
-    html.find('.jeu-label a').click(async event => {
-      this.actor.rollJeu(RdDSheetUtility.getItemId(event));
-    });
-    html.find('.recettecuisine-label a').click(async event => {
-      this.actor.rollRecetteCuisine(RdDSheetUtility.getItemId(event));
-    });
-    html.find('.subacteur-label a').click(async event => {
-      let actorId = RdDSheetUtility.getEventItemData(event, 'actor-id');
-      let actor = game.actors.get(actorId);
-      if (actor) {
-        actor.sheet.render(true);
-      }
-    });
-
-    // Boutons spéciaux MJs
-    html.find('.forcer-tmr-aleatoire').click(async event => {
-      this.actor.reinsertionAleatoire("Action MJ");
-    });
-    html.find('.afficher-tmr').click(async event => {
-      this.actor.changeTMRVisible();
-    });
-
-    // Points de reve actuel
-    html.find('.ptreve-actuel a').click(async event => {
-      this.actor.rollCarac('reve-actuel');
-    });
-
-    // Roll Weapon1
-    html.find('.arme-label a').click(async event => {
-      let arme = this._getEventArmeCombat(event);
-      this.actor.rollArme(duplicate(arme));
-    });
-    // Initiative pour l'arme
-    html.find('.arme-initiative a').click(async event => {
-      let combatant = game.combat.combatants.find(c => c.actor.id == this.actor.id);
-      if (combatant) {
-        let action = this._getEventArmeCombat(event);
-        RdDCombatManager.rollInitiativeAction(combatant._id, action);
-      } else {
-        ui.notifications.info("Impossible de lancer l'initiative sans être dans un combat.");
-      }
-    });
-    // Display TMR, visualisation
-    html.find('.visu-tmr').click(async event => {
-      this.actor.displayTMR("visu");
-    });
-
-    // Display TMR, normal
-    html.find('.monte-tmr').click(async event => {
-      this.actor.displayTMR("normal");
-    });
-
-    // Display TMR, fast 
-    html.find('.monte-tmr-rapide').click(async event => {
-      this.actor.displayTMR("rapide");
-    });
-
-    html.find('.repos').click(async event => {
-      await DialogRepos.create(this.actor);
-    });
-    html.find('.delete-active-effect').click(async event => {
-      if (game.user.isGM) {
-        let effect = $(event.currentTarget).parents(".active-effect").data('effect');
-        this.actor.removeEffect(effect);
-      }
-    });
-    html.find('.enlever-tous-effets').click(async event => {
-      if (game.user.isGM) {
-        await this.actor.removeEffects();
-      }
-    });
-    html.find('.conteneur-name a').click(async event => {
-      RdDUtility.toggleAfficheContenu(RdDSheetUtility.getItemId(event));
-      this.render(true);
-    });
-    html.find('.carac-xp-augmenter').click(async event => {
-      let caracName = event.currentTarget.name.replace("augmenter.", "");
-      this.actor.updateCaracXPAuto(caracName);
-    });
-    html.find('.competence-xp-augmenter').click(async event => {
-      this.actor.updateCompetenceXPAuto(RdDSheetUtility.getItemId(event));
-    });
-    html.find('.competence-stress-augmenter').click(async event => {
-      this.actor.updateCompetenceStress(RdDSheetUtility.getItemId(event));
-    });
-
-    if (this.options.vueDetaillee) {
-      // On carac change
-      html.find('.carac-value').change(async event => {
-        let caracName = event.currentTarget.name.replace(".value", "").replace("system.carac.", "");
-        this.actor.updateCarac(caracName, parseInt(event.target.value));
-      });
-      html.find('input.carac-xp').change(async event => {
-        let caracName = event.currentTarget.name.replace(".xp", "").replace("system.carac.", "");
-        this.actor.updateCaracXP(caracName, parseInt(event.target.value));
-      });
-      // On competence change
-      html.find('.competence-value').change(async event => {
-        let compName = event.currentTarget.attributes.compname.value;
-        //console.log("Competence changed :", compName);
-        this.actor.updateCompetence(compName, parseInt(event.target.value));
-      });
-      // On competence xp change
-      html.find('input.competence-xp').change(async event => {
-        let compName = event.currentTarget.attributes.compname.value;
-        this.actor.updateCompetenceXP(compName, parseInt(event.target.value));
-      });
-      // On competence xp change
-      html.find('input.competence-xp-sort').change(async event => {
-        let compName = event.currentTarget.attributes.compname.value;
-        this.actor.updateCompetenceXPSort(compName, parseInt(event.target.value));
-      });
-      // On competence archetype change
-      html.find('.competence-archetype').change(async event => {
-        let compName = event.currentTarget.attributes.compname.value;
-        this.actor.updateCompetenceArchetype(compName, parseInt(event.target.value));
-      });
-    }
-
-    html.find('.show-hide-competences').click(async event => {
-      this.options.showCompNiveauBase = !this.options.showCompNiveauBase;
-      this.render(true);
-    });
-
-    html.find('.recherche')
-      .each((index, field) => {
-        if (this.options.recherche) {
-          field.focus();
-          field.setSelectionRange(this.options.recherche.start, this.options.recherche.end);
-        }
-      })
-      .keyup(async event => {
-        const nouvelleRecherche = this._optionRecherche(event.currentTarget);
-        if (this.options.recherche?.text != nouvelleRecherche?.text){
-          this.options.recherche = nouvelleRecherche;
-          if (this.timerRecherche) {
-            clearTimeout(this.timerRecherche);
-          }
-          this.timerRecherche = setTimeout(() => {
-            this.timerRecherche = undefined;
-            this.render(true);
-          }, 500);
-        }
-      })
-      .change(async event =>
-        this.options.recherche = this._optionRecherche(event.currentTarget)
-      );
-    html.find('.vue-detaillee').click(async event => {
-      this.options.vueDetaillee = !this.options.vueDetaillee;
-      this.render(true);
-    });
-
-    // On pts de reve change
-    html.find('.pointsreve-value').change(async event => {
-      let reveValue = event.currentTarget.value;
-      this.actor.update({ "system.reve.reve.value": reveValue });
-    });
-
-    // On seuil de reve change
-    html.find('.seuil-reve-value').change(async event => {
-      console.log("seuil-reve-value", event.currentTarget)
-      this.actor.setPointsDeSeuil(event.currentTarget.value);
-    });
-
-    html.find('#attribut-protection-edit').change(async event => {
-      this.actor.updateAttributeValue(event.currentTarget.attributes.name.value, parseInt(event.target.value));
-    });
-
-    // On stress change
-    html.find('.compteur-edit').change(async event => {
-      let fieldName = event.currentTarget.attributes.name.value;
-      this.actor.updateCompteurValue(fieldName, parseInt(event.target.value));
-    });
-
-    html.find('#ethylisme').change(async event => {
-      this.actor.setEthylisme(parseInt(event.target.value));
-    });
-    html.find('.stress-test').click(async event => {
-      this.actor.transformerStress();
-    });
-    html.find('.moral-malheureux').click(async event => {
-      this.actor.jetDeMoral('malheureuse');
-    });
-    html.find('.moral-neutre').click(async event => {
-      this.actor.jetDeMoral('neutre');
-    });
-    html.find('.moral-heureux').click(async event => {
-      this.actor.jetDeMoral('heureuse');
-    });
-    html.find('.ethylisme-test').click(async event => {
-      this.actor.jetEthylisme();
-    });
-
-    html.find('.jet-vie').click(async event => {
-      this.actor.jetVie();
-    });
-    html.find('.jet-endurance').click(async event => {
-      this.actor.jetEndurance();
-    });
-
-    html.find('.monnaie-plus').click(async event => {
-      this.actor.monnaieIncDec(RdDSheetUtility.getItemId(event), 1);
-    });
-    html.find('.monnaie-moins').click(async event => {
-      this.actor.monnaieIncDec(RdDSheetUtility.getItemId(event), -1);
-    });
-
-    html.find('.vie-plus').click(async event => {
-      this.actor.santeIncDec("vie", 1);
-    });
-    html.find('.vie-moins').click(async event => {
-      this.actor.santeIncDec("vie", -1);
-    });
-    html.find('.endurance-plus').click(async event => {
-      this.actor.santeIncDec("endurance", 1);
-    });
-    html.find('.endurance-moins').click(async event => {
-      this.actor.santeIncDec("endurance", -1);
-    });
-    html.find('.ptreve-actuel-plus').click(async event => {
-      this.actor.reveActuelIncDec(1);
-    });
-    html.find('.ptreve-actuel-moins').click(async event => {
-      this.actor.reveActuelIncDec(-1);
-    });
-    html.find('.fatigue-plus').click(async event => {
-      this.actor.santeIncDec("fatigue", 1);
-    });
-    html.find('.fatigue-moins').click(async event => {
-      this.actor.santeIncDec("fatigue", -1);
-    });
-  }
-
-  _optionRecherche(target) {
-    if (!target.value?.length){
-      return undefined;
-    }
-    return {
-      text: target.value,
-      start: target.selectionStart,
-      end: target.selectionEnd,
-    };
   }
 
   _getEventArmeCombat(event) {
-    const li = $(event.currentTarget)?.parents(".item");
+    const li = this.html.find(event.currentTarget)?.parents(".item");
     let armeName = li.data("arme-name");
     let compName = li.data('competence-name');
     const arme = this.armesList.find(a => a.name == armeName && a.system.competence == compName);
@@ -563,7 +500,7 @@ export class RdDActorSheet extends ActorSheet {
     const sheetTabs = this.element.find(".sheet-tabs");
     const sheetBody = this.element.find(".sheet-body");
     let bodyHeight = position.height - sheetHeader[0].clientHeight;
-    if (sheetTabs.length>0) {
+    if (sheetTabs.length > 0) {
       bodyHeight -= sheetTabs[0].clientHeight;
     }
     sheetBody.css("height", bodyHeight);

module/actor-vehicule-sheet.js

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

module/actor/base-actor-sheet.js

@@ -0,0 +1,301 @@
+import { RdDUtility } from "../rdd-utility.js";
+import { Misc } from "../misc.js";
+import { DialogSplitItem } from "../dialog-split-item.js";
+import { RdDSheetUtility } from "../rdd-sheet-utility.js";
+import { Monnaie } from "../item-monnaie.js";
+import { RdDItem, TYPES } from "../item.js";
+import { RdDItemCompetenceCreature } from "../item-competencecreature.js";
+
+/* -------------------------------------------- */
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+export class RdDBaseActorSheet extends ActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+    RdDUtility.initAfficheContenu();
+    return mergeObject(super.defaultOptions, {
+      classes: ["rdd", "sheet", "actor"],
+      template: "systems/foundryvtt-reve-de-dragon/templates/actor-sheet.html",
+      width: 550,
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }],
+      showCompNiveauBase: false,
+      vueDetaillee: false
+    });
+  }
+
+  /* -------------------------------------------- */
+  async getData() {
+    Monnaie.validerMonnaies(this.actor.itemTypes['monnaie']);
+
+    this.actor.recompute();
+    let formData = {
+      title: this.title,
+      id: this.actor.id,
+      type: this.actor.type,
+      img: this.actor.img,
+      name: this.actor.name,
+      system: this.actor.system,
+      description: await TextEditor.enrichHTML(this.actor.system.description, { async: true }),
+      notesmj: await TextEditor.enrichHTML(this.actor.system.notesmj, { async: true }),
+      options: RdDSheetUtility.mergeDocumentRights(this.options, this.actor, this.isEditable)
+    }
+
+    RdDBaseActorSheet.filterItemsPerTypeForSheet(formData, this.actor.itemTypes);
+    formData.calc = {
+      fortune: Monnaie.toSolsDeniers(this.actor.getFortune()),
+      prixTotalEquipement: this.actor.computePrixTotalEquipement(),
+      encTotal: await this.actor.computeEncTotal(),
+    }
+
+    this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.inventaires);
+    this._appliquerRechercheObjets(formData.conteneurs, formData.inventaires);
+    formData.conteneurs = RdDUtility.conteneursRacine(formData.conteneurs);
+    formData.competences.filter(it => it.type == TYPES.competencecreature)
+      .forEach(it => it.isdommages = RdDItemCompetenceCreature.isDommages(it))
+    return formData;
+  }
+
+  _appliquerRechercheObjets(conteneurs, inventaires) {
+    if (this.options.recherche?.text) {
+      const recherche = this.options.recherche;
+      const allVisible = inventaires.filter(it => it.isNomTypeLike(recherche.text)).map(it => it.id);
+      let addVisible = conteneurs.filter(it => it.isNomTypeLike(recherche.text)).map(it => it.id)
+      do {
+        allVisible.push(...addVisible)
+        const parentsIds = conteneurs.filter(it => it.system.contenu.find(id => allVisible.includes(id))).map(it => it.id)
+        addVisible = parentsIds.filter(id => !allVisible.includes(id))
+      }
+      while (addVisible.length > 0)
+      inventaires.forEach(it => it.system.isHidden = !allVisible.includes(it.id))
+      conteneurs.forEach(it => it.system.isHidden = !allVisible.includes(it.id))
+    }
+    else {
+      inventaires.forEach(it => it.system.isHidden = false)
+      conteneurs.forEach(it => it.system.isHidden = false)
+    }
+  }
+
+  /* -------------------------------------------- */
+  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('.conteneur-name a').click(async event => {
+      RdDUtility.toggleAfficheContenu(this.getItemId(event));
+      this.render(true);
+    });
+    this.html.find('.item-edit').click(async event => this.getItem(event)?.sheet.render(true))
+    this.html.find('.item-montrer').click(async event => this.getItem(event)?.postItemToChat());
+    this.html.find('.actor-montrer').click(async event => this.actor.postActorToChat());
+    this.html.find('.recherche')
+      .each((index, field) => {
+        this._rechercheSelectArea(field);
+      })
+      .keyup(async event => this._rechercherKeyup(event))
+      .change(async event => this._rechercherKeyup(event));
+    this.html.find('.recherche').prop("disabled", false);
+    // Everything below here is only needed if the sheet is editable
+    if (!this.options.editable) return;
+
+    this.html.find('.item-split').click(async event => {
+      const item = this.getItem(event);
+      RdDSheetUtility.splitItem(item, this.actor);
+    });
+    this.html.find('.item-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();
+    });
+    this.html.find('.nettoyer-conteneurs').click(async event => {
+      this.actor.nettoyerConteneurs();
+    });
+  }
+
+  _rechercherKeyup(event) {
+    const currentTarget = event.currentTarget;
+    const nouvelleRecherche = this._optionRecherche(currentTarget);
+    if (this.options.recherche?.text != nouvelleRecherche?.text) {
+      this.options.recherche = nouvelleRecherche;
+      if (this.timerRecherche) {
+        clearTimeout(this.timerRecherche);
+      }
+      this.timerRecherche = setTimeout(() => {
+        this.timerRecherche = undefined;
+        this.render(true);
+      }, 500);
+    }
+  }
+
+  _rechercheSelectArea(field) {
+    if (this.options.recherche) {
+      field.focus();
+      field.setSelectionRange(this.options.recherche.start, this.options.recherche.end);
+    }
+  }
+
+  getItemId(event) {
+    return RdDSheetUtility.getItemId(event);
+  }
+
+  getItem(event) {
+    return RdDSheetUtility.getItem(event, this.actor);
+  }
+
+  _optionRecherche(target) {
+    if (!target.value?.length) {
+      return undefined;
+    }
+    return {
+      text: target.value,
+      start: target.selectionStart,
+      end: target.selectionEnd,
+    };
+  }
+  /* -------------------------------------------- */
+  _getHeaderButtons() {
+    let buttons = super._getHeaderButtons();
+    buttons.unshift({
+      class: "montrer",
+      icon: "fas fa-comment",
+      onclick: ev => this.actor.postActorToChat()
+    });
+    return buttons
+  }
+
+  /* -------------------------------------------- */
+  async _onDropItem(event, dragData) {
+    const destItemId = this.html.find(event.target)?.closest('.item').attr('data-item-id')
+    const dropParams = await RdDSheetUtility.prepareItemDropParameters(destItemId, this.actor, dragData, this.objetVersConteneur)
+    if (dropParams) {
+      const callSuper = await this.actor.processDropItem(dropParams)
+      if (callSuper) {
+        await super._onDropItem(event, dragData)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  async selectObjetTypeToCreate() {
+    let types = this.getTypesInventaire().sort(Misc.ascending(type => Misc.typeName('Item', type)));
+    let content = `<span class="competence-label">Selectionnez le type d'équipement</span><select class="item-type">`;
+    for (let typeName of types) {
+      content += `<option value="${typeName}">${Misc.typeName('Item', typeName)}</option>`
+    }
+    content += '</select>';
+    let d = new Dialog({
+      title: "Créer un équipement",
+      content: content,
+      buttons: {
+        create: {
+          icon: '<i class="fas fa-check"></i>',
+          label: "Créer l'objet",
+          callback: () => this.actor.createItem($(".item-type").val())
+        }
+      }
+    });
+    d.render(true);
+  }
+
+  getTypesInventaire() {
+    return RdDItem.getItemTypesInventaire();
+  }
+
+  /** @override */
+  setPosition(options = {}) {
+    const position = super.setPosition(options);
+    const sheetHeader = this.element.find(".sheet-header");
+    const sheetTabs = this.element.find(".sheet-tabs");
+    const sheetBody = this.element.find(".sheet-body");
+    let bodyHeight = position.height - sheetHeader[0].clientHeight;
+    if (sheetTabs.length > 0) {
+      bodyHeight -= sheetTabs[0].clientHeight;
+    }
+    sheetBody.css("height", bodyHeight);
+    return position;
+  }
+
+
+  /* -------------------------------------------- */
+  /** @override */
+  _updateObject(event, formData) {
+    // Update the Actor
+    return this.actor.update(formData);
+  }
+
+  async splitItem(item) {
+    const dialog = await DialogSplitItem.create(item, (item, split) => this._onSplitItem(item, split));
+    dialog.render(true);
+  }
+
+  async _onSplitItem(item, split) {
+    if (split >= 1 && split < item.system.quantite) {
+      await item.diminuerQuantite(split);
+      const splitItem = duplicate(item);
+      splitItem.system.quantite = split;
+      await this.actor.createEmbeddedDocuments('Item', [splitItem])
+    }
+  }
+
+  vendre(item) {
+    item?.proposerVente(this.actor.getQuantiteDisponible(item));
+  }
+
+}

module/actor/base-actor.js

@@ -0,0 +1,644 @@
+import { ChatUtility } from "../chat-utility.js";
+import { SYSTEM_SOCKET_ID } from "../constants.js";
+import { Monnaie } from "../item-monnaie.js";
+import { Misc } from "../misc.js";
+import { RdDAudio } from "../rdd-audio.js";
+import { RdDConfirm } from "../rdd-confirm.js";
+import { RdDUtility } from "../rdd-utility.js";
+import { SystemCompendiums } from "../settings/system-compendiums.js";
+import { APP_ASTROLOGIE_REFRESH } from "../sommeil/app-astrologie.js";
+
+export class RdDBaseActor extends Actor {
+
+  static getDefaultImg(itemType) {
+    return game.system.rdd.actorClasses[itemType]?.defaultIcon ?? defaultItemImg[itemType];
+  }
+
+  /* -------------------------------------------- */
+  static init() {
+    Hooks.on("preUpdateItem", (item, change, options, id) => RdDBaseActor.getParentActor(item)?.onPreUpdateItem(item, change, options, id));
+    Hooks.on("createItem", (item, options, id) => RdDBaseActor.getParentActor(item)?.onCreateItem(item, options, id));
+    Hooks.on("deleteItem", (item, options, id) => RdDBaseActor.getParentActor(item)?.onDeleteItem(item, options, id));
+    Hooks.on("updateActor", (actor, change, options, actorId) => actor.onUpdateActor(change, options, actorId));
+  }
+
+  static onSocketMessage(sockmsg) {
+    switch (sockmsg.msg) {
+      case "msg_remote_actor_call":
+        return RdDBaseActor.onRemoteActorCall(sockmsg.data, sockmsg.userId);
+      case "msg_reset_nombre_astral":
+        game.user.character.resetNombresAstraux();
+        game.system.rdd.calendrier.notifyChangeNombresAstraux();
+        return;
+      case "msg_refresh_nombre_astral":
+        Hooks.callAll(APP_ASTROLOGIE_REFRESH);
+        return;
+    }
+  }
+
+  static remoteActorCall(callData, userId = undefined) {
+    userId = userId ?? Misc.firstConnectedGMId();
+    if (userId == game.user.id) {
+      RdDBaseActor.onRemoteActorCall(callData, userId);
+      return false;
+    }
+    else {
+      game.socket.emit(SYSTEM_SOCKET_ID, { msg: "msg_remote_actor_call", data: callData, userId: userId });
+      return true;
+    }
+  }
+
+  static onRemoteActorCall(callData, userId) {
+    if (userId == game.user.id) {
+      const actor = game.actors.get(callData?.actorId);
+      if (Misc.isOwnerPlayerOrUniqueConnectedGM(actor)) { // Seul le joueur choisi effectue l'appel: le joueur courant si propriétaire de l'actor, ou le MJ sinon
+        const args = callData.args;
+        console.info(`RdDBaseActor.onRemoteActorCall: pour l'Actor ${callData.actorId}, appel de RdDBaseActor.${callData.method}(`, ...args, ')');
+        actor[callData.method](...args);
+      }
+    }
+  }
+
+  static getParentActor(document) {
+    return document?.parent instanceof Actor ? document.parent : undefined
+  }
+
+  /**
+   * Cet methode surcharge Actor.create() pour ajouter si besoin des Items par défaut:
+   * compétences et monnaies.
+  *
+  * @param {Object} actorData template d'acteur auquel ajouter des informations.
+  * @param {Object} options   optionspour customiser la création
+  */
+  static async create(actorData, options) {
+    // import depuis un compendium
+    if (actorData instanceof Array) {
+      return super.create(actorData, options);
+    }
+    // Création d'un acteur avec des items (uniquement en cas de duplication): pas besoin d'ajouter d'items
+    if (actorData.items) {
+      return await super.create(actorData, options);
+    }
+    actorData.items = [];
+    if (actorData.type == "personnage") {
+      const competences = await SystemCompendiums.getCompetences(actorData.type);
+      actorData.items = actorData.items.concat(competences.map(i => i.toObject()))
+        .concat(Monnaie.monnaiesStandard());
+    }
+    else if (actorData.type == "commerce") {
+      actorData.items = actorData.items.concat(Monnaie.monnaiesStandard());
+    }
+    return super.create(actorData, options);
+  }
+
+  constructor(docData, context = {}) {
+    if (!context.rdd?.ready) {
+      mergeObject(context, { rdd: { ready: true } });
+      const ActorConstructor = game.system.rdd.actorClasses[docData.type];
+      if (ActorConstructor) {
+        if (!docData.img) {
+          docData.img = ActorConstructor.defaultIcon;
+        }
+        return new ActorConstructor(docData, context);
+      }
+    }
+    super(docData, context);
+  }
+
+  isCreatureEntite() { return this.type == 'creature' || this.type == 'entite'; }
+  isCreature() { return this.type == 'creature'; }
+  isEntite() { return this.type == 'entite'; }
+  isPersonnage() { return this.type == 'personnage'; }
+  isVehicule() { return this.type == 'vehicule'; }
+  getItem(id, type = undefined) {
+    const item = this.items.get(id);
+    if (type == undefined || (item?.type == type)) {
+      return item;
+    }
+    return undefined;
+  }
+
+  listItems(type = undefined) { return (type ? this.itemTypes[type] : this.items); }
+  filterItems(filter, type = undefined) { return (type ? this.itemTypes[type] : this.items)?.filter(filter); }
+  findItemLike(idOrName, type) {
+    return this.getItem(idOrName, type)
+      ?? Misc.findFirstLike(idOrName, this.listItems(type), { description: Misc.typeName('Item', type) });
+  }
+
+  getMonnaie(id) { return this.findItemLike(id, 'monnaie'); }
+
+  recompute() { }
+
+
+  /* -------------------------------------------- */
+  async onPreUpdateItem(item, change, options, id) { }
+
+  async onCreateItem(item, options, id) { }
+
+  async onDeleteItem(item, options, id) { }
+
+  async onUpdateActor(update, options, actorId) { }
+
+  async onTimeChanging(oldTimestamp, newTimestamp) {
+    this.items.filter(it => it.isFinPeriode(oldTimestamp, newTimestamp))
+      .forEach(async it => await it.onFinPeriodeTemporel(oldTimestamp, newTimestamp))
+  }
+
+  async creerObjetParMJ(object){
+    if (!Misc.isUniqueConnectedGM()) {
+      RdDBaseActor.remoteActorCall({
+        actorId: this.id,
+        method: 'creerObjetParMJ',
+        args: [object]
+      });
+      return;
+    }
+    await this.createEmbeddedDocuments('Item', [object])
+  }
+
+  /* -------------------------------------------- */
+  getFortune() {
+    return Monnaie.getFortune(this.itemTypes['monnaie']);
+  }
+
+  /* -------------------------------------------- */
+  async itemQuantiteIncDec(id, value) {
+    let item = this.getItem(id);
+    if (item && item.isInventaire()) {
+      const quantite = Math.max(0, item.system.quantite + value);
+      await this.updateEmbeddedDocuments('Item', [{ _id: item.id, 'system.quantite': quantite }]);
+    }
+  }
+
+  computePrixTotalEquipement() {
+    return this.items.filter(it => it.isInventaire())
+      .filter(it => !it.isMonnaie())
+      .map(it => it.valeurTotale())
+      .reduce(Misc.sum(), 0);
+  }
+
+  async payerSols(depense) {
+    depense = Number(depense);
+    if (depense == 0) {
+      return;
+    }
+    let fortune = this.getFortune();
+    console.log("payer", game.user.character, depense, fortune);
+    let msg = "";
+    if (fortune >= depense) {
+      await Monnaie.optimiserFortune(this, fortune - depense);
+      msg = `Vous avez payé <strong>${depense} Sols</strong>, qui ont été soustraits de votre argent.`;
+      RdDAudio.PlayContextAudio("argent"); // Petit son
+    } else {
+      msg = "Vous n'avez pas assez d'argent pour payer cette somme !";
+    }
+
+    let message = {
+      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+      content: msg
+    };
+    ChatMessage.create(message);
+  }
+
+  async depenserSols(sols) {
+    let reste = this.getFortune() - Number(sols);
+    if (reste >= 0) {
+      await Monnaie.optimiserFortune(this, reste);
+    }
+    return reste;
+  }
+
+  async ajouterSols(sols, fromActorId = undefined) {
+    sols = Number(sols);
+    if (sols == 0) {
+      return;
+    }
+    if (sols < 0) {
+      ui.notifications.error(`Impossible d'ajouter un gain de ${sols} <0`);
+      return;
+    }
+    if (fromActorId && !game.user.isGM) {
+      RdDBaseActor.remoteActorCall({
+        userId: Misc.connectedGMOrUser(),
+        actorId: this.id,
+        method: 'ajouterSols', args: [sols, fromActorId]
+      });
+    }
+    else {
+      const fromActor = game.actors.get(fromActorId)
+      await Monnaie.optimiserFortune(this, sols + this.getFortune());
+
+      RdDAudio.PlayContextAudio("argent"); // Petit son
+      ChatMessage.create({
+        whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+        content: `Vous avez reçu <strong>${sols} Sols</strong> ${fromActor ? " de " + fromActor.name : ''}, qui ont été ajoutés à votre argent.`
+      });
+    }
+  }
+
+  /* -------------------------------------------- */
+
+  getQuantiteDisponible(item) {
+    return item?.isService() ? undefined : item?.getQuantite();
+  }
+
+  /* -------------------------------------------- */
+  async achatVente(achat) {
+    if (achat.vendeurId == achat.acheteurId) {
+      ui.notifications.info("Inutile de se vendre à soi-même");
+      return;
+    }
+    if (!Misc.isUniqueConnectedGM()) {
+      RdDBaseActor.remoteActorCall({
+        actorId: achat.vendeurId ?? achat.acheteurId,
+        method: 'achatVente',
+        args: [achat]
+      });
+      return;
+    }
+    const cout = Number(achat.prixTotal ?? 0);
+    const vendeur = achat.vendeurId ? game.actors.get(achat.vendeurId) : undefined;
+    const acheteur = achat.acheteurId ? game.actors.get(achat.acheteurId) : undefined;
+    const quantite = (achat.choix.nombreLots ?? 1) * (achat.vente.tailleLot);
+    const itemVendu = vendeur?.getItem(achat.vente.item._id) ?? game.items.get(achat.vente.item._id);
+    if (!itemVendu) {
+      ChatUtility.notifyUser(achat.userId, 'warn', vendeur ? `Le vendeur n'a pas plus de ${achat.vente.item.name} !`: `Impossible de retrouver: ${achat.vente.item.name} !`);
+      return;
+    }
+    if (vendeur && !this.verifierQuantite(itemVendu, quantite)) {
+      ChatUtility.notifyUser(achat.userId, 'warn', `Le vendeur n'a pas assez de ${itemVendu.name} !`);
+      return
+    }
+    if (acheteur && !acheteur.verifierFortune(cout)) {
+      ChatUtility.notifyUser(achat.userId, 'warn', `Vous n'avez pas assez d'argent pour payer ${Math.ceil(cout / 100)} sols !`);
+      return;
+    }
+    await this.decrementerVente(vendeur, itemVendu, quantite, cout);
+    if (acheteur) {
+      await acheteur.depenserSols(cout);
+      const createdItemId = await acheteur.creerQuantiteItem(itemVendu, quantite);
+      await acheteur.consommerNourritureAchetee(achat, achat.vente, createdItemId);
+    }
+    if (cout > 0) {
+      RdDAudio.PlayContextAudio("argent");
+    }
+    const chatAchatItem = duplicate(achat.vente);
+    chatAchatItem.quantiteTotal = quantite;
+    ChatMessage.create({
+      user: achat.userId,
+      speaker: { alias: (acheteur ?? vendeur).name },
+      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
+      content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-achat-item.html', chatAchatItem)
+    });
+
+    if (!achat.vente.quantiteIllimite) {
+      if (achat.vente.quantiteNbLots <= achat.choix.nombreLots) {
+        ChatUtility.removeChatMessageId(achat.chatMessageIdVente);
+      }
+      else if (achat.chatMessageIdVente) {
+        achat.vente.properties = itemVendu.getProprietes();
+        achat.vente.quantiteNbLots -= achat.choix.nombreLots;
+        achat.vente.jsondata = JSON.stringify(achat.vente.item);
+        const messageVente = game.messages.get(achat.chatMessageIdVente);
+        messageVente.update({ content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-vente-item.html', achat.vente) });
+        messageVente.render(true);
+      }
+    }
+  }
+
+  async decrementerVente(vendeur, itemVendu, quantite, cout) {
+    if (vendeur) {
+      await vendeur.ajouterSols(cout);
+      await vendeur.decrementerQuantiteItem(itemVendu, quantite);
+    }
+  }
+
+  verifierFortune(cout) {
+    return this.getFortune() >= cout;
+  }
+
+  verifierQuantite(item, quantiteDemande) {
+    const disponible = item?.getQuantite();
+    return disponible == undefined || disponible >= quantiteDemande;
+  }
+
+  async consommerNourritureAchetee(achat, vente, createdItemId) {
+    if (achat.choix.consommer && vente.item.type == 'nourritureboisson' && createdItemId != undefined) {
+      achat.choix.doses = achat.choix.nombreLots;
+      await this.consommerNourritureboisson(createdItemId, achat.choix, vente.actingUserId);
+    }
+  }
+
+
+  async decrementerQuantiteItem(item, quantite, options = { supprimerSiZero: true }) {
+    if (item.isService()) {
+      return;
+    }
+    let resteQuantite = (item.system.quantite ?? 1) - quantite;
+    if (resteQuantite <= 0) {
+      if (options.supprimerSiZero) {
+        await this.deleteEmbeddedDocuments("Item", [item.id]);
+      }
+      else {
+        await this.updateEmbeddedDocuments("Item", [{ _id: item.id, 'system.quantite': 0 }]);
+      }
+      if (resteQuantite < 0) {
+        ui.notifications.warn(`La quantité de ${item.name} était insuffisante, l'objet a donc été supprimé`)
+      }
+    }
+    else if (resteQuantite > 0) {
+      await this.updateEmbeddedDocuments("Item", [{ _id: item.id, 'system.quantite': resteQuantite }]);
+    }
+  }
+
+  async creerQuantiteItem(item, quantite) {
+    if (this.canReceive(item)) {
+      const isItemEmpilable = "quantite" in item.system;
+      const baseItem = {
+        type: item.type,
+        img: item.img,
+        name: item.name,
+        system: mergeObject(item.system, { quantite: isItemEmpilable ? quantite : undefined })
+      };
+      const newItems = isItemEmpilable ? [baseItem] : Array.from({ length: quantite }, (_, i) => baseItem);
+      const items = await this.createEmbeddedDocuments("Item", newItems);
+      return items.length > 0 ? items[0].id : undefined;
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeMalusSurEncombrement() {
+    return 0;
+  }
+
+  getEncombrementMax() {
+    return 0;
+  }
+
+  async computeEncTotal() {
+    if (!this.pack) {
+      this.encTotal = this.items.map(it => it.getEncTotal()).reduce(Misc.sum(), 0);
+      return this.encTotal;
+    }
+    return 0;
+  }
+
+  async createItem(type, name = undefined) {
+    if (!name) {
+      name = 'Nouveau ' + Misc.typeName('Item', type);
+    }
+    await this.createEmbeddedDocuments('Item', [{ name: name, type: type }], { renderSheet: true });
+  }
+
+  canReceive(item) {
+    return false;
+  }
+
+  async processDropItem(params) {
+    const targetActorId = this.id;
+    const sourceActorId = params.sourceActorId;
+    const itemId = params.itemId;
+    const destId = params.destId;
+    const srcId = params.srcId;
+    if (sourceActorId && sourceActorId != targetActorId) {
+      console.log("Moving objects", sourceActorId, targetActorId, itemId);
+      this.moveItemsBetweenActors(itemId, sourceActorId);
+      return false;
+    }
+    let result = true;
+    const item = this.getItem(itemId);
+    if (item?.isInventaire('all') && sourceActorId == targetActorId) {
+      // rangement
+      if (srcId != destId && itemId != destId) { // déplacement de l'objet
+        const src = this.getItem(srcId);
+        const dest = this.getItem(destId);
+        const cible = this.getContenantOrParent(dest);
+        const [empilable, message] = item.isInventaireEmpilable(dest);
+        if (empilable) {
+          await dest.empiler(item)
+          result = false;
+        }
+        // changer de conteneur
+        else if (!cible || this.conteneurPeutContenir(cible, item)) {
+          await this.enleverDeConteneur(item, src, params.onEnleverConteneur);
+          await this.ajouterDansConteneur(item, cible, params.onAjouterDansConteneur);
+          if (message && !dest.isConteneur()) {
+            ui.notifications.info(cible
+              ? `${message}<br>${item.name} a été déplacé dans: ${cible.name}`
+              : `${message}<br>${item.name} a été sorti du conteneur`);
+          }
+        }
+      }
+    }
+    await this.computeEncTotal();
+    return result;
+  }
+
+  getContenantOrParent(dest) {
+    if (!dest || dest.isConteneur()) {
+      return dest;
+    }
+    return this.getContenant(dest);
+  }
+
+  getContenant(item) {
+    return this.itemTypes['conteneur'].find(it => it.system.contenu.includes(item.id));
+  }
+
+
+  /* -------------------------------------------- */
+  conteneurPeutContenir(dest, item) {
+    if (!dest) {
+      return true;
+    }
+    if (!dest.isConteneur()) {
+      return false;
+    }
+    const destData = dest
+    if (this._isConteneurContenu(item, dest)) {
+      ui.notifications.warn(`Impossible de déplacer un conteneur parent (${item.name}) dans un de ses contenus ${destData.name} !`);
+      return false; // Loop detected !
+    }
+
+    // Calculer le total actuel des contenus
+    let encContenu = this.getRecursiveEnc(dest) - Number(destData.system.encombrement);
+    let newEnc = this.getRecursiveEnc(item); // Calculer le total actuel du nouvel objet
+
+    // Teste si le conteneur de destination a suffisament de capacité pour recevoir le nouvel objet
+    if (Number(destData.system.capacite) < encContenu + newEnc) {
+      ui.notifications.warn(
+        `Le conteneur ${dest.name} a une capacité de ${destData.system.capacite}, et contient déjà ${encContenu}.
+        Impossible d'y ranger: ${item.name} d'encombrement ${newEnc}!`);
+      return false;
+    }
+    return true;
+  }
+
+  /* -------------------------------------------- */
+  _isConteneurContenu(item, conteneur) {
+    if (item?.isConteneur()) { // Si c'est un conteneur, il faut vérifier qu'on ne le déplace pas vers un sous-conteneur lui appartenant
+      for (let id of item.system.contenu) {
+        let subObjet = this.getItem(id);
+        if (subObjet?.id == conteneur.id) {
+          return true; // Loop detected !
+        }
+        if (subObjet?.isConteneur()) {
+          return this._isConteneurContenu(subObjet, conteneur);
+        }
+      }
+    }
+    return false;
+  }
+  /* -------------------------------------------- */
+  getRecursiveEnc(objet) {
+    if (!objet) {
+      return 0;
+    }
+    const tplData = objet.system;
+    if (objet.type != 'conteneur') {
+      return Number(tplData.encombrement) * Number(tplData.quantite);
+    }
+    const encContenus = tplData.contenu.map(idContenu => this.getRecursiveEnc(this.getItem(idContenu)));
+    return encContenus.reduce(Misc.sum(), 0)
+      + Number(tplData.encombrement) /* TODO? Number(tplData.quantite) -- on pourrait avoir plusieurs conteneurs...*/
+  }
+
+  /* -------------------------------------------- */
+  /** Ajoute un item dans un conteneur, sur la base
+   * de leurs ID */
+  async ajouterDansConteneur(item, conteneur, onAjouterDansConteneur) {
+    if (!conteneur) {
+      // TODO: afficher
+      item.estContenu = false;
+    }
+    else if (conteneur.isConteneur()) {
+      item.estContenu = true;
+      await this.updateEmbeddedDocuments('Item', [{
+        _id: conteneur.id,
+        'system.contenu': [...conteneur.system.contenu, item.id]
+      }]);
+      onAjouterDansConteneur(item.id, conteneur.id);
+    }
+  }
+
+  /* -------------------------------------------- */
+  /** Fonction de remise à plat de l'équipement (ie vide les champs 'contenu') */
+  async nettoyerConteneurs() {
+    RdDConfirm.confirmer({
+      settingConfirmer: "confirmation-vider",
+      content: `<p>Etes vous certain de vouloir vider tous les conteneurs ?</p>`,
+      title: 'Vider les conteneurs',
+      buttonLabel: 'Vider',
+      onAction: async () => {
+        const corrections = [];
+        for (let item of this.items) {
+          if (item.estContenu) {
+            item.estContenu = undefined;
+          }
+          if (item.type == 'conteneur' && item.system.contenu.length > 0) {
+            corrections.push({ _id: item.id, 'system.contenu': [] });
+          }
+        }
+        if (corrections.length > 0) {
+          await this.updateEmbeddedDocuments('Item', corrections);
+        }
+      }
+    });
+  }
+
+  /* -------------------------------------------- */
+  buildSubConteneurObjetList(conteneurId, deleteList) {
+    let conteneur = this.getItem(conteneurId);
+    if (conteneur?.type == 'conteneur') { // Si c'est un conteneur
+      for (let subId of conteneur.system.contenu) {
+        let subObj = this.getItem(subId);
+        if (subObj) {
+          if (subObj.type == 'conteneur') {
+            this.buildSubConteneurObjetList(subId, deleteList);
+          }
+          deleteList.push({ id: subId, conteneurId: conteneurId });
+        }
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  async deleteAllConteneur(itemId, options) {
+    let list = [];
+    list.push({ id: itemId, conteneurId: undefined }); // Init list
+    this.buildSubConteneurObjetList(itemId, list);
+    await this.deleteEmbeddedDocuments('Item', list.map(it => it.id), options);
+  }
+
+  /* -------------------------------------------- */
+  /** Supprime un item d'un conteneur, sur la base
+   * de leurs ID */
+  async enleverDeConteneur(item, conteneur, onEnleverDeConteneur) {
+    if (conteneur?.isConteneur()) {
+      item.estContenu = false;
+      await this.updateEmbeddedDocuments('Item', [{
+        _id: conteneur.id,
+        'system.contenu': conteneur.system.contenu.filter(id => id != item.id)
+      }]);
+      onEnleverDeConteneur();
+    }
+  }
+
+  /* -------------------------------------------- */
+  async moveItemsBetweenActors(itemId, sourceActorId) {
+    let itemsList = []
+    let sourceActor = game.actors.get(sourceActorId);
+    itemsList.push({ id: itemId, conteneurId: undefined }); // Init list
+    sourceActor.buildSubConteneurObjetList(itemId, itemsList); // Get itemId list
+
+    const itemsDataToCreate = itemsList.map(it => sourceActor.getItem(it.id))
+      .map(it => duplicate(it))
+      .map(it => { it.system.contenu = []; return it; });
+    let newItems = await this.createEmbeddedDocuments('Item', itemsDataToCreate);
+
+    let itemMap = this._buildMapOldNewId(itemsList, newItems);
+
+    for (let item of itemsList) { // Second boucle pour traiter la remise en conteneurs
+      // gestion conteneur/contenu
+      if (item.conteneurId) { // l'Objet était dans un conteneur
+        let newConteneurId = itemMap[item.conteneurId]; // Get conteneur
+        let newConteneur = this.getItem(newConteneurId);
+
+        let newItemId = itemMap[item.id]; // Get newItem
+
+        console.log('New conteneur filling!', newConteneur, newItemId, item);
+        let contenu = duplicate(newConteneur.system.contenu);
+        contenu.push(newItemId);
+        await this.updateEmbeddedDocuments('Item', [{ _id: newConteneurId, 'system.contenu': contenu }]);
+      }
+    }
+    for (let item of itemsList) {
+      await sourceActor.deleteEmbeddedDocuments('Item', [item.id]);
+    }
+  }
+
+  _buildMapOldNewId(itemsList, newItems) {
+    let itemMap = {};
+    for (let i = 0; i < itemsList.length; i++) {
+      itemMap[itemsList[i].id] = newItems[i].id; // Pour garder le lien ancien / nouveau
+    }
+    return itemMap;
+  }
+
+  /* -------------------------------------------- */
+  async postActorToChat(modeOverride) {
+    let chatData = {
+      doctype: 'Actor',
+      id: this.id,
+      type: this.type,
+      img: this.img,
+      pack: this.pack,
+      name: this.name,
+      system: { description: this.system.description }
+    }
+    renderTemplate('systems/foundryvtt-reve-de-dragon/templates/post-actor.html', chatData)
+      .then(html => ChatMessage.create(RdDUtility.chatDataSetup(html, modeOverride)));
+  }
+
+
+}

module/actor/commerce-sheet.js

@@ -0,0 +1,95 @@
+import { DialogItemAchat } from "../dialog-item-achat.js";
+import { RdDItem } from "../item.js";
+import { RdDSheetUtility } from "../rdd-sheet-utility.js";
+import { RdDUtility } from "../rdd-utility.js";
+import { RdDBaseActorSheet } from "./base-actor-sheet.js";
+import { RdDCommerce } from "./commerce.js";
+
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+export class RdDCommerceSheet extends RdDBaseActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+    return mergeObject(super.defaultOptions, {
+      classes: ["rdd", "sheet", "actor"],
+      template: "systems/foundryvtt-reve-de-dragon/templates/actor/commerce-actor-sheet.html",
+      width: 600,
+      height: 720,
+      tabs: [],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }]
+    });
+  }
+  get title() {
+    if (this.actor.token && this.actor.token != this.actor.prototypeToken) {
+      return this.actor.token.name;
+    }
+    return super.title
+  }
+
+  async getData() {
+    const formData = await super.getData();
+    if (this.actor.token && this.actor.token != this.actor.prototypeToken) {
+      mergeObject(formData,
+        {
+          title: this.actor.token.name,
+          token: {
+            img: this.actor.token.texture.src
+          }
+        },
+        { overwrite: true });
+
+    }
+    return formData;
+  }
+  /* -------------------------------------------- */
+  /** @override */
+  activateListeners(html) {
+    super.activateListeners(html);
+
+    this.html.find('a.item-acheter').click(async event => await this.vente(this.getItem(event)));
+
+    if (!this.options.editable) return;
+
+    this.html.find('a.item-quantite-moins').click(async event => await this.getItem(event)?.quantiteIncDec(-1, { supprimerSiZero: false }));
+    this.html.find('a.item-quantite-plus').click(async event => await this.getItem(event)?.quantiteIncDec(1));
+    this.html.find('input.item-quantite').change(async event => {
+      const newQuantite = Math.max(0, Number.parseInt(this.html.find(event.currentTarget).val()));
+      await this.getItem(event)?.update({ "system.quantite": newQuantite });
+    })
+    this.html.find('input.item-cout').change(async event => {
+      const newCout = Math.max(0, Number(this.html.find(event.currentTarget).val()));
+      await this.getItem(event)?.update({ "system.cout": newCout });
+    })
+  }
+
+  getTypesInventaire() {
+    return RdDItem.getItemTypesInventaire('all');
+  }
+
+
+  async vente(item) {
+    const acheteur = RdDUtility.getSelectedActor();
+    if (!acheteur) {
+      ui.notifications.warn(`Pas d'acheteur sélectionné`);
+      return;
+    }
+    const disponible = this.actor.getQuantiteDisponible(item)
+    if (disponible == 0) {
+      ui.notifications.warn(`${this.name} n'a plus de ${item.name} en vente`);
+      return;
+    }
+
+    await DialogItemAchat.onAcheter({
+      item,
+      vendeur: this.actor,
+      acheteur,
+      quantiteIllimite: disponible == undefined,
+      nbLots: disponible ?? 1,
+      tailleLot: 1,
+      prixLot: item.calculerPrixCommercant()
+    });
+  }
+}

module/actor/commerce.js

@@ -0,0 +1,53 @@
+import { Misc } from "../misc.js";
+import { RdDBaseActor } from "./base-actor.js";
+
+export class RdDCommerce extends RdDBaseActor {
+
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/services/commerce.webp";
+  }
+
+  prepareData() {
+    super.prepareData();
+  }
+  prepareDerivedData() {
+    super.prepareDerivedData();
+  }
+
+  canReceive(item) {
+    if (item.isInventaire('all')) {
+      return true;
+    }
+    return super.canReceive(item);
+  }
+
+  getQuantiteDisponible(item) {
+    return (this.system.illimite || item?.isService()) ? undefined : item.getQuantite();
+  }
+
+  verifierFortune(cout) {
+    return this.system.illimite || super.verifierFortune(cout);
+  }
+  async depenserSols(cout) {
+    if (this.system.illimite) {
+      return
+    }
+    await super.depenserSols(cout)
+  }
+
+  async consommerNourritureAchetee(achat, vente, createdItemId) {
+    // ne pas consommer pour un commerce
+  }
+
+  async decrementerQuantiteItem(item, quantite) {
+    if (this.system.illimite) {
+      return;
+    }
+    await super.decrementerQuantiteItem(item, quantite, { supprimerSiZero: false });
+  }
+
+  calculerPrix(item) {
+    const pourcentage = this.system.pourcentage ?? 100;
+    return Misc.keepDecimals(Math.ceil(item.system.cout * pourcentage) / 100, 2);
+  }
+}

module/actor/experience-log.js

@@ -0,0 +1,39 @@
+
+export const XP_TOPIC = {
+  XP: { code: 'xp', label: 'xp' },
+  XPSORT: { code: 'xpsort', label: 'xp sort' },
+  NIVEAU: { code: 'niveau', label: 'Niveau' },
+  XPCARAC: { code: 'xpcarac', label: 'xp carac' },
+  CARAC: { code: 'carac', label: 'Carac' },
+  STRESS: { code: 'stress', label: 'Stress' },
+  TRANSFORM: { code: 'xps', label: 'Transformé' },
+}
+
+export class ExperienceLog {
+
+  static async add(actor, topic, from, to, raison, manuel = false) {
+    if (!actor.hasPlayerOwner || !actor.isPersonnage()) {
+      return
+    }
+    if (from == to) {
+      return
+    }
+    const newXpLog = {
+      mode: topic?.code ?? topic,
+      raison: (manuel ? '(manuel) ' : '') + raison,
+      from: from,
+      to: to,
+      valeur: to - from,
+      daterdd: game.system.rdd.calendrier.dateCourante(),
+      datereel: game.system.rdd.calendrier.dateReel().replace('T', ' ')
+    };
+    console.log('ExperienceLog.add', newXpLog)
+    const newExperienceLog = (actor.system.experiencelog ?? []).concat([newXpLog]);
+    await actor.update({ [`system.experiencelog`]: newExperienceLog });
+  }
+
+  static labelTopic(topic) {
+    const xpt = Object.values(XP_TOPIC).find(it => it.code == topic);
+    return xpt?.label ?? xpt?.code ?? topic;
+  }
+}

module/chat-utility.js

@@ -78,11 +78,7 @@ export class ChatUtility {
 
   /* -------------------------------------------- */
   static async createChatWithRollMode(name, chatOptions) {
-    return await ChatUtility.createChatMessage(name, game.settings.get("core", "rollMode"), chatOptions);
+    let rollMode = game.settings.get("core", "rollMode")
-  }
-
-  /* -------------------------------------------- */
-  static async createChatMessage(name, rollMode, chatOptions) {
     switch (rollMode) {
       case "blindroll": // GM only
         if (!game.user.isGM) {

module/dialog-chronologie.js

@@ -1,5 +1,7 @@
 import { SYSTEM_RDD } from "./constants.js";
 import { Grammar } from "./grammar.js";
+import { HtmlUtility } from "./html-utility.js";
+import { RdDTimestamp } from "./time/rdd-timestamp.js";
 
 
 const LATEST_USED_JOURNAL_ID = "chronologie-dernier-journal";
@@ -16,104 +18,119 @@ export class DialogChronologie extends Dialog {
     });
   }
   static async create() {
-    const dateRdD = game.system.rdd.calendrier.getCalendrier();
     const dialogData = {
       auteur: game.user.name,
       isGM: game.user.isGM,
       information: "",
       journalId: game.settings.get(SYSTEM_RDD, LATEST_USED_JOURNAL_ID),
       journaux: game.journal.filter(it => it.testUserPermission(game.user, CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER)),
-      dateRdD: dateRdD,
+      timestamp: game.system.rdd.calendrier.timestamp,
-      jourRdD: dateRdD.jour +1,
+      dateReel: game.system.rdd.calendrier.dateReel()
-      heureRdD: game.system.rdd.calendrier.getCurrentHeure(),
-      dateReel: DialogChronologie.getCurrentDateTime()
     };
     const html = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/dialog-chronologie.html", dialogData);
-    const dialog = new DialogChronologie(html);
+    const dialog = new DialogChronologie(html, dialogData);
     dialog.render(true);
   }
 
-  constructor(html) {
+  constructor(html, dialogData) {
     const options = {
       classes: ["DialogChronologie"],
       width: 500,
       height: 'fit-content',
       'z-index': 99999
     };
+    const timeData = dialogData.timestamp.toCalendrier()
     const conf = {
-      title: "Chronologie",
+      title: `Chronologie - ${timeData.jourDuMois} ${timeData.mois.label} - Heure  ${timeData.heure.label}`,
       content: html,
       buttons: {
-        ajout: { label: "Ajouter", callback: it => this.ajouter() },
       }
     };
     super(conf, options);
-  }
+    this.dialogData = dialogData;
-
-  static getCurrentDateTime() {
-    return new Date().toLocaleString("sv-SE", {
-      year: "numeric",
-      month: "2-digit",
-      day: "2-digit",
-      hour: "2-digit",
-      minute: "2-digit"
-    }).replace(" ", "T");
   }
 
   activateListeners(html) {
+    this.html = html;
     super.activateListeners(html);
+    const journalPrecedent = game.journal.get(this.dialogData.journalId);
+    this.showChronologiePreset(!(journalPrecedent?.canUserModify(game.user)))
+
+    this.html.find("a.chronologie-preset-show").click(event => this.showChronologiePreset(true));
+    this.html.find("a.chronologie-preset-hide").click(event => this.showChronologiePreset(false));
+    this.html.find("button.chronologie-ajouter").click(event => this.ajouter());
+  }
+
+  showChronologiePreset(showPreset) {
+    HtmlUtility.showControlWhen(this.html.find(".chronologie-preset-show"), !showPreset);
+    HtmlUtility.showControlWhen(this.html.find(".chronologie-preset-hide"), showPreset);
+    HtmlUtility.showControlWhen(this.html.find(".chronologie-preset"), showPreset);
   }
 
   async ajouter() {
     await this.forceValidation();
     const { journalId, journalEntry } = this.findJournal();
-    // ajouter à la page ou créer une page
+    if (journalEntry?.canUserModify(game.user)) {
-    this.addContentToJournal(journalEntry, await this.prepareChronologieEntry());
+      const journalParameters = this.extractJournalParameters();
 
+      const jour = journalParameters.dateRdD.jour;
+      const mois = journalParameters.dateRdD.mois.label;
+      const annee = journalParameters.dateRdD.annee;
+      const section = `${jour} ${mois} ${annee}`
+      const content = await this.prepareChronologieEntry(journalParameters);
+      // ajouter à la page ou créer une page
+      this.addContentToJournal(journalEntry, section, content);
       this.storeLatestUsedJournalEntry(journalId);
+      this.close();
+    }
+    else {
+      const journal = this.html.find("form.rdddialogchrono select[name='journalId']").val();
+      ui.notifications.warn(`Le journal ${journal} n'est pas accessible`);
+    }
   }
 
   async forceValidation() {
-    await $("form.rdddialogchrono :input").change();
+    await this.html.find("form.rdddialogchrono :input").change();
   }
 
   findJournal() {
-    const journalId = $("form.rdddialogchrono :input[name='journalId']").val();
+    const journalId = this.html.find("form.rdddialogchrono :input[name='journalId']").val();
     const journalEntry = game.journal.get(journalId);
     return { journalId, journalEntry };
   }
 
-  async prepareChronologieEntry() {
+  async prepareChronologieEntry(journalParameters) {
-    return await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/chronologie-entry.html", this.extractJournalParameters());
+    return await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/chronologie-entry.html", journalParameters);
   }
 
   extractJournalParameters() {
     return {
-      auteur: $("form.rdddialogchrono :input[name='auteur']").val(),
+      auteur: this.html.find("form.rdddialogchrono :input[name='auteur']").val(),
-      information: $("form.rdddialogchrono :input[name='information']").val(),
+      information: this.html.find("form.rdddialogchrono :input[name='information']").val(),
       dateRdD: {
-        jour: $("form.rdddialogchrono :input[name='jourRdD']").val(),
+        jour: this.html.find("form.rdddialogchrono :input[name='chronologie.jourDuMois']").val(),
-        moisRdD: $("form.rdddialogchrono :input[name='dateRdD.moisRdD.key']").val(),
+        mois: RdDTimestamp.definition(this.html.find("form.rdddialogchrono :input[name='chronologie.mois']").val()),
-        annee: $("form.rdddialogchrono :input[name='dateRdD.annee']").val()
+        annee: this.html.find("form.rdddialogchrono :input[name='chronologie.annee']").val(),
+        heure: RdDTimestamp.definition(this.html.find("form.rdddialogchrono :input[name='chronologie.heure']").val()),
+        minute: this.html.find("form.rdddialogchrono :input[name='chronologie.minute']").val(),
       },
-      heureRdD: $("form.rdddialogchrono :input[name='heureRdD']").val(),
+      dateReel: this.html.find("form.rdddialogchrono :input[name='dateReel']").val()
-      dateReel: $("form.rdddialogchrono :input[name='dateReel']").val().replace('T', ' ')
     }
   }
 
-  addContentToJournal(journalEntry, content) {
+  addContentToJournal(journalEntry, section, content) {
-    let page = journalEntry.pages.find(p => p.type == 'text' && Grammar.equalsInsensitive(p.name, 'Chronologie'));
+    let page = journalEntry.pages.find(p => p.type == 'text' && Grammar.equalsInsensitive(p.name, section));
     if (page) {
-      page.update({ 'text.content': content + '\n' + page.text.content });
+      page.update({ 'text.content': page.text.content + '\n' + content });
     }
     else {
-      journalEntry.createEmbeddedDocuments('JournalEntryPage', [this.newPageChronologie(content)]);
+      journalEntry.createEmbeddedDocuments('JournalEntryPage', [this.newPageChronologie(section, content)]);
     }
   }
 
-  newPageChronologie(content) {
+  newPageChronologie(section, content) {
     return new JournalEntryPage({
-      name: 'Chronologie',
+      name: section,
       type: 'text',
       title: { show: true, level: 1 },
       text: { content: content, format: 1 }

module/dialog-create-signedraconique.js

@@ -1,6 +1,6 @@
 import { ChatUtility } from "./chat-utility.js";
 import { HtmlUtility } from "./html-utility.js";
-import { RdDItemSigneDraconique } from "./item-signedraconique.js";
+import { RdDItemSigneDraconique } from "./item/signedraconique.js";
 import { TMRUtility } from "./tmr-utility.js";
 
 export class DialogCreateSigneDraconique extends Dialog {
@@ -37,8 +37,8 @@ export class DialogCreateSigneDraconique extends Dialog {
   }
   
   async _onCreerSigneActeurs() {
-    await $("[name='signe.system.ephemere']").change();
+    await this.html.find("[name='signe.system.ephemere']").change();
-    await $(".signe-xp-sort").change();
+    await this.html.find(".signe-xp-sort").change();
     this.validerSigne();
     this.dialogData.actors.filter(it => it.selected)
     .map(it => game.actors.get(it.id))
@@ -57,19 +57,20 @@ export class DialogCreateSigneDraconique extends Dialog {
   }
 
   validerSigne() {
-    this.dialogData.signe.name = $("[name='signe.name']").val();
+    this.dialogData.signe.name = this.html.find("[name='signe.name']").val();
-    this.dialogData.signe.system.valeur.norm = $("[name='signe.system.valeur.norm']").val();
+    this.dialogData.signe.system.valeur.norm = this.html.find("[name='signe.system.valeur.norm']").val();
-    this.dialogData.signe.system.valeur.sign = $("[name='signe.system.valeur.sign']").val();
+    this.dialogData.signe.system.valeur.sign = this.html.find("[name='signe.system.valeur.sign']").val();
-    this.dialogData.signe.system.valeur.part = $("[name='signe.system.valeur.part']").val();
+    this.dialogData.signe.system.valeur.part = this.html.find("[name='signe.system.valeur.part']").val();
-    this.dialogData.signe.system.difficulte = $("[name='signe.system.difficulte']").val();
+    this.dialogData.signe.system.difficulte = this.html.find("[name='signe.system.difficulte']").val();
-    this.dialogData.signe.system.ephemere = $("[name='signe.system.ephemere']").prop("checked");
+    this.dialogData.signe.system.ephemere = this.html.find("[name='signe.system.ephemere']").prop("checked");
-    this.dialogData.signe.system.duree = $("[name='signe.system.duree']").val();
+    this.dialogData.signe.system.duree = this.html.find("[name='signe.system.duree']").val();
     this.dialogData.signe.system.typesTMR = TMRUtility.buildListTypesTMRSelection(this.dialogData.tmrs);
   }
   
   /* -------------------------------------------- */
   activateListeners(html) {
     super.activateListeners(html);
+    this.html = html;
     this.setEphemere(this.dialogData.signe.system.ephemere);
     html.find(".signe-aleatoire").click(event => this.setSigneAleatoire());
     html.find("[name='signe.system.ephemere']").change((event) => this.setEphemere(event.currentTarget.checked));
@@ -81,27 +82,27 @@ export class DialogCreateSigneDraconique extends Dialog {
   async setSigneAleatoire() {
     const newSigne = await RdDItemSigneDraconique.randomSigneDraconique({ephemere: true});
 
-    $("[name='signe.name']").val(newSigne.name);
+    this.html.find("[name='signe.name']").val(newSigne.name);
-    $("[name='signe.system.valeur.norm']").val(newSigne.system.valeur.norm);
+    this.html.find("[name='signe.system.valeur.norm']").val(newSigne.system.valeur.norm);
-    $("[name='signe.system.valeur.sign']").val(newSigne.system.valeur.sign);
+    this.html.find("[name='signe.system.valeur.sign']").val(newSigne.system.valeur.sign);
-    $("[name='signe.system.valeur.part']").val(newSigne.system.valeur.part);
+    this.html.find("[name='signe.system.valeur.part']").val(newSigne.system.valeur.part);
-    $("[name='signe.system.difficulte']").val(newSigne.system.difficulte);
+    this.html.find("[name='signe.system.difficulte']").val(newSigne.system.difficulte);
-    $("[name='signe.system.duree']").val(newSigne.system.duree);
+    this.html.find("[name='signe.system.duree']").val(newSigne.system.duree);
-    $("[name='signe.system.ephemere']").prop("checked", newSigne.system.ephemere);
+    this.html.find("[name='signe.system.ephemere']").prop("checked", newSigne.system.ephemere);
     this.dialogData.tmrs = TMRUtility.buildSelectionTypesTMR(newSigne.system.typesTMR);
     this.dialogData.tmrs.forEach(t => {
-      $(`[data-tmr-name='${t.name}']`).prop( "checked", t.selected);
+      this.html.find(`[data-tmr-name='${t.name}']`).prop( "checked", t.selected);
     })
     this.setEphemere(newSigne.system.ephemere);
   }
 
   async setEphemere(ephemere) {
     this.dialogData.signe.system.ephemere = ephemere;
-    HtmlUtility._showControlWhen($(".signe-system-duree"), ephemere);
+    HtmlUtility.showControlWhen(this.html.find(".signe-system-duree"), ephemere);
   }
 
   async onSelectActor(event) {
-    const actorId = $(event.currentTarget)?.data("actor-id");
+    const actorId = this.html.find(event.currentTarget)?.data("actor-id");
     const actor = this.dialogData.actors.find(it => it.id == actorId);
     if (actor) {
       actor.selected = event.currentTarget.checked;
@@ -109,7 +110,7 @@ export class DialogCreateSigneDraconique extends Dialog {
   }
 
   onSelectTmr(event) {
-    const tmrName = $(event.currentTarget)?.data("tmr-name");
+    const tmrName = this.html.find(event.currentTarget)?.data("tmr-name");
     const onTmr = this.tmrs.find(it => it.name == tmrName);
     if (onTmr){
       onTmr.selected = event.currentTarget.checked;

module/dialog-fabriquer-potion.js

@@ -5,7 +5,7 @@ import { RdDUtility } from "./rdd-utility.js";
 export class DialogFabriquerPotion extends Dialog {
 
   /* -------------------------------------------- */
-  static async create(actor, item, dialogConfig) {
+  static async create(actor, item, onActionItem) {
     const min = DialogFabriquerPotion.nombreBrinsMinimum(item);
     if (item.system.quantite < min) {
       ui.notifications.warn(`Vous avez ${item.system.quantite} brins de ${item.name}, il en faut au moins ${min} pour faire une potion!`);
@@ -13,18 +13,10 @@ export class DialogFabriquerPotion extends Dialog {
     }
     let potionData = DialogFabriquerPotion.prepareData(actor, item);
 
-    let conf = {
+    const html = await renderTemplate( 'systems/foundryvtt-reve-de-dragon/templates/dialog-fabriquer-potion-base.html', potionData);
-      title: `Fabriquer une potion de ${potionData.system.categorie}`,
-      content: await renderTemplate(dialogConfig.html, potionData),
-      default: potionData.buttonName,
-    };
 
     let options = { classes: ["dialogfabriquerpotion"], width: 600, height: 160, 'z-index': 99999 };
-    mergeObject(options, dialogConfig.options ?? {}, { overwrite: true })
+    new DialogFabriquerPotion(actor, potionData, onActionItem, html, options).render(true);
-
-    const dialog = new DialogFabriquerPotion(actor, potionData, conf, options);
-    dialog.render(true);
-    return dialog;
   }
 
   /* -------------------------------------------- */
@@ -40,10 +32,15 @@ export class DialogFabriquerPotion extends Dialog {
   }
 
   /* -------------------------------------------- */
-  constructor(actor, potionData, conf, options) {
+  constructor(actor, potionData, onActionItem, html, options) {
-    conf.buttons = {
+    const conf = {
-      [potionData.buttonName]: {
+      title: `Fabriquer une potion de ${potionData.system.categorie}`,
-        label: potionData.buttonName, callback: it => this.onFabriquer(it)
+      content: html,
+      default: 'fabriquer',
+      buttons: {
+        'fabriquer': {
+          label: potionData.buttonName, callback: it => this.onFabriquer()
+        }
       }
     };
 
@@ -51,6 +48,26 @@ export class DialogFabriquerPotion extends Dialog {
 
     this.actor = actor;
     this.potionData = potionData;
+    this.onActionItem = onActionItem;
+  }
+
+  /* -------------------------------------------- */
+  activateListeners(html) {
+    super.activateListeners(html);
+    this.html = html;
+    this.html.find("[name='nbBrins']").change(event => {
+      this.potionData.nbBrins = Misc.toInt(event.currentTarget.value);
+      const brinsManquants = Math.max(0, DialogFabriquerPotion.nombreBrinsOptimal(this.potionData) - this.potionData.nbBrins);
+      this.potionData.herbebonus = Math.max(0, this.potionData.system.niveau - brinsManquants)
+    });
+  }
+
+  /* -------------------------------------------- */
+  async onFabriquer() {
+    await this.html.find("[name='nbBrins']").change();
+    await this.actor.fabriquerPotion(this.potionData);
+    this.close();
+    await this.onActionItem()
   }
 
   static nombreBrinsMinimum(herbeData) {
@@ -68,22 +85,4 @@ export class DialogFabriquerPotion extends Dialog {
     }
     return 1;
   }
-
-  /* -------------------------------------------- */
-  activateListeners(html) {
-    super.activateListeners(html);
-
-    html.find("#nbBrins").change(event => {
-      this.potionData.nbBrins = Misc.toInt(event.currentTarget.value);
-      const brinsManquants = Math.max(0, DialogFabriquerPotion.nombreBrinsOptimal(this.potionData) - this.potionData.nbBrins);
-      this.potionData.herbebonus = Math.max(0, this.potionData.system.niveau - brinsManquants)
-    });
-  }
-
-  /* -------------------------------------------- */
-  async onFabriquer(it) {
-    await $("#nbBrins").change();
-    this.actor.fabriquerPotion(this.potionData);
-    this.close();
-  }
 }

module/dialog-item-achat.js

@@ -1,14 +1,13 @@
-
+import { Misc } from "./misc.js";
-import { Monnaie } from "./item-monnaie.js";
 import { RdDUtility } from "./rdd-utility.js";
 
 export class DialogItemAchat extends Dialog {
 
-  static venteData(button) {
+  static preparerAchat(chatButton) {
-    const vendeurId = button.attributes['data-vendeurId']?.value;
+    const vendeurId = chatButton.attributes['data-vendeurId']?.value;
     const vendeur = vendeurId ? game.actors.get(vendeurId) : undefined;
     const acheteur = RdDUtility.getSelectedActor();
-    const json = button.attributes['data-jsondata']?.value;
+    const json = chatButton.attributes['data-jsondata']?.value;
     if (!acheteur && !vendeur) {
       ui.notifications.info("Pas d'acheteur ni de vendeur, aucun changement");
       return undefined;
@@ -18,59 +17,77 @@ export class DialogItemAchat extends Dialog {
       return undefined;
     }
 
-    const prixLot = Number(button.attributes['data-prixLot']?.value ?? 0);
     return {
-      item: json ? JSON.parse(json) : undefined,
+      item: JSON.parse(json),
-      actingUserId: game.user.id,
+      vendeur,
-      vendeurId: vendeurId,
+      acheteur,
-      vendeur: vendeur,
+      nbLots: parseInt(chatButton.attributes['data-quantiteNbLots']?.value),
-      acheteur: acheteur,
+      tailleLot: parseInt(chatButton.attributes['data-tailleLot']?.value ?? 1),
-      tailleLot: parseInt(button.attributes['data-tailleLot']?.value ?? 1),
+      prixLot: Number(chatButton.attributes['data-prixLot']?.value ?? 0),
-      quantiteIllimite: button.attributes['data-quantiteIllimite']?.value == 'true',
+      quantiteIllimite: chatButton.attributes['data-quantiteIllimite']?.value == 'true',
-      quantiteNbLots: parseInt(button.attributes['data-quantiteNbLots']?.value),
+      chatMessageIdVente: RdDUtility.findChatMessageId(chatButton),
-      choix: {
-        nombreLots: 1,
-        seForcer: false,
-        supprimerSiZero: true
-      },
-      prixLot: prixLot,
-      prixTotal: prixLot,
-      isVente: prixLot > 0,
-      chatMessageIdVente: RdDUtility.findChatMessageId(button)
     };
   }
 
-  static async onAcheter(venteData) {
+
+  static async onAcheter({ item, vendeur, acheteur, tailleLot, prixLot, nbLots, quantiteIllimite, chatMessageIdVente }) {
+    const venteData = {
+      item,
+      actingUserId: game.user.id,
+      vendeur,
+      acheteur,
+      tailleLot,
+      quantiteIllimite,
+      quantiteNbLots: nbLots,
+      choix: { seForcer: false, supprimerSiZero: true },
+      prixLot,
+      isVente: prixLot > 0,
+      isConsommable: item.type == 'nourritureboisson' && acheteur?.isPersonnage(),
+      chatMessageIdVente
+    };
+
+    DialogItemAchat.changeNombreLots(venteData, 1);
     const html = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/dialog-item-achat.html`, venteData);
-    const dialog = new DialogItemAchat(html, venteData);
+    new DialogItemAchat(html, venteData).render(true);
-    dialog.render(true);
+  }
+
+  static changeNombreLots(venteData, nombreLots) {
+    venteData.choix.nombreLots = nombreLots;
+    venteData.prixTotal = (nombreLots * venteData.prixLot).toFixed(2);
+    if (venteData.isConsommable) {
+      const doses = nombreLots * venteData.tailleLot;
+      venteData.totalSust = Misc.keepDecimals(doses * (venteData.item.system.sust ?? 0), 2);
+      venteData.totalDesaltere = venteData.item.system.boisson
+        ? Misc.keepDecimals(doses * (venteData.item.system.desaltere ?? 0), 2)
+        : 0;
+    }
   }
 
   constructor(html, venteData) {
-    const isConsommable = venteData.item.type == 'nourritureboisson' && venteData.acheteur?.isPersonnage();
     let options = { classes: ["dialogachat"], width: 400, height: 'fit-content', 'z-index': 99999 };
 
     const actionAchat = venteData.prixLot > 0 ? "Acheter" : "Prendre";
     const buttons = {};
-    if (isConsommable) {
+    if (venteData.isConsommable) {
       buttons["consommer"] = { label: venteData.item.system.boisson ? "Boire" : "Manger", callback: it => this.onAchatConsommer() }
     }
     buttons[actionAchat] = { label: actionAchat, callback: it => { this.onAchat(); } };
     buttons["decliner"] = { label: "Décliner", callback: it => { } };
+    const acheteur = venteData.acheteur?.name ?? 'Un acheteur';
+    const vendeur = venteData.vendeur?.name ?? 'Un vendeur';
     let conf = {
-      title: venteData.acheteur ? venteData.acheteur.name + " - " + actionAchat : actionAchat,
+      title: `${acheteur} - ${actionAchat} à ${vendeur}`,
       content: html,
       default: actionAchat,
       buttons: buttons
     };
 
     super(conf, options);
-
     this.venteData = venteData;
   }
 
   async onAchat() {
-    await $(".nombreLots").change();
+    await this.html.find(".nombreLots").change();
     (this.venteData.vendeur ?? this.venteData.acheteur).achatVente({
       userId: game.user.id,
       vendeurId: this.venteData.vendeur?.id,
@@ -90,9 +107,9 @@ export class DialogItemAchat extends Dialog {
   /* -------------------------------------------- */
   activateListeners(html) {
     super.activateListeners(html);
-
+    this.html = html;
-    html.find(".nombreLots").change(event => this.setNombreLots(Number(event.currentTarget.value)));
+    this.html.find(".nombreLots").change(event => this.setNombreLots(Number(event.currentTarget.value)));
-    html.find(".se-forcer").change(event => this.setSeForcer(event));
+    this.html.find(".se-forcer").change(event => this.setSeForcer(event));
   }
 
   setSeForcer(event) {
@@ -100,13 +117,21 @@ export class DialogItemAchat extends Dialog {
   }
 
   setNombreLots(nombreLots) {
-    if (nombreLots > this.venteData.quantiteNbLots) {
+
+    if (!this.venteData.quantiteIllimite) {
+      if (!this.venteData.quantiteIllimite && nombreLots > this.venteData.quantiteNbLots) {
         ui.notifications.warn(`Seulement ${this.venteData.quantiteNbLots} lots disponibles, vous ne pouvez pas en prendre ${nombreLots}`)
       }
-    this.venteData.choix.nombreLots = Math.min(nombreLots, this.venteData.quantiteNbLots);
+      nombreLots = Math.min(nombreLots, this.venteData.quantiteNbLots);
-    this.venteData.prixTotal = (nombreLots * this.venteData.prixLot).toFixed(2);
-    $(".nombreLots").val(this.venteData.choix.nombreLots);
-    $(".prixTotal").text(this.venteData.prixTotal);
     }
 
+    DialogItemAchat.changeNombreLots(this.venteData, nombreLots);
+
+    this.html.find(".nombreLots").val(nombreLots);
+    this.html.find(".prixTotal").text(this.venteData.prixTotal);
+    this.html.find("span.total-sust").text(this.venteData.totalSust);
+    this.html.find("span.total-desaltere").text(this.venteData.totalDesaltere);
+  }
+
+
 }

module/dialog-item-consommer.js

@@ -2,13 +2,13 @@ import { Misc } from "./misc.js";
 
 export class DialogConsommer extends Dialog {
 
-  static async create(actor, item, onActionItem = async ()=>{}) {
+  static async create(actor, item, onActionItem = async () => { }) {
     const consommerData = DialogConsommer.prepareData(actor, item);
     const html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/dialog-item-consommer.html', consommerData);
     return new DialogConsommer(actor, item, consommerData, html, onActionItem)
   }
 
-  constructor(actor, item, consommerData, html, onActionItem = async ()=>{}) {
+  constructor(actor, item, consommerData, html, onActionItem = async () => { }) {
     const options = { classes: ["dialogconsommer"], width: 350, height: 'fit-content', 'z-index': 99999 };
     let conf = {
       title: consommerData.title,
@@ -17,8 +17,9 @@ export class DialogConsommer extends Dialog {
       buttons: {
         [consommerData.buttonName]: {
           label: consommerData.buttonName, callback: async it => {
-            await this.onConsommer(it);
+            await this.onConsommer();
-            await onActionItem();}
+            await onActionItem();
+          }
         }
       }
     };
@@ -30,17 +31,23 @@ export class DialogConsommer extends Dialog {
     this.consommerData = consommerData;
   }
 
-  async onConsommer(event) {
+  activateListeners(html) {
-    await $(".se-forcer").change();
+    super.activateListeners(html);
-    await $(".consommer-doses").change();
+    this.html = html;
+    this.html.find(".se-forcer").change(event => this.setSeForcer(event));
+    this.html.find(".consommer-doses").change(event => this.selectDoses(event));
+  }
+
+  async onConsommer() {
+    await this.html.find(".se-forcer").change();
+    await this.html.find(".consommer-doses").change();
     await this.actor.consommer(this.item, this.consommerData.choix);
   }
 
   /* -------------------------------------------- */
   static prepareData(actor, item) {
-    item = duplicate(item);
     let consommerData = {
-      item: item,
+      item: duplicate(item),
       cuisine: actor.getCompetence('cuisine'),
       choix: {
         doses: 1,
@@ -48,33 +55,47 @@ export class DialogConsommer extends Dialog {
       }
     }
     switch (item.type) {
+      case 'herbe': case 'faune':
+        consommerData.title = 'Manger une portion crue: ';
+        consommerData.buttonName = "Manger";
+        break;
       case 'nourritureboisson':
-        consommerData.title = item.system.boisson ? `${item.name}: boire une dose` : `${item.name}: manger une portion`;
+        consommerData.title = item.system.boisson ? 'Boire une dose: ' : 'Manger une portion: ';
         consommerData.buttonName = item.system.boisson ? "Boire" : "Manger";
         break;
       case 'potion':
-        consommerData.title = `${item.name}: boire la potion`;
+        consommerData.title = 'Boire la potion: ';
         consommerData.buttonName = "Boire";
         break;
     }
-    DialogConsommer.calculDoses(consommerData, consommerData.choix.doses)
+    consommerData.title += item.name;
+    DialogConsommer.calculDoses(consommerData, item)
     return consommerData;
   }
 
-  static calculDoses(consommer) {
+  static calculDoses(consommer, item) {
     const doses = consommer.choix.doses;
+    switch (item.type) {
+      case 'herbe': case 'faune':
+        consommer.totalSust = doses;
+        consommer.totalDesaltere = 0;
+        consommer.choix.sust = 1;
+        consommer.choix.quantite = 0;
+        consommer.choix.encombrement = Misc.keepDecimals(consommer.item.system.encombrement / item.system.sust, 2);
+        return;
+      case 'nourritureboisson':
+        consommer.choix.sust = consommer.item.system.sust;
+        consommer.choix.quantite = doses;
+        consommer.choix.encombrement = 0
         consommer.totalSust = Misc.keepDecimals(doses * (consommer.item.system.sust ?? 0), 2);
         consommer.totalDesaltere = consommer.item.system.boisson
           ? Misc.keepDecimals(doses * (consommer.item.system.desaltere ?? 0), 2)
           : 0;
+        break;
+      case 'potion':
+        consommer.totalSust = 0
+        consommer.totalDesaltere = 0
     }
-
-
-  /* -------------------------------------------- */
-  activateListeners(html) {
-    super.activateListeners(html);
-    html.find(".se-forcer").change(event => this.setSeForcer(event));
-    html.find(".consommer-doses").change(event => this.selectDoses(event));
   }
 
 
@@ -84,8 +105,8 @@ export class DialogConsommer extends Dialog {
 
   selectDoses(event) {
     this.consommerData.choix.doses = Number(event.currentTarget.value);
-    DialogConsommer.calculDoses(this.consommerData);
+    DialogConsommer.calculDoses(this.consommerData, this.item);
-    $(".total-sust").text(this.consommerData.totalSust);
+    this.html.find(".total-sust").text(this.consommerData.totalSust);
-    $(".total-desaltere").text(this.consommerData.totalDesaltere);
+    this.html.find(".total-desaltere").text(this.consommerData.totalDesaltere);
   }
 }

module/dialog-item-vente.js

@@ -2,21 +2,22 @@ import { HtmlUtility } from "./html-utility.js";
 
 export class DialogItemVente extends Dialog {
 
-  static async display(item, callback) {
+  static async display({ item, callback, quantiteMax = undefined }) {
-    const quantite = item.isConteneur() ? 1 : item.system.quantite;
+    const quantite = quantiteMax ?? item.getQuantite() ?? 1;
+    const isOwned = item.parent;
     const venteData = {
       item: item,
       alias: item.actor?.name ?? game.user.name,
       vendeurId: item.actor?.id,
-      prixOrigine: item.system.cout,
+      prixOrigine: item.calculerPrixCommercant(),
-      prixUnitaire: item.system.cout,
+      prixUnitaire: item.calculerPrixCommercant(),
-      prixLot: item.system.cout,
+      prixLot: item.calculerPrixCommercant(),
       tailleLot: 1,
       quantiteNbLots: quantite,
       quantiteMaxLots: quantite,
-      quantiteMax: quantite ,
+      quantiteMax: quantite,
-      quantiteIllimite: !item.isOwned,
+      quantiteIllimite: item.isItemCommerce() ? quantiteMax == undefined : !isOwned,
-      isOwned: item.isOwned,
+      isOwned: isOwned,
     };
     const html = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/dialog-item-vente.html`, venteData);
     return new DialogItemVente(venteData, html, callback).render(true);
@@ -37,57 +38,65 @@ export class DialogItemVente extends Dialog {
     this.venteData = venteData;
   }
 
-  async onProposer(it) {
-    await $(".tailleLot").change();
-    await $(".quantiteNbLots").change();
-    await $(".quantiteIllimite").change();
-    await $(".prixLot").change();
-    this.callback(this.venteData);
-  }
-
-  /* -------------------------------------------- */
   activateListeners(html) {
     super.activateListeners(html);
 
-    HtmlUtility._showControlWhen($(".quantiteNbLots"), !this.venteData.quantiteIllimite)
+    this.html = html;
+    this.html.find(".tailleLot").change(event => this.setTailleLot(Number(event.currentTarget.value)));
+    this.html.find(".quantiteNbLots").change(event => this.setNbLots(Number(event.currentTarget.value)));
+    this.html.find(".quantiteIllimite").change(event => this.setQuantiteIllimite(event.currentTarget.checked));
+    this.html.find(".prixLot").change(event => this.setPrixLot(Number(event.currentTarget.value)));
 
-    html.find(".tailleLot").change(event => this.setTailleLot(Number(event.currentTarget.value)));
+    this.setQuantiteIllimite(this.venteData.quantiteIllimite);
-    html.find(".quantiteNbLots").change(event => this.setNbLots(Number(event.currentTarget.value)));
-    html.find(".quantiteIllimite").change(event => this.setQuantiteIllimite(event.currentTarget.checked));
-    html.find(".prixLot").change(event => this.setPrixLot(Number(event.currentTarget.value)));
   }
 
+  async onProposer(it) {
+    this.updateVente(this.getChoixVente());
+    this.callback(this.venteData);
+  }
+
+  updateVente(update) {
+    mergeObject(this.venteData, update);
+  }
+
+  getChoixVente() {
+    return {
+      quantiteNbLots: Number(this.html.find(".quantiteNbLots").val()),
+      tailleLot: Number(this.html.find(".tailleLot").val()),
+      quantiteIllimite: this.html.find(".quantiteIllimite").is(':checked'),
+      prixLot: Number(this.html.find(".prixLot").val())
+    };
+  }
+
+  /* -------------------------------------------- */
   setPrixLot(prixLot) {
     this.venteData.prixLot = prixLot;
   }
 
   setTailleLot(tailleLot) {
-    // recalculer le prix du lot
+    const maxLots = Math.floor(this.venteData.quantiteMax / tailleLot);
-    if (tailleLot != this.venteData.tailleLot) {
+    this.updateVente({
-      this.venteData.prixLot = (tailleLot * this.venteData.prixOrigine).toFixed(2);
+      tailleLot,
-      $(".prixLot").val(this.venteData.prixLot);
+      quantiteNbLots: Math.min(maxLots, this.venteData.quantiteNbLots),
-    }
+      quantiteMaxLots: maxLots,
-    this.venteData.tailleLot = tailleLot;
+      prixLot: (tailleLot * this.venteData.prixOrigine).toFixed(2)
-    if (this.venteData.isOwned) {
+    });
-      // recalculer le nombre de lots max
+
-      this.venteData.quantiteMaxLots = Math.floor(this.venteData.quantiteMax / tailleLot);
+    this.html.find(".prixLot").val(this.venteData.prixLot);
-      this.venteData.quantiteNbLots = Math.min(this.venteData.quantiteMaxLots, this.venteData.quantiteNbLots);
+    this.html.find(".quantiteNbLots").val(this.venteData.quantiteNbLots);
-      $(".quantiteNbLots").val(this.venteData.quantiteNbLots);
+    this.html.find(".quantiteNbLots").attr("max", this.venteData.quantiteMaxLots)
-      $(".quantiteNbLots").attr("max", this.venteData.quantiteMaxLots)
-    }
   }
 
   setNbLots(nbLots) {
-    if (this.venteData.isOwned) {
+    this.updateVente({
-      nbLots = Math.max(0, Math.min(nbLots, this.venteData.quantiteMaxLots));
+      quantiteNbLots: this.venteData.isOwned ? Math.max(0, Math.min(nbLots, this.venteData.quantiteMaxLots)) : nbLots
-    }
+    })
-    this.venteData.quantiteNbLots = nbLots;
+    this.html.find(".quantiteNbLots").val(this.venteData.quantiteNbLots);
-    $(".quantiteNbLots").val(this.venteData.quantiteNbLots);
   }
 
   setQuantiteIllimite(checked) {
-    this.venteData.quantiteIllimite = checked;
+    this.updateVente({ quantiteIllimite: checked })
-    $(".label-quantiteIllimite").text(this.venteData.quantiteIllimite ? "Illimités" : "disponibles");
+    this.html.find(".label-quantiteIllimite").text(this.venteData.quantiteIllimite ? "Illimités" : "disponibles");
-    HtmlUtility._showControlWhen($(".quantiteNbLots"), !this.venteData.quantiteIllimite)
+    HtmlUtility.showControlWhen(this.html.find(".quantiteNbLots"), !this.venteData.quantiteIllimite)
   }
 }

module/dialog-repos.js

@@ -1,56 +0,0 @@
-import { Misc } from "./misc.js";
-
-export class DialogRepos extends Dialog {
-
-  static async create(actor) {
-    const html = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/dialog-repos.html", actor);
-    const dialog = new DialogRepos(html, actor);
-    dialog.render(true);
-  }
-
-  constructor(html, actor) {
-    let options = { classes: ["DialogCreateSigneDraconiqueActorsActors"], width: 500, height: 400, 'z-index': 99999 };
-    let conf = {
-      title: "Se reposer",
-      content: html,
-      default: "repos",
-      buttons: {
-        "repos": { label: "Se reposer", callback: async it => { this.repos(); } }
-      }
-    };
-    super(conf, options);
-    this.actor = actor;
-  }
-
-  async repos() {
-    await $("[name='nb-heures']").change();
-    await $("[name='nb-jours']").change();
-    const selection = await $("[name='repos']:checked").val();
-    const nbHeures = Number.parseInt(await $("[name='nb-heures']").val());
-    const nbJours = Number.parseInt(await $("[name='nb-jours']").val());
-    switch (selection) {
-      case "sieste": {
-        await this.actor.dormir(nbHeures);
-        return;
-      }
-      case "nuit": {
-        let heuresDormies = await this.actor.dormir(nbHeures);
-        if (heuresDormies == nbHeures){
-          await this.actor.dormirChateauDormant();
-        }
-        return;
-      }
-      case "chateau-dormant":
-        await this.actor.dormirChateauDormant();
-        return;
-      case "gris-reve": {
-        await this.actor.grisReve(nbJours);
-        return;
-      }
-    }
-  }
-  /* -------------------------------------------- */
-  activateListeners(html) {
-    super.activateListeners(html);
-  }
-}

module/dialog-select-target.js

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

module/dialog-split-item.js

@@ -12,21 +12,15 @@ export class DialogSplitItem extends Dialog {
   }
 
   constructor(item, splitData, html, callback) {
-    let options = { classes: ["dialogsplit"], width: 300, height: 160, 'z-index': 99999 };
+    let options = { classes: ["dialogsplit"], width: 300, height: 'fit-content', 'z-index': 99999 };
-
     let conf = {
       title: "Séparer en deux",
       content: html,
       default: "separer",
       buttons: {
-        "separer": {
+        "separer": { label: "Séparer", callback: it => this.onSplit() }
-          label: "Séparer", callback: it => {
-            this.onSplit();
-          }
-        }
       }
     };
-    
     super(conf, options);
 
     this.callback = callback;
@@ -34,18 +28,18 @@ export class DialogSplitItem extends Dialog {
     this.splitData = splitData;
   }
 
-  async onSplit(){
-    await $(".choix-quantite").change();
-    this.callback(this.item, this.splitData.choix.quantite);
-  }
-
-  /* -------------------------------------------- */
   activateListeners(html) {
     super.activateListeners(html);
-
+    this.html = html;
-    html.find(".choix-quantite").change(event => {
+    this.html.find(".choix-quantite").change(event => {
       this.splitData.choix.quantite = Number(event.currentTarget.value);
     });
   }
 
+  /* -------------------------------------------- */
+  async onSplit() {
+    await this.html.find(".choix-quantite").change();
+    this.callback(this.item, this.splitData.choix.quantite);
+  }
+
 }

module/dialog-validation-encaissement.js

@@ -7,7 +7,7 @@ import { RdDUtility } from "./rdd-utility.js";
  */
 export class DialogValidationEncaissement extends Dialog {
 
-  static async validerEncaissement(actor, rollData, armure, show, onEncaisser) {
+  static async validerEncaissement(actor, rollData, armure, show, attackerId, onEncaisser) {
     let encaissement = await RdDUtility.jetEncaissement(rollData, armure, { showDice: HIDE_DICE });
     const html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/dialog-validation-encaissement.html', {
       actor: actor,
@@ -15,15 +15,15 @@ export class DialogValidationEncaissement extends Dialog {
       encaissement: encaissement,
       show: show
     });
-    const dialog = new DialogValidationEncaissement(html, actor, rollData, armure, encaissement, show, onEncaisser);
+    const dialog = new DialogValidationEncaissement(html, actor, rollData, armure, encaissement, show, attackerId, onEncaisser);
     dialog.render(true);
   }
 
   /* -------------------------------------------- */
-  constructor(html, actor, rollData, armure, encaissement, show, onEncaisser) {
+  constructor(html, actor, rollData, armure, encaissement, show, attackerId, onEncaisser) {
     // Common conf
     let buttons = {
-      "valider": { label: "Valider", callback: html => this.validerEncaissement() },
+      "valider": { label: "Valider", callback: html => this.onValider() },
       "annuler": { label: "Annuler", callback: html => { } },
     };
 
@@ -35,7 +35,7 @@ export class DialogValidationEncaissement extends Dialog {
     }
 
     let dialogOptions = {
-      classes: ["rdddialog"],
+      classes: ["rdd-roll-dialog"],
       width: 350,
       height: 290
     }
@@ -48,6 +48,7 @@ export class DialogValidationEncaissement extends Dialog {
     this.armure = armure;
     this.encaissement = encaissement;
     this.show = show;
+    this.attackerId = attackerId;
     this.onEncaisser = onEncaisser;
     this.forceDiceResult = {total: encaissement.roll.result };
   }
@@ -55,16 +56,17 @@ export class DialogValidationEncaissement extends Dialog {
   /* -------------------------------------------- */
   activateListeners(html) {
     super.activateListeners(html);
-    html.find('input.encaissement-roll-result').keyup(async event => {
+    this.html = html;
+    this.html.find('input.encaissement-roll-result').keyup(async event => {
       this.forceDiceResult.total = event.currentTarget.value;
       this.encaissement = await RdDUtility.jetEncaissement(this.rollData, this.armure, { showDice: HIDE_DICE, forceDiceResult: this.forceDiceResult});
-      $('label.encaissement-total').text(this.encaissement.total);
+      this.html.find('label.encaissement-total').text(this.encaissement.total);
-      $('label.encaissement-blessure').text(this.encaissement.blessures)
+      this.html.find('label.encaissement-blessure').text(this.encaissement.blessures)
     });
   }
 
-  async validerEncaissement() {
+  async onValider() {
     this.encaissement = await RdDUtility.jetEncaissement(this.rollData, this.armure, { showDice: SHOW_DICE, forceDiceResult: this.forceDiceResult});
-    this.onEncaisser(this.encaissement, this.show)
+    this.onEncaisser(this.encaissement, this.show, this.attackerId)
   }
 }

module/environnement.js

@@ -1,210 +1,78 @@
 import { SYSTEM_RDD } from "./constants.js";
 import { Grammar } from "./grammar.js";
 import { Misc } from "./misc.js";
-import { CompendiumTableHelpers, SystemCompendiums, CompendiumTable } from "./settings/system-compendiums.js";
+import { CompendiumTableHelpers, CompendiumTable, SystemCompendiums } from "./settings/system-compendiums.js";
 
-const RARETES = [
-  { name: 'Commune', frequence: 54, min: 27, max: 108 },
-  { name: 'Frequente', frequence: 18, min: 9, max: 36 },
-  { name: 'Rare', frequence: 6, min: 3, max: 12 },
-  { name: 'Rarissime', frequence: 2, min: 1, max: 4 }]
 
-const SETTINGS_LISTE_MILIEUX = "liste-milieux";
+const COMPENDIUMS_RECHERCHE = 'compendiums-recherche';
-const MILIEUX = [
-  "Collines",
-  "Déserts",
-  "Désolations",
-  "Forêts",
-  "Forêts Tropicales",
-  "Marais",
-  "Milieux Aquatiques",
-  "Milieux Maritimes",
-  "Montagnes",
-  "Plaines",
-  "Sous-Sols",
-]
-const ITEM_ENVIRONNEMENT_TYPES = [
-  'herbe', 'ingredient'
-]
 
 export class Environnement {
-
   static init() {
-    game.settings.register(SYSTEM_RDD, SETTINGS_LISTE_MILIEUX, {
+    game.settings.register(SYSTEM_RDD, COMPENDIUMS_RECHERCHE, {
-      name: "Liste des milieux proposés",
+      name: COMPENDIUMS_RECHERCHE,
-      hint: "Liste des milieux proposés pour la faune&flore, séparés par des virgules",
+      default: [
+        SystemCompendiums.getCompendium('faune-flore-mineraux'),
+        SystemCompendiums.getCompendium('meditations-et-ecrits'),
+        SystemCompendiums.getCompendium('equipement')
+      ],
       scope: "world",
-      config: true,
+      config: false,
-      default: MILIEUX.reduce(Misc.joining(',')),
+      type: Object
-      type: String
     });
+
     game.system.rdd.environnement = new Environnement();
+    Hooks.once('ready', () => game.system.rdd.environnement.onReady());
   }
 
   constructor() {
-    this.table = new CompendiumTable('faune-flore-mineraux', 'Item', ITEM_ENVIRONNEMENT_TYPES)
+    this.compendiums = [];
+    this.compendiumTables = [];
+    this.mapMilieux = {}
   }
 
-  static getRarete(name = undefined) {
+  async onReady() {
-    return RARETES.find(it => it.name == name) ?? RARETES[0];
+    await this.$prepareCompendiums()
-  }
-
-  static getFrequenceRarete(rarete, field = undefined) {
-    const selected = this.getRarete(rarete);
-    return selected[field];
   }
 
   async milieux() {
-    const milieux = new Set(this.getMilieuxSettings());
+    return Object.values(this.mapMilieux);
-    const elements = await this.getElements(it => 1, it => ITEM_ENVIRONNEMENT_TYPES.includes(it.type));
-    elements.forEach(it => it.system.environnement.forEach(env => milieux.add(env.milieu)))
-    return [...milieux];
   }
 
-  getMilieuxSettings() {
+  async saveCompendiums(compendiumIds) {
-    return game.settings.get(SYSTEM_RDD, SETTINGS_LISTE_MILIEUX).split(',');
+    game.settings.set(SYSTEM_RDD, COMPENDIUMS_RECHERCHE, compendiumIds);
+    await this.$prepareCompendiums();
   }
 
-  async findEnvironnementsLike(search) {
+  async $prepareCompendiums() {
-    return (await this.milieux()).filter(it => Grammar.includesLowerCaseNoAccent(it, search));
+    this.compendiums = game.settings.get(SYSTEM_RDD, COMPENDIUMS_RECHERCHE).filter(c => SystemCompendiums.getPack(c));
+
+    this.compendiumTables = this.compendiums.map(it => new CompendiumTable(it, 'Item'));
+    const compendiumItems = await this.getElements(it => 1, it => it.isInventaire());
+    const fromCompendiums = Misc.concat(compendiumItems.map(it => it.getMilieux().filter(m => m)));
+    this.mapMilieux = Misc.indexLowercase(fromCompendiums);
   }
 
-  async searchToChatMessage(search) {
+  async autresMilieux(item) {
-    const table = await this.buildEnvironnementTable(search);
+    const milieuxExistants = item.getMilieux().map(it => Grammar.toLowerCaseNoAccent(it));
-    await CompendiumTableHelpers.tableToChatMessage(table, 'Item', ITEM_ENVIRONNEMENT_TYPES, `ressources en "${search}"`);
+    return Object.keys(this.mapMilieux)
-    return true
+      .filter(it => !milieuxExistants.includes(it))
+      .map(it => this.mapMilieux[it]);
   }
 
-  async getRandom(search) {
-    const table = await this.buildEnvironnementTable(search);
-    return await CompendiumTableHelpers.getRandom(table, 'Item', ITEM_ENVIRONNEMENT_TYPES, undefined, `ressources en "${search}"`);
-  }
-
-  async buildEnvironnementTable(search) {
-    const itemRareteEnMilieu = item => item.system?.environnement.find(env => Grammar.includesLowerCaseNoAccent(env.milieu, search));
-    const itemFrequenceEnMilieu = item => itemRareteEnMilieu(item)?.frequence ?? 0;
-    const isPresentEnMilieu = item => itemFrequenceEnMilieu(item) > 0;
-    return await this.table.buildTable(itemFrequenceEnMilieu, isPresentEnMilieu);
-  }
-
-
   async getElements(itemFrequence, filter) {
-    return await this.table.getContent(itemFrequence, filter);
+    const compendiumsElement = await Promise.all(
+      this.compendiumTables.map(async compTable => await compTable.getContent(itemFrequence, filter))
+    );
+    const elements = compendiumsElement.reduce((a, b) => a.concat(b));
+    elements.sort(Misc.ascending(it => it.name))
+    return elements;
+  }
+
+  async buildTable(itemFrequence, filter = it => true) {
+    if (!itemFrequence) {
+      itemFrequence = it => it.getFrequence()
+    }
+    const elements = await this.getElements(itemFrequence, filter);;
+    return CompendiumTableHelpers.buildTable(elements, itemFrequence);
   }
 }
-
-export class EnvironmentSheetHelper {
-
-  static defaultOptions(defaultOptions, type) {
-    return mergeObject(defaultOptions, {
-      classes: ["rdd", "sheet", "item"],
-      template: `systems/foundryvtt-reve-de-dragon/templates/item-${type}-sheet.html`,
-      width: 500,
-      height: 600,
-      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "informations" }]
-    });
-  }
-
-  /* -------------------------------------------- */
-  static getHeaderButtons(sheet, buttons) {
-    buttons.unshift({ class: "post", icon: "fas fa-comment", onclick: ev => sheet.item.postItem() });
-    return buttons;
-  }
-
-  static setPosition(sheet, superPosition) {
-    const position = superPosition;
-    const sheetHeader = sheet.element.find(".sheet-header");
-    const sheetBody = sheet.element.find(".sheet-body");
-    sheetBody.css("height", position.height - sheetHeader[0].clientHeight)
-    return position;
-  }
-
-  /* -------------------------------------------- */
-  static async getData(sheet) {
-    const formData = duplicate(sheet.item);
-    const milieux = await game.system.rdd.environnement.milieux();
-    const milieuxDisponibles = milieux.filter(it => !sheet.item.system.environnement.find(e => e.milieu == it));
-    mergeObject(formData, {
-      title: formData.name,
-      isGM: game.user.isGM,
-      owner: sheet.actor?.isOwner,
-      isOwned: sheet.actor ? true : false,
-      actorId: sheet.actor?.id,
-      editable: sheet.isEditable,
-      cssClass: sheet.isEditable ? "editable" : "locked",
-      milieux: milieuxDisponibles
-    });
-    return formData;
-  }
-
-  static activateListeners(sheet, html) {
-    if (!sheet.options.editable) return;
-    html.find("a.milieu-add").click(event => EnvironmentSheetHelper.onAddMilieu(sheet, event));
-    html.find("div.environnement-milieu a.milieu-delete").click(event => EnvironmentSheetHelper.onDeleteMilieu(sheet, event));
-    html.find("div.environnement-milieu select.environnement-rarete").change(event => EnvironmentSheetHelper.onChange(sheet, event,
-      (updated) => {
-        const name = $(event.currentTarget).val();
-        const rarete = Environnement.getRarete(name);
-        updated.rarete = rarete.name;
-        updated.frequence = Math.min(
-          Math.max(rarete.min, updated.frequence ?? rarete.frequence),
-          rarete.max);
-      }));
-    html.find("div.environnement-milieu input[name='environnement-frequence']").change(event => EnvironmentSheetHelper.onChange(sheet, event,
-      (updated) => {
-        updated.frequence = Number($(event.currentTarget).val())
-      }));
-  }
-
-  static async onAddMilieu(sheet, event) {
-    const milieu = $("input.input-selection-milieu").val();
-    if (!milieu) {
-      ui.notifications.warn(`Choisissez le milieu dans lequel se trouve le/la ${sheet.item.name}`);
-      return
-    }
-    const list = sheet.item.system.environnement;
-    const exists = list.find(it => it.milieu == milieu);
-    if (exists) {
-      ui.notifications.warn(`${sheet.item.name} a déjà une rareté ${exists.rarete} en ${milieu} (fréquence: ${exists.frequence})`);
-      return
-    }
-    const rarete = Environnement.getRarete();
-    const newList = [...list, { milieu, rarete: rarete.name, frequence: rarete.frequence }].sort(Misc.ascending(it => it.milieu))
-    await sheet.item.update({ 'system.environnement': newList })
-  }
-
-  static async onDeleteMilieu(sheet, event) {
-    const milieu = EnvironmentSheetHelper.$getEventMilieu(event);
-    if (milieu) {
-      const newList = sheet.item.system.environnement.filter(it => it.milieu != milieu)
-        .sort(Misc.ascending(it => it.milieu));
-      await sheet.item.update({ 'system.environnement': newList });
-    }
-  }
-
-  static async onChange(sheet, event, doMutation) {
-    const list = sheet.item.system.environnement;
-    const milieu = EnvironmentSheetHelper.$getEventMilieu(event);
-    const updated = list.find(it => it.milieu == milieu);
-    if (updated) {
-      doMutation(updated);
-      const newList = [...list.filter(it => it.milieu != milieu), updated]
-        .sort(Misc.ascending(it => it.milieu));
-      await sheet.item.update({ 'system.environnement': newList });
-    }
-  }
-
-  static $getEventMilieu(event) {
-    return $(event.currentTarget)?.parents("div.environnement-milieu").data("milieu");
-  }
-
-  static template(itemType) {
-    /* -------------------------------------------- */
-    return `systems/foundryvtt-reve-de-dragon/templates/item-${itemType}-sheet.html`;
-  }
-
-  static title(item) {
-    return Misc.typeName('Item', item.type) + ': ' + item.name;
-  }
-
-}

module/html-utility.js

@@ -1,10 +1,10 @@
 export class HtmlUtility{
-  static _showControlWhen(control, condition) {
+  static showControlWhen(jQuerySelector, condition) {
     if (condition) {
-      control.show();
+      jQuerySelector.show();
     }
     else {
-      control.hide();
+      jQuerySelector.hide();
     }
   }
 }

module/item-arme.js

@@ -1,5 +1,5 @@
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js"
-import { Misc } from "./misc.js";
+import { TYPES } from "./item.js";
 import { RdDCombatManager } from "./rdd-combat.js";
 
 const nomCategorieParade = {
@@ -20,7 +20,7 @@ const nomCategorieParade = {
 export class RdDItemArme extends Item {
 
   static isArme(item) {
-    return (item.type == 'competencecreature' && item.system.iscombat) || item.type == 'arme';
+    return RdDItemCompetenceCreature.getCategorieAttaque(item) || item.type == 'arme';
   }
 
   /* -------------------------------------------- */
@@ -28,7 +28,7 @@ export class RdDItemArme extends Item {
     switch (arme ? arme.type : '') {
       case 'arme': return arme;
       case 'competencecreature':
-        return RdDItemCompetenceCreature.armeNaturelle(arme);
+        return RdDItemCompetenceCreature.armeCreature(arme);
     }
     return RdDItemArme.mainsNues();
   }
@@ -166,7 +166,7 @@ export class RdDItemArme extends Item {
     let corpsACorps = competences.find(it => it.name == 'Corps à corps') ?? { system: { niveau: -6 } };
     let init = RdDCombatManager.calculInitiative(corpsACorps.system.niveau, carac['melee'].value);
     armes.push(RdDItemArme.mainsNues({ niveau: corpsACorps.system.niveau, initiative: init }));
-    //armes.push(RdDItemArme.empoignade({ niveau: corpsACorps.system.niveau, initiative: init }));
+    armes.push(RdDItemArme.empoignade({ niveau: corpsACorps.system.niveau, initiative: init }));
   }
 
   static corpsACorps(mainsNuesActor) {

module/item-competence.js

@@ -8,22 +8,22 @@ const xp_par_niveau = [5, 5, 5, 10, 10, 10, 10, 15, 15, 15, 15, 20, 20, 20, 20,
 const niveau_max = xp_par_niveau.length - 10;
 /* -------------------------------------------- */
 const limitesArchetypes = [
-  { "niveau": 0, "nombreMax": 100, "nombre": 0 },
+  { "niveau": 0, "nombreMax": 100, "reste": 100 },
-  { "niveau": 1, "nombreMax": 10, "nombre": 0 },
+  { "niveau": 1, "nombreMax": 10, "reste": 10 },
-  { "niveau": 2, "nombreMax": 9, "nombre": 0 },
+  { "niveau": 2, "nombreMax": 9, "reste": 9 },
-  { "niveau": 3, "nombreMax": 8, "nombre": 0 },
+  { "niveau": 3, "nombreMax": 8, "reste": 8 },
-  { "niveau": 4, "nombreMax": 7, "nombre": 0 },
+  { "niveau": 4, "nombreMax": 7, "reste": 7 },
-  { "niveau": 5, "nombreMax": 6, "nombre": 0 },
+  { "niveau": 5, "nombreMax": 6, "reste": 6 },
-  { "niveau": 6, "nombreMax": 5, "nombre": 0 },
+  { "niveau": 6, "nombreMax": 5, "reste": 5 },
-  { "niveau": 7, "nombreMax": 4, "nombre": 0 },
+  { "niveau": 7, "nombreMax": 4, "reste": 4 },
-  { "niveau": 8, "nombreMax": 3, "nombre": 0 },
+  { "niveau": 8, "nombreMax": 3, "reste": 3 },
-  { "niveau": 9, "nombreMax": 2, "nombre": 0 },
+  { "niveau": 9, "nombreMax": 2, "reste": 2 },
-  { "niveau": 10, "nombreMax": 1, "nombre": 0 },
+  { "niveau": 10, "nombreMax": 1, "reste": 1 },
-  { "niveau": 11, "nombreMax": 1, "nombre": 0 }
+  { "niveau": 11, "nombreMax": 1, "reste": 1 }
 ];
 
 /* -------------------------------------------- */
-const categorieCompetences = {
+const categoriesCompetences = {
   "generale": { base: -4, label: "Générales" },
   "particuliere": { base: -8, label: "Particulières" },
   "specialisee": { base: -11, label: "Spécialisées" },
@@ -49,16 +49,16 @@ const competence_xp_cumul = _buildCumulXP();
 
 export class RdDItemCompetence extends Item {
   /* -------------------------------------------- */
-  static getCategorieCompetences() {
+  static getCategories() {
-    return categorieCompetences;
+    return categoriesCompetences;
-  }
-  /* -------------------------------------------- */
-  static getNiveauBase(category) {
-    return categorieCompetences[category].base;
   }
   /* -------------------------------------------- */
   static getLabelCategorie(category) {
-    return categorieCompetences[category].label;
+    return categoriesCompetences[category].label;
+  }
+  /* -------------------------------------------- */
+  static getNiveauBase(category, categories = categoriesCompetences) {
+    return categories[category]?.base ?? 0;
   }
 
   /* -------------------------------------------- */
@@ -190,18 +190,9 @@ export class RdDItemCompetence extends Item {
     }
   }
 
-  /* -------------------------------------------- */
-  static isVisible(item) {
-    return Number(item.system.niveau) != RdDItemCompetence.getNiveauBase(item.system.categorie);
-  }
-
-  static nomContientTexte(item, texte) {
-    return Grammar.toLowerCaseNoAccent(item.name).includes(Grammar.toLowerCaseNoAccent(texte))
-  }
-
   /* -------------------------------------------- */
   static isNiveauBase(item) {
-    return Number(item.system.niveau) == RdDItemCompetence.getNiveauBase(item.system.categorie);
+    return Number(item.system.niveau) == RdDItemCompetence.getNiveauBase(item.system.categorie, item.getCategories());
   }
 
   /* -------------------------------------------- */
@@ -267,18 +258,47 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   static computeResumeArchetype(competences) {
-    const archetype = RdDItemCompetence.getLimitesArchetypes();
+    const computed = duplicate(limitesArchetypes);
     competences.map(it => Math.max(0, it.system.niveau_archetype))
-      .forEach(niveau => {
+      .filter(n => n > 0)
-        archetype[niveau] = archetype[niveau] ?? { "niveau": niveau, "nombreMax": 0, "nombre": 0 };
+      .forEach(n => {
-        archetype[niveau].nombre = (archetype[niveau]?.nombre ?? 0) + 1;
+        computed[n] = computed[n] ?? { niveau: n, nombreMax: 0, reste: 0 };
+        computed[n].reste = computed[n].reste - 1;
       });
-    return archetype;
+      return computed.filter(it => it.reste > 0 && it.niveau > 0);
   }
 
   /* -------------------------------------------- */
-  static getLimitesArchetypes() {
+  static triVisible(competences) {
-    return duplicate(limitesArchetypes);
+    return competences.filter(it => !it.system.isHidden)
+      .sort((a, b) => RdDItemCompetence.compare(a, b))
+  }
+
+  static $positionTri(comp) {
+    if (comp.name.startsWith("Survie")) {
+      if (comp.name.includes("Cité")) return 0;
+      if (comp.name.includes("Extérieur")) return 1;
+      return 2;
+    }
+    if (comp.system.categorie.startsWith("melee")) {
+      if (comp.name.includes("Corps")) return 0;
+      if (comp.name.includes("Dague")) return 1;
+      if (comp.name.includes("Esquive")) return 2;
+      return 3;
+    }
+    if (comp.system.categorie.startsWith("draconic")) {
+      if (comp.name.includes("Oniros")) return 0;
+      if (comp.name.includes("Hypnos")) return 1;
+      if (comp.name.includes("Narcos")) return 2;
+      if (comp.name.includes("Thanatos")) return 3;
+      return 4;
+    }
+    return 0;
+  }
+
+  static compare(a, b) {
+    const diff = RdDItemCompetence.$positionTri(a) - RdDItemCompetence.$positionTri(b);
+    return diff ? diff : a.name.localeCompare(b.name);
   }
 
 }

module/item-competencecreature.js

@@ -1,49 +1,95 @@
 
+import { RdDItem, TYPES } from "./item.js";
 import { RdDCombatManager } from "./rdd-combat.js";
 
+const categories = {
+  "generale": { base: 0, label: "Générale" },
+  "naturelle": { base: 0, label: "Arme naturelle" },
+  "melee": { base: 0, label: "Mêlée" },
+  "parade": { base: 0, label: "Parade" },
+  "tir": { base: 0, label: "Tir" },
+  "lancer": { base: 0, label: "Lancer" },
+  "possession": { base: 0, label: "Possession" },
+}
+
 /* -------------------------------------------- */
 export class RdDItemCompetenceCreature extends Item {
 
-  /* -------------------------------------------- */
+  static getCategories() {
-  static setRollDataCreature(rollData) {
+    return categories;
-    rollData.competence = rollData.competence
-    rollData.carac = { "carac_creature": { label: rollData.competence.name, value: rollData.competence.system.carac_value } }
-    rollData.competence.system.defaut_carac = "carac_creature"
-    rollData.competence.system.categorie = "creature"
-    rollData.selectedCarac =  rollData.carac.carac_creature
-    if (rollData.competence.system.iscombat) {
-      rollData.arme = RdDItemCompetenceCreature.armeNaturelle(rollData.competence);
-    }
   }
 
   /* -------------------------------------------- */
-  static armeNaturelle(competencecreature) {
+  static setRollDataCreature(rollData) {
-    if (RdDItemCompetenceCreature.isCompetenceAttaque(competencecreature)) {
+    rollData.carac = { "carac_creature": { label: rollData.competence.name, value: rollData.competence.system.carac_value } }
-      // si c'est un Item compétence: cloner pour ne pas modifier lma compétence
+    rollData.competence.system.defaut_carac = "carac_creature"
-      let arme = (competencecreature instanceof Item) ? competencecreature.clone():  competencecreature;
+    rollData.selectedCarac = rollData.carac.carac_creature
-      mergeObject(arme.system,
+    rollData.arme = RdDItemCompetenceCreature.armeCreature(rollData.competence);
+  }
+
+  /* -------------------------------------------- */
+  static armeCreature(item) {
+    const categorieAttaque = RdDItemCompetenceCreature.getCategorieAttaque(item)
+    if (categorieAttaque != undefined) {
+      // si c'est un Item compétence: cloner pour ne pas modifier la compétence
+      let arme = item.clone();
+      mergeObject(arme,
         {
+          action: item.isCompetencePossession() ? 'possession' : 'attaque',
+          system: {
             competence: arme.name,
-          initiative: RdDCombatManager.calculInitiative(competencecreature.system.niveau, competencecreature.system.carac_value),
+            cac: categorieAttaque == "naturelle" ? "naturelle" : "",
-          niveau: competencecreature.system.niveau,
+            niveau: item.system.niveau,
+            initiative: RdDCombatManager.calculInitiative(item.system.niveau, item.system.carac_value),
             equipe: true,
             resistance: 100,
             dommagesReels: arme.system.dommages,
             penetration: 0,
             force: 0,
             rapide: true,
-          cac: competencecreature.system.isnaturelle ? "naturelle" : "",
+          }
-          action: 'attaque'
         });
       return arme;
     }
-    console.error("RdDItemCompetenceCreature.toActionArme(", competencecreature, ") : impossible de transformer l'Item en arme");
     return undefined;
   }
 
   /* -------------------------------------------- */
-  static isCompetenceAttaque(item) {
+  static getCategorieAttaque(item) {
-    return item.type == 'competencecreature' && item.system.iscombat;
+    if (item.type == TYPES.competencecreature) {
+      switch (item.system.categorie) {
+        case "melee":
+        case "tir":
+        case "lancer":
+        case "naturelle":
+        case "possession":
+          return item.system.categorie
+      }
+    }
+    return undefined
+  }
+  static isDommages(item) {
+    if (item.type == TYPES.competencecreature) {
+      switch (item.system.categorie) {
+        case "melee":
+        case "tir":
+        case "lancer":
+        case "naturelle":
+          return true
+      }
+    }
+    return false
+  }
+  static isParade(item) {
+    if (item.type == TYPES.competencecreature) {
+      switch (item.system.categorie) {
+        case "melee":
+        case "naturelle":
+        case "parade":
+          return true
+      }
+    }
+    return false
   }
 
   /* -------------------------------------------- */

module/item-herbe-sheet.js

@@ -1,45 +0,0 @@
-import { SYSTEM_RDD } from "./constants.js";
-import { EnvironmentSheetHelper as EnvironmentItemSheet } from "./environnement.js";
-import { Misc } from "./misc.js";
-
-const ITEM_TYPE = 'herbe';
-
-export class RdDHerbeItemSheet extends ItemSheet {
-
-  static register() {
-    Items.registerSheet(SYSTEM_RDD, RdDHerbeItemSheet, {
-      label: Misc.typeName('Item', ITEM_TYPE),
-      types: [ITEM_TYPE],
-      makeDefault: true
-    });
-  }
-
-  static get defaultOptions() {
-    return EnvironmentItemSheet.defaultOptions(super.defaultOptions, ITEM_TYPE);
-  }
-
-  _getHeaderButtons() {
-    return EnvironmentItemSheet.getHeaderButtons(this, super._getHeaderButtons());
-  }
-
-  setPosition(options = {}) {
-    return EnvironmentItemSheet.setPosition(this, super.setPosition(options));
-  }
-
-  async getData() {
-    return await EnvironmentItemSheet.getData(this);
-  }
-
-  activateListeners(html) {
-    super.activateListeners(html);
-    EnvironmentItemSheet.activateListeners(this, html);
-  }
-
-  get template() {
-    return EnvironmentItemSheet.template(this.item.type);
-  }
-
-  get title() {
-    return EnvironmentItemSheet.title(this.item);
-  }
-}

module/item-ingredient-sheet.js

@@ -1,44 +0,0 @@
-import { SYSTEM_RDD } from "./constants.js";
-import { EnvironmentSheetHelper } from "./environnement.js";
-import { Misc } from "./misc.js";
-
-const ITEM_TYPE = 'ingredient';
-export class RdDIngredientItemSheet extends ItemSheet {
-
-  static register() {
-    Items.registerSheet(SYSTEM_RDD, RdDIngredientItemSheet, {
-      label: Misc.typeName('Item', ITEM_TYPE),
-      types: [ITEM_TYPE],
-      makeDefault: true
-    });
-  }
-
-  static get defaultOptions() {
-    return EnvironmentSheetHelper.defaultOptions(super.defaultOptions, ITEM_TYPE);
-  }
-
-  _getHeaderButtons() {
-    return EnvironmentSheetHelper.getHeaderButtons(this, super._getHeaderButtons());
-  }
-
-  setPosition(options = {}) {
-    return EnvironmentSheetHelper.setPosition(this, super.setPosition(options));
-  }
-
-  async getData() {
-    return await EnvironmentSheetHelper.getData(this);
-  }
-
-  activateListeners(html) {
-    super.activateListeners(html);
-    EnvironmentSheetHelper.activateListeners(this, html);
-  }
-
-  get template() {
-    return EnvironmentSheetHelper.template(this.item.type);
-  }
-
-  get title() {
-    return EnvironmentSheetHelper.title(this.item);
-  }
-}

module/item-monnaie.js

@@ -2,27 +2,28 @@ import { Misc } from "./misc.js";
 import { LOG_HEAD } from "./constants.js";
 
 const MONNAIE_ETAIN = {
-  name: "Etain (1 denier)", type: 'monnaie',
+  name: "Denier (étain)", type: 'monnaie',
   img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_etain_poisson.webp",
   system: { quantite: 0, cout: 0.01, encombrement: 0.001, description: "" }
 };
 const MONNAIE_BRONZE = {
-  name: "Bronze (10 deniers)", type: 'monnaie',
+  name: "Sou (bronze)", type: 'monnaie',
   img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_bronze_epees.webp",
   system: { quantite: 0, cout: 0.10, encombrement: 0.002, description: "" }
 };
 const MONNAIE_ARGENT = {
-  name: "Argent (1 sol)", type: 'monnaie',
+  name: "Sol (argent)", type: 'monnaie',
   img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_argent_sol.webp",
   system: { quantite: 0, cout: 1, encombrement: 0.003, description: "" }
 };
 const MONNAIE_OR = {
-  name: "Or (10 sols)", type: 'monnaie',
+  name: "Dragon (or)", type: 'monnaie',
   img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_or_sol.webp",
   system: { quantite: 0, cout: 10, encombrement: 0.004, description: "" }
 };
 
 const MONNAIES_STANDARD = [MONNAIE_ETAIN, MONNAIE_BRONZE, MONNAIE_ARGENT, MONNAIE_OR];
+const VALEUR_DENIERS = sols => Math.max(Math.floor((sols ?? 0) * 100), 0);
 
 export class Monnaie {
 
@@ -40,15 +41,11 @@ export class Monnaie {
   }
 
   static deValeur(monnaie, valeur) {
-    return Monnaie.valEntiere(valeur) == Monnaie.valEntiere(monnaie.system.cout)
+    return VALEUR_DENIERS(valeur) == VALEUR_DENIERS(monnaie.system.cout)
-  }
-
-  static valEntiere(sols) {
-    return Math.max(Math.floor((sols??0)*100), 0);
   }
 
   static triValeurEntiere() {
-    return Misc.ascending(item => Monnaie.valEntiere(item.system.cout))
+    return Misc.ascending(item => VALEUR_DENIERS(item.system.cout))
   }
 
   static async creerMonnaiesStandard(actor) {
@@ -65,11 +62,26 @@ export class Monnaie {
     return deniers;
   }
 
+  static toSolsDeniers(fortune) {
+    return {
+      sols: Math.floor(fortune),
+      deniers: Math.round(100 * (fortune - Math.floor(fortune)))
+    };
+  }
+
+  static getFortune(monnaies) {
+    return (monnaies??[])
+      .map(m => Number(m.system.cout) * Number(m.system.quantite))
+      .reduce(Misc.sum(), 0);
+  }
+
   static async optimiserFortune(actor, fortune) {
-    let resteEnDeniers = Math.round(fortune*100);
+    let resteEnDeniers = Math.round(fortune * 100);
     let monnaies = actor.itemTypes['monnaie'];
     let updates = [];
-    let parValeur = Misc.classifyFirst(monnaies, it => Monnaie.valEntiere(it.system.cout));
+    Monnaie.validerMonnaies(monnaies, actor);
+
+    let parValeur = Misc.classifyFirst(monnaies, it => VALEUR_DENIERS(it.system.cout));
     for (let valeurDeniers of [1000, 100, 10, 1]) {
       const itemPiece = parValeur[valeurDeniers];
       if (itemPiece) {
@@ -77,17 +89,25 @@ export class Monnaie {
         if (quantite != itemPiece.system.quantite) {
           updates.push({ _id: parValeur[valeurDeniers].id, 'system.quantite': quantite });
         }
-        resteEnDeniers -= quantite*valeurDeniers;
+        resteEnDeniers -= quantite * valeurDeniers;
       }
     }
     console.log('Monnaie.optimiserFortune', actor.name, 'total', fortune, 'parValeur', parValeur, 'updates', updates, 'reste', resteEnDeniers);
     if (updates.length > 0) {
       await actor.updateEmbeddedDocuments('Item', updates);
     }
-    if (resteEnDeniers > 0){
+    if (resteEnDeniers > 0) {
       // créer le reste en deniers fortune en deniers
       await Monnaie.creerMonnaiesDeniers(actor, resteEnDeniers);
     }
   }
 
+  static validerMonnaies(monnaies, actor = undefined) {
+    monnaies.filter(it => VALEUR_DENIERS(it.system.cout) == 0)
+      .map(it => `La  monnaie ${it.name} de l'acteur ${actor?.name ?? 'sélectionné'} a une valeur de 0!`)
+      .forEach(message => {
+        ui.notifications.warn(message);
+        console.warn(message);
+      });
+  }
 }

module/item-sheet.js

@@ -9,40 +9,67 @@ import { ReglesOptionelles } from "./settings/regles-optionelles.js";
 import { SYSTEM_RDD } from "./constants.js";
 import { RdDSheetUtility } from "./rdd-sheet-utility.js";
 import { SystemCompendiums } from "./settings/system-compendiums.js";
+import { Misc } from "./misc.js";
+import { RdDTimestamp } from "./time/rdd-timestamp.js";
+import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
+import { TYPES } from "./item.js";
 
 /**
- * Extend the basic ItemSheet with some very simple modifications
+ * Extend the basic ItemSheet for RdD specific items
- * @extends {ItemSheet}
  */
 export class RdDItemSheet extends ItemSheet {
 
+  static get ITEM_TYPE() {
+    return undefined
+  }
+
+  static defaultTemplate(type) {
+    return type ?
+      `systems/foundryvtt-reve-de-dragon/templates/item-${type}-sheet.html` :
+      "systems/foundryvtt-reve-de-dragon/templates/item-sheet.html";
+  }
+
+  static register(sheetClass) {
+    Items.registerSheet(SYSTEM_RDD, sheetClass, {
+      label: Misc.typeName('Item', sheetClass.ITEM_TYPE),
+      types: [sheetClass.ITEM_TYPE],
+      makeDefault: true
+    })
+  }
+
   /** @override */
   static get defaultOptions() {
     return mergeObject(super.defaultOptions, {
       classes: [SYSTEM_RDD, "sheet", "item"],
-      template: "systems/foundryvtt-reve-de-dragon/templates/item-sheet.html",
+      template: RdDItemSheet.defaultTemplate(RdDItemSheet.ITEM_TYPE),
       width: 550,
       height: 550
     });
   }
 
+  /* -------------------------------------------- */
+  get template() {
+    return RdDItemSheet.defaultTemplate(this.item.type);
+  }
+
+  get title() {
+    return `${Misc.typeName('Item', this.item.type)}: ${this.item.name}`;
+  }
 
   /* -------------------------------------------- */
   _getHeaderButtons() {
     let buttons = super._getHeaderButtons();
-    // Add "Post to chat" button
+    if (this.item.isInventaire() && this.item.isVideOuNonConteneur()) {
-    // We previously restricted this to GM and editable items only. If you ever find this comment because it broke something: eh, sorry!
-    if ("cout" in this.item.system && this.item.isVideOuNonConteneur()) {
       buttons.unshift({
         class: "vendre",
         icon: "fas fa-comments-dollar",
-        onclick: ev => this.item.proposerVente()
+        onclick: ev => this.item.proposerVente(1)
       });
     }
     buttons.unshift({
       class: "montrer",
       icon: "fas fa-comment",
-      onclick: ev => this.item.postItem()
+      onclick: ev => this.item.postItemToChat()
     });
     return buttons
   }
@@ -61,252 +88,225 @@ export class RdDItemSheet extends ItemSheet {
   /* -------------------------------------------- */
   async getData() {
     let formData = {
-      id: this.item.id,
       title: this.item.name,
+      id: this.item.id,
       type: this.item.type,
       img: this.item.img,
       name: this.item.name,
       system: this.item.system,
-      isGM: game.user.isGM,
       actorId: this.actor?.id,
-      owner: this.item.isOwner,
+      description: await TextEditor.enrichHTML(this.item.system.description, { async: true }),
-      editable: this.isEditable,
+      descriptionmj: await TextEditor.enrichHTML(this.item.system.descriptionmj, { async: true }),
-      cssClass: this.isEditable ? "editable" : "locked",
+      isComestible: this.item.getUtilisationCuisine(),
-      isSoins: false,
+      options: RdDSheetUtility.mergeDocumentRights(this.options, this.item, this.isEditable)
-      description:  await TextEditor.enrichHTML(this.object.system.description, {async: true}),
-      descriptionmj:  await TextEditor.enrichHTML(this.object.system.descriptionmj, {async: true})
-
-    }
-    if (this.actor) {
-      formData.isOwned = true;
-      if (this.item.type == 'conteneur') {
-        this.prepareConteneurData(formData);
     }
+    if (this.item.type == TYPES.competencecreature) {
+      formData.isparade = RdDItemCompetenceCreature.isParade(this.item)
+      formData.isdommages = RdDItemCompetenceCreature.isDommages(this.item)
     }
 
-    const competences = await SystemCompendiums.getCompetences(this.actor?.type);
+    const competences = await SystemCompendiums.getCompetences('personnage');
-    formData.categorieCompetences = RdDItemCompetence.getCategorieCompetences()
+    formData.categories = this.item.getCategories()
     if (this.item.type == 'tache' || this.item.type == 'livre' || this.item.type == 'meditation' || this.item.type == 'oeuvre') {
       formData.caracList = duplicate(game.system.model.Actor.personnage.carac)
       formData.caracList["reve-actuel"] = duplicate(game.system.model.Actor.personnage.reve.reve)
       formData.competences = competences;
     }
     if (this.item.type == 'arme') {
-      formData.competences = competences.filter(it => RdDItemCompetence.isCompetenceArme(it));
+      formData.competences = competences.filter(it => RdDItemCompetence.isCompetenceArme(it))
     }
     if (['sort', 'sortreserve'].includes(this.item.type)) {
       formData.competences = competences.filter(it => RdDItemCompetence.isDraconic(it));
     }
     if (this.item.type == 'recettecuisine') {
-      formData.ingredients = await TextEditor.enrichHTML(this.object.system.ingredients, {async: true})
+      formData.ingredients = await TextEditor.enrichHTML(this.object.system.ingredients, { async: true })
     }
     if (this.item.type == 'extraitpoetique') {
-      formData.extrait = await TextEditor.enrichHTML(this.object.system.extrait, {async: true})
+      formData.extrait = await TextEditor.enrichHTML(this.object.system.extrait, { async: true })
-      formData.texte = await TextEditor.enrichHTML(this.object.system.texte, {async: true})
+      formData.texte = await TextEditor.enrichHTML(this.object.system.texte, { async: true })
     }
     if (this.item.type == 'recettealchimique') {
       RdDAlchimie.processManipulation(this.item, this.actor && this.actor.id);
-      formData.manipulation_update = await TextEditor.enrichHTML(this.object.system.manipulation_update, {async: true})
+      formData.manipulation_update = await TextEditor.enrichHTML(this.object.system.manipulation_update, { async: true })
-      formData.utilisation = await TextEditor.enrichHTML(this.object.system.utilisation, {async: true})
+      formData.utilisation = await TextEditor.enrichHTML(this.object.system.utilisation, { async: true })
-      formData.enchantement = await TextEditor.enrichHTML(this.object.system.enchantement, {async: true})
+      formData.enchantement = await TextEditor.enrichHTML(this.object.system.enchantement, { async: true })
-      formData.sureffet = await TextEditor.enrichHTML(this.object.system.sureffet, {async: true})
+      formData.sureffet = await TextEditor.enrichHTML(this.object.system.sureffet, { async: true })
     }
     if (this.item.type == 'gemme') {
       formData.gemmeTypeList = RdDGemme.getGemmeTypeOptionList();
       RdDGemme.calculDataDerivees(this.item);
     }
     if (this.item.type == 'potion') {
-      if (this.dateUpdated) {
+      await RdDHerbes.addPotionFormData(formData);
-        formData.system.prdate = this.dateUpdated;
-        this.dateUpdated = undefined;
     }
-      await RdDHerbes.updatePotionData(formData);
+    if (formData.options.isOwned && this.item.type == 'herbe' && (formData.system.categorie == 'Soin' || formData.system.categorie == 'Repos')) {
-    }
-    if (formData.isOwned && this.item.type == 'herbe' && (formData.system.categorie == 'Soin' || formData.system.categorie == 'Repos')) {
       formData.isIngredientPotionBase = true;
     }
     if (this.item.type == 'sortreserve') {
       const sortId = this.item.system.sortid;
-      formData.sort = formData.isOwned ? this.item.actor.items.get(sortId) : game.items.get(sortId);
+      formData.sort = formData.options.isOwned ? this.item.actor.items.get(sortId) : game.items.get(sortId);
     }
     formData.bonusCaseList = RdDItemSort.getBonusCaseList(formData, true);
 
     return formData;
   }
 
-  /* -------------------------------------------- */
-  prepareConteneurData(formData) {
-    RdDUtility.filterEquipementParType(formData, this.actor.itemTypes);
-
-    this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.objets);
-    formData.subItems = formData.conteneurs.find(it => it._id == this.item.id)?.subItems;
-
-  }
-
   /* -------------------------------------------- */
   /** @override */
   activateListeners(html) {
     super.activateListeners(html);
+    this.html = html;
 
-    if (this.item.type == 'conteneur') {
+    HtmlUtility.showControlWhen(this.html.find(".item-cout"), ReglesOptionelles.isUsing('afficher-prix-joueurs')
-      this.form.ondragstart = (event) => this._onDragStart(event);
+      || game.user.isGM
-      this.form.ondrop = (event) => this._onDrop(event);
+      || !this.item.isOwned);
-    }
+    HtmlUtility.showControlWhen(this.html.find(".item-magique"), this.item.isMagique());
-
-    let itemSheetDialog = this;
-
-    HtmlUtility._showControlWhen($(".item-cout"), ReglesOptionelles.isUsing('afficher-prix-joueurs') || game.user.isGM || !this.item.isOwned);
-    HtmlUtility._showControlWhen($(".item-magique"), this.item.isMagique());
 
     // Everything below here is only needed if the sheet is editable
     if (!this.options.editable) return;
 
-    // Select competence categorie
+    this.form.ondragstart = (event) => this._onDragStart(event);
-    html.find(".categorie").change(event => this._onSelectCategorie(event));
+    this.form.ondrop = (event) => this._onDrop(event);
 
-    html.find('.sheet-competence-xp').change((event) => {
+    // Select competence categorie
+    this.html.find(".categorie").change(event => this._onSelectCategorie(event));
+
+    this.html.find('.sheet-competence-xp').change((event) => {
       if (this.item.isCompetencePersonnage()) {
         RdDUtility.checkThanatosXP(this.item.name);
       }
     });
+    this.html.find(".item-cout input[name='system.cout']").change(event => {
+      if (this.item.isMonnaie()) {
+        const value = event.currentTarget.value;
+        if (Number(value) == 0) {
+          ui.notifications.error(`${this.actor?.name ?? 'Monnaie'}: La monnaie ${this.item.name} a maintenant une valeur de 0, et ne peut plus être utilisée pour payer!`)
+        }
+      }
+    })
 
-    html.find('.enchanteDate').change((event) => {
+    this.html.find('.date-enchantement').change((event) => {
-      let jour = Number($('#jourMois').val());
+      const jour = Number(this.html.find('input.date-enchantement[name="enchantement.jour"]').val());
-      let mois = $('#nomMois').val();
+      const mois = RdDTimestamp.definition(this.html.find('select.date-enchantement[name="enchantement.mois"]').val());
-      this.dateUpdated = game.system.rdd.calendrier.getIndexFromDate(jour, mois);
+      const indexDate = game.system.rdd.calendrier.getIndexFromDate(jour, mois.heure);
+      this.item.update({ 'system.prdate': indexDate });
+      console.warn(`Date d'enchantement modifiée ${jour}/${mois.heure}: ${indexDate}`)
     });
 
-    html.find('.creer-tache-livre').click((event) => {
+    this.html.find('.creer-tache-livre').click((event) => this._getEventActor(event).creerTacheDepuisLivre(this.item));
-      let actorId = event.currentTarget.attributes['data-actor-id'].value;
+    this.html.find('.consommer-potion').click((event) => this._getEventActor(event).consommerPotion(this.item, this.getActionRenderItem()));
-      let actor = game.actors.get(actorId);
+    this.html.find('.creer-potion-base').click((event) => this._getEventActor(event).dialogFabriquerPotion(this.item));
-      actor.creerTacheDepuisLivre(this.item);
-    });
-    html.find('.consommer-potion').click((event) => {
-      let actorId = event.currentTarget.attributes['data-actor-id'].value;
-      let actor = game.actors.get(actorId);
-      actor.consommerPotion(this.item);
-    });
-    html.find('.creer-potion-base').click((event) => {
-      let actorId = event.currentTarget.attributes['data-actor-id'].value;
-      let actor = game.actors.get(actorId);
-      actor.dialogFabriquerPotion(this.item);
-    });
 
-    html.find('.alchimie-tache a').click((event) => {
+    this.html.find('.alchimie-tache a').click((event) => {
-      let actorId = event.currentTarget.attributes['data-actor-id'].value;
+      let actor = this._getEventActor(event);
+      if (actor) {
         let recetteId = event.currentTarget.attributes['data-recette-id'].value;
         let tacheName = event.currentTarget.attributes['data-alchimie-tache'].value;
         let tacheData = event.currentTarget.attributes['data-alchimie-data'].value;
-      let actor = game.actors.get(actorId);
-      if (actor) {
         actor.effectuerTacheAlchimie(recetteId, tacheName, tacheData);
       } else {
         ui.notifications.info("Impossible trouver un acteur pour réaliser cette tache Alchimique.");
       }
     });
 
-    html.find('.item-split').click(async event => {
+    if (this.actor) {
-      const item = RdDSheetUtility.getItem(event, this.actor);
+      this.html.find('.item-split').click(async event => RdDSheetUtility.splitItem(RdDSheetUtility.getItem(event, this.actor), this.actor, this.getActionRenderItem()));
-      await RdDSheetUtility.splitItem(item, this.actor, async () => itemSheetDialog.render(true));
+      this.html.find('.item-edit').click(async event => RdDSheetUtility.getItem(event, this.actor)?.sheet.render(true));
+      this.html.find('.item-delete').click(async event => RdDUtility.confirmActorItemDelete(this, RdDSheetUtility.getItem(event, this.actor)));
+      this.html.find('.item-vendre').click(async event => RdDSheetUtility.getItem(event, this.actor)?.proposerVente());
+      this.html.find('.item-montrer').click(async event => RdDSheetUtility.getItem(event, this.actor)?.postItemToChat());
+      this.html.find('.item-action').click(async event => RdDSheetUtility.getItem(event, this.actor)?.actionPrincipale(this.actor, this.getActionRenderItem()));
+
+      this.html.find('.item-quantite-plus').click(async event => {
+        await this.actor.itemQuantiteIncDec(RdDSheetUtility.getItemId(event), 1)
+        this.render();
       });
-    html.find('.item-edit').click(async event => {
+      this.html.find('.item-quantite-moins').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
+        await this.actor.itemQuantiteIncDec(RdDSheetUtility.getItemId(event), -1)
-      item.sheet.render(true);
+        this.render();
-    });
-    html.find('.item-delete').click(async event => {
-      const li = RdDSheetUtility.getEventElement(event);
-      const item = this.actor.getObjet(li.data("item-id"));
-      RdDUtility.confirmerSuppressionItem(this, item, li);
-    });
-    html.find('.item-vendre').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
-      item?.proposerVente();
-    });
-    html.find('.item-montrer').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
-      item?.postItem();
-    });
-    html.find('.item-action').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
-      this.actor.actionItem(item, async () => itemSheetDialog.render(true));
-    });
-    html.find('.conteneur-name a').click(async event => {
-      RdDUtility.toggleAfficheContenu(RdDSheetUtility.getItemId(event));
-      this.render(true);
       });
     }
 
+    const updateItemTimestamp = (path, timestamp) => this.item.update({ [path]: duplicate(timestamp) })
+
+    RdDTimestamp.handleTimestampEditor(this.html, 'system.temporel.debut', updateItemTimestamp);
+    RdDTimestamp.handleTimestampEditor(this.html, 'system.temporel.fin', updateItemTimestamp);
+  }
+
+  getActionRenderItem() {
+    return async () => {
+      let item = this.item;
+      while (item) {
+        await item.sheet?.render()
+        item = this.actor.getContenant(item)
+      }
+    }
+  }
+
+  _getEventActor(event) {
+    let actorId = event.currentTarget.attributes['data-actor-id'].value;
+    let actor = game.actors.get(actorId);
+    return actor;
+  }
+
+
   /* -------------------------------------------- */
   async _onSelectCategorie(event) {
     event.preventDefault();
 
     if (this.item.isCompetence()) {
-      let level = RdDItemCompetence.getNiveauBase(event.currentTarget.value);
+      const categorie = event.currentTarget.value;
+      const level =  RdDItemCompetence.getNiveauBase(categorie, this.item.getCategories());
       this.item.system.base = level;
-      $("#base").val(level);
+      this.html.find('[name="system.base"]').val(level);
     }
   }
 
   /* -------------------------------------------- */
-  get template() {
-    let type = this.item.type
-    return `systems/foundryvtt-reve-de-dragon/templates/item-${type}-sheet.html`;
-  }
-
-  /* -------------------------------------------- */
-
   /** @override */
   _updateObject(event, formData) {
+    if (this.item.type == 'sort') {
       // Données de bonus de cases ?
-    formData['system.bonuscase'] = RdDItemSort.buildBonusCaseStringFromFormData(formData.bonusValue, formData.caseValue);
+      formData['system.bonuscase'] = RdDItemSort.buildBonuscaseFromArrays(formData.bonusValue, formData.caseValue);
-
+    }
     return this.item.update(formData);
   }
 
+  /* -------------------------------------------- */
   async _onDragStart(event) {
-    console.log("_onDragStart", event);
-    if (event.target.classList.contains("entity-link")) return;
-
-    const itemId = event.srcElement?.attributes["data-item-id"].value;
-    const item = this.actor.items.get(itemId);
-    // Create drag data
-    const dragData = {
-      actorId: this.actor.id,
-      type: "Item",
-      data: item.system
-    };
-
-    event.dataTransfer.setData("text/plain", JSON.stringify(dragData));
   }
 
   async _onDrop(event) {
     // Try to extract the dragData
-    let dragData;
+    let dragData = RdDItemSheet.$extractDragData(event);
-    try {
+    if (!dragData) return false;
-      dragData = JSON.parse(event.dataTransfer.getData('text/plain'));
-    } catch (err) {
-      return false;
-    }
-
     const allowed = Hooks.call("dropActorSheetData", this.actor, this, dragData);
-    if (allowed === false) return;
+    if (allowed === false) return false;
 
     // Handle different dragData types
     switch (dragData.type) {
       case "Item":
         return this._onDropItem(event, dragData);
+      case "Actor":
+        return this._onDropActor(event, dragData);
     }
     return super._onDrop(event);
   }
 
-  /* -------------------------------------------- */
+  static $extractDragData(event) {
-  async _onDropItem(event, dragData) {
+    try {
-    if (this.actor) {
+      const eventData = event?.dataTransfer?.getData('text/plain');
-      const dropParams = RdDSheetUtility.prepareItemDropParameters(this.item.id, this.actor.id, dragData, this.objetVersConteneur);
+      if (eventData) {
-      await this.actor.processDropItem(dropParams);
+        return JSON.parse(eventData);
-      await this.render(true);
       }
+    } catch (err) { }
+    return undefined;
   }
 
+  async _onDropItem(event, dragData) {
+  }
+
+  async _onDropActor(event, dragData) {
+  }
 
 }

module/item-sort.js

@@ -1,4 +1,3 @@
-/* -------------------------------------------- */
 import { Misc } from "./misc.js";
 import { TMRUtility } from "./tmr-utility.js";
 
@@ -16,7 +15,7 @@ export class RdDItemSort extends Item {
   }
 
   /* -------------------------------------------- */
-  static setCoutReveReel(sort){
+  static setCoutReveReel(sort) {
     if (sort) {
       sort.system.ptreve_reel = this.isCoutVariable(sort) ? 1 : sort.system.ptreve;
     }
@@ -31,30 +30,22 @@ export class RdDItemSort extends Item {
   }
 
   /* -------------------------------------------- */
-  static buildBonusCaseList( caseBonusString, newCase ) {
+  static buildBonusCaseList(bonuscase, newCase) {
-      if (caseBonusString == undefined) {
+    const list = RdDItemSort._bonuscaseStringToList(bonuscase)
-        return [];
+    if (newCase) {
+      return list.concat({ case: "Nouvelle", bonus: 0 });
     }
-      let bonusCaseList = [];
+    return list;
-      let bonusCaseArray = caseBonusString == undefined ? [] : caseBonusString.split(',');
-      for( let bonusCase of bonusCaseArray) {
-        let bonusSplit = bonusCase.split(':');
-        bonusCaseList.push( { case: bonusSplit[0], bonus: bonusSplit[1] } );
-      }
-      if ( newCase )
-        bonusCaseList.push( {case: "Nouvelle", bonus: 0} );
-      return bonusCaseList;
   }
 
-  /* -------------------------------------------- */
   /**
    * Retourne une liste de bonus/case pour un item-sheet
   * @param {} item 
   */
-  static getBonusCaseList( item, newCase = false ) {
+  static getBonusCaseList(item, newCase = false) {
     // Gestion spéciale case bonus
-    if ( item.type == 'sort') {
+    if (item.type == 'sort') {
-      return this.buildBonusCaseList(item.system.bonuscase, newCase );
+      return RdDItemSort.buildBonusCaseList(item.system.bonuscase, newCase);
     }
     return undefined;
   }
@@ -63,56 +54,61 @@ export class RdDItemSort extends Item {
   /** Met à jour les données de formulaire 
    * si static des bonus de cases sont présents 
    * */
-  static buildBonusCaseStringFromFormData( bonuses, cases ) {
+  static buildBonuscaseFromArrays(bonuses, coords) {
-    if ( bonuses ) {
+    if (bonuses) {
-      let list = [];
+      const list = [];
-      let caseCheck = {};
+      const caseCheck = {};
-      for (let i=0; i<bonuses.length; i++) {
+      for (let i = 0; i < bonuses.length && i < coords.length; i++) {
-        let coord = cases[i]?.toUpperCase() || 'A1';
+        const coord = coords[i] == 'Fleuve' ? 'Fleuve' : (coords[i]?.toUpperCase() ?? 'A1');
-        let bonus = bonuses[i] || 0;
+        const bonus = bonuses[i] || 0;
-        if ( TMRUtility.verifyTMRCoord( coord ) && bonus > 0 && caseCheck[coord] == undefined ) {
+        if (TMRUtility.verifyTMRCoord(coord) && bonus > 0 && caseCheck[coord] == undefined) {
           caseCheck[coord] = bonus;
-          list.push( coord+":"+bonus );
+          list.push({ case: coord, bonus: bonus });
         }
       }
-      return list.toString();
+      return RdDItemSort._bonuscaseListToString(list);
     }
     return undefined;
   }
 
   /* -------------------------------------------- */
-  static incrementBonusCase( actor, sort, coord ) {
+  static incrementBonusCase(actor, sort, coord) {
-      let bonusCaseList = this.buildBonusCaseList(sort.system.bonuscase, false);
+    if (TMRUtility.getTMR(coord).type == "fleuve") {
-      //console.log("ITEMSORT", sort, bonusCaseList);
+      coord = 'Fleuve';
+    }
+    const list = RdDItemSort.buildBonusCaseList(sort.system.bonuscase, false);
+    const bonus = Number(list.find(it => it.case == coord)?.bonus ?? 0);
+    const modified = { case: coord, bonus: bonus + 1 };
 
-      let found = false;
+    const bonuscase = RdDItemSort._bonuscaseListToString(
-      let StringList = []; 
+      list.filter(it => it.case != coord).concat(modified)
-      for( let bc of bonusCaseList) {
+    );
-        if (bc.case == coord) { // Case existante
-          found = true;
-          bc.bonus = Number(bc.bonus) + 1;
-        }
-        StringList.push( bc.case+':'+bc.bonus );
-      }
-      if ( !found) { //Nouvelle case, bonus de 1
-        StringList.push(coord+':1');
-      }
 
     // Sauvegarde/update
-      let bonuscase = StringList.toString();
+    actor.updateEmbeddedDocuments('Item', [{ _id: sort._id, 'system.bonuscase': bonuscase }]);
-      //console.log("Bonus cae :", bonuscase);
-      actor.updateEmbeddedDocuments('Item', [{ _id: sort._id, 'system.bonuscase': bonuscase }] );
   }
 
+
   /* -------------------------------------------- */
-  static getCaseBonus( sort, coord) {
+  static getCaseBonus(sort, coord) {
-    let bonusCaseList = this.buildBonusCaseList(sort.system.bonuscase, false);
+    const isFleuve = TMRUtility.getTMR(coord).type == "fleuve";
-    for( let bc of bonusCaseList) {
+
-      if (bc.case == coord) { // Case existante
+    let bc = RdDItemSort.buildBonusCaseList(sort.system.bonuscase, false)
-        return Number(bc.bonus);
+      .filter(it => it.case == coord || (isFleuve && it.case == 'Fleuve'))
+      .find(it => true)
+    return Number(bc?.bonus ?? 0);
   }
+
+  static _bonuscaseListToString(list) {
+    return list.map(it => `${it.case}:${it.bonus}`)
+      .sort(Misc.ascending())
+      .join(',');
   }
-    return 0;
+  static _bonuscaseStringToList(bonuscase) {
+    return (bonuscase ?? '').split(',').map(it => {
+      const b = it.split(':');
+      return { case: b[0], bonus: b[1] };
+    });
   }
 
 }

module/item-tache.js

@@ -1,4 +0,0 @@
-export class RdDItemTache extends Item {
-  
-
-}

module/item.js

@@ -1,28 +1,89 @@
 import { DialogItemVente } from "./dialog-item-vente.js";
 import { Grammar } from "./grammar.js";
-import { Monnaie } from "./item-monnaie.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";
+import { RdDRaretes } from "./item/raretes.js";
+import { RdDItemCompetence } from "./item-competence.js";
+import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
 
-const typesObjetsEquipement = [
+export const TYPES = {
-  "arme",
+  competence: 'competence',
-  "armure",
+  competencecreature: 'competencecreature',
-  "conteneur",
+  empoignade: 'empoignade',
-  "gemme",
+  possession: 'possession',
-  "herbe",
+  blessure: 'blessure',
-  "ingredient",
+  maladie: 'maladie',
-  "livre",
+  poison: 'poison',
-  "monnaie",
+  arme: 'arme',
-  "munition",
+  armure: 'armure',
-  "nourritureboisson",
+  conteneur: 'conteneur',
-  "objet",
+  objet: 'objet',
-  "potion",
+  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',
+  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 = [
+  TYPES.arme,
+  TYPES.armure,
+  TYPES.conteneur,
+  TYPES.faune,
+  TYPES.gemme,
+  TYPES.herbe,
+  TYPES.plante,
+  TYPES.ingredient,
+  TYPES.livre,
+  TYPES.monnaie,
+  TYPES.munition,
+  TYPES.nourritureboisson,
+  TYPES.objet,
+  TYPES.potion,
 ]
-const typesObjetsOeuvres = ["oeuvre", "recettecuisine", "musique", "chant", "danse", "jeu"]
+const typesInventaire = {
-const typesObjetsDraconiques = ["queue", "ombre", "souffle", "tete", "signedraconique", "sortreserve", "rencontre"]
+  materiel: typesInventaireMateriel,
-const typesObjetsConnaissance = ["meditation", "recettealchimique", "sort"]
+  all: ['service'].concat(typesInventaireMateriel),
-const typesObjetsEffet = ["possession", "poison", "maladie"]
+}
-const typesObjetsCompetence = ["competence", "competencecreature"]
+
+const typesObjetsOeuvres = [TYPES.oeuvre, TYPES.recettecuisine, TYPES.musique, TYPES.chant, TYPES.danse, TYPES.jeu]
+const typesObjetsDraconiques = [TYPES.queue, TYPES.ombre, TYPES.souffle, TYPES.tete, TYPES.signedraconique, TYPES.sortreserve, TYPES.rencontre]
+const typesObjetsConnaissance = [TYPES.meditation, TYPES.recettealchimique, TYPES.sort]
+const typesObjetsEffet = [TYPES.possession, TYPES.poison, TYPES.maladie, TYPES.blessure]
+const typesObjetsCompetence = [TYPES.competence, TYPES.competencecreature]
+const typesObjetsTemporels = [TYPES.blessure, TYPES.poison, TYPES.maladie, TYPES.queue, TYPES.ombre, TYPES.souffle, TYPES.signedraconique, TYPES.rencontre]
+const typesObjetsEquipable = [TYPES.arme, TYPES.armure, TYPES.objet];
+const typesEnvironnement = typesInventaireMateriel;
 const encBrin = 0.00005; // un brin = 1 décigramme = 1/10g = 1/10000kg = 1/20000 enc
 const encPepin = 0.0007; /* un pépin de gemme = 1/10 cm3 = 1/1000 l = 3.5/1000 kg = 7/2000 kg = 7/1000 enc
 densité 3.5 (~2.3 à 4, parfois plus) -- https://www.juwelo.fr/guide-des-pierres/faits-et-chiffres/ 
@@ -36,6 +97,7 @@ export const defaultItemImg = {
   conteneur: "systems/foundryvtt-reve-de-dragon/icons/objets/sac_a_dos.webp",
   sort: "systems/foundryvtt-reve-de-dragon/icons/competence_oniros.webp",
   herbe: "systems/foundryvtt-reve-de-dragon/icons/botanique/Endorlotte.webp",
+  faune: "systems/foundryvtt-reve-de-dragon/icons/faune/rongeur.webp",
   ingredient: "systems/foundryvtt-reve-de-dragon/icons/objets/sable_poudre.webp",
   livre: "systems/foundryvtt-reve-de-dragon/icons/objets/livre.webp",
   potion: "systems/foundryvtt-reve-de-dragon/icons/objets/liqueur_de_bagdol.webp",
@@ -55,30 +117,36 @@ export const defaultItemImg = {
   poison: "systems/foundryvtt-reve-de-dragon/icons/maladies_venins/venin.webp",
   oeuvre: "systems/foundryvtt-reve-de-dragon/icons/competence_comedie.webp",
   nourritureboisson: "systems/foundryvtt-reve-de-dragon/icons/objets/provision_crue.webp",
+  service: "systems/foundryvtt-reve-de-dragon/icons/services/lit.webp",
   signedraconique: "systems/foundryvtt-reve-de-dragon/icons/tmr/signe_draconique.webp",
   gemme: "systems/foundryvtt-reve-de-dragon/icons/gemmes/almaze.webp",
   possession: "systems/foundryvtt-reve-de-dragon/icons/entites/possession2.webp",
   sortreserve: "systems/foundryvtt-reve-de-dragon/icons/competence_oniros.webp",
   extraitpoetique: "systems/foundryvtt-reve-de-dragon/icons/competence_ecriture.webp",
   tarot: "systems/foundryvtt-reve-de-dragon/icons/tarots/dos-tarot.webp",
+  empoignade: "systems/foundryvtt-reve-de-dragon/icons/competence_corps_a_corps.webp"
 }
 
 /* -------------------------------------------- */
 export class RdDItem extends Item {
 
-  static getDefaultImg(itemType) {
+  static get defaultIcon() {
-    return defaultItemImg[itemType];
+    return undefined;
   }
 
-  static isEquipementFieldEditable(type, field) {
+  static getDefaultImg(itemType) {
+    return game.system.rdd.itemClasses[itemType]?.defaultIcon ?? defaultItemImg[itemType];
+  }
+
+  static isFieldInventaireModifiable(type, field) {
     switch (field) {
       case 'quantite':
-        if (['conteneur'].includes(type)) {
+        if ([TYPES.conteneur].includes(type)) {
           return false;
         }
         break;
       case 'cout':
-        if(['monnaie'].includes(type)){
+        if ([TYPES.monnaie].includes(type)) {
           return game.user.isGM;
         }
         break;
@@ -86,57 +154,127 @@ export class RdDItem extends Item {
     return true;
   }
 
-  static getUniteQuantite(type) {
+  static async getCorrespondingItem(itemRef) {
-    switch (type) {
+    if (itemRef.pack) {
-      case "monnaie": return "(Pièces)"
+      return await SystemCompendiums.loadDocument(itemRef)
-      case "herbe": return "(Brins)"
-      case "ingredient": return "(Pépins ou Brins)"
     }
-    return '';
+    return game.items.get(itemRef.id ?? itemRef._id);
   }
 
-  constructor(itemData, context) {
+  static getItemTypesInventaire(mode = 'materiel') {
-    if (!itemData.img) {
+    return typesInventaire[mode ?? 'materiel']
-      itemData.img = RdDItem.getDefaultImg(itemData.type);
   }
-    super(itemData, context);
+  static getItemTypesDraconiques() {
+    return typesObjetsDraconiques;
   }
-
+  static getItemTypesEnvironnement() {
-  static getTypesObjetsEquipement() {
+    return typesEnvironnement;
-    return typesObjetsEquipement
   }
 
   static getTypesOeuvres() {
     return typesObjetsOeuvres
   }
 
-  isCompetencePersonnage() {
+  constructor(docData, context = {}) {
-    return this.type == 'competence'
+    if (!context.rdd?.ready) {
+      mergeObject(context, { rdd: { ready: true } });
+      const ItemConstructor = game.system.rdd.itemClasses[docData.type];
+      if (ItemConstructor) {
+        if (!docData.img) {
+          docData.img = ItemConstructor.defaultIcon;
         }
-  isCompetence() {
+        return new ItemConstructor(docData, context);
-    return typesObjetsCompetence.includes(this.type)
       }
-  isEquipement() {
-    return typesObjetsEquipement.includes(this.type)
     }
-  isOeuvre() {
+    if (!docData.img) {
-    return typesObjetsOeuvres.includes(this.type)
+      docData.img = RdDItem.getDefaultImg(docData.type);
     }
-  isDraconique() {
+    super(docData, context);
-    return typesObjetsDraconiques.includes(this.type)
   }
-  isEffet() {
+
-    return typesObjetsEffet.includes(this.type)
+  getUniteQuantite() {
+    switch (this.type) {
+      case TYPES.monnaie: return "(Pièces)"
+      case TYPES.herbe:
+        switch (this.system.categorie) {
+          case 'Alchimie': case 'Repos': case 'Soin':
+            return "(Brins)"
+          case 'Cuisine': return '';
         }
-  isConnaissance() {
+        return '';
-    return typesObjetsConnaissance.includes(this.type)
+      case TYPES.ingredient: return "(Pépins ou Brins)"
     }
-  isConteneur() {
+    return '';
-    return this.type == 'conteneur';
+  }
+
+  isEquipable() {
+    return typesObjetsEquipable.includes(this.type)
+  }
+
+  isCompetencePersonnage() { return this.type == TYPES.competence }
+  isCompetenceCreature() { return this.type == TYPES.competencecreature }
+  isConteneur() { return this.type == TYPES.conteneur; }
+  isMonnaie() { return this.type == TYPES.monnaie; }
+  isPotion() { return this.type == TYPES.potion; }
+  isNourritureBoisson() { return this.type == TYPES.nourritureboisson; }
+  isService() { return this.type == TYPES.service; }
+
+  isCompetence() { return typesObjetsCompetence.includes(this.type) }
+  isCompetencePossession() { return TYPES.competencecreature == this.type && this.system.categorie == "possession" }
+  isTemporel() { return typesObjetsTemporels.includes(this.type) }
+  isOeuvre() { return typesObjetsOeuvres.includes(this.type) }
+  isDraconique() { return RdDItem.getItemTypesDraconiques().includes(this.type) }
+  isQueueDragon() { return [TYPES.queue, TYPES.ombre].includes(this.type) }
+  isEffet() { return typesObjetsEffet.includes(this.type) }
+  isConnaissance() { return typesObjetsConnaissance.includes(this.type) }
+
+  isInventaire(mode = 'materiel') { return RdDItem.getItemTypesInventaire(mode).includes(this.type); }
+  isBoisson() { return this.isNourritureBoisson() && this.system.boisson; }
+  isAlcool() { return this.isNourritureBoisson() && this.system.boisson && this.system.alcoolise; }
+  isHerbeAPotion() { return this.type == TYPES.herbe && (this.system.categorie == 'Soin' || this.system.categorie == 'Repos'); }
+  isBlessure() { return this.type == TYPES.blessure }
+
+  isPresentDansMilieux(milieux) {
+    return this.getEnvironnements(milieux).length > 0
+  }
+  getCategories() {
+    switch (this.type) {
+      case TYPES.competence: return RdDItemCompetence.getCategories()
+      case TYPES.competencecreature: return RdDItemCompetenceCreature.getCategories()
+    }
+    return {}
+  }
+
+  getEnvironnements(milieux = undefined) {
+    const environnements = this.isInventaire() ? this.system.environnement : undefined;
+    if (milieux == undefined || !environnements) {
+      return environnements ?? [];
+    }
+    return environnements.filter(env => milieux.includes(env.milieu))
+  }
+
+  getMilieux() {
+    return this.getEnvironnements().map(env => env.milieu);
+  }
+
+  getRaretes(milieux = undefined) {
+    if (this.isInventaire()) {
+      const raretes = this.getEnvironnements(milieux).map(env => RdDRaretes.byCode(env.rarete));
+      if (milieux == undefined && raretes.length == 0) {
+        return [RdDRaretes.rareteFrequente()];
+      }
+      return raretes;
+    }
+    return [RdDRaretes.rareteEgale()];
+  }
+
+  getFrequence(milieux = undefined) {
+    const frequences = this.getEnvironnements(milieux).map(it => it.frequence);
+    return frequences.length == 0 ? 0 : Math.max(...frequences);
   }
 
   getItemGroup() {
-    if (this.isEquipement()) return "equipement";
+    if (this.isInventaire()) return "equipement";
     if (this.isOeuvre()) return "oeuvre";
     if (this.isDraconique()) return "draconique";
     if (this.isConnaissance()) return "connaissance";
@@ -145,70 +283,153 @@ export class RdDItem extends Item {
     return "autres";
   }
 
-  isConteneurNonVide() {
+  isConteneurNonVide() { return this.isConteneur() && (this.system.contenu?.length ?? 0) > 0; }
-    return this.isConteneur() && (this.system.contenu?.length ?? 0) > 0;
+  isConteneurVide() { return this.isConteneur() && (this.system.contenu?.length ?? 0) == 0; }
+  isVideOuNonConteneur() { return !this.isConteneur() || (this.system.contenu?.length ?? 0) == 0; }
+
+  isFinPeriode(oldTimestamp, newTimestamp) {
+    if (!this.isTemporel()) {
+      return false;
+    }
+    const finPeriode = new RdDTimestamp(this.system.temporel.fin);
+    return oldTimestamp.compare(finPeriode) < 0 && finPeriode.compare(newTimestamp) <= 0
   }
 
-  isConteneurVide() {
+  async onCreateItemTemporel(actor) {
-    return this.isConteneur() && (this.system.contenu?.length ?? 0) == 0;
+    if (this.isTemporel()) {
+      const timestampDebut = game.system.rdd.calendrier.timestamp;
+      const timestampFin = await this.calculerFinPeriodeTemporel(timestampDebut);
+      await actor.updateEmbeddedDocuments('Item', [{
+        _id: this.id,
+        'system.temporel.debut': duplicate(timestampDebut),
+        'system.temporel.fin': duplicate(timestampFin),
+      }])
+    }
   }
 
-  isVideOuNonConteneur() {
+  async calculerFinPeriodeTemporel(timestampDebut) {
-    return !this.isConteneur() || (this.system.contenu?.length ?? 0) == 0;
+    return timestampDebut;
   }
 
-  isAlcool() {
+  async onFinPeriodeTemporel(oldTimestamp, newTimestamp) {
-    return this.type == 'nourritureboisson' && this.system.boisson && this.system.alcoolise;
+    if (this.isTemporel() && this.actor) {
+      await this.onFinPeriode(oldTimestamp, newTimestamp);
     }
-  isHerbeAPotion() {
-    return this.type == 'herbe' && (this.system.categorie == 'Soin' || this.system.categorie == 'Repos');
   }
-  isPotion() {
+
-    return this.type == 'potion';
+  async onFinPeriode(oldTimestamp, newTimestamp) {
+    console.log(`${this.actor.name}: l'objet ${this.name} a expiré et été supprimé`);
+    await this.actor?.deleteEmbeddedDocuments('Item', [this.id]);
   }
+
+  getUtilisation() {
+    switch (this.type) {
+      case 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 TYPES.nourritureboisson: return 'cuisine';
+      case TYPES.herbe: case TYPES.faune: case TYPES.ingredient: case TYPES.plante:
+        switch (this.system.categorie) {
+          case 'Cuisine': return 'cuisine';
+          case 'Toxique': case 'Poison': return 'poison';
+          case 'Alchimie': return 'alchimie'
+          case 'Soin': case 'Repos': return 'soins'
+        }
+        return this.system.sust > 0 ? 'cuisine' : '';
+    }
+    return '';
+  }
+
+  getUtilisationCuisine() {
+    if (this.getUtilisation() == 'cuisine') {
+      switch (this.type) {
+        case TYPES.nourritureboisson:
+          return 'pret';
+        case TYPES.herbe: case TYPES.faune: case TYPES.ingredient: case TYPES.plante:
+          return 'brut';
+      }
+    }
+    return '';
+  }
+
   isCristalAlchimique() {
-    return this.type == 'objet' && Grammar.toLowerCaseNoAccent(this.name) == 'cristal alchimique' && this.system.quantite > 0;
+    return this.type == TYPES.objet && Grammar.includesLowerCaseNoAccent(this.name, 'cristal alchimique') && this.system.quantite > 0;
   }
 
   isMagique() {
     return this.system.magique
   }
 
+  isItemCommerce() {
+    return this.parent?.type == 'commerce';
+  }
+
+  isNomLike(texte) {
+    return Grammar.includesLowerCaseNoAccent(this.name, texte)
+  }
+  isNomTypeLike(texte) {
+    return this.isNomLike(texte) || Grammar.includesLowerCaseNoAccent(Misc.typeName(this.type, 'Item'), texte)
+  }
+
   getQuantite() {
-    return Math.round(this.isConteneur() ? 1 : (this.system.quantite ?? 0))
+    return this.isService() ? undefined : Math.round(this.system.quantite ?? 0)
   }
 
   getEncTotal() {
-    return this.getEnc() * this.getQuantite();
+    return (this.getQuantite() ?? 0) * this.getEnc();
   }
 
   getEnc() {
     switch (this.type) {
-      case 'herbe':
+      case TYPES.service:
-        return encBrin;
+        return 0;
-      case 'gemme':
+      case TYPES.herbe:
+        return this.getEncHerbe();
+      case TYPES.gemme:
         return encPepin * this.system.taille;
     }
     return Math.max(this.system.encombrement ?? 0, 0);
   }
 
+  getEncHerbe() {
+    switch (this.system.categorie) {
+      case 'Repos': case 'Soin': case 'Alchimie':
+        return encBrin;
+    }
+    return this.system.encombrement;
+
+  }
+
   valeurTotale() {
-    return this.getQuantite() * this.valeur()
+    return (this.isService() ? 1 : this.getQuantite()) * this.valeur()
   }
 
   valeur() {
     return this.system.cout ?? 0
   }
 
+  calculerPrixCommercant() {
+    if (this.isItemCommerce()) {
+      // appliquer le pourcentage
+      return this.parent.calculerPrix(this);
+    }
+    return this.system.cout;
+  }
+
   prepareDerivedData() {
     super.prepareDerivedData();
-    if (this.isEquipement()) {
+    if (this.isInventaire()) {
       this.system.encTotal = this.getEncTotal();
       if (this.isPotion()) {
         this.prepareDataPotion()
       }
       this.system.actionPrincipale = this.getActionPrincipale({ warnIfNot: false });
     }
+    this.equipable = this.isEquipable();
   }
 
   prepareDataPotion() {
@@ -223,19 +444,43 @@ export class RdDItem extends Item {
   }
 
   getActionPrincipale(options = { warnIfNot: true }) {
-    const warn = options.warnIfNot;
     switch (this.type) {
-      case 'nourritureboisson': return this._actionOrWarnQuantiteZero(this.system.boisson ? 'Boire' : 'Manger', warn);
+      case TYPES.conteneur: return 'Ouvrir';
-      case 'potion': return this._actionOrWarnQuantiteZero('Boire', warn);
+    }
-      case 'livre': return this._actionOrWarnQuantiteZero('Lire', warn);
+    if (this.actor?.isPersonnage()) {
-      case 'conteneur': return 'Ouvrir';
+      const warn = options.warnIfNot;
-      case 'herbe':  return this.isHerbeAPotion() ? this._actionOrWarnQuantiteZero('Décoction', warn) : undefined;
+      if (this.getUtilisationCuisine() == 'brut') {
-      case 'queue': case 'ombre': return this.system.refoulement>0 ? 'Refouler' : undefined;
+        return 'Utiliser';
+      }
+      switch (this.type) {
+        case TYPES.nourritureboisson: return this._actionOrWarnQuantiteZero(this.system.boisson ? 'Boire' : 'Manger', warn);
+        case TYPES.potion: return this._actionOrWarnQuantiteZero('Boire', warn);
+        case TYPES.livre: return this._actionOrWarnQuantiteZero('Lire', warn);
+        case TYPES.herbe: return this.isHerbeAPotion() ? this._actionOrWarnQuantiteZero('Décoction', warn) : undefined;
+        case TYPES.queue: case TYPES.ombre: return this.system.refoulement > 0 ? 'Refouler' : undefined;
+      }
     }
     return undefined;
   }
 
-  _actionOrWarnQuantiteZero(actionName, warn){
+  /* -------------------------------------------- */
+  async actionPrincipale(actor, onActionItem = async () => { }) {
+    if (!this.getActionPrincipale()) {
+      return;
+    }
+    if (await actor.actionNourritureboisson(this, onActionItem)) {
+      return;
+    }
+    switch (this.type) {
+      case TYPES.potion: return await actor.consommerPotion(this, onActionItem);
+      case TYPES.livre: return await actor.actionLire(this);
+      case TYPES.conteneur: return await this.sheet.render(true);
+      case TYPES.herbe: return await actor.actionHerbe(this, onActionItem);
+      case TYPES.queue: case TYPES.ombre: return await actor.actionRefoulement(this);
+    }
+  }
+
+  _actionOrWarnQuantiteZero(actionName, warn) {
     if ((this.system.quantite ?? 0) <= 0) {
       if (warn) {
         ui.notifications.warn(`Vous n'avez plus de ${this.name}.`);
@@ -252,7 +497,43 @@ export class RdDItem extends Item {
     await this.quantiteIncDec(-nombre, options);
   }
 
-  async quantiteIncDec(nombre, options = { diminuerQuantite: true, supprimerSiZero: false }) {
+  async onCreateDecoupeComestible(actor) {
+    if (actor && this.getUtilisationCuisine() == 'brut' && this.system.sust != 1) {
+      if (this.system.sust < 1) {
+        await actor.updateEmbeddedDocuments('Item', [{
+          _id: this.id,
+          'system.sust': 0
+        }])
+      }
+      else {
+        const sust = Math.floor(this.system.sust);
+        await actor.updateEmbeddedDocuments('Item', [{
+          _id: this.id,
+          'system.quantite': this.system.quantite * sust,
+          'system.encombrement': Misc.keepDecimals(this.system.encombrement / sust, 2),
+          'system.cout': Misc.keepDecimals(this.system.cout / sust, 2),
+          'system.sust': 1
+        }])
+      }
+    }
+  }
+
+  async empiler(item) {
+    if (this.getUtilisationCuisine() == 'brut') {
+      const sust = this.system.sust + item.system.sust;
+      const encombrement = this.system.encombrement + item.system.encombrement;
+      await this.update({
+        "system.sust": sust,
+        "system.encombrement": encombrement
+      });
+    }
+    else {
+      await this.quantiteIncDec(item.system.quantite);
+    }
+    await item.delete();
+  }
+
+  async quantiteIncDec(nombre, options = { supprimerSiZero: false }) {
     const quantite = Number(this.system.quantite ?? -1);
     if (quantite >= 0) {
       const reste = Math.max(quantite + Number(nombre), 0);
@@ -275,11 +556,10 @@ export class RdDItem extends Item {
 
   /* -------------------------------------------- */
   // détermine si deux équipements sont similaires: de même type, et avec les même champs hormis la quantité
-  isEquipementEmpilable(other) {
+  isInventaireEmpilable(other) {
-    if (!other || !this.isEquipement()) {
+    if (!other || !this.isInventaire()) {
       return [false, undefined];
     }
-
     if (this.system.quantite == undefined) {
       return [false, `Impossible de regrouper des ${this.type}, ils ne sont pas empilables`];
     }
@@ -290,8 +570,13 @@ export class RdDItem extends Item {
       return [false, `Impossible de regrouper ${this.name} avec ${other.name}`];
     }
     else {
-      const differences = Object.entries(this.system)
+      const excludedProperties = ['quantite', 'cout', 'encTotal', 'environnement', 'contenu'];
-        .filter(([key, value]) => !['quantite', 'cout', 'encTotal'].includes(key) && value != other.system[key]);
+      if (this.getUtilisationCuisine()) {
+        excludedProperties.push('sust', 'encombrement');
+      }
+      let differences = Object.entries(this.system)
+        .filter(([key, value]) => !excludedProperties.includes(key))
+        .filter(([key, value]) => value != other.system[key])
       if (differences.length > 0) {
         let message = `Impossible de regrouper les ${this.type} ${this.name}: `;
         for (const [key, value] of differences) {
@@ -303,13 +588,16 @@ export class RdDItem extends Item {
     return [true, undefined];
   }
 
-  async proposerVente() {
+  async proposerVente(quantiteMax = undefined) {
     console.log(this);
     if (this.isConteneurNonVide()) {
       ui.notifications.warn(`Votre ${this.name} n'est pas vide, pas possible de le proposer`);
       return;
     }
-    await DialogItemVente.display(this, async (vente) =>  {
+    await DialogItemVente.display({
+      item: this,
+      quantiteMax,
+      callback: async (vente) => {
         vente["properties"] = this.getProprietes();
         if (vente.isOwned) {
           if (vente.quantiteNbLots * vente.tailleLot > vente.quantiteMax) {
@@ -319,61 +607,69 @@ export class RdDItem extends Item {
         }
         vente.jsondata = JSON.stringify(vente.item);
 
-      console.log(vente);
         let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-vente-item.html', vente);
         ChatMessage.create(RdDUtility.chatDataSetup(html));
+      }
     });
   }
 
   /* -------------------------------------------- */
   getProprietes() {
-    return this[`_${this.type}ChatData`]();
+    if (this[`_${this.type}ChatData`]) {
+      return this[`_${this.type}ChatData`]().filter(it => it != undefined);
+    }
+    return [];
   }
 
   /* -------------------------------------------- */
-  async postItem(modeOverride) {
+  async postItemToChat(modeOverride) {
     console.log(this);
-    let chatData = duplicate(this);
+    let chatData = {
-    chatData["properties"] = this.getProprietes();
+      doctype: 'Item',
-    if (this.actor) {
+      id: this.id,
-      chatData.actor = { id: this.actor.id };
+      type: this.type,
+      img: this.img,
+      pack: this.pack,
+      name: this.name,
+      actor: this.actor ? { id: this.actor.id } : undefined,
+      system: { description: this.system.description },
+      properties: this.getProprietes(),
     }
-    // JSON object for easy creation
+    renderTemplate(this.getChatItemTemplate(), chatData).then(html => {
-    chatData.jsondata = JSON.stringify(
-      {
-        compendium: "postedItem",
-        payload: chatData,
-      });
-
-    renderTemplate('systems/foundryvtt-reve-de-dragon/templates/post-item.html', chatData).then(html => {
       let chatOptions = RdDUtility.chatDataSetup(html, modeOverride);
       ChatMessage.create(chatOptions)
     });
   }
 
-  static propertyIfDefined(name, val, condition = (it) => true) {
+  getChatItemTemplate() {
-    return condition ? [`<b>${name}</b>: ${val}`] : [];
+    return 'systems/foundryvtt-reve-de-dragon/templates/post-item.html';
   }
 
+  static propertyIfDefined(name, val, condition = true) {
+    return condition ? `<b>${name}</b>: ${val}` : undefined;
+  }
+
+  _inventaireTemplateChatData() {
+    return [
+      RdDItem.propertyIfDefined('Qualité', this.system.qualite, this.system.qualite != 0),
+      RdDItem.propertyIfDefined('Encombrement', this.system.encombrement)
+      // cout et quantité masqués
+    ]
+  }
   /* -------------------------------------------- */
   _objetChatData() {
-    return [].concat(
+    return this._inventaireTemplateChatData()
-      RdDItem.propertyIfDefined('Résistance', this.system.resistance, this.system.resistance),
-      RdDItem.propertyIfDefined('Qualité', this.system.qualite, this.system.qualite),
-      RdDItem.propertyIfDefined('Encombrement', this.system.encombrement),
-    );
   }
 
   /* -------------------------------------------- */
   _nourritureboissonChatData() {
-    return [].concat(
+    return [
       RdDItem.propertyIfDefined('Sustentation', this.system.sust, this.system.sust > 0),
       RdDItem.propertyIfDefined('Désaltère', this.system.desaltere, this.system.boisson),
       RdDItem.propertyIfDefined('Force alcool', this.system.force, this.system.boisson && this.system.alcoolise),
       RdDItem.propertyIfDefined('Exotisme', this.system.exotisme, this.system.exotisme < 0),
-      RdDItem.propertyIfDefined('Qualité', this.system.qualite, this.system.qualite),
+      ...this._inventaireTemplateChatData()
-      RdDItem.propertyIfDefined('Encombrement', this.system.encombrement),
+    ]
-    );
   }
   /* -------------------------------------------- */
   _armeChatData() {
@@ -382,21 +678,19 @@ export class RdDItem extends Item {
       `<b>Dommages</b>: ${this.system.dommages}`,
       `<b>Force minimum</b>: ${this.system.force}`,
       `<b>Resistance</b>: ${this.system.resistance}`,
-      `<b>Encombrement</b>: ${this.system.encombrement}`
+      ...this._inventaireTemplateChatData()
     ]
   }
   /* -------------------------------------------- */
   _conteneurChatData() {
     return [
       `<b>Capacité</b>: ${this.system.capacite} Enc.`,
-      `<b>Encombrement</b>: ${this.system.encombrement}`
+      ...this._inventaireTemplateChatData()
     ]
   }
   /* -------------------------------------------- */
   _munitionChatData() {
-    return [
+    return this._inventaireTemplateChatData()
-      `<b>Encombrement</b>: ${this.system.encombrement}`
-    ]
   }
   /* -------------------------------------------- */
   _armureChatData() {
@@ -404,7 +698,7 @@ export class RdDItem extends Item {
       `<b>Protection</b>: ${this.system.protection}`,
       `<b>Détérioration</b>: ${this.system.deterioration}`,
       `<b>Malus armure</b>: ${this.system.malus}`,
-      `<b>Encombrement</b>: ${this.system.encombrement}`
+      ...this._inventaireTemplateChatData()
     ]
   }
   /* -------------------------------------------- */
@@ -438,16 +732,24 @@ export class RdDItem extends Item {
   _herbeChatData() {
     return [
       `<b>Milieu</b>: ${this.system.milieu}`,
-      `<b>Rareté</b>: ${this.system.rarete}`,
       `<b>Catégorie</b>: ${this.system.categorie}`,
+      ...this._inventaireTemplateChatData()
     ]
   }
   /* -------------------------------------------- */
   _ingredientChatData() {
     return [
       `<b>Milieu</b>: ${this.system.milieu}`,
-      `<b>Rareté</b>: ${this.system.rarete}`,
       `<b>Catégorie</b>: ${this.system.categorie}`,
+      ...this._inventaireTemplateChatData()
+    ]
+  }
+  /* -------------------------------------------- */
+  _fauneChatData() {
+    return [
+      `<b>Sustentation</b>: ${this.system.sust}`,
+      `<b>Milieu</b>: ${this.system.milieu}`,
+      ...this._inventaireTemplateChatData()
     ]
   }
   /* -------------------------------------------- */
@@ -457,12 +759,9 @@ export class RdDItem extends Item {
       `<b>Compétence</b>: ${this.system.competence}`,
       `<b>Périodicité</b>: ${this.system.periodicite}`,
       `<b>Fatigue</b>: ${this.system.fatigue}`,
-      `<b>Difficulté</b>: ${this.system.difficulte}`
+      `<b>Difficulté</b>: ${this.system.difficulte}`,
-    ].concat([
+      RdDItem.propertyIfDefined('Points de Tâche', this.system.points_de_tache, this.system.cacher_points_de_tache),
-      this.system.cacher_points_de_tache ? [] :`<b>Points de Tâche</b>: ${this.system.points_de_tache}`
-    ]).concat([
       `<b>Points de Tâche atteints</b>: ${this.system.points_de_tache_courant}`]
-    );
   }
   /* -------------------------------------------- */
   _livreChatData() {
@@ -470,8 +769,8 @@ export class RdDItem extends Item {
       `<b>Compétence</b>: ${this.system.competence}`,
       `<b>Auteur</b>: ${this.system.auteur}`,
       `<b>Difficulté</b>: ${this.system.difficulte}`,
-      `<b>Points de Tâche</b>: ${this.system.points_de_tache}`,
+      RdDItem.propertyIfDefined('Points de Tâche', this.system.points_de_tache, this.system.cacher_points_de_tache),
-      `<b>Encombrement</b>: ${this.system.encombrement}`
+      ...this._inventaireTemplateChatData()
     ]
   }
   /* -------------------------------------------- */
@@ -479,32 +778,44 @@ export class RdDItem extends Item {
     return [
       `<b>Rareté</b>: ${this.system.rarete}`,
       `<b>Catégorie</b>: ${this.system.categorie}`,
-      `<b>Encombrement</b>: ${this.system.encombrement}`,
+      ...this._inventaireTemplateChatData()
     ]
   }
   /* -------------------------------------------- */
   _queueChatData() {
+    function label(categorie) {
+      switch (categorie) {
+        case 'ideefixe': return 'Idée fixe';
+        case 'lancinant': return 'Désir lancinant';
+      }
+      return ''
+    }
     return [
-      `<b>Refoulement</b>: ${this.system.refoulement}`
+      `<b>Refoulement</b>: ${this.system.refoulement}`,
+      `<b>Catégorie</b>: ${label(this.system.categorie)}`,
+      `<b>Affecte</b>: ${this.system.hautrevant ? 'les haut-rêvants' : 'tout le monde'}`,
     ]
   }
   /* -------------------------------------------- */
   _ombreChatData() {
-    return [
+    return this._queueChatData()
-      `<b>Refoulement</b>: ${this.system.refoulement}`
-    ]
   }
   /* -------------------------------------------- */
   _souffleChatData() {
-    return [];
+    return [
+      `<b>Affecte</b>: ${this.system.hautrevant ? 'les haut-rêvants' : 'tout le monde'}`,
+    ];
   }
   /* -------------------------------------------- */
   _teteChatData() {
-    return [];
+    return [
+      `<b>Affecte</b>: ${this.system.hautrevant ? 'les haut-rêvants' : 'tout le monde'}`,
+    ];
   }
   /* -------------------------------------------- */
   _tarotChatData() {
     return [
+      RdDItem.propertyIfDefined('Carte', RdDUtility.linkCompendium(this.pack, this.id, this.name), this.pack),
       `<b>Concept</b>: ${this.system.concept}`,
       `<b>Aspect</b>: ${this.system.aspect}`,
     ]
@@ -518,10 +829,7 @@ export class RdDItem extends Item {
   }
   /* -------------------------------------------- */
   _monnaieChatData() {
-    return [
+    return this._inventaireTemplateChatData()
-      `<b>Valeur en Sols</b>: ${this.system.cout}`,
-      `<b>Encombrement</b>: ${this.system.encombrement}`
-    ]
   }
   /* -------------------------------------------- */
   _meditationChatData() {
@@ -545,9 +853,9 @@ export class RdDItem extends Item {
       ]
     }
     return [
-      `<b>Force</b>: ${this.system.force}`,
+      `<b>Force</b>: ${this.system.formule}`,
       `<b>Refoulement</b>: ${this.system.refoulement}`,
-      `<b>Présent de cités</b>: ${this.system.presentCite}`,
+      RdDItem.propertyIfDefined('<b>Présent de cités</b>', '', this.system.presentCite),
     ]
   }
   /* -------------------------------------------- */
@@ -562,15 +870,12 @@ export class RdDItem extends Item {
     if (!this.system.identifie) {
       return [`<b>Inconnue</b>`]
     }
-    let properties = [
+    return [
       `<b>Malignité</b>: ${this.system.malignite}`,
       `<b>Périodicité</b>: ${this.system.periodicite}`,
-        `<b>Dommages</b>: ${this.system.dommages}`
+      `<b>Dommages</b>: ${this.system.dommages}`,
+      RdDItem.propertyIfDefined('<b>Remedes</b>', this.system.remedes, this.system.remedesconnus),
     ]
-    if (this.system.remedesconnus) {
-      properties.push(`<b>Remedes</b>: ${this.system.remedes}`)
-    }
-    return properties;
   }
 
   /* -------------------------------------------- */
@@ -585,8 +890,7 @@ export class RdDItem extends Item {
       `<b>Taille</b>: ${this.system.taille}`,
       `<b>Inertie</b>: ${this.system.inertie}`,
       `<b>Enchantabilité</b>: ${this.system.enchantabilite}`,
-      `<b>Prix</b>: ${this.system.cout}`,
+      ...this._inventaireTemplateChatData()
     ]
   }
-
 }

module/item/armure.js

@@ -0,0 +1,51 @@
+import { RdDItem } from "../item.js";
+import { Misc } from "../misc.js";
+import { ReglesOptionelles } from "../settings/regles-optionelles.js";
+
+export class RdDItemArmure extends RdDItem {
+
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/armes_armures/armure_plaques.webp";
+  }
+
+  deteriorerArmure(dmg) {
+    if (!ReglesOptionelles.isUsing('deteriorationArmure') || this.system.protection == '0') {
+      return;
+    }
+    let deterioration = (this.system.deterioration ?? 0) + dmg;
+    let protection = this.system.protection;
+
+    if (deterioration >= 10) {
+      deterioration -= 10;
+      protection = this.calculProtectionDeterioree();
+      ChatMessage.create({ content: `Votre armure ${this.name} s'est détériorée, elle protège maintenant de ${protection}` });
+    }
+    this.update({
+      system: {
+        deterioration: deterioration,
+        protection: protection
+      }
+    });
+  }
+
+  calculProtectionDeterioree() {
+    const protectionCourante = this.system.protection;
+    let res = /(\d+)?d(\d+)(\-\d+)?/.exec(protectionCourante);
+    if (res) {
+      let protection = Misc.toInt(res[2]);
+      let malus = Misc.toInt(res[3]) - 1;
+      if (protection + malus <= 0) {
+        return 0;
+      } else {
+        return `1d${protection}${malus}`;
+      }
+    }
+    else if (/\d+/.exec(protectionCourante)) {
+      return `1d${protectionCourante}`;
+    }
+    else {
+      ui.notifications.warn(`La valeur d'armure de votre ${this.name} est incorrecte`);
+      return undefined;
+    }
+  }
+}

module/item/blessure.js

@@ -0,0 +1,199 @@
+import { RdDItem } from "../item.js";
+import { Misc } from "../misc.js";
+import { RdDTimestamp } from "../time/rdd-timestamp.js";
+
+const BASE_TACHE_SOIN_BLESSURE = {
+  type: "tache",
+  img: 'systems/foundryvtt-reve-de-dragon/icons/competence_chirurgie.webp',
+  system: { carac: "dexterite", competence: "Chirurgie", periodicite: "1 round", fatigue: 0, }
+}
+const TACHES_SOIN_BLESSURE = {
+  6: { name: 'Blessure critique', system: { difficulte: -6, points_de_tache: 6 } },
+  4: { name: 'Blessure grave', system: { difficulte: -4, points_de_tache: 4 } },
+  2: { name: 'Blessure légère', system: { difficulte: -2, points_de_tache: 2 } },
+}
+
+const definitionsBlessures = [
+  { type: "contusion", gravite: 0, label: 'Contusion/éraflure', max: 100, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/eraflure.webp" },
+  { type: "legere", gravite: 2, label: 'Légère', max: 5, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/blessure.webp" },
+  { type: "grave", gravite: 4, label: 'Grave', max: 2, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/blessure.webp" },
+  { type: "critique", gravite: 6, label: 'Critique', max: 1, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/blessure.webp" },
+  { type: "mort", gravite: 8, label: 'Mort', max: 1, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/mort.webp" }
+]
+
+export class RdDItemBlessure extends RdDItem {
+
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/sante/blessure.webp";
+  }
+
+  prepareDerivedData() {
+    super.prepareDerivedData();
+    this.system.label = this.getLabelGravite()
+  }
+
+  static prepareTacheSoin(gravite) {
+    const tache = TACHES_SOIN_BLESSURE[gravite]
+    if (!tache) {
+      ui.notifications.warn(`Pas de tâche de soins pour une blessure ${gravite}`)
+      return undefined;
+    }
+    return mergeObject(duplicate(BASE_TACHE_SOIN_BLESSURE), tache)
+  }
+  static async createBlessure(actor, gravite, localisation = '', attacker) {
+    const definition = RdDItemBlessure.getDefinition(gravite)
+    const blessure = {
+      name: definition.label,
+      type: 'blessure',
+      img: definition.icon,
+      system: {
+        gravite: gravite,
+        difficulte: - gravite,
+        localisation: localisation,
+        origine: attacker?.name ?? ""
+      }
+    }
+    const blessures = await actor.createEmbeddedDocuments('Item', [blessure])
+    return blessures[0]
+  }
+
+  static async createTacheSoinBlessure(actor, gravite) {
+    const tache = RdDItemBlessure.prepareTacheSoin(gravite)
+    if (tache) {
+      const taches = await actor.createEmbeddedDocuments('Item', [tache], { renderSheet: false });
+      return taches[0];
+    }
+    return undefined
+  }
+
+  async updateTacheSoinBlessure(tache) {
+    if (tache) {
+      await tache.update({
+        system: {
+          itemId: this.id,
+          difficulte: Math.min(this.system.difficulte, tache.system.difficulte),
+          points_de_tache_courant: Math.max(0, this.system.premierssoins.tache)
+        }
+      });
+    }
+  }
+
+  async setSoinsBlessure(systemUpdate = {}) {
+    systemUpdate = mergeObject(systemUpdate, this.system, { overwrite: false }),
+      systemUpdate.soinscomplets.done = systemUpdate.premierssoins.done && systemUpdate.soinscomplets.done
+    await this.update({
+      img: this.getImgSoins(systemUpdate.gravite, systemUpdate.soinscomplets.done),
+      system: systemUpdate
+    });
+  }
+
+  async recuperationBlessure({ actor, timestamp, message, isMaladeEmpoisonne, blessures }) {
+    if (this.parent != actor || actor == undefined) {
+      return
+    }
+    if (new RdDTimestamp(this.system.temporel.fin).compare(timestamp) > 0) {
+      // attente periode
+      return
+    }
+    if (this.system.gravite > 0) {
+      const update = { system: { premierssoins: { bonus: 0 }, soinscomplets: { bonus: 0 } } }
+      const gravite = this.system.gravite;
+      const graviteMoindre = gravite - 2;
+      const moindres = blessures.filter(it => it.system.gravite == graviteMoindre, 'blessures').length
+      const label = this.getLabelGravite();
+
+      let rolled = await actor.jetRecuperationConstitution(this.system.soinscomplets.bonus, message);
+
+      if (rolled.isETotal) {
+        message.content += ` -- une blessure ${label} s'infecte (temps de guérison augmenté de ${gravite} jours, perte de vie)`;
+        await actor.santeIncDec("vie", -1);
+        mergeObject(update, {
+          system: { fin: { indexDate: timestamp.addJours(gravite).indexDate } }
+        });
+      }
+      else {
+        if (!isMaladeEmpoisonne && rolled.isSuccess && this.peutRetrograder(graviteMoindre, moindres)) {
+          message.content += ` -- une blessure ${label} cicatrise`;
+          mergeObject(update, {
+            system: { gravite: graviteMoindre, fin: { indexDate: timestamp.addJours(graviteMoindre).indexDate } }
+          });
+        }
+        else {
+          message.content += ` -- une blessure ${label} reste stable`;
+        }
+      }
+      await this.update(update);
+    }
+  }
+
+  peutRetrograder(graviteMoindre, moindres) {
+    return moindres < RdDItemBlessure.getDefinition(graviteMoindre).max
+  }
+
+  async calculerFinPeriodeTemporel(debut) {
+    return await debut.nouveauJour().addJours(this.system.gravite);
+  }
+
+  async onFinPeriode(oldTimestamp, newTimestamp) {
+    if (this.system.gravite <= 0) {
+      await super.onFinPeriode(oldTimestamp, newTimestamp)
+    }
+  }
+
+  getImgSoins(gravite, soins) {
+    let img = 'blessure'
+    if (gravite > 6) {
+      img = 'mort'
+    }
+    if (gravite <= 0) {
+      img = 'eraflure'
+    }
+    return `systems/foundryvtt-reve-de-dragon/icons/sante/${soins ? 'blessure-soins' : img}.webp`
+  }
+
+  getLabelGravite() {
+    return RdDItemBlessure.getDefinition(this.system.gravite).label
+  }
+
+  static getDefinition(gravite) {
+    return definitionsBlessures.sort(Misc.ascending(it => it.gravite))
+      .find(it => it.gravite >= gravite);
+  }
+  static maxBlessures(gravite) {
+    return RdDItemBlessure.getDefinition(gravite).max
+  }
+
+  isContusion() {
+    return this.system.gravite <= 0
+  }
+  isLegere() {
+    return this.system.gravite > 0 && this.system.gravite <= 2
+  }
+  isGrave() {
+    return this.system.gravite > 2 && this.system.gravite <= 4
+  }
+  isCritique() {
+    return this.system.gravite > 4 && this.system.gravite <= 6
+  }
+  isMort() {
+    return this.system.gravite > 6
+  }
+
+  getProprietes() {
+    return [
+      RdDItem.propertyIfDefined('Causée par', this.system.origine, this.system.origine),
+      `<b>Heure et Date</b>: ${new RdDTimestamp(this.system.temporel.debut).formatDateHeure()}`,
+      RdDItem.propertyIfDefined('Blessé', this.parent?.name, this.parent),
+      `<b>Localisation</b>: ${this.system.localisation}`,
+      `<b>Gravité</b>: ${RdDItemBlessure.getDefinition(this.system.gravite).label}`,
+      `<b>Difficulté des soins</b>: ${this.system.difficulte}`,
+      (this.system.soinscomplets.done ?
+        `<b>Bonus soins complets</b>: ${this.system.soinscomplets.bonus}` :
+        (this.system.premierssoins.done ?
+          `<b>Bonus premiers soins</b>: ${this.system.premierssoins.bonus}` :
+          `<b>Points de tâche</b>: ${this.system.premierssoins.tache}`
+        )
+      ),
+    ];
+  }
+}

module/item/maladie.js

@@ -0,0 +1,47 @@
+import { RdDItem } from "../item.js";
+import { Misc } from "../misc.js";
+import { RdDTimestamp } from "../time/rdd-timestamp.js";
+
+export class RdDItemMaladie extends RdDItem {
+
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/maladies_venins/maladie.webp";
+  }
+
+  async calculerFinPeriodeTemporel(debut) {
+    return await debut.addPeriode(this.system.periode.nombre, this.system.periode.unite);
+  }
+
+  async onFinPeriode(oldTimestamp, newTimestamp) {
+    await RdDItemMaladie.notifierMaladiePoison(this, oldTimestamp, newTimestamp)
+  }
+
+  static async notifierMaladiePoison(mal, oldTimestamp, newTimestamp) {
+    if (mal.actor) {
+      const souffrance = mal.system.identifie
+        ? `de ${mal.name}`
+        : `d'un mal inconnu`
+      ChatMessage.create({ content: `${mal.actor.name} souffre ${souffrance} (${Misc.typeName('Item', mal.type)}): vérifiez que les effets ne se sont pas aggravés !` });
+      mal.postItemToChat('gmroll');
+      await RdDItemMaladie.prolongerPeriode(mal,oldTimestamp, newTimestamp);
+    }
+  }
+
+  static async prolongerPeriode(mal, oldTimestamp, newTimestamp) {
+    if (mal.actor) {
+      // TODO: déterminer le nombre de périodes écoulées
+      console.log(`${mal.actor.name}: le mal ${mal.name} a atteint la fin de sa période et été prolongé`);
+      const current = newTimestamp;
+      const finPeriode = new RdDTimestamp(mal.system.temporel.fin)
+      const periodeSuivante = (finPeriode.compare(current) > 0 ? finPeriode : current);
+      const timestampFin = await mal.calculerFinPeriodeTemporel(periodeSuivante);
+
+      await mal.actor.updateEmbeddedDocuments('Item', [{
+        _id: mal.id,
+        'system.temporel.fin': duplicate(timestampFin),
+      }])
+    }
+  }
+
+
+}

module/item/ombre.js

@@ -0,0 +1,11 @@
+import { RdDItem } from "../item.js";
+
+export class RdDItemOmbre extends RdDItem {
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/queue_dragon.webp";
+  }
+
+  async calculerFinPeriodeTemporel(debut) {
+    return await debut.appliquerDuree(this.system.duree, this.parent);
+  }
+}

module/item/poison.js

@@ -0,0 +1,17 @@
+import { RdDItem } from "../item.js";
+import { RdDItemMaladie } from "./maladie.js";
+
+export class RdDItemPoison extends RdDItem {
+
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/maladies_venins/venin.webp";
+  }
+
+  async calculerFinPeriodeTemporel(debut) {
+    return await debut.addPeriode(this.system.periode.nombre, this.system.periode.unite) ;
+  }
+
+  async onFinPeriode(oldTimestamp, newTimestamp) {
+    RdDItemMaladie.notifierMaladiePoison(this, oldTimestamp, newTimestamp)
+  }
+}

module/item/queue.js

@@ -0,0 +1,13 @@
+import { RdDItem } from "../item.js";
+
+export class RdDItemQueue extends RdDItem {
+
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/queue_dragon.webp";
+  }
+
+  async calculerFinPeriodeTemporel(debut) {
+    return await debut.appliquerDuree(this.system.duree, this.parent);
+  }
+
+}

module/item/raretes.js

@@ -0,0 +1,31 @@
+
+const RARETE_COMMUNE = { code: 'Commune', label: 'Commune', frequence: 54, min: 27, max: 108 };
+const RARETE_FREQUENTE = { code: 'Frequente', label: 'Fréquente', frequence: 18, min: 9, max: 36 };
+const RARETE_RARE = { code: 'Rare', label: 'Rare', frequence: 6, min: 3, max: 12 };
+const RARETE_RARISSIME = { code: 'Rarissime', label: 'Rarissime', frequence: 2, min: 1, max: 4 };
+const RARETE_INEXISTANT = { code: 'Inexistant', label: 'Inexistant', frequence: 0, min: 0, max: 0 };
+const RARETE_EGALE = { code: 'eqal', label: 'Egal', frequence: 1, min: 1, max: 1 };
+
+const RARETES = [
+  RARETE_COMMUNE,
+  RARETE_FREQUENTE,
+  RARETE_RARE,
+  RARETE_RARISSIME,
+  RARETE_INEXISTANT,
+]
+
+export class RdDRaretes {
+
+  static rareteFrequente() { return RARETE_FREQUENTE; }
+  static rareteEgale() { return RARETE_EGALE; }
+  static raretes() { return RARETES; }
+
+  static byCode(code = undefined) {
+    return RARETES.find(it => it.code == code) ?? RARETE_FREQUENTE;
+  }
+
+  static getChamp(rarete, field = undefined) {
+    return RdDRaretes.byCode(rarete)[field ?? 'frequence'];
+  }
+
+}

module/item/rencontre.js

@@ -1,4 +1,5 @@
-import { EffetsRencontre } from "./effets-rencontres.js";
+import { EffetsRencontre } from "../tmr/effets-rencontres.js";
+import { RdDItem } from "../item.js";
 
 const tableEffets = [
   { code: "messager", resultat: "succes", description: "Envoie un message à (force) cases", method: EffetsRencontre.messager },
@@ -36,7 +37,11 @@ const tableEffets = [
   // { code: "epart-souffle", resultat: "echec", description: "Souffle de dragon sur échec particulier" },
 ];
 
-export class RdDRencontre {
+export class RdDRencontre extends RdDItem {
+
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/tete_dragon.webp";
+  }
 
   static getEffetsSucces() { return RdDRencontre.getEffets("succes"); }
   static getEffetsEchec() { return RdDRencontre.getEffets("echec"); }
@@ -68,4 +73,8 @@ export class RdDRencontre {
     }
   }
 
+  async calculerFinPeriodeTemporel(debut) {
+    return await debut.nouvelleHeure().addHeures(12);
+  }
+
 }

module/item/service.js

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

module/item/sheet-base-inventaire.js

@@ -0,0 +1,120 @@
+import { HtmlUtility } from "../html-utility.js";
+import { RdDItemSheet } from "../item-sheet.js";
+import { Misc } from "../misc.js";
+import { RdDRaretes } from "./raretes.js";
+
+const TYPE_ITEMS_NATURELS = ["faune", "herbe", "plante", "ingredient"];
+
+export class RdDItemInventaireSheet extends RdDItemSheet {
+
+  static get defaultOptions() {
+    return mergeObject(RdDItemSheet.defaultOptions, {
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "informations" }]
+    });
+  }
+
+  setPosition(options = {}) {
+    const position = super.setPosition(options);
+    const sheetHeader = this.element.find(".sheet-header");
+    const sheetBody = this.element.find(".sheet-body");
+    sheetBody.css("height", position.height - sheetHeader[0].clientHeight)
+    return position;
+  }
+
+  async getData() {
+    const formData = await super.getData();
+    return mergeObject(formData, {
+      milieux: await game.system.rdd.environnement.autresMilieux(this.item)
+    });
+  }
+
+  activateListeners(html) {
+    super.activateListeners(html);
+    HtmlUtility.showControlWhen(this.html.find("div.description-milieu"), TYPE_ITEMS_NATURELS.includes(this.item.type));
+
+    if (!this.options.editable) return;
+    this.html.find("a.preparer-nourriture").click(event => this.preparerNourriture(event));
+    this.html.find("a.manger-nourriture").click(event => this.mangerNourriture(event));
+
+    this.html.find("input.input-selection-milieu").keypress(event => {
+      if (event.keyCode == '13') {
+        this.onAddMilieu(event);
+      }
+      event.stopPropagation();
+    })
+    this.html.find("a.milieu-add").click(event => this.onAddMilieu(event));
+    this.html.find("div.environnement-milieu a.milieu-delete").click(event => this.onDeleteMilieu(event));
+    this.html.find("div.environnement-milieu select.environnement-rarete").change(event => this.onChange(event,
+      updated => this.$changeRarete(event, updated)));
+    this.html.find("div.environnement-milieu input[name='environnement-frequence']").change(event => this.onChange(event,
+      updated => this.$changeFrequence(event, updated)));
+
+
+  }
+
+  async preparerNourriture(event) {
+    if (this.actor && this.item.getUtilisationCuisine() == 'brut') {
+      await this.actor.preparerNourriture(this.item);
+    }
+  }
+
+  async mangerNourriture(event) {
+    if (this.actor && this.item.getUtilisation() == 'cuisine') {
+      await this.actor.mangerNourriture(this.item);
+    }
+  }
+
+  $changeFrequence(event, updated) {
+    updated.frequence = Number(this.html.find(event.currentTarget).val());
+  }
+
+  $changeRarete(event, updated) {
+    const code = this.html.find(event.currentTarget).val();
+    const rarete = RdDRaretes.byCode(code);
+    updated.rarete = rarete.code;
+    updated.frequence = rarete.frequence;
+  }
+
+  async onAddMilieu(event) {
+    const milieu = this.html.find('input.input-selection-milieu').val();
+    if (!milieu) {
+      ui.notifications.warn(`Choisissez le milieu dans lequel se trouve le/la ${this.item.name}`);
+      return
+    }
+    const list = this.item.getEnvironnements();
+    const exists = list.find(it => it.milieu == milieu);
+    if (exists) {
+      ui.notifications.warn(`${this.item.name} a déjà une rareté ${exists.rarete} en ${milieu} (fréquence: ${exists.frequence})`);
+      return
+    }
+    const rarete = RdDRaretes.rareteFrequente();
+    const added = { milieu, rarete: rarete.code, frequence: rarete.frequence };
+    const newList = [added, ...list].sort(Misc.ascending(it => it.milieu))
+    await this.item.update({ 'system.environnement': newList })
+  }
+
+  async onDeleteMilieu(event) {
+    const milieu = this.$getEventMilieu(event);
+    if (milieu != undefined) {
+      const newList = this.item.getEnvironnements().filter(it => it.milieu != milieu)
+        .sort(Misc.ascending(it => it.milieu));
+      await this.item.update({ 'system.environnement': newList });
+    }
+  }
+
+  async onChange(event, doMutation) {
+    const list = this.item.system.environnement;
+    const milieu = this.$getEventMilieu(event);
+    const updated = list.find(it => it.milieu == milieu);
+    if (updated) {
+      doMutation(updated);
+      const newList = [...list.filter(it => it.milieu != milieu), updated]
+        .sort(Misc.ascending(it => it.milieu));
+      await this.item.update({ 'system.environnement': newList });
+    }
+  }
+
+  $getEventMilieu(event) {
+    return this.html.find(event.currentTarget)?.parents("div.environnement-milieu").data("milieu");
+  }
+}

module/item/sheet-blessure.js

@@ -0,0 +1,29 @@
+import { RdDItemSheet } from "../item-sheet.js";
+
+export class RdDBlessureItemSheet extends RdDItemSheet {
+
+  static get ITEM_TYPE() { return "blessure" };
+
+  async getData() {
+    const formData = await super.getData();
+    formData.disabled = formData.options.isGM || formData.options.isOwned ? '' : 'disabled';
+    return formData;
+  }
+
+  activateListeners(html) {
+    super.activateListeners(html);
+
+    if (!this.options.editable) return;
+
+    this.html.find('[name="premierssoins-done"]').change(async event => {
+      await this.item.setSoinsBlessure({ premierssoins: { done: event.currentTarget.checked } });
+    });
+    this.html.find('[name="soinscomplets-done"]').change(async event => {
+      await this.item.setSoinsBlessure({ soinscomplets: { done: event.currentTarget.checked } })
+    });
+    this.html.find('[name="system-gravite"]').change(async event => {
+      const gravite = Number(event.currentTarget.value)
+      await this.item.setSoinsBlessure({ gravite: gravite, difficulte: - gravite })
+    });
+  }
+}

module/item/sheet-conteneur.js

@@ -0,0 +1,62 @@
+import { RdDBaseActorSheet } from "../actor/base-actor-sheet.js";
+import { RdDSheetUtility } from "../rdd-sheet-utility.js";
+import { RdDUtility } from "../rdd-utility.js";
+import { RdDItemInventaireSheet } from "./sheet-base-inventaire.js";
+
+export class RdDConteneurItemSheet extends RdDItemInventaireSheet {
+
+  static get ITEM_TYPE() { return "conteneur" };
+
+  async getData() {
+    const formData = await super.getData();
+    if (this.actor) {
+      this.prepareConteneurData(formData);
+    }
+    return formData;
+  }
+
+  activateListeners(html) {
+    super.activateListeners(html);
+
+    if (!this.options.editable) return;
+
+    this.html.find('.conteneur-name a').click(async event => {
+      RdDUtility.toggleAfficheContenu(RdDSheetUtility.getItemId(event));
+      this.render(true);
+    });
+  }
+
+  /* -------------------------------------------- */
+  prepareConteneurData(formData) {
+    RdDBaseActorSheet.filterItemsPerTypeForSheet(formData, this.actor.itemTypes);
+    this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.inventaires);
+    formData.subItems = formData.conteneurs.find(it => it._id == this.item.id)?.subItems;
+  }
+
+  async _onDragStart(event) {
+    console.log("_onDragStart", event);
+    if (event.target.classList.contains("entity-link")) return;
+
+    const itemId = event.srcElement?.attributes["data-item-id"].value;
+    const item = this.actor.items.get(itemId);
+    // Create drag data
+    const dragData = {
+      actorId: this.actor.id,
+      type: "Item",
+      data: item.system,
+      uuid: item.uuid
+    };
+
+    event.dataTransfer.setData("text/plain", JSON.stringify(dragData));
+  }
+
+  async _onDropItem(event, dragData) {
+    if (this.actor) {
+      const destItemId = this.html.find(event.target)?.closest('.item').attr('data-item-id') ?? this.item.id
+      const dropParams = await RdDSheetUtility.prepareItemDropParameters(destItemId, this.actor, dragData, this.objetVersConteneur);
+      await this.actor.processDropItem(dropParams);
+      await this.render(true);
+    }
+  }
+
+}

module/item/sheet-faune.js

@@ -0,0 +1,38 @@
+import { RdDItemInventaireSheet } from "./sheet-base-inventaire.js";
+
+export class RdDFauneItemSheet extends RdDItemInventaireSheet {
+
+  static get ITEM_TYPE() { return "faune" };
+
+  activateListeners(html) {
+    super.activateListeners(html);
+
+    if (!this.options.editable) return;
+
+    html.find("a.linked-actor-delete").click(event => this.onDeleteLinkedActor());
+  }
+
+  async _onDropActor(event, dragData) {
+    console.log('faune:dropActor', event, dragData)
+    const linkedActor = fromUuidSync(dragData.uuid);
+    if (linkedActor?.pack) {
+      this.item.update({
+        'system.actor.pack': linkedActor.pack,
+        'system.actor.id': linkedActor._id,
+        'system.actor.name': linkedActor.name
+      });
+    }
+    else {
+      ui.notifications.warn(`${linkedActor.name} ne provient pas d'un compendium.
+        <br>Choisissez une créature du compendium pour représenter un élément de faune générique`)
+    }
+  }
+  async onDeleteLinkedActor() {
+    this.item.update({
+      'system.actor.pack': '',
+      'system.actor.id': '',
+      'system.actor.name': ''
+    });
+  }
+
+}

module/item/sheet-herbe.js

@@ -0,0 +1,6 @@
+import { RdDItemInventaireSheet } from "./sheet-base-inventaire.js";
+
+export class RdDHerbeItemSheet extends RdDItemInventaireSheet {
+
+  static get ITEM_TYPE() { return "herbe" };
+}

module/item/sheet-ingredient.js

@@ -0,0 +1,5 @@
+import { RdDItemInventaireSheet } from "./sheet-base-inventaire.js";
+
+export class RdDIngredientItemSheet extends RdDItemInventaireSheet {
+  static get ITEM_TYPE() { return "ingredient" };
+}

module/item/sheet-plante.js

@@ -0,0 +1,7 @@
+import { RdDItemInventaireSheet } from "./sheet-base-inventaire.js";
+
+export class RdDPlanteItemSheet extends RdDItemInventaireSheet {
+
+  static get ITEM_TYPE() { return "plante" };
+
+}

module/item/sheet-rencontre.js

@@ -1,29 +1,16 @@
-import { RdDRencontre } from "./item-rencontre.js";
+import { RdDRencontre } from "./rencontre.js";
+import { RdDItemSheet } from "../item-sheet.js";
 
-/**
+export class RdDRencontreItemSheet extends RdDItemSheet {
- * Item sheet pour configurer les rencontres
+  
- * @extends {ItemSheet}
+  static get ITEM_TYPE() { return "rencontre" };
- */
-export class RdDRencontreItemSheet extends ItemSheet {
 
-  /** @override */
   static get defaultOptions() {
     return mergeObject(super.defaultOptions, {
-      classes: ["rdd", "sheet", "item"],
-      template: "systems/foundryvtt-reve-de-dragon/templates/item-rencontre-sheet.html",
-      width: 500,
-      height: 500,
       tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }]
     });
   }
 
-  /* -------------------------------------------- */
-  _getHeaderButtons() {
-    let buttons = super._getHeaderButtons();
-    buttons.unshift({ class: "post", icon: "fas fa-comment", onclick: ev => this.item.postItem() });
-    return buttons;
-  }
-
   /* -------------------------------------------- */
   /** @override */
   setPosition(options = {}) {
@@ -34,18 +21,10 @@ export class RdDRencontreItemSheet extends ItemSheet {
     return position;
   }
 
-
   /* -------------------------------------------- */
   async getData() {
-    const formData = duplicate(this.item);
+    const formData = await super.getData();
     mergeObject(formData, {
-      title: formData.name,
-      isGM: game.user.isGM,
-      owner: this.actor?.isOwner,
-      isOwned: this.actor ? true : false,
-      actorId: this.actor?.id,
-      editable: this.isEditable,
-      cssClass: this.isEditable ? "editable" : "locked",
       effets: {
         succes: {
           liste: RdDRencontre.getEffetsSucces(),
@@ -65,15 +44,15 @@ export class RdDRencontreItemSheet extends ItemSheet {
   activateListeners(html) {
     super.activateListeners(html);
     if (!this.options.editable) return;
-    html.find("a.effet-add").click(event => this.onAddEffet(event));
+    this.html.find("a.effet-add").click(event => this.onAddEffet(event));
-    html.find("a.effet-delete").click(event => this.onDeleteEffet(event));
+    this.html.find("a.effet-delete").click(event => this.onDeleteEffet(event));
   }
 
   async onAddEffet(event) {
-    const resultat = $(event.currentTarget)?.data("effet-resultat");
+    const resultat = this.html.find(event.currentTarget)?.data("effet-resultat");
     const keyEffets = `system.${resultat}.effets`;
 
-    const code = $(event.currentTarget)?.data("effet-code");
+    const code = this.html.find(event.currentTarget)?.data("effet-code");
     const liste = RdDRencontre.getListeEffets(this.item, resultat);
     liste.push(code);
 
@@ -81,10 +60,10 @@ export class RdDRencontreItemSheet extends ItemSheet {
   }
 
   async onDeleteEffet(event) {
-    const resultat = $(event.currentTarget)?.data("effet-resultat");
+    const resultat = this.html.find(event.currentTarget)?.data("effet-resultat");
     const keyEffets = `system.${resultat}.effets`;
     
-    const pos = $(event.currentTarget)?.data("effet-pos");
+    const pos = this.html.find(event.currentTarget)?.data("effet-pos");
     const liste = RdDRencontre.getListeEffets(this.item, resultat);
     liste.splice(pos, 1);
     
@@ -96,13 +75,4 @@ export class RdDRencontreItemSheet extends ItemSheet {
     updates[key] = liste;
     this.item.update(updates);
   }
-
-  get template() {
-  /* -------------------------------------------- */
-    return `systems/foundryvtt-reve-de-dragon/templates/item-rencontre-sheet.html`;
-  }
-
-  get title() {
-    return `Rencontre: ${this.object.name}`;
-  }
 }

module/item/sheet-service.js

@@ -0,0 +1,16 @@
+import { RdDItemSheet } from "../item-sheet.js";
+
+export class RdDServiceItemSheet extends RdDItemSheet {
+
+  static get ITEM_TYPE() { return "service" };
+
+  async getData() {
+    const formData = await super.getData();
+    formData.disabled = formData.options.isGM || formData.options.isOwned ? '' : 'disabled';
+    return formData;
+  }
+
+  activateListeners(html) {
+    super.activateListeners(html);
+  }
+}

module/item/sheet-signedraconique.js

@@ -1,29 +1,14 @@
-import { SYSTEM_RDD } from "./constants.js";
+import { RdDItemSheet } from "../item-sheet.js";
-import { RdDItemSigneDraconique } from "./item-signedraconique.js";
+import { RdDItemSigneDraconique } from "./signedraconique.js";
-import { TMRUtility } from "./tmr-utility.js";
+import { TMRUtility } from "../tmr-utility.js";
 
 /**
  * Item sheet pour signes draconiques
- * @extends {ItemSheet}
+ * @extends {RdDItemSheet}
  */
-export class RdDSigneDraconiqueItemSheet extends ItemSheet {
+export class RdDSigneDraconiqueItemSheet extends RdDItemSheet {
 
-  /** @override */
+  static get ITEM_TYPE() { return "signedraconique" }
-  static get defaultOptions() {
-    return mergeObject(super.defaultOptions, {
-      classes: [SYSTEM_RDD, "sheet", "item"],
-      template: "systems/foundryvtt-reve-de-dragon/templates/item-signedraconique-sheet.html",
-      width: 550,
-      height: 550
-    });
-  }
-
-  /* -------------------------------------------- */
-  _getHeaderButtons() {
-    let buttons = super._getHeaderButtons();
-    buttons.unshift({ class: "post", icon: "fas fa-comment", onclick: ev => this.item.postItem() });
-    return buttons;
-  }
 
   /* -------------------------------------------- */
   /** @override */
@@ -38,18 +23,9 @@ export class RdDSigneDraconiqueItemSheet extends ItemSheet {
 
   /* -------------------------------------------- */
   async getData() {
-    const formData = duplicate(this.item);
+    const formData = await super.getData();
     this.tmrs = TMRUtility.buildSelectionTypesTMR(this.item.system.typesTMR);
-    mergeObject(formData, {
+    formData.tmrs = this.tmrs;
-      tmrs: this.tmrs,
-      title: formData.name,
-      isGM: game.user.isGM,
-      owner: this.actor?.isOwner,
-      isOwned: this.actor ? true : false,
-      actorId: this.actor?.id,
-      editable: this.isEditable,
-      cssClass: this.isEditable ? "editable" : "locked",
-    });
     return formData;
   }
 
@@ -61,12 +37,13 @@ export class RdDSigneDraconiqueItemSheet extends ItemSheet {
     if (!this.options.editable) return;
 
     html.find(".signe-aleatoire").click(event => this.setSigneAleatoire());
-    html.find("input.select-tmr").change((event) => this.onSelectTmr(event));
+    html.find("input.select-tmr").change(event => this.onSelectTmr(event));
-    html.find(".signe-xp-sort").change((event) => this.onValeurXpSort(event.currentTarget.attributes['data-typereussite']?.value, Number(event.currentTarget.value)));
+    html.find(".signe-xp-sort").change(event => this.onValeurXpSort(event.currentTarget.attributes['data-typereussite']?.value, Number(event.currentTarget.value)));
   }
 
   async setSigneAleatoire() {
     const newSigne = await RdDItemSigneDraconique.randomSigneDraconique();
+    newSigne.name = this.item.name;
     this.item.update(newSigne);
   }
 
@@ -88,12 +65,4 @@ export class RdDSigneDraconiqueItemSheet extends ItemSheet {
     await this.item.update({ 'system.valeur': newValeur });
   }
 
-  /* -------------------------------------------- */
-  get template() {
-    return `systems/foundryvtt-reve-de-dragon/templates/item-signedraconique-sheet.html`;
-  }
-
-  get title() {
-    return `Signe draconique: ${this.object.name}`;
-  }
 }

module/item/signedraconique.js

@@ -1,8 +1,9 @@
-import { defaultItemImg } from "./item.js";
+import { RdDItem, defaultItemImg } from "../item.js";
-import { Misc } from "./misc.js";
+import { Misc } from "../misc.js";
-import { RdDDice } from "./rdd-dice.js";
+import { RdDDice } from "../rdd-dice.js";
-import { RdDRollTables } from "./rdd-rolltables.js";
+import { RdDRollTables } from "../rdd-rolltables.js";
-import { TMRType, TMRUtility } from "./tmr-utility.js";
+import { RdDTimestamp } from "../time/rdd-timestamp.js";
+import { TMRType, TMRUtility } from "../tmr-utility.js";
 
 const tableSignesIndicatifs = [
   { rarete: "Très facile", difficulte: 0, xp: 6, nbCases: 14 },
@@ -15,7 +16,17 @@ const tableSignesIndicatifs = [
 
 const DIFFICULTE_LECTURE_SIGNE_MANQUE = +11;
 
-export class RdDItemSigneDraconique {
+export class RdDItemSigneDraconique extends RdDItem {
+
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/tmr/signe_draconique.webp";
+  }
+
+  
+  async calculerFinPeriodeTemporel(debut) {
+    // TODO
+    return RdDTimestamp.formulesDuree().find(it => it.code == "").calcul(debut, this.actor);
+  }
 
   static prepareSigneDraconiqueMeditation(meditation, rolled) {
     return {

module/item/souffle.js

@@ -0,0 +1,13 @@
+import { RdDItem } from "../item.js";
+
+export class RdDItemSouffle extends RdDItem {
+
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/souffle_dragon.webp";
+  }
+
+  async calculerFinPeriodeTemporel(debut) {
+    return await debut.appliquerDuree(this.system.duree, this.parent);
+  }
+
+}