.gitignore

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

changelog.md

@@ -1,298 +1,10 @@
-# v10.7 - L'os de Sémolosse
+==================================================================
+v0.9.2 - 05/09/2020
 
-## v10.7.20 - la poigne de Sémolosse
+Erreur de calcul sur points de vie
-- correction de méthodes qui filtrent les items
+Gestion différente des compétences "troncs"
-  - 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
+==================================================================
-- correction de l'empoignade
+v0.9.1 - 03/09/2020
-  - 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
 
-## v10.7.19 - les fantômes de Sémolosse
+Initial official release
-- 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,52 +3,46 @@
     "TypePersonnage": "Personnage",
     "TypeCreature": "Créature",
     "TypeEntite": "Entité de cauchemar",
-    "TypeCommerce": "Commerce",
     "TypeVehicule": "Véhicule"
   },
   "ITEM": {
-    "TypeArme": "Arme",
+    "TypeObjet": "Objet",
-    "TypeArmure": "Armure",
+    "TypeGemme": "Gemme",
-    "TypeBlessure": "Blessure",
-    "TypeCasetmr": "TMR spéciale",
-    "TypeChant": "Chant",
     "TypeCompetence": "Compétence",
     "TypeCompetencecreature": "Compétence de créature",
-    "TypeConteneur": "Conteneur",
-    "TypeDanse": "Danse",
-    "TypeExtraitpoetique": "Extrait poetique",
-    "TypeFaune": "Faune",
-    "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",
+    "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",
-    "TypeQueue": "Queue de Dragon",
+    "TypeArme": "Arme",
+    "TypeArmure": "Armure",
+    "TypeConteneur": "Conteneur",
+    "TypeNourritureboisson": "Nourriture & boisson",
+    "TypeChant": "Chant",
+    "TypeDanse": "Danse",
+    "TypeMusique": "Musique",
+    "TypeOeuvre": "Oeuvre",
+    "TypeTache": "Tâche",
+    "TypeJeu": "Jeu",
     "TypeRecettealchimique": "Recette alchimique",
     "TypeRecettecuisine": "Recette de cuisine",
-    "TypeRencontre": "Rencontre TMR",
-    "TypeService": "Service",
-    "TypeSignedraconique": "Signe draconique",
     "TypeSort": "Sort",
-    "TypeSortreserve": "Sort en réserve",
+    "TypeMeditation": "Méditation",
+    "TypeSignedraconique": "Signe draconique",
+    "TypeQueue": "Queue de Dragon",
+    "TypeOmbre": "Ombre de Thanatos",
     "TypeSouffle": "Souffle de Dragon",
-    "TypeTache": "Tâche",
+    "TypeTete": "Tête de Dragon",
-    "TypeTarot": "Carte de tarot",
+    "TypePossession": "Possession",
-    "TypeTete": "Tête de Dragon"
+    "TypeSortreserve": "Sort en réserve"
   },
   "EFFECT": {
     "StatusStunned": "Sonné",

module/actor-creature-sheet.js

@@ -1,9 +1,14 @@
-import { RdDActorSheet } from "./actor-sheet.js";
 
 /**
  * Extend the basic ActorSheet with some very simple modifications
  * @extends {ActorSheet}
  */
+
+import { RdDUtility } from "./rdd-utility.js";
+import { RdDActorSheet } from "./actor-sheet.js";
+import { RdDCarac } from "./rdd-carac.js";
+
+/* -------------------------------------------- */
 export class RdDActorCreatureSheet extends RdDActorSheet {
 
   /** @override */
@@ -14,7 +19,7 @@ export class RdDActorCreatureSheet extends RdDActorSheet {
       width: 640,
       height: 720,
       tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }],
-      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }]
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }]
     });
   }
 
@@ -27,17 +32,24 @@ export class RdDActorCreatureSheet extends RdDActorSheet {
     if (!this.options.editable) return;
 
     // On competence change
-    this.html.find('.creature-carac').change(async event => {
+    html.find('.creature-carac').change(async event => {
       let compName = event.currentTarget.attributes.compname.value;
       this.actor.updateCreatureCompetence(compName, "carac_value", parseInt(event.target.value));
     });
-    this.html.find('.creature-niveau').change(async event => {
+    html.find('.creature-niveau').change(async event => {
       let compName = event.currentTarget.attributes.compname.value;
       this.actor.updateCreatureCompetence(compName, "niveau", parseInt(event.target.value));
     });
-    this.html.find('.creature-dommages').change(async event => {
+    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,65 +1,42 @@
 import { RdDActorSheet } from "./actor-sheet.js";
-import { RdDSheetUtility } from "./rdd-sheet-utility.js";
+import { HtmlUtility } from "./html-utility.js";
 import { RdDUtility } from "./rdd-utility.js";
 
 export class RdDActorEntiteSheet extends RdDActorSheet {
 
   /** @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: undefined }]
+      dragDrop: [{dragSelector: ".item-list .item", dropSelector: null}]
     });
   }
-  async getData() {
-    let formData = await super.getData();
-    formData.resonances = this.actor.system.sante.resonnance.actors.map(actorId => game.actors.get(actorId))
-      .map(actor => { return { id: actor.id, name: actor.name, img: actor.img } })
-    return formData
-  }
 
   /* -------------------------------------------- */
   /** @override */
-  activateListeners(html) {
+	activateListeners(html) {
     super.activateListeners(html);
 
     // Everything below here is only needed if the sheet is editable
     if (!this.options.editable) return;
 
     // On competence change
-    this.html.find('.creature-carac').change(async event => {
+    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) );
-    });
+      } );    
-    this.html.find('.creature-niveau').change(async event => {
+    html.find('.creature-niveau').change(async event => {
-      let compName = event.currentTarget.attributes.compname.value;
+        let compName = event.currentTarget.attributes.compname.value;
-      this.actor.updateCreatureCompetence(compName, "niveau", parseInt(event.target.value));
+        this.actor.updateCreatureCompetence( compName, "niveau", parseInt(event.target.value) );
-    });
+      } );    
-    this.html.find('.creature-dommages').change(async event => {
+      html.find('.creature-dommages').change(async event => {
-      let compName = event.currentTarget.attributes.compname.value;
+        let compName = event.currentTarget.attributes.compname.value;
-      this.actor.updateCreatureCompetence(compName, "dommages", parseInt(event.target.value));
+        this.actor.updateCreatureCompetence( compName, "dommages", parseInt(event.target.value) );
-    });
+      } );    
-    this.html.find('.resonance-delete').click(async event => {
-      const li = RdDSheetUtility.getEventElement(event);
-      const actorId = li.data("actor-id");
-      if (actorId) {
-        const actorResonance = game.actors.get(actorId);
-        RdDUtility.confirmerSuppressionSubacteur(this, actorResonance, li, () => {
-          console.log('Delete : ', actorId);
-          this.removeSubacteur(actorId);
-          RdDUtility.slideOnDelete(this, li);
-        });
-      }
-    });
-  }
-
-  async removeSubacteur(actorId) {
-    let newResonances = this.actor.system.sante.resonnance.actors.filter(id => id != actorId);
-    await this.actor.update({ 'system.sante.resonnance.actors': newResonances }, { renderSheet: false });
   }
 
 }

module/actor-sheet.js

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

module/actor-vehicule-sheet.js

@@ -1,4 +1,5 @@
 import { RdDUtility } from "./rdd-utility.js";
+import { RdDSheetUtility } from "./rdd-sheet-utility.js";
 import { RdDActorSheet } from "./actor-sheet.js";
 
 /* -------------------------------------------- */
@@ -14,26 +15,9 @@ export class RdDActorVehiculeSheet extends RdDActorSheet {
       width: 640,
       height: 720,
       tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }],
-      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }]
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }]
     });
   }
 
