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

Reviewed-on: #662

.gitignore

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

changelog.md

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

lang/fr.json

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

module/actor-creature-sheet.js

@@ -40,11 +40,4 @@ export class RdDActorCreatureSheet extends RdDActorSheet {
       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,22 +1,30 @@
 import { RdDActorSheet } from "./actor-sheet.js";
+import { RdDSheetUtility } from "./rdd-sheet-utility.js";
+import { RdDUtility } from "./rdd-utility.js";
 
 export class RdDActorEntiteSheet extends RdDActorSheet {
 
   /** @override */
-	static get defaultOptions() {
-	  return mergeObject(super.defaultOptions, {
-  	  classes: ["rdd", "sheet", "actor"],
-  	  template: "systems/foundryvtt-reve-de-dragon/templates/actor-entite-sheet.html",
+  static get defaultOptions() {
+    return mergeObject(super.defaultOptions, {
+      classes: ["rdd", "sheet", "actor"],
+      template: "systems/foundryvtt-reve-de-dragon/templates/actor-entite-sheet.html",
       width: 640,
       height: 720,
-      tabs: [{navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac"}],
-      dragDrop: [{dragSelector: ".item-list .item", dropSelector: undefined}]
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }]
     });
   }
+  async getData() {
+    let formData = await super.getData();
+    formData.resonances = this.actor.system.sante.resonnance.actors.map(actorId => game.actors.get(actorId))
+      .map(actor => { return { id: actor.id, name: actor.name, img: actor.img } })
+    return formData
+  }
 
   /* -------------------------------------------- */
   /** @override */
-	activateListeners(html) {
+  activateListeners(html) {
     super.activateListeners(html);
 
     // Everything below here is only needed if the sheet is editable
@@ -24,17 +32,34 @@ export class RdDActorEntiteSheet extends RdDActorSheet {
 
     // On competence change
     this.html.find('.creature-carac').change(async event => {
-        let compName = event.currentTarget.attributes.compname.value;
-        this.actor.updateCreatureCompetence( compName, "carac_value", parseInt(event.target.value) );
-      } );    
+      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 => {
-        let compName = event.currentTarget.attributes.compname.value;
-        this.actor.updateCreatureCompetence( compName, "niveau", parseInt(event.target.value) );
-      } );    
-      this.html.find('.creature-dommages').change(async event => {
-        let compName = event.currentTarget.attributes.compname.value;
-        this.actor.updateCreatureCompetence( compName, "dommages", parseInt(event.target.value) );
-      } );    
+      let compName = event.currentTarget.attributes.compname.value;
+      this.actor.updateCreatureCompetence(compName, "niveau", parseInt(event.target.value));
+    });
+    this.html.find('.creature-dommages').change(async event => {
+      let compName = event.currentTarget.attributes.compname.value;
+      this.actor.updateCreatureCompetence(compName, "dommages", parseInt(event.target.value));
+    });
+    this.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

@@ -10,15 +10,18 @@ import { DialogSplitItem } from "./dialog-split-item.js";
 import { ReglesOptionelles } from "./settings/regles-optionelles.js";
 import { RdDSheetUtility } from "./rdd-sheet-utility.js";
 import { STATUSES } from "./settings/status-effects.js";
-import { Monnaie } from "./item-monnaie.js";
 import { MAINS_DIRECTRICES } from "./actor.js";
+import { RdDBaseActorSheet } from "./actor/base-actor-sheet.js";
+import { RdDItem } from "./item.js";
+import { RdDItemBlessure } from "./item/blessure.js";
+import { RdDEmpoignade } from "./rdd-empoignade.js";
 
 /* -------------------------------------------- */
 /**
  * Extend the basic ActorSheet with some very simple modifications
  * @extends {ActorSheet}
  */
-export class RdDActorSheet extends ActorSheet {
+export class RdDActorSheet extends RdDBaseActorSheet {
 
   /** @override */
   static get defaultOptions() {
@@ -36,42 +39,26 @@ export class RdDActorSheet extends ActorSheet {
 
   /* -------------------------------------------- */
   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;
-    this.actor.computeEtatGeneral();
-
-    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: {
-        fortune: Monnaie.getFortuneSolsDeniers(this.actor),
-        encTotal: await this.actor.computeEncombrementTotalEtMalusArmure(),
-        surenc: this.actor.computeMalusSurEncombrement(),
-        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;
@@ -81,9 +68,9 @@ export class RdDActorSheet extends ActorSheet {
       formData.calc.fatigue = RdDUtility.calculFatigueHtml(formData.system.sante.fatigue.value, formData.system.sante.endurance.max);
 
       formData.competences.forEach(item => {
-        item.system.isVisible = this.options.recherche
-          ? RdDItemCompetence.nomContientTexte(item, this.options.recherche.text)
-          : (!this.options.showCompNiveauBase || !RdDItemCompetence.isNiveauBase(item));
+        item.system.isHidden = this.options.recherche
+          ? !item.isNomLike(this.options.recherche.text)
+          : (this.options.showCompNiveauBase && RdDItemCompetence.isNiveauBase(item));
         RdDItemCompetence.levelUp(item, formData.system.compteurs.experience.value);
       });
 
@@ -97,6 +84,7 @@ export class RdDActorSheet extends ActorSheet {
       RdDItemArme.ajoutCorpsACorps(formData.combat, formData.competences, formData.system.carac);
       formData.esquives = this.actor.getCompetences("Esquive");
       formData.combat = RdDCombatManager.listActionsArmes(formData.combat, formData.competences, formData.system.carac);
+      formData.empoignades = this.actor.getEmpoignades();
 
       this.armesList = formData.combat;
 
@@ -125,28 +113,27 @@ export class RdDActorSheet extends ActorSheet {
   /* -------------------------------------------- */  /** @override */
   activateListeners(html) {
     super.activateListeners(html);
-    this.html = html;
 
-    HtmlUtility._showControlWhen(this.html.find(".appliquerFatigue"), ReglesOptionelles.isUsing("appliquer-fatigue"));
+    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-split').click(async event => {
+    this.html.find('.item-action').click(async event => {
       const item = RdDSheetUtility.getItem(event, this.actor);
-      RdDSheetUtility.splitItem(item, this.actor);
+      item?.actionPrincipale(this.actor, async () => this.render())
     });
-    this.html.find('.item-edit').click(async event => RdDSheetUtility.getItem(event, this.actor)?.sheet.render(true))
-    this.html.find('.item-delete').click(async event => RdDUtility.confirmActorItemDelete(this, RdDSheetUtility.getItem(event, this.actor)));
-    this.html.find('.item-vendre').click(async event => RdDSheetUtility.getItem(event, this.actor)?.proposerVente());
-    this.html.find('.item-montrer').click(async event => RdDSheetUtility.getItem(event, this.actor)?.postItem());
-    this.html.find('.item-action').click(async event => RdDSheetUtility.getItem(event, this.actor)?.actionPrincipale(this.actor));
+
     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);
+        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 => {
@@ -159,6 +146,13 @@ export class RdDActorSheet extends ActorSheet {
       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();
     })
@@ -174,39 +168,31 @@ export class RdDActorSheet extends ActorSheet {
     this.html.find('.creer-tache').click(async event => {
       this.createEmptyTache();
     });
-    this.html.find('.creer-un-objet').click(async event => {
-      RdDUtility.selectObjetType(this);
-    });
+    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 => {
-      RdDUtility.selectTypeOeuvre(this);
-    });
-    this.html.find('.nettoyer-conteneurs').click(async event => {
-      this.actor.nettoyerConteneurs();
+      this.selectTypeOeuvreToCreate();
     });
 
-    // Blessure control
-    this.html.find('.blessure-control').click(async event => {
-      const tr = this.html.find(event.currentTarget).parents(".item");
-      let btype = tr.data("blessure-type");
-      let index = tr.data('blessure-index');
-      let active = this.html.find(event.currentTarget).data('blessure-active');
-      //console.log(btype, index, active);
-      await this.actor.manageBlessureFromSheet(btype, index, active);
+    this.html.find('.blessure-premierssoins-done').change(async event => {
+      const blessure = this.getBlessure(event);
+      await blessure?.setSoinsBlessure({ premierssoins: { done: event.currentTarget.checked } });
     });
-
-    // Blessure data
-    this.html.find('.blessure-soins').change(async event => {
-      const tr = this.html.find(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);
+    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
@@ -278,9 +264,14 @@ export class RdDActorSheet extends ActorSheet {
 
     // Points de reve actuel
     this.html.find('.ptreve-actuel a').click(async event => {
-      this.actor.rollCarac('reve-actuel');
+      this.actor.rollCarac('reve-actuel', true);
     });
 
+    // Suite empoignade
+    this.html.find('.empoignade-label a').click(async event => {
+      let emp = RdDSheetUtility.getItem(event, this.actor)
+      RdDEmpoignade.onAttaqueEmpoignadeFromItem(emp)
+    });
     // Roll Weapon1
     this.html.find('.arme-label a').click(async event => {
       let arme = this._getEventArmeCombat(event);
@@ -325,10 +316,6 @@ export class RdDActorSheet extends ActorSheet {
         await this.actor.removeEffects();
       }
     });
-    this.html.find('.conteneur-name a').click(async event => {
-      RdDUtility.toggleAfficheContenu(RdDSheetUtility.getItemId(event));
-      this.render(true);
-    });
     this.html.find('.carac-xp-augmenter').click(async event => {
       let caracName = event.currentTarget.name.replace("augmenter.", "");
       this.actor.updateCaracXPAuto(caracName);
@@ -378,29 +365,6 @@ export class RdDActorSheet extends ActorSheet {
       this.render(true);
     });
 
-    this.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)
-      );
     this.html.find('.vue-detaillee').click(async event => {
       this.options.vueDetaillee = !this.options.vueDetaillee;
       this.render(true);
@@ -418,19 +382,12 @@ export class RdDActorSheet extends ActorSheet {
       this.actor.setPointsDeSeuil(event.currentTarget.value);
     });
 
-    this.html.find('#attribut-protection-edit').change(async event => {
-      this.actor.updateAttributeValue(event.currentTarget.attributes.name.value, parseInt(event.target.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('#ethylisme').change(async event => {
-      this.actor.setEthylisme(parseInt(event.target.value));
-    });
     this.html.find('.stress-test').click(async event => {
       this.actor.transformerStress();
     });
@@ -454,13 +411,6 @@ export class RdDActorSheet extends ActorSheet {
       this.actor.jetEndurance();
     });
 
-    this.html.find('.monnaie-plus').click(async event => {
-      this.actor.monnaieIncDec(RdDSheetUtility.getItemId(event), 1);
-    });
-    this.html.find('.monnaie-moins').click(async event => {
-      this.actor.monnaieIncDec(RdDSheetUtility.getItemId(event), -1);
-    });
-
     this.html.find('.vie-plus').click(async event => {
       this.actor.santeIncDec("vie", 1);
     });
@@ -487,6 +437,12 @@ export class RdDActorSheet extends ActorSheet {
     });
   }
 
+  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);
   }
@@ -499,36 +455,30 @@ export class RdDActorSheet extends ActorSheet {
   }
 
   /* -------------------------------------------- */
-  async _onDropItem(event, dragData) {
-    const destItemId = this.html.find(event.target)?.closest('.item').attr('data-item-id')
-    const dropParams = 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 selectTypeOeuvreToCreate() {
+    let types = RdDItem.getTypesOeuvres();
+    let content = `<span class="competence-label">Selectionnez le type d'oeuvre</span><select class="item-type">`;
+    for (let typeName of types) {
+      content += `<option value="${typeName}">${Misc.typeName('Item', typeName)}</option>`
     }
-  }
-
-  /* -------------------------------------------- */
-  async createItem(name, type) {
-    await this.actor.createEmbeddedDocuments('Item', [{ name: name, type: type }], { renderSheet: true });
+    content += '</select>';
+    let dialog = new Dialog({
+      title: "Créer une oeuvre",
+      content: content,
+      buttons: {
+        create: {
+          icon: '<i class="fas fa-check"></i>',
+          label: "Créer l'oeuvre",
+          callback: () => this.actor.createItem($(".item-type").val())
+        }
+      }
+    });
+    dialog.render(true);
   }
 
   /* -------------------------------------------- */
   async createEmptyTache() {
-    await this.createItem('Nouvelle tache', 'tache');
-  }
-
-  _optionRecherche(target) {
-    if (!target.value?.length) {
-      return undefined;
-    }
-    return {
-      text: target.value,
-      start: target.selectionStart,
-      end: target.selectionEnd,
-    };
+    await this.actor.createItem('tache', 'Nouvelle tache');
   }
 
   _getEventArmeCombat(event) {

module/actor/base-actor-sheet.js

@@ -0,0 +1,301 @@
+import { RdDUtility } from "../rdd-utility.js";
+import { Misc } from "../misc.js";
+import { DialogSplitItem } from "../dialog-split-item.js";
+import { RdDSheetUtility } from "../rdd-sheet-utility.js";
+import { Monnaie } from "../item-monnaie.js";
+import { RdDItem, TYPES } from "../item.js";
+import { RdDItemCompetenceCreature } from "../item-competencecreature.js";
+
+/* -------------------------------------------- */
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+export class RdDBaseActorSheet extends ActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+    RdDUtility.initAfficheContenu();
+    return mergeObject(super.defaultOptions, {
+      classes: ["rdd", "sheet", "actor"],
+      template: "systems/foundryvtt-reve-de-dragon/templates/actor-sheet.html",
+      width: 550,
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }],
+      showCompNiveauBase: false,
+      vueDetaillee: false
+    });
+  }
+
+  /* -------------------------------------------- */
+  async getData() {
+    Monnaie.validerMonnaies(this.actor.itemTypes['monnaie']);
+
+    this.actor.recompute();
+    let formData = {
+      title: this.title,
+      id: this.actor.id,
+      type: this.actor.type,
+      img: this.actor.img,
+      name: this.actor.name,
+      system: this.actor.system,
+      description: await TextEditor.enrichHTML(this.actor.system.description, { async: true }),
+      notesmj: await TextEditor.enrichHTML(this.actor.system.notesmj, { async: true }),
+      options: RdDSheetUtility.mergeDocumentRights(this.options, this.actor, this.isEditable)
+    }
+
+    RdDBaseActorSheet.filterItemsPerTypeForSheet(formData, this.actor.itemTypes);
+    formData.calc = {
+      fortune: Monnaie.toSolsDeniers(this.actor.getFortune()),
+      prixTotalEquipement: this.actor.computePrixTotalEquipement(),
+      encTotal: await this.actor.computeEncTotal(),
+    }
+
+    this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.inventaires);
+    this._appliquerRechercheObjets(formData.conteneurs, formData.inventaires);
+    formData.conteneurs = RdDUtility.conteneursRacine(formData.conteneurs);
+    formData.competences.filter(it => it.type == TYPES.competencecreature)
+      .forEach(it => it.isdommages = RdDItemCompetenceCreature.isDommages(it))
+    return formData;
+  }
+
+  _appliquerRechercheObjets(conteneurs, inventaires) {
+    if (this.options.recherche?.text) {
+      const recherche = this.options.recherche;
+      const allVisible = inventaires.filter(it => it.isNomTypeLike(recherche.text)).map(it => it.id);
+      let addVisible = conteneurs.filter(it => it.isNomTypeLike(recherche.text)).map(it => it.id)
+      do {
+        allVisible.push(...addVisible)
+        const parentsIds = conteneurs.filter(it => it.system.contenu.find(id => allVisible.includes(id))).map(it => it.id)
+        addVisible = parentsIds.filter(id => !allVisible.includes(id))
+      }
+      while (addVisible.length > 0)
+      inventaires.forEach(it => it.system.isHidden = !allVisible.includes(it.id))
+      conteneurs.forEach(it => it.system.isHidden = !allVisible.includes(it.id))
+    }
+    else {
+      inventaires.forEach(it => it.system.isHidden = false)
+      conteneurs.forEach(it => it.system.isHidden = false)
+    }
+  }
+
+  /* -------------------------------------------- */
+  static filterItemsPerTypeForSheet(formData, itemTypes) {
+    formData.blessures = Misc.arrayOrEmpty(itemTypes['blessure']);
+    formData.recettescuisine = Misc.arrayOrEmpty(itemTypes['recettecuisine']);
+    formData.recettesAlchimiques = Misc.arrayOrEmpty(itemTypes['recettealchimique']);
+    formData.maladies = Misc.arrayOrEmpty(itemTypes['maladie']);
+    formData.poisons = Misc.arrayOrEmpty(itemTypes['poison']);
+    formData.possessions = Misc.arrayOrEmpty(itemTypes['possession']);
+    formData.maladiesPoisons = formData.maladies.concat(formData.poisons);
+    formData.competences = (itemTypes['competence'] ?? []).concat(itemTypes['competencecreature'] ?? []);
+    formData.sortsReserve = Misc.arrayOrEmpty(itemTypes['sortreserve']);
+
+    formData.sorts = Misc.arrayOrEmpty(itemTypes['sort']);
+    formData.rencontres = Misc.arrayOrEmpty(itemTypes['rencontre']);
+    formData.casestmr = Misc.arrayOrEmpty(itemTypes['casetmr']);
+    formData.signesdraconiques = Misc.arrayOrEmpty(itemTypes['signedraconique']);
+    formData.queues = Misc.arrayOrEmpty(itemTypes['queue']);
+    formData.souffles = Misc.arrayOrEmpty(itemTypes['souffle']);
+    formData.ombres = Misc.arrayOrEmpty(itemTypes['ombre']);
+    formData.tetes = Misc.arrayOrEmpty(itemTypes['tete']);
+    formData.taches = Misc.arrayOrEmpty(itemTypes['tache']);
+    formData.meditations = Misc.arrayOrEmpty(itemTypes['meditation']);
+    formData.chants = Misc.arrayOrEmpty(itemTypes['chant']);
+    formData.danses = Misc.arrayOrEmpty(itemTypes['danse']);
+    formData.musiques = Misc.arrayOrEmpty(itemTypes['musique']);
+    formData.oeuvres = Misc.arrayOrEmpty(itemTypes['oeuvre']);
+    formData.jeux = Misc.arrayOrEmpty(itemTypes['jeu']);
+
+    formData.services = Misc.arrayOrEmpty(itemTypes['service']);
+    formData.conteneurs = Misc.arrayOrEmpty(itemTypes['conteneur']);
+    formData.materiel = Misc.arrayOrEmpty(itemTypes['objet']);
+    formData.armes = Misc.arrayOrEmpty(itemTypes['arme']);
+    formData.armures = Misc.arrayOrEmpty(itemTypes['armure']);
+    formData.munitions = Misc.arrayOrEmpty(itemTypes['munition']);
+    formData.livres = Misc.arrayOrEmpty(itemTypes['livre']);
+    formData.potions = Misc.arrayOrEmpty(itemTypes['potion']);
+    formData.plantes = Misc.arrayOrEmpty(itemTypes['plante']);
+    formData.ingredients = Misc.arrayOrEmpty(itemTypes['ingredient']);
+    formData.faunes = Misc.arrayOrEmpty(itemTypes['faune']);
+    formData.herbes = Misc.arrayOrEmpty(itemTypes['herbe']);
+    formData.nourritureboissons = Misc.arrayOrEmpty(itemTypes['nourritureboisson']);
+    formData.gemmes = Misc.arrayOrEmpty(itemTypes['gemme']);
+    formData.monnaies = Misc.arrayOrEmpty(itemTypes['monnaie']).sort(Monnaie.triValeurEntiere());
+    formData.objets = Misc.arrayOrEmpty(itemTypes['objet'])
+
+    formData.inventaires = RdDItem.getItemTypesInventaire('all')
+      .map(t => Misc.arrayOrEmpty(itemTypes[t]))
+      .reduce((a, b) => a.concat(b), [])
+      .sort(Misc.ascending(it => it.name));
+  }
+
+  /* -------------------------------------------- */  /** @override */
+  activateListeners(html) {
+    super.activateListeners(html);
+    this.html = html;
+
+    this.html.find('.conteneur-name a').click(async event => {
+      RdDUtility.toggleAfficheContenu(this.getItemId(event));
+      this.render(true);
+    });
+    this.html.find('.item-edit').click(async event => this.getItem(event)?.sheet.render(true))
+    this.html.find('.item-montrer').click(async event => this.getItem(event)?.postItemToChat());
+    this.html.find('.actor-montrer').click(async event => this.actor.postActorToChat());
+    this.html.find('.recherche')
+      .each((index, field) => {
+        this._rechercheSelectArea(field);
+      })
+      .keyup(async event => this._rechercherKeyup(event))
+      .change(async event => this._rechercherKeyup(event));
+    this.html.find('.recherche').prop("disabled", false);
+    // Everything below here is only needed if the sheet is editable
+    if (!this.options.editable) return;
+
+    this.html.find('.item-split').click(async event => {
+      const item = this.getItem(event);
+      RdDSheetUtility.splitItem(item, this.actor);
+    });
+    this.html.find('.item-quantite-plus').click(async event => this.actor.itemQuantiteIncDec(this.getItemId(event), 1));
+    this.html.find('.item-quantite-moins').click(async event => this.actor.itemQuantiteIncDec(this.getItemId(event), -1));
+    this.html.find('.item-delete').click(async event => RdDUtility.confirmActorItemDelete(this, this.getItem(event)));
+    this.html.find('.item-vendre').click(async event => this.vendre(this.getItem(event)));
+
+    this.html.find('.creer-un-objet').click(async event => {
+      this.selectObjetTypeToCreate();
+    });
+    this.html.find('.nettoyer-conteneurs').click(async event => {
+      this.actor.nettoyerConteneurs();
+    });
+  }
+
+  _rechercherKeyup(event) {
+    const currentTarget = event.currentTarget;
+    const nouvelleRecherche = this._optionRecherche(currentTarget);
+    if (this.options.recherche?.text != nouvelleRecherche?.text) {
+      this.options.recherche = nouvelleRecherche;
+      if (this.timerRecherche) {
+        clearTimeout(this.timerRecherche);
+      }
+      this.timerRecherche = setTimeout(() => {
+        this.timerRecherche = undefined;
+        this.render(true);
+      }, 500);
+    }
+  }
+
+  _rechercheSelectArea(field) {
+    if (this.options.recherche) {
+      field.focus();
+      field.setSelectionRange(this.options.recherche.start, this.options.recherche.end);
+    }
+  }
+
+  getItemId(event) {
+    return RdDSheetUtility.getItemId(event);
+  }
+
+  getItem(event) {
+    return RdDSheetUtility.getItem(event, this.actor);
+  }
+
+  _optionRecherche(target) {
+    if (!target.value?.length) {
+      return undefined;
+    }
+    return {
+      text: target.value,
+      start: target.selectionStart,
+      end: target.selectionEnd,
+    };
+  }
+  /* -------------------------------------------- */
+  _getHeaderButtons() {
+    let buttons = super._getHeaderButtons();
+    buttons.unshift({
+      class: "montrer",
+      icon: "fas fa-comment",
+      onclick: ev => this.actor.postActorToChat()
+    });
+    return buttons
+  }
+
+  /* -------------------------------------------- */
+  async _onDropItem(event, dragData) {
+    const destItemId = this.html.find(event.target)?.closest('.item').attr('data-item-id')
+    const dropParams = await RdDSheetUtility.prepareItemDropParameters(destItemId, this.actor, dragData, this.objetVersConteneur)
+    if (dropParams) {
+      const callSuper = await this.actor.processDropItem(dropParams)
+      if (callSuper) {
+        await super._onDropItem(event, dragData)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  async selectObjetTypeToCreate() {
+    let types = this.getTypesInventaire().sort(Misc.ascending(type => Misc.typeName('Item', type)));
+    let content = `<span class="competence-label">Selectionnez le type d'équipement</span><select class="item-type">`;
+    for (let typeName of types) {
+      content += `<option value="${typeName}">${Misc.typeName('Item', typeName)}</option>`
+    }
+    content += '</select>';
+    let d = new Dialog({
+      title: "Créer un équipement",
+      content: content,
+      buttons: {
+        create: {
+          icon: '<i class="fas fa-check"></i>',
+          label: "Créer l'objet",
+          callback: () => this.actor.createItem($(".item-type").val())
+        }
+      }
+    });
+    d.render(true);
+  }
+
+  getTypesInventaire() {
+    return RdDItem.getItemTypesInventaire();
+  }
+
+  /** @override */
+  setPosition(options = {}) {
+    const position = super.setPosition(options);
+    const sheetHeader = this.element.find(".sheet-header");
+    const sheetTabs = this.element.find(".sheet-tabs");
+    const sheetBody = this.element.find(".sheet-body");
+    let bodyHeight = position.height - sheetHeader[0].clientHeight;
+    if (sheetTabs.length > 0) {
+      bodyHeight -= sheetTabs[0].clientHeight;
+    }
+    sheetBody.css("height", bodyHeight);
+    return position;
+  }
+
+
+  /* -------------------------------------------- */
+  /** @override */
+  _updateObject(event, formData) {
+    // Update the Actor
+    return this.actor.update(formData);
+  }
+
+  async splitItem(item) {
+    const dialog = await DialogSplitItem.create(item, (item, split) => this._onSplitItem(item, split));
+    dialog.render(true);
+  }
+
+  async _onSplitItem(item, split) {
+    if (split >= 1 && split < item.system.quantite) {
+      await item.diminuerQuantite(split);
+      const splitItem = duplicate(item);
+      splitItem.system.quantite = split;
+      await this.actor.createEmbeddedDocuments('Item', [splitItem])
+    }
+  }
+
+  vendre(item) {
+    item?.proposerVente(this.actor.getQuantiteDisponible(item));
+  }
+
+}

module/actor/base-actor.js

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

module/actor/commerce-sheet.js

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

module/actor/commerce.js

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

module/actor/experience-log.js

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

module/chat-utility.js

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

module/dialog-chronologie.js

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

module/dialog-create-signedraconique.js

@@ -1,6 +1,6 @@
 import { ChatUtility } from "./chat-utility.js";
 import { HtmlUtility } from "./html-utility.js";
-import { RdDItemSigneDraconique } from "./item-signedraconique.js";
+import { RdDItemSigneDraconique } from "./item/signedraconique.js";
 import { TMRUtility } from "./tmr-utility.js";
 
 export class DialogCreateSigneDraconique extends Dialog {
@@ -98,7 +98,7 @@ export class DialogCreateSigneDraconique extends Dialog {
 
   async setEphemere(ephemere) {
     this.dialogData.signe.system.ephemere = ephemere;
-    HtmlUtility._showControlWhen(this.html.find(".signe-system-duree"), ephemere);
+    HtmlUtility.showControlWhen(this.html.find(".signe-system-duree"), ephemere);
   }
 
   async onSelectActor(event) {

module/dialog-fabriquer-potion.js

@@ -5,7 +5,7 @@ import { RdDUtility } from "./rdd-utility.js";
 export class DialogFabriquerPotion extends Dialog {
 
   /* -------------------------------------------- */
-  static async create(actor, item, dialogConfig) {
+  static async create(actor, item, onActionItem) {
     const min = DialogFabriquerPotion.nombreBrinsMinimum(item);
     if (item.system.quantite < min) {
       ui.notifications.warn(`Vous avez ${item.system.quantite} brins de ${item.name}, il en faut au moins ${min} pour faire une potion!`);
@@ -13,12 +13,10 @@ export class DialogFabriquerPotion extends Dialog {
     }
     let potionData = DialogFabriquerPotion.prepareData(actor, item);
 
-    const html = await renderTemplate(dialogConfig.html, potionData);
+    const html = await renderTemplate( 'systems/foundryvtt-reve-de-dragon/templates/dialog-fabriquer-potion-base.html', potionData);
 
     let options = { classes: ["dialogfabriquerpotion"], width: 600, height: 160, 'z-index': 99999 };
-    mergeObject(options, dialogConfig.options ?? {}, { overwrite: true })
-
-    new DialogFabriquerPotion(actor, potionData, html, options).render(true);
+    new DialogFabriquerPotion(actor, potionData, onActionItem, html, options).render(true);
   }
 
   /* -------------------------------------------- */
@@ -34,14 +32,14 @@ export class DialogFabriquerPotion extends Dialog {
   }
 
   /* -------------------------------------------- */
-  constructor(actor, potionData, html, options) {
+  constructor(actor, potionData, onActionItem, html, options) {
     const conf = {
       title: `Fabriquer une potion de ${potionData.system.categorie}`,
       content: html,
       default: 'fabriquer',
       buttons: {
         'fabriquer': {
-          label: potionData.buttonName, callback: it => this.onFabriquer(html)
+          label: potionData.buttonName, callback: it => this.onFabriquer()
         }
       }
     };
@@ -50,6 +48,7 @@ export class DialogFabriquerPotion extends Dialog {
 
     this.actor = actor;
     this.potionData = potionData;
+    this.onActionItem = onActionItem;
   }
 
   /* -------------------------------------------- */
@@ -64,10 +63,11 @@ export class DialogFabriquerPotion extends Dialog {
   }
 
   /* -------------------------------------------- */
-  async onFabriquer(html) {
+  async onFabriquer() {
     await this.html.find("[name='nbBrins']").change();
-    this.actor.fabriquerPotion(this.potionData);
+    await this.actor.fabriquerPotion(this.potionData);
     this.close();
+    await this.onActionItem()
   }
 
   static nombreBrinsMinimum(herbeData) {

module/dialog-item-achat.js

@@ -18,7 +18,7 @@ export class DialogItemAchat extends Dialog {
     }
 
     return {
-      item: (json ? JSON.parse(json) : undefined),
+      item: JSON.parse(json),
       vendeur,
       acheteur,
       nbLots: parseInt(chatButton.attributes['data-quantiteNbLots']?.value),
@@ -30,14 +30,12 @@ export class DialogItemAchat extends Dialog {
   }
 
 
-  static async onAcheter({ item, vendeur, acheteur, service, tailleLot, prixLot, nbLots, quantiteIllimite, chatMessageIdVente }) {
+  static async onAcheter({ item, vendeur, acheteur, tailleLot, prixLot, nbLots, quantiteIllimite, chatMessageIdVente }) {
     const venteData = {
       item,
       actingUserId: game.user.id,
-      vendeurId: vendeur?.id,
       vendeur,
       acheteur,
-      service,
       tailleLot,
       quantiteIllimite,
       quantiteNbLots: nbLots,
@@ -76,7 +74,7 @@ export class DialogItemAchat extends Dialog {
     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.service ?? venteData.vendeur)?.name ?? 'Un vendeur';
+    const vendeur = venteData.vendeur?.name ?? 'Un vendeur';
     let conf = {
       title: `${acheteur} - ${actionAchat} à ${vendeur}`,
       content: html,
@@ -92,7 +90,6 @@ export class DialogItemAchat extends Dialog {
     await this.html.find(".nombreLots").change();
     (this.venteData.vendeur ?? this.venteData.acheteur).achatVente({
       userId: game.user.id,
-      serviceId: this.venteData.service?.id,
       vendeurId: this.venteData.vendeur?.id,
       acheteurId: this.venteData.acheteur?.id,
       prixTotal: this.venteData.prixTotal,

module/dialog-item-vente.js

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

module/dialog-repos.js

@@ -1,56 +0,0 @@
-
-export class DialogRepos extends Dialog {
-
-  static async create(actor) {
-    const html = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/dialog-repos.html", actor);
-    const dialog = new DialogRepos(html, actor);
-    dialog.render(true);
-  }
-
-  constructor(html, actor) {
-    let options = { classes: ["DialogCreateSigneDraconiqueActorsActors"], width: 400, height: 'fit-content', '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;
-  }
-  activateListeners(html) {
-    super.activateListeners(html);
-    this.html = html;
-  }
-  /* -------------------------------------------- */
-
-  async repos() {
-    await this.html.find("[name='nb-heures']").change();
-    await this.html.find("[name='nb-jours']").change();
-    const selection = await this.html.find("[name='repos']:checked").val();
-    const nbHeures = Number.parseInt(await this.html.find("[name='nb-heures']").val());
-    const nbJours = Number.parseInt(await this.html.find("[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;
-      }
-    }
-  }
-}

module/dialog-validation-encaissement.js

@@ -7,7 +7,7 @@ import { RdDUtility } from "./rdd-utility.js";
  */
 export class DialogValidationEncaissement extends Dialog {
 
-  static async validerEncaissement(actor, rollData, armure, show, onEncaisser) {
+  static async validerEncaissement(actor, rollData, armure, show, attackerId, onEncaisser) {
     let encaissement = await RdDUtility.jetEncaissement(rollData, armure, { showDice: HIDE_DICE });
     const html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/dialog-validation-encaissement.html', {
       actor: actor,
@@ -15,15 +15,15 @@ export class DialogValidationEncaissement extends Dialog {
       encaissement: encaissement,
       show: show
     });
-    const dialog = new DialogValidationEncaissement(html, actor, rollData, armure, encaissement, show, onEncaisser);
+    const dialog = new DialogValidationEncaissement(html, actor, rollData, armure, encaissement, show, attackerId, onEncaisser);
     dialog.render(true);
   }
 
   /* -------------------------------------------- */
-  constructor(html, actor, rollData, armure, encaissement, show, onEncaisser) {
+  constructor(html, actor, rollData, armure, encaissement, show, attackerId, onEncaisser) {
     // Common conf
     let buttons = {
-      "valider": { label: "Valider", callback: html => this.validerEncaissement() },
+      "valider": { label: "Valider", callback: html => this.onValider() },
       "annuler": { label: "Annuler", callback: html => { } },
     };
 
@@ -48,6 +48,7 @@ export class DialogValidationEncaissement extends Dialog {
     this.armure = armure;
     this.encaissement = encaissement;
     this.show = show;
+    this.attackerId = attackerId;
     this.onEncaisser = onEncaisser;
     this.forceDiceResult = {total: encaissement.roll.result };
   }
@@ -64,8 +65,8 @@ export class DialogValidationEncaissement extends Dialog {
     });
   }
 
-  async validerEncaissement() {
+  async onValider() {
     this.encaissement = await RdDUtility.jetEncaissement(this.rollData, this.armure, { showDice: SHOW_DICE, forceDiceResult: this.forceDiceResult});
-    this.onEncaisser(this.encaissement, this.show)
+    this.onEncaisser(this.encaissement, this.show, this.attackerId)
   }
 }

module/environnement.js

@@ -1,223 +1,78 @@
 import { SYSTEM_RDD } from "./constants.js";
 import { Grammar } from "./grammar.js";
 import { Misc } from "./misc.js";
-import { CompendiumTableHelpers, CompendiumTable } from "./settings/system-compendiums.js";
+import { CompendiumTableHelpers, CompendiumTable, SystemCompendiums } from "./settings/system-compendiums.js";
 
-const RARETES = [
-  { name: 'Commune', frequence: 54, min: 27, max: 108 },
-  { name: 'Frequente', frequence: 18, min: 9, max: 36 },
-  { name: 'Rare', frequence: 6, min: 3, max: 12 },
-  { name: 'Rarissime', frequence: 2, min: 1, max: 4 }]
-const DEFAULT_RARETE = 1;
 
-const SETTINGS_LISTE_MILIEUX = "liste-milieux";
-const MILIEUX = [
-  "Collines",
-  "Cours d'eau",
-  "Déserts",
-  "Forêts",
-  "Marais",
-  "Maritimes",
-  "Montagnes",
-  "Plaines",
-  "Sous-sols"
-]
-const ITEM_ENVIRONNEMENT_TYPES = [
-  'herbe', 'ingredient', 'faune'
-]
+const COMPENDIUMS_RECHERCHE = 'compendiums-recherche';
 
 export class Environnement {
-
   static init() {
-    game.settings.register(SYSTEM_RDD, SETTINGS_LISTE_MILIEUX, {
-      name: "Liste des milieux proposés",
-      hint: "Liste des milieux proposés pour la faune&flore, séparés par des virgules",
+    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: true,
-      default: MILIEUX.reduce(Misc.joining(',')),
-      type: String
+      config: false,
+      type: Object
     });
+
     game.system.rdd.environnement = new Environnement();
+    Hooks.once('ready', () => game.system.rdd.environnement.onReady());
   }
 
   constructor() {
-    this.table = new CompendiumTable('faune-flore-mineraux', 'Item', ITEM_ENVIRONNEMENT_TYPES)
+    this.compendiums = [];
+    this.compendiumTables = [];
+    this.mapMilieux = {}
   }
 
-  static getRarete(name = undefined) {
-    return RARETES.find(it => it.name == name) ?? RARETES[DEFAULT_RARETE];
-  }
-
-  static getFrequenceRarete(rarete, field = undefined) {
-    const selected = this.getRarete(rarete);
-    return selected[field];
+  async onReady() {
+    await this.$prepareCompendiums()
   }
 
   async milieux() {
-    return Object.values(await this.mapMilieux());
+    return Object.values(this.mapMilieux);
   }
 
-  async mapMilieux() {
-    const compendiumItems = await this.getElements(it => 1, it => ITEM_ENVIRONNEMENT_TYPES.includes(it.type));
-    return Misc.indexLowercase(this.getMilieuxSettings().concat(Environnement.listMilieux(compendiumItems)));
+  async saveCompendiums(compendiumIds) {
+    game.settings.set(SYSTEM_RDD, COMPENDIUMS_RECHERCHE, compendiumIds);
+    await this.$prepareCompendiums();
   }
 
-  static listMilieux(items) {
-    return Misc.concat(items.map(it => Environnement.$itemToMilieux(it).filter(m => m)));
+  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 mapMilieux = await this.mapMilieux();
-    const milieuxExistants = Environnement.$itemToMilieux(item).map(it => Grammar.toLowerCaseNoAccent(it));
-    return Object.keys(mapMilieux)
+    const milieuxExistants = item.getMilieux().map(it => Grammar.toLowerCaseNoAccent(it));
+    return Object.keys(this.mapMilieux)
       .filter(it => !milieuxExistants.includes(it))
-      .map(it => mapMilieux[it]);
+      .map(it => this.mapMilieux[it]);
   }
 
-  static $itemToMilieux(item) {
-    return item.system.environnement.map(env => env.milieu);
-  }
-
-  getMilieuxSettings() {
-    return game.settings.get(SYSTEM_RDD, SETTINGS_LISTE_MILIEUX).split(',').map(it => it.trim()).filter(it => it != '');
-  }
-
-  async findEnvironnementsLike(search) {
-    const milieux = await this.mapMilieux();
-    const searchLower = Grammar.toLowerCaseNoAccent(search);
-    const keys = Object.keys(milieux).filter(it => it.includes(searchLower));
-    if (keys.length > 1) {
-      const milieuExact = milieux[searchLower];
-      if (milieuExact) {
-        return [milieuExact];
-      }
-    }
-    return keys.map(k => milieux[k]);
-  }
-
-  async searchToChatMessage(milieux, typeName) {
-    const table = await this.buildEnvironnementTable(milieux);
-    await CompendiumTableHelpers.tableToChatMessage(table, 'Item', ITEM_ENVIRONNEMENT_TYPES, typeName);
-    return true
-  }
-
-  async getRandom(milieux, typeName) {
-    const table = await this.buildEnvironnementTable(milieux);
-    return await CompendiumTableHelpers.getRandom(table, 'Item', ITEM_ENVIRONNEMENT_TYPES, undefined, typeName);
-  }
-
-  async buildEnvironnementTable(milieux) {
-    const filterMilieux = item => item.system?.environnement.filter(env => milieux.includes(env.milieu));
-    const itemRareteEnMilieu = item => {
-      const raretes = filterMilieux(item);
-      const frequenceMax = Math.max(raretes.map(env => env.frequence));
-      return raretes.find(env => env.frequence == frequenceMax);
-    }
-    const itemFrequenceEnMilieu = item => itemRareteEnMilieu(item)?.frequence ?? 0;
-    const isPresentEnMilieu = item => itemFrequenceEnMilieu(item) > 0;
-    return await this.table.buildTable(itemFrequenceEnMilieu, isPresentEnMilieu);
-  }
-
-
   async getElements(itemFrequence, filter) {
-    return await this.table.getContent(itemFrequence, filter);
+    const compendiumsElement = await Promise.all(
+      this.compendiumTables.map(async compTable => await compTable.getContent(itemFrequence, filter))
+    );
+    const elements = compendiumsElement.reduce((a, b) => a.concat(b));
+    elements.sort(Misc.ascending(it => it.name))
+    return elements;
+  }
+
+  async buildTable(itemFrequence, filter = it => true) {
+    if (!itemFrequence) {
+      itemFrequence = it => it.getFrequence()
+    }
+    const elements = await this.getElements(itemFrequence, filter);;
+    return CompendiumTableHelpers.buildTable(elements, itemFrequence);
   }
 }
-
-export class EnvironmentSheetHelper {
-
-  static defaultOptions(defaultOptions) {
-    return mergeObject(defaultOptions, {
-      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "informations" }]
-    });
-  }
-
-  static setPosition(sheet, superPosition) {
-    const position = superPosition;
-    const sheetHeader = sheet.element.find(".sheet-header");
-    const sheetBody = sheet.element.find(".sheet-body");
-    sheetBody.css("height", position.height - sheetHeader[0].clientHeight)
-    return position;
-  }
-
-  /* -------------------------------------------- */
-  static async getData(sheet, formData) {
-    return mergeObject(formData, {
-      milieux: await game.system.rdd.environnement.autresMilieux(sheet.item)
-    });
-  }
-
-  static activateListeners(sheet) {
-    if (!sheet.options.editable) return;
-
-    sheet.html.find("input.input-selection-milieu").keypress(event => {
-      if (event.keyCode == '13') {
-        EnvironmentSheetHelper.onAddMilieu(sheet, event);
-      }
-      event.stopPropagation();
-    })
-    sheet.html.find("a.milieu-add").click(event => EnvironmentSheetHelper.onAddMilieu(sheet, event));
-    sheet.html.find("div.environnement-milieu a.milieu-delete").click(event => EnvironmentSheetHelper.onDeleteMilieu(sheet, event));
-    sheet.html.find("div.environnement-milieu select.environnement-rarete").change(event => EnvironmentSheetHelper.onChange(sheet, event,
-      updated => EnvironmentSheetHelper.$changeRarete(sheet, event, updated)));
-    sheet.html.find("div.environnement-milieu input[name='environnement-frequence']").change(event => EnvironmentSheetHelper.onChange(sheet, event,
-      updated => EnvironmentSheetHelper.$changeFrequence(sheet, event, updated)));
-  }
-
-  static $changeFrequence(sheet, event, updated) {
-    updated.frequence = Number(sheet.html.find(event.currentTarget).val());
-  }
-
-  static $changeRarete(sheet, event, updated) {
-    const name = sheet.html.find(event.currentTarget).val();
-    const rarete = Environnement.getRarete(name);
-    updated.rarete = rarete.name;
-    updated.frequence = rarete.frequence;
-    // updated.frequence = Math.min(
-    //   Math.max(rarete.min, updated.frequence ?? rarete.frequence),
-    //   rarete.max);
-  }
-
-  static async onAddMilieu(sheet, event) {
-    const milieu = sheet.html.find('input.input-selection-milieu').val();
-    if (!milieu) {
-      ui.notifications.warn(`Choisissez le milieu dans lequel se trouve le/la ${sheet.item.name}`);
-      return
-    }
-    const list = sheet.item.system.environnement;
-    const exists = list.find(it => it.milieu == milieu);
-    if (exists) {
-      ui.notifications.warn(`${sheet.item.name} a déjà une rareté ${exists.rarete} en ${milieu} (fréquence: ${exists.frequence})`);
-      return
-    }
-    const rarete = Environnement.getRarete();
-    const newList = [...list, { milieu, rarete: rarete.name, frequence: rarete.frequence }].sort(Misc.ascending(it => it.milieu))
-    await sheet.item.update({ 'system.environnement': newList })
-  }
-
-  static async onDeleteMilieu(sheet, event) {
-    const milieu = EnvironmentSheetHelper.$getEventMilieu(sheet, event);
-    if (milieu != undefined) {
-      const newList = sheet.item.system.environnement.filter(it => it.milieu != milieu)
-        .sort(Misc.ascending(it => it.milieu));
-      await sheet.item.update({ 'system.environnement': newList });
-    }
-  }
-
-  static async onChange(sheet, event, doMutation) {
-    const list = sheet.item.system.environnement;
-    const milieu = EnvironmentSheetHelper.$getEventMilieu(sheet, event);
-    const updated = list.find(it => it.milieu == milieu);
-    if (updated) {
-      doMutation(updated);
-      const newList = [...list.filter(it => it.milieu != milieu), updated]
-        .sort(Misc.ascending(it => it.milieu));
-      await sheet.item.update({ 'system.environnement': newList });
-    }
-  }
-
-  static $getEventMilieu(sheet, event) {
-    return sheet.html.find(event.currentTarget)?.parents("div.environnement-milieu").data("milieu");
-  }
-
-}

module/html-utility.js

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

module/item-arme.js

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

module/item-competence.js

@@ -23,7 +23,7 @@ const limitesArchetypes = [
 ];
 
 /* -------------------------------------------- */
-const categorieCompetences = {
+const categoriesCompetences = {
   "generale": { base: -4, label: "Générales" },
   "particuliere": { base: -8, label: "Particulières" },
   "specialisee": { base: -11, label: "Spécialisées" },
@@ -49,16 +49,16 @@ const competence_xp_cumul = _buildCumulXP();
 
 export class RdDItemCompetence extends Item {
   /* -------------------------------------------- */
-  static getCategorieCompetences() {
-    return categorieCompetences;
-  }
-  /* -------------------------------------------- */
-  static getNiveauBase(category) {
-    return categorieCompetences[category].base;
+  static getCategories() {
+    return categoriesCompetences;
   }
   /* -------------------------------------------- */
   static getLabelCategorie(category) {
-    return categorieCompetences[category].label;
+    return categoriesCompetences[category].label;
+  }
+  /* -------------------------------------------- */
+  static getNiveauBase(category, categories = categoriesCompetences) {
+    return categories[category]?.base ?? 0;
   }
 
   /* -------------------------------------------- */
@@ -190,18 +190,9 @@ export class RdDItemCompetence extends Item {
     }
   }
 
-  /* -------------------------------------------- */
-  static isVisible(item) {
-    return Number(item.system.niveau) != RdDItemCompetence.getNiveauBase(item.system.categorie);
-  }
-
-  static nomContientTexte(item, texte) {
-    return Grammar.toLowerCaseNoAccent(item.name).includes(Grammar.toLowerCaseNoAccent(texte))
-  }
-
   /* -------------------------------------------- */
   static isNiveauBase(item) {
-    return Number(item.system.niveau) == RdDItemCompetence.getNiveauBase(item.system.categorie);
+    return Number(item.system.niveau) == RdDItemCompetence.getNiveauBase(item.system.categorie, item.getCategories());
   }
 
   /* -------------------------------------------- */
@@ -279,7 +270,7 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   static triVisible(competences) {
-    return competences.filter(it => it.system.isVisible)
+    return competences.filter(it => !it.system.isHidden)
       .sort((a, b) => RdDItemCompetence.compare(a, b))
   }
 

module/item-competencecreature.js

@@ -1,51 +1,97 @@
 
+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 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.competence.system.categorie = "creature"
-    rollData.selectedCarac =  rollData.carac.carac_creature
-    if (rollData.competence.system.iscombat) {
-      rollData.arme = RdDItemCompetenceCreature.armeNaturelle(rollData.competence);
-    }
+  static getCategories() {
+    return categories;
   }
 
   /* -------------------------------------------- */
-  static armeNaturelle(competencecreature) {
-    if (RdDItemCompetenceCreature.isCompetenceAttaque(competencecreature)) {
-      // si c'est un Item compétence: cloner pour ne pas modifier lma compétence
-      let arme = (competencecreature instanceof Item) ? competencecreature.clone():  competencecreature;
-      mergeObject(arme.system,
+  static setRollDataCreature(rollData) {
+    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.arme = RdDItemCompetenceCreature.armeCreature(rollData.competence);
+  }
+
+  /* -------------------------------------------- */
+  static armeCreature(item) {
+    const categorieAttaque = RdDItemCompetenceCreature.getCategorieAttaque(item)
+    if (categorieAttaque != undefined) {
+      // si c'est un Item compétence: cloner pour ne pas modifier la compétence
+      let arme = item.clone();
+      mergeObject(arme,
         {
-          competence: arme.name,
-          initiative: RdDCombatManager.calculInitiative(competencecreature.system.niveau, competencecreature.system.carac_value),
-          niveau: competencecreature.system.niveau,
-          equipe: true,
-          resistance: 100,
-          dommagesReels: arme.system.dommages,
-          penetration: 0,
-          force: 0,
-          rapide: true,
-          cac: competencecreature.system.isnaturelle ? "naturelle" : "",
-          action: 'attaque'
+          action: item.isCompetencePossession() ? 'possession' : 'attaque',
+          system: {
+            competence: arme.name,
+            cac: categorieAttaque == "naturelle" ? "naturelle" : "",
+            niveau: item.system.niveau,
+            initiative: RdDCombatManager.calculInitiative(item.system.niveau, item.system.carac_value),
+            equipe: true,
+            resistance: 100,
+            dommagesReels: arme.system.dommages,
+            penetration: 0,
+            force: 0,
+            rapide: true,
+          }
         });
       return arme;
     }
-    console.error("RdDItemCompetenceCreature.toActionArme(", competencecreature, ") : impossible de transformer l'Item en arme");
     return undefined;
   }
 
   /* -------------------------------------------- */
-  static isCompetenceAttaque(item) {
-    return item.type == 'competencecreature' && item.system.iscombat;
+  static getCategorieAttaque(item) {
+    if (item.type == TYPES.competencecreature) {
+      switch (item.system.categorie) {
+        case "melee":
+        case "tir":
+        case "lancer":
+        case "naturelle":
+        case "possession":
+          return item.system.categorie
+      }
+    }
+    return undefined
   }
-  
+  static isDommages(item) {
+    if (item.type == TYPES.competencecreature) {
+      switch (item.system.categorie) {
+        case "melee":
+        case "tir":
+        case "lancer":
+        case "naturelle":
+          return true
+      }
+    }
+    return false
+  }
+  static isParade(item) {
+    if (item.type == TYPES.competencecreature) {
+      switch (item.system.categorie) {
+        case "melee":
+        case "naturelle":
+        case "parade":
+          return true
+      }
+    }
+    return false
+  }
+
   /* -------------------------------------------- */
   static isCompetenceParade(item) {
     return item.type == 'competencecreature' && item.system.categorie_parade !== "";

module/item-faune-sheet.js

@@ -1,67 +0,0 @@
-import { EnvironmentSheetHelper } from "./environnement.js";
-import { RdDItemSheet } from "./item-sheet.js";
-import { RdDUtility } from "./rdd-utility.js";
-
-export class RdDFauneItemSheet extends RdDItemSheet {
-
-  static get ITEM_TYPE() { return "faune" };
-
-  static get defaultOptions() {
-    return EnvironmentSheetHelper.defaultOptions(super.defaultOptions);
-  }
-
-  setPosition(options = {}) {
-    return EnvironmentSheetHelper.setPosition(this, super.setPosition(options));
-  }
-
-  async getData() {
-    const formData = await super.getData();
-    return await EnvironmentSheetHelper.getData(this, formData);
-  }
-
-  activateListeners(html) {
-    super.activateListeners(html);
-    if (!this.options.editable) return;
-
-    EnvironmentSheetHelper.activateListeners(this);
-
-    html.find("a.linked-actor-delete").click(event => this.onDeleteLinkedActor());
-    html.find("a.preparer-nourriture").click(event => this.preparerNourriture(event));
-    html.find("a.manger-nourriture").click(event => this.mangerNourriture(event));
-  }
-
-  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': ''
-    });
-  }
-
-  async preparerNourriture(event) {
-    if (this.actor) {
-      await this.actor.preparerNourriture(this.item);
-    }
-  }
-  async mangerNourriture(event) {
-    if (this.actor) {
-      await this.actor.mangerNourriture(this.item);
-    }
-  }
-
-}

module/item-herbe-sheet.js

@@ -1,25 +0,0 @@
-import { EnvironmentSheetHelper } from "./environnement.js";
-import { RdDItemSheet } from "./item-sheet.js";
-
-export class RdDHerbeItemSheet extends RdDItemSheet {
-
-  static get ITEM_TYPE() { return "herbe" };
-
-  static get defaultOptions() {
-    return EnvironmentSheetHelper.defaultOptions(super.defaultOptions);
-  }
-
-  setPosition(options = {}) {
-    return EnvironmentSheetHelper.setPosition(this, super.setPosition(options));
-  }
-
-  async getData() {
-    const formData = await super.getData();
-    return await EnvironmentSheetHelper.getData(this, formData);
-  }
-
-  activateListeners(html) {
-    super.activateListeners(html);
-    EnvironmentSheetHelper.activateListeners(this);
-  }
-}

module/item-ingredient-sheet.js

@@ -1,25 +0,0 @@
-import { EnvironmentSheetHelper } from "./environnement.js";
-import { RdDItemSheet } from "./item-sheet.js";
-
-export class RdDIngredientItemSheet extends RdDItemSheet {
-
-  static get ITEM_TYPE() { return "ingredient" };
-
-  static get defaultOptions() {
-    return EnvironmentSheetHelper.defaultOptions(super.defaultOptions);
-  }
-
-  setPosition(options = {}) {
-    return EnvironmentSheetHelper.setPosition(this, super.setPosition(options));
-  }
-
-  async getData() {
-    const formData = await super.getData();
-    return await EnvironmentSheetHelper.getData(this, formData);
-  }
-
-  activateListeners(html) {
-    super.activateListeners(html);
-    EnvironmentSheetHelper.activateListeners(this);
-  }
-}

module/item-monnaie.js

@@ -17,7 +17,7 @@ const MONNAIE_ARGENT = {
   system: { quantite: 0, cout: 1, encombrement: 0.003, description: "" }
 };
 const MONNAIE_OR = {
-  name: "Dreagon (or)", type: 'monnaie',
+  name: "Dragon (or)", type: 'monnaie',
   img: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_or_sol.webp",
   system: { quantite: 0, cout: 10, encombrement: 0.004, description: "" }
 };
@@ -62,29 +62,24 @@ export class Monnaie {
     return deniers;
   }
 
-  static getFortune(actor) {
-    if (actor) {
-      Monnaie.validerMonnaies(actor);
-      return actor.itemTypes['monnaie']
-        .map(m => Number(m.system.cout) * Number(m.system.quantite))
-        .reduce(Misc.sum(), 0);
-    }
-    return 0;
-  }
-
-  static getFortuneSolsDeniers(actor) {
-    const fortune = Monnaie.getFortune(actor);
+  static toSolsDeniers(fortune) {
     return {
       sols: Math.floor(fortune),
       deniers: Math.round(100 * (fortune - Math.floor(fortune)))
     };
   }
 
+  static getFortune(monnaies) {
+    return (monnaies??[])
+      .map(m => Number(m.system.cout) * Number(m.system.quantite))
+      .reduce(Misc.sum(), 0);
+  }
+
   static async optimiserFortune(actor, fortune) {
     let resteEnDeniers = Math.round(fortune * 100);
     let monnaies = actor.itemTypes['monnaie'];
     let updates = [];
-    Monnaie.validerMonnaies(actor);
+    Monnaie.validerMonnaies(monnaies, actor);
 
     let parValeur = Misc.classifyFirst(monnaies, it => VALEUR_DENIERS(it.system.cout));
     for (let valeurDeniers of [1000, 100, 10, 1]) {
@@ -107,9 +102,9 @@ export class Monnaie {
     }
   }
 
-  static validerMonnaies(actor) {
-    actor.itemTypes['monnaie'].filter(it => VALEUR_DENIERS(it.system.cout) == 0)
-      .map(it => `La  monnaie ${it.name} de l'acteur ${actor.name} a une valeur de 0!`)
+  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-service-sheet.js

@@ -1,81 +0,0 @@
-import { RdDItemSheet } from "./item-sheet.js";
-import { Misc } from "./misc.js";
-import { RdDUtility } from "./rdd-utility.js";
-import { SystemCompendiums } from "./settings/system-compendiums.js";
-import { DialogItemAchat } from "./dialog-item-achat.js";
-import { RdDItem } from "./item.js";
-import { RdDItemService } from "./item-service.js";
-
-export class RdDServiceItemSheet extends RdDItemSheet {
-
-  static get ITEM_TYPE() { return "service" };
-
-  async getData() {
-    const formData = await super.getData();
-    formData.disabled = formData.isGM || formData.isOwned ? '' : 'disabled';
-    return formData;
-  }
-
-  activateListeners(html) {
-    super.activateListeners(html);
-
-    this.html.find('a.rdd-world-content-link').click(async event => {
-      const itemRef = this.getItemRef(event);
-      game.items.get(itemRef.id)?.sheet.render(true)
-    });
-
-    this.html.find('a.sub-item-acheter').click(async event => {
-      const subItem = this.item.findRefItem(this.getItemRef(event));
-      await this.item.acheter(RdDUtility.getSelectedActor(), subItem);
-    });
-
-    if (!this.options.editable) return;
-
-    this.html.find('a.sub-item-vendre').click(async event => {
-      const subItem = this.item.findRefItem(this.getItemRef(event));
-      await this.item.vendre(subItem);
-    });
-
-    this.html.find('a.sub-item-delete').click(async event => {
-      await this.item.removeRefItem(this.getItemRef(event));
-    });
-
-    this.html.find('a.sub-item-quantite-moins').click(async event => await this.item.increaseRefItemQuantite(this.getItemRef(event), -1))
-    this.html.find('a.sub-item-quantite-plus').click(async event => await this.item.increaseRefItemQuantite(this.getItemRef(event), 1))
-    this.html.find('input.sub-item-quantite').change(async event => {
-      const newQuantite = Math.max(0, Number.parseInt(this.html.find(event.currentTarget).val()));
-      await this.item.updateRefItem(this.getItemRef(event), it => it.system.quantite = newQuantite);
-    })
-    this.html.find('input.sub-item-cout').change(async event => {
-      const newCout = Math.max(0, Number(this.html.find(event.currentTarget).val()));
-      await this.item.updateRefItem(this.getItemRef(event), it => it.system.cout = newCout);
-    })
-    this.html.find('a.sub-item-info-add').click(__ =>
-      ui.notifications.info(`Utiliser le glisser-déposer pour ajouter des objets depuis un compendium ou les objets du monde`)
-    );
-
-  }
-
-  async _onDropItem(event, dragData) {
-    let linkedItem = fromUuidSync(dragData.uuid);
-    const existing = this.item.system.items.find(it => it.pack == linkedItem.pack && it.id == linkedItem.id && it.type == linkedItem.type);
-    if (existing) {
-      ui.notifications.warn(`${this.item.name} contient déjà un ${existing.name}`);
-      return;
-    }
-    if (linkedItem.pack) {
-      linkedItem = await SystemCompendiums.loadDocument(linkedItem);
-    }
-    if (linkedItem.isInventaire()) {
-      await this.item.addRefItem(RdDServiceItemSheet.createSubItem(linkedItem));
-    }
-    else {
-      ui.notifications.warn(`${this.item.name} ne peut pas proposer à la vente de ${Misc.typeName('Item', linkedItem.type)}: ${linkedItem.name}`);
-    }
-  }
-
-  getItemRef(event) {
-    const itemRow = this.html.find(event.currentTarget)?.parents('.item.service-item');
-    return { id: itemRow?.data("item-id"), pack: itemRow?.data("pack") ?? undefined }
-  }
-}

module/item-service.js

@@ -1,140 +0,0 @@
-import { DialogItemAchat } from "./dialog-item-achat.js";
-import { RdDItem } from "./item.js";
-import { Misc } from "./misc.js";
-
-export class RdDItemService extends RdDItem {
-
-  static get defaultIcon() {
-    return "systems/foundryvtt-reve-de-dragon/icons/items/services.webp";
-  }
-
-  /** @override*/
-  getUserLevel(user) {
-    const level = super.getUserLevel(user);
-    if (level == CONST.DOCUMENT_OWNERSHIP_LEVELS.NONE) {
-      // si quelqu'un a accès au lien d'un service, il peut le voir
-      return CONST.DOCUMENT_OWNERSHIP_LEVELS.LIMITED;
-    }
-    return level;
-  }
-
-  isService() { return true; }
-  getChatItemTemplate() { return 'systems/foundryvtt-reve-de-dragon/templates/post-item-service.html'; }
-  getProprietes() { return []; }
-
-  getServiceItem(itemRef) {
-    if (this.isService()) {
-      return this.system.items.find(it => it.id == itemRef.id && it.pack == itemRef.pack);
-    }
-    return undefined;
-  }
-
-  getQuantiteDisponible(itemRef, max) {
-    if (this.system.illimite) {
-      return max;
-    }
-    const subItem = this.getServiceItem(itemRef);
-    return subItem?.system.quantite ?? 0;
-  }
-
-  async venteRefItem(ref, quantite, cout) {
-    if (this.actor) {
-      await this.actor.ajouterSols(cout);
-    }
-    await this.increaseRefItemQuantite(ref, -quantite);
-  }
-
-  async vendre(subItem) {
-    const item = await RdDItem.getCorrespondingItem(subItem);
-    const quantiteMax = this.system.illimite ? undefined : subItem.system.quantite;
-    await item.proposerVente({ service: this, quantiteMax });
-  }
-
-  async acheter(acheteur, subItem) {
-    if (!acheteur) {
-      ui.notifications.warn(`Pas d'acheteur sélectionné`);
-      return;
-    }
-    const nbLots = this.system.illimite ? 1 : subItem.system.quantite;
-    if (nbLots <= 0) {
-      ui.notifications.warn(`${this.name} n'a plus de ${subItem.name} en vente`);
-      return;
-    }
-
-    await DialogItemAchat.onAcheter({
-      item: await RdDItem.getCorrespondingItem(subItem),
-      acheteur,
-      service: this,
-      quantiteIllimite: this.system.illimite,
-      nbLots,
-      tailleLot: 1,
-      prixLot: subItem.system.cout
-    });
-  }
-
-  static createSubItem(linkedItem) {
-    return {
-      id: linkedItem.id,
-      pack: linkedItem.pack,
-      name: linkedItem.name,
-      img: linkedItem.img,
-      system: {
-        quantite: 1,
-        cout: linkedItem.system.cout ?? 0
-      }
-    };
-  }
-
-  static matchRefItem({ id, pack }) {
-    return it => it.id == id && (pack ? (it.pack == pack) : (!it.pack));
-  }
-
-  findRefItem(ref) {
-    return this.system.items.find(RdDItemService.matchRefItem(ref));
-  }
-
-  async increaseRefItemQuantite(ref, quantite) {
-    await this.updateRefItem(ref,
-      it => it.system.quantite = Math.max(0, it.system.quantite + quantite)
-    );
-  }
-
-  async updateRefItem(ref, update = it => { }) {
-    await this.updateRefItems(RdDItemService.matchRefItem(ref), update);
-  }
-
-  async addRefItem(newItem) {
-    if (!newItem.id) {
-      ui.notifications.warn(`${newItem?.name ?? '??'} n'a pas d'identifiant`);
-      return;
-    }
-    if (this.system.items.find(RdDItemService.matchRefItem(newItem))) {
-      ui.notifications.warn(`${newItem?.name ?? newItem.id} est déjà présent ici`);
-      return;
-    }
-    await this.setRefItems([...this.system.items, newItem]);
-  }
-
-  async removeRefItem(ref) {
-    await this.removeRefItems(RdDItemService.matchRefItem(ref));
-  }
-
-  async removeRefItems(matcher = it => false) {
-    await this.setRefItems(this.system.items.filter(it => !matcher(it)));
-  }
-
-  async updateRefItems(matcher = it => false, update = it => { }) {
-    const updatedList = this.system.items.map(it => {
-      if (matcher(it)) {
-        update(it);
-      }
-      return it;
-    });
-    await this.setRefItems(updatedList);
-  }
-
-  async setRefItems(newItems) {
-    await this.update({ 'system.items': newItems.sort(Misc.ascending(it => it.type + ':' + it.name)) });
-  }
-
-}

module/item-sheet.js

@@ -10,6 +10,9 @@ 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
@@ -60,13 +63,13 @@ export class RdDItemSheet extends ItemSheet {
       buttons.unshift({
         class: "vendre",
         icon: "fas fa-comments-dollar",
-        onclick: ev => this.item.proposerVente()
+        onclick: ev => this.item.proposerVente(1)
       });
     }
     buttons.unshift({
       class: "montrer",
       icon: "fas fa-comment",
-      onclick: ev => this.item.postItem()
+      onclick: ev => this.item.postItemToChat()
     });
     return buttons
   }
@@ -85,33 +88,32 @@ export class RdDItemSheet extends ItemSheet {
   /* -------------------------------------------- */
   async getData() {
     let formData = {
-      id: this.item.id,
       title: this.item.name,
+      id: this.item.id,
       type: this.item.type,
       img: this.item.img,
       name: this.item.name,
       system: this.item.system,
-      isGM: game.user.isGM,
       actorId: this.actor?.id,
-      isOwned: this.actor ? true : false,
-      owner: this.item.isOwner,
-      editable: this.isEditable,
-      cssClass: this.isEditable ? "editable" : "locked",
-      isSoins: false,
       description: await TextEditor.enrichHTML(this.item.system.description, { async: true }),
       descriptionmj: await TextEditor.enrichHTML(this.item.system.descriptionmj, { async: true }),
-      isComestible: this.item.isComestible()
+      isComestible: this.item.getUtilisationCuisine(),
+      options: RdDSheetUtility.mergeDocumentRights(this.options, this.item, this.isEditable)
+    }
+    if (this.item.type == TYPES.competencecreature) {
+      formData.isparade = RdDItemCompetenceCreature.isParade(this.item)
+      formData.isdommages = RdDItemCompetenceCreature.isDommages(this.item)
     }
 
-    const competences = await SystemCompendiums.getCompetences(this.actor?.type);
-    formData.categorieCompetences = RdDItemCompetence.getCategorieCompetences()
+    const competences = await SystemCompendiums.getCompetences('personnage');
+    formData.categories = this.item.getCategories()
     if (this.item.type == 'tache' || this.item.type == 'livre' || this.item.type == 'meditation' || this.item.type == 'oeuvre') {
       formData.caracList = duplicate(game.system.model.Actor.personnage.carac)
       formData.caracList["reve-actuel"] = duplicate(game.system.model.Actor.personnage.reve.reve)
       formData.competences = competences;
     }
     if (this.item.type == 'arme') {
-      formData.competences = competences.filter(it => RdDItemCompetence.isCompetenceArme(it));
+      formData.competences = competences.filter(it => RdDItemCompetence.isCompetenceArme(it))
     }
     if (['sort', 'sortreserve'].includes(this.item.type)) {
       formData.competences = competences.filter(it => RdDItemCompetence.isDraconic(it));
@@ -135,18 +137,14 @@ export class RdDItemSheet extends ItemSheet {
       RdDGemme.calculDataDerivees(this.item);
     }
     if (this.item.type == 'potion') {
-      if (this.dateUpdated) {
-        formData.system.prdate = this.dateUpdated;
-        this.dateUpdated = undefined;
-      }
-      await RdDHerbes.updatePotionData(formData);
+      await RdDHerbes.addPotionFormData(formData);
     }
-    if (formData.isOwned && this.item.type == 'herbe' && (formData.system.categorie == 'Soin' || formData.system.categorie == 'Repos')) {
+    if (formData.options.isOwned && this.item.type == 'herbe' && (formData.system.categorie == 'Soin' || formData.system.categorie == 'Repos')) {
       formData.isIngredientPotionBase = true;
     }
     if (this.item.type == 'sortreserve') {
       const sortId = this.item.system.sortid;
-      formData.sort = formData.isOwned ? this.item.actor.items.get(sortId) : game.items.get(sortId);
+      formData.sort = formData.options.isOwned ? this.item.actor.items.get(sortId) : game.items.get(sortId);
     }
     formData.bonusCaseList = RdDItemSort.getBonusCaseList(formData, true);
 
@@ -159,8 +157,10 @@ export class RdDItemSheet extends ItemSheet {
     super.activateListeners(html);
     this.html = html;
 
-    HtmlUtility._showControlWhen(this.html.find(".item-cout"), ReglesOptionelles.isUsing('afficher-prix-joueurs') || game.user.isGM || !this.item.isOwned);
-    HtmlUtility._showControlWhen(this.html.find(".item-magique"), this.item.isMagique());
+    HtmlUtility.showControlWhen(this.html.find(".item-cout"), ReglesOptionelles.isUsing('afficher-prix-joueurs')
+      || game.user.isGM
+      || !this.item.isOwned);
+    HtmlUtility.showControlWhen(this.html.find(".item-magique"), this.item.isMagique());
 
     // Everything below here is only needed if the sheet is editable
     if (!this.options.editable) return;
@@ -185,14 +185,16 @@ export class RdDItemSheet extends ItemSheet {
       }
     })
 
-    this.html.find('.enchanteDate').change((event) => {
-      let jour = Number(this.html.find('[name="splitDate.day"]').val());
-      let mois = this.html.find('[name="splitDate.month"]').val();
-      this.dateUpdated = game.system.rdd.calendrier.getIndexFromDate(jour, mois);
+    this.html.find('.date-enchantement').change((event) => {
+      const jour = Number(this.html.find('input.date-enchantement[name="enchantement.jour"]').val());
+      const mois = RdDTimestamp.definition(this.html.find('select.date-enchantement[name="enchantement.mois"]').val());
+      const indexDate = game.system.rdd.calendrier.getIndexFromDate(jour, mois.heure);
+      this.item.update({ 'system.prdate': indexDate });
+      console.warn(`Date d'enchantement modifiée ${jour}/${mois.heure}: ${indexDate}`)
     });
 
     this.html.find('.creer-tache-livre').click((event) => this._getEventActor(event).creerTacheDepuisLivre(this.item));
-    this.html.find('.consommer-potion').click((event) => this._getEventActor(event).consommerPotion(this.item));
+    this.html.find('.consommer-potion').click((event) => this._getEventActor(event).consommerPotion(this.item, this.getActionRenderItem()));
     this.html.find('.creer-potion-base').click((event) => this._getEventActor(event).dialogFabriquerPotion(this.item));
 
     this.html.find('.alchimie-tache a').click((event) => {
@@ -207,12 +209,38 @@ export class RdDItemSheet extends ItemSheet {
       }
     });
 
-    this.html.find('.item-split').click(async event => RdDSheetUtility.splitItem(RdDSheetUtility.getItem(event, this.actor), this.actor, async () => this.render(true)));
-    this.html.find('.item-edit').click(async event => RdDSheetUtility.getItem(event, this.actor)?.sheet.render(true));
-    this.html.find('.item-delete').click(async event => RdDUtility.confirmActorItemDelete(this, RdDSheetUtility.getItem(event, this.actor)));
-    this.html.find('.item-vendre').click(async event => RdDSheetUtility.getItem(event, this.actor)?.proposerVente());
-    this.html.find('.item-montrer').click(async event => RdDSheetUtility.getItem(event, this.actor)?.postItem());
-    this.html.find('.item-action').click(async event => RdDSheetUtility.getItem(event, this.actor)?.actionPrincipale(this.actor, async () => this.render(true)));
+    if (this.actor) {
+      this.html.find('.item-split').click(async event => RdDSheetUtility.splitItem(RdDSheetUtility.getItem(event, this.actor), this.actor, this.getActionRenderItem()));
+      this.html.find('.item-edit').click(async event => RdDSheetUtility.getItem(event, this.actor)?.sheet.render(true));
+      this.html.find('.item-delete').click(async event => RdDUtility.confirmActorItemDelete(this, RdDSheetUtility.getItem(event, this.actor)));
+      this.html.find('.item-vendre').click(async event => RdDSheetUtility.getItem(event, this.actor)?.proposerVente());
+      this.html.find('.item-montrer').click(async event => RdDSheetUtility.getItem(event, this.actor)?.postItemToChat());
+      this.html.find('.item-action').click(async event => RdDSheetUtility.getItem(event, this.actor)?.actionPrincipale(this.actor, this.getActionRenderItem()));
+
+      this.html.find('.item-quantite-plus').click(async event => {
+        await this.actor.itemQuantiteIncDec(RdDSheetUtility.getItemId(event), 1)
+        this.render();
+      });
+      this.html.find('.item-quantite-moins').click(async event => {
+        await this.actor.itemQuantiteIncDec(RdDSheetUtility.getItemId(event), -1)
+        this.render();
+      });
+    }
+
+    const updateItemTimestamp = (path, timestamp) => this.item.update({ [path]: duplicate(timestamp) })
+
+    RdDTimestamp.handleTimestampEditor(this.html, 'system.temporel.debut', updateItemTimestamp);
+    RdDTimestamp.handleTimestampEditor(this.html, 'system.temporel.fin', updateItemTimestamp);
+  }
+
+  getActionRenderItem() {
+    return async () => {
+      let item = this.item;
+      while (item) {
+        await item.sheet?.render()
+        item = this.actor.getContenant(item)
+      }
+    }
   }
 
   _getEventActor(event) {
@@ -221,12 +249,14 @@ export class RdDItemSheet extends ItemSheet {
     return actor;
   }
 
+
   /* -------------------------------------------- */
   async _onSelectCategorie(event) {
     event.preventDefault();
 
     if (this.item.isCompetence()) {
-      let level = RdDItemCompetence.getNiveauBase(event.currentTarget.value);
+      const categorie = event.currentTarget.value;
+      const level =  RdDItemCompetence.getNiveauBase(categorie, this.item.getCategories());
       this.item.system.base = level;
       this.html.find('[name="system.base"]').val(level);
     }
@@ -237,9 +267,8 @@ export class RdDItemSheet extends ItemSheet {
   _updateObject(event, formData) {
     if (this.item.type == 'sort') {
       // Données de bonus de cases ?
-      formData['system.bonuscase'] = RdDItemSort.buildBonusCaseStringFromFormData(formData.bonusValue, formData.caseValue);
+      formData['system.bonuscase'] = RdDItemSort.buildBonuscaseFromArrays(formData.bonusValue, formData.caseValue);
     }
-
     return this.item.update(formData);
   }
 

module/item-sort.js

@@ -1,4 +1,3 @@
-/* -------------------------------------------- */
 import { Misc } from "./misc.js";
 import { TMRUtility } from "./tmr-utility.js";
 
@@ -14,9 +13,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;
     }
@@ -25,94 +24,91 @@ 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( caseBonusString, newCase ) {
-      if (caseBonusString == undefined) {
-        return [];
-      }
-      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;
+  static buildBonusCaseList(bonuscase, newCase) {
+    const list = RdDItemSort._bonuscaseStringToList(bonuscase)
+    if (newCase) {
+      return list.concat({ case: "Nouvelle", bonus: 0 });
     }
-    
-  /* -------------------------------------------- */
+    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') {
-      return this.buildBonusCaseList(item.system.bonuscase, newCase );
+    if (item.type == 'sort') {
+      return RdDItemSort.buildBonusCaseList(item.system.bonuscase, newCase);
     }
     return undefined;
   }
-    
+
   /* -------------------------------------------- */
   /** Met à jour les données de formulaire 
    * si static des bonus de cases sont présents 
    * */
-  static buildBonusCaseStringFromFormData( bonuses, cases ) {
-    if ( bonuses ) {
-      let list = [];
-      let caseCheck = {};
-      for (let i=0; i<bonuses.length; i++) {
-        let coord = cases[i]?.toUpperCase() || 'A1';
-        let bonus = bonuses[i] || 0;
-        if ( TMRUtility.verifyTMRCoord( coord ) && bonus > 0 && caseCheck[coord] == undefined ) {
+  static buildBonuscaseFromArrays(bonuses, coords) {
+    if (bonuses) {
+      const list = [];
+      const caseCheck = {};
+      for (let i = 0; i < bonuses.length && i < coords.length; i++) {
+        const coord = coords[i] == 'Fleuve' ? 'Fleuve' : (coords[i]?.toUpperCase() ?? 'A1');
+        const bonus = bonuses[i] || 0;
+        if (TMRUtility.verifyTMRCoord(coord) && bonus > 0 && caseCheck[coord] == undefined) {
           caseCheck[coord] = bonus;
-          list.push( coord+":"+bonus );
+          list.push({ case: coord, bonus: bonus });
         }
       }
-      return list.toString();
+      return RdDItemSort._bonuscaseListToString(list);
     }
     return undefined;
   }
-  
+
   /* -------------------------------------------- */
-  static incrementBonusCase( actor, sort, coord ) {
-      let bonusCaseList = this.buildBonusCaseList(sort.system.bonuscase, false);
-      //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);
-      }
+  static incrementBonusCase(actor, sort, coord) {
+    if (TMRUtility.getTMR(coord).type == "fleuve") {
+      coord = 'Fleuve';
     }
-    return 0;
+    const list = RdDItemSort.buildBonusCaseList(sort.system.bonuscase, false);
+    const bonus = Number(list.find(it => it.case == coord)?.bonus ?? 0);
+    const modified = { case: coord, bonus: bonus + 1 };
+
+    const bonuscase = RdDItemSort._bonuscaseListToString(
+      list.filter(it => it.case != coord).concat(modified)
+    );
+
+    // Sauvegarde/update
+    actor.updateEmbeddedDocuments('Item', [{ _id: sort._id, 'system.bonuscase': bonuscase }]);
+  }
+
+
+  /* -------------------------------------------- */
+  static getCaseBonus(sort, coord) {
+    const isFleuve = TMRUtility.getTMR(coord).type == "fleuve";
+
+    let bc = RdDItemSort.buildBonusCaseList(sort.system.bonuscase, false)
+      .filter(it => it.case == coord || (isFleuve && it.case == 'Fleuve'))
+      .find(it => true)
+    return Number(bc?.bonus ?? 0);
+  }
+
+  static _bonuscaseListToString(list) {
+    return list.map(it => `${it.case}:${it.bonus}`)
+      .sort(Misc.ascending())
+      .join(',');
+  }
+  static _bonuscaseStringToList(bonuscase) {
+    return (bonuscase ?? '').split(',').map(it => {
+      const b = it.split(':');
+      return { case: b[0], bonus: b[1] };
+    });
   }
 
 }

module/item-tache.js

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

module/item.js

@@ -2,29 +2,88 @@ import { DialogItemVente } from "./dialog-item-vente.js";
 import { Grammar } from "./grammar.js";
 import { Misc } from "./misc.js";
 import { RdDHerbes } from "./rdd-herbes.js";
+import { RdDTimestamp } from "./time/rdd-timestamp.js";
 import { RdDUtility } from "./rdd-utility.js";
 import { SystemCompendiums } from "./settings/system-compendiums.js";
+import { RdDRaretes } from "./item/raretes.js";
+import { RdDItemCompetence } from "./item-competence.js";
+import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
 
-const typesObjetsInventaire = [
-  "arme",
-  "armure",
-  "conteneur",
-  "gemme",
-  "herbe",
-  "ingredient",
-  "faune",
-  "livre",
-  "monnaie",
-  "munition",
-  "nourritureboisson",
-  "objet",
-  "potion",
+export const TYPES = {
+  competence: 'competence',
+  competencecreature: 'competencecreature',
+  empoignade: 'empoignade',
+  possession: 'possession',
+  blessure: 'blessure',
+  maladie: 'maladie',
+  poison: 'poison',
+  arme: 'arme',
+  armure: 'armure',
+  conteneur: 'conteneur',
+  objet: 'objet',
+  monnaie: 'monnaie',
+  gemme: 'gemme',
+  munition: 'munition',
+  nourritureboisson: 'nourritureboisson',
+  herbe: 'herbe',
+  plante: 'plante',
+  ingredient: 'ingredient',
+  faune: 'faune',
+  livre: 'livre',
+  potion: 'potion',
+  service: 'service',
+  musique: 'musique',
+  danse: 'danse',
+  chant: 'chant',
+  jeu: 'jeu',
+  recettecuisine: 'recettecuisine',
+  oeuvre: 'oeuvre',
+  recettealchimique: 'recettealchimique',
+  tache: 'tache',
+  sort: 'sort',
+  sortreserve: 'sortreserve',
+  rencontre: 'rencontre',
+  queue: 'queue',
+  ombre: 'ombre',
+  souffle: 'souffle',
+  tete: 'tete',
+  casetmr: 'casetmr',
+  meditation: 'meditation',
+  signedraconique: 'signedraconique',
+  tarot: 'tarot',
+  nombreastral: 'nombreastral',
+  extraitpoetique: 'extraitpoetique',
+}
+
+const typesInventaireMateriel = [
+  TYPES.arme,
+  TYPES.armure,
+  TYPES.conteneur,
+  TYPES.faune,
+  TYPES.gemme,
+  TYPES.herbe,
+  TYPES.plante,
+  TYPES.ingredient,
+  TYPES.livre,
+  TYPES.monnaie,
+  TYPES.munition,
+  TYPES.nourritureboisson,
+  TYPES.objet,
+  TYPES.potion,
 ]
-const typesObjetsOeuvres = ["oeuvre", "recettecuisine", "musique", "chant", "danse", "jeu"]
-const typesObjetsDraconiques = ["queue", "ombre", "souffle", "tete", "signedraconique", "sortreserve", "rencontre"]
-const typesObjetsConnaissance = ["meditation", "recettealchimique", "sort"]
-const typesObjetsEffet = ["possession", "poison", "maladie"]
-const typesObjetsCompetence = ["competence", "competencecreature"]
+const typesInventaire = {
+  materiel: typesInventaireMateriel,
+  all: ['service'].concat(typesInventaireMateriel),
+}
+
+const typesObjetsOeuvres = [TYPES.oeuvre, TYPES.recettecuisine, TYPES.musique, TYPES.chant, TYPES.danse, TYPES.jeu]
+const typesObjetsDraconiques = [TYPES.queue, TYPES.ombre, TYPES.souffle, TYPES.tete, TYPES.signedraconique, TYPES.sortreserve, TYPES.rencontre]
+const typesObjetsConnaissance = [TYPES.meditation, TYPES.recettealchimique, TYPES.sort]
+const typesObjetsEffet = [TYPES.possession, TYPES.poison, TYPES.maladie, TYPES.blessure]
+const typesObjetsCompetence = [TYPES.competence, TYPES.competencecreature]
+const typesObjetsTemporels = [TYPES.blessure, TYPES.poison, TYPES.maladie, TYPES.queue, TYPES.ombre, TYPES.souffle, TYPES.signedraconique, TYPES.rencontre]
+const typesObjetsEquipable = [TYPES.arme, TYPES.armure, TYPES.objet];
+const typesEnvironnement = typesInventaireMateriel;
 const encBrin = 0.00005; // un brin = 1 décigramme = 1/10g = 1/10000kg = 1/20000 enc
 const encPepin = 0.0007; /* un pépin de gemme = 1/10 cm3 = 1/1000 l = 3.5/1000 kg = 7/2000 kg = 7/1000 enc
 densité 3.5 (~2.3 à 4, parfois plus) -- https://www.juwelo.fr/guide-des-pierres/faits-et-chiffres/ 
@@ -58,18 +117,23 @@ export const defaultItemImg = {
   poison: "systems/foundryvtt-reve-de-dragon/icons/maladies_venins/venin.webp",
   oeuvre: "systems/foundryvtt-reve-de-dragon/icons/competence_comedie.webp",
   nourritureboisson: "systems/foundryvtt-reve-de-dragon/icons/objets/provision_crue.webp",
-  service: "systems/foundryvtt-reve-de-dragon/icons/items/services.webp",
+  service: "systems/foundryvtt-reve-de-dragon/icons/services/lit.webp",
   signedraconique: "systems/foundryvtt-reve-de-dragon/icons/tmr/signe_draconique.webp",
   gemme: "systems/foundryvtt-reve-de-dragon/icons/gemmes/almaze.webp",
   possession: "systems/foundryvtt-reve-de-dragon/icons/entites/possession2.webp",
   sortreserve: "systems/foundryvtt-reve-de-dragon/icons/competence_oniros.webp",
   extraitpoetique: "systems/foundryvtt-reve-de-dragon/icons/competence_ecriture.webp",
   tarot: "systems/foundryvtt-reve-de-dragon/icons/tarots/dos-tarot.webp",
+  empoignade: "systems/foundryvtt-reve-de-dragon/icons/competence_corps_a_corps.webp"
 }
 
 /* -------------------------------------------- */
 export class RdDItem extends Item {
 
+  static get defaultIcon() {
+    return undefined;
+  }
+
   static getDefaultImg(itemType) {
     return game.system.rdd.itemClasses[itemType]?.defaultIcon ?? defaultItemImg[itemType];
   }
@@ -77,12 +141,12 @@ export class RdDItem extends Item {
   static isFieldInventaireModifiable(type, field) {
     switch (field) {
       case 'quantite':
-        if (['conteneur'].includes(type)) {
+        if ([TYPES.conteneur].includes(type)) {
           return false;
         }
         break;
       case 'cout':
-        if (['monnaie'].includes(type)) {
+        if ([TYPES.monnaie].includes(type)) {
           return game.user.isGM;
         }
         break;
@@ -97,8 +161,14 @@ export class RdDItem extends Item {
     return game.items.get(itemRef.id ?? itemRef._id);
   }
 
-  static getItemTypesInventaire() {
-    return typesObjetsInventaire
+  static getItemTypesInventaire(mode = 'materiel') {
+    return typesInventaire[mode ?? 'materiel']
+  }
+  static getItemTypesDraconiques() {
+    return typesObjetsDraconiques;
+  }
+  static getItemTypesEnvironnement() {
+    return typesEnvironnement;
   }
 
   static getTypesOeuvres() {
@@ -122,50 +192,86 @@ export class RdDItem extends Item {
     super(docData, context);
   }
 
-  static get defaultIcon() {
-    return undefined;
-  }
-
   getUniteQuantite() {
     switch (this.type) {
-      case "monnaie": return "(Pièces)"
-      case "herbe":
+      case TYPES.monnaie: return "(Pièces)"
+      case TYPES.herbe:
         switch (this.system.categorie) {
           case 'Alchimie': case 'Repos': case 'Soin':
             return "(Brins)"
           case 'Cuisine': return '';
         }
         return '';
-      case "ingredient": return "(Pépins ou Brins)"
+      case TYPES.ingredient: return "(Pépins ou Brins)"
     }
     return '';
   }
 
-  isCompetencePersonnage() { return this.type == 'competence' }
-  isCompetenceCreature() { return this.type == 'competencecreature' }
-  isConteneur() { return this.type == 'conteneur'; }
-  isMonnaie() { return this.type == 'monnaie'; }
-  isNourritureBoisson() { return this.type == 'nourritureboisson'; }
-  isService() { return this.type == 'service'; }
-  isCompetence() {
-    return typesObjetsCompetence.includes(this.type)
-  }
-  isInventaire() {
-    return typesObjetsInventaire.includes(this.type);
-  }
-  isOeuvre() {
-    return typesObjetsOeuvres.includes(this.type)
-  }
-  isDraconique() {
-    return typesObjetsDraconiques.includes(this.type)
-  }
-  isEffet() {
-    return typesObjetsEffet.includes(this.type)
-  }
-  isConnaissance() {
-    return typesObjetsConnaissance.includes(this.type)
+  isEquipable() {
+    return typesObjetsEquipable.includes(this.type)
   }
 
+  isCompetencePersonnage() { return this.type == TYPES.competence }
+  isCompetenceCreature() { return this.type == TYPES.competencecreature }
+  isConteneur() { return this.type == TYPES.conteneur; }
+  isMonnaie() { return this.type == TYPES.monnaie; }
+  isPotion() { return this.type == TYPES.potion; }
+  isNourritureBoisson() { return this.type == TYPES.nourritureboisson; }
+  isService() { return this.type == TYPES.service; }
+
+  isCompetence() { return typesObjetsCompetence.includes(this.type) }
+  isCompetencePossession() { return TYPES.competencecreature == this.type && this.system.categorie == "possession" }
+  isTemporel() { return typesObjetsTemporels.includes(this.type) }
+  isOeuvre() { return typesObjetsOeuvres.includes(this.type) }
+  isDraconique() { return RdDItem.getItemTypesDraconiques().includes(this.type) }
+  isQueueDragon() { return [TYPES.queue, TYPES.ombre].includes(this.type) }
+  isEffet() { return typesObjetsEffet.includes(this.type) }
+  isConnaissance() { return typesObjetsConnaissance.includes(this.type) }
+
+  isInventaire(mode = 'materiel') { return RdDItem.getItemTypesInventaire(mode).includes(this.type); }
+  isBoisson() { return this.isNourritureBoisson() && this.system.boisson; }
+  isAlcool() { return this.isNourritureBoisson() && this.system.boisson && this.system.alcoolise; }
+  isHerbeAPotion() { return this.type == TYPES.herbe && (this.system.categorie == 'Soin' || this.system.categorie == 'Repos'); }
+  isBlessure() { return this.type == TYPES.blessure }
+
+  isPresentDansMilieux(milieux) {
+    return this.getEnvironnements(milieux).length > 0
+  }
+  getCategories() {
+    switch (this.type) {
+      case TYPES.competence: return RdDItemCompetence.getCategories()
+      case TYPES.competencecreature: return RdDItemCompetenceCreature.getCategories()
+    }
+    return {}
+  }
+
+  getEnvironnements(milieux = undefined) {
+    const environnements = this.isInventaire() ? this.system.environnement : undefined;
+    if (milieux == undefined || !environnements) {
+      return environnements ?? [];
+    }
+    return environnements.filter(env => milieux.includes(env.milieu))
+  }
+
+  getMilieux() {
+    return this.getEnvironnements().map(env => env.milieu);
+  }
+
+  getRaretes(milieux = undefined) {
+    if (this.isInventaire()) {
+      const raretes = this.getEnvironnements(milieux).map(env => RdDRaretes.byCode(env.rarete));
+      if (milieux == undefined && raretes.length == 0) {
+        return [RdDRaretes.rareteFrequente()];
+      }
+      return raretes;
+    }
+    return [RdDRaretes.rareteEgale()];
+  }
+
+  getFrequence(milieux = undefined) {
+    const frequences = this.getEnvironnements(milieux).map(it => it.frequence);
+    return frequences.length == 0 ? 0 : Math.max(...frequences);
+  }
 
   getItemGroup() {
     if (this.isInventaire()) return "equipement";
@@ -177,60 +283,113 @@ export class RdDItem extends Item {
     return "autres";
   }
 
-  isConteneurNonVide() {
-    return this.isConteneur() && (this.system.contenu?.length ?? 0) > 0;
+  isConteneurNonVide() { return this.isConteneur() && (this.system.contenu?.length ?? 0) > 0; }
+  isConteneurVide() { return this.isConteneur() && (this.system.contenu?.length ?? 0) == 0; }
+  isVideOuNonConteneur() { return !this.isConteneur() || (this.system.contenu?.length ?? 0) == 0; }
+
+  isFinPeriode(oldTimestamp, newTimestamp) {
+    if (!this.isTemporel()) {
+      return false;
+    }
+    const finPeriode = new RdDTimestamp(this.system.temporel.fin);
+    return oldTimestamp.compare(finPeriode) < 0 && finPeriode.compare(newTimestamp) <= 0
   }
 
-  isConteneurVide() {
-    return this.isConteneur() && (this.system.contenu?.length ?? 0) == 0;
+  async onCreateItemTemporel(actor) {
+    if (this.isTemporel()) {
+      const timestampDebut = game.system.rdd.calendrier.timestamp;
+      const timestampFin = await this.calculerFinPeriodeTemporel(timestampDebut);
+      await actor.updateEmbeddedDocuments('Item', [{
+        _id: this.id,
+        'system.temporel.debut': duplicate(timestampDebut),
+        'system.temporel.fin': duplicate(timestampFin),
+      }])
+    }
   }
 
-  isVideOuNonConteneur() {
-    return !this.isConteneur() || (this.system.contenu?.length ?? 0) == 0;
+  async calculerFinPeriodeTemporel(timestampDebut) {
+    return timestampDebut;
   }
 
-  isComestible() {
+  async onFinPeriodeTemporel(oldTimestamp, newTimestamp) {
+    if (this.isTemporel() && this.actor) {
+      await this.onFinPeriode(oldTimestamp, newTimestamp);
+    }
+  }
+
+  async onFinPeriode(oldTimestamp, newTimestamp) {
+    console.log(`${this.actor.name}: l'objet ${this.name} a expiré et été supprimé`);
+    await this.actor?.deleteEmbeddedDocuments('Item', [this.id]);
+  }
+
+  getUtilisation() {
     switch (this.type) {
-      case 'nourritureboisson': return 'pret';
-      case 'herbe':
-        return this.system.categorie == 'Cuisine' && this.system.sust > 0 ? 'brut' : '';
-      case 'faune':
-        return this.system.sust > 0 ? 'brut' : '';
+      case TYPES.potion:
+        switch (this.system.categorie) {
+          case 'Alchimie': case 'AlchimieEnchante': case 'AlchimieAutre': return 'alchimie'
+          case 'Cuisine': return 'cuisine'
+          case 'Remede': case 'Repos': case 'ReposEnchante': case 'Soin': case 'SoinEnchante': return 'soins'
+        }
+        return '';
+      case TYPES.nourritureboisson: return 'cuisine';
+      case TYPES.herbe: case TYPES.faune: case TYPES.ingredient: case TYPES.plante:
+        switch (this.system.categorie) {
+          case 'Cuisine': return 'cuisine';
+          case 'Toxique': case 'Poison': return 'poison';
+          case 'Alchimie': return 'alchimie'
+          case 'Soin': case 'Repos': return 'soins'
+        }
+        return this.system.sust > 0 ? 'cuisine' : '';
     }
     return '';
   }
 
-  isAlcool() {
-    return this.isNourritureBoisson() && this.system.boisson && this.system.alcoolise;
+  getUtilisationCuisine() {
+    if (this.getUtilisation() == 'cuisine') {
+      switch (this.type) {
+        case TYPES.nourritureboisson:
+          return 'pret';
+        case TYPES.herbe: case TYPES.faune: case TYPES.ingredient: case TYPES.plante:
+          return 'brut';
+      }
+    }
+    return '';
   }
 
-  isHerbeAPotion() {
-    return this.type == 'herbe' && (this.system.categorie == 'Soin' || this.system.categorie == 'Repos');
-  }
-  isPotion() {
-    return this.type == 'potion';
-  }
   isCristalAlchimique() {
-    return this.type == 'objet' && Grammar.toLowerCaseNoAccent(this.name) == 'cristal alchimique' && this.system.quantite > 0;
+    return this.type == TYPES.objet && Grammar.includesLowerCaseNoAccent(this.name, 'cristal alchimique') && this.system.quantite > 0;
   }
 
   isMagique() {
     return this.system.magique
   }
 
+  isItemCommerce() {
+    return this.parent?.type == 'commerce';
+  }
+
+  isNomLike(texte) {
+    return Grammar.includesLowerCaseNoAccent(this.name, texte)
+  }
+  isNomTypeLike(texte) {
+    return this.isNomLike(texte) || Grammar.includesLowerCaseNoAccent(Misc.typeName(this.type, 'Item'), texte)
+  }
+
   getQuantite() {
-    return Math.round(this.system.quantite ?? 0)
+    return this.isService() ? undefined : Math.round(this.system.quantite ?? 0)
   }
 
   getEncTotal() {
-    return this.getEnc() * this.getQuantite();
+    return (this.getQuantite() ?? 0) * this.getEnc();
   }
 
   getEnc() {
     switch (this.type) {
-      case 'herbe':
+      case TYPES.service:
+        return 0;
+      case TYPES.herbe:
         return this.getEncHerbe();
-      case 'gemme':
+      case TYPES.gemme:
         return encPepin * this.system.taille;
     }
     return Math.max(this.system.encombrement ?? 0, 0);
@@ -246,13 +405,21 @@ export class RdDItem extends Item {
   }
 
   valeurTotale() {
-    return this.getQuantite() * this.valeur()
+    return (this.isService() ? 1 : this.getQuantite()) * this.valeur()
   }
 
   valeur() {
     return this.system.cout ?? 0
   }
 
+  calculerPrixCommercant() {
+    if (this.isItemCommerce()) {
+      // appliquer le pourcentage
+      return this.parent.calculerPrix(this);
+    }
+    return this.system.cout;
+  }
+
   prepareDerivedData() {
     super.prepareDerivedData();
     if (this.isInventaire()) {
@@ -262,6 +429,7 @@ export class RdDItem extends Item {
       }
       this.system.actionPrincipale = this.getActionPrincipale({ warnIfNot: false });
     }
+    this.equipable = this.isEquipable();
   }
 
   prepareDataPotion() {
@@ -277,19 +445,19 @@ export class RdDItem extends Item {
 
   getActionPrincipale(options = { warnIfNot: true }) {
     switch (this.type) {
-      case 'conteneur': return 'Ouvrir';
+      case TYPES.conteneur: return 'Ouvrir';
     }
     if (this.actor?.isPersonnage()) {
       const warn = options.warnIfNot;
-      if (this.isComestible() == 'brut') {
+      if (this.getUtilisationCuisine() == 'brut') {
         return 'Utiliser';
       }
       switch (this.type) {
-        case 'nourritureboisson': return this._actionOrWarnQuantiteZero(this.system.boisson ? 'Boire' : 'Manger', warn);
-        case 'potion': return this._actionOrWarnQuantiteZero('Boire', warn);
-        case 'livre': return this._actionOrWarnQuantiteZero('Lire', warn);
-        case 'herbe': return this.isHerbeAPotion() ? this._actionOrWarnQuantiteZero('Décoction', warn) : undefined;
-        case 'queue': case 'ombre': return this.system.refoulement > 0 ? 'Refouler' : undefined;
+        case TYPES.nourritureboisson: return this._actionOrWarnQuantiteZero(this.system.boisson ? 'Boire' : 'Manger', warn);
+        case TYPES.potion: return this._actionOrWarnQuantiteZero('Boire', warn);
+        case TYPES.livre: return this._actionOrWarnQuantiteZero('Lire', warn);
+        case TYPES.herbe: return this.isHerbeAPotion() ? this._actionOrWarnQuantiteZero('Décoction', warn) : undefined;
+        case TYPES.queue: case TYPES.ombre: return this.system.refoulement > 0 ? 'Refouler' : undefined;
       }
     }
     return undefined;
@@ -304,11 +472,11 @@ export class RdDItem extends Item {
       return;
     }
     switch (this.type) {
-      case 'potion': return await actor.consommerPotion(this, onActionItem);
-      case 'livre': return await actor.actionLire(this);
-      case 'conteneur': return await this.sheet.render(true);
-      case 'herbe': return await actor.actionHerbe(this);
-      case 'queue': case 'ombre': return await actor.actionRefoulement(this);
+      case TYPES.potion: return await actor.consommerPotion(this, onActionItem);
+      case TYPES.livre: return await actor.actionLire(this);
+      case TYPES.conteneur: return await this.sheet.render(true);
+      case TYPES.herbe: return await actor.actionHerbe(this, onActionItem);
+      case TYPES.queue: case TYPES.ombre: return await actor.actionRefoulement(this);
     }
   }
 
@@ -330,7 +498,7 @@ export class RdDItem extends Item {
   }
 
   async onCreateDecoupeComestible(actor) {
-    if (actor && this.isComestible() == 'brut' && this.system.sust != 1) {
+    if (actor && this.getUtilisationCuisine() == 'brut' && this.system.sust != 1) {
       if (this.system.sust < 1) {
         await actor.updateEmbeddedDocuments('Item', [{
           _id: this.id,
@@ -351,7 +519,7 @@ export class RdDItem extends Item {
   }
 
   async empiler(item) {
-    if (this.isComestible() == 'brut') {
+    if (this.getUtilisationCuisine() == 'brut') {
       const sust = this.system.sust + item.system.sust;
       const encombrement = this.system.encombrement + item.system.encombrement;
       await this.update({
@@ -365,7 +533,7 @@ export class RdDItem extends Item {
     await item.delete();
   }
 
-  async quantiteIncDec(nombre, options = { diminuerQuantite: true, supprimerSiZero: false }) {
+  async quantiteIncDec(nombre, options = { supprimerSiZero: false }) {
     const quantite = Number(this.system.quantite ?? -1);
     if (quantite >= 0) {
       const reste = Math.max(quantite + Number(nombre), 0);
@@ -402,8 +570,8 @@ export class RdDItem extends Item {
       return [false, `Impossible de regrouper ${this.name} avec ${other.name}`];
     }
     else {
-      const excludedProperties = ['quantite', 'cout', 'encTotal'];
-      if (this.isComestible()) {
+      const excludedProperties = ['quantite', 'cout', 'encTotal', 'environnement', 'contenu'];
+      if (this.getUtilisationCuisine()) {
         excludedProperties.push('sust', 'encombrement');
       }
       let differences = Object.entries(this.system)
@@ -420,7 +588,7 @@ export class RdDItem extends Item {
     return [true, undefined];
   }
 
-  async proposerVente({ service = undefined, quantiteMax = undefined }) {
+  async proposerVente(quantiteMax = undefined) {
     console.log(this);
     if (this.isConteneurNonVide()) {
       ui.notifications.warn(`Votre ${this.name} n'est pas vide, pas possible de le proposer`);
@@ -428,7 +596,6 @@ export class RdDItem extends Item {
     }
     await DialogItemVente.display({
       item: this,
-      service,
       quantiteMax,
       callback: async (vente) => {
         vente["properties"] = this.getProprietes();
@@ -455,20 +622,19 @@ export class RdDItem extends Item {
   }
 
   /* -------------------------------------------- */
-  async postItem(modeOverride) {
+  async postItemToChat(modeOverride) {
     console.log(this);
-    let chatData = duplicate(this);
-    chatData["properties"] = this.getProprietes();
-    if (this.actor) {
-      chatData.actor = { id: this.actor.id };
+    let chatData = {
+      doctype: 'Item',
+      id: this.id,
+      type: this.type,
+      img: this.img,
+      pack: this.pack,
+      name: this.name,
+      actor: this.actor ? { id: this.actor.id } : undefined,
+      system: { description: this.system.description },
+      properties: this.getProprietes(),
     }
-    // JSON object for easy creation
-    chatData.jsondata = JSON.stringify(
-      {
-        compendium: "postedItem",
-        payload: chatData,
-      });
-
     renderTemplate(this.getChatItemTemplate(), chatData).then(html => {
       let chatOptions = RdDUtility.chatDataSetup(html, modeOverride);
       ChatMessage.create(chatOptions)
@@ -476,9 +642,6 @@ export class RdDItem extends Item {
   }
 
   getChatItemTemplate() {
-    switch (this.type) {
-      case 'service': return 'systems/foundryvtt-reve-de-dragon/templates/post-item-service.html';
-    }
     return 'systems/foundryvtt-reve-de-dragon/templates/post-item.html';
   }
 

module/item/armure.js

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

module/item/blessure.js

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

module/item/maladie.js

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

module/item/ombre.js

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

module/item/poison.js

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

module/item/queue.js

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

module/item/raretes.js

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

module/item/rencontre.js

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

module/item/service.js

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

module/item/sheet-base-inventaire.js

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

module/item/sheet-blessure.js

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

module/item/sheet-conteneur.js

@@ -1,8 +1,9 @@
-import { RdDItemSheet } from "./item-sheet.js";
-import { RdDSheetUtility } from "./rdd-sheet-utility.js";
-import { RdDUtility } from "./rdd-utility.js";
+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 RdDItemSheet {
+export class RdDConteneurItemSheet extends RdDItemInventaireSheet {
 
   static get ITEM_TYPE() { return "conteneur" };
 
@@ -27,9 +28,8 @@ export class RdDConteneurItemSheet extends RdDItemSheet {
 
   /* -------------------------------------------- */
   prepareConteneurData(formData) {
-    RdDUtility.filterEquipementParType(formData, this.actor.itemTypes);
-
-    this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.objets);
+    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;
   }
 
@@ -43,7 +43,8 @@ export class RdDConteneurItemSheet extends RdDItemSheet {
     const dragData = {
       actorId: this.actor.id,
       type: "Item",
-      data: item.system
+      data: item.system,
+      uuid: item.uuid
     };
 
     event.dataTransfer.setData("text/plain", JSON.stringify(dragData));
@@ -51,7 +52,8 @@ export class RdDConteneurItemSheet extends RdDItemSheet {
 
   async _onDropItem(event, dragData) {
     if (this.actor) {
-      const dropParams = RdDSheetUtility.prepareItemDropParameters(this.item.id, this.actor, dragData, this.objetVersConteneur);
+      const destItemId = this.html.find(event.target)?.closest('.item').attr('data-item-id') ?? this.item.id
+      const dropParams = await RdDSheetUtility.prepareItemDropParameters(destItemId, this.actor, dragData, this.objetVersConteneur);
       await this.actor.processDropItem(dropParams);
       await this.render(true);
     }

module/item/sheet-faune.js

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

module/item/sheet-herbe.js

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

module/item/sheet-ingredient.js

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

module/item/sheet-plante.js

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

module/item/sheet-rencontre.js

@@ -1,5 +1,5 @@
-import { RdDRencontre } from "./item-rencontre.js";
-import { RdDItemSheet } from "./item-sheet.js";
+import { RdDRencontre } from "./rencontre.js";
+import { RdDItemSheet } from "../item-sheet.js";
 
 export class RdDRencontreItemSheet extends RdDItemSheet {
   

module/item/sheet-service.js

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

module/item/sheet-signedraconique.js

@@ -1,6 +1,6 @@
-import { RdDItemSheet } from "./item-sheet.js";
-import { RdDItemSigneDraconique } from "./item-signedraconique.js";
-import { TMRUtility } from "./tmr-utility.js";
+import { RdDItemSheet } from "../item-sheet.js";
+import { RdDItemSigneDraconique } from "./signedraconique.js";
+import { TMRUtility } from "../tmr-utility.js";
 
 /**
  * Item sheet pour signes draconiques

module/item/signedraconique.js

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

module/item/souffle.js

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

module/migrations.js

@@ -1,6 +1,10 @@
+import { RdDBaseActor } from "./actor/base-actor.js";
 import { LOG_HEAD, SYSTEM_RDD } from "./constants.js";
-import { Environnement } from "./environnement.js";
 import { Grammar } from "./grammar.js";
+import { Monnaie } from "./item-monnaie.js";
+import { RdDItem, TYPES } from "./item.js";
+import { RdDTimestamp } from "./time/rdd-timestamp.js";
+import { RdDRaretes } from "./item/raretes.js";
 
 class Migration {
   get code() { return "sample"; }
@@ -9,7 +13,7 @@ class Migration {
 
   async applyItemsUpdates(computeUpdates) {
     await game.actors.forEach(async (actor) => {
-      const actorItemUpdates = computeUpdates(actor.items);
+      const actorItemUpdates = computeUpdates(actor.items).filter(it => it != undefined);
       if (actorItemUpdates.length > 0) {
         console.log(
           this.code,
@@ -20,7 +24,7 @@ class Migration {
       }
     });
 
-    const itemUpdates = computeUpdates(game.items);
+    const itemUpdates = computeUpdates(game.items).filter(it => it != undefined);
     if (itemUpdates.length > 0) {
       console.log(this.code, "Applying updates on items", itemUpdates);
       await Item.updateDocuments(itemUpdates);
@@ -41,9 +45,9 @@ class _1_5_34_migrationPngWebp {
     }
     function prepareDocumentsImgUpdate(documents) {
       return documents.filter(it => it.img && it.img.match(regexOldPngJpg))
-      .map(it => {
-        return { _id: it.id, img: convertImgToWebp(it.img) }
-      });
+        .map(it => {
+          return { _id: it.id, img: convertImgToWebp(it.img) }
+        });
     }
 
     const itemsUpdates = prepareDocumentsImgUpdate(game.items);
@@ -61,7 +65,6 @@ class _1_5_34_migrationPngWebp {
   }
 }
 
-
 class _10_0_16_MigrationSortsReserve extends Migration {
   get code() { return "creation-item-sort-reserve"; }
   get version() { return "10.0.16"; }
@@ -284,10 +287,11 @@ class _10_3_0_FrequenceEnvironnement extends Migration {
   }
 
   _updatesFrequences(it) {
+    const rarete = RdDRaretes.byCode(it.system.rarete);
     return {
       _id: it.id,
       'system.rarete': undefined,
-      'system.environnement': [{ milieu: it.system.milieu, rarete: it.system.rarete, frequence: Environnement.getFrequenceRarete(it.system.rarete, 'frequence') }]
+      'system.environnement': [{ milieu: it.system.milieu, rarete: rarete.code, frequence: rarete.frequence }]
     }
   }
 }
@@ -325,6 +329,190 @@ class _10_3_17_Monnaies extends Migration {
   }
 }
 
+class _10_4_6_ServicesEnCommerces extends Migration {
+
+  get code() { return "migration-service-acteurs"; }
+  get version() { return "10.4.6"; }
+
+  async migrate() {
+    const servicesToMigrate = game.items.filter(it => it.type == 'service');
+    servicesToMigrate.forEach(async service => {
+      const commerce = await this.convertServiceToCommerce(service);
+      await RdDBaseActor.create(commerce, { renderSheet: false });
+      await service.delete();
+    });
+  }
+
+  async convertServiceToCommerce(service) {
+    return {
+      name: service.name, img: service.img, type: 'commerce',
+      system: {
+        description: service.system.description,
+        notesmj: service.system.descriptionmj,
+        illimite: service.system.illimite
+      },
+      items: await this.transformInventaireCommerce(service)
+    }
+  }
+  async transformInventaireCommerce(service) {
+    const serviceItems = (service.system.items ?? []);
+    const commerceItems = await Promise.all(serviceItems.map(async (it) => { return await this.transformToItemBoutique(it); }));
+    return commerceItems.concat(Monnaie.monnaiesStandard());
+  }
+
+  async transformToItemBoutique(serviceRefItem) {
+    const item = await RdDItem.getCorrespondingItem(serviceRefItem);
+    const itemToCreate = {
+      name: item.name, img: item.img, type: item.type,
+      system: mergeObject({ cout: serviceRefItem.system.cout, quantite: serviceRefItem.system.quantite }, item.system, { overwrite: false })
+    };
+    return itemToCreate;
+  }
+}
+
+class _10_5_0_UpdatePeriodicite extends Migration {
+  get code() { return "migration-periodicite-poisons-maladies"; }
+  get version() { return "10.5.0"; }
+
+  async migrate() {
+    await this.applyItemsUpdates(items => this._updatePeriodicite(items));
+  }
+
+  _updatePeriodicite(items) {
+    return items.filter(it => ['poison', 'maladie'].includes(it.type))
+      .filter(it => it.system.periodicite != "")
+      .map(it => {
+        let [incubation, periodicite] = this.getPeriodicite(it);
+        const periode = periodicite.split(' ');
+        let unite = periode.length == 2
+          ? RdDTimestamp.formulesPeriode().find(it => Grammar.includesLowerCaseNoAccent(periode[1], it.code))?.code
+          : undefined
+        if (unite && Number(periode[0])) {
+          return {
+            _id: it.id,
+            'system.periodicite': undefined,
+            'system.incubation': incubation,
+            'system.periode.nombre': Number.parseInt(periode[0]),
+            'system.periode.unite': unite
+          };
+        }
+        else {
+          return {
+            _id: it.id,
+            'system.periodicite': undefined,
+            'system.incubation': it.system.periodicite
+          };
+        }
+      }).filter(it => it != undefined);
+  }
+
+  getPeriodicite(it) {
+    let p = it.system.periodicite.split(/[\/\\]/);
+    switch (p.length) {
+      case 2: return [p[0].trim(), p[1].trim()];
+      case 1: return ["", it.system.periodicite.trim()];
+      default: return [it.system.periodicite.trim(), ""];
+    }
+  }
+}
+
+class _10_7_0_MigrationBlessures extends Migration {
+  get code() { return "migration-blessures"; }
+  get version() { return "10.7.0"; }
+
+  async migrate() {
+    const timestamp = game.system.rdd.calendrier.getTimestamp()
+    await Promise.all(game.actors.filter(it => it.isPersonnage() || it.isCreature())
+      .map(async (actor) => {
+        const legeres = actor.system.blessures?.legeres.liste.filter(it => it.active).map(it => this.creerBlessure(2, 'légère', it, timestamp)) ?? [];
+        const graves = actor.system.blessures?.graves.liste.filter(it => it.active).map(it => this.creerBlessure(4, 'grave', it, timestamp)) ?? [];
+        const critiques = actor.system.blessures?.critiques.liste.filter(it => it.active).map(it => this.creerBlessure(6, 'critique', it, timestamp));
+        const blessures = legeres.concat(graves).concat(critiques);
+        if (blessures.length > 0) {
+          await actor.createEmbeddedDocuments("Item", blessures);
+        }
+        await actor.update({
+          'system.blessures.legeres.liste': [],
+          'system.blessures.graves.liste': [],
+          'system.blessures.critiques.liste': []
+        })
+      }));
+  }
+  creerBlessure(gravite, graviteTexte, blessure, timestamp) {
+    const dateBlessure = timestamp.addJours(-blessure.jours);
+    const datePremiereRecup = dateBlessure.addJours(gravite);
+    return {
+      name: `Blessure ${graviteTexte}`,
+      type: 'blessure',
+      img: `systems/foundryvtt-reve-de-dragon/icons/sante/blessure${blessure.psdone ? '-soins' : ''}.webp`,
+      system: {
+        gravite: gravite,
+        difficulte: -gravite,
+        debut: { indexDate: dateBlessure.indexDate, indexMinute: 0 },
+        fin: { indexDate: datePremiereRecup.indexDate, indexMinute: 0 },
+        premierssoins: { done: blessure.psdone, bonus: blessure.premiers_soins },
+        soinscomplets: { done: blessure.scdone, bonus: blessure.soins_complets },
+        localisation: blessure.localisation
+      }
+    }
+  }
+}
+
+class _10_7_19_CategorieCompetenceCreature extends Migration {
+  get code() { return "categorie-competence-creature"; }
+  get version() { return "10.7.19"; }
+
+  async migrate() {
+    await this.applyItemsUpdates(items => items
+      .filter(it => TYPES.competencecreature == it.type)
+      .map(it => this.migrateCompetenceCreature(it))
+    );
+  }
+
+  migrateCompetenceCreature(it) {
+    const categorie = this.getCategorie(it)
+    if (categorie == it.system.categorie) {
+      return undefined
+    }
+    return { _id: it.id, 'system.categorie': categorie }
+  }
+
+  getCategorie(it) {
+    if (it.system.ispossession) {
+      return 'possession'
+    }
+    switch (it.system.categorie) {
+      case "melee":
+        if (it.system.isnaturelle) {
+          return 'naturelle'
+        }
+        return 'melee'
+      case "particuliere": case "specialisee": case "connaissance":
+        return "generale"
+      default:
+        return it.system.categorie
+    }
+  }
+}
+
+class _10_7_19_PossessionsEntiteVictime extends Migration {
+  get code() { return "possessions-entite-victime"; }
+  get version() { return "10.7.19"; }
+
+  async migrate() {
+    await this.applyItemsUpdates(items => items
+      .filter(it => TYPES.possession == it.type)
+      .map(it => this.migratePossession(it))
+    );
+  }
+
+  migratePossession(it) {
+    return { _id: it.id,
+      'system.entite.actorid': it.system.possesseurid,
+      'system.victime.actorid': it.system.possedeid
+    }
+  }
+}
 
 export class Migrations {
   static getMigrations() {
@@ -338,7 +526,12 @@ export class Migrations {
       new _10_2_10_DesirLancinant_IdeeFixe(),
       new _10_3_0_Inventaire(),
       new _10_3_0_FrequenceEnvironnement(),
-      new _10_3_17_Monnaies()
+      new _10_3_17_Monnaies(),
+      new _10_4_6_ServicesEnCommerces(),
+      new _10_5_0_UpdatePeriodicite(),
+      new _10_7_0_MigrationBlessures(),
+      new _10_7_19_CategorieCompetenceCreature(),
+      new _10_7_19_PossessionsEntiteVictime(),
     ];
   }
 
@@ -355,16 +548,10 @@ export class Migrations {
   migrate() {
     const currentVersion = game.settings.get(SYSTEM_RDD, "systemMigrationVersion");
     if (isNewerVersion(game.system.version, currentVersion)) {
-      //if (true) { /* comment previous and uncomment here to test before upgrade  */
+      // if (true) { /* comment previous and uncomment here to test before upgrade  */
       const migrations = Migrations.getMigrations().filter(m => isNewerVersion(m.version, currentVersion));
       if (migrations.length > 0) {
-        migrations.sort((a, b) =>
-          isNewerVersion(a.version, b.version)
-            ? 1
-            : isNewerVersion(b.version, a.version)
-              ? -1
-              : 0
-        );
+        migrations.sort((a, b) => this.compareVersions(a, b));
         migrations.forEach(async (m) => {
           ui.notifications.info(
             `Executing migration ${m.code}: version ${currentVersion} is lower than ${m.version}`
@@ -390,4 +577,8 @@ export class Migrations {
       console.log(LOG_HEAD + `No system version changed`);
     }
   }
+
+  compareVersions(a, b) {
+    return isNewerVersion(a.version, b.version) ? 1 : isNewerVersion(b.version, a.version) ? -1 : 0;
+  }
 }

module/misc.js

@@ -46,6 +46,9 @@ export class Misc {
       : '';
   }
 
+  static arrayOrEmpty(items) {
+    return items?.length ? items : [];
+  }
   /**
    * Converts the value to an integer, or to 0 if undefined/null/not representing integer
    * @param {*} value value to convert to an integer using parseInt
@@ -82,6 +85,7 @@ export class Misc {
     list.forEach(it => addToObj(obj, it))
     return obj;
   }
+
   static concat(lists) {
     return lists.reduce((a, b) => a.concat(b), []);
   }
@@ -115,6 +119,17 @@ export class Misc {
     }
   }
 
+  /**
+   * @returns an array of incremental integers (including from / excluding to).
+   *  if max<min, the array is decrementing integers 
+   */
+  static intArray(from, to) {
+    if (from > to) {
+      return Array.from(Array(from - to).keys()).map(i => from - i)
+    }
+    return Array.from(Array(to - from).keys()).map(i => from + i)
+  }
+
   static distinct(array) {
     return [...new Set(array)];
   }
@@ -135,11 +150,11 @@ export class Misc {
   }
 
   static isRollModeHiddenToPlayer() {
-      switch (game.settings.get("core", "rollMode")) {
-        case CONST.DICE_ROLL_MODES.BLIND:
-        case CONST.DICE_ROLL_MODES.SELF: return true;
-      }
-      return false
+    switch (game.settings.get("core", "rollMode")) {
+      case CONST.DICE_ROLL_MODES.BLIND:
+      case CONST.DICE_ROLL_MODES.SELF: return true;
+    }
+    return false
   }
 
   static getActiveUser(id) {
@@ -150,11 +165,11 @@ export class Misc {
     return game.users.filter(u => u.isGM && u.active).sort(Misc.ascending(u => u.id)).find(u => u.isGM && u.active);
   }
 
-  static isOwnerPlayer(actor, user=undefined) {
+  static isOwnerPlayer(actor, user = undefined) {
     return actor.testUserPermission(user ?? game.user, CONST.DOCUMENT_PERMISSION_LEVELS.OWNER)
   }
 
-  static  isOwnerPlayerOrUniqueConnectedGM(actor, user =undefined){
+  static isOwnerPlayerOrUniqueConnectedGM(actor, user = undefined) {
     return Misc.isOwnerPlayer(actor, user) ?? Misc.isUniqueConnectedGM();
   }
 
@@ -224,4 +239,15 @@ export class Misc {
     }
     return subset;
   }
+
+  static cssRotation(angle) {
+    const rotation = `rotate(${angle}deg)`;
+    return {
+      'transform': rotation,
+      '-ms-transform': rotation,
+      '-moz-transform': rotation,
+      '-webkit-transform': rotation,
+      '-o-transform': rotation
+    };
+  }
 }

module/rdd-alchimie.js

@@ -8,13 +8,11 @@ export class RdDAlchimie {
 
   /* -------------------------------------------- */
   static processManipulation(recette, actorId = undefined) {
-    //console.log("CALLED", recette, recette.isOwned, actorId );
     let manip = recette.system.manipulation;
     let matchArray = manip.match(matchOperations);
     if (matchArray) {
       for (let matchStr of matchArray) {
         let result = matchStr.match(matchOperationTerms);
-        //console.log("RESULT ", result);
         if (result[1] && result[2]) {
           let commande = Misc.upperFirst(result[1]);
           let replacement = this[`_alchimie${commande}`](recette, result[2], actorId);
@@ -27,20 +25,19 @@ export class RdDAlchimie {
 
   /* -------------------------------------------- */
   static _alchimieCouleur(recette, couleurs, actorId) {
-    if (actorId) {
-      return `<span class="alchimie-tache"><a data-recette-id="${recette._id}" data-actor-id="${actorId}" data-alchimie-tache="couleur" data-alchimie-data="${couleurs}">couleur ${couleurs}</a></span>`;
-    } else {
-      return `<span class="alchimie-tache">couleur ${couleurs} </span>`;
-    }
+    return RdDAlchimie._alchimieLink(recette, couleurs, actorId,  'couleur',  'Température');
   }
 
   /* -------------------------------------------- */
   static _alchimieConsistance(recette, consistances, actorId) {
-    if (actorId) {
-      return `<span class="alchimie-tache"><a data-recette-id="${recette._id}" data-actor-id="${actorId}" data-alchimie-tache="consistance" data-alchimie-data="${consistances}">consistance ${consistances}</a></span>`;
-    } else {
-      return `<span class="alchimie-tache">consistance ${consistances} </span>`;
-    }
+    return RdDAlchimie._alchimieLink(recette, consistances, actorId,  'consistance',  'Consistance');
+  }
+
+  static _alchimieLink(recette, termes, actorId, tacheAlchimie, labelTache) {
+    const difficulte = RdDAlchimie.getDifficulte(termes);
+    const link = actorId ? ` <a data-recette-id="${recette._id}" data-actor-id="${actorId}" data-alchimie-tache="${tacheAlchimie}" data-alchimie-data="${termes}">` : '';
+    const endLink = actorId ? '</a>' : '';
+    return `<span class="alchimie-tache">${link}${labelTache} ${termes} (${difficulte})${endLink}</span>`;
   }
 
   /* -------------------------------------------- */

module/rdd-astrologie-editeur.js

@@ -1,48 +0,0 @@
-
-/**
- * Extend the base Dialog entity by defining a custom window to perform roll.
- * @extends {Dialog}
- */
- export class RdDAstrologieEditeur extends Dialog {
-
-  /* -------------------------------------------- */
-  constructor(html, calendrier, calendrierData) {
-
-    let myButtons = {
-        resetButton: { label: "Re-tirer les nombres astraux", callback: html => this.resetNombreAstraux() },
-        saveButton: { label: "Fermer", callback: html => this.fillData() }
-      };
-
-    // Common conf
-    let dialogConf = { content: html, title: "Editeur d'Astrologie", buttons: myButtons, default: "saveButton" };
-    let dialogOptions = { classes: ["rdd-roll-dialog"], width: 600, height: 300, 'z-index': 99999 }  
-    super(dialogConf, dialogOptions)
-    
-    this.calendrier = calendrier;
-    this.updateData( calendrierData );
-  }
-
-  activateListeners(html) {
-    super.activateListeners(html);
-    this.html = html;
-  }
-
-
-  /* -------------------------------------------- */  
-  async resetNombreAstraux() {
-    game.system.rdd.calendrier.resetNombreAstral();
-    await game.system.rdd.calendrier.rebuildListeNombreAstral();
-
-    game.system.rdd.calendrier.showAstrologieEditor();
-  }
-
-  /* -------------------------------------------- */  
-  fillData( ) {
-  }
-
-  /* -------------------------------------------- */
-  updateData( calendrierData ) {
-    this.calendrierData = duplicate(calendrierData);
-  }
-
-}

module/rdd-astrologie-joueur.js

@@ -1,104 +0,0 @@
-import { RdDItemCompetence } from "./item-competence.js";
-import { Misc } from "./misc.js";
-import { SYSTEM_SOCKET_ID } from "./constants.js";
-
-
-/**
- * Extend the base Dialog entity by defining a custom window to perform roll.
- * @extends {Dialog}
- */
-export class RdDAstrologieJoueur extends Dialog {
-
-  /* -------------------------------------------- */
-  static async create(actor, dialogConfig) {
-
-    let dialogData = {
-      nombres: this.organizeNombres(actor),
-      dates: game.system.rdd.calendrier.getJoursSuivants(10),
-      etat: actor.getEtatGeneral(),
-      ajustementsConditions: CONFIG.RDD.ajustementsConditions,
-      astrologie: RdDItemCompetence.findCompetence(actor.items, 'Astrologie')
-    }
-    const html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/dialog-astrologie-joueur.html', dialogData);
-    let options = { classes: ["rdd-roll-dialog"], width: 600, height: 500, 'z-index': 99999 };
-    if (dialogConfig.options) {
-      mergeObject(options, dialogConfig.options, { overwrite: true });
-    }
-    return new RdDAstrologieJoueur(html, actor, dialogData);
-  }
-
-  /* -------------------------------------------- */
-  constructor(html, actor, dialogData) {
-    const dialogConf = {
-      title: "Nombres Astraux",
-      content: html,
-      default: "saveButton",
-      buttons: {
-        saveButton: { label: "Fermer", callback: html => this.quitDialog() }
-      },
-    };
-    const dialogOptions = { classes: ["rdd-roll-dialog"], width: 600, height: 300, 'z-index': 99999 };
-    super(dialogConf, dialogOptions);
-
-    this.actor = actor;
-    this.dataNombreAstral = duplicate(dialogData);
-  }
-
-  /* -------------------------------------------- */
-  activateListeners(html) {
-    super.activateListeners(html);
-    this.html = html;
-
-    this.html.find(function () {
-      this.html.find("[name='diffConditions']").val(0);
-    });
-
-    this.html.find('[name="jet-astrologie"]').click((event) => {
-      this.requestJetAstrologie();
-    });
-  }
-
-  /* -------------------------------------------- */
-  static organizeNombres(actor) {
-    let itemNombres = actor.listItemsData('nombreastral');
-    let itemFiltered = {};
-    for (let item of itemNombres) {
-      if (itemFiltered[item.system.jourindex]) {
-        itemFiltered[item.system.jourindex].listValues.push(item.system.value);
-      } else {
-        itemFiltered[item.system.jourindex] = {
-          listValues: [item.system.value],
-          jourlabel: item.system.jourlabel
-        }
-      }
-    }
-    return itemFiltered;
-  }
-
-  /* -------------------------------------------- */
-  requestJetAstrologie() {
-    let socketData = {
-      id: this.actor.id,
-      carac_vue: this.actor.system.carac['vue'].value,
-      etat: this.dataNombreAstral.etat,
-      astrologie: this.dataNombreAstral.astrologie,
-      conditions: this.html.find('[name="diffConditions"]').val(),
-      date: this.html.find('[name="joursAstrologie"]').val(),
-      userId: game.user.id
-    }
-    if (Misc.isUniqueConnectedGM()) {
-      game.system.rdd.calendrier.requestNombreAstral(socketData);
-    } else {
-      game.socket.emit(SYSTEM_SOCKET_ID, {
-        msg: "msg_request_nombre_astral",
-        data: socketData
-      });
-    }
-    this.close();
-  }
-
-  /* -------------------------------------------- */
-  quitDialog() {
-  }
-
-}

module/rdd-bonus.js

@@ -1,4 +1,5 @@
 import { RdDCarac } from "./rdd-carac.js";
+import { RdDPossession } from "./rdd-possession.js";
 
 const conditionsTactiques = [
   { type: '', descr: '', dmg: 0, attaque: 0, parade: 0, esquive: true },
@@ -24,11 +25,17 @@ export class RdDBonus {
   }
   /* -------------------------------------------- */
   static isDefenseAttaqueFinesse(rollData) {
+    if (rollData.isEmpoignade && rollData.rolled?.isPart) {
+      return true
+    }
+    if (RdDPossession.isDefensePossession(rollData)) {
+      return RdDPossession.isPossessionFinesse(rollData)
+    }
     return rollData.attackerRoll?.particuliere == 'finesse';
   }
 
   /* -------------------------------------------- */
-  static dmg(rollData, dmgActor, isCauchemar = false) {
+  static dmg(rollData, dmgActor, isEntiteIncarnee = false) {
     let dmg = { total: 0 };
     if (rollData.arme && rollData.arme.name.toLowerCase() == "esquive") {
       // Specific case management
@@ -41,7 +48,7 @@ export class RdDBonus {
       dmg.dmgSurprise = RdDBonus.dmgBonus(rollData.ajustements?.attaqueDefenseurSurpris.used);
       dmg.dmgActor = rollData.selectedCarac ? RdDBonus._dmgPerso(dmgActor, rollData.selectedCarac.label, dmg.dmgArme) : 0;
       dmg.total = dmg.dmgSurprise + dmg.dmgTactique + dmg.dmgArme + dmg.dmgActor + dmg.dmgParticuliere;
-      dmg.mortalite = RdDBonus._calculMortalite(rollData, isCauchemar)
+      dmg.mortalite = RdDBonus._calculMortalite(rollData, isEntiteIncarnee)
     }
     return dmg;
   }
@@ -62,11 +69,8 @@ export class RdDBonus {
   }
 
   /* -------------------------------------------- */
-  static _calculMortalite(rollData, isCauchemar) {
-    if (isCauchemar) {
-      return "cauchemar";
-    }
-    return isCauchemar ? "cauchemar"
+  static _calculMortalite(rollData, isEntiteIncarnee) {
+    return isEntiteIncarnee ? "entiteincarnee"
       : rollData.dmg?.mortalite
       ?? rollData.arme?.system.mortalite
       ?? "mortel";
@@ -74,7 +78,7 @@ export class RdDBonus {
 
   /* -------------------------------------------- */
   static _dmgArme(rollData) {
-    if ( rollData.arme) {
+    if (rollData.arme) {
       let dmgBase = rollData.arme.system.dommagesReels ?? Number(rollData.arme.system.dommages ?? 0);
       //Le bonus dégats magiques ne peut pas faire dépasser le bonus de l'arme (cf p.278)
       return dmgBase + Math.min(dmgBase, rollData.arme.system.magique ? rollData.arme.system.ecaille_efficacite : 0);

module/rdd-calendrier-editeur.js

@@ -1,52 +0,0 @@
-import { Misc } from "./misc.js";
-
-/**
- * Extend the base Dialog entity by defining a custom window to perform roll.
- * @extends {Dialog}
- */
-export class RdDCalendrierEditeur extends Dialog {
-
-  /* -------------------------------------------- */
-  constructor(html, calendrier, calendrierData) {
-    let dialogConf = {
-      content: html,
-      title: "Editeur de date/heure",
-      buttons: {
-        save: { label: "Enregistrer", callback: html => this.fillData() }
-      },
-      default: "save"
-    };
-    let dialogOptions = { classes: ["rdd-dialog-calendar-editor"], width: 400, height: 'fit-content', 'z-index': 99999 }
-    super(dialogConf, dialogOptions)
-
-    this.calendrier = calendrier;
-    this.calendrierData = calendrierData;
-  }
-
-  activateListeners(html) {
-    super.activateListeners(html);
-    this.html = html;
-    this.html.find("input[name='nomMois']").val(this.calendrierData.moisKey);
-    this.html.find("select[name='nomHeure']").val(this.calendrierData.heureKey);
-    this.html.find("select[name='jourMois']").val(this.calendrierData.jourMois);
-    this.html.find("select[name='minutesRelative']").val(this.calendrierData.minutesRelative);
-    this.html.find("select[name='annee']").val(this.calendrierData.annee);
-  }
-
-  /* -------------------------------------------- */
-  fillData() {
-    this.calendrierData.annee = this.html.find("input[name='annee']").val();
-    this.calendrierData.moisKey = this.html.find("select[name='nomMois']").val();
-    this.calendrierData.heureKey = this.html.find("select[name='nomHeure']").val();
-    this.calendrierData.jourMois = this.html.find("select[name='jourMois']").val();
-    this.calendrierData.minutesRelative = this.html.find("select[name='minutesRelative']").val();
-
-    this.calendrier.saveEditeur(this.calendrierData)
-  }
-
-  /* -------------------------------------------- */
-  updateData(calendrierData) {
-    this.calendrierData = duplicate(calendrierData);
-  }
-
-}

module/rdd-calendrier.js

@@ -1,649 +0,0 @@
-/* -------------------------------------------- */
-import { RdDCalendrierEditeur } from "./rdd-calendrier-editeur.js";
-import { RdDAstrologieEditeur } from "./rdd-astrologie-editeur.js";
-import { HtmlUtility } from "./html-utility.js";
-import { RdDResolutionTable } from "./rdd-resolution-table.js";
-import { RdDUtility } from "./rdd-utility.js";
-import { Grammar } from "./grammar.js";
-import { RdDDice } from "./rdd-dice.js";
-import { Misc } from "./misc.js";
-import { HIDE_DICE, SHOW_DICE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
-import { DialogChronologie } from "./dialog-chronologie.js";
-
-/* -------------------------------------------- */
-const dossierIconesHeures = 'systems/foundryvtt-reve-de-dragon/icons/heures/'
-const heuresList = ["vaisseau", "sirene", "faucon", "couronne", "dragon", "epees", "lyre", "serpent", "poissonacrobate", "araignee", "roseau", "chateaudormant"];
-const heuresDef = {
-  "vaisseau": {key: "vaisseau", label: "Vaisseau", lettreFont: 'v', saison: "printemps", heure: 0, icon: 'hd01.svg' },
-  "sirene": { key: "sirene", label: "Sirène", lettreFont: 'i', saison: "printemps", heure: 1, icon: 'hd02.svg' },
-  "faucon": { key: "faucon", label: "Faucon", lettreFont: 'f', saison: "printemps", heure: 2, icon: 'hd03.svg' },
-  "couronne": { key: "couronne", label: "Couronne", lettreFont: '', saison: "ete", heure: 3, icon: 'hd04.svg' },
-  "dragon": { key: "dragon", label: "Dragon", lettreFont: 'd', saison: "ete", heure: 4, icon: 'hd05.svg' },
-  "epees": { key: "epees", label: "Epées", lettreFont: 'e', saison: "ete", heure: 5, icon: 'hd06.svg' },
-  "lyre": { key: "lyre", label: "Lyre", lettreFont: 'l', saison: "automne", heure: 6, icon: 'hd07.svg' },
-  "serpent": { key: "serpent", label: "Serpent", lettreFont: 's', saison: "automne", heure: 7, icon: 'hd08.svg' },
-  "poissonacrobate": { key: "poissonacrobate", label: "Poisson Acrobate", lettreFont: 'p', saison: "automne", heure: 8, icon: 'hd09.svg' },
-  "araignee": { key: "araignee", label: "Araignée", lettreFont: 'a', saison: "hiver", heure: 9, icon: 'hd10.svg' },
-  "roseau": { key: "roseau", label: "Roseau", lettreFont: 'r', saison: "hiver", heure: 10, icon: 'hd11.svg' },
-  "chateaudormant": { key: "chateaudormant", label: "Château Dormant", lettreFont: 'c', saison: "hiver", heure: 11, icon: 'hd12.svg' }
-};
-const saisonsDef = {
-  "printemps": { label: "Printemps" },
-  "ete": { label: "Eté" },
-  "automne": { label: "Automne" },
-  "hiver": { label: "Hiver" }
-};
-
-const RDD_MOIS_PAR_AN = 12;
-export const RDD_JOUR_PAR_MOIS = 28;
-const RDD_HEURES_PAR_JOUR = 12;
-const RDD_MINUTES_PAR_HEURES = 120;
-const MAX_NOMBRE_ASTRAL = 12;
-
-/* -------------------------------------------- */
-export class RdDCalendrier extends Application {
-
-  static get defaultOptions() {
-    return mergeObject(super.defaultOptions, {
-      template: "systems/foundryvtt-reve-de-dragon/templates/calendar-template.html",
-      popOut: false,
-      resizable: false
-    });
-  }
-
-  static createCalendrierPos() {
-    return { top: 200, left: 200 };
-  }
-
-  static getDefSigne(chiffre) {
-    chiffre = chiffre % RDD_MOIS_PAR_AN;
-    return Object.values(heuresDef).find(h => h.heure == chiffre);
-  }
-
-  static getSigneAs(key, value) {
-    const heure = (typeof value == 'string' || typeof value == 'number') && Number.isInteger(Number(value))
-      ? Number(value)
-      : (typeof value == 'string') ? RdDCalendrier.getChiffreFromSigne(value)
-      : undefined
-
-    if (heure != undefined && ['key', 'label', 'lettreFont', 'saison', 'heure', 'icon'].includes(key)) {
-      return RdDCalendrier.getDefSigne(heure)[key]
-    }
-    if (heure != undefined && ['webp'].includes(key)) {
-      return RdDCalendrier.getDefSigne(heure)['icon'].replace('svg', 'webp');
-    }
-    console.error(`Appel à getSigneAs('${key}', ${value}) avec une clé/heure incorrects`);
-    return value;
-
-  }
-  static getChiffreFromSigne(signe) {
-    return heuresList.indexOf(signe);
-  }
-
-  static createCalendrierInitial() {
-    return {
-      heureRdD: 0,
-      minutesRelative: 0,
-      indexJour: 0,
-      annee: 0,
-      moisRdD: 0,
-      moisLabel: heuresDef["vaisseau"].label,
-      jour: 0
-    }
-  }
-
-  getCalendrier(index) {
-    index = index ?? this.getCurrentDayIndex();
-    const mois = Math.floor(index / RDD_JOUR_PAR_MOIS) % RDD_MOIS_PAR_AN;
-    return {
-      heureRdD: 0, // Index dans heuresList / heuresDef[x].heure
-      minutesRelative: 0,
-      indexJour: index,
-      annee: Math.floor(index / (RDD_JOUR_PAR_MOIS * RDD_MOIS_PAR_AN)),
-      moisRdD: RdDCalendrier.getDefSigne(mois).heure,
-      moisLabel: RdDCalendrier.getDefSigne(mois).label,
-      jour: (index % RDD_JOUR_PAR_MOIS) // Le calendrier stocke le jour en 0-27, mais en 1-28 à l'affichage
-    }
-  }
-
-  constructor() {
-    super();
-    // position
-    this.calendrierPos = duplicate(game.settings.get(SYSTEM_RDD, "calendrier-pos"));
-    if (this.calendrierPos == undefined || this.calendrierPos.top == undefined) {
-      this.calendrierPos = RdDCalendrier.createCalendrierPos();
-      game.settings.set(SYSTEM_RDD, "calendrier-pos", this.calendrierPos);
-    }
-
-    // Calendrier
-    this.calendrier = duplicate(game.settings.get(SYSTEM_RDD, "calendrier") ?? RdDCalendrier.createCalendrierInitial());
-    this.calendrier.annee = this.calendrier.annee ?? Math.floor((this.calendrier.moisRdD ?? 0) / RDD_MOIS_PAR_AN);
-    this.calendrier.moisRdD = (this.calendrier.moisRdD ?? 0) % RDD_MOIS_PAR_AN;
-
-    if (Misc.isUniqueConnectedGM()) { // Uniquement si GM
-      game.settings.set(SYSTEM_RDD, "calendrier", this.calendrier);
-
-      this.listeNombreAstral = this.getListeNombreAstral();
-      this.rebuildListeNombreAstral(HIDE_DICE); // Ensure always up-to-date
-    }
-    console.log('RdDCalendrier.constructor()', this.calendrier, this.calendrierPos, this.listeNombreAstral);
-  }
-
-  /* -------------------------------------------- */
-  /** @override */
-  async activateListeners(html) {
-    super.activateListeners(html);
-    this.html = html;
-
-    this.updateDisplay();
-
-    this.html.find('.ajout-chronologie').click(ev => DialogChronologie.create());
-
-    this.html.find('.calendar-btn').click(ev => this.onCalendarButton(ev));
-
-    this.html.find('.calendar-btn-edit').click(ev => {
-      ev.preventDefault();
-      this.showCalendarEditor();
-    });
-
-    this.html.find('.astrologie-btn-edit').click(ev => {
-      ev.preventDefault();
-      this.showAstrologieEditor();
-    });
-
-    this.html.find('#calendar-move-handle').mousedown(ev => {
-      ev.preventDefault();
-      ev = ev || window.event;
-      let isRightMB = false;
-      if ("which" in ev) { // Gecko (Firefox), WebKit (Safari/Chrome) & Opera
-        isRightMB = ev.which == 3;
-      } else if ("button" in ev) { // IE, Opera 
-        isRightMB = ev.button == 2;
-      }
-
-      if (!isRightMB) {
-        dragElement(document.getElementById("calendar-time-container"));
-        let pos1 = 0, pos2 = 0, pos3 = 0, pos4 = 0;
-
-        function dragElement(elmnt) {
-          elmnt.onmousedown = dragMouseDown;
-          function dragMouseDown(e) {
-            e = e || window.event;
-            e.preventDefault();
-            pos3 = e.clientX;
-            pos4 = e.clientY;
-
-            document.onmouseup = closeDragElement;
-            document.onmousemove = elementDrag;
-          }
-
-          function elementDrag(e) {
-            e = e || window.event;
-            e.preventDefault();
-            // calculate the new cursor position:
-            pos1 = pos3 - e.clientX;
-            pos2 = pos4 - e.clientY;
-            pos3 = e.clientX;
-            pos4 = e.clientY;
-            // set the element's new position:
-            elmnt.style.bottom = undefined
-            elmnt.style.top = (elmnt.offsetTop - pos2) + "px";
-            elmnt.style.left = (elmnt.offsetLeft - pos1) + "px";
-          }
-
-          function closeDragElement() {
-            // stop moving when mouse button is released:
-            elmnt.onmousedown = undefined;
-            document.onmouseup = undefined;
-            document.onmousemove = undefined;
-            let xPos = (elmnt.offsetLeft - pos1) > window.innerWidth ? window.innerWidth - 200 : (elmnt.offsetLeft - pos1);
-            let yPos = (elmnt.offsetTop - pos2) > window.innerHeight - 20 ? window.innerHeight - 100 : (elmnt.offsetTop - pos2)
-            xPos = xPos < 0 ? 0 : xPos;
-            yPos = yPos < 0 ? 0 : yPos;
-            if (xPos != (elmnt.offsetLeft - pos1) || yPos != (elmnt.offsetTop - pos2)) {
-              elmnt.style.top = (yPos) + "px";
-              elmnt.style.left = (xPos) + "px";
-            }
-            game.system.rdd.calendrier.calendrierPos.top = yPos;
-            game.system.rdd.calendrier.calendrierPos.left = xPos;
-            if (game.user.isGM) {
-              game.settings.set(SYSTEM_RDD, "calendrier-pos", duplicate(game.system.rdd.calendrier.calendrierPos));
-            }
-          }
-        }
-      } else if (isRightMB) {
-        game.system.rdd.calendrier.calendrierPos.top = 200;
-        game.system.rdd.calendrier.calendrierPos.left = 200;
-        if (game.user.isGM) {
-          game.settings.set(SYSTEM_RDD, "calendrier-pos", duplicate(game.system.rdd.calendrier.calendrierPos));
-        }
-        this.setPos(game.system.rdd.calendrier.calendrierPos);
-      }
-    });
-  }
-  /* -------------------------------------------- */
-  getListeNombreAstral() {
-    return game.settings.get(SYSTEM_RDD, "liste-nombre-astral") ?? [];
-  }
-
-  /* -------------------------------------------- */
-  getDateFromIndex(index) {
-    const dateRdD = this.getCalendrier(index);
-    return (dateRdD.jour + 1) + ' ' + dateRdD.moisLabel;
-  }
-
-  /* -------------------------------------------- */
-  getDayMonthFromIndex(index = undefined) {
-    const dateRdD = this.getCalendrier(index);
-    return {
-      day: dateRdD.jour + 1,
-      month: heuresList[dateRdD.moisRdD]
-    }
-  }
-
-  /* -------------------------------------------- */
-  getCurrentHeure() {
-    return heuresList[this.calendrier.heureRdD];
-  }
-
-  /* -------------------------------------------- */
-  getCurrentDayIndex() {
-    return (((this.calendrier.annee ?? 0) * RDD_MOIS_PAR_AN + (this.calendrier.moisRdD ?? 0)) * RDD_JOUR_PAR_MOIS) + (this.calendrier.jour ?? 0);
-  }
-
-  /* -------------------------------------------- */
-  getIndexFromDate(jour, mois) {
-    return (heuresDef[mois].heure * RDD_JOUR_PAR_MOIS) + jour - 1;
-  }
-  /* -------------------------------------------- */
-  getJoursSuivants(num) {
-    let jours = [];
-    let index = this.getCurrentDayIndex();
-    for (let i = 0; i < num; i++) {
-      jours[i] = { label: this.getDateFromIndex(index + i), index: index + i };
-    }
-    return jours;
-  }
-
-  /* -------------------------------------------- */
-  async ajouterNombreAstral(index, showDice = SHOW_DICE) {
-    const nombreAstral = await RdDDice.rollTotal("1dh", { showDice: showDice, rollMode: "selfroll" });
-    const dateFuture = this.getDateFromIndex(index);
-    if (showDice != HIDE_DICE) {
-      ChatMessage.create({
-        whisper: ChatMessage.getWhisperRecipients("GM"),
-        content: `Le chiffre astrologique du ${dateFuture} sera le ${nombreAstral}`
-      });
-    }
-    return {
-      nombreAstral: nombreAstral,
-      valeursFausses: [],
-      index: index
-    }
-  }
-
-  /* -------------------------------------------- */
-  getCurrentNombreAstral() {
-    let indexDate = this.getCurrentDayIndex();
-    return this.getNombreAstral(indexDate);
-  }
-
-  /* -------------------------------------------- */
-  resetNombreAstral() {
-    this.listeNombreAstral = [];
-    game.settings.set(SYSTEM_RDD, "liste-nombre-astral", this.listeNombreAstral);
-
-    game.socket.emit(SYSTEM_SOCKET_ID, {
-      msg: "msg_reset_nombre_astral",
-      data: {}
-    });
-  }
-
-  /* -------------------------------------------- */
-  getNombreAstral(indexDate) {
-    const listNombreAstral = this.getListeNombreAstral();
-    let astralData = listNombreAstral.find((nombreAstral, i) => nombreAstral.index == indexDate);
-    return astralData?.nombreAstral;
-  }
-
-  /* -------------------------------------------- */
-  async rebuildListeNombreAstral(showDice = HIDE_DICE) {
-    if (Misc.isUniqueConnectedGM()) {
-      let jourCourant = this.getCurrentDayIndex();
-      let newList = [];
-      for (let i = 0; i < MAX_NOMBRE_ASTRAL; i++) {
-        let dayIndex = jourCourant + i;
-        let na = this.listeNombreAstral.find(n => n.index == dayIndex);
-        if (na) {
-          newList[i] = na;
-        } else {
-          newList[i] = await this.ajouterNombreAstral(dayIndex, showDice);
-        }
-      }
-      game.settings.set(SYSTEM_RDD, "liste-nombre-astral", newList);
-      this.listeNombreAstral = newList;
-    }
-  }
-
-  /* -------------------------------------------- */
-  async onCalendarButton(ev) {
-    ev.preventDefault();
-    const calendarAvance = ev.currentTarget.attributes['data-calendar-avance'];
-    const calendarSet = ev.currentTarget.attributes['data-calendar-set'];
-    if (calendarAvance) {
-      await this.incrementTime(Number(calendarAvance.value));
-    }
-    else if (calendarSet) {
-      this.positionnerHeure(Number(calendarSet.value));
-    }
-    this.updateDisplay();
-  }
-
-  /* -------------------------------------------- */
-  checkMaladie( periode) {
-    for (let actor of game.actors) {
-      if (actor.type == 'personnage') {
-        let maladies = actor.items.filter( item => (item.type == 'maladie' || (item.type == 'poison' && item.system.active) ) && item.system.periodicite.toLowerCase().includes(periode) );
-        for (let maladie of maladies) {
-          if ( maladie.system.identifie) {
-            ChatMessage.create({ content: `${actor.name} souffre de ${maladie.name} (${maladie.type}): vérifiez que les effets ne se sont pas aggravés !` });
-          } else {
-            ChatMessage.create({ content: `${actor.name} souffre d'un mal inconnu (${maladie.type}): vérifiez que les effets ne se sont pas aggravés !` });
-          }
-          let itemMaladie = actor.getObjet(maladie.id)
-          itemMaladie.postItem( 'gmroll');
-        }
-      }
-    }    
-  }
-
-  /* -------------------------------------------- */
-  async incrementTime(minutes = 0) {
-    this.calendrier.minutesRelative += minutes;
-    this.checkMaladie("round");
-    this.checkMaladie("minute");
-    if (this.calendrier.minutesRelative >= RDD_MINUTES_PAR_HEURES) {
-      this.calendrier.minutesRelative -= RDD_MINUTES_PAR_HEURES;
-      this.calendrier.heureRdD += 1;
-      this.checkMaladie("heure");
-      }
-    if (this.calendrier.heureRdD >= RDD_HEURES_PAR_JOUR) {
-      this.calendrier.heureRdD -= RDD_HEURES_PAR_JOUR;
-      await this.incrementerJour();
-      this.checkMaladie("heure");
-      this.checkMaladie("jour");
-    }
-    game.settings.set(SYSTEM_RDD, "calendrier", duplicate(this.calendrier));
-    // Notification aux joueurs // TODO: replace with Hook on game settings update
-    game.socket.emit(SYSTEM_SOCKET_ID, {
-      msg: "msg_sync_time",
-      data: duplicate(this.calendrier)
-    });
-  }
-
-  /* -------------------------------------------- */
-  async incrementerJour() {
-    const index = this.getCurrentDayIndex() + 1;
-    this.calendrier = this.getCalendrier(index);
-    await this.rebuildListeNombreAstral();
-  }
-
-  /* -------------------------------------------- */
-  syncPlayerTime(calendrier) {
-    this.calendrier = duplicate(calendrier); // Local copy update
-    this.updateDisplay();
-  }
-
-  /* -------------------------------------------- */
-  async positionnerHeure(indexHeure) {
-    if (indexHeure <= this.calendrier.heureRdD) {
-      await this.incrementerJour();
-    }
-    this.calendrier.heureRdD = indexHeure;
-    this.calendrier.minutesRelative = 0;
-    game.settings.set(SYSTEM_RDD, "calendrier", duplicate(this.calendrier));
-  }
-
-  /* -------------------------------------------- */
-  fillCalendrierData(formData = {}) {
-    const mois = RdDCalendrier.getDefSigne(this.calendrier.moisRdD);
-    const heure = RdDCalendrier.getDefSigne(this.calendrier.heureRdD);
-    console.log('fillCalendrierData', this.calendrier, mois, heure);
-
-    formData.heureKey = heure.key;
-    formData.moisKey = mois.key;
-    formData.jourMois = this.calendrier.jour + 1;
-    formData.nomMois = mois.label; // heures et mois nommés identiques
-    formData.annee = this.calendrier.annee;
-    formData.iconMois = dossierIconesHeures + mois.icon;
-    formData.nomHeure = heure.label;
-    formData.iconHeure = dossierIconesHeures + heure.icon;
-    formData.nomSaison = saisonsDef[mois.saison].label;
-    formData.heureRdD = this.calendrier.heureRdD;
-    formData.minutesRelative = this.calendrier.minutesRelative;
-    formData.isGM = game.user.isGM;
-    return formData;
-  }
-
-  /* -------------------------------------------- */
-  getLectureAstrologieDifficulte(dateIndex) {
-    let indexNow = this.getCurrentDayIndex();
-    let diffDay = dateIndex - indexNow;
-    return - Math.floor(diffDay / 2);
-  }
-
-  /* -------------------------------------------- */
-  async requestNombreAstral(request) {
-    if (Misc.isUniqueConnectedGM()) { // Only once
-      console.log(request);
-      let jourDiff = this.getLectureAstrologieDifficulte(request.date);
-      let niveau = Number(request.astrologie.system.niveau) + Number(request.conditions) + Number(jourDiff) + Number(request.etat);
-      let rollData = {
-        caracValue: request.carac_vue,
-        finalLevel: niveau,
-        showDice: HIDE_DICE,
-        rollMode: "blindroll"
-      };
-      await RdDResolutionTable.rollData(rollData);
-      let nbAstral = this.getNombreAstral(request.date);
-      request.rolled = rollData.rolled;
-      request.isValid = true;
-      if (!request.rolled.isSuccess) {
-        request.isValid = false;
-        nbAstral = await RdDDice.rollTotal("1dhr" + nbAstral, { rollMode: "selfroll" });
-        // Mise à jour des nombres astraux du joueur
-        let astralData = this.listeNombreAstral.find((nombreAstral, i) => nombreAstral.index == request.date);
-        astralData.valeursFausses.push({ actorId: request.id, nombreAstral: nbAstral });
-        game.settings.set(SYSTEM_RDD, "liste-nombre-astral", this.listeNombreAstral);
-      }
-      request.nbAstral = nbAstral;
-      if (Misc.getActiveUser(request.userId)?.isGM) {
-        RdDUtility.responseNombreAstral(request);
-      } else {
-        game.socket.emit(SYSTEM_SOCKET_ID, {
-          msg: "msg_response_nombre_astral",
-          data: request
-        });
-      }
-    }
-  }
-
-  /* -------------------------------------------- */
-  findHeure(heure) {
-    heure = Grammar.toLowerCaseNoAccentNoSpace(heure);
-    let parHeureOuLabel = Object.values(heuresDef).filter(it => (it.heure + 1) == parseInt(heure) || Grammar.toLowerCaseNoAccentNoSpace(it.label) == heure);
-    if (parHeureOuLabel.length == 1) {
-      return parHeureOuLabel[0];
-    }
-    let parLabelPartiel = Object.values(heuresDef).filter(it => Grammar.toLowerCaseNoAccentNoSpace(it.label).includes(heure));
-    if (parLabelPartiel.length > 0) {
-      parLabelPartiel.sort(Misc.ascending(h => h.label.length));
-      return parLabelPartiel[0];
-    }
-    return undefined;
-  }
-  /* -------------------------------------------- */
-  getHeureNumber( hNum) {
-    let heure = Object.values(heuresDef).find(it => (it.heure) == hNum);
-    return heure
-  }
-
-  /* -------------------------------------------- */
-  getHeuresChanceMalchance(heureNaissance) {
-    let heuresChancesMalchances = [];
-    let defHeure = this.findHeure(heureNaissance);
-    if (defHeure) {
-      let hn = defHeure.heure;
-      let chiffreAstral = this.getCurrentNombreAstral() ?? 0;
-      heuresChancesMalchances[0] = { value : "+4", heures: [this.getHeureNumber((hn + chiffreAstral) % RDD_HEURES_PAR_JOUR).label]};
-      heuresChancesMalchances[1] = { value : "+2", heures: [this.getHeureNumber((hn + chiffreAstral+4) % RDD_HEURES_PAR_JOUR).label, 
-        this.getHeureNumber((hn + chiffreAstral + 8) % RDD_HEURES_PAR_JOUR).label ] };
-      heuresChancesMalchances[2] = { value : "-4", heures: [this.getHeureNumber((hn + chiffreAstral+6) % RDD_HEURES_PAR_JOUR).label]};
-      heuresChancesMalchances[3] = { value : "-2", heures: [this.getHeureNumber((hn + chiffreAstral+3) % RDD_HEURES_PAR_JOUR).label, 
-          this.getHeureNumber((hn + chiffreAstral + 9) % RDD_HEURES_PAR_JOUR).label ]};
-    }
-    return heuresChancesMalchances;
-  }
-
-  /* -------------------------------------------- */
-  getAjustementAstrologique(heureNaissance, name = undefined) {
-    let defHeure = this.findHeure(heureNaissance);
-    if (defHeure) {
-      let hn = defHeure.heure;
-      let chiffreAstral = this.getCurrentNombreAstral() ?? 0;
-      let heureCourante = this.calendrier.heureRdD;
-      let ecartChance = (hn + chiffreAstral - heureCourante) % RDD_HEURES_PAR_JOUR;
-      switch (ecartChance) {
-        case 0: return 4;
-        case 4: case 8: return 2;
-        case 6: return -4;
-        case 3: case 9: return -2;
-      }
-    }
-    else if (name) {
-      ui.notifications.warn(name + " n'a pas d'heure de naissance, ou elle est incorrecte : " + heureNaissance);
-    }
-    else {
-      ui.notifications.warn(heureNaissance + " ne correspond pas à une heure de naissance");
-    }
-    return 0;
-  }
-
-  /* -------------------------------------------- */
-  getData() {
-    let formData = super.getData();
-
-    this.fillCalendrierData(formData);
-
-    this.setPos(this.calendrierPos);
-    return formData;
-  }
-
-  /* -------------------------------------------- */
-  setPos(pos) {
-    return new Promise(resolve => {
-      function check() {
-        let elmnt = document.getElementById("calendar-time-container");
-        if (elmnt) {
-          elmnt.style.bottom = undefined;
-          let xPos = (pos.left) > window.innerWidth ? window.innerWidth - 200 : pos.left;
-          let yPos = (pos.top) > window.innerHeight - 20 ? window.innerHeight - 100 : pos.top;
-          elmnt.style.top = (yPos) + "px";
-          elmnt.style.left = (xPos) + "px";
-          resolve();
-        } else {
-          setTimeout(check, 30);
-        }
-      }
-      check();
-    });
-  }
-
-  /* -------------------------------------------- */
-  updateDisplay() {
-    let calendrier = this.fillCalendrierData();
-    // Rebuild text du calendrier
-    let dateHTML = `${calendrier.jourMois} ${calendrier.nomMois} ${calendrier.annee} (${calendrier.nomSaison})`
-    if (game.user.isGM) {
-      dateHTML = dateHTML + " - NA: " + (this.getCurrentNombreAstral() ?? "indéterminé");
-    }
-    for (let handle of document.getElementsByClassName("calendar-date-rdd")) {
-      handle.innerHTML = dateHTML;
-    }
-    for (let heure of document.getElementsByClassName("calendar-heure-texte")) {
-      heure.innerHTML = calendrier.nomHeure;
-    }
-    for (const minute of document.getElementsByClassName("calendar-time-disp")) {
-      minute.innerHTML = `${calendrier.minutesRelative} minutes`;
-    }
-    for (const heureImg of document.getElementsByClassName("calendar-heure-img")) {
-      heureImg.src = calendrier.iconHeure;
-    }
-  }
-
-  /* -------------------------------------------- */
-  async saveEditeur(calendrierData) {
-    this.calendrier.minutesRelative = Number(calendrierData.minutesRelative);
-    this.calendrier.jour = Number(calendrierData.jourMois) - 1;
-    this.calendrier.moisRdD = RdDCalendrier.getChiffreFromSigne(calendrierData.moisKey);
-    this.calendrier.annee = Number(calendrierData.annee);
-    this.calendrier.heureRdD = RdDCalendrier.getChiffreFromSigne(calendrierData.heureKey);
-    game.settings.set(SYSTEM_RDD, "calendrier", duplicate(this.calendrier));
-
-    await this.rebuildListeNombreAstral();
-
-    game.socket.emit(SYSTEM_SOCKET_ID, {
-      msg: "msg_sync_time",
-      data: duplicate(this.calendrier)
-    });
-
-    this.updateDisplay();
-  }
-
-  /* -------------------------------------------- */
-  async showCalendarEditor() {
-    let calendrierData = duplicate(this.fillCalendrierData());
-    if (this.editeur == undefined) {
-      calendrierData.jourMoisOptions = RdDCalendrier.buildJoursMois();
-      calendrierData.heuresOptions = [0, 1];
-      calendrierData.minutesOptions = Array(RDD_MINUTES_PAR_HEURES).fill().map((item, index) => 0 + index);
-      let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/calendar-editor-template.html', calendrierData);
-      this.editeur = new RdDCalendrierEditeur(html, this, calendrierData)
-    }
-    this.editeur.updateData(calendrierData);
-    this.editeur.render(true);
-  }
-
-  static buildJoursMois() {
-    return Array(RDD_JOUR_PAR_MOIS).fill().map((item, index) => 1 + index);
-  }
-
-  /* -------------------------------------------- */
-  async showAstrologieEditor() {
-    let calendrierData = duplicate(this.fillCalendrierData());
-    let astrologieArray = [];
-    this.listeNombreAstral = this.listeNombreAstral || [];
-    for (let astralData of this.listeNombreAstral) {
-      astralData.humanDate = this.getDateFromIndex(astralData.index);
-      for (let vf of astralData.valeursFausses) {
-        let actor = game.actors.get(vf.actorId);
-        vf.actorName = (actor) ? actor.name : "Inconnu";
-      }
-      astrologieArray.push(duplicate(astralData));
-    }
-    let heuresParActeur = {};
-    for (let actor of game.actors) {
-      let heureNaissance = actor.getHeureNaissance();
-      if ( heureNaissance) {
-        heuresParActeur[actor.name] = this.getHeuresChanceMalchance(heureNaissance);
-      }      
-    }
-    //console.log("ASTRO", astrologieArray);
-    calendrierData.astrologieData = astrologieArray;
-    calendrierData.heuresParActeur = heuresParActeur;
-    let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/calendar-astrologie-template.html', calendrierData);
-    let astrologieEditeur = new RdDAstrologieEditeur(html, this, calendrierData)
-    astrologieEditeur.updateData(calendrierData);
-    astrologieEditeur.render(true);
-  }
-}

module/rdd-carac.js

@@ -39,9 +39,10 @@ const tableCaracDerivee = {
 
 export class RdDCarac {
 
-  static isAgiliteOuDerivee(selectedCarac) {
+  static isAgiliteOuDerobee(selectedCarac) {
     return selectedCarac?.label.match(/(Agilité|Dérobée)/);
   }
+
   static isVolonte(selectedCarac) {
     return selectedCarac?.label == 'Volonté';
   }
@@ -57,15 +58,6 @@ export class RdDCarac {
       selectedCarac?.label.match(/(Apparence|Force|Agilité|Dextérité|Vue|Ouïe|Odorat-Goût|Empathie|Dérobée|Mêlée|Tir|Lancer)/);
   }
 
-  static isIgnoreEtatGeneral(rollData) {
-    const selectedCarac = rollData.selectedCarac;
-    return !selectedCarac ||
-      rollData.ethylisme ||
-      RdDCarac.isChance(selectedCarac) ||
-      (RdDCarac.isReve(selectedCarac) && !rollData.competence);
-  }
-
-
   static computeTotal(carac, beaute = undefined) {
     const total = Object.values(carac ?? {}).filter(c => !c.derivee)
       .map(it => parseInt(it.value))

module/rdd-combat.js

@@ -1,6 +1,5 @@
 import { ChatUtility } from "./chat-utility.js";
-import { ENTITE_BLURETTE, ENTITE_INCARNE, ENTITE_NONINCARNE, HIDE_DICE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
-import { DialogSelectTarget } from "./dialog-select-target.js";
+import { ENTITE_BLURETTE, HIDE_DICE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
 import { Grammar } from "./grammar.js";
 import { RdDItemArme } from "./item-arme.js";
 import { RdDItemCompetence } from "./item-competence.js";
@@ -13,6 +12,7 @@ import { RdDRollTables } from "./rdd-rolltables.js";
 import { ReglesOptionelles } from "./settings/regles-optionelles.js";
 import { STATUSES } from "./settings/status-effects.js";
 import { Targets } from "./targets.js";
+import { RdDEmpoignade } from "./rdd-empoignade.js";
 
 /* -------------------------------------------- */
 const premierRoundInit = [
@@ -40,35 +40,32 @@ export class RdDCombatManager extends Combat {
 
   static init() {
     /* -------------------------------------------- */
-    Hooks.on("getCombatTrackerEntryContext", (html, options) => {
-      RdDCombatManager.pushInitiativeOptions(html, options);
-    });
-    Hooks.on("preDeleteCombat", (combat, html, id) => {
-      combat.onPreDeleteCombat()
-    });
-  }
-
-  /* -------------------------------------------- */
-  cleanItemUse() {
-    for (let turn of this.turns) {
-      turn.actor.resetItemUse()
-    }
+    Hooks.on("getCombatTrackerEntryContext", (html, options) => { RdDCombatManager.pushInitiativeOptions(html, options); });
+    Hooks.on("updateCombat", (combat, change, options, userId) => { RdDCombat.onUpdateCombat(combat, change, options, userId) });
+    Hooks.on("preDeleteCombat", (combat, html, id) => { combat.onPreDeleteCombat() });
   }
 
   /* -------------------------------------------- */
   async nextRound() {
-    this.cleanItemUse();
     await this.finDeRound();
     return await super.nextRound();
   }
 
   /* -------------------------------------------- */
   async onPreDeleteCombat() {
-    await this.finDeRound({ terminer: true });
+    if (Misc.isUniqueConnectedGM()) {
+      await this.finDeRound({ terminer: true });
+      ChatUtility.removeChatMessageContaining(`<div data-combatid="${this.id}" data-combatmessage="actor-turn-summary">`)
+      game.messages.filter(m => ChatUtility.getMessageData(m, 'attacker-roll') != undefined && ChatUtility.getMessageData(m, 'defender-roll') != undefined)
+        .forEach(it => it.delete());
+      RdDEmpoignade.deleteAllEmpoignades()
+    }
   }
 
   /* -------------------------------------------- */
   async finDeRound(options = { terminer: false }) {
+    this.turns.forEach(turn => turn.actor.resetItemUse());
+
     for (let combatant of this.combatants) {
       if (combatant.actor) {
         await combatant.actor.finDeRound(options);
@@ -90,19 +87,32 @@ export class RdDCombatManager extends Combat {
       let rollFormula = formula ?? RdDCombatManager.formuleInitiative(2, 10, 0, 0);
       if (!formula) {
         if (combatant.actor.type == 'creature' || combatant.actor.type == 'entite') {
-          const competence = combatant.actor.items.find(it => it.system.iscombat)
+          const competence = combatant.actor.items.find(it => RdDItemCompetenceCreature.getCategorieAttaque(it))
           if (competence) {
             rollFormula = RdDCombatManager.formuleInitiative(2, competence.system.carac_value, competence.system.niveau, 0);
           }
         } else {
           const armeCombat = combatant.actor.itemTypes['arme'].find(it => it.system.equipe)
-          const compName = (armeCombat == undefined) ? "Corps à corps" : armeCombat.system.competence;
+          let compName = "Corps à corps"
+          if (armeCombat) {
+            if (armeCombat.system.competence != "") {
+              compName = armeCombat.system.competence
+            }
+            if (armeCombat.system.lancer != "") {
+              compName = armeCombat.system.lancer
+            }
+            if (armeCombat.system.tir != "") {
+              compName = armeCombat.system.tir
+            }
+          }
           const competence = RdDItemCompetence.findCompetence(combatant.actor.items, compName);
-          if (competence) {
+          if (competence && competence.system.defaut_carac) {
             const carac = combatant.actor.system.carac[competence.system.defaut_carac].value;
             const niveau = competence.system.niveau;
             const bonusEcaille = (armeCombat?.system.magique) ? armeCombat.system.ecaille_efficacite : 0;
             rollFormula = RdDCombatManager.formuleInitiative(2, carac, niveau, bonusEcaille);
+          } else {
+            ui.notifications.warn(`Votre arme ${armeCombat.name} n'a pas de compétence renseignée`);
           }
         }
       }
@@ -111,10 +121,10 @@ export class RdDCombatManager extends Combat {
       if (!roll.total) {
         roll.evaluate({ async: false });
       }
-      if (roll.total <= 0) roll.total = 0.00;
-      console.log("Compute init for", rollFormula, roll.total, combatant);
+      const total = Math.max(roll.total, 0.00);
+      console.log("Compute init for", rollFormula, roll, total, combatant);
       let id = combatant._id || combatant.id;
-      await this.updateEmbeddedDocuments("Combatant", [{ _id: id, initiative: roll.total }]);
+      await this.updateEmbeddedDocuments("Combatant", [{ _id: id, initiative: total }]);
 
       // Send a chat message
       let rollMode = messageOptions.rollMode || game.settings.get("core", "rollMode");
@@ -145,9 +155,8 @@ export class RdDCombatManager extends Combat {
   }
 
   /* -------------------------------------------- */
-  static calculInitiative(niveau, caracValue, bonusEcaille = 0) {
-    let base = niveau + Math.floor(caracValue / 2);
-    base += bonusEcaille;
+  static calculInitiative(niveau, caracValue, bonus = 0) {
+    let base = niveau + Math.floor(caracValue / 2) + bonus;
     return "1d6" + (base >= 0 ? "+" : "") + base;
   }
 
@@ -221,15 +230,15 @@ export class RdDCombatManager extends Combat {
   }
 
   static listActionsCreature(competences) {
-    return competences.filter(it => RdDItemCompetenceCreature.isCompetenceAttaque(it))
-      .map(it => RdDItemCompetenceCreature.armeNaturelle(it));
+    return competences.map(it => RdDItemCompetenceCreature.armeCreature(it))
+      .filter(it => it != undefined);
   }
 
   static listActionsPossessions(actor) {
     return RdDCombatManager._indexActions(actor.getPossessions().map(p => {
       return {
         name: p.name,
-        action: 'conjurer',
+        action: 'possession',
         system: {
           competence: p.name,
           possessionid: p.system.possessionid,
@@ -246,15 +255,15 @@ export class RdDCombatManager extends Combat {
       return actions;
     }
     if (actor.isCreatureEntite()) {
-      actions = actions.concat(RdDCombatManager.listActionsCreature(actor.itemTypes['competencecreature']));
-    } else {
+      actions = RdDCombatManager.listActionsCreature(actor.itemTypes['competencecreature']);
+    } else if (actor.isPersonnage()) {
       // Recupération des items 'arme'
       const armes = actor.itemTypes['arme'].filter(it => RdDItemArme.isArmeUtilisable(it))
-        //.concat(RdDItemArme.empoignade())
+        .concat(RdDItemArme.empoignade())
         .concat(RdDItemArme.mainsNues());
 
       const competences = actor.itemTypes['competence'];
-      actions = actions.concat(RdDCombatManager.listActionsArmes(armes, competences, actor.system.carac));
+      actions = RdDCombatManager.listActionsArmes(armes, competences, actor.system.carac);
 
       if (actor.system.attributs.hautrevant.value) {
         actions.push({ name: "Draconic", action: 'haut-reve', system: { initOnly: true, competence: "Draconic" } });
@@ -342,7 +351,7 @@ export class RdDCombatManager extends Combat {
     } else if (combatant.actor.getSurprise() == "demi") {
       initOffset = 0;
       initInfo = "Demi Surprise"
-    } else if (action.action == 'conjurer') {
+    } else if (action.action == 'possession') {
       initOffset = 10;
       caracForInit = combatant.actor.getReveActuel();
       initInfo = "Possession"
@@ -421,18 +430,11 @@ export class RdDCombatManager extends Combat {
 /* -------------------------------------------- */
 export class RdDCombat {
 
-  static init() {
-    Hooks.on("updateCombat", (combat, change, options, userId) => { RdDCombat.onUpdateCombat(combat, change, options, userId) });
-    Hooks.on("preDeleteCombat", (combat, options, userId) => { RdDCombat.onPreDeleteCombat(combat, options, userId); });
-  }
-
   /* -------------------------------------------- */
   static onSocketMessage(sockmsg) {
     switch (sockmsg.msg) {
-      case "msg_encaisser":
-        return RdDCombat.onMsgEncaisser(sockmsg.data);
-      case "msg_defense":
-        return RdDCombat.onMsgDefense(sockmsg.data);
+      case "msg_encaisser": return RdDCombat.onMsgEncaisser(sockmsg.data);
+      case "msg_defense": return RdDCombat.onMsgDefense(sockmsg.data);
     }
   }
 
@@ -443,16 +445,6 @@ export class RdDCombat {
     }
   }
 
-  /* -------------------------------------------- */
-  static onPreDeleteCombat(combat, options, userId) {
-    if (Misc.isUniqueConnectedGM()) {
-      combat.cleanItemUse();
-      ChatUtility.removeChatMessageContaining(`<div data-combatid="${combat.id}" data-combatmessage="actor-turn-summary">`)
-      game.messages.filter(m => ChatUtility.getMessageData(m, 'attacker-roll') != undefined && ChatUtility.getMessageData(m, 'defender-roll') != undefined)
-        .forEach(it => it.delete());
-    }
-  }
-
   /* -------------------------------------------- */
   static combatNouveauTour(combat) {
     if (Misc.isUniqueConnectedGM()) {
@@ -757,29 +749,14 @@ export class RdDCombat {
 
   /* -------------------------------------------- */
   async attaque(competence, arme) {
-    // const nonIncarnee = this.defender.isEntite([ENTITE_NONINCARNE])
-    // const blurette = this.defender.isEntite([ENTITE_BLURETTE])
-    // if (nonIncarnee || blurette) {
-    //   ChatMessage.create( {
-    //     content: `<strong>La cible est ${nonIncarnee ? 'non incarnée' : 'une blurette'}.
-    //       Il est impossible de l'atteindre.`,
-    //     whisper: ChatMessage.getWhisperRecipients("GM")})
-    // }
-
     if (!await this.attacker.accorder(this.defender, 'avant-attaque')) {
       return;
     }
-    if (arme.system.cac == 'empoignade' && this.attacker.isCombatTouche()) {
-      ChatMessage.create({
-        alias: this.attacker.name,
-        whisper: ChatUtility.getWhisperRecipientsAndGMs(this.attacker.name),
-        content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-actor-perte-empoignade.html', {
-          attacker: this.attacker,
-          competence: competence
-        })
-      });
+    if (arme.system.cac == 'empoignade') {
+      RdDEmpoignade.onAttaqueEmpoignade(this.attacker, this.defender)
       return;
     }
+    RdDEmpoignade.checkEmpoignadeEnCours(this.attacker)
 
     let rollData = this._prepareAttaque(competence, arme);
     console.log("RdDCombat.attaque >>>", rollData);
@@ -813,7 +790,7 @@ export class RdDCombat {
       passeArme: randomID(16),
       mortalite: arme?.system.mortalite,
       coupsNonMortels: false,
-      competence: competence,
+      competence: competence.clone(),
       surprise: this.attacker.getSurprise(true),
       surpriseDefenseur: this.defender.getSurprise(true),
       targetToken: Targets.extractTokenData(this.target),
@@ -971,9 +948,8 @@ export class RdDCombat {
   /* -------------------------------------------- */
   _filterArmesParade(defender, competence) {
     let items = defender.items.filter(it => RdDItemArme.isArmeUtilisable(it) || RdDItemCompetenceCreature.isCompetenceParade(it))
-    for (let item of items) {
-      item.system.nbUsage = defender.getItemUse(item.id); // Ajout du # d'utilisation ce round  
-    }
+    items.forEach(item => item.system.nbUsage = defender.getItemUse(item.id)); // Ajout du # d'utilisation ce round  
+
     switch (competence.system.categorie) {
       case 'tir':
       case 'lancer':
@@ -1069,7 +1045,7 @@ export class RdDCombat {
       passeArme: attackerRoll.passeArme,
       diffLibre: attackerRoll.diffLibre,
       attackerRoll: attackerRoll,
-      competence: this.defender.getCompetence(competenceParade),
+      competence: this.defender.getCompetence(competenceParade).clone(),
       arme: armeParade,
       surprise: this.defender.getSurprise(true),
       needParadeSignificative: ReglesOptionelles.isUsing('categorieParade') && RdDItemArme.needParadeSignificative(attackerRoll.arme, armeParade),
@@ -1150,7 +1126,7 @@ export class RdDCombat {
       passeArme: attackerRoll.passeArme,
       diffLibre: attackerRoll.diffLibre,
       attackerRoll: attackerRoll,
-      competence: competence,
+      competence: competence.clone(),
       surprise: this.defender.getSurprise(true),
       surpriseDefenseur: this.defender.getSurprise(true),
       carac: this.defender.system.carac,
@@ -1328,13 +1304,8 @@ export class RdDCombat {
       blessuresStatus: actor.computeResumeBlessure(),
       SConst: actor.getSConst(),
       actorId: actor.id,
-      isGrave: false,
-      isCritique: false
-    }
-    if (actor.countBlessuresNonSoigneeByName("critiques") > 0) { // Pour éviter le cumul grave + critique
-      formData.isCritique = true;
-    } else if (actor.countBlessuresNonSoigneeByName("graves") > 0) {
-      formData.isGrave = true;
+      isGrave: actor.countBlessures(it => it.isGrave()) > 0,
+      isCritique: actor.countBlessures(it => it.isCritique()) > 0
     }
 
     ChatUtility.createChatWithRollMode(actor.name, {

module/rdd-commands.js

@@ -2,7 +2,8 @@
 
 import { DialogChronologie } from "./dialog-chronologie.js";
 import { DialogCreateSigneDraconique } from "./dialog-create-signedraconique.js";
-import { DialogStress } from "./dialog-stress.js";
+import { DialogChateauDormant } from "./sommeil/dialog-chateau-dormant.js";
+import { DialogStress } from "./sommeil/dialog-stress.js";
 import { RdDItemCompetence } from "./item-competence.js";
 import { Misc } from "./misc.js";
 import { RdDCarac } from "./rdd-carac.js";
@@ -13,7 +14,7 @@ import { RdDResolutionTable } from "./rdd-resolution-table.js";
 import { RdDRollResolutionTable } from "./rdd-roll-resolution-table.js";
 import { RdDRollTables } from "./rdd-rolltables.js";
 import { RdDUtility } from "./rdd-utility.js";
-import { CompendiumTableHelpers } from "./settings/system-compendiums.js";
+import { FenetreRechercheTirage } from "./tirage/fenetre-recherche-tirage.js";
 import { TMRUtility } from "./tmr-utility.js";
 
 const rddRollNumeric = /^(\d+)\s*([\+\-]?\d+)?\s*(s)?/;
@@ -23,6 +24,7 @@ export class RdDCommands {
 
   static init() {
     const rddCommands = new RdDCommands();
+    game.system.rdd.commands = rddCommands;
 
     Hooks.on("chatMessage", (html, content, msg) => {
       if (content[0] == '/') {
@@ -35,7 +37,6 @@ export class RdDCommands {
       return true;
     });
 
-    game.system.rdd.commands = rddCommands;
   }
 
   constructor() {
@@ -63,7 +64,6 @@ export class RdDCommands {
           <br><strong>/table rencontre deso</strong> affiche la table des rencontres en Désolation
           <br><strong>/table rencontre mauvaise</strong> affiche la table des mauvaises rencontres`
     });
-    this.registerCommand({ path: ["/table", "milieu"], func: (content, msg, params) => this.tableMilieu(msg, params, 'liste'), descr: "Affiche la table des ressource naturelles pour un milieu donné" });
 
     this.registerCommand({ path: ["/tirer", "comp"], func: (content, msg, params) => RdDRollTables.getCompetence('chat'), descr: "Tire une compétence au hasard" });
     this.registerCommand({ path: ["/tirer", "queue"], func: (content, msg, params) => RdDRollTables.getQueue('chat'), descr: "Tire une Queue de Dragon" });
@@ -75,8 +75,9 @@ export class RdDCommands {
     this.registerCommand({ path: ["/tirer", "ideefixe"], func: (content, msg, params) => RdDRollTables.getIdeeFixe('chat'), descr: "Tire une Idée fixe" });
     this.registerCommand({ path: ["/tirer", "desir"], func: (content, msg, params) => RdDRollTables.getDesirLancinant('chat'), descr: "Tire un Désir Lancinant" });
     this.registerCommand({ path: ["/tirer", "rencontre"], func: (content, msg, params) => this.getRencontreTMR(params), descr: `Détermine une rencontre dans les TMR (synonyme de "/tmrr")` });
-    this.registerCommand({ path: ["/tirer", "milieu"], func: (content, msg, params) => this.tableMilieu(msg, params, 'chat'), descr: "Effectue un tirage dans la table desressource naturelles pour un milieu donné" });
+    this.registerCommand({ path: ["/tirage"], func: (content, msg, params) => this.tirage(), descr: "Ouvre la fenêtre de recherche et tirage" });
 
+    this.registerCommand({ path: ["/sommeil"], func: (content, msg, params) => this.sommeil(msg, params), descr: "Prépare le passage de journée pour chateau dormant" });
     this.registerCommand({ path: ["/meteo"], func: (content, msg, params) => this.getMeteo(msg, params), descr: "Propose une météo marine" });
     this.registerCommand({ path: ["/nom"], func: (content, msg, params) => RdDNameGen.getName(msg, params), descr: "Génère un nom aléatoire" });
 
@@ -206,16 +207,16 @@ export class RdDCommands {
     let rollMode = game.settings.get("core", "rollMode");
     if (["gmroll", "blindroll"].includes(rollMode)) {
       msg["whisper"] = ChatMessage.getWhisperRecipients("GM");
-    } 
-    if (rollMode === "blindroll"){
+    }
+    if (rollMode === "blindroll") {
       msg["blind"] = true;
-    } 
+    }
     msg["type"] = 0;
 
     if (!this.commandsTable) {
       this._registerCommands();
     }
-  
+
     let command = commandLine[0].toLowerCase();
     if (this._isCommandHandled(command)) {
       let params = commandLine.slice(1);
@@ -225,7 +226,7 @@ export class RdDCommands {
     return false;
   }
 
-  _isCommandHandled(command){
+  _isCommandHandled(command) {
     return this.commandsTable[command] != undefined;
   }
 
@@ -254,10 +255,7 @@ export class RdDCommands {
   }
 
   /* -------------------------------------------- */
-  async help(msg) {
-    this.help(msg, undefined);
-  }
-  async help(msg, table) {
+  async help(msg, table = undefined) {
     let commands = []
     this._buildSubTableHelp(commands, table ?? this.commandsTable);
 
@@ -331,10 +329,10 @@ export class RdDCommands {
           diff = 0;
         }
         const caracName = params[0];
-        let competence = length > 1 ? actors[0].getCompetence(Misc.join(params.slice(1, length), ' ')) : {name:undefined};
+        let competence = length > 1 ? actors[0].getCompetence(Misc.join(params.slice(1, length), ' ')) : { name: undefined };
         if (competence) {
           for (let actor of actors) {
-            await actor.rollCaracCompetence(caracName, competence.name, diff);
+            await actor.doRollCaracCompetence(caracName, competence.name, diff);
           }
         }
         return;
@@ -398,32 +396,6 @@ export class RdDCommands {
     return false;
   }
 
-  async tableMilieu(msg, params, toChat) {
-    if (params && params.length > 0) {
-      const search = Misc.join(params, ' ');
-      const milieux = await game.system.rdd.environnement.findEnvironnementsLike(search);
-      if (milieux.length == 0) {
-        const tous = Object.values(await game.system.rdd.environnement.milieux());
-        return RdDCommands._chatAnswer(msg, `<strong>Aucun milieu correspondant à '${search}'.</strong>
-          <br>Milieux disponibles:
-          <br><ul class="chat-list"><li>${tous.reduce(Misc.joining('</li><li>'))}</li></ul>`);
-      }
-      if (milieux.length > 1) {
-        ui.notifications.warn(`<strong>Plusieurs milieux correspondent à '${search}'</strong>:
-          <br><ul class="chat-list"><li>${milieux.reduce(Misc.joining('</li><li>'))}</li></ul>`);
-      }
-      const tableName = `ressources en ${milieux.reduce(Misc.joining(', '))}`;
-      if (toChat == 'liste') {
-        return await game.system.rdd.environnement.searchToChatMessage(milieux, tableName);
-      }
-      else {
-        const row = await game.system.rdd.environnement.getRandom(milieux, tableName);
-        await CompendiumTableHelpers.tableRowToChatMessage(row, 'Item');
-        return true;
-      }
-    }
-    return false;
-  }
   /* -------------------------------------------- */
   getCoutXpComp(msg, params) {
     if (params && (params.length == 1 || params.length == 2)) {
@@ -448,17 +420,27 @@ export class RdDCommands {
   }
 
   async creerSignesDraconiques() {
-    DialogCreateSigneDraconique.createSigneForActors();
+    if (game.user.isGM) {
+      DialogCreateSigneDraconique.createSigneForActors();
+    }
+    else {
+      ui.notifications.warn("Seul le MJ est autorisé à utiliser la commande /signe");
+    }
     return true;
   }
 
   async supprimerSignesDraconiquesEphemeres() {
-    game.actors.forEach(actor => {
-      const ephemeres = actor.items.filter(item => item.type = 'signedraconique' && item.system.ephemere);
-      if (ephemeres.length > 0) {
-        actor.deleteEmbeddedDocuments("Item", ephemeres.map(item => item.id));
-      }
-    });
+    if (game.user.isGM) {
+      game.actors.forEach(actor => {
+        const ephemeres = actor.items.filter(item => item.type = 'signedraconique' && item.system.ephemere);
+        if (ephemeres.length > 0) {
+          actor.deleteEmbeddedDocuments("Item", ephemeres.map(item => item.id));
+        }
+      });
+    }
+    else {
+      ui.notifications.warn("Seul le MJ est autorisé à utiliser la commande /signe");
+    }
     return true;
   }
 
@@ -481,13 +463,14 @@ export class RdDCommands {
       let name = params[params.length - 1];
       if (name == undefined) {
         for (let actor of game.actors) {
-          actor.distribuerStress('stress', stress, motif);
+          // TODO: ne plus stresser les entités de cauchemar!
+          await actor.distribuerStress('stress', stress, motif);
         }
       } else {
         //console.log(stressValue, nomJoueur);
         let actor = Misc.findActor(name, game.actors.filter(it => it.hasPlayerOwner)) ?? Misc.findPlayer(name)?.character
         if (actor) {
-          actor.distribuerStress('stress', stress, motif);
+          await actor.distribuerStress('stress', stress, motif);
         }
         else {
           ui.notifications.warn(`Pas de personnage ou de joueur correspondant à ${name}!`);
@@ -501,5 +484,11 @@ export class RdDCommands {
     return await RdDMeteo.getMeteo();
   }
 
+  async tirage() {
+    FenetreRechercheTirage.create();
+  }
+  async sommeil() {
+    DialogChateauDormant.create();
+  }
 }
 

module/rdd-compendium-organiser.js

@@ -1,8 +1,8 @@
 import { SYSTEM_RDD } from "./constants.js";
 
-export class RddCompendiumOrganiser {
+export class RdDCompendiumOrganiser {
   static init() {
-    Hooks.on('renderCompendium', async (pack, html, compendiumData) => RddCompendiumOrganiser.onRenderCompendium(pack, html, compendiumData))
+    Hooks.on('renderCompendium', async (pack, html, compendiumData) => RdDCompendiumOrganiser.onRenderCompendium(pack, html, compendiumData))
   }
 
   static async onRenderCompendium(compendium, html, compendiumData) {
@@ -10,14 +10,14 @@ export class RddCompendiumOrganiser {
     const pack = compendium.collection
     if (pack.metadata.system === SYSTEM_RDD) {
       html.find('.directory-item').each((i, element) => {
-        RddCompendiumOrganiser.setEntityTypeName(pack, element);
+        RdDCompendiumOrganiser.setEntityTypeName(pack, element);
       });
     }
   }
 
   static async setEntityTypeName(pack, element) {
-    const label = RddCompendiumOrganiser.getEntityTypeLabel(await pack.getDocument(element.dataset.documentId));
-    RddCompendiumOrganiser.insertEntityType(element, label);
+    const label = RdDCompendiumOrganiser.getEntityTypeLabel(await pack.getDocument(element.dataset.documentId));
+    RdDCompendiumOrganiser.insertEntityType(element, label);
   }
 
   static insertEntityType(element, label) {

module/rdd-empoignade.js

@@ -0,0 +1,436 @@
+/* -------------------------------------------- */
+import { RdDResolutionTable } from "./rdd-resolution-table.js";
+import { RdDRoll } from "./rdd-roll.js";
+import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
+import { ChatUtility } from "./chat-utility.js";
+import { STATUSES } from "./settings/status-effects.js";
+import { ReglesOptionelles } from "./settings/regles-optionelles.js";
+import { TYPES } from "./item.js";
+
+/* -------------------------------------------- */
+
+/* -------------------------------------------- */
+export class RdDEmpoignade {
+
+  /* -------------------------------------------- */
+  static init() {
+  }
+
+  /* -------------------------------------------- */
+  static registerChatCallbacks(html) {
+    html.on("click", '.defense-empoignade-cac', event => {
+      const chatMessage = ChatUtility.getChatMessage(event);
+      const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
+      let defenseMode = event.currentTarget.attributes['data-defense-mode'].value
+      RdDEmpoignade.onDefenseEmpoignade(rollData, defenseMode, "Corps à corps", "melee")
+    });
+    html.on("click", '.defense-empoignade-esquive', event => {
+      const chatMessage = ChatUtility.getChatMessage(event);
+      const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
+      let defenseMode = event.currentTarget.attributes['data-defense-mode'].value
+      RdDEmpoignade.onDefenseEmpoignade(rollData, defenseMode, "Esquive", "derobee")
+    });
+    html.on("click", '.empoignade-poursuivre', event => {
+      let attackerId = event.currentTarget.attributes['data-attackerId'].value
+      let defenderId = event.currentTarget.attributes['data-defenderId'].value
+      RdDEmpoignade.onAttaqueEmpoignadeValidee(game.actors.get(attackerId), game.actors.get(defenderId))
+    });
+    html.on("click", '.empoignade-entrainer-sol', event => {
+      const chatMessage = ChatUtility.getChatMessage(event);
+      const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
+      RdDEmpoignade.entrainerAuSol(rollData)
+      ChatUtility.removeChatMessageId(chatMessage.id)
+    });
+    html.on("click", '.empoignade-projeter-sol', event => {
+      const chatMessage = ChatUtility.getChatMessage(event);
+      const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
+      RdDEmpoignade.projeterAuSol(rollData)
+      ChatUtility.removeChatMessageId(chatMessage.id)
+    });
+    html.on("change", '.empoignade-perte-endurance', event => {
+      const chatMessage = ChatUtility.getChatMessage(event);
+      const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
+      if (event.currentTarget.value && event.currentTarget.value != "none") {
+        RdDEmpoignade.perteEndurance(rollData, event.currentTarget.value)
+        ChatUtility.removeChatMessageId(chatMessage.id)
+      }
+    });
+  }
+
+  /* -------------------------------------------- */
+  static checkEmpoignadeEnCours(actor) {
+    // TODO: autoriser la perception? la comédie/séduction?
+    if (RdDEmpoignade.isEmpoignadeEnCours(actor)) {
+      ui.notifications.warn("Une empoignade est en cours ! Normalement, vous ne pouvez rien faire d'autre que continuer l'empoignade ou la rompre.")
+      return true;
+    }
+    return false;
+  }
+
+  /* -------------------------------------------- */
+  static $storeRollEmpoignade(msg, rollData) {
+    RdDEmpoignade.$reduceActorToIds(rollData);
+    ChatUtility.setMessageData(msg, "empoignade-roll-data", rollData);
+  }
+
+  static $reduceActorToIds(rollData) {
+    rollData.attacker = { id: rollData.attacker.id };
+    rollData.defender = { id: rollData.defender.id };
+  }
+
+  /* -------------------------------------------- */
+  static $readRollEmpoignade(msg) {
+    const rollData = ChatUtility.getMessageData(msg, 'empoignade-roll-data');
+    RdDEmpoignade.$replaceIdsWithActors(rollData);
+    return rollData
+  }
+
+  static $replaceIdsWithActors(rollData) {
+    rollData.attacker = game.actors.get(rollData.attacker.id);
+    rollData.defender = game.actors.get(rollData.defender.id);
+  }
+
+  /* -------------------------------------------- */
+  static isEmpoignadeEnCours(actor) {
+    return actor.itemTypes[TYPES.empoignade].find(it => it.system.pointsemp > 0)
+  }
+
+  /* -------------------------------------------- */
+  static getEmpoignadeById(actor, id) {
+    let emp = actor.itemTypes[TYPES.empoignade].find(it => it.system.empoignadeid == id)
+    return emp && duplicate(emp) || undefined;
+  }
+
+  /* -------------------------------------------- */
+  static getEmpoignade(attacker, defender) {
+    let emp = attacker.itemTypes[TYPES.empoignade].find(it =>
+      (it.system.empoigneurid == attacker.id && it.system.empoigneid == defender.id) ||
+      (it.system.empoigneurid == defender.id && it.system.empoigneid == attacker.id)
+    )
+    if (emp) {
+      return duplicate(emp);
+    }
+    return undefined;
+  }
+
+  /* -------------------------------------------- */
+  static getMalusTaille(emp, attacker, defender) {
+    // Si pas empoigné, alors 0
+    if (emp.system.pointsemp == 0) {
+      return 0
+    }
+    // p135: Malus de -1 par point de taille de différence de taille au delà de 1 (donc -2 pour une différence de 3, ...)
+    const diffTaille = attacker.system.carac.taille.value - defender.system.carac.taille.value;
+    const diffTailleAbs = Math.abs(diffTaille)
+    const signDiff = diffTaille > 0 ? 1 : -1
+
+    if (diffTailleAbs > 2) {
+      return signDiff * (diffTailleAbs - 1)
+    }
+    return 0
+  }
+
+  static isActionAutorisee(mode, attacker, defender) {
+    const acting = RdDEmpoignade.isActionDefenseur(mode) ? defender : attacker;
+    if (acting.getUserLevel(game.user) < CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER) {
+      ui.notifications.warn(`Vous n'êtes pas autorisé à choisir l'action de ${acting.name}`)
+      return false;
+    }
+    return true
+  }
+
+  static isActionDefenseur(mode) {
+    switch (mode) {
+      case "liberer":
+      case "contrer-empoigner":
+        return true;
+    }
+    return false;
+  }
+
+  /* -------------------------------------------- */
+  static async onAttaqueEmpoignade(attacker, defender) {
+    if (!RdDEmpoignade.isActionAutorisee("empoigner", attacker, defender)) {
+      return
+    }
+    let empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)
+    const isNouvelle = empoignade == undefined;
+    empoignade = empoignade ?? (await RdDEmpoignade.createEmpoignade(attacker, defender))
+    //console.log("W.", empoignade, defender.hasArmeeMeleeEquipee())
+    if ((isNouvelle || empoignade.system.pointsemp == 0) && defender.hasArmeeMeleeEquipee()) {
+      ChatUtility.createChatWithRollMode(attacker.name, {
+        content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-empoignade-valider.html`, { attacker: attacker, defender: defender })
+      })
+    } else {
+      await this.onAttaqueEmpoignadeValidee(attacker, defender)
+    }
+  }
+
+  /* -------------------------------------------- */
+  static async onAttaqueEmpoignadeValidee(attacker, defender) {
+    let empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)
+    const isNouvelle = empoignade == undefined;
+    empoignade = empoignade ?? (await RdDEmpoignade.createEmpoignade(attacker, defender))
+
+    let mode = (empoignade && empoignade.system.empoigneurid == attacker.id) ? "empoigner" : "liberer"
+
+    if (!RdDEmpoignade.isActionAutorisee(mode, attacker, defender)) {
+      return
+    }
+
+    let rollData = {
+      mode, empoignade, attacker, defender,
+      isEmpoignade: true,
+      competence: attacker.getCompetence("Corps à corps").clone(),
+      selectedCarac: attacker.system.carac.melee,
+      malusTaille: RdDEmpoignade.getMalusTaille(empoignade, attacker, defender)
+    }
+    if (attacker.isCreatureEntite()) {
+      RdDItemCompetenceCreature.setRollDataCreature(rollData)
+    }
+    if (empoignade.system.pointsemp >= 2) {
+      if (!empoignade.system.ausol) {
+        let msg = await RdDResolutionTable.displayRollData(rollData, attacker, 'chat-empoignade-entrainer.html');
+        RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
+      }
+    } else {
+      await RdDEmpoignade.$rollAttaqueEmpoignade(attacker, rollData, isNouvelle);
+    }
+  }
+
+  /* -------------------------------------------- */
+  static async onAttaqueEmpoignadeFromItem(empoignade) {
+    let attacker = game.actors.get(empoignade.system.empoigneurid)
+    let defender = game.actors.get(empoignade.system.empoigneid)
+    await this.onAttaqueEmpoignadeValidee(attacker, defender)
+  }
+
+  static async onImmobilisation(attacker, defender, empoignade) {
+    const rollData = {
+      mode: "immobilise",
+      empoignade, attacker, defender,
+      isEmpoignade: true,
+      competence: attacker.getCompetence("Corps à corps").clone()
+    }
+    const msg = await ChatMessage.create({
+      whisper: ChatUtility.getWhisperRecipientsAndGMs(attacker.name),
+      content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-empoignade-immobilise.html`, rollData)
+    })
+    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
+  }
+
+  /* -------------------------------------------- */
+  static async $rollAttaqueEmpoignade(attacker, rollData, isNouvelle = false) {
+    const dialog = await RdDRoll.create(attacker, rollData,
+      { html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-competence.html' },
+      {
+        name: 'jet-empoignade',
+        label: 'Empoigner',
+        callbacks: [{ action: async (r) => await RdDEmpoignade.$onRollEmpoignade(r, isNouvelle) },]
+      });
+    dialog.render(true);
+  }
+
+  /* -------------------------------------------- */
+  static async $onRollEmpoignade(rollData, isNouvelle = false) {
+    let attacker = game.actors.get(rollData.attacker.id)
+    let defender = game.actors.get(rollData.defender.id)
+
+
+    if (rollData.rolled.isSuccess && isNouvelle) {
+      const objectEmpoignade = rollData.empoignade.toObject();
+      // Creer l'empoignade sur attaquant/defenseur
+      attacker.creerObjetParMJ(objectEmpoignade);
+      defender.creerObjetParMJ(objectEmpoignade);
+    }
+
+    rollData.empoignade.isSuccess = rollData.rolled.isSuccess;
+    if (rollData.rolled.isPart) {
+      rollData.particuliere = "finesse";
+    }
+    let msg = await RdDResolutionTable.displayRollData(rollData, attacker, 'chat-empoignade-resultat.html');
+    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
+  }
+
+  /* -------------------------------------------- */
+  static async onDefenseEmpoignade(attackerRoll, mode, competenceName = "Corps à corps", carac = "melee") {
+    let attacker = game.actors.get(attackerRoll.attacker.id)
+    let defender = game.actors.get(attackerRoll.defender.id)
+    if (!RdDEmpoignade.isActionAutorisee(mode, attacker, defender)) {
+      return
+    }
+
+    let empoignade = this.getEmpoignade(attacker, defender)
+
+    if (!empoignade) {
+      ui.notifications.warn("Une erreur s'est produite : Aucune empoignade trouvée !!")
+      return
+    }
+
+    empoignade = duplicate(empoignade)
+    let defenderRoll = {
+      mode, attacker, defender, empoignade, attackerRoll,
+      diffLibre: attackerRoll.diffLibre,
+      attaqueParticuliere: attackerRoll.particuliere,
+      competence: defender.getCompetence(competenceName).clone(),
+      surprise: defender.getSurprise(true),
+      carac: defender.system.carac,
+      selectedCarac: defender.system.carac[carac],
+      malusTaille: RdDEmpoignade.getMalusTaille(empoignade, defender, attacker),
+      show: {}
+    };
+    await RdDEmpoignade.$rollDefenseEmpoignade(defender, defenderRoll);
+  }
+
+  /* -------------------------------------------- */
+  static async $rollDefenseEmpoignade(defender, defenderRoll) {
+    const dialog = await RdDRoll.create(defender, defenderRoll,
+      { html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-defense-empoignade.html' },
+      {
+        name: 'empoignade',
+        label: 'Contrer',
+        callbacks: [
+          { action: async (r) => await RdDEmpoignade.$onRollContrerLiberer(r) }
+        ]
+      }
+    );
+    dialog.render(true);
+  }
+
+  /* -------------------------------------------- */
+  static async $onRollContrerLiberer(rollData) {
+    let empoignade = rollData.empoignade
+    
+    if (rollData.mode == "contrer-empoigner" && !rollData.rolled.isSuccess) {
+      empoignade.system.pointsemp++
+      RdDEmpoignade.$updateEtatEmpoignade(empoignade)
+    }
+    if (rollData.mode == "contrer-liberer" && !rollData.rolled.isSuccess) {
+      empoignade.system.pointsemp--
+      RdDEmpoignade.$updateEtatEmpoignade(empoignade)
+    }
+    
+    await RdDResolutionTable.displayRollData(rollData, rollData.defender, 'chat-empoignade-resultat.html')
+    if (empoignade.system.pointsemp >= 2) {
+      let msg = await RdDResolutionTable.displayRollData(rollData, rollData.attacker, 'chat-empoignade-entrainer.html');
+      RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
+    }
+  }
+
+  /* -------------------------------------------- */
+  static async $updateEtatEmpoignade(empoignade) {
+    console.log("UPDATE Empoignade", empoignade)
+
+    let defender = game.actors.get(empoignade.system.empoigneid)
+    let emp = RdDEmpoignade.getEmpoignadeById(defender, empoignade.system.empoignadeid)
+    let update = { _id: emp._id, "system.pointsemp": empoignade.system.pointsemp, "system.ausol": empoignade.system.ausol }
+    await defender.updateEmbeddedDocuments('Item', [update])
+
+    let attacker = game.actors.get(empoignade.system.empoigneurid)
+    emp = RdDEmpoignade.getEmpoignadeById(attacker, empoignade.system.empoignadeid)
+    update = { _id: emp._id, "system.pointsemp": empoignade.system.pointsemp, "system.ausol": empoignade.system.ausol }
+    await attacker.updateEmbeddedDocuments('Item', [update])
+  }
+
+  /* -------------------------------------------- */
+  static async $deleteEmpoignade(empoignade) {
+    console.log("DELETE Empoignade", empoignade)
+
+    let defender = game.actors.get(empoignade.system.empoigneid)
+    let emp = RdDEmpoignade.getEmpoignadeById(defender, empoignade.system.empoignadeid)
+    await defender.deleteEmbeddedDocuments('Item', [emp._id])
+  }
+
+  /* -------------------------------------------- */
+  static async entrainerAuSol(rollData) {
+    let attacker = game.actors.get(rollData.attacker.id)
+    let defender = game.actors.get(rollData.defender.id)
+    if (!RdDEmpoignade.isActionAutorisee("immobilise", attacker, defender)) {
+      return
+    }
+    let empoignade = this.getEmpoignade(attacker, defender)
+
+    empoignade.system.ausol = true
+    await this.$updateEtatEmpoignade(empoignade)
+
+    await attacker.setEffect(STATUSES.StatusProne, true);
+    await defender.setEffect(STATUSES.StatusProne, true);
+
+    let msg = await RdDResolutionTable.displayRollData(rollData, attacker, 'chat-empoignade-entrainer-sol.html');
+    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
+  }
+
+  /* -------------------------------------------- */
+  static async projeterAuSol(rollData) {
+    let attacker = game.actors.get(rollData.attacker.id)
+    let defender = game.actors.get(rollData.defender.id)
+    if (!RdDEmpoignade.isActionAutorisee("immobilise", attacker, defender)) {
+      return
+    }
+    let empoignade = this.getEmpoignade(attacker, defender)
+
+    await defender.setEffect(STATUSES.StatusProne, true);
+    await this.$deleteEmpoignade(empoignade)
+
+    let msg = await RdDResolutionTable.displayRollData(rollData, attacker, 'chat-empoignade-projeter-sol.html');
+    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
+  }
+
+  /* -------------------------------------------- */
+  static async perteEndurance(rollData, perteMode) {
+    let attacker = game.actors.get(rollData.attacker.id)
+    let defender = game.actors.get(rollData.defender.id)
+    if (!RdDEmpoignade.isActionAutorisee("immobilise", attacker, defender)) {
+      return
+    }
+    let empoignade = this.getEmpoignade(attacker, defender)
+
+    //console.log("Perte d'endurance :!!!", perteMode)
+    let endValue = defender.system.sante.endurance.value
+    if (perteMode == "end0") {
+      await defender.santeIncDec("endurance", -endValue);
+    }
+    if (perteMode == "end1") {
+      await defender.santeIncDec("endurance", -(endValue - 1));
+    }
+    if (perteMode == "endmoitie") {
+      await defender.santeIncDec("endurance", -Math.floor(endValue / 2));
+    }
+    if (perteMode == "endquart") {
+      await defender.santeIncDec("endurance", -(3 * Math.floor(endValue / 4)));
+    }
+    let msg = await RdDResolutionTable.displayRollData(rollData, attacker, 'chat-empoignade-perte-endurance.html');
+    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
+  }
+
+  /* -------------------------------------------- */
+  static async deleteAllEmpoignades() {
+    for (let actor of game.actors) {
+      let empIds = actor.itemTypes["empoignade"].map(it => it.id)
+      await actor.deleteEmbeddedDocuments('Item', empIds)
+    }
+  }
+
+  /* -------------------------------------------- */
+  static async deleteLinkedEmpoignade(actorId, empoignade) {
+    let actorDeleteId = (actorId == empoignade.system.empoigneurid) ? empoignade.system.empoigneid : empoignade.system.empoigneurid
+    let actor = game.actors.get(actorDeleteId)
+    let emp = this.getEmpoignadeById(actor, empoignade.system.empoignadeid)
+    if (emp) {
+      await actor.deleteEmbeddedDocuments('Item', [emp._id])
+    }
+  }
+
+  /* -------------------------------------------- */
+  static async createEmpoignade(attacker, defender) {
+    return await Item.create({
+      name: "Empoignade en cours de " + attacker.name + ' sur ' + defender.name,
+      type: 'empoignade',
+      img: "systems/foundryvtt-reve-de-dragon/icons/entites/possession2.webp",
+      system: { description: "", empoignadeid: randomID(16), compteempoigne: 0, empoigneurid: attacker.id, empoigneid: defender.id, ptsemp: 0, empoigneurname: attacker.name, empoignename: defender.name }
+    },
+      {
+        temporary: true
+      })
+  }
+}

module/rdd-herbes.js

@@ -1,7 +1,6 @@
-import { RdDUtility } from "./rdd-utility.js";
-import { RdDCalendrier } from "./rdd-calendrier.js";
 import { Grammar } from "./grammar.js";
 import { SystemCompendiums } from "./settings/system-compendiums.js";
+import { RdDTimestamp } from "./time/rdd-timestamp.js";
 
 /* -------------------------------------------- */
 export class RdDHerbes extends Item {
@@ -29,7 +28,7 @@ export class RdDHerbes extends Item {
   }
 
   /* -------------------------------------------- */
-  static async updatePotionData(formData) {
+  static async addPotionFormData(formData) {
     formData.isSoins = formData.system.categorie.includes('Soin');
     formData.isRepos = formData.system.categorie.includes('Repos');
     if (formData.isSoins) {
@@ -40,9 +39,8 @@ export class RdDHerbes extends Item {
     }
     formData.herbesSoins = RdDHerbes.buildHerbesList(this.herbesSoins, 12);
     formData.herbesRepos = RdDHerbes.buildHerbesList(this.herbesRepos, 7);
-    formData.jourMoisOptions = RdDCalendrier.buildJoursMois();
-    formData.dateActuelle = game.system.rdd.calendrier.getDateFromIndex();
-    formData.splitDate = game.system.rdd.calendrier.getDayMonthFromIndex(formData.system.prdate);
+    formData.dateActuelle = game.system.rdd.calendrier.dateCourante();
+    formData.enchantement = RdDTimestamp.splitIndexDate(formData.system.prdate);
   }
 
   /* -------------------------------------------- */

module/rdd-main.js

@@ -1,41 +1,64 @@
 import { SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
-import { RdDActor } from "./actor.js";
-import { RdDItemSheet } from "./item-sheet.js";
-import { RdDActorSheet } from "./actor-sheet.js";
-import { RdDActorCreatureSheet } from "./actor-creature-sheet.js";
-import { RdDActorVehiculeSheet } from "./actor-vehicule-sheet.js";
-import { RdDActorEntiteSheet } from "./actor-entite-sheet.js";
+import { Migrations } from './migrations.js';
+
 import { RdDUtility } from "./rdd-utility.js";
 import { TMRUtility } from "./tmr-utility.js";
-import { RdDCalendrier } from "./rdd-calendrier.js";
+import { TMRRencontres } from "./tmr-rencontres.js";
+import { RdDCalendrier } from "./time/rdd-calendrier.js";
+import { RdDTimestamp } from "./time/rdd-timestamp.js";
+import { DialogChronologie } from "./dialog-chronologie.js";
+
 import { RdDResolutionTable } from "./rdd-resolution-table.js";
 import { RdDTokenHud } from "./rdd-token-hud.js";
 import { RdDCommands } from "./rdd-commands.js";
 import { RdDCombatManager, RdDCombat } from "./rdd-combat.js";
 import { ChatUtility } from "./chat-utility.js";
 import { StatusEffects } from "./settings/status-effects.js";
-import { RddCompendiumOrganiser } from "./rdd-compendium-organiser.js";
+import { RdDCompendiumOrganiser } from "./rdd-compendium-organiser.js";
 import { ReglesOptionelles } from "./settings/regles-optionelles.js";
 import { RdDHotbar } from "./rdd-hotbar-drop.js"
 import { EffetsDraconiques } from "./tmr/effets-draconiques.js";
 import { RdDHerbes } from "./rdd-herbes.js";
-import { RdDItem } from "./item.js";
 import { RdDDice } from "./rdd-dice.js";
 import { RdDPossession } from "./rdd-possession.js";
-import { RdDSigneDraconiqueItemSheet } from "./item-signedraconique-sheet.js";
 import { Misc } from "./misc.js";
-import { Migrations } from './migrations.js';
-import { DialogChronologie } from "./dialog-chronologie.js";
+
 import { SystemCompendiums } from "./settings/system-compendiums.js";
-import { RdDRencontreItemSheet } from "./item-rencontre-sheet.js";
-import { TMRRencontres } from "./tmr-rencontres.js";
-import { RdDHerbeItemSheet } from "./item-herbe-sheet.js";
 import { Environnement } from "./environnement.js";
-import { RdDIngredientItemSheet } from "./item-ingredient-sheet.js";
-import { RdDFauneItemSheet } from "./item-faune-sheet.js";
-import { RdDConteneurItemSheet } from "./item-conteneur-sheet.js";
-import { RdDServiceItemSheet } from "./item-service-sheet.js";
-import { RdDItemService } from "./item-service.js";
+
+import { RdDActor } from "./actor.js";
+import { RdDBaseActor } from "./actor/base-actor.js";
+import { RdDCommerce } from "./actor/commerce.js";
+import { RdDActorSheet } from "./actor-sheet.js";
+import { RdDCommerceSheet } from "./actor/commerce-sheet.js";
+import { RdDActorCreatureSheet } from "./actor-creature-sheet.js";
+import { RdDActorVehiculeSheet } from "./actor-vehicule-sheet.js";
+import { RdDActorEntiteSheet } from "./actor-entite-sheet.js";
+
+import { RdDItem } from "./item.js";
+import { RdDItemBlessure } from "./item/blessure.js";
+import { RdDItemService } from "./item/service.js";
+import { RdDItemMaladie } from "./item/maladie.js";
+import { RdDItemPoison } from "./item/poison.js";
+import { RdDItemSigneDraconique } from "./item/signedraconique.js";
+import { RdDItemQueue } from "./item/queue.js";
+import { RdDItemOmbre } from "./item/ombre.js";
+import { RdDItemSouffle } from "./item/souffle.js";
+import { RdDRencontre } from "./item/rencontre.js";
+
+import { RdDItemSheet } from "./item-sheet.js";
+import { RdDBlessureItemSheet } from "./item/sheet-blessure.js";
+import { RdDServiceItemSheet } from "./item/sheet-service.js";
+import { RdDRencontreItemSheet } from "./item/sheet-rencontre.js";
+import { RdDHerbeItemSheet } from "./item/sheet-herbe.js";
+import { RdDPlanteItemSheet } from "./item/sheet-plante.js";
+import { RdDIngredientItemSheet } from "./item/sheet-ingredient.js";
+import { RdDFauneItemSheet } from "./item/sheet-faune.js";
+import { RdDConteneurItemSheet } from "./item/sheet-conteneur.js";
+import { RdDSigneDraconiqueItemSheet } from "./item/sheet-signedraconique.js";
+import { RdDItemInventaireSheet } from "./item/sheet-base-inventaire.js";
+import { AppAstrologie } from "./sommeil/app-astrologie.js";
+import { RdDItemArmure } from "./item/armure.js";
 
 /**
  * RdD system
@@ -54,9 +77,23 @@ export class SystemReveDeDragon {
     this.RdDUtility = RdDUtility;
     this.RdDHotbar = RdDHotbar;
     this.itemClasses = {
-      service: RdDItemService
+      armure: RdDItemArmure,
+      blessure: RdDItemBlessure,
+      maladie: RdDItemMaladie,
+      ombre: RdDItemOmbre,
+      poison: RdDItemPoison,
+      queue: RdDItemQueue,
+      rencontre: RdDRencontre,
+      service: RdDItemService,
+      signedraconique: RdDItemSigneDraconique,
+      souffle: RdDItemSouffle,
     }
     this.actorClasses = {
+      commerce: RdDCommerce,
+      creature: RdDActor,
+      entite: RdDActor,
+      personnage: RdDActor,
+      vehicule: RdDActor,
     }
   }
 
@@ -65,6 +102,8 @@ export class SystemReveDeDragon {
   /* -------------------------------------------- */
   async onInit() {
     game.system.rdd = this;
+    this.AppAstrologie = AppAstrologie;
+
 
     console.log(`Initializing Reve de Dragon System`);
 
@@ -72,13 +111,107 @@ export class SystemReveDeDragon {
     RdDUtility.preloadHandlebarsTemplates();
 
     /* -------------------------------------------- */
+    this.initSystemSettings();
+
+    /* -------------------------------------------- */
+    // Set an initiative formula for the system 
+    CONFIG.Combat.initiative = {
+      formula: "1+(1d6/10)",
+      decimals: 2
+    };
+
+    /* -------------------------------------------- */
+    game.socket.on(SYSTEM_SOCKET_ID, async (sockmsg) => {
+      console.log(">>>>> MSG RECV", sockmsg);
+      try {
+        RdDUtility.onSocketMessage(sockmsg);
+        RdDCombat.onSocketMessage(sockmsg);
+        ChatUtility.onSocketMessage(sockmsg);
+        RdDBaseActor.onSocketMessage(sockmsg);
+      } catch (e) {
+        console.error('game.socket.on(SYSTEM_SOCKET_ID) Exception: ', sockmsg, ' => ', e)
+      }
+    });
+
+    /* -------------------------------------------- */
+    // Define custom Entity classes
+    CONFIG.Actor.documentClass = RdDBaseActor;
+    CONFIG.Item.documentClass = RdDItem;
+    CONFIG.RDD = {
+      resolutionTable: RdDResolutionTable.resolutionTable,
+      carac_array: RdDUtility.getCaracArray(),
+      ajustementsConditions: RdDUtility.getAjustementsConditions(),
+      difficultesLibres: RdDUtility.getDifficultesLibres()
+    }
+
+    /* -------------------------------------------- */
+    // Register sheet application classes
+    Actors.unregisterSheet("core", ActorSheet);
+    Actors.registerSheet(SYSTEM_RDD, RdDCommerceSheet, { types: ["commerce"], makeDefault: true });
+    Actors.registerSheet(SYSTEM_RDD, RdDActorSheet, { types: ["personnage"], makeDefault: true });
+    Actors.registerSheet(SYSTEM_RDD, RdDActorCreatureSheet, { types: ["creature"], makeDefault: true });
+    Actors.registerSheet(SYSTEM_RDD, RdDActorVehiculeSheet, { types: ["vehicule"], makeDefault: true });
+    Actors.registerSheet(SYSTEM_RDD, RdDActorEntiteSheet, { types: ["entite"], makeDefault: true });
+    Items.unregisterSheet("core", ItemSheet);
+
+    RdDItemSheet.register(RdDSigneDraconiqueItemSheet);
+    RdDItemSheet.register(RdDRencontreItemSheet);
+    RdDItemSheet.register(RdDConteneurItemSheet);
+    RdDItemSheet.register(RdDHerbeItemSheet);
+    RdDItemSheet.register(RdDFauneItemSheet);
+    RdDItemSheet.register(RdDPlanteItemSheet);
+    RdDItemSheet.register(RdDIngredientItemSheet);
+    RdDItemSheet.register(RdDServiceItemSheet);
+    RdDItemSheet.register(RdDBlessureItemSheet);
+
+    Items.registerSheet(SYSTEM_RDD, RdDItemInventaireSheet, {
+      types: [
+        "objet", "arme", "armure", "livre", "potion", "munition",
+        "monnaie", "nourritureboisson", "gemme",
+      ], makeDefault: true
+    });
+    Items.registerSheet(SYSTEM_RDD, RdDItemSheet, {
+      types: [
+        "competence", "competencecreature",
+        "recettealchimique", "musique", "chant", "danse", "jeu", "recettecuisine", "oeuvre",
+        "meditation", "queue", "ombre", "souffle", "tete", "casetmr", "sort", "sortreserve",
+        "nombreastral", "tache", "maladie", "poison", "possession",
+        "tarot", "extraitpoetique", "empoignade"
+      ], makeDefault: true
+    });
+    CONFIG.Combat.documentClass = RdDCombatManager;
+
+    // préparation des différents modules
+    RdDTimestamp.init();
+    RdDCalendrier.init();
+    SystemCompendiums.init();
+    DialogChronologie.init();
+    ReglesOptionelles.init();
+    RdDUtility.init();
+    RdDDice.init();
+    RdDCommands.init();
+    RdDCombatManager.init();
+    RdDTokenHud.init();
+    RdDBaseActor.init();
+    RdDCompendiumOrganiser.init();
+    EffetsDraconiques.init()
+    TMRUtility.init();
+    RdDHotbar.initDropbar();
+    RdDPossession.init();
+    TMRRencontres.init();
+    Environnement.init();
+
+    Hooks.once('ready', () => this.onReady());
+  }
+
+  initSystemSettings() {
     game.settings.register(SYSTEM_RDD, "accorder-entite-cauchemar", {
       name: "Accorder le rêve aux entités",
       hint: "A quel moment les personnages doivent accorder leur rêve aux entités de cauchemar",
       scope: "world",
       config: true,
       type: String,
-      choices: {           // If choices are defined, the resulting setting will be a select menu
+      choices: {
         "avant-attaque": "Avant l'attaque",
         "avant-defense": "Avant la défense",
         "avant-encaissement": "Avant l'encaissement",
@@ -86,34 +219,6 @@ export class SystemReveDeDragon {
       default: "avant-encaissement"
     });
 
-    /* -------------------------------------------- */
-    game.settings.register(SYSTEM_RDD, "calendrier", {
-      name: "calendrier",
-      scope: "world",
-      config: false,
-      default: RdDCalendrier.createCalendrierInitial(),
-      type: Object
-    });
-
-    /* -------------------------------------------- */
-    game.settings.register(SYSTEM_RDD, "liste-nombre-astral", {
-      name: "liste-nombre-astral",
-      scope: "world",
-      config: false,
-      default: [],
-      type: Object
-    });
-
-    /* -------------------------------------------- */
-    game.settings.register(SYSTEM_RDD, "calendrier-pos", {
-      name: "calendrierPos",
-      scope: "client",
-      config: false,
-      default: RdDCalendrier.createCalendrierPos(),
-      type: Object
-    });
-
-
     /* -------------------------------------------- */
     game.settings.register(SYSTEM_RDD, "supprimer-dialogues-combat-chat", {
       name: "Supprimer les dialogues de combat",
@@ -123,6 +228,7 @@ export class SystemReveDeDragon {
       default: true,
       type: Boolean
     });
+
     /* -------------------------------------------- */
     game.settings.register(SYSTEM_RDD, "activer-sons-audio", {
       name: "Activer les bruitages intégrés",
@@ -146,88 +252,6 @@ export class SystemReveDeDragon {
       },
       default: "aucun"
     });
-
-    /* -------------------------------------------- */
-    // Set an initiative formula for the system 
-    CONFIG.Combat.initiative = {
-      formula: "1+(1d6/10)",
-      decimals: 2
-    };
-
-    /* -------------------------------------------- */
-    game.socket.on(SYSTEM_SOCKET_ID, async (sockmsg) => {
-      console.log(">>>>> MSG RECV", sockmsg);
-      try {
-        RdDUtility.onSocketMessage(sockmsg);
-        RdDCombat.onSocketMessage(sockmsg);
-        ChatUtility.onSocketMessage(sockmsg);
-        RdDActor.onSocketMessage(sockmsg);
-      } catch (e) {
-        console.error('game.socket.on(SYSTEM_SOCKET_ID) Exception: ', sockmsg, ' => ', e)
-      }
-    });
-
-    /* -------------------------------------------- */
-    // Define custom Entity classes
-    CONFIG.Actor.documentClass = RdDActor;
-    CONFIG.Item.documentClass = RdDItem;
-    CONFIG.RDD = {
-      resolutionTable: RdDResolutionTable.resolutionTable,
-      carac_array: RdDUtility.getCaracArray(),
-      ajustementsConditions: RdDUtility.getAjustementsConditions(),
-      difficultesLibres: RdDUtility.getDifficultesLibres()
-    }
-
-    /* -------------------------------------------- */
-    // Register sheet application classes
-    Actors.unregisterSheet("core", ActorSheet);
-    Actors.registerSheet(SYSTEM_RDD, RdDActorSheet, { types: ["personnage"], makeDefault: true });
-    Actors.registerSheet(SYSTEM_RDD, RdDActorCreatureSheet, { types: ["creature"], makeDefault: true });
-    Actors.registerSheet(SYSTEM_RDD, RdDActorVehiculeSheet, { types: ["vehicule"], makeDefault: true });
-    Actors.registerSheet(SYSTEM_RDD, RdDActorEntiteSheet, { types: ["entite"], makeDefault: true });
-    Items.unregisterSheet("core", ItemSheet);
-
-    RdDItemSheet.register(RdDSigneDraconiqueItemSheet);
-    RdDItemSheet.register(RdDRencontreItemSheet);
-    RdDItemSheet.register(RdDConteneurItemSheet);
-    RdDItemSheet.register(RdDHerbeItemSheet);
-    RdDItemSheet.register(RdDFauneItemSheet);
-    RdDItemSheet.register(RdDIngredientItemSheet);
-    RdDItemSheet.register(RdDServiceItemSheet);
-
-    Items.registerSheet(SYSTEM_RDD, RdDItemSheet, {
-      types: [
-        "competence", "competencecreature",
-        "recettealchimique", "musique", "chant", "danse", "jeu", "recettecuisine", "oeuvre",
-        "objet", "arme", "armure", "livre", "potion", "munition",
-        "monnaie", "nourritureboisson", "gemme",
-        "meditation", "queue", "ombre", "souffle", "tete", "casetmr", "sort", "sortreserve",
-        "nombreastral", "tache", "maladie", "poison", "possession",
-        "tarot", "extraitpoetique"
-      ], makeDefault: true
-    });
-    CONFIG.Combat.documentClass = RdDCombatManager;
-
-    // préparation des différents modules
-    SystemCompendiums.init();
-    DialogChronologie.init();
-    ReglesOptionelles.init();
-    RdDUtility.init();
-    RdDDice.init();
-    RdDCommands.init();
-    RdDCombat.init();
-    RdDCombatManager.init();
-    RdDTokenHud.init();
-    RdDActor.init();
-    RddCompendiumOrganiser.init();
-    EffetsDraconiques.init()
-    TMRUtility.init();
-    RdDHotbar.initDropbar();
-    RdDPossession.init();
-    TMRRencontres.init();
-    Environnement.init();
-
-    Hooks.once('ready', () => this.onReady());
   }
 
   async onReady() {
@@ -240,9 +264,11 @@ export class SystemReveDeDragon {
       let sidebar = document.getElementById("sidebar");
       sidebar.style.width = "min-content";
     }
-  
+    game.system.rdd.calendrier = new RdDCalendrier();
     if (Misc.isUniqueConnectedGM()) {
       new Migrations().migrate();
+      this.messageDeBienvenue();
+      this.registerUsageCount(SYSTEM_RDD);
     }
 
     StatusEffects.onReady();
@@ -250,14 +276,7 @@ export class SystemReveDeDragon {
     RdDDice.onReady();
     /* -------------------------------------------- */
     /* Affiche/Init le calendrier */
-    let calendrier = new RdDCalendrier();
-    let templatePath = "systems/foundryvtt-reve-de-dragon/templates/calendar-template.html";
-    let templateData = {};
-    renderTemplate(templatePath, templateData).then(html => {
-      calendrier.render(true);
-    });
-    game.system.rdd.calendrier = calendrier; // Reference;
-
+    game.system.rdd.calendrier.display();
     // Avertissement si joueur sans personnage
     if (!game.user.isGM && game.user.character == undefined) {
       ui.notifications.info("Attention ! Vous n'êtes connecté à aucun personnage !");
@@ -266,14 +285,10 @@ export class SystemReveDeDragon {
         user: game.user.id
       });
     }
-    if (Misc.isUniqueConnectedGM()) {
-      this.messageDeBienvenue();
-      this.registerUsageCount(SYSTEM_RDD);
-    }
   }
-  
+
   /* -------------------------------------------- */
-   messageDeBienvenue() {
+  messageDeBienvenue() {
     if (game.user.isGM) {
       ChatUtility.removeChatMessageContaining('<div id="message-bienvenue-rdd">');
       ChatMessage.create({

module/rdd-namegen.js

@@ -1,4 +1,4 @@
-import { RdDActor } from "./actor.js";
+import { RdDBaseActor } from "./actor/base-actor.js";
 import { Misc } from "./misc.js";
 import { RdDDice } from "./rdd-dice.js";
 
@@ -20,7 +20,7 @@ export class RdDNameGen {
 
   static async onCreerActeur(event) {
     const button = event.currentTarget;
-    await RdDActor.create({
+    await RdDBaseActor.create({
         name: button.attributes['data-nom'].value,
         type: button.attributes['data-type'].value
       },

module/rdd-possession.js

@@ -1,9 +1,9 @@
 /* -------------------------------------------- */
-import { RdDCombat } from "./rdd-combat.js";
 import { RdDResolutionTable } from "./rdd-resolution-table.js";
 import { RdDRoll } from "./rdd-roll.js";
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
 import { Targets } from "./targets.js";
+import { TYPES } from "./item.js";
 
 /* -------------------------------------------- */
 /* On part du principe qu'une entité démarre tjs 
@@ -20,9 +20,9 @@ export class RdDPossession {
 
   /* -------------------------------------------- */
   static searchPossessionFromEntite(attacker, defender) {
-    let poss = attacker.items.find(poss => poss.type == 'possession' && poss.system.possedeid == defender.id);
+    let poss = attacker.items.find(poss => poss.type == TYPES.possession && poss.system.victime.actorid == defender.id);
     if (!poss) {
-      poss = defender.items.find(poss => poss.type == 'possession' && poss.system.possedeid == defender.id);
+      poss = defender.items.find(poss => poss.type == TYPES.possession && poss.system.victime.actorid == defender.id);
     }
     return poss && duplicate(poss) || undefined;
   }
@@ -31,39 +31,40 @@ export class RdDPossession {
   static async onAttaquePossession(target, attacker, competence, suitePossession = undefined) {
     const defender = target.actor;
     const fromEntite = RdDPossession.searchPossessionFromEntite(attacker, defender);
-    const isNouvelle = !suitePossession && ! fromEntite;
+    const isNouvelle = !suitePossession && !fromEntite;
     const possession = (suitePossession ?? fromEntite ?? (await RdDPossession.createPossession(attacker, defender)));
-    
+
     RdDPossession.$updateEtatPossession(possession)
 
     let rollData = {
-      mode: "possession",
+      mode: "attaque",
       isECNIDefender: false,
-      competence: competence,
+      competence: competence.clone(),
       possession: possession,
       attacker: attacker,
       defender: defender,
       targetToken: Targets.extractTokenData(target)
     };
-    if (attacker.isCreatureEntite()) {
-      RdDItemCompetenceCreature.setRollDataCreature(rollData)
-    }
-    
+    RdDPossession.selectCompetenceDraconicOuPossession(rollData, attacker)
+
     await RdDPossession.$rollAttaquePossession(attacker, rollData, isNouvelle);
   }
-  
+
   /* -------------------------------------------- */
-  static async onConjurerPossession(attacker, competence, possession) {
+  static async onConjurerPossession(attacker, possession) {
     possession = duplicate(possession);
     RdDPossession.$updateEtatPossession(possession)
+
+    const defender = game.actors.get(possession.system.entite.actorid);
     let rollData = {
-      mode: "possession",
+      mode: "attaque",
       isECNIDefender: true,
-      competence: competence,
       possession: possession,
       attacker: attacker,
-      defender: game.actors.get(possession.system.possesseurid)
+      defender: defender,
     };
+    RdDPossession.selectCompetenceDraconicOuPossession(rollData, attacker)
+
     await RdDPossession.$rollAttaquePossession(attacker, rollData);
   }
 
@@ -71,7 +72,7 @@ export class RdDPossession {
   static async onDefensePossession(attackerId, defenderId, possessionId) {
     let attacker = game.actors.get(attackerId)
     let possession = attacker?.getPossession(possessionId)
-    defenderId = defenderId ?? possession?.system.possesseurid ?? undefined
+    defenderId = defenderId ?? possession?.system.entite.actorid ?? undefined
     let defender = game.actors.get(defenderId)
     possession = possession ?? defender?.getPossession(possessionId) ?? undefined;
 
@@ -82,19 +83,29 @@ export class RdDPossession {
     possession = duplicate(possession)
     // Update for draconic roll
     let rollData = {
-      mode: "conjuration",
+      mode: "defense",
       isECNIDefender: defender.type == "entite",
       possession: possession,
       attacker: attacker,
       defender: defender,
-      competence: defender.getDraconicOuPossession(),
-      selectedCarac: defender.system.carac.reve,
-      forceCarac: { 'reve-actuel': { label: "Rêve Actuel", value: defender.getReveActuel() } }
     }
-    rollData.competence.system.defaut_carac = 'reve-actuel'
-
+    RdDPossession.selectCompetenceDraconicOuPossession(rollData, defender)
+    rollData.diffLibre = RdDPossession.getInfoAttaque(rollData).diffLibre
+    
     await RdDPossession.$rollDefensePossession(defender, rollData);
   }
+  
+  static selectCompetenceDraconicOuPossession(rollData, rollingActor) {
+    rollData.competence = rollingActor.getDraconicOuPossession();
+    if (rollingActor.isCreatureEntite()) {
+      RdDItemCompetenceCreature.setRollDataCreature(rollData)
+    }
+    else {
+      rollData.selectedCarac = rollingActor.system.carac.reve
+      rollData.forceCarac = { 'reve-actuel': { label: "Rêve Actuel", value: rollingActor.getReveActuel() } }
+      rollData.competence.system.defaut_carac = 'reve-actuel'
+    }
+  }
 
   /* -------------------------------------------- */
   static async $rollAttaquePossession(attacker, rollData, isNouvelle = false) {
@@ -104,21 +115,22 @@ export class RdDPossession {
         name: 'jet-possession',
         label: rollData.isECNIDefender ? 'Conjurer la possession' : 'Possession',
         callbacks: [
-          { condition: r => (r.rolled.isSuccess), action: async (r) => await RdDPossession.$onRollPossession(r, true, isNouvelle) },
-          { condition: r => (r.rolled.isEchec), action: async (r) => await RdDPossession.$onRollPossession(r, false, isNouvelle) },
+          { action: async (r) => await RdDPossession.$onRollPossession(r, isNouvelle) },
         ]
       });
-      dialog.render(true);
+    dialog.render(true);
   }
 
   /* -------------------------------------------- */
-  static async $onRollPossession(rollData, isSuccess, isNouvelle = false) {
-    rollData.possession.isSuccess = isSuccess;
-    RdDPossession.$updateEtatPossession(rollData.possession);
+  static async $onRollPossession(rollData, isNouvelle = false) {
+    rollData.possession.isSuccess = rollData.rolled.isSuccess;
+    RdDPossession.$updateEtatPossession(rollData.possession, rollData);
     if (isNouvelle) {
       // Creer la possession sur le defenseur
-      rollData.defender.createEmbeddedDocuments('Item', [rollData.possession.toObject()])
+      await rollData.defender.createEmbeddedDocuments('Item', [rollData.possession.toObject()])
     }
+    const possession = (rollData.isECNIDefender ? rollData.attacker : rollData.defender).getPossession(rollData.possession.system.possessionid)
+    RdDPossession.storePossessionAttaque(possession, rollData)
     await RdDResolutionTable.displayRollData(rollData, rollData.attacker, 'chat-resultat-possession.html');
   }
 
@@ -127,35 +139,42 @@ export class RdDPossession {
     const dialog = await RdDRoll.create(defender, rollData,
       { html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-defense-possession.html' },
       {
-        name: 'conjurer',
+        name: 'possession',
         label: 'Conjurer une Possession',
         callbacks: [
           { action: async (r) => await RdDPossession.$onRollConjuration(r) }
-        ]  
-      }  
-    );  
+        ]
+      }
+    );
     dialog.render(true);
-  }  
+  }
 
   /* -------------------------------------------- */
   static async $onRollConjuration(rollData) {
-    let actor = game.actors.get(rollData.possession.system.possedeid)
+    let victime = game.actors.get(rollData.possession.system.victime.actorid)
+    let compteur = rollData.possession.system.compteur
     if (!rollData.rolled.isSuccess) {
       if (rollData.isECNIDefender) {
-        rollData.possession.system.compteur--
+        compteur--
       } else {
-        rollData.possession.system.compteur++
+        compteur++
       }
-      let update = { _id: rollData.possession._id, "system.compteur": rollData.possession.system.compteur }
-      await actor.updateEmbeddedDocuments('Item', [update])
     }
-
+    const possession = victime.getPossession(rollData.possession.system.possessionid)
+    await possession.update({
+      system: {
+        compteur: compteur,
+        entite: { diffLibre: 0, finesse: false },
+        victime: { diffLibre: 0, finesse: false }
+      }
+    })
+    rollData.possession = possession
     RdDPossession.$updateEtatPossession(rollData.possession)
 
-    await RdDResolutionTable.displayRollData(rollData,rollData.defender, 'chat-resultat-possession.html')
+    await RdDResolutionTable.displayRollData(rollData, rollData.defender, 'chat-resultat-possession.html')
     if (rollData.possession.isPosseder || rollData.possession.isConjurer) {
       // conjuration
-      actor.deleteEmbeddedDocuments("Item", [rollData.possession._id])
+      victime.deleteEmbeddedDocuments("Item", [rollData.possession._id])
     }
   }
 
@@ -180,13 +199,43 @@ export class RdDPossession {
     }
   }
 
+  /* -------------------------------------------- */
+  static isPossessionFinesse(rollData) {
+    return RdDPossession.getInfoAttaque(rollData).finesse
+  }
+  /* -------------------------------------------- */
+  static getInfoAttaque(rollData) {
+    return rollData.possession.system[rollData.isECNIDefender ? 'victime' : 'entite'];
+  }
+  /* -------------------------------------------- */
+  static isDefensePossession(rollData) {
+    return rollData.possession && rollData.mode == "defense"
+  }
+  /* -------------------------------------------- */
+  static storePossessionAttaque(possession, rollData = undefined) {
+    const attaquant = rollData?.isECNIDefender ? 'victime' : 'entite'
+    possession.update({
+      [`system.${attaquant}`]: {
+        diffLibre: rollData?.diffLibre ?? 0,
+        finesse: rollData?.rolled.isPart ?? false
+      }
+    })
+  }
+
   /* -------------------------------------------- */
   static async createPossession(attacker, defender) {
     return await Item.create({
-        name: "Possession en cours de " + attacker.name, type: 'possession',
-        img: "systems/foundryvtt-reve-de-dragon/icons/entites/possession2.webp",
-        system: { description: "", typepossession: attacker.name, possede: false, possessionid: randomID(16), possesseurid: attacker.id, possedeid: defender.id, date: 0, compteur: 0 }
-      },
+      name: "Possession en cours de " + attacker.name, type: 'possession',
+      img: "systems/foundryvtt-reve-de-dragon/icons/entites/possession2.webp",
+      system: {
+        description: "", typepossession: attacker.name,
+        possede: false,
+        possessionid: randomID(16),
+        entite: { actorid: attacker.id },
+        victime: { actorid: defender.id },
+        compteur: 0
+      }
+    },
       {
         temporary: true
       })

module/rdd-resolution-table.js

@@ -91,13 +91,17 @@ export class RdDResolutionTable {
 
   /* -------------------------------------------- */
   static async displayRollData(rollData, actor = undefined, template = 'chat-resultat-general.html') {
-    return await ChatUtility.createChatWithRollMode(actor?.userName ?? game.user.name, {
-      content: await RdDResolutionTable.buildRollDataHtml(rollData, actor, template)
+    return await ChatUtility.createChatWithRollMode(RdDResolutionTable.actorChatName(actor), {
+      content: await RdDResolutionTable.buildRollDataHtml(rollData, template)
     });
   }
 
+  static actorChatName(actor) {
+    return actor?.userName ?? game.user.name;
+  }
+
   /* -------------------------------------------- */
-  static async buildRollDataHtml(rollData, actor, template = 'chat-resultat-general.html') {
+  static async buildRollDataHtml(rollData, template = 'chat-resultat-general.html') {
     rollData.show = rollData.show || {};
     return await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/${template}`, rollData);
   }
@@ -195,17 +199,6 @@ export class RdDResolutionTable {
     return Math.max(Math.floor(carac * (diff + 10) / 2), 1);
   }
 
-  /* -------------------------------------------- */
-  static isAjustementAstrologique(rollData) {
-    if (rollData.selectedCarac?.label.toLowerCase().includes('chance')) {
-      return true;
-    }
-    if (rollData.selectedSort?.system.isrituel) {
-      return true;
-    }
-    return false;
-  }
-
   /* -------------------------------------------- */
   static isEchec(rollData) {
     switch (rollData.surprise) {
@@ -294,12 +287,9 @@ export class RdDResolutionTable {
       carac: carac,
       difficulte: level,
       min: minLevel,
-      rows: RdDResolutionTable.incrementalArray(minCarac, maxCarac),
-      cols: RdDResolutionTable.incrementalArray(minLevel, maxLevel)
+      rows: Misc.intArray(minCarac, maxCarac+1),
+      cols: Misc.intArray(minLevel, maxLevel+1)
     });
   }
-  static incrementalArray(min, max) {
-    return Array.from(Array(max-min+1).keys()).map(i=>i+min)
-  }
 
 }

module/rdd-roll-encaisser.js

@@ -30,9 +30,9 @@ export class RdDEncaisser extends Dialog {
       };
     }
     else if (actor.isEntite([ENTITE_BLURETTE, ENTITE_INCARNE])) {
-      dialogConf.default = "cauchemar"
+      dialogConf.default = "entiteincarnee"
       dialogConf.buttons = {
-        "cauchemar": { label: "Cauchemar", callback: html => this.performEncaisser("cauchemar") }
+        "entiteincarnee": { label: "Entité incarnée", callback: html => this.performEncaisser("entiteincarnee") }
       }
     }
 
@@ -70,7 +70,6 @@ export class RdDEncaisser extends Dialog {
         total: Number(this.modifier),
         ajustement: Number(this.modifier),
         encaisserSpecial: this.encaisserSpecial,
-        loc: { result: 0, label: "" },
         mortalite: mortalite
       }
     });

module/rdd-roll.js

@@ -276,11 +276,11 @@ export class RdDRoll extends Dialog {
     const diffVariable = RdDItemSort.isDifficulteVariable(sort);
     const coutVariable = RdDItemSort.isCoutVariable(sort);
 
-    HtmlUtility._showControlWhen(this.html.find(".div-sort-non-rituel"), !sort.system.isrituel);
-    HtmlUtility._showControlWhen(this.html.find(".div-sort-difficulte-var"), diffVariable);
-    HtmlUtility._showControlWhen(this.html.find(".div-sort-difficulte-fixe"), !diffVariable);
-    HtmlUtility._showControlWhen(this.html.find(".div-sort-ptreve-var"), coutVariable);
-    HtmlUtility._showControlWhen(this.html.find(".div-sort-ptreve-fixe"), !coutVariable);
+    HtmlUtility.showControlWhen(this.html.find(".div-sort-non-rituel"), !sort.system.isrituel);
+    HtmlUtility.showControlWhen(this.html.find(".div-sort-difficulte-var"), diffVariable);
+    HtmlUtility.showControlWhen(this.html.find(".div-sort-difficulte-fixe"), !diffVariable);
+    HtmlUtility.showControlWhen(this.html.find(".div-sort-ptreve-var"), coutVariable);
+    HtmlUtility.showControlWhen(this.html.find(".div-sort-ptreve-fixe"), !coutVariable);
   }
 
   async setSelectedSigneDraconique(signe) {
@@ -311,11 +311,11 @@ export class RdDRoll extends Dialog {
     const resolutionTable = await RdDResolutionTable.buildHTMLTable(RdDResolutionTable.subTable(rollData.caracValue, rollData.finalLevel))
     const adjustements = await this.buildAjustements(rollData);
 
-    HtmlUtility._showControlWhen(this.html.find(".use-encTotal"), rollData.ajustements.encTotal.visible && RdDCarac.isAgiliteOuDerivee(rollData.selectedCarac));
-    HtmlUtility._showControlWhen(this.html.find(".use-surenc"), rollData.ajustements.surenc.visible && RdDCarac.isActionPhysique(rollData.selectedCarac));
-    HtmlUtility._showControlWhen(this.html.find(".utilisation-moral"), rollData.use.appelAuMoral);
-    HtmlUtility._showControlWhen(this.html.find(".diffMoral"), rollData.ajustements.moralTotal.used);
-    HtmlUtility._showControlWhen(this.html.find(".divAppelAuMoral"), rollData.use.appelAuMoral);
+    HtmlUtility.showControlWhen(this.html.find(".use-encTotal"), rollData.ajustements.encTotal.visible && RdDCarac.isAgiliteOuDerobee(rollData.selectedCarac));
+    HtmlUtility.showControlWhen(this.html.find(".use-surenc"), rollData.ajustements.surenc.visible && RdDCarac.isActionPhysique(rollData.selectedCarac));
+    HtmlUtility.showControlWhen(this.html.find(".utilisation-moral"), rollData.use.appelAuMoral);
+    HtmlUtility.showControlWhen(this.html.find(".divAppelAuMoral"), rollData.use.appelAuMoral);
+    HtmlUtility.showControlWhen(this.html.find(".diffMoral"), rollData.ajustements.moralTotal.used);
 
     // Mise à jour valeurs
     this.html.find(".dialog-roll-title").text(this._getTitle(rollData));

module/rdd-sheet-utility.js

@@ -1,7 +1,25 @@
 import { DialogSplitItem } from "./dialog-split-item.js";
+import { RdDItem } from "./item.js";
 
 export class RdDSheetUtility {
 
+  static mergeDocumentRights(options, document, editable) {
+    const userRightLevel = game.user.isGM
+      ? CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER
+      : document.getUserLevel(game.user);
+    let newOptions = {
+      isGM: game.user.isGM,
+      isOwned: document.parent ? true : false,
+      editable: editable,
+      cssClass: editable ? "editable" : "locked",
+      isLimited: userRightLevel >= CONST.DOCUMENT_OWNERSHIP_LEVELS.LIMITED,
+      isObserver: userRightLevel >= CONST.DOCUMENT_OWNERSHIP_LEVELS.OBSERVER,
+      isOwner: userRightLevel >= CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER
+    }
+    mergeObject(options, newOptions);
+    return options;
+  }
+
   static getItem(event, actor) {
     return actor.items.get(RdDSheetUtility.getItemId(event))
   }
@@ -19,8 +37,11 @@ export class RdDSheetUtility {
     return $(event.currentTarget)?.parents(".item");
   }
 
-  static prepareItemDropParameters(destItemId, actor, dragData, objetVersConteneur) {
-    const item = fromUuidSync(dragData.uuid)
+  static async prepareItemDropParameters(destItemId, actor, dragData, objetVersConteneur) {
+    let item = fromUuidSync(dragData.uuid);
+    if (item.pack && !item.system) {
+      item = await RdDItem.getCorrespondingItem(item);
+    }
     if (actor.canReceive(item)) {
       return {
         destId: destItemId,

module/rdd-tmr-dialog.js

@@ -15,8 +15,8 @@ import { HtmlUtility } from "./html-utility.js";
 import { ReglesOptionelles } from "./settings/regles-optionelles.js";
 import { RdDDice } from "./rdd-dice.js";
 import { STATUSES } from "./settings/status-effects.js";
-import { RdDRencontre } from "./item-rencontre.js";
-import { RdDCalendrier } from "./rdd-calendrier.js";
+import { RdDRencontre } from "./item/rencontre.js";
+import { RdDTimestamp } from "./time/rdd-timestamp.js";
 
 /* -------------------------------------------- */
 
@@ -207,8 +207,8 @@ export class RdDTMRDialog extends Dialog {
       return;
     }
 
-    HtmlUtility._showControlWhen(this.html.find(".appliquerFatigue"), ReglesOptionelles.isUsing("appliquer-fatigue"));
-    HtmlUtility._showControlWhen(this.html.find(".lire-signe-draconique"), this.actor.isResonanceSigneDraconique(this._getActorCoord()));
+    HtmlUtility.showControlWhen(this.html.find(".appliquerFatigue"), ReglesOptionelles.isUsing("appliquer-fatigue"));
+    HtmlUtility.showControlWhen(this.html.find(".lire-signe-draconique"), this.actor.isResonanceSigneDraconique(this._getActorCoord()));
 
     // Roll Sort
     this.html.find('.lancer-sort').click((event) => {
@@ -245,7 +245,7 @@ export class RdDTMRDialog extends Dialog {
     }
     const coord = this._getActorCoord();
 
-    HtmlUtility._showControlWhen(this.html.find(".lire-signe-draconique"), this.actor.isResonanceSigneDraconique(coord));
+    HtmlUtility.showControlWhen(this.html.find(".lire-signe-draconique"), this.actor.isResonanceSigneDraconique(coord));
 
     let ptsreve = document.getElementById("tmr-pointsreve-value");
     ptsreve.innerHTML = this.actor.system.reve.reve.value;
@@ -284,7 +284,12 @@ export class RdDTMRDialog extends Dialog {
   }
 
   /* -------------------------------------------- */
-  async onActionRencontre(action, tmr) {
+  async onActionRencontre(action, tmr, rencontre) {
+    if (!this.currentRencontre) {
+      ui.notifications.warn("#612 Rencontre perdue, récupération en cours. Vous pouvez contacter l'équipe avec les logs pour aider à résoudre ce problème")
+      console.error("#612 Rencontre perdue", action, tmr, rencontre, this);
+      this.currentRencontre = rencontre;
+    }
     switch (action) {
       case 'derober':
         await this.derober();
@@ -588,6 +593,7 @@ export class RdDTMRDialog extends Dialog {
       return await game.system.rdd.rencontresTMR.getRencontreAleatoire(tmr, this.actor.isMauvaiseRencontre())
     } else {
       this._tellToUser(myRoll + ": Pas de rencontre en " + locTMR);
+      return undefined;
     }
   }
 
@@ -798,19 +804,21 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   async declencheSortEnReserve(coord) {
-    let sorts = this.getSortsReserve(coord);
+    const sorts = this.getSortsReserve(coord);
     if (sorts.length > 0) {
       if (EffetsDraconiques.isSortReserveImpossible(this.actor)) {
         ui.notifications.error("Une queue ou un souffle vous empèche de déclencher de sort!");
         return;
       }
-      if (!EffetsDraconiques.isUrgenceDraconique(this.actor) &&
-        (EffetsDraconiques.isReserveEnSecurite(this.actor) || this.isReserveExtensible(coord))) {
-        let msg = "Vous êtes sur une case avec un Sort en Réserve. Grâce à votre Tête <strong>Reserve en Sécurité</strong> ou <strong>Réserve Exensible</strong>, vous pouvez contrôler le déclenchement. Cliquez si vous souhaitez le déclencher : <ul>";
-        for (let sort of sorts) {
-          msg += `<li><a class="chat-card-button declencher-sort-reserve" data-actor-id="${this.actor.id}" data-tmr-coord="${coord}" data-sort-id='${sort.id}">${sort.name}</a></li>`;
-        }
-        msg += "</ol>";
+      const reserveSecurite = EffetsDraconiques.isReserveEnSecurite(this.actor);
+      const reserveExtensible = this.isReserveExtensible(coord);
+      if (!EffetsDraconiques.isUrgenceDraconique(this.actor) && (reserveSecurite || reserveExtensible)) {
+        const msg = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-demande-declencher-sort.hbs`, {
+          actor: this.actor,
+          sorts: sorts,
+          coord: coord,
+          tete: { reserveSecurite: reserveSecurite, reserveExtensible: reserveExtensible }
+        })
         ChatMessage.create({
           content: msg,
           whisper: ChatMessage.getWhisperRecipients(game.user.name)
@@ -840,7 +848,7 @@ export class RdDTMRDialog extends Dialog {
   async processSortReserve(sortReserve) {
     await this.actor.deleteEmbeddedDocuments('Item', [sortReserve.id]);
     console.log("declencheSortEnReserve", sortReserve);
-    const heureCible = RdDCalendrier.getSigneAs('label', sortReserve.system.heurecible);
+    const heureCible = RdDTimestamp.definition(sortReserve.system.heurecible).label;
     this._tellToUserAndGM(`Vous avez déclenché 
         ${sortReserve.system.echectotal ? "<strong>l'échec total!</strong>" : "le sort"}
         en réserve <strong>${sortReserve.name}</strong>

module/rdd-tmr-rencontre-dialog.js

@@ -29,12 +29,13 @@ export class RdDTMRRencontreDialog extends Dialog {
     this.toClose = false;
     this.tmr = tmr;
     this.tmrApp = tmrApp;
+    this.rencontre = rencontre;
     this.tmrApp.minimize();
   }
 
   async onButtonAction(action) {
     this.toClose = true;
-    this.tmrApp.onActionRencontre(action, this.tmr)
+    this.tmrApp.onActionRencontre(action, this.tmr, this.rencontre)
   }
   
   /* -------------------------------------------- */

module/rdd-token-hud.js

@@ -2,6 +2,7 @@
 import { HtmlUtility } from "./html-utility.js";
 import { Misc } from "./misc.js";
 import { RdDCombatManager } from "./rdd-combat.js";
+import { Targets } from "./targets.js";
 
 /* -------------------------------------------- */
 export class RdDTokenHud {
@@ -18,29 +19,39 @@ export class RdDTokenHud {
   }
 
   /* -------------------------------------------- */
-  static async addExtensionHud(app, html, tokenId) {
+  static async addExtensionHud(app, html, tokenId, isCombat) {
 
     let token = canvas.tokens.get(tokenId);
     let actor = token.actor;
-    let combatant = game.combat.combatants.find(c => c.tokenId == tokenId);
-    if (! (combatant?.actor) ) {
+    app.hasExtension = true;
+    // soins
+    await RdDTokenHud.addExtensionHudSoins(html, actor);
+
+    if (isCombat) {
+      let combatant = game.combat.combatants.find(c => c.tokenId == tokenId);
+      if (!(combatant?.actor)) {
         ui.notifications.warn(`Le combatant ${token.name} n'est pas associé à un acteur, impossible de déterminer ses actions de combat!`)
         return;
+      }
+      let actions = RdDCombatManager.listActionsCombat(combatant);
+      // initiative
+      await RdDTokenHud.addExtensionHudInit(html, combatant, actions);
+      // combat
+      await RdDTokenHud.addExtensionHudCombat(html, combatant, actions);
     }
-    app.hasExtension = true;
 
-    let actionsCombat = RdDCombatManager.listActionsCombat(combatant);
+
+  }
+
+  static async addExtensionHudInit(html, combatant, actions) {
     const hudData = {
-      combatant: combatant,
-      actions: actionsCombat,
+      combatant, actions,
       commandes: [
         { name: "Autre action", command: 'autre' },
-        { name: 'Initiative +1', command: 'inc', value: 0.01 }, 
+        { name: 'Initiative +1', command: 'inc', value: 0.01 },
         { name: 'Initiative -1', command: 'dec', value: -0.01 }]
     };
-
     const controlIconCombat = html.find('.control-icon[data-action=combat]');
-    // initiative
     await RdDTokenHud._configureSubMenu(controlIconCombat,
       'systems/foundryvtt-reve-de-dragon/templates/hud-actor-init.html',
       hudData,
@@ -51,48 +62,70 @@ export class RdDTokenHud {
           RdDTokenHud._initiativeCommand(initCommand, combatantId);
         } else {
           let index = event.currentTarget.attributes['data-action-index'].value;
-          let action = actionsCombat[index];
+          let action = hudData.actions[index];
           RdDCombatManager.rollInitiativeAction(combatantId, action);
-        } 
+        }
       });
+  }
 
+  static async addExtensionHudCombat(html, combatant, actions) {
+    const hudData = { combatant, actions, commandes: [] };
     const controlIconTarget = html.find('.control-icon[data-action=target]');
-    // combat
     await RdDTokenHud._configureSubMenu(controlIconTarget, 'systems/foundryvtt-reve-de-dragon/templates/hud-actor-attaque.html', hudData,
       (event) => {
         const actionIndex = event.currentTarget.attributes['data-action-index']?.value;
-        const action = actionsCombat[actionIndex];
-        if (action.action == 'conjurer') {
-          actor.conjurerPossession(actor.getPossession(action.system.possessionid));
+        const action = hudData.actions[actionIndex];
+        const possession = action.action == 'possession' ? combatant.actor.getPossession(action.system.possessionid) : undefined;
+        if (possession) {
+          combatant.actor.conjurerPossession(possession);
         }
         else {
-          actor.rollArme(action);
+          combatant.actor.rollArme(action);
         }
       });
   }
 
+  static async addExtensionHudSoins(html, sourceActor) {
+    const target = Targets.getTarget({ warn: false });
+    if (target?.actor) {
+      const hudSoins = { blessures: target.actor.blessuresASoigner() ?? [] };
+      if (hudSoins.blessures.length > 0) {
+        // soins
+        const controlIconTarget = html.find('.control-icon[data-action=combat]');
+        await RdDTokenHud._configureSubMenu(controlIconTarget,
+          'systems/foundryvtt-reve-de-dragon/templates/hud-actor-soins.hbs',
+          hudSoins,
+          (event) => {
+            const blessureId = event.currentTarget.attributes['data-blessure-id']?.value;
+            sourceActor.rollSoins(target.actor, blessureId)
+          });
+      }
+    }
+  }
+
   static _initiativeCommand(initCommand, combatantId) {
     switch (initCommand) {
       case 'inc': return RdDCombatManager.incDecInit(combatantId, 0.01);
       case 'dec': return RdDCombatManager.incDecInit(combatantId, -0.01);
-      case 'autre': return RdDCombatManager.rollInitiativeAction(combatantId, 
+      case 'autre': return RdDCombatManager.rollInitiativeAction(combatantId,
         { name: "Autre action", action: 'autre', system: { initOnly: true, competence: "Autre action" } });
     }
   }
 
   /* -------------------------------------------- */
   static async addTokenHudExtensions(app, html, tokenId) {
-    const controlIconCombat  = html.find('.control-icon[data-action=combat]');
-    controlIconCombat.click(event => {
-      if (event.currentTarget.className.includes('active')) {
-        RdDTokenHud.removeExtensionHud(app, html, tokenId);
-      } else {
-        setTimeout(function () { RdDTokenHud.addExtensionHud(app, html, tokenId) }, 200);
-      }
-    });
+    const controlIconCombat = html.find('.control-icon[data-action=combat]');
+    if (controlIconCombat.length > 0) {
+      controlIconCombat.click(event => {
+        if (event.currentTarget.className.includes('active')) {
+          RdDTokenHud.removeExtensionHud(app, html, tokenId);
+        } else {
+          setTimeout(() => RdDTokenHud.addExtensionHud(app, html, tokenId), 200);
+        }
+      });
 
-    if (controlIconCombat.length>0 && controlIconCombat[0].className.includes('active')) {
-      RdDTokenHud.addExtensionHud(app, html, tokenId);
+      const isCombat = controlIconCombat[0].className.includes('active');
+      RdDTokenHud.addExtensionHud(app, html, tokenId, isCombat);
     }
   }
 
@@ -100,9 +133,9 @@ export class RdDTokenHud {
   static async _configureSubMenu(insertionPoint, template, hudData, onMenuItem) {
     const hud = $(await renderTemplate(template, hudData));
     const list = hud.find('div.rdd-hud-list');
-    
+
     RdDTokenHud._toggleHudListActive(hud, list);
-    
+
     hud.find('img.rdd-hud-togglebutton').click(event => RdDTokenHud._toggleHudListActive(hud, list));
     list.find('.rdd-hud-menu').click(onMenuItem);
 
@@ -111,6 +144,6 @@ export class RdDTokenHud {
 
   static _toggleHudListActive(hud, list) {
     hud.toggleClass('active');
-    HtmlUtility._showControlWhen(list, hud.hasClass('active'));
+    HtmlUtility.showControlWhen(list, hud.hasClass('active'));
   }
 }

module/rdd-utility.js

@@ -8,21 +8,22 @@ import { DialogItemAchat } from "./dialog-item-achat.js";
 import { ReglesOptionelles } from "./settings/regles-optionelles.js";
 import { RdDDice } from "./rdd-dice.js";
 import { RdDItem } from "./item.js";
-import { Monnaie } from "./item-monnaie.js";
 import { RdDPossession } from "./rdd-possession.js";
 import { RdDNameGen } from "./rdd-namegen.js";
 import { RdDConfirm } from "./rdd-confirm.js";
-import { RdDCalendrier } from "./rdd-calendrier.js";
-import { Environnement } from "./environnement.js";
 import { RdDItemCompetence } from "./item-competence.js";
 import { RdDResolutionTable } from "./rdd-resolution-table.js";
+import { RdDTimestamp } from "./time/rdd-timestamp.js";
+import { RdDRaretes } from "./item/raretes.js";
+import { RdDEmpoignade } from "./rdd-empoignade.js";
+import { ExperienceLog } from "./actor/experience-log.js";
 
 /* -------------------------------------------- */
 // This table starts at 0 -> niveau -10
 const carac_array = ["taille", "apparence", "constitution", "force", "agilite", "dexterite", "vue", "ouie", "odoratgout", "volonte", "intellect", "empathie", "reve", "chance", "melee", "tir", "lancer", "derobee"];
-const difficultesLibres = [0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10];
-const ajustementsConditions = [-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, +1, +2, +3, +4, +5, +6, +7, +8, +9, +10];
-const ajustementsEncaissement = [-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, +1, +2, +3, +4, +5, +6, +7, +8, +9, +10, +11, +12, +13, +14, +15, +16, +17, +18, +19, +20, +21, +22, +23, +24, +25];
+const difficultesLibres = Misc.intArray(0, -11);
+const ajustementsConditions = Misc.intArray(-10, 11);
+const ajustementsEncaissement = Misc.intArray(-10, 26);
 
 /* -------------------------------------------- */
 function _buildAllSegmentsFatigue(max) {
@@ -67,38 +68,31 @@ const fatigueMarche = {
   "tresdifficile": { "4": 4, "6": 6 }
 }
 
-/* -------------------------------------------- */
-const definitionsBlessures = [
-  { type: "legere", facteur: 2 },
-  { type: "grave", facteur: 4 },
-  { type: "critique", facteur: 6 }
-]
-
 /* -------------------------------------------- */
 const nomEthylisme = ["Emeché", "Gris", "Pinté", "Pas frais", "Ivre", "Bu", "Complètement fait", "Ivre mort"];
 
 /* -------------------------------------------- */
 const definitionsEncaissement = {
   "mortel": [
-    { minimum: undefined, maximum: 0, endurance: "0", vie: "0", eraflures: 0, legeres: 0, graves: 0, critiques: 0 },
-    { minimum: 1, maximum: 10, endurance: "1d4", vie: "0", eraflures: 1, legeres: 0, graves: 0, critiques: 0 },
-    { minimum: 11, maximum: 15, endurance: "1d6", vie: "0", eraflures: 0, legeres: 1, graves: 0, critiques: 0 },
-    { minimum: 16, maximum: 19, endurance: "2d6", vie: "2", eraflures: 0, legeres: 0, graves: 1, critiques: 0 },
-    { minimum: 20, maximum: undefined, endurance: "100", vie: "4 + @over20", eraflures: 0, legeres: 0, graves: 0, critiques: 1 },
+    { minimum: undefined, maximum: 0, endurance: "0", vie: "0", gravite: -1},
+    { minimum: 1, maximum: 10, endurance: "1d4", vie: "0", gravite: 0},
+    { minimum: 11, maximum: 15, endurance: "1d6", vie: "0", gravite: 2},
+    { minimum: 16, maximum: 19, endurance: "2d6", vie: "2", gravite: 4},
+    { minimum: 20, maximum: undefined, endurance: "100", vie: "4 + @over20", gravite: 6},
   ],
   "non-mortel": [
-    { minimum: undefined, maximum: 0, endurance: "0", vie: "0", eraflures: 0, legeres: 0, graves: 0, critiques: 0 },
-    { minimum: 1, maximum: 10, endurance: "1d4", vie: "0", eraflures: 1, legeres: 0, graves: 0, critiques: 0 },
-    { minimum: 11, maximum: 15, endurance: "1d6", vie: "0", eraflures: 1, legeres: 0, graves: 0, critiques: 0 },
-    { minimum: 16, maximum: 19, endurance: "2d6", vie: "0", eraflures: 0, legeres: 1, graves: 0, critiques: 0 },
-    { minimum: 20, maximum: undefined, endurance: "100", vie: "0", eraflures: 0, legeres: 1, graves: 0, critiques: 0 },
+    { minimum: undefined, maximum: 0, endurance: "0", vie: "0", gravite: -1},
+    { minimum: 1, maximum: 10, endurance: "1d4", vie: "0", gravite: 0 },
+    { minimum: 11, maximum: 15, endurance: "1d6", vie: "0", gravite: 0 },
+    { minimum: 16, maximum: 19, endurance: "2d6", vie: "0", gravite: 2 },
+    { minimum: 20, maximum: undefined, endurance: "100", vie: "0", gravite: 2 },
   ],
-  "cauchemar": [
-    { minimum: undefined, maximum: 0, endurance: "0", vie: "0", eraflures: 0, legeres: 0, graves: 0, critiques: 0 },
-    { minimum: 1, maximum: 10, endurance: "1d4", vie: "0", eraflures: 1, legeres: 0, graves: 0, critiques: 0 },
-    { minimum: 11, maximum: 15, endurance: "1d6", vie: "0", eraflures: 1, legeres: 0, graves: 0, critiques: 0 },
-    { minimum: 16, maximum: 19, endurance: "2d6", vie: "0", eraflures: 1, legeres: 0, graves: 0, critiques: 0 },
-    { minimum: 20, maximum: undefined, endurance: "3d6 + @over20", vie: "0", eraflures: 1, legeres: 0, graves: 0, critiques: 0 },
+  "entiteincarnee": [
+    { minimum: undefined, maximum: 0, endurance: "0", vie: "0", gravite: -1},
+    { minimum: 1, maximum: 10, endurance: "1d4", vie: "0", gravite: 0},
+    { minimum: 11, maximum: 15, endurance: "1d6", vie: "0", gravite: 0 },
+    { minimum: 16, maximum: 19, endurance: "2d6", vie: "0", gravite: 0 },
+    { minimum: 20, maximum: undefined, endurance: "3d6 + @over20", vie: "0", gravite: 0 },
   ]
 };
 
@@ -140,9 +134,10 @@ export class RdDUtility {
       'systems/foundryvtt-reve-de-dragon/templates/actor/xp-competences.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/combat.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/blessures.html',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/blessure.html',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/blessure.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/actor/maladies-poisons.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/possessions.html',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/resonances.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/actor/taches.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/taches.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/oeuvres.html',
@@ -150,6 +145,7 @@ export class RdDUtility {
       'systems/foundryvtt-reve-de-dragon/templates/actor/jeux.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/alchimie.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/astrologie.html',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/chirurgie.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/non-haut-revant.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/haut-revant.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/dragon-queues.html',
@@ -170,51 +166,28 @@ export class RdDUtility {
       'systems/foundryvtt-reve-de-dragon/templates/actor/liens-animaux.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/liens-suivants.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/liens-vehicules.html',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire.html',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire-item.html',
       //Items
       'systems/foundryvtt-reve-de-dragon/templates/scripts/autocomplete-script.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/scripts/autocomplete.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/item/boutons-comestible.html',
+      'systems/foundryvtt-reve-de-dragon/templates/item/temporel.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/item/partial-inventaire.html',
       'systems/foundryvtt-reve-de-dragon/templates/item/partial-environnement.html',
       'systems/foundryvtt-reve-de-dragon/templates/item/partial-tab-environnement.html',
-      'systems/foundryvtt-reve-de-dragon/templates/header-item.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-competence-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-competencecreature-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-arme-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-armure-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-objet-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-conteneur-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-sort-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-herbe-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-ingredient-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-faune-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-livre-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-tache-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-potion-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-rencontre-sheet.html',
       'systems/foundryvtt-reve-de-dragon/templates/item-queue-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-souffle-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-tarot-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-tete-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-ombre-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-monnaie-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-meditation-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-nourritureboisson-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-signedraconique-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-possession-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-extraitpoetique-sheet.html',
-      'systems/foundryvtt-reve-de-dragon/templates/item-service-sheet.html',
+      'systems/foundryvtt-reve-de-dragon/templates/header-item.html',
       // partial enums
       'systems/foundryvtt-reve-de-dragon/templates/enum-caracteristiques.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-base-competence.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-aspect-tarot.html',
-      'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-competence.html',
+      'systems/foundryvtt-reve-de-dragon/templates/enum-categories.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-ingredient.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-parade.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-potion.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-vehicule.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-competence.html',
-      'systems/foundryvtt-reve-de-dragon/templates/enum-herbesoin-ingredient.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-heures.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-initpremierround.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-niveau-ethylisme.html',
@@ -222,8 +195,14 @@ export class RdDUtility {
       'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-queue.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-draconic.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-tmr-type.html',
+      'systems/foundryvtt-reve-de-dragon/templates/enum-periode.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-tmr-effet.html',
       // Partials
+      'systems/foundryvtt-reve-de-dragon/templates/tirage/liste-resultats-recherche.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/time/horloge.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/common/timestamp.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/common/periodicite.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/common/enum-duree.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/common/compendium-link.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/partial-description-overflow.html',
       'systems/foundryvtt-reve-de-dragon/templates/partial-description-sort.html',
@@ -252,10 +231,10 @@ export class RdDUtility {
       'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-meditation.html',
       'systems/foundryvtt-reve-de-dragon/templates/dialog-tmr.html',
       'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-alchimie.html',
-      'systems/foundryvtt-reve-de-dragon/templates/dialog-astrologie-joueur.html',
-      // Calendrier
-      'systems/foundryvtt-reve-de-dragon/templates/calendar-template.html',
-      'systems/foundryvtt-reve-de-dragon/templates/calendar-editor-template.html',
+      'systems/foundryvtt-reve-de-dragon/templates/sommeil/sommeil-actor-moral.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/sommeil/astrologie-gardien.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/sommeil/astrologie-joueur.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/sommeil/astrologie-theme.hbs',
       // HUD
       'systems/foundryvtt-reve-de-dragon/templates/hud-actor-init.html',
       'systems/foundryvtt-reve-de-dragon/templates/hud-actor-attaque.html',
@@ -264,20 +243,6 @@ export class RdDUtility {
       'systems/foundryvtt-reve-de-dragon/templates/chat-description.html',
       'systems/foundryvtt-reve-de-dragon/templates/chat-info-appel-au-moral.html',
       'systems/foundryvtt-reve-de-dragon/templates/chat-info-distance.html',
-      'systems/foundryvtt-reve-de-dragon/templates/chat-demande-defense.html',
-      'systems/foundryvtt-reve-de-dragon/templates/chat-demande-attaque-particuliere.html',
-      'systems/foundryvtt-reve-de-dragon/templates/chat-demande-attaque-etotal.html',
-      'systems/foundryvtt-reve-de-dragon/templates/chat-resultat-appelchance.html',
-      'systems/foundryvtt-reve-de-dragon/templates/chat-resultat-attaque.html',
-      'systems/foundryvtt-reve-de-dragon/templates/chat-resultat-encaissement.html',
-      'systems/foundryvtt-reve-de-dragon/templates/chat-resultat-parade.html',
-      'systems/foundryvtt-reve-de-dragon/templates/chat-resultat-esquive.html',
-      'systems/foundryvtt-reve-de-dragon/templates/chat-resultat-competence.html',
-      'systems/foundryvtt-reve-de-dragon/templates/chat-resultat-general.html',
-      'systems/foundryvtt-reve-de-dragon/templates/chat-resultat-tache.html',
-      'systems/foundryvtt-reve-de-dragon/templates/chat-resultat-sort.html',
-      'systems/foundryvtt-reve-de-dragon/templates/chat-resultat-alchimie.html',
-      'systems/foundryvtt-reve-de-dragon/templates/chat-resultat-possession.html',
       'systems/foundryvtt-reve-de-dragon/templates/chat-actor-turn-summary.html',
       'systems/foundryvtt-reve-de-dragon/templates/chat-actor-competence-xp.html',
       'systems/foundryvtt-reve-de-dragon/templates/chat-actor-carac-xp.html',
@@ -291,18 +256,27 @@ export class RdDUtility {
     Handlebars.registerHelper('computeResolutionChances', (row, col) => RdDResolutionTable.computeChances(row, col));
     Handlebars.registerHelper('upperFirst', str => Misc.upperFirst(str ?? 'Null'));
     Handlebars.registerHelper('lowerFirst', str => Misc.lowerFirst(str ?? 'Null'));
-    Handlebars.registerHelper('upper', str => str?.toUpperCase() ?? 'NULL');
+    Handlebars.registerHelper('upper', str => str?.toUpperCase() ?? '');
+    Handlebars.registerHelper('lowercase', str => str?.toLowerCase() ?? '');
     Handlebars.registerHelper('le', str => Grammar.articleDetermine(str));
     Handlebars.registerHelper('apostrophe', (article, str) => Grammar.apostrophe(article, str));
     Handlebars.registerHelper('un', str => Grammar.articleIndetermine(str));
     Handlebars.registerHelper('accord', (genre, ...args) => Grammar.accord(genre, args));
-    Handlebars.registerHelper('buildConteneur', (objet) => { return new Handlebars.SafeString(RdDUtility.buildConteneur(objet)); });
-    Handlebars.registerHelper('buildContenu', (objet) => { return new Handlebars.SafeString(RdDUtility.buildContenu(objet, 1, true)); });
+    Handlebars.registerHelper('buildLigneInventaire', (item, options) => { return new Handlebars.SafeString(RdDUtility.buildLigneInventaire(item, options)); });
+    Handlebars.registerHelper('buildInventaireConteneur', (actorId, itemId, options) => { return new Handlebars.SafeString(RdDUtility.buildInventaireConteneur(actorId, itemId, options)); });
+    Handlebars.registerHelper('buildContenuConteneur', (item, options) => { return new Handlebars.SafeString(RdDUtility.buildContenuConteneur(item, options)); });
+    Handlebars.registerHelper('calculerPrixCommercant', item => item.calculerPrixCommercant());
     Handlebars.registerHelper('caseTmr-label', coord => TMRUtility.getTMRLabel(coord));
     Handlebars.registerHelper('caseTmr-type', coord => TMRUtility.getTMRType(coord));
     Handlebars.registerHelper('typeTmr-name', type => TMRUtility.typeTmrName(type));
     Handlebars.registerHelper('effetRencontre-name', coord => TMRUtility.typeTmrName(coord));
-    Handlebars.registerHelper('signeHeure', (key, heure)  => RdDCalendrier.getSigneAs(key, heure));
+
+    Handlebars.registerHelper('timestamp-imgSigneHeure', (heure) => { return new Handlebars.SafeString(RdDTimestamp.imgSigneHeure(heure)) });
+    Handlebars.registerHelper('timestamp-imgSigne', (heure) => { return new Handlebars.SafeString(RdDTimestamp.imgSigne(heure)) });
+    Handlebars.registerHelper('timestamp-extract', timestamp => new RdDTimestamp(timestamp).toCalendrier());
+    Handlebars.registerHelper('timestamp-formulesDuree', () => RdDTimestamp.formulesDuree());
+    Handlebars.registerHelper('timestamp-formulesPeriode', () => RdDTimestamp.formulesPeriode());
+
     Handlebars.registerHelper('min', (...args) => Math.min(...args.slice(0, -1)));
     Handlebars.registerHelper('regle-optionnelle', (option) => ReglesOptionelles.isUsing(option));
     Handlebars.registerHelper('trier', list => list.sort((a, b) => a.name.localeCompare(b.name)));
@@ -310,68 +284,21 @@ export class RdDUtility {
     Handlebars.registerHelper('linkCompendium', (pack, id, name) => RdDUtility.linkCompendium(pack, id, name));
     Handlebars.registerHelper('uniteQuantite', (itemId, actorId) => RdDUtility.getItem(itemId, actorId)?.getUniteQuantite());
     Handlebars.registerHelper('isFieldInventaireModifiable', (type, field) => RdDItem.isFieldInventaireModifiable(type, field));
-    Handlebars.registerHelper('getFrequenceRarete', (rarete, field) => Environnement.getFrequenceRarete(rarete, field));
+    Handlebars.registerHelper('rarete-getChamp', (rarete, field) => RdDRaretes.getChamp(rarete, field));
+
+    Handlebars.registerHelper('experienceLog-topic', topic => ExperienceLog.labelTopic(topic));
+
     return loadTemplates(templatePaths);
   }
 
   static getItem(itemId, actorId = undefined) {
-    return actorId ? game.actors.get(actorId)?.getObjet(itemId) : game.items.get(itemId);
+    return actorId ? game.actors.get(actorId)?.getItem(itemId) : game.items.get(itemId);
   }
 
   static linkCompendium(pack, id, name) {
     return `@Compendium[${pack}.${id}]{${name}}`;
   }
 
-  /* -------------------------------------------- */
-  static async creerObjet(actorSheet) {
-    let itemType = $(".item-type").val();
-    await actorSheet.createItem('Nouveau ' + itemType, itemType);
-  }
-
-  /* -------------------------------------------- */
-  static async selectObjetType(actorSheet) {
-    let typeObjets = RdDItem.getItemTypesInventaire();
-    let options = `<span class="competence-label">Selectionnez le type d'équipement</span><select class="item-type">`;
-    for (let typeName of typeObjets) {
-      options += `<option value="${typeName}">${typeName}</option>`
-    }
-    options += '</select>';
-    let d = new Dialog({
-      title: "Créer un équipement",
-      content: options,
-      buttons: {
-        one: {
-          icon: '<i class="fas fa-check"></i>',
-          label: "Créer l'objet",
-          callback: () => this.creerObjet(actorSheet)
-        }
-      }
-    });
-    d.render(true);
-  }
-
-  /* -------------------------------------------- */
-  static async selectTypeOeuvre(actorSheet) {
-    let typeObjets = RdDItem.getTypesOeuvres();
-    let options = `<span class="competence-label">Selectionnez le type d'oeuvre</span><select class="item-type">`;
-    for (let typeName of typeObjets) {
-      options += `<option value="${typeName}">${typeName}</option>`
-    }
-    options += '</select>';
-    let d = new Dialog({
-      title: "Créer un équipement",
-      content: options,
-      buttons: {
-        one: {
-          icon: '<i class="fas fa-check"></i>',
-          label: "Créer l'objet",
-          callback: () => this.creerObjet(actorSheet)
-        }
-      }
-    });
-    d.render(true);
-  }
-
   /* -------------------------------------------- */
   static buildListOptions(min, max) {
     let options = ""
@@ -412,76 +339,13 @@ export class RdDUtility {
   }
 
   /* -------------------------------------------- */
-  static filterItemsPerTypeForSheet(formData, itemTypes) {
-
-    RdDUtility.filterEquipementParType(formData, itemTypes);
-
-    formData.sorts = this.arrayOrEmpty(itemTypes['sort']);
-    formData.rencontres = this.arrayOrEmpty(itemTypes['rencontre']);
-    formData.casestmr = this.arrayOrEmpty(itemTypes['casetmr']);
-    formData.signesdraconiques = this.arrayOrEmpty(itemTypes['signedraconique']);
-    formData.queues = this.arrayOrEmpty(itemTypes['queue']);
-    formData.souffles = this.arrayOrEmpty(itemTypes['souffle']);
-    formData.ombres = this.arrayOrEmpty(itemTypes['ombre']);
-    formData.tetes = this.arrayOrEmpty(itemTypes['tete']);
-    formData.taches = this.arrayOrEmpty(itemTypes['tache']);
-    formData.meditations = this.arrayOrEmpty(itemTypes['meditation']);
-    formData.chants = this.arrayOrEmpty(itemTypes['chant']);
-    formData.danses = this.arrayOrEmpty(itemTypes['danse']);
-    formData.musiques = this.arrayOrEmpty(itemTypes['musique']);
-    formData.oeuvres = this.arrayOrEmpty(itemTypes['oeuvre']);
-    formData.jeux = this.arrayOrEmpty(itemTypes['jeu']);
-
-    formData.services = this.arrayOrEmpty(itemTypes['service']);
-    formData.recettescuisine = this.arrayOrEmpty(itemTypes['recettecuisine']);
-    formData.recettesAlchimiques = this.arrayOrEmpty(itemTypes['recettealchimique']);
-    formData.maladies = this.arrayOrEmpty(itemTypes['maladie']);
-    formData.poisons = this.arrayOrEmpty(itemTypes['poison']);
-    formData.possessions = this.arrayOrEmpty(itemTypes['possession']);
-    formData.maladiesPoisons = formData.maladies.concat(formData.poisons);
-    formData.competences = (itemTypes['competence'] ?? []).concat(itemTypes['competencecreature'] ?? []);
-    formData.sortsReserve = this.arrayOrEmpty(itemTypes['sortreserve']);
-  }
-
-  static filterEquipementParType(formData, itemTypes) {
-    formData.conteneurs = this.arrayOrEmpty(itemTypes['conteneur']);
-
-    formData.materiel = this.arrayOrEmpty(itemTypes['objet']);
-    formData.armes = this.arrayOrEmpty(itemTypes['arme']);
-    formData.armures = this.arrayOrEmpty(itemTypes['armure']);
-    formData.munitions = this.arrayOrEmpty(itemTypes['munition']);
-    formData.livres = this.arrayOrEmpty(itemTypes['livre']);
-    formData.potions = this.arrayOrEmpty(itemTypes['potion']);
-    formData.ingredients = this.arrayOrEmpty(itemTypes['ingredient']);
-    formData.faunes = this.arrayOrEmpty(itemTypes['faune']);
-    formData.herbes = this.arrayOrEmpty(itemTypes['herbe']);
-    formData.monnaie = this.arrayOrEmpty(itemTypes['monnaie']).sort(Monnaie.triValeurEntiere());
-    formData.nourritureboissons = this.arrayOrEmpty(itemTypes['nourritureboisson']);
-    formData.gemmes = this.arrayOrEmpty(itemTypes['gemme']);
-
-    formData.objets = formData.conteneurs
-      .concat(formData.materiel)
-      .concat(formData.armes)
-      .concat(formData.armures)
-      .concat(formData.munitions)
-      .concat(formData.livres)
-      .concat(formData.potions)
-      .concat(formData.ingredients)
-      .concat(formData.herbes)
-      .concat(formData.faunes)
-      .concat(formData.monnaie)
-      .concat(formData.nourritureboissons)
-      .concat(formData.gemmes);
-  }
-
-  /* -------------------------------------------- */
-  static buildArbreDeConteneurs(conteneurs, objets) {
+  static buildArbreDeConteneurs(conteneurs, inventaires) {
     let objetVersConteneur = {};
     // Attribution des objets aux conteneurs
     for (let conteneur of conteneurs) {
       conteneur.subItems = [];
       for (let id of conteneur.system.contenu ?? []) {
-        let objet = objets.find(objet => (id == objet._id));
+        let objet = inventaires.find(objet => (id == objet._id));
         if (objet) {
           objet.estContenu = true; // Permet de filtrer ce qui est porté dans le template
           objetVersConteneur[id] = conteneur._id;
@@ -490,20 +354,20 @@ export class RdDUtility {
       }
     }
     for (let conteneur of conteneurs) {
-      conteneur.system.encTotal = RdDUtility.calculEncContenu(conteneur, objets);
+      conteneur.system.encTotal = RdDUtility.calculEncContenu(conteneur, inventaires);
     }
     return objetVersConteneur;
   }
 
   /* -------------------------------------------- */
-  static calculEncContenu(conteneur, objets) {
+  static calculEncContenu(conteneur, inventaires) {
     const contenus = (conteneur.system.contenu ?? []).filter(id => id != undefined)
-      .map(id => objets.find(it => (id == it.id)))
+      .map(id => inventaires.find(it => (id == it.id)))
       .filter(it => it);
     let enc = Number(conteneur.system.encombrement ?? 0) * Number(conteneur.system.quantite ?? 1);
     for (let contenu of contenus) {
       if (contenu.type == 'conteneur') {
-        enc += RdDUtility.calculEncContenu(contenu, objets);
+        enc += RdDUtility.calculEncContenu(contenu, inventaires);
       }
       else {
         enc += Number(contenu.system.encombrement ?? 0) * Number(contenu.system.quantite ?? 1)
@@ -518,35 +382,64 @@ export class RdDUtility {
     return conteneurs.filter((conteneur, index, arr) => !conteneur.estContenu);
   }
 
-  /* -------------------------------------------- */
-  /** Construit la structure récursive des conteneurs, avec imbrication potentielle
-   * 
-   */
-  static buildConteneur(objet, profondeur) {
-    if (!profondeur) profondeur = 1;
-    objet.niveau = profondeur;
-    const isConteneur = objet.type == 'conteneur';
-    const isOuvert = isConteneur && this.getAfficheContenu(objet._id);
-    const isVide = isConteneur && objet.system.contenu.length == 0;
-    const conteneur = Handlebars.partials['systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-item.html']({
-      item: objet,
-      vide: isVide,
-      ouvert: isOuvert
-    });
-    const contenu = isConteneur ? RdDUtility.buildContenu(objet, profondeur, isOuvert) : '';
-    return conteneur + contenu;
+  static prepareOptionsArbreInventaire(item, optionsArbre) {
+    if (!optionsArbre.profondeur) {
+      optionsArbre.profondeur = 1
+    };
+    if (!optionsArbre.templateItem) {
+      optionsArbre.templateItem = item.parent?.type == 'commerce'
+        ? "systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire-item.html"
+        : "systems/foundryvtt-reve-de-dragon/templates/actor/inventaire-item.html";
+    }
+    item.niveau = optionsArbre.profondeur;
   }
 
   /* -------------------------------------------- */
-  static buildContenu(objet, profondeur, afficherContenu) {
-    if (!profondeur) profondeur = 1;
-    objet.niveau = profondeur;
-    const display = afficherContenu ? 'item-display-show' : 'item-display-hide';
-    let strContenu = `<ul class='item-list alterne-list ${display} list-item-margin${Math.min(profondeur,6)}'>`;
-    for (let subItem of objet.subItems) {
-      strContenu += this.buildConteneur(subItem, profondeur + 1);
+
+  /**
+   * Construit la structure récursive des conteneurs, avec imbrication potentielle
+   */
+  static buildLigneInventaire(item, options = {}, optionsArbre = { ouvert: false, profondeur: 1 }) {
+    RdDUtility.prepareOptionsArbreInventaire(item, optionsArbre);
+
+    const isConteneur = item.type == 'conteneur';
+    const inventaire = {
+      item: item,
+      vide: isConteneur && item.system.contenu.length == 0,
+      ouvert: isConteneur && RdDUtility.getAfficheContenu(item._id),
+      options: options
+    };
+    optionsArbre.ouvert = inventaire.ouvert
+    const ligneObjet = Handlebars.partials[optionsArbre.templateItem](inventaire);
+    if (isConteneur) {
+      return ligneObjet + RdDUtility.buildContenuConteneur(item, options, optionsArbre);
     }
-    return strContenu + "</ul>";
+    return ligneObjet;
+  }
+
+  static buildInventaireConteneur(actorId, itemId, options) {
+    const actor = game.actors.get(actorId)
+    const item = actor?.items.get(itemId)
+    if (item) {
+      return RdDUtility.buildContenuConteneur(item, options, { ouvert: true, profondeur: 1 });
+    }
+    return '';
+  }
+
+  /* -------------------------------------------- */
+  static buildContenuConteneur(conteneur, options = {}, optionsArbre = {}) {
+    RdDUtility.prepareOptionsArbreInventaire(conteneur, optionsArbre);
+    const display = optionsArbre.ouvert ? 'item-display-show' : 'item-display-hide';
+    const profondeur = optionsArbre.profondeur;
+
+    optionsArbre.profondeur++;
+    const lignesContenu = conteneur.subItems.sort(Misc.ascending(it => it.name))
+      .map(contenu => this.buildLigneInventaire(contenu, options, optionsArbre));
+
+    return `<ul class='item-list alterne-list ${display} list-item-margin${Math.min(profondeur, 6)}'>`
+      + lignesContenu.reduce(Misc.joining(''), '')
+      + "</ul>";
+
   }
 
   /* -------------------------------------------- */
@@ -563,10 +456,6 @@ export class RdDUtility {
     return ajustementsEncaissement;
   }
 
-  static getDefinitionsBlessures() {
-    return definitionsBlessures;
-  }
-
   /* -------------------------------------------- */
   static getSegmentsFatigue(maxEnd) {
     maxEnd = Math.max(maxEnd, 1);
@@ -696,7 +585,7 @@ export class RdDUtility {
 
     return await RdDUtility.prepareEncaissement(rollData, roll, armure);
   }
-  
+
   /* -------------------------------------------- */
   static async prepareEncaissement(rollData, roll, armure) {
     const jetTotal = roll.total + rollData.dmg.total - armure;
@@ -707,17 +596,10 @@ export class RdDUtility {
     encaissement.dmg.loc.label = encaissement.dmg.loc.label ?? 'Corps;';
     encaissement.roll = roll;
     encaissement.armure = armure;
+    encaissement.penetration = rollData.arme?.system.penetration ?? 0;
     encaissement.total = jetTotal;
     encaissement.vie = await RdDUtility._evaluatePerte(encaissement.vie, over20);
     encaissement.endurance = await RdDUtility._evaluatePerte(encaissement.endurance, over20);
-    encaissement.penetration = rollData.arme?.system.penetration ?? 0;
-    encaissement.blessures = (
-      encaissement.critiques> 0 ? "Critique":
-      encaissement.graves> 0 ? "Grave":
-      encaissement.legeres> 0 ? "Légère":
-      encaissement.eraflures>0 ? "Contusions/Eraflures":
-      'Aucune'
-    );
     return encaissement;
   }
 
@@ -770,8 +652,6 @@ export class RdDUtility {
     switch (sockmsg.msg) {
       case "msg_gm_chat_message":
         return ChatUtility.handleGMChatMessage(sockmsg.data);
-      case "msg_sync_time":
-        return game.system.rdd.calendrier.syncPlayerTime(sockmsg.data);
       case "msg_request_nombre_astral":
         return game.system.rdd.calendrier.requestNombreAstral(sockmsg.data);
       case "msg_response_nombre_astral":
@@ -788,6 +668,7 @@ export class RdDUtility {
   /* -------------------------------------------- */
   static async chatListeners(html) {
     RdDCombat.registerChatCallbacks(html);
+    RdDEmpoignade.registerChatCallbacks(html);
 
     // Gestion spécifique message passeurs
     html.on("click", '.tmr-passeur-coord a', event => {
@@ -833,8 +714,16 @@ export class RdDUtility {
       }
     });
     html.on("click", '.rdd-world-content-link', async event => {
-      const itemId = html.find(event.currentTarget)?.data("id");
-      game.items.get(itemId)?.sheet.render(true)
+      const htmlElement = html.find(event.currentTarget);
+      const id = htmlElement?.data("id");
+      const doctype = htmlElement?.data("doctype");
+      switch (doctype ?? 'Item') {
+        case 'Actor':
+          return game.actors.get(id)?.sheet.render(true);
+        case 'Item':
+        default:
+          return game.items.get(id)?.sheet.render(true);
+      }
     });
   }
 
@@ -911,7 +800,7 @@ export class RdDUtility {
     if (p2[2] == 'd') deniers += Number(p2[1]);
     if (p2[2] == 's') sols += Number(p2[1]);
 
-    let sommeAPayer = sols + deniers/100;
+    let sommeAPayer = sols + deniers / 100;
     let msgPayer = `La somme de ${sols} Sols et ${deniers} Deniers est à payer<br>
       <a class='payer-button chat-card-button' data-somme-a-payer='${sommeAPayer}'>Payer</a>`
     ChatMessage.create({ content: msgPayer });
@@ -938,17 +827,13 @@ export class RdDUtility {
   }
 
   /* -------------------------------------------- */
-  static confirmerSuppressionSubacteur(sheet, subActor, htmlToDelete) {
+  static confirmerSuppressionSubacteur(sheet, subActor, htmlToDelete, onSuppression = ()=>{}) {
     RdDConfirm.confirmer({
       settingConfirmer: "confirmation-supprimer-lien-acteur",
       content: `<p>Etes vous certain de vouloir supprimer le lien vers ${subActor.name} ?</p>`,
       title: 'Confirmer la suppression',
       buttonLabel: 'Supprimer le lien',
-      onAction: () => {
-        console.log('Delete : ', subActor.id);
-        sheet.actor.removeSubacteur(subActor.id);
-        RdDUtility.slideOnDelete(sheet, htmlToDelete);
-      }
+      onAction: onSuppression
     })
   }
 
@@ -994,10 +879,10 @@ export class RdDUtility {
   /* -------------------------------------------- */
   static afficherHeuresChanceMalchance(heureNaissance) {
     if (game.user.isGM) {
-      let heure = game.system.rdd.calendrier.findHeure(heureNaissance);
+      const heure = RdDTimestamp.findHeure(heureNaissance - 1);
       if (heureNaissance && heure) {
         let ajustement = game.system.rdd.calendrier.getAjustementAstrologique(heureNaissance);
-        const current = game.system.rdd.calendrier.findHeure(game.system.rdd.calendrier.getCurrentHeure());
+        const current = game.system.rdd.calendrier.heureCourante();
         ChatMessage.create({
           content: `A l'heure de <strong>${current.label}</strong>, le modificateur de Chance/Malchance est de <strong>${Misc.toSignedString(ajustement)}</strong> pour l'heure de naissance <strong>${heure.label}</strong>.`,
           whisper: ChatMessage.getWhisperRecipients("GM")

module/rolldata-ajustements.js

@@ -5,6 +5,7 @@ import { RdDItemSort } from "./item-sort.js";
 import { Misc } from "./misc.js";
 import { RdDBonus } from "./rdd-bonus.js";
 import { RdDCarac } from "./rdd-carac.js";
+import { RdDPossession } from "./rdd-possession.js";
 import { RdDUtility } from "./rdd-utility.js";
 import { ReglesOptionelles } from "./settings/regles-optionelles.js";
 
@@ -30,7 +31,7 @@ export const referenceAjustements = {
   },
   diffLibre: {
     isUsed: (rollData, actor) => rollData.diffLibre != undefined,
-    getLabel: (rollData, actor) => rollData.selectedSort?.name ?? rollData.attackerRoll ? 'Imposée' : 'Libre',
+    getLabel: (rollData, actor) => rollData.selectedSort?.name ?? rollData.attackerRoll ?? RdDPossession.isDefensePossession(rollData) ? 'Imposée' : 'Libre',
     getValue: (rollData, actor) => rollData.selectedSort
       ? RdDItemSort.getDifficulte(rollData.selectedSort, rollData.diffLibre)
       : rollData.diffLibre ?? rollData.competence?.system.default_diffLibre ?? 0
@@ -51,19 +52,19 @@ export const referenceAjustements = {
     getValue: (rollData, actor) => RdDBonus.find(rollData.surpriseDefenseur).attaque,
   },
   etat: {
-    isUsed: (rollData, actor) => !RdDCarac.isIgnoreEtatGeneral(rollData),
+    isUsed: (rollData, actor) => !RollDataAjustements.isIgnoreEtatGeneral(rollData),
     getLabel: (rollData, actor) => 'Etat général',
     getValue: (rollData, actor) => actor.getEtatGeneral({ ethylisme: rollData.forceAlcool != undefined })
   },
   malusArmure: {
-    isVisible: (rollData, actor) => RdDCarac.isAgiliteOuDerivee(rollData.selectedCarac),
-    isUsed: (rollData, actor) => RdDCarac.isAgiliteOuDerivee(rollData.selectedCarac),
+    isVisible: (rollData, actor) => RdDCarac.isAgiliteOuDerobee(rollData.selectedCarac),
+    isUsed: (rollData, actor) => RdDCarac.isAgiliteOuDerobee(rollData.selectedCarac),
     getLabel: (rollData, actor) => 'Malus armure',
     getValue: (rollData, actor) => actor.getMalusArmure()
   },
   encTotal: {
-    isVisible: (rollData, actor) => RdDCarac.isAgiliteOuDerivee(rollData.selectedCarac) && RdDItemCompetence.isMalusEncombrementTotal(rollData.competence),
-    isUsed: (rollData, actor) => !rollData.oeuvre && RdDCarac.isAgiliteOuDerivee(rollData.selectedCarac) && RdDItemCompetence.isMalusEncombrementTotal(rollData.competence) && rollData.use.encTotal,
+    isVisible: (rollData, actor) => RdDCarac.isAgiliteOuDerobee(rollData.selectedCarac) && RdDItemCompetence.isMalusEncombrementTotal(rollData.competence),
+    isUsed: (rollData, actor) => !rollData.oeuvre && RdDCarac.isAgiliteOuDerobee(rollData.selectedCarac) && RdDItemCompetence.isMalusEncombrementTotal(rollData.competence) && rollData.use.encTotal,
     getLabel: (rollData, actor) => 'Encombrement total',
     getValue: (rollData, actor) => -actor.getEncTotal()
   },
@@ -139,6 +140,12 @@ export const referenceAjustements = {
     isUsed: (rollData, actor) => rollData.ethylisme != undefined,
     getLabel: (rollData, actor) => "Ethylisme - " + RdDUtility.getNomEthylisme(rollData.ethylisme),
     getValue: (rollData, actor) => rollData.ethylisme,
+  },
+  tailleempoignade: {
+    isVisible: (rollData, actor) => rollData.isEmpoignade,
+    isUsed: (rollData, actor) => rollData.isEmpoignade,
+    getLabel: (rollData, actor) => "Malus de taille",
+    getValue: (rollData, actor) => rollData.malusTaille,
   }
 }
 
@@ -171,4 +178,11 @@ export class RollDataAjustements {
     return sum;
   }
 
+  static isIgnoreEtatGeneral(rollData) {
+    const selectedCarac = rollData.selectedCarac;
+    return !selectedCarac ||
+      rollData.ethylisme ||
+      RdDCarac.isChance(selectedCarac) ||
+      (RdDCarac.isReve(selectedCarac) && !rollData.competence);
+  }
 }

module/settings/regles-optionelles.js

@@ -17,6 +17,7 @@ const listeReglesOptionelles = [
   { group: 'Règles générales', name: 'afficher-prix-joueurs', descr: "Afficher le prix de l'équipement des joueurs", uniquementJoueur: true},
   { group: 'Règles générales', name: 'appliquer-fatigue', descr: "Appliquer les règles de fatigue"},
   { group: 'Règles générales', name: 'afficher-colonnes-reussite', descr: "Afficher le nombre de colonnes de réussite ou d'échec", default: false },
+  { group: 'Règles générales', name: 'chateau-dormant-gardien', descr: "Saisie des heures de sommeil/jets de moral par le gardien des rêves", default: true },
 
   { group: 'Confirmations', name: 'confirmer-combat-sans-cible',         descr: "Confirmer avant une attaque sans cible", scope: "client"},
   { group: 'Confirmations', name: 'confirmation-tmr',                    descr: "Confirmer pour monter dans les TMR", scope: "client"},

module/settings/system-compendiums.js

@@ -52,12 +52,16 @@ export class SystemCompendiums extends FormApplication {
   }
 
   static getPack(compendium) {
+    const pack = game.packs.get(compendium);
+    if (pack) {
+      return pack;
+    }
     return game.packs.get(SystemCompendiums.getCompendium(compendium)) ?? game.packs.get(SystemCompendiums._getDefaultCompendium(compendium));
   }
 
   static async getPackContent(compendium, docType) {
     const pack = SystemCompendiums.getPack(compendium);
-    if (pack.metadata.type == docType) {
+    if (pack?.metadata.type == docType) {
       return await pack.getDocuments();
     }
     return [];
@@ -177,7 +181,7 @@ export class SystemCompendiums extends FormApplication {
  */
 export class CompendiumTable {
 
-  constructor(compendium, type, subTypes, sorting = undefined) {
+  constructor(compendium, type, subTypes = undefined, sorting = undefined) {
     this.compendium = compendium;
     this.type = type;
     this.subTypes = subTypes;
@@ -187,13 +191,13 @@ export class CompendiumTable {
   async getContent(itemFrequence = it => it.system.frequence, filter = it => true) {
     return await SystemCompendiums.getContent(this.compendium,
       this.type,
-      it => this.subTypes.includes(it.type) && filter(it),
+      it => (!this.subTypes || this.subTypes.includes(it.type)) && itemFrequence(it) > 0 && filter(it),
       itemFrequence,
       this.sorting);
   }
 
   async buildTable(itemFrequence = it => it.system.frequence, filter = it => true) {
-    const elements = await this.getContent(filter, itemFrequence);
+    const elements = await this.getContent(itemFrequence, filter);
     return CompendiumTableHelpers.buildTable(elements, itemFrequence);
   }
 
@@ -225,9 +229,23 @@ export class CompendiumTableHelpers {
     });
   }
 
-  static async getRandom(table, type, subTypes, forcedRoll = undefined, localisation = undefined) {
+  static concatTables(...tables) {
+    const rows = tables.reduce((a, b) => a.concat(b));
+    let max = 0;
+    const total = rows.map(it => it.frequence).reduce(Misc.sum(), 0);
+    return rows.map(row => {
+      const frequence = row.frequence;
+      row.min = max + 1;
+      row.max = max + frequence;
+      row.total = total
+      max += frequence;
+      return row;
+    })
+  }
+  static async getRandom(table, type, subTypes = ['objet'], forcedRoll = undefined, localisation = undefined) {
     if (table.length == 0) {
-      ui.notifications.warn(`Aucun ${Misc.typeName(type, subTypes[0])} trouvé dans ${localisation ?? ' les compendiums'}`);
+      const typeName = Misc.typeName(type, subTypes[0]);
+      ui.notifications.warn(`Aucun ${typeName} trouvé dans ${localisation ?? ' les compendiums'}`);
       return undefined;
     }
     return await CompendiumTableHelpers.selectRow(table, forcedRoll);
@@ -260,7 +278,7 @@ export class CompendiumTableHelpers {
       roll: row.roll,
       document: row.document,
       percentages,
-      typeName: Misc.typeName(type, row.document.type),
+      typeName: Misc.typeName(type, row.document?.type ?? 'objet'),
       isGM: game.user.isGM,
     });
     const messageData = {

module/sommeil/app-astrologie.js

@@ -0,0 +1,206 @@
+import { SYSTEM_RDD, SYSTEM_SOCKET_ID } from "../constants.js";
+import { Misc } from "../misc.js";
+import { RdDTimestamp } from "../time/rdd-timestamp.js";
+
+export const APP_ASTROLOGIE_REFRESH = `${SYSTEM_RDD}-refresh-astrologie`
+
+export class AppAstrologie extends Application {
+  static async create(actor = undefined, options = {}) {
+    if (actor == undefined && !game.user.isGM) {
+      actor = game.user.character
+    }
+    if (!actor && !game.user.isGM) {
+      console.error("AppAstrologie uniquement accessible pour le MJ, ou depuis un personnage pour un joueur")
+    }
+    new AppAstrologie(actor, options).render(true);
+  }
+
+
+  static get defaultOptions() {
+    return mergeObject(super.defaultOptions, {
+      template: "systems/foundryvtt-reve-de-dragon/templates/sommeil/app-astrologie.hbs",
+      title: "Astrologie",
+      width: 'fit-content',
+      height: 'fit-content',
+      classes: ['calendar-astrologie'],
+      popOut: true,
+      resizable: false
+    });
+  }
+
+  constructor(actor, options = {}) {
+    super(options);
+    this.actor = actor;
+    this.hookReference = Hooks.on(APP_ASTROLOGIE_REFRESH, () => this.refreshAstrologie());
+  }
+
+  getData(options) {
+    this.appData = super.getData(options)
+    const calendrier = game.system.rdd.calendrier;
+    mergeObject(this.appData, {
+      isGM: game.user.isGM,
+      isActor: this.actor != undefined,
+      calendrier: calendrier.getTimestamp().toCalendrier(),
+      dates: calendrier.getJoursSuivants(10),
+      heures: RdDTimestamp.definitions(),
+      actorAstrologie: this.getActorAstrologie(),
+      gmAstrologie: this.getGMAstrologie(calendrier),
+      theme: {
+        signeAstral: RdDTimestamp.definition(0),
+        signeNaissance: RdDTimestamp.definition(0)
+      }
+    })
+    return this.appData;
+  }
+
+  getActorAstrologie() {
+    if (this.actor) {
+      return {
+        actor: this.actor,
+        nombres: this._organizeNombresAstraux(this.actor.itemTypes['nombreastral']),
+        ajustements: CONFIG.RDD.difficultesLibres,
+        etat: this.actor.getEtatGeneral(),
+        astrologie: this.actor.getCompetence('Astrologie')
+      }
+    }
+    return {}
+  }
+
+  _organizeNombresAstraux(nombresAstraux) {
+    let organized = {};
+    nombresAstraux.forEach(na => {
+      if (!organized[na.system.jourindex]) {
+        organized[na.system.jourindex] = {
+          listValues: [],
+          jourlabel: na.system.jourlabel
+        }
+      }
+      organized[na.system.jourindex].listValues.push(na.system.value);
+    })
+    return organized;
+  }
+
+  getGMAstrologie(calendrier) {
+    if (game.user.isGM) {
+      const nbAstral = calendrier.getNombreAstral()
+      const heures = RdDTimestamp.heures();
+      return {
+        ajustementsActors: game.actors.filter(it => it.isPersonnage() && it.hasPlayerOwner)
+          .map(actor => this.getAjustementActor(actor, nbAstral, heures)),
+        nombresAstraux: calendrier.getNombresAstraux().map(na => this.getDetailNombreAstral(na))
+      }
+    }
+    return {}
+  }
+
+  getAjustementActor(actor, nbAstral, heures) {
+    const hn = RdDTimestamp.findHeure(actor.getHeureNaissance())?.heure ?? 0;
+    return {
+      actor,
+      ajustements: heures.map(heure => {
+        return { heure, ajustement: RdDTimestamp.ajustementAstrologiqueHeure(hn, nbAstral, heure) };
+      })
+    }
+  }
+
+  getDetailNombreAstral(nombreAstral) {
+    const detail = duplicate(nombreAstral);
+    const timestamp = new RdDTimestamp({ indexDate: nombreAstral.index });
+    detail.date = { mois: timestamp.mois, jour: timestamp.jour + 1 };
+    detail.valeursFausses.forEach(fausse => fausse.actorName = game.actors.get(fausse.actorId).name ?? "Inconnu");
+    return detail;
+  }
+
+  /* -------------------------------------------- */
+  activateListeners(html) {
+    super.activateListeners(html);
+    this.html = html;
+    this.html.find('select[name="signe-astral"]').change(event => {
+      this.selectNombreAstral(this.html.find('select[name="signe-astral"]').val());
+    })
+    this.html.find('select[name="signe-naissance"]').change(event => {
+      this.selectHeureNaissance(this.html.find('select[name="signe-naissance"]').val());
+    })
+    this.html.find('td.nombre-astral').click(event => {
+      this.selectNombreAstral(Number.parseInt(event.currentTarget.attributes['data-nombre-astral'].value) - 1);
+    })
+    this.html.find('tr.heure-naissance').click(event => {
+      this.selectHeureNaissance(event.currentTarget.attributes['data-heure-naissance'].value);
+    })
+    this.html.find('[name="jet-astrologie"]').click(event => this.requestJetAstrologie());
+    this.html.find('[name="rebuild-nombres-astraux"]').click(event => this.rebuildNombresAstraux());
+
+    this.onCalculThemeAstral();
+  }
+
+  selectHeureNaissance(heureNaissance) {
+    this.appData.theme.signeNaissance = RdDTimestamp.definition(heureNaissance);
+    this.onCalculThemeAstral();
+  }
+
+  selectNombreAstral(nombreAstral) {
+    this.appData.theme.signeAstral = RdDTimestamp.definition(nombreAstral);
+    this.onCalculThemeAstral();
+  }
+
+  /* -------------------------------------------- */
+  async rebuildNombresAstraux() {
+    game.system.rdd.calendrier.resetNombresAstraux();
+
+    await game.system.rdd.calendrier.rebuildNombresAstraux();
+  }
+
+  onCalculThemeAstral() {
+    const chiffreAstral = this.appData.theme.signeAstral.heure + 1;
+    const heureNaissance = this.appData.theme.signeNaissance.heure + 1;
+    RdDTimestamp.definitions().forEach(dh => {
+      const ajustement = RdDTimestamp.ajustementAstrologiqueHeure(heureNaissance, chiffreAstral, dh.heure + 1);
+      const txtAjustement = ajustement == 0 ? '' : Misc.toSignedString(ajustement);
+      this.html.find(`div.horloge-ajustement.heure-${dh.hh}`).text(txtAjustement)
+    });
+
+    this.html.find(`select[name="signe-astral"]`).val(this.appData.theme.signeAstral.key)
+    this.html.find(`select[name="signe-naissance"]`).val(this.appData.theme.signeNaissance.key)
+
+    const angleAstrologie = ((chiffreAstral + heureNaissance) * 30) % 360 - 45;
+    this.html.find(`div.horloge-roue div.disque-astro img`).css(Misc.cssRotation(angleAstrologie));
+
+    const timestamp = game.system.rdd.calendrier.getTimestamp();
+
+    this.html.find(`div.horloge-roue div.horloge-aiguille-heure img`).css(Misc.cssRotation(timestamp.angleHeure));
+    this.html.find(`div.horloge-roue div.horloge-aiguille-minute img`).css(Misc.cssRotation(timestamp.angleMinute));
+  }
+
+  requestJetAstrologie() {
+    if (!this.appData?.isActor) {
+      return
+    }
+    let socketData = {
+      id: this.appData.actorAstrologie.actor.id,
+      carac_vue: this.actor.system.carac['vue'].value,
+      etat: this.actor.getEtatGeneral(),
+      astrologie: this.actor.getCompetence('Astrologie'),
+      conditions: this.html.find('[name="diffConditions"]').val(),
+      date: this.html.find('[name="joursAstrologie"]').val(),
+      userId: game.user.id
+    }
+    if (Misc.isUniqueConnectedGM()) {
+      game.system.rdd.calendrier.requestNombreAstral(socketData);
+    } else {
+      game.socket.emit(SYSTEM_SOCKET_ID, {
+        msg: "msg_request_nombre_astral",
+        data: socketData
+      });
+    }
+  }
+
+  refreshAstrologie() {
+    this.render(true)
+  }
+
+  async close(options) {
+    Hooks.off(APP_ASTROLOGIE_REFRESH, this.hookReference);
+    this.hookReference = undefined
+    await super.close(options)
+  }
+}