Merge pull request '## v11.0.26 - le crépuscule de Khrachtchoum' (#673) from VincentVk/foundryvtt-reve-de-dragon:v11 into v11

Reviewed-on: public/foundryvtt-reve-de-dragon#673

.gitignore

@@ -8,3 +8,7 @@ todo.md
 /jsconfig.json
 /package.json
 /package-lock.json
+/packs/*/
+/packs/*/CURRENT
+/packs/*/LOG
+/packs/*/LOCK

changelog.md

@@ -1,266 +1,98 @@
- --- 
+# v11.0
+## v11.0.26 - le crépuscule de Khrachtchoum
+- gestion correcte des TMRs
+  - les TMRs ne sont jamais minimisées (par le système) quand le haut-rêvant est en demi-rêve
+  - lorsqu'une fenêtre liée aux demi-rêve est affichée, cliquer sur les TMRs n'a pas d'effet
+  - les lancers de sorts et lectures de signes sont affichées en premier plan
+  - Les effets qui ouvrent une fenêtre sont bien affichés en premier plan
+  - en cas de rencontre suivie de maîtrises/conquêtes, les fenêtres s'enchaînent
+- Le drag&drop vers la barre de macro est corrigé
+  - pour les créatures, possibilités d'avoir les attaques ou autres compétences
+  - pour les personnages, les macros sont créées:
+    - pour les compétences
+    - pour le corps à corps, trois macros sont créées: compétence, pugilat, empoignade
+    - pour les armes
+      - deux macros sont créées pour les armes à 1/2 mains
+      - deux macros sont créées pour les armes de mélée et lancer
+      - 4 macros si votre arbalête se lance, tire, et se manie à 1 ou 2 mains...
+- les jets de compétences d'attaque des créatures fonctionnent de nouveau
 
-# v11.0 
+## v11.0.25 - la vision du rêve de Khrachtchoum
+- Les TMRs restent affichées tant que le Haut-rêvant est en demi-rêve
 
-# v10.7 - L'os de Semolosse
+## v11.0.24 - les couleurs de Khrachtchoum
+- nouvelle carte des TMRs
 
-## v10.7.14 - l'expérience de Semolosse
-- 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, ...)
+## v11.0.23 - la lumière de Khrachtchoum
+- ajustement automatique de la luminosité selon l'heure pour les scènes:
+   - avec une vision des tokens (sinon: ce n'est pas une scène de carte pour tokens)
+   - avec illumination globale (correspondant à une illumination extérieure)
+   - quand lampe "allumée" dans la fenêtre du calendrier
 
-## v10.7.13 - l'armure de Semolosse
-- Fix: en cas d'armure variable, la détérioration diminue le dé d'armure
+## v11.0.22 - les automatismes de Khrachtchoum le Problémeux
+- Macro pour attaquer avec les compétences de créatures
 
-## 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é
+## v11.0.20
+- Macro pour attaquer avec les armes des personnages
 
-## v10.7.11 - Le Pugilat de Semolosse
-- Fix sur la projection au sol.
+## v11.0.17
+- Fix: les actions de commerce ne s'appliquait pas bien aux personnages des tokens non liés
 
-## v10.7.10 - Le Pugilat de Semolosse
-- Gestion de l'empoignade
-- Corrections sur l'initiative
-- Correction sur l'equipement des vêtements et bijoux
+## v11.0.15 - L'apprentissage de Khrachtchoum
+- Fix: l'expérience ne s'appliquait plus sur certaines réussites particulières (régression depuis la 11.0.7)
 
-##  v10.7.9 - Le Pugilat de Semolosse
+## v11.0.14 - Les pincettes de Khrachtchoum le Problémeux
+- Correction du calcul de la place restante lors de l'ajout dans un conteneur
 
-- 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.
+## v11.0.13 - La multiplication de l'eau de Khrachtchoum le Problémeux
+- Correction de la vente depuis un commerce ayant des quantités illimitées
 
-  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).
+## v11.0.12 - Les poids de la mesure de Khrachtchoum le Problémeux
+- Correction des malus de surencombrement
+- Le malus armure est correctement affiché dans l'onglet des caractéristiques
+- Correction d'orthographe et amélioration des messages des oeuvres d'art
 
-## 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
+## v11.0.11 - Les bleus de Khrachtchoum le Problémeux
+- si le gardien configure le sommeil, les joueurs sont notifiés que chateau dormant vient de passer
+- possibilité de créer des armes et des compétences de créatures non-mortelles.
 
-## 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
+## v11.0.10 - Les Songes de Khrachtchoum le Problémeux
+- on peut de nouveau se déplacer dans les TMRs d'un clic sur la case à atteindre
+- Lire un livre depuis l'inventaire permet de nouveau de faire un jet de la tâche
+  créée au lieu de créer toujours une nouvelle tâche
+- La sélection des TMR pour la création de signes draconiques ne cause plus d'erreurs
+- la récupération d'endurance en cas d'insomnie est limitée à la moitié
+- le résultat du sommeil lors d'un rêve de dragon à la première heure s'affiche normalement
+- lorsque le gardien gère la durée des nuits, en cas de rêve de dragon,
+  les heures dormies sont déduites des heures restant à dormir
 
-- Magie
-  - correction des bonus de cases pour les sorts en Fleuve
+## v11.0.9 - Les Souvenirs de Khrachtchoum le Problémeux
+- mode de saisie de l'archétype en vue détaillée
+- création  une nouvelle incarnation depuis l'archétype
+- réorganisation de la fenêtre de sélection des règles optionnelles
+- correction de l'affichage du type dans les fenêtres d'objets
 
-## 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
+## v11.0.8 - la poigne de Sémolosse
+- lien vers le changelog
+- organisation des compendiums du système
+- 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
 
-## 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
+# v11.0.7
 
-## 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é
+- 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é
 
-- 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
+Cf branche v10 pour l'historique des versions 10
 
-## v10.7.2 - les maux de dents de Semolosse
-- correction des récupérations de blessures
-- la fin de château dormant se passe normalement
-
-## v10.7.1 - L'os de Semolosse
-- Fix rapide sur les jets de carac qui n'étaient plus possibles
-
-## v10.7.0 - L'os de Semolosse
-- 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

module/actor-sheet.js

@@ -7,7 +7,7 @@ import { Misc } from "./misc.js";
 import { RdDCombatManager } from "./rdd-combat.js";
 import { RdDCarac } from "./rdd-carac.js";
 import { DialogSplitItem } from "./dialog-split-item.js";
-import { ReglesOptionelles } from "./settings/regles-optionelles.js";
+import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
 import { RdDSheetUtility } from "./rdd-sheet-utility.js";
 import { STATUSES } from "./settings/status-effects.js";
 import { MAINS_DIRECTRICES } from "./actor.js";
@@ -33,7 +33,8 @@ export class RdDActorSheet extends RdDBaseActorSheet {
       tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }],
       dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }],
       showCompNiveauBase: false,
-      vueDetaillee: false
+      vueDetaillee: false,
+      vueArchetype: false,
     });
   }
 
@@ -56,6 +57,7 @@ export class RdDActorSheet extends RdDBaseActorSheet {
       resumeBlessures: this.actor.computeResumeBlessure(this.actor.system.blessures),
       caracTotal: RdDCarac.computeTotal(this.actor.system.carac, this.actor.system.beaute),
       surEncombrementMessage: this.actor.getMessageSurEncombrement(),
+      malusArmure: this.actor.getMalusArmure()
     })
 
     this.timerRecherche = undefined;
@@ -79,9 +81,12 @@ export class RdDActorSheet extends RdDBaseActorSheet {
       });
 
       // toujours avoir une liste d'armes (pour mettre esquive et corps à corps)
-      formData.combat = duplicate(formData.armes ?? []);
+      const actor = this.actor;
+      formData.combat = duplicate(formData.armes);
       RdDItemArme.computeNiveauArmes(formData.combat, formData.competences);
-      RdDItemArme.ajoutCorpsACorps(formData.combat, formData.competences, formData.system.carac);
+      formData.combat.push(RdDItemArme.mainsNues(actor));
+      formData.combat.push(RdDItemArme.empoignade(actor));
+  
       formData.esquives = this.actor.getCompetences("Esquive");
       formData.combat = RdDCombatManager.listActionsArmes(formData.combat, formData.competences, formData.system.carac);
       formData.empoignades = this.actor.getEmpoignades();
@@ -114,7 +119,7 @@ export class RdDActorSheet extends RdDBaseActorSheet {
   activateListeners(html) {
     super.activateListeners(html);
 
-    HtmlUtility.showControlWhen(this.html.find(".appliquerFatigue"), ReglesOptionelles.isUsing("appliquer-fatigue"));
+    HtmlUtility.showControlWhen(this.html.find(".appliquerFatigue"), ReglesOptionnelles.isUsing("appliquer-fatigue"));
 
     // Everything below here is only needed if the sheet is editable
     if (!this.options.editable) return;
@@ -353,12 +358,19 @@ export class RdDActorSheet extends RdDBaseActorSheet {
         let compName = event.currentTarget.attributes.compname.value;
         this.actor.updateCompetenceXPSort(compName, parseInt(event.target.value));
       });
+      this.html.find('.toggle-archetype').click(async event => {
+        this.options.vueArchetype = !this.options.vueArchetype;
+        this.render(true);
+      });
       // On competence archetype change
       this.html.find('.competence-archetype').change(async event => {
         let compName = event.currentTarget.attributes.compname.value;
         this.actor.updateCompetenceArchetype(compName, parseInt(event.target.value));
       });
     }