-  activateListeners(html) {
-    super.activateListeners(html);
-    if (!this.options.editable) return;
-
-    this.html.find('.resistance-moins').click(async event => {
-      this.actor.vehicleIncDec("resistance", -1);
-    });
-    this.html.find('.resistance-plus').click(async event => {
-      this.actor.vehicleIncDec("resistance", 1);
-    });
-    this.html.find('.structure-moins').click(async event => {
-      this.actor.vehicleIncDec("structure", -1);
-    });
-    this.html.find('.structure-plus').click(async event => {
-      this.actor.vehicleIncDec("structure", 1);
-    });
-  }
 
 }

module/actor/base-actor-sheet.js

@@ -1,301 +0,0 @@
-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

@@ -1,644 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

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

module/chat-utility.js

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

module/dialog-chronologie.js

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

module/dialog-fabriquer-potion.js

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

module/dialog-item-achat.js

@@ -1,13 +1,15 @@
+
+import { Monnaie } from "./item-monnaie.js";
 import { Misc } from "./misc.js";
 import { RdDUtility } from "./rdd-utility.js";
 
 export class DialogItemAchat extends Dialog {
 
-  static preparerAchat(chatButton) {
+  static venteData(button) {
-    const vendeurId = chatButton.attributes['data-vendeurId']?.value;
+    const vendeurId = button.attributes['data-vendeurId']?.value;
     const vendeur = vendeurId ? game.actors.get(vendeurId) : undefined;
     const acheteur = RdDUtility.getSelectedActor();
-    const json = chatButton.attributes['data-jsondata']?.value;
+    const json = button.attributes['data-jsondata']?.value;
     if (!acheteur && !vendeur) {
       ui.notifications.info("Pas d'acheteur ni de vendeur, aucun changement");
       return undefined;
@@ -17,85 +19,64 @@ export class DialogItemAchat extends Dialog {
       return undefined;
     }
 
+    const prixLot = Monnaie.arrondiDeniers(button.attributes['data-prixLot']?.value ?? 0);
     return {
-      item: JSON.parse(json),
+      item: json ? JSON.parse(json) : undefined,
-      vendeur,
+      vendeurId: vendeurId,
-      acheteur,
+      vendeur: vendeur,
-      nbLots: parseInt(chatButton.attributes['data-quantiteNbLots']?.value),
+      acheteur: acheteur,
-      tailleLot: parseInt(chatButton.attributes['data-tailleLot']?.value ?? 1),
+      tailleLot: parseInt(button.attributes['data-tailleLot']?.value ?? 1),
-      prixLot: Number(chatButton.attributes['data-prixLot']?.value ?? 0),
+      quantiteIllimite: button.attributes['data-quantiteIllimite']?.value == 'true',
-      quantiteIllimite: chatButton.attributes['data-quantiteIllimite']?.value == 'true',
+      quantiteNbLots: parseInt(button.attributes['data-quantiteNbLots']?.value),
-      chatMessageIdVente: RdDUtility.findChatMessageId(chatButton),
+      choix: {
-    };
+        nombreLots: 1,
-  }
+        seForcer: false,
-
+        supprimerSiZero: true
-
+      },
-  static async onAcheter({ item, vendeur, acheteur, tailleLot, prixLot, nbLots, quantiteIllimite, chatMessageIdVente }) {
+      prixLot: prixLot,
-    const venteData = {
+      prixTotal: prixLot,
-      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: RdDUtility.findChatMessageId(button)
-      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 async onAcheter(venteData) {
-  static changeNombreLots(venteData, nombreLots) {
+    const html = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/dialog-item-achat.html`, venteData);
-    venteData.choix.nombreLots = nombreLots;
+    const dialog = new DialogItemAchat(html, venteData);
-    venteData.prixTotal = (nombreLots * venteData.prixLot).toFixed(2);
+    dialog.render(true);
-    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 isConsommable = venteData.item.type == 'nourritureboisson' && venteData.acheteur?.isPersonnage();
+    let options = { classes: ["dialogachat"], width: 400, height: isConsommable ? 450 : 350, 'z-index': 99999 };
 
     const actionAchat = venteData.prixLot > 0 ? "Acheter" : "Prendre";
     const buttons = {};
-    if (venteData.isConsommable) {
+    if (isConsommable) {
-      buttons["consommer"] = { label: venteData.item.system.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: `${acheteur} - ${actionAchat} à ${vendeur}`,
+      title: venteData.acheteur ? venteData.acheteur.name + " - " + actionAchat : actionAchat,
       content: html,
       default: actionAchat,
       buttons: buttons
     };
 
     super(conf, options);
+
     this.venteData = venteData;
   }
 
   async onAchat() {
-    await this.html.find(".nombreLots").change();
+    await $(".nombreLots").change();
     (this.venteData.vendeur ?? this.venteData.acheteur).achatVente({
       userId: game.user.id,
       vendeurId: this.venteData.vendeur?.id,
       acheteurId: this.venteData.acheteur?.id,
       prixTotal: this.venteData.prixTotal,
       chatMessageIdVente: this.venteData.chatMessageIdVente,
-      choix: this.venteData.choix,
+      choix: this.venteData.choix
-      vente: this.venteData
     });
   }
 
@@ -107,9 +88,9 @@ export class DialogItemAchat extends Dialog {
   /* -------------------------------------------- */
   activateListeners(html) {
     super.activateListeners(html);
-    this.html = html;
+
-    this.html.find(".nombreLots").change(event => this.setNombreLots(Number(event.currentTarget.value)));
+    html.find(".nombreLots").change(event => this.setNombreLots(Number(event.currentTarget.value)));
-    this.html.find(".se-forcer").change(event => this.setSeForcer(event));
+    html.find(".se-forcer").change(event => this.setSeForcer(event));
   }
 
   setSeForcer(event) {
@@ -117,21 +98,13 @@ export class DialogItemAchat extends Dialog {
   }
 
   setNombreLots(nombreLots) {
-
+    if (nombreLots > this.venteData.quantiteNbLots) {
-    if (!this.venteData.quantiteIllimite) {
+      ui.notifications.warn(`Seulement ${this.venteData.quantiteNbLots} lots disponibles, vous ne pouvez pas en prendre ${nombreLots}`)
-      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);
     }
-
+    this.venteData.choix.nombreLots = Math.min(nombreLots, this.venteData.quantiteNbLots);
-    DialogItemAchat.changeNombreLots(this.venteData, nombreLots);
+    this.venteData.prixTotal = (nombreLots * this.venteData.prixLot).toFixed(2);
-
+    $(".nombreLots").val(this.venteData.choix.nombreLots);
-    this.html.find(".nombreLots").val(nombreLots);
+    $(".prixTotal").text(this.venteData.prixTotal);
-    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: 'fit-content', 'z-index': 99999 };
+    const options = { classes: ["dialogconsommer"], width: 350, height: 450, 'z-index': 99999 };
     let conf = {
       title: consommerData.title,
       content: html,
@@ -17,9 +17,8 @@ export class DialogConsommer extends Dialog {
       buttons: {
         [consommerData.buttonName]: {
           label: consommerData.buttonName, callback: async it => {
-            await this.onConsommer();
+            await this.onConsommer(it);
-            await onActionItem();
+            await onActionItem();}
-          }
         }
       }
     };
@@ -31,23 +30,17 @@ export class DialogConsommer extends Dialog {
     this.consommerData = consommerData;
   }
 
-  activateListeners(html) {
+  async onConsommer(event) {
-    super.activateListeners(html);
+    await $(".se-forcer").change();
-    this.html = html;
+    await $(".consommer-doses").change();
-    this.html.find(".se-forcer").change(event => this.setSeForcer(event));
-    this.html.find(".consommer-doses").change(event => this.selectDoses(event));
-  }
-
-  async onConsommer() {
-    await this.html.find(".se-forcer").change();
-    await this.html.find(".consommer-doses").change();
     await this.actor.consommer(this.item, this.consommerData.choix);
   }
 
   /* -------------------------------------------- */
   static prepareData(actor, item) {
+    item = duplicate(item);
     let consommerData = {
-      item: duplicate(item),
+      item: item,
       cuisine: actor.getCompetence('cuisine'),
       choix: {
         doses: 1,
@@ -55,47 +48,33 @@ export class DialogConsommer extends Dialog {
       }
     }
     switch (item.type) {
-      case 'herbe': case 'faune':
-        consommerData.title = 'Manger une portion crue: ';
-        consommerData.buttonName = "Manger";
-        break;
       case 'nourritureboisson':
-        consommerData.title = item.system.boisson ? 'Boire une dose: ' : 'Manger une portion: ';
+        consommerData.title = item.system.boisson ? `${item.name}: boire une dose` : `${item.name}: manger une portion`;
         consommerData.buttonName = item.system.boisson ? "Boire" : "Manger";
         break;
       case 'potion':
-        consommerData.title = 'Boire la potion: ';
+        consommerData.title = `${item.name}: boire la potion`;
         consommerData.buttonName = "Boire";
         break;
     }
-    consommerData.title += item.name;
+    DialogConsommer.calculDoses(consommerData, consommerData.choix.doses)
-    DialogConsommer.calculDoses(consommerData, item)
     return consommerData;
   }
 
-  static calculDoses(consommer, item) {
+  static calculDoses(consommer) {
     const doses = consommer.choix.doses;
-    switch (item.type) {
+    consommer.totalSust = Misc.keepDecimals(doses * (consommer.item.system.sust ?? 0), 2);
-      case 'herbe': case 'faune':
+    consommer.totalDesaltere = consommer.item.system.boisson
-        consommer.totalSust = doses;
+      ? Misc.keepDecimals(doses * (consommer.item.system.desaltere ?? 0), 2)
-        consommer.totalDesaltere = 0;
+      : 0;
-        consommer.choix.sust = 1;
+  }
-        consommer.choix.quantite = 0;
+
-        consommer.choix.encombrement = Misc.keepDecimals(consommer.item.system.encombrement / item.system.sust, 2);
+
-        return;
+  /* -------------------------------------------- */
-      case 'nourritureboisson':
+  activateListeners(html) {
-        consommer.choix.sust = consommer.item.system.sust;
+    super.activateListeners(html);
-        consommer.choix.quantite = doses;
+    html.find(".se-forcer").change(event => this.setSeForcer(event));
-        consommer.choix.encombrement = 0
+    html.find(".consommer-doses").change(event => this.selectDoses(event));
-        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
-    }
   }
 
 
@@ -105,8 +84,8 @@ export class DialogConsommer extends Dialog {
 
   selectDoses(event) {
     this.consommerData.choix.doses = Number(event.currentTarget.value);
-    DialogConsommer.calculDoses(this.consommerData, this.item);
+    DialogConsommer.calculDoses(this.consommerData);
-    this.html.find(".total-sust").text(this.consommerData.totalSust);
+    $(".total-sust").text(this.consommerData.totalSust);
-    this.html.find(".total-desaltere").text(this.consommerData.totalDesaltere);
+    $(".total-desaltere").text(this.consommerData.totalDesaltere);
   }
 }

module/dialog-item-vente.js

@@ -1,30 +1,30 @@
 import { HtmlUtility } from "./html-utility.js";
+import { Misc } from "./misc.js";
 
 export class DialogItemVente extends Dialog {
 
-  static async display({ item, callback, quantiteMax = undefined }) {
+  static async display(item, callback) {
-    const quantite = quantiteMax ?? item.getQuantite() ?? 1;
+    const quantite = item.isConteneur() ? 1 : item.system.quantite;
-    const isOwned = item.parent;
     const venteData = {
       item: item,
       alias: item.actor?.name ?? game.user.name,
       vendeurId: item.actor?.id,
-      prixOrigine: item.calculerPrixCommercant(),
+      prixOrigine: item.system.cout,
-      prixUnitaire: item.calculerPrixCommercant(),
+      prixUnitaire: item.system.cout,
-      prixLot: item.calculerPrixCommercant(),
+      prixLot: item.system.cout,
       tailleLot: 1,
       quantiteNbLots: quantite,
       quantiteMaxLots: quantite,
-      quantiteMax: quantite,
+      quantiteMax: quantite ,
-      quantiteIllimite: item.isItemCommerce() ? quantiteMax == undefined : !isOwned,
+      quantiteIllimite: !item.isOwned,
-      isOwned: isOwned,
+      isOwned: item.isOwned,
     };
     const html = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/dialog-item-vente.html`, venteData);
     return new DialogItemVente(venteData, html, callback).render(true);
   }
 
   constructor(venteData, html, callback) {
-    let options = { classes: ["dialogvente"], width: 400, height: 'fit-content', 'z-index': 99999 };
+    let options = { classes: ["dialogvente"], width: 400, height: 300, 'z-index': 99999 };
 
     let conf = {
       title: "Proposer",
@@ -38,65 +38,57 @@ export class DialogItemVente extends Dialog {
     this.venteData = venteData;
   }
 
-  activateListeners(html) {
-    super.activateListeners(html);
-
-    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)));
-
-    this.setQuantiteIllimite(this.venteData.quantiteIllimite);
-  }
-
   async onProposer(it) {
-    this.updateVente(this.getChoixVente());
+    await $(".tailleLot").change();
+    await $(".quantiteNbLots").change();
+    await $(".quantiteIllimite").change();
+    await $(".prixLot").change();
     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())
-    };
-  }
-
   /* -------------------------------------------- */
+  activateListeners(html) {
+    super.activateListeners(html);
+
+    HtmlUtility._showControlWhen($(".quantiteNbLots"), !this.venteData.quantiteIllimite)
+
+    html.find(".tailleLot").change(event => this.setTailleLot(Number(event.currentTarget.value)));
+    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)));
+  }
+
   setPrixLot(prixLot) {
     this.venteData.prixLot = prixLot;
   }
 
   setTailleLot(tailleLot) {
-    const maxLots = Math.floor(this.venteData.quantiteMax / tailleLot);
+    // recalculer le prix du lot
-    this.updateVente({
+    if (tailleLot != this.venteData.tailleLot) {
-      tailleLot,
+      this.venteData.prixLot = (tailleLot * this.venteData.prixOrigine).toFixed(2);
-      quantiteNbLots: Math.min(maxLots, this.venteData.quantiteNbLots),
+      $(".prixLot").val(this.venteData.prixLot);
-      quantiteMaxLots: maxLots,
+    }
-      prixLot: (tailleLot * this.venteData.prixOrigine).toFixed(2)
+    this.venteData.tailleLot = tailleLot;
-    });
+    if (this.venteData.isOwned) {
-
+      // recalculer le nombre de lots max
-    this.html.find(".prixLot").val(this.venteData.prixLot);
+      this.venteData.quantiteMaxLots = Math.floor(this.venteData.quantiteMax / tailleLot);
-    this.html.find(".quantiteNbLots").val(this.venteData.quantiteNbLots);
+      this.venteData.quantiteNbLots = Math.min(this.venteData.quantiteMaxLots, this.venteData.quantiteNbLots);
-    this.html.find(".quantiteNbLots").attr("max", this.venteData.quantiteMaxLots)
+      $(".quantiteNbLots").val(this.venteData.quantiteNbLots);
+      $(".quantiteNbLots").attr("max", this.venteData.quantiteMaxLots)
+    }
   }
 
   setNbLots(nbLots) {
-    this.updateVente({
+    if (this.venteData.isOwned) {
-      quantiteNbLots: this.venteData.isOwned ? Math.max(0, Math.min(nbLots, this.venteData.quantiteMaxLots)) : nbLots
+      nbLots = Math.max(0, Math.min(nbLots, this.venteData.quantiteMaxLots));
-    })
+    }
-    this.html.find(".quantiteNbLots").val(this.venteData.quantiteNbLots);
+    this.venteData.quantiteNbLots = nbLots;
+    $(".quantiteNbLots").val(this.venteData.quantiteNbLots);
   }
 
   setQuantiteIllimite(checked) {
-    this.updateVente({ quantiteIllimite: checked })
+    this.venteData.quantiteIllimite = checked;
-    this.html.find(".label-quantiteIllimite").text(this.venteData.quantiteIllimite ? "Illimités" : "disponibles");
+    $(".label-quantiteIllimite").text(this.venteData.quantiteIllimite ? "Illimités" : "disponibles");
-    HtmlUtility.showControlWhen(this.html.find(".quantiteNbLots"), !this.venteData.quantiteIllimite)
+    HtmlUtility._showControlWhen($(".quantiteNbLots"), !this.venteData.quantiteIllimite)
   }
 }

