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
-todo.txt
+.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,45 +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",
-    "TypeRencontrestmr": "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",
+    "TypeSortreserve": "Sort en réserve",
     "TypeSouffle": "Souffle de Dragon",
-    "TypeTete": "Tête de Dragon",
+    "TypeTache": "Tâche",
-    "TypePossession": "Possession"
+    "TypeTarot": "Carte de tarot",
+    "TypeTete": "Tête de Dragon"
   },
   "EFFECT": {
     "StatusStunned": "Sonné",

module/actor-creature-sheet.js

@@ -1,15 +1,9 @@
+import { RdDActorSheet } from "./actor-sheet.js";
 
 /**
  * Extend the basic ActorSheet with some very simple modifications
  * @extends {ActorSheet}
  */
-
-import { HtmlUtility } from "./html-utility.js";
-import { RdDUtility } from "./rdd-utility.js";
-import { RdDActorSheet } from "./actor-sheet.js";
-import { RdDCarac } from "./rdd-carac.js";
-
-/* -------------------------------------------- */
 export class RdDActorCreatureSheet extends RdDActorSheet {
 
   /** @override */
@@ -20,60 +14,30 @@ export class RdDActorCreatureSheet extends RdDActorSheet {
       width: 640,
       height: 720,
       tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }],
-      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }]
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }]
     });
   }
 