+    this.html.find('.nouvelle-incarnation').click(async event => {
+      this.actor.nouvelleIncarnation();
+    });
 
     this.html.find('.show-hide-competences').click(async event => {
       this.options.showCompNiveauBase = !this.options.showCompNiveauBase;
@@ -456,9 +468,9 @@ export class RdDActorSheet extends RdDBaseActorSheet {
 
   /* -------------------------------------------- */
   async selectTypeOeuvreToCreate() {
-    let typeObjets = RdDItem.getTypesOeuvres();
+    let types = RdDItem.getTypesOeuvres();
     let content = `<span class="competence-label">Selectionnez le type d'oeuvre</span><select class="item-type">`;
-    for (let typeName of typeObjets) {
+    for (let typeName of types) {
       content += `<option value="${typeName}">${Misc.typeName('Item', typeName)}</option>`
     }
     content += '</select>';

module/actor.js

@@ -18,7 +18,7 @@ import { RdDAlchimie } from "./rdd-alchimie.js";
 import { STATUSES, StatusEffects } from "./settings/status-effects.js";
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
 import { RdDItemSigneDraconique } from "./item/signedraconique.js";
-import { ReglesOptionelles } from "./settings/regles-optionelles.js";
+import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
 import { EffetsDraconiques } from "./tmr/effets-draconiques.js";
 import { Draconique } from "./tmr/draconique.js";
 import { RdDCarac } from "./rdd-carac.js";
@@ -38,13 +38,14 @@ import { RdDItemBlessure } from "./item/blessure.js";
 import { AppAstrologie } from "./sommeil/app-astrologie.js";
 import { RdDEmpoignade } from "./rdd-empoignade.js";
 import { ExperienceLog, XP_TOPIC } from "./actor/experience-log.js";
+import { TYPES } from "./item.js";
 
 const POSSESSION_SANS_DRACONIC = {
   img: 'systems/foundryvtt-reve-de-dragon/icons/entites/possession.webp',
   name: 'Sans draconic',
   system: {
     niveau: 0,
-    defaut_carac: "reve",
+    defaut_carac: "reve-actuel",
   }
 };
 
@@ -94,7 +95,6 @@ export class RdDActor extends RdDBaseActor {
     this.computeIsHautRevant();
     await this.cleanupConteneurs();
     await this.computeEncTotal();
-    await this.computeMalusArmure();
   }
 
   /* -------------------------------------------- */
@@ -109,7 +109,7 @@ export class RdDActor extends RdDBaseActor {
 
   canReceive(item) {
     if (this.isCreature()) {
-      return item.type == 'competencecreature' || item.isInventaire();
+      return item.type == TYPES.competencecreature || item.isInventaire();
     }
     if (this.isEntite()) {
       return item.type == 'competencecreature';
@@ -133,7 +133,7 @@ export class RdDActor extends RdDBaseActor {
   }
   /* -------------------------------------------- */
   getFatigueActuelle() {
-    if (ReglesOptionelles.isUsing("appliquer-fatigue") && this.isPersonnage()) {
+    if (ReglesOptionnelles.isUsing("appliquer-fatigue") && this.isPersonnage()) {
       return this.system.sante.fatigue?.value;
     }
     return 0;
@@ -217,7 +217,12 @@ export class RdDActor extends RdDBaseActor {
 
   /* -------------------------------------------- */
   getMalusArmure() {
-    return Misc.toInt(this.system.attributs?.malusarmure?.value)
+    if (this.isPersonnage()) {
+      return this.itemTypes[TYPES.armure].filter(it => it.system.equipe)
+        .map(it => it.system.malus)
+        .reduce(Misc.sum(), 0);
+    }
+    return 0;
   }
 
   /* -------------------------------------------- */
@@ -227,12 +232,21 @@ export class RdDActor extends RdDBaseActor {
 
   /* -------------------------------------------- */
   getCompetence(idOrName, options = {}) {
+    if (idOrName instanceof Item) {
+      return idOrName.isCompetence() ? idOrName : undefined
+    }
     return RdDItemCompetence.findCompetence(this.items, idOrName, options)
   }
 
   getCompetences(name) {
     return RdDItemCompetence.findCompetences(this.items, name)
   }
+  getCompetenceCorpsACorps(options = {}) {
+    return this.getCompetence("Corps à corps", options)
+  }
+  getCompetencesEsquive() {
+    return this.getCompetences("esquive")
+  }
   /* -------------------------------------------- */
   getTache(id) {
     return this.findItemLike(id, 'tache');
@@ -260,7 +274,7 @@ export class RdDActor extends RdDBaseActor {
   }
   /* -------------------------------------------- */
   getDraconicList() {
-    return this.items.filter(it => it.isCompetencePersonnage() && it.system.categorie == 'draconic')
+    return this.itemTypes[TYPES.competence].filter(it => it.system.categorie == 'draconic')
   }
   /* -------------------------------------------- */
   getBestDraconic() {
@@ -270,25 +284,26 @@ export class RdDActor extends RdDBaseActor {
   }
 
   getDraconicOuPossession() {
-    const possessions = this.items.filter(it => it.type == 'competencecreature' && it.system.ispossession)
-      .sort(Misc.descending(it => it.system.niveau));
-    if (possessions.length > 0) {
-      return duplicate(possessions[0]);
+    const possession = this.itemTypes[TYPES.competencecreature].filter(it => it.system.categorie == 'possession')
+      .sort(Misc.descending(it => it.system.niveau))
+      .find(it => true);
+    if (possession) {
+      return possession;
     }
     const draconics = [...this.getDraconicList().filter(it => it.system.niveau >= 0),
       POSSESSION_SANS_DRACONIC]
       .sort(Misc.descending(it => it.system.niveau));
-    return duplicate(draconics[0]);
+    return draconics[0];
   }
 
   getPossession(possessionId) {
-    return this.items.find(it => it.type == 'possession' && it.system.possessionid == possessionId);
+    return this.itemTypes[TYPES.possession].find(it => it.system.possessionid == possessionId);
   }
   getPossessions() {
-    return this.items.filter(it => it.type == 'possession');
+    return this.itemTypes[TYPES.possession];
   }
   getEmpoignades() {
-    return this.items.filter(it => it.type == 'empoignade');
+    return this.itemTypes[TYPES.empoignade];
   }
   getDemiReve() {
     return this.system.reve.tmrpos.coord;
@@ -363,7 +378,7 @@ export class RdDActor extends RdDBaseActor {
 
   async _openRollDialog({ name, label, template, rollData, callbackAction }) {
     const dialog = await RdDRoll.create(this, rollData,
-      { html: template },
+      { html: template, close: html => { this.tmrApp?.restoreTMRAfterAction() } },
       {
         name: name,
         label: label,
@@ -374,6 +389,7 @@ export class RdDActor extends RdDBaseActor {
         ]
       });
     dialog.render(true);
+    return dialog
   }
 
 
@@ -385,6 +401,14 @@ export class RdDActor extends RdDBaseActor {
       await this.distribuerStress('stress', consigne.stress.valeur, consigne.stress.motif);
     }
     await this.update({ 'system.sommeil': consigne.sommeil })
+    const player = this.findPlayer();
+    if (player) {
+      ChatUtility.notifyUser(player.id, 'info', `Vous pouvez gérer la nuit de ${this.name}`);
+    }
+  }
+
+  findPlayer() {
+    return game.users.players.find(player => player.active && player.character?.id == this.id);
   }
 
   async onTimeChanging(oldTimestamp, newTimestamp) {
@@ -455,7 +479,7 @@ export class RdDActor extends RdDBaseActor {
 
   /* -------------------------------------------- */
   async dormirChateauDormant() {
-    if (!ReglesOptionelles.isUsing("chateau-dormant-gardien") || !this.system.sommeil || this.system.sommeil.nouveaujour) {
+    if (!ReglesOptionnelles.isUsing("chateau-dormant-gardien") || !this.system.sommeil || this.system.sommeil.nouveaujour) {
       const message = {
         whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
         content: ""
@@ -531,7 +555,7 @@ export class RdDActor extends RdDBaseActor {
   /* -------------------------------------------- */
   async _recuperationBlessures(message, isMaladeEmpoisonne) {
     const timestamp = game.system.rdd.calendrier.getTimestamp()
-    const blessures = this.filterItems(it => it.system.gravite > 0, 'blessure').sort(Misc.ascending(it => it.system.gravite))
+    const blessures = this.filterItems(it => it.system.gravite > 0, TYPES.blessure).sort(Misc.ascending(it => it.system.gravite))
 
     await Promise.all(blessures.map(b => b.recuperationBlessure({
       actor: this,
@@ -545,7 +569,7 @@ export class RdDActor extends RdDBaseActor {
   }
 
   async supprimerBlessures(filterToDelete) {
-    const toDelete = this.filterItems(filterToDelete, 'blessure')
+    const toDelete = this.filterItems(filterToDelete, TYPES.blessure)
       .map(it => it.id);
     await this.deleteEmbeddedDocuments('Item', toDelete);
   }
@@ -553,7 +577,7 @@ export class RdDActor extends RdDBaseActor {
   /* -------------------------------------------- */
   async _recupererVie(message, isMaladeEmpoisonne) {
     const tData = this.system
-    let blessures = this.filterItems(it => it.system.gravite > 0, 'blessure');
+    let blessures = this.filterItems(it => it.system.gravite > 0, TYPES.blessure);
     if (blessures.length > 0) {
       return
     }
@@ -619,21 +643,22 @@ export class RdDActor extends RdDBaseActor {
       whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
       content: this.name + ': '
     };
-    await this.recupereEndurance(message);
-    if (this.system.sommeil?.insomnie || heures == 0) {
+    const insomnie = this.system.sommeil?.insomnie || heures == 0;
+    await this.recupereEndurance({ message: message, demi: insomnie });
+    if (insomnie) {
       message.content += 'Vous ne trouvez pas le sommeil';
     }
     else {
       let jetsReve = [];
       let dormi = await this.dormirDesHeures(jetsReve, message, heures, options);
-      message.content += `Vous dormez ${dormi.heures <= 1 ? 'une heure' : (dormi.heures + ' heures')}. `;
       if (jetsReve.length > 0) {
-        message.content += `Vous récupérez ${jetsReve.filter(it => it >= 0).reduce(Misc.joining("+"))} Points de rêve. `;
+        message.content += `Vous récupérez ${jetsReve.map(it => it < 0 ? '(dragon)' : it).reduce(Misc.joining("+"))} Points de rêve. `;
       }
       if (dormi.etat == 'eveil') {
-        message.content += 'Vous êtes réveillé par un Rêve de Dragon.'
+        await this.reveilReveDeDragon(message, dormi.heures);
       }
       options.chateauDormant = options.chateauDormant && dormi.heures >= heures;
+      message.content += `Vous avez dormi ${dormi.heures <= 1 ? 'une heure' : (dormi.heures + ' heures')}. `;
     }
 
     if (!options.grisReve) {
@@ -647,6 +672,14 @@ export class RdDActor extends RdDBaseActor {
     }
   }
 
+  async reveilReveDeDragon(message, heures) {
+    message.content += 'Vous êtes réveillé par un Rêve de Dragon.';
+    const restant = Math.max(this.system.sommeil?.heures - heures, 0)
+    if (restant > 0) {
+      await this.update({ 'system.sommeil': { heures: restant } });
+    }
+  }
+
   async dormirDesHeures(jetsReve, message, heures, options) {
     const dormi = { heures: 0, etat: 'dort' };
     for (; dormi.heures < heures && dormi.etat == 'dort'; dormi.heures++) {
@@ -700,8 +733,13 @@ export class RdDActor extends RdDBaseActor {
   }
 
   /* -------------------------------------------- */
-  async recupereEndurance(message) {
-    const manquant = this._computeEnduranceMax() - this.system.sante.endurance.value;
+  async recupereEndurance({ message, demi }) {
+    let max = this._computeEnduranceMax();
+    if (demi) {
+      max = Math.floor(max / 2);
+    }
+    const manquant = max - this.system.sante.endurance.value;
+
     if (manquant > 0) {
       await this.santeIncDec("endurance", manquant);
       message.content += `Vous récuperez ${manquant} points d'endurance. `;
@@ -710,7 +748,7 @@ export class RdDActor extends RdDBaseActor {
 
   /* -------------------------------------------- */
   async recupererFatigue(message) {
-    if (ReglesOptionelles.isUsing("appliquer-fatigue")) {
+    if (ReglesOptionnelles.isUsing("appliquer-fatigue")) {
       let fatigue = this.system.sante.fatigue.value;
       const fatigueMin = this._computeFatigueMin();
       if (fatigue <= fatigueMin) {
@@ -778,7 +816,7 @@ export class RdDActor extends RdDBaseActor {
   async combattreReveDeDragon(force) {
     let rollData = {
       actor: this,
-      competence: duplicate(this.getDraconicOuPossession()),
+      competence: this.getDraconicOuPossession(),
       canClose: false,
       rencontre: await game.system.rdd.rencontresTMR.getReveDeDragon(force),
       tmr: true,
@@ -818,7 +856,7 @@ export class RdDActor extends RdDBaseActor {
       system: { sortid: sort._id, draconic: (draconic?.name ?? sort.system.draconic), ptreve: ptreve, coord: coord, heurecible: 'Vaisseau' }
     }],
       { renderSheet: false });
-    this.currentTMR.updateTokens();
+    this.tmrApp.updateTokens();
   }
 
   /* -------------------------------------------- */
@@ -959,9 +997,9 @@ export class RdDActor extends RdDBaseActor {
 
   /* -------------------------------------------- */
   async updateCompetence(idOrName, compValue) {
-    let competence = this.getCompetence(idOrName);
+    const competence = this.getCompetence(idOrName);
     if (competence) {
-      let toNiveau = compValue ?? RdDItemCompetence.getNiveauBase(competence.system.categorie);
+      const toNiveau = compValue ?? RdDItemCompetence.getNiveauBase(competence.system.categorie, competence.getCategories());
       this.notifyCompetencesTronc(competence, toNiveau);
       const fromNiveau = competence.system.niveau;
       await this.updateEmbeddedDocuments('Item', [{ _id: competence.id, 'system.niveau': toNiveau }]);
@@ -1090,7 +1128,7 @@ export class RdDActor extends RdDBaseActor {
       case 'entite': case 'vehicule':
         return 0;
     }
-    return Math.min(0, this.getEncombrementMax() - Math.ceil(Number(this.getEncTotal())));
+    return Math.min(0, Math.floor(this.getEncombrementMax() - this.encTotal));
   }
 
   getMessageSurEncombrement() {
@@ -1118,20 +1156,6 @@ export class RdDActor extends RdDBaseActor {
     }
   }
 
-
-  /* -------------------------------------------- */
-  async computeMalusArmure() {
-    if (this.isPersonnage()) {
-      const malusArmure = this.filterItems(it => it.type == 'armure' && it.system.equipe)
-        .map(it => it.system.malus ?? 0)
-        .reduce(Misc.sum(), 0);
-      // Mise à jour éventuelle du malus armure
-      if (this.system.attributs?.malusarmure?.value != malusArmure) {
-        await this.updateAttributeValue("malusarmure", malusArmure);
-      }
-    }
-  }
-
   /* -------------------------------------------- */
   computeResumeBlessure() {
     const blessures = this.filterItems(it => it.system.gravite > 0, 'blessure')
@@ -1176,7 +1200,7 @@ export class RdDActor extends RdDBaseActor {
     }
     // Pour les autres
     let state = Math.min(this.system.sante.vie.value - this.system.sante.vie.max, 0);
-    if (ReglesOptionelles.isUsing("appliquer-fatigue") && this.system.sante.fatigue) {
+    if (ReglesOptionnelles.isUsing("appliquer-fatigue") && this.system.sante.fatigue) {
       state += RdDUtility.currentFatigueMalus(this.system.sante.fatigue.value, this.system.sante.endurance.max);
     }
     // Ajout de l'éthylisme
@@ -1360,21 +1384,46 @@ export class RdDActor extends RdDBaseActor {
 
   /* -------------------------------------------- */
   async finDeRound(options = { terminer: false }) {
+    await this.$finDeRoundSuppressionEffetsTermines(options);
+    await this.$finDeRoundBlessuresGraves();
+    await this.$finDeRoundSupprimerObsoletes();
+    await this.$finDeRoundEmpoignade();
+  }
+
+  async $finDeRoundSuppressionEffetsTermines(options) {
     for (let effect of this.getEffects()) {
       if (effect.duration.type !== 'none' && (effect.duration.remaining <= 0 || options.terminer)) {
         await effect.delete();
         ChatMessage.create({ content: `${this.name} n'est plus ${Misc.lowerFirst(game.i18n.localize(effect.system.label))} !` });
       }
     }
+  }
+
+  async $finDeRoundBlessuresGraves() {
     if (this.isPersonnage() || this.isCreature()) {
-      const nbGraves = this.filterItems(it => it.isGrave(), 'blessure').length
+      const nbGraves = this.filterItems(it => it.isGrave(), 'blessure').length;
       if (nbGraves > 0) {
         // Gestion blessure graves : -1 pt endurance par blessure grave
-        await this.santeIncDec("endurance", - nbGraves);
+        await this.santeIncDec("endurance", -nbGraves);
       }
     }
   }
 
+  async $finDeRoundSupprimerObsoletes() {
+    const obsoletes = []
+      .concat(this.itemTypes[TYPES.empoignade].filter(it => it.system.pointsemp <= 0))
+      .concat(this.itemTypes[TYPES.possession].filter(it => it.system.compteur < -2 || it.system.compteur > 2))
+      .map(it => it.id);
+    await this.deleteEmbeddedDocuments('Item', obsoletes);
+  }
+
+  async $finDeRoundEmpoignade() {
+    const immobilisations = this.itemTypes[TYPES.empoignade].filter(it => it.system.pointsemp >= 2 && it.system.empoigneurid == this.id);
+    immobilisations.forEach(emp => RdDEmpoignade.onImmobilisation(this,
+      game.actors.get(emp.system.empoigneid),
+      emp
+    ))
+  }
   /* -------------------------------------------- */
   async setSonne(sonne = true) {
     if (this.isEntite()) {
@@ -1478,7 +1527,7 @@ export class RdDActor extends RdDBaseActor {
 
   /* -------------------------------------------- */
   async santeIncDec(name, inc, isCritique = false) {
-    if (name == 'fatigue' && !ReglesOptionelles.isUsing("appliquer-fatigue")) {
+    if (name == 'fatigue' && !ReglesOptionnelles.isUsing("appliquer-fatigue")) {
       return;
     }
     const sante = duplicate(this.system.sante)
@@ -1520,7 +1569,7 @@ export class RdDActor extends RdDBaseActor {
     }
     compteur.value = result.newValue;
     // If endurance lost, then the same amount of fatigue cannot be recovered
-    if (ReglesOptionelles.isUsing("appliquer-fatigue") && sante.fatigue && fatigue > 0) {
+    if (ReglesOptionnelles.isUsing("appliquer-fatigue") && sante.fatigue && fatigue > 0) {
       sante.fatigue.value = Math.max(sante.fatigue.value + fatigue, this._computeFatigueMin());
     }
     await this.update({ "system.sante": sante })
@@ -1679,6 +1728,7 @@ export class RdDActor extends RdDBaseActor {
       await this.rollTache(tache.id);
     }
   }
+
   async actionHerbe(item, onActionItem = async () => { }) {
     if (item.isHerbeAPotion()) {
       return DialogFabriquerPotion.create(this, item, onActionItem);
@@ -1701,6 +1751,7 @@ export class RdDActor extends RdDBaseActor {
   async consommerNourritureboisson(itemId, choix = { doses: 1, seForcer: false, supprimerSiZero: false }, userId = undefined) {
     if (userId != undefined && userId != game.user.id) {
       RdDBaseActor.remoteActorCall({
+        tokenId: this.token?.id,
         actorId: this.id,
         method: 'consommerNourritureboisson',
         args: [itemId, choix, userId]
@@ -2097,12 +2148,11 @@ export class RdDActor extends RdDBaseActor {
       ui.notifications.info(`Aucun sort disponible en ${TMRUtility.getTMR(coord).label} !`);
       return;
     }
-    if (this.currentTMR) this.currentTMR.minimize(); // Hide
 
     const draconicList = this.computeDraconicAndSortIndex(sorts);
     const reve = duplicate(this.system.carac.reve);
 
-    await this._openRollDialog({
+    const dialog = await this._openRollDialog({
       name: 'lancer-un-sort',
       label: 'Lancer un sort',
       template: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-sort.html',
@@ -2118,8 +2168,12 @@ export class RdDActor extends RdDBaseActor {
         diffLibre: RdDItemSort.getDifficulte(sorts[0], -7), // Per default at startup
         coutreve: Array(30).fill().map((item, index) => 1 + index),
       },
-      callbackAction: r => this._rollUnSortResult(r)
+      callbackAction: async r => {
+        await this._rollUnSortResult(r);
+        if (!r.isSortReserve) this.tmrApp?.close();
+      }
     });
+    this.tmrApp?.setTMRPendingAction(dialog);
   }
 
   /* -------------------------------------------- */
@@ -2210,17 +2264,11 @@ export class RdDActor extends RdDBaseActor {
     reveActuel = Math.max(reveActuel - rollData.depenseReve, 0);
     await this.update({ "system.reve.reve.value": reveActuel });
 
-    if (rollData.isSortReserve) {
-      this.currentTMR.maximize(); // Re-display TMR
-    } else {
-      this.currentTMR.close(); // Close TMR !
-    }
     // Final chat message
     await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-sort.html');
 
     if (reveActuel == 0) { // 0 points de reve
       ChatMessage.create({ content: this.name + " est réduit à 0 Points de Rêve, et tombe endormi !" });
-      closeTMR = true;
     }
   }
 
@@ -2295,18 +2343,16 @@ export class RdDActor extends RdDBaseActor {
   /* -------------------------------------------- */
   async rollCompetence(idOrName, options = { tryTarget: true }) {
     RdDEmpoignade.checkEmpoignadeEnCours(this)
-    let rollData = {
-      carac: this.system.carac,
-      competence: this.getCompetence(idOrName)
-    }
-    if (rollData.competence.type == 'competencecreature') {
-      if (rollData.competence.system.iscombat && options.tryTarget && Targets.hasTargets()) {
+    const competence = this.getCompetence(idOrName);
+    let rollData = { carac: this.system.carac, competence: competence }
+    if (competence.type == TYPES.competencecreature) {
+      const arme = RdDItemCompetenceCreature.armeCreature(competence)
+      if (arme && options.tryTarget && Targets.hasTargets()) {
         Targets.selectOneToken(target => {
-          if (rollData.competence.system.ispossession) {
-            RdDPossession.onAttaquePossession(target, this, rollData.competence)
+          if (arme.action == "possession") {
+            RdDPossession.onAttaquePossession(target, this, competence)
           }
           else {
-            const arme = RdDItemCompetenceCreature.armeNaturelle(rollData.competence)
             RdDCombat.rddCombatTarget(target, this).attaque(competence, arme)
           }
         });
@@ -2318,7 +2364,7 @@ export class RdDActor extends RdDBaseActor {
 
     await this._openRollDialog({
       name: 'jet-competence',
-      label: 'Jet ' + Grammar.apostrophe('de', rollData.competence.name),
+      label: 'Jet ' + Grammar.apostrophe('de', competence.name),
       template: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-competence.html',
       rollData: rollData,
       callbackAction: r => this.$onRollCompetence(r, options)
@@ -2422,7 +2468,7 @@ export class RdDActor extends RdDBaseActor {
   /* -------------------------------------------- */
   async _tacheResult(rollData, options) {
     // Mise à jour de la tache
-    rollData.appliquerFatigue = ReglesOptionelles.isUsing("appliquer-fatigue");
+    rollData.appliquerFatigue = ReglesOptionnelles.isUsing("appliquer-fatigue");
     rollData.tache = duplicate(rollData.tache);
     rollData.tache.system.points_de_tache_courant += rollData.rolled.ptTache;
     if (rollData.rolled.isETotal) {
@@ -2682,8 +2728,6 @@ export class RdDActor extends RdDBaseActor {
       ui.notifications.info(`Aucun signe draconiques en ${coord} !`);
       return;
     }
-    if (this.currentTMR) this.currentTMR.minimize(); // Hide
-
     let draconicList = this.getDraconicList()
       .map(draconic => {
         let draconicLecture = duplicate(draconic);
@@ -2706,7 +2750,7 @@ export class RdDActor extends RdDBaseActor {
     const dialog = await RdDRoll.create(this, rollData,
       {
         html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-signedraconique.html',
-        close: html => { this.currentTMR.maximize() } // Re-display TMR
+        close: html => { this.tmrApp?.restoreTMRAfterAction() }
       },
       {
         name: 'lire-signe-draconique',
@@ -2718,6 +2762,7 @@ export class RdDActor extends RdDBaseActor {
       }
     );
     dialog.render(true);
+    this.tmrApp?.setTMRPendingAction(dialog);
   }
 
   /* -------------------------------------------- */
@@ -2736,7 +2781,7 @@ export class RdDActor extends RdDBaseActor {
     }
     await this.deleteEmbeddedDocuments("Item", [rollData.signe._id]);
     await RdDResolutionTable.displayRollData(rollData, this.name, 'chat-resultat-lecture-signedraconique.html');
-    this.currentTMR.close();
+    this.tmrApp.close();
   }
 
   /* -------------------------------------------- */
@@ -2971,8 +3016,8 @@ export class RdDActor extends RdDBaseActor {
 
   /* -------------------------------------------- */
   refreshTMRView() {
-    if (this.currentTMR) {
-      this.currentTMR.externalRefresh();
+    if (this.tmrApp) {
+      this.tmrApp.externalRefresh();
     }
   }
 
@@ -2980,6 +3025,7 @@ export class RdDActor extends RdDBaseActor {
   async displayTMR(mode = "normal") {
     if (this.tmrApp) {
       ui.notifications.warn("Vous êtes déja dans les TMR....");
+      this.tmrApp.forceTMRDisplay();
       return
     }
     if (mode != 'visu' && this.getEffect(STATUSES.StatusDemiReve)) {
@@ -3025,35 +3071,60 @@ export class RdDActor extends RdDBaseActor {
       hasPlayerOwner: this.hasPlayerOwner
     }
 
-    this.currentTMR = await RdDTMRDialog.create(this, tmrFormData);
-    this.currentTMR.render(true);
+    this.tmrApp = await RdDTMRDialog.create(this, tmrFormData);
+    this.tmrApp.render(true);
   }
 
   /* -------------------------------------------- */
-  rollArme(arme) {
+  getCompetenceArme(arme, competenceName) {
+    switch (arme.type) {
+      case TYPES.competencecreature:
+        return arme.name
+      case TYPES.arme:
+        switch (competenceName) {
+          case 'competence': return arme.system.competence;
+          case 'unemain': return RdDItemArme.competence1Mains(arme);
+          case 'deuxmains': return RdDItemArme.competence2Mains(arme);
+          case 'tir': return arme.system.tir;
+          case 'lancer': return arme.system.lancer;
+        }
+    }
+    return undefined
+  }
+
+  /* -------------------------------------------- */
+  /**
+   * 
+   * @param {*} arme item d'arme/compétence de créature
+   * @param {*} categorieArme catégorie d'attaque à utiliser: competence (== melee), lancer, tir; naturelle, possession
+   * @returns 
+   */
+  rollArme(arme, categorieArme = "competence") {
+    let compToUse = this.getCompetenceArme(arme, categorieArme)
     if (!Targets.hasTargets()) {
       RdDConfirm.confirmer({
         settingConfirmer: "confirmer-combat-sans-cible",
-        content: `<p>Voulez vous faire un jet de compétence ${arme.system.competence} sans choisir de cible valide?
+        content: `<p>Voulez vous faire un jet de ${compToUse} sans choisir de cible valide?
                   <br>Tous les jets de combats devront être gérés à la main
                   </p>`,
         title: 'Ne pas utiliser les automatisation de combat',
         buttonLabel: "Pas d'automatisation",
         onAction: async () => {
-          this.rollCompetence(arme.system.competence, { tryTarget: false })
+          this.rollCompetence(compToUse, { tryTarget: false })
         }
       });
       return;
     }
+
     Targets.selectOneToken(target => {
       if (Targets.isTargetEntite(target)) {
         ui.notifications.warn(`Vous ne pouvez pas attaquer une entité non incarnée avec votre ${arme.name}!!!!`);
         return;
       }
 
-
-      const competence = this.getCompetence(arme.system.competence)
-      if (competence.system.ispossession) {
+      const competence = this.getCompetence(compToUse)
+      //console.log("RollArme", competence, arme)
+      if (competence.isCompetencePossession()) {
         return RdDPossession.onAttaquePossession(target, this, competence);
       }
       RdDCombat.rddCombatTarget(target, this).attaque(competence, arme);
@@ -3081,7 +3152,7 @@ export class RdDActor extends RdDBaseActor {
 
   async onRollTachePremiersSoins(blessureId, rollData) {
     if (!this.isOwner) {
-      return RdDBaseActor.remoteActorCall({ actorId: this.id, method: 'onRollTachePremiersSoins', args: [blessureId, rollData] });
+      return RdDBaseActor.remoteActorCall({ tokenId: this.token?.id, actorId: this.id, method: 'onRollTachePremiersSoins', args: [blessureId, rollData] });
     }
     const blessure = this.getItem(blessureId, 'blessure')
     console.log('TODO update blessure', this, blessureId, rollData, rollData.tache);
@@ -3111,7 +3182,7 @@ export class RdDActor extends RdDBaseActor {
 
   async onRollSoinsComplets(blessureId, rollData) {
     if (!this.isOwner) {
-      return RdDBaseActor.remoteActorCall({ actorId: this.id, method: 'onRollSoinsComplets', args: [blessureId, rollData] });
+      return RdDBaseActor.remoteActorCall({ tokenId: this.token?.id, actorId: this.id, method: 'onRollSoinsComplets', args: [blessureId, rollData] });
     }
     const blessure = this.getItem(blessureId, 'blessure')
     if (blessure && blessure.system.premierssoins.done && !blessure.system.soinscomplets.done) {
@@ -3133,9 +3204,7 @@ export class RdDActor extends RdDBaseActor {
 
   /* -------------------------------------------- */
   conjurerPossession(possession) {
-    // TODO: choix de la compétence de draconic ou de possession
-    let draconic = this.getDraconicOuPossession();
-    RdDPossession.onConjurerPossession(this, draconic, possession)
+    RdDPossession.onConjurerPossession(this, possession)
   }
 
   /* -------------------------------------------- */
@@ -3204,25 +3273,32 @@ export class RdDActor extends RdDBaseActor {
     if (attacker && !await attacker.accorder(this, 'avant-encaissement')) {
       return;
     }
-    if (ReglesOptionelles.isUsing('validation-encaissement-gr') && !game.user.isGM) {
+    const attackerId = attacker?.id;
+    if (ReglesOptionnelles.isUsing('validation-encaissement-gr') && !game.user.isGM) {
       RdDBaseActor.remoteActorCall({
+        tokenId: this.token?.id,
         actorId: this.id,
-        method: 'validerEncaissement',
-        args: [rollData, show]
+        method: 'appliquerEncaissement',
+        args: [rollData, show, attackerId]
       });
       return;
     }
+    await this.appliquerEncaissement(rollData, show, attackerId);
+  }
+
+  async appliquerEncaissement(rollData, show, attackerId) {
     const armure = await this.computeArmure(rollData);
-    if (ReglesOptionelles.isUsing('validation-encaissement-gr')) {
-      DialogValidationEncaissement.validerEncaissement(this, rollData, armure, show, (encaissement, show) => this._appliquerEncaissement(encaissement, show, attacker));
+    if (ReglesOptionnelles.isUsing('validation-encaissement-gr')) {
+      DialogValidationEncaissement.validerEncaissement(this, rollData, armure, show, attackerId, (encaissement, show, attackerId) => this._appliquerEncaissement(encaissement, show, attackerId));
     }
     else {
       let encaissement = await RdDUtility.jetEncaissement(rollData, armure, { showDice: SHOW_DICE });
-      await this._appliquerEncaissement(encaissement, show, attacker)
+      await this._appliquerEncaissement(encaissement, show, attackerId);
     }
   }
 
-  async _appliquerEncaissement(encaissement, show, attacker) {
+  async _appliquerEncaissement(encaissement, show, attackedId) {
+    const attacker = attackedId ? game.actors.get(attackedId) : undefined
     let santeOrig = duplicate(this.system.sante);
 
     const blessure = await this.ajouterBlessure(encaissement, attacker); // Will update the result table
@@ -3799,5 +3875,39 @@ export class RdDActor extends RdDBaseActor {
       content: `${this.name} a reçu un/une ${item.type}: ${item.name}, qui ${manualMessage ? "n'est pas" : "est"} géré(e) automatiquement. ${manualMessage ? manualMessage : ''}`
     });
   }
+
+  async nouvelleIncarnation() {
+    let incarnation = this.toObject();
+
+    incarnation.items = Array.from(this.items.filter(it => it.type == TYPES.competence),
+      it => {
+        it = it.toObject();
+        it.id = undefined;
+        it.system.niveau = it.system.base;
+        it.system.niveau_archetype = Math.max(it.system.niveau + (it.system.xp > 0 ? 1 : 0), it.system.niveau_archetype);
+        it.system.xp = 0;
+        it.system.xp_sort = 0;
+        it.system.default_diffLibre = 0;
+        return it;
+      });
+
+    incarnation.name = 'Réincarnation de ' + incarnation.name
+    incarnation.system = {
+      carac: duplicate(this.system.carac),
+      heure: RdDTimestamp.defHeure(await RdDDice.rollTotal("1dh", { rollMode: "selfroll", showDice: SHOW_DICE })).key,
+      age: 18,
+      biographie: '',
+      notes: '',
+      experiencelog: [],
+      'compteurs.experience.value': 3000,
+      'reve.seuil.value': this.system.carac.reve.value,
+      'reve.reve.value': this.system.carac.reve.value,
+      subacteurs: { suivants: [], montures: [], vehicules: [] },
+    }
+    incarnation = await RdDBaseActor.create(incarnation);
+    await incarnation.deleteEmbeddedDocuments('ActiveEffect', incarnation.getEmbeddedCollection("ActiveEffect").map(it => it.id));
+    await incarnation.remiseANeuf();
+    incarnation.sheet.render(true);
+  }
 }
 

module/actor/base-actor-sheet.js

@@ -3,7 +3,8 @@ 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 } from "../item.js";
+import { RdDItem, TYPES } from "../item.js";
+import { RdDItemCompetenceCreature } from "../item-competencecreature.js";
 
 /* -------------------------------------------- */
 /**
@@ -50,16 +51,18 @@ export class RdDBaseActorSheet extends ActorSheet {
       encTotal: await this.actor.computeEncTotal(),
     }
 
-    this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.objets);
-    this._appliquerRechercheObjets(formData.objets, formData.conteneurs);
+    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(objets, conteneurs) {
+  _appliquerRechercheObjets(conteneurs, inventaires) {
     if (this.options.recherche?.text) {
       const recherche = this.options.recherche;
-      const allVisible = objets.filter(it => it.isNomTypeLike(recherche.text)).map(it => it.id);
+      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)
@@ -67,11 +70,11 @@ export class RdDBaseActorSheet extends ActorSheet {
         addVisible = parentsIds.filter(id => !allVisible.includes(id))
       }
       while (addVisible.length > 0)
-      objets.forEach(it => it.system.isHidden = !allVisible.includes(it.id))
+      inventaires.forEach(it => it.system.isHidden = !allVisible.includes(it.id))
       conteneurs.forEach(it => it.system.isHidden = !allVisible.includes(it.id))
     }
     else {
-      objets.forEach(it => it.system.isHidden = false)
+      inventaires.forEach(it => it.system.isHidden = false)
       conteneurs.forEach(it => it.system.isHidden = false)
     }
   }
@@ -118,33 +121,34 @@ export class RdDBaseActorSheet extends ActorSheet {
     formData.herbes = Misc.arrayOrEmpty(itemTypes['herbe']);
     formData.nourritureboissons = Misc.arrayOrEmpty(itemTypes['nourritureboisson']);
     formData.gemmes = Misc.arrayOrEmpty(itemTypes['gemme']);
-    formData.monnaie = Misc.arrayOrEmpty(itemTypes['monnaie']).sort(Monnaie.triValeurEntiere());
+    formData.monnaies = Misc.arrayOrEmpty(itemTypes['monnaie']).sort(Monnaie.triValeurEntiere());
+    formData.objets = Misc.arrayOrEmpty(itemTypes['objet'])
 
-    formData.objets = RdDItem.getItemTypesInventaire('all')
+    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 );
+  }
+
+  /* -------------------------------------------- */  /** @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;
 
@@ -230,9 +234,9 @@ export class RdDBaseActorSheet extends ActorSheet {
 
   /* -------------------------------------------- */
   async selectObjetTypeToCreate() {
-    let typeObjets = this.getTypesInventaire().sort(Misc.ascending(type => Misc.typeName('Item', type)));
+    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 typeObjets) {
+    for (let typeName of types) {
       content += `<option value="${typeName}">${Misc.typeName('Item', typeName)}</option>`
     }
     content += '</select>';

module/actor/base-actor.js

@@ -3,6 +3,7 @@ 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";
@@ -49,7 +50,13 @@ export class RdDBaseActor extends Actor {
 
   static onRemoteActorCall(callData, userId) {
     if (userId == game.user.id) {
-      const actor = game.actors.get(callData?.actorId);
+      let actor = game.actors.get(callData?.actorId);
+      if ( callData.tokenId) {
+        let token = canvas.tokens.placeables.find(t => t.id == callData.tokenId)
+        if (token) {
+          actor = token.actor
+        }
+      }
       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, ')');
@@ -118,7 +125,7 @@ export class RdDBaseActor extends Actor {
   }
 
   listItems(type = undefined) { return (type ? this.itemTypes[type] : this.items); }
-  filterItems(filter, type = undefined) { return type ? this.itemTypes[type]?.filter(filter) ?? [] : []; }
+  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) });
@@ -143,6 +150,19 @@ export class RdDBaseActor extends Actor {
       .forEach(async it => await it.onFinPeriodeTemporel(oldTimestamp, newTimestamp))
   }
 
+  async creerObjetParMJ(object) {
+    if (!Misc.isUniqueConnectedGM()) {
+      RdDBaseActor.remoteActorCall({
+        tokenId: this.token?.id,
+        actorId: this.id,
+        method: 'creerObjetParMJ',
+        args: [object]
+      });
+      return;
+    }
+    await this.createEmbeddedDocuments('Item', [object])
+  }
+
   /* -------------------------------------------- */
   getFortune() {
     return Monnaie.getFortune(this.itemTypes['monnaie']);
@@ -207,6 +227,7 @@ export class RdDBaseActor extends Actor {
     if (fromActorId && !game.user.isGM) {
       RdDBaseActor.remoteActorCall({
         userId: Misc.connectedGMOrUser(),
+        tokenId: this.token?.id,
         actorId: this.id,
         method: 'ajouterSols', args: [sols, fromActorId]
       });
@@ -247,13 +268,12 @@ export class RdDBaseActor extends Actor {
     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) ?? achat.vente.item;
+    const itemVendu = vendeur?.getItem(achat.vente.item._id) ?? game.items.get(achat.vente.item._id);
     if (!itemVendu) {
-      ui.notifications.warn("Erreur sur achat: rien à acheter<br>Si possible, transmettez les logs de la console aux développeurs");
-      console.log('Erreur sur achat: rien à acheter', achat);
+      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 (!this.verifierQuantite(vendeur, itemVendu, quantite)) {
+    if (vendeur && !vendeur.verifierQuantite(itemVendu, quantite)) {
       ChatUtility.notifyUser(achat.userId, 'warn', `Le vendeur n'a pas assez de ${itemVendu.name} !`);
       return
     }
@@ -264,7 +284,7 @@ export class RdDBaseActor extends Actor {
     await this.decrementerVente(vendeur, itemVendu, quantite, cout);
     if (acheteur) {
       await acheteur.depenserSols(cout);
-      const createdItemId = await acheteur.creerQuantiteItem(achat.vente.item, quantite);
+      const createdItemId = await acheteur.creerQuantiteItem(itemVendu, quantite);
       await acheteur.consommerNourritureAchetee(achat, achat.vente, createdItemId);
     }
     if (cout > 0) {
@@ -305,9 +325,9 @@ export class RdDBaseActor extends Actor {
     return this.getFortune() >= cout;
   }
 
-  verifierQuantite(vendeur, item, quantiteTotal) {
-    const disponible = vendeur?.getQuantiteDisponible(item);
-    return disponible == undefined || disponible >= quantiteTotal;
+  verifierQuantite(item, quantiteDemande) {
+    const disponible = this.getQuantiteDisponible(item);
+    return disponible == undefined || disponible >= quantiteDemande;
   }
 
   async consommerNourritureAchetee(achat, vente, createdItemId) {
@@ -435,62 +455,33 @@ export class RdDBaseActor extends Actor {
 
 
   /* -------------------------------------------- */
-  conteneurPeutContenir(dest, item) {
+  conteneurPeutContenir(dest, moved) {
     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 !
+    if (moved.isConteneurContenu(dest)) {
+      ui.notifications.warn(`Impossible de déplacer un conteneur parent (${moved.name}) dans un de ses contenus ${dest.name} !`);
+      return false;
     }
 
     // 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
+    const encContenu = dest.getEncContenu();
+    const newEnc = moved.getEncTotal(); // Calculer le total actuel du nouvel objet
+    const placeDisponible = Math.roundDecimals(dest.system.capacite - encContenu - newEnc, 4)
 
     // Teste si le conteneur de destination a suffisament de capacité pour recevoir le nouvel objet
-    if (Number(destData.system.capacite) < encContenu + newEnc) {
+    if (placeDisponible < 0) {
       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}!`);
+        `Le conteneur ${dest.name} a une capacité de ${dest.system.capacite}, et contient déjà ${encContenu}.
+        Impossible d'y ranger: ${moved.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 */

module/actor/commerce.js

@@ -22,12 +22,13 @@ export class RdDCommerce extends RdDBaseActor {
   }
 
   getQuantiteDisponible(item) {
-    return this.system.illimite || item.isService() ? undefined : item.getQuantite();
+    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

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

@@ -114,7 +114,7 @@ export class DialogChronologie extends Dialog {
         heure: RdDTimestamp.definition(this.html.find("form.rdddialogchrono :input[name='chronologie.heure']").val()),
         minute: this.html.find("form.rdddialogchrono :input[name='chronologie.minute']").val(),
       },
-      dateReel: this.html.find("form.rdddialogchrono :input[name='dateReel']").val()
+      dateReel: this.html.find("form.rdddialogchrono :input[name='dateReel']").val().replace('T', ' ')
     }
   }
 

module/dialog-create-signedraconique.js

@@ -111,7 +111,7 @@ export class DialogCreateSigneDraconique extends Dialog {
 
   onSelectTmr(event) {
     const tmrName = this.html.find(event.currentTarget)?.data("tmr-name");
-    const onTmr = this.tmrs.find(it => it.name == tmrName);
+    const onTmr = this.dialogData.tmrs.find(it => it.name == tmrName);
     if (onTmr){
       onTmr.selected = event.currentTarget.checked;
     }

module/dialog-validation-encaissement.js

@@ -7,7 +7,7 @@ import { RdDUtility } from "./rdd-utility.js";
  */
 export class DialogValidationEncaissement extends Dialog {
 
-  static async validerEncaissement(actor, rollData, armure, show, 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,12 +15,12 @@ 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.onValider() },
@@ -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 };
   }
@@ -66,6 +67,6 @@ export class DialogValidationEncaissement extends Dialog {
 
   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/item-arme.js

@@ -1,4 +1,5 @@
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js"
+import { TYPES } from "./item.js";
 import { RdDCombatManager } from "./rdd-combat.js";
 
 const nomCategorieParade = {
@@ -19,15 +20,15 @@ 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 == TYPES.arme;
   }
 
   /* -------------------------------------------- */
   static getArme(arme) {
     switch (arme ? arme.type : '') {
-      case 'arme': return arme;
-      case 'competencecreature':
-        return RdDItemCompetenceCreature.armeNaturelle(arme);
+      case TYPES.arme: return arme;
+      case TYPES.competencecreature:
+        return RdDItemCompetenceCreature.armeCreature(arme);
     }
     return RdDItemArme.mainsNues();
   }
@@ -67,14 +68,14 @@ export class RdDItemArme extends Item {
       return armeData.system.categorie_parade;
     }
     // pour compatibilité avec des personnages existants
-    if (armeData.type == 'competencecreature' || armeData.system.categorie == 'creature') {
+    if (armeData.type == TYPES.competencecreature || armeData.system.categorie == 'creature') {
       return armeData.system.categorie_parade || (armeData.system.isparade ? 'armes-naturelles' : '');
     }
     if (!armeData.type.match(/arme|competencecreature/)) {
       return '';
     }
     if (armeData.system.competence == undefined) {
-      return 'competencecreature';
+      return TYPES.competencecreature;
     }
     let compname = armeData.system.competence.toLowerCase();
     if (compname.match(/^(dague de jet|javelot|fouet|arc|arbalête|fronde|hache de jet|fléau)$/)) return '';
@@ -156,23 +157,33 @@ export class RdDItemArme extends Item {
     }
     return armeData;
   }
+  static competence2Mains(arme) {
+    return arme.system.competence.replace(" 1 main", " 2 mains");
+  }
+
+  static competence1Mains(arme) {
+    return arme.system.competence.replace(" 2 mains", " 1 main");
+  }
 
   static isArmeUtilisable(arme) {
     return arme.type == 'arme' && arme.system.equipe && (arme.system.resistance > 0 || arme.system.portee_courte > 0);
   }
 
-  static ajoutCorpsACorps(armes, competences, carac) {
-    let corpsACorps = competences.find(it => it.name == 'Corps à corps') ?? { system: { niveau: -6 } };
-    let init = RdDCombatManager.calculInitiative(corpsACorps.system.niveau, carac['melee'].value);
-    armes.push(RdDItemArme.mainsNues({ niveau: corpsACorps.system.niveau, initiative: init }));
-    armes.push(RdDItemArme.empoignade({ niveau: corpsACorps.system.niveau, initiative: init }));
+  static ajoutCorpsACorps(armes, actor) {
+    armes.push(RdDItemArme.mainsNues(actor));
+    armes.push(RdDItemArme.empoignade(actor));
   }
 
-  static corpsACorps(mainsNuesActor) {
-    const corpsACorps = {
+  static corpsACorps(actor) {
+    let competence = actor?.getCompetenceCorpsACorps() ?? { system: { niveau: -6 } };
+    let melee = actor? actor.system.carac['melee'].value : 0
+    return {
+      _id: competence?.id,
       name: 'Corps à corps',
+      type: TYPES.arme,
       img: 'systems/foundryvtt-reve-de-dragon/icons/competence_corps_a_corps.webp',
       system: {
+        initiative: RdDCombatManager.calculInitiative(competence.system.niveau, melee),
         equipe: true,
         rapide: true,
         force: 0,
@@ -180,23 +191,22 @@ export class RdDItemArme extends Item {
         dommagesReels: 0,
         mortalite: 'non-mortel',
         competence: 'Corps à corps',
+        deuxmains: true,
         categorie_parade: 'sans-armes'
       }
-    };
-    mergeObject(corpsACorps.system, mainsNuesActor ?? {}, { overwrite: false });
-    return corpsACorps;
+    }
   }
 
-  static mainsNues(mainsNuesActor) {
-    const mainsNues = RdDItemArme.corpsACorps(mainsNuesActor)
+  static mainsNues(actor) {
+    const mainsNues = RdDItemArme.corpsACorps(actor)
     mainsNues.name = 'Mains nues'
     mainsNues.system.cac = 'pugilat'
     mainsNues.system.baseInit = 4
     return mainsNues;
   }
-  
-  static empoignade(mainsNuesActor) {
-    const empoignade = RdDItemArme.corpsACorps(mainsNuesActor)
+
+  static empoignade(actor) {
+    const empoignade = RdDItemArme.corpsACorps(actor)
     empoignade.name = 'Empoignade'
     empoignade.system.cac = 'empoignade'
     empoignade.system.baseInit = 3

module/item-competence.js

@@ -8,22 +8,22 @@ const xp_par_niveau = [5, 5, 5, 10, 10, 10, 10, 15, 15, 15, 15, 20, 20, 20, 20,
 const niveau_max = xp_par_niveau.length - 10;
 /* -------------------------------------------- */
 const limitesArchetypes = [
-  { "niveau": 0, "nombreMax": 100, "reste": 100 },
-  { "niveau": 1, "nombreMax": 10, "reste": 10 },
-  { "niveau": 2, "nombreMax": 9, "reste": 9 },
-  { "niveau": 3, "nombreMax": 8, "reste": 8 },
-  { "niveau": 4, "nombreMax": 7, "reste": 7 },
-  { "niveau": 5, "nombreMax": 6, "reste": 6 },
-  { "niveau": 6, "nombreMax": 5, "reste": 5 },
-  { "niveau": 7, "nombreMax": 4, "reste": 4 },
-  { "niveau": 8, "nombreMax": 3, "reste": 3 },
-  { "niveau": 9, "nombreMax": 2, "reste": 2 },
-  { "niveau": 10, "nombreMax": 1, "reste": 1 },
-  { "niveau": 11, "nombreMax": 1, "reste": 1 }
+  { niveau: 0, nombreMax: 100 },
+  { niveau: 1, nombreMax: 10 },
+  { niveau: 2, nombreMax: 9 },
+  { niveau: 3, nombreMax: 8 },
+  { niveau: 4, nombreMax: 7 },
+  { niveau: 5, nombreMax: 6 },
+  { niveau: 6, nombreMax: 5 },
+  { niveau: 7, nombreMax: 4 },
+  { niveau: 8, nombreMax: 3 },
+  { niveau: 9, nombreMax: 2 },
+  { niveau: 10, nombreMax: 1 },
+  { niveau: 11, nombreMax: 1 },
 ];
 
 /* -------------------------------------------- */
-const categorieCompetences = {
+const categoriesCompetences = {
   "generale": { base: -4, label: "Générales" },
   "particuliere": { base: -8, label: "Particulières" },
   "specialisee": { base: -11, label: "Spécialisées" },
@@ -49,16 +49,16 @@ const competence_xp_cumul = _buildCumulXP();
 
 export class RdDItemCompetence extends Item {
   /* -------------------------------------------- */
-  static getCategorieCompetences() {
-    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;
   }
 
   /* -------------------------------------------- */
@@ -79,10 +79,9 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   static isCompetenceArme(competence) {
-    if (competence.isCompetence()) {
+    if (competence.isCompetence() && !competence.isCorpsACorps() && !competence.isEsquive()) {
       switch (competence.system.categorie) {
         case 'melee':
-          return !Grammar.toLowerCaseNoAccent(competence.name).includes('esquive');
         case 'tir':
         case 'lancer':
           return true;
@@ -93,10 +92,10 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   static isArmeUneMain(competence) {
-    return RdDItemCompetence.isCompetenceArme(competence) && competence.name.toLowerCase().includes("1 main");
+    return competence.isCompetenceArme() && competence.name.toLowerCase().includes("1 main");
   }
   static isArme2Main(competence) {
-    return RdDItemCompetence.isCompetenceArme(competence) && competence.name.toLowerCase().includes("2 main");
+    return competence.isCompetenceArme() && competence.name.toLowerCase().includes("2 main");
   }
 
   static isThanatos(competence) {
@@ -192,7 +191,7 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   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());
   }
 
   /* -------------------------------------------- */
@@ -259,13 +258,17 @@ export class RdDItemCompetence extends Item {
   /* -------------------------------------------- */
   static computeResumeArchetype(competences) {
     const computed = duplicate(limitesArchetypes);
+    computed.forEach(it => { it.nombre = 0; it.reste = it.nombreMax; });
+
     competences.map(it => Math.max(0, it.system.niveau_archetype))
       .filter(n => n > 0)
       .forEach(n => {
-        computed[n] = computed[n] ?? { niveau: n, nombreMax: 0, reste: 0 };
-        computed[n].reste = computed[n].reste - 1;
+        computed[n] = computed[n] ?? { niveau: n, nombreMax: 0, reste: 0, nombre: 0 };
+        computed[n].reste--;
+        computed[n].nombre++;
+
       });
-      return computed.filter(it => it.reste > 0 && it.niveau > 0);
+    return computed.filter(it => it.niveau > 0);
   }
 
   /* -------------------------------------------- */

module/item-competencecreature.js

@@ -1,51 +1,97 @@
 
+import { 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-sheet.js

@@ -5,12 +5,14 @@ import { RdDItemCompetence } from "./item-competence.js";
 import { RdDHerbes } from "./rdd-herbes.js";
 import { RdDGemme } from "./rdd-gemme.js";
 import { HtmlUtility } from "./html-utility.js";
-import { ReglesOptionelles } from "./settings/regles-optionelles.js";
+import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
 import { SYSTEM_RDD } from "./constants.js";
 import { RdDSheetUtility } from "./rdd-sheet-utility.js";
 import { SystemCompendiums } from "./settings/system-compendiums.js";
 import { Misc } from "./misc.js";
 import { RdDTimestamp } from "./time/rdd-timestamp.js";
+import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
+import { TYPES } from "./item.js";
 
 /**
  * Extend the basic ItemSheet for RdD specific items
@@ -98,16 +100,20 @@ export class RdDItemSheet extends ItemSheet {
       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('personnage');
-    formData.categorieCompetences = RdDItemCompetence.getCategorieCompetences()
+    formData.categories = this.item.getCategories()
     if (this.item.type == 'tache' || this.item.type == 'livre' || this.item.type == 'meditation' || this.item.type == 'oeuvre') {
       formData.caracList = duplicate(game.system.model.Actor.personnage.carac)
       formData.caracList["reve-actuel"] = duplicate(game.system.model.Actor.personnage.reve.reve)
       formData.competences = competences;
     }
     if (this.item.type == 'arme') {
-      formData.competences = competences.filter(it => RdDItemCompetence.isCompetenceArme(it))
+      formData.competences = competences.filter(it => it.isCompetenceArme())
     }
     if (['sort', 'sortreserve'].includes(this.item.type)) {
       formData.competences = competences.filter(it => RdDItemCompetence.isDraconic(it));
@@ -151,7 +157,7 @@ export class RdDItemSheet extends ItemSheet {
     super.activateListeners(html);
     this.html = html;
 
-    HtmlUtility.showControlWhen(this.html.find(".item-cout"), ReglesOptionelles.isUsing('afficher-prix-joueurs')
+    HtmlUtility.showControlWhen(this.html.find(".item-cout"), ReglesOptionnelles.isUsing('afficher-prix-joueurs')
       || game.user.isGM
       || !this.item.isOwned);
     HtmlUtility.showControlWhen(this.html.find(".item-magique"), this.item.isMagique());
@@ -249,7 +255,8 @@ export class RdDItemSheet extends ItemSheet {
     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);
     }

module/item.js

@@ -6,44 +6,55 @@ 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";
 
 export const TYPES = {
   competence: 'competence',
   competencecreature: 'competencecreature',
+  empoignade: 'empoignade',
+  possession: 'possession',
+  blessure: 'blessure',
+  maladie: 'maladie',
+  poison: 'poison',
   arme: 'arme',
   armure: 'armure',
   conteneur: 'conteneur',
-  sort: 'sort',
+  objet: 'objet',
+  monnaie: 'monnaie',
+  gemme: 'gemme',
+  munition: 'munition',
+  nourritureboisson: 'nourritureboisson',
   herbe: 'herbe',
-  faune: 'faune',
+  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',
-  recettealchimique: 'recettealchimique',
-  chant: 'chant',
-  danse: 'danse',
-  jeu: 'jeu',
-  recettecuisine: 'recettecuisine',
-  musique: 'musique',
-  maladie: 'maladie',
-  poison: 'poison',
-  oeuvre: 'oeuvre',
-  nourritureboisson: 'nourritureboisson',
-  service: 'service',
   signedraconique: 'signedraconique',
-  gemme: 'gemme',
-  possession: 'possession',
-  sortreserve: 'sortreserve',
-  extraitpoetique: 'extraitpoetique',
   tarot: 'tarot',
-  empoignade: 'empoignade'
+  nombreastral: 'nombreastral',
+  extraitpoetique: 'extraitpoetique',
 }
+
 const typesInventaireMateriel = [
   TYPES.arme,
   TYPES.armure,
@@ -209,6 +220,33 @@ export class RdDItem extends Item {
   isService() { return this.type == TYPES.service; }
 
   isCompetence() { return typesObjetsCompetence.includes(this.type) }
+  isEsquive() {
+    return (this.isCompetence()
+      && this.system.categorie == 'melee'
+      && Grammar.includesLowerCaseNoAccent(this.name, 'Esquive'));
+  }
+
+  isCorpsACorps() {
+    return (this.isCompetence()
+      && this.system.categorie == 'melee'
+      && Grammar.includesLowerCaseNoAccent(this.name, 'Corps à Corps'));
+  }
+
+  isCompetenceArme() {
+    if (this.isCompetence()) {
+      switch (this.system.categorie) {
+        case 'melee':
+          return !this.isCorpsACorps() && !this.isEsquive()
+        case 'tir':
+        case 'lancer':
+          return true;
+      }
+    }
+    return false;
+  }
+
+
+  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) }
@@ -225,6 +263,13 @@ export class RdDItem extends Item {
   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;
@@ -361,7 +406,7 @@ export class RdDItem extends Item {
   }
 
   getEncTotal() {
-    return (this.isService() ? 0 : this.getQuantite()) * this.getEnc();
+    return (this.getQuantite() ?? 0) * this.getEnc();
   }
 
   getEnc() {
@@ -376,6 +421,16 @@ export class RdDItem extends Item {
     return Math.max(this.system.encombrement ?? 0, 0);
   }
 
+  getEncContenu() {
+    return this.getContenu()
+      .map(it => it.getRecursiveEnc())
+      .reduce(Misc.sum(), 0);
+  }
+
+  getRecursiveEnc() {
+    return this.getEncTotal() + this.getEncContenu()
+  }
+
   getEncHerbe() {
     switch (this.system.categorie) {
       case 'Repos': case 'Soin': case 'Alchimie':
@@ -385,6 +440,18 @@ export class RdDItem extends Item {
 
   }
 
+  getContenu() {
+    if (this.isConteneur()) {
+      return this.system.contenu.map(idContenu => this.actor.getItem(idContenu));
+    }
+    return []
+  }
+
+  isConteneurContenu(conteneur) {
+    return this.getContenu()
+      .find(it => it.id == conteneur.id || it.isConteneurContenu(conteneur))
+  }
+
   valeurTotale() {
     return (this.isService() ? 1 : this.getQuantite()) * this.valeur()
   }
@@ -656,7 +723,7 @@ export class RdDItem extends Item {
   _armeChatData() {
     return [
       `<b>Compétence</b>: ${this.system.competence}`,
-      `<b>Dommages</b>: ${this.system.dommages}`,
+      `<b>Dommages</b>: ${this.system.dommages} ${this.system.mortalite == 'non-mortel' ? '(Non mortel)' : ''}`,
       `<b>Force minimum</b>: ${this.system.force}`,
       `<b>Resistance</b>: ${this.system.resistance}`,
       ...this._inventaireTemplateChatData()

module/item/armure.js

@@ -1,6 +1,6 @@
 import { RdDItem } from "../item.js";
 import { Misc } from "../misc.js";
-import { ReglesOptionelles } from "../settings/regles-optionelles.js";
+import { ReglesOptionnelles } from "../settings/regles-optionnelles.js";
 
 export class RdDItemArmure extends RdDItem {
 
@@ -9,7 +9,7 @@ export class RdDItemArmure extends RdDItem {
   }
 
   deteriorerArmure(dmg) {
-    if (!ReglesOptionelles.isUsing('deteriorationArmure') || this.system.protection == '0') {
+    if (!ReglesOptionnelles.isUsing('deteriorationArmure') || this.system.protection == '0') {
       return;
     }
     let deterioration = (this.system.deterioration ?? 0) + dmg;

module/item/sheet-conteneur.js

@@ -29,7 +29,7 @@ export class RdDConteneurItemSheet extends RdDItemInventaireSheet {
   /* -------------------------------------------- */
   prepareConteneurData(formData) {
     RdDBaseActorSheet.filterItemsPerTypeForSheet(formData, this.actor.itemTypes);
-    this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.objets);
+    this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.inventaires);
     formData.subItems = formData.conteneurs.find(it => it._id == this.item.id)?.subItems;
   }
 

module/migrations.js

@@ -2,7 +2,7 @@ import { RdDBaseActor } from "./actor/base-actor.js";
 import { LOG_HEAD, SYSTEM_RDD } from "./constants.js";
 import { Grammar } from "./grammar.js";
 import { Monnaie } from "./item-monnaie.js";
-import { RdDItem } from "./item.js";
+import { RdDItem, TYPES } from "./item.js";
 import { RdDTimestamp } from "./time/rdd-timestamp.js";
 import { RdDRaretes } from "./item/raretes.js";
 
@@ -13,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,
@@ -24,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);
@@ -65,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"; }
@@ -370,6 +369,7 @@ class _10_4_6_ServicesEnCommerces extends Migration {
     return itemToCreate;
   }
 }
+
 class _10_5_0_UpdatePeriodicite extends Migration {
   get code() { return "migration-periodicite-poisons-maladies"; }
   get version() { return "10.5.0"; }
@@ -458,6 +458,62 @@ class _10_7_0_MigrationBlessures extends Migration {
   }
 }
 
+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() {
     return [
@@ -474,6 +530,8 @@ export class Migrations {
       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(),
     ];
   }
 
@@ -490,7 +548,7 @@ 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) => this.compareVersions(a, b));

module/misc.js

@@ -42,7 +42,7 @@ export class Misc {
   }
 
   static typeName(type, subType) {
-    return subType ? game.i18n.localize(`${type.toUpperCase()}.Type${Misc.upperFirst(subType)}`)
+    return subType ? game.i18n.localize(`TYPES.${type}.${Misc.upperFirst(subType)}`)
       : '';
   }
 

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 },
@@ -27,6 +28,9 @@ export class RdDBonus {
     if (rollData.isEmpoignade && rollData.rolled?.isPart) {
       return true
     }
+    if (RdDPossession.isDefensePossession(rollData)) {
+      return RdDPossession.isPossessionFinesse(rollData)
+    }
     return rollData.attackerRoll?.particuliere == 'finesse';
   }
 
@@ -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-carac.js

@@ -58,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

@@ -9,7 +9,7 @@ import { RdDBonus } from "./rdd-bonus.js";
 import { RdDResolutionTable } from "./rdd-resolution-table.js";
 import { RdDRoll } from "./rdd-roll.js";
 import { RdDRollTables } from "./rdd-rolltables.js";
-import { ReglesOptionelles } from "./settings/regles-optionelles.js";
+import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
 import { STATUSES } from "./settings/status-effects.js";
 import { Targets } from "./targets.js";
 import { RdDEmpoignade } from "./rdd-empoignade.js";
@@ -75,7 +75,7 @@ export class RdDCombatManager extends Combat {
       }
     }
   }
-
+  
   /************************************************************************************/
   async rollInitiative(ids, formula = undefined, messageOptions = {}) {
     console.log(`${game.system.title} | Combat.rollInitiative()`, ids, formula, messageOptions);
@@ -87,7 +87,7 @@ 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);
           }
@@ -171,8 +171,7 @@ export class RdDCombatManager extends Combat {
         if (arme.system.unemain && arme.system.deuxmains && !dommages.includes("/")) {
           ui.notifications.info("Les dommages de l'arme à 1/2 mains " + arme.name + " ne sont pas corrects (ie sous la forme X/Y)");
         }
-        if ((arme.system.unemain && arme.system.competence) ||
-          (arme.system.competence.toLowerCase().includes("corps à corps"))) {
+        if (arme.system.unemain && arme.system.competence) {
           actions.push(RdDCombatManager.$prepareAttaqueArme({
             arme: arme,
             infoMain: "(1 main)",
@@ -187,7 +186,7 @@ export class RdDCombatManager extends Combat {
             arme: arme,
             infoMain: "(2 mains)",
             dommagesReel: Number(tableauDommages[1]),
-            competence: arme.system.competence.replace(" 1 main", " 2 mains"),
+            competence: RdDItemArme.competence2Mains(arme),
             carac: carac,
             competences: competences
           }));
@@ -230,15 +229,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,
@@ -255,15 +254,14 @@ export class RdDCombatManager extends Combat {
       return actions;
     }
     if (actor.isCreatureEntite()) {
-      actions = actions.concat(RdDCombatManager.listActionsCreature(actor.itemTypes['competencecreature']));
+      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.mainsNues());
-
       const competences = actor.itemTypes['competence'];
-      actions = actions.concat(RdDCombatManager.listActionsArmes(armes, competences, actor.system.carac));
+      const armes = actor.itemTypes['arme'].filter(it => RdDItemArme.isArmeUtilisable(it))
+        .concat(RdDItemArme.empoignade(actor))
+        .concat(RdDItemArme.mainsNues(actor));
+      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" } });
@@ -351,7 +349,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"
@@ -789,7 +787,6 @@ export class RdDCombat {
     let rollData = {
       passeArme: randomID(16),
       mortalite: arme?.system.mortalite,
-      coupsNonMortels: false,
       competence: competence,
       surprise: this.attacker.getSurprise(true),
       surpriseDefenseur: this.defender.getSurprise(true),
@@ -886,8 +883,8 @@ export class RdDCombat {
     }
 
     // # utilisation esquive
-    const corpsACorps = this.defender.getCompetence("Corps à corps", { onMessage: it => console.info(it, this.defender) });
-    const esquives = duplicate(this.defender.getCompetences("esquive", { onMessage: it => console.info(it, this.defender) }))
+    const corpsACorps = this.defender.getCompetenceCorpsACorps({ onMessage: it => console.info(it, this.defender) });
+    const esquives = duplicate(this.defender.getCompetencesEsquive())
     esquives.forEach(e => e.system.nbUsage = e?._id ? this.defender.getItemUse(e._id) : 0);
 
     const paramChatDefense = {
@@ -1048,7 +1045,7 @@ export class RdDCombat {
       competence: this.defender.getCompetence(competenceParade),
       arme: armeParade,
       surprise: this.defender.getSurprise(true),
-      needParadeSignificative: ReglesOptionelles.isUsing('categorieParade') && RdDItemArme.needParadeSignificative(attackerRoll.arme, armeParade),
+      needParadeSignificative: ReglesOptionnelles.isUsing('categorieParade') && RdDItemArme.needParadeSignificative(attackerRoll.arme, armeParade),
       needResist: RdDItemArme.needArmeResist(attackerRoll.arme, armeParade),
       carac: this.defender.system.carac,
       show: {}
@@ -1166,7 +1163,7 @@ export class RdDCombat {
 
   /* -------------------------------------------- */
   async computeDeteriorationArme(defenderRoll) {
-    if (!ReglesOptionelles.isUsing('resistanceArmeParade')) {
+    if (!ReglesOptionnelles.isUsing('resistanceArmeParade')) {
       return;
     }
     const attackerRoll = defenderRoll.attackerRoll;
@@ -1215,7 +1212,7 @@ export class RdDCombat {
           }
         }
         // Si l'arme de parade n'est pas un bouclier, jet de désarmement (p.132)
-        if (ReglesOptionelles.isUsing('defenseurDesarme') && resistance > 0 && RdDItemArme.getCategorieParade(defenderRoll.arme) != 'boucliers') {
+        if (ReglesOptionnelles.isUsing('defenseurDesarme') && resistance > 0 && RdDItemArme.getCategorieParade(defenderRoll.arme) != 'boucliers') {
           let desarme = await RdDResolutionTable.rollData({
             caracValue: this.defender.getForce(),
             finalLevel: Misc.toInt(defenderRoll.competence.system.niveau) - dmg,
@@ -1230,7 +1227,7 @@ export class RdDCombat {
   /* -------------------------------------------- */
   async computeRecul(defenderRoll) { // Calcul du recul (p. 132)
     const attackerRoll = defenderRoll.attackerRoll;
-    if (ReglesOptionelles.isUsing('recul') && this._isForceOuCharge(attackerRoll)) {
+    if (ReglesOptionnelles.isUsing('recul') && this._isForceOuCharge(attackerRoll)) {
       const impact = this._computeImpactRecul(attackerRoll);
       const rollRecul = await RdDResolutionTable.rollData({ caracValue: 10, finalLevel: impact });
       if (rollRecul.rolled.isSuccess) {

module/rdd-confirm.js

@@ -1,10 +1,10 @@
 import { Grammar } from "./grammar.js";
-import { ReglesOptionelles } from "./settings/regles-optionelles.js";
+import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
 
 export class RdDConfirm {
   /* -------------------------------------------- */
   static confirmer(options, autresActions) {
-    options.bypass = options.bypass || !(options.settingConfirmer == undefined || ReglesOptionelles.isUsing(options.settingConfirmer));
+    options.bypass = options.bypass || !(options.settingConfirmer == undefined || ReglesOptionnelles.isUsing(options.settingConfirmer));
     if (options.bypass) {
       options.onAction();
     }
@@ -47,7 +47,7 @@ export class RdDConfirm {
         icon: '<i class="fas fa-user-check"></i>',
         label: options.buttonLabel + "<br>et ne plus demander",
         callback: () => {
-          ReglesOptionelles.set(options.settingConfirmer, false);
+          ReglesOptionnelles.set(options.settingConfirmer, false);
           options.onAction();
         }
       }

module/rdd-empoignade.js

@@ -4,6 +4,8 @@ import { RdDRoll } from "./rdd-roll.js";
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
 import { ChatUtility } from "./chat-utility.js";
 import { STATUSES } from "./settings/status-effects.js";
+import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
+import { TYPES } from "./item.js";
 
 /* -------------------------------------------- */
 
@@ -14,6 +16,47 @@ 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?
@@ -24,74 +67,92 @@ export class RdDEmpoignade {
     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['empoignade'].find(it => it.system.pointsemp > 0)
+    return actor.itemTypes[TYPES.empoignade].find(it => it.system.pointsemp > 0)
   }
 
   /* -------------------------------------------- */
   static getEmpoignadeById(actor, id) {
-    let emp = actor.itemTypes['empoignade'].find(it => it.system.empoignadeid == 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['empoignade'].find(it => it.system.empoigneurid == attacker.id && it.system.empoigneid == defender.id)
-    if (!emp) {
-      emp = attacker.itemTypes['empoignade'].find(it => it.system.empoigneurid == defender.id && it.system.empoigneid == attacker.id)
-    }
+    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
     }
-    // Malus de -1 si différence de taille de 2 ou plus (p 135)
-    if (attacker.system.carac.taille.value < defender.system.carac.taille.value - 1) {
-      return attacker.system.carac.taille.value - (defender.system.carac.taille.value - 1)
+    // 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 async onAttaqueEmpoignadeValidee(attacker, defender) {
-    let empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)
-    const isNouvelle = empoignade == undefined;
-    empoignade = empoignade ?? (await RdDEmpoignade.createEmpoignade(attacker, defender))
+  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
+  }
 
-    let mode = (empoignade && empoignade.system.empoigneurid == attacker.id) ? "empoigner" : "liberer"
-
-    let rollData = {
-      mode: mode,
-      isEmpoignade: true,
-      competence: attacker.getCompetence("Corps à corps"),
-      selectedCarac: attacker.system.carac.melee,
-      empoignade: empoignade,
-      attackerId: attacker.id,
-      attackerName: attacker.name,
-      defenderName: defender.name,
-      defenderId: defender.id,
-      malusTaille: RdDEmpoignade.getMalusTaille(empoignade, attacker, defender)
-    }
-    if (attacker.isCreatureEntite()) {
-      RdDItemCompetenceCreature.setRollDataCreature(rollData)
-    }
-    if (empoignade.system.pointsemp >= 2) {
-      let msg = await RdDResolutionTable.displayRollData(rollData, attacker, 'chat-empoignade-actions.html');
-      ChatUtility.setMessageData(msg, "empoignade-roll-data", rollData)
-    } else {
-      await RdDEmpoignade.$rollAttaqueEmpoignade(attacker, rollData, isNouvelle);
+  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))
@@ -105,6 +166,38 @@ export class RdDEmpoignade {
     }
   }
 
+  /* -------------------------------------------- */
+  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.getCompetenceCorpsACorps(),
+      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)
@@ -112,6 +205,20 @@ export class RdDEmpoignade {
     await this.onAttaqueEmpoignadeValidee(attacker, defender)
   }
 
+  static async onImmobilisation(attacker, defender, empoignade) {
+    const rollData = {
+      mode: "immobilise",
+      empoignade, attacker, defender,
+      isEmpoignade: true,
+      competence: attacker.getCompetenceCorpsACorps()
+    }
+    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,
@@ -119,35 +226,40 @@ export class RdDEmpoignade {
       {
         name: 'jet-empoignade',
         label: 'Empoigner',
-        callbacks: [
-          { condition: r => (r.rolled.isSuccess), action: async (r) => await RdDEmpoignade.$onRollEmpoignade(r, true, isNouvelle) },
-          { condition: r => (r.rolled.isEchec), action: async (r) => await RdDEmpoignade.$onRollEmpoignade(r, false, isNouvelle) },
-        ]
+        callbacks: [{ action: async (r) => await RdDEmpoignade.$onRollEmpoignade(r, isNouvelle) },]
       });
     dialog.render(true);
   }
 
   /* -------------------------------------------- */
-  static async $onRollEmpoignade(rollData, isSuccess, isNouvelle = false) {
-    let attacker = game.actors.get(rollData.attackerId)
-    let defender = game.actors.get(rollData.defenderId)
+  static async $onRollEmpoignade(rollData, isNouvelle = false) {
+    let attacker = game.actors.get(rollData.attacker.id)
+    let defender = game.actors.get(rollData.defender.id)
 
-    let empoignade = rollData.empoignade
-    empoignade.isSuccess = isSuccess;
 
-    if (isSuccess && isNouvelle) {
+    if (rollData.rolled.isSuccess && isNouvelle) {
+      const objectEmpoignade = rollData.empoignade.toObject();
       // Creer l'empoignade sur attaquant/defenseur
-      await attacker.createEmbeddedDocuments('Item', [empoignade.toObject()])
-      await defender.createEmbeddedDocuments('Item', [empoignade.toObject()])
+      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');
-    ChatUtility.setMessageData(msg, "empoignade-roll-data", rollData)
+    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
   }
 
   /* -------------------------------------------- */
-  static async onDefenseEmpoignade(rollData, defenseMode, competenceName = "Corps à corps", carac = "melee") {
-    let attacker = game.actors.get(rollData.attackerId)
-    let defender = game.actors.get(rollData.defenderId)
+  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) {
@@ -156,18 +268,23 @@ export class RdDEmpoignade {
     }
 
     empoignade = duplicate(empoignade)
-    rollData.mode = defenseMode
-    rollData.empoignade = empoignade
-    rollData.competence = defender.getCompetence(competenceName),
-      rollData.selectedCarac = defender.system.carac[carac],
-      rollData.malusTaille = RdDEmpoignade.getMalusTaille(empoignade, defender, attacker)
-
-    await RdDEmpoignade.$rollDefenseEmpoignade(defender, rollData);
+    let defenderRoll = {
+      mode, attacker, defender, empoignade, attackerRoll,
+      diffLibre: attackerRoll.diffLibre,
+      attaqueParticuliere: attackerRoll.particuliere,
+      competence: defender.getCompetence(competenceName),
+      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, rollData) {
-    const dialog = await RdDRoll.create(defender, rollData,
+  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',
@@ -183,7 +300,7 @@ export class RdDEmpoignade {
   /* -------------------------------------------- */
   static async $onRollContrerLiberer(rollData) {
     let empoignade = rollData.empoignade
-
+    
     if (rollData.mode == "contrer-empoigner" && !rollData.rolled.isSuccess) {
       empoignade.system.pointsemp++
       RdDEmpoignade.$updateEtatEmpoignade(empoignade)
@@ -192,13 +309,12 @@ export class RdDEmpoignade {
       empoignade.system.pointsemp--
       RdDEmpoignade.$updateEtatEmpoignade(empoignade)
     }
-
-    if (empoignade.system.pointsemp >= 2) {
-      let attacker = game.actors.get(empoignade.system.empoigneurid)
-      let msg = await RdDResolutionTable.displayRollData(rollData, attacker, 'chat-empoignade-actions.html');
-      ChatUtility.setMessageData(msg, "empoignade-roll-data", rollData)
-    }
+    
     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);
+    }
   }
 
   /* -------------------------------------------- */
@@ -223,16 +339,15 @@ export class RdDEmpoignade {
     let defender = game.actors.get(empoignade.system.empoigneid)
     let emp = RdDEmpoignade.getEmpoignadeById(defender, empoignade.system.empoignadeid)
     await defender.deleteEmbeddedDocuments('Item', [emp._id])
-
-    //let attacker = game.actors.get(empoignade.system.empoigneurid)
-    //emp = RdDEmpoignade.getEmpoignadeById(attacker, empoignade.system.empoignadeid)
-    //await attacker.deleteEmbeddedDocuments('Item', [emp._id])
   }
 
   /* -------------------------------------------- */
   static async entrainerAuSol(rollData) {
-    let attacker = game.actors.get(rollData.attackerId)
-    let defender = game.actors.get(rollData.defenderId)
+    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
@@ -242,25 +357,32 @@ export class RdDEmpoignade {
     await defender.setEffect(STATUSES.StatusProne, true);
 
     let msg = await RdDResolutionTable.displayRollData(rollData, attacker, 'chat-empoignade-entrainer-sol.html');
-    ChatUtility.setMessageData(msg, "empoignade-roll-data", rollData)
+    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
   }
 
   /* -------------------------------------------- */
   static async projeterAuSol(rollData) {
-    let attacker = game.actors.get(rollData.attackerId)
-    let defender = game.actors.get(rollData.defenderId)
+    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');
-    ChatUtility.setMessageData(msg, "empoignade-roll-data", rollData)
+    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
   }
+
   /* -------------------------------------------- */
   static async perteEndurance(rollData, perteMode) {
-    let attacker = game.actors.get(rollData.attackerId)
-    let defender = game.actors.get(rollData.defenderId)
+    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)
@@ -278,7 +400,7 @@ export class RdDEmpoignade {
       await defender.santeIncDec("endurance", -(3 * Math.floor(endValue / 4)));
     }
     let msg = await RdDResolutionTable.displayRollData(rollData, attacker, 'chat-empoignade-perte-endurance.html');
-    ChatUtility.setMessageData(msg, "empoignade-roll-data", rollData)
+    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
   }
 
   /* -------------------------------------------- */

module/rdd-hotbar-drop.js

@@ -1,12 +1,17 @@
+import { RdDItemArme } from "./item-arme.js";
+import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
+import { TYPES } from "./item.js";
 
 export class RdDHotbar {
 
-  static async addToHotbar(item, slot) {
-    let command = `game.system.rdd.RdDHotbar.rollMacro("${item.name}", "${item.type}");`;
-    let macro = game.macros.contents.find(m => (m.name === item.name) && (m.command === command));
+  static async createItemMacro(item, slot, armeCompetence = undefined) {
+    const itemName = item.name;
+    let macroName = itemName + RdDHotbar.$macroNameSuffix(armeCompetence);
+    let command = `game.system.rdd.RdDHotbar.rollMacro("${itemName}", "${item.type}", "${armeCompetence}");`
+    let macro = game.macros.contents.find(m => (m.name === itemName) && (m.command === command));
     if (!macro) {
       macro = await Macro.create({
-        name: item.name,
+        name: macroName,
         type: "script",
         img: item.img,
         command: command
@@ -15,6 +20,59 @@ export class RdDHotbar {
     await game.user.assignHotbarMacro(macro, slot);
   }
 
+  static $macroNameSuffix(armeCompetence) {
+    switch (armeCompetence) {
+      case 'unemain': return ' (1 main)';
+      case 'deuxmains': return ' (2 main)';
+      case 'tir': return ' (tir)';
+      case 'lancer': return ' (lancer)';
+      case 'pugilat': return ' (pugilat)';
+      case 'empoignade': return ' (empoignade)';
+
+    }
+    return ''
+  }
+
+  static async addToHotbar(item, slot) {
+    switch (item?.type ?? '') {
+      case TYPES.arme:
+        {
+          // Les armes peuvent avoir plusieurs usages
+          if (item.system.competence != '') {
+            if (item.system.unemain) {
+              await this.createItemMacro(item, slot++, 'unemain')
+            }
+            if (item.system.deuxmains) {
+              await this.createItemMacro(item, slot++, 'deuxmains')
+            }
+          }
+          if (item.system.lancer != '') {
+            await this.createItemMacro(item, slot++, 'lancer')
+          }
+          if (item.system.tir != '') {
+            await this.createItemMacro(item, slot++, 'lancer')
+          }
+        }
+        return
+      case TYPES.competencecreature:
+        const categorie = RdDItemCompetenceCreature.getCategorieAttaque(item) ?? 'competence';
+        await this.createItemMacro(item, slot, categorie)
+        return
+      default:
+      case TYPES.competence:
+        await this.createItemMacro(item, slot++, 'competence')
+        if (item.isCorpsACorps()) {
+          await this.createItemMacro(item, slot++, 'pugilat')
+          await this.createItemMacro(item, slot++, 'empoignade')
+        }
+        if (item.isCompetenceArme()) {
+          ui.notifications.info(`${item.name} est une compétence d'arme, la macro n'est pas liée à un arme.<br>
+          Créez la macro depuis l'arme ou l'onglet combat pour garder les automatisations de combat.`);
+        }
+        return
+    }
+  }
+
   /**
    * Create a macro when dropping an entity on the hotbar
    * Item      - open roll dialog for item
@@ -23,20 +81,19 @@ export class RdDHotbar {
    */
   static initDropbar() {
 
-    Hooks.on("hotbarDrop", (bar, documentData, slot) => {
+    Hooks.on('hotbarDrop', (bar, documentData, slot) => {
 
       // Create item macro if rollable item - weapon, spell, prayer, trait, or skill
-      if (documentData.type == "Item") {
-        let item = fromUuidSync(documentData.uuid)
-        if (item == undefined) {
-          item = this.actor.items.get(documentData.uuid)
+      if (documentData.type == 'Item') {
+        const item = fromUuidSync(documentData.uuid) ?? this.actor.items.get(documentData.uuid)
+        console.log('DROP', documentData, item)
+        switch (item?.type) {
+          case TYPES.arme:
+          case TYPES.competence:
+          case TYPES.competencecreature:
+            this.addToHotbar(item, slot)
+            return false
         }
-        console.log("DROP", documentData, item)
-        if (!item || (item.type != "arme" && item.type != "competence")) {
-          return true
-        }
-        this.addToHotbar(item, slot)
-        return false
       }
 
       return true
@@ -44,12 +101,14 @@ export class RdDHotbar {
   }
 
   /** Roll macro */
-  static rollMacro(itemName, itemType, bypassData) {
+  static rollMacro(itemName, itemType, categorieArme = 'competence') {
     const speaker = ChatMessage.getSpeaker();
     let actor;
     if (speaker.token) actor = game.actors.tokens[speaker.token];
     if (!actor) actor = game.actors.get(speaker.actor);
-
+    if (!actor) {
+      return ui.notifications.warn(`Impossible de trouver le personnage concerné`);
+    }
     let item = actor?.items.find(it => it.name === itemName && it.type == itemType) ?? undefined;
     if (!item) {
       return ui.notifications.warn(`Impossible de trouver l'objet de cette macro`);
@@ -57,10 +116,23 @@ export class RdDHotbar {
 
     // Trigger the item roll
     switch (item.type) {
-      case "arme":
-        return actor.rollArme(item);
-      case "competence":
-        return actor.rollCompetence(itemName);
+      case TYPES.arme:
+        return actor.rollArme(item, categorieArme);
+      case TYPES.competence:
+        if (item.isCorpsACorps()) {
+          switch (categorieArme) {
+            case 'pugilat':
+              return actor.rollArme(RdDItemArme.mainsNues(actor), 'competence');
+            case 'empoignade':
+              return actor.rollArme(RdDItemArme.empoignade(actor), 'competence');
+          }
+        }
+        return actor.rollCompetence(item);
+      case TYPES.competencecreature:
+        return item.system.iscombat && !item.system.isparade
+          ? actor.rollArme(item, categorieArme)
+          : actor.rollCompetence(item);
+
     }
   }
 

module/rdd-main.js

@@ -15,7 +15,7 @@ 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 { ReglesOptionelles } from "./settings/regles-optionelles.js";
+import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
 import { RdDHotbar } from "./rdd-hotbar-drop.js"
 import { EffetsDraconiques } from "./tmr/effets-draconiques.js";
 import { RdDHerbes } from "./rdd-herbes.js";
@@ -59,6 +59,7 @@ 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";
+import { AutoAdjustDarkness as AutoAdjustDarkness } from "./time/auto-adjust-darkness.js";
 
 /**
  * RdD system
@@ -182,11 +183,12 @@ export class SystemReveDeDragon {
     CONFIG.Combat.documentClass = RdDCombatManager;
 
     // préparation des différents modules
+    AutoAdjustDarkness.init();
     RdDTimestamp.init();
     RdDCalendrier.init();
     SystemCompendiums.init();
     DialogChronologie.init();
-    ReglesOptionelles.init();
+    ReglesOptionnelles.init();
     RdDUtility.init();
     RdDDice.init();
     RdDCommands.init();

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,13 +31,13 @@ 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,
       possession: possession,
@@ -45,25 +45,26 @@ export class RdDPossession {
       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

@@ -1,7 +1,7 @@
 import { ChatUtility } from "./chat-utility.js";
 import { Misc } from "./misc.js";
 import { RdDDice } from "./rdd-dice.js";
-import { ReglesOptionelles } from "./settings/regles-optionelles.js";
+import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
 
 /**
  * difficultés au delà de -10
@@ -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);
   }
@@ -122,7 +126,7 @@ export class RdDResolutionTable {
     rolled.bonus = rollData.bonus;
     rolled.factorHtml = Misc.getFractionHtml(rollData.diviseurSignificative);
 
-    if (ReglesOptionelles.isUsing("afficher-colonnes-reussite")) {
+    if (ReglesOptionnelles.isUsing("afficher-colonnes-reussite")) {
       rolled.niveauNecessaire = this.findNiveauNecessaire(caracValue, rolled.roll);
       rolled.ajustementNecessaire = rolled.niveauNecessaire - finalLevel;
     }

module/rdd-roll-resolution-table.js

@@ -112,7 +112,7 @@ export class RdDRollResolutionTable extends Dialog {
   async updateRollResult() {
     let rollData = this.rollData;
     rollData.caracValue = parseInt(rollData.selectedCarac.value)
-    rollData.finalLevel = this._computeFinalLevel(rollData);
+    rollData.finalLevel = Misc.toInt(rollData.diffConditions) + Misc.toInt(rollData.diffLibre);
 
     const htmlTable = await RdDResolutionTable.buildHTMLTable({
       carac: rollData.caracValue,
@@ -129,12 +129,6 @@ export class RdDRollResolutionTable extends Dialog {
   }
 
   /* -------------------------------------------- */
-  _computeFinalLevel(rollData) {
-    const diffConditions = Misc.toInt(rollData.diffConditions);
-    const diffLibre = Misc.toInt(rollData.diffLibre);
-
-    return diffLibre + diffConditions;
-  }
 
   async close() {
     await super.close();

module/rdd-roll.js

@@ -6,7 +6,7 @@ import { Misc } from "./misc.js";
 import { RdDBonus } from "./rdd-bonus.js";
 import { RdDCarac } from "./rdd-carac.js";
 import { RdDResolutionTable } from "./rdd-resolution-table.js";
-import { ReglesOptionelles } from "./settings/regles-optionelles.js";
+import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
 
 /**
  * Extend the base Dialog entity to select roll parameters
@@ -85,7 +85,7 @@ export class RdDRoll extends Dialog {
     if (RdDBonus.isDefenseAttaqueFinesse(rollData)) {
       facteurSign *= 2;
     }
-    if (!ReglesOptionelles.isUsing('tripleSignificative')) {
+    if (!ReglesOptionnelles.isUsing('tripleSignificative')) {
       facteurSign = Math.min(facteurSign, 4);
     }
     return facteurSign;
@@ -187,7 +187,7 @@ export class RdDRoll extends Dialog {
       console.log("RdDRollSelectDialog - Cout reve", ptreve);
       this.updateRollResult(html);
     });
-    this.html.find("[name='coupsNonMortels']").change((event) => {
+    this.html.find("[name='mortalite']").change((event) => {
       this.rollData.dmg.mortalite = event.currentTarget.checked ? "non-mortel" : "mortel";
       this.updateRollResult(html);
     });
@@ -295,8 +295,7 @@ export class RdDRoll extends Dialog {
 
     rollData.dmg = rollData.attackerRoll?.dmg ?? RdDBonus.dmg(rollData, this.actor.getBonusDegat())
     rollData.caracValue = parseInt(rollData.selectedCarac.value)
-    rollData.mortalite = rollData.attackerRoll?.dmg.mortalite ?? rollData.dmg.mortalite ?? 'mortel';
-    rollData.coupsNonMortels = (rollData.attackerRoll?.dmg.mortalite ?? rollData.dmg.mortalite) == 'non-mortel';
+    rollData.mortalite = rollData.attackerRoll?.dmg.mortalite ?? rollData.dmg.mortalite ?? rollData.mortalite ?? 'mortel';
     rollData.use.appelAuMoral = this.actor.isPersonnage() && RdDCarac.isActionPhysique(rollData.selectedCarac);
     let dmgText = Misc.toSignedString(rollData.dmg.total);
 
@@ -306,7 +305,6 @@ export class RdDRoll extends Dialog {
     }
 
     RollDataAjustements.calcul(rollData, this.actor);
-    rollData.finalLevel = this._computeFinalLevel(rollData);
 
     const resolutionTable = await RdDResolutionTable.buildHTMLTable(RdDResolutionTable.subTable(rollData.caracValue, rollData.finalLevel))
     const adjustements = await this.buildAjustements(rollData);
@@ -314,12 +312,12 @@ export class RdDRoll extends Dialog {
     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(".diffMoral"), rollData.ajustements.moralTotal.used);
     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));
-    this.html.find("[name='coupsNonMortels']").prop('checked', rollData.mortalite == 'non-mortel');
+    this.html.find("[name='mortalite']").prop('checked', rollData.mortalite == 'non-mortel');
     this.html.find(".dmg-arme-actor").text(dmgText);
     this.html.find("div.placeholder-ajustements").empty().append(adjustements);
     this.html.find("div.placeholder-resolution").empty().append(resolutionTable)
@@ -331,30 +329,6 @@ export class RdDRoll extends Dialog {
     return await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/partial-roll-ajustements.html`, rollData);
   }
 
-  /* -------------------------------------------- */
-  _computeFinalLevel(rollData) {
-    return RollDataAjustements.sum(rollData.ajustements);
-  }
-  /* -------------------------------------------- */
-  _computeDiffCompetence(rollData) {
-    if (rollData.competence) {
-      return Misc.toInt(rollData.competence.system.niveau);
-    }
-    if (rollData.draconicList) {
-      return Misc.toInt(rollData.competence.system.niveau);
-    }
-    return 0;
-  }
-
-  /* -------------------------------------------- */
-  _computeMalusArmure(rollData) {
-    let malusArmureValue = 0;
-    if (rollData.malusArmureValue && (rollData.selectedCarac.label == "Agilité" || rollData.selectedCarac.label == "Dérobée")) {
-      malusArmureValue = rollData.malusArmureValue;
-    }
-    return malusArmureValue;
-  }
-
   /* -------------------------------------------- */
   _getTitle(rollData) {
     const carac = rollData.selectedCarac.label;

module/rdd-tmr-dialog.js

@@ -2,7 +2,6 @@ import { SHOW_DICE } from "./constants.js";
 import { RollDataAjustements } from "./rolldata-ajustements.js";
 import { RdDUtility } from "./rdd-utility.js";
 import { TMRUtility } from "./tmr-utility.js";
-import { tmrConstants } from "./tmr-constants.js";
 import { RdDResolutionTable } from "./rdd-resolution-table.js";
 import { RdDTMRRencontreDialog } from "./rdd-tmr-rencontre-dialog.js";
 import { ChatUtility } from "./chat-utility.js";
@@ -12,7 +11,7 @@ import { EffetsDraconiques } from "./tmr/effets-draconiques.js";
 import { PixiTMR } from "./tmr/pixi-tmr.js";
 import { Draconique } from "./tmr/draconique.js";
 import { HtmlUtility } from "./html-utility.js";
-import { ReglesOptionelles } from "./settings/regles-optionelles.js";
+import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
 import { RdDDice } from "./rdd-dice.js";
 import { STATUSES } from "./settings/status-effects.js";
 import { RdDRencontre } from "./item/rencontre.js";
@@ -39,14 +38,16 @@ export class RdDTMRDialog extends Dialog {
       title: "Terres Médianes de Rêve",
       content: html,
       buttons: {
-        closeButton: { label: "Fermer", callback: html => this.close(html) }
+        closeButton: {
+          label: "Fermer", callback: html => this.close()
+        }
       },
       default: "closeButton"
     }
 
     const dialogOptions = {
       classes: ["tmrdialog"],
-      width: 920, height: 980,
+      width: 920, maxheight: 1024, height: 'fit-content',
       'z-index': 40
     }
     super(dialogConf, dialogOptions);
@@ -55,15 +56,15 @@ export class RdDTMRDialog extends Dialog {
     this.actor = actor;
     this.actor.tmrApp = this; // reference this app in the actor structure
     this.viewOnly = tmrData.mode == "visu"
-    this.fatigueParCase = this.viewOnly || !ReglesOptionelles.isUsing("appliquer-fatigue") ? 0 : this.actor.getTMRFatigue();
+    this.fatigueParCase = this.viewOnly || !ReglesOptionnelles.isUsing("appliquer-fatigue") ? 0 : this.actor.getTMRFatigue();
     this.cumulFatigue = 0;
     this.loadRencontres();
     this.loadCasesSpeciales();
     this.allTokens = [];
     this.rencontreState = 'aucune';
     this.pixiApp = new PIXI.Application({ width: 720, height: 860 });
-
     this.pixiTMR = new PixiTMR(this, this.pixiApp);
+    this.subdialog = undefined
 
     this.callbacksOnAnimate = [];
     if (!this.viewOnly) {
@@ -74,6 +75,30 @@ export class RdDTMRDialog extends Dialog {
     this.pixiTMR.load((loader, resources) => this.createPixiSprites());
   }
 
+  async forceTMRDisplay() {
+    this.bringToTop();
+    if (this.subdialog) {
+      this.subdialog.bringToTop();
+    }
+  }
+  async restoreTMRAfterAction() {
+    this.subdialog = undefined
+    this.bringToTop();
+  }
+
+  forceTMRContinueAction() {
+    ui.notifications.warn('Vous devez finir votre action avant de continuer dans les TMR');
+    this.subdialog.bringToTop();
+    return;
+  }
+
+  setTMRPendingAction(dialog) {
+    this.subdialog = dialog
+    if (dialog instanceof Application) {
+      dialog.bringToTop();
+    }
+  }
+
   isDemiReveCache() {
     return !game.user.isGM && this.actor.isTMRCache();
   }
@@ -175,6 +200,9 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   async moveFromKey(move) {
+    if (this.subdialog) {
+      return this.forceTMRContinueAction();
+    }
     let oddq = TMRUtility.coordTMRToOddq(this._getActorCoord());
 
     if (move == 'top') oddq.row -= 1;
@@ -199,7 +227,9 @@ export class RdDTMRDialog extends Dialog {
     super.activateListeners(html);
     this.html = html;
 
-    document.getElementById("tmrrow1").insertCell(0).append(this.pixiApp.view);
+    document.getElementsByClassName("tmr-row")
+      .item(0)
+      .insertCell(0).append(this.pixiApp.view);
 
     if (this.viewOnly) {
       this.html.find('.lancer-sort').remove();
@@ -207,9 +237,13 @@ export class RdDTMRDialog extends Dialog {
       return;
     }
 
-    HtmlUtility.showControlWhen(this.html.find(".appliquerFatigue"), ReglesOptionelles.isUsing("appliquer-fatigue"));
+    HtmlUtility.showControlWhen(this.html.find(".appliquerFatigue"), ReglesOptionnelles.isUsing("appliquer-fatigue"));
     HtmlUtility.showControlWhen(this.html.find(".lire-signe-draconique"), this.actor.isResonanceSigneDraconique(this._getActorCoord()));
 
+    this.html.find('tr.tmr-row *').click((event) => {
+      this.subdialog?.bringToTop();
+    });
+
     // Roll Sort
     this.html.find('.lancer-sort').click((event) => {
       this.actor.rollUnSort(this._getActorCoord());
@@ -227,11 +261,10 @@ export class RdDTMRDialog extends Dialog {
 
     // Gestion du cout de montée en points de rêve
     let reveCout = ((this.tmrdata.isRapide && !EffetsDraconiques.isDeplacementAccelere(this.actor)) ? -2 : -1) - this.actor.countMonteeLaborieuse();
-    if (ReglesOptionelles.isUsing("appliquer-fatigue")) {
+    if (ReglesOptionnelles.isUsing("appliquer-fatigue")) {
       this.cumulFatigue += this.fatigueParCase;
     }
     await this.actor.reveActuelIncDec(reveCout);
-
     // Le reste...
     this.updateValuesDisplay();
     let tmr = TMRUtility.getTMR(this._getActorCoord());
@@ -263,7 +296,7 @@ export class RdDTMRDialog extends Dialog {
     let refoulement = document.getElementById("tmr-refoulement-value");
     refoulement.innerHTML = this.actor.system.reve.refoulement.value;
 
-    if (ReglesOptionelles.isUsing("appliquer-fatigue")) {
+    if (ReglesOptionnelles.isUsing("appliquer-fatigue")) {
       let fatigueItem = document.getElementById("tmr-fatigue-table");
       fatigueItem.innerHTML = "<table class='table-fatigue'>" + RdDUtility.makeHTMLfatigueMatrix(this.actor.system.sante.fatigue.value, this.actor.system.sante.endurance.max).html() + "</table>";
     }
@@ -271,6 +304,10 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   async close() {
+    if (this.subdialog) {
+      return this.forceTMRContinueAction()
+    }
+
     this.descenteTMR = true;
     if (this.actor.tmrApp) {
       this.actor.tmrApp = undefined; // Cleanup reference
@@ -293,6 +330,7 @@ export class RdDTMRDialog extends Dialog {
     switch (action) {
       case 'derober':
         await this.derober();
+        this.restoreTMRAfterAction();
         return;
       case 'refouler':
         await this.refouler();
@@ -305,6 +343,7 @@ export class RdDTMRDialog extends Dialog {
         break;
     }
     await this.postRencontre(tmr);
+    this.restoreTMRAfterAction();
   }
 
   async derober() {
@@ -360,14 +399,13 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   checkQuitterTMR() {
-
     if (this.actor.isDead()) {
       this._tellToGM("Vous êtes mort : vous quittez les Terres médianes !");
       this.close();
       return true;
     }
     const resteAvantInconscience = this.actor.getFatigueMax() - this.actor.getFatigueActuelle() - this.cumulFatigue;
-    if (ReglesOptionelles.isUsing("appliquer-fatigue") && resteAvantInconscience <= 0) {
+    if (ReglesOptionnelles.isUsing("appliquer-fatigue") && resteAvantInconscience <= 0) {
       this._tellToGM("Vous vous écroulez de fatigue : vous quittez les Terres médianes !");
       this.quitterLesTMRInconscient();
       return true;
@@ -451,7 +489,7 @@ export class RdDTMRDialog extends Dialog {
     setTimeout(() => {
       // TODO: remplacer par une boucle while(this.currentRencontre) ?
       rencData.nbRounds++;
-      if (ReglesOptionelles.isUsing("appliquer-fatigue")) {
+      if (ReglesOptionnelles.isUsing("appliquer-fatigue")) {
         this.cumulFatigue += this.fatigueParCase;
       }
       this._tentativeMaitrise(rencData);
@@ -531,8 +569,9 @@ export class RdDTMRDialog extends Dialog {
         await this.maitriserRencontre();
       }
       else {
-        let dialog = new RdDTMRRencontreDialog(this, this.currentRencontre, tmr);
+        const dialog = new RdDTMRRencontreDialog(this.actor, this.currentRencontre, tmr);
         dialog.render(true);
+        this.setTMRPendingAction(dialog);
       }
     }
     else {
@@ -544,9 +583,12 @@ export class RdDTMRDialog extends Dialog {
   _presentCite(tmr) {
     const presentCite = this.casesSpeciales.find(c => EffetsDraconiques.presentCites.isCase(c, tmr.coord));
     if (presentCite) {
-      this.minimize();
       const caseData = presentCite;
-      EffetsDraconiques.presentCites.choisirUnPresent(caseData, (present => this._utiliserPresentCite(presentCite, present, tmr)));
+      const dialog = EffetsDraconiques.presentCites.choisirUnPresent(caseData, present => {
+        this._utiliserPresentCite(presentCite, present, tmr)
+        this.restoreTMRAfterAction();
+      });
+      this.setTMRPendingAction(dialog);
     }
     return presentCite;
   }
@@ -572,8 +614,6 @@ export class RdDTMRDialog extends Dialog {
       presentCite: presentCite
     };
     await this._tentativeMaitrise(rencontreData);
-
-    this.maximize();
     this.postRencontre(tmr);
   }
 
@@ -587,7 +627,10 @@ export class RdDTMRDialog extends Dialog {
       ? TMRUtility.getTMRType(tmr.coord) + " ??"
       : tmr.label + " (" + tmr.coord + ")");
 
+    const fakeDialogRencontre = { bringToTop: () => { } };
+    this.setTMRPendingAction(fakeDialogRencontre)
     let myRoll = await RdDDice.rollTotal("1dt", { showDice: SHOW_DICE });
+    this.restoreTMRAfterAction()
     if (myRoll == 7) {
       this._tellToUser(myRoll + ": Rencontre en " + locTMR);
       return await game.system.rdd.rencontresTMR.getRencontreAleatoire(tmr, this.actor.isMauvaiseRencontre())
@@ -777,22 +820,22 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   async _maitriserTMR(rollData, callbackMaitrise) {
-    this.minimize(); // Hide
     rollData.isTMRCache = rollData.actor.isTMRCache();
     const dialog = await RdDRoll.create(this.actor, rollData,
       {
         html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-maitrise-tmr.html',
-        close: html => { this.maximize(); } // Re-display TMR
       },
       {
         name: rollData.maitrise.verbe, label: rollData.maitrise.action,
         callbacks: [
           this.actor.createCallbackExperience(),
+          { action: r => { this.restoreTMRAfterAction() } },
           { action: callbackMaitrise }
         ]
       }
     );
     dialog.render(true);
+    this.setTMRPendingAction(dialog);
   }
 
   /* -------------------------------------------- */
@@ -862,7 +905,8 @@ export class RdDTMRDialog extends Dialog {
   nettoyerRencontre() {
     if (!this.currentRencontre) return; // Sanity check
     if (this.currentRencontre.graphics) {
-      for (let drawRect of this.currentRencontre.graphics) { // Suppression des dessins des zones possibles
+      for (let drawRect of this.currentRencontre.graphics) {
+        // Suppression des dessins des zones possibles
         this.pixiApp.stage.removeChild(drawRect);
       }
     }
@@ -895,8 +939,8 @@ export class RdDTMRDialog extends Dialog {
   }
 
   /* -------------------------------------------- */
-  isConnaissanceFleuve(currentTMR, nextTMR) {
-    return TMRUtility.getTMR(currentTMR).type == 'fleuve' &&
+  isConnaissanceFleuve(tmrApp, nextTMR) {
+    return TMRUtility.getTMR(tmrApp).type == 'fleuve' &&
       TMRUtility.getTMR(nextTMR).type == 'fleuve' &&
       EffetsDraconiques.isConnaissanceFleuve(this.actor);
   }
@@ -906,15 +950,15 @@ export class RdDTMRDialog extends Dialog {
     if (this.viewOnly) {
       return;
     }
-    let clickOddq = RdDTMRDialog._computeEventOddq(event.data.originalEvent);
-    await this._onClickTMRPos(clickOddq); // Vérifier l'état des compteurs reve/fatigue/vie
-  }
-
-  /* -------------------------------------------- */
-  async _onClickTMRPos(clickOddq) {
+    if (this.subdialog) {
+      return this.forceTMRContinueAction()
+    }
+    let clickOddq = TMRUtility.computeEventOddq(event);
     let currentOddq = TMRUtility.coordTMRToOddq(this._getActorCoord());
+
     let targetCoord = TMRUtility.oddqToCoordTMR(clickOddq);
     let currentCoord = TMRUtility.oddqToCoordTMR(currentOddq);
+
     // Validation de la case de destination (gestion du cas des rencontres qui peuvent téléporter)
     let deplacementType = this._calculDeplacement(targetCoord, currentCoord, currentOddq, clickOddq);
 
@@ -946,7 +990,7 @@ export class RdDTMRDialog extends Dialog {
         await this._messagerDemiReve(targetCoord);
         break;
       default:
-        ui.notifications.error("Vous ne pouvez pas vous déplacer que sur des cases adjacentes à votre position ou valides dans le cas d'une rencontre");
+        ui.notifications.error("Vous ne pouvez vous déplacer que sur des cases adjacentes à votre position ou valides dans le cas d'une rencontre");
         console.log("STATUS :", this.rencontreState, this.currentRencontre);
     }
 
@@ -975,9 +1019,11 @@ export class RdDTMRDialog extends Dialog {
   /* -------------------------------------------- */
   async _messagerDemiReve(targetCoord) {
     /*
-     TODO: si la case a un sort en réserve, lancer ce sort.
+     TODO:
+     Si la case a un sort en réserve, lancer ce sort.
      Si la case est le demi-rêve, ne pas lancer de sort.
-     Si un lancement de sort est en cours, trouver un moyen de réafficher cette fenêtre si on essaie de lancer un sort (ou bloquer le lancer de sort)
+     Si un lancement de sort est en cours, trouver un moyen de réafficher cette fenêtre
+       si on essaie de lancer un sort (ou bloquer le lancer de sort)
     */
     this.notifierResonanceSigneDraconique(targetCoord);
     await this.actor.rollUnSort(targetCoord);
@@ -994,6 +1040,9 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   async _deplacerDemiReve(targetCoord, deplacementType) {
+    if (this.subdialog) {
+      return this.forceTMRContinueAction()
+    }
     if (this.currentRencontre != 'normal') {
       this.nettoyerRencontre();
     }
@@ -1004,7 +1053,7 @@ export class RdDTMRDialog extends Dialog {
     await this.actor.updateCoordTMR(tmr.coord);
 
     this.forceDemiRevePositionView();
-    if (ReglesOptionelles.isUsing("appliquer-fatigue")) {
+    if (ReglesOptionnelles.isUsing("appliquer-fatigue")) {
       this.cumulFatigue += this.fatigueParCase;
     }
     this.updateValuesDisplay();
@@ -1043,25 +1092,16 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   async positionnerDemiReve(coord) {
+    if (this.subdialog) {
+      return this.forceTMRContinueAction()
+    }
+
     await this.actor.updateCoordTMR(coord);
     this.forceDemiRevePositionView();
     let tmr = TMRUtility.getTMR(coord);
     await this.postRencontre(tmr);
     return tmr;
   }
-
-  /* -------------------------------------------- */
-  static _computeEventOddq(origEvent) {
-    console.log("EVENT", origEvent)
-    let canvasRect = origEvent.target.getBoundingClientRect();
-    let x = origEvent.clientX - canvasRect.left;
-    let y = origEvent.clientY - canvasRect.top;
-    let col = Math.floor(x / tmrConstants.cellw); //  [From 0 -> 12]
-    y -= col % 2 == 0 ? tmrConstants.col1_y : tmrConstants.col2_y;
-    let row = Math.floor(y / tmrConstants.cellh); //  [From 0 -> 14]
-    return { col: col, row: row };
-  }
-
   /* -------------------------------------------- */
   /** Retourne les coordonnées x, h, w, h du rectangle d'une case donnée */
   _getCaseRectangleCoord(coord) {

module/rdd-tmr-rencontre-dialog.js

@@ -2,7 +2,7 @@
 export class RdDTMRRencontreDialog extends Dialog {
 
   /* -------------------------------------------- */
-  constructor(tmrApp, rencontre, tmr) {
+  constructor(actor, rencontre, tmr) {
     const dialogConf = {
       title: "Rencontre en TMR!",
       content: "Vous rencontrez un " + rencontre.name + " de force " + rencontre.system.force + "<br>",
@@ -28,23 +28,30 @@ export class RdDTMRRencontreDialog extends Dialog {
 
     this.toClose = false;
     this.tmr = tmr;
-    this.tmrApp = tmrApp;
+    this.actor = actor;
     this.rencontre = rencontre;
-    this.tmrApp.minimize();
   }
 
   async onButtonAction(action) {
     this.toClose = true;
-    this.tmrApp.onActionRencontre(action, this.tmr, this.rencontre)
+    await this.actor.tmrApp?.restoreTMRAfterAction();
+    this.actor.tmrApp?.onActionRencontre(action, this.tmr, this.rencontre)
   }
   
   /* -------------------------------------------- */
-  close() {
-    if (this.toClose) {
-      this.tmrApp.maximize();
-      return super.close();
+  async close() {
+    if (this.actor.tmrApp){
+      if (this.toClose) {
+        return await super.close();
+      }
+      else {
+        ui.notifications.info("Vous devez résoudre la rencontre.");
+        this.actor.tmrApp.forceTMRContinueAction();
+      }
+    }
+    else {
+      return await super.close();
     }
-    ui.notifications.info("Vous devez résoudre la rencontre.");
   }
 
 }

module/rdd-token-hud.js

@@ -75,8 +75,8 @@ export class RdDTokenHud {
       (event) => {
         const actionIndex = event.currentTarget.attributes['data-action-index']?.value;
         const action = hudData.actions[actionIndex];
-        if (action.action == 'conjurer') {
-          const possession = combatant.actor.getPossession(action.system.possessionid);
+        const possession = action.action == 'possession' ? combatant.actor.getPossession(action.system.possessionid) : undefined;
+        if (possession) {
           combatant.actor.conjurerPossession(possession);
         }
         else {

module/rdd-utility.js

@@ -5,7 +5,7 @@ import { Misc } from "./misc.js";
 import { Grammar } from "./grammar.js";
 import { TMRUtility } from "./tmr-utility.js";
 import { DialogItemAchat } from "./dialog-item-achat.js";
-import { ReglesOptionelles } from "./settings/regles-optionelles.js";
+import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
 import { RdDDice } from "./rdd-dice.js";
 import { RdDItem } from "./item.js";
 import { RdDPossession } from "./rdd-possession.js";
@@ -121,6 +121,7 @@ export class RdDUtility {
       'systems/foundryvtt-reve-de-dragon/templates/actor/header-compteurs-entitee.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/header-effects.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/header-hautreve.html',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/archetype.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/actor/vue-detaillee.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/carac-main.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/carac-derivee.html',
@@ -179,24 +180,25 @@ export class RdDUtility {
       'systems/foundryvtt-reve-de-dragon/templates/item-queue-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-base-competence.html',
+      'systems/foundryvtt-reve-de-dragon/templates/enum-caracteristiques.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-queue.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-draconic.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-mortalite.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-niveau-ethylisme.html',
-      'systems/foundryvtt-reve-de-dragon/templates/enum-rarete.html',
-      '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-rarete.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-tmr-effet.html',
+      'systems/foundryvtt-reve-de-dragon/templates/enum-tmr-type.html',
       // Partials
       'systems/foundryvtt-reve-de-dragon/templates/tirage/liste-resultats-recherche.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/time/horloge.hbs',
@@ -278,7 +280,7 @@ export class RdDUtility {
     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('regle-optionnelle', (option) => ReglesOptionnelles.isUsing(option));
     Handlebars.registerHelper('trier', list => list.sort((a, b) => a.name.localeCompare(b.name)));
     Handlebars.registerHelper('filtreTriCompetences', competences => RdDItemCompetence.triVisible(competences));
     Handlebars.registerHelper('linkCompendium', (pack, id, name) => RdDUtility.linkCompendium(pack, id, name));
@@ -339,13 +341,13 @@ export class RdDUtility {
   }
 
   /* -------------------------------------------- */
-  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;
@@ -354,20 +356,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)
@@ -478,7 +480,7 @@ export class RdDUtility {
 
   /* -------------------------------------------- */
   static calculFatigueHtml(fatigue, endurance) {
-    return ReglesOptionelles.isUsing("appliquer-fatigue") ? {
+    return ReglesOptionnelles.isUsing("appliquer-fatigue") ? {
       malus: RdDUtility.calculMalusFatigue(fatigue, endurance),
       html: "<table class='table-fatigue'>" + RdDUtility.makeHTMLfatigueMatrix(fatigue, endurance).html() + "</table>"
     } : { malus: 0, html: '' };
@@ -554,14 +556,14 @@ export class RdDUtility {
     let formula = "2d10";
 
     // Chaque dé fait au minmum la difficulté libre
-    if (ReglesOptionelles.isUsing('degat-minimum-malus-libre')) {
+    if (ReglesOptionnelles.isUsing('degat-minimum-malus-libre')) {
       if (rollData.diffLibre < 0) {
         let valeurMin = Math.abs(rollData.diffLibre);
         formula += "min" + valeurMin;
       }
     }
     // Chaque dé fait au minmum la difficulté libre
-    if (ReglesOptionelles.isUsing('degat-ajout-malus-libre')) {
+    if (ReglesOptionnelles.isUsing('degat-ajout-malus-libre')) {
       if (rollData.diffLibre < 0) {
         let valeurMin = Math.abs(rollData.diffLibre);
         formula += "+" + valeurMin;
@@ -571,7 +573,7 @@ export class RdDUtility {
     let roll = await RdDDice.roll(formula, options);
 
     // 1 dé fait au minmum la difficulté libre
-    if (ReglesOptionelles.isUsing('degat-minimum-malus-libre-simple')) {
+    if (ReglesOptionnelles.isUsing('degat-minimum-malus-libre-simple')) {
       if (rollData.diffLibre < 0) {
         let valeurMin = Math.abs(rollData.diffLibre);
         if (roll.terms[0].results[0].result < valeurMin) {
@@ -624,7 +626,7 @@ export class RdDUtility {
 
   /* -------------------------------------------- */
   static currentFatigueMalus(value, max) {
-    if (ReglesOptionelles.isUsing("appliquer-fatigue")) {
+    if (ReglesOptionnelles.isUsing("appliquer-fatigue")) {
       max = Math.max(1, Math.min(max, 60));
       value = Math.min(max * 2, Math.max(0, value));
 
@@ -668,6 +670,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 => {
@@ -694,44 +697,6 @@ export class RdDUtility {
       RdDPossession.onDefensePossession(attackerId, defenderId, possessionId)
     });
 
-    html.on("click", '.defense-empoignade-cac', event => {
-      const chatMessage = ChatUtility.getChatMessage(event);
-      const rollData = ChatUtility.getMessageData(chatMessage, 'empoignade-roll-data');
-      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 = ChatUtility.getMessageData(chatMessage, 'empoignade-roll-data');
-      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 = ChatUtility.getMessageData(chatMessage, 'empoignade-roll-data');
-      RdDEmpoignade.entrainerAuSol(rollData) 
-      ChatUtility.removeChatMessageId(chatMessage.id)
-    });
-    html.on("click", '.empoignade-projeter-sol', event => {
-      const chatMessage = ChatUtility.getChatMessage(event);
-      const rollData = ChatUtility.getMessageData(chatMessage, 'empoignade-roll-data');
-      RdDEmpoignade.projeterAuSol(rollData) 
-      ChatUtility.removeChatMessageId(chatMessage.id)
-    });
-    html.on("change", '.empoignade-perte-endurance', event => {
-      const chatMessage = ChatUtility.getChatMessage(event);
-      const rollData = ChatUtility.getMessageData(chatMessage, 'empoignade-roll-data');
-      if (event.currentTarget.value && event.currentTarget.value != "none") {
-        RdDEmpoignade.perteEndurance(rollData, event.currentTarget.value) 
-        ChatUtility.removeChatMessageId(chatMessage.id)  
-      }
-    });
-        
     // gestion bouton tchat Acheter
     html.on("click", '.button-acheter', event => {
       const venteData = DialogItemAchat.preparerAchat(event.currentTarget);

module/rolldata-ajustements.js

@@ -5,8 +5,9 @@ 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";
+import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
 
 /**
  * tous les ajustements pouvant s'appliquer.
@@ -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,7 +52,7 @@ 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 })
   },
@@ -85,7 +86,7 @@ export const referenceAjustements = {
     getValue: (rollData, actor) => actor.getMoralTotal()
   },
   astrologique: {
-    isUsed: (rollData, actor) => ReglesOptionelles.isUsing("astrologie") && RdDBonus.isAjustementAstrologique(rollData),
+    isUsed: (rollData, actor) => ReglesOptionnelles.isUsing("astrologie") && RdDBonus.isAjustementAstrologique(rollData),
     getLabel: (rollData, actor) => 'Astrologique',
     getValue: (rollData, actor) => actor.ajustementAstrologique()
   },
@@ -163,7 +164,7 @@ export class RollDataAjustements {
         descr: reference.getDescr && reference.getDescr(rollData, actor)
       }
     }
-    rollData.finalLevel = RollDataAjustements.sum(rollData.ajustements);
+    rollData.finalLevel = RollDataAjustements.sum(rollData.ajustements)
   }
 
   /* -------------------------------------------- */
@@ -177,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

@@ -1,119 +0,0 @@
-import { SYSTEM_RDD } from "../constants.js";
-import { Misc } from "../misc.js";
-
-const listeReglesOptionelles = [
-  { group: 'Règles de combat', name: 'recul', descr: "Appliquer le recul en cas de particulière en force ou de charge" },
-  { group: 'Règles de combat', name: 'resistanceArmeParade', descr: "Faire le jet de résistance des armes lors de parades pouvant les endommager" },
-  { group: 'Règles de combat', name: 'deteriorationArmure', descr: "Tenir compte de la détérioration des armures" },
-  { group: 'Règles de combat', name: 'defenseurDesarme', descr: "Le défenseur peut être désarmé en parant une particulière en force ou une charge avec une arme autre qu'un bouclier" },
-  { group: 'Règles de combat', name: 'categorieParade', descr: "Le défenseur doit obtenir une significative en cas de parade avec des armes de catégories différentes" },
-  { group: 'Règles de combat', name: 'tripleSignificative', descr: "En cas de demi-surprise, d'attaque particulière en finesse, et de catégories d'armes différentes, le défenseur doit obtenir 1/8 des chances de succès" },
-  { group: 'Règles de combat', name: 'degat-minimum-malus-libre-simple', descr: "Le malus libre d'attaque remplace une des valeurs de dés d'encaissement si elle est plus petite. Exemple : la difficulté libre de l'attaquant est de -4. Sur le jet d'encaissement, si le plus petit dé est inférieur à 4, alors il devient 4.", default: false },
-  { group: 'Règles de combat', name: 'degat-minimum-malus-libre', descr: "Le malus libre d'attaque remplace une valeur de dés d'encaissement si elle est plus petite. Exemple : la difficulté libre de l'attaquant est de -4. Sur le jet d'encaissement, tout résultat inférieur à 4 devient 4.", default: false },
-  { group: 'Règles de combat', name: 'degat-ajout-malus-libre', descr: "Le malus libre d'attaque s'ajoute au jet d'encaissement et aux autres bonus. Exemple : la difficulté libre de l'attaquant est de -4. Le jet d'encaissement est effectué à 2d10+4, plus les bonus de situation et d'armes.", default: false },
-  { group: 'Règles de combat', name: 'validation-encaissement-gr', descr: "Le Gardien des Rêves doit valider les jets d'encaissement et peut les changer.", default: false },
-
-  { group: 'Règles générales', name: 'astrologie', descr: "Appliquer les ajustements astrologiques aux jets de chance et aux rituels"},
-  { 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"},
-  { group: 'Confirmations', name: 'confirmation-refouler',               descr: "Confirmer avant de refouler", scope: "client"},
-  { group: 'Confirmations', name: 'confirmation-vider',                  descr: "Confirmer pour vider l'équipement", scope: "client"},
-  { group: 'Confirmations', name: 'confirmation-supprimer-lien-acteur',  descr: "Confirmer pour détacher un animal/suivant/véhicule", scope: "client"},
-  { group: 'Confirmations', name: 'confirmation-supprimer-equipement',   descr: "Confirmer la suppression des équipements", scope: "client"},
-  { group: 'Confirmations', name: 'confirmation-supprimer-oeuvre',       descr: "Confirmer la suppression des oeuvres", scope: "client"},
-  { group: 'Confirmations', name: 'confirmation-supprimer-connaissance', descr: "Confirmer la suppression des connaissances", scope: "client"},
-  { group: 'Confirmations', name: 'confirmation-supprimer-draconique',   descr: "Confirmer la suppression des queues, souffles, têtes", scope: "client"},
-  { group: 'Confirmations', name: 'confirmation-supprimer-effet',        descr: "Confirmer la suppression des effets", scope: "client"},
-  { group: 'Confirmations', name: 'confirmation-supprimer-competence',   descr: "Confirmer la suppression des compétences", scope: "client"},
-  { group: 'Confirmations', name: 'confirmation-supprimer-autres',       descr: "Confirmer la suppression des autres types d'Objets", scope: "client"},
-];
-
-const uniquementJoueur = listeReglesOptionelles.filter(it => it.uniquementJoueur).map(it=>it.name);
-
-export class ReglesOptionelles extends FormApplication {
-  static init() {
-    for (const regle of listeReglesOptionelles) {
-      const name = regle.name;
-      const id = ReglesOptionelles._getIdRegle(name);
-      game.settings.register(SYSTEM_RDD, id, { name: id, scope: regle.scope ?? "world", config: false, default: regle.default == undefined ? true : regle.default, type: Boolean });
-    }
-
-    game.settings.registerMenu(SYSTEM_RDD, "rdd-options-regles", {
-      name: "Choisir les règles optionelles",
-      label: "Règles optionelles",
-      hint: "Ouvre la fenêtre de sélection des règles optionelles",
-      icon: "fas fa-bars",
-      type: ReglesOptionelles
-    });
-  }
-
-  constructor(...args) {
-    super(...args);
-  }
-
-  static _getIdRegle(name) {
-    return `rdd-option-${name}`;
-  }
-
-  static get defaultOptions() {
-    const options = super.defaultOptions;
-    mergeObject(options, {
-      id: "regles-optionelles",
-      template: "systems/foundryvtt-reve-de-dragon/templates/settings/regles-optionelles.html",
-      height: 600,
-      width: 450,
-      minimizable: false,
-      closeOnSubmit: true,
-      title: "Règles optionnelles"
-    });
-    return options;
-  }
-
-  getData() {
-    let formData = super.getData();
-    const regles = listeReglesOptionelles.filter(it => game.user.isGM || it.scope == "client").map(it => {
-      it = duplicate(it);
-      it.id = ReglesOptionelles._getIdRegle(it.name);
-      it.active = ReglesOptionelles.isSet(it.name);
-      return it;
-    });
-    formData.regles = regles;
-    formData.groups = Misc.classify(regles, it => it.group);
-    return formData;
-  }
-
-  static isUsing(name) {
-    if (game.user.isGM && uniquementJoueur.includes(name)) {
-      return true;
-    }
-    return ReglesOptionelles.isSet(name);
-  }
-
-  static isSet(name) {
-    return game.settings.get(SYSTEM_RDD, ReglesOptionelles._getIdRegle(name));
-  }
-
-  static set(name, value) {
-    return game.settings.set(SYSTEM_RDD, ReglesOptionelles._getIdRegle(name), value ? true: false);
-  }
-
-  activateListeners(html) {
-    html.find(".select-option").click((event) => {
-      if (event.currentTarget.attributes.name) {
-        let id = event.currentTarget.attributes.name.value;
-        let isChecked = event.currentTarget.checked;
-        game.settings.set(SYSTEM_RDD, id, isChecked);
-      }
-    });
-  }
-
-  async _updateObject(event, formData) {
-    this.close();
-  }
-}
-

module/settings/regles-optionnelles.js

@@ -0,0 +1,122 @@
+import { SYSTEM_RDD } from "../constants.js";
+import { Misc } from "../misc.js";
+
+const listeReglesOptionnelles = [
+  { group: 'Règles générales', name: 'appliquer-fatigue',           descr: "Appliquer les règles de fatigue"},
+  { group: 'Règles générales', name: 'astrologie',                  descr: "Appliquer les ajustements astrologiques aux jets de chance et aux rituels"},
+
+  { group: 'Règles de combat', name: 'recul',                       descr: "Appliquer le recul en cas de particulière en force ou de charge" },
+  { group: 'Règles de combat', name: 'resistanceArmeParade',        descr: "Faire le jet de résistance des armes lors de parades pouvant les endommager" },
+  { group: 'Règles de combat', name: 'deteriorationArmure',         descr: "Tenir compte de la détérioration des armures" },
+  { group: 'Règles de combat', name: 'defenseurDesarme',            descr: "Le défenseur peut être désarmé en parant une particulière en force ou une charge avec une arme autre qu'un bouclier" },
+  { group: 'Règles de combat', name: 'categorieParade',             descr: "Le défenseur doit obtenir une significative en cas de parade avec des armes de catégories différentes" },
+  { group: 'Règles de combat', name: 'tripleSignificative',         descr: "En cas de demi-surprise, d'attaque particulière en finesse, et de catégories d'armes différentes, le défenseur doit obtenir 1/8 des chances de succès" },
+  { group: 'Règles de combat', name: 'validation-encaissement-gr',  descr: "Le Gardien des Rêves doit valider les jets d'encaissement et peut les changer.", default: false },
+  
+  { group: 'Automatisation', name: 'chateau-dormant-gardien',       descr: "Saisie des heures de sommeil/jets de moral par le gardien des rêves", default: true },
+
+  { group: 'Affichage', name: 'afficher-colonnes-reussite',         descr: "Afficher le nombre de colonnes de réussite ou d'échec", default: false },
+  { group: 'Affichage', name: 'afficher-prix-joueurs',              descr: "Afficher le prix de l'équipement des joueurs", uniquementJoueur: 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"},
+  { group: 'Confirmations', name: 'confirmation-refouler',               descr: "Confirmer avant de refouler", scope: "client"},
+  { group: 'Confirmations', name: 'confirmation-vider',                  descr: "Confirmer pour vider l'équipement", scope: "client"},
+  { group: 'Confirmations', name: 'confirmation-supprimer-lien-acteur',  descr: "Confirmer pour détacher un animal/suivant/véhicule", scope: "client"},
+  { group: 'Confirmations', name: 'confirmation-supprimer-equipement',   descr: "Confirmer la suppression des équipements", scope: "client"},
+  { group: 'Confirmations', name: 'confirmation-supprimer-oeuvre',       descr: "Confirmer la suppression des oeuvres", scope: "client"},
+  { group: 'Confirmations', name: 'confirmation-supprimer-connaissance', descr: "Confirmer la suppression des connaissances", scope: "client"},
+  { group: 'Confirmations', name: 'confirmation-supprimer-draconique',   descr: "Confirmer la suppression des queues, souffles, têtes", scope: "client"},
+  { group: 'Confirmations', name: 'confirmation-supprimer-effet',        descr: "Confirmer la suppression des effets", scope: "client"},
+  { group: 'Confirmations', name: 'confirmation-supprimer-competence',   descr: "Confirmer la suppression des compétences", scope: "client"},
+  { group: 'Confirmations', name: 'confirmation-supprimer-autres',       descr: "Confirmer la suppression des autres types d'Objets", scope: "client"},
+
+  { group: 'Options alternatives', name: 'degat-minimum-malus-libre-simple',  descr: "Le malus libre d'attaque remplace une des valeurs de dés d'encaissement si elle est plus petite. Exemple : la difficulté libre de l'attaquant est de -4. Sur le jet d'encaissement, si le plus petit dé est inférieur à 4, alors il devient 4.", default: false },
+  { group: 'Options alternatives', name: 'degat-minimum-malus-libre',         descr: "Le malus libre d'attaque remplace une valeur de dés d'encaissement si elle est plus petite. Exemple : la difficulté libre de l'attaquant est de -4. Sur le jet d'encaissement, tout résultat inférieur à 4 devient 4.", default: false },
+  { group: 'Options alternatives', name: 'degat-ajout-malus-libre',           descr: "Le malus libre d'attaque s'ajoute au jet d'encaissement et aux autres bonus. Exemple : la difficulté libre de l'attaquant est de -4. Le jet d'encaissement est effectué à 2d10+4, plus les bonus de situation et d'armes.", default: false },
+];
+
+const uniquementJoueur = listeReglesOptionnelles.filter(it => it.uniquementJoueur).map(it=>it.name);
+
+export class ReglesOptionnelles extends FormApplication {
+  static init() {
+    for (const regle of listeReglesOptionnelles) {
+      const name = regle.name;
+      const id = ReglesOptionnelles._getIdRegle(name);
+      game.settings.register(SYSTEM_RDD, id, { name: id, scope: regle.scope ?? "world", config: false, default: regle.default == undefined ? true : regle.default, type: Boolean });
+    }
+
+    game.settings.registerMenu(SYSTEM_RDD, "rdd-options-regles", {
+      name: "Choisir les règles optionnelles",
+      label: "Règles optionnelles",
+      hint: "Ouvre la fenêtre de sélection des règles optionnelles",
+      icon: "fas fa-bars",
+      type: ReglesOptionnelles
+    });
+  }
+
+  constructor(...args) {
+    super(...args);
+  }
+
+  static _getIdRegle(name) {
+    return `rdd-option-${name}`;
+  }
+
+  static get defaultOptions() {
+    const options = super.defaultOptions;
+    mergeObject(options, {
+      id: "regles-optionnelles",
+      template: "systems/foundryvtt-reve-de-dragon/templates/settings/regles-optionnelles.html",
+      height: 600,
+      width: 450,
+      minimizable: false,
+      closeOnSubmit: true,
+      title: "Règles optionnelles"
+    });
+    return options;
+  }
+
+  getData() {
+    let formData = super.getData();
+    const regles = listeReglesOptionnelles.filter(it => game.user.isGM || it.scope == "client").map(it => {
+      it = duplicate(it);
+      it.id = ReglesOptionnelles._getIdRegle(it.name);
+      it.active = ReglesOptionnelles.isSet(it.name);
+      return it;
+    });
+    formData.regles = regles;
+    formData.groups = Misc.classify(regles, it => it.group);
+    return formData;
+  }
+
+  static isUsing(name) {
+    if (game.user.isGM && uniquementJoueur.includes(name)) {
+      return true;
+    }
+    return ReglesOptionnelles.isSet(name);
+  }
+
+  static isSet(name) {
+    return game.settings.get(SYSTEM_RDD, ReglesOptionnelles._getIdRegle(name));
+  }
+
+  static set(name, value) {
+    return game.settings.set(SYSTEM_RDD, ReglesOptionnelles._getIdRegle(name), value ? true: false);
+  }
+
+  activateListeners(html) {
+    html.find(".select-option").click((event) => {
+      if (event.currentTarget.attributes.name) {
+        let id = event.currentTarget.attributes.name.value;
+        let isChecked = event.currentTarget.checked;
+        game.settings.set(SYSTEM_RDD, id, isChecked);
+      }
+    });
+  }
+
+  async _updateObject(event, formData) {
+    this.close();
+  }
+}
+

module/settings/system-compendiums.js

@@ -47,6 +47,7 @@ export class SystemCompendiums extends FormApplication {
       label: "Compendiums système",
       hint: "Ouvre la fenêtre de sélection des compendiums système",
       icon: "fas fa-bars",
+      restricted: true,
       type: SystemCompendiums
     })
   }

module/sommeil/app-astrologie.js

@@ -128,7 +128,7 @@ export class AppAstrologie extends Application {
       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.html.find('[name="rebuild-nombres-astraux"]').click(event => this.onRebuild());
 
     this.onCalculThemeAstral();
   }
@@ -144,7 +144,7 @@ export class AppAstrologie extends Application {
   }
 
   /* -------------------------------------------- */
-  async rebuildNombresAstraux() {
+  async onRebuild() {
     game.system.rdd.calendrier.resetNombresAstraux();
 
     await game.system.rdd.calendrier.rebuildNombresAstraux();

module/sommeil/dialog-repos.js

@@ -1,4 +1,4 @@
-import { ReglesOptionelles } from "../settings/regles-optionelles.js";
+import { ReglesOptionnelles } from "../settings/regles-optionnelles.js";
 import { EffetsDraconiques } from "../tmr/effets-draconiques.js";
 
 export class DialogRepos extends Dialog {
@@ -7,7 +7,7 @@ export class DialogRepos extends Dialog {
     if (!actor.isPersonnage()) {
       return
     }
-    if (!ReglesOptionelles.isUsing("chateau-dormant-gardien") || !actor.hasPlayerOwner) {
+    if (!ReglesOptionnelles.isUsing("chateau-dormant-gardien") || !actor.hasPlayerOwner) {
       actor.system.sommeil = {
         "nouveaujour": true,
         "insomnie": EffetsDraconiques.isSujetInsomnie(actor),

module/time/auto-adjust-darkness.js

@@ -0,0 +1,34 @@
+import { SYSTEM_RDD } from "../constants.js";
+
+export const AUTO_ADJUST_DARKNESS = "auto-adjust-darkness";
+
+export class AutoAdjustDarkness {
+
+  static init() {
+    game.settings.register(SYSTEM_RDD, AUTO_ADJUST_DARKNESS, {
+      name: AUTO_ADJUST_DARKNESS,
+      scope: "world",
+      config: false,
+      default: true,
+      type: Boolean
+    });
+  }
+
+  static async adjust(darkness) {
+    if (AutoAdjustDarkness.isAuto()) {
+      const scene = game.scenes.viewed;
+      if (scene.globalLight && scene.tokenVision) {
+        await scene.update({ darkness });
+      }
+    }
+  }
+
+  static isAuto() {
+    return game.settings.get(SYSTEM_RDD, AUTO_ADJUST_DARKNESS);
+  }
+
+  static async toggle() {
+    const previous = AutoAdjustDarkness.isAuto();
+    await game.settings.set(SYSTEM_RDD, AUTO_ADJUST_DARKNESS, !previous)
+  }
+}

module/time/rdd-calendrier.js

@@ -5,10 +5,11 @@ import { RdDUtility } from "../rdd-utility.js";
 import { RdDDice } from "../rdd-dice.js";
 import { Misc } from "../misc.js";
 import { DialogChronologie } from "../dialog-chronologie.js";
-import { HIDE_DICE, SHOW_DICE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "../constants.js";
-import { ReglesOptionelles } from "../settings/regles-optionelles.js";
+import { HIDE_DICE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "../constants.js";
+import { ReglesOptionnelles } from "../settings/regles-optionnelles.js";
 import { DialogChateauDormant } from "../sommeil/dialog-chateau-dormant.js";
 import { APP_ASTROLOGIE_REFRESH, AppAstrologie } from "../sommeil/app-astrologie.js";
+import { AutoAdjustDarkness } from "./auto-adjust-darkness.js";
 
 const TEMPLATE_CALENDRIER = "systems/foundryvtt-reve-de-dragon/templates/time/calendar.hbs";
 
@@ -51,7 +52,7 @@ export class RdDCalendrier extends Application {
     if (Misc.isUniqueConnectedGM()) { // Uniquement si GM
       RdDTimestamp.setWorldTime(this.timestamp);
       this.nombresAstraux = this.getNombresAstraux();
-      this.rebuildNombresAstraux(HIDE_DICE); // Ensure always up-to-date
+      this.rebuildNombresAstraux(); // Ensure always up-to-date
     }
     Hooks.on('updateSetting', async (setting, update, options, id) => this.onUpdateSetting(setting, update, options, id));
   }
@@ -84,33 +85,22 @@ export class RdDCalendrier extends Application {
   }
 
   display() {
+    AutoAdjustDarkness.adjust(RdDTimestamp.getWorldTime().darkness);
     const pos = this.getSavePosition()
     this.render(true, { left: pos.left, top: pos.top });
     return this;
   }
 
   _getHeaderButtons() {
-    const buttons = [];
     if (game.user.isGM) {
-      buttons.unshift({
-        class: "calendar-astrologie",
-        icon: "fa-solid fa-moon-over-sun",
-        onclick: ev => this.showAstrologieEditor()
-      },
-        {
-          class: "calendar-set-datetime",
-          icon: "fa-solid fa-calendar-pen",
-          onclick: ev => this.showCalendarEditor()
-        });
+      return [
+        { class: "calendar-astrologie", icon: "fa-solid fa-moon-over-sun", onclick: ev => this.showAstrologieEditor() },
+        { class: "calendar-set-datetime", icon: "fa-solid fa-calendar-pen", onclick: ev => this.showCalendarEditor() },
+      ]
     }
-    return buttons
+    return []
   }
 
-  /*async maximize() {
-    await super.maximize()
-    this.render(true)
-  }*/
-
   async close() { }
 
   async onUpdateSetting(setting, update, options, id) {
@@ -134,6 +124,7 @@ export class RdDCalendrier extends Application {
     formData.isGM = game.user.isGM;
     formData.heures = RdDTimestamp.definitions()
     formData.horlogeAnalogique = this.horlogeAnalogique;
+    formData.autoDarkness = AutoAdjustDarkness.isAuto()
     return formData;
   }
 
@@ -144,6 +135,7 @@ export class RdDCalendrier extends Application {
     this.html = html;
     this.html.find('.ajout-chronologie').click(ev => DialogChronologie.create());
     this.html.find('.toggle-horloge-analogique').click(ev => this.onToggleHorlogeAnalogique())
+    this.html.find('.toggle-auto-darkness').click(ev => this.onToggleAutoDarkness())
     this.html.find('.calendar-btn').click(ev => this.onCalendarButton(ev));
     this.html.find('.horloge-roue .horloge-heure').click(event => {
       const h = this.html.find(event.currentTarget)?.data('heure');
@@ -229,15 +221,8 @@ export class RdDCalendrier extends Application {
   }
 
   /* -------------------------------------------- */
-  async ajouterNombreAstral(indexDate, showDice = SHOW_DICE) {
-    const nombreAstral = await RdDDice.rollTotal("1dh", { showDice: showDice, rollMode: "selfroll" });
-    const dateFuture = RdDTimestamp.formatIndexDate(indexDate);
-    if (showDice != HIDE_DICE) {
-      ChatMessage.create({
-        whisper: ChatMessage.getWhisperRecipients("GM"),
-        content: `Le chiffre astrologique du ${dateFuture} sera le ${nombreAstral}`
-      });
-    }
+  async ajouterNombreAstral(indexDate) {
+    const nombreAstral = await RdDDice.rollTotal("1dh", { showDice: HIDE_DICE, rollMode: "selfroll" });
     return {
       nombreAstral: nombreAstral,
       valeursFausses: [],
@@ -272,9 +257,8 @@ export class RdDCalendrier extends Application {
   }
 
   /* -------------------------------------------- */
-  async rebuildNombresAstraux(showDice = HIDE_DICE) {
+  async rebuildNombresAstraux() {
     if (Misc.isUniqueConnectedGM()) {
-      console.log("Astral rebuild")
       let newList = [];
       for (let i = 0; i < MAX_NOMBRE_ASTRAL; i++) {
         let dayIndex = this.timestamp.indexDate + i;
@@ -282,7 +266,7 @@ export class RdDCalendrier extends Application {
         if (na) {
           newList[i] = na;
         } else {
-          newList[i] = await this.ajouterNombreAstral(dayIndex, showDice);
+          newList[i] = await this.ajouterNombreAstral(dayIndex);
         }
       }
       this.nombresAstraux = newList;
@@ -305,7 +289,7 @@ export class RdDCalendrier extends Application {
     const oldTimestamp = this.timestamp;
     await Promise.all(game.actors.map(async actor => await actor.onTimeChanging(oldTimestamp, newTimestamp)));
     RdDTimestamp.setWorldTime(newTimestamp);
-    if (oldTimestamp.indexDate + 1 == newTimestamp.indexDate && ReglesOptionelles.isUsing("chateau-dormant-gardien")) {
+    if (oldTimestamp.indexDate + 1 == newTimestamp.indexDate && ReglesOptionnelles.isUsing("chateau-dormant-gardien")) {
       await DialogChateauDormant.create();
     }
     this.timestamp = newTimestamp;
@@ -380,7 +364,7 @@ export class RdDCalendrier extends Application {
       if (request.rolled.isSuccess) {
         if (request.rolled.isPart) {
           // Gestion expérience (si existante)
-          request.competence = actor.getCompetence("astrologie")
+          request.competence = actor.getCompetence('Astrologie')
           request.selectedCarac = actor.system.carac["vue"];
           actor.appliquerAjoutExperience(request, 'hide');
         }
@@ -452,4 +436,9 @@ export class RdDCalendrier extends Application {
   async showAstrologieEditor() {
     await AppAstrologie.create();
   }
+
+  async onToggleAutoDarkness() {
+    await AutoAdjustDarkness.toggle()
+    this.display()
+  }
 }

module/time/rdd-timestamp.js

@@ -2,6 +2,7 @@ import { SHOW_DICE, SYSTEM_RDD } from "../constants.js";
 import { Grammar } from "../grammar.js";
 import { Misc } from "../misc.js";
 import { RdDDice } from "../rdd-dice.js";
+import { AutoAdjustDarkness } from "./auto-adjust-darkness.js";
 
 export const WORLD_TIMESTAMP_SETTING = "calendrier";
 
@@ -15,18 +16,18 @@ export const RDD_MINUTES_PAR_JOUR = 1440; //RDD_HEURES_PAR_JOUR * RDD_MINUTES_PA
 const ROUNDS_PAR_MINUTE = 10;
 
 const DEFINITION_HEURES = [
-  { key: "vaisseau", label: "Vaisseau", lettreFont: 'v', saison: "Printemps" },
-  { key: "sirene", label: "Sirène", lettreFont: 'i', saison: "Printemps" },
-  { key: "faucon", label: "Faucon", lettreFont: 'f', saison: "Printemps" },
-  { key: "couronne", label: "Couronne", lettreFont: '', saison: "Eté" },
-  { key: "dragon", label: "Dragon", lettreFont: 'd', saison: "Eté" },
-  { key: "epees", label: "Epées", lettreFont: 'e', saison: "Eté" },
-  { key: "lyre", label: "Lyre", lettreFont: 'l', saison: "Automne" },
-  { key: "serpent", label: "Serpent", lettreFont: 's', saison: "Automne" },
-  { key: "poissonacrobate", label: "Poisson Acrobate", lettreFont: 'p', saison: "Automne" },
-  { key: "araignee", label: "Araignée", lettreFont: 'a', saison: "Hiver" },
-  { key: "roseau", label: "Roseau", lettreFont: 'r', saison: "Hiver" },
-  { key: "chateaudormant", label: "Château Dormant", lettreFont: 'c', saison: "Hiver" },
+  { key: "vaisseau", label: "Vaisseau", lettreFont: 'v', saison: "Printemps" , darkness: 0.7},
+  { key: "sirene", label: "Sirène", lettreFont: 'i', saison: "Printemps" , darkness: 0.4},
+  { key: "faucon", label: "Faucon", lettreFont: 'f', saison: "Printemps" , darkness: 0},
+  { key: "couronne", label: "Couronne", lettreFont: '', saison: "Eté" , darkness: 0},
+  { key: "dragon", label: "Dragon", lettreFont: 'd', saison: "Eté", darkness: 0 },
+  { key: "epees", label: "Epées", lettreFont: 'e', saison: "Eté", darkness: 0},
+  { key: "lyre", label: "Lyre", lettreFont: 'l', saison: "Automne", darkness: 0.4 },
+  { key: "serpent", label: "Serpent", lettreFont: 's', saison: "Automne", darkness: 0.7 },
+  { key: "poissonacrobate", label: "Poisson Acrobate", lettreFont: 'p', saison: "Automne", darkness: 1 },
+  { key: "araignee", label: "Araignée", lettreFont: 'a', saison: "Hiver", darkness: 1 },
+  { key: "roseau", label: "Roseau", lettreFont: 'r', saison: "Hiver", darkness: 1 },
+  { key: "chateaudormant", label: "Château Dormant", lettreFont: 'c', saison: "Hiver", darkness: 1 },
 ]
 
 const FORMULES_DUREE = [
@@ -58,6 +59,7 @@ export class RdDTimestamp {
       type: Object
     });
 
+
     for (let i = 0; i < DEFINITION_HEURES.length; i++) {
       DEFINITION_HEURES[i].heure = i;
       DEFINITION_HEURES[i].hh = RdDTimestamp.hh(i);
@@ -66,7 +68,6 @@ export class RdDTimestamp {
     }
   }
 
-
   static hh(heure) {
     return heure < 9 ? `0${heure + 1}` : `${heure + 1}`;
   }
@@ -156,7 +157,9 @@ export class RdDTimestamp {
     fields.minute.change(async (event) => await onChangeTimestamp(fields, path));
   }
 
-
+  static defHeure(heure) {
+    return DEFINITION_HEURES.find(it => (it.heure) == heure % RDD_HEURES_PAR_JOUR);
+  }
   static findHeure(heure) {
     heure = Grammar.toLowerCaseNoAccentNoSpace(heure);
     let parHeureOuLabel = DEFINITION_HEURES.filter(it => (it.heure) == parseInt(heure) % RDD_HEURES_PAR_JOUR || Grammar.toLowerCaseNoAccentNoSpace(it.label) == heure);
@@ -237,6 +240,13 @@ export class RdDTimestamp {
   get angleHeure() { return this.indexMinute / RDD_MINUTES_PAR_JOUR * 360 - 45 }
   get angleMinute() { return this.indexMinute / RDD_MINUTES_PAR_HEURES * 360 + 45 }
 
+  get darkness() {
+    const darknessDebut = RdDTimestamp.definition(this.heure).darkness *100
+    const darknessFin = RdDTimestamp.definition(this.heure + 1).darkness *100
+    const darknessMinute = Math.round((darknessFin - darknessDebut) * this.minute / RDD_MINUTES_PAR_HEURES);
+    return (darknessDebut + darknessMinute)/100
+  }
+
   /**
    * Convertit le timestamp en une structure avec les informations utiles
    * pour afficher la date et l'heure

module/tmr-utility.js

@@ -1,6 +1,7 @@
 import { Misc } from "./misc.js";
 import { Grammar } from "./grammar.js";
 import { RdDDice } from "./rdd-dice.js";
+import { tmrConstants } from "./tmr-constants.js";
 
 /* -------------------------------------------- */
 const TMRMapping = {
@@ -163,7 +164,7 @@ const TMRMapping = {
   C12: { type: "lac", label: "Lac de Fricassa" },
   D12: { type: "collines", label: "Collines d’Huaï" },
   E12: { type: "monts", label: "Monts Ajourés" },
-  F12: { type: "necropole", label: "Nécropole de Troat" },
+  F12: { type: "necropole", label: "Nécropole de Throat" },
   G12: { type: "plaines", label: "Plaines de Lufmil" },
   H12: { type: "collines", label: "Collines de Tooth" },
   I12: { type: "gouffre", label: "Gouffre Abimeux" },
@@ -199,7 +200,7 @@ const TMRMapping = {
   K14: { type: "necropole", label: "Nécropole d’Antinéar" },
   L14: { type: "plaines", label: "Plaines de Jislith" },
   M14: { type: "desolation", label: "Désolation d’Après" },
-  
+
   A15: { type: "cite", label: "Cité de Mielh" },
   C15: { type: "plaines", label: "Plaines de Toué" },
   E15: { type: "foret", label: "Forêt des Furies" },
@@ -274,11 +275,11 @@ export class TMRUtility {
     const tmr = TMRUtility.getTMR(coord);
     return Grammar.articleDetermine(tmr.type) + ' ' + tmr.label;
   }
-  
-  static findTMRLike(type, options = {inclusMauvaise:true}) {
+
+  static findTMRLike(type, options = { inclusMauvaise: true }) {
     const choix = [...Object.values(TMRType)]
-    if (options.inclusMauvaise){
-      choix.push({name: 'Mauvaise'});
+    if (options.inclusMauvaise) {
+      choix.push({ name: 'Mauvaise' });
     }
     const selection = Misc.findAllLike(type, choix).map(it => it.name);
     if (selection.length == 0) {
@@ -297,7 +298,7 @@ export class TMRUtility {
   }
 
   static buildSelectionTypesTMR(typesTMR) {
-    typesTMR = typesTMR?? [];
+    typesTMR = typesTMR ?? [];
     return Object.values(TMRType).map(value => Misc.upperFirst(value.name))
       .sort()
       .map(name => { return { name: name, selected: typesTMR.includes(name) } });
@@ -375,6 +376,36 @@ export class TMRUtility {
     return caseList;
   }
 
+  // /* -------------------------------------------- */
+  static computeEventPosition(event) {
+    if (!event.nativeEvent.target.getBoundingClientRect) {
+      return { x: 0, y: 0 }
+    }
+    const canvasRect = event.nativeEvent.target.getBoundingClientRect();
+    return {
+      x: event.nativeEvent.clientX - canvasRect.left,
+      y: event.nativeEvent.clientY - canvasRect.top
+    };
+  }
+
+  /* -------------------------------------------- */
+  static computeEventOddq(event) {
+    var { x, y } = TMRUtility.computeEventPosition(event);
+    return TMRUtility.computeOddq(x, y);
+  }
+
+  static computeOddq(x, y) {
+    const col = Math.floor(x / tmrConstants.cellw); //  [From 0 -> 12]
+    const decallageColonne = col % 2 == 0 ? tmrConstants.col1_y : tmrConstants.col2_y;
+    const row = Math.floor((y - decallageColonne) / tmrConstants.cellh); //  [From 0 -> 14]
+    return { col, row };
+  }
+
+  static computeEventCoord(event) {
+    const oddq = TMRUtility.computeEventOddq(event);
+    return TMRUtility.oddqToCoordTMR(oddq);
+  }
+
   /* -------------------------------------------- */
   // https://www.redblobgames.com/grids/hexagons/#distances
   // TMR Letter-row correspond to "odd-q" grid (letter => col, numeric => row )
@@ -400,7 +431,7 @@ export class TMRUtility {
       col >= 0 && col < 13 &&
       row >= 0 &&
       (row + col % 2 <= 14)
-      );
+    );
     // if (x >= 0 && x < 13 && y >= 0 && y < 14) return true;
     // if (x >= 0 && x < 13 && x % 2 == 0 && y == 14) return true;
     // return false;
@@ -444,7 +475,7 @@ export class TMRUtility {
 
   static axial_subtract(a, b) {
     return {
-      q: a.q- b.q,
+      q: a.q - b.q,
       r: a.r - b.r
     };
   }
@@ -456,7 +487,7 @@ export class TMRUtility {
   // return Cube(q, r, s)
   // }
 
-  
+
   // /* -------------------------------------------- */
   // static computeRealPictureCoordinates(coordOddq) {
   //   let decallagePairImpair = (coordOddq.col % 2 == 0) ? tmrConstants.col1_y : tmrConstants.col2_y;

module/tmr/carte-tmr.js

@@ -4,7 +4,6 @@ import { PixiTMR } from "./pixi-tmr.js";
 export class CarteTmr extends Draconique {
 
   constructor() {
-    console.log("Sprite create 1!!!!")
     super();
   }
 
@@ -14,9 +13,25 @@ export class CarteTmr extends Draconique {
   async onActorCreateOwned(actor, item) { }
 
   code() { return 'tmr' }
-  img() { return 'systems/foundryvtt-reve-de-dragon/styles/img/ui/tmp_main_r1.webp' }
+  img() { return 'systems/foundryvtt-reve-de-dragon/styles/img/ui/tmr.webp' }
 
   createSprite(pixiTMR) {
-    return pixiTMR.carteTmr(this.code());
+
+    const img = PixiTMR.getImgFromCode(this.code())
+    const sprite = new PIXI.Sprite(PIXI.utils.TextureCache[img]);
+    // Setup the position of the TMR
+    sprite.x = 0;
+    sprite.y = 0;
+    sprite.width = 722;
+    sprite.height = 860;
+    // Rotate around the center
+    sprite.anchor.set(0);
+    sprite.buttonMode = true;
+    sprite.tmrObject = pixiTMR;
+
+    pixiTMR.addTooltip(sprite, (e,s) => this.computeTooltip(e,s));
+    pixiTMR.pixiApp.stage.addChild(sprite);
+    return sprite;
   }
+
 }

module/tmr/draconique.js

@@ -11,7 +11,7 @@ const registeredEffects = [
 export class Draconique {
   static isCaseTMR(item) { return item.type == TYPES.casetmr; }
   static isQueueDragon(item) { return item.isQueueDragon(); }
-  static isSouffleDragon(item) {return item.type == TYPES.souffle; }
+  static isSouffleDragon(item) { return item.type == TYPES.souffle; }
   static isTeteDragon(item) { return item.type == TYPES.tete; }
   static isQueueSouffle(item) { return Draconique.isQueueDragon(item) || Draconique.isSouffleDragon(item); }
 
@@ -78,25 +78,45 @@ export class Draconique {
   /**
    * @param {*} img l'url du fichier image à utiliser pour le token. Si indéfini (et si createSprite n'est pas surchargé),
    *  un disque est utilisé.
-   */
+  */
   img() { return undefined }
 
   /**
-   * factory d'élément graphique PIXI correpsondant à l'objet draconique
+   * factory d'élément graphique PIXI correspondant à l'objet draconique
    * @param {*} pixiTMR instance de PixiTMR qui gère les tooltips, les méthodes de création de sprite standard, les clicks.
-   */
+  */
   token(pixiTMR, linkData, coordTMR, type = undefined) {
     const token = {
       sprite: this.createSprite(pixiTMR),
       coordTMR: coordTMR
     };
     token[type ?? this.code()] = linkData;
-    console.log("SPRITE: ", token.sprite)
-    //PixiTMR.getImgFromCode()
-    pixiTMR.addTooltip(token.sprite, this.tooltip(linkData));
+    this.linkData = linkData;
+    if (this.tooltip(linkData)) {
+      pixiTMR.addTooltip(token.sprite, (e, s) => this.computeTooltip(e, s));
+    }
     return token;
   }
 
+  /**
+   * methode en charge de recalculer le tooltip lorsque la souris bouge
+   * @param {*} event evenement contenant les coordonnées
+   * @param {*} sprite sprite pour laquelle calculer le tooltip
+   */
+  computeTooltip(event, sprite) {
+    if (sprite.isOver) {
+      const oddq = TMRUtility.computeEventOddq(event);
+      const coord = TMRUtility.oddqToCoordTMR(oddq);
+      const tmr = TMRUtility.getTMR(coord)
+      if (tmr){
+        const label = TMRUtility.getTMRLabel(coord);
+        const text = this.tooltip(this.linkData);
+        return text ? `${coord}: ${label}\n${text}` : `${coord}: ${label}`
+      }
+    }
+    return '';
+  }
+
   /**
    * factory d'élément graphique PIXI correpsondant à l'objet draconique
    * @param {*} pixiTMR instance de PixiTMR qui gère les tooltips, les méthodes de création de sprite standard, les clicks.
@@ -118,11 +138,11 @@ export class Draconique {
   isCase(item, coord = undefined) {
     return Draconique.isCaseTMR(item) && item.system.specific == this.code() && (coord ? item.system.coord == coord : true);
   }
-  
+
   find(list, coord = undefined) {
     return list.find(c => this.isCase(c, coord));
   }
-  
+
   async createCaseTmr(actor, label, tmr, sourceId = undefined) {
     const casetmrData = {
       name: label, type: 'casetmr', img: this.img(),
@@ -130,12 +150,12 @@ export class Draconique {
     };
     await actor.createEmbeddedDocuments('Item', [casetmrData]);
   }
-  
+
   async deleteCasesTmr(actor, draconique) {
     let caseTmrs = actor.items.filter(it => this.isCaseForSource(it, draconique));
     await actor.deleteEmbeddedDocuments('Item', caseTmrs.map(it => it.id));
   }
-  
+
   isCaseForSource(item, draconique) {
     return Draconique.isCaseTMR(item) && item.system.specific == this.code() && item.system.sourceid == draconique.id;
   }

module/tmr/pixi-tmr.js

@@ -1,6 +1,8 @@
+import { RdDTMRDialog } from "../rdd-tmr-dialog.js";
 import { tmrConstants, tmrTokenZIndex } from "../tmr-constants.js";
+import { TMRUtility } from "../tmr-utility.js";
 
-const tooltipStyle = new PIXI.TextStyle({
+export const tooltipStyle = new PIXI.TextStyle({
   fontFamily: 'CaslonAntique',
   fontSize: 18,
   fill: '#FFFFFF',
@@ -20,7 +22,7 @@ export class PixiTMR {
     this.callbacksOnAnimate = [];
   }
 
-  async load( onLoad = (loader, resources) => {} )  {
+  async load(onLoad = (loader, resources) => { }) {
     // WIP - Deprecated since v7 : let loader = new PIXI.Loader();
     for (const [name, img] of Object.entries(PixiTMR.textures)) {
       const texture = await PIXI.Assets.load(img);
@@ -40,40 +42,17 @@ export class PixiTMR {
     PixiTMR.textures[name] = img;
   }
 
-  animate(animation = pixiApp=>{})
-  {
+  animate(animation = pixiApp => { }) {
     this.callbacksOnAnimate.push(() => animation(this.pixiApp));
   }
 
-  carteTmr(code) {
-    let img = PixiTMR.getImgFromCode(code)
-    const carteTmr = new PIXI.Sprite(PIXI.utils.TextureCache[img]);
-    console.log(code, carteTmr)
-    // Setup the position of the TMR
-    carteTmr.x = 0;
-    carteTmr.y = 0;
-    carteTmr.width = 720;
-    carteTmr.height = 860;
-    // Rotate around the center
-    carteTmr.anchor.set(0);
-    carteTmr.eventMode = 'dynamic'; // PIXI 7 : Not sure ..
-    // This one is deprecated ; carteTmr.interactive = true;
-    carteTmr.buttonMode = true;
-    carteTmr.tmrObject = this;
-    if (!this.tmrObject.viewOnly) {
-      carteTmr.on('pointerdown', event => this.onClickBackground(event));
-    }
-    this.pixiApp.stage.addChild(carteTmr);
-    return carteTmr;
-  }
-
   sprite(code, options = {}) {
     let img = PixiTMR.getImgFromCode(code)
     const texture = PIXI.utils.TextureCache[img];
     if (!texture) {
       console.error("Texture manquante", code, PIXI.utils.TextureCache)
       return;
-    }  
+    }
     let sprite = new PIXI.Sprite(texture);
     sprite.width = options.taille ?? tmrConstants.half;
     sprite.height = options.taille ?? tmrConstants.half;
@@ -81,13 +60,13 @@ export class PixiTMR {
     if (options.color) {
       sprite.tint = options.color;
     }
-    sprite.zIndex = options.zIndex ?? tmrTokenZIndex.casehumide+1;
+    sprite.zIndex = options.zIndex ?? tmrTokenZIndex.casehumide + 1;
     sprite.alpha = options.alpha ?? 0.75;
     sprite.decallage = options.decallage ?? tmrConstants.center;
     this.pixiApp.stage.addChild(sprite);
     return sprite;
-  }  
-  
+  }
+
   circle(name, options = {}) {
     let sprite = new PIXI.Graphics();
     sprite.beginFill(options.color, options.opacity);
@@ -98,27 +77,37 @@ export class PixiTMR {
     return sprite;
   }
 
-  addTooltip(sprite, text) {
-    if (text) {
-      sprite.tooltip = new PIXI.Text(text, tooltipStyle);
-      sprite.tooltip.zIndex = tmrTokenZIndex.tooltip;
-      sprite.isOver = false;
-      // Deprecated : sprite.interactive = true; 
-      sprite.eventMode = 'dynamic'; // PIXI 7 To be checked
-      sprite.on('pointerdown', event => this.onClickBackground(event))
-        .on('pointerover', () => this.onShowTooltip(sprite))
-        .on('pointerout', () => this.onHideTooltip(sprite));
-    }
+  addTooltip(sprite, computeTooltip) {
+    sprite.tooltip = new PIXI.Text('', tooltipStyle);
+    sprite.tooltip.zIndex = tmrTokenZIndex.tooltip;
+    sprite.isOver = false;
+    sprite.eventMode = 'dynamic'; // PIXI 7 To be checked
+    sprite
+      .on('pointermove', event => this.onPointerMove(event, sprite, computeTooltip))
+      .on('pointerdown', event => this.onClickBackground(event))
+      .on('pointerover', event => this.onShowTooltip(event, sprite))
+      .on('pointerout', event => this.onHideTooltip(event, sprite));
   }
-  
 
   onClickBackground(event) {
-    this.tmrObject.onClickTMR(event)
+    if (!this.viewOnly) {
+      this.tmrObject.onClickTMR(event)
+    }
   }
 
-  onShowTooltip(sprite) {
-    if (sprite.tooltip) {
+  onPointerMove(event, sprite, computeTooltip) {
+    if (sprite.isOver && sprite.tooltip) {
+      var { x, y } = TMRUtility.computeEventPosition(event);
+      const oddq = TMRUtility.computeOddq(x, y);
 
+      sprite.tooltip.x = x + (oddq.col > 8 ? - 3 * tmrConstants.full : tmrConstants.half)
+      sprite.tooltip.y = y + (oddq.row > 10 ? - tmrConstants.half : tmrConstants.half)
+      sprite.tooltip.text = computeTooltip(event, sprite);
+    }
+  }
+
+  onShowTooltip(event, sprite) {
+    if (sprite.tooltip) {
       if (!sprite.isOver) {
         sprite.tooltip.x = sprite.x;
         sprite.tooltip.y = sprite.y;
@@ -128,7 +117,7 @@ export class PixiTMR {
     }
   }
 
-  onHideTooltip(sprite) {
+  onHideTooltip(event, sprite) {
     if (sprite.tooltip) {
       if (sprite.isOver) {
         this.pixiApp.stage.removeChild(sprite.tooltip);
@@ -137,7 +126,7 @@ export class PixiTMR {
     }
   }
 
-  setPosition( sprite, oddq) {
+  setPosition(sprite, oddq) {
     let decallagePairImpair = (oddq.col % 2 == 0) ? tmrConstants.col1_y : tmrConstants.col2_y;
     let dx = (sprite.decallage == undefined) ? 0 : sprite.decallage.x;
     let dy = (sprite.decallage == undefined) ? 0 : sprite.decallage.y;

module/tmr/present-cites.js

@@ -49,12 +49,13 @@ export class PresentCites extends Draconique {
     const presents = await game.system.rdd.rencontresTMR.getPresentsCite()
     const buttons = {};
     presents.forEach(r =>  buttons['present'+r.id] = { icon: '<i class="fas fa-check"></i>', label: r.name, callback: async () => onChoixPresent(r) });
-    let d = new Dialog({
+    let dialog = new Dialog({
       title: "Présent des cités",
       content: `La ${this.tmrLabel(casetmr)} vous offre un présent, faites votre choix`,
       buttons: buttons
     });
-    d.render(true);
+    dialog.render(true);
+    return dialog
   }
 
   async ouvrirLePresent(actor, casetmr) {

packs/animaux/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000045

packs/animaux/LOG

@@ -1,7 +0,0 @@
-2023/05/29-08:40:34.656615 7fca067fc6c0 Recovering log #43
-2023/05/29-08:40:34.674483 7fca067fc6c0 Delete type=3 #41
-2023/05/29-08:40:34.674520 7fca067fc6c0 Delete type=0 #43
-2023/05/29-08:50:04.296687 7fca04ff96c0 Level-0 table #48: started
-2023/05/29-08:50:04.296723 7fca04ff96c0 Level-0 table #48: 0 bytes OK
-2023/05/29-08:50:04.302846 7fca04ff96c0 Delete type=0 #46
-2023/05/29-08:50:04.323728 7fca04ff96c0 Manual compaction at level-0 from '!actors!0ogeNTXl7IwYfWZR' @ 72057594037927935 : 1 .. '!actors.items!zMvyRrp10dkfcS43.shsUV8UpU18c0RJK' @ 0 : 0; will stop at (end)

packs/animaux/LOG.old

@@ -1,7 +0,0 @@
-2023/05/29-08:00:37.697935 7fca067fc6c0 Recovering log #39
-2023/05/29-08:00:37.713407 7fca067fc6c0 Delete type=3 #37
-2023/05/29-08:00:37.713452 7fca067fc6c0 Delete type=0 #39
-2023/05/29-08:38:02.219865 7fca04ff96c0 Level-0 table #44: started
-2023/05/29-08:38:02.219887 7fca04ff96c0 Level-0 table #44: 0 bytes OK
-2023/05/29-08:38:02.226757 7fca04ff96c0 Delete type=0 #42
-2023/05/29-08:38:02.239623 7fca04ff96c0 Manual compaction at level-0 from '!actors!0ogeNTXl7IwYfWZR' @ 72057594037927935 : 1 .. '!actors.items!zMvyRrp10dkfcS43.shsUV8UpU18c0RJK' @ 0 : 0; will stop at (end)

packs/archetypes/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000044

packs/archetypes/LOG

@@ -1,7 +0,0 @@
-2023/05/29-08:40:34.682366 7fca057fa6c0 Recovering log #42
-2023/05/29-08:40:34.699920 7fca057fa6c0 Delete type=3 #40
-2023/05/29-08:40:34.699959 7fca057fa6c0 Delete type=0 #42
-2023/05/29-08:50:04.323849 7fca04ff96c0 Level-0 table #47: started
-2023/05/29-08:50:04.323886 7fca04ff96c0 Level-0 table #47: 0 bytes OK
-2023/05/29-08:50:04.330053 7fca04ff96c0 Delete type=0 #45
-2023/05/29-08:50:04.352593 7fca04ff96c0 Manual compaction at level-0 from '!actors!1Nng9d8r6lrPHCaJ' @ 72057594037927935 : 1 .. '!actors.items!ryUZTa17LzNv25UY.zyNYa3hYtrOcF2jA' @ 0 : 0; will stop at (end)

packs/archetypes/LOG.old

@@ -1,7 +0,0 @@
-2023/05/29-08:00:37.736173 7fca05ffb6c0 Recovering log #38
-2023/05/29-08:00:37.750924 7fca05ffb6c0 Delete type=3 #36
-2023/05/29-08:00:37.750965 7fca05ffb6c0 Delete type=0 #38
-2023/05/29-08:38:02.239711 7fca04ff96c0 Level-0 table #43: started
-2023/05/29-08:38:02.239732 7fca04ff96c0 Level-0 table #43: 0 bytes OK
-2023/05/29-08:38:02.246710 7fca04ff96c0 Delete type=0 #41
-2023/05/29-08:38:02.253050 7fca04ff96c0 Manual compaction at level-0 from '!actors!1Nng9d8r6lrPHCaJ' @ 72057594037927935 : 1 .. '!actors.items!ryUZTa17LzNv25UY.zyNYa3hYtrOcF2jA' @ 0 : 0; will stop at (end)

packs/arts-et-divertissements.db

@@ -0,0 +1,49 @@
+{"name":"Moussecaille","type":"recettecuisine","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.240HPtZsgZQERFMF"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/recette_cuisine_6.webp","effects":[],"_id":"240HPtZsgZQERFMF","system":{"description":"<p>Civet de cailles aux mousseroles.</p>\n<p>La mousserole est un petit champignon rose, tr&egrave;s abondant apr&egrave;s la pluie (commun). Pratiquement, cette recette peut s&rsquo;appliquer &agrave; tout gibier &agrave; plume pr&eacute;par&eacute; aux champignons.</p>","descriptionmj":"","niveau":6,"ingredients":"<ul>\n<li>4 grosses cailles (1 sust chaque)</li>\n<li>3 livres de mousseroles</li>\n<li>4 &eacute;chalotes</li>\n<li>1 racine de r&eacute;f&egrave;ble</li>\n<li>1 schouillat de miel</li>\n<li>10 schouillats de beurre</li>\n<li>2 doigts d&rsquo;huile</li>\n<li>5 schouillats de farine de bl&eacute;di&egrave;ze</li>\n<li>eau</li>\n<li>sel</li>\n<li>4 brins de klampine</li>\n<li>4 brins de luciane</li>\n<li>1 brin de mentharde</li>\n<li>4 brins de p&egrave;pre</li>\n</ul>","duree":"80 minutes","sust":8,"exotisme":0,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870029,"modifiedTime":1671048281603,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Panaris et Phlegmon","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.36YGDFJBxekzEvBw"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_7.webp","effects":[],"_id":"36YGDFJBxekzEvBw","system":{"description":"<p>Romance sur la fatalit&eacute; qui s&eacute;pare deux amants et que seule la mort r&eacute;unit.</p>\n<p>&Agrave; la fin, la belle Panaris est transform&eacute;e en carafe et le gentil Phlegmon en bouchon de cristal. L&rsquo;empereur, &agrave; qui &eacute;choit le flacon, les rassemble symboliquement.</p>","descriptionmj":"","niveau":7,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870029,"modifiedTime":1671048281603,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La danse des sept rêves","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.4mhiTAEhwDh7S3i0"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_sol_8.webp","effects":[],"_id":"4mhiTAEhwDh7S3i0","system":{"description":"<p>V&eacute;ritable ballet, la danse des sept r&ecirc;ves est une chor&eacute;graphie dramatique &eacute;labor&eacute;e.</p>","descriptionmj":"","type":"soliste","agilite":false,"apparence":true,"niveau":6,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870030,"modifiedTime":1671048281604,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Les fléchettes","type":"jeu","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.8jOKQkuS6RJyM3uD"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_flechettes.webp","effects":[],"_id":"8jOKQkuS6RJyM3uD","system":{"description":"<p>Jeu d&rsquo;adresse consistant &agrave; viser une cible avec des fl&eacute;chettes.</p>\n<p>Pour simuler une partie, faire tirer &agrave; chaque participant 5 jets de Lancer/Jeu &agrave; z&eacute;ro et additionner les points de t&acirc;che obtenus. Le plus grand nombre gagne.</p>","descriptionmj":"","type":"adressehasard","base":-6,"caraccomp":"Lancer","reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870030,"modifiedTime":1671048281604,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La peccadille","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.8p4pMXbgY4S5fZjJ"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_2.webp","effects":[],"_id":"8p4pMXbgY4S5fZjJ","system":{"description":"<p>La peccadille se danse &agrave; deux, comme la valse ou le tango. Plus lente et moins rythm&eacute;e&nbsp; que les deux premi&egrave;res, elle comporte quatre figures :</p>\n<p>1) les cavaliers se tiennent par les mains</p>\n<p>2) ils se tiennent par la taille</p>\n<p>3) figure libre, improvis&eacute;e par celui ou celle qui a invit&eacute; l&rsquo;autre</p>\n<p>4) les deux visages doivent se rapprocher de fa&ccedil;on &agrave; se toucher par le bout du nez &agrave; l&rsquo;exclusion de toute autre partie du corps.</p>\n<p>Et l&rsquo;on recommence.</p>\n<p>L&rsquo;int&eacute;r&ecirc;t de cette danse r&eacute;side dans sa figure libre, sobre ou os&eacute;e, et sa difficult&eacute; dans le nez &agrave; nez.</p>\n<p>Il arrive lors de cette figure que, emport&eacute;s par le mouvement, les visages se heurtent violemment, ce qui produit toujours une mauvaise impression chez le partenaire.</p>","descriptionmj":"","type":"recreative","agilite":false,"apparence":true,"niveau":2,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870030,"modifiedTime":1671048281604,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Les dragons","type":"jeu","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.AVAMD5C2mxuOfwV4"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_calculs.webp","effects":[],"_id":"AVAMD5C2mxuOfwV4","system":{"description":"<p>Les dragons sont les &eacute;checs draconics.</p>\n<p>Plus complexes et soumis &agrave; beaucoup plus de variantes que nos &eacute;checs, les dragons se jouent sur un plateau de 7 x 7 cases. Chaque joueur poss&egrave;de 14 pi&egrave;ces : le voyageur, le haut-r&ecirc;vant, la pucelle, le groin, le m&eacute;nestrel, l&rsquo;archer, la maison, et 7 arbres.</p>\n<p>Les arbres sont l&rsquo;&eacute;quivalent des pions et servent &agrave; constituer les for&ecirc;ts. Les joueurs ne jouent pas l&rsquo;un en face de l&rsquo;autre, mais c&ocirc;te &agrave; c&ocirc;te, avec l&rsquo;&eacute;chiquier devant eux. Il y a ainsi le joueur de droite qui plante la for&ecirc;t dite dextriote, et le joueur de gauche qui plante la for&ecirc;t sinistrante. Quelle que soit la variante jou&eacute;e, l&rsquo;&eacute;chiquier commence vide, les joueurs introduisant leurs pi&egrave;ces, arbres ou autres, l&rsquo;un apr&egrave;s l&rsquo;autre.</p>\n<p>Selon les variantes, les pi&egrave;ces ne se d&eacute;placent pas de la m&ecirc;me fa&ccedil;on. Les arbres ne prennent ni ne se d&eacute;placent jamais. Ils servent d&rsquo;obstacle aux lignes de d&eacute;placement des autres pi&egrave;ces. Seuls les haut-r&ecirc;vants peuvent les prendre dans certaines variantes.</p>\n<p>Les maisons, &eacute;galement fixes, ne peuvent &ecirc;tre prises que quand elles sont vides. Selon les variantes, elles peuvent contenir de deux &agrave; quatre autres pi&egrave;ces (qui coexistent sur la m&ecirc;me case), sauf des arbres. Dans la maison les pi&egrave;ces sont prot&eacute;g&eacute;es, on ne peut les prendre. Une variante permet d&rsquo;agrandir la maison en sacrifiant un arbre.</p>\n<p>Selon une autre, les archers peuvent augmenter leur nombre de fl&egrave;ches en sacrifiant &eacute;galement un arbre.</p>\n<p>Dans la variante traditionnelle, la plus ancienne, le but du jeu est d&rsquo;investir la maison adverse. Cela suppose qu&rsquo;elle soit vide. Il faut pr&eacute;alablement &eacute;liminer ou neutraliser les pi&egrave;ces en dehors, jusqu&rsquo;&agrave; obliger les occupants de la maison &agrave; sortir (comme aux &eacute;checs, on ne peut passer son coup, on doit effectuer un mouvement).</p>\n<p>Dans des variantes plus r&eacute;centes, plus faciles, le but est de capturer une certaine pi&egrave;ce adverse, g&eacute;n&eacute;ralement le groin ou la pucelle (qui joue l&rsquo;&eacute;quivalent du roi de nos &eacute;checs). Une variante tr&egrave;s populaire oblige que ce soit le groin qui capture la pucelle.</p>\n<p>La dur&eacute;e d&rsquo;une partie de dragons est en moyenne d&rsquo;une heure.</p>","descriptionmj":"","type":"reflexion","base":-8,"caraccomp":"Intellect","reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870030,"modifiedTime":1671048281605,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La mort d’Amarak","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.C5smOdHzrDHlrrZq"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_6.webp","effects":[],"_id":"C5smOdHzrDHlrrZq","system":{"description":"<p>&Eacute;pop&eacute;e &agrave; gros budget et effets sp&eacute;ciaux spectaculaires.</p>\n<p>Amarak, ayant bu une potion de gigantisme, meurt en se cognant la t&ecirc;te dans la lune.</p>","descriptionmj":"","niveau":6,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870030,"modifiedTime":1671048281605,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La princesse endormie","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.CBpwK9udfdzlWbfb"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_7.webp","effects":[],"_id":"CBpwK9udfdzlWbfb","system":{"description":"<p>Ballade sur une princesse qui se pique le doigt et dort tr&egrave;s longtemps suite &agrave; un mal&eacute;fice.</p>\n<p>Les derniers couplets sont malheureusement oubli&eacute;s, de sorte que la chanson ne finit pas.</p>","descriptionmj":"","niveau":7,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870030,"modifiedTime":1671048281605,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Le mal rêvé","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.FcTMJE5Wfd02axxd"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_4.webp","effects":[],"_id":"FcTMJE5Wfd02axxd","system":{"description":"<p>Complainte sur la destin&eacute;e mis&eacute;rable d&rsquo;un homme qui avait les oreilles &agrave; la place des genoux.</p>","descriptionmj":"","niveau":4,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870031,"modifiedTime":1671048281605,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La plumette","type":"jeu","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.HyOXCAtpaP7eaHGj"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_plumette.webp","effects":[],"_id":"HyOXCAtpaP7eaHGj","system":{"description":"<p>Jeu d&rsquo;adresse et de volont&eacute;, la plumette se joue &agrave; deux, chacun chatouillant le visage de l&rsquo;autre avec une plume. Les visages doivent rester imperturbables.</p>\n<p>Le premier qui trahit un signe quelconque (rire, &eacute;ternuement, grimace) a perdu.</p>\n<p>Pour simuler une partie, utiliser les r&egrave;gles de combat, chacun &agrave; tour de r&ocirc;le attaquant ou tentant de parer l&rsquo;adversaire.</p>\n<p>Pour attaquer, utiliser DEXT&Eacute;RIT&Eacute;/Jeu difficult&eacute; libre et pour parer VOLONT&Eacute;/Jeu &agrave; la difficult&eacute; de l&rsquo;attaque. Le vainqueur est le premier &agrave; r&eacute;ussir une attaque non par&eacute;e.</p>","descriptionmj":"","type":"adressehasard","base":-4,"caraccomp":"Dextérité / Volonté","reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870032,"modifiedTime":1671048281605,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La bergamasque","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.KJ0Ck2G2t4lYIKJH"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_5.webp","effects":[],"_id":"KJ0Ck2G2t4lYIKJH","system":{"description":"<p>La bergamasque reprend le principe de la sarabande, mais sur un rythme plus vif et des figures plus compliqu&eacute;es.</p>","descriptionmj":"","type":"recreative","agilite":false,"apparence":true,"niveau":5,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870032,"modifiedTime":1671048281606,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Les calculs","type":"jeu","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.MixMWkfRpEN51QuP"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_calculs.webp","effects":[],"_id":"MixMWkfRpEN51QuP","system":{"description":"<p>Ce jeu se pratique avec des calculs, c&rsquo;est &agrave;-dire des petits cailloux, que l&rsquo;on pose alternativement sur une surface grill&eacute;e.</p>\n<p>La strat&eacute;gie est &agrave; mi-chemin entre le go et le morpion.</p>\n<p>Tr&egrave;s pratiqu&eacute;, ce jeu peut &ecirc;tre facilement improvis&eacute; en tra&ccedil;ant la grille &agrave; la craie sur une table, ou &agrave; l&rsquo;ext&eacute;rieur, sur du sable lisse.</p>","descriptionmj":"","type":"reflexion","base":-6,"caraccomp":"Intellect","reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870032,"modifiedTime":1671048281606,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La serpentine","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.N7bgcR8OEh6MpfiF"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_sol_1.webp","effects":[],"_id":"N7bgcR8OEh6MpfiF","system":{"description":"<p>Danse basique, lente ou vive, ondulante et serpentine.</p>","descriptionmj":"","type":"soliste","agilite":false,"apparence":true,"niveau":1,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870032,"modifiedTime":1671048281606,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Rêve de Dragon","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.OTRi9mHhIANUnPA7"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_8.webp","effects":[],"_id":"OTRi9mHhIANUnPA7","system":{"description":"<p>R&eacute;citatif, dont la moralit&eacute; se r&eacute;sume ainsi : puisque tout n&rsquo;est qu&rsquo;un r&ecirc;ve, allons dormir.</p>","descriptionmj":"","niveau":8,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870033,"modifiedTime":1671048281607,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Choucroume","type":"recettecuisine","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.POuOV6xoPnO0b9OQ"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/recette_cuisine_2.webp","effects":[],"_id":"POuOV6xoPnO0b9OQ","system":{"description":"<p>Vari&eacute;t&eacute; de bloutade au chou, cuite dans de la bi&egrave;re.</p>\n<p>&Eacute;mincer finement le chou et le faire revenir dans l&rsquo;huile.</p>\n<p>Ajouter la bi&egrave;re, le sel, les aromates, puis cuire sans cesser de touiller comme pour une bloutade ordinaire.</p>","descriptionmj":"","niveau":2,"ingredients":"<ul>\n<li>1 livre de chou &eacute;minc&eacute;</li>\n<li>2 doigts d&rsquo;huile</li>\n<li>1 pinte de bi&egrave;re</li>\n<li>sel</li>\n<li>8 brins d&rsquo;aromates (b&eacute;jaune, luciane)</li>\n</ul>\n<p>&nbsp;</p>\n<p>Une variante appel&eacute;e choucroume liquide utilise le double de bi&egrave;re (2 pintes) et se consomme froide.</p>","duree":"30 minutes","sust":8,"exotisme":0,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870033,"modifiedTime":1671048281607,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La turlutaine","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.Q5Lx4WWKWGFjF9cX"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_3.webp","effects":[],"_id":"Q5Lx4WWKWGFjF9cX","system":{"description":"<p>Sarabande simplifi&eacute;e dans&eacute;e par les villageois, moins lente et moins guind&eacute;e que cette derni&egrave;re.</p>\n<p>On danse tant&ocirc;t en groupe, tant&ocirc;t par couples, avec changements de partenaire.</p>\n<p>Au moment de la s&eacute;paration pour reformer le groupe, les partenaires s&rsquo;envoient des baisers du bout des doigts.</p>","descriptionmj":"","type":"recreative","agilite":false,"apparence":true,"niveau":3,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870033,"modifiedTime":1671048281607,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Le bourrichon","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.QvMNog5MF3vDIBGR"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_0.webp","effects":[],"_id":"QvMNog5MF3vDIBGR","system":{"description":"<p>Le bourrichon est une sorte de farandole joyeuse et rythm&eacute;e o&ugrave; un grand nombre de danseurs &eacute;voluent en se tenant par la main. Les figures sont libres, l&rsquo;essentiel &eacute;tant de garder le rythme.</p>","descriptionmj":"","type":"recreative","agilite":true,"apparence":true,"niveau":0,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870033,"modifiedTime":1671048281607,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Grabuge","type":"recettecuisine","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.RvsPbA1ehQgRvGu6"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/recette_cuisine_3.webp","effects":[],"_id":"RvsPbA1ehQgRvGu6","system":{"description":"<p>Plat de tomari, de plures et de poisson mijot&eacute; au pif-paf.</p>","descriptionmj":"","niveau":3,"ingredients":"<ul>\n<li>1 livre de tomari</li>\n<li>1 livre de poisson (mer ou eau douce)</li>\n<li>2 poireaux</li>\n<li>6 oignons</li>\n<li>1 laitue</li>\n<li>2 schouillats de beurre</li>\n<li>2 doigts d&rsquo;huile</li>\n<li>1 doigt de vinaigre</li>\n<li>eau</li>\n<li>sel</li>\n<li>6 brins de luciane</li>\n<li>6 brins de klampine</li>\n<li>8 brins de pif-paf</li>\n</ul>","duree":"60 minutes","sust":12,"exotisme":0,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870033,"modifiedTime":1671048281608,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La danse du feu","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.UBVYoQmilTmkqppd"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_sol_5.webp","effects":[],"_id":"UBVYoQmilTmkqppd","system":{"description":"<p>La danse du feu se danse usuellement de nuit et pr&egrave;s d&rsquo;un feu.</p>\n<p>Lente, aux mouvements plus sugg&eacute;r&eacute;s que marqu&eacute;s, elle est imitative des flammes, comme si le danseur avait le feu pour partenaire.</p>","descriptionmj":"","type":"soliste","agilite":false,"apparence":true,"niveau":5,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870034,"modifiedTime":1671048281608,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La danse du voile","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.Ui1bMMBBdxMb2AZ2"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_sol_6.webp","effects":[],"_id":"Ui1bMMBBdxMb2AZ2","system":{"description":"<p>De caract&egrave;re libre, tant&ocirc;t alti&egrave;re comme la souveraine ou d&eacute;hanch&eacute;e comme la callipyge, cette danse utilise un voile comme accessoire (pi&egrave;ce de tissu, ch&acirc;le, &eacute;charpe, etc.).</p>\n<p>Son int&eacute;r&ecirc;t r&eacute;side dans les mouvements du voile avec lesquels s&rsquo;harmonisent ceux de la danseuse.</p>\n<p>Peu pratiqu&eacute;e par les hommes.</p>","descriptionmj":"","type":"soliste","agilite":false,"apparence":true,"niveau":6,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870034,"modifiedTime":1671048281608,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Fleur de haut-rêve","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.Y5rAtXL0WxOqqbZs"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_1.webp","effects":[],"_id":"Y5rAtXL0WxOqqbZs","system":{"description":"<p>Romance &agrave; l&rsquo;eau de rose sur les malheurs d&rsquo;une jeune haut-r&ecirc;vante.</p>","descriptionmj":"","niveau":1,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870034,"modifiedTime":1671048281609,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La souveraine","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.Y791UctCHALnBgjO"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_sol_4.webp","effects":[],"_id":"Y791UctCHALnBgjO","system":{"description":"<p>Danse tr&egrave;s lente, sobre, hi&eacute;ratique, plus caract&eacute;ris&eacute;e par ses poses que par ses mouvements.</p>","descriptionmj":"","type":"soliste","agilite":false,"apparence":true,"niveau":4,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870034,"modifiedTime":1671048281609,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Bras de fer","type":"jeu","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.ZJvL0e5hjuws7mIH"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_brasdefer.webp","effects":[],"_id":"ZJvL0e5hjuws7mIH","system":{"description":"<p>Pour attaquer, utiliser Force/Jeu difficult&eacute; libre.&nbsp; Pour parer, l'opposant joue pareillement&nbsp; Force/Jeu &agrave; la difficult&eacute; de l&rsquo;attaque.</p>\n<p>Le vainqueur est le premier &agrave; r&eacute;ussir une attaque non par&eacute;e.</p>","descriptionmj":"","type":"adressehasard","base":-4,"caraccomp":"Force","reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870034,"modifiedTime":1671048281609,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La chèvre rose","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.aB78Io55m2kXDjwQ"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_3.webp","effects":[],"_id":"aB78Io55m2kXDjwQ","system":{"description":"<p>Ballade comique sur une ch&egrave;vre de la couleur en question, qui s&rsquo;av&egrave;re finalement &ecirc;tre une princesse m&eacute;tamorphos&eacute;e par un mal&eacute;fice.</p>","descriptionmj":"","niveau":3,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870034,"modifiedTime":1671048281609,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Tripotée","type":"recettecuisine","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.aWfeLfT1kM2cCrNn"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/recette_cuisine_2.webp","effects":[],"_id":"aWfeLfT1kM2cCrNn","system":{"description":"<p>Soupe v&eacute;g&eacute;tarienne comprenant des l&eacute;gumes de chacune des trois sortes. Selon les l&eacute;gumes utilis&eacute;s, la tripot&eacute;e peut avoir de multiples variantes, la plus courante &eacute;tant pois-quaroce-turneps.</p>","descriptionmj":"","niveau":2,"ingredients":"<ul>\n<li>1/2 livre de cosses</li>\n<li>1/2 livre de porte-p&eacute;pins</li>\n<li>1/2 livre de racines</li>\n<li>eau</li>\n<li>5 schouillats de farine de bl&eacute;di&egrave;ze</li>\n<li>3 schouillats de farine de bloute</li>\n<li>4 brins de b&eacute;jaune</li>\n<li>2 brins de muscaline</li>\n<li>2 brins de p&egrave;pre</li>\n</ul>","duree":"40 minutes","sust":6,"exotisme":0,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870035,"modifiedTime":1671048281609,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Tiens, v’là les Groins !","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.dwSY0ImswRHUSuRQ"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_0.webp","effects":[],"_id":"dwSY0ImswRHUSuRQ","system":{"description":"<p>Chanson de marche peu rafin&eacute;e, comme en t&eacute;moigne le refrain :</p>\n<blockquote>\n<p>&laquo; Tiens, v&rsquo;l&agrave; les Groins !</p>\n<p>&Ccedil;a y&rsquo;en a eux qui faire du foin !</p>\n<p>Quand y&rsquo;en a pr&egrave;s, y&rsquo;en a pas loin !</p>\n<p>Tiens, v&rsquo;l&agrave; les Groins ! &raquo;</p>\n</blockquote>","descriptionmj":"","niveau":0,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870035,"modifiedTime":1671048281609,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La volée","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.ehAslJ16qKJDrTqt"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_6.webp","effects":[],"_id":"ehAslJ16qKJDrTqt","system":{"description":"<p>Danse villageoise, la vol&eacute;e est une farandole rapide incluant des sauts et des figures quasi acrobatiques, ainsi que des moments rapproch&eacute;s &agrave; deux (comme la peccadille). Elle est &eacute;videmment r&eacute;serv&eacute;e aux bons danseurs, et particuli&egrave;rement ext&eacute;nuante.</p>","descriptionmj":"","type":"recreative","agilite":true,"apparence":true,"niveau":6,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870035,"modifiedTime":1671048281609,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"jOL4buV3m3nHr8v7","name":"Le doublon","type":"jeu","img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_doublon.webp","effects":[],"folder":null,"sort":0,"flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.jOL4buV3m3nHr8v7"}},"system":{"description":"<p>Jeu de pur hasard consistant &agrave; obtenir un double avec deux d&eacute;s.</p>\n<p>Si plusieurs joueurs y parviennent, le plus haut gagne ; si aucun n&rsquo;y parvient, le coup est nul et les mises restent au pot.</p>\n<p>Pour simuler une partie de doublon, faire simplement tirer des jets de CHANCE &agrave; z&eacute;ro (ajust&eacute;s astrologiquement), mais sans comp&eacute;tence, pas m&ecirc;me Jeu, et comparer les r&eacute;sultats (&eacute;chec, r&eacute;ussite normale, significative, etc.) : le meilleur gagne. &Agrave; &eacute;galit&eacute; de r&eacute;ussites, le coup est nul.</p>","descriptionmj":"","type":"de","base":0,"caraccomp":"Chance","reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870036,"modifiedTime":1671048281609,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Le rossignol d’Ostarlath","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.jUsy5PTDwBgDrRnq"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_8.webp","effects":[],"_id":"jUsy5PTDwBgDrRnq","system":{"description":"<p>Romance o&ugrave; les paroles, peu importantes, sont essentiellement un exercice de vocalises.</p>","descriptionmj":"","niveau":8,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870037,"modifiedTime":1671048281610,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Le roi des ours","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.jUxckTsggDZBgn2W"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_3.webp","effects":[],"_id":"jUxckTsggDZBgn2W","system":{"description":"<p>Sanglante &eacute;pop&eacute;e sur un th&egrave;me identique* : mal&eacute;fice, m&eacute;tamorphose et superbe vengeance finale.</p>\n<p>&nbsp;</p>\n<p><em>*voir \"La ch&egrave;vre rose\"</em></p>","descriptionmj":"","niveau":3,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870037,"modifiedTime":1671048281610,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La route est longue","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.jyPBU95uPhIhsdpa"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_0.webp","effects":[],"_id":"jyPBU95uPhIhsdpa","system":{"description":"<p>Chanson de marche aux couplets r&eacute;p&eacute;titifs.</p>\n<blockquote>\n<p>&laquo; Une lieue sans cheval, &ccedil;a use, &ccedil;a use</p>\n<p>Une lieue sans cheval, &ccedil;a use les sandales !&raquo;</p>\n</blockquote>","descriptionmj":"","niveau":0,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870037,"modifiedTime":1671048281610,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La danse du couteau","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.k9EELSV0DrurUt1e"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_sol_6.webp","effects":[],"_id":"k9EELSV0DrurUt1e","system":{"description":"<p>Plus masculine que f&eacute;minine, cette danse utilise un couteau (dague) comme accessoire.</p>\n<p>Elle est imitative d&rsquo;un combat.</p>","descriptionmj":"","type":"soliste","agilite":false,"apparence":true,"niveau":6,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870037,"modifiedTime":1671048281610,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"L’amour est morte","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.kCU7A8fMczERjizY"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_5.webp","effects":[],"_id":"kCU7A8fMczERjizY","system":{"description":"<p>Romance sentimentale d&rsquo;une tristesse &agrave; faire pleurer les cailloux.</p>","descriptionmj":"","niveau":5,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870037,"modifiedTime":1671048281610,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Amandjara","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.kiIlPL5XANy5OgYn"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_2.webp","effects":[],"_id":"kiIlPL5XANy5OgYn","system":{"description":"<p>S&eacute;r&eacute;nade sur la l&eacute;gendaire cit&eacute; d&rsquo;Amandjara,</p>\n<p>&laquo; Perle du d&eacute;sert bleu, sur qui la lune fait les doux yeux ... &raquo;</p>","descriptionmj":"","niveau":2,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870038,"modifiedTime":1671048281611,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Bloutade","type":"recettecuisine","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.lv6AiGYIjtqHhn7u"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/recette_cuisine_1.webp","effects":[],"_id":"lv6AiGYIjtqHhn7u","system":{"description":"<p>Pur&eacute;e de farine de bloute.</p>\n<p>&nbsp;</p>\n<p><strong>Bloute</strong></p>\n<p>Avec le tomari ou le bl&eacute;di&egrave;ze, la bloute est &agrave; la base de l&rsquo;alimentation dans un grand nombre d&rsquo;endroits. C&rsquo;est un tubercule de forme et de couleur voisins de notre manioc, &agrave; la chair g&eacute;latineuse et fade. Totalement immangeables telles quelles, les bloutes sont mises &agrave; s&eacute;cher sur des claies, puis broy&eacute;es en farine. Ce n&rsquo;est qu&rsquo;ainsi qu&rsquo;on peut les consommer. La farine de bloute entre dans la confection des brouets et des rago&ucirc;ts, notamment de la bloutade. Ainsi cuite, elle ressemble &agrave; du tapioca.</p>","descriptionmj":"","niveau":1,"ingredients":"<ul>\n<li>1 livre de farine de bloute*</li>\n<li>1/2 livre de viande de porc ou de padongre coup&eacute;e en petits morceaux</li>\n<li>2 doigts d&rsquo;huile</li>\n<li>eau,</li>\n<li>sel</li>\n<li>8 brins d&rsquo;aromates (b&eacute;jaune, luciane)</li>\n</ul>","duree":"30 minutes","sust":8,"exotisme":0,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870038,"modifiedTime":1671048281611,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Le tisonnier","type":"jeu","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.mRzHzrubRkyqHUTC"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_tisonnier.webp","effects":[],"_id":"mRzHzrubRkyqHUTC","system":{"description":"<p>On commence par se mettre d&rsquo;accord sur la valeur hi&eacute;rarchique des symboles et des combinaisons possibles, puis le jeu consiste, &agrave; chaque distribution de cartes, &agrave; miser selon un syst&egrave;me de surench&egrave;res jusqu&rsquo;&agrave; ce que les cartes soient d&eacute;voil&eacute;es.</p>\n<p>La combinaison la plus forte emporte alors les mises.</p>\n<p>Le jeu demande de la chance, sans laquelle il est difficile de gagner &agrave; long terme, mais tout autant de l&rsquo;empathie pour bluffer lors des surench&egrave;res.</p>\n<p>Pour simuler une partie, jouer un jet de CHANCE &agrave; z&eacute;ro (ajust&eacute; astrologiquement), suivi d&rsquo;un jet d&rsquo;EMPATHIE/Jeu &agrave; z&eacute;ro, et additionner les points de t&acirc;che obtenus par les deux jets. Le vainqueur est celui qui en totalise le plus.</p>","descriptionmj":"","type":"carte","base":-4,"caraccomp":"Chance / Empathie","reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870038,"modifiedTime":1671048281611,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Plume de zyglute","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.nCFFhbL54WXU0FFi"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_4.webp","effects":[],"_id":"nCFFhbL54WXU0FFi","system":{"description":"<p>S&eacute;r&eacute;nade.</p>\n<p>Belle musique, mais paroles d&rsquo;une rare stupidit&eacute; :</p>\n<blockquote>\n<p>&laquo; Coin-coin, glou-glou, c&rsquo;est qui ? c&rsquo;est vous ? &raquo;</p>\n</blockquote>","descriptionmj":"","niveau":4,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870038,"modifiedTime":1671048281611,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"L’auberge noire","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.srNKj5s0TOw7VDQ4"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_5.webp","effects":[],"_id":"srNKj5s0TOw7VDQ4","system":{"description":"<p>Complainte macabre sur un aubergiste qui assassine ses clients avec la r&acirc;pe &agrave; fromage.</p>","descriptionmj":"","niveau":5,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870038,"modifiedTime":1671048281611,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Ma chope est vide !","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.uGVOeSq2ZKMG8VjU"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_0.webp","effects":[],"_id":"uGVOeSq2ZKMG8VjU","system":{"description":"<p>Chanson &agrave; boire peu raffin&eacute;e.</p>","descriptionmj":"","niveau":0,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870039,"modifiedTime":1671048281611,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La callipyge","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.uf7a9D5RYw7gOi36"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_sol_2.webp","effects":[],"_id":"uf7a9D5RYw7gOi36","system":{"description":"<p>Comme la serpentine, avec des effets plus marqu&eacute;s, essentiellement bas&eacute;e sur les mouvements du bassin. La callipyge n&rsquo;est g&eacute;n&eacute;ralement dans&eacute;e que par les femmes.</p>","descriptionmj":"","type":"soliste","agilite":false,"apparence":true,"niveau":2,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870039,"modifiedTime":1671048281612,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La gambade","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.uxdljYU7TlC2F6oA"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_1.webp","effects":[],"_id":"uxdljYU7TlC2F6oA","system":{"description":"<p>Gigue endiabl&eacute;e, proche du bourrichon, mais avec des figures un peu moins sommaires.</p>","descriptionmj":"","type":"recreative","agilite":true,"apparence":true,"niveau":1,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870039,"modifiedTime":1671048281612,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Trompe de padongre à la mentharde","type":"recettecuisine","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.uzSivEs6SFEGVoI0"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/recette_cuisine_4.webp","effects":[],"_id":"uzSivEs6SFEGVoI0","system":{"description":"<p>Enduite de miel, de beurre et entour&eacute;e de feuilles de mentharde fra&icirc;ches, la trompe de padongre doit &ecirc;tre cuite au four et arros&eacute;e r&eacute;guli&egrave;rement de lait. Toute la difficult&eacute; r&eacute;side dans la cuisson.</p>","descriptionmj":"","niveau":4,"ingredients":"<ul>\n<li>1 belle trompe de padongre (10 sust)</li>\n<li>25 schouillats de miel</li>\n<li>1 livre de beurre</li>\n<li>1 pinte de lait</li>\n<li>20 brins de mentharde</li>\n<li>sel</li>\n</ul>","duree":"90 minutes","sust":12,"exotisme":0,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870039,"modifiedTime":1671048281613,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La triplette","type":"jeu","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.vYPjOjd3vSAvjL76"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_doublon.webp","effects":[],"_id":"vYPjOjd3vSAvjL76","system":{"description":"<p>Autre jeu de hasard, la triplette est un jeu de d&eacute;s de combinaisons se jouant avec trois d&eacute;s (sorte de 421).</p>\n<p>Pour simuler une partie de triplette, d&eacute;terminer l&rsquo;ordre dans lequel jouent les participants. Le premier &agrave; jouer peut tenter de un &agrave; trois jets de CHANCE &agrave; z&eacute;ro (ajust&eacute;s astrologiquement comme pour le doublon), et additionner les points de t&acirc;che obtenus.</p>\n<p>Attention aux &eacute;checs qui donnent des points n&eacute;gatifs ! Il peut &ecirc;tre plus judicieux de se contenter d&rsquo;un seul jet bien r&eacute;ussi.</p>\n<p>Les joueurs suivants, en effet, pourront &agrave; leur tour tenter le m&ecirc;me nombre de jets de CHANCE ou moins, mais pas davantage. Le plus grand nombre de points gagne finalement.</p>","descriptionmj":"","type":"de","base":0,"caraccomp":"Chance","reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870040,"modifiedTime":1671048281613,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Le voyageur","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.vlqX5BC9recz2kM2"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_1.webp","effects":[],"_id":"vlqX5BC9recz2kM2","system":{"description":"<p>Ballade sur les tribulations d&rsquo;un voyageur.</p>\n<p>Interminable, cette chanson poss&egrave;de plus de cent couplets.</p>\n<p>&nbsp;</p>\n<p><em>D&eacute;terminer en tirant 1d100 le nombre de couplets connus.</em></p>","descriptionmj":"","niveau":1,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870040,"modifiedTime":1671048281613,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La pétasse","type":"jeu","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.vo8GoXIBNWp1GY12"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/jeux_petasse.webp","effects":[],"_id":"vo8GoXIBNWp1GY12","system":{"description":"<p>Jeu d&rsquo;adresse combinant boules et quilles.</p>\n<p>Chaque joueur dispose de plusieurs quilles, appel&eacute;es p&eacute;tasses, et de boules de bois, appel&eacute;es tronchets. Le jeu conna&icirc;t de nombreuses variantes, mais le principe g&eacute;n&eacute;ral est le m&ecirc;me : culbuter les p&eacute;tasses des adversaires en &eacute;vitant de se faire troncher les siennes.</p>\n<p>Pour simuler une partie, faire tirer &agrave; chaque participant 5 jets de Lancer/Jeu &agrave; z&eacute;ro et additionner les points de t&acirc;che obtenus. Le plus grand nombre gagne.</p>","descriptionmj":"","type":"adressehasard","base":-6,"caraccomp":"Lancer","reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870040,"modifiedTime":1671048281613,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"La sarabande","type":"danse","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.wf1jpIZmrB5LfK93"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/danse_4.webp","effects":[],"_id":"wf1jpIZmrB5LfK93","system":{"description":"<p>Peu pratiqu&eacute;e dans les villages, la sarabande est une danse de cour, lente et solennelle, alternant groupe et couples, comme la turlutaine dont elle est une version &laquo;s&eacute;rieuse&raquo;.</p>\n<p>Les changements de partenaire s&rsquo;accompagnent de profondes r&eacute;v&eacute;rences.</p>","descriptionmj":"","type":"recreative","agilite":false,"apparence":true,"niveau":4,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870042,"modifiedTime":1671048281613,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Le retour du baron gris","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.xjITZoom3Azu9NQa"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_2.webp","effects":[],"_id":"xjITZoom3Azu9NQa","system":{"description":"<p>&Eacute;pop&eacute;e pleine de cavalcades, de trahisons, de batailles et de cervelles &eacute;clat&eacute;es.</p>","descriptionmj":"","niveau":2,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870042,"modifiedTime":1671048281614,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"L’heure de la Lyre","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.yLcvnrbqIKS4ezj7"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_1.webp","effects":[],"_id":"yLcvnrbqIKS4ezj7","system":{"description":"<p>Berceuse sur le th&egrave;me de la nuit qui descend.</p>","descriptionmj":"","niveau":1,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870043,"modifiedTime":1671048281614,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Le cavalier de sombre neige","type":"chant","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.arts-et-divertissements.zRQ5WnPI483CKm9Q"}},"img":"systems/foundryvtt-reve-de-dragon/icons/arts/chant_6.webp","effects":[],"_id":"zRQ5WnPI483CKm9Q","system":{"description":"<p>&Eacute;pop&eacute;e pleine de suspense et de terreur, o&ugrave; le soleil est rouge, la lune violette et la neige noire.</p>","descriptionmj":"","niveau":6,"reference":""},"ownership":{"default":0,"rYShh2P1DNavdoBD":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047870043,"modifiedTime":1671048281614,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}

packs/arts-et-divertissements/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000044

packs/arts-et-divertissements/LOG

@@ -1,7 +0,0 @@
-2023/05/29-08:40:34.473425 7fca057fa6c0 Recovering log #42
-2023/05/29-08:40:34.489629 7fca057fa6c0 Delete type=3 #40
-2023/05/29-08:40:34.489672 7fca057fa6c0 Delete type=0 #42
-2023/05/29-08:50:04.169228 7fca04ff96c0 Level-0 table #47: started
-2023/05/29-08:50:04.169266 7fca04ff96c0 Level-0 table #47: 0 bytes OK
-2023/05/29-08:50:04.176244 7fca04ff96c0 Delete type=0 #45
-2023/05/29-08:50:04.189729 7fca04ff96c0 Manual compaction at level-0 from '!items!240HPtZsgZQERFMF' @ 72057594037927935 : 1 .. '!items!zRQ5WnPI483CKm9Q' @ 0 : 0; will stop at (end)

packs/arts-et-divertissements/LOG.old

@@ -1,7 +0,0 @@
-2023/05/29-08:00:37.527199 7fca057fa6c0 Recovering log #38
-2023/05/29-08:00:37.537455 7fca057fa6c0 Delete type=3 #36
-2023/05/29-08:00:37.537507 7fca057fa6c0 Delete type=0 #38
-2023/05/29-08:38:02.086958 7fca04ff96c0 Level-0 table #43: started
-2023/05/29-08:38:02.086980 7fca04ff96c0 Level-0 table #43: 0 bytes OK
-2023/05/29-08:38:02.093744 7fca04ff96c0 Delete type=0 #41
-2023/05/29-08:38:02.107101 7fca04ff96c0 Manual compaction at level-0 from '!items!240HPtZsgZQERFMF' @ 72057594037927935 : 1 .. '!items!zRQ5WnPI483CKm9Q' @ 0 : 0; will stop at (end)

packs/competences-creatures.db

@@ -0,0 +1,29 @@
+{"_id":"0zRL8bOpCXNQnIR4","name":"Ruade","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.0zRL8bOpCXNQnIR4"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-pietinement.webp","effects":[],"system":{"description":null,"descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":4,"isparade":false},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702692,"modifiedTime":1671048288982,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"4GmpkphbsmQjvVVK","name":"Escalade","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.4GmpkphbsmQjvVVK"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_escalade.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":false,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702692,"modifiedTime":1671048288983,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"6DK46pyO0hzEuuUg","name":"Morsure","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.6DK46pyO0hzEuuUg"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-morsure.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"generale","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":1,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702692,"modifiedTime":1671048288983,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Possession","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.c0I93Q53i4ZmxpyT"}},"img":"systems/foundryvtt-reve-de-dragon/icons/entites/possession.webp","effects":[],"system":{"description":"<p>L'entit&eacute; tente de prendre possession du corps de sa victime.</p>","descriptionmj":"","categorie_parade":"","niveau":2,"default_diffLibre":0,"categorie":"draconic","carac_value":14,"iscombat":true,"isnaturelle":true,"ispossession":true,"dommages":0,"isparade":false},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624976822,"modifiedTime":1671048288983,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"_id":"9u16zxXRurCtxuOX","folder":null,"sort":0,"ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3}}
+{"_id":"BjqRrGtHtTzuNpZB","name":"Griffes et Crocs","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.BjqRrGtHtTzuNpZB"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-griffes.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":1,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702692,"modifiedTime":1671048288983,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"CYpxxf1uTa78NWR9","name":"Esquive","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.CYpxxf1uTa78NWR9"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_esquive.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":false,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702692,"modifiedTime":1671048288983,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"JTuBQCPdumw3DfxH","name":"Crête","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.JTuBQCPdumw3DfxH"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-crete.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":3,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702693,"modifiedTime":1671048288983,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"Kt7WlB5Ui97X211z","name":"Vol","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.Kt7WlB5Ui97X211z"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-vol.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":false,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702693,"modifiedTime":1671048288983,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"LWQHz5ymNBzh6ZEr","name":"Cornes","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.LWQHz5ymNBzh6ZEr"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-corne.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":2,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702693,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"NctG7suzvGE7ZZzj","name":"Bras-bouches","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.NctG7suzvGE7ZZzj"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-brasbouche.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"epees-lourdes","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":2,"isparade":true},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702693,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"OzHBowOMADRwcVXR","name":"Pierre Tenue","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.OzHBowOMADRwcVXR"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-pierretenue.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":false,"ispossession":false,"dommages":2,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702693,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"PCwbR6lghjydTj93","name":"Grande morsure","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.PCwbR6lghjydTj93"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-morsure.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":2,"isparade":false},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702693,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"PrVuVpwuYaZtwRUi","name":"Piétinement","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.PrVuVpwuYaZtwRUi"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-pietinement.webp","effects":[],"system":{"description":null,"descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":4,"isparade":false},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702693,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"RAnasKnoA3OQgwfv","name":"Pinces","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.RAnasKnoA3OQgwfv"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-pinces.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"epees-lourdes","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":3,"isparade":true},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702694,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"XgfRxSj8Ty1d3JFM","name":"Mandibules","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.XgfRxSj8Ty1d3JFM"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-mandibules.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"generale","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":2,"isparade":false,"carac-value":null},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702694,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"Zpl2Bi451vB3r91W","name":"Coup de pied","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.Zpl2Bi451vB3r91W"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-coup_de_pied.webp","effects":[],"system":{"description":null,"descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":3,"isparade":false},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702694,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Possession","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.c0I93Q53i4ZmxpyT"}},"img":"systems/foundryvtt-reve-de-dragon/icons/entites/possession.webp","effects":[],"system":{"categorie_parade":"","niveau":2,"default_diffLibre":0,"carac_value":14,"iscombat":true,"isparade":false,"ispossession":true,"dommages":0,"description":"<p>L'entit&eacute; tente de prendre possession du corps de sa victime.</p>","descriptionmj":"","categorie":"draconic"},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.0.16","coreVersion":"10.285","createdTime":1663624976822,"modifiedTime":1663625011162,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"_id":"duVgxI3Cdko0KzAj","folder":null,"sort":0,"ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3}}
+{"_id":"efl1HdDSKpBfImQ1","name":"Pierre Lancée","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.efl1HdDSKpBfImQ1"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-pierrelancee.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"lancer","carac_value":0,"iscombat":true,"isnaturelle":false,"ispossession":false,"dommages":1,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702694,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"h9ASt4vrvEgxfj7j","name":"Tronçonneuse","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.h9ASt4vrvEgxfj7j"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-tronconneuse.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":10,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702694,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"jhua9kkCs55OV7Yl","name":"Grandes griffes","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.jhua9kkCs55OV7Yl"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-griffes.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"sans-armes","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":2,"isparade":true},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702694,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"lzEdMrKXbOYrWG5S","name":"Vigilance","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.lzEdMrKXbOYrWG5S"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_vigilance.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":false,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702694,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"ndNshntOYb1JFNqi","name":"Serres","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.ndNshntOYb1JFNqi"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-serres.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":2,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702694,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"os88Rsp7mBkahqmh","name":"Bec","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.os88Rsp7mBkahqmh"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-beak.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702695,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"qilRzXpVaGceNmQp","name":"Dague","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.qilRzXpVaGceNmQp"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_dague.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"dagues","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":false,"ispossession":false,"dommages":1,"isparade":true},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702695,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"qrd9AoZzFgyzFBxz","name":"Griffes","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.qrd9AoZzFgyzFBxz"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-griffes.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"sans-armes","niveau":0,"default_diffLibre":0,"categorie":"melee","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":1,"isparade":true},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702695,"modifiedTime":1671048288984,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"sUdXhpuVVOAlcVpo","name":"Pickpocket","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.sUdXhpuVVOAlcVpo"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_pickpocket.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":false,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702695,"modifiedTime":1671048288985,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"shsUV8UpU18c0RJK","name":"Course","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.shsUV8UpU18c0RJK"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_course.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":false,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702695,"modifiedTime":1671048288985,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"yBUVTjTXYfwvzusb","name":"Saut","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.yBUVTjTXYfwvzusb"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_saut.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"generale","carac_value":0,"iscombat":false,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":false},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702695,"modifiedTime":1671048288985,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"yDHZfK4RmwQW4YaW","name":"Discrétion","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.yDHZfK4RmwQW4YaW"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_discretion.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":false,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624702695,"modifiedTime":1671048288985,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}

packs/competences-creatures/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000044

packs/competences-creatures/LOG

@@ -1,7 +0,0 @@
-2023/05/29-08:40:34.473425 7fca06ffd6c0 Recovering log #42
-2023/05/29-08:40:34.489628 7fca06ffd6c0 Delete type=3 #40
-2023/05/29-08:40:34.489672 7fca06ffd6c0 Delete type=0 #42
-2023/05/29-08:50:04.162334 7fca04ff96c0 Level-0 table #47: started
-2023/05/29-08:50:04.162374 7fca04ff96c0 Level-0 table #47: 0 bytes OK
-2023/05/29-08:50:04.169093 7fca04ff96c0 Delete type=0 #45
-2023/05/29-08:50:04.189714 7fca04ff96c0 Manual compaction at level-0 from '!items!0zRL8bOpCXNQnIR4' @ 72057594037927935 : 1 .. '!items!yDHZfK4RmwQW4YaW' @ 0 : 0; will stop at (end)

packs/competences-creatures/LOG.old

@@ -1,7 +0,0 @@
-2023/05/29-08:00:37.527196 7fca05ffb6c0 Recovering log #38
-2023/05/29-08:00:37.537511 7fca05ffb6c0 Delete type=3 #36
-2023/05/29-08:00:37.537612 7fca05ffb6c0 Delete type=0 #38
-2023/05/29-08:38:02.093873 7fca04ff96c0 Level-0 table #43: started
-2023/05/29-08:38:02.093898 7fca04ff96c0 Level-0 table #43: 0 bytes OK
-2023/05/29-08:38:02.100659 7fca04ff96c0 Delete type=0 #41
-2023/05/29-08:38:02.114114 7fca04ff96c0 Manual compaction at level-0 from '!items!0zRL8bOpCXNQnIR4' @ 72057594037927935 : 1 .. '!items!yDHZfK4RmwQW4YaW' @ 0 : 0; will stop at (end)

packs/competences-entites.db

@@ -0,0 +1,15 @@
+{"_id":"0Ms9iKxqigNNpZEx","name":"Esquive","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.0Ms9iKxqigNNpZEx"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_esquive.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":false,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895714,"modifiedTime":1671048307066,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"18wcei5hlEInsBFO","name":"Attaque","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.18wcei5hlEInsBFO"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-griffes.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":0,"carac-value":null,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895715,"modifiedTime":1671048307066,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"3Crwg8cx2JOb697T","name":"Parade","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.3Crwg8cx2JOb697T"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_saut.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":false,"isnaturelle":true,"ispossession":false,"dommages":0,"carac-value":null,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895715,"modifiedTime":1671048307066,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"6eWCVDYLXXO1Z48D","name":"Grandes griffes","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.BjqRrGtHtTzuNpZB"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-griffes.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"sans-armes","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":2,"isparade":false},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895715,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"9Y83OsQgeyR5oCdH","name":"Griffes","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.BjqRrGtHtTzuNpZB"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-griffes.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"sans-armes","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":1,"carac-value":null,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895715,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"D9cBJ3EJPYLnABiJ","name":"Tentacules","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.D9cBJ3EJPYLnABiJ"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-tentacule.webp","effects":[],"system":{"description":"<p>Attaque ou parade avec un tentacule.</p>","descriptionmj":"","categorie_parade":"boucliers","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":2,"isparade":true},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895716,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"QGULMUoC9JXFze0r","name":"Bouclier Lourd","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.QGULMUoC9JXFze0r"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_bouclier.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"boucliers","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":0,"carac-value":null,"isparade":true},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895716,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"WsYnwR8GcOxfuCI0","name":"Bras-Galet","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.WsYnwR8GcOxfuCI0"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_course.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":1,"carac-value":null,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895716,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"c0I93Q53i4ZmxpyT","name":"Corps à Corps","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.c0I93Q53i4ZmxpyT"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_corps_a_corps.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"sans-armes","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":true},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895716,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"d5SZ09sFaG3cL2Rg","name":"Bec","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.os88Rsp7mBkahqmh"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-beak.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":0,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895716,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"db8E8HwROw1ZcwRR","name":"Crocs","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-creatures.NctG7suzvGE7ZZzj"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-brasbouche.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":1,"carac-value":null,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895716,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"gPOQd9NI7AFH0whX","name":"Epée Bâtarde","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-humanoides.YTKld5ggDsHqwYoR"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_epee_1_main.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"epees-lourdes","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":4,"carac-value":null,"isparade":true},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895717,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"j1xHCzfIeYKgXxoH","name":"Morsure","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.j1xHCzfIeYKgXxoH"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-morsure.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":1,"isparade":false},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895717,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"_id":"lDZ3qUPKN35ob5TH","name":"Grande morsure","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.lDZ3qUPKN35ob5TH"}},"img":"systems/foundryvtt-reve-de-dragon/icons/compcreature-morsure.webp","effects":[],"system":{"description":"","descriptionmj":"","categorie_parade":"","niveau":0,"default_diffLibre":0,"categorie":"","carac_value":0,"iscombat":true,"isnaturelle":true,"ispossession":false,"dommages":2,"isparade":false},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047895717,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Possession","type":"competencecreature","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences-entites.c0I93Q53i4ZmxpyT"}},"img":"systems/foundryvtt-reve-de-dragon/icons/entites/possession.webp","effects":[],"system":{"description":"<p>L'entit&eacute; tente de prendre possession du corps de sa victime.</p>","descriptionmj":"","categorie_parade":"","niveau":2,"default_diffLibre":-4,"categorie":"melee","carac_value":14,"iscombat":true,"isnaturelle":true,"ispossession":true,"dommages":0,"isparade":false},"ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1663624976822,"modifiedTime":1671048307067,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"wDHR5UHWq568lfGa"}

packs/competences-entites/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000044

packs/competences-entites/LOG

@@ -1,7 +0,0 @@
-2023/05/29-08:40:34.492648 7fca057fa6c0 Recovering log #42
-2023/05/29-08:40:34.503069 7fca057fa6c0 Delete type=3 #40
-2023/05/29-08:40:34.503121 7fca057fa6c0 Delete type=0 #42
-2023/05/29-08:50:04.176372 7fca04ff96c0 Level-0 table #47: started
-2023/05/29-08:50:04.176410 7fca04ff96c0 Level-0 table #47: 0 bytes OK
-2023/05/29-08:50:04.182550 7fca04ff96c0 Delete type=0 #45
-2023/05/29-08:50:04.189740 7fca04ff96c0 Manual compaction at level-0 from '!items!0Ms9iKxqigNNpZEx' @ 72057594037927935 : 1 .. '!items!wDHR5UHWq568lfGa' @ 0 : 0; will stop at (end)

packs/competences-entites/LOG.old

@@ -1,7 +0,0 @@
-2023/05/29-08:00:37.541075 7fca06ffd6c0 Recovering log #38
-2023/05/29-08:00:37.554609 7fca06ffd6c0 Delete type=3 #36
-2023/05/29-08:00:37.554667 7fca06ffd6c0 Delete type=0 #38
-2023/05/29-08:38:02.100767 7fca04ff96c0 Level-0 table #43: started
-2023/05/29-08:38:02.100800 7fca04ff96c0 Level-0 table #43: 0 bytes OK
-2023/05/29-08:38:02.107003 7fca04ff96c0 Delete type=0 #41
-2023/05/29-08:38:02.114130 7fca04ff96c0 Manual compaction at level-0 from '!items!0Ms9iKxqigNNpZEx' @ 72057594037927935 : 1 .. '!items!wDHR5UHWq568lfGa' @ 0 : 0; will stop at (end)

packs/competences.db

@@ -0,0 +1,67 @@
+{"name":"Comédie","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.2JLK5e97WbTM5WxX"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_comedie.webp","_id":"2JLK5e97WbTM5WxX","system":{"description":"<p>L’art de paraître sur une scène : jouer un rôle, déclamer des vers, mimer, conter. Peut aussi servir à simuler, mystifier.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-8,"default_diffLibre":0,"base":-8,"categorie":"particuliere","xp":0,"defaut_carac":"apparence","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890257,"modifiedTime":1671048297532,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Jeu","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.3VSMRwMYpOi83wgE"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_jeu.webp","_id":"3VSMRwMYpOi83wgE","system":{"description":"<p>Jeux de tripot, manipuler les dés. Connaître les jeux et les meilleures stratégies, déceler un tricheur et tricher soi-même.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-11,"default_diffLibre":0,"base":-11,"categorie":"specialisee","xp":0,"defaut_carac":"intellect","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890257,"modifiedTime":1671048297533,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Cuisine","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.3qRzl3nhLZNsoDsI"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_cuisine.webp","_id":"3qRzl3nhLZNsoDsI","system":{"description":"<p>Identifier les saveurs culinaires, les épices et les aromates. Exécuter, inventer une recette. Faire griller un gibier sur un feu de&nbsp;camp n’est généralement pas de la cuisine,&nbsp;mais de la simple survie.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-4,"default_diffLibre":0,"base":-4,"categorie":"generale","xp":0,"defaut_carac":"odoratgout","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890258,"modifiedTime":1671048297533,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Survie en Sous-Sol","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.6pXxEdeo7xcDvgx0"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_survie_sous_sol.webp","_id":"6pXxEdeo7xcDvgx0","system":{"description":"<p>Par exemple pister un gibier en forêt demande l’usage de Survie en forêt, trouver une grotte pour s’abriter en montagne demande Survie en montagne. Survie en extérieur tient lieu de survie spécifique pour les plaines et collines non boisées.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-8,"default_diffLibre":0,"base":-8,"categorie":"particuliere","xp":0,"defaut_carac":"intellect","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890258,"modifiedTime":1671048297533,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Corps à corps","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.8Uj41cL5Qlxxy675"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_corps_a_corps.webp","_id":"8Uj41cL5Qlxxy675","system":{"description":"<p>Groupées en une seule jusqu’au niveau zéro, ces compétences sont les principes de base du combat de mêlée. Corps à&nbsp;corps permet de se battre sans armes ; Es-quive permet d’esquiver toutes les sortes&nbsp;de coup ; Dague de mêlée permet l’utilisation de la dague au contact.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-6,"default_diffLibre":0,"base":-6,"categorie":"melee","xp":0,"defaut_carac":"melee","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890258,"modifiedTime":1671048297533,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Discrétion","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.94P55yZfeipCGbsr"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_discretion.webp","_id":"94P55yZfeipCGbsr","system":{"description":"<p>Se déplacer en silence, sans se faire remarquer, passer inaperçu, se fondre dans</p>\n<p>l’anonymat, se cacher.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-4,"default_diffLibre":0,"base":-4,"categorie":"generale","xp":0,"defaut_carac":"agilite","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890258,"modifiedTime":1671048297533,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Saut","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.9ICvksiNG6Bhm8CE"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_saut.webp","_id":"9ICvksiNG6Bhm8CE","system":{"description":"<p>Sauter par-dessus un obstacle ou sauter en contrebas ; rattraper une chute en la transformant en saut.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-4,"default_diffLibre":0,"base":-4,"categorie":"generale","xp":0,"defaut_carac":"agilite","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890259,"modifiedTime":1671048297533,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Navigation","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.AXeWswf2Dth9ysvy"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_navigation.webp","_id":"AXeWswf2Dth9ysvy","system":{"description":"<p>Connaissance des manœuvres à accomplir sur un voilier, connaissance de la mer, de ses courants (voir Navigation, p325).</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-11,"default_diffLibre":0,"base":-11,"categorie":"specialisee","xp":0,"defaut_carac":"vue","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890259,"modifiedTime":1671048297533,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Séduction","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.AbM6lJ7DI2UAWLxj"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_seduction.webp","_id":"AbM6lJ7DI2UAWLxj","system":{"description":"<p>L’art d’être galant, de paraître attirant. Permet les conquêtes amoureuses.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-4,"default_diffLibre":0,"base":-4,"categorie":"generale","xp":0,"defaut_carac":"apparence","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890260,"modifiedTime":1671048297533,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Masse à 2 mains","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.BMAloiSbDKOu3b4C"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_masse_2_mains.webp","_id":"BMAloiSbDKOu3b4C","system":{"description":"<p>Ces compétences permettent l’utilisation des masses, gourdins, bâtons, pour attaquer, voire parer.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-6,"default_diffLibre":0,"base":-6,"categorie":"melee","xp":0,"defaut_carac":"melee","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890260,"modifiedTime":1671048297533,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Chirurgie","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.BlG2YPATIbnY3m9P"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_chirurgie.webp","_id":"BlG2YPATIbnY3m9P","system":{"description":"<p>L’art de soigner les blessures, panser, recoudre ; savoir se servir d’un rasoir. Chirurgie&nbsp;est utilisée pour accomplir premiers soins et soins complets sur toutes les blessures, et&nbsp;par extension, pour tous les actes de secourisme et de réanimation.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-11,"default_diffLibre":0,"base":-11,"categorie":"specialisee","xp":0,"defaut_carac":"dexterite","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890260,"modifiedTime":1671048297533,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Survie en Montagne","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.BzqBOeqS6HvJhqey"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_survie_montagne.webp","_id":"BzqBOeqS6HvJhqey","system":{"description":"<p>Par exemple pister un gibier en forêt demande l’usage de Survie en forêt, trouver une grotte pour s’abriter en montagne demande Survie en montagne. Survie en extérieur tient lieu de survie spécifique pour les plaines et collines non boisées.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-8,"default_diffLibre":0,"base":-8,"categorie":"particuliere","xp":0,"defaut_carac":"intellect","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890260,"modifiedTime":1671048297533,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Métallurgie","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.CHyk96ypxMrg8VXh"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_metallurgie.webp","_id":"CHyk96ypxMrg8VXh","system":{"description":"<p>C’est au sens large le travail du métal, et principalement du fer. Battre le fer, forger, tremper, limer, poncer, riveter. Évaluer la qualité, la solidité, d’un objet de fer, une arme par exemple.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-11,"default_diffLibre":0,"base":-11,"categorie":"specialisee","xp":0,"defaut_carac":"force","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890260,"modifiedTime":1671048297533,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Equitation","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.F5iQNrZSeJsfyTnV"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_equitation.webp","_id":"F5iQNrZSeJsfyTnV","system":{"description":"<p>Monter à cheval, et, d’une manière générale, connaissance des chevaux. Peut s’appliquer aux autres montures de Rêve de&nbsp;Dragon : aligates, zyglutes, etc.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-8,"default_diffLibre":0,"base":-8,"categorie":"particuliere","xp":0,"defaut_carac":"agilite","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890260,"modifiedTime":1671048297534,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Hache à 2 mains","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.F97wHYDsQ5UyvJnb"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_hache_a_2_mains.webp","_id":"F97wHYDsQ5UyvJnb","system":{"description":"<p>Ces deux compétences permettent l’utilisation des hachettes, cognées et haches de bataille, pour attaquer.</p>\n<p>&nbsp;</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-6,"default_diffLibre":0,"base":-6,"categorie":"melee","xp":0,"defaut_carac":"melee","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890260,"modifiedTime":1671048297534,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Charpenterie","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.FqLWG6xjISKMLPiX"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_charpenterie.webp","_id":"FqLWG6xjISKMLPiX","system":{"description":"<p>C’est au sens large le travail du bois, charpenterie, menuiserie, ébénisterie. Évaluer&nbsp;la qualité, solidité, d’une structure de bois.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-8,"default_diffLibre":0,"base":-8,"categorie":"particuliere","xp":0,"defaut_carac":"dexterite","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890260,"modifiedTime":1671048297534,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Astrologie","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.GIIQm22Q4bBsmxpE"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_astrologie.webp","_id":"GIIQm22Q4bBsmxpE","system":{"description":"<p>Connaissance des étoiles et de leur signification symbolique. Calculer les nombres astraux gouvernant la chance de chaque&nbsp;individu. S’orienter aux étoiles (voir Astrologie, p155).</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-11,"default_diffLibre":0,"base":-11,"categorie":"connaissance","xp":0,"defaut_carac":"vue","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890260,"modifiedTime":1671048297534,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Course","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.Jz4AZdDlSjsyoUsm"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_course.webp","_id":"Jz4AZdDlSjsyoUsm","system":{"description":"<p>Sprinter le plus vite possible, ou courir sur de longues distances en m&eacute;nageant son souffle.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-4,"default_diffLibre":0,"base":-4,"categorie":"generale","xp":0,"defaut_carac":"agilite","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890261,"modifiedTime":1671048297534,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Chant","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.LE4nA119la5cd0bC"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_chant.webp","_id":"LE4nA119la5cd0bC","system":{"description":"<p>Savoir chanter juste, se souvenir de mélodies, improviser.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-4,"default_diffLibre":0,"base":-4,"categorie":"generale","xp":0,"defaut_carac":"ouie","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890261,"modifiedTime":1671048297534,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Danse","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.LhP3Y0qCBHNp2atl"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_danse.webp","_id":"LhP3Y0qCBHNp2atl","system":{"description":"<p>Être capable de danser en mesure, de danser harmonieusement avec une personne</p>\n<p>ou un groupe, de charmer un public par&nbsp;une exhibition.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-4,"default_diffLibre":0,"base":-4,"categorie":"generale","xp":0,"defaut_carac":"agilite","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890261,"modifiedTime":1671048297534,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Epée à 2 mains","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.MLIEbxSJHkY1m3No"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_epee_2_mains.webp","_id":"MLIEbxSJHkY1m3No","system":{"description":"<p>Ces compétences permettent l’utilisation des sept types d’épées de Rêve de Dragon pour attaquer ou parer.</p>\n<p>&nbsp;</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-6,"default_diffLibre":0,"base":-6,"categorie":"melee","xp":0,"defaut_carac":"melee","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890261,"modifiedTime":1671048297534,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Dessin","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.OVcZE4kfiPYEOzgm"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_dessin.webp","_id":"OVcZE4kfiPYEOzgm","system":{"description":"<p>Avoir le sens des proportions. Savoir dessiner, faire le portrait de quelqu’un, mais</p>\n<p>également savoir faire un schéma, une carte, un plan, aux proportions exactes.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-4,"default_diffLibre":0,"base":-4,"categorie":"generale","xp":0,"defaut_carac":"tir","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890261,"modifiedTime":1671048297534,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Orfèvrerie","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.PMOjO2CdedH1UTyi"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_orfevrerie.webp","_id":"PMOjO2CdedH1UTyi","system":{"description":"<p>Travail et connaissance des métaux précieux : or, argent, cuivre, étain, et par extension des pierres et perles précieuses.&nbsp;Évaluer la taille et la pureté d’une gemme,&nbsp;le prix d’un bijou.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-11,"default_diffLibre":0,"base":-11,"categorie":"specialisee","xp":0,"defaut_carac":"dexterite","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890261,"modifiedTime":1671048297535,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Serrurerie","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.PMnsXDyeB8w8ZG2k"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_serrurerie.webp","_id":"PMnsXDyeB8w8ZG2k","system":{"description":"<p>Compréhension des mécaniques et mécanismes, et plus particulièrement des serrures. Comprendre un mécanisme, le faire fonctionner, le réparer, le désarmer, le crocheter.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-11,"default_diffLibre":0,"base":-11,"categorie":"specialisee","xp":0,"defaut_carac":"dexterite","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890261,"modifiedTime":1671048297535,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Survie en Forêt","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.PbvubzCxnOSnWLpG"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_survie_foret.webp","_id":"PbvubzCxnOSnWLpG","system":{"description":"<p>Par exemple pister un gibier en forêt demande l’usage de Survie en forêt, trouver une grotte pour s’abriter en montagne demande Survie en montagne. Survie en extérieur tient lieu de survie spécifique pour les plaines et collines non boisées.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-8,"default_diffLibre":0,"base":-8,"categorie":"particuliere","xp":0,"defaut_carac":"intellect","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890261,"modifiedTime":1671048297535,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Botanique","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.PmwXYvmutlyQEonB"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_botanique.webp","_id":"PmwXYvmutlyQEonB","system":{"description":"<p>Identification des espèces végétales et de leurs propriétés. Permet de savoir si une plante connue pousse dans un milieu donné. Recherche de cette plante.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-11,"default_diffLibre":0,"base":-11,"categorie":"connaissance","xp":0,"defaut_carac":"vue","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890262,"modifiedTime":1671048297536,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Bouclier","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.SJE3ghtswQwP1dIy"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_bouclier.webp","_id":"SJE3ghtswQwP1dIy","system":{"description":"<p>Utilisation de toutes les sortes de bouclierpour parer.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-6,"default_diffLibre":0,"base":-6,"categorie":"melee","xp":0,"defaut_carac":"melee","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890262,"modifiedTime":1671048297536,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Alchimie","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.TAKRb9CdMUhs9dd4"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_alchimie.webp","_id":"TAKRb9CdMUhs9dd4","system":{"description":"<p>Connaissance des recettes et préparations alchimiques. Identification, élaboration, des solutions diverses, breuvages, poudres, onguents, crèmes, etc. (voir Principes d’alchimie, p357).</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-11,"default_diffLibre":0,"base":-11,"categorie":"connaissance","xp":0,"defaut_carac":"intellect","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890262,"modifiedTime":1671048297536,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Vigilance","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.VyAJK54OPjiRt8oH"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_vigilance.webp","_id":"VyAJK54OPjiRt8oH","system":{"description":"<p>Le talent d’être toujours sur ses gardes, prêt à déceler la moindre anomalie, de</p>\n<p>bruit, d’odeur, de mouvement, etc. Permet de ne pas être surpris en combat, par</p>\n<p>exemple. Indispensable pour monter sérieusement la garde.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-4,"default_diffLibre":0,"base":-4,"categorie":"generale","xp":0,"defaut_carac":"volonte","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890262,"modifiedTime":1671048297536,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Médecine","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.XK2TlYnhR8FlDaEi"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_medecine.webp","_id":"XK2TlYnhR8FlDaEi","system":{"description":"<p>Diagnostic et soin des maladies. Connaissance des remèdes.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-11,"default_diffLibre":0,"base":-11,"categorie":"connaissance","xp":0,"defaut_carac":"intellect","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890263,"modifiedTime":1671048297538,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Maroquinerie","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.XYMQBxFKSs2nPW0J"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_maroquinerie.webp","_id":"XYMQBxFKSs2nPW0J","system":{"description":"<p>Travail du cuir et de la peau. Dépecer correctement un animal en vue de conserver la peau, préparation au tannage, tannage. Évaluer la qualité, la solidité, d’un travail de cuir.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-11,"default_diffLibre":0,"base":-11,"categorie":"specialisee","xp":0,"defaut_carac":"dexterite","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890263,"modifiedTime":1671048297538,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Dague","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.XZNm5W8nTe8aCG61"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_dague.webp","_id":"XZNm5W8nTe8aCG61","system":{"description":"<p>Pour utiliser les Dagues et les Couteaux en combat</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-6,"default_diffLibre":0,"base":-6,"categorie":"melee","xp":0,"defaut_carac":"melee","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890263,"modifiedTime":1671048297538,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Survie en Marais","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.azn3Sm7XYKP78huL"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_survie_marais.webp","_id":"azn3Sm7XYKP78huL","system":{"description":"<p>Par exemple pister un gibier en forêt demande l’usage de Survie en forêt, trouver une grotte pour s’abriter en montagne demande Survie en montagne. Survie en extérieur tient lieu de survie spécifique pour les plaines et collines non boisées.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-8,"default_diffLibre":0,"base":-8,"categorie":"particuliere","xp":0,"defaut_carac":"intellect","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890263,"modifiedTime":1671048297538,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Voie d'Hypnos","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.bt2cR4aE6lIOeg4F"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_hypnos.webp","_id":"bt2cR4aE6lIOeg4F","system":{"description":"<p>Magie d’illusion, suggestion, invocation.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-11,"default_diffLibre":0,"base":-11,"categorie":"draconic","xp":0,"defaut_carac":"reve","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890263,"modifiedTime":1671048297538,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Zoologie","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.c5wursWW03ckpyqn"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_zoologie.webp","_id":"c5wursWW03ckpyqn","system":{"description":"<p>Connaissance des espèces animales, de leurs mœurs, leur des habitat.</p>","descriptionmj":"","niveau":-11,"default_diffLibre":0,"base":-11,"categorie":"connaissance","xp":0,"defaut_carac":"intellect","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890263,"modifiedTime":1671048297539,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Masse à 1 main","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.cMHm3gQr9rUp4iPK"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_masse_1_main.webp","_id":"cMHm3gQr9rUp4iPK","system":{"description":"<p>Ces compétences permettent l’utilisation des masses, gourdins, bâtons, pour attaquer, voire parer.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-6,"default_diffLibre":0,"base":-6,"categorie":"melee","xp":0,"defaut_carac":"melee","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890263,"modifiedTime":1671048297539,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Voie de Thanatos","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.dPlTQzvU3CEg5qKc"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_thanatos.webp","_id":"dPlTQzvU3CEg5qKc","system":{"description":"<p>Magie noire des forces du cauchemar.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-11,"default_diffLibre":0,"base":-11,"categorie":"draconic","xp":0,"defaut_carac":"reve","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890263,"modifiedTime":1671048297539,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Pickpocket","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.dT5cvI7q1HcrLaT1"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_pickpocket.webp","_id":"dT5cvI7q1HcrLaT1","system":{"description":"<p>Art extrêmement dangereux du vol à la tire.</p>","descriptionmj":"","niveau":-8,"default_diffLibre":0,"base":-8,"categorie":"particuliere","xp":0,"defaut_carac":"dexterite","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890263,"modifiedTime":1671048297539,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Maçonnerie","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.dwGVDTUJYP9FcmWM"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_maconnerie.webp","_id":"dwGVDTUJYP9FcmWM","system":{"description":"<p>C’est au sens large le travail de la pierre. Évaluer la qualité, la solidité d’une struc-</p>\n<p>ture maçonnée.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-8,"default_diffLibre":0,"base":-8,"categorie":"particuliere","xp":0,"defaut_carac":"vue","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890264,"modifiedTime":1671048297539,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Epée à 1 main","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.fPhPcCP3sbS6mfbS"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_epee_1_main.webp","_id":"fPhPcCP3sbS6mfbS","system":{"description":"<p>Groupées en une seule jusqu’au niveau zéro, ces compétences sont les principes de base du combat de mêlée. Corps à&nbsp;corps permet de se battre sans armes ; Es-quive permet d’esquiver toutes les sortes&nbsp;de coup ; Dague de mêlée permet l’utilisation de la dague au contact.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-6,"default_diffLibre":0,"base":-6,"categorie":"melee","xp":0,"defaut_carac":"melee","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890264,"modifiedTime":1671048297539,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Escalade","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.gECPPcn6j3B3sWTS"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_escalade.webp","_id":"gECPPcn6j3B3sWTS","system":{"description":"<p>Escalader des obstacles, grimper à la corde, à un arbre, le long d’une paroi.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-4,"default_diffLibre":0,"base":-4,"categorie":"generale","xp":0,"defaut_carac":"force","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890264,"modifiedTime":1671048297539,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Légendes","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.i3wMVkXObzlDVZTG"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_legendes.webp","_id":"i3wMVkXObzlDVZTG","system":{"description":"<p>Connaissance des légendes et des faits du passé. Légendes tient lieu d’histoire.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-11,"default_diffLibre":0,"base":-11,"categorie":"connaissance","xp":0,"defaut_carac":"intellect","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890264,"modifiedTime":1671048297539,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Fronde","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.iNXKIfaETtgSGA0S"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_fronde.webp","_id":"iNXKIfaETtgSGA0S","system":{"description":"<p>Utilisation de la fronde giratoire.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-8,"default_diffLibre":0,"base":-8,"categorie":"tir","xp":0,"defaut_carac":"tir","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890264,"modifiedTime":1671048297539,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Arbalète","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.lt9VC7PkX4Faiduq"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_arbalete.webp","_id":"lt9VC7PkX4Faiduq","system":{"description":"<p>Utilisation de tous les types d’arbalètes.</p>","descriptionmj":"","niveau":-8,"default_diffLibre":0,"base":-8,"categorie":"tir","xp":0,"defaut_carac":"tir","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890264,"modifiedTime":1671048297539,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Javelot","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.neuzZG2C5C0IJ1yk"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_javelot.webp","_id":"neuzZG2C5C0IJ1yk","system":{"description":"<p>Utilisation de la lance courte ou de la javeline en lancer.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-8,"default_diffLibre":0,"base":-8,"categorie":"lancer","xp":0,"defaut_carac":"lancer","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890264,"modifiedTime":1671048297539,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Voie d'Oniros","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.nnR2UHelUaF8dxYn"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_oniros.webp","_id":"nnR2UHelUaF8dxYn","system":{"description":"<p>Magie s’appliquant au monde inanimé.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-11,"default_diffLibre":0,"base":-11,"categorie":"draconic","xp":0,"defaut_carac":"reve","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890265,"modifiedTime":1671048297539,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Esquive","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.oFje22fZF1FaCQhN"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_esquive.webp","_id":"oFje22fZF1FaCQhN","system":{"description":"<p>Groupées en une seule jusqu’au niveau zéro, ces compétences sont les principes de base du combat de mêlée. Corps à&nbsp;corps permet de se battre sans armes ; Es-quive permet d’esquiver toutes les sortes&nbsp;de coup ; Dague de mêlée permet l’utilisation de la dague au contact.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-6,"default_diffLibre":0,"base":-6,"categorie":"melee","xp":0,"defaut_carac":"derobee","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890265,"modifiedTime":1671048297539,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Survie en Cité","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.oHnSnCw1RAW5t15S"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_survie_cite.webp","_id":"oHnSnCw1RAW5t15S","system":{"description":"<p>Se sentir à son aise dans un milieu urbain, dans une foule. Savoir s’orienter intuitivement dans le dédale d’une cité inconnue, et en déceler les dangers : coupeurs de bourse, escrocs, tout autant que patrouilles de gardes. Savoir à qui s’adresser.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-8,"default_diffLibre":0,"base":-8,"categorie":"particuliere","xp":0,"defaut_carac":"derobee","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890265,"modifiedTime":1671048297539,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Jonglerie","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.owCW3nZDvlJy1kCT"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_jonglerie.webp","_id":"owCW3nZDvlJy1kCT","system":{"description":"<p>Balles, quilles, couteaux, torches enflammées : l’art traditionnel du jongleur.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-11,"default_diffLibre":0,"base":-11,"categorie":"specialisee","xp":0,"defaut_carac":"dexterite","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890265,"modifiedTime":1671048297539,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Natation","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.qBUtHhyjvrg1c34I"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_natation.webp","_id":"qBUtHhyjvrg1c34I","system":{"description":"<p>Nager, plonger.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-11,"default_diffLibre":0,"base":-11,"categorie":"specialisee","xp":0,"defaut_carac":"force","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890265,"modifiedTime":1671048297539,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Ecriture","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.qmIpUeedvjC8nGF1"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_ecriture.webp","_id":"qmIpUeedvjC8nGF1","system":{"description":"<p>Lire et &eacute;crire. Savoir composer un texte, un po&egrave;me. Connaissance g&eacute;n&eacute;rale des langues anciennes.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-11,"default_diffLibre":0,"base":-11,"categorie":"connaissance","xp":0,"defaut_carac":"intellect","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890266,"modifiedTime":1671048297540,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Fléau","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.r79VAGS1fRUm4oAd"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_fleau.webp","_id":"r79VAGS1fRUm4oAd","system":{"description":"<p>Utilisation de tous les types de fléaux, pour attaquer.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-6,"default_diffLibre":0,"base":-6,"categorie":"melee","xp":0,"defaut_carac":"melee","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890266,"modifiedTime":1671048297540,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Armes d'hast","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.rwsHwIDszSIPBkrO"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_armes_hast.webp","_id":"rwsHwIDszSIPBkrO","system":{"description":"<p>Utilisation de toutes les piques, vouges, hallebardes, toujours maniées à deux mains, pour attaquer.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-6,"default_diffLibre":0,"base":-6,"categorie":"melee","xp":0,"defaut_carac":"melee","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890266,"modifiedTime":1671048297540,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Arc","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.tVbFkKSN4n0RSrFU"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_arc.webp","_id":"tVbFkKSN4n0RSrFU","system":{"description":"<p>Utilisation de tous les types d’arcs.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-8,"default_diffLibre":0,"base":-8,"categorie":"tir","xp":0,"defaut_carac":"tir","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890266,"modifiedTime":1671048297540,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Dague de jet","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.thJy5AN0qePmfpJu"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_dague_jet.webp","_id":"thJy5AN0qePmfpJu","system":{"description":"<p>Utilisation de la dague en lancer.</p>","descriptionmj":"","niveau":-8,"default_diffLibre":0,"base":-8,"categorie":"lancer","xp":0,"defaut_carac":"lancer","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890266,"modifiedTime":1671048297540,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Bricolage","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.tvIGIPaEJZBaySil"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_bricolage.webp","_id":"tvIGIPaEJZBaySil","system":{"description":"<p>L’art d’être inventif avec ses doigts, pour de&nbsp;petits aménagements ou réparations. Ne&nbsp;peut en aucun cas se substituer aux compétences d’artisanat, Charpenterie, Maçonnerie, etc. Bricolage est utilisé quand l’usage&nbsp;de ces compétences n’est pas pertinent.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-4,"default_diffLibre":0,"base":-4,"categorie":"generale","xp":0,"defaut_carac":"dexterite","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890266,"modifiedTime":1671048297540,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Voie de Narcos","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.u1Peok1EYkBcVsmN"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_narcos.webp","_id":"u1Peok1EYkBcVsmN","system":{"description":"<p>Magie d’enchantement.</p>","descriptionmj":"","niveau":-11,"default_diffLibre":0,"base":-11,"categorie":"draconic","xp":0,"defaut_carac":"reve","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890266,"modifiedTime":1671048297540,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Survie en Glaces","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.uGPqmorAYxv1jboC"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_survie_glace.webp","_id":"uGPqmorAYxv1jboC","system":{"description":"<p>Par exemple pister un gibier en forêt demande l’usage de Survie en forêt, trouver une grotte pour s’abriter en montagne demande Survie en montagne. Survie en extérieur tient lieu de survie spécifique pour les plaines et collines non boisées.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-8,"default_diffLibre":0,"base":-8,"categorie":"particuliere","xp":0,"defaut_carac":"intellect","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890266,"modifiedTime":1671048297540,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Survie en Extérieur","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.ue5iDSm2f4efQDWO"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_survie_exterieur.webp","_id":"ue5iDSm2f4efQDWO","system":{"description":"<p>Se sentir à son aise dans la nature, hors de toute civilisation, s’orienter. Construireun abri, allumer un feu en mauvaisesconditions, trouver de l’eau, pêcher, savoirExemplaire pour dépecer un gibier et l’accommoder sur un feu de braise. Quand un milieu particulier devient déterminant, utiliser à la place une des 6 survies spécifiques.</p>","descriptionmj":"","niveau":-8,"default_diffLibre":0,"base":-8,"categorie":"particuliere","xp":0,"defaut_carac":"intellect","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890266,"modifiedTime":1671048297540,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Survie en Désert","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.vDOAyWc2YnuhNnFF"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_survie_desert.webp","_id":"vDOAyWc2YnuhNnFF","system":{"description":"<p>Par exemple pister un gibier en forêt demande l’usage de Survie en forêt, trouver une grotte pour s’abriter en montagne demande Survie en montagne. Survie en extérieur tient lieu de survie spécifique pour les plaines et collines non boisées.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-8,"default_diffLibre":0,"base":-8,"categorie":"particuliere","xp":0,"defaut_carac":"intellect","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890266,"modifiedTime":1671048297540,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Fouet","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.vIQVQxUeiw36hztI"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_fouet.webp","_id":"vIQVQxUeiw36hztI","system":{"description":"<p>Utilisation du fouet.</p>","descriptionmj":"","niveau":-8,"default_diffLibre":0,"base":-8,"categorie":"lancer","xp":0,"defaut_carac":"lancer","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890266,"modifiedTime":1671048297541,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Travestissement","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.w9QubIHdWEUorges"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_travestissement.webp","_id":"w9QubIHdWEUorges","system":{"description":"<p>L’art de se déguiser, de se grimer, de se rendre méconnaissable.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-8,"default_diffLibre":0,"base":-8,"categorie":"particuliere","xp":0,"defaut_carac":"apparence","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890266,"modifiedTime":1671048297541,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Hache à 1 main","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.wEfuLImdNX4BSXVi"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_hache_a_1_main.webp","_id":"wEfuLImdNX4BSXVi","system":{"description":"<p>Ces deux compétences permettent l’utilisation des hachettes, cognées et haches de bataille, pour attaquer.</p>\n<p>&nbsp;</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-6,"default_diffLibre":0,"base":-6,"categorie":"melee","xp":0,"defaut_carac":"melee","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890267,"modifiedTime":1671048297541,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Musique","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.wefdYe0kvWKioPmk"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_musique.webp","_id":"wefdYe0kvWKioPmk","system":{"description":"<p>Solfège et règles musicales, jeu d’un instrument. Musique donne droit à la connaissance d’un instrument de musique, un seul, à spécifier.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-8,"default_diffLibre":0,"base":-8,"categorie":"particuliere","xp":0,"defaut_carac":"ouie","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890267,"modifiedTime":1671048297541,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Commerce","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.zO7Av9hJ2vdJiPgI"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_defaut.webp","_id":"zO7Av9hJ2vdJiPgI","system":{"description":"<p>Évaluer le prix d’une marchandise, la valeur d’une monnaie locale. Savoir</p>\n<p>jusqu’où l’on peut marchander (lequel&nbsp;marchandage doit être fait en jeu de rôle</p>\n<p>par le joueur lui-même).</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-8,"default_diffLibre":0,"base":-8,"categorie":"particuliere","xp":0,"defaut_carac":"intellect","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890267,"modifiedTime":1671048297541,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Lance","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.zPTXua2Kq6TeBTTZ"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_lance.webp","_id":"zPTXua2Kq6TeBTTZ","system":{"description":"<p>Utilisation en mêlée de la lance courte et de la javeline, pour attaquer, voire parer. La lance n’est toujours qu’à une main.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-6,"default_diffLibre":0,"base":-6,"categorie":"melee","xp":0,"defaut_carac":"melee","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890267,"modifiedTime":1671048297541,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
+{"name":"Acrobatie","type":"competence","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.competences.zyNYa3hYtrOcF2jA"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_acrobatie.webp","_id":"zyNYa3hYtrOcF2jA","system":{"description":"<p>Pirouettes, sauts périlleux, art du funambule, et d’une manière générale, toutes les performances d’agilité spécialisées.</p>\n<p>&nbsp;</p>","descriptionmj":"","niveau":-11,"default_diffLibre":0,"base":-11,"categorie":"specialisee","xp":0,"defaut_carac":"agilite","niveau_archetype":0,"xp_sort":0},"ownership":{"default":0,"Q4cUvqxCxMoTJXDL":3},"effects":[],"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671047890267,"modifiedTime":1671048297541,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}

packs/competences/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000044

packs/competences/LOG

@@ -1,7 +0,0 @@
-2023/05/29-08:40:34.456465 7fca057fa6c0 Recovering log #42
-2023/05/29-08:40:34.470405 7fca057fa6c0 Delete type=3 #40
-2023/05/29-08:40:34.470461 7fca057fa6c0 Delete type=0 #42
-2023/05/29-08:50:04.182611 7fca04ff96c0 Level-0 table #47: started
-2023/05/29-08:50:04.182632 7fca04ff96c0 Level-0 table #47: 0 bytes OK
-2023/05/29-08:50:04.189614 7fca04ff96c0 Delete type=0 #45
-2023/05/29-08:50:04.189758 7fca04ff96c0 Manual compaction at level-0 from '!items!2JLK5e97WbTM5WxX' @ 72057594037927935 : 1 .. '!items!zyNYa3hYtrOcF2jA' @ 0 : 0; will stop at (end)

packs/competences/LOG.old

@@ -1,7 +0,0 @@
-2023/05/29-08:00:37.513847 7fca057fa6c0 Recovering log #38
-2023/05/29-08:00:37.523914 7fca057fa6c0 Delete type=3 #36
-2023/05/29-08:00:37.524000 7fca057fa6c0 Delete type=0 #38
-2023/05/29-08:38:02.080652 7fca04ff96c0 Level-0 table #43: started
-2023/05/29-08:38:02.080678 7fca04ff96c0 Level-0 table #43: 0 bytes OK
-2023/05/29-08:38:02.086831 7fca04ff96c0 Delete type=0 #41
-2023/05/29-08:38:02.093863 7fca04ff96c0 Manual compaction at level-0 from '!items!2JLK5e97WbTM5WxX' @ 72057594037927935 : 1 .. '!items!zyNYa3hYtrOcF2jA' @ 0 : 0; will stop at (end)