Merge pull request '13.0.36 - Les rêveries d'Illisys' (#801) from feature/v13-corrections into v13

Reviewed-on: https, #801

assets/actions/ouvrir.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" style="height: 256px; width: 256px;"><defs><radialGradient id="skoll-open-chest-gradient-2"><stop offset="0%" stop-color="#b8e986" stop-opacity="1"></stop><stop offset="100%" stop-color="#ffe0af" stop-opacity="1"></stop></radialGradient><linearGradient x1="0" x2="0" y1="0" y2="1" id="skoll-open-chest-gradient-5"><stop offset="0%" stop-color="#417505" stop-opacity="1"></stop><stop offset="100%" stop-color="#8b572a" stop-opacity="1"></stop></linearGradient></defs><g class="" transform="translate(1,0)" style=""><path d="M457.03 213.037 416.514 100.24C425 77.232 433.27 68.075 437.527 64.633c3.162-2.563 5.922-3.534 8.185-2.904 4.134 1.168 8.775 7.7 12.278 17.456 11.266 31.347 10.377 87.094-.96 133.85zm-324.287-17.9 312.804 34.84-43.82-122.1L145.558 79.34c2.593 36.102-1.913 79.913-12.817 115.796zM128.98 77.5l-45.06-5.02 37.03 103.123c7.773-32.06 10.625-68.357 8.03-98.102zm-27.52-50.31c-3.793 3.1-10.77 10.666-18.25 28.566L402.23 91.3c5.333-13.695 11.37-24.702 17.88-32.495L108.796 24.13c-2.573-.29-5.415 1.51-7.338 3.06zm280.63 283.338.61 169.352 66.352-53.63-.61-169.35zM366.163 487.9 46.62 452.306 46 278.396l319.553 35.594zM216.726 337.648a9.777 9.777 0 0 0 5.168-9.405c-.248-6.367-5.364-12.092-11.43-12.857h-.125c-6.14-.693-10.904 3.927-10.646 10.335a13.973 13.973 0 0 0 5.767 10.543l-2.17 25.073 17.57 2.005zm219.28-91.983-307.46-34.25v59.54l242.712 27.037zM58.31 263.13l54.34 6.058v-49.98z" fill="#fff" fill-opacity="1" transform="translate(25.6, 25.6) scale(0.9, 0.9) rotate(0, 256, 256) skewX(0) skewY(0)"></path></g></svg>

changelog.md

@@ -1,5 +1,111 @@
 # 13.0
 