-
-  /* -------------------------------------------- */
-  async getData() {
-    let formData = await super.getData()
-    //console.log("Creature : ", formData, formData.system)
-    formData.calc = {
-      caracTotal: RdDCarac.computeTotal(formData.data.carac),
-      resumeBlessures: this.actor.computeResumeBlessure(formData.data.blessures),
-      encTotal: await this.actor.computeEncombrementTotalEtMalusArmure(),
-      surEncombrementMessage: this.actor.getMessageSurEncombrement()
-    }
-
-    RdDUtility.filterItemsPerTypeForSheet(formData);
-    this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.objets);
-    formData.conteneurs = RdDUtility.conteneursRacine(formData.conteneurs);
-
-    console.log("Creature : ", this.objetVersConteneur, formData);
-
-    return formData;
-  }
-
   /* -------------------------------------------- */
   /** @override */
   activateListeners(html) {
     super.activateListeners(html);
 
-    HtmlUtility._showControlWhen($(".gm-only"), game.user.isGM);
-
     // Everything below here is only needed if the sheet is editable
     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,146 +1,65 @@
-/**
+import { RdDActorSheet } from "./actor-sheet.js";
- * Extend the basic ActorSheet with some very simple modifications
+import { RdDSheetUtility } from "./rdd-sheet-utility.js";
- * @extends {ActorSheet}
- */
-
-import { HtmlUtility } from "./html-utility.js";
-import { Misc } from "./misc.js";
 import { RdDUtility } from "./rdd-utility.js";
 
-/* -------------------------------------------- */  
+export class RdDActorEntiteSheet extends RdDActorSheet {
-export class RdDActorEntiteSheet extends ActorSheet {
 
   /** @override */
-	static get defaultOptions() {
+  static get defaultOptions() {
-	  return mergeObject(super.defaultOptions, {
+    return mergeObject(super.defaultOptions, {
-  	  classes: ["rdd", "sheet", "actor"],
+      classes: ["rdd", "sheet", "actor"],
-  	  template: "systems/foundryvtt-reve-de-dragon/templates/actor-entite-sheet.html",
+      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: null}]
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }]
     });
   }
-
-
-  /* -------------------------------------------- */
   async getData() {
-    const objectData = this.object;
+    let formData = await super.getData();
-    let formData = {
+    formData.resonances = this.actor.system.sante.resonnance.actors.map(actorId => game.actors.get(actorId))
-      title: this.title,
+      .map(actor => { return { id: actor.id, name: actor.name, img: actor.img } })
-      id: objectData.id,
+    return formData
-      type: objectData.type,
-      img: objectData.img,
-      name: objectData.name,
-      //   actor: this.object,
-      editable: this.isEditable,
-      cssClass: this.isEditable ? "editable" : "locked",
-      data: foundry.utils.deepClone(this.actor.system),
-      effects: this.object.effects.map(e => foundry.utils.deepClone(e)),
-      //   items: items,
-      limited: this.object.limited,
-      options: this.options,
-      owner: this.document.isOwner,
-      itemsByType: Misc.classify(this.object.items.map(i => foundry.utils.deepClone(i))),
-    };
-    
-    formData.options.isGM = game.user.isGM;
-    RdDUtility.filterItemsPerTypeForSheet(formData);
-
-
-    return formData;
   }
-  
+
   /* -------------------------------------------- */
   /** @override */
-	activateListeners(html) {
+  activateListeners(html) {
     super.activateListeners(html);
 
-    HtmlUtility._showControlWhen($(".gm-only"), game.user.isGM);
-
     // Everything below here is only needed if the sheet is editable
     if (!this.options.editable) return;
 
-    // Update Inventory Item
-    html.find('.item-edit').click(event => {
-      const li = $(event.currentTarget).parents(".item");
-      const item = this.actor.getEmbeddedDocument('Item', li.data("itemId"));
-      item.sheet.render(true);
-    });
-
-    // Delete Inventory Item
-    html.find('.item-delete').click(event => {
-      const li = $(event.currentTarget).parents(".item");
-      this.actor.deleteEmbeddedDocuments('Item', [li.data("itemId")]);
-      li.slideUp(200, () => this.render(false));
-    });
-
-    // Roll Carac
-    html.find('.carac-label a').click(async event => {
-      let caracName = event.currentTarget.attributes.name.value;
-      this.actor.rollCarac( caracName.toLowerCase() );
-    });
-    
     // 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;
+      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 => {
-        let compName = event.currentTarget.attributes.compname.value;
-        this.actor.updateCreatureCompetence( compName, "niveau", parseInt(event.target.value) );
-      } );    
-      html.find('.creature-dommages').change(async event => {
-        let compName = event.currentTarget.attributes.compname.value;
-        this.actor.updateCreatureCompetence( compName, "dommages", parseInt(event.target.value) );
-      } );    
-  
-    // Roll Skill
-    html.find('.competence-label a').click(async event => {
-      let compName = event.currentTarget.text;
-      this.actor.rollCompetence( compName );
     });
-
+    this.html.find('.creature-niveau').change(async event => {
-    html.find('.endurance-plus').click(event => {
+      let compName = event.currentTarget.attributes.compname.value;
-      this.actor.santeIncDec("endurance", 1);
+      this.actor.updateCreatureCompetence(compName, "niveau", parseInt(event.target.value));
-      this.render(true);
     });
-    html.find('.endurance-moins').click(event => {
+    this.html.find('.creature-dommages').change(async event => {
-      this.actor.santeIncDec("endurance", -1);
+      let compName = event.currentTarget.attributes.compname.value;
-      this.render(true);
+      this.actor.updateCreatureCompetence(compName, "dommages", parseInt(event.target.value));
     });
-
+    this.html.find('.resonance-delete').click(async event => {
-    html.find('.encaisser-direct').click(event => {
+      const li = RdDSheetUtility.getEventElement(event);
-      this.actor.encaisser();
+      const actorId = li.data("actor-id");
-    });
+      if (actorId) {
-
+        const actorResonance = game.actors.get(actorId);
-    html.find('.remise-a-neuf').click(event => {
+        RdDUtility.confirmerSuppressionSubacteur(this, actorResonance, li, () => {
-      if (game.user.isGM) {
+          console.log('Delete : ', actorId);
-        this.actor.remiseANeuf();
+          this.removeSubacteur(actorId);
+          RdDUtility.slideOnDelete(this, li);
+        });
       }
     });
   }
-  
 
-  /* -------------------------------------------- */
+  async removeSubacteur(actorId) {
-
+    let newResonances = this.actor.system.sante.resonnance.actors.filter(id => id != actorId);
-  /** @override */
+    await this.actor.update({ 'system.sante.resonnance.actors': newResonances }, { renderSheet: false });
-  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");
-    const bodyHeight = position.height - sheetHeader[0].clientHeight - sheetTabs[0].clientHeight;
-    sheetBody.css("height", bodyHeight);
-    return position;
   }
 
-
-  /* -------------------------------------------- */
-
-  /** @override */
-  _updateObject(event, formData) {
-    // Update the Actor
-    return this.object.update(formData);
-  }
 }

module/actor-sheet.js

@@ -1,8 +1,3 @@
-/**
- * Extend the basic ActorSheet with some very simple modifications
- * @extends {ActorSheet}
- */
-
 import { RdDUtility } from "./rdd-utility.js";
 import { HtmlUtility } from "./html-utility.js";
 import { RdDItemArme } from "./item-arme.js";
@@ -12,12 +7,21 @@ import { Misc } from "./misc.js";
 import { RdDCombatManager } from "./rdd-combat.js";
 import { RdDCarac } from "./rdd-carac.js";
 import { DialogSplitItem } from "./dialog-split-item.js";
-import { ReglesOptionelles } from "./regles-optionelles.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";
 
 /* -------------------------------------------- */
-export class RdDActorSheet extends ActorSheet {
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+export class RdDActorSheet extends RdDBaseActorSheet {
 
   /** @override */
   static get defaultOptions() {
@@ -25,10 +29,9 @@ export class RdDActorSheet extends ActorSheet {
     return mergeObject(super.defaultOptions, {
       classes: ["rdd", "sheet", "actor"],
       template: "systems/foundryvtt-reve-de-dragon/templates/actor-sheet.html",
-      width: 640,
+      width: 550,
       tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }],
-      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }],
-      editCaracComp: false,
       showCompNiveauBase: false,
       vueDetaillee: false
     });
@@ -36,275 +39,214 @@ export class RdDActorSheet extends ActorSheet {
 
   /* -------------------------------------------- */
   async getData() {
-    const objectData = this.object.system
+    let formData = await super.getData();
-    this.timerRecherche = undefined;
+    mergeObject(formData,
-    
+      {
-    console.log("New actor", objectData)
+        editable: this.isEditable,
-    let formData = {
+        cssClass: this.isEditable ? "editable" : "locked",
-      title: this.title,
+        effects: this.actor.effects.map(e => foundry.utils.deepClone(e)),
-      id: this.object.id,
+        limited: this.actor.limited,
-      type: this.object.type,
+        owner: this.actor.isOwner,
-      img: this.object.img,
+        biographie: await TextEditor.enrichHTML(this.actor.system.biographie, { async: true }),
-      name: this.object.name,
+        notes: await TextEditor.enrichHTML(this.actor.system.notes, { async: true }),
-      editable: this.isEditable,
+      });
-      cssClass: this.isEditable ? "editable" : "locked",
+    mergeObject(formData.calc, {
-      data: foundry.utils.deepClone(this.actor.system),
+      surenc: this.actor.computeMalusSurEncombrement(),
-      effects: this.object.effects.map(e => foundry.utils.deepClone(e)),
-      limited: this.object.limited,
-      options: this.options,
-      owner: this.document.isOwner,
-      itemsByType: Misc.classify(this.object.items.map(i => foundry.utils.deepClone(i))),
-    }
-    RdDUtility.filterItemsPerTypeForSheet(formData)
-  
-    formData.options.isGM = game.user.isGM;
-
-    if (formData.type == 'creature') return formData; // Shortcut
-
-    formData.competenceByCategory = Misc.classify(formData.competences, it => it.system.categorie)
-
-    formData.calc = {
-      comptageArchetype: RdDItemCompetence.computeResumeArchetype(formData.competences),
-      competenceXPTotal: RdDItemCompetence.computeTotalXP(formData.competences),
-      caracTotal: RdDCarac.computeTotal(formData.data.carac, formData.data.beaute),
-      // Mise à jour de l'encombrement total et du prix de l'équipement
-      encTotal: await this.actor.computeEncombrementTotalEtMalusArmure(),
-      prixTotalEquipement: this.actor.computePrixTotalEquipement(),
       surprise: RdDBonus.find(this.actor.getSurprise(false)).descr,
-      fatigue: RdDUtility.calculFatigueHtml(formData.data.sante.fatigue.value, formData.data.sante.endurance.max),
+      resumeBlessures: this.actor.computeResumeBlessure(this.actor.system.blessures),
-      resumeBlessures: this.actor.computeResumeBlessure(formData.data.blessures),
+      caracTotal: RdDCarac.computeTotal(this.actor.system.carac, this.actor.system.beaute),
-      surEncombrementMessage: this.actor.getMessageSurEncombrement()
+      surEncombrementMessage: this.actor.getMessageSurEncombrement(),
-    };
+    })
 
-    formData.competences.forEach(item => {
+    this.timerRecherche = undefined;
-      item.visible = this.options.recherche
-        ? RdDItemCompetence.nomContientTexte(item, this.options.recherche.text)
-        : (!this.options.showCompNiveauBase || !RdDItemCompetence.isNiveauBase(item));
-      RdDItemCompetence.levelUp(item, formData.data.compteurs.experience.value);
-    });
 
-    Object.values(formData.data.carac).forEach(c => {
+    if (formData.type == 'personnage') {
-      RdDCarac.levelUp(c);
+      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.fatigue = RdDUtility.calculFatigueHtml(formData.system.sante.fatigue.value, formData.system.sante.endurance.max);
 
+      formData.competences.forEach(item => {
+        item.system.isHidden = this.options.recherche
+          ? !item.isNomLike(this.options.recherche.text)
+          : (this.options.showCompNiveauBase && RdDItemCompetence.isNiveauBase(item));
+        RdDItemCompetence.levelUp(item, formData.system.compteurs.experience.value);
+      });
 
-    // toujours avoir une liste d'armes (pour mettre esquive et corps à corps)
+      Object.values(formData.system.carac).forEach(c => {
-    formData.combat = duplicate(formData.armes ?? []);
+        RdDCarac.levelUp(c);
-    RdDItemArme.computeNiveauArmes(formData.combat, formData.competences);
+      });
-    RdDItemArme.ajoutCorpsACorps(formData.combat, formData.competences, formData.data.carac);
-    formData.esquives = this.actor.getCompetences("Esquive").map(i => foundry.utils.deepClone(i.system));
-    formData.combat = RdDCombatManager.listActionsArmes(formData.combat, formData.competences, formData.data.carac);
 
-    this.armesList = formData.combat;
+      // toujours avoir une liste d'armes (pour mettre esquive et corps à corps)
+      formData.combat = duplicate(formData.armes ?? []);
+      RdDItemArme.computeNiveauArmes(formData.combat, formData.competences);
+      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();
 
-    // Common data
+      this.armesList = formData.combat;
-    formData.ajustementsConditions = CONFIG.RDD.ajustementsConditions;
-    formData.difficultesLibres = CONFIG.RDD.difficultesLibres;
 
-    formData.hautreve = {
+      // Common data
-      isDemiReve: this.actor.getEffectByLabel("Demi-rêve"),
+      formData.ajustementsConditions = CONFIG.RDD.ajustementsConditions;
-      sortsReserve: formData.data.reve.reserve.list,
+      formData.difficultesLibres = CONFIG.RDD.difficultesLibres;
-      rencontres: duplicate(formData.data.reve.rencontre.list),
-      casesTmr: formData.itemsByType.casetmr,
-      cacheTMR: this.actor.isTMRCache()
-    }
 
-    this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.objets);
+      formData.hautreve = {
-    formData.conteneurs = RdDUtility.conteneursRacine(formData.conteneurs);
+        isDemiReve: this.actor.getEffect(STATUSES.StatusDemiReve),
+        cacheTMR: this.actor.isTMRCache()
+      }
 
-    formData.subacteurs = {
+      formData.subacteurs = {
-      vehicules: this.actor.listeVehicules(),
+        vehicules: this.actor.listeVehicules(),
-      montures: this.actor.listeMontures(),
+        montures: this.actor.listeMontures(),
-      suivants: this.actor.listeSuivants()
+        suivants: this.actor.listeSuivants()
-    }
+      }
-    if (this.actor.getBestDraconic().system.niveau > -11 && !this.actor.isHautRevant()) {
+      if (this.actor.getBestDraconic().system.niveau > -11 && !this.actor.isHautRevant()) {
-      ui.notifications.error(`${this.actor.name} a des compétences draconiques, mais pas le don de Haut-Rêve!
+        ui.notifications.error(`${this.actor.name} a des compétences draconiques, mais pas le don de Haut-Rêve!
-        <br>Ajoutez-lui la tête "Don de Haut-Rêve" pour lui permettre d'utiliser ses compétences et d'accéder aux terres médianes du rêve`);
+          <br>Ajoutez-lui la tête "Don de Haut-Rêve" pour lui permettre d'utiliser ses compétences et d'accéder aux terres médianes du rêve`);
+      }
     }
     return formData;
   }
 
-  isCompetenceAffichable(competence) {
-    return !this.options.showCompNiveauBase || !RdDItemCompetence.isNiveauBase(competence);
-  }
-
-  /* -------------------------------------------- */
-  async _onDropActor(event, dragData) {
-    console.log("_onDropActor", this.actor.id, dragData);
-    this.actor.addSubActeur(dragData.id || dragData.data._id);
-    super._onDropActor(event, dragData);
-  }
-
-  /* -------------------------------------------- */
-  async _onDropItem(event, dragData) {
-    const destItemId = $(event.target)?.closest('.item').attr('data-item-id')
-    const dropParams = RdDSheetUtility.prepareItemDropParameters(destItemId, this.actor.id, dragData, this.objetVersConteneur)
-    const callSuper = await this.actor.processDropItem(dropParams)
-    if (callSuper) {
-      await super._onDropItem(event, dragData)
-    }
-  }
-
-  /* -------------------------------------------- */
-  async createItem(name, type) {
-    await this.actor.createEmbeddedDocuments('Item', [{ name: name, type: type }], { renderSheet: true });
-  }
-
-  /* -------------------------------------------- */
-  async createEmptyTache() {
-    await this.createItem('Nouvelle tache', 'tache');
-  }
-
   /* -------------------------------------------- */  /** @override */
   activateListeners(html) {
     super.activateListeners(html);
 
-    HtmlUtility._showControlWhen($(".gm-only"), game.user.isGM);
+    HtmlUtility.showControlWhen(this.html.find(".appliquerFatigue"), ReglesOptionelles.isUsing("appliquer-fatigue"));
-    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 => {
+    this.html.find('.item-action').click(async event => {
       const item = RdDSheetUtility.getItem(event, this.actor);
-      RdDSheetUtility.splitItem(item, this.actor);
+      item?.actionPrincipale(this.actor, async () => this.render())
-    });
-    html.find('.item-edit').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor)
-      console.log("ITEM :", item)
-      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('.rencontre-delete').click(async event => {
-      this.actor.deleteTMRRencontre(RdDSheetUtility.getItemId(event));
-    });
-    html.find('.item-delete').click(async event => {
-      const li = RdDSheetUtility.getEventElement(event);
-      RdDUtility.confirmerSuppression(this, 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 => {
+    this.html.find('.subacteur-delete').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);
-      RdDUtility.confirmerSuppressionSubacteur(this, li);
+      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));
     });
 
-    html.find('.encaisser-direct').click(async event => {
+    this.html.find('.encaisser-direct').click(async event => {
       this.actor.encaisser();
     })
-    html.find('.sheet-possession-attack').click(async event => {
+    this.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 => {
+    this.html.find('.remise-a-neuf').click(async event => {
       if (game.user.isGM) {
         this.actor.remiseANeuf();
       }
     });
-    html.find('.creer-tache').click(async event => {
+    this.html.find('.creer-tache').click(async event => {
       this.createEmptyTache();
     });
-    html.find('.creer-un-objet').click(async event => {
+    this.html.find('.creer-tache-blessure-legere').click(async event => RdDItemBlessure.createTacheSoinBlessure(this.actor, 2));
-      RdDUtility.selectObjetType(this);
+    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));
-    html.find('.creer-une-oeuvre').click(async event => {
+    this.html.find('.creer-blessure-legere').click(async event => RdDItemBlessure.createBlessure(this.actor, 2));
-      RdDUtility.selectTypeOeuvre(this);
+    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));
-    html.find('#nettoyer-conteneurs').click(async event => {
+    this.html.find('.creer-une-oeuvre').click(async event => {
-      this.actor.nettoyerConteneurs();
+      this.selectTypeOeuvreToCreate();
     });
 
-    // Blessure control
+    this.html.find('.blessure-premierssoins-done').change(async event => {
-    html.find('.blessure-control').click(async event => {
+      const blessure = this.getBlessure(event);
-      const tr = $(event.currentTarget).parents(".item");
+      await blessure?.setSoinsBlessure({ premierssoins: { done: event.currentTarget.checked } });
-      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);
     });
-
+    this.html.find('.blessure-soinscomplets-done').change(async event => {
-    // Blessure data
+      const blessure = this.getBlessure(event);
-    html.find('.blessures-soins').change(async event => {
+      await blessure?.setSoinsBlessure({ soinscomplets: { done: event.currentTarget.checked } })
-      const tr = $(event.currentTarget).parents(".item");
+    });
-      let btype = tr.data('blessure-type');
+    this.html.find('.blessure-premierssoins-bonus').change(async event => {
-      let index = tr.data('blessure-index');
+      const blessure = this.getBlessure(event);
-      let psoins = tr.find('.blessure-premiers_soins').val();
+      await blessure?.setSoinsBlessure({ premierssoins: { bonus: Number(event.currentTarget.value) } })
-      let pcomplets = tr.find('.blessure-soins_complets').val();
+    });
-      let jours = tr.find('.blessure-jours').val();
+    this.html.find('.blessure-soinscomplets-bonus').change(async event => {
-      let loc = tr.find('.blessure-localisation').val();
+      const blessure = this.getBlessure(event);
-      let psdone = tr.find('.blessure-psdone:checked').val();
+      await blessure?.setSoinsBlessure({ soinscomplets: { bonus: Number(event.currentTarget.value) } })
-      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.html.find('.item-equip').click(async event => {
       this.actor.equiperObjet(RdDSheetUtility.getItemId(event));
     });
 
     // Roll Carac
-    html.find('.carac-label a').click(async event => {
+    this.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.html.find('.chance-actuelle').click(async event => {
       this.actor.rollCarac('chance-actuelle');
     });
 
-    html.find('.chance-appel').click(async event => {
+    this.html.find('.chance-appel').click(async event => {
       this.actor.rollAppelChance();
     });
 
-    html.find('#jet-astrologie').click(async event => {
+    this.html.find('[name="jet-astrologie"]').click(async event => {
       this.actor.astrologieNombresAstraux();
     });
 
     // Roll Skill
-    html.find('a.competence-label').click(async event => {
+    this.html.find('a.competence-label').click(async event => {
       this.actor.rollCompetence(RdDSheetUtility.getItemId(event));
     });
-    html.find('.tache-label a').click(async event => {
+    this.html.find('.tache-label a').click(async event => {
       this.actor.rollTache(RdDSheetUtility.getItemId(event));
     });
-    html.find('.meditation-label a').click(async event => {
+    this.html.find('.meditation-label a').click(async event => {
       this.actor.rollMeditation(RdDSheetUtility.getItemId(event));
     });
-    html.find('.chant-label a').click(async event => {
+    this.html.find('.chant-label a').click(async event => {
       this.actor.rollChant(RdDSheetUtility.getItemId(event));
     });
-    html.find('.danse-label a').click(async event => {
+    this.html.find('.danse-label a').click(async event => {
       this.actor.rollDanse(RdDSheetUtility.getItemId(event));
     });
-    html.find('.musique-label a').click(async event => {
+    this.html.find('.musique-label a').click(async event => {
       this.actor.rollMusique(RdDSheetUtility.getItemId(event));
     });
-    html.find('.oeuvre-label a').click(async event => {
+    this.html.find('.oeuvre-label a').click(async event => {
       this.actor.rollOeuvre(RdDSheetUtility.getItemId(event));
     });
-    html.find('.jeu-label a').click(async event => {
+    this.html.find('.jeu-label a').click(async event => {
       this.actor.rollJeu(RdDSheetUtility.getItemId(event));
     });
-    html.find('.recettecuisine-label a').click(async event => {
+    this.html.find('.recettecuisine-label a').click(async event => {
       this.actor.rollRecetteCuisine(RdDSheetUtility.getItemId(event));
     });
-    html.find('.subacteur-label a').click(async 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) {
@@ -313,26 +255,31 @@ export class RdDActorSheet extends ActorSheet {
     });
 
     // Boutons spéciaux MJs
-    html.find('.forcer-tmr-aleatoire').click(async event => {
+    this.html.find('.forcer-tmr-aleatoire').click(async event => {
       this.actor.reinsertionAleatoire("Action MJ");
     });
-    html.find('.afficher-tmr').click(async event => {
+    this.html.find('.afficher-tmr').click(async event => {
-      this.actor.afficheTMRetMessage();
+      this.actor.changeTMRVisible();
     });
 
     // Points de reve actuel
-    html.find('.ptreve-actuel a').click(async event => {
+    this.html.find('.ptreve-actuel a').click(async event => {
-      this.actor.rollCarac('reve-actuel');
+      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
-    html.find('.arme-label a').click(async event => {
+    this.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 => {
+    this.html.find('.arme-initiative a').click(async event => {
-      let combatant = game.combat.data.combatants.find(c => c.actor.data._id == this.actor.data._id);
+      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);
@@ -341,211 +288,201 @@ export class RdDActorSheet extends ActorSheet {
       }
     });
     // Display TMR, visualisation
-    html.find('.visu-tmr').click(async event => {
+    this.html.find('.visu-tmr').click(async event => {
       this.actor.displayTMR("visu");
     });
 
     // Display TMR, normal
-    html.find('.monte-tmr').click(async event => {
+    this.html.find('.monte-tmr').click(async event => {
       this.actor.displayTMR("normal");
     });
 
     // Display TMR, fast 
-    html.find('.monte-tmr-rapide').click(async event => {
+    this.html.find('.monte-tmr-rapide').click(async event => {
       this.actor.displayTMR("rapide");
     });
 
-    html.find('.repos').click(async event => {
+    this.html.find('.repos').click(async event => {
-      await DialogRepos.create(this.actor);
+      await this.actor.repos();
     });
-    html.find('.delete-active-effect').click(async event => {
+    this.html.find('.delete-active-effect').click(async event => {
-      let id = $(event.currentTarget).parents(".active-effect").data('id');
+      if (game.user.isGM) {
-      this.actor.enleverActiveEffectById(id);
+        let effect = this.html.find(event.currentTarget).parents(".active-effect").data('effect');
+        this.actor.removeEffect(effect);
+      }
     });
-    html.find('.enlever-tous-effets').click(async event => {
+    this.html.find('.enlever-tous-effets').click(async event => {
-      this.actor.enleverTousLesEffets();
+      if (game.user.isGM) {
+        await this.actor.removeEffects();
+      }
     });
-    html.find('.conteneur-name a').click(async event => {
+    this.html.find('.carac-xp-augmenter').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.html.find('.competence-xp-augmenter').click(async event => {
       this.actor.updateCompetenceXPAuto(RdDSheetUtility.getItemId(event));
     });
-    html.find('.competence-stress-augmenter').click(async event => {
+    this.html.find('.competence-stress-augmenter').click(async event => {
       this.actor.updateCompetenceStress(RdDSheetUtility.getItemId(event));
     });
 
-    if (this.options.editCaracComp) {
+    if (this.options.vueDetaillee) {
       // On carac change
-      html.find('.carac-value').change(async event => {
+      this.html.find('.carac-value').change(async event => {
         let caracName = event.currentTarget.name.replace(".value", "").replace("system.carac.", "");
-        //console.log("Value changed :", event, caracName);
         this.actor.updateCarac(caracName, parseInt(event.target.value));
       });
-      html.find('.carac-xp').change(async event => {
+      this.html.find('input.carac-xp').change(async event => {
         let caracName = event.currentTarget.name.replace(".xp", "").replace("system.carac.", "");
-        //console.log("Value changed :", event, caracName);
         this.actor.updateCaracXP(caracName, parseInt(event.target.value));
       });
       // On competence change
-      html.find('.competence-value').change(async event => {
+      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
-      html.find('.competence-xp').change(async event => {
+      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
-      html.find('.competence-xp-sort').change(async event => {
+      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
-      html.find('.competence-archetype').change(async event => {
+      this.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.html.find('.show-hide-competences').click(async event => {
       this.options.showCompNiveauBase = !this.options.showCompNiveauBase;
       this.render(true);
     });
-    html.find('.lock-unlock-sheet').click(async event => {
-      this.options.editCaracComp = !this.options.editCaracComp;
-      this.render(true);
-    });
 
-    html.find('.recherche')
+    this.html.find('.vue-detaillee').click(async event => {
-      .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 => {
+    this.html.find('.pointsreve-value').change(async event => {
       let reveValue = event.currentTarget.value;
-      this.actor.update({ "data.reve.reve.value": reveValue });
+      this.actor.update({ "system.reve.reve.value": reveValue });
     });
 
     // On seuil de reve change
-    html.find('.seuil-reve-value').change(async event => {
+    this.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 => {
+    this.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.html.find('.stress-test').click(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.html.find('.moral-malheureux').click(async event => {
       this.actor.jetDeMoral('malheureuse');
     });
-    html.find('.moral-neutre').click(async event => {
+    this.html.find('.moral-neutre').click(async event => {
       this.actor.jetDeMoral('neutre');
     });
-    html.find('.moral-heureux').click(async event => {
+    this.html.find('.moral-heureux').click(async event => {
       this.actor.jetDeMoral('heureuse');
     });
-    html.find('#ethylisme-test').click(async event => {
+    this.html.find('.ethylisme-test').click(async event => {
       this.actor.jetEthylisme();
     });
 
-    html.find('.jet-vie').click(async event => {
+    this.html.find('.jet-vie').click(async event => {
       this.actor.jetVie();
     });
-    html.find('.jet-endurance').click(async event => {
+    this.html.find('.jet-endurance').click(async event => {
       this.actor.jetEndurance();
     });
 
-    html.find('.monnaie-plus').click(async event => {
+    this.html.find('.vie-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.html.find('.vie-moins').click(async event => {
       this.actor.santeIncDec("vie", -1);
     });
-    html.find('.endurance-plus').click(async event => {
+    this.html.find('.endurance-plus').click(async event => {
       this.actor.santeIncDec("endurance", 1);
     });
-    html.find('.endurance-moins').click(async event => {
+    this.html.find('.endurance-moins').click(async event => {
       this.actor.santeIncDec("endurance", -1);
     });
-    html.find('.ptreve-actuel-plus').click(async event => {
+    this.html.find('.ptreve-actuel-plus').click(async event => {
       this.actor.reveActuelIncDec(1);
     });
-    html.find('.ptreve-actuel-moins').click(async event => {
+    this.html.find('.ptreve-actuel-moins').click(async event => {
       this.actor.reveActuelIncDec(-1);
     });
-    html.find('.fatigue-plus').click(async event => {
+    this.html.find('.fatigue-plus').click(async event => {
       this.actor.santeIncDec("fatigue", 1);
     });
-    html.find('.fatigue-moins').click(async event => {
+    this.html.find('.fatigue-moins').click(async event => {
       this.actor.santeIncDec("fatigue", -1);
     });
   }
 
-  _optionRecherche(target) {
+  getBlessure(event) {
-    if (!target.value?.length){
+    const itemId = this.html.find(event.currentTarget).parents(".item-blessure").data('item-id');
-      return undefined;
+    const blessure = this.actor.getItem(itemId, 'blessure');
+    return blessure;
+  }
+
+  isCompetenceAffichable(competence) {
+    return !this.options.showCompNiveauBase || !RdDItemCompetence.isNiveauBase(competence);
+  }
+
+  /* -------------------------------------------- */
+  async _onDropActor(event, dragData) {
+    const dropActor = fromUuidSync(dragData.uuid);
+    this.actor.addSubActeur(dropActor);
+    super._onDropActor(event, dragData);
+  }
+
+  /* -------------------------------------------- */
+  async selectTypeOeuvreToCreate() {
+    let types = RdDItem.getTypesOeuvres();
+    let content = `<span class="competence-label">Selectionnez le type d'oeuvre</span><select class="item-type">`;
+    for (let typeName of types) {
+      content += `<option value="${typeName}">${Misc.typeName('Item', typeName)}</option>`
     }
-    return {
+    content += '</select>';
-      text: target.value,
+    let dialog = new Dialog({
-      start: target.selectionStart,
+      title: "Créer une oeuvre",
-      end: target.selectionEnd,
+      content: content,
-    };
+      buttons: {
+        create: {
+          icon: '<i class="fas fa-check"></i>',
+          label: "Créer l'oeuvre",
+          callback: () => this.actor.createItem($(".item-type").val())
+        }
+      }
+    });
+    dialog.render(true);
+  }
+
+  /* -------------------------------------------- */
+  async createEmptyTache() {
+    await this.actor.createItem('tache', 'Nouvelle tache');
   }
 
   _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);
@@ -562,7 +499,10 @@ export class RdDActorSheet extends ActorSheet {
     const sheetHeader = this.element.find(".sheet-header");
     const sheetTabs = this.element.find(".sheet-tabs");
     const sheetBody = this.element.find(".sheet-body");
-    const bodyHeight = position.height - sheetHeader[0].clientHeight - sheetTabs[0].clientHeight;
+    let bodyHeight = position.height - sheetHeader[0].clientHeight;
+    if (sheetTabs.length > 0) {
+      bodyHeight -= sheetTabs[0].clientHeight;
+    }
     sheetBody.css("height", bodyHeight);
     return position;
   }
@@ -572,7 +512,7 @@ export class RdDActorSheet extends ActorSheet {
   /** @override */
   _updateObject(event, formData) {
     // Update the Actor
-    return this.object.update(formData);
+    return this.actor.update(formData);
   }
 
   async splitItem(item) {
@@ -581,11 +521,11 @@ export class RdDActorSheet extends ActorSheet {
   }
 
   async _onSplitItem(item, split) {
-    if (split >= 1 && split < Misc.data(item).data.quantite) {
+    if (split >= 1 && split < item.system.quantite) {
       await item.diminuerQuantite(split);
-      const itemData = duplicate(Misc.data(item));
+      const splitItem = duplicate(item);
-      itemData.data.quantite = split;
+      splitItem.system.quantite = split;
-      await this.actor.createEmbeddedDocuments('Item', [itemData])
+      await this.actor.createEmbeddedDocuments('Item', [splitItem])
     }
   }
 

module/actor-vehicule-sheet.js

@@ -1,15 +1,8 @@
-/**
- * Extend the basic ActorSheet with some very simple modifications
- * @extends {ActorSheet}
- */
-
 import { RdDUtility } from "./rdd-utility.js";
-import { HtmlUtility } from "./html-utility.js";
+import { RdDActorSheet } from "./actor-sheet.js";
-import { Misc } from "./misc.js";
-import { RdDSheetUtility } from "./rdd-sheet-utility.js";
 
 /* -------------------------------------------- */
-export class RdDActorVehiculeSheet extends ActorSheet {
+export class RdDActorVehiculeSheet extends RdDActorSheet {
 
   /** @override */
   static get defaultOptions() {
@@ -21,145 +14,26 @@ export class RdDActorVehiculeSheet extends ActorSheet {
       width: 640,
       height: 720,
       tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }],
-      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }]
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }]
     });
   }
 
-  /* -------------------------------------------- */
-  async getData() {
-    const objectData = this.object
-    let formData = {
-      title: this.title,
-      id: objectData.id,
-      type: objectData.type,
-      img: objectData.img,
-      name: objectData.name,
-      editable: this.isEditable,
-      cssClass: this.isEditable ? "editable" : "locked",
-      data: foundry.utils.deepClone(this.object.system),
-      effects: this.object.effects.map(e => foundry.utils.deepClone(e)),
-      limited: this.object.limited,
-      options: this.options,
-      owner: this.document.isOwner,
-      itemsByType: Misc.classify(this.object.items.map(i => foundry.utils.deepClone(i))),
-    };
-
-    RdDUtility.filterItemsPerTypeForSheet(formData);
-    this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.objets);
-    formData.conteneurs = RdDUtility.conteneursRacine(formData.conteneurs);
-
-    formData.options.isGM = game.user.isGM;
-
-    formData.calc = {
-      encTotal: await this.actor.computeEncombrementTotalEtMalusArmure(),
-      surEncombrementMessage: this.actor.getMessageSurEncombrement()
-    }
-
-    console.log("DATA", formData);
-
-    return formData;
-  }
-
-  async computeMalusArmure() {
-    // pas de malus armure
-  }
-  /* -------------------------------------------- */
-  async _onDropItem(event, dragData) {
-    const destItemId = $(event.target)?.closest('.item').attr('data-item-id');
-    const dropParams = RdDSheetUtility.prepareItemDropParameters(destItemId, this.actor.id, dragData, this.objetVersConteneur);
-    const callSuper = await this.actor.processDropItem(dropParams);
-    if (callSuper) {
-      await super._onDropItem(event, dragData)
-    }
-  }
-
-  /* -------------------------------------------- */
-  async createItem(name, type) {
-    await this.actor.createEmbeddedDocuments('Item', [{ name: name, type: type }], { renderSheet: true });
-  }
-
-  /* -------------------------------------------- */
-  async monnaieIncDec(id, value) {
-    let monnaie = this.getMonnaie(id);
-    if (monnaie) {
-      const quantite = Math.max(0, monnaie.system.quantite + value);
-      await this.updateEmbeddedDocuments('Item', [{ _id: monnaie.id, 'data.quantite': quantite }]);
-    }
-  }
-
-  /* -------------------------------------------- */
-  /** @override */
   activateListeners(html) {
     super.activateListeners(html);
-
-    HtmlUtility._showControlWhen($(".gm-only"), game.user.isGM);
-
-    // Everything below here is only needed if the sheet is editable
     if (!this.options.editable) return;
 
-    // Update Inventory Item
+    this.html.find('.resistance-moins').click(async event => {
-    html.find('.item-edit').click(async event => {
+      this.actor.vehicleIncDec("resistance", -1);
-      const item = RdDSheetUtility.getItem(event, this.actor);
-      item.sheet.render(true);
     });
-    // Delete Inventory Item
+    this.html.find('.resistance-plus').click(async event => {
-    html.find('.item-delete').click(async event => {
+      this.actor.vehicleIncDec("resistance", 1);
-      const li = RdDSheetUtility.getEventElement(event);
-      RdDUtility.confirmerSuppression(this, li);
     });
-    html.find('.item-vendre').click(async event => {
+    this.html.find('.structure-moins').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
+      this.actor.vehicleIncDec("structure", -1);
-      item?.proposerVente();
     });
-    html.find('.item-montrer').click(async event => {
+    this.html.find('.structure-plus').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
+      this.actor.vehicleIncDec("structure", 1);
-      item?.postItem();
     });
-
-    html.find('.item-action').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
-      this.actor.actionItem(item);
-    });
-
-    html.find('.creer-un-objet').click(async event => {
-      RdDUtility.selectObjetType(this);
-    });
-    html.find('#nettoyer-conteneurs').click(async event => {
-      this.actor.nettoyerConteneurs();
-    });
-
-    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);
-    });
-
-    // Display info about queue
-    html.find('.conteneur-name a').click((event) => {
-      RdDUtility.toggleAfficheContenu(RdDSheetUtility.getItemId(event));
-      this.render(true);
-    });
-
   }
 
-  /* -------------------------------------------- */
-  /** @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");
-    const bodyHeight = position.height - sheetHeader[0].clientHeight - sheetTabs[0].clientHeight;
-    sheetBody.css("height", bodyHeight);
-    return position;
-  }
-
-
-  /* -------------------------------------------- */
-  /** @override */
-  _updateObject(event, formData) {
-    // Update the Actor
-    return this.object.update(formData);
-  }
 }

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

@@ -1,7 +1,6 @@
 import { Misc } from "./misc.js";
 import { SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
 
-export const MESSAGE_DATA = 'message-data';
 
 /**
  * Class providing helper methods to get the list of users, and 
@@ -19,61 +18,50 @@ export class ChatUtility {
   
   /* -------------------------------------------- */
   static notifyUser(userId, level = 'info', message) {
-    const data = {
+    const socketData = {
       userId: userId, level: level, message: message
     };
     if (game.user.id == userId) {
-      ChatUtility.onNotifyUser(data);
+      ChatUtility.onNotifyUser(socketData);
     }
     else {
       game.socket.emit(SYSTEM_SOCKET_ID, {
-        msg: "msg_user_ui_notifications", data: data
+        msg: "msg_user_ui_notifications", data: socketData
       });
     }
   }
 
-  static onNotifyUser(data) {
+  static onNotifyUser(socketData) {
-    if (game.user.id == data.userId) {
+    if (game.user.id == socketData.userId) {
-      switch (data.level) {
+      switch (socketData.level) {
-        case 'warn': ui.notifications.warn(data.message); break;
+        case 'warn': ui.notifications.warn(socketData.message); break;
-        case 'error': ui.notifications.error(data.message); break;
+        case 'error': ui.notifications.error(socketData.message); break;
-        default: ui.notifications.info(data.message); break;
+        default: ui.notifications.info(socketData.message); break;
       }
     }
   }
 
   /* -------------------------------------------- */
-  static onRemoveMessages(data) {
+  static onRemoveMessages(socketData) {
     if (Misc.isUniqueConnectedGM()) {
-      if (data.part) {
+      if (socketData.part) {
-        const toDelete = game.messages.filter(it => it.data.content.includes(data.part));
+        const toDelete = game.messages.filter(it => it.content.includes(socketData.part));
         toDelete.forEach(it => it.delete());
       }
-      if (data.messageId) {
+      if (socketData.messageId) {
-        game.messages.get(data.messageId)?.delete();
+        game.messages.get(socketData.messageId)?.delete();
       }
     }
   }
 
-  static onRemoveMessages(data) {
-    if (Misc.isUniqueConnectedGM()) {
-      if (data.part) {
-        const toDelete = game.messages.filter(it => it.content.includes(data.part));
-        toDelete.forEach(it => it.delete());
-      }
-      if (data.messageId) {
-        game.messages.get(data.messageId)?.delete();
-      }
-    }
-  }
   /* -------------------------------------------- */
 
-  static removeMessages(data) {
+  static removeMessages(socketData) {
     if (Misc.isUniqueConnectedGM()) {
-      ChatUtility.onRemoveMessages(data);
+      ChatUtility.onRemoveMessages(socketData);
     }
     else {
-      game.socket.emit(SYSTEM_SOCKET_ID, { msg: "msg_delete_chat_message", data: data });
+      game.socket.emit(SYSTEM_SOCKET_ID, { msg: "msg_delete_chat_message", data: socketData });
     }
   }
 
@@ -90,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) {
@@ -141,7 +125,7 @@ export class ChatUtility {
 
   /* -------------------------------------------- */
   static getUsers(filter) {
-    return Misc.getUsers().filter(filter).map(user => user.data._id);
+    return game.users.filter(filter).map(user => user.id);
   }
 
   /* -------------------------------------------- */
@@ -154,17 +138,17 @@ export class ChatUtility {
   }
 
   /* -------------------------------------------- */
-  static handleGMChatMessage(data) {
+  static handleGMChatMessage(socketData) {
-    console.log("blindMessageToGM", data);
+    console.log("blindMessageToGM", socketData);
     if (game.user.isGM) { // message privé pour GM only
-      data.user = game.user.id;
+      socketData.user = game.user.id;
-      ChatMessage.create(data);
+      ChatMessage.create(socketData);
     }
   }
 
-  static async setMessageData(chatMessage, key, data) {
+  static async setMessageData(chatMessage, key, flag) {
-    if (data) {
+    if (flag) {
-      await chatMessage.setFlag(SYSTEM_RDD, key, JSON.stringify(data));
+      await chatMessage.setFlag(SYSTEM_RDD, key, JSON.stringify(flag));
     }
   }
 

module/constants.js

@@ -1,5 +1,6 @@
 export const SYSTEM_RDD = 'foundryvtt-reve-de-dragon';
 export const SYSTEM_SOCKET_ID = 'system.foundryvtt-reve-de-dragon';
+export const LOG_HEAD = 'RdD | ';
 
 export const HIDE_DICE = 'hide';
 export const SHOW_DICE = 'show';

module/dialog-chronologie.js

@@ -0,0 +1,143 @@
+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";
+
+export class DialogChronologie extends Dialog {
+
+  static init() {
+    game.settings.register(SYSTEM_RDD, LATEST_USED_JOURNAL_ID, {
+      name: "Dernier article de journal utilisé pour enregistrer la chronologie",
+      scope: "client",
+      config: false,
+      default: "",
+      type: String
+    });
+  }
+  static async create() {
+    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)),
+      timestamp: game.system.rdd.calendrier.timestamp,
+      dateReel: game.system.rdd.calendrier.dateReel()
+    };
+    const html = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/dialog-chronologie.html", dialogData);
+    const dialog = new DialogChronologie(html, dialogData);
+    dialog.render(true);
+  }
+
+  constructor(html, dialogData) {
+    const options = {
+      classes: ["DialogChronologie"],
+      width: 500,
+      height: 'fit-content',
+      'z-index': 99999
+    };
+    const timeData = dialogData.timestamp.toCalendrier()
+    const conf = {
+      title: `Chronologie - ${timeData.jourDuMois} ${timeData.mois.label} - Heure  ${timeData.heure.label}`,
+      content: html,
+      buttons: {
+      }
+    };
+    super(conf, options);
+    this.dialogData = dialogData;
+  }
+
+  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();
+    if (journalEntry?.canUserModify(game.user)) {
+      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 this.html.find("form.rdddialogchrono :input").change();
+  }
+
+  findJournal() {
+    const journalId = this.html.find("form.rdddialogchrono :input[name='journalId']").val();
+    const journalEntry = game.journal.get(journalId);
+    return { journalId, journalEntry };
+  }
+
+  async prepareChronologieEntry(journalParameters) {
+    return await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/chronologie-entry.html", journalParameters);
+  }
+
+  extractJournalParameters() {
+    return {
+      auteur: this.html.find("form.rdddialogchrono :input[name='auteur']").val(),
+      information: this.html.find("form.rdddialogchrono :input[name='information']").val(),
+      dateRdD: {
+        jour: this.html.find("form.rdddialogchrono :input[name='chronologie.jourDuMois']").val(),
+        mois: RdDTimestamp.definition(this.html.find("form.rdddialogchrono :input[name='chronologie.mois']").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(),
+      },
+      dateReel: this.html.find("form.rdddialogchrono :input[name='dateReel']").val()
+    }
+  }
+
+  addContentToJournal(journalEntry, section, content) {
+    let page = journalEntry.pages.find(p => p.type == 'text' && Grammar.equalsInsensitive(p.name, section));
+    if (page) {
+      page.update({ 'text.content': page.text.content + '\n' + content });
+    }
+    else {
+      journalEntry.createEmbeddedDocuments('JournalEntryPage', [this.newPageChronologie(section, content)]);
+    }
+  }
+
+  newPageChronologie(section, content) {
+    return new JournalEntryPage({
+      name: section,
+      type: 'text',
+      title: { show: true, level: 1 },
+      text: { content: content, format: 1 }
+    });
+  }
+
+  storeLatestUsedJournalEntry(journalId) {
+    game.settings.set(SYSTEM_RDD, LATEST_USED_JOURNAL_ID, journalId);
+  }
+}

module/dialog-create-signedraconique.js

@@ -1,7 +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 { Misc } from "./misc.js";
 import { TMRUtility } from "./tmr-utility.js";
 
 export class DialogCreateSigneDraconique extends Dialog {
@@ -10,12 +9,13 @@ export class DialogCreateSigneDraconique extends Dialog {
     const signe = await RdDItemSigneDraconique.randomSigneDraconique({ephemere: true});
     let dialogData = {
       signe: signe,
-      tmrs: TMRUtility.listSelectedTMR(signe.data.typesTMR ?? []),
+      tmrs: TMRUtility.buildSelectionTypesTMR(signe.system.typesTMR),
-      actors: game.actors.filter(actor => actor.isHautRevant()).map(actor => {
+      actors: game.actors.filter(actor => actor.isPersonnage() && actor.isHautRevant())
-        let actorData = duplicate(actor);
+        .map(actor => ({
-        actorData.selected = actor.hasPlayerOwner;
+          id: actor.id,
-        return actorData;
+          name: actor.name,
-      })
+          selected: true
+        }))
     };
 
     const html = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/dialog-create-signedraconique.html", dialogData);
@@ -23,12 +23,11 @@ export class DialogCreateSigneDraconique extends Dialog {
       .render(true);
   }
 
-  constructor(dialogData, html, callback) {
+  constructor(dialogData, html) {
     let options = { classes: ["DialogCreateSigneDraconiqueActorsActors"], width: 500, height: 650, 'z-index': 99999 };
     let conf = {
       title: "Créer un signe",
       content: html,
-      default: "Ajouter aux haut-rêvants",
       buttons: {
         "Ajouter aux haut-rêvants": { label: "Ajouter aux haut-rêvants", callback: it => { this._onCreerSigneActeurs(); } }
       }
@@ -36,15 +35,16 @@ export class DialogCreateSigneDraconique extends Dialog {
     super(conf, options);
     this.dialogData = dialogData;
   }
-
+  
   async _onCreerSigneActeurs() {
-    await $("[name='signe.data.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))
+    this.dialogData.actors.filter(it => it.selected)
-      .forEach(actor => this._createSigneForActor(actor, this.dialogData.signe));
+    .map(it => game.actors.get(it.id))
+    .forEach(actor => this._createSigneForActor(actor, this.dialogData.signe));
   }
-
+  
   async _createSigneForActor(actor, signe) {
     actor.createEmbeddedDocuments("Item", [signe]);
     ChatMessage.create({
@@ -57,62 +57,72 @@ 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.data.valeur.norm = $("[name='signe.data.valeur.norm']").val();
+    this.dialogData.signe.system.valeur.norm = this.html.find("[name='signe.system.valeur.norm']").val();
-    this.dialogData.signe.data.valeur.sign = $("[name='signe.data.valeur.sign']").val();
+    this.dialogData.signe.system.valeur.sign = this.html.find("[name='signe.system.valeur.sign']").val();
-    this.dialogData.signe.data.valeur.part = $("[name='signe.data.valeur.part']").val();
+    this.dialogData.signe.system.valeur.part = this.html.find("[name='signe.system.valeur.part']").val();
-    this.dialogData.signe.data.difficulte = $("[name='signe.data.difficulte']").val();
+    this.dialogData.signe.system.difficulte = this.html.find("[name='signe.system.difficulte']").val();
-    this.dialogData.signe.data.ephemere = $("[name='signe.data.ephemere']").prop("checked");
+    this.dialogData.signe.system.ephemere = this.html.find("[name='signe.system.ephemere']").prop("checked");
-    this.dialogData.signe.data.duree = $("[name='signe.data.duree']").val();
+    this.dialogData.signe.system.duree = this.html.find("[name='signe.system.duree']").val();
-    this.dialogData.signe.data.typesTMR = $(".select-tmr").val();
+    this.dialogData.signe.system.typesTMR = TMRUtility.buildListTypesTMRSelection(this.dialogData.tmrs);
   }
-
+  
   /* -------------------------------------------- */
   activateListeners(html) {
     super.activateListeners(html);
-    this.setEphemere(this.dialogData.signe.data.ephemere);
+    this.html = html;
+    this.setEphemere(this.dialogData.signe.system.ephemere);
     html.find(".signe-aleatoire").click(event => this.setSigneAleatoire());
-    html.find("[name='signe.data.ephemere']").change((event) => this.setEphemere(event.currentTarget.checked));
+    html.find("[name='signe.system.ephemere']").change((event) => this.setEphemere(event.currentTarget.checked));
-    html.find(".select-actor").change((event) => this.onSelectActor(event));
     html.find(".signe-xp-sort").change((event) => this.onValeurXpSort(event));
+    html.find("input.select-actor").change((event) => this.onSelectActor(event));
+    html.find("input.select-tmr").change((event) => this.onSelectTmr(event));
   }
 
   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.data.valeur.norm']").val(newSigne.data.valeur.norm);
+    this.html.find("[name='signe.system.valeur.norm']").val(newSigne.system.valeur.norm);
-    $("[name='signe.data.valeur.sign']").val(newSigne.data.valeur.sign);
+    this.html.find("[name='signe.system.valeur.sign']").val(newSigne.system.valeur.sign);
-    $("[name='signe.data.valeur.part']").val(newSigne.data.valeur.part);
+    this.html.find("[name='signe.system.valeur.part']").val(newSigne.system.valeur.part);
-    $("[name='signe.data.difficulte']").val(newSigne.data.difficulte);
+    this.html.find("[name='signe.system.difficulte']").val(newSigne.system.difficulte);
-    $("[name='signe.data.duree']").val(newSigne.data.duree);
+    this.html.find("[name='signe.system.duree']").val(newSigne.system.duree);
-    $("[name='signe.data.ephemere']").prop("checked", newSigne.data.ephemere);
+    this.html.find("[name='signe.system.ephemere']").prop("checked", newSigne.system.ephemere);
-    $(".select-tmr").val(newSigne.data.typesTMR);
+    this.dialogData.tmrs = TMRUtility.buildSelectionTypesTMR(newSigne.system.typesTMR);
-    this.setEphemere(newSigne.data.ephemere);
+    this.dialogData.tmrs.forEach(t => {
+      this.html.find(`[data-tmr-name='${t.name}']`).prop( "checked", t.selected);
+    })
+    this.setEphemere(newSigne.system.ephemere);
   }
 
   async setEphemere(ephemere) {
-    this.dialogData.signe.data.ephemere = ephemere;
+    this.dialogData.signe.system.ephemere = ephemere;
-    HtmlUtility._showControlWhen($(".signe-data-duree"), ephemere);
+    HtmlUtility.showControlWhen(this.html.find(".signe-system-duree"), ephemere);
   }
 
   async onSelectActor(event) {
-    event.preventDefault();
+    const actorId = this.html.find(event.currentTarget)?.data("actor-id");
-    const options = event.currentTarget.options;
+    const actor = this.dialogData.actors.find(it => it.id == actorId);
-    for (var i = 0; i < options.length; i++) { // looping over the options
+    if (actor) {
-      const actorId = options[i].attributes["data-actor-id"].value;
+      actor.selected = event.currentTarget.checked;
-      const actor = this.dialogData.actors.find(it => it._id == actorId);
+    }
-      if (actor) {
-        actor.selected = options[i].selected;
-      }
-    };
   }
 
+  onSelectTmr(event) {
+    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;
+    }
+  }
+
+
   onValeurXpSort(event) {
     const codeReussite = event.currentTarget.attributes['data-typereussite']?.value ?? 0;
     const xp = Number(event.currentTarget.value);
-    const oldValeur = this.dialogData.signe.data.valeur;
+    const oldValeur = this.dialogData.signe.system.valeur;
-    this.dialogData.signe.data.valeur = RdDItemSigneDraconique.calculValeursXpSort(codeReussite, xp, oldValeur);
+    this.dialogData.signe.system.valeur = RdDItemSigneDraconique.calculValeursXpSort(codeReussite, xp, oldValeur);
   }
 
 }

module/dialog-fabriquer-potion.js

@@ -5,37 +5,42 @@ 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!`);
+      return;
+    }
     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.data.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;
   }
 
   /* -------------------------------------------- */
   static prepareData(actor, item) {
     let potionData = duplicate(item)
-    potionData.nbBrinsSelect = RdDUtility.buildListOptions(1, potionData.data.quantite);
+    potionData.nbBrinsSelect = RdDUtility.buildListOptions(
-    potionData.nbBrins = Math.min(potionData.data.quantite, DialogFabriquerPotion.getNombreBrinOptimal(potionData));
+      DialogFabriquerPotion.nombreBrinsMinimum(item),
+      DialogFabriquerPotion.nombreBrinsOptimal(item));
+    potionData.nbBrins = Math.min(potionData.system.quantite, DialogFabriquerPotion.nombreBrinsOptimal(potionData));
+    potionData.herbebonus = item.system.niveau;
     potionData.buttonName = "Fabriquer";
     return potionData;
   }
 
   /* -------------------------------------------- */
-  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()
+        }
       }
     };
 
@@ -43,29 +48,41 @@ export class DialogFabriquerPotion extends Dialog {
 
     this.actor = actor;
     this.potionData = potionData;
-  }
+    this.onActionItem = onActionItem;
-
-  static getNombreBrinOptimal(herbeData) {
-    switch (herbeData.data.categorie ?? '') {
-      case "Soin": return 12 - herbeData.data.niveau;
-      case "Repos": return 7 - herbeData.data.niveau;
-    }
-    return 1;
   }
 
   /* -------------------------------------------- */
   activateListeners(html) {
     super.activateListeners(html);
-
+    this.html = html;
-    html.find("#nbBrins").change(event => {
+    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(it) {
+  async onFabriquer() {
-    await $("#nbBrins").change();
+    await this.html.find("[name='nbBrins']").change();
-    this.actor.fabriquerPotion(this.potionData);
+    await this.actor.fabriquerPotion(this.potionData);
     this.close();
+    await this.onActionItem()
+  }
+
+  static nombreBrinsMinimum(herbeData) {
+    switch (herbeData.system.categorie ?? '') {
+      case "Soin": return 1 + Math.max(0, 12 - 2 * herbeData.system.niveau);
+      case "Repos": return 1 + Math.max(0, 7 - 2 * herbeData.system.niveau);
+    }
+    return 1;
+  }
+
+  static nombreBrinsOptimal(herbeData) {
+    switch (herbeData.system.categorie ?? '') {
+      case "Soin": return 12 - herbeData.system.niveau;
+      case "Repos": return 7 - herbeData.system.niveau;
+    }
+    return 1;
   }
 }

module/dialog-item-achat.js

@@ -1,93 +1,104 @@
-
 import { Misc } from "./misc.js";
 import { RdDUtility } from "./rdd-utility.js";
 
 export class DialogItemAchat extends Dialog {
 
-  static async onButtonAcheter(event) {
+  static preparerAchat(chatButton) {
-    const buttonAcheter = event.currentTarget;
+    const vendeurId = chatButton.attributes['data-vendeurId']?.value;
-    if (!buttonAcheter.attributes['data-jsondata']?.value) {
-      ui.notifications.warn("Impossible d'acheter: informations sur l'objet manquantes")
-      return;
-    }
-    const chatMessageIdVente = RdDUtility.findChatMessageId(buttonAcheter);
-
-    const vendeurId = buttonAcheter.attributes['data-vendeurId']?.value;
     const vendeur = vendeurId ? game.actors.get(vendeurId) : undefined;
     const acheteur = RdDUtility.getSelectedActor();
-
+    const json = chatButton.attributes['data-jsondata']?.value;
     if (!acheteur && !vendeur) {
       ui.notifications.info("Pas d'acheteur ni de vendeur, aucun changement");
-      return;
+      return undefined;
+    }
+    if (!json) {
+      ui.notifications.warn("Impossible d'acheter: informations sur l'objet manquantes")
+      return undefined;
     }
 
-    let venteData = DialogItemAchat.prepareVenteData(buttonAcheter, vendeurId, vendeur, acheteur);
+    return {
-    const html = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/dialog-item-achat.html`, venteData);
+      item: JSON.parse(json),
-    const dialog = new DialogItemAchat(html, vendeur, acheteur, venteData, chatMessageIdVente);
+      vendeur,
-    dialog.render(true);
+      acheteur,
+      nbLots: parseInt(chatButton.attributes['data-quantiteNbLots']?.value),
+      tailleLot: parseInt(chatButton.attributes['data-tailleLot']?.value ?? 1),
+      prixLot: Number(chatButton.attributes['data-prixLot']?.value ?? 0),
+      quantiteIllimite: chatButton.attributes['data-quantiteIllimite']?.value == 'true',
+      chatMessageIdVente: RdDUtility.findChatMessageId(chatButton),
+    };
   }
 
-  constructor(html, vendeur, acheteur, venteData, chatMessageIdVente) {
+
-    const isConsommable = venteData.item.type == 'nourritureboisson';
+  static async onAcheter({ item, vendeur, acheteur, tailleLot, prixLot, nbLots, quantiteIllimite, chatMessageIdVente }) {
-    let options = { classes: ["dialogachat"], width: 400, height: isConsommable ? 450 : 350, 'z-index': 99999 };
+    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);
+    new DialogItemAchat(html, venteData).render(true);
+  }
+
+  static changeNombreLots(venteData, nombreLots) {
+    venteData.choix.nombreLots = nombreLots;
+    venteData.prixTotal = (nombreLots * venteData.prixLot).toFixed(2);
+    if (venteData.isConsommable) {
+      const doses = nombreLots * venteData.tailleLot;
+      venteData.totalSust = Misc.keepDecimals(doses * (venteData.item.system.sust ?? 0), 2);
+      venteData.totalDesaltere = venteData.item.system.boisson
+        ? Misc.keepDecimals(doses * (venteData.item.system.desaltere ?? 0), 2)
+        : 0;
+    }
+  }
+
+  constructor(html, venteData) {
+    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.data.boisson ? "Boire" : "Manger", callback: it => { this.onAchatConsommer(); } }
+      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.vendeur = vendeur;
-    this.acheteur = acheteur;
-    this.chatMessageIdVente = chatMessageIdVente;
     this.venteData = venteData;
   }
 
-  static prepareVenteData(buttonAcheter, vendeurId, vendeur, acheteur) {
-    const jsondata = buttonAcheter.attributes['data-jsondata']?.value;
-    const prixLot = parseInt(buttonAcheter.attributes['data-prixLot']?.value ?? 0);
-    let venteData = {
-      item: JSON.parse(jsondata),
-      vendeurId: vendeurId,
-      vendeur: vendeur,
-      acheteur:acheteur,
-      tailleLot: parseInt(buttonAcheter.attributes['data-tailleLot']?.value ?? 1),
-      quantiteIllimite: buttonAcheter.attributes['data-quantiteIllimite']?.value == 'true',
-      quantiteNbLots: parseInt(buttonAcheter.attributes['data-quantiteNbLots']?.value),
-      choix: {
-        nombreLots: 1,
-        seForcer: false,
-        supprimerSiZero: true
-      },
-      prixLot: prixLot,
-      prixTotal: prixLot,
-      isVente: prixLot > 0
-    };
-    return venteData;
-  }
-
   async onAchat() {
-    await $(".nombreLots").change();
+    await this.html.find(".nombreLots").change();
-    (this.vendeur ?? this.acheteur).achatVente({
+    (this.venteData.vendeur ?? this.venteData.acheteur).achatVente({
       userId: game.user.id,
-      vendeurId: this.vendeur?.id,
+      vendeurId: this.venteData.vendeur?.id,
-      acheteurId: this.acheteur?.id,
+      acheteurId: this.venteData.acheteur?.id,
       prixTotal: this.venteData.prixTotal,
-      chatMessageIdVente: this.chatMessageIdVente,
+      chatMessageIdVente: this.venteData.chatMessageIdVente,
-      choix: this.venteData.choix
+      choix: this.venteData.choix,
+      vente: this.venteData
     });
   }
-  
+
   async onAchatConsommer() {
     this.venteData.choix.consommer = true;
     await this.onAchat();
@@ -96,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) {
@@ -106,9 +117,21 @@ export class DialogItemAchat extends Dialog {
   }
 
   setNombreLots(nombreLots) {
-    this.venteData.choix.nombreLots = nombreLots;
+
-    this.venteData.prixTotal = (nombreLots * this.venteData.prixLot).toFixed(2);
+    if (!this.venteData.quantiteIllimite) {
-    $(".prixTotal").text(this.venteData.prixTotal);
+      if (!this.venteData.quantiteIllimite && nombreLots > this.venteData.quantiteNbLots) {
+        ui.notifications.warn(`Seulement ${this.venteData.quantiteNbLots} lots disponibles, vous ne pouvez pas en prendre ${nombreLots}`)
+      }
+      nombreLots = Math.min(nombreLots, this.venteData.quantiteNbLots);
+    }
+
+    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,14 +2,14 @@ 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: 450, 'z-index': 99999 };
+    const options = { classes: ["dialogconsommer"], width: 350, height: 'fit-content', 'z-index': 99999 };
     let conf = {
       title: consommerData.title,
       content: html,
@@ -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,51 +31,71 @@ 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) {
-    const itemData = duplicate(item);
     let consommerData = {
-      item: itemData,
+      item: duplicate(item),
       cuisine: actor.getCompetence('cuisine'),
       choix: {
         doses: 1,
         seForcer: false,
       }
     }
-    switch (itemData.type) {
+    switch (item.type) {
+      case 'herbe': case 'faune':
+        consommerData.title = 'Manger une portion crue: ';
+        consommerData.buttonName = "Manger";
+        break;
       case 'nourritureboisson':
-        consommerData.title = itemData.data.boisson ? `${itemData.name}: boire une dose` : `${itemData.name}: manger une portion`;
+        consommerData.title = item.system.boisson ? 'Boire une dose: ' : 'Manger une portion: ';
-        consommerData.buttonName = itemData.data.boisson ? "Boire" : "Manger";
+        consommerData.buttonName = item.system.boisson ? "Boire" : "Manger";
         break;
       case 'potion':
-        consommerData.title = `${itemData.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(consommerData) {
+  static calculDoses(consommer, item) {
-    const doses = consommerData.choix.doses;
+    const doses = consommer.choix.doses;
-    consommerData.totalSust = Misc.keepDecimals(doses * (consommerData.item.data.sust ?? 0), 2);
+    switch (item.type) {
-    consommerData.totalDesaltere = consommerData.item.data.boisson
+      case 'herbe': case 'faune':
-      ? Misc.keepDecimals(doses * (consommerData.item.data.desaltere ?? 0), 2)
+        consommer.totalSust = doses;
-      : 0;
+        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;
-  activateListeners(html) {
+      case 'nourritureboisson':
-    super.activateListeners(html);
+        consommer.choix.sust = consommer.item.system.sust;
-    html.find(".se-forcer").change(event => this.setSeForcer(event));
+        consommer.choix.quantite = doses;
-    html.find(".consommer-doses").change(event => this.selectDoses(event));
+        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
+    }
   }
 
 
@@ -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

@@ -1,31 +1,30 @@
 import { HtmlUtility } from "./html-utility.js";
-import { Misc } from "./misc.js";
 
 export class DialogItemVente extends Dialog {
 
-  static async create(item, callback) {
+  static async display({ item, callback, quantiteMax = undefined }) {
-    const itemData = item
+    const quantite = quantiteMax ?? item.getQuantite() ?? 1;
-    const quantite = item.isConteneur() ? 1 : itemData.system.quantite;
+    const isOwned = item.parent;
     const venteData = {
-      item: itemData,
+      item: item,
       alias: item.actor?.name ?? game.user.name,
       vendeurId: item.actor?.id,
-      prixOrigine: itemData.system.cout,
+      prixOrigine: item.calculerPrixCommercant(),
-      prixUnitaire: itemData.system.cout,
+      prixUnitaire: item.calculerPrixCommercant(),
-      prixLot: itemData.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);
+    return new DialogItemVente(venteData, html, callback).render(true);
   }
 
   constructor(venteData, html, callback) {
-    let options = { classes: ["dialogvente"], width: 400, height: 300, 'z-index': 99999 };
+    let options = { classes: ["dialogvente"], width: 400, height: 'fit-content', 'z-index': 99999 };
 
     let conf = {
       title: "Proposer",
@@ -39,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) {
-    let actorData = actor
-    const html = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/dialog-repos.html", actorData);
-    new DialogRepos(html, actor).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

@@ -0,0 +1,37 @@
+
+export class DialogSelectTarget extends Dialog {
+  constructor(html, onSelectTarget, targets) {
+    const options = {
+      classes: ["rdd-dialog-select-target"],
+      width: 'fit-content',
+      height: 'fit-content',
+      'max-height': 600,
+      'z-index': 99999
+    };
+    const conf = {
+      title: "Choisir une cible",
+      content: html,
+      buttons: {}
+    };
+    super(conf, options);
+    this.onSelectTarget = onSelectTarget;
+    this.targets = targets;
+  }
+
+  activateListeners(html) {
+    super.activateListeners(html);
+    this.html = html;
+    this.html.find("li.select-target").click((event) => {
+      this.targetSelected(this.html.find(event.currentTarget)?.data("token-id"));
+    });
+  }
+
+
+  targetSelected(tokenId) {
+    const target = this.targets.find(it => it.id == tokenId);
+    this.close();
+    if (target) {
+      this.onSelectTarget(target);
+    }
+  }
+}

module/dialog-split-item.js

@@ -3,50 +3,43 @@ import { Misc } from "./misc.js";
 export class DialogSplitItem extends Dialog {
 
   static async create(item, callback) {
-    const itemData = item
     const splitData = {
-      item: itemData,
+      item: item,
-      choix: { quantite: 1, max: itemData.data.quantite - 1 }
+      choix: { quantite: 1, max: item.system.quantite - 1 }
     };
     const html = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/dialog-item-split.html`, splitData);
     return new DialogSplitItem(item, splitData, html, callback)
   }
 
   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;
     this.item = item;
     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-stress.js

@@ -1,72 +0,0 @@
-import { Misc } from "./misc.js";
-
-export class DialogStress extends Dialog {
-
-  static async distribuerStress() {
-    let dialogData = {
-      motif: "Motif",
-      stress: 10,
-      immediat: false,
-      actors: game.actors.filter(actor => actor.hasPlayerOwner && actor.isPersonnage())
-        .map(actor => {
-          let actorData = duplicate(actor);
-          actorData.selected = actor.hasPlayerOwner;
-          return actorData;
-        })
-    };
-
-    const html = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/dialog-stress.html", dialogData);
-    new DialogStress(dialogData, html)
-      .render(true);
-  }
-
-  constructor(dialogData, html) {
-    let options = { classes: ["DialogStress"], width: 400, height: 320, 'z-index': 99999 };
-    let conf = {
-      title: "Donner du stress",
-      content: html,
-      buttons: {
-        "Stress": { label: "Stress !", callback: it => { this._onStress(); } }
-      }
-    };
-    super(conf, options);
-    this.dialogData = dialogData;
-  }
-
-  async _onStress() {
-    this.validerStress();
-    const compteur = this.dialogData.immediat ? 'experience' : 'stress';
-    const stress = this.dialogData.stress;
-    const motif = this.dialogData.motif;
-
-    this.dialogData.actors.filter(it => it.selected)
-      .map(it => game.actors.get(it._id))
-      .forEach(actor => actor.distribuerStress(compteur, stress, motif));
-  }
-
-
-  validerStress() {
-    this.dialogData.motif = $("form.rdddialogstress input[name='motif']").val();
-    this.dialogData.stress = $("form.rdddialogstress input[name='stress']").val();
-    this.dialogData.immediat = $("form.rdddialogstress input[name='immediat']").prop("checked");;
-  }
-
-  /* -------------------------------------------- */
-  activateListeners(html) {
-    super.activateListeners(html);
-    html.find(".select-actor").change((event) => this.onSelectActor(event));
-  }
-
-  async onSelectActor(event) {
-    event.preventDefault();
-    const options = event.currentTarget.options;
-    for (var i = 0; i < options.length; i++) { // looping over the options
-      const actorId = options[i].attributes["data-actor-id"].value;
-      const actor = this.dialogData.actors.find(it => it._id == actorId);
-      if (actor) {
-        actor.selected = options[i].selected;
-      }
-    };
-  }
-
-}

module/dialog-validation-encaissement.js

@@ -0,0 +1,72 @@
+import { HIDE_DICE, SHOW_DICE } from "./constants.js";
+import { RdDUtility } from "./rdd-utility.js";
+
+/**
+ * Extend the base Dialog entity by defining a custom window to perform roll.
+ * @extends {Dialog}
+ */
+export class DialogValidationEncaissement extends Dialog {
+
+  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,
+      rollData: rollData,
+      encaissement: encaissement,
+      show: show
+    });
+    const dialog = new DialogValidationEncaissement(html, actor, rollData, armure, encaissement, show, attackerId, onEncaisser);
+    dialog.render(true);
+  }
+
+  /* -------------------------------------------- */
+  constructor(html, actor, rollData, armure, encaissement, show, attackerId, onEncaisser) {
+    // Common conf
+    let buttons = {
+      "valider": { label: "Valider", callback: html => this.onValider() },
+      "annuler": { label: "Annuler", callback: html => { } },
+    };
+
+    let dialogConf = {
+      title: "Validation d'encaissement",
+      content: html,
+      buttons: buttons,
+      default: "valider"
+    }
+
+    let dialogOptions = {
+      classes: ["rdd-roll-dialog"],
+      width: 350,
+      height: 290
+    }
+
+    // Select proper roll dialog template and stuff
+    super(dialogConf, dialogOptions);
+
+    this.actor = actor
+    this.rollData = rollData;
+    this.armure = armure;
+    this.encaissement = encaissement;
+    this.show = show;
+    this.attackerId = attackerId;
+    this.onEncaisser = onEncaisser;
+    this.forceDiceResult = {total: encaissement.roll.result };
+  }
+
+  /* -------------------------------------------- */
+  activateListeners(html) {
+    super.activateListeners(html);
+    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});
+      this.html.find('label.encaissement-total').text(this.encaissement.total);
+      this.html.find('label.encaissement-blessure').text(this.encaissement.blessures)
+    });
+  }
+
+  async onValider() {
+    this.encaissement = await RdDUtility.jetEncaissement(this.rollData, this.armure, { showDice: SHOW_DICE, forceDiceResult: this.forceDiceResult});
+    this.onEncaisser(this.encaissement, this.show, this.attackerId)
+  }
+}

module/environnement.js

@@ -0,0 +1,78 @@
+import { SYSTEM_RDD } from "./constants.js";
+import { Grammar } from "./grammar.js";
+import { Misc } from "./misc.js";
+import { CompendiumTableHelpers, CompendiumTable, SystemCompendiums } from "./settings/system-compendiums.js";
+
+
+const COMPENDIUMS_RECHERCHE = 'compendiums-recherche';
+
+export class Environnement {
+  static init() {
+    game.settings.register(SYSTEM_RDD, COMPENDIUMS_RECHERCHE, {
+      name: COMPENDIUMS_RECHERCHE,
+      default: [
+        SystemCompendiums.getCompendium('faune-flore-mineraux'),
+        SystemCompendiums.getCompendium('meditations-et-ecrits'),
+        SystemCompendiums.getCompendium('equipement')
+      ],
+      scope: "world",
+      config: false,
+      type: Object
+    });
+
+    game.system.rdd.environnement = new Environnement();
+    Hooks.once('ready', () => game.system.rdd.environnement.onReady());
+  }
+
+  constructor() {
+    this.compendiums = [];
+    this.compendiumTables = [];
+    this.mapMilieux = {}
+  }
+
+  async onReady() {
+    await this.$prepareCompendiums()
+  }
+
+  async milieux() {
+    return Object.values(this.mapMilieux);
+  }
+
+  async saveCompendiums(compendiumIds) {
+    game.settings.set(SYSTEM_RDD, COMPENDIUMS_RECHERCHE, compendiumIds);
+    await this.$prepareCompendiums();
+  }
+
+  async $prepareCompendiums() {
+    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 autresMilieux(item) {
+    const milieuxExistants = item.getMilieux().map(it => Grammar.toLowerCaseNoAccent(it));
+    return Object.keys(this.mapMilieux)
+      .filter(it => !milieuxExistants.includes(it))
+      .map(it => this.mapMilieux[it]);
+  }
+
+  async getElements(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);
+  }
+}

module/grammar.js

@@ -19,10 +19,14 @@ export class Grammar {
     return word.match(/^[aeiouy]/i)
   }
 
+  static equalsInsensitive(a, b) {
+    return Grammar.toLowerCaseNoAccent(a) == Grammar.toLowerCaseNoAccent(b)
+  }
   
   static includesLowerCaseNoAccent(value, content) {
     return Grammar.toLowerCaseNoAccent(value).includes(Grammar.toLowerCaseNoAccent(content));
   }
+
   /* -------------------------------------------- */
   static toLowerCaseNoAccent(words) {
     return words?.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "") ?? words;

module/hook-renderChatLog.js

@@ -1,9 +0,0 @@
-/* -------------------------------------------- */
-import { RdDUtility } from "./rdd-utility.js";
-
-/* -------------------------------------------- */
-// Activate chat listeners defined 
-// Hooks.on('renderChatLog', (log, html, data) => {
-//   RdDUtility.chatListeners(html);
-// });
-

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 = {
@@ -19,18 +19,16 @@ const nomCategorieParade = {
 /* -------------------------------------------- */
 export class RdDItemArme extends Item {
 
-  static isArme(itemData) {
+  static isArme(item) {
-    itemData = itemData
+    return RdDItemCompetenceCreature.getCategorieAttaque(item) || item.type == 'arme';
-    return (itemData.type == 'competencecreature' && itemData.system.iscombat) || itemData.type == 'arme';
   }
 
   /* -------------------------------------------- */
-  static getArmeData(armeData) {
+  static getArme(arme) {
-    armeData = armeData
+    switch (arme ? arme.type : '') {
-    switch (armeData ? armeData.type : '') {
+      case 'arme': return arme;
-      case 'arme': return armeData;
       case 'competencecreature':
-        return RdDItemCompetenceCreature.toActionArme(armeData);
+        return RdDItemCompetenceCreature.armeCreature(arme);
     }
     return RdDItemArme.mainsNues();
   }
@@ -160,18 +158,18 @@ export class RdDItemArme extends Item {
     return armeData;
   }
 
-  static isArmeUtilisable(itemData) {
+  static isArmeUtilisable(arme) {
-    return itemData.type == 'arme' && itemData.system.equipe && (itemData.system.resistance > 0 || itemData.system.portee_courte > 0);
+    return arme.type == 'arme' && arme.system.equipe && (arme.system.resistance > 0 || arme.system.portee_courte > 0);
   }
 
   static ajoutCorpsACorps(armes, competences, carac) {
     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.data.niveau, initiative: init }));
+    armes.push(RdDItemArme.empoignade({ niveau: corpsACorps.system.niveau, initiative: init }));
   }
 
-  static corpsACorps(actorData) {
+  static corpsACorps(mainsNuesActor) {
     const corpsACorps = {
       name: 'Corps à corps',
       img: 'systems/foundryvtt-reve-de-dragon/icons/competence_corps_a_corps.webp',
@@ -179,27 +177,27 @@ export class RdDItemArme extends Item {
         equipe: true,
         rapide: true,
         force: 0,
-        dommages: 0,
+        dommages: "0",
         dommagesReels: 0,
         mortalite: 'non-mortel',
         competence: 'Corps à corps',
         categorie_parade: 'sans-armes'
       }
     };
-    mergeObject(corpsACorps.system, actorData ?? {}, { overwrite: false });
+    mergeObject(corpsACorps.system, mainsNuesActor ?? {}, { overwrite: false });
     return corpsACorps;
   }
 
-  static mainsNues(actorData) {
+  static mainsNues(mainsNuesActor) {
-    const mainsNues = RdDItemArme.corpsACorps(actorData)
+    const mainsNues = RdDItemArme.corpsACorps(mainsNuesActor)
     mainsNues.name = 'Mains nues'
     mainsNues.system.cac = 'pugilat'
     mainsNues.system.baseInit = 4
     return mainsNues;
   }
   
-  static empoignade(actorData) {
+  static empoignade(mainsNuesActor) {
-    const empoignade = RdDItemArme.corpsACorps(actorData)
+    const empoignade = RdDItemArme.corpsACorps(mainsNuesActor)
     empoignade.name = 'Empoignade'
     empoignade.system.cac = 'empoignade'
     empoignade.system.baseInit = 3

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" },
@@ -34,13 +34,6 @@ const categorieCompetences = {
   "lancer": { base: -8, label: "Lancer" }
 }
 
-const compendiumCompetences = {
-  "personnage": "foundryvtt-reve-de-dragon.competences",
-  "creature": "foundryvtt-reve-de-dragon.competences-creatures",
-  "entite": "foundryvtt-reve-de-dragon.competences-entites"
-};
-
-
 function _buildCumulXP() {
   let cumulXP = { "-11": 0 };
   let cumul = 0;
@@ -55,23 +48,17 @@ function _buildCumulXP() {
 const competence_xp_cumul = _buildCumulXP();
 
 export class RdDItemCompetence extends Item {
-
   /* -------------------------------------------- */
-  static actorCompendium(actorType) {
+  static getCategories() {
-    return compendiumCompetences[actorType];
+    return categoriesCompetences;
-  }
-
-  /* -------------------------------------------- */
-  static getCategorieCompetences() {
-    return categorieCompetences;
-  }
-  /* -------------------------------------------- */
-  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;
   }
 
   /* -------------------------------------------- */
@@ -84,27 +71,36 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   static getVoieDraconic(competences, voie) {
-    return RdDItemCompetence.findCompetence(competences.filter(it => RdDItemCompetence.isDraconic(it)), voie);
+    return RdDItemCompetence.findFirstItem(competences, voie, {
+      preFilter: it => it.isCompetence() && RdDItemCompetence.isDraconic(it),
+      description: 'Draconic',
+    });
   }
 
   /* -------------------------------------------- */
   static isCompetenceArme(competence) {
-    switch (competence.system.categorie) {
+    if (competence.isCompetence()) {
-      case 'melee':
+      switch (competence.system.categorie) {
-        return competence.name != 'Esquive';
+        case 'melee':
-      case 'tir':
+          return !Grammar.toLowerCaseNoAccent(competence.name).includes('esquive');
-      case 'lancer':
+        case 'tir':
-        return true;
+        case 'lancer':
+          return true;
+      }
     }
     return false;
   }
 
   /* -------------------------------------------- */
   static isArmeUneMain(competence) {
-    return competence.name.toLowerCase().includes("1 main");
+    return RdDItemCompetence.isCompetenceArme(competence) && competence.name.toLowerCase().includes("1 main");
   }
   static isArme2Main(competence) {
-    return competence.name.toLowerCase().includes("2 main");
+    return RdDItemCompetence.isCompetenceArme(competence) && competence.name.toLowerCase().includes("2 main");
+  }
+
+  static isThanatos(competence) {
+    return competence.isCompetencePersonnage() && Grammar.toLowerCaseNoAccent(competence.name).includes('thanatos');
   }
 
   /* -------------------------------------------- */
@@ -133,7 +129,7 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   static computeXP(competence) {
-    const factor = competence.name.includes('Thanatos') ? 2 : 1; // Thanatos compte double !
+    const factor = RdDItemCompetence.isThanatos(competence) ? 2 : 1; // Thanatos compte double !
     const xpNiveau = RdDItemCompetence.computeDeltaXP(competence.system.base, competence.system.niveau ?? competence.system.base);
     const xp = competence.system.xp ?? 0;
     const xpSort = competence.system.xp_sort ?? 0;
@@ -183,51 +179,56 @@ export class RdDItemCompetence extends Item {
   }
 
   /* -------------------------------------------- */
-  static levelUp(itemData, stressTransforme) {
+  static levelUp(item, stressTransforme) {
-    itemData.system.xpNext = RdDItemCompetence.getCompetenceNextXp(itemData.system.niveau);
+    item.system.xpNext = RdDItemCompetence.getCompetenceNextXp(item.system.niveau);
-    const xpManquant = itemData.system.xpNext - itemData.system.xp;
+    const xpManquant = item.system.xpNext - item.system.xp;
-    itemData.system.isLevelUp = xpManquant <= 0;
+    item.system.isLevelUp = xpManquant <= 0;
-    itemData.system.isStressLevelUp = (xpManquant > 0 && stressTransforme >= xpManquant && itemData.system.niveau < itemData.system.niveau_archetype);
+    item.system.isStressLevelUp = (xpManquant > 0 && stressTransforme >= xpManquant && item.system.niveau < item.system.niveau_archetype);
-    itemData.system.stressXpMax = 0;
+    item.system.stressXpMax = 0;
-    if (xpManquant > 0 && stressTransforme > 0 && itemData.system.niveau < itemData.system.niveau_archetype) {
+    if (xpManquant > 0 && stressTransforme > 0 && item.system.niveau < item.system.niveau_archetype) {
-        itemData.system.stressXpMax = Math.min(xpManquant , stressTransforme);
+      item.system.stressXpMax = Math.min(xpManquant, stressTransforme);
     }
   }
 
   /* -------------------------------------------- */
-  static isVisible(itemData) {
+  static isNiveauBase(item) {
-    return Number(itemData.data.niveau) != RdDItemCompetence.getNiveauBase(itemData.data.categorie);
+    return Number(item.system.niveau) == RdDItemCompetence.getNiveauBase(item.system.categorie, item.getCategories());
-  }
-
-  static nomContientTexte(itemData, texte) {
-    return Grammar.toLowerCaseNoAccent(itemData.name).includes(Grammar.toLowerCaseNoAccent(texte))
-  }
-
-  /* -------------------------------------------- */
-  static isNiveauBase(itemData) {
-    return Number(itemData.system.niveau) == RdDItemCompetence.getNiveauBase(itemData.system.categorie);
   }
 
   /* -------------------------------------------- */
   static findCompetence(list, idOrName, options = {}) {
-    if (idOrName == undefined) {
+    if (idOrName == undefined || idOrName == "") {
-      return undefined;
+      return RdDItemCompetence.sansCompetence();
     }
-    options = mergeObject(options, {
+    options = mergeObject(options, { preFilter: it => it.isCompetence(), description: 'compétence' }, { overwrite: false });
-      preFilter: it => RdDItemCompetence.isCompetence(it),
+    return RdDItemCompetence.findFirstItem(list, idOrName, options);
-      description: 'compétence',
-    });
-    return list.find(it => it.id == idOrName && RdDItemCompetence.isCompetence(it))
-      ?? Misc.findFirstLike(idOrName, list, options);
   }
 
   /* -------------------------------------------- */
   static findCompetences(list, name) {
-    return Misc.findAllLike(name, list, { filter: it => RdDItemCompetence.isCompetence(it), description: 'compétence' });
+    return Misc.findAllLike(name, list, { filter: it => it.isCompetence(), description: 'compétence' });
   }
 
-  static isCompetence(item) {
+  static sansCompetence() {
-    return item.type == 'competence' || item.type == 'competencecreature';
+    return {
+      name: "Sans compétence",
+      type: "competence",
+      img: "systems/foundryvtt-reve-de-dragon/icons/templates/icone_parchement_vierge.webp",
+      system: {
+        niveau: 0,
+        default_diffLibre: 0,
+        base: 0,
+        categorie: "Aucune",
+        description: "",
+        descriptionmj: "",
+        defaut_carac: "",
+      }
+    };
+  }
+
+  static findFirstItem(list, idOrName, options) {
+    return list.find(it => it.id == idOrName && options.preFilter(it))
+      ?? Misc.findFirstLike(idOrName, list, options);
   }
 
   /* -------------------------------------------- */
@@ -257,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,51 +1,99 @@
-import { Misc } from "./misc.js";
+
+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.toActionArme(rollData.competence);
-    }
   }
 
   /* -------------------------------------------- */
-  static toActionArme(item) {
+  static setRollDataCreature(rollData) {
-    if (RdDItemCompetenceCreature.isCompetenceAttaque(item)) {
+    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 = (item instanceof Item) ? item.clone():  item;
+    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,
         {
-          competence: arme.name,
+          action: item.isCompetencePossession() ? 'possession' : 'attaque',
-          resistance: 100,
+          system: {
-          equipe: true,
+            competence: arme.name,
-          dommagesReels: arme.system.dommages,
+            cac: categorieAttaque == "naturelle" ? "naturelle" : "",
-          penetration: 0,
+            niveau: item.system.niveau,
-          force: 0,
+            initiative: RdDCombatManager.calculInitiative(item.system.niveau, item.system.carac_value),
-          rapide: true,
+            equipe: true,
-          action: 'attaque'
+            resistance: 100,
+            dommagesReels: arme.system.dommages,
+            penetration: 0,
+            force: 0,
+            rapide: true,
+          }
         });
       return arme;
     }
-    console.error("RdDItemCompetenceCreature.toActionArme(", item, ") : impossible de transformer l'Item en arme");
     return undefined;
   }
 
   /* -------------------------------------------- */
-  static isCompetenceAttaque(itemData) {
+  static getCategorieAttaque(item) {
-    itemData = itemData
+    if (item.type == TYPES.competencecreature) {
-    return itemData.type == 'competencecreature' && itemData.system.iscombat;
+      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
+  }
+
   /* -------------------------------------------- */
-  static isCompetenceParade(itemData) {
+  static isCompetenceParade(item) {
-    itemData = itemData
+    return item.type == 'competencecreature' && item.system.categorie_parade !== "";
-    return itemData.type == 'competencecreature' && itemData.system.isparade;
   }
 }  

module/item-monnaie.js

@@ -1,59 +1,113 @@
 import { Misc } from "./misc.js";
+import { LOG_HEAD } from "./constants.js";
 
-const monnaiesData = [
+const MONNAIE_ETAIN = {
-  {
+  name: "Denier (étain)", type: 'monnaie',
-    name: "Etain (1 denier)", type: 'monnaie',
+  img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_etain_poisson.webp",
-    img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_etain_poisson.webp",
+  system: { quantite: 0, cout: 0.01, encombrement: 0.001, description: "" }
-    data: { quantite: 0, valeur_deniers: 1, encombrement: 0.001, description: "" }
+};
-  },
+const MONNAIE_BRONZE = {
-  {
+  name: "Sou (bronze)", type: 'monnaie',
-    name: "Bronze (10 deniers)", type: 'monnaie',
+  img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_bronze_epees.webp",
-    img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_bronze_epees.webp",
+  system: { quantite: 0, cout: 0.10, encombrement: 0.002, description: "" }
-    data: { quantite: 0, valeur_deniers: 10, encombrement: 0.002, description: "" }
+};
-  },
+const MONNAIE_ARGENT = {
-  {
+  name: "Sol (argent)", type: 'monnaie',
-    name: "Argent (1 sol)", type: 'monnaie',
+  img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_argent_sol.webp",
-    img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_argent_sol.webp",
+  system: { quantite: 0, cout: 1, encombrement: 0.003, description: "" }
-    data: { quantite: 0, valeur_deniers: 100, encombrement: 0.003, description: "" }
+};
-  },
+const MONNAIE_OR = {
-  {
+  name: "Dragon (or)", type: 'monnaie',
-    name: "Or (10 sols)", type: 'monnaie',
+  img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_or_sol.webp",
-    img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_or_sol.webp",
+  system: { quantite: 0, cout: 10, encombrement: 0.004, description: "" }
-    data: { quantite: 0, valeur_deniers: 1000, 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 {
 
-  static isSystemMonnaie(item) {
+  static monnaiesStandard() {
-    let present = monnaiesData.find(monnaie => monnaie.system.valeur_deniers == item?.system?.valeur_deniers);
+    return MONNAIES_STANDARD;
-    return present;
   }
 
-  static monnaiesData() {
+  static monnaiesManquantes(actor) {
-    return monnaiesData;
+    const disponibles = actor.itemTypes['monnaie'];
+    const manquantes = MONNAIES_STANDARD.filter(standard => !disponibles.find(disponible => Monnaie.deValeur(disponible, standard.system?.cout)));
+    if (manquantes.length > 0) {
+      console.error(`${LOG_HEAD} monnaiesManquantes pour ${actor.name}`, manquantes, ' avec monnaies', disponibles, MONNAIES_STANDARD);
+    }
+    return manquantes;
   }
 
-  static filtrerMonnaies(items) {
+  static deValeur(monnaie, valeur) {
-    return items.filter(it => it.type == 'monnaie');
+    return VALEUR_DENIERS(valeur) == VALEUR_DENIERS(monnaie.system.cout)
   }
 
-  static monnaiesManquantes(items) {
+  static triValeurEntiere() {
-    const valeurs = Monnaie.filtrerMonnaies(items)
+    return Misc.ascending(item => VALEUR_DENIERS(item.system.cout))
-      .map(it => it.system.valeur_deniers);
-    const manquantes = monnaiesData.filter(monnaie => !valeurs.find(v => v != monnaie.system?.valeur_deniers))
-    return []; //manquantes;
   }
 
-  static deValeur(monnaie, v) {
+  static async creerMonnaiesStandard(actor) {
-    return v != monnaie.system.valeur_deniers
+    await actor.createEmbeddedDocuments('Item', MONNAIES_STANDARD, { renderSheet: false });
   }
 
-  static arrondiDeniers(sols) {
+  static async creerMonnaiesDeniers(actor, fortune) {
-    return sols.toFixed(2);
+    await actor.createEmbeddedDocuments('Item', [Monnaie.creerDeniers(fortune)], { renderSheet: false });
   }
 
-  static triValeurDenier() {
+  static creerDeniers(fortune) {
-    return Misc.ascending(item => item.system.valeur_deniers)
+    const deniers = duplicate(MONNAIE_ETAIN);
+    deniers.system.quantite = fortune;
+    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 monnaies = actor.itemTypes['monnaie'];
+    let updates = [];
+    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) {
+        const quantite = Math.floor(resteEnDeniers / valeurDeniers);
+        if (quantite != itemPiece.system.quantite) {
+          updates.push({ _id: parValeur[valeurDeniers].id, 'system.quantite': quantite });
+        }
+        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) {
+      // 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

@@ -4,45 +4,72 @@ import { RdDAlchimie } from "./rdd-alchimie.js";
 import { RdDItemCompetence } from "./item-competence.js";
 import { RdDHerbes } from "./rdd-herbes.js";
 import { RdDGemme } from "./rdd-gemme.js";
-import { Misc } from "./misc.js";
 import { HtmlUtility } from "./html-utility.js";
-import { ReglesOptionelles } from "./regles-optionelles.js";
+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.object.system && this.object.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,231 +88,225 @@ export class RdDItemSheet extends ItemSheet {
   /* -------------------------------------------- */
   async getData() {
     let formData = {
-      id: this.object.id,
+      title: this.item.name,
-      title: this.object.name,
+      id: this.item.id,
-      type: this.object.type,
+      type: this.item.type,
-      img: this.object.img,
+      img: this.item.img,
-      name: this.object.name,
+      name: this.item.name,
-      data: this.object.system,
+      system: this.item.system,
-      isGM: game.user.isGM,
       actorId: this.actor?.id,
-      owner: this.document.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)
     }
-    if (this.actor) {
+    if (this.item.type == TYPES.competencecreature) {
-      formData.isOwned = true;
+      formData.isparade = RdDItemCompetenceCreature.isParade(this.item)
-      if (this.object.type == 'conteneur') {
+      formData.isdommages = RdDItemCompetenceCreature.isDommages(this.item)
-        this.prepareConteneurData(formData);
-      }
     }
 
-    formData.categorieCompetences = RdDItemCompetence.getCategorieCompetences()
+    const competences = await SystemCompendiums.getCompetences('personnage');
-    if (formData.type == 'tache' || formData.type == 'livre' || formData.type == 'meditation' || formData.type == 'oeuvre') {
+    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 = await RdDUtility.loadCompendium('foundryvtt-reve-de-dragon.competences')
+      formData.competences = competences;
     }
-    if (formData.type == 'arme') {
+    if (this.item.type == 'arme') {
-      formData.competences = await RdDUtility.loadCompendium('foundryvtt-reve-de-dragon.competences', it => RdDItemCompetence.isCompetenceArme(it));
+      formData.competences = competences.filter(it => RdDItemCompetence.isCompetenceArme(it))
-      console.log(formData.competences)
     }
-    if (formData.type == 'recettealchimique') {
+    if (['sort', 'sortreserve'].includes(this.item.type)) {
-      RdDAlchimie.processManipulation(objectData, this.actor && this.actor.id);
+      formData.competences = competences.filter(it => RdDItemCompetence.isDraconic(it));
     }
-    if (formData.type == 'gemme') {
+    if (this.item.type == 'recettecuisine') {
+      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.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.utilisation = await TextEditor.enrichHTML(this.object.system.utilisation, { async: true })
+      formData.enchantement = await TextEditor.enrichHTML(this.object.system.enchantement, { async: true })
+      formData.sureffet = await TextEditor.enrichHTML(this.object.system.sureffet, { async: true })
+    }
+    if (this.item.type == 'gemme') {
       formData.gemmeTypeList = RdDGemme.getGemmeTypeOptionList();
-      RdDGemme.calculDataDerivees(formData.data);
+      RdDGemme.calculDataDerivees(this.item);
     }
-    if (formData.type == 'potion') {
+    if (this.item.type == 'potion') {
-      if (this.dateUpdated) {
+      await RdDHerbes.addPotionFormData(formData);
-        formData.data.prdate = this.dateUpdated;
-        this.dateUpdated = undefined;
-      }
-      RdDHerbes.updatePotionData(formData);
     }
-    if (formData.isOwned && formData.type == 'herbe' && (formData.data.categorie == 'Soin' || formData.data.categorie == 'Repos')) {
+    if (formData.options.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.options.isOwned ? this.item.actor.items.get(sortId) : game.items.get(sortId);
+    }
     formData.bonusCaseList = RdDItemSort.getBonusCaseList(formData, true);
 
     return formData;
   }
 
-  /* -------------------------------------------- */
-  prepareConteneurData(formData) {
-    formData.itemsByType = Misc.classify(this.actor.items.map(i => foundry.utils.deepClone(i)))
-    RdDUtility.filterEquipementParType(formData)
-
-    this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.objets);
-    formData.subItems = formData.conteneurs.find(it => it._id == this.object.id)?.subItems;
-
-  }
-
   /* -------------------------------------------- */
   /** @override */
   activateListeners(html) {
     super.activateListeners(html);
+    this.html = html;
 
-    if (this.object.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.object.isOwned);
-    HtmlUtility._showControlWhen($(".item-magique"), this.object.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
-      if (this.object.data.type == 'competence') {
+    this.html.find(".categorie").change(event => this._onSelectCategorie(event));
-        RdDUtility.checkThanatosXP(this.object.data.name);
+
+    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);
-      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) {
+        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;
         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)));
-    html.find('.item-edit').click(async event => {
+      this.html.find('.item-vendre').click(async event => RdDSheetUtility.getItem(event, this.actor)?.proposerVente());
-      const item = RdDSheetUtility.getItem(event, this.actor);
+      this.html.find('.item-montrer').click(async event => RdDSheetUtility.getItem(event, this.actor)?.postItemToChat());
-      item.sheet.render(true);
+      this.html.find('.item-action').click(async event => RdDSheetUtility.getItem(event, this.actor)?.actionPrincipale(this.actor, this.getActionRenderItem()));
-    });
+
-    html.find('.item-delete').click(async event => {
+      this.html.find('.item-quantite-plus').click(async event => {
-      const li = RdDSheetUtility.getEventElement(event);
+        await this.actor.itemQuantiteIncDec(RdDSheetUtility.getItemId(event), 1)
-      RdDUtility.confirmerSuppression(this, li);
+        this.render();
-    });
+      });
-    html.find('.item-vendre').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?.proposerVente();
+        this.render();
-    });
+      });
-    html.find('.item-montrer').click(async event => {
+    }
-      const item = RdDSheetUtility.getItem(event, this.actor);
+
-      item?.postItem();
+    const updateItemTimestamp = (path, timestamp) => this.item.update({ [path]: duplicate(timestamp) })
-    });
+
-    html.find('.item-action').click(async event => {
+    RdDTimestamp.handleTimestampEditor(this.html, 'system.temporel.debut', updateItemTimestamp);
-      const item = RdDSheetUtility.getItem(event, this.actor);
+    RdDTimestamp.handleTimestampEditor(this.html, 'system.temporel.fin', updateItemTimestamp);
-      this.actor.actionItem(item, async () => itemSheetDialog.render(true));
-    });
-    html.find('.conteneur-name a').click(async event => {
-      RdDUtility.toggleAfficheContenu(RdDSheetUtility.getItemId(event));
-      this.render(true);
-    });
   }
 
+  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.object.isCompetence()) {
+    if (this.item.isCompetence()) {
-      let level = RdDItemCompetence.getNiveauBase(event.currentTarget.value);
+      const categorie = event.currentTarget.value;
-      this.object.system.base = level;
+      const level =  RdDItemCompetence.getNiveauBase(categorie, this.item.getCategories());
-      $("#base").val(level);
+      this.item.system.base = level;
+      this.html.find('[name="system.base"]').val(level);
     }
   }
 
   /* -------------------------------------------- */
-  get template() {
+  /** @override */
-    let type = this.object.type
+  _updateObject(event, formData) {
-    return `systems/foundryvtt-reve-de-dragon/templates/item-${type}-sheet.html`;
+    if (this.item.type == 'sort') {
+      // Données de bonus de cases ?
+      formData['system.bonuscase'] = RdDItemSort.buildBonuscaseFromArrays(formData.bonusValue, formData.caseValue);
+    }
+    return this.item.update(formData);
   }
 
   /* -------------------------------------------- */
-
-  /** @override */
-  _updateObject(event, formData) { // Deprecated en v0.8 à clarifier    
-    // Données de bonus de cases ?
-    formData = RdDItemSort.buildBonusCaseStringFromFormData(formData);
-
-    return this.object.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.data
-    };
-
-    event.dataTransfer.setData("text/plain", JSON.stringify(dragData));
   }
 
   async _onDrop(event) {
-    // Try to extract the data
+    // Try to extract the dragData
-    let data;
+    let dragData = RdDItemSheet.$extractDragData(event);
-    try {
+    if (!dragData) return false;
-      data = JSON.parse(event.dataTransfer.getData('text/plain'));
+    const allowed = Hooks.call("dropActorSheetData", this.actor, this, dragData);
-    } catch (err) {
+    if (allowed === false) return false;
-      return false;
-    }
 
-    const allowed = Hooks.call("dropActorSheetData", this.actor, this, data);
+    // Handle different dragData types
-    if (allowed === false) return;
+    switch (dragData.type) {
-
-    // Handle different data types
-    switch (data.type) {
       case "Item":
-        return this._onDropItem(event, data);
+        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.object.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-signedraconique-sheet.js

@@ -1,96 +0,0 @@
-import { SYSTEM_RDD } from "./constants.js";
-import { RdDItemSigneDraconique } from "./item-signedraconique.js";
-import { Misc } from "./misc.js";
-import { TMRType, TMRUtility } from "./tmr-utility.js";
-
-/**
- * Item sheet pour signes draconiques
- * @extends {ItemSheet}
- */
-export class RdDSigneDraconiqueItemSheet extends ItemSheet {
-
-  /** @override */
-  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 */
-  setPosition(options = {}) {
-    const position = super.setPosition(options);
-    const sheetHeader = this.element.find(".sheet-header");
-    const sheetBody = this.element.find(".sheet-body");
-    const bodyHeight = position.height - sheetHeader[0].clientHeight;
-    sheetBody.css("height", bodyHeight);
-    return position;
-  }
-
-
-  /* -------------------------------------------- */
-  async getData() {
-    const formData = duplicate(this.object);
-    mergeObject(formData, {
-      title: formData.name,
-      isGM: game.user.isGM,
-      owner: this.document.isOwner,
-      isOwned: this.actor ? true : false,
-      actorId: this.actor?.id,
-      editable: this.isEditable,
-      cssClass: this.isEditable ? "editable" : "locked",
-    });
-    formData.tmrs = TMRUtility.listSelectedTMR(formData.data.typesTMR ?? []);
-    return formData;
-  }
-
-  /* -------------------------------------------- */
-  /** @override */
-  activateListeners(html) {
-    super.activateListeners(html);
-
-    if (!this.options.editable) return;
-
-    html.find(".signe-aleatoire").click(event => this.setSigneAleatoire());
-    html.find(".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)));
-  }
-
-  async setSigneAleatoire() {
-    const newSigne = await RdDItemSigneDraconique.randomSigneDraconique();
-    this.object.update(newSigne);
-  }
-
-  async onSelectTmr(event) {
-    event.preventDefault();
-    const selectedTMR = $(".select-tmr").val();
-    this.object.update({ 'data.typesTMR': selectedTMR });
-  }
-
-  async onValeurXpSort(event) {
-    const codeReussite = event.currentTarget.attributes['data-typereussite']?.value ?? 0;
-    const xp = Number(event.currentTarget.value);
-    const oldValeur = this.object.system.valeur;
-    const newValeur = RdDItemSigneDraconique.calculValeursXpSort(codeReussite, xp, oldValeur);
-    await this.object.update({ 'data.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-sort.js

@@ -1,4 +1,3 @@
-/* -------------------------------------------- */
 import { Misc } from "./misc.js";
 import { TMRUtility } from "./tmr-utility.js";
 
@@ -7,16 +6,16 @@ export class RdDItemSort extends Item {
 
   /* -------------------------------------------- */
   static isDifficulteVariable(sort) {
-    return sort && (sort.data.difficulte.toLowerCase() == "variable");
+    return sort && (sort.system.difficulte.toLowerCase() == "variable");
   }
 
   /* -------------------------------------------- */
   static isCoutVariable(sort) {
-    return sort && (sort.data.ptreve.toLowerCase() == "variable" || sort.data.ptreve.indexOf("+") >= 0);
+    return sort && (sort.system.ptreve.toLowerCase() == "variable" || sort.system.ptreve.indexOf("+") >= 0);
   }
- 
+
   /* -------------------------------------------- */
-  static setCoutReveReel(sort){
+  static setCoutReveReel(sort) {
     if (sort) {
       sort.system.ptreve_reel = this.isCoutVariable(sort) ? 1 : sort.system.ptreve;
     }
@@ -25,99 +24,91 @@ export class RdDItemSort extends Item {
   /* -------------------------------------------- */
   static getDifficulte(sort, variable) {
     if (sort && !RdDItemSort.isDifficulteVariable(sort)) {
-       return Misc.toInt(sort.data.difficulte);
+      return Misc.toInt(sort.system.difficulte);
     }
     return variable;
   }
 
   /* -------------------------------------------- */
-  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 = [];
-      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;
     }
-    
+    return list;
-  /* -------------------------------------------- */
+  }
+
   /**
    * 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.data.bonuscase, newCase );
+      return RdDItemSort.buildBonusCaseList(item.system.bonuscase, newCase);
     }
     return undefined;
   }
-    
+
-    /* -------------------------------------------- */
-    /** Met à jour les données de formulaire 
-     * si static des bonus de cases sont présents 
-     * */
-    static buildBonusCaseStringFromFormData( formData ) {
-      if ( formData.bonusValue ) {
-        let list = [];
-        let caseCheck = {};
-        for(let i=0; i<formData.bonusValue.length; i++) {
-          let coord = formData.caseValue[i] || 'A1';
-          coord = coord.toUpperCase();
-          if ( TMRUtility.verifyTMRCoord( coord  ) ) { // Sanity check
-            let bonus = formData.bonusValue[i] || 0;
-            if ( bonus > 0 && caseCheck[coord] == undefined ) {
-              caseCheck[coord] = bonus;
-              list.push( coord+":"+bonus );  
-            }
-          }
-        }
-        formData.bonusValue = undefined; 
-        formData.caseValue  = undefined; 
-        formData['data.bonuscase'] = list.toString(); // Reset
-      }
-      return formData;
-  }
-  
   /* -------------------------------------------- */
-  static incrementBonusCase( actor, sort, coord ) {
+  /** Met à jour les données de formulaire 
-      let bonusCaseList = this.buildBonusCaseList(sort.data.bonuscase, false);
+   * si static des bonus de cases sont présents 
-      //console.log("ITEMSORT", sort, bonusCaseList);
+   * */
-      
+  static buildBonuscaseFromArrays(bonuses, coords) {
-      let found = false;
+    if (bonuses) {
-      let StringList = []; 
+      const list = [];
-      for( let bc of bonusCaseList) {
+      const caseCheck = {};
-        if (bc.case == coord) { // Case existante
+      for (let i = 0; i < bonuses.length && i < coords.length; i++) {
-          found = true;
+        const coord = coords[i] == 'Fleuve' ? 'Fleuve' : (coords[i]?.toUpperCase() ?? 'A1');
-          bc.bonus = Number(bc.bonus) + 1;
+        const bonus = bonuses[i] || 0;
+        if (TMRUtility.verifyTMRCoord(coord) && bonus > 0 && caseCheck[coord] == undefined) {
+          caseCheck[coord] = bonus;
+          list.push({ case: coord, bonus: bonus });
         }
-        StringList.push( bc.case+':'+bc.bonus );
-      }
-      if ( !found) { //Nouvelle case, bonus de 1
-        StringList.push(coord+':1');
-      }
-  
-      // Sauvegarde/update
-      let bonuscase = StringList.toString();
-      //console.log("Bonus cae :", bonuscase);
-      actor.updateEmbeddedDocuments('Item', [{ _id: sort._id, 'data.bonuscase': bonuscase }] );
-  }
-  
-  /* -------------------------------------------- */
-  static getCaseBonus( sort, coord) {
-    let bonusCaseList = this.buildBonusCaseList(sort.data.bonuscase, false);
-    for( let bc of bonusCaseList) {
-      if (bc.case == coord) { // Case existante
-        return Number(bc.bonus);
       }
+      return RdDItemSort._bonuscaseListToString(list);
     }
-    return 0;
+    return undefined;
+  }
+
+  /* -------------------------------------------- */
+  static incrementBonusCase(actor, sort, coord) {
+    if (TMRUtility.getTMR(coord).type == "fleuve") {
+      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 };
+
+    const bonuscase = RdDItemSort._bonuscaseListToString(
+      list.filter(it => it.case != coord).concat(modified)
+    );
+
+    // Sauvegarde/update
+    actor.updateEmbeddedDocuments('Item', [{ _id: sort._id, 'system.bonuscase': bonuscase }]);
+  }
+
+
+  /* -------------------------------------------- */
+  static getCaseBonus(sort, coord) {
+    const isFleuve = TMRUtility.getTMR(coord).type == "fleuve";
+
+    let bc = RdDItemSort.buildBonusCaseList(sort.system.bonuscase, false)
+      .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(',');
+  }
+  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/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

@@ -0,0 +1,80 @@
+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 },
+  { code: "passeur", resultat: "succes", description: "Déplacer le demi-rêve à (force) cases", method: EffetsRencontre.passeur},
+  { code: "reve+f", resultat: "succes", description: "Gain de (force) points de rêve" , method: EffetsRencontre.reve_plus_force},
+  { code: "teleport", resultat: "succes", description: "Déplacer le demi-rêve (même type)", method: EffetsRencontre.teleportation_typecase },
+  { code: "part+tete", resultat: "succes", description: "Tête de dragon sur réussite particulière", method: EffetsRencontre.rdd_part_tete },
+  { code: "part+xp", resultat: "succes", description: "Expérience sur réussite particulière", method: EffetsRencontre.experience_particuliere },
+  { code: "seuil", resultat: "succes", description: "Récupération de seuil de rêve", method: EffetsRencontre.regain_seuil },
+
+  { code: "reve-1", resultat: "echec", description: "Perte de 1 point de rêve", method: EffetsRencontre.reve_moins_1 },
+  { code: "reve-f", resultat: "echec", description: "Perte de (force) points de rêve", method: EffetsRencontre.reve_moins_force },
+  { code: "vie-1", resultat: "echec", description: "Perte de 1 point de vie", method: EffetsRencontre.vie_moins_1 },
+  { code: "reinsere", resultat: "echec", description: "Réinsertion aléatoire", method: EffetsRencontre.reinsertion },
+  { code: "persistant", resultat: "echec", description: "Bloque le demi-rêve", method: EffetsRencontre.rencontre_persistante },
+  { code: "teleport-aleatoire", resultat: "echec", description: "Déplacement aléatoire (même type)", method: EffetsRencontre.teleportation_aleatoire_typecase },
+  { code: "aleatoire", resultat: "echec", description: "Déplacement aléatoire", method: EffetsRencontre.deplacement_aleatoire },
+  { code: "sort-aleatoire", resultat: "echec", description: "Déclenche un sort en réserve aléatoire", method: EffetsRencontre.sort_aleatoire },
+  { code: "rompu", resultat: "echec", description: "Demi-rêve interrompu", method: EffetsRencontre.demireve_rompu },
+  { code: "echec-queue", resultat: "echec", description: "Queue(s) de dragon sur échec", method: EffetsRencontre.rdd_echec_queue },
+
+  { code: "reve+1", resultat: "succes", description: "Gain de 1 point de rêve", method: EffetsRencontre.reve_plus_1 },
+  { code: "vie-f", resultat: "echec", description: "Perte de (force) points de vie", method: EffetsRencontre.vie_moins_force },
+  { code: "moral+1", resultat: "succes", description: "Gain de 1 point de moral", method: EffetsRencontre.moral_plus_1 },
+  { code: "moral-1", resultat: "echec", description: "Perte de 1 point de moral", method: EffetsRencontre.moral_moins_1 },
+  { code: "xpsort+f", resultat: "succes", description: "Gain de (force) xp sort", method: EffetsRencontre.xp_sort_force },
+  { code: "endurance-1", resultat: "echec", description: "Perte de 1 point d'endurance", method: EffetsRencontre.end_moins_1 },
+  { code: "endurance-f", resultat: "echec", description: "Perte de (force) points d'endurance", method: EffetsRencontre.end_moins_force },
+  { code: "fatigue+1", resultat: "echec", description: "Coup de fatigue de 1 point", method: EffetsRencontre.fatigue_plus_1},
+  { code: "fatigue+f", resultat: "echec", description: "Coup de fatigue de 1 (force) points", method: EffetsRencontre.fatigue_plus_force },
+  { code: "fatigue-1", resultat: "succes", description: "Récupération de 1 point de fatigue", method: EffetsRencontre.fatigue_moins_1},
+  { code: "fatigue-f", resultat: "succes", description: "Récupération de 1 (force) points de fatigue", method: EffetsRencontre.fatigue_moins_force },
+  { code: "perte-chance", resultat: "echec", description: "Perte de chance actuelle", method: EffetsRencontre.perte_chance },
+  { code: "stress+1", resultat: "succes", description: "Gain de 1 point de stress", method: EffetsRencontre.stress_plus_1 },
+  // { code: "epart-souffle", resultat: "echec", description: "Souffle de dragon sur échec particulier" },
+];
+
+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"); }
+  static getEffets(resultat) {
+    return tableEffets.filter(e => resultat == e.resultat);
+  }
+  
+  static mapEffets(liste) {
+    return liste.map(it => RdDRencontre.getEffet(it));
+  }
+  
+  static getListeEffets(item, reussite) {
+    if (reussite == 'echec') {
+      return [...item.system.echec.effets];
+    }
+    if (reussite == 'succes') {
+      return [...item.system.succes.effets];
+    }
+    return [];
+  }
+
+  static getEffet(code) {
+    return tableEffets.find(it => code == it.code)
+  }
+
+  static async appliquer(codes, tmrDialog, rencData) {
+    for(const effet of RdDRencontre.mapEffets(codes)){
+      await effet.method(tmrDialog, rencData);
+    }
+  }
+
+  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

@@ -0,0 +1,78 @@
+import { RdDRencontre } from "./rencontre.js";
+import { RdDItemSheet } from "../item-sheet.js";
+
+export class RdDRencontreItemSheet extends RdDItemSheet {
+  
+  static get ITEM_TYPE() { return "rencontre" };
+
+  static get defaultOptions() {
+    return mergeObject(super.defaultOptions, {
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }]
+    });
+  }
+
+  /* -------------------------------------------- */
+  /** @override */
+  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();
+    mergeObject(formData, {
+      effets: {
+        succes: {
+          liste: RdDRencontre.getEffetsSucces(),
+          select: RdDRencontre.mapEffets(this.item.system.succes.effets)
+        },
+        echec: {
+          liste: RdDRencontre.getEffetsEchec(),
+          select: RdDRencontre.mapEffets(this.item.system.echec.effets)
+        }
+      }
+    });
+    return formData;
+  }
+
+  /* -------------------------------------------- */
+  /** @override */
+  activateListeners(html) {
+    super.activateListeners(html);
+    if (!this.options.editable) return;
+    this.html.find("a.effet-add").click(event => this.onAddEffet(event));
+    this.html.find("a.effet-delete").click(event => this.onDeleteEffet(event));
+  }
+
+  async onAddEffet(event) {
+    const resultat = this.html.find(event.currentTarget)?.data("effet-resultat");
+    const keyEffets = `system.${resultat}.effets`;
+
+    const code = this.html.find(event.currentTarget)?.data("effet-code");
+    const liste = RdDRencontre.getListeEffets(this.item, resultat);
+    liste.push(code);
+
+    await this._updateEffetsRencontre(keyEffets, liste);
+  }
+
+  async onDeleteEffet(event) {
+    const resultat = this.html.find(event.currentTarget)?.data("effet-resultat");
+    const keyEffets = `system.${resultat}.effets`;
+    
+    const pos = this.html.find(event.currentTarget)?.data("effet-pos");
+    const liste = RdDRencontre.getListeEffets(this.item, resultat);
+    liste.splice(pos, 1);
+    
+    await this._updateEffetsRencontre(keyEffets, liste);
+  }
+  
+  async _updateEffetsRencontre(key, liste) {
+    const updates = {};
+    updates[key] = liste;
+    this.item.update(updates);
+  }
+}

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