module/dialog-repos.js

@@ -0,0 +1,56 @@
+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

@@ -1,37 +0,0 @@
-
-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

@@ -12,34 +12,40 @@ export class DialogSplitItem extends Dialog {
   }
 
   constructor(item, splitData, html, callback) {
-    let options = { classes: ["dialogsplit"], width: 300, height: 'fit-content', 'z-index': 99999 };
+    let options = { classes: ["dialogsplit"], width: 300, height: 160, 'z-index': 99999 };
+
     let conf = {
       title: "Séparer en deux",
       content: html,
       default: "separer",
       buttons: {
-        "separer": { label: "Séparer", callback: it => this.onSplit() }
+        "separer": {
+          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;
+
-    this.html.find(".choix-quantite").change(event => {
+    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,3 +1,4 @@
+import { RdDSheetUtility } from "./rdd-sheet-utility.js";
 
 export class DialogStress extends Dialog {
 
@@ -15,7 +16,7 @@ export class DialogStress extends Dialog {
         )
     };
 
-    const html = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/sommeil/dialog-stress.html", dialogData);
+    const html = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/dialog-stress.html", dialogData);
     new DialogStress(dialogData, html)
       .render(true);
   }
@@ -23,7 +24,7 @@ export class DialogStress extends Dialog {
   constructor(dialogData, html) {
     const options = { classes: ["DialogStress"],
       width: 400,
-      height: 'fit-content',
+      height: 205+dialogData.actors.length*25,
       'z-index': 99999
     };
     const conf = {
@@ -31,30 +32,31 @@ export class DialogStress extends Dialog {
       content: html,
       buttons: {
         stress: { label: "Stress !", callback: it => { this.onStress(); } }
-      }
+      },
+      default: "stress"
     };
     super(conf, options);
     this.dialogData = dialogData;
   }
 
-  activateListeners(html) {
-    super.activateListeners(html);
-    this.html = html;
-    this.html.find("input.select-actor").change((event) => this.onSelectActor(event));
-  }
-
   async onStress() {
-    const motif = this.html.find("form.rdddialogstress input[name='motif']").val();
+    const motif = $("form.rdddialogstress input[name='motif']").val();
-    const stress = Number(this.html.find("form.rdddialogstress input[name='stress']").val());
+    const stress = Number($("form.rdddialogstress input[name='stress']").val());
-    const compteur = (this.html.find("form.rdddialogstress input[name='immediat']").prop("checked")) ? 'experience' : 'stress';
+    const compteur = ($("form.rdddialogstress input[name='immediat']").prop("checked")) ? 'experience' : 'stress';
 
     this.dialogData.actors.filter(it => it.selected)
       .map(it => game.actors.get(it.id))
-      .forEach(async actor => await actor.distribuerStress(compteur, stress, motif));
+      .forEach(actor => actor.distribuerStress(compteur, stress, motif));
+  }
+
+  /* -------------------------------------------- */
+  activateListeners(html) {
+    super.activateListeners(html);
+    html.find("input.select-actor").change((event) => this.onSelectActor(event));
   }
 
   async onSelectActor(event) {
-    const actorId = this.html.find(event.currentTarget)?.data("actor-id");
+    const actorId = $(event.currentTarget)?.data("actor-id");
     const actor = this.dialogData.actors.find(it => it.id == actorId);
     if (actor) {
       actor.selected = event.currentTarget.checked;

module/dialog-validation-encaissement.js

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

module/environnement.js

@@ -1,78 +0,0 @@
-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,14 +19,10 @@ 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/html-utility.js

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

module/item-arme.js

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

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, "reste": 100 },
+  { "niveau": 0, "nombreMax": 100, "nombre": 0 },
-  { "niveau": 1, "nombreMax": 10, "reste": 10 },
+  { "niveau": 1, "nombreMax": 10, "nombre": 0 },
-  { "niveau": 2, "nombreMax": 9, "reste": 9 },
+  { "niveau": 2, "nombreMax": 9, "nombre": 0 },
-  { "niveau": 3, "nombreMax": 8, "reste": 8 },
+  { "niveau": 3, "nombreMax": 8, "nombre": 0 },
-  { "niveau": 4, "nombreMax": 7, "reste": 7 },
+  { "niveau": 4, "nombreMax": 7, "nombre": 0 },
-  { "niveau": 5, "nombreMax": 6, "reste": 6 },
+  { "niveau": 5, "nombreMax": 6, "nombre": 0 },
-  { "niveau": 6, "nombreMax": 5, "reste": 5 },
+  { "niveau": 6, "nombreMax": 5, "nombre": 0 },
-  { "niveau": 7, "nombreMax": 4, "reste": 4 },
+  { "niveau": 7, "nombreMax": 4, "nombre": 0 },
-  { "niveau": 8, "nombreMax": 3, "reste": 3 },
+  { "niveau": 8, "nombreMax": 3, "nombre": 0 },
-  { "niveau": 9, "nombreMax": 2, "reste": 2 },
+  { "niveau": 9, "nombreMax": 2, "nombre": 0 },
-  { "niveau": 10, "nombreMax": 1, "reste": 1 },
+  { "niveau": 10, "nombreMax": 1, "nombre": 0 },
-  { "niveau": 11, "nombreMax": 1, "reste": 1 }
+  { "niveau": 11, "nombreMax": 1, "nombre": 0 }
 ];
 
 /* -------------------------------------------- */
-const categoriesCompetences = {
+const categorieCompetences = {
   "generale": { base: -4, label: "Générales" },
   "particuliere": { base: -8, label: "Particulières" },
   "specialisee": { base: -11, label: "Spécialisées" },
@@ -34,6 +34,13 @@ const categoriesCompetences = {
   "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;
@@ -48,17 +55,23 @@ function _buildCumulXP() {
 const competence_xp_cumul = _buildCumulXP();
 
 export class RdDItemCompetence extends Item {
+
   /* -------------------------------------------- */
-  static getCategories() {
+  static actorCompendium(actorType = undefined) {
-    return categoriesCompetences;
+    return compendiumCompetences[actorType ?? 'personnage'];
+  }
+
+  /* -------------------------------------------- */
+  static getCategorieCompetences() {
+    return categorieCompetences;
+  }
+  /* -------------------------------------------- */
+  static getNiveauBase(category) {
+    return categorieCompetences[category].base;
   }
   /* -------------------------------------------- */
   static getLabelCategorie(category) {
-    return categoriesCompetences[category].label;
+    return categorieCompetences[category].label;
-  }
-  /* -------------------------------------------- */
-  static getNiveauBase(category, categories = categoriesCompetences) {
-    return categories[category]?.base ?? 0;
   }
 
   /* -------------------------------------------- */
@@ -72,9 +85,9 @@ export class RdDItemCompetence extends Item {
   /* -------------------------------------------- */
   static getVoieDraconic(competences, voie) {
     return RdDItemCompetence.findFirstItem(competences, voie, {
-      preFilter: it => it.isCompetence() && RdDItemCompetence.isDraconic(it),
+       preFilter: it => it.isCompetence() && RdDItemCompetence.isDraconic(it),
-      description: 'Draconic',
+       description: 'Draconic',
-    });
+      });
   }
 
   /* -------------------------------------------- */
@@ -186,21 +199,30 @@ export class RdDItemCompetence extends Item {
     item.system.isStressLevelUp = (xpManquant > 0 && stressTransforme >= xpManquant && item.system.niveau < item.system.niveau_archetype);
     item.system.stressXpMax = 0;
     if (xpManquant > 0 && stressTransforme > 0 && item.system.niveau < item.system.niveau_archetype) {
-      item.system.stressXpMax = Math.min(xpManquant, stressTransforme);
+        item.system.stressXpMax = Math.min(xpManquant , stressTransforme);
     }
   }
 
+  /* -------------------------------------------- */
+  static isVisible(item) {
+    return Number(item.system.niveau) != RdDItemCompetence.getNiveauBase(item.system.categorie);
+  }
+
+  static nomContientTexte(item, texte) {
+    return Grammar.toLowerCaseNoAccent(item.name).includes(Grammar.toLowerCaseNoAccent(texte))
+  }
+
   /* -------------------------------------------- */
   static isNiveauBase(item) {
-    return Number(item.system.niveau) == RdDItemCompetence.getNiveauBase(item.system.categorie, item.getCategories());
+    return Number(item.system.niveau) == RdDItemCompetence.getNiveauBase(item.system.categorie);
   }
 
   /* -------------------------------------------- */
   static findCompetence(list, idOrName, options = {}) {
-    if (idOrName == undefined || idOrName == "") {
+    if (idOrName == undefined) {
-      return RdDItemCompetence.sansCompetence();
+      return undefined;
     }
-    options = mergeObject(options, { preFilter: it => it.isCompetence(), description: 'compétence' }, { overwrite: false });
+    options = mergeObject(options, { preFilter: it => it.isCompetence(), description: 'compétence' }, {overwrite: false});
     return RdDItemCompetence.findFirstItem(list, idOrName, options);
   }
 
@@ -209,23 +231,6 @@ export class RdDItemCompetence extends Item {
     return Misc.findAllLike(name, list, { filter: it => it.isCompetence(), description: 'compétence' });
   }
 
-  static sansCompetence() {
-    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);
@@ -258,47 +263,18 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   static computeResumeArchetype(competences) {
-    const computed = duplicate(limitesArchetypes);
+    const archetype = RdDItemCompetence.getLimitesArchetypes();
     competences.map(it => Math.max(0, it.system.niveau_archetype))
-      .filter(n => n > 0)
+      .forEach(niveau => {
-      .forEach(n => {
+        archetype[niveau] = archetype[niveau] ?? { "niveau": niveau, "nombreMax": 0, "nombre": 0 };
-        computed[n] = computed[n] ?? { niveau: n, nombreMax: 0, reste: 0 };
+        archetype[niveau].nombre = (archetype[niveau]?.nombre ?? 0) + 1;
-        computed[n].reste = computed[n].reste - 1;
       });
-      return computed.filter(it => it.reste > 0 && it.niveau > 0);
+    return archetype;
   }
 
   /* -------------------------------------------- */
-  static triVisible(competences) {
+  static getLimitesArchetypes() {
-    return competences.filter(it => !it.system.isHidden)
+    return duplicate(limitesArchetypes);
-      .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,97 +1,51 @@
-
+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() {
-    return categories;
-  }
-
   /* -------------------------------------------- */
   static setRollDataCreature(rollData) {
+    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.selectedCarac = rollData.carac.carac_creature
+    rollData.competence.system.categorie = "creature"
-    rollData.arme = RdDItemCompetenceCreature.armeCreature(rollData.competence);
+    rollData.selectedCarac =  rollData.carac.carac_creature
+    if (rollData.competence.system.iscombat) {
+      rollData.arme = RdDItemCompetenceCreature.toActionArme(rollData.competence);
+    }
   }
 
   /* -------------------------------------------- */
-  static armeCreature(item) {
+  static toActionArme(competencecreature) {
-    const categorieAttaque = RdDItemCompetenceCreature.getCategorieAttaque(item)
+    if (RdDItemCompetenceCreature.isCompetenceAttaque(competencecreature)) {
-    if (categorieAttaque != undefined) {
+      // si c'est un Item compétence: cloner pour ne pas modifier lma compétence
-      // si c'est un Item compétence: cloner pour ne pas modifier la compétence
+      let arme = (competencecreature instanceof Item) ? competencecreature.clone():  competencecreature;
-      let arme = item.clone();
+      mergeObject(arme.system,
-      mergeObject(arme,
         {
-          action: item.isCompetencePossession() ? 'possession' : 'attaque',
+          competence: arme.name,
-          system: {
+          initiative: RdDCombatManager.calculInitiative(competencecreature.system.niveau, competencecreature.system.carac_value),
-            competence: arme.name,
+          niveau: competencecreature.system.niveau,
-            cac: categorieAttaque == "naturelle" ? "naturelle" : "",
+          equipe: true,
-            niveau: item.system.niveau,
+          resistance: 100,
-            initiative: RdDCombatManager.calculInitiative(item.system.niveau, item.system.carac_value),
+          dommagesReels: arme.system.dommages,
-            equipe: true,
+          penetration: 0,
-            resistance: 100,
+          force: 0,
-            dommagesReels: arme.system.dommages,
+          rapide: true,
-            penetration: 0,
+          cac: competencecreature.system.isnaturelle ? "naturelle" : "",
-            force: 0,
+          action: 'attaque'
-            rapide: true,
-          }
         });
       return arme;
     }
+    console.error("RdDItemCompetenceCreature.toActionArme(", competencecreature, ") : impossible de transformer l'Item en arme");
     return undefined;
   }
 
   /* -------------------------------------------- */
-  static getCategorieAttaque(item) {
+  static isCompetenceAttaque(item) {
-    if (item.type == TYPES.competencecreature) {
+    return item.type == 'competencecreature' && item.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(item) {
     return item.type == 'competencecreature' && item.system.categorie_parade !== "";

module/item-monnaie.js

@@ -2,28 +2,27 @@ import { Misc } from "./misc.js";
 import { LOG_HEAD } from "./constants.js";
 
 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",
-  system: { quantite: 0, cout: 0.01, encombrement: 0.001, description: "" }
+  system: { 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",
-  system: { quantite: 0, cout: 0.10, encombrement: 0.002, description: "" }
+  system: { 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",
-  system: { quantite: 0, cout: 1, encombrement: 0.003, description: "" }
+  system: { 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",
-  system: { quantite: 0, cout: 10, encombrement: 0.004, description: "" }
+  system: { 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 {
 
@@ -33,7 +32,7 @@ export class Monnaie {
 
   static monnaiesManquantes(actor) {
     const disponibles = actor.itemTypes['monnaie'];
-    const manquantes = MONNAIES_STANDARD.filter(standard => !disponibles.find(disponible => Monnaie.deValeur(disponible, standard.system?.cout)));
+    const manquantes = MONNAIES_STANDARD.filter(standard => !disponibles.find(disponible => Monnaie.deValeur(disponible, standard.system?.valeur_deniers)));
     if (manquantes.length > 0) {
       console.error(`${LOG_HEAD} monnaiesManquantes pour ${actor.name}`, manquantes, ' avec monnaies', disponibles, MONNAIES_STANDARD);
     }
@@ -41,11 +40,15 @@ export class Monnaie {
   }
 
   static deValeur(monnaie, valeur) {
-    return VALEUR_DENIERS(valeur) == VALEUR_DENIERS(monnaie.system.cout)
+    return valeur == monnaie.system.valeur_deniers
   }
 
-  static triValeurEntiere() {
+  static arrondiDeniers(sols) {
-    return Misc.ascending(item => VALEUR_DENIERS(item.system.cout))
+    return Number(sols).toFixed(2);
+  }
+
+  static triValeurDenier() {
+    return Misc.ascending(item => item.system.valeur_deniers)
   }
 
   static async creerMonnaiesStandard(actor) {
@@ -62,52 +65,29 @@ export class Monnaie {
     return deniers;
   }
 
-  static toSolsDeniers(fortune) {
+  static async optimiser(actor, fortune) {
-    return {
+    let reste = fortune;
-      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 => it.system.valeur_deniers);
-
+    for (let valeur of  [1000, 100, 10, 1]) {
-    let parValeur = Misc.classifyFirst(monnaies, it => VALEUR_DENIERS(it.system.cout));
+      const itemPiece = parValeur[valeur];
-    for (let valeurDeniers of [1000, 100, 10, 1]) {
+      const piecesDeCetteValeur = Math.floor(reste / valeur);
-      const itemPiece = parValeur[valeurDeniers];
       if (itemPiece) {
-        const quantite = Math.floor(resteEnDeniers / valeurDeniers);
+        if (piecesDeCetteValeur != itemPiece.system.quantite) {
-        if (quantite != itemPiece.system.quantite) {
+          updates.push({ _id: parValeur[valeur].id, 'system.quantite': piecesDeCetteValeur });
-          updates.push({ _id: parValeur[valeurDeniers].id, 'system.quantite': quantite });
         }
-        resteEnDeniers -= quantite * valeurDeniers;
+        reste -= piecesDeCetteValeur*valeur;
       }
     }
-    console.log('Monnaie.optimiserFortune', actor.name, 'total', fortune, 'parValeur', parValeur, 'updates', updates, 'reste', resteEnDeniers);
+    console.log('Monnaie.optimiser', actor.name, 'total', fortune, 'parValeur', parValeur, 'updates', updates, 'reste', reste);
     if (updates.length > 0) {
       await actor.updateEmbeddedDocuments('Item', updates);
     }
-    if (resteEnDeniers > 0) {
+    if (reste>0){
       // créer le reste en deniers fortune en deniers
-      await Monnaie.creerMonnaiesDeniers(actor, resteEnDeniers);
+      await Monnaie.creerMonnaiesDeniers(actor, reste);
     }
   }
 
-  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,72 +4,45 @@ 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 "./settings/regles-optionelles.js";
+import { ReglesOptionelles } from "./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 for RdD specific items
+ * Extend the basic ItemSheet with some very simple modifications
+ * @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: RdDItemSheet.defaultTemplate(RdDItemSheet.ITEM_TYPE),
+      template: "systems/foundryvtt-reve-de-dragon/templates/item-sheet.html",
       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();
-    if (this.item.isInventaire() && this.item.isVideOuNonConteneur()) {
+    // Add "Post to chat" button
+    // We previously restricted this to GM and editable items only. If you ever find this comment because it broke something: eh, sorry!
+    if ("cout" in this.item.system && this.item.isVideOuNonConteneur()) {
       buttons.unshift({
         class: "vendre",
         icon: "fas fa-comments-dollar",
-        onclick: ev => this.item.proposerVente(1)
+        onclick: ev => this.item.proposerVente()
       });
     }
     buttons.unshift({
       class: "montrer",
       icon: "fas fa-comment",
-      onclick: ev => this.item.postItemToChat()
+      onclick: ev => this.item.postItem()
     });
     return buttons
   }
@@ -88,225 +61,246 @@ export class RdDItemSheet extends ItemSheet {
   /* -------------------------------------------- */
   async getData() {
     let formData = {
-      title: this.item.name,
       id: this.item.id,
+      title: this.item.name,
       type: this.item.type,
       img: this.item.img,
       name: this.item.name,
       system: this.item.system,
+      // TODO: v10 remove
+      data: this.item.system,
+      isGM: game.user.isGM,
       actorId: this.actor?.id,
-      description: await TextEditor.enrichHTML(this.item.system.description, { async: true }),
+      owner: this.item.isOwner,
-      descriptionmj: await TextEditor.enrichHTML(this.item.system.descriptionmj, { async: true }),
+      editable: this.isEditable,
-      isComestible: this.item.getUtilisationCuisine(),
+      cssClass: this.isEditable ? "editable" : "locked",
-      options: RdDSheetUtility.mergeDocumentRights(this.options, this.item, this.isEditable)
+      isSoins: false,
+      description:  await TextEditor.enrichHTML(this.object.system.description, {async: true}),
+      descriptionmj:  await TextEditor.enrichHTML(this.object.system.descriptionmj, {async: true})
+
     }
-    if (this.item.type == TYPES.competencecreature) {
+    if (this.actor) {
-      formData.isparade = RdDItemCompetenceCreature.isParade(this.item)
+      formData.isOwned = true;
-      formData.isdommages = RdDItemCompetenceCreature.isDommages(this.item)
+      if (this.item.type == 'conteneur') {
+        this.prepareConteneurData(formData);
+      }
     }
 
-    const competences = await SystemCompendiums.getCompetences('personnage');
+    formData.categorieCompetences = RdDItemCompetence.getCategorieCompetences()
-    formData.categories = this.item.getCategories()
     if (this.item.type == 'tache' || this.item.type == 'livre' || this.item.type == 'meditation' || this.item.type == 'oeuvre') {
       formData.caracList = duplicate(game.system.model.Actor.personnage.carac)
       formData.caracList["reve-actuel"] = duplicate(game.system.model.Actor.personnage.reve.reve)
-      formData.competences = competences;
+      formData.competences = await RdDUtility.loadItems(it => it.isCompetencePersonnage(), RdDItemCompetence.actorCompendium(this.actor?.type))
     }
     if (this.item.type == 'arme') {
-      formData.competences = competences.filter(it => RdDItemCompetence.isCompetenceArme(it))
+      formData.competences = await RdDUtility.loadItems(it => RdDItemCompetence.isCompetenceArme(it),  RdDItemCompetence.actorCompendium(this.actor?.type))
-    }
-    if (['sort', 'sortreserve'].includes(this.item.type)) {
-      formData.competences = competences.filter(it => RdDItemCompetence.isDraconic(it));
     }
     if (this.item.type == 'recettecuisine') {
-      formData.ingredients = await TextEditor.enrichHTML(this.object.system.ingredients, { async: true })
+      formData.ingredients =  await TextEditor.enrichHTML(this.object.system.ingredients, {async: true})
-    }
-    if (this.item.type == 'extraitpoetique') {
-      formData.extrait = await TextEditor.enrichHTML(this.object.system.extrait, { async: true })
-      formData.texte = await TextEditor.enrichHTML(this.object.system.texte, { async: true })
     }
     if (this.item.type == 'recettealchimique') {
       RdDAlchimie.processManipulation(this.item, this.actor && this.actor.id);
-      formData.manipulation_update = await TextEditor.enrichHTML(this.object.system.manipulation_update, { async: true })
+      formData.manipulation_update =  await TextEditor.enrichHTML(this.object.system.manipulation_update, {async: true})
-      formData.utilisation = await TextEditor.enrichHTML(this.object.system.utilisation, { async: true })
+      formData.utilisation =  await TextEditor.enrichHTML(this.object.system.utilisation, {async: true})
-      formData.enchantement = await TextEditor.enrichHTML(this.object.system.enchantement, { async: true })
+      formData.enchantement =  await TextEditor.enrichHTML(this.object.system.enchantement, {async: true})
-      formData.sureffet = await TextEditor.enrichHTML(this.object.system.sureffet, { async: true })
+      formData.sureffet =  await TextEditor.enrichHTML(this.object.system.sureffet, {async: true})
     }
     if (this.item.type == 'gemme') {
       formData.gemmeTypeList = RdDGemme.getGemmeTypeOptionList();
       RdDGemme.calculDataDerivees(this.item);
     }
     if (this.item.type == 'potion') {
-      await RdDHerbes.addPotionFormData(formData);
+      if (this.dateUpdated) {
+        formData.system.prdate = this.dateUpdated;
+        this.dateUpdated = undefined;
+      }
+      await RdDHerbes.updatePotionData(formData);
     }
-    if (formData.options.isOwned && this.item.type == 'herbe' && (formData.system.categorie == 'Soin' || formData.system.categorie == 'Repos')) {
+    if (formData.isOwned && this.item.type == 'herbe' && (formData.system.categorie == 'Soin' || formData.system.categorie == 'Repos')) {
       formData.isIngredientPotionBase = true;
     }
     if (this.item.type == 'sortreserve') {
       const sortId = this.item.system.sortid;
-      formData.sort = formData.options.isOwned ? this.item.actor.items.get(sortId) : game.items.get(sortId);
+      formData.sort = formData.isOwned ? this.item.actor.items.get(sortId) : game.items.get(sortId);
     }
     formData.bonusCaseList = RdDItemSort.getBonusCaseList(formData, true);
 
     return formData;
   }
 
+  /* -------------------------------------------- */
+  prepareConteneurData(formData) {
+    RdDUtility.filterEquipementParType(formData, this.actor.itemTypes);
+
+    this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.objets);
+    formData.subItems = formData.conteneurs.find(it => it._id == this.item.id)?.subItems;
+
+  }
+
   /* -------------------------------------------- */
   /** @override */
   activateListeners(html) {
     super.activateListeners(html);
-    this.html = html;
 
-    HtmlUtility.showControlWhen(this.html.find(".item-cout"), ReglesOptionelles.isUsing('afficher-prix-joueurs')
+    if (this.item.type == 'conteneur') {
-      || game.user.isGM
+      this.form.ondragstart = (event) => this._onDragStart(event);
-      || !this.item.isOwned);
+      this.form.ondrop = (event) => this._onDrop(event);
-    HtmlUtility.showControlWhen(this.html.find(".item-magique"), this.item.isMagique());
+    }
+
+    let itemSheetDialog = this;
+
+    HtmlUtility._showControlWhen($(".item-cout"), ReglesOptionelles.isUsing('afficher-prix-joueurs') || game.user.isGM || !this.item.isOwned);
+    HtmlUtility._showControlWhen($(".item-magique"), this.item.isMagique());
 
     // Everything below here is only needed if the sheet is editable
     if (!this.options.editable) return;
 
-    this.form.ondragstart = (event) => this._onDragStart(event);
-    this.form.ondrop = (event) => this._onDrop(event);
-
     // Select competence categorie
-    this.html.find(".categorie").change(event => this._onSelectCategorie(event));
+    html.find(".categorie").change(event => this._onSelectCategorie(event));
 
-    this.html.find('.sheet-competence-xp').change((event) => {
+    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!`)
-        }
-      }
-    })
 
-    this.html.find('.date-enchantement').change((event) => {
+    html.find('.enchanteDate').change((event) => {
-      const jour = Number(this.html.find('input.date-enchantement[name="enchantement.jour"]').val());
+      let jour = Number($('#jourMois').val());
-      const mois = RdDTimestamp.definition(this.html.find('select.date-enchantement[name="enchantement.mois"]').val());
+      let mois = $('#nomMois').val();
-      const indexDate = game.system.rdd.calendrier.getIndexFromDate(jour, mois.heure);
+      this.dateUpdated = game.system.rdd.calendrier.getIndexFromDate(jour, mois);
-      this.item.update({ 'system.prdate': indexDate });
-      console.warn(`Date d'enchantement modifiée ${jour}/${mois.heure}: ${indexDate}`)
     });
 
-    this.html.find('.creer-tache-livre').click((event) => this._getEventActor(event).creerTacheDepuisLivre(this.item));
+    html.find('.creer-tache-livre').click((event) => {
-    this.html.find('.consommer-potion').click((event) => this._getEventActor(event).consommerPotion(this.item, this.getActionRenderItem()));
+      let actorId = event.currentTarget.attributes['data-actor-id'].value;
-    this.html.find('.creer-potion-base').click((event) => this._getEventActor(event).dialogFabriquerPotion(this.item));
+      let actor = game.actors.get(actorId);
+      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);
+    });
 
-    this.html.find('.alchimie-tache a').click((event) => {
+    html.find('.alchimie-tache a').click((event) => {
-      let actor = this._getEventActor(event);
+      let actorId = event.currentTarget.attributes['data-actor-id'].value;
+      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.");
       }
     });
 
-    if (this.actor) {
+    html.find('.item-split').click(async event => {
-      this.html.find('.item-split').click(async event => RdDSheetUtility.splitItem(RdDSheetUtility.getItem(event, this.actor), this.actor, this.getActionRenderItem()));
+      const item = RdDSheetUtility.getItem(event, this.actor);
-      this.html.find('.item-edit').click(async event => RdDSheetUtility.getItem(event, this.actor)?.sheet.render(true));
+      await RdDSheetUtility.splitItem(item, this.actor, async () => itemSheetDialog.render(true));
-      this.html.find('.item-delete').click(async event => RdDUtility.confirmActorItemDelete(this, RdDSheetUtility.getItem(event, this.actor)));
+    });
-      this.html.find('.item-vendre').click(async event => RdDSheetUtility.getItem(event, this.actor)?.proposerVente());
+    html.find('.item-edit').click(async event => {
-      this.html.find('.item-montrer').click(async event => RdDSheetUtility.getItem(event, this.actor)?.postItemToChat());
+      const item = RdDSheetUtility.getItem(event, this.actor);
-      this.html.find('.item-action').click(async event => RdDSheetUtility.getItem(event, this.actor)?.actionPrincipale(this.actor, this.getActionRenderItem()));
+      item.sheet.render(true);
-
+    });
-      this.html.find('.item-quantite-plus').click(async event => {
+    html.find('.item-delete').click(async event => {
-        await this.actor.itemQuantiteIncDec(RdDSheetUtility.getItemId(event), 1)
+      const li = RdDSheetUtility.getEventElement(event);
-        this.render();
+      const item = this.actor.getObjet(li.data("item-id"));
-      });
+      RdDUtility.confirmerSuppressionItem(this, item, li);
-      this.html.find('.item-quantite-moins').click(async event => {
+    });
-        await this.actor.itemQuantiteIncDec(RdDSheetUtility.getItemId(event), -1)
+    html.find('.item-vendre').click(async event => {
-        this.render();
+      const item = RdDSheetUtility.getItem(event, this.actor);
-      });
+      item?.proposerVente();
-    }
+    });
-
+    html.find('.item-montrer').click(async event => {
-    const updateItemTimestamp = (path, timestamp) => this.item.update({ [path]: duplicate(timestamp) })
+      const item = RdDSheetUtility.getItem(event, this.actor);
-
+      item?.postItem();
-    RdDTimestamp.handleTimestampEditor(this.html, 'system.temporel.debut', updateItemTimestamp);
+    });
-    RdDTimestamp.handleTimestampEditor(this.html, 'system.temporel.fin', updateItemTimestamp);
+    html.find('.item-action').click(async event => {
+      const item = RdDSheetUtility.getItem(event, this.actor);
+      this.actor.actionItem(item, async () => itemSheetDialog.render(true));
+    });
+    html.find('.conteneur-name a').click(async event => {
+      RdDUtility.toggleAfficheContenu(RdDSheetUtility.getItemId(event));
+      this.render(true);
+    });
   }
 
-  getActionRenderItem() {
-    return async () => {
-      let item = this.item;
-      while (item) {
-        await item.sheet?.render()
-        item = this.actor.getContenant(item)
-      }
-    }
-  }
-
-  _getEventActor(event) {
-    let actorId = event.currentTarget.attributes['data-actor-id'].value;
-    let actor = game.actors.get(actorId);
-    return actor;
-  }
-
-
   /* -------------------------------------------- */
   async _onSelectCategorie(event) {
     event.preventDefault();
 
     if (this.item.isCompetence()) {
-      const categorie = event.currentTarget.value;
+      let level = RdDItemCompetence.getNiveauBase(event.currentTarget.value);
-      const level =  RdDItemCompetence.getNiveauBase(categorie, this.item.getCategories());
       this.item.system.base = level;
-      this.html.find('[name="system.base"]').val(level);
+      $("#base").val(level);
     }
   }
 
   /* -------------------------------------------- */
+  get template() {
+    let type = this.item.type
+    return `systems/foundryvtt-reve-de-dragon/templates/item-${type}-sheet.html`;
+  }
+
+  /* -------------------------------------------- */
+
   /** @override */
   _updateObject(event, formData) {
-    if (this.item.type == 'sort') {
+    // Données de bonus de cases ?
-      // Données de bonus de cases ?
+    formData['system.bonuscase'] = RdDItemSort.buildBonusCaseStringFromFormData(formData.bonusValue, formData.caseValue);
-      formData['system.bonuscase'] = RdDItemSort.buildBonuscaseFromArrays(formData.bonusValue, formData.caseValue);
+
-    }
     return this.item.update(formData);
   }
 
-  /* -------------------------------------------- */
   async _onDragStart(event) {
+    console.log("_onDragStart", event);
+    if (event.target.classList.contains("entity-link")) return;
+
+    const itemId = event.srcElement?.attributes["data-item-id"].value;
+    const item = this.actor.items.get(itemId);
+    // Create drag data
+    const dragData = {
+      actorId: this.actor.id,
+      type: "Item",
+      data: item.system
+    };
+
+    event.dataTransfer.setData("text/plain", JSON.stringify(dragData));
   }
 
   async _onDrop(event) {
     // Try to extract the dragData
-    let dragData = RdDItemSheet.$extractDragData(event);
+    let dragData;
-    if (!dragData) return false;
+    try {
+      dragData = JSON.parse(event.dataTransfer.getData('text/plain'));
+    } catch (err) {
+      return false;
+    }
+
     const allowed = Hooks.call("dropActorSheetData", this.actor, this, dragData);
-    if (allowed === false) return false;
+    if (allowed === false) return;
 
     // Handle different dragData types
     switch (dragData.type) {
       case "Item":
         return this._onDropItem(event, dragData);
-      case "Actor":
-        return this._onDropActor(event, dragData);
     }
     return super._onDrop(event);
   }
 
-  static $extractDragData(event) {
+  /* -------------------------------------------- */
-    try {
-      const eventData = event?.dataTransfer?.getData('text/plain');
-      if (eventData) {
-        return JSON.parse(eventData);
-      }
-    } catch (err) { }
-    return undefined;
-  }
-
   async _onDropItem(event, dragData) {
+    if (this.actor) {
+      const dropParams = RdDSheetUtility.prepareItemDropParameters(this.item.id, this.actor.id, dragData, this.objetVersConteneur);
+      await this.actor.processDropItem(dropParams);
+      await this.render(true);
+    }
   }
 
-  async _onDropActor(event, dragData) {
-  }
 
 }

module/item-signedraconique-sheet.js

@@ -1,14 +1,30 @@
-import { RdDItemSheet } from "../item-sheet.js";
+import { SYSTEM_RDD } from "./constants.js";
-import { RdDItemSigneDraconique } from "./signedraconique.js";
+import { RdDItemSigneDraconique } from "./item-signedraconique.js";
-import { TMRUtility } from "../tmr-utility.js";
+import { Misc } from "./misc.js";
+import { TMRType, TMRUtility } from "./tmr-utility.js";
 
 /**
  * Item sheet pour signes draconiques
- * @extends {RdDItemSheet}
+ * @extends {ItemSheet}
  */
-export class RdDSigneDraconiqueItemSheet extends RdDItemSheet {
+export class RdDSigneDraconiqueItemSheet extends ItemSheet {
 
-  static get ITEM_TYPE() { return "signedraconique" }
+  /** @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 */
@@ -23,9 +39,18 @@ export class RdDSigneDraconiqueItemSheet extends RdDItemSheet {
 
   /* -------------------------------------------- */
   async getData() {
-    const formData = await super.getData();
+    const formData = duplicate(this.item);
     this.tmrs = TMRUtility.buildSelectionTypesTMR(this.item.system.typesTMR);
-    formData.tmrs = this.tmrs;
+    mergeObject(formData, {
+      tmrs: this.tmrs,
+      title: formData.name,
+      isGM: game.user.isGM,
+      owner: this.actor?.isOwner,
+      isOwned: this.actor ? true : false,
+      actorId: this.actor?.id,
+      editable: this.isEditable,
+      cssClass: this.isEditable ? "editable" : "locked",
+    });
     return formData;
   }
 
@@ -37,13 +62,12 @@ export class RdDSigneDraconiqueItemSheet extends RdDItemSheet {
     if (!this.options.editable) return;
 
     html.find(".signe-aleatoire").click(event => this.setSigneAleatoire());
-    html.find("input.select-tmr").change(event => this.onSelectTmr(event));
+    html.find("input.select-tmr").change((event) => this.onSelectTmr(event));
-    html.find(".signe-xp-sort").change(event => this.onValeurXpSort(event.currentTarget.attributes['data-typereussite']?.value, Number(event.currentTarget.value)));
+    html.find(".signe-xp-sort").change((event) => this.onValeurXpSort(event.currentTarget.attributes['data-typereussite']?.value, Number(event.currentTarget.value)));
   }
 
   async setSigneAleatoire() {
     const newSigne = await RdDItemSigneDraconique.randomSigneDraconique();
-    newSigne.name = this.item.name;
     this.item.update(newSigne);
   }
 
@@ -65,4 +89,12 @@ export class RdDSigneDraconiqueItemSheet extends RdDItemSheet {
     await this.item.update({ 'system.valeur': newValeur });
   }
 
+  /* -------------------------------------------- */
+  get template() {
+    return `systems/foundryvtt-reve-de-dragon/templates/item-signedraconique-sheet.html`;
+  }
+
+  get title() {
+    return `Signe draconique: ${this.object.name}`;
+  }
 }

module/item-signedraconique.js

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

module/item-sort.js

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

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

module/item/armure.js

@@ -1,51 +0,0 @@
-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

@@ -1,199 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

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

@@ -1,17 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

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

module/item/rencontre.js

@@ -1,80 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,120 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

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

module/item/sheet-ingredient.js

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

module/item/sheet-plante.js

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

module/item/sheet-rencontre.js

@@ -1,78 +0,0 @@
-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

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

module/item/souffle.js

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