+## 13.0.36 - Les rêveries d'Illisys
+
+- Corrections v14
+  - les attaques à distance n'empèchent plus la fenêtre d'attaque de s'ouvrir
+  - les commandes (/help, ...) fonctionnent en v14
+- Les feuilles d'acteurs ne s'ouvrent plus lors d'un changement (par exemple en cas d'encaissement)
+- Les jeux sont correctement affichés
+- Ajout d'une gravité de blessure sur les encaissement d'entités
+- Amélioration de champs numériques: ajout de min et max quand c'est utile
+- correction pour cuisiner depuis l'équipement
+- les boutons dans les listes d'équipement sont mieux affichés sans retour à la ligne
+
+
+## 13.0.35 - Les travaux d'Illisys
+
+- Correction du recul contre une entité de cauchemar (qui utilise le rêve comme force)
+- Correction erreur lors de la suppression d'un objet d'un conteneur
+- Meilleure gestion des messages publics/GM, en particulier pour les tirage dans les compendiums
+- Filtrage des boutons pour les acteurs non personnages (pour éviter de faire manger l'auberge...)
+
+## 13.0.34 - La saumuche d'Illysis
+
+- la qualité des "improvisations du moment" se base sur le niveau du cuisinier
+- l'appel au moral n'est pas affiché à l'ouverture d'une fenêtre de jets de sorts (ou de tâche intellectuelle)
+- la difficulté variable de l'annulation de magie est bien prise en compte
+- correction erreur lors de la suppression d'un objet d'un conteneur
+
+## 13.0.33 - L'ébriété d'Illysis
+
+- le stade éméché ne cause plus de perte d'endurance
+
+## 13.0.32 - Le surpoids d'Illysis
+
+- Le malus d'encombrement sur jet d'Agilité avec Natation ou Acrobatie peuvent être changés, et sont correctement arrondis
+- L'ajustement de condition est plus visible sur les résultats de jets de dés
+- Les blessures graves soignées ne font pas perdre d'endurance par round
+- Les blessures et pertes correspondantes (vie, endurance, effets sonné, ...) s'affichent correctement
+- la remise à neuf ne provoque pas d'erreur pour certains effets déjà supprimés
+
+## 13.0.31 - Les choix multiples d'Illysis
+
+- les défauts de caractéristique/difficulté des compétences ne sont pris que si aucun autre choix n'est fait
+- lors d'une attaque à deux mains avec une arme à une ou deux mains, les dommages à deux mains sont bien utilisés
+
+## 13.0.30 - Le pansement d'Illysis
+
+- les soins d'un joueur à l'autre fonctionne de nouveau
+- la fenêtre de jet de compétence s'ouvre avec la caractéristique et la difficulté par défaut
+- on peut saisir des valeurs négatives au clavier en sélectionnant les conditions/difficultés
+
+## 13.0.29 - Le tricorne d'Illysis
+
+- gestion des attaques avec jets V2 depuis l'onglet de combat
+- les jets de résistance en mode V2 fonctionnent sans sélection de compétence
+- affichage de l'expérience correspondant aux sorts pour aider à la création
+- affichage de l'équivallent d'expérience des caractéristiques
+
+## 13.0.28 - La quadrature d'Illysis
+
+- Les ajustements de portée sont calculés pour les attaques à distance
+- L'appel au moral dans le tchat ne déplace plus les boutons d'appel à la chance
+- Correction d'apparence V13
+  - la fenêtre de choix des status utilisés est affichée correctement
+  - la fenêtre d'astrologie MJ est affichée correctement
+
+## 13.0.27 - Les lunettes d'Illysis
+
+- Les heures ne sont plus affichées en doublon sur les messages
+- Les conteneurs ouverts sont mis à jour si leur contenu change
+- Le style des icones d'objets est homogénéisé
+- Ajout d'icônes: coffre, tissu de soie, parchemin
+- Amélioration des choix d'actions de combat
+  - le choix d'initiative limite les attaques disponibles
+  - les compétences sont triées dans l'ordre décroissant
+
+## 13.0.26 - La ménagerie d'Illysis
+
+- Correction: on peut de nouveau modifier les caractéristiques des créatures
+
+## 13.0.24 - Le grand oubli d'Illysis
+
+- ajout d'un bouton pour supprimer les anciens messages du tchat
+- correction de messages d'erreur 'User ... lacks permission' / 'Active Effect ... does not exist'
+- les joueurs peuvent affecter leurs enchantements aux objets enchantables de leur équipement
+- correction des boutons pour lancer les maladresses
+  - utilisation des tables de compendium
+  - correction des droits pour mise à jour du message
+- correction de la cuisine
+  - reprise de l'image de cuisine dans l'équipement
+  - prise en compte de la difficulté pour préparer la nourriture brute
+
+
+## 13.0.23 - Le marché d'Illysis
+
+- Améliorations
+  - lors de la consommation suite à un achat, les jets d'appréciation/éthylisme
+    sont faits par l'acheteur. Du coup, c'est lui qui lance le jet d'appréciation
+    (pour un service ou un plat de qualité), et ses dés sont utilisés avec dice-so-nice
+  - les créatures ont le statut Inconscient quand leur endurance est à 0
+- Fenêtre de jets V2
+  - les soins de blessures sont correctement appliqués
+  - correction d'affichage jet sans compétence/avec compétence
+  - correction de la prise en compte des tactiques
+  - correction du filtrage des défenses selon l'attaque
+  - lorsque le mode de visibilité des jets général est changé, les fenêtres de jets suivent ce changement
+
 ## 13.0.22 - Les reflets d'Illysis
 
 - Améliorations

css/foundryvtt-reve-de-dragon.css

@@ -893,7 +893,7 @@ body {
   max-width: 1.4rem;
   max-height: 1.4rem;
   border: 1px;
-  background: center / contain no-repeat url("../../icons/templates/icone_parchement_vierge.webp");
+  background: center / contain no-repeat url("../icons/templates/icone_parchement_vierge.webp");
 }
 .system-foundryvtt-reve-de-dragon .sheet-header .header-compteurs {
   width: calc(60% - 110px - 1rem);
@@ -1120,49 +1120,27 @@ body {
   text-align: left;
 }
 .system-foundryvtt-reve-de-dragon .equipement-nom {
-  flex-grow: 3;
+  flex-grow: 4;
+  flex-shrink: 2;
   margin: 0;
-  justify-content: center;
   text-align: left;
   display: ruby;
 }
 .system-foundryvtt-reve-de-dragon .equipement-valeur {
   margin: 0;
-  flex-grow: 1.5;
+  flex-grow: 1;
+  flex-shrink: 1;
   text-align: center;
 }
 .system-foundryvtt-reve-de-dragon .equipement-detail {
   margin: 0;
   flex-grow: 1;
-  align-items: center;
-  justify-content: center;
-  text-align: center;
-}
-.system-foundryvtt-reve-de-dragon span.equipement-detail-buttons {
-  margin: 0;
-  flex-grow: 1.5;
+  flex-shrink: 1;
   align-items: center;
   justify-content: center;
   text-align: center;
   display: flex;
-  flex-direction: row;
-}
-.system-foundryvtt-reve-de-dragon .equipement-button {
-  margin: 0;
-  flex-grow: 0.5;
-  align-items: center;
-  justify-content: center;
-  text-align: center;
-}
-.system-foundryvtt-reve-de-dragon :is(.item-actions-controls, .equipement-actions) {
-  margin: 0;
-  flex-grow: 1.2;
-  align-items: end;
-  justify-content: flex-end;
-  text-align: right;
-}
-.system-foundryvtt-reve-de-dragon .liste-equipement :is(.equipement-actions, .item-actions-controls) {
-  flex-grow: 2;
+  min-width: max-content;
 }
 .system-foundryvtt-reve-de-dragon .blessure-control {
   flex-grow: 1;
@@ -1210,6 +1188,10 @@ body {
   color: rgba(173, 36, 26, 0.9);
   text-shadow: 1px 1px 4px #3c3c3c;
 }
+.system-foundryvtt-reve-de-dragon .rdd-dialog.status-effects li {
+  display: flex;
+  flex-direction: row;
+}
 .system-foundryvtt-reve-de-dragon .rdd-dialog-select img.select-img {
   -webkit-box-flex: 0;
   -ms-flex: 0 0 48px;
@@ -1522,12 +1504,24 @@ body {
 .system-foundryvtt-reve-de-dragon .competence-list .item-controls.hidden-controls {
   display: none !important;
 }
+.system-foundryvtt-reve-de-dragon .competence-header .item-actions-controls {
+  flex-shrink: 2;
+  flex-grow: 2;
+}
 .system-foundryvtt-reve-de-dragon .item-actions-controls,
 .system-foundryvtt-reve-de-dragon .item-controls {
-  vertical-align: super;
+  margin: 0;
+  flex-grow: 1;
+  flex-shrink: 1;
+  align-items: end;
+  text-align: right;
+  min-width: max-content;
+  flex-basis: fit-content;
+  vertical-align: baseline;
 }
 .system-foundryvtt-reve-de-dragon .item-actions-controls img,
 .system-foundryvtt-reve-de-dragon .item-controls img {
+  vertical-align: text-bottom;
   display: inline;
   max-width: 1rem;
   max-height: 1rem;
@@ -1540,10 +1534,17 @@ body {
   font-size: 0.8em;
   color: var(--color-controls-light);
 }
-.system-foundryvtt-reve-de-dragon .item-actions-controls img:hover,
-.system-foundryvtt-reve-de-dragon .item-controls img:hover,
-.system-foundryvtt-reve-de-dragon .item-actions-controls i:is(.fas, .far, .fa-solid, .fa-regular):hover,
-.system-foundryvtt-reve-de-dragon .item-controls i:is(.fas, .far, .fa-solid, .fa-regular):hover {
+.system-foundryvtt-reve-de-dragon .item-actions-controls a:hover,
+.system-foundryvtt-reve-de-dragon .item-controls a:hover {
+  text-shadow: 1px 0px 0px #ff6600;
+}
+.system-foundryvtt-reve-de-dragon .item-actions-controls a img:hover,
+.system-foundryvtt-reve-de-dragon .item-controls a img:hover {
+  opacity: 0.6;
+  filter: drop-shadow(1px 1px 1px #009966) invert(0.8);
+}
+.system-foundryvtt-reve-de-dragon .item-actions-controls a i:is(.fas, .far, .fa-solid, .fa-regular):hover,
+.system-foundryvtt-reve-de-dragon .item-controls a i:is(.fas, .far, .fa-solid, .fa-regular):hover {
   opacity: 0.6;
 }
 .system-foundryvtt-reve-de-dragon .rdd-roll-dialog .description-sort {
@@ -1726,25 +1727,121 @@ body {
 .system-foundryvtt-reve-de-dragon form.app-personnage-aleatoire h2 {
   min-width: 30rem;
 }
-.system-foundryvtt-reve-de-dragon .app-calendar-astrologie div.theme-astral {
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.theme-astral {
   width: 14rem;
   margin: 0.4rem;
 }
-.system-foundryvtt-reve-de-dragon .app-calendar-astrologie div.horloge-roue {
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-roue {
   position: relative;
   left: calc(50% - 6.5rem);
   width: 13rem;
   height: 13rem;
 }
-.system-foundryvtt-reve-de-dragon .app-calendar-astrologie div.horloge-roue div.horloge-heure {
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-roue div.horloge-heure {
   position: absolute;
   width: 1.8rem;
   height: 1.8rem;
 }
-.system-foundryvtt-reve-de-dragon .app-calendar-astrologie div.horloge-roue div.horloge-heure img.horloge-heure-img {
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-roue div.horloge-heure img.horloge-heure-img {
   width: 2rem;
   height: 2rem;
 }
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-heure.heure-01 {
+  top: calc(50% - 1rem + 0 * 41%);
+  left: calc(50% - 1rem + -1 * 41%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-heure.heure-02 {
+  top: calc(50% - 1rem + -0.5 * 41%);
+  left: calc(50% - 1rem + -0.8660254 * 41%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-heure.heure-03 {
+  top: calc(50% - 1rem + -0.8660254 * 41%);
+  left: calc(50% - 1rem + -0.5 * 41%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-heure.heure-04 {
+  top: calc(50% - 1rem + -1 * 41%);
+  left: calc(50% - 1rem + 0 * 41%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-heure.heure-05 {
+  top: calc(50% - 1rem + -0.8660254 * 41%);
+  left: calc(50% - 1rem + 0.5 * 41%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-heure.heure-06 {
+  top: calc(50% - 1rem + -0.5 * 41%);
+  left: calc(50% - 1rem + 0.8660254 * 41%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-heure.heure-07 {
+  top: calc(50% - 1rem + 0 * 41%);
+  left: calc(50% - 1rem + 1 * 41%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-heure.heure-08 {
+  top: calc(50% - 1rem + 0.5 * 41%);
+  left: calc(50% - 1rem + 0.8660254 * 41%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-heure.heure-09 {
+  top: calc(50% - 1rem + 0.8660254 * 41%);
+  left: calc(50% - 1rem + 0.5 * 41%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-heure.heure-10 {
+  top: calc(50% - 1rem + 1 * 41%);
+  left: calc(50% - 1rem + 0 * 41%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-heure.heure-11 {
+  top: calc(50% - 1rem + 0.8660254 * 41%);
+  left: calc(50% - 1rem + -0.5 * 41%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-heure.heure-12 {
+  top: calc(50% - 1rem + 0.5 * 41%);
+  left: calc(50% - 1rem + -0.8660254 * 41%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-ajustement.heure-01 {
+  top: calc(50% - 0.4rem + 0 * 28%);
+  left: calc(50% - 0.4rem + -1 * 28%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-ajustement.heure-02 {
+  top: calc(50% - 0.4rem + -0.5 * 28%);
+  left: calc(50% - 0.4rem + -0.8660254 * 28%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-ajustement.heure-03 {
+  top: calc(50% - 0.4rem + -0.8660254 * 28%);
+  left: calc(50% - 0.4rem + -0.5 * 28%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-ajustement.heure-04 {
+  top: calc(50% - 0.4rem + -1 * 28%);
+  left: calc(50% - 0.4rem + 0 * 28%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-ajustement.heure-05 {
+  top: calc(50% - 0.4rem + -0.8660254 * 28%);
+  left: calc(50% - 0.4rem + 0.5 * 28%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-ajustement.heure-06 {
+  top: calc(50% - 0.4rem + -0.5 * 28%);
+  left: calc(50% - 0.4rem + 0.8660254 * 28%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-ajustement.heure-07 {
+  top: calc(50% - 0.4rem + 0 * 28%);
+  left: calc(50% - 0.4rem + 1 * 28%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-ajustement.heure-08 {
+  top: calc(50% - 0.4rem + 0.5 * 28%);
+  left: calc(50% - 0.4rem + 0.8660254 * 28%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-ajustement.heure-09 {
+  top: calc(50% - 0.4rem + 0.8660254 * 28%);
+  left: calc(50% - 0.4rem + 0.5 * 28%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-ajustement.heure-10 {
+  top: calc(50% - 0.4rem + 1 * 28%);
+  left: calc(50% - 0.4rem + 0 * 28%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-ajustement.heure-11 {
+  top: calc(50% - 0.4rem + 0.8660254 * 28%);
+  left: calc(50% - 0.4rem + -0.5 * 28%);
+}
+.system-foundryvtt-reve-de-dragon .rdd-calendar-astrologie div.horloge-ajustement.heure-12 {
+  top: calc(50% - 0.4rem + 0.5 * 28%);
+  left: calc(50% - 0.4rem + -0.8660254 * 28%);
+}
 .system-foundryvtt-reve-de-dragon .window-app .window-content,
 .system-foundryvtt-reve-de-dragon .window-app.sheet .window-content .sheet-body,
 .system-foundryvtt-reve-de-dragon .application .window-content {
@@ -2271,8 +2368,9 @@ body {
 }
 .system-foundryvtt-reve-de-dragon .chat-inline-icon {
   border: 0;
-  padding: 1px;
+  padding: 0 0.2rem;
   vertical-align: text-top;
+  display: inline;
 }
 .system-foundryvtt-reve-de-dragon .actor-img-small {
   max-width: 1.5rem;
@@ -2390,12 +2488,6 @@ body {
   background: #1e1914;
   border: 1px solid #482e1c;
 }
-.system-foundryvtt-reve-de-dragon #players {
-  border-image: url(../assets/ui/footer-button.webp) 10 repeat;
-  border-image-width: 4px;
-  border-image-outset: 0px;
-  background: #1e1914;
-}
 .system-foundryvtt-reve-de-dragon #navigation #scene-list .scene.nav-item.active {
   background: #482e1c;
 }
@@ -2589,102 +2681,6 @@ body {
   top: calc(50% - 0.7rem + 0.5 * 38%);
   left: calc(50% - 0.7rem + -0.8660254 * 41%);
 }
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-heure.heure-01 {
-  top: calc(50% - 1rem + 0 * 41%);
-  left: calc(50% - 1rem + -1 * 41%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-heure.heure-02 {
-  top: calc(50% - 1rem + -0.5 * 41%);
-  left: calc(50% - 1rem + -0.8660254 * 41%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-heure.heure-03 {
-  top: calc(50% - 1rem + -0.8660254 * 41%);
-  left: calc(50% - 1rem + -0.5 * 41%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-heure.heure-04 {
-  top: calc(50% - 1rem + -1 * 41%);
-  left: calc(50% - 1rem + 0 * 41%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-heure.heure-05 {
-  top: calc(50% - 1rem + -0.8660254 * 41%);
-  left: calc(50% - 1rem + 0.5 * 41%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-heure.heure-06 {
-  top: calc(50% - 1rem + -0.5 * 41%);
-  left: calc(50% - 1rem + 0.8660254 * 41%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-heure.heure-07 {
-  top: calc(50% - 1rem + 0 * 41%);
-  left: calc(50% - 1rem + 1 * 41%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-heure.heure-08 {
-  top: calc(50% - 1rem + 0.5 * 41%);
-  left: calc(50% - 1rem + 0.8660254 * 41%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-heure.heure-09 {
-  top: calc(50% - 1rem + 0.8660254 * 41%);
-  left: calc(50% - 1rem + 0.5 * 41%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-heure.heure-10 {
-  top: calc(50% - 1rem + 1 * 41%);
-  left: calc(50% - 1rem + 0 * 41%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-heure.heure-11 {
-  top: calc(50% - 1rem + 0.8660254 * 41%);
-  left: calc(50% - 1rem + -0.5 * 41%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-heure.heure-12 {
-  top: calc(50% - 1rem + 0.5 * 41%);
-  left: calc(50% - 1rem + -0.8660254 * 41%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-ajustement.heure-01 {
-  top: calc(50% - 0.4rem + 0 * 28%);
-  left: calc(50% - 0.4rem + -1 * 28%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-ajustement.heure-02 {
-  top: calc(50% - 0.4rem + -0.5 * 28%);
-  left: calc(50% - 0.4rem + -0.8660254 * 28%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-ajustement.heure-03 {
-  top: calc(50% - 0.4rem + -0.8660254 * 28%);
-  left: calc(50% - 0.4rem + -0.5 * 28%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-ajustement.heure-04 {
-  top: calc(50% - 0.4rem + -1 * 28%);
-  left: calc(50% - 0.4rem + 0 * 28%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-ajustement.heure-05 {
-  top: calc(50% - 0.4rem + -0.8660254 * 28%);
-  left: calc(50% - 0.4rem + 0.5 * 28%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-ajustement.heure-06 {
-  top: calc(50% - 0.4rem + -0.5 * 28%);
-  left: calc(50% - 0.4rem + 0.8660254 * 28%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-ajustement.heure-07 {
-  top: calc(50% - 0.4rem + 0 * 28%);
-  left: calc(50% - 0.4rem + 1 * 28%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-ajustement.heure-08 {
-  top: calc(50% - 0.4rem + 0.5 * 28%);
-  left: calc(50% - 0.4rem + 0.8660254 * 28%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-ajustement.heure-09 {
-  top: calc(50% - 0.4rem + 0.8660254 * 28%);
-  left: calc(50% - 0.4rem + 0.5 * 28%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-ajustement.heure-10 {
-  top: calc(50% - 0.4rem + 1 * 28%);
-  left: calc(50% - 0.4rem + 0 * 28%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-ajustement.heure-11 {
-  top: calc(50% - 0.4rem + 0.8660254 * 28%);
-  left: calc(50% - 0.4rem + -0.5 * 28%);
-}
-.system-foundryvtt-reve-de-dragon .calendar-astrologie div.horloge-ajustement.heure-12 {
-  top: calc(50% - 0.4rem + 0.5 * 28%);
-  left: calc(50% - 0.4rem + -0.8660254 * 28%);
-}
 .system-foundryvtt-reve-de-dragon .calendar-boutons-heure .calendar-btn:is(.calendar-lyre, .calendar-vaisseau) img {
   color: hsla(0, 0%, 100%, 0.5);
   border: none;

info-message.html

@@ -0,0 +1,6 @@
+<h3>L'oeuf de Dragon</h3>
+<p>
+  On raconte que si le premier Vaisseau, on trouve un oeuf couvé par
+  un lapin, il faut bien s'occuper dudit lapin, car quatre mois plus tard
+  pourrait bien éclore un dragon!
+</p>

less/foundryvtt-reve-de-dragon.less

@@ -136,7 +136,7 @@
     max-height: 1.4rem;
     border: 1px;
     background: center / contain no-repeat
-      url("../../icons/templates/icone_parchement_vierge.webp");
+      url("../icons/templates/icone_parchement_vierge.webp");
   }
 
   .sheet-header .header-compteurs {
@@ -393,49 +393,27 @@
     text-align: left;
   }
   .equipement-nom {
-    flex-grow: 3;
+    flex-grow: 4;
+    flex-shrink: 2;
     margin: 0;
-    justify-content: center;
     text-align: left;
     display: ruby;
   }
   .equipement-valeur {
     margin: 0;
-    flex-grow: 1.5;
+    flex-grow: 1;
+    flex-shrink: 1;
     text-align: center;
   }
   .equipement-detail {
     margin: 0;
     flex-grow: 1;
-    align-items: center;
-    justify-content: center;
-    text-align: center;
-  }
-  span.equipement-detail-buttons {
-    margin: 0;
-    flex-grow: 1.5;
+    flex-shrink: 1;
     align-items: center;
     justify-content: center;
     text-align: center;
     display: flex;
-    flex-direction: row;
-  }
-  .equipement-button {
-    margin: 0;
-    flex-grow: 0.5;
-    align-items: center;
-    justify-content: center;
-    text-align: center;
-  }
-  :is(.item-actions-controls, .equipement-actions) {
-    margin: 0;
-    flex-grow: 1.2;
-    align-items: end;
-    justify-content: flex-end;
-    text-align: right;
-  }
-  .liste-equipement :is(.equipement-actions, .item-actions-controls) {
-    flex-grow: 2;
+    min-width: max-content;
   }
 
   .blessure-control {
@@ -484,7 +462,10 @@
     color: rgba(173, 36, 26, 0.9);
     text-shadow: 1px 1px 4px rgba(60, 60, 60, 1);
   }
-
+  .rdd-dialog.status-effects li {
+      display: flex;
+      flex-direction: row;
+  }
   .rdd-dialog-select img.select-img {
     -webkit-box-flex: 0;
     -ms-flex: 0 0 48px;
@@ -845,13 +826,22 @@
   .competence-list .item-controls.hidden-controls {
     display: none !important;
   }
+  .competence-header .item-actions-controls{
+    flex-shrink: 2;
+    flex-grow: 2;
+  }
   .item-actions-controls,
   .item-controls {
-    vertical-align: super;
-    // a {
-    // }
-
+    margin: 0;
+    flex-grow: 1;
+    flex-shrink: 1;
+    align-items: end;
+    text-align: right;
+    min-width: max-content;
+    flex-basis: fit-content;
+    vertical-align: baseline;
     img {
+      vertical-align: text-bottom;
       display: inline;
       max-width: 1rem;
       max-height: 1rem;
@@ -865,8 +855,16 @@
       color: var(--color-controls-light);
     }
 
-    img:hover,
-    i:is(.fas, .far, .fa-solid, .fa-regular):hover {
+    a:hover {
+      text-shadow: 1px 0px 0px #ff6600;
+    }
+
+    a img:hover{
+      opacity: 0.6;
+      filter: drop-shadow(1px 1px 1px #009966) invert(0.8);
+    }
+
+    a i:is(.fas, .far, .fa-solid, .fa-regular):hover {
       opacity: 0.6;
     }
   }
@@ -1056,7 +1054,7 @@
       min-width: 30rem;
     }
   }
-  .app-calendar-astrologie {
+  .rdd-calendar-astrologie {
     div.theme-astral {
       width: 14rem;
       margin: 0.4rem;
@@ -1076,6 +1074,105 @@
         }
       }
     }
+    
+      div.horloge-heure.heure-01 {
+        top: calc(50% - 1rem + sin(-180deg) * 41%);
+        left: calc(50% - 1rem + cos(-180deg) * 41%);
+      }
+      div.horloge-heure.heure-02 {
+        top: calc(50% - 1rem + sin(-150deg) * 41%);
+        left: calc(50% - 1rem + cos(-150deg) * 41%);
+      }
+      div.horloge-heure.heure-03 {
+        top: calc(50% - 1rem + sin(-120deg) * 41%);
+        left: calc(50% - 1rem + cos(-120deg) * 41%);
+      }
+      div.horloge-heure.heure-04 {
+        top: calc(50% - 1rem + sin(-90deg) * 41%);
+        left: calc(50% - 1rem + cos(-90deg) * 41%);
+      }
+      div.horloge-heure.heure-05 {
+        top: calc(50% - 1rem + sin(-60deg) * 41%);
+        left: calc(50% - 1rem + cos(-60deg) * 41%);
+      }
+      div.horloge-heure.heure-06 {
+        top: calc(50% - 1rem + sin(-30deg) * 41%);
+        left: calc(50% - 1rem + cos(-30deg) * 41%);
+      }
+      div.horloge-heure.heure-07 {
+        top: calc(50% - 1rem + sin(-0deg) * 41%);
+        left: calc(50% - 1rem + cos(-0deg) * 41%);
+      }
+      div.horloge-heure.heure-08 {
+        top: calc(50% - 1rem + sin(30deg) * 41%);
+        left: calc(50% - 1rem + cos(30deg) * 41%);
+      }
+      div.horloge-heure.heure-09 {
+        top: calc(50% - 1rem + sin(60deg) * 41%);
+        left: calc(50% - 1rem + cos(60deg) * 41%);
+      }
+      div.horloge-heure.heure-10 {
+        top: calc(50% - 1rem + sin(90deg) * 41%);
+        left: calc(50% - 1rem + cos(90deg) * 41%);
+      }
+      div.horloge-heure.heure-11 {
+        top: calc(50% - 1rem + sin(120deg) * 41%);
+        left: calc(50% - 1rem + cos(120deg) * 41%);
+      }
+      div.horloge-heure.heure-12 {
+        top: calc(50% - 1rem + sin(150deg) * 41%);
+        left: calc(50% - 1rem + cos(150deg) * 41%);
+      }
+
+      div.horloge-ajustement.heure-01 {
+        top: calc(50% - 0.4rem + sin(180deg) * 28%);
+        left: calc(50% - 0.4rem + cos(180deg) * 28%);
+      }
+      div.horloge-ajustement.heure-02 {
+        top: calc(50% - 0.4rem + sin(-150deg) * 28%);
+        left: calc(50% - 0.4rem + cos(-150deg) * 28%);
+      }
+      div.horloge-ajustement.heure-03 {
+        top: calc(50% - 0.4rem + sin(-120deg) * 28%);
+        left: calc(50% - 0.4rem + cos(-120deg) * 28%);
+      }
+      div.horloge-ajustement.heure-04 {
+        top: calc(50% - 0.4rem + sin(-90deg) * 28%);
+        left: calc(50% - 0.4rem + cos(-90deg) * 28%);
+      }
+      div.horloge-ajustement.heure-05 {
+        top: calc(50% - 0.4rem + sin(-60deg) * 28%);
+        left: calc(50% - 0.4rem + cos(-60deg) * 28%);
+      }
+      div.horloge-ajustement.heure-06 {
+        top: calc(50% - 0.4rem + sin(-30deg) * 28%);
+        left: calc(50% - 0.4rem + cos(-30deg) * 28%);
+      }
+      div.horloge-ajustement.heure-07 {
+        top: calc(50% - 0.4rem + sin(0deg) * 28%);
+        left: calc(50% - 0.4rem + cos(0deg) * 28%);
+      }
+      div.horloge-ajustement.heure-08 {
+        top: calc(50% - 0.4rem + sin(30deg) * 28%);
+        left: calc(50% - 0.4rem + cos(30deg) * 28%);
+      }
+      div.horloge-ajustement.heure-09 {
+        top: calc(50% - 0.4rem + sin(60deg) * 28%);
+        left: calc(50% - 0.4rem + cos(60deg) * 28%);
+      }
+      div.horloge-ajustement.heure-10 {
+        top: calc(50% - 0.4rem + sin(90deg) * 28%);
+        left: calc(50% - 0.4rem + cos(90deg) * 28%);
+      }
+      div.horloge-ajustement.heure-11 {
+        top: calc(50% - 0.4rem + sin(120deg) * 28%);
+        left: calc(50% - 0.4rem + cos(120deg) * 28%);
+      }
+      div.horloge-ajustement.heure-12 {
+        top: calc(50% - 0.4rem + sin(150deg) * 28%);
+        left: calc(50% - 0.4rem + cos(150deg) * 28%);
+      }
+
   }
 
   .window-app .window-content,
@@ -1665,8 +1762,9 @@
   }
   .chat-inline-icon {
     border: 0;
-    padding: 1px;
+    padding: 0 0.2rem;
     vertical-align: text-top;
+    display: inline;
   }
 
   .actor-img-small {
@@ -1800,13 +1898,6 @@
     border: 1px solid rgba(72, 46, 28, 1);
   }
 
-  #players {
-    border-image: url(../assets/ui/footer-button.webp) 10 repeat;
-    border-image-width: 4px;
-    border-image-outset: 0px;
-    background: rgba(30, 25, 20, 1);
-  }
-
   #navigation #scene-list .scene.nav-item.active {
     background: rgba(72, 46, 28, 1);
   }
@@ -2013,106 +2104,6 @@
     }
   }
 
-  .calendar-astrologie {
-    div.horloge-heure.heure-01 {
-      top: calc(50% - 1rem + sin(-180deg) * 41%);
-      left: calc(50% - 1rem + cos(-180deg) * 41%);
-    }
-    div.horloge-heure.heure-02 {
-      top: calc(50% - 1rem + sin(-150deg) * 41%);
-      left: calc(50% - 1rem + cos(-150deg) * 41%);
-    }
-    div.horloge-heure.heure-03 {
-      top: calc(50% - 1rem + sin(-120deg) * 41%);
-      left: calc(50% - 1rem + cos(-120deg) * 41%);
-    }
-    div.horloge-heure.heure-04 {
-      top: calc(50% - 1rem + sin(-90deg) * 41%);
-      left: calc(50% - 1rem + cos(-90deg) * 41%);
-    }
-    div.horloge-heure.heure-05 {
-      top: calc(50% - 1rem + sin(-60deg) * 41%);
-      left: calc(50% - 1rem + cos(-60deg) * 41%);
-    }
-    div.horloge-heure.heure-06 {
-      top: calc(50% - 1rem + sin(-30deg) * 41%);
-      left: calc(50% - 1rem + cos(-30deg) * 41%);
-    }
-    div.horloge-heure.heure-07 {
-      top: calc(50% - 1rem + sin(-0deg) * 41%);
-      left: calc(50% - 1rem + cos(-0deg) * 41%);
-    }
-    div.horloge-heure.heure-08 {
-      top: calc(50% - 1rem + sin(30deg) * 41%);
-      left: calc(50% - 1rem + cos(30deg) * 41%);
-    }
-    div.horloge-heure.heure-09 {
-      top: calc(50% - 1rem + sin(60deg) * 41%);
-      left: calc(50% - 1rem + cos(60deg) * 41%);
-    }
-    div.horloge-heure.heure-10 {
-      top: calc(50% - 1rem + sin(90deg) * 41%);
-      left: calc(50% - 1rem + cos(90deg) * 41%);
-    }
-    div.horloge-heure.heure-11 {
-      top: calc(50% - 1rem + sin(120deg) * 41%);
-      left: calc(50% - 1rem + cos(120deg) * 41%);
-    }
-    div.horloge-heure.heure-12 {
-      top: calc(50% - 1rem + sin(150deg) * 41%);
-      left: calc(50% - 1rem + cos(150deg) * 41%);
-    }
-
-    div.horloge-ajustement.heure-01 {
-      top: calc(50% - 0.4rem + sin(180deg) * 28%);
-      left: calc(50% - 0.4rem + cos(180deg) * 28%);
-    }
-    div.horloge-ajustement.heure-02 {
-      top: calc(50% - 0.4rem + sin(-150deg) * 28%);
-      left: calc(50% - 0.4rem + cos(-150deg) * 28%);
-    }
-    div.horloge-ajustement.heure-03 {
-      top: calc(50% - 0.4rem + sin(-120deg) * 28%);
-      left: calc(50% - 0.4rem + cos(-120deg) * 28%);
-    }
-    div.horloge-ajustement.heure-04 {
-      top: calc(50% - 0.4rem + sin(-90deg) * 28%);
-      left: calc(50% - 0.4rem + cos(-90deg) * 28%);
-    }
-    div.horloge-ajustement.heure-05 {
-      top: calc(50% - 0.4rem + sin(-60deg) * 28%);
-      left: calc(50% - 0.4rem + cos(-60deg) * 28%);
-    }
-    div.horloge-ajustement.heure-06 {
-      top: calc(50% - 0.4rem + sin(-30deg) * 28%);
-      left: calc(50% - 0.4rem + cos(-30deg) * 28%);
-    }
-    div.horloge-ajustement.heure-07 {
-      top: calc(50% - 0.4rem + sin(0deg) * 28%);
-      left: calc(50% - 0.4rem + cos(0deg) * 28%);
-    }
-    div.horloge-ajustement.heure-08 {
-      top: calc(50% - 0.4rem + sin(30deg) * 28%);
-      left: calc(50% - 0.4rem + cos(30deg) * 28%);
-    }
-    div.horloge-ajustement.heure-09 {
-      top: calc(50% - 0.4rem + sin(60deg) * 28%);
-      left: calc(50% - 0.4rem + cos(60deg) * 28%);
-    }
-    div.horloge-ajustement.heure-10 {
-      top: calc(50% - 0.4rem + sin(90deg) * 28%);
-      left: calc(50% - 0.4rem + cos(90deg) * 28%);
-    }
-    div.horloge-ajustement.heure-11 {
-      top: calc(50% - 0.4rem + sin(120deg) * 28%);
-      left: calc(50% - 0.4rem + cos(120deg) * 28%);
-    }
-    div.horloge-ajustement.heure-12 {
-      top: calc(50% - 0.4rem + sin(150deg) * 28%);
-      left: calc(50% - 0.4rem + cos(150deg) * 28%);
-    }
-  }
-
   .calendar-boutons-heure {
     .calendar-btn:is(.calendar-lyre, .calendar-vaisseau) img {
       color: hsla(0, 0%, 100%, 0.5);

module/achat-vente/chat-vente.js

@@ -40,17 +40,21 @@ export class ChatVente {
 
   static async diminuerQuantiteAchatVente(chatMessageId, quantite) {
     const chatMessage = game.messages.get(chatMessageId)
-    const vente = ChatVente.getDetailVente(chatMessageId)
-    vente.nbLots = Math.max(0, vente.nbLots - quantite)
-    await chatMessage.setFlag(SYSTEM_RDD, NB_LOTS, vente.nbLots)
 
-    const html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-vente-item.hbs', vente);
-    chatMessage.update({ content: html });
-    chatMessage.render(true);
+    const vente = ChatVente.getDetailVente(chatMessageId)
+    if (vente.nbLots <= quantite) {
+      ChatUtility.removeChatMessageId(chatMessageIdVente);
+    }
+    else {
+      vente.nbLots = vente.nbLots - quantite
+      await chatMessage.setFlag(SYSTEM_RDD, NB_LOTS, vente.nbLots)
+      const html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-vente-item.hbs', vente)
+      await chatMessage.update({ content: html }, { render: true })
+    }
   }
 
   static async displayAchatVente(vente) {
-    const html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-vente-item.hbs', vente);
+    const html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-vente-item.hbs', vente)
     const chatMessage = await ChatMessage.create(RdDUtility.chatDataSetup(html))
     await chatMessage.setFlag(SYSTEM_RDD, NB_LOTS, vente.nbLots)
     await chatMessage.setFlag(SYSTEM_RDD, DETAIL_VENTE, {

module/actor-sheet.js

@@ -19,6 +19,7 @@ import { RdDCoeur } from "./coeur/rdd-coeur.js";
 import { AppPersonnageAleatoire } from "./actor/random/app-personnage-aleatoire.js";
 import { RdDTextEditor } from "./apps/rdd-text-roll-editor.js";
 import { MORAL } from "./moral/apprecier.mjs";
+import { RdDItemSort } from "./item-sort.js";
 
 /* -------------------------------------------- */
 /**
@@ -50,8 +51,9 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
     foundry.utils.mergeObject(formData.calc, {
       surenc: this.actor.computeMalusSurEncombrement(),
       surprise: RdDBonus.find(this.actor.getSurprise(false)).label,
-      resumeBlessures: this.actor.computeResumeBlessure(this.actor.system.blessures),
+      blessures: this.actor.computeResumeBlessure(this.actor.system.blessures),
       caracTotal: RdDCarac.computeTotal(this.actor.system.carac, this.actor.system.beaute),
+      caracTotalXp: RdDCarac.computeTotalXp(this.actor.system.carac, this.actor.system.beaute),
       surEncombrementMessage: this.actor.isSurenc() ? "Sur-Encombrement!" : "",
       malusArmure: this.actor.getMalusArmure()
     })
@@ -61,9 +63,13 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
     if (formData.type == ACTOR_TYPES.personnage) {
       formData.options.mainsDirectrices = MAINS_DIRECTRICES;
       formData.byCateg = Misc.classify(formData.competences, it => it.system.categorie)
-      formData.calc.comptageArchetype = RdDItemCompetence.computeResumeArchetype(formData.competences);
-      formData.calc.competenceXPTotal = RdDItemCompetence.computeTotalXP(formData.competences);
-      formData.calc.fatigue = RdDUtility.calculFatigueHtml(formData.system.sante.fatigue.value, formData.system.sante.endurance.max);
+      foundry.utils.mergeObject(formData.calc, {
+        comptageArchetype: RdDItemCompetence.computeResumeArchetype(formData.competences),
+        competenceXPTotal: RdDItemCompetence.computeTotalXP(formData.competences),
+        sortsXPTotal: RdDItemSort.computeTotalXP(this.actor.itemTypes[ITEM_TYPES.sort]),
+        fatigue: RdDUtility.calculFatigueHtml(formData.system.sante.fatigue.value, formData.system.sante.endurance.max)
+
+      })
 
       formData.competences.forEach(item => {
         item.system.isHidden = this.options.recherche
@@ -273,7 +279,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
 
     // On pts de reve change
     this.html.find('.pointsreve-value').change(async event => await this.actor.update({ "system.reve.reve.value": event.currentTarget.value }))
-    this.html.find('.seuil-reve-value').change(async event => await this.actor.setPointsDeSeuil(event.currentTarget.value))
+    this.html.find('.seuil-reve-value').change(async event => await this.actor.update({ "system.reve.seuil.value": event.currentTarget.value }))
 
     this.html.find('.stress-test').click(async event => await this.actor.transformerStress())
     this.html.find('.moral-malheureux').click(async event => await this.actor.jetDeMoral(MORAL.MALHEUREUX))

module/actor/base-actor-reve.js

@@ -26,7 +26,7 @@ import { BASE_CORPS_A_CORPS, BASE_ESQUIVE, CATEGORIES_COMPETENCES_CREATURES } fr
 import { RollDataAjustements } from "../rolldata-ajustements-v1.js";
 import { MappingCreatureArme } from "../item/mapping-creature-arme.mjs";
 import RollDialog from "../roll/roll-dialog.mjs";
-import { ATTAQUE_ROLL_TYPES, DEFAULT_ROLL_TYPES, DIFF, ROLL_TYPE_ATTAQUE} from "../roll/roll-constants.mjs";
+import { DEFAULT_ROLL_TYPES, DIFF, ROLL_TYPE_ATTAQUE } from "../roll/roll-constants.mjs";
 import { OptionsAvancees, ROLL_DIALOG_V2 } from "../settings/options-avancees.js";
 import { PART_COMP } from "../roll/roll-part-comp.mjs";
 import { RdDInitiative } from "../initiative.mjs";
@@ -48,39 +48,24 @@ export class RdDBaseActorReve extends RdDBaseActor {
   }
 
   getCarac() {
-    return foundry.utils.mergeObject(this.system.carac,
-      {
-        'reve-actuel': this.getCaracReveActuel(),
-        'chance-actuelle': this.getCaracChanceActuelle()
-      },
-      { inplace: false })
-  }
-
-  getCaracChanceActuelle() {
-    return {
-      label: 'Chance actuelle',
-      value: this.getChanceActuel(),
-      type: "number"
-    };
-  }
-
-  getCaracReveActuel() {
-    return {
-      label: 'Rêve actuel',
-      value: this.getReveActuel(),
-      type: "number"
-    };
+    const carac = super.getCarac()
+    foundry.utils.mergeObject(carac, this.getCaracReveActuel())
+    foundry.utils.mergeObject(carac, this.getCaracCompetenceCreature(), { overwrite: false })
+    return carac
   }
 
   getTaille() { return Misc.toInt(this.system.carac.taille?.value) }
   getConstitution() { return this.getReve() }
+
   getForce() { return this.getReve() }
   getAgilite() { return this.getForce() }
   getReve() { return Misc.toInt(this.system.carac.reve?.value) }
   getChance() { return this.getReve() }
+  getChanceActuel() { return this.getChance() }
+  getCaracChanceActuelle() { return { [CARACS.CHANCE_ACTUELLE]: { label: 'Chance actuelle', value: this.getChanceActuel(), type: "number" } } }
 
   getReveActuel() { return this.getReve() }
-  getChanceActuel() { return this.getChance() }
+  getCaracReveActuel() { return { [CARACS.REVE_ACTUEL]: { label: "Rêve Actuel", value: this.getReveActuel(), type: "number" } } }
 
   getEnduranceMax() { return Math.max(1, this.getTaille() + this.getConstitution()) }
   getEncombrementMax() { return (this.getForce() + this.getTaille()) / 2 }
@@ -169,11 +154,11 @@ export class RdDBaseActorReve extends RdDBaseActor {
 
   async computeArmure(dmg) { return this.getProtectionNaturelle() }
   async remiseANeuf() { }
-  async appliquerAjoutExperience(rollData, hideChatMessage = 'show') { }
+  async ajoutExperience(rollData, hideChatMessage = 'show') { }
 
-  computeResumeBlessure() { }
+  computeResumeBlessure() { return []}
   countBlessures(filter = it => !it.isContusion()) { return 0 }
-  async santeIncDec(name, inc, isCritique = false) { }
+  async santeIncDec(name, inc, isCritique) { }
 
   async finDeRound(options = { terminer: false }) {
     await this.finDeRoundSuppressionEffetsTermines(options)
@@ -208,7 +193,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
       .map(async it => await RdDEmpoignade.onImmobilisation(this, it)))
   }
 
-  async finDeRoundPossession(){
+  async finDeRoundPossession() {
     await Promise.all(this.itemTypes[ITEM_TYPES.possession]
       .map(async it => await RdDPossessionV2.onPossession(this, it)))
   }
@@ -257,21 +242,28 @@ export class RdDBaseActorReve extends RdDBaseActor {
     return this.itemTypes[ITEM_TYPES.empoignade];
   }
 
+  async updateCarac(caracName, to) {
+    const path = `system.carac.${caracName}.value`;
+    let updates = {};
+    updates[path] = Number.parseInt(to)
+    await this.update(updates, { noHook: true });
+  }
+
   /* -------------------------------------------- */
   async updateCreatureCompetence(idOrName, fieldName, value) {
     let competence = this.getCompetence(idOrName);
     if (competence) {
       function getFieldPath(fieldName) {
         switch (fieldName) {
-          case "niveau": return 'system.niveau';
-          case "dommages": return 'system.dommages';
-          case "carac_value": return 'system.carac_value';
+          case "niveau": return 'system.niveau'
+          case "dommages": return 'system.dommages'
+          case "carac_value": return 'system.carac_value'
         }
         return undefined
       }
-      const path = getFieldPath(fieldName);
+      const path = getFieldPath(fieldName)
       if (path) {
-        await competence.update({ [path]: value });
+        await competence.update({ [path]: value })
       }
     }
   }
@@ -303,7 +295,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
 
   /* -------------------------------------------- */
   createCallbackExperience() {
-    return { action: r => this.appliquerAjoutExperience(r) }
+    return { action: r => this.ajoutExperience(r) }
   }
 
   /* -------------------------------------------- */
@@ -312,7 +304,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
     return { action: r => this.appliquerAppelMoral(r) }
   }
 
-  async appliquerAjoutExperience(rollData, hideChatMessage = 'show') { }
+  async ajoutExperience(rollData, hideChatMessage = 'show') { }
   async appliquerAppelMoral(rollData) { }
 
   async _onCloseRollDialog(html) { }
@@ -348,7 +340,10 @@ export class RdDBaseActorReve extends RdDBaseActor {
         competence: competence,
         show: { title: options?.title ?? '' }
       },
-      callbacks: [async r => this.$onRollCompetence(r, options)]
+      callbacks: [
+        async r => this.$onRollCompetence(r, options),
+        ...(options?.callbacks ?? [])
+      ]
     });
   }
   /**
@@ -376,13 +371,11 @@ export class RdDBaseActorReve extends RdDBaseActor {
     }
     RollDataAjustements.calcul(rollData, this);
     await RdDResolutionTable.rollData(rollData);
-    this.gererExperience(rollData);
+    this.ajoutExperience(rollData);
     await RdDResolutionTable.displayRollData(rollData, this)
     return rollData.rolled;
   }
 
-  gererExperience(rollData) { }
-
   /* -------------------------------------------- */
   async roll() {
     if (OptionsAvancees.isUsing(ROLL_DIALOG_V2)) {
@@ -487,17 +480,15 @@ export class RdDBaseActorReve extends RdDBaseActor {
 
   async rollCompetence(idOrName, options = { tryTarget: true, arme: undefined }) {
     RdDEmpoignade.checkEmpoignadeEnCours(this)
-
     const competence = this.getCompetence(idOrName);
     if (OptionsAvancees.isUsing(ROLL_DIALOG_V2)) {
       const rollData = {
         ids: { actorId: this.id },
-        type: { allowed: options.arme ? ATTAQUE_ROLL_TYPES : DEFAULT_ROLL_TYPES },
+        type: { allowed: DEFAULT_ROLL_TYPES },
         selected: {
           carac: competence.type == ITEM_TYPES.competencecreature ? { key: competence.name } : undefined,
           comp: { key: competence.name },
-          diff: { type: options.arme ? DIFF.ATTAQUE : DIFF.LIBRE, value: competence.system.default_diffLibre ?? 0 },
-          attaque: options.arme ? { arme: { key: options.arme.id } } : undefined
+          diff: { type: DIFF.LIBRE, value: competence.system.default_diffLibre ?? 0 },
         }
       }
       return await RollDialog.create(rollData)
@@ -569,7 +560,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
             type: {
               allowed: [ROLL_TYPE_ATTAQUE], current: ROLL_TYPE_ATTAQUE
             }
-          };
+          }
           return await RollDialog.create(rollData, { onRollDone: RollDialog.onRollDoneClose })
         }
       })
@@ -578,16 +569,18 @@ export class RdDBaseActorReve extends RdDBaseActor {
 
   /** --------------------------------------------
    * @param {*} arme item d'arme/compétence de créature
-   * @param {*} categorieArme catégorie d'attaque à utiliser: competence (== melee), lancer, tir; naturelle, possession
+   * @param {*} maniement catégorie d'attaque à utiliser: competence (== melee), lancer, tir; naturelle, possession
    * @returns
    */
-  rollArme(arme, categorieArme = 'competence', token = undefined) {
+  async rollArme(arme, maniement = 'competence', token = undefined) {
     token = token ?? RdDUtility.getSelectedToken(this)
-    const compToUse = RdDItemArme.getCompetenceArme(arme, categorieArme)
+    const compToUse = RdDItemArme.getCompetenceArme(arme, maniement)
+
     if (!RdDItemArme.isUtilisable(arme)) {
       ui.notifications.warn(`Arme inutilisable: ${arme.name} non équipée ou avec une résistance de 0 ou moins`)
       return
     }
+
     if (!Targets.hasTargets()) {
       RdDConfirm.confirmer({
         settingConfirmer: "confirmer-combat-sans-cible",
@@ -599,7 +592,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
         onAction: async () => {
           this.rollCompetence(compToUse, { tryTarget: false, arme: arme })
         }
-      });
+      })
       return
     }
 
@@ -609,11 +602,12 @@ export class RdDBaseActorReve extends RdDBaseActor {
         return
       }
 
-      const competence = this.getCompetence(compToUse)
-      if (competence.isCompetencePossession()) {
-        return RdDPossession.onAttaquePossession(target, this, competence);
+      const comp = this.getCompetence(compToUse)
+      if (comp.isCompetencePossession()) {
+        // TODO: vérifier si c'est possible, sinon simplifier
+        return RdDPossession.onAttaquePossession(target, this, comp);
       }
-      RdDCombat.rddCombatTarget(target, this, token).attaque(competence, arme);
+      RdDCombat.rddCombatTarget(target, this, token).attaque(comp, arme, maniement)
     })
   }
 
@@ -660,28 +654,23 @@ export class RdDBaseActorReve extends RdDBaseActor {
         jet => this.$onEncaissement(jet, show, attackerToken, defenderToken));
     }
   }
-
-  async $onEncaissement(jet, show, attackerToken, defenderToken) {
-    await this.onAppliquerJetEncaissement(jet, attackerToken);
-    await this.$afficherEncaissement(jet, show, defenderToken);
-  }
-
   async onAppliquerJetEncaissement(encaissement, attackerToken) { }
 
-  async $afficherEncaissement(encaissement, show, defenderToken) {
+  async $onEncaissement(encaissement, show, attackerToken, defenderToken) {
+    await this.onAppliquerJetEncaissement(encaissement, attackerToken);
+
     foundry.utils.mergeObject(encaissement, {
       alias: defenderToken?.name ?? this.getAlias(),
       hasPlayerOwner: this.hasPlayerOwner,
       show: show ?? {}
     }, { overwrite: false });
 
-    await ChatUtility.createChatWithRollMode(
+    await ChatMessage.create(ChatUtility.adaptVisibility(
       {
         roll: encaissement.roll,
         content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-resultat-encaissement.hbs', encaissement)
       },
-      this
-    )
+      { actor: this }))
 
     if (!encaissement.hasPlayerOwner && encaissement.endurance != 0) {
       encaissement = foundry.utils.duplicate(encaissement)
@@ -736,7 +725,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
     }
 
     await RdDRollResult.displayRollData(rollData, this, 'chat-resultat-accorder-cauchemar.hbs')
-    await this.appliquerAjoutExperience(rollData, true)
+    await this.ajoutExperience(rollData, true)
     return rolled.isSuccess;
   }
 

module/actor/base-actor-sang.js

@@ -7,6 +7,8 @@ import { RdDDice } from "../rdd-dice.js";
 import { RdDItemBlessure } from "../item/blessure.js";
 import { ChatUtility } from "../chat-utility.js";
 import { Misc } from "../misc.js";
+import { RdDBaseActor } from "./base-actor.js";
+import { CARACS } from "../rdd-carac.js";
 
 /**
  * Classe de base pour les acteurs qui peuvent subir des blessures
@@ -15,6 +17,14 @@ import { Misc } from "../misc.js";
  */
 export class RdDBaseActorSang extends RdDBaseActorReve {
 
+
+  async _preUpdate(changed, options, user) {
+    const updatedEndurance = changed?.system?.sante?.endurance
+    if (updatedEndurance && options.diff) {
+      await this.setEffect(STATUSES.StatusUnconscious, updatedEndurance.value == 0)
+    }
+  }
+
   prepareActorData() {
     this.system.sante.vie.max = Math.ceil((this.getTaille() + this.getConstitution()) / 2)
     this.system.sante.vie.value = Math.min(this.system.sante.vie.value, this.system.sante.vie.max)
@@ -22,10 +32,18 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
     this.system.attributs.encombrement.value = this.getEncombrementMax()
   }
 
+  getCarac() {
+    const carac = super.getCarac()
+    foundry.utils.mergeObject(carac, this.getCaracChanceActuelle())
+    foundry.utils.mergeObject(carac, this.getCaracVie())
+    return carac
+  }
+
   getForce() { return Misc.toInt(this.system.carac.force?.value) }
   getConstitution() { return Misc.toInt(this.system.carac.constitution?.value) }
   getVolonte() { return Misc.toInt(this.system.carac.volonte?.value) }
 
+  getCaracVie() { return { [CARACS.VIE]: { label: "Vie", value: this.getVieMax(), type: "number" } } }
   getVieMax() { return Misc.toInt(this.system.sante.vie?.max) }
   getEnduranceMax() { return Math.max(1, this.getTaille() + this.getConstitution()) }
   getFatigueMax() { return this.getEnduranceMax() * 2 }
@@ -61,51 +79,64 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
     return Math.min(0, Math.floor(this.getEncombrementMax() - this.encTotal));
   }
 
+  countBlessures(filter) { return this.itemTypes[ITEM_TYPES.blessure].filter(filter).length }
   isDead() { return this.system.sante.vie.value < -this.getSConst() }
 
-  nbBlessuresLegeres() { return this.itemTypes[ITEM_TYPES.blessure].filter(it => it.isLegere()).length }
-  nbBlessuresGraves() { return this.itemTypes[ITEM_TYPES.blessure].filter(it => it.isGrave()).length }
-  nbBlessuresCritiques() { return this.itemTypes[ITEM_TYPES.blessure].filter(it => it.isCritique()).length }
-
   /* -------------------------------------------- */
   computeResumeBlessure() {
-    const nbLegeres = this.nbBlessuresLegeres()
-    const nbGraves = this.nbBlessuresGraves()
-    const nbCritiques = this.nbBlessuresCritiques()
+    function descBlessure(count, name) {
+      return count > 0 ? [`${count} ${name}${count > 1 ? "s" : ""}`] : []
+    }
 
-    if (nbLegeres + nbGraves + nbCritiques == 0) {
-      return "Aucune blessure";
-    }
-    let resume = "Blessures:";
-    if (nbLegeres > 0) {
-      resume += " " + nbLegeres + " légère" + (nbLegeres > 1 ? "s" : "");
-    }
-    if (nbGraves > 0) {
-      if (nbLegeres > 0)
-        resume += ",";
-      resume += " " + nbGraves + " grave" + (nbGraves > 1 ? "s" : "");
-    }
-    if (nbCritiques > 0) {
-      if (nbGraves > 0 || nbLegeres > 0)
-        resume += ",";
-      resume += " une CRITIQUE !";
-    }
-    return resume;
+    const nbContusions = this.countBlessures(it => it.isContusion())
+    const nbLegeres = this.countBlessures(it => it.isLegere())
+    const nbGraves = this.countBlessures(it => it.isGrave())
+    const nbCritiques = this.countBlessures(it => it.isCritique())
+    return [
+      ... (nbCritiques > 0 ? ['une CRITIQUE !'] : []),
+      ...descBlessure(nbGraves, 'grave'),
+      ...descBlessure(nbLegeres, 'légère'),
+      ...descBlessure(nbContusions, 'contusion'),
+    ]
   }
 
   blessuresASoigner() { return [] }
 
   async computeArmure(attackerRoll) { return this.getProtectionNaturelle() }
   async remiseANeuf() { }
-  async appliquerAjoutExperience(rollData, hideChatMessage = 'show') { }
+  async ajoutExperience(rollData, hideChatMessage = 'show') { }
 
   /* -------------------------------------------- */
 
   async onAppliquerJetEncaissement(encaissement, attackerToken) {
     const santeOrig = foundry.utils.duplicate(this.system.sante);
-    const blessure = await this.ajouterBlessure(encaissement, attackerToken); // Will update the result table
-    const perteVie = await this.santeIncDec("vie", -encaissement.vie);
-    const perteEndurance = await this.santeIncDec("endurance", -encaissement.endurance, blessure?.isCritique());
+    const blessure = this.nouvelleBlessure(encaissement.gravite, {
+      localisation: encaissement.dmg?.loc.label ?? '',
+      origine: attackerToken?.name ?? ''
+    })
+    if (blessure.system.gravite == encaissement.gravite) {
+      blessure.system.vie = encaissement.vie
+      blessure.system.endurance = encaissement.endurance
+    }
+    else { // aggravation du fait du nombre de blessures
+      blessure.system.vie = blessure.system.vie
+      const rollPerteEndurance = new Roll(blessure.system.endurance)
+      await rollPerteEndurance.evaluate()
+      blessure.system.endurance = rollPerteEndurance.total
+    }
+    const isCritique = blessure.system.gravite >= 6;
+    if (isCritique) {
+      blessure.system.endurance = this.getEnduranceActuelle()
+    }
+    // Will update the result table
+    if (blessure.system.gravite > 6) {
+      this.setEffect(STATUSES.StatusComma, true)
+      encaissement.mort = "à seconde blessure critique"
+    }
+
+    const perteVie = await this.santeIncDec("vie", -encaissement.vie)
+    const perteEndurance = await this.santeIncDec("endurance", -encaissement.endurance, isCritique)
+    await this.createEmbeddedDocuments('Item', [blessure])
 
     foundry.utils.mergeObject(encaissement, {
       resteEndurance: perteEndurance.newValue,
@@ -114,32 +145,31 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
       endurance: perteEndurance.perte,
       vie: santeOrig.vie.value - perteVie.newValue,
       blessure: blessure
-    });
+    })
   }
 
   /* -------------------------------------------- */
   async santeIncDec(name, inc, isCritique = false) {
     if (name == 'fatigue' && !ReglesOptionnelles.isUsing("appliquer-fatigue")) {
-      return;
+      return
+    }
+    if (!this.system.sante[name]) {
+      return
     }
     const sante = foundry.utils.duplicate(this.system.sante)
-    let compteur = sante[name];
-    if (!compteur) {
-      return;
-    }
-    let result = {
-      sonne: false,
-    };
+    const compteur = sante[name]
+    const result = { sonne: false }
     let perteEndurance = 0
     let minValue = name == "vie" ? -this.getSConst() - 1 : 0;
 
     result.newValue = Math.max(minValue, Math.min(compteur.value + inc, compteur.max));
-    //console.log("New value ", inc, minValue, result.newValue);
     let fatigue = 0;
+
     if (name == "endurance") {
-      if (result.newValue == 0 && inc < 0 && !isCritique) { // perte endurance et endurance devient 0 (sauf critique) -> -1 vie
-        sante.vie.value--;
-        result.perteVie = true;
+      if (result.newValue == 0 && inc < 0 && !isCritique) {
+        // perte endurance et endurance devient 0 (sauf critique) -> -1 vie
+        sante.vie.value--
+        result.perteVie = true
       }
       result.newValue = Math.max(0, result.newValue);
       if (inc > 0) { // le max d'endurance s'applique seulement à la récupération
@@ -156,21 +186,87 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
     if (ReglesOptionnelles.isUsing("appliquer-fatigue") && sante.fatigue && fatigue > 0) {
       sante.fatigue.value = Math.max(sante.fatigue.value + fatigue, this.getFatigueMin());
     }
-    await this.update({ "system.sante": sante }, { render: true })
+    await this.update({ "system.sante": sante })
 
     if (perteEndurance > 1) {
       // Peut-être sonné si 2 points d'endurance perdus d'un coup
       foundry.utils.mergeObject(result, await this.jetEndurance(result.newValue));
     } else if (name == "endurance" && inc > 0) {
-      await this.setSonne(false);
+      await this.setSonne(false)
     }
 
     if (this.isDead()) {
-      await this.setEffect(STATUSES.StatusComma, true);
+      await this.setEffect(STATUSES.StatusComma, true)
     }
     return result
   }
 
+  async callbackPremiersSoins(blessureId, rollData, soigneurId) {
+    await this.onRollTachePremiersSoins(blessureId,
+      rollData.v2 ? rollData.current.tache.tache : rollData.tache,
+      rollData.rolled.isETotal,
+      soigneurId)
+  }
+  async onRollTachePremiersSoins(blessureId, tache, isETotal, soigneurId) {
+    if (!this.isOwner) {
+      return RdDBaseActor.remoteActorCall({
+        tokenId: this.token?.id,
+        actorId: this.id,
+        method: 'onRollTachePremiersSoins', args: [blessureId, tache, isETotal, soigneurId]
+      })
+    }
+
+    const blessure = this.getItem(blessureId, 'blessure')
+    if (blessure && !blessure.system.premierssoins.done) {
+      if (isETotal) {
+        await blessure.update({
+          'system.difficulte': blessure.system.difficulte - 1,
+          'system.premierssoins.tache': Math.max(0, tache.system.points_de_tache_courant)
+        })
+      }
+      else {
+        const bonus = tache.system.points_de_tache_courant - tache.system.points_de_tache
+        await blessure.update({
+          'system.premierssoins': {
+            done: (bonus >= 0),
+            bonus: Math.max(0, bonus),
+            tache: Math.max(0, tache.system.points_de_tache_courant)
+          }
+        })
+        if (bonus >= 0 && soigneurId) {
+          const soigneur = game.actors.get(soigneurId)
+          await soigneur.deleteEmbeddedDocuments('Item', [tache.id], { render: true })
+        }
+      }
+    }
+  }
+
+  async onRollSoinsComplets(blessureId, rollData) {
+    if (!this.isOwner) {
+      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) {
+      // TODO: update de la blessure: passer par le MJ!
+      if (rollData.rolled.isETotal) {
+        await blessure.setSoinsBlessure({
+          difficulte: blessure.system.difficulte - 1,
+          premierssoins: { done: false, bonus: 0 }, soinscomplets: { done: false, bonus: 0 },
+        })
+      }
+      else {
+        // soins complets finis
+        await blessure.setSoinsBlessure({
+          soinscomplets: { done: true, bonus: Math.max(0, rollData.rolled.ptTache) },
+        })
+      }
+    }
+  }
+
   /* -------------------------------------------- */
   _computeEnduranceMax() {
     const diffVie = this.system.sante.vie.max - this.system.sante.vie.value;
@@ -187,9 +283,9 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
     await super.onCreateItem(item, options, id)
   }
 
-  async onUpdateItem(item, options, id) {
+  async onUpdateItem(item, updates, options, id) {
     await this.changeItemEffects(item);
-    await super.onUpdateItem(item, options, id)
+    await super.onUpdateItem(item, updates, options, id)
   }
 
   async onDeleteItem(item, options, id) {
@@ -200,12 +296,12 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
   async changeItemEffects(item) {
     switch (item.type) {
       case ITEM_TYPES.blessure:
-        await this.changeStateBleeding();
+        await this.changeStateBleeding()
         break;
       case ITEM_TYPES.maladie:
       case ITEM_TYPES.poison:
-        await this.changeStateMalade();
-        break;
+        await this.changeStateMalade()
+        break
     }
   }
 
@@ -224,32 +320,15 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
   }
 
   /* -------------------------------------------- */
-  async ajouterBlessure(encaissement, attackerToken = undefined) {
-    if (encaissement.gravite < 0) return;
-    if (encaissement.gravite > 0) {
-      while (this.countBlessures(it => it.system.gravite == encaissement.gravite) >= RdDItemBlessure.maxBlessures(encaissement.gravite) && encaissement.gravite <= 6) {
+  nouvelleBlessure(gravite, options = { origine: undefined, localisation: '' }) {
+    if (gravite < 0) return
+    if (gravite > 0) {
+      while (this.countBlessures(it => it.system.gravite == gravite) >= RdDItemBlessure.maxBlessures(gravite) && gravite <= 6) {
         // Aggravation
-        encaissement.gravite += 2
-        if (encaissement.gravite > 2) {
-          encaissement.vie += 2;
-        }
+        gravite += 2
       }
     }
-    const endActuelle = this.getEnduranceActuelle();
-    const blessure = await RdDItemBlessure.createBlessure(this, encaissement.gravite, encaissement.dmg?.loc.label ?? '', attackerToken);
-    if (blessure.isCritique()) {
-      encaissement.endurance = endActuelle
-    }
-
-    if (blessure.isMort()) {
-      this.setEffect(STATUSES.StatusComma, true);
-      encaissement.mort = true;
-      ChatMessage.create({
-        content: `<img class="chat-icon" src="icons/svg/skull.svg" data-tooltip="charge" />
-        <strong>${this.getAlias()} vient de succomber à une seconde blessure critique ! Que les Dragons gardent son Archétype en paix !</strong>`
-      });
-    }
-    return blessure;
+    return RdDItemBlessure.prepareBlessure(gravite, options);
   }
 
   async supprimerBlessure({ gravite }) {
@@ -261,8 +340,8 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
 
   async supprimerBlessures(filterToDelete) {
     const toDelete = this.filterItems(filterToDelete, ITEM_TYPES.blessure)
-      .map(it => it.id);
-    await this.deleteEmbeddedDocuments('Item', toDelete);
+      .map(it => it.id)
+    await this.deleteEmbeddedDocuments('Item', toDelete)
   }
 
   countBlessures(filter = it => !it.isContusion()) {
@@ -279,12 +358,11 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
       return
     }
     const jetDeVie = await RdDDice.roll("1d20");
-
     const sConst = this.getSConst();
     const vie = this.system.sante.vie.value;
-    const isCritique = this.nbBlessuresCritiques() > 0;
-    const isGrave = this.nbBlessuresGraves();
-    const isEchecTotal = jetDeVie.total == 20;
+    const isCritique = this.countBlessures(it => it.isCritique()) > 0
+    const isGrave = this.countBlessures(it => it.isGrave())
+    const isEchecTotal = jetDeVie.total == 20
     const isSuccess = jetDeVie.total == 1 || jetDeVie.total <= vie;
     const perte = isSuccess ? 0 : 1 + (isEchecTotal ? vie + sConst : 0)
     const prochainJet = (jetDeVie.total == 1 && vie > 0 ? 20 : 1) * (isCritique ? 1 : isGrave > 0 ? sConst : 0)
@@ -305,7 +383,7 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
     ChatMessage.create({
       content: msgText,
       whisper: ChatUtility.getOwners(this)
-    });
+    })
   }
 
   /* -------------------------------------------- */
@@ -313,13 +391,14 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
     const jetEndurance = (await RdDDice.roll("1d20")).total;
     const sonne = jetEndurance == 20 || jetEndurance > (resteEndurance ?? this.system.sante.endurance.value)
     if (sonne) {
-      await this.setSonne();
+      await this.setSonne(true)
     }
     return { jetEndurance, sonne }
   }
 
   async finDeRoundBlessures() {
-    const nbGraves = this.filterItems(it => it.isGrave(), 'blessure').length;
+    const nbGraves = this.itemTypes[ITEM_TYPES.blessure]
+      .filter(it => it.isGrave() && !it.system.premierssoins.done).length;
     if (nbGraves > 0) {
       // Gestion blessure graves : -1 pt endurance par blessure grave
       await this.santeIncDec("endurance", -nbGraves);
@@ -328,8 +407,9 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
 
   async setSonne(sonne = true) {
     if (!game.combat && sonne) {
+      // TODO: vérifier si comportement toujours valable
       ui.notifications.info(`${this.getAlias()} est hors combat, il ne reste donc pas sonné`);
-      return;
+      return
     }
     await this.setEffect(STATUSES.StatusStunned, sonne)
   }

module/actor/base-actor.js

@@ -12,6 +12,7 @@ import { SystemCompendiums } from "../settings/system-compendiums.js";
 import { RdDItem } from "../item.js";
 import { StatusEffects, STATUSES } from "../settings/status-effects.js";
 import { Apprecier } from "../moral/apprecier.mjs";
+import { CARACS } from "../rdd-carac.js";
 
 export class RdDBaseActor extends Actor {
 
@@ -23,7 +24,7 @@ export class RdDBaseActor extends Actor {
   }
 
   static $findCaracByName(carac, name) {
-    const caracList = Object.entries(carac);
+    const caracList = Object.entries(carac)
     let entry = Misc.findFirstLike(name, caracList, { mapper: it => it[0], description: 'caractéristique', onMessage: m => { } });
     if (!entry || entry.length == 0) {
       entry = Misc.findFirstLike(name, caracList, { mapper: it => it[1].label, description: 'caractéristique' });
@@ -48,11 +49,9 @@ export class RdDBaseActor extends Actor {
 
   static init() {
     Handlebars.registerHelper('actor-isFeminin', actor => actor.isFeminin())
-    Hooks.on("preUpdateItem", (item, change, options, id) => Misc.documentIfResponsible(item.parent)?.onPreUpdateItem(item, change, options, id))
     Hooks.on("createItem", (item, options, id) => Misc.documentIfResponsible(item.parent)?.onCreateItem(item, options, id))
-    Hooks.on("updateItem", (item, options, id) => Misc.documentIfResponsible(item.parent)?.onUpdateItem(item, options, id))
+    Hooks.on("updateItem", (item, updates, options, id) => Misc.documentIfResponsible(item.parent)?.onUpdateItem(item, updates, options, id))
     Hooks.on("deleteItem", (item, options, id) => Misc.documentIfResponsible(item.parent)?.onDeleteItem(item, options, id))
-    Hooks.on("updateActor", (actor, change, options, actorId) => Misc.documentIfResponsible(actor)?.onUpdateActor(change, options, actorId))
   }
 
   static onSocketMessage(sockmsg) {
@@ -62,14 +61,14 @@ export class RdDBaseActor extends Actor {
     }
   }
 
-  static remoteActorCall(callData) {
+  static remoteActorCall(callData, userId = undefined) {
     if (game.user.isGM) {
       RdDBaseActor.onRemoteActorCall(callData, game.user.id)
       return false
     }
     else {
       const gmUserId = Misc.firstConnectedGMId()
-      if (gmUserId){
+      if (gmUserId) {
         game.socket.emit(SYSTEM_SOCKET_ID, {
           msg: "msg_remote_actor_call",
           data: callData,
@@ -92,25 +91,11 @@ export class RdDBaseActor extends Actor {
   }
 
   static getRealActor(actorId, tokenId) {
-    if (tokenId) {
-      let token = canvas.tokens.get(tokenId)
-      if (token) {
-        return token.actor
-      }
-    }
-    return game.actors.get(actorId)
+    const actor = tokenId ? canvas.tokens.get(tokenId)?.actor : undefined
+    return actor ?? game.actors.get(actorId)
   }
 
-  getAlias() {
-    if (this.token?.name != null && this.token != this.prototypeToken) {
-      return this.token.name
-    }
-    return this.name
-  }
-
-  isPersonnageJoueur() { return false }
-
-  static extractActorMin = (actor) => { return { id: actor?.id, type: actor?.type, name: actor?.name, img: actor?.img }; };
+  static extractActorMin(actor) { return { id: actor?.id, type: actor?.type, name: actor?.name, img: actor?.img } }
 
   /**
    * Cette methode surcharge Actor.create() pour ajouter si besoin des Items par défaut:
@@ -155,30 +140,56 @@ export class RdDBaseActor extends Actor {
     super(docData, context);
   }
 
+  getAlias() {
+    if (this.token?.name != null && this.token != this.prototypeToken) {
+      return this.token.name
+    }
+    return this.name
+  }
+
+  isPersonnageJoueur() { return false }
+
+  getCarac() {
+    return foundry.utils.duplicate(this.system.carac)
+  }
+
   findCaracByName(name) {
     name = Grammar.toLowerCaseNoAccent(name)
     switch (name) {
-      case 'reve-actuel': case 'reve actuel':
-        return this.system.carac.reve
-      case 'chance-actuelle': case 'chance actuelle':
-        return this.system.carac.chance
-      case 'vie':
-        return this.system.sante.vie
+      case 'reve actuel':
+        name = CARACS.REVE_ACTUEL
+        break
+      case 'chance actuelle':
+        name = CARACS.CHANCE_ACTUELLE
+        break
     }
-
-    const carac = this.system.carac;
+    const carac = this.getCarac()
     return RdDBaseActor.$findCaracByName(carac, name);
   }
 
+  getCaracCompetenceCreature() {
+    return this.isCreatureOuEntite()
+      ? Object.fromEntries(this.itemTypes[ITEM_TYPES.competencecreature].map(it => [Grammar.toLowerCaseNoAccent(it.name), { label: it.name, value: it.system.carac_value }]))
+      : {}
+  }
+
   mapCarac(caracCode) { return caracCode }
 
   getCaracByName(name) {
-    name = this.mapCarac(Grammar.toLowerCaseNoAccent(name))
+    name = this.mapCarac(Grammar.toLowerCaseNoAccent(name)) ?? name
     switch (name) {
-      case 'reve-actuel': case 'reve actuel':
-        return this.getCaracReveActuel();
-      case 'chance-actuelle': case 'chance-actuelle':
-        return this.getCaracChanceActuelle();
+      case 'reve actuel':
+        name = CARACS.REVE_ACTUEL
+        break
+      case 'chanceactuelle':
+        name = CARACS.CHANCE_ACTUELLE
+        break
+    }
+    switch (name) {
+      case CARACS.REVE_ACTUEL:
+        return this.getCaracReveActuel()[CARACS.REVE_ACTUEL]
+      case CARACS.CHANCE_ACTUELLE:
+        return this.getCaracChanceActuelle()[CARACS.CHANCE_ACTUELLE]
     }
     return this.findCaracByName(name);
   }
@@ -203,6 +214,41 @@ export class RdDBaseActor extends Actor {
     }
   }
 
+  async _preUpdate(changed, options, user) {
+    const updatedCarac = changed?.system?.carac
+    if (updatedCarac && (updatedCarac.force || updatedCarac.reve || updatedCarac.taille)) {
+      await this.setEffect(STATUSES.StatusSurEnc, this.isSurenc())
+    }
+    await this.delayedRenderSheet('_preUpdate', changed, options)
+    return super._preUpdate(changed, options, user)
+  }
+  
+  _onUpdate(changed, options, userId) {
+    super._onUpdate(changed, options, userId)
+    if (userId == game.user.id){
+      this.delayedRenderSheet('_onUpdate', changed, options)
+    }
+  }
+
+  async delayedRenderSheet(caller, data, options) {
+    this.refreshDelayCounter = (this.refreshDelayCounter ?? 0)+1
+    if (this.refreshDelayCounter == 1) {
+      this.renderAfterDelay(this.refreshDelayCounter)
+    }
+  }
+
+  renderAfterDelay(currentCounter) {
+    setTimeout(async () => {
+      if (currentCounter == this.refreshDelayCounter) {
+        this.sheet?.render()
+        this.refreshDelayCounter = 0
+      }
+      else {
+        this.renderAfterDelay(this.refreshDelayCounter)
+      }
+    }, 30)
+  }
+
   /* -------------------------------------------- */
   prepareData() {
     super.prepareData()
@@ -215,6 +261,7 @@ export class RdDBaseActor extends Actor {
   prepareActorData() { }
 
   async computeEtatGeneral() { }
+
   /* -------------------------------------------- */
   findPlayer() {
     return game.users.players.find(player => player.active && player.character?.id == this.id);
@@ -267,14 +314,14 @@ export class RdDBaseActor extends Actor {
     return this.getEffects().filter(it => it.statuses.has(effectId))
   }
 
-  async setEffect(effectId, status) {
+  async setEffect(effectId, status, options = { render: true }) {
     if (this.isEffectAllowed(effectId)) {
       const effects = this.getEffectsByStatus(effectId)
       if (!status && effects.length > 0) {
-        await this.deleteEmbeddedDocuments('ActiveEffect', effects.map(it => it.id), { render: true })
+        await this.deleteEmbeddedDocuments('ActiveEffect', effects.map(it => it.id), options)
       }
       if (status && effects.length == 0) {
-        await this.createEmbeddedDocuments("ActiveEffect", [StatusEffects.prepareActiveEffect(effectId)], { render: true })
+        await this.createEmbeddedDocuments("ActiveEffect", [StatusEffects.prepareActiveEffect(effectId)], options)
       }
     }
   }
@@ -283,13 +330,13 @@ export class RdDBaseActor extends Actor {
     this.removeEffects(it => it.id == id)
   }
 
-  async removeEffects(filter = e => true) {
+  async removeEffects(filter = e => true, options = { render: true }) {
     if (game.user.isGM) {
       const ids = this.getEffects(filter)
         .filter(it => this.canRemoveEffects(it))
         .map(it => it.id)
       if (ids.length > 0) {
-        await this.deleteEmbeddedDocuments('ActiveEffect', ids)
+        await this.deleteEmbeddedDocuments('ActiveEffect', ids, options)
       }
 
     }
@@ -308,21 +355,15 @@ export class RdDBaseActor extends Actor {
   async updateCarac(caracName, to) {
   }
 
-  async onUpdateActor(change, options, actorId) {
-    const updatedCarac = change?.system?.carac
-    if (updatedCarac && (updatedCarac.force || updatedCarac.reve || updatedCarac.taille)) {
-      console.log(' onUpdateActor', change, options, actorId)
-      await this.setEffect(STATUSES.StatusSurEnc, this.isSurenc())
-    }
-  }
-
   /* -------------------------------------------- */
-  async onPreUpdateItem(item, change, options, id) { }
+
 
   async onCreateItem(item, options, id) {
   }
 
-  async onUpdateItem(item, options, id) {
+  async onUpdateItem(item, updates, options, id) {
+    const conteneur = item.findConteneur()
+    conteneur?.render(options.render)
   }
 
   async onDeleteItem(item, options, id) {
@@ -331,15 +372,14 @@ export class RdDBaseActor extends Actor {
     }
   }
 
-
   async _removeItemFromConteneur(item) {
-    const updates = this.items.filter(it => it.isConteneur() && it.system.contenu.includes(item.id))
-      .map(conteneur => {
-        const nouveauContenu = conteneur.system.contenu.filter(id => id != item.id)
-        return { _id: conteneur.id, 'system.contenu': nouveauContenu }
-      })
-    if (updates.length > 0) {
-      await this.updateEmbeddedDocuments('Item', updates)
+    const conteneur = this.findConteneur(item);
+    if (conteneur) {
+      const nouveauContenu = conteneur.system.contenu.filter(id => id != item.id)
+      const updates = { _id: conteneur.id, 'system.contenu': nouveauContenu }
+      if (updates.length > 0) {
+        await this.updateEmbeddedDocuments('Item', updates)
+      }
     }
   }
 
@@ -363,7 +403,7 @@ export class RdDBaseActor extends Actor {
   /* -------------------------------------------- */
   async cleanupConteneurs() {
     if (Misc.isOwnerPlayer(this)) {
-      let updates = this.itemTypes['conteneur']
+      let updates = this.itemTypes[ITEM_TYPES.conteneur]
         .filter(c => c.system.contenu.filter(id => this.getItem(id) == undefined).length > 0)
         .map(c => { return { _id: c._id, 'system.contenu': c.system.contenu.filter(id => this.getItem(id) != undefined) } });
       if (updates.length > 0) {
@@ -374,7 +414,7 @@ export class RdDBaseActor extends Actor {
 
   /* -------------------------------------------- */
   getFortune() {
-    return Monnaie.getFortune(this.itemTypes['monnaie']);
+    return Monnaie.getFortune(this.itemTypes[ITEM_TYPES.monnaie]);
   }
 
   /* -------------------------------------------- */
@@ -417,6 +457,14 @@ export class RdDBaseActor extends Actor {
   }
 
   async depenserSols(sols) {
+    if (!this.isOwner) {
+      return RdDBaseActor.remoteActorCall({
+        userId: Misc.connectedGMOrUser(),
+        tokenId: this.token?.id,
+        actorId: this.id,
+        method: 'depenserSols', args: [sols]
+      })
+    }
     let reste = this.getFortune() - Number(sols);
     if (reste >= 0) {
       await Monnaie.optimiserFortune(this, reste);
@@ -425,32 +473,31 @@ export class RdDBaseActor extends Actor {
   }
 
   async ajouterSols(sols, fromActorId = undefined) {
-    sols = Number(sols);
+    sols = Number(sols)
     if (sols == 0) {
-      return;
+      return
     }
     if (sols < 0) {
-      ui.notifications.error(`Impossible d'ajouter un gain de ${sols} <0`);
-      return;
+      ui.notifications.error(`Impossible d'ajouter un gain de ${sols} <0`)
+      return
     }
     if (fromActorId && !this.isOwner) {
-      RdDBaseActor.remoteActorCall({
+      return RdDBaseActor.remoteActorCall({
         userId: Misc.connectedGMOrUser(),
         tokenId: this.token?.id,
         actorId: this.id,
         method: 'ajouterSols', args: [sols, fromActorId]
-      });
+      })
     }
-    else {
-      const fromActor = game.actors.get(fromActorId)
-      await Monnaie.optimiserFortune(this, sols + this.getFortune());
 
-      RdDAudio.PlayContextAudio("argent"); // Petit son
-      ChatMessage.create({
-        whisper: ChatUtility.getOwners(this),
-        content: `Vous avez reçu <strong>${sols} Sols</strong> ${fromActor ? " de " + fromActor.name : ''}, qui ont été ajoutés à votre argent.`
-      });
-    }
+    const fromActor = game.actors.get(fromActorId)
+    await Monnaie.optimiserFortune(this, sols + this.getFortune());
+
+    RdDAudio.PlayContextAudio("argent"); // Petit son
+    ChatMessage.create({
+      whisper: ChatUtility.getOwners(this),
+      content: `Vous avez reçu <strong>${sols} Sols</strong> ${fromActor ? " de " + fromActor.name : ''}, qui ont été ajoutés à votre argent.`
+    })
   }
 
   /* -------------------------------------------- */
@@ -462,24 +509,28 @@ export class RdDBaseActor extends Actor {
   /* -------------------------------------------- */
   async achatVente(achat) {
     if (achat.vendeurId == achat.acheteurId) {
-      ui.notifications.info("Inutile de se vendre à soi-même");
-      return;
+      ui.notifications.info("Inutile de se vendre à soi-même")
+      return
     }
-    if (!game.user.isGM) {
+    const cout = Number(achat.prixTotal ?? 0)
+    const acheteur = achat.acheteurId ? game.actors.get(achat.acheteurId) : undefined
+
+    if (acheteur && !acheteur.isOwner) {
+      ui.notifications.warn(`${game.user.id} n'est pas propriétaire de ${this.name} et effectue un achat pour lui!`)
       RdDBaseActor.remoteActorCall({
-        actorId: achat.vendeurId ?? achat.acheteurId,
+        actorId: achat.acheteurId,
         method: 'achatVente', args: [achat]
       });
       return
     }
-    const cout = Number(achat.prixTotal ?? 0);
-    const vendeur = achat.vendeurId ? game.actors.get(achat.vendeurId) : undefined;
-    const acheteur = achat.acheteurId ? game.actors.get(achat.acheteurId) : undefined;
+
+
+    const vendeur = achat.vendeurId ? game.actors.get(achat.vendeurId) : undefined
     const quantite = (achat.choix.nombreLots ?? 1) * (achat.vente.tailleLot);
     const itemVendu = vendeur?.getItem(achat.vente.item._id) ?? game.items.get(achat.vente.item._id);
     if (!itemVendu) {
       ChatUtility.notifyUser(achat.userId, 'warn', vendeur ? `Le vendeur n'a pas plus de ${achat.vente.item.name} !` : `Impossible de retrouver: ${achat.vente.item.name} !`);
-      return;
+      return
     }
     if (vendeur && !vendeur.verifierQuantite(itemVendu, quantite)) {
       ChatUtility.notifyUser(achat.userId, 'warn', `Le vendeur n'a pas assez de ${itemVendu.name} !`);
@@ -487,10 +538,10 @@ export class RdDBaseActor extends Actor {
     }
     if (acheteur && !acheteur.verifierFortune(cout)) {
       ChatUtility.notifyUser(achat.userId, 'warn', `Vous n'avez pas assez d'argent pour payer ${Math.ceil(cout / 100)} sols !`);
-      return;
+      return
     }
-    await vendeur?.vendre(itemVendu, quantite, cout);
-    await acheteur?.acheter(itemVendu, quantite, cout, achat)
+    await vendeur?.vendre(itemVendu, quantite, cout, acheteur);
+    await acheteur?.acheter(itemVendu, quantite, cout, achat, vendeur)
 
     if (cout > 0) {
       RdDAudio.PlayContextAudio("argent");
@@ -505,22 +556,32 @@ export class RdDBaseActor extends Actor {
     });
 
     if (!achat.vente.quantiteIllimite) {
-      if (achat.vente.nbLots <= achat.choix.nombreLots) {
-        ChatUtility.removeChatMessageId(achat.chatMessageIdVente);
-      }
-      else if (achat.chatMessageIdVente) {
-        await ChatVente.diminuerQuantiteAchatVente(achat.chatMessageIdVente, achat.choix.nombreLots)
-      }
+      await this.updateMessageVente(achat.chatMessageIdVente, achat.choix.nombreLots);
     }
   }
 
-  async vendre(item, quantite, cout) {
-    await this.ajouterSols(cout);
-    await this.decrementerQuantiteItem(item, quantite);
+  async updateMessageVente(chatMessageIdVente, nombreLots) {
+    const chatMessage = game.messages.get(chatMessageIdVente)
+    if (!chatMessage.isOwner) {
+      return RdDBaseActor.remoteActorCall({
+        userId: Misc.firstConnectedGMId(),
+        actorId: this.id,
+        method: 'updateMessageVente', args: [chatMessageIdVente, nombreLots]
+      })
+    }
+    await ChatVente.diminuerQuantiteAchatVente(chatMessageIdVente, nombreLots);
+  }
+
+  async vendre(item, quantite, cout, acheteur) {
+    await this.ajouterSols(cout, acheteur?.id)
+    await this.decrementerQuantiteItem(item.id, quantite)
   }
 
   async acheter(item, quantite, cout, achat) {
     await this.depenserSols(cout)
+    if (!this.isOwner) {
+      ui.notifications.warn(`${game.user.id} n'est pas propriétaire de ${this.name} et effectue un achat!`)
+    }
     const createdItemId = await this.creerQuantiteItem(item, quantite)
     if (item.type == ITEM_TYPES.nourritureboisson && achat.choix.consommer && createdItemId != undefined) {
       achat.choix.doses = achat.choix.nombreLots;
@@ -542,43 +603,46 @@ export class RdDBaseActor extends Actor {
 
   async consommerNourritureboisson(itemId, choix, userId) { }
 
-  async decrementerQuantiteItem(item, quantite, options = { supprimerSiZero: true }) {
+  async decrementerQuantiteItem(itemId, quantite, options = { supprimerSiZero: true }) {
+    const item = this.items.get(itemId)
     if (item.isService()) {
-      return;
+      return
     }
-    const itemId = item.id;
-    let resteQuantite = (item.system.quantite ?? 1) - quantite;
-    if (resteQuantite <= 0) {
-      if (options.supprimerSiZero) {
-        await this.deleteEmbeddedDocuments("Item", [item.id]);
-      }
-      else {
-        await this.updateEmbeddedDocuments("Item", [{ _id: itemId, 'system.quantite': 0 }]);
-      }
-      if (resteQuantite < 0) {
-        ui.notifications.warn(`La quantité de ${item.name} était insuffisante, l'objet a donc été supprimé`)
-      }
+
+    if (!this.isOwner) {
+      return RdDBaseActor.remoteActorCall({
+        userId: Misc.connectedGMOrUser(),
+        tokenId: this.token?.id,
+        actorId: this.id,
+        method: 'decrementerQuantiteItem', args: [itemId, quantite, options]
+      })
     }
-    else if (resteQuantite > 0) {
-      const realItem = this.getItem(item.id)
-      realItem.update({ 'system.quantite': resteQuantite });
-      await this.updateEmbeddedDocuments("Item", [{ _id: item.id, 'system.quantite': resteQuantite }]);
+
+    const resteQuantite = Math.max((item.system.quantite ?? 1) - quantite, 0)
+    if (resteQuantite <= 0 && options.supprimerSiZero) {
+      await this.deleteEmbeddedDocuments("Item", [itemId]);
+    }
+    else {
+      await this.updateEmbeddedDocuments("Item", [{ _id: itemId, 'system.quantite': resteQuantite }])
     }
   }
 
   async creerQuantiteItem(item, quantite) {
-    if (this.canReceive(item)) {
-      const isItemEmpilable = "quantite" in item.system;
-      const baseItem = {
-        type: item.type,
-        img: item.img,
-        name: item.name,
-        system: foundry.utils.mergeObject(item.system, { quantite: isItemEmpilable ? quantite : undefined }, { inplace: false })
-      };
-      const newItems = isItemEmpilable ? [baseItem] : Array.from({ length: quantite }, (_, i) => baseItem);
-      const items = await this.createEmbeddedDocuments("Item", newItems);
-      return items.length > 0 ? items[0].id : undefined;
+    if (!this.canReceive(item)) {
+      return
     }
+
+    const isItemEmpilable = "quantite" in item.system;
+    const baseItem = {
+      type: item.type,
+      img: item.img,
+      name: item.name,
+      system: foundry.utils.mergeObject(item.system, { quantite: isItemEmpilable ? quantite : undefined }, { inplace: false })
+    }
+
+    const newItems = isItemEmpilable ? [baseItem] : Array.from({ length: quantite }, (_, i) => baseItem);
+    const items = await this.createEmbeddedDocuments("Item", newItems);
+    return newItems.length > 0 ? items[0].id : undefined;
   }
 
   /* -------------------------------------------- */
@@ -631,7 +695,7 @@ export class RdDBaseActor extends Actor {
       if (srcId != destId && itemId != destId) { // déplacement de l'objet
         const src = this.getItem(srcId);
         const dest = this.getItem(destId);
-        const cible = this.getContenantOrParent(dest);
+        const cible = this.findConteneurOrParent(dest);
         const [empilable, message] = item.isInventaireEmpilable(dest);
         if (empilable) {
           await dest.empiler(item)
@@ -653,15 +717,15 @@ export class RdDBaseActor extends Actor {
     return result;
   }
 
-  getContenantOrParent(dest) {
+  findConteneurOrParent(dest) {
     if (!dest || dest.isConteneur()) {
       return dest;
     }
-    return this.getContenant(dest);
+    return this.findConteneur(dest)
   }
 
-  getContenant(item) {
-    return this.itemTypes['conteneur'].find(it => it.system.contenu.includes(item.id));
+  findConteneur(item) {
+    return this.itemTypes[ITEM_TYPES.conteneur].find(it => it.system.contenu.includes(item.id));
   }
 
 
@@ -836,6 +900,7 @@ export class RdDBaseActor extends Actor {
     ui.notifications.info(`${this.getAlias()} ne peut pas faire cette action: ${action}`)
   }
 
+  ajoutExperience(rollData) { }
   isAlcoolise() { return false }
   async jetEthylisme() { this.actionImpossible("jet d'éthylisme") }
   async rollAppelChance() { this.actionImpossible("appel à la chance") }
@@ -866,4 +931,5 @@ export class RdDBaseActor extends Actor {
         }
       })
   }
+
 }

module/actor/commerce.js

@@ -28,11 +28,11 @@ export class RdDCommerce extends RdDBaseActor {
     await super.depenserSols(cout)
   }
 
-  async decrementerQuantiteItem(item, quantite) {
+  async decrementerQuantiteItem(itemId, quantite) {
     if (this.system.illimite) {
       return;
     }
-    await super.decrementerQuantiteItem(item, quantite, { supprimerSiZero: false });
+    await super.decrementerQuantiteItem(itemId, quantite, { supprimerSiZero: false });
   }
 
   calculerPrix(item) {

module/actor/creature.js

@@ -15,8 +15,8 @@ export class RdDCreature extends RdDBaseActorSang {
   }
 
   async remiseANeuf() {
-    await this.removeEffects(e => true);
-    await this.supprimerBlessures(it => true);
+    await this.removeEffects(e => true)
+    await this.supprimerBlessures(it => true)
     await this.update({
       'system.sante.endurance.value': this.system.sante.endurance.max,
       'system.sante.vie.value': this.system.sante.vie.max,

module/actor/entite-sheet.js

@@ -18,6 +18,7 @@ export class RdDActorEntiteSheet extends RdDBaseActorReveSheet {
     formData.niveau = this.actor.getNiveau()
     delete formData.system.carac.niveau
     formData.resonances = this.actor.system.sante.resonnance.actors.map(actorId => game.actors.get(actorId))
+      .filter(actor => actor != undefined)
       .map(actor => { return { id: actor.id, name: actor.name, img: actor.img } })
     return formData
   }
@@ -75,6 +76,6 @@ export class RdDActorEntiteSheet extends RdDBaseActorReveSheet {
   async resonanceDelete(actorId) {
     console.log('Delete : ', actorId);
     let newResonances = this.actor.system.sante.resonnance.actors.filter(id => id != actorId);
-    await this.actor.update({ 'system.sante.resonnance.actors': newResonances }, { renderSheet: false });
+    await this.actor.update({ 'system.sante.resonnance.actors': newResonances }, { render: false });
   }
 }

module/actor/entite.js

@@ -43,9 +43,7 @@ export class RdDEntite extends RdDBaseActorReve {
 
   async remiseANeuf() {
     if (!this.isEntiteNonIncarnee()) {
-      await this.update({
-        'system.sante.endurance.value': this.system.sante.endurance.max
-      });
+      await this.update({ 'system.sante.endurance.value': this.system.sante.endurance.max })
     }
     await this.removeEffects(e => true)
   }
@@ -85,12 +83,9 @@ export class RdDEntite extends RdDBaseActorReve {
     if (this.isEntiteNonIncarnee()) {
       return
     }
+    encaissement.isEntiteIncarnee = true
     const perteEndurance = await this.santeIncDec("endurance", -encaissement.endurance);
-    foundry.utils.mergeObject(encaissement, {
-      resteEndurance: perteEndurance.newValue,
-      endurance: perteEndurance.perte,
-      blessure: RdDItemBlessure.prepareBlessure(encaissement.gravite, encaissement.dmg?.loc.label ?? '', attackerToken)
-    })
+    foundry.utils.mergeObject(encaissement, { resteEndurance: perteEndurance.newValue, endurance: perteEndurance.perte })
   }
 
   isEntiteAccordee(attacker) {

module/actor/export-scriptarium/actor-encart-sheet.js

@@ -46,9 +46,9 @@ export class RdDActorExportSheet extends RdDActorSheet {
     formData.export = this.getMappingValues(formData.context, this.actor)
     formData.competences = this.getCompetences(CATEGORIES_COMPETENCES_BASE)
     formData.draconic = this.getCompetences(CATEGORIES_DRACONIC)
-    const legeres = this.actor.nbBlessuresLegeres()
-    const graves = this.actor.nbBlessuresGraves()
-    const critiques = this.actor.nbBlessuresCritiques()
+    const legeres = this.actor.countBlessures(it => it.isLegere())
+    const graves = this.actor.countBlessures(it => it.isGrave())
+    const critiques = this.actor.countBlessures(it => it.isCritique())
     formData.etat = {
       surenc: this.actor.computeMalusSurEncombrement(),
       fatigue: {
@@ -103,11 +103,10 @@ export class RdDActorExportSheet extends RdDActorSheet {
         gravite: this.html.find(event.currentTarget).data('gravite')
       })
     )
-    this.html.find('.click-blessure-add').click(async event =>
-      await this.actor.ajouterBlessure({
-        gravite: this.html.find(event.currentTarget).data('gravite')
-      })
-    )
+    this.html.find('.click-blessure-add').click(async event => {
+      const blessure = this.actor.nouvelleBlessure(this.html.find(event.currentTarget).data('gravite'))
+      await actor.createEmbeddedDocuments('Item', [blessure])
+    })
     this.html.find('.button-export').click(async event => await
       ExportScriptarium.INSTANCE.exportActors([this.actor],
         `${this.actor.uuid}-${this.actor.name}`

module/chat-utility.js

@@ -5,7 +5,7 @@ import { RdDTextEditor } from "./apps/rdd-text-roll-editor.js";
 
 
 /**
- * Class providing helper methods to get the list of users, and
+ * Class providing helper methods around the Chat message
  */
 export class ChatUtility {
 
@@ -92,27 +92,28 @@ export class ChatUtility {
   }
 
   /* -------------------------------------------- */
-  static async createChatWithRollMode(messageData, actor = undefined, rollMode = game.settings.get("core", "rollMode")) {
-    switch (rollMode) {
+  static adaptVisibility( messageData, options = { actor: undefined, rollMode: undefined }) {
+    foundry.utils.mergeObject(options, { rollMode: game.settings.get("core", "rollMode") }, { overwrite: false });
+    switch (options.rollMode) {
       case "blindroll": // GM only
         if (!game.user.isGM) {
           ChatUtility.blindMessageToGM(messageData)
-          messageData.whisper = [game.user];
-          messageData.content = "Message envoyé en aveugle au Gardien"
+          messageData.whisper = [game.user]
+          messageData.content = "Message envoyé en aveugle au Gardien";
         }
         else {
           messageData.whisper = ChatUtility.getGMs()
         }
-        break
+        break;
       case "gmroll":
-        messageData.whisper = actor ? ChatUtility.getOwners(actor) : ChatUtility.getUserAndGMs()
-        break
+        messageData.whisper = options.actor ? ChatUtility.getOwners(options.actor) : ChatUtility.getUserAndGMs()
+        break;
       case "selfroll":
         messageData.whisper = [game.user]
         break
     }
-    messageData.alias = messageData.alias ?? actor?.name ?? game.user.name
-    return await ChatMessage.create(messageData)
+    messageData.alias = messageData.alias ?? options.actor?.name ?? game.user.name
+    return messageData
   }
 
   static tellToUser(message) {
@@ -134,6 +135,7 @@ export class ChatUtility {
       whisper: ChatUtility.getUserAndGMs()
     })
   }
+
   static getOwners(document) {
     return document ? game.users.filter(it => document.getUserLevel(it) == CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER) : [game.user]
   }
@@ -215,11 +217,13 @@ export class ChatUtility {
 
   static async onRenderChatMessage(chatMessage, html, data) {
     const rddTimestamp = chatMessage.getFlag(SYSTEM_RDD, 'rdd-timestamp')
-    if (rddTimestamp) {
+    const heureRdD = $(html).find('header.message-header .heure-rdd')
+    if (rddTimestamp && heureRdD.length == 0) {
+      const messageTimestamp = $(html).find('header.message-header .message-timestamp');
       const timestamp = new RdDTimestamp(rddTimestamp);
       const timestampData = timestamp.toCalendrier();
       const dateHeure = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/common/date-heure.hbs', timestampData);
-      $(html).find('header.message-header .message-timestamp').after(dateHeure)
+      messageTimestamp.after(dateHeure)
     }
   }
 
@@ -233,4 +237,9 @@ export class ChatUtility {
   static async setTimestamp(chatMessage) {
     await chatMessage.setFlag(SYSTEM_RDD, 'rdd-timestamp', game.system.rdd.calendrier.getTimestamp());
   }
+
+  static getISODate(chatMessage) {
+    const date = new Date(chatMessage.timestamp);
+    return date?.toISOString().substring(0, 10)
+  }
 }

module/chat/dialog-flush-by-date.mjs

@@ -0,0 +1,77 @@
+import { ChatUtility } from "../chat-utility.js"
+import { Misc } from "../misc.js"
+import { RdDTimestamp } from "../time/rdd-timestamp.js"
+
+const fields = foundry.applications.fields
+
+export class DialogFlushByDate {
+
+  static async init() {
+    Hooks.once("renderChatLog", async () => await DialogFlushByDate.onFirstRenderChatLog())
+  }
+
+  static async onFirstRenderChatLog() {
+    if (game.user.isGM) {
+      const content = await foundry.applications.handlebars.renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat/button-flush-by-date.hbs')
+      const flushButton = document.querySelector("#chat-controls button[data-action='flush']")
+      flushButton.insertAdjacentHTML("afterend", content)
+      flushButton.parentElement.querySelector("button[name='flush-by-date']")?.addEventListener(
+        "click", e => {
+          if (game.messages.size > 0) {
+            DialogFlushByDate.create()
+          }
+          else {
+            ui.notifications.info("Aucun message à supprimer!")
+          }
+          e.preventDefault()
+        })
+    }
+  }
+
+  static async create() {
+    const dates = DialogFlushByDate.getChatMessageDates(game.messages)
+
+    const selectGroup = fields.createFormGroup({
+      input: fields.createSelectInput({
+        options: dates.map(it => { return { label: `${it.dateTerre} | ${it.dateReve}`, value: it.timestamp } }),
+        name: 'timestamp'
+      }),
+      label: 'Messages antérieurs au',
+      hint: 'Supprimer les messages antérieurs à la date'
+    })
+
+    const selected = await foundry.applications.api.DialogV2.input({
+      window: { title: "Supprimer les messages du tchat" },
+      content: selectGroup.outerHTML,
+      ok: {
+        label: "Supprimer",
+        icon: "fa-solid fa-trash-can",
+      }
+    })
+    if (selected) {
+      const timestamp = Number.parseInt(selected.timestamp)
+      const toDelete = game.messages.filter(it => it.timestamp < timestamp)
+      toDelete.forEach(it => it.delete())
+    }
+  }
+
+  static getChatMessageDates(messages) {
+    const datesTerre = Object.values(Misc.classifyFirst(messages,
+      m => ChatUtility.getISODate(m),
+      m => DialogFlushByDate.chatMessageDates(m)))
+    const timestamps = new Set(datesTerre.map(it => it.timestamp))
+    const datesReve = Object.values(Misc.classifyFirst(messages,
+      m => RdDTimestamp.fromChatMessage(m).isoDate(),
+      m => DialogFlushByDate.chatMessageDates(m)))
+    const dates = [...datesTerre, ...datesReve.filter(it => !timestamps.has(it.timestamp))]
+    return dates.sort(Misc.ascending(it => it.timestamp))
+  }
+
+  static chatMessageDates(it) {
+    return {
+      timestamp: it.timestamp,
+      dateTerre: new Date(it.timestamp).toLocaleDateString(),
+      dateReve: RdDTimestamp.fromChatMessage(it).formatDate()
+    }
+  }
+}

module/combat/distance.mjs

@@ -13,7 +13,7 @@ export class Distance {
       }
       return undefined
     }
-    switch (attaque.comp.type) {
+    switch (attaque.comp?.type) {
       case ITEM_TYPES.competence: return mapTypeAttaque(attaque.main)
       case ITEM_TYPES.competencecreature: return mapTypeAttaque(attaque.arme.system.categorie)
     }
@@ -36,20 +36,19 @@ export class Distance {
   }
 
   static distance(token, defenderToken) {
-    if (token instanceof Token && defenderToken instanceof Token) {
-      const ray = new foundry.canvas.geometry.Ray(
-        token.getCenterPoint(),
-        defenderToken.getCenterPoint()
-      )
-      return Number(canvas.grid.measureDistances([{ ray }], { gridSpaces: false }))
+    if (Distance.$isToken(token) && Distance.$isToken(defenderToken)) {
+      const source = token.getCenterPoint()
+      const target = defenderToken.getCenterPoint()
+      const measure = canvas.grid.measurePath([ source, target])
+      return measure.distance
     }
     return -1 /* distance indéterminée */
   }
 
   static isVisible(token, defenderToken) {
     // TODO: regarder les StatusEffect aveuglé?
-    if (token instanceof Token && defenderToken instanceof Token) {
-      return canvas.effects.visibility.testVisibility(defenderToken.getCenterPoint(), { object: token })
+    if (Distance.$isToken(token) && Distance.$isToken(defenderToken)) {
+      return canvas.visibility.testVisibility(defenderToken.getCenterPoint(), { object: token })
     }
     return true
   }
@@ -79,11 +78,11 @@ export class Distance {
   }
 
   static ajustementMouvement(defenderToken) {
-    if (defenderToken instanceof Token) {
+    if (Distance.$isToken(defenderToken)) {
       if (defenderToken.actor?.getSurprise(true) != '') return { msg: "immobile (surprise)", diff: 0 };
-      if (defenderToken.inCombat) return { msg: "en mouvement (combat)", diff: -4 };
+      if (defenderToken.inCombat) return { msg: "en combat", diff: -4 };
     }
-    return { msg: "à déterminer (0 immobile, -3 actif, -4 en mouvement, -5 en zig-zag)", diff: -3 };
+    return { msg: "à déterminer", diff: -3 };
   }
 
   static diff(...ajustements) {
@@ -116,4 +115,8 @@ export class Distance {
     return undefined
   }
 
+  static $isToken(token) {
+    return token instanceof Token || token instanceof TokenDocument
+  }
+
 }

module/effect/base-active-effect.js

@@ -0,0 +1,19 @@
+
+export class RdDActiveEffect extends ActiveEffect {
+
+  async _preCreate(data, options, user) {
+    await this.parent?.delayedRenderSheet('_preCreateEffect', data, options)
+    return super._preCreate(data, options, user)
+  }
+
+  async _preUpdate(changed, options, user) {
+    await this.parent?.delayedRenderSheet('_preUpdateEffect', changed, options)
+    return super._preUpdate(changed, options, user)
+  }
+
+  async _preDelete(options, user) {
+    await this.parent?.delayedRenderSheet('_preDeleteEffect', { id: this.id }, options)
+    return super._preDelete(options, user)
+  }
+
+}

module/enchantement/dialog-enchanter.js

@@ -1,10 +1,10 @@
-import { ITEM_TYPES, renderTemplate } from "../constants.js"
+import { ACTOR_TYPES, ITEM_TYPES, renderTemplate } from "../constants.js"
 import { RdDItemSort } from "../item-sort.js"
 import { Misc } from "../misc.js"
 
 export const ACTION_ITEM_ENCHANTER =  {
   code: 'item-enchanter', label: 'Enchanter', icon: it => 'fa-solid fa-sparkles',
-  filter: it => game.user.isGM || DialogEnchanter.isEnchantable(it) && it.parent?.type != ACTOR_TYPES.commerce,
+  filter: it => DialogEnchanter.isEnchantable(it) && it.parent?.type != ACTOR_TYPES.commerce,
   action: (item, actor) => DialogEnchanter.enchanter(item)
 }
 

module/item-competence.js

@@ -1,4 +1,4 @@
-
+import { ChatUtility } from "./chat-utility.js";
 import { Grammar } from "./grammar.js";
 import { RdDInitiative } from "./initiative.mjs";
 import { RdDItem } from "./item.js";
@@ -71,6 +71,36 @@ export class RdDItemCompetence extends RdDItem {
     }
     return undefined
   }
+
+  async _preUpdate(changed, options, user) {
+    await this.checkCompetenceXP(changed.system?.xp)
+    return super._preUpdate(changed, options, user)
+  }
+  
+  async checkCompetenceXP(newXP, display = true) {
+    if (this.actor?.isPersonnage() && newXP && newXP != this.system.xp && newXP > 0) {
+      const newNiv = this.system.niveau + 1
+      let needed = RdDItemCompetence.getCompetenceNextXp(newNiv)
+      if (newXP >= needed) {
+        const xpData = {
+          alias: this.actor.getAlias(),
+          competence: this.name,
+          niveau: newNiv,
+          xp: newXP,
+          archetype: this.system.niveau_archetype,
+          archetypeWarning: newNiv > this.system.niveau_archetype
+        }
+        if (display) {
+          ChatMessage.create({
+            whisper: ChatUtility.getOwners(this.actor),
+            content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-competence-xp.hbs`, xpData)
+          })
+        }
+        return xpData
+      }
+    }
+  }
+
   /* -------------------------------------------- */
   static getLabelCategorie(category) {
     return CATEGORIES_COMPETENCES[category].label;
@@ -136,7 +166,7 @@ export class RdDItemCompetence extends RdDItem {
           return troncList;
       }
     }
-    return [];
+    return []
   }
 
   /* -------------------------------------------- */

module/item-sheet.js

@@ -16,6 +16,7 @@ import { RdDTextEditor } from "./apps/rdd-text-roll-editor.js";
 import { ItemAction } from "./item/item-actions.js";
 import { SANS_COMPETENCE } from "./item/base-items.js";
 import { Apprecier } from "./moral/apprecier.mjs";
+import { CARACS } from "./rdd-carac.js";
 
 /**
  * Extend the basic ItemSheet for RdD specific items
@@ -118,7 +119,7 @@ export class RdDItemSheetV1 extends foundry.appv1.sheets.ItemSheet {
       this.item.type == ITEM_TYPES.meditation ||
       this.item.type == ITEM_TYPES.oeuvre) {
       formData.caracList = foundry.utils.duplicate(game.model.Actor.personnage.carac)
-      formData.caracList["reve-actuel"] = foundry.utils.duplicate(game.model.Actor.personnage.reve.reve)
+      formData.caracList[CARACS.REVE_ACTUEL] = foundry.utils.duplicate(game.model.Actor.personnage.reve.reve)
     }
     if (this.item.type == ITEM_TYPES.arme) {
       formData.competences = formData.competences.filter(it => it.isCompetenceArme())

module/item-sort.js

@@ -41,6 +41,11 @@ export class RdDItemSort extends RdDItem {
     return value ? value.replace('variable', 'var') : ''
   }
 
+  static computeTotalXP(sorts) {
+    return sorts.map(sort => RdDItemSort.isDifficulteVariable(sort) ? 70 : -10 * Misc.toInt(sort.system.difficulte))
+      .reduce(Misc.sum(), 0)
+  }
+
   static isSortOnCoord(sort, coord) {
     let tmr = TMRUtility.getTMR(coord)
     const caseTMR = sort.system.caseTMR.toLowerCase();

module/item.js

@@ -81,13 +81,17 @@ export const defaultItemImg = {
   souffle: "systems/foundryvtt-reve-de-dragon/icons/souffle_dragon.webp",
   tarot: "systems/foundryvtt-reve-de-dragon/icons/tarots/dos-tarot.webp",
   tete: "systems/foundryvtt-reve-de-dragon/icons/tete_dragon.webp",
-  monnaie:"systems/foundryvtt-reve-de-dragon/icons/objets/piece_etain_poisson.webp",
+  monnaie: "systems/foundryvtt-reve-de-dragon/icons/objets/piece_etain_poisson.webp",
   munition: "systems/foundryvtt-reve-de-dragon/icons/objets/fleche.webp"
 }
 
+const ITEM_TYPES_PLURIEL = {
+  [ITEM_TYPES.jeu]: 'jeux'
+}
+
 /* -------------------------------------------- */
 export class RdDItem extends Item {
-  
+
   static get defaultIcon() {
     return undefined;
   }
@@ -112,6 +116,13 @@ export class RdDItem extends Item {
     return true;
   }
 
+  static itemTypePluriel(type) {
+    if (ITEM_TYPES[type]) {
+      return ITEM_TYPES_PLURIEL[type] ?? (type + 's')
+    }
+    console.error(`Item type ${type} is undefined`)
+    return type
+  }
   static async getCorrespondingItem(itemRef) {
     if (itemRef.pack) {
       return await SystemCompendiums.loadDocument(itemRef)
@@ -163,6 +174,21 @@ export class RdDItem extends Item {
     super(docData, context);
   }
 
+  async _preCreate(data, options, user) {
+    await this.parent?.delayedRenderSheet('_preCreateItem', data, options)
+    return super._preCreate(data, options, user)
+  }
+
+  async _preUpdate(changed, options, user) {
+    await this.parent?.delayedRenderSheet('_preUpdateItem', changed, options)
+    return super._preUpdate(changed, options, user)
+  }
+
+  async _preDelete(options, user) {
+    await this.parent?.delayedRenderSheet('_preDeleteItem', { id: this.id }, options)
+    return super._preDelete(options, user)
+  }
+
   getUniteQuantite() {
     switch (this.type) {
       case ITEM_TYPES.monnaie: return "(Pièces)"
@@ -185,6 +211,13 @@ export class RdDItem extends Item {
   isCompetencePersonnage() { return this.type == ITEM_TYPES.competence }
   isCompetenceCreature() { return this.type == ITEM_TYPES.competencecreature }
   isConteneur() { return this.type == ITEM_TYPES.conteneur }
+  findConteneur() {
+    if (this.isInventaire('all') && this.parent) {
+      return this.parent.findConteneur(this)
+    }
+    return undefined
+  }
+
   isMonnaie() { return this.type == ITEM_TYPES.monnaie }
   isNourritureBoisson() { return this.type == ITEM_TYPES.nourritureboisson; }
   isService() { return this.type == ITEM_TYPES.service }

module/item/arme.js

@@ -45,7 +45,7 @@ export class RdDItemArme extends RdDItem {
   isParade() { return this.system.resistance > 0 && this.system.categorie_parade }
   isBouclier() { return RdDItemArme.getCategorieParade(this).includes('bouclier') }
 
-  
+
   getCompetenceAction(main) {
     switch (main) {
       case ATTAQUE_TYPE.UNE_MAIN: return this.competence1Mains()
@@ -174,24 +174,30 @@ export class RdDItemArme extends RdDItem {
 
   static defenseArmeParade(armeAttaque, armeParade) {
     const defCategory = RdDItemArme.getCategorieParade(armeParade)
-    if (defCategory == 'boucliers') {
-      return 'norm'
+    switch (defCategory) {
+      case 'boucliers':
+          return 'norm'
+      case '':
+        return 'impossible'
     }
-    if (armeAttaque?.system?.competence?.toLowerCase().match(/(fléau)/)) {
-      return ''
-    }
-    if (armeParade.system?.tir) {
-      return ''
+    if (RdDItemArme.$isFleau(armeAttaque)) {
+      return 'impossible'
     }
+
     const attCategory = RdDItemArme.getCategorieParade(armeAttaque)
     switch (attCategory) {
-      case 'armes-naturelles': case 'sans-armes':
-        return defCategory == 'sans-armes' ? 'norm' : ''
+      case 'sans-armes':
+      case 'armes-naturelles':
+        return defCategory == attCategory ? 'norm' : 'impossible'
       default:
         return RdDItemArme.needParadeSignificative(armeAttaque, armeParade) ? 'sign' : 'norm'
     }
   }
 
+  static $isFleau(armeAttaque) {
+    return armeAttaque?.system?.competence?.toLowerCase().match(/(fléau)/);
+  }
+
   /* -------------------------------------------- */
   static needParadeSignificative(armeAttaque, armeParade) {
     if (!armeAttaque || !armeParade) {

module/item/blessure.js

@@ -19,7 +19,7 @@ const definitionsBlessures = [
   { type: "legere", gravite: 2, endurance: "1d6", vie: 0, label: 'Légère', max: 5, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/blessure.webp" },
   { type: "grave", gravite: 4, endurance: "2d6", vie: -2, label: 'Grave', max: 2, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/blessure.webp" },
   { type: "critique", gravite: 6, endurance: "-100", vie: -4, label: 'Critique', max: 1, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/blessure.webp" },
-  { type: "mort", gravite: 8, label: 'Mort', max: 1, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/mort.webp" }
+  { type: "mort", gravite: 8, endurance: "-100", vie: 0, label: 'Mort', max: 1, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/mort.webp" }
 ]
 
 export class RdDItemBlessure extends RdDItem {
@@ -71,13 +71,13 @@ export class RdDItemBlessure extends RdDItem {
     return 0
   }
 
-  static async createBlessure(actor, gravite, localisation = '', attackerToken = undefined) {
-    const blessure = RdDItemBlessure.prepareBlessure(gravite, localisation, attackerToken);
-    const blessures = await actor.createEmbeddedDocuments('Item', [blessure])
+  static async createBlessure(actor, gravite, options = { localisation: '', origine: '', render: true }) {
+    const blessure = RdDItemBlessure.prepareBlessure(gravite, options);
+    const blessures = await actor.createEmbeddedDocuments('Item', [blessure], options)
     return blessures[0]
   }
 
-  static prepareBlessure(gravite, localisation, attackerToken) {
+  static prepareBlessure(gravite, options = { localisation: '', origine: '' }) {
     const definition = RdDItemBlessure.getDefinition(gravite);
     return {
       name: definition.label,
@@ -85,9 +85,11 @@ export class RdDItemBlessure extends RdDItem {
       img: definition.icon,
       system: {
         gravite: gravite,
+        vie: definition.vie,
+        endurance: definition.endurance,
         difficulte: -gravite,
-        localisation: localisation,
-        origine: attackerToken?.name ?? ""
+        localisation: options.localisation,
+        origine: options.origine
       }
     }
   }
@@ -104,11 +106,9 @@ export class RdDItemBlessure extends RdDItem {
   async updateTacheSoinBlessure(tache) {
     if (tache) {
       await tache.update({
-        system: {
-          itemId: this.id,
-          difficulte: Math.min(this.system.difficulte, tache.system.difficulte),
-          points_de_tache_courant: Math.max(0, this.system.premierssoins.tache)
-        }
+        'system.itemId': this.id,
+        'system.difficulte': Math.min(this.system.difficulte, tache.system.difficulte),
+        'system.points_de_tache_courant': Math.max(0, this.system.premierssoins.tache)
       });
     }
   }
@@ -160,7 +160,7 @@ export class RdDItemBlessure extends RdDItem {
           message.content += ` -- une blessure ${label} reste stable`;
         }
       }
-      await this.update(update);
+      await this.update(update)
     }
   }
 

module/item/item-actions.js

@@ -1,4 +1,4 @@
-import { ACTOR_TYPES } from "../constants.js"
+import { ACTOR_TYPES, ITEM_TYPES } from "../constants.js"
 import { Misc } from "../misc.js"
 import { RdDSheetUtility } from "../rdd-sheet-utility.js"
 import { RdDUtility } from "../rdd-utility.js"
@@ -11,90 +11,104 @@ import { RdDUtility } from "../rdd-utility.js"
 const _SPACEHOLDER = { placeholder: true }
 
 const _VENDRE = {
-  code: 'item-vendre', label: 'Vendre ou donner', icon: it => 'fa-solid fa-comments-dollar',
+  code: 'item-vendre', label: 'Vendre ou donner', icon: 'fa-solid fa-comments-dollar',
   filter: it => Misc.toInt(it.system.quantite) > 0 || it.parent?.type == ACTOR_TYPES.commerce,
   action: (item, actor) => item.proposerVente()
 }
 const _ACHETER = {
-  code: 'item-acheter', label: 'Acheter', icon: it => 'fa-regular fa-coins',
+  code: 'item-acheter', label: 'Acheter', icon: 'fa-regular fa-coins',
   filter: it => it.parent?.type == ACTOR_TYPES.commerce,
   allowLimited: true,
   action: (item, actor) => actor.vente(item)
 }
 const _MONTRER = {
-  code: 'item-montrer', label: 'Montrer', icon: it => 'fa-solid fa-comment',
+  code: 'item-montrer', label: 'Montrer', icon: 'fa-solid fa-comment',
   allowLimited: true,
   action: (item, actor) => item.postItemToChat()
 }
 const _SPLIT = {
-  code: 'item-split', label: 'Séparer le goupe', icon: it => 'fa-solid fa-unlink',
+  code: 'item-split', label: 'Séparer le goupe', icon: 'fa-solid fa-unlink',
+  actorFilter: actor => actor.isOwner,
   filter: it => Misc.toInt(it.system.quantite) > 1 && it.parent?.type != ACTOR_TYPES.commerce,
   action: (item, actor) => RdDSheetUtility.splitItem(item, actor)
 }
 
 const _EDIT = {
-  code: 'item-edit', label: 'Editer', icon: it => 'fa-solid fa-edit',
+  code: 'item-edit', label: it => it.type == ITEM_TYPES.conteneur ? 'Ouvrir' : 'Editer',
+  icon: 'fa-solid fa-edit',
   action: (item, actor) => item.sheet.render(true)
 }
+
 const _DELETE = {
-  code: 'item-delete', label: 'Supprimer', icon: it => 'fa-solid fa-trash',
+  code: 'item-delete', label: 'Supprimer', icon: 'fa-solid fa-trash',
   optionsFilter: options => options.isOwner,
   action: (item, actor) => RdDUtility.confirmActorItemDelete(item, actor)
 }
 const _EQUIPER = {
   code: 'item-equip', label: 'Equiper', icon: it => it.system.equipe ? 'fa-solid fa-hand-rock' : 'fa-regular fa-hand-paper',
+  actorFilter: actor => actor.isPersonnage(),
   filter: it => !it.estContenu && it.isEquipable(),
   action: (item, actor) => actor.equiperObjet(item)
 }
 
 const _CUISINER = {
-  code: 'item-cuisiner', label: 'Cuisiner', icon: it => 'fa-solid fa-utensils',
+  code: 'item-cuisiner', label: 'Cuisiner',
+  img: 'systems/foundryvtt-reve-de-dragon/assets/actions/cuisine.svg',
+  actorFilter: actor => actor.isPersonnage(),
   filter: it => it.getUtilisation() == 'cuisine' && it.system.sust > 0,
   action: (item, actor) => actor.preparerNourriture(item)
 }
 const _MANGER_CRU = {
-  code: 'item-manger-cru', label: 'Manger cru', icon: it => 'fa-solid fa-drumstick-bite',
+  code: 'item-manger-cru', label: 'Manger cru', icon: 'fa-solid fa-drumstick-bite',
+  actorFilter: actor => actor.isPersonnage(),
   filter: it => it.getUtilisation() == 'cuisine' && it.system.sust > 0,
   action: (item, actor) => actor.mangerNourriture(item)
 }
 const _MANGER = {
-  code: 'item-manger', label: 'Manger', icon: it => 'fa-solid fa-utensils',
+  code: 'item-manger', label: 'Manger', icon: 'fa-solid fa-utensils',
+  actorFilter: actor => actor.isPersonnage(),
   filter: it => !(it.system.boisson),
   action: (item, actor) => actor.mangerNourriture(item)
 }
 const _BOIRE = {
-  code: 'item-boire', label: 'Boire', icon: it => 'fa-solid fa-glass-water',
+  code: 'item-boire', label: 'Boire', icon: 'fa-solid fa-glass-water',
+  actorFilter: actor => actor.isPersonnage(),
   filter: it => it.system.boisson,
   action: (item, actor) => actor.mangerNourriture(item)
 }
 const _DECOCTION = {
-  code: 'item-decoction', label: 'Décoction', icon: it => 'fa-solid fa-flask-vial',
+  code: 'item-decoction', label: 'Décoction', icon: 'fa-solid fa-flask-vial',
+  actorFilter: actor => actor.isPersonnage(),
   action: (item, actor) => actor.fabriquerDecoctionHerbe(item)
 }
+
 const _OUVRIR = {
-  code: 'item-edit', label: 'Ouvrir', icon: it => 'fa-solid fa-eye',
+  code: 'item-edit', label: 'Ouvrir',
+  img: 'systems/foundryvtt-reve-de-dragon/assets/actions/ouvrir.svg',
   action: (item, actor) => item.sheet.render(true)
 }
-
 const _LIRE = {
-  code: 'item-lire', label: 'Lire', icon: it => 'fa-solid fa-book-open',
+  code: 'item-lire', label: 'Lire', icon: 'fa-solid fa-book-open',
+  actorFilter: actor => actor.isPersonnage(),
   action: (item, actor) => actor.actionLire(item)
 }
 
 const _REFOULER = {
-  code: 'item-refouler', label: 'Refouler', icon: it => 'fa-solid fa-burst',
+  code: 'item-refouler', label: 'Refouler', icon: 'fa-solid fa-burst',
+  actorFilter: actor => actor.isPersonnage(),
   filter: it => it.system.refoulement > 0,
   action: (item, actor) => actor.actionRefoulement(item)
 }
 
 const _SORT_RESERVE = {
-  code: 'item-sortreserve-add', label: 'Ajouter en réserve', icon: it => 'fa-solid fa-sparkles',
+  code: 'item-sortreserve-add', label: 'Ajouter en réserve', icon: 'fa-solid fa-sparkles',
+  actorFilter: actor => actor.isPersonnage(),
   filter: it => game.user.isGM && !it.system.isrituel,
   action: (item, actor) => actor.addSortReserve(item)
 }
 
 export const COMMON_ACTIONS = [_EQUIPER]
-export const DEFAULT_ACTIONS = [_ACHETER, _SPACEHOLDER, _SPLIT, _VENDRE, _MONTRER, _EDIT, _DELETE]
+export const DEFAULT_ACTIONS = [_ACHETER, _SPLIT, _SPACEHOLDER, _VENDRE, _MONTRER, _EDIT, _DELETE]
 
 export const ITEM_ACTIONS = {
   faune: [_CUISINER, _MANGER_CRU],
@@ -114,16 +128,37 @@ export class ItemAction {
   static applies(action, item, options) {
     return action && item
       && item.isActionAllowed(action.code)
+      && (!action.actorFilter || (item.actor && action.actorFilter(item.actor)))
       && (!action.filter || action.filter(item))
       && (action.allowLimited || options.editable)
       && (!action.optionsFilter || action.optionsFilter(options))
   }
 
-  static icon(action, item) {
-    if (action && action.icon) {
-      return action.icon(item)
+  static label(action, item) {
+    if (action.placeholder) {
+      return ""
     }
-    return undefined
+    return ItemAction.getParam(action.label, item)
+  }
+
+  static img(action, item) {
+    if (action.placeholder) {
+      return ""
+    }
+
+    const img = ItemAction.getParam(action.img, item)
+    if (img) {
+      return `<img src="${img}" />`
+    }
+    const icon = ItemAction.getParam(action.icon, item)
+    if (icon) {
+      return `<i class="${icon}"></i>`
+    }
+    return action.label
+  }
+
+  static getParam(p, item) {
+    return typeof (p) == 'function' ? p(item) : p
   }
 
   static async onActionItem(event, actor, options) {

module/item/sheet-base-inventaire.js

@@ -77,41 +77,41 @@ export class RdDInventaireItemSheet extends RdDItemSheetV1 {
   }
 
   async onAddMilieu(event) {
-    const milieu = this.html.find('input.input-selection-milieu').val();
+    const milieu = this.html.find('input.input-selection-milieu').val()
     if (!milieu) {
-      ui.notifications.warn(`Choisissez le milieu dans lequel se trouve le/la ${this.item.name}`);
+      ui.notifications.warn(`Choisissez le milieu dans lequel se trouve le/la ${this.item.name}`)
       return
     }
-    const list = this.item.getEnvironnements();
-    const exists = list.find(it => it.milieu == milieu);
+    const list = this.item.getEnvironnements()
+    const exists = list.find(it => it.milieu == milieu)
     if (exists) {
       ui.notifications.warn(`${this.item.name} a déjà une rareté ${exists.rarete} en ${milieu} (fréquence: ${exists.frequence})`);
       return
     }
-    const rarete = RdDRaretes.rareteFrequente();
-    const added = { milieu, rarete: rarete.code, frequence: rarete.frequence };
+    const rarete = RdDRaretes.rareteFrequente()
+    const added = { milieu, rarete: rarete.code, frequence: rarete.frequence }
     const newList = [added, ...list].sort(Misc.ascending(it => it.milieu))
     await this.item.update({ 'system.environnement': newList })
   }
 
   async onDeleteMilieu(event) {
-    const milieu = this.$getEventMilieu(event);
+    const milieu = this.$getEventMilieu(event)
     if (milieu != undefined) {
       const newList = this.item.getEnvironnements().filter(it => it.milieu != milieu)
-        .sort(Misc.ascending(it => it.milieu));
-      await this.item.update({ 'system.environnement': newList });
+        .sort(Misc.ascending(it => it.milieu))
+      await this.item.update({ 'system.environnement': newList })
     }
   }
 
   async onChange(event, doMutation) {
-    const list = this.item.system.environnement;
-    const milieu = this.$getEventMilieu(event);
-    const updated = list.find(it => it.milieu == milieu);
+    const list = this.item.system.environnement
+    const milieu = this.$getEventMilieu(event)
+    const updated = list.find(it => it.milieu == milieu)
     if (updated) {
-      doMutation(updated);
+      doMutation(updated)
       const newList = [...list.filter(it => it.milieu != milieu), updated]
-        .sort(Misc.ascending(it => it.milieu));
-      await this.item.update({ 'system.environnement': newList });
+        .sort(Misc.ascending(it => it.milieu))
+      await this.item.update({ 'system.environnement': newList })
     }
   }
 

module/item/sheet-faune.js

@@ -20,7 +20,7 @@ export class RdDFauneItemSheet extends RdDInventaireItemSheet {
         'system.actor.pack': linkedActor.pack,
         'system.actor.id': linkedActor._id,
         'system.actor.name': linkedActor.name
-      });
+      })
     }
     else {
       ui.notifications.warn(`${linkedActor.name} ne provient pas d'un compendium.
@@ -32,7 +32,7 @@ export class RdDFauneItemSheet extends RdDInventaireItemSheet {
       'system.actor.pack': '',
       'system.actor.id': '',
       'system.actor.name': ''
-    });
+    })
   }
 
 }

module/migrations.js

@@ -16,22 +16,18 @@ class Migration {
   async migrate() { }
 
   async applyItemsUpdates(computeUpdates) {
-    await game.actors.forEach(async (actor) => {
+    await Promise.all(game.actors.map(actor => {
       const actorItemUpdates = computeUpdates(actor.items).filter(it => it != undefined);
       if (actorItemUpdates.length > 0) {
-        console.log(
-          this.code,
-          `Applying updates on actor ${actor.name} items`,
-          actorItemUpdates
-        );
-        await actor.updateEmbeddedDocuments("Item", actorItemUpdates);
+        console.log(this.code, `Applying updates on actor ${actor.name} items`, actorItemUpdates);
+        return actor.updateEmbeddedDocuments("Item", actorItemUpdates);
       }
-    });
+    }))
 
-    const itemUpdates = computeUpdates(game.items).filter(it => it != undefined);
+    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);
+      console.log(this.code, "Applying updates on items", itemUpdates)
+      await Item.updateDocuments(itemUpdates)
     }
   }
 }
@@ -58,13 +54,13 @@ class _1_5_34_migrationPngWebp {
     //Migrate system png to webp
     await Item.updateDocuments(itemsUpdates);
     await Actor.updateDocuments(actorsUpdates);
-    game.actors.forEach(actor => {
-      if (actor.token?.img && actor.token.img.match(regexOldPngJpg)) {
-        actor.update({ "token.img": convertImgToWebp(actor.token.img) });
-      }
-      const actorItemsToUpdate = prepareDocumentsImgUpdate(actor.items);
-      actor.updateEmbeddedDocuments('Item', actorItemsToUpdate);
-    });
+    await Promise.all(game.actors
+      .filter(actor => actor.token?.img && actor.token.img.match(regexOldPngJpg))
+      .map(actor => actor.update({ "token.img": convertImgToWebp(actor.token.img) }))
+    )
+    await Promise.all(game.actors.map(actor =>
+      actor.updateEmbeddedDocuments('Item', prepareDocumentsImgUpdate(actor.items))
+    ))
   }
 }
 
@@ -125,16 +121,15 @@ class _10_0_21_VehiculeStructureResistanceMax extends Migration {
   get version() { return "10.0.21"; }
 
   async migrate() {
-    await game.actors
-      .filter((actor) => actor.type == "vehicule")
-      .forEach(async (actor) => {
-        await actor.update({
+    await Promise.all(
+      game.actors.filter(actor => actor.type == "vehicule")
+        .map(actor => actor.update({
           'system.etat.resistance.value': actor.system.resistance,
           'system.etat.resistance.max': actor.system.resistance,
           'system.etat.structure.value': actor.system.structure,
           'system.etat.structure.max': actor.system.structure
-        })
-      });
+        }))
+    )
   }
 }
 
@@ -192,9 +187,9 @@ class _10_2_5_ArmesTirLancer extends Migration {
   get version() { return "10.2.5"; }
 
   migrateArmeTirLancer(it) {
-    let updates = foundry.utils.mergeObject({ _id: it.id }, this.getMapping(it).updates);
-    console.log(it.name, updates);
-    return updates;
+    const updates = foundry.utils.mergeObject({ _id: it.id }, this.getMapping(it).updates)
+    console.log(it.name, updates)
+    return updates
   }
 
   async migrate() {

module/misc.js

@@ -24,6 +24,13 @@ export class Misc {
     return text.charAt(0).toLowerCase() + text.slice(1);
   }
 
+ static stripHtml(html)
+  {
+    const tmp = document.createElement("DIV")
+    tmp.innerHTML = html
+    return tmp.textContent || tmp.innerText || ""
+  }
+
   static toSignedString(number) {
     const value = parseInt(number)
     const isPositiveNumber = value != NaN && value > 0;
@@ -134,12 +141,12 @@ export class Misc {
     return itemsBy
   }
 
-  static classifyFirst(items, classifier) {
+  static classifyFirst(items, classifier, classified = it => it) {
     let itemsBy = {};
     for (const item of items) {
       const classification = classifier(item);
       if (!itemsBy[classification]) {
-        itemsBy[classification] = item;
+        itemsBy[classification] = classified(item);
       }
     }
     return itemsBy;
@@ -180,11 +187,15 @@ export class Misc {
     return (a, b) => a + separator + b;
   }
 
-  static connectedGMOrUser(ownerId = undefined) {
-    if (ownerId && game.user.id == ownerId) {
-      return ownerId;
+  static connectedUserOrGM(userId = undefined) {
+    if (userId && game.user.id == userId) {
+      return userId
     }
-    return Misc.firstConnectedGM()?.id ?? game.user.id;
+    return Misc.firstConnectedGM()?.id
+  }
+
+  static connectedGMOrUser(userId = undefined) {
+    return Misc.connectedUserOrGM(userId) ?? game.user.id
   }
 
   static isRollModeHiddenToPlayer() {
@@ -220,8 +231,10 @@ export class Misc {
    *  and there is no connected GM
    */
   static documentIfResponsible(document) {
-    if (game.users.activeGM || (Misc.connectedGMs().length == 0 && Misc.isFirstOwnerPlayer(document))) {
-      return document
+    if (Misc.isFirstConnectedGM() || (Misc.connectedGMs().length == 0 && Misc.isFirstOwnerPlayer(document))) {
+      if (document.isOwner) {
+        return document
+      }
     }
     return undefined
   }
@@ -230,16 +243,16 @@ export class Misc {
     if (Misc.isOwnerPlayer(document)) {
       return await action(document)
     } else {
-      return await orElse(document ?? {name: '<aucune sélection>'})
+      return await orElse(document ?? { name: '<aucune sélection>' })
     }
   }
 
   static isOwnerPlayer(document) {
-    return document && document.testUserPermission && document.testUserPermission(game.user, CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER)
+    return document?.isOwner
   }
 
   static isFirstOwnerPlayer(document) {
-    if (!document?.testUserPermission) {
+    if (!document?.isOwner) {
       return false
     }
     return game.users.find(u => document.testUserPermission(u, CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER)) == game.user
@@ -249,7 +262,7 @@ export class Misc {
    * @returns true pour un seul utilisateur: le premier GM connecté par ordre d'id
    */
   static isFirstConnectedGM() {
-    return game.user == game.users.activeGM
+    return game.users.activeGM != undefined && game.user == game.users.activeGM
   }
 
   static hasConnectedGM() {

module/moral/apprecier.mjs

@@ -104,7 +104,7 @@ export class Apprecier {
 
   apprecier(callbacks = []) {
     if (this.qualite <= 0) {
-      this.raisons.push(`la qualité ${this.qualite} est négative.`)
+      this.raisons.push(`la qualité ${this.qualite} est insuffisante.`)
     }
     if (this.qualite <= this.actor.getMoralTotal()) {
       this.raisons.push(`la qualité de ${this.qualite} est inférieure au moral de ${this.actor.getMoralTotal()}.`)

module/rdd-bonus.js

@@ -70,7 +70,7 @@ export class RdDBonus {
       dmgParticuliere: RdDBonus._dmgParticuliere(rollData),
       dmgSurprise: rollData.opponent?.surprise?.dmg ?? 0,
       mortalite: RdDBonus.mortalite(attaque.dmg?.mortalite, arme?.system.mortalite),
-      dmgActor: RdDBonus.bonusDmg(actor, attaque.carac.key, dmgArme, attaque.forceRequise),
+      dmgActor: RdDBonus.bonusDmg(actor, attaque.carac?.key, dmgArme, attaque.forceRequise),
       dmgForceInsuffisante: Math.min(0, actor.getForce() - (attaque.forceRequise ?? 0)),
       dmgDiffLibre: ReglesOptionnelles.isUsing('degat-ajout-malus-libre') ? Math.abs(attaque.diff ?? 0) : 0
     }

module/rdd-carac.js

@@ -61,7 +61,9 @@ export const CARACS = {
   DEROBEE: 'derobee',
   CHANCE_ACTUELLE: 'chance-actuelle',
   REVE_ACTUEL: 'reve-actuel',
+  VIE: 'vie'
 }
+
 export const LIST_CARAC_PERSONNAGE = {
   [CARACS.TAILLE]: { code: CARACS.TAILLE, label: 'Taille', isCarac: true, path: 'system.carac.taille.value' },
   [CARACS.APPARENCE]: { code: CARACS.APPARENCE, label: 'Apparence', isCarac: true, path: 'system.carac.apparence.value' },
@@ -166,10 +168,18 @@ export class RdDCarac {
     const total = Object.values(carac ?? {}).filter(c => !c.derivee)
       .map(it => parseInt(it.value))
       .reduce(Misc.sum(), 0);
-    const beauteSuperieur10 = Math.max((beaute ?? 10) - 10, 0);
+    const beauteSuperieur10 = Math.max((beaute ?? 10) - 10, 0)
     return total + beauteSuperieur10;
   }
 
+  static computeTotalXp(carac, beaute = undefined) {
+    const totalXp = Object.values(carac ?? {}).filter(c => !c.derivee)
+      .map(it => RdDCarac.getCaracXp(0, Misc.toInt(it.value)) + Misc.toInt(it.xp))
+      .reduce(Misc.sum(), 0);
+    const beauteXp = beaute > 10 ? RdDCarac.getCaracXp(10, beaute) : 0
+    return totalXp + beauteXp;
+  }
+
   static levelUp(it) {
     it.xpNext = RdDCarac.getCaracNextXp(it.value);
     it.isLevelUp = (it.xp >= it.xpNext);
@@ -182,12 +192,16 @@ export class RdDCarac {
 
   /* -------------------------------------------- */
   static getCaracNextXp(value) {
-    const nextValue = Number(value) + 1;
+    value = Number(value);
+    const nextValue = value + 1;
     // xp est le coût pour atteindre cette valeur, on regarde donc le coût de la valeur+1
-    return RdDCarac.getCaracXp(nextValue);
+    return RdDCarac.getCaracXp(value, nextValue)
   }
 
-  static getCaracXp(targetValue) {
-    return RdDCarac.getCaracDerivee(targetValue)?.xp ?? 200;
+  static getCaracXp(from, to) {
+    return Array.from({ length: to - from },
+      (_, i) => from + i + 1)
+      .map(it => RdDCarac.getCaracDerivee(it)?.xp ?? 200)
+      .reduce(Misc.sum(), 0)
   }
 }

module/rdd-combat.js

@@ -63,6 +63,11 @@ export class RdDCombatManager extends Combat {
       it.token.id == tokenId
     )
   }
+
+  static getRangInitiativeCombatant(actorId, tokenId) {
+    const combatant = RdDCombatManager.getCombatant(actorId, tokenId)
+    return combatant?.system.init?.rang
+  }
   /* -------------------------------------------- */
   async nextRound() {
     await this.finDeRound();
@@ -383,7 +388,7 @@ export class RdDCombat {
 
   /* -------------------------------------------- */
   static onMsgEncaisser(msg) {
-    let defender = canvas.tokens.get(msg.defenderToken.id).actor;
+    let defender = canvas.tokens.get(msg.defenderToken.id)?.actor;
     if (Misc.isOwnerPlayer(defender)) {
       let attackerRoll = msg.attackerRoll;
       let attacker = msg.attackerId ? game.actors.get(msg.attackerId) : undefined;
@@ -462,24 +467,10 @@ export class RdDCombat {
     this.defenderId = this.defender.id
     this.attackerTokenId = attackerTokenId
     this.defenderTokenId = defenderTokenId
-    this.attackerToken = RdDCombat.$extractAttackerTokenData(attacker, attackerTokenId)
-    this.defenderToken = RdDCombat.$extractDefenderTokenData(defender, defenderTokenId, target)
+    this.attackerToken = Targets.getTokenData(attacker, attackerTokenId)
+    this.defenderToken = Targets.getTokenData(defender, defenderTokenId, target)
   }
 
-  static $extractAttackerTokenData(attacker, attackerTokenId) {
-    const token = canvas.tokens.get(attackerTokenId);
-    return token ? Targets.extractTokenData(token) : Targets.buildActorTokenData(attackerTokenId, attacker)
-  }
-
-  static $extractDefenderTokenData(defender, defenderTokenId, target) {
-    if (target) {
-      return Targets.extractTokenData(target)
-    }
-    const token = canvas.tokens.get(defenderTokenId);
-    return token ? Targets.extractTokenData(token) : Targets.buildActorTokenData(defenderTokenId, defender)
-  }
-
-
   /* -------------------------------------------- */
   async onEvent(button, event) {
     const chatMessage = ChatUtility.getChatMessage(event);
@@ -514,8 +505,8 @@ export class RdDCombat {
   /* -------------------------------------------- */
   attaqueChanceuse(attackerRoll) {
     ui.notifications.info("L'attaque est rejouée grâce à la chance")
-    attackerRoll.essais.attaqueChance = true;
-    this.attaque(attackerRoll, attackerRoll.arme);
+    attackerRoll.essais.attaqueChance = true
+    this.attaque(attackerRoll, attackerRoll.arme)
   }
 
   /* -------------------------------------------- */
@@ -642,11 +633,11 @@ export class RdDCombat {
     }
   }
 
-  async attaqueV2() {
+  async attaqueV2(options = undefined) {
     if (!await this.attacker.accorder(this.defender, 'avant-attaque')) {
       return
     }
-    await this.doRollAttaque({
+    const rollData = {
       ids: {
         actorId: this.attackerId,
         actorTokenId: this.attackerTokenId,
@@ -654,8 +645,19 @@ export class RdDCombat {
         opponentTokenId: this.defenderTokenId,
       },
       type: { allowed: ['attaque'], current: 'attaque' },
+      selected: {},
       passeArme: foundry.utils.randomID(16),
-    })
+    }
+    if (options) {
+      rollData.selected = {
+        attaque: {
+          comp: { id: options.comp.id },
+          arme: { id: options.arme.id },
+          main: options.main
+        }
+      }
+    }
+    await this.doRollAttaque(rollData)
   }
 
   async doRollAttaque(rollData, callbacks = []) {
@@ -721,7 +723,7 @@ export class RdDCombat {
 
     const choixDefense = await ChatMessage.create({
       // message privé: du défenseur à lui même (et aux GMs)
-      speaker: ChatMessage.getSpeaker(this.defender, canvas.tokens.get(this.defenderTokenId)),
+      speaker: ChatMessage.getSpeaker({ actor: this.defender, token: canvas.tokens.get(this.defenderTokenId) }),
       alias: this.attacker?.getAlias(),
       whisper: ChatUtility.getOwners(this.defender),
       content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-demande-defense.hbs', defenseData)
@@ -736,12 +738,14 @@ export class RdDCombat {
   }
 
   /* -------------------------------------------- */
-  async attaque(competence, arme) {
+  async attaque(competence, arme, main) {
     if (!await this.attacker.accorder(this.defender, 'avant-attaque')) {
       return
     }
     if (OptionsAvancees.isUsing(ROLL_DIALOG_V2)) {
-      return this.attacker.rollCompetence(competence.name, { arme: arme })
+      return this.attaqueV2(
+        { comp: competence, arme: arme, main: main }
+      )
     }
     if (arme.system.cac == EMPOIGNADE) {
       RdDEmpoignade.onAttaqueEmpoignade(this.attacker, this.defender)
@@ -750,7 +754,7 @@ export class RdDCombat {
     RdDEmpoignade.checkEmpoignadeEnCours(this.attacker)
 
     let rollData = this._prepareAttaque(competence, arme)
-    console.log("RdDCombat.attaque >>>", rollData);
+    console.log("RdDCombat.attaque >>>", rollData)
     if (arme) {
       this.attacker.verifierForceMin(arme);
     }
@@ -775,7 +779,7 @@ export class RdDCombat {
   /* -------------------------------------------- */
   _prepareAttaque(competence, arme) {
     let rollData = {
-      mode: ROLL_TYPE_ATTAQUE,
+      mode: 'attaque',
       alias: this.attacker?.getAlias(),
       passeArme: foundry.utils.randomID(16),
       mortalite: arme?.system.mortalite,
@@ -925,7 +929,7 @@ export class RdDCombat {
   async _chatMessageDefense(paramDemandeDefense, defenderRoll) {
     const choixDefense = await ChatMessage.create({
       // message privé: du défenseur à lui même (et aux GMs)
-      speaker: ChatMessage.getSpeaker(this.defender, canvas.tokens.get(this.defenderTokenId)),
+      speaker: ChatMessage.getSpeaker({ actor: this.defender, token: canvas.tokens.get(this.defenderTokenId) }),
       alias: this.attacker?.getAlias(),
       whisper: ChatUtility.getOwners(this.defender),
       content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-demande-defense-v1.hbs', paramDemandeDefense),
@@ -992,9 +996,9 @@ export class RdDCombat {
     const arme = rollData.arme;
     const avecArme = !['', 'sans-armes', 'armes-naturelles'].includes(arme?.system.categorie_parade ?? '');
     const action = (rollData.attackerRoll ? (arme ? "la parade" : "l'esquive") : "l'attaque");
-    ChatUtility.createChatWithRollMode(
+    await ChatMessage.create(ChatUtility.adaptVisibility(
       { content: `<strong>Maladresse à ${action}!</strong> ` + await RdDRollTables.getMaladresse({ arme: avecArme }) },
-      this.defender)
+      { actor: this.defender }))
   }
 
   /* -------------------------------------------- */
@@ -1118,9 +1122,9 @@ export class RdDCombat {
   async infoAttaquantDesarme(rollData) {
     if (/*TODO: parade?*/!rollData.attackerRoll?.particuliere) {
       // TODO: attaquant doit jouer résistance et peut être désarmé p132
-      ChatUtility.createChatWithRollMode(
+      await ChatMessage.create(ChatUtility.adaptVisibility(
         { content: `(à gérer) L'attaquant doit jouer résistance et peut être désarmé (p132)` },
-        this.defender)
+        { actor: this.defender }))
     }
   }
 
@@ -1152,9 +1156,9 @@ export class RdDCombat {
     console.log("RdDCombat._onParadeParticuliere >>>", defenderRoll);
     if (!defenderRoll.attackerRoll.isPart) {
       // TODO: attaquant doit jouer résistance et peut être désarmé p132
-      ChatUtility.createChatWithRollMode(
+      await ChatMessage.create(ChatUtility.adaptVisibility(
         { content: `(à gérer) L'attaquant doit jouer résistance et peut être désarmé (p132)` },
-        this.defender)
+        { actor: this.defender }))
     }
   }
   /* -------------------------------------------- */
@@ -1239,9 +1243,9 @@ export class RdDCombat {
   /* -------------------------------------------- */
   async _onEsquiveParticuliere(defenderRoll) {
     console.log("RdDCombat._onEsquiveParticuliere >>>", defenderRoll);
-    ChatUtility.createChatWithRollMode(
+    await ChatMessage.create(ChatUtility.adaptVisibility(
       { content: "<strong>Vous pouvez esquiver une deuxième fois!</strong>" },
-      this.defender);
+      { actor: this.defender }))
   }
 
   /* -------------------------------------------- */
@@ -1378,6 +1382,7 @@ export class RdDCombat {
       return
     }
     const alias = token?.name ?? actor.getAlias();
+    const blessuresGraves = actor.countBlessures(it => it.isGrave());
     const formData = {
       combatId: combat._id,
       alias: alias,
@@ -1388,7 +1393,7 @@ export class RdDCombat {
       actorId: actor.id,
       actor: actor,
       tokenId: token.id,
-      isGrave: actor.countBlessures(it => it.isGrave()) > 0,
+      blessuresGraves: blessuresGraves,
       isCritique: actor.countBlessures(it => it.isCritique()) > 0
     }
     await ChatMessage.create({

module/rdd-commands.js

@@ -27,20 +27,8 @@ const rddRollNumeric = /^(\d+)\s*([\+\-]?\d+)?\s*(s)?/;
 export class RdDCommands {
 
   static init() {
-    const rddCommands = new RdDCommands();
-    game.system.rdd.commands = rddCommands;
-
-    Hooks.on("chatMessage", (html, content, msg) => {
-      if (content[0] == '/') {
-        let regExp = /(\S+)/g;
-        let commands = content.match(regExp);
-        if (rddCommands.processChatCommand(commands, content, msg)) {
-          return false;
-        }
-      }
-      return true;
-    });
-
+    game.system.rdd.commands = new RdDCommands()
+    Hooks.on("chatMessage", (chatLog, message, msg) => game.system.rdd.commands.onChatMessage(message, msg))
   }
 
   constructor() {
@@ -116,6 +104,7 @@ export class RdDCommands {
     this.registerCommand({
       path: ["/xp", "carac"], func: (content, msg, params) => this.getCoutXpCarac(msg, params),
       descr: `Détermine le coût d'expérience pour augmenter une caractéristique. Exemples:
+        <br>/xp carac 12 15: coût pour passer de 12 15
         <br>/xp carac 15: coût pour atteindre 15 (depuis 14)`
     });
 
@@ -215,6 +204,17 @@ export class RdDCommands {
   }
 
 
+  onChatMessage(message, msg = {}) {
+    const content = Misc.stripHtml(message)
+    if (content[0] == '/') {
+      const commands = content.match(/(\S+)/g)
+      if (this.processChatCommand(commands, content, msg)) {
+        return false
+      }
+    }
+    return true
+  }
+
   /* -------------------------------------------- */
   /* Manage chat commands */
   processChatCommand(commandLine, content = '', msg = {}) {
@@ -440,13 +440,18 @@ export class RdDCommands {
 
   /* -------------------------------------------- */
   getCoutXpCarac(msg, params) {
-    if (params && params.length == 1) {
-      let to = Number(params[0]);
-      return RdDCommands._chatAnswer(msg, `Coût pour passer une caractéristique de ${to - 1} à ${to}: ${RdDCarac.getCaracXp(to)}`);
-    }
-    else {
-      return false;
+    if (params) {
+      if (params.length == 1) {
+        const to = Number(params[0])
+        return RdDCommands._chatAnswer(msg, `Coût pour passer une caractéristique de ${to - 1} à ${to}: ${RdDCarac.getCaracXp(to - 1, to)}`);
+      }
+      if (params.length == 2) {
+        const from = Number(params[0]);
+        const to = Number(params[1]);
+        return RdDCommands._chatAnswer(msg, `Coût pour passer une caractéristique de ${from} à ${to}: ${RdDCarac.getCaracXp(from, to)}`);
+      }
     }
+    return false
   }
 
   async creerSignesDraconiques() {

module/rdd-empoignade.js

@@ -15,21 +15,28 @@ export class RdDEmpoignade {
   }
 
   /* -------------------------------------------- */
+  static getActorEmpoignade(actorId) {
+    const actor = game.actors.get(actorId)
+    if (actor == undefined) {
+      ui.notifications.warn(`Impossible de retrouver l'acteur ${actorId}, l'empoignade ne peut pas être continuée.`)
+    }
+    return actor
+  }
+
   static isCombatantEmpoignade(actorId, tokenId) {
     const combatant = RdDCombatManager.getCombatant(actorId, tokenId)
-    return MAP_PHASE.empoignade.rang == combatant?.system.init?.rang
+    return combatant && MAP_PHASE.empoignade.rang == combatant?.system.init?.rang
   }
 
   static async ajustementEmpoignade(attacker, defender, adjust = 1) {
     let empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)
     if (empoignade?.system.empoigneurid == defender.id) {
-      let empoignade = RdDEmpoignade.getEmpoignade(defender, attacker)
+      empoignade = RdDEmpoignade.getEmpoignade(defender, attacker)
       return await RdDEmpoignade.$ajustementEmpoignade(empoignade, defender, attacker, - adjust);
     }
     return await RdDEmpoignade.$ajustementEmpoignade(empoignade, attacker, defender, adjust);
   }
 
-
   static async $ajustementEmpoignade(empoignade, attacker, defender, adjust) {
     const empId = empoignade?.system.empoignadeid ?? foundry.utils.randomID(16);
     const empFin = (empoignade?.system.pointsemp ?? 0) + adjust
@@ -73,30 +80,32 @@ export class RdDEmpoignade {
       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))
-    });
+      const attacker = RdDEmpoignade.getActorFromEventTag(event, 'data-attackerId')
+      const defender = RdDEmpoignade.getActorFromEventTag(event, 'data-defenderId')
+      if (attacker && defender) {
+        RdDEmpoignade.onAttaqueEmpoignadeValidee(attacker, defender)
+      }
+    })
     $(html).on("click", '.empoignade-entrainer-sol', event => {
       const chatMessage = ChatUtility.getChatMessage(event);
       const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
       RdDEmpoignade.entrainerAuSol(rollData)
       ChatUtility.remover(chatMessage)()
-    });
+    })
     $(html).on("click", '.empoignade-projeter-sol', event => {
       const chatMessage = ChatUtility.getChatMessage(event);
       const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
       RdDEmpoignade.projeterAuSol(rollData)
       ChatUtility.remover(chatMessage)()
-    });
+    })
     $(html).on("change", '.empoignade-perte-endurance', event => {
       const chatMessage = ChatUtility.getChatMessage(event);
       const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
@@ -104,7 +113,11 @@ export class RdDEmpoignade {
         RdDEmpoignade.perteEndurance(rollData, event.currentTarget.value)
         ChatUtility.remover(chatMessage)()
       }
-    });
+    })
+  }
+
+  static getActorFromEventTag(event, tag) {
+    return RdDEmpoignade.getActorEmpoignade(event.currentTarget.attributes[tag]?.value ?? '<inconnu>')
   }
 
   /* -------------------------------------------- */
@@ -112,32 +125,31 @@ export class RdDEmpoignade {
     // TODO: autoriser la perception? la comédie/séduction?
     if (RdDEmpoignade.isEmpoignadeEnCours(actor)) {
       ui.notifications.warn("Une empoignade est en cours ! Normalement, vous ne pouvez rien faire d'autre que continuer l'empoignade ou la rompre.")
-      return true;
+      return true
     }
-    return false;
+    return false
   }
 
   /* -------------------------------------------- */
   static $storeRollEmpoignade(msg, rollData) {
-    RdDEmpoignade.$reduceActorToIds(rollData);
-    ChatUtility.setMessageData(msg, "empoignade-roll-data", rollData);
+    ChatUtility.setMessageData(msg, "empoignade-roll-data", RdDEmpoignade.$reduceActorToIds(rollData))
   }
 
   static $reduceActorToIds(rollData) {
-    rollData.attacker = { id: rollData.attacker.id };
-    rollData.defender = { id: rollData.defender.id };
+    rollData.attacker = { id: rollData.attacker.id }
+    rollData.defender = { id: rollData.defender.id }
+    return rollData
   }
 
   /* -------------------------------------------- */
   static $readRollEmpoignade(msg) {
-    const rollData = ChatUtility.getMessageData(msg, 'empoignade-roll-data');
-    RdDEmpoignade.$replaceIdsWithActors(rollData);
-    return rollData
+    return RdDEmpoignade.$replaceIdsWithActors(ChatUtility.getMessageData(msg, 'empoignade-roll-data'))
   }
 
   static $replaceIdsWithActors(rollData) {
-    rollData.attacker = game.actors.get(rollData.attacker.id);
-    rollData.defender = game.actors.get(rollData.defender.id);
+    rollData.attacker = RdDEmpoignade.getActorEmpoignade(rollData.attacker.id)
+    rollData.defender = RdDEmpoignade.getActorEmpoignade(rollData.defender.id)
+    return rollData
   }
 
   /* -------------------------------------------- */
@@ -147,19 +159,21 @@ export class RdDEmpoignade {
 
   /* -------------------------------------------- */
   static getEmpoignadeById(actor, id) {
-    return actor.itemTypes[ITEM_TYPES.empoignade].find(it => it.system.empoignadeid == id)
+    return actor?.itemTypes[ITEM_TYPES.empoignade].find(it => it.system.empoignadeid == id)
   }
 
   /* -------------------------------------------- */
   static getEmpoignade(attacker, defender) {
-    let emp = attacker.itemTypes[ITEM_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 foundry.utils.duplicate(emp);
+    if (attacker && defender) {
+      const empoignade = attacker.itemTypes[ITEM_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 (empoignade) {
+        return foundry.utils.duplicate(empoignade)
+      }
     }
-    return undefined;
+    return undefined
   }
 
   /* -------------------------------------------- */
@@ -180,10 +194,14 @@ export class RdDEmpoignade {
   }
 
   static isActionAutorisee(mode, attacker, defender) {
-    const acting = RdDEmpoignade.isActionDefenseur(mode) ? defender : attacker;
+    if (!defender || !attacker) {
+      return false
+    }
+
+    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 false
     }
     return true
   }
@@ -205,14 +223,11 @@ export class RdDEmpoignade {
     let empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)
     const isNouvelle = empoignade == undefined;
     empoignade = empoignade ?? (await RdDEmpoignade.createEmpoignade(attacker, defender))
-    //console.log("W.", empoignade, defender.hasArmeeMeleeEquipee())
     if ((isNouvelle || empoignade.system.pointsemp == 0) && defender.hasArmeeMeleeEquipee()) {
-      ChatUtility.createChatWithRollMode(
-        {
-          content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-empoignade-valider.hbs`, { attacker: attacker, defender: defender })
-        },
-        attacker
-      )
+      await ChatMessage.create(ChatUtility.adaptVisibility(
+        { content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-empoignade-valider.hbs`, { attacker: attacker, defender: defender }) },
+        { actor: attacker }
+      ))
     } else {
       await this.onAttaqueEmpoignadeValidee(attacker, defender)
     }
@@ -264,30 +279,34 @@ export class RdDEmpoignade {
 
   /* -------------------------------------------- */
   static async onAttaqueEmpoignadeFromItem(empoignade) {
-    let attacker = game.actors.get(empoignade.system.empoigneurid)
-    let defender = game.actors.get(empoignade.system.empoigneid)
-    await this.onAttaqueEmpoignadeValidee(attacker, defender)
+    const attacker = RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneurid)
+    const defender = RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneid)
+    if (attacker && defender) {
+      await this.onAttaqueEmpoignadeValidee(attacker, defender)
+    }
   }
 
   static async onImmobilisation(attacker, empoignade) {
-    const defender = game.actors.get(empoignade.system.empoigneid)
-    const empDefenseur = defender.itemTypes[ITEM_TYPES.empoignade]
-      .find(it => it.system.empoignadeid == empoignade.system.empoignadeid);
-    await defender.updateEmbeddedDocuments('Item', [{
-      _id: empDefenseur.id,
-      'system.immobilise': true
-    }])
-    const rollData = {
-      mode: "immobilise",
-      empoignade, attacker, defender,
-      isEmpoignade: true,
-      competence: attacker.getCompetenceCorpsACorps()
+    const defender = RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneid)
+    if (defender) {
+      const empDefenseur = defender.itemTypes[ITEM_TYPES.empoignade]
+        .find(it => it.system.empoignadeid == empoignade.system.empoignadeid);
+      await defender.updateEmbeddedDocuments('Item', [{
+        _id: empDefenseur.id,
+        'system.immobilise': true
+      }])
+      const rollData = {
+        mode: "immobilise",
+        empoignade, attacker, defender,
+        isEmpoignade: true,
+        competence: attacker.getCompetenceCorpsACorps()
+      }
+      const msg = await ChatMessage.create({
+        whisper: ChatUtility.getOwners(attacker),
+        content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-empoignade-immobilise.hbs`, rollData)
+      })
+      RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
     }
-    const msg = await ChatMessage.create({
-      whisper: ChatUtility.getOwners(attacker),
-      content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-empoignade-immobilise.hbs`, rollData)
-    })
-    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
   }
 
   /* -------------------------------------------- */
@@ -304,30 +323,30 @@ export class RdDEmpoignade {
 
   /* -------------------------------------------- */
   static async $onRollEmpoignade(rollData, isNouvelle = false) {
-    let attacker = game.actors.get(rollData.attacker.id)
-    let defender = game.actors.get(rollData.defender.id)
+    const attacker = RdDEmpoignade.getActorEmpoignade(rollData.attacker.id)
+    const defender = RdDEmpoignade.getActorEmpoignade(rollData.defender.id)
 
+    if (attacker && defender) {
+      if (rollData.rolled.isSuccess && isNouvelle) {
+        RdDEmpoignade.$createEtatEmpoignade(rollData.empoignade)
+      }
 
-    if (rollData.rolled.isSuccess && isNouvelle) {
-      RdDEmpoignade.$createEtatEmpoignade(rollData.empoignade)
+      rollData.empoignade.isSuccess = rollData.rolled.isSuccess;
+      if (rollData.rolled.isPart) {
+        rollData.particuliere = "finesse";
+      }
+      let msg = await RdDRollResult.displayRollData(rollData, defender, 'chat-empoignade-resultat.hbs');
+      RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
     }
-
-    rollData.empoignade.isSuccess = rollData.rolled.isSuccess;
-    if (rollData.rolled.isPart) {
-      rollData.particuliere = "finesse";
-    }
-    let msg = await RdDRollResult.displayRollData(rollData, defender, 'chat-empoignade-resultat.hbs');
-    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
   }
 
   /* -------------------------------------------- */
   static async onDefenseEmpoignade(attackerRoll, mode, competenceName = "Corps à corps", carac = "melee") {
-    let attacker = game.actors.get(attackerRoll.attacker.id)
-    let defender = game.actors.get(attackerRoll.defender.id)
+    const attacker = RdDEmpoignade.getActorEmpoignade(rollData.attacker.id)
+    const defender = RdDEmpoignade.getActorEmpoignade(rollData.defender.id)
     if (!RdDEmpoignade.isActionAutorisee(mode, attacker, defender)) {
       return
     }
-
     let empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)
 
     if (!empoignade) {
@@ -367,7 +386,7 @@ export class RdDEmpoignade {
 
   /* -------------------------------------------- */
   static async $onRollContrerLiberer(rollData) {
-    let empoignade = rollData.empoignade
+    const empoignade = rollData.empoignade
 
     if (rollData.mode == "contrer-empoigner" && !rollData.rolled.isSuccess) {
       empoignade.system.pointsemp++
@@ -389,35 +408,40 @@ export class RdDEmpoignade {
   static async $createEtatEmpoignade(empoignade) {
     console.log("CREATE Empoignade", empoignade)
 
-    let defender = game.actors.get(empoignade.system.empoigneid)
-    let attacker = game.actors.get(empoignade.system.empoigneurid)
+    const attacker = RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneurid)
+    const defender = RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneid)
 
-    // Creer l'empoignade sur attaquant/defenseur
-    await attacker.creerObjetParMJ(empoignade)
-    await defender.creerObjetParMJ(empoignade)
+    if (attacker && defender) {
+      // Creer l'empoignade sur attaquant et defenseur
+      await attacker.creerObjetParMJ(empoignade)
+      await defender.creerObjetParMJ(empoignade)
+    }
   }
 
   /* -------------------------------------------- */
   static async $updateEtatEmpoignade(empoignade, attacker, defender) {
-    const belligerants = [
-      attacker ?? game.actors.get(empoignade.system.empoigneurid),
-      defender ?? game.actors.get(empoignade.system.empoigneid)]
-    const removeEmp = empoignade.system.pointsemp == 0
+    attacker = attacker ?? RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneurid)
+    defender = defender ?? RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneid)
 
-    if (removeEmp) {
-      const emp = RdDEmpoignade.getEmpoignadeById(attacker, empoignade.system.empoignadeid)
-      return await attacker.deleteEmbeddedDocuments('Item', [emp.id])
-    }
-    else {
-      await Promise.all(
-        belligerants.map(async belligerant => {
-          const emp = RdDEmpoignade.getEmpoignadeById(belligerant, empoignade.system.empoignadeid)
-          return await belligerant.updateEmbeddedDocuments('Item', [{
-            _id: emp.id,
-            "system.pointsemp": empoignade.system.pointsemp,
-            "system.ausol": empoignade.system.ausol
-          }])
-        }))
+    if (attacker && defender) {
+      const belligerants = [attacker, defender]
+      const removeEmp = empoignade.system.pointsemp == 0
+
+      if (removeEmp) {
+        const emp = RdDEmpoignade.getEmpoignadeById(attacker, empoignade.system.empoignadeid)
+        return await attacker.deleteEmbeddedDocuments('Item', [emp.id])
+      }
+      else {
+        await Promise.all(
+          belligerants.map(async belligerant => {
+            const emp = RdDEmpoignade.getEmpoignadeById(belligerant, empoignade.system.empoignadeid)
+            return await belligerant.updateEmbeddedDocuments('Item', [{
+              _id: emp.id,
+              "system.pointsemp": empoignade.system.pointsemp,
+              "system.ausol": empoignade.system.ausol
+            }])
+          }))
+      }
     }
   }
 
@@ -425,19 +449,21 @@ export class RdDEmpoignade {
   static async $deleteEmpoignade(empoignade) {
     console.log("DELETE Empoignade", empoignade)
 
-    const defender = game.actors.get(empoignade.system.empoigneid)
-    const emp = RdDEmpoignade.getEmpoignadeById(defender, empoignade.system.empoignadeid)
-    await defender.deleteEmbeddedDocuments('Item', [emp.id])
+    const defender = RdDEmpoignade.getActorEmpoignade(empoignade.system.empoigneid)
+    if (defender) {
+      const emp = RdDEmpoignade.getEmpoignadeById(defender, empoignade.system.empoignadeid)
+      await defender.deleteEmbeddedDocuments('Item', [emp.id])
+    }
   }
 
   /* -------------------------------------------- */
   static async entrainerAuSol(rollData) {
-    let attacker = game.actors.get(rollData.attacker.id)
-    let defender = game.actors.get(rollData.defender.id)
+    const attacker = RdDEmpoignade.getActorEmpoignade(rollData.attacker.id)
+    const defender = RdDEmpoignade.getActorEmpoignade(rollData.defender.id)
     if (!RdDEmpoignade.isActionAutorisee("immobilise", attacker, defender)) {
       return
     }
-    let empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)
+    const empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)
 
     empoignade.system.ausol = true
     await this.$updateEtatEmpoignade(empoignade)
@@ -445,14 +471,14 @@ export class RdDEmpoignade {
     await attacker.setEffect(STATUSES.StatusProne, true);
     await defender.setEffect(STATUSES.StatusProne, true);
 
-    let msg = await RdDRollResult.displayRollData(rollData, attacker, 'chat-empoignade-entrainer-sol.hbs');
+    const msg = await RdDRollResult.displayRollData(rollData, attacker, 'chat-empoignade-entrainer-sol.hbs');
     RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
   }
 
   /* -------------------------------------------- */
   static async projeterAuSol(rollData) {
-    let attacker = game.actors.get(rollData.attacker.id)
-    let defender = game.actors.get(rollData.defender.id)
+    const attacker = RdDEmpoignade.getActorEmpoignade(rollData.attacker.id)
+    const defender = RdDEmpoignade.getActorEmpoignade(rollData.defender.id)
     if (!RdDEmpoignade.isActionAutorisee("immobilise", attacker, defender)) {
       return
     }
@@ -467,8 +493,8 @@ export class RdDEmpoignade {
 
   /* -------------------------------------------- */
   static async perteEndurance(rollData, perteMode) {
-    let attacker = game.actors.get(rollData.attacker.id)
-    let defender = game.actors.get(rollData.defender.id)
+    const attacker = RdDEmpoignade.getActorEmpoignade(rollData.attacker.id)
+    const defender = RdDEmpoignade.getActorEmpoignade(rollData.defender.id)
     if (perteMode == "none" || !RdDEmpoignade.isActionAutorisee("immobilise", attacker, defender)) {
       return
     }
@@ -501,11 +527,11 @@ export class RdDEmpoignade {
 
   /* -------------------------------------------- */
   static async deleteLinkedEmpoignade(actorId, empoignade) {
-    let actorDeleteId = (actorId == empoignade.system.empoigneurid) ? empoignade.system.empoigneid : empoignade.system.empoigneurid
-    let actor = game.actors.get(actorDeleteId)
-    let emp = this.getEmpoignadeById(actor, empoignade.system.empoignadeid)
-    if (emp) {
-      await actor.deleteEmbeddedDocuments('Item', [emp.id])
+    const actorDeleteId = (actorId == empoignade.system.empoigneurid) ? empoignade.system.empoigneid : empoignade.system.empoigneurid
+    const actor = RdDEmpoignade.getActorEmpoignade(actorDeleteId)
+    const empoignadeOpposant = this.getEmpoignadeById(actor, empoignade.system.empoignadeid)
+    if (actor && empoignadeOpposant) {
+      await actor.deleteEmbeddedDocuments('Item', [empoignadeOpposant.id])
     }
   }
 

module/rdd-hotbar-drop.js

@@ -101,7 +101,7 @@ export class RdDHotbar {
   }
 
   /** Roll macro */
-  static rollMacro(itemName, itemType, categorieArme = 'competence') {
+  static rollMacro(itemName, itemType, maniement = 'competence') {
     const speaker = ChatMessage.getSpeaker();
     let actor;
     if (speaker.token) actor = game.actors.tokens[speaker.token];
@@ -117,10 +117,10 @@ export class RdDHotbar {
     // Trigger the item roll
     switch (item.type) {
       case ITEM_TYPES.arme:
-        return actor.rollArme(item, categorieArme);
+        return actor.rollArme(item, maniement);
       case ITEM_TYPES.competence:
         if (item.isCorpsACorps()) {
-          switch (categorieArme) {
+          switch (maniement) {
             case PUGILAT:
               return actor.rollArme(RdDItemArme.pugilat(actor));
             case EMPOIGNADE:
@@ -130,7 +130,7 @@ export class RdDHotbar {
         return actor.rollCompetence(item);
       case ITEM_TYPES.competencecreature:
         return item.system.iscombat
-          ? actor.rollArme(item, categorieArme)
+          ? actor.rollArme(item, maniement)
           : actor.rollCompetence(item);
 
     }

module/rdd-main.js

@@ -1,5 +1,7 @@
 import { SYSTEM_RDD, SYSTEM_SOCKET_ID, RDD_CONFIG, ITEM_TYPES } from "./constants.js"
 
+const RDD_INFO_MESSAGE_URL = "https://gitea.scriptarium.org/Scriptarium/foundryvtt-reve-de-dragon/raw/branch/v13/info-message.html"
+
 import { RdDUtility } from "./rdd-utility.js"
 import { TMRUtility } from "./tmr-utility.js"
 import { TMRRencontres } from "./tmr-rencontres.js"
@@ -90,6 +92,9 @@ import { Migrations } from './migrations.js'
 import RollDialog from "./roll/roll-dialog.mjs"
 import ChatRollResult from "./roll/chat-roll-result.mjs"
 import ExportPdf from "./actor/export-pdf/export-pdf.mjs"
+import { DialogFlushByDate } from "./chat/dialog-flush-by-date.mjs"
+import { Remote } from "./remote.mjs"
+import { RdDActiveEffect } from "./effect/base-active-effect.js"
 
 /**
  * RdD system
@@ -181,6 +186,7 @@ export class SystemReveDeDragon {
     game.socket.on(SYSTEM_SOCKET_ID, async (sockmsg) => {
       console.log(">>>>> MSG RECV", sockmsg)
       try {
+        Remote.onSocketMessage(sockmsg)
         RdDUtility.onSocketMessage(sockmsg)
         RdDCombat.onSocketMessage(sockmsg)
         ChatUtility.onSocketMessage(sockmsg)
@@ -194,6 +200,7 @@ export class SystemReveDeDragon {
     // Define custom Entity classes
     console.log(`Initializing Reve de Dragon Documents`)
     CONFIG.Actor.documentClass = RdDBaseActor
+    CONFIG.ActiveEffect.documentClass = RdDActiveEffect
     CONFIG.Item.documentClass = RdDItem
     CONFIG.Item.dataModels = {
       monnaie: models.RdDModelMonnaie,
@@ -247,11 +254,11 @@ export class SystemReveDeDragon {
         ITEM_TYPES.jeu,
         ITEM_TYPES.race,
         ITEM_TYPES.recettecuisine,
-        ITEM_TYPES.oeuvre, 
+        ITEM_TYPES.oeuvre,
         ITEM_TYPES.meditation,
         ITEM_TYPES.queue,
-        ITEM_TYPES.ombre, 
-        ITEM_TYPES.souffle, 
+        ITEM_TYPES.ombre,
+        ITEM_TYPES.souffle,
         ITEM_TYPES.tete,
         ITEM_TYPES.casetmr,
         ITEM_TYPES.sort,
@@ -300,6 +307,7 @@ export class SystemReveDeDragon {
     ExportPdf.init()
     RollDialog.init()
     ChatRollResult.init()
+    DialogFlushByDate.init()
   }
 
   initSettings() {
@@ -352,6 +360,15 @@ export class SystemReveDeDragon {
       },
       default: "aucun"
     })
+
+    /* -------------------------------------------- */
+    game.settings.register(SYSTEM_RDD, "info-msg-timeout", {
+      name: "Gestion du timeout d'affichage du message d'information",
+      scope: "world",
+      config: false,
+      type: Number,
+      default: 0
+    })
   }
 
   async onReady() {
@@ -410,10 +427,33 @@ export class SystemReveDeDragon {
       <br>Vous trouverez quelques informations pour démarrer dans ce document : @Compendium[foundryvtt-reve-de-dragon.rappel-des-regles.7uGrUHGdPu0EmIu2]{Documentation MJ/Joueurs}
       <br>La commande <code>/aide</code> dans le chat permet de voir les commandes spécifiques à Rêve de Dragon.</div>
       ` })
+      // Get last message display time
+      const lastDisplay = game.settings.get(SYSTEM_RDD, "info-msg-timeout") || 0
+      const now = Date.now()
+      const oneDayMs = 24 * 60 * 60 * 1000
+      if (now - lastDisplay < oneDayMs) {
+        return // Already displayed in the last 24 hours
+      }
+      // Update last display time
+      game.settings.set(SYSTEM_RDD, "info-msg-timeout", now)
+      // Try to fetch the welcome message from the github repo RDD_INFO_MESSAGE_URL
+      fetch(RDD_INFO_MESSAGE_URL)
+        .then(response => response.text())
+        .then(html => {
+          console.log("Fetched welcome message:", html);
+          ChatMessage.create({
+            user: game.user.id,
+            whisper: [game.user.id],
+            content: html
+          });
+        })
+        .catch(error => {
+          console.error("Error fetching welcome message:", error);
+        });
     }
   }
 
-  roll(rollData, actors, options){
+  roll(rollData, actors, options) {
     RollDialog.create(rollData, actors, options)
   }
 }

module/rdd-possession.js

@@ -2,6 +2,7 @@ import { RdDRoll } from "./rdd-roll.js";
 import { Targets } from "./targets.js";
 import { ITEM_TYPES } from "./constants.js";
 import { RdDRollResult } from "./rdd-roll-result.js";
+import { CARACS } from "./rdd-carac.js";
 
 /* -------------------------------------------- */
 /* On part du principe qu'une entité démarre tjs 
@@ -96,15 +97,14 @@ export class RdDPossession {
   static selectCompetenceDraconicOuPossession(rollData, rollingActor) {
     rollData.competence = rollingActor.getDraconicOuPossession().find(it => true);
     if (rollingActor.isCreatureOuEntite()) {
-      const carac = rollingActor.system.carac
-      rollData.carac = carac
-      rollData.competence.system.defaut_carac = 'reve'
-      rollData.selectedCarac = carac.reve
+      rollData.carac = rollingActor.system.carac
+      rollData.competence.system.defaut_carac = CARACS.REVE
+      rollData.selectedCarac = rollingActor.system.carac.reve
     }
     else {
-      rollData.forceCarac = { 'reve-actuel': { label: "Rêve Actuel", value: rollingActor.getReveActuel() } }
-      rollData.selectedCarac = rollData.forceCarac['reve-actuel']
-      rollData.competence.system.defaut_carac = 'reve-actuel'
+      rollData.forceCarac = rollingActor.getCaracReveActuel()
+      rollData.selectedCarac = rollData.forceCarac[CARACS.REVE_ACTUEL]
+      rollData.competence.system.defaut_carac = CARACS.REVE_ACTUEL
     }
   }
 

module/rdd-roll-result.js

@@ -4,12 +4,10 @@ import { renderTemplate } from "./constants.js";
 export class RdDRollResult {
 
   static async displayRollData(rollData, actor = undefined, template = 'chat-resultat-general.hbs') {
-    const chatMessage = await ChatUtility.createChatWithRollMode(
+    return await ChatMessage.create(ChatUtility.adaptVisibility(
       { content: await RdDRollResult.buildRollDataHtml(rollData, template) },
-      actor,
-      rollData.current?.rollmode?.key
-    )
-    return chatMessage
+      { actor: actor, rollMode: rollData.current?.rollmode?.key }
+    ))
   }
 
   static async buildRollDataHtml(rollData, template = 'chat-resultat-general.hbs') {

module/rdd-roll.js

@@ -4,7 +4,7 @@ import { RdDItemCompetence } from "./item-competence.js";
 import { RdDItemSort } from "./item-sort.js";
 import { Misc } from "./misc.js";
 import { RdDBonus } from "./rdd-bonus.js";
-import { RdDCarac } from "./rdd-carac.js";
+import { CARACS, RdDCarac } from "./rdd-carac.js";
 import { RdDResolutionTable } from "./rdd-resolution-table.js";
 import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
 import { Grammar } from "./grammar.js";
@@ -65,7 +65,7 @@ export class RdDRoll extends Dialog {
     }
     // Mini patch :Ajout du rêve actuel
     if (actor.type == ACTOR_TYPES.personnage) {
-      defaultRollData.carac["reve-actuel"] = actor.system.reve.reve
+      defaultRollData.carac[CARACS.REVE_ACTUEL] = actor.system.reve.reve
     }
 
     foundry.utils.mergeObject(rollData, defaultRollData, { recursive: true, overwrite: false });

module/rdd-rolltables.js

@@ -34,9 +34,9 @@ export class RdDRollTables {
   }
 
   /* -------------------------------------------- */
-  static async getCompetence(toChat = false) {
+  static async getCompetence(toChat = false, rollMode = "gmroll") {
     if (toChat == 'liste') {
-      return await RdDRollTables.listOrRoll('competences', 'Item', ['competence'], toChat, it => 1);
+      return await RdDRollTables.listOrRoll('competences', 'Item', ['competence'], toChat, rollMode, it => 1);
     }
     else {
       return await RdDRollTables.drawItemFromRollTable("Détermination aléatoire de compétence", toChat);
@@ -44,56 +44,58 @@ export class RdDRollTables {
   }
 
   /* -------------------------------------------- */
-  static async getSouffle(toChat = false) {
-    return await RdDRollTables.listOrRoll('souffles-de-dragon', 'Item', ['souffle'], toChat);
+  static async getSouffle(toChat = false, rollMode = "gmroll") {
+    return await RdDRollTables.listOrRoll('souffles-de-dragon', 'Item', ['souffle'], toChat, rollMode);
   }
 
   /* -------------------------------------------- */
-  static async getQueue(toChat = false) {
-    return await RdDRollTables.listOrRoll('queues-de-dragon', 'Item', ['queue'], toChat);
+  static async getQueue(toChat = false, rollMode = "gmroll") {
+    return await RdDRollTables.listOrRoll('queues-de-dragon', 'Item', ['queue'], toChat, rollMode);
   }
 
-  static async getDesirLancinant(toChat = false) {
-    return await RdDRollTables.listOrRoll('queues-de-dragon', 'Item', ['queue'], toChat,
+  static async getDesirLancinant(toChat = false, rollMode = "gmroll") {
+    return await RdDRollTables.listOrRoll('queues-de-dragon', 'Item', ['queue'], toChat, rollMode,
       it => it.system.frequence,
       it => it.system.categorie == 'lancinant');
   }
 
-  static async getIdeeFixe(toChat = false) {
-    return await RdDRollTables.listOrRoll('queues-de-dragon', 'Item', ['queue'], toChat,
+  static async getIdeeFixe(toChat = false, rollMode = "gmroll") {
+    return await RdDRollTables.listOrRoll('queues-de-dragon', 'Item', ['queue'], toChat, rollMode,
       it => it.system.frequence,
       it => it.system.categorie == 'ideefixe');
   }
 
   /* -------------------------------------------- */
-  static async getTeteHR(toChat = false) {
-    return await RdDRollTables.listOrRoll('tetes-de-dragon-pour-haut-revants', 'Item', ['tete'], toChat);
+  static async getTeteHR(toChat = false, rollMode = "gmroll") {
+    return await RdDRollTables.listOrRoll('tetes-de-dragon-pour-haut-revants', 'Item', ['tete'], toChat, rollMode);
   }
 
   /* -------------------------------------------- */
-  static async getTete(toChat = false) {
-    return await RdDRollTables.listOrRoll('tetes-de-dragon-pour-tous-personnages', 'Item', ['tete'], toChat);
+  static async getTete(toChat = false, rollMode = "gmroll") {
+    return await RdDRollTables.listOrRoll('tetes-de-dragon-pour-tous-personnages', 'Item', ['tete'], toChat, rollMode);
   }
 
   /* -------------------------------------------- */
-  static async getOmbre(toChat = false) {
-    return await RdDRollTables.listOrRoll('ombres-de-thanatos', 'Item', ['ombre'], toChat);
+  static async getOmbre(toChat = false, rollMode = "gmroll") {
+    return await RdDRollTables.listOrRoll('ombres-de-thanatos', 'Item', ['ombre'], toChat, rollMode);
   }
 
   /* -------------------------------------------- */
-  static async getTarot(toChat = true) {
-    return await RdDRollTables.listOrRoll('tarot-draconique', 'Item', ['tarot'], toChat);
+  static async getTarot(toChat = true, rollMode = "gmroll") {
+    return await RdDRollTables.listOrRoll('tarot-draconique', 'Item', ['tarot'], toChat, rollMode);
   }
 
   /* -------------------------------------------- */
-  static async listOrRoll(compendium, type, subTypes, toChat, itemFrequence = it => it.system.frequence, filter = it => true) {
+  static async listOrRoll(compendium, type, subTypes, toChat, rollMode,
+    itemFrequence = it => it.system.frequence,
+    filter = it => true) {
     const table = new CompendiumTable(compendium, type, subTypes);
     if (toChat == 'liste') {
       return await table.toChatMessage(itemFrequence, filter);
     }
     const row = await table.getRandom(itemFrequence, filter);
     if (row) {
-      await CompendiumTableHelpers.tableRowToChatMessage(row, type);
+      await CompendiumTableHelpers.tableRowToChatMessage(row, type, { rollMode: rollMode });
       return row.document;
     }
     return undefined;

module/rdd-sheet-utility.js

@@ -93,7 +93,7 @@ export class RdDSheetUtility {
   static async renderItemBranch(actor, item) {
     while (item) {
       await item.sheet?.render()
-      item = actor.getContenant(item)
+      item = actor.findConteneur(item)
     }
   }
 }

module/rdd-tmr-dialog.js

@@ -16,6 +16,7 @@ import { RdDDice } from "./rdd-dice.js";
 import { RdDRencontre } from "./item/rencontre.js";
 import { ITEM_TYPES } from "./constants.js";
 import { Misc } from "./misc.js";
+import { CARACS } from "./rdd-carac.js";
 
 const TMR_DISPLAY_SIZE = {
   code: 'tmr-display-size',
@@ -125,7 +126,7 @@ export class RdDTMRDialog extends Dialog {
     HtmlUtility.showControlWhen(this.html.find(".lire-signe-draconique"), this.actor.isResonanceSigneDraconique(this._getCoordActor()));
 
     this.html.find('form.tmr-dialog *').click(event => {
-      if (this.subdialog?.rendered){
+      if (this.subdialog?.rendered) {
         this.subdialog?.bringToFront()
       }
     })
@@ -685,12 +686,12 @@ export class RdDTMRDialog extends Dialog {
         tmr: tmr,
         canClose: false,
         diffLibre: -7,
-        forceCarac: { 'reve-actuel': { label: "Rêve Actuel", value: this.actor.getReveActuel() } },
+        forceCarac: this.actor.getCaracReveActuel(),
         maitrise: { verbe: 'maîtriser', action: 'Maîtriser le fleuve' }
       }
-      rollData.double = EffetsDraconiques.isDoubleResistanceFleuve(this.actor) ? true : undefined,
-        rollData.competence.system.defaut_carac = 'reve-actuel';
-      await this._rollMaitriseCaseHumide(rollData);
+      rollData.double = EffetsDraconiques.isDoubleResistanceFleuve(this.actor) ? true : undefined
+      rollData.competence.system.defaut_carac = CARACS.REVE_ACTUEL
+      await this._rollMaitriseCaseHumide(rollData)
     }
   }
 
@@ -810,30 +811,30 @@ export class RdDTMRDialog extends Dialog {
       tmr: tmr,
       canClose: options.canClose ?? false,
       diffLibre: options.difficulte ?? -7,
-      forceCarac: { 'reve-actuel': { label: "Rêve Actuel", value: this.actor.getReveActuel() } },
+      forceCarac: this.actor.getCaracReveActuel(),
       maitrise: { verbe: 'conquérir', action: options.action }
-    };
-    rollData.competence.system.defaut_carac = 'reve-actuel';
+    }
+    rollData.competence.system.defaut_carac = CARACS.REVE_ACTUEL
 
-    await this._maitriserTMR(rollData, r => this._onResultatConquerir(r, options));
+    await this._maitriserTMR(rollData, r => this._onResultatConquerir(r, options))
   }
 
   /* -------------------------------------------- */
   async _onResultatConquerir(rollData, options) {
     if (rollData.rolled.isETotal) {
-      rollData.souffle = await this.actor.ajouterSouffle({ chat: false });
+      rollData.souffle = await this.actor.ajouterSouffle({ chat: false })
     }
-    rollData.poesie = await Poetique.getExtrait();
+    rollData.poesie = await Poetique.getExtrait()
     ChatMessage.create({
       whisper: ChatUtility.getOwners(this.actor),
       content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-resultat-maitrise-tmr.hbs`, rollData)
-    });
+    })
     if (rollData.rolled.isEchec) {
-      options.onConqueteEchec(rollData, options.effetDraconique);
+      options.onConqueteEchec(rollData, options.effetDraconique)
     }
     else {
-      await options.onConqueteReussie(rollData, options.effetDraconique);
-      this.updateTokens();
+      await options.onConqueteReussie(rollData, options.effetDraconique)
+      this.updateTokens()
     }
   }
 
@@ -967,7 +968,7 @@ export class RdDTMRDialog extends Dialog {
     const targetOddq = this.pixiTMR.computeEventOddq(event)
     const targetCoord = TMRUtility.oddqToCoordTMR(targetOddq)
 
-    if (targetCoord == COORD_TMR_INCONNU){
+    if (targetCoord == COORD_TMR_INCONNU) {
       ui.notifications.error("Vous ne pouvez pas vous déplacer ici");
       return
     }
@@ -1136,12 +1137,12 @@ export class RdDTMRDialog extends Dialog {
     if (!token) {
       return
     }
-    if (this.demiReve === token && this.isDemiReveCache()) {
+    if (this.isDemiReveCache() && [EffetsDraconiques.rencontre.code(), EffetsDraconiques.demiReve.code()].includes(token.code)) {
       return
     }
-    this.pixiTMR.positionToken(token);
+    this.pixiTMR.positionToken(token)
     if (!this.allTokens.includes(token)) {
-      this.allTokens.push(token);
+      this.allTokens.push(token)
     }
   }
 }

module/rdd-utility.js

@@ -147,7 +147,7 @@ export class RdDUtility {
       'systems/foundryvtt-reve-de-dragon/templates/actor/taches.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/actor/oeuvres.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/actor/oeuvre.hbs',
-      'systems/foundryvtt-reve-de-dragon/templates/actor/jeus.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/jeux.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/actor/alchimie.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/actor/astrologie.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/actor/chirurgie.hbs',
@@ -348,7 +348,8 @@ export class RdDUtility {
     // Items
     Handlebars.registerHelper('rarete-getChamp', (rarete, field) => RdDRaretes.getChamp(rarete, field));
     Handlebars.registerHelper('item-action-applies', (action, item, options) => ItemAction.applies(action, item, options))
-    Handlebars.registerHelper('item-action-icon', (action, item) => ItemAction.icon(action, item))
+    Handlebars.registerHelper('item-action-label', (action, item) => new Handlebars.SafeString(ItemAction.label(action, item)))
+    Handlebars.registerHelper('item-action-img', (action, item) => new Handlebars.SafeString(ItemAction.img(action, item)))
     Handlebars.registerHelper('item-name', (item) => item.nameDisplay)
 
     // TMRs
@@ -482,7 +483,7 @@ export class RdDUtility {
 
   static filterItemsPerTypeForSheet(formData, itemTypes) {
     Object.values(ITEM_TYPES).forEach(t => {
-      formData[t + 's'] = Misc.arrayOrEmpty(itemTypes[t])
+      formData[RdDItem.itemTypePluriel(t)] = Misc.arrayOrEmpty(itemTypes[t])
       itemTypes[t].forEach(item => item.actions = item.itemActions())
     })
 
@@ -679,7 +680,7 @@ export class RdDUtility {
     encaissement.dmg = dmg
     if (ReglesOptionnelles.isUsing('localisation-aleatoire')) {
       encaissement.dmg.loc = dmg.loc ?? await RdDUtility.getLocalisation(targetActor.type)
-      encaissement.dmg.loc.label = encaissement.dmg.loc.label ?? 'Corps;'
+      encaissement.dmg.loc.label = encaissement.dmg.loc.label ?? 'Corps'
     }
     else {
       encaissement.dmg.loc = { label: '' }
@@ -688,9 +689,9 @@ export class RdDUtility {
     encaissement.armure = armure
     encaissement.penetration = dmg.penetration
     encaissement.total = jetTotal
-    encaissement.vie = await RdDUtility._evaluatePerte(encaissement.vie, over20);
-    encaissement.endurance = await RdDUtility._evaluatePerte(encaissement.endurance, over20);
-    return encaissement;
+    encaissement.vie = await RdDUtility._evaluatePerte(encaissement.vie, over20)
+    encaissement.endurance = await RdDUtility._evaluatePerte(encaissement.endurance, over20)
+    return encaissement
   }
 
   /* -------------------------------------------- */

module/remote.mjs

@@ -0,0 +1,53 @@
+import { RdDBaseActor } from "./actor/base-actor.js";
+import { SYSTEM_SOCKET_ID } from "./constants.js";
+import { Misc } from "./misc.js";
+
+export class Remote {
+
+  static onSocketMessage(sockmsg) {
+    switch (sockmsg.msg) {
+      case "msg_remote_call":
+        return Remote.onRemoteCall(sockmsg.userId, sockmsg.data);
+    }
+  }
+
+  static remoteCall({ userId = undefined, documentName, documentId, tokenId = undefined, method, args }) {
+    const callData = { documentName, documentId, tokenId, method, args }
+    const sendToUserId = Misc.connectedUserOrGM(userId)
+    if (sendToUserId == undefined) {
+      ui.notifications.error(`Impossible d'envoyer un message à ${userId}`)
+    }
+    else if (sendToUserId == game.user.id) {
+      Remote.onRemoteCall(game.user.id, callData)
+      return false
+    }
+    else {
+      game.socket.emit(SYSTEM_SOCKET_ID, { msg: "msg_remote_call", userId: sendToUserId, data: callData })
+      return true
+    }
+  }
+
+  static onRemoteCall(userId, callData) {
+    if (userId == game.user.id) {
+      // Seul le joueur choisi effectue l'appel: le joueur courant si propriétaire de l'actor, ou le MJ sinon
+      const doc = Remote.getDoc(callData)
+      if (doc) {
+        const args = callData.args;
+        const method = callData.method;
+        console.info(`Remote.onRemoteCall: ${callData.documentName} ${callData.documentId}, appel de ${method}(`, ...args, ')')
+        doc[method](...args)
+      }
+    }
+  }
+
+  static getDoc(callData) {
+    switch (callData.documentName) {
+      case 'Actor': return RdDBaseActor.getRealActor(callData.documentId, callData.tokenId)
+      case 'Item': return game.items.get(callData.documentId)
+      case 'RollTable': return game.tables.get(callData.documentId)
+      case 'ChatMessage': return game.messages.get(callData.documentId)
+    }
+    return undefined
+  }
+
+}

module/roll/chat-roll-result.mjs

@@ -16,6 +16,7 @@ import { Misc } from "../misc.js"
 import { RollBasicParts } from "./roll-basic-parts.mjs"
 import { RdDPossessionV2 } from "../rdd-possession-v2.mjs"
 import { Apprecier } from "../moral/apprecier.mjs"
+import { Remote } from "../remote.mjs"
 
 export default class ChatRollResult {
   static init() {
@@ -42,16 +43,15 @@ export default class ChatRollResult {
   async display(roll, impacts) {
     this.prepareDisplay(roll)
 
-    const chatMessage = await ChatUtility.createChatWithRollMode(
+    const chatMessage = await ChatMessage.create(ChatUtility.adaptVisibility(
       {
         content: await this.buildRollHtml(roll)
       },
       roll.active.actor,
       roll.current?.rollmode?.key
-    )
-    const save = RollDialog.saveParts(roll, impacts)
+    ))
 
-    await this.saveChatMessageRoll(chatMessage, save)
+    await this.saveChatMessageRoll(chatMessage, roll, impacts)
     return chatMessage
   }
 
@@ -105,8 +105,8 @@ export default class ChatRollResult {
           if (attaque &&
             (roll.rolled.isEchec || !roll.current.defense.isEsquive) &&
             (attaque.particuliere == 'force' || 'charge' == attaque.tactique?.key)) {
-            const taille = defender.system.carac.taille.value
-            const impact = attacker.system.carac.force.value + roll.attackerRoll?.dmg.dmgArme
+            const taille = defender.getTaille()
+            const impact = attacker.getForce() + roll.attackerRoll?.dmg.dmgArme
             return {
               raison: 'charge' == attaque.tactique?.key ? 'charge' : 'particulière en force',
               taille: taille,
@@ -166,8 +166,27 @@ export default class ChatRollResult {
     return roll.active?.actor ?? (roll.ids?.actorId ? game.actors.get(roll.ids.actorId) : undefined)
   }
 
-  async saveChatMessageRoll(chatMessage, savedRoll) {
-    await ChatUtility.setMessageData(chatMessage, 'rollData', savedRoll)
+  async updateChatMessage(chatMessage, savedRoll) {
+    RollDialog.loadRollData(savedRoll)
+    savedRoll.dmg = savedRoll.current.attaque?.dmg
+
+    await this.saveChatMessageRoll(chatMessage, savedRoll)
+
+    this.prepareDisplay(savedRoll)
+
+    const content = await this.buildRollHtml(savedRoll)
+    Remote.remoteCall({
+      userId: chatMessage.author.id,
+      documentName: chatMessage.documentName,
+      documentId: chatMessage.id,
+      method: 'update',
+      args: [{ content: content }, { render: true }]
+    })
+  }
+
+  async saveChatMessageRoll(chatMessage, roll, impacts = undefined) {
+    const save = RollDialog.saveParts(roll, impacts)
+    await ChatUtility.setMessageData(chatMessage, 'rollData', save)
   }
 
   loadChatMessageRoll(chatMessage) {
@@ -176,16 +195,6 @@ export default class ChatRollResult {
     return savedRoll
   }
 
-  async updateChatMessage(chatMessage, savedRoll) {
-    await this.saveChatMessageRoll(chatMessage, savedRoll)
-    const copy = foundry.utils.duplicate(savedRoll)
-    RollDialog.loadRollData(copy)
-    savedRoll.dmg = copy.current.attaque?.dmg
-    this.prepareDisplay(copy)
-    chatMessage.update({ content: await this.buildRollHtml(copy) })
-    chatMessage.render(true)
-  }
-
   onClickAppelChance(event) {
     event.preventDefault()
     const chatMessage = ChatUtility.getChatMessage(event)
@@ -197,28 +206,28 @@ export default class ChatRollResult {
     )
   }
 
-  async onAppelChanceSuccess(reRoll, chatMessage) {
-    reRoll.type.retry = true
-    await this.updateChatMessage(chatMessage, reRoll)
+  async onAppelChanceSuccess(roll, chatMessage) {
+    roll.type.retry = true
+    await this.updateChatMessage(chatMessage, roll)
 
     const callbacks = [ChatUtility.remover(chatMessage)]
     // TODO: annuler les effets...
-    switch (reRoll.type.current) {
+    switch (roll.type.current) {
       case ROLL_TYPE_DEFENSE:
-        this.getCombat(reRoll)?.doRollDefense(reRoll, callbacks)
+        this.getCombat(roll)?.doRollDefense(roll, callbacks)
         break
       case ROLL_TYPE_ATTAQUE:
-        this.getCombat(reRoll)?.doRollAttaque(reRoll, callbacks)
+        this.getCombat(roll)?.doRollAttaque(roll, callbacks)
         break
       default: {
-        await RollDialog.create(reRoll, { onRollDone: RollDialog.onRollDoneClose, callbacks })
+        await RollDialog.create(roll, { onRollDone: RollDialog.onRollDoneClose, callbacks })
       }
     }
   }
 
-  async onAppelChanceEchec(reRoll, chatMessage) {
-    reRoll.type.retry = true
-    await this.updateChatMessage(chatMessage, reRoll)
+  async onAppelChanceEchec(roll, chatMessage) {
+    roll.type.retry = true
+    await this.updateChatMessage(chatMessage, roll)
   }
 
   onClickAppelDestinee(event) {
@@ -229,10 +238,9 @@ export default class ChatRollResult {
     const actor = this.getActiveActor(savedRoll)
 
     Misc.doIfOwner(actor, it => it.appelDestinee(async () => {
-      const reRoll = foundry.utils.duplicate(savedRoll)
-      reRoll.type.retry = true
-      RdDResolutionTable.significativeRequise(reRoll.rolled)
-      await this.updateChatMessage(chatMessage, reRoll)
+      savedRoll.type.retry = true
+      RdDResolutionTable.significativeRequise(savedRoll.rolled)
+      await this.updateChatMessage(chatMessage, savedRoll)
     }))
   }
 

module/roll/roll-dialog.mjs

@@ -42,7 +42,6 @@ import ChatRollResult from "./chat-roll-result.mjs";
 import { renderTemplate } from "../constants.js";
 import { RollTypeCuisine } from "./roll-type-cuisine.mjs";
 import { RollPartCuisine } from "./roll-part-cuisine.mjs";
-import { OptionsAvancees, ROLL_DIALOG_V2_TEST } from "../settings/options-avancees.js";
 import { ActorImpacts } from "../technical/actor-impacts.mjs";
 import { RollPartEmpoignade } from "./roll-part-empoignade.mjs";
 import { RollPartEmpoignadeTaille } from "./roll-part-empoignade-taille.mjs";
@@ -199,9 +198,7 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
   }
 
   static onRollDoneClose(dialog, roll) {
-    if (roll.type.retry || !OptionsAvancees.isUsing(ROLL_DIALOG_V2_TEST)) {
-      dialog.close()
-    }
+    dialog.close()
   }
 
   static init() { }
@@ -221,7 +218,7 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
 
     foundry.applications.handlebars.loadTemplates(ALL_ROLL_TYPES.map(m => m.chatResultTemplate))
     foundry.applications.handlebars.loadTemplates(ROLL_PARTS.map(p => p.template))
-    ROLL_PARTS.forEach(p => p.onReady())
+    ROLL_PARTS.forEach(p => p.onReady(ROLL_PARTS))
 
     Handlebars.registerHelper('roll-centered-array', (base, show) => {
       show = Math.abs(show)
@@ -289,6 +286,13 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
     // rien pour l'instant
   }
 
+  static getAllowedParts(rollData) {
+    return rollData.type?.allowed
+      ? ROLL_PARTS.filter(p => RollDialog.$isIntersecting(rollData.type.allowed, p.rollTypes))
+      : ROLL_PARTS
+
+  }
+
   /** pre-configure les paramètres des différentes parties de la fenêtre (par exemple, prépare les listes de caractéristiques/compétences */
   static $prepareRollData(rollData) {
     rollData.current = rollData.current ?? {}
@@ -302,17 +306,17 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
       ? [potential]
       : (rollData.type.allowed ?? ALL_ROLL_TYPES.filter(m => m.isAllowed(rollData) && m.visible(rollData)).map(m => m.code) ?? [ROLL_TYPE_COMP])
     const rollType = allowed.find(c => c == rollData.type.current) ?? allowed[0]
+    const allowedRollParts = RollDialog.getAllowedParts(rollData)
 
     rollData.type.allowed = allowed
     rollData.type.current = rollType
     ALL_ROLL_TYPES.find(m => m.code == rollType).setRollDataType(rollData)
 
-    rollData.refs = foundry.utils.mergeObject(rollData.refs ?? {}, Object.fromEntries(ROLL_PARTS.map(p => [p.code, {}])));
+    rollData.refs = foundry.utils.mergeObject(rollData.refs ?? {}, Object.fromEntries(allowedRollParts.map(p => [p.code, {}])));
     rollData.options = rollData.options ?? { rollMode: game.settings.get("core", "rollMode") }
 
-    ROLL_PARTS.forEach(p => RollDialog.$initializeRollPart(rollData, p.code))
-    ROLL_PARTS
-      .filter(p => RollDialog.$isIntersecting(allowed, p.rollTypes))
+    allowedRollParts.forEach(p => RollDialog.$initializeRollPart(rollData, p.code))
+    allowedRollParts
       .filter(p => p.isValid(rollData))
       .forEach(p => {
         p.restore(rollData)
@@ -350,11 +354,13 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
         }
         if (from.current) {
           // stockage de current
-          ROLL_PARTS.filter(p => p.isActive(from))
+          RollDialog.getAllowedParts(from)
+            .filter(p => p.isActive(from))
             .forEach(p => p.storeClean(from, target))
         }
       }
     }
+
     const target = RollBasicParts.initFrom(rollData)
     saveBasics(rollData, target)
     if (impacts) {
@@ -374,7 +380,7 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
     this.rollData = rollData
     this.rollOptions = {
       callbacks: [
-        async r => await r.active.actor.appliquerAjoutExperience(r),
+        async r => await r.active.actor.ajoutExperience(r),
         async r => await r.active.actor.appliquerAppelMoral(r),
         ...(rollOptions.callbacks ?? [])
       ],
@@ -382,12 +388,14 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
       onClose: rollOptions.onClose ?? RollDialog.onCloseDoNothing
     }
     this.chatRollResult = new ChatRollResult()
+    this.rollParts = RollDialog.getAllowedParts(rollData)
+
     this.selectType()
     this.registerHooks(rollData)
   }
 
   registerHooks(rollData) {
-    ROLL_PARTS.filter(p => p.isValid(rollData))
+    this.rollParts.filter(p => p.isValid(rollData))
       .forEach(p => p.getHooks(this).forEach(h => {
         const hook = h.hook;
         const id = Hooks.on(hook, h.fn)
@@ -407,13 +415,12 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
     selectedType.onSelect(this.rollData)
     this.rollData.type.label = selectedType.title(this.rollData)
 
-    ROLL_PARTS.find(it => it.code == PART_CARAC).filterCaracs(this.rollData)
-    ROLL_PARTS.find(it => it.code == PART_COMP).filterComps(this.rollData)
+    this.rollParts.find(it => it.code == PART_CARAC).filterCaracs(this.rollData)
+    this.rollParts.find(it => it.code == PART_COMP).filterComps(this.rollData)
   }
 
-
-  static getActiveParts(rollData) {
-    return ROLL_PARTS.filter(p => p.isActive(rollData))
+  getActiveParts() {
+    return this.rollParts.filter(p => p.isActive(this.rollData))
   }
 
   rollTitle(rollData) {
@@ -448,12 +455,13 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
     ))
 
     Promise.all(
-      RollDialog.getActiveParts(this.rollData).map(async p => await p._onRender(this, context, options))
+      this.getActiveParts().map(async p => await p._onRender(this, context, options))
     )
   }
 
   static getAjustements(rollData) {
-    return RollDialog.getActiveParts(rollData)
+    return RollDialog.getAllowedParts(rollData)
+      .filter(p => p.isActive(rollData))
       .map(p => p.getAjustements(rollData))
       .reduce((a, b) => a.concat(b))
       .sort((a, b) => a.value == undefined ? 1 : b.value == undefined ? -1 : 0)
@@ -470,17 +478,14 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
       .map(m => m.toTypeData(rollData))
     RollBasicParts.loadSurprises(rollData, this.getSelectedType().code)
     rollData.type.label = this.getSelectedType()?.title(rollData)
-    //TOCHECK: set type.label ?
-    const visibleRollParts = RollDialog.getActiveParts(rollData)
-    visibleRollParts.forEach(p => p.applyExternalImpacts(visibleRollParts, rollData))
 
-    this.setSpecialComp(visibleRollParts);
-
-    visibleRollParts.forEach(p => p.prepareContext(rollData))
+    this.getActiveParts().forEach(p => p.applyExternalImpacts(this.getActiveParts(), rollData))
+    this.setSpecialComp(this.getActiveParts());
+    this.getActiveParts().forEach(p => p.prepareContext(rollData))
 
     RollDialog.calculAjustement(rollData)
 
-    const templates = RollDialog.getActiveParts(rollData).map(p => p.toTemplateData())
+    const templates = this.getActiveParts().map(p => p.toTemplateData())
     const context = await super._prepareContext()
     return foundry.utils.mergeObject(
       {
@@ -494,8 +499,7 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
     const specialComp = visibleRollParts.map(p => p.getSpecialComp(this.rollData))
       .reduce((a, b) => a.concat(b))
     if (specialComp.length > 0) {
-      const rollPartComp = RollDialog.getActiveParts(this.rollData)
-        .find(it => it.code == PART_COMP);
+      const rollPartComp = this.getActiveParts().find(it => it.code == PART_COMP)
       rollPartComp?.setSpecialComp(this.rollData, specialComp)
     }
   }
@@ -535,12 +539,15 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
     roll.result = selectedRollType.getResult(roll, impacts)
 
     console.info('RollDialog.roll:', roll)
+
     const callbacks = [
-      ...this.rollOptions.callbacks,
       ...selectedRollType.callbacks(this.rollOptions),
+      ...this.rollOptions.callbacks,
     ]
 
-    await Promise.all(callbacks.map(async callback => await callback(roll)))
+    for (let callback of callbacks) {
+      await callback(roll)
+    }
 
     await impacts.applyImpacts()
     selectedRollType.onApplyImpacts(roll, impacts)
@@ -559,7 +566,7 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
   }
 
   async defaultCallback(roll, rolled) {
-    await roll.active.actor.appliquerAjoutExperience(roll)
+    await roll.active.actor.ajoutExperience(roll)
     await roll.active.actor.appliquerAppelMoral(roll)
   }
 

module/roll/roll-part-astrologique.mjs

@@ -1,4 +1,5 @@
 import { Grammar } from "../grammar.js"
+import { CARACS } from "../rdd-carac.js"
 import { ReglesOptionnelles } from "../settings/regles-optionnelles.js"
 import { ROLL_TYPE_SORT } from "./roll-constants.mjs"
 import { RollPartCheckbox } from "./roll-part-checkbox.mjs"
@@ -20,7 +21,7 @@ export class RollPartAstrologique extends RollPartCheckbox {
   }
 
   isJetChance(rollData) {
-    return Grammar.includesLowerCaseNoAccent(rollData.current.carac.key, 'chance')
+    return Grammar.includesLowerCaseNoAccent(rollData.current.carac.key, CARACS.CHANCE)
   }
 
   $isUsingAstrologie() {

module/roll/roll-part-attaque.mjs

@@ -1,8 +1,11 @@
 import { Distance } from "../combat/distance.mjs"
 import { RDD_CONFIG } from "../constants.js"
+import { MAP_PHASE, RdDInitiative } from "../initiative.mjs"
 import { ATTAQUE_TYPE_MELEE } from "../item/arme.js"
+import { Misc } from "../misc.js"
 import { RdDBonus } from "../rdd-bonus.js"
 import { CARACS } from "../rdd-carac.js"
+import { RdDCombatManager } from "../rdd-combat.js"
 import { RdDEmpoignade } from "../rdd-empoignade.js"
 import { DIFF, ROLL_TYPE_ATTAQUE, ROLL_TYPE_COMP } from "./roll-constants.mjs"
 import RollDialog from "./roll-dialog.mjs"
@@ -17,9 +20,9 @@ export const PART_ATTAQUE = 'attaque'
 
 const TACTIQUES = RdDBonus.tactiques.filter(it => it.isTactique)
 
-const FILTER_ATTAQUE_EMPOIGNADE = attaque => attaque.arme.isEmpoignade()
-const FILTER_ATTAQUE_NON_EMPOIGNADE = attaque => !attaque.arme.isEmpoignade()
-const FILTER_ATTAQUE_EMPOIGNE = attaque => attaque.arme.isUtilisableEmpoigne() && ATTAQUE_TYPE_MELEE.includes(attaque.main)
+const FILTER_ATTAQUE_EMPOIGNADE = attaque => attaque.arme?.isEmpoignade()
+const FILTER_ATTAQUE_RANG = rang => attaque => !attaque.arme?.isEmpoignade() && (attaque.rang == rang || rang == undefined)
+const FILTER_ATTAQUE_EMPOIGNE = attaque => attaque.arme?.isUtilisableEmpoigne() && ATTAQUE_TYPE_MELEE.includes(attaque.main)
 
 export class RollPartAttaque extends RollPartSelect {
 
@@ -33,8 +36,9 @@ export class RollPartAttaque extends RollPartSelect {
   loadRefs(rollData) {
     const refs = this.getRefs(rollData)
     const attaques = rollData.active.actor.listAttaques()
+      .sort(Misc.descending(it => it.comp?.system.niveau ?? -8))
     refs.all = attaques.map(it => RollPartAttaque.$extractAttaque(it, rollData))
-    this.filterAttaquesEmpoignade(rollData)
+    this.filterAttaquesInitiative(rollData)
     refs.tactiques = TACTIQUES
     if (refs.attaques.length > 0) {
       const attaque = this.findAttaque(refs.attaques, this.getSaved(rollData))
@@ -46,23 +50,33 @@ export class RollPartAttaque extends RollPartSelect {
     return it.arme.isEmpoignade()
   }
 
-  store(rollData, targetData) {
-    super.store(rollData, targetData)
-    this.getSaved(targetData).dmg = this.getCurrent(rollData).dmg
-  }
-
   restore(rollData) {
-    const saved = this.getSaved(rollData)
-    super.restore(rollData)
-    if (saved.dmg != undefined) {
-      this.getCurrent(rollData).dmg = this.getSaved(rollData).dmg
+    const saved = this.getSaved(rollData) ?? {}
+    if (saved.key) {
+      this.setCurrent(rollData, {
+        key: saved.key,
+        tactique: saved.tactique,
+        dmg: saved.dmg
+      })
     }
   }
 
+  store(rollData, targetData) {
+    const current = this.getCurrent(rollData)
+    this.setSaved(targetData, {
+      key: current.key,
+      tactique: current.tactique,
+      dmg: current.dmg
+    })
+  }
+
+
   findAttaque(attaques, saved) {
-    return attaques.find(at => at.arme.id == saved?.arme?.id &&
-      at.comp.id == saved?.comp?.id
-    )
+    return attaques.find(it => it.key == saved.key) ??
+      attaques.find(it => it.arme.id == (saved?.arme?.id ?? it.arme.id)
+        && it.comp.id == (saved?.comp?.id ?? it.comp.id)
+        && it.main == (saved?.main ?? it.main)
+      )
   }
 
   choices(refs) { return refs.attaques }
@@ -72,24 +86,27 @@ export class RollPartAttaque extends RollPartSelect {
     attaque.tactique = TACTIQUES[0]
     attaque.initialDiff = attaque.comp?.system.default_diffLibre ?? 0
     attaque.distance = Distance.ajustements(rollData.active?.token, rollData.opponent?.token, attaque)
+    attaque.rang = RdDInitiative.phaseArme(attaque.comp?.system.categorie, attaque.arme)?.rang
     return attaque
   }
 
   prepareContext(rollData) {
-    this.filterAttaquesEmpoignade(rollData)
+    this.filterAttaquesInitiative(rollData)
     const current = this.getCurrent(rollData)
     current.dmg = RdDBonus.dmgRollV2(rollData, current)
   }
 
-  filterAttaquesEmpoignade(rollData) {
+  filterAttaquesInitiative(rollData) {
     const refs = this.getRefs(rollData)
-    const isEmpoignade = RdDEmpoignade.isCombatantEmpoignade(rollData.ids.actorId, rollData.ids.actorTokenId)
+    const rang = RdDCombatManager.getRangInitiativeCombatant(rollData.ids.actorId, rollData.ids.actorTokenId)
+    const isEmpoignade = MAP_PHASE.empoignade.rang == rang
+    //const isEmpoignade = RdDEmpoignade.isCombatantEmpoignade(rollData.ids.actorId, rollData.ids.actorTokenId)
     refs.isEmpoignadeEnCours = RdDEmpoignade.isEmpoignadeEnCours(rollData.active.actor)
     const filterAttaques = isEmpoignade ?
       FILTER_ATTAQUE_EMPOIGNADE
       : refs.isEmpoignadeEnCours
         ? FILTER_ATTAQUE_EMPOIGNE
-        : FILTER_ATTAQUE_NON_EMPOIGNADE
+        : FILTER_ATTAQUE_RANG(rang)
     refs.attaques = refs.all.filter(filterAttaques)
   }
 
@@ -102,7 +119,11 @@ export class RollPartAttaque extends RollPartSelect {
 
 
   $selectAttaque(rollData, key) {
+    const tactique = this.getCurrent(rollData).tactique
     this.selectByKey(rollData, key)
+    if (tactique) {
+      this.getCurrent(rollData).tactique = tactique
+    }
   }
 
   async _onRender(rollDialog, context, options) {
@@ -158,8 +179,8 @@ export class RollPartAttaque extends RollPartSelect {
     if (this.visible(rollData)) {
       const current = this.getCurrent(rollData)
       switch (part.code) {
-        case PART_CARAC: return part.filterCaracs(rollData, [current.carac.key])
-        case PART_COMP: return part.filterComps(rollData, [current.comp.name])
+        case PART_CARAC: return part.filterCaracs(rollData, [current.carac?.key])
+        case PART_COMP: return part.filterComps(rollData, [current.comp?.name])
         case PART_DIFF: {
           if (Distance.typeAttaqueDistance(current)) {
             part.setDiff(rollData, { type: DIFF.DEFAUT })

module/roll/roll-part-checkbox.mjs

@@ -41,7 +41,7 @@ export class RollPartCheckbox extends RollPart {
   }
 
   getCheckboxLabelAjustement(rollData) {
-    return `${this.getCheckboxIcon(rollData)} ${this.getRefs(rollData).label}`
+    return `${this.getCheckboxIcon(rollData)} ${this.getCheckboxLabel(rollData)}`
   }
 
   async _onRender(rollDialog, context, options) {