Migration complétée vers appv2

.gitea/workflows/release.yaml

@@ -0,0 +1,63 @@
+name: Release Creation
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - run: echo "💡 The ${{ gitea.repository }} repository will cloned to the runner."
+
+      #- uses: actions/checkout@v3
+      - uses: https://github.com/RouxAntoine/checkout@v3.5.4
+
+      # get part of the tag after the `v`
+      - name: Extract tag version number
+        id: get_version
+        uses: https://github.com/battila7/get-version-action@v2
+
+      # Substitute the Manifest and Download URLs in the module.json
+      - name: Substitute Manifest and Download Links For Versioned Ones
+        id: sub_manifest_link_version
+        uses: https://github.com/microsoft/variable-substitution@v1
+        with:
+          files: "system.json"
+        env:
+          version: ${{steps.get_version.outputs.version-without-v}}
+          url: https://www.uberwald.me/gitea/${{gitea.repository}}
+          manifest: https://www.uberwald.me/gitea/public/fvtt-te-deum/releases/download/latest/system.json
+          download: https://www.uberwald.me/gitea/public/fvtt-te-deum/releases/download/${{github.event.release.tag_name}}/fvtt-te-deum.zip
+
+      # Create a zip file with all files required by the module to add to the release
+      - run: |
+          apt update -y
+          apt install -y zip
+
+      - run: zip -r ./fvtt-te-deum.zip system.json README.md LICENSE.txt assets/ fonts/ images/ lang/ modules/ styles/ packs/ templates/
+
+      - name: setup go
+        uses: https://github.com/actions/setup-go@v4
+        with:
+          go-version: ">=1.20.1"
+
+      - name: Use Go Action
+        id: use-go-action
+        uses: https://gitea.com/actions/release-action@main
+        with:
+          files: |-
+            ./fvtt-te-deum.zip
+            system.json
+          api_key: "${{secrets.ALLOW_PUSH_RELEASE}}"
+
+      - name: Publish to Foundry server
+        uses: https://github.com/djlechuck/foundryvtt-publish-package-action@v1
+        with:
+          token: ${{ secrets.FOUNDRYVTT_RELEASE_TOKEN }}
+          id: 'fvtt-te-deum'
+          version: ${{github.event.release.tag_name}}
+          manifest: 'https://www.uberwald.me/gitea/public/fvtt-te-deum/releases/download/latest/system.json'
+          notes: 'https://www.uberwald.me/gitea/${{gitea.repository}}/releases/download/${{github.event.release.tag_name}}/fvtt-te-deum.zip'
+          compatibility-minimum: '13'
+          compatibility-verified: '13'

.gitignore

@@ -0,0 +1,54 @@
+# Dependencies
+node_modules/
+package-lock.json
+
+# Build outputs
+styles/tedeum.css
+styles/*.css.map
+
+# IDE & Editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# System files
+Thumbs.db
+desktop.ini
+
+# Logs
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+*.log
+
+# Temporary files
+*.tmp
+*.temp
+.cache/
+
+# Environment variables
+.env
+.env.local
+
+# Optional: Uncomment if you want to ignore pack database files
+# These are usually committed for systems, but can be regenerated
+# packs/**/*.ldb
+# packs/**/LOG
+# packs/**/LOG.old
+# packs/**/MANIFEST-*
+# packs/**/CURRENT
+
+# Compiled source
+dist/
+build/
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db

LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright 2023 Open Sesame Games
+Copyright 2025 Open Sesame Games
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

README.md

@@ -1,37 +1,26 @@
-# Te Deum Pour Un Massacre for  FoundryVTT (French RPG, Open Sesam Games, Official)
-
-
-This is a base game system with functionnal character sheets for the game Te Deum.
-You can join the kickstarter and obtain the base books here : https://www.kickstarter.com/projects/osg-us/ecryme
-
-# System overview
-
-
-The game system in Foundry offers the following features :
-- PC/NPC sheet
-- Skill rolls
-- Cephaly rolls (with Anency support)
-- Confrontation management, with detailed result in the chat card
-- Weapon rolls
-- Trait management, with Spleen and Ideal also.
-- Compendiums of items for the game
-
-![System Snapshot](https://www.lahiette.com/leratierbretonnien/wp-content/uploads/2023/08/ecryme_snapshot_01.webp "System Snapshot")
+# Système Foundry pour Te Deum pour un Massacre (French RPG, Open Sesame Games, Official)
 
+This is a base game system with functionnal character sheets for the game Te Deum pour un massacre.
 
 # Contributions
 
 - Original code realised by Uberwald (https://www.uberwald.me/)
 
+Snapshot of the system : 
+
+![Alt text](https://www.lahiette.com/leratierbretonnien/wp-content/uploads/2025/02/tedeum_snapshot.webp "a title")
 
 
 # Copyright mentions
 
-Copyright 2023 Open Sesame Games
+Copyright 2025 Open Sesame Games
 All rights reserved
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+Te Deum pour un massacre is a game written by Jean-Philippe Jaworski. The author retains his moral rights regarding this work in both print and digital formats.
+
 # Requests or Problems
 
 Please report any requests or problems you have at contact@open-sesame.games
+

changelog.md

@@ -0,0 +1,29 @@
+# 13.0.0
+
+- Support de Foundry v13
+
+# 12.0.23
+
+- Correction sur les jets réussie en tir
+- Correction sur le dés négatif pour les échecs critiques
+- Correction sur l'XP et édition de l'XP en mode MJ
+
+# 12.0.22
+
+- Correction pour les armes d'hast
+- Correction sur la zone libre d'équipement
+- Bouton + pour créer un équipement à nouveau opérationnel
+- Modification de la gestion des jets en combat, avec gestion opposition ou degats immédiats
+- Gestion du genre dans la création de personnage
+
+# 12.0.21
+
+- Creation de PNJ OK
+
+# 12.0.20
+
+- Corrections sur la création de perso
+
+# 12.0.19
+
+- Initial release !

gulpfile.js

@@ -1,25 +1,17 @@
 var gulp = require('gulp');
-
+var less = require('gulp-less');
 var postcss = require('gulp-postcss');
-
 var autoprefixer = require('autoprefixer');
-var cssnext = require('postcss-preset-env');
-var precss = require('precss');
 
 gulp.task('css', function () {
-
-  var processors = [
-    autoprefixer,
-    cssnext,
-    precss
-  ];
-
-  return gulp.src('./postcss/*.css')
-    .pipe(postcss(processors))
+  return gulp.src('./less/*.less')
+    .pipe(less())
+    .pipe(postcss([autoprefixer]))
     .pipe(gulp.dest('./styles'));
 });
 
+gulp.task('watch', function () {
+  gulp.watch('./less/*.less', gulp.series('css'));
+});
 
-function watchUpdates() {
-  gulp.watch('./postcss/*.css', css);
-}
+gulp.task('default', gulp.series('css'));

lang/fr.json

@@ -1,175 +1,20 @@
 {
   "TYPES": {
     "Actor":{
-      "pc": "Personnage Joueur",
-      "npc": "Personnage Non Joueur",
-      "annency": "Anence"
+      "pj": "Personnage Joueur",
+      "pnj": "Personnage Non Joueur"
     },
     "Item": {
-      "trait": "Trait",
-      "weapon": "Arme",
-      "equipment": "Equipement",
-      "maneuver": "Manoeuvre",
-      "specialization": "Spécialisation"
-    }
-  },
-  "ECRY": {
-    "settings": {
-      "cogs": "Engrenages",
-      "cephaly": "Céphalie",
-      "boheme": "Bohême",
-      "amertume": "Amertume",
-      "gamelevel": "Niveau de jeu"
-    },
-    "chat": {
-      "formula": "Formule",
-      "difficulty": "Difficulté",
-      "dicesum": "Dés",
-      "result": "Resultat",
-      "margin": "Marge",
-      "success": "Succés!",
-      "failure": "Echec!",
-      "specialization": "Spécialisation",
-      "traitbonus": "Trait bonus",
-      "traitmalus": "Trait malus",
-      "bonusmalustraits": "Bonus/Malus des Traits",
-      "spectranscend": "Dépassement de soi : ",
-      "confrontselected": "Confrontation selectionnée",
-      "sentogm": "La confrontation a été envoyée au MJ"
-    },
-    "rule": {
-      "cephaly-success-12": "Durée : 1 scène - Impact : Superficiel - Bonus : 1 - Elegie : 1",
-      "cephaly-success-4": "Durée : 1 semaine - Impact : Léger - Bonus : 2 - Elegie : 2",
-      "cephaly-success-6": "Durée : 1 mois - Impact : Grave - Bonus : 3 - Elegie : 3",
-      "cephaly-success-8": "Durée : 1 année - Impact : Majeur - Bonus : 4 - Elegie : 4",
-      "cephaly-success-10": "Durée : Permanent - Impact : Mort - Bonus : 5 - Elegie : 5",
-      "cephaly-failure-2": "Durée : 1 scène - Impact : Superficiel - Malus : 1 - Symptôme non visible et sans gravité - Altération bégigne difficilement repérable",
-      "cephaly-failure-4": "Durée : 1 semaine - Impact : Léger - Malus : 2 - Symptôme visible non incapacitant - Altération repérable",
-      "cephaly-failure-6": "Durée : 1 mois - Impact : Grave - Malus : 3 - Symptôme incapacitant - Altération repérable et fâcheuse",
-      "cephaly-failure-8": "Durée : 1 année - Impact : Majeur - Malus : 4 - Symptôme très incapacitant - Altération dangereuse",
-      "cephaly-failure-10": "Durée : Permanent - Impact : Mort/Folie - Malus : 5 - Symptôme spectaculaire et repoussant - Altération dangereuse globalement"
-
-    },
-    "warn": {
-      "notenoughdice": "L'Accomplissement et la Préservation doivent avoir 2 dés chacun"
-    },
-    "ui": {
-      "equipmentfree": "Equipements (saisie libre)",
-      "traitType": "Type de trait",
-      "niveauTrait": "Niveau du trait",
-      "effect": "Incidence",
-      "weight": "Poids",
-      "cost": "Prix",
-      "costUnit": "Unité",
-      "ingot": "Lingot",
-      "ingotin": "Lingotin",
-      "goldcoin": "Pièce d'or",
-      "lige": "Lige",
-      "hurle": "Hurle",
-      "coin": "Sous",
-      "notes": "Notes",
-      "bio": "Bio",
-      "bionotes": "Bio&Notes",
-      "skills": "Compétences",
-      "traits": "Traits",
-      "equipment": "Equipement",
-      "physical": "Physiques",
-      "mental": "Mentales",
-      "social": "Sociales",
-      "athletics": "Athlétisme",
-      "driving": "Conduite",
-      "fencing": "Escrime",
-      "brawling": "Pugilat",
-      "shooting": "Tir",
-      "anthropomecanology": "Anthropo-Mécanologie",
-      "ecrymology": "Écrymologie",
-      "traumatology": "Traumatologie",
-      "traversology": "Traversologie",
-      "urbatechnology": "Urbatechnologie", 
-      "quibbling": "Argutie",
-      "creativity": "Créativité",
-      "loquacity": "Faconde",
-      "guile": "Maraude",
-      "performance" :"Représentation",
-      "skill": "Compétence",
-      "troublesome": "Malaisé",
-      "occasional": "Peu frequent",
-      "difficult": "Difficile",
-      "uncommon": "Atypique",
-      "verydifficult": "Très difficile",
-      "rare": "Rare",
-      "extremdifficult": "Extrêmement difficile",
-      "veryrare": "Très rare",
-      "increddifficult": "Incroyable",
-      "exceptrare": "Exceptionnel",
-      "none": "Aucun",
-      "roll": "Lancer les dés !",
-      "cancel": "Annuler",
-      "rolltitle": "Ou l'on teste ses compétences",
-      "spec": "Spécialisation",
-      "traitbonus": "Traits bonus",
-      "traitmalus": "Traits malus",
-      "applyideal": "Utiliser l'idéal",
-      "applyspleen": "Utiliser le spleen",
-      "skilltranscendence": "Dépassement de soi",
-      "confrontation": "Confrontation",
-      "rollnormal": "Normal (4d6)",
-      "rollspleen": "Avec le Spleen (5d6, 4 plus bas conservés)",
-      "rollideal": "Avec l'Idéal (5d6, 4 plus haut conservés)",
-      "superficial": "Superficiel",
-      "light": "Léger",
-      "serious": "Grave",
-      "major": "Majeur",
-      "impactType": "Type d'Impact",
-      "impactLevel": "Niveau d'impact",
-      "impactphysical": "Physique",
-      "impactmental": "Mental",
-      "impactsocial": "Social",
-      "impactmalus": "Malus d'Impact",
-      "ongoingconfront": "Confrontations en cours",
-      "confront":"Confrontation",
-      "launchconfront": "Lancer la confrontation",
-      "execution": "Accomplissement",
-      "preservation": "Préservation",
-      "dicepool": "Dés disponibles",
-      "selectconfront": "Sélectionner pour la Confrontation",
-      "transcendapply": "Appliquer la Transcendence à ",
-      "healthcombat": "Santé&Combat",
-      "name": "Nom",
-      "weapons": "Armes",
-      "weapon": "Arme",
-      "melee": "Mêlée",
-      "ranged": "A Distance",
-      "weapontype": "Type d'arme",
-      "type": "Type",
-      "applyimpact": "Appliquer l'impact",
-      "applybonus": "Appliquer le bonus",
-      "bonuspool": "Bonus disponibles",
-      "cephaly": "Cephalie",
-      "elegy": "Elégie",
-      "entelechy": "Entéléchie",
-      "mekany": "Mekanë",
-      "psyche": "Psyché",
-      "scoria": "Scorie",
-      "cephalydifficulty": "Difficulté de la Céphalie",
-      "maneuvers": "Manoeuvres",
-      "annency": "Anence",
-      "iscollective": "Collective",
-      "ismultiple": "Multiple",
-      "description": "Description",
-      "location": "Lieu",
-      "characters": "Personnages",
-      "enhancements": "Améliorations",
-      "oniricform": "Forme Onorique (Bohême)",
-      "ideals": "Idéaux",
-      "politic": "Idéaux politiques",
-      "boheme": "Bohême",
-      "annencybonus": "Bonus d'Anence",
-      "bornplace": "Lieu de naissance",
-      "residence": "Résidence",
-      "origin": "Origine",
-      "childhood": "Enfance",
-      "bonus": "Bonus"
+      "competence": "Competence",
+      "arme": "Arme",
+      "equipement": "Equipement",
+      "armure": "Armure",
+      "grace": "Grace",
+      "origine": "Origine",
+      "education": "Education",
+      "blessure": "Blessure",
+      "maladie": "Maladie",
+      "simple": "Simple"
     }
   }
 }

less/actor-sheet.less

@@ -0,0 +1,469 @@
+.editor {
+  border: 2;
+  height: 100%;
+  padding: 0 3px;
+}
+
+.medium-editor {
+  border: 2;
+  height: 240px;
+  max-height: 240px;
+  overflow-y: auto;
+  overflow-x: hidden;
+  padding: 0 3px;
+
+  prose-mirror, .editor, .editor-content, .ProseMirror {
+    overflow: hidden;
+    height: auto;
+  }
+}
+
+.small-editor {
+  border: 2;
+  height: 120px;
+  max-height: 120px;
+  overflow-y: auto;
+  overflow-x: hidden;
+  padding: 0 3px;
+
+  prose-mirror, .editor, .editor-content, .ProseMirror {
+    overflow: hidden;
+    height: auto;
+  }
+}
+
+.questionnaire-reponse {
+  max-width: 42rem;
+  margin-left: 1rem;
+}
+
+.questionnaire-element {
+  margin-top: 0.5rem;
+}
+
+// Style unifié pour tous les inputs et selects (fiches acteur, item, roll dialogs)
+.fvtt-te-deum {
+  input:not([type="checkbox"]):not([type="radio"]):not([type="range"]):not([type="submit"]):not([type="image"]):not([type="file"]),
+  select {
+    background: rgba(248, 245, 238, 0.95);
+    color: rgba(19, 18, 18, 0.95);
+    border: 1px solid rgba(139, 115, 85, 0.35);
+    border-radius: 3px;
+    padding: 0.15rem 0.3rem;
+    transition: border-color 0.2s ease, box-shadow 0.2s ease;
+
+    &:hover {
+      border-color: rgba(139, 115, 85, 0.65);
+      box-shadow: 0 1px 3px rgba(0, 0, 0, 0.12);
+    }
+
+    &:focus {
+      outline: none;
+      border-color: rgba(139, 115, 85, 0.85);
+      box-shadow: 0 0 0 2px rgba(139, 115, 85, 0.2);
+    }
+
+    &:disabled {
+      color: rgba(19, 18, 18, 0.4);
+      background: rgba(220, 216, 205, 0.6);
+      border-color: rgba(139, 115, 85, 0.15);
+    }
+  }
+
+  textarea {
+    background: rgba(248, 245, 238, 0.95);
+    color: rgba(19, 18, 18, 0.95);
+    border: 1px solid rgba(139, 115, 85, 0.35);
+    border-radius: 3px;
+    padding: 0.2rem 0.4rem;
+    transition: border-color 0.2s ease, box-shadow 0.2s ease;
+
+    &:hover {
+      border-color: rgba(139, 115, 85, 0.65);
+    }
+
+    &:focus {
+      outline: none;
+      border-color: rgba(139, 115, 85, 0.85);
+      box-shadow: 0 0 0 2px rgba(139, 115, 85, 0.2);
+    }
+  }
+}
+
+.fvtt-te-deum.window-app .window-content,
+.fvtt-te-deum.application .window-content,
+.fvtt-te-deum.window-app.sheet .window-content .sheet-body,
+.fvtt-te-deum.application.sheet .window-content .sheet-body {
+  font-size: 0.8rem;
+  background: rgba(226, 226, 222, 0.95);
+  color: rgba(19, 18, 18, 0.95);
+}
+
+// Améliorations pour les fiches d'items
+.item-form {
+  .sheet-header {
+    background: linear-gradient(
+      135deg,
+      rgba(226, 226, 222, 0.95) 0%,
+      rgba(240, 235, 225, 0.9) 100%
+    );
+    padding: 0.8rem;
+    border-radius: 8px;
+    box-shadow: 0 2px 6px rgba(0, 0, 0, 0.15);
+    border: 1px solid rgba(139, 115, 85, 0.3);
+    margin-bottom: 0.5rem;
+
+    h1.charname input {
+      // Voir règles haute-spécificité charname ci-dessous
+    }
+  }
+
+  .sheet-body {
+    ul {
+      list-style: none;
+      padding: 0;
+      margin: 0;
+
+      li.flexrow {
+        background: rgba(255, 255, 255, 0.3);
+        padding: 0.4rem 0.6rem;
+        margin: 0.3rem 0;
+        border-radius: 4px;
+        border-left: 3px solid rgba(139, 115, 85, 0.3);
+        transition: all 0.2s ease;
+
+        &:hover {
+          background: rgba(255, 255, 255, 0.5);
+          border-left-color: rgba(139, 115, 85, 0.6);
+          box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+        }
+      }
+    }
+
+    h3 {
+      background: linear-gradient(
+        135deg,
+        rgba(196, 186, 166, 0.6) 0%,
+        rgba(226, 226, 222, 0.5) 100%
+      );
+      padding: 0.4rem 0.6rem;
+      margin: 0.8rem 0 0.4rem 0;
+      border-radius: 4px;
+      border-left: 4px solid rgba(139, 115, 85, 0.6);
+      box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+      font-family: MailartRubberstamp;
+      font-size: 1.1rem;
+      color: #3d3a2e;
+    }
+
+    input[type="checkbox"] {
+      width: 18px;
+      height: 18px;
+      cursor: pointer;
+    }
+  }
+}
+
+// Champ "name" — règles haute-spécificité (spec 0,6,2 / 0,7,2) pour surcharger les règles génériques d'input
+// Fiche acteur : font-size 3rem
+.fvtt-te-deum.application .window-content .sheet-header h1.charname input[name="name"],
+.fvtt-te-deum.window-app .window-content .sheet-header h1.charname input[name="name"] {
+  font-family: "GreatPrimer";
+  font-size: 3rem;
+  background: transparent;
+  border: none;
+  border-bottom: 2px solid rgba(139, 115, 85, 0.4);
+  color: rgba(50, 35, 15, 0.95);
+  width: 100%;
+  height: 100%;
+  margin: 0;
+  letter-spacing: 0.05em;
+  transition: border-color 0.2s ease;
+
+  &:hover {
+    border-width: 2px;
+    border-color: rgba(139, 115, 85, 0.7);
+  }
+
+  &:focus {
+    border-bottom-color: rgba(139, 115, 85, 0.9);
+    outline: none;
+  }
+}
+
+// Fiche item : même style mais font-size plus petit
+.fvtt-te-deum.application .window-content .item-form .sheet-header h1.charname input[name="name"],
+.fvtt-te-deum.window-app .window-content .item-form .sheet-header h1.charname input[name="name"] {
+  font-size: 1.6rem;
+  height: auto;
+}
+
+.fvtt-te-deum .sheet-body {
+  padding: 0.25rem 0.5rem;
+
+  &:after {
+    content: "";
+    display: block;
+    clear: both;
+  }
+}
+
+.fvtt-te-deum nav {
+  &.tabs {
+    .item {
+      z-index: 2;
+      position: relative;
+      opacity: 1;
+      color: rgba(29, 28, 31);
+      padding: 0 0.25rem;
+
+      &:after {
+        content: "";
+        position: absolute;
+        top: 0;
+        right: 0;
+        height: 2rem;
+        width: 1px;
+      }
+    }
+  }
+}
+
+.select-diff {
+  display: inline-block;
+  text-align: left;
+  width: 50px;
+}
+
+.fvtt-te-deum.window-app.sheet .window-content .carac-value,
+.fvtt-te-deum.application.sheet .window-content .carac-value,
+.fvtt-te-deum.window-app.sheet .window-content .competence-xp,
+.fvtt-te-deum.application.sheet .window-content .competence-xp {
+  margin: 0.05rem;
+  flex-basis: 3rem;
+  text-align: center;
+}
+
+.fvtt-te-deum h1,
+.fvtt-te-deum h2,
+.fvtt-te-deum h3,
+.fvtt-te-deum h4 {
+  font-weight: bold;
+  color: rgba(19, 18, 18, 0.95);
+}
+
+.fvtt-te-deum .malus-sante {
+  font-size: 0.88rem;
+  font-weight: normal;
+}
+
+.fvtt-te-deum .malus-sante-active {
+  color: rgba(200, 80, 10, 0.95);
+  font-weight: bold;
+}
+
+.fvtt-te-deum ul,
+.fvtt-te-deum ol {
+  margin: 0;
+  padding: 0;
+}
+
+.fvtt-te-deum ul,
+.fvtt-te-deum li {
+  list-style-type: none;
+}
+
+.header-fields {
+  li {
+    margin: 0;
+    padding: 0;
+  }
+}
+
+.alterne-list {
+  & > .list-item {
+    &:hover {
+      background: rgba(226, 226, 222, 0.4);
+      transform: translateX(2px);
+    }
+
+    &:nth-child(even) {
+      background: rgba(240, 235, 225, 0.3);
+    }
+
+    &:nth-child(odd) {
+      background: rgba(250, 245, 235, 0.2);
+    }
+  }
+}
+
+.specialisation-label {
+  font-size: 0.8rem;
+}
+
+.carac-label,
+.attr-label {
+  font-weight: bold;
+}
+
+.list-item {
+  margin: 0.125rem;
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+  border-radius: 0.3rem;
+  padding: 0.3rem 0.4rem;
+  flex: 1 1 5rem;
+  border: 1px solid rgba(139, 115, 85, 0.15);
+  transition: all 0.2s ease;
+
+  &:hover {
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.15);
+    border-color: rgba(139, 115, 85, 0.3);
+    background: rgba(255, 255, 255, 0.3);
+  }
+}
+
+.list-item-shadow {
+  background: linear-gradient(
+    135deg,
+    rgba(170, 168, 167, 0.25) 0%,
+    rgba(200, 195, 185, 0.2) 100%
+  );
+  flex-grow: 0;
+  flex-wrap: nowrap;
+  justify-content: flex-start;
+  border-left: 3px solid rgba(139, 115, 85, 0.3);
+}
+
+.list-item-shadow2 {
+  background: linear-gradient(
+    135deg,
+    rgba(87, 60, 32, 0.2) 0%,
+    rgba(120, 90, 60, 0.15) 100%
+  );
+  flex-grow: 0;
+  flex-wrap: nowrap;
+  justify-content: flex-start;
+  border-left: 3px solid rgba(87, 60, 32, 0.4);
+}
+
+.item-display-show {
+  display: block;
+}
+
+.item-display-hide {
+  display: none;
+}
+
+.item-quantite {
+  margin-left: 0.5rem;
+}
+
+.list-item-margin1 {
+  margin-left: 1rem;
+}
+
+.list-item-margin2 {
+  margin-left: 2rem;
+}
+
+.list-item-margin3 {
+  margin-left: 3rem;
+}
+
+.list-item-margin4 {
+  margin-left: 4rem;
+}
+
+.sheet-competence-img {
+  width: 24px;
+  max-width: 24px;
+  height: 24px;
+  max-height: 24px;
+  flex-grow: 0;
+  margin-right: 0.25rem;
+  border-radius: 3px;
+  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.15);
+  border: 1px solid rgba(139, 115, 85, 0.3);
+}
+
+.competence-column {
+  flex-direction: column;
+  align-content: flex-start;
+  justify-content: flex-start;
+  flex-grow: 0;
+  flex-basis: 1;
+}
+
+.competence-header {
+  align-content: flex-start;
+  justify-content: flex-start;
+  font-weight: bold;
+  flex-grow: 0;
+}
+
+.comp-li {
+  max-width: 8rem;
+  width: 8rem;
+}
+
+.description-label {
+  flex-grow: 2;
+  margin-left: 4px;
+}
+
+.status-header-label {
+  margin-left: 2px;
+}
+
+.roll-dialog-label {
+  margin: 4px 0;
+  min-width: 96px;
+}
+
+.short-label {
+  flex-grow: 1;
+}
+
+.keyword-label {
+  font-size: 0.85rem;
+}
+
+.item-sheet-label {
+  flex-grow: 1;
+}
+
+.item-text-long-line {
+  flex-grow: 3;
+}
+
+.score-label {
+  flex-grow: 2;
+  align-content: center;
+}
+
+.attribut-value,
+.carac-value {
+  flex-grow: 0;
+  flex-basis: 64px;
+  margin-right: 4px;
+  margin-left: 4px;
+}
+
+.sante-value,
+.competence-value {
+  flex-grow: 0;
+  flex-basis: 2rem;
+  margin-right: 0.25rem;
+  margin-left: 0.25rem;
+}
+
+.description-value {
+  flex-grow: 0;
+  flex-basis: 4rem;
+  margin-right: 0.25rem;
+  margin-left: 0.25rem;
+}
+
+.small-label {
+  margin-top: 5px;
+}

less/base.less

@@ -0,0 +1,235 @@
+.fvtt-te-deum.window-app,
+.fvtt-te-deum.application {
+  text-align: justify;
+  font-size: 16px;
+  letter-spacing: 1px;
+
+  &.sheet {
+    .window-content {
+      margin: 0;
+      padding: 0;
+      font-family: "GreatPrimer";
+
+      .sheet-header {
+        color: rgba(19, 18, 18, 0.95);
+        background: rgba(226, 226, 222, 0.95);
+      }
+
+      .tooltip {
+        &:hover {
+          .tooltiptext {
+            top: 2rem;
+            left: 2rem;
+            margin: 0;
+            padding: 0.25rem;
+          }
+        }
+      }
+    }
+  }
+}
+
+.fvtt-te-deum.sheet header.sheet-header h1 input,
+.window-app .window-header,
+.application .window-header,
+#actors .directory-list,
+#navigation #scene-list .scene.nav-item {
+  font-size: 1rem;
+}
+
+.fvtt-te-deum.sheet {
+  nav {
+    &.sheet-tabs,
+    &.tabs {
+      font-size: 0.8rem;
+      font-size: 1.2rem;
+      font-weight: bold;
+      height: 3rem;
+      flex: 0 0 3rem;
+      margin: 0;
+      padding: 0 0 0 0.25rem;
+      text-align: center;
+      line-height: 1.5rem;
+      border-top: 0 none;
+      border-bottom: 0 none;
+      background:
+        linear-gradient(rgba(226, 226, 222, 0.5), rgba(226, 226, 222, 0.5)),
+        url("../images/ui/frise_bottom_01.webp");
+      background-repeat: no-repeat;
+      background-size: 100% 100%;
+      z-index: 1;
+    }
+  }
+
+  header {
+    &.sheet-header {
+      .profile-img {
+        -o-object-fit: cover;
+        object-fit: cover;
+        -o-object-position: 50% 0;
+        object-position: 50% 0;
+        margin: 0.5rem 0 0.5rem 0.5rem;
+        padding: 0;
+      }
+
+      .flex-compteurs {
+        text-align: right;
+      }
+
+      .resource-content {
+        width: 2rem;
+      }
+    }
+  }
+
+  .tab[data-tab] {
+    padding: 0;
+  }
+
+  li {
+    margin: 0.2rem;
+    padding: 0.15rem;
+  }
+}
+
+.fvtt-te-deum.window-app input,
+.fvtt-te-deum.application input,
+.fvtt-te-deum .item-form,
+.fvtt-te-deum.sheet header.sheet-header .flex-group-center.flex-compteurs,
+.fvtt-te-deum.sheet header.sheet-header .flex-group-center.flex-fatigue,
+.fvtt-te-deum select,
+.fvtt-te-deum button,
+.item-checkbox,
+#sidebar,
+#players,
+#navigation #nav-toggle {
+  font-size: 0.8rem;
+}
+
+.window-header {
+  background: rgba(0, 0, 0, 0.75);
+}
+
+.strong-text {
+  font-weight: bold;
+}
+
+.fvtt-te-deum .tabs .item.active,
+.fvtt-te-deum .blessures-list li ul li:first-child:hover,
+.fvtt-te-deum a:hover {
+  text-shadow: 1px 0px 0px #ff6600;
+}
+
+.rollable:hover,
+.rollable:focus {
+  color: #000;
+  text-shadow: 0 0 10px red;
+  cursor: pointer;
+}
+
+li.folder > .folder-header h3 {
+  color: #aaa;
+}
+
+.fvtt-te-deum table {
+  border: 1px solid #7a7971;
+}
+
+.grid,
+.grid-2col {
+  display: grid;
+  grid-column: span 2 / span 2;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  grid-gap: 10px;
+  grid-gap: 10px;
+  gap: 10px;
+  margin: 10px 0;
+  padding: 0;
+}
+
+.grid-3col {
+  grid-column: span 3 / span 3;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+}
+
+.grid-4col {
+  grid-column: span 4 / span 4;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+}
+
+.grid-5col {
+  grid-column: span 5 / span 5;
+  grid-template-columns: repeat(5, minmax(0, 1fr));
+}
+
+.grid-6col {
+  grid-column: span 5 / span 5;
+  grid-template-columns: repeat(5, minmax(0, 1fr));
+}
+
+.grid-7col {
+  grid-column: span 7 / span 7;
+  grid-template-columns: repeat(7, minmax(0, 1fr));
+}
+
+.grid-8col {
+  grid-column: span 8 / span 8;
+  grid-template-columns: repeat(8, minmax(0, 1fr));
+}
+
+.grid-9col {
+  grid-column: span 9 / span 9;
+  grid-template-columns: repeat(9, minmax(0, 1fr));
+}
+
+.grid-10col {
+  grid-column: span 10 / span 10;
+  grid-template-columns: repeat(10, minmax(0, 1fr));
+}
+
+.grid-11col {
+  grid-column: span 11 / span 11;
+  grid-template-columns: repeat(11, minmax(0, 1fr));
+}
+
+.grid-12col {
+  grid-column: span 12 / span 12;
+  grid-template-columns: repeat(12, minmax(0, 1fr));
+}
+
+.flex-group-center,
+.flex-group-left,
+.flex-group-right {
+  justify-content: center;
+  align-items: center;
+  text-align: center;
+  padding: 5px;
+}
+
+.flex-group-left {
+  justify-content: flex-start;
+  text-align: left;
+}
+
+.flex-group-right {
+  justify-content: flex-end;
+  text-align: right;
+}
+
+.flex-center {
+  align-items: center;
+  justify-content: center;
+  text-align: center;
+}
+
+.table-create-actor {
+  font-size: 0.8rem;
+}
+
+.flex-between {
+  justify-content: space-between;
+}
+
+.flex-shrink {
+  flex: "flex-shrink";
+}

less/chat.less

@@ -0,0 +1,581 @@
+.chat-message-header {
+  background: linear-gradient(
+    135deg,
+    rgba(226, 226, 222, 0.95) 0%,
+    rgba(196, 186, 166, 0.9) 100%
+  );
+  font-size: 0.9rem;
+  min-height: 26px;
+  text-align: center;
+  vertical-align: middle;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border-bottom: 2px solid rgba(139, 115, 85, 0.6);
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.15);
+  padding: 0.1rem 0.3rem;
+  border-radius: 6px 6px 0 0;
+}
+
+.chat-message .message-header .flavor-text,
+.chat-message .message-header .whisper-to {
+  font-size: 0.9rem;
+}
+
+.chat-result-text {
+  font-weight: bold;
+  font-family: GreatPrimer;
+  font-size: 1.1rem;
+  color: rgba(80, 50, 15, 0.95);
+  padding: 0 0 0.1rem 0;
+  line-height: 1.3;
+  border-bottom: 1px solid rgba(139, 115, 85, 0.4);
+  display: block;
+  margin-bottom: 0.2rem;
+  letter-spacing: 0.03em;
+}
+
+.chat-actor-name {
+  font-weight: bold;
+  font-family: GreatPrimer;
+  font-size: 1.1rem;
+  color: rgba(80, 50, 15, 0.95);
+  line-height: 1;
+  letter-spacing: 0.03em;
+  margin: 0;
+  padding: 0;
+}
+
+.chat-actor-name-opposition {
+  font-weight: bold;
+  font-family: GreatPrimer;
+  font-size: 1.1rem;
+  color: rgba(80, 50, 15, 0.95);
+  padding: 0.1rem 0.3rem;
+  letter-spacing: 0.03em;
+}
+
+.chat-result-success {
+  color: #2d5016;
+  background: linear-gradient(
+    135deg,
+    rgba(144, 238, 144, 0.3),
+    rgba(107, 186, 107, 0.25)
+  );
+  padding: 0.25rem 0.6rem;
+  border-radius: 4px;
+  border-left: 3px solid #4a7c2c;
+  display: inline-block;
+  margin: 0.15rem 0;
+  box-shadow: 0 1px 3px rgba(45, 80, 22, 0.2);
+  font-weight: bold;
+}
+
+.chat-result-failure {
+  color: #7a1a1a;
+  background: linear-gradient(
+    135deg,
+    rgba(255, 160, 160, 0.3),
+    rgba(205, 120, 120, 0.25)
+  );
+  padding: 0.25rem 0.6rem;
+  border-radius: 4px;
+  border-left: 3px solid #a82020;
+  display: inline-block;
+  margin: 0.15rem 0;
+  box-shadow: 0 1px 3px rgba(122, 26, 26, 0.2);
+  font-weight: bold;
+}
+
+.chat-img {
+  width: 64px;
+  height: 64px;
+}
+
+.chat-command-img {
+  border: 0px;
+  width: 32px;
+  height: 32px;
+  transition:
+    transform 0.2s ease,
+    box-shadow 0.2s ease;
+  border-radius: 4px;
+
+  &:hover {
+    transform: scale(1.1);
+    box-shadow: 0 3px 8px rgba(255, 102, 0, 0.4);
+  }
+}
+
+.chat-result-column {
+  min-width: 70%;
+  width: 70%;
+}
+
+.roll-dialog-header {
+  background: linear-gradient(
+    135deg,
+    rgba(226, 226, 222, 0.95) 0%,
+    rgba(196, 186, 166, 0.9) 100%
+  );
+  min-height: 48px;
+  padding: 0.4rem 0.6rem;
+  border-radius: 6px 6px 0 0;
+  border-bottom: 2px solid rgba(139, 115, 85, 0.6);
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.15);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.5rem;
+
+  .actor-icon {
+    width: 40px;
+    height: 40px;
+    border-radius: 50%;
+    border: 2px solid rgba(139, 115, 85, 0.5);
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.2);
+  }
+
+  .dialog-roll-title {
+    font-family: GreatPrimer;
+    font-size: 1.1rem;
+    margin: 0;
+    color: #3d3a2e;
+    text-shadow: 1px 1px 1px rgba(255, 255, 255, 0.5);
+  }
+}
+
+.actor-icon {
+  width: 28px;
+  height: 28px;
+  padding: 1px;
+  border-radius: 50%;
+  border: 2px solid rgba(139, 115, 85, 0.5);
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.2);
+  flex-shrink: 0;
+  margin-right: 0.4rem;
+}
+
+.padding-dice {
+  padding-top: 0.2rem;
+  padding-bottom: 0.2rem;
+}
+
+.dice-image {
+  box-sizing: border-box;
+  border: none;
+  border-radius: 0;
+  max-width: 100%;
+}
+
+.dice-image-reroll {
+  background-color: rgba(115, 224, 115, 0.25);
+  border-color: #011d33;
+  box-sizing: border-box;
+  border: 1px;
+  border-radius: 0%;
+  max-width: 100%;
+}
+
+.chat-dice {
+  width: 15%;
+  height: 15%;
+  font-size: 15px;
+  padding: 10px;
+  padding-bottom: 20px;
+  padding-top: 0.2rem;
+  padding-bottom: 0.2rem;
+}
+
+.div-center {
+  align-self: center;
+}
+
+.chat-message {
+  background: rgba(240, 235, 225, 0.95);
+  font-size: 0.9rem;
+  border-radius: 8px;
+  box-shadow: 0 3px 8px rgba(0, 0, 0, 0.15);
+  border: 1px solid rgba(139, 115, 85, 0.3);
+
+  &.whisper {
+    background: rgba(220, 220, 210, 0.85);
+    border: 2px solid #545469;
+    box-shadow: 0 3px 10px rgba(84, 84, 105, 0.3);
+  }
+
+  .chat-icon {
+    border: 0;
+    padding: 2px 6px 2px 2px;
+    float: left;
+    width: 64px;
+    height: 64px;
+  }
+}
+
+.ability-icon {
+  border: 0;
+  padding: 2px 2px 2px 2px;
+  max-width: 32px;
+  max-height: 32px;
+  width: auto;
+  height: auto;
+}
+
+.small-ability-icon {
+  border: 0;
+  padding: 2px 2px 2px 2px;
+  max-width: 16px;
+  max-height: 16px;
+  width: auto;
+  height: auto;
+}
+
+.combat-icon {
+  border: 0;
+  padding: 2px 2px 2px 2px;
+  max-width: 24px;
+  max-height: 24px;
+  width: auto;
+  height: auto;
+}
+
+#sidebar-tabs {
+  flex: 0 0 32px;
+  box-sizing: border-box;
+  margin: 0 0 5px;
+  border-bottom: 1px solid rgba(0, 0, 0, 0);
+  box-shadow: inset 0 0 2rem rgba(0, 0, 0, 0.5);
+
+  & > .item {
+    &.active {
+      border: 1px solid rgba(114, 98, 72, 1);
+      background: rgba(30, 25, 20, 0.75);
+      box-shadow: 0 0 6px inset rgba(114, 98, 72, 1);
+    }
+  }
+}
+
+#controls .scene-control,
+#controls .control-tool {
+  box-shadow: 0 0 3px #000;
+  margin: 0 0 8px;
+  border-radius: 0;
+  background: rgba(30, 25, 20, 1);
+  background-origin: padding-box;
+  border-image-width: 4px;
+  border-image-outset: 0px;
+}
+
+#controls .scene-control.active,
+#controls .control-tool.active,
+#controls .scene-control:hover,
+#controls .control-tool:hover {
+  background: rgba(72, 46, 28, 1);
+  background-origin: padding-box;
+  border-image-width: 4px;
+  border-image-outset: 0px;
+  box-shadow: 0 0 3px #ff6400;
+}
+
+#hotbar {
+  #action-bar {
+    #macro-list {
+      border: 1px solid rgba(72, 46, 28, 1);
+      box-shadow: 2px 2px 5px #000000;
+    }
+
+    .macro {
+      border-image: url(img/ui/bg_control.jpg) 21 repeat;
+      border-image-slice: 6 6 6 6 fill;
+      border-image-width: 6px 6px 6px 6px;
+      border-image-outset: 0px 0px 0px 0px;
+      border-radius: 0px;
+    }
+  }
+
+  .bar-controls {
+    background: rgba(30, 25, 20, 1);
+    border: 1px solid rgba(72, 46, 28, 1);
+  }
+}
+
+#players {
+  border-image-width: 4px;
+  border-image-outset: 0px;
+  background: rgba(30, 25, 20, 1);
+}
+
+#navigation {
+  #scene-list {
+    .scene {
+      &.nav-item {
+        background: rgba(30, 25, 20, 1);
+        background-origin: padding-box;
+        border-image-width: 4px;
+        border-image-outset: 0px;
+
+        &.active {
+          background: rgba(72, 46, 28, 1);
+        }
+      }
+    }
+  }
+
+  #nav-toggle {
+    background: rgba(30, 25, 20, 1);
+    background-origin: padding-box;
+    border-image-width: 4px;
+    border-image-outset: 0px;
+  }
+}
+
+#navigation #scene-list .scene.view,
+#navigation #scene-list .scene.context {
+  background: rgba(72, 46, 28, 1);
+  background-origin: padding-box;
+  border-image-width: 4px;
+  border-image-outset: 0px;
+  box-shadow: 0 0 3px #ff6400;
+}
+
+.chat-card-button {
+  box-shadow: inset 0px 1px 0px 0px #a6827e;
+  background: linear-gradient(
+    to bottom,
+    rgba(33, 55, 74, 0.98824) 5%,
+    rgba(21, 40, 51, 0.67059) 100%
+  );
+  background-color: rgba(125, 93, 59, 0);
+  border-radius: 3px;
+  border: 2px ridge #846109;
+  display: inline-block;
+  cursor: pointer;
+  color: #ffffff;
+  font-size: 0.8rem;
+  padding: 4px 12px 0px 12px;
+  text-decoration: none;
+  text-shadow: 0px 1px 0px #4d3534;
+  position: relative;
+  margin: 2px;
+
+  &:hover {
+    background: linear-gradient(to bottom, #800000 5%, #3e0101 100%);
+    background-color: red;
+  }
+
+  &:active {
+    position: relative;
+    top: 1px;
+  }
+}
+
+.plus-minus-button {
+  box-shadow: inset 0px 1px 0px 0px #a6827e;
+  background: linear-gradient(
+    to bottom,
+    rgba(33, 55, 74, 0.98824) 5%,
+    rgba(21, 40, 51, 0.67059) 100%
+  );
+  background-color: rgba(125, 93, 59, 0);
+  border-radius: 2px;
+  border: 1px ridge #846109;
+  display: inline-block;
+  cursor: pointer;
+  color: #ffffff;
+  margin: 2px 2px 2px 2px;
+  padding: 2px 2px 2px 2px;
+  text-decoration: none;
+  text-shadow: 0px 1px 0px #4d3534;
+  position: relative;
+  margin: 0px;
+}
+
+.plus-minus-button:hover,
+.chat-card-button:hover {
+  background: linear-gradient(to bottom, #800000 5%, #3e0101 100%);
+  background-color: red;
+}
+
+.plus-minus-button:active,
+.chat-card-button:active {
+  position: relative;
+  top: 1px;
+}
+
+.plus-minus {
+  font-size: 0.9rem;
+  font-weight: bold;
+}
+
+.ul-level1 {
+  padding-left: 2rem;
+}
+
+#pause {
+  font-size: 2rem;
+
+  & > h3 {
+    color: #ccc;
+  }
+
+  & > img {
+    content: url(../images/ui/logo_tedeum_pause.webp);
+    height: 200px;
+    width: 200px;
+    top: -200px;
+    left: calc(50% - 132px);
+  }
+}
+
+#logo {
+  content: url(../images/ui/logo_tedeum_pause.webp);
+  width: 100px;
+  height: 60px;
+}
+
+.dice-cell {
+  padding-left: 12px;
+  padding-right: 12px;
+  width: 60px;
+  text-align: center;
+}
+
+.dice-formula,
+.dice-total {
+  height: 54px;
+  position: relative;
+}
+
+// Améliorations esthétiques pour les messages de chat
+.chat-roll-details {
+  background: rgba(255, 255, 255, 0.4);
+  border-radius: 4px;
+  padding: 0.4rem 0.5rem;
+  margin: 0.25rem 0;
+  border: 1px solid rgba(139, 115, 85, 0.25);
+
+  ul {
+    margin: 0;
+    padding-left: 0.8rem;
+
+    li {
+      padding: 0.05rem 0;
+      line-height: 1.25;
+
+      strong {
+        color: rgba(70, 67, 49, 0.9);
+      }
+    }
+  }
+}
+
+.chat-roll-result-section {
+  background: linear-gradient(
+    135deg,
+    rgba(255, 250, 240, 0.6),
+    rgba(245, 240, 230, 0.5)
+  );
+  border-radius: 4px;
+  padding: 0.35rem;
+  margin: 0.2rem 0;
+  border: 2px solid rgba(139, 115, 85, 0.3);
+  box-shadow: inset 0 1px 3px rgba(0, 0, 0, 0.1);
+
+  .chat-total-result {
+    font-size: 1rem;
+    font-weight: bold;
+    color: #3d3a2e;
+    text-align: center;
+    padding: 0.25rem;
+    background: rgba(226, 226, 222, 0.5);
+    border-radius: 4px;
+    margin-bottom: 0.25rem;
+    text-shadow: 1px 1px 2px rgba(255, 255, 255, 0.5);
+  }
+}
+
+.chat-dice-formula {
+  display: inline-block;
+  background: rgba(139, 115, 85, 0.15);
+  padding: 0.15rem 0.4rem;
+  border-radius: 3px;
+  font-family: monospace;
+  font-size: 0.9em;
+  border: 1px solid rgba(139, 115, 85, 0.3);
+  color: #5a4a3a;
+  font-weight: 600;
+}
+
+.chat-difficulty-badge {
+  display: inline-block;
+  background: linear-gradient(
+    135deg,
+    rgba(180, 160, 130, 0.4),
+    rgba(160, 140, 110, 0.35)
+  );
+  padding: 0.15rem 0.5rem;
+  border-radius: 10px;
+  font-weight: bold;
+  border: 1px solid rgba(139, 115, 85, 0.4);
+  color: #4a3a2a;
+  font-size: 0.85em;
+  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.15);
+}
+
+.chat-info-badge {
+  display: inline-block;
+  background: rgba(100, 149, 237, 0.15);
+  padding: 0.15rem 0.4rem;
+  border-radius: 3px;
+  border-left: 2px solid rgba(70, 130, 180, 0.6);
+  margin: 0.08rem 0;
+  font-size: 0.8em;
+  color: #2c4a6a;
+}
+
+.chat-warning-badge {
+  display: inline-block;
+  background: rgba(255, 200, 100, 0.2);
+  padding: 0.15rem 0.4rem;
+  border-radius: 3px;
+  border-left: 2px solid rgba(218, 165, 32, 0.7);
+  margin: 0.08rem 0;
+  font-size: 0.8em;
+  color: #7a5a1a;
+}
+
+.chat-actions-bar {
+  display: flex;
+  justify-content: center;
+  gap: 0.3rem;
+  padding: 0.4rem;
+  background: rgba(226, 226, 222, 0.4);
+  border-top: 1px solid rgba(139, 115, 85, 0.25);
+  border-radius: 0 0 6px 6px;
+  margin-top: 0.25rem;
+
+  a {
+    transition: all 0.2s ease;
+
+    &:hover {
+      transform: translateY(-2px);
+    }
+  }
+}
+
+.chat-negative-dice {
+  display: inline-block;
+  background: linear-gradient(
+    135deg,
+    rgba(255, 100, 100, 0.2),
+    rgba(220, 80, 80, 0.15)
+  );
+  padding: 0.2rem 0.5rem;
+  border-radius: 4px;
+  border: 2px solid rgba(178, 34, 34, 0.4);
+  font-weight: bold;
+  color: #8b0000;
+  margin: 0.15rem 0;
+  box-shadow: 0 1px 3px rgba(178, 34, 34, 0.2);
+}

less/dialogs.less

@@ -0,0 +1,235 @@
+.te-deum-roll-dialog {
+  .window-header {
+    border-radius: 10px 10px 0% 0%;
+  }
+
+  .window-content {
+    border-radius: 0% 0% 10px 10px;
+  }
+}
+
+.skill-roll-dialog {
+  background: linear-gradient(
+    135deg,
+    rgba(240, 235, 225, 0.98) 0%,
+    rgba(250, 245, 235, 0.95) 100%
+  );
+  border-radius: 8px;
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2);
+  border: 1px solid rgba(139, 115, 85, 0.3);
+  overflow: hidden;
+
+  .flexcol {
+    padding: 0.6rem 0.8rem;
+    gap: 0.4rem;
+  }
+
+  .flexrow {
+    margin: 0.3rem 0;
+    padding: 0.4rem 0.5rem;
+    background: rgba(255, 255, 255, 0.4);
+    border-radius: 4px;
+    border-left: 3px solid rgba(139, 115, 85, 0.3);
+    align-items: center;
+    gap: 0.5rem;
+    transition: all 0.2s ease;
+
+    &:hover {
+      background: rgba(255, 255, 255, 0.6);
+      border-left-color: rgba(139, 115, 85, 0.6);
+      box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+    }
+  }
+
+  .roll-dialog-label {
+    font-family: GreatPrimer;
+    font-size: 0.85rem;
+    font-weight: 600;
+    color: #3d3a2e;
+    min-width: 140px;
+
+    &:first-child {
+      color: rgba(70, 67, 49, 0.9);
+      font-weight: 700;
+    }
+  }
+
+  input[type="checkbox"] {
+    width: 18px;
+    height: 18px;
+    cursor: pointer;
+  }
+
+  div {
+    margin-top: 4px;
+    margin-bottom: 4px;
+  }
+
+  .sheet-footer {
+    padding: 0.5rem 0.8rem;
+    gap: 0.5rem;
+    border-top: 1px solid rgba(139, 115, 85, 0.3);
+    margin-top: 0.5rem;
+
+    button {
+      flex: 1;
+      padding: 0.4rem 0.8rem;
+      border-radius: 4px;
+      font-family: "GreatPrimer";
+      font-size: 0.9rem;
+      cursor: pointer;
+      border: 1px solid rgba(139, 115, 85, 0.5);
+      background: linear-gradient(135deg, rgba(196, 186, 166, 0.8) 0%, rgba(226, 226, 222, 0.9) 100%);
+      color: rgba(50, 35, 15, 0.95);
+      transition: all 0.2s ease;
+
+      &:hover {
+        background: linear-gradient(135deg, rgba(196, 186, 166, 1) 0%, rgba(210, 205, 195, 1) 100%);
+        border-color: rgba(139, 115, 85, 0.8);
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.15);
+      }
+    }
+  }
+}
+
+.confront-dice {
+  border-width: 0px;
+}
+
+.bonus-spec {
+  max-width: 48px;
+}
+
+.confront-bonus-container {
+  position: relative;
+  flex-grow: 1;
+  text-align: center;
+  color: black;
+}
+
+.pool-list {
+  align-items: center;
+  justify-content: center;
+}
+
+.corps-combat-block {
+  position: relative;
+  width: 600px;
+  height: 600px;
+}
+
+.silhouette-combat-picture {
+  width: 250px;
+  max-width: 250px;
+  border: 0;
+}
+
+.silhouette-combat-block {
+  position: absolute;
+  background: white;
+  border-color: darkgray;
+  border-style: ridge;
+  border: 1;
+  width: 180px;
+  min-height: 84px;
+  height: auto;
+  margin: 0 auto;
+  font-size: 0.8rem;
+  align-self: center;
+  overflow: visible;
+}
+
+.silhouette-combat-space {
+  width: 60px;
+  min-width: 60px;
+}
+
+.center-content {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+
+.chat-message .message {
+  font-family: "GreatPrimer";
+  font-size: 0.9rem;
+}
+
+.fvtt-te-deum-character-creator {
+  /*background: rgba(226, 226, 222, 0.95);*/
+  font-family: "GreatPrimer";
+  font-size: 0.9rem;
+
+  .field-title {
+    font-weight: bold;
+  }
+
+  .form-group label {
+    color: rgba(30, 25, 15, 0.9);
+  }
+
+  .status-section {
+    display: block;
+    max-width: 34rem;
+  }
+
+  .creator-finished-section {
+    display: block;
+    max-width: 34rem;
+    text-align: center;
+    margin-bottom: 1rem;
+  }
+
+  .stage-main-details {
+    text-align: center;
+    margin-top: 1rem;
+  }
+}
+
+.grace-texte {
+  margin-top: 1rem;
+}
+
+.chat-welcome {
+  text-align: center;
+}
+
+.item-name-label {
+  min-width: 12rem;
+}
+
+.compendium-sidebar .directory-item.compendium.locked .compendium-name {
+  background: rgba(0, 0, 0, 0.1);
+}
+
+.compendium-sidebar .directory-item.compendium .compendium-name {
+  background: rgba(0, 0, 0, 0.1);
+}
+
+.compendium-sidebar .directory-item.compendium:hover .compendium-name {
+  text-shadow: 0 0 8px var(--color-shadow-primary);
+  background: rgba(0, 0, 0, 0.9);
+}
+
+.compendium-sidebar .directory-item.compendium .compendium-footer .source {
+  display: inline-block;
+  font-size: var(--font-size-12);
+  padding: 1px 0.5rem 0 0.25rem;
+  border-radius: 0 3px 0 0;
+  background: rgba(0, 0, 0, 0.1);
+}
+
+.tedeum-create-character {
+  align-self: anchor-center;
+}
+
+.message-chat-center {
+  text-align: center;
+}
+
+.welcome-message-h3 {
+  font-size: 1.2rem;
+  text-align: center;
+  margin-bottom: 0.5rem;
+  color: darkred;
+}

less/items.less

@@ -0,0 +1,414 @@
+.padd-right {
+  margin-right: 8px;
+}
+
+.padd-left {
+  margin-left: 8px;
+}
+
+.fortune-row {
+  flex-wrap: nowrap;
+  align-items: center;
+  gap: 0.4rem;
+  padding: 0.3rem 0.5rem;
+  margin-bottom: 0.5rem;
+
+  label {
+    flex: 0 0 auto;
+    min-width: unset;
+    font-weight: 600;
+    color: rgba(70, 67, 49, 0.9);
+  }
+
+  input {
+    flex: 0 0 auto;
+  }
+}
+
+.stack-left {
+  align-items: center;
+  flex-shrink: 1;
+  flex-grow: 0;
+}
+
+.packed-left {
+  white-space: nowrap;
+  flex-grow: 0;
+}
+
+.input-numeric-short {
+  width: 52px;
+  max-width: 52px;
+  flex-grow: 0;
+  flex-shrink: 0;
+  flex-basis: 52px;
+  margin-right: 0.15rem;
+  margin-left: 0.15rem;
+}
+
+.abilities-table {
+  align-content: flex-start;
+}
+
+.tokenhudext {
+  display: flex;
+  flex: 0 !important;
+  font-weight: 600;
+
+  &.left {
+    justify-content: flex-start;
+    flex-direction: column;
+    position: absolute;
+    top: 2.75rem;
+    right: 4rem;
+  }
+
+  &.right {
+    justify-content: flex-start;
+    flex-direction: column;
+    position: absolute;
+    top: 2.75rem;
+    left: 4rem;
+  }
+}
+
+.control-icon {
+  &.tokenhudicon {
+    width: -moz-fit-content;
+    width: fit-content;
+    height: -moz-fit-content;
+    height: fit-content;
+    min-width: 6rem;
+    flex-basis: auto;
+    padding: 0;
+    line-height: 1rem;
+    margin: 0.25rem;
+
+    &.right {
+      margin-left: 8px;
+    }
+  }
+}
+
+#token-hud {
+  .status-effects {
+    &.active {
+      z-index: 2;
+    }
+  }
+}
+
+.token-sheet {
+  .window-content {
+    .flexcol {
+      .sheet-tabs {
+        font-size: 0.8rem;
+      }
+    }
+  }
+}
+
+.item-checkbox {
+  height: 25px;
+  border: 1px solid rgba(115, 105, 83, 0.65098);
+  border-left: none;
+  font-weight: 500;
+  font-size: 1rem;
+  color: black;
+  padding-top: 5px;
+  margin-right: 0px;
+  width: 45px;
+  position: relative;
+  left: 0px;
+  text-align: center;
+}
+
+.skill-label {
+  font-size: 0.7rem;
+}
+
+.skill-good-checkbox {
+  max-height: 10px;
+  max-width: 10px;
+}
+
+.flex-actions-bar {
+  flex-grow: 2;
+}
+
+#sidebar {
+  font-size: 1rem;
+  background-color: #f5f5f5;
+  background-position: 0px 35px;
+  background-repeat: no-repeat;
+  background: rgba(226, 226, 222, 0.95);
+  color: rgba(19, 18, 18, 0.95);
+
+  &.collapsed {
+    height: 470px !important;
+  }
+
+  #sidebar-tabs {
+    i {
+      display: inline-block;
+      background-position: center;
+      background-size: cover;
+      text-shadow: 1px 1px 0 rgba(0, 0, 0, 0.75);
+    }
+  }
+}
+
+#sidebar-tabs > .collapsed,
+#chat-controls .chat-control-icon {
+  color: rgba(19, 18, 18, 0.95);
+  text-shadow: 1px 1px 0 rgba(0, 0, 0, 0.75);
+}
+
+.sidebar-tab {
+  .directory-list {
+    .entity {
+      border-top: 1px rgba(0, 0, 0, 0.25);
+      border-bottom: 0 none;
+      padding: 0.25rem 0;
+
+      &:hover {
+        background: rgba(0, 0, 0, 0.05);
+        cursor: pointer;
+      }
+    }
+  }
+}
+
+.status-small-label {
+  font-size: 0.65rem;
+}
+
+.no-grow {
+  flex-grow: 1;
+  max-width: 32px;
+}
+
+.status-col-name {
+  max-width: 72px;
+}
+
+.img-no-border {
+  max-width: 48px;
+  max-height: 48px;
+  border: 0px;
+}
+
+.items-title-bg {
+  margin-top: 6px;
+  color: rgba(19, 18, 18, 0.95);
+  background: linear-gradient(
+    135deg,
+    rgba(196, 186, 166, 0.6) 0%,
+    rgba(226, 226, 222, 0.5) 100%
+  );
+  border-radius: 4px;
+  padding: 0.3rem 0.5rem;
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+  border-left: 4px solid rgba(139, 115, 85, 0.6);
+
+  h3 {
+    margin: 0;
+    padding: 0;
+    font-size: 1.15rem;
+    font-weight: 600;
+    color: rgba(19, 18, 18, 0.95);
+  }
+}
+
+.item-name-label-header-long2 {
+  flex-grow: 1;
+  max-width: 14rem;
+  min-width: 14rem;
+}
+
+.impact-box {
+  border-width: 2px;
+  border-color: #000000;
+  border-radius: 6px;
+  border: 2px ridge #443307;
+  margin: 4px;
+  padding: 4px;
+}
+
+.impact-title {
+  font-size: bold;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin-left: auto;
+  margin-right: auto;
+  text-align: center;
+}
+
+.items-title-text {
+  text-align: center;
+  font-family: MailartRubberstamp;
+  margin-left: 4px;
+}
+
+.lock-icon {
+  width: 16px;
+  height: 16px;
+}
+
+.item-sheet-img {
+  width: 64px;
+  height: 64px;
+  border: 2px solid rgba(139, 115, 85, 0.4);
+  border-radius: 8px;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2);
+  object-fit: cover;
+}
+
+.item-name-img {
+  flex-grow: 1;
+  max-width: 2rem;
+  min-width: 2rem;
+}
+
+.item-field {
+  margin-top: 4px;
+}
+
+.item-field-xp {
+  margin-top: 4px;
+  min-width: 8rem;
+  max-width: 8rem;
+}
+
+.item-field-label-short {
+  flex-grow: 1;
+  max-width: 4rem;
+  min-width: 4rem;
+}
+
+.item-field-label-medium {
+  flex-grow: 1;
+  max-width: 6rem;
+  min-width: 6rem;
+}
+
+.item-field-label-long,
+.item-name-label-long {
+  font-weight: 600;
+  color: rgba(70, 67, 49, 0.9);
+  min-width: 160px;
+}
+
+.item-field-skill {
+  flex-grow: 1;
+  max-width: 6.8rem;
+  min-width: 6.8rem;
+}
+
+.item-field-label-long {
+  flex-grow: 1;
+  max-width: 10rem;
+  min-width: 10rem;
+}
+
+.item-field-title-long {
+  flex-grow: 1;
+  max-width: 12rem;
+  min-width: 12rem;
+}
+
+.item-field-label-long14 {
+  flex-grow: 1;
+  max-width: 14rem;
+  min-width: 14rem;
+  color: rgba(70, 67, 49, 0.9);
+  font-size: 1.0rem;
+  font-weight: 600;
+}
+
+.carac-box {
+  background: linear-gradient(
+    135deg,
+    rgba(226, 226, 222, 0.4) 0%,
+    rgba(240, 235, 225, 0.3) 100%
+  );
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+  border-radius: 0.45rem;
+  padding: 0.3rem 0.5rem;
+  border: 1px solid rgba(139, 115, 85, 0.2);
+  transition: all 0.2s ease;
+
+  &:hover {
+    border-color: rgba(139, 115, 85, 0.4);
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.15);
+  }
+}
+
+.comp-box {
+  max-width: 16rem;
+  min-width: 16rem;
+  width: 16rem;
+  min-height: 1.6rem;
+  background: linear-gradient(
+    135deg,
+    rgba(250, 245, 235, 0.5) 0%,
+    rgba(255, 255, 255, 0.3) 100%
+  );
+  padding: 0.25rem 0.4rem;
+  margin: 0.15rem;
+  border-radius: 3px;
+  border-left: 2px solid rgba(139, 115, 85, 0.3);
+  transition: all 0.2s ease;
+
+  &:hover {
+    background: rgba(226, 226, 222, 0.4);
+    border-left-color: rgba(139, 115, 85, 0.6);
+    transform: translateX(2px);
+  }
+}
+
+.item-control-end {
+  align-self: flex-end;
+}
+
+.alternate-list {
+  margin-top: 4px;
+  flex-wrap: nowrap;
+}
+
+.item-filler {
+  flex-grow: 6;
+  flex-shrink: 7;
+}
+
+.item-controls-fixed {
+  min-width: 2rem;
+  max-width: 2rem;
+}
+
+.item-controls-fixed-full {
+  min-width: 3rem;
+  max-width: 3rem;
+}
+
+.item-left-pad {
+  margin-left: 4px;
+}
+
+.attribute-label {
+  font-weight: bold;
+}
+
+.flexrow-no-expand {
+  flex-grow: 0;
+}
+
+.item-input-small {
+  max-width: 16px;
+  max-height: 12px;
+}
+
+.character-summary-rollable {
+  text-decoration: underline;
+}

less/layout.less

@@ -0,0 +1,240 @@
+.fvtt-te-deum.window-app.sheet .window-content,
+.fvtt-te-deum.application.sheet .window-content {
+  overflow: hidden;
+  display: flex;
+  flex-direction: column;
+}
+
+// AppV2: le part wrapper et la section root du template doivent propager la hauteur
+// Uniquement pour les fiches (.sheet) — les autres fenêtres (dialogs) gardent un layout block normal
+.application.fvtt-te-deum.sheet .window-content > [data-application-part],
+.application.fvtt-te-deum.sheet .window-content > [data-application-part] > section {
+  flex: 1 1 0;
+  min-height: 0;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+}
+
+.fvtt-te-deum {
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+
+  .sheet-header {
+    flex: 0 0 auto;
+    overflow: hidden;
+    display: flex;
+    flex-direction: row;
+    flex-wrap: wrap;
+    justify-content: flex-start;
+    margin-bottom: 10px;
+    background: linear-gradient(
+      135deg,
+      rgba(226, 226, 222, 0.95) 0%,
+      rgba(240, 235, 225, 0.9) 100%
+    );
+    padding: 0.3rem 0.8rem;
+    border-radius: 8px;
+    box-shadow: 0 2px 6px rgba(0, 0, 0, 0.15);
+    border: 1px solid rgba(139, 115, 85, 0.3);
+
+    .profile-img {
+      flex: 0 0 128px;
+      width: 128px;
+      height: auto;
+      max-height: 128px;
+      margin-top: 0px;
+      margin-right: 10px;
+      -o-object-fit: cover;
+      object-fit: cover;
+      -o-object-position: 50% 0;
+      object-position: 50% 0;
+      border-width: 0px;
+      border-radius: 8px;
+      box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2);
+      border: 2px solid rgba(139, 115, 85, 0.4);
+    }
+
+    .header-fields {
+      flex: 1;
+    }
+
+    h1 {
+      &.charname {
+        height: 50px;
+        padding: 0px;
+        margin: 5px 0;
+        border-bottom: 0;
+      }
+    }
+
+    .header-identity-fields {
+      flex-wrap: nowrap;
+      align-items: center;
+      gap: 0.3rem;
+      margin-top: 0.2rem;
+
+      input, select {
+        flex: 1 1 auto;
+        font-size: 0.75rem;
+        height: 1.6rem;
+      }
+    }
+
+    .header-identity-label {
+      flex: 0 0 auto;
+      font-size: 0.7rem;
+      font-weight: 600;
+      color: rgba(70, 67, 49, 0.9);
+      white-space: nowrap;
+    }
+  }
+
+  .sheet-tabs {
+    flex: 0;
+    font-family: "MailartRubberstamp";
+    font-size: 2.2rem;
+  }
+
+  .tox {
+    .tox-editor-container {
+      background: #fff;
+    }
+
+    .tox-edit-area {
+      padding: 0 8px;
+    }
+  }
+
+  .resource-label {
+    font-weight: bold;
+    text-transform: uppercase;
+  }
+
+  .tabs {
+    height: 40px;
+    border-top: 1px solid rgba(139, 115, 85, 0.4);
+    border-bottom: 1px solid rgba(139, 115, 85, 0.4);
+    background: linear-gradient(
+      180deg,
+      rgba(226, 226, 222, 0.5) 0%,
+      rgba(240, 235, 225, 0.3) 100%
+    );
+    color: #000000;
+    font-family: "GreatPrimer";
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+
+    .item {
+      line-height: 40px;
+      font-weight: bold;
+      padding: 0 1rem;
+      transition: all 0.2s ease;
+
+      &:hover {
+        background: rgba(226, 226, 222, 0.6);
+        color: rgba(70, 67, 49, 0.9);
+      }
+
+      &.active {
+        text-decoration: underline;
+        text-shadow: none;
+        background: rgba(196, 186, 166, 0.4);
+        border-bottom: 3px solid rgba(139, 115, 85, 0.8);
+      }
+    }
+  }
+
+  .items-list {
+    list-style: none;
+    margin: 1px 0;
+    padding: 0;
+    overflow-y: auto;
+
+    .item-header {
+      font-weight: bold;
+    }
+
+    .item {
+      height: 30px;
+      line-height: 24px;
+      padding: 1px 0;
+      border-bottom: 1px solid #bbb;
+
+      .item-image {
+        flex: 0 0 24px;
+        margin-right: 5px;
+      }
+
+      img {
+        display: block;
+      }
+    }
+
+    .item-name {
+      margin: 0;
+    }
+
+    .item-controls {
+      flex: 0 0 86px;
+      text-align: right;
+    }
+  }
+}
+
+.profile-img-container {
+  margin-right: 0.2rem;
+  max-width: 140px;
+  width: 140px;
+}
+
+.button-img {
+  vertical-align: baseline;
+  width: 8%;
+  height: 8%;
+  max-height: 48px;
+  border-width: 0px;
+  border: 1px solid rgba(0, 0, 0, 0);
+
+  &:hover {
+    color: rgba(255, 255, 128, 0.7);
+    border: 1px solid rgba(255, 128, 0, 0.8);
+    cursor: pointer;
+  }
+}
+
+.button-effect-img {
+  vertical-align: baseline;
+  width: 16px;
+  max-height: 16px;
+  height: 16;
+  border-width: 0;
+}
+
+.small-button-container {
+  height: 16px;
+  width: 16px;
+  border: 0;
+  vertical-align: bottom;
+}
+
+.fvtt-te-deum .sheet-body {
+  flex: 1 1 0;
+  min-height: 0;
+  overflow: hidden;
+  font-size: 0.8rem;
+  font-family: "GreatPrimer";
+}
+
+.fvtt-te-deum .sheet-body .tab {
+  height: 100%;
+  overflow-y: auto;
+  font-size: 0.8rem;
+  font-family: "GreatPrimer";
+}
+
+.fvtt-te-deum .sheet-body .tab .editor {
+  height: 100%;
+  font-size: 0.8rem;
+  font-family: "GreatPrimer";
+}

less/tedeum.less

@@ -0,0 +1,7 @@
+@import "variables";
+@import "base";
+@import "layout";
+@import "actor-sheet";
+@import "items";
+@import "chat";
+@import "dialogs";

less/variables.less

@@ -0,0 +1,30 @@
+@font-face {
+  font-family: "MailartRubberstamp";
+  src: url("../fonts/MailartRubberstamp-Regular.woff") format("woff");
+  font-family: "GreatPrimer";
+  src: url("../fonts/IM_FELL_Great_Primer_Roman.woff") format("woff");
+}
+
+// Variables LESS
+@window-header-title-font-size: 1.3rem;
+@window-header-title-font-weight: normal;
+@window-header-title-color: #f5f5f5;
+@major-button-font-size: 1.05rem;
+@major-button-font-weight: normal;
+@major-button-color: #dadada;
+@tab-header-font-size: 1rem;
+@tab-header-font-weight: 700;
+@tab-header-color: #403f3e;
+@tab-header-color-active: #4a0404;
+@actor-input-font-size: 0.8rem;
+@actor-input-font-weight: 500;
+@actor-input-color: black;
+@actor-label-font-size: 0.8rem;
+@actor-label-font-weight: 700;
+@actor-label-color: rgba(70, 67, 49, 0.76863);
+@debug-background-color-red: rgba(255, 0, 0, 0.32941);
+@debug-background-color-blue: rgba(29, 0, 255, 0.32941);
+@debug-background-color-green: rgba(84, 255, 0, 0.32941);
+@debug-box-shadow-red: inset 0 0 2px red;
+@debug-box-shadow-blue: inset 0 0 2px blue;
+@debug-box-shadow-green: inset 0 0 2px green;

modules/actors/tedeum-actor-sheet.js

@@ -1,151 +1,227 @@
 /**
- * Extend the basic ActorSheet with some very simple modifications
- * @extends {ActorSheet}
+ * Feuille de personnage Te Deum - AppV2
  */
 
 import { TeDeumUtility } from "../common/tedeum-utility.js";
 
+const { HandlebarsApplicationMixin } = foundry.applications.api
+
 /* -------------------------------------------- */
-export class TeDeumActorPJSheet extends ActorSheet {
+export class TeDeumActorPJSheet extends HandlebarsApplicationMixin(foundry.applications.sheets.ActorSheetV2) {
+
+  constructor(options = {}) {
+    super(options)
+    this._sheetMode = this.constructor.SHEET_MODES.PLAY
+  }
+
+  static SHEET_MODES = { EDIT: 0, PLAY: 1 }
 
   /** @override */
-  static get defaultOptions() {
-
-    return mergeObject(super.defaultOptions, {
-      classes: ["fvtt-te-deum", "sheet", "actor"],
-      template: "systems/fvtt-te-deum/templates/actors/actor-sheet.hbs",
+  static DEFAULT_OPTIONS = {
+    classes: ["fvtt-te-deum", "sheet", "actor"],
+    position: {
       width: 860,
-      height:680,
-      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "skills" }],
-      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
-      editScore: true
-    });
+      height: 680,
+    },
+    form: {
+      submitOnChange: true,
+      closeOnSubmit: false,
+    },
+    window: {
+      resizable: true,
+    },
+    dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
+    actions: {
+      editImage: TeDeumActorPJSheet.#onEditImage,
+      toggleSheet: TeDeumActorPJSheet.#onToggleSheet,
+      editItem: TeDeumActorPJSheet.#onEditItem,
+      deleteItem: TeDeumActorPJSheet.#onDeleteItem,
+      createItem: TeDeumActorPJSheet.#onCreateItem,
+      createBlessure: TeDeumActorPJSheet.#onCreateBlessure,
+      createCompetence: TeDeumActorPJSheet.#onCreateCompetence,
+      equipItem: TeDeumActorPJSheet.#onEquipItem,
+      modifyQuantity: TeDeumActorPJSheet.#onModifyQuantity,
+      rollCompetence: TeDeumActorPJSheet.#onRollCompetence,
+      rollArme: TeDeumActorPJSheet.#onRollArme,
+      rollDegats: TeDeumActorPJSheet.#onRollDegats,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    sheet: {
+      template: "systems/fvtt-te-deum/templates/actors/actor-sheet.hbs",
+    },
+  }
+
+  tabGroups = { primary: "principal" }
+
+  get isEditMode() {
+    return this._sheetMode === this.constructor.SHEET_MODES.EDIT
+  }
+
+  get isPlayMode() {
+    return this._sheetMode === this.constructor.SHEET_MODES.PLAY
   }
 
   /* -------------------------------------------- */
-  async getData() {
-
-    let formData = {
+  /** @override */
+  async _prepareContext() {
+    const actor = this.document
+    return {
       title: this.title,
-      id: this.actor.id,
-      type: this.actor.type,
-      img: this.actor.img,
-      name: this.actor.name,
+      id: actor.id,
+      type: actor.type,
+      img: actor.img,
+      name: actor.name,
       editable: this.isEditable,
       cssClass: this.isEditable ? "editable" : "locked",
-      system: duplicate(this.object.system),
-      limited: this.object.limited,
-      competences: this.actor.getCompetences(),
-      config: duplicate(game.system.tedeum.config),
-      armes: this.actor.getArmes(),
-      caracList: this.actor.prepareCaracteristiques(),
-      providence: this.actor.prepareProvidence(),
-      arbreCompetences: this.actor.prepareArbreCompetences(),
-      equipements: this.actor.getEquipements(),
-      graces: this.actor.getGraces(),
-      description: await TextEditor.enrichHTML(this.object.system.description, { async: true }),
-      notes: await TextEditor.enrichHTML(this.object.system.notes, { async: true }),
-      options: this.options,
-      owner: this.document.isOwner,
-      editScore: this.options.editScore,
-      isGM: game.user.isGM
+      system: foundry.utils.duplicate(actor.system),
+      systemFields: actor.system.schema.fields,
+      limited: actor.limited,
+      competences: actor.getCompetences(),
+      config: foundry.utils.duplicate(game.system.tedeum.config),
+      armes: actor.getArmes(),
+      caracList: actor.prepareCaracteristiques(),
+      providence: actor.prepareProvidence(),
+      arbreCompetences: actor.prepareArbreCompetences(),
+      equipements: actor.getEquipements(),
+      simples: actor.getSimples(),
+      armures: actor.getArmures(),
+      graces: actor.getGraces(),
+      blessures: actor.getBlessures(),
+      maladies: actor.getMaladies(),
+      poisons: actor.getPoisons(),
+      combat: actor.prepareCombat(),
+      bonusDegats: actor.getBonusDegats(),
+      nbActions: actor.getNbActions(),
+      initiative: actor.getInitiative(),
+      pointsArmuresLourdes: actor.getNbArmures(),
+      nbArmuresLourdes: actor.getNbArmuresLourdesActuel(),
+      santeModifier: actor.getSanteModifier(),
+      educations: actor.getEducations(),
+      enrichedDescription: await foundry.applications.ux.TextEditor.implementation.enrichHTML(actor.system.description, { async: true }),
+      enrichedEquipmentFree: await foundry.applications.ux.TextEditor.implementation.enrichHTML(actor.system.equipmentfree, { async: true }),
+      enrichedNotes: await foundry.applications.ux.TextEditor.implementation.enrichHTML(actor.system.notes, { async: true }),
+      enrichedHistoire: await foundry.applications.ux.TextEditor.implementation.enrichHTML(actor.system.histoire, { async: true }),
+      owner: actor.isOwner,
+      isEditMode: this.isEditMode,
+      isPlayMode: this.isPlayMode,
+      isGM: game.user.isGM,
     }
-    this.formData = formData;
-
-    console.log("PC : ", formData, this.object);
-    return formData;
   }
 
-
   /* -------------------------------------------- */
   /** @override */
-  activateListeners(html) {
-    super.activateListeners(html);
+  _onRender(context, options) {
+    super._onRender(context, options)
 
-    // Everything below here is only needed if the sheet is editable
-    if (!this.options.editable) return;
-    
-    html.bind("keydown", function(e) { // Ignore Enter in actores sheet
-      if (e.keyCode === 13) return false;
-    });  
+    // Tab navigation
+    const nav = this.element.querySelector('nav.tabs[data-group]')
+    if (nav) {
+      const group = nav.dataset.group
+      const activeTab = this.tabGroups[group] || "principal"
+      nav.querySelectorAll('[data-tab]').forEach(link => {
+        const tab = link.dataset.tab
+        link.classList.toggle('active', tab === activeTab)
+        link.addEventListener('click', event => {
+          event.preventDefault()
+          this.tabGroups[group] = tab
+          this.render()
+        })
+      })
+      this.element.querySelectorAll(`[data-group="${group}"][data-tab]`).forEach(content => {
+        content.classList.toggle('active', content.dataset.tab === activeTab)
+      })
+    }
 
-    // Update Inventory Item
-    html.find('.item-edit').click(ev => {
-      const li = $(ev.currentTarget).parents(".item-id")
-      let itemId = li.data("item-id")
-      const item = this.actor.items.get( itemId );
-      item.sheet.render(true);
-    });
-    // Delete Inventory Item
-    html.find('.item-delete').click(ev => {
-      const li = $(ev.currentTarget).parents(".item-id")
-      TeDeumUtility.confirmDelete(this, li).catch("Error : No deletion confirmed")
+    // Ignore Enter key in sheet inputs
+    this.element.addEventListener('keydown', e => {
+      if (e.keyCode === 13 && e.target.tagName !== 'TEXTAREA') e.preventDefault()
     })
-    html.find('.item-add').click(ev => {
-      let dataType = $(ev.currentTarget).data("type")
-      this.actor.createEmbeddedDocuments('Item', [{ name: "NewItem", type: dataType }], { renderSheet: true })
+  }
+
+  /* -------------------------------------------- */
+  // #region Static action handlers
+
+  static async #onEditImage(event) {
+    const fp = new FilePicker({
+      type: "image",
+      current: this.document.img,
+      callback: path => this.document.update({ img: path }),
     })
-        
-    html.find('.subactor-edit').click(ev => {
-      const li = $(ev.currentTarget).parents(".item");
-      let actorId = li.data("actor-id");
-      let actor = game.actors.get( actorId );
-      actor.sheet.render(true);
-    });
-    
-    html.find('.subactor-delete').click(ev => {
-      const li = $(ev.currentTarget).parents(".item");
-      let actorId = li.data("actor-id");
-      this.actor.delSubActor(actorId);
-    });
-    html.find('.quantity-minus').click(event => {
-      const li = $(event.currentTarget).parents(".item");
-      this.actor.incDecQuantity( li.data("item-id"), -1 );
-    } );
-    html.find('.quantity-plus').click(event => {
-      const li = $(event.currentTarget).parents(".item");
-      this.actor.incDecQuantity( li.data("item-id"), +1 );
-    } );
-
-    html.find('.roll-competence').click((event) => {
-      let compId = $(event.currentTarget).data("comp-id")
-      this.actor.rollCompetence(compId)
-    });    
-    html.find('.roll-arme').click((event) => {
-      const armeId = $(event.currentTarget).data("arme-id")
-      this.actor.rollArme(armeId)
-    });
-    
-    html.find('.lock-unlock-sheet').click((event) => {
-      this.options.editScore = !this.options.editScore;
-      this.render(true);
-    });    
-    html.find('.item-equip').click(ev => {
-      const li = $(ev.currentTarget).parents(".item");
-      this.actor.equipItem( li.data("item-id") );
-      this.render(true);      
-    });
-    html.find('.update-field').change(ev => {
-      const fieldName = $(ev.currentTarget).data("field-name");
-      let value = Number(ev.currentTarget.value);
-      this.actor.update( { [`${fieldName}`]: value } );
-    });    
-  }
-  
-  /* -------------------------------------------- */
-  /** @override */
-  setPosition(options = {}) {
-    const position = super.setPosition(options);
-    const sheetBody = this.element.find(".sheet-body");
-    const bodyHeight = position.height - 192;
-    sheetBody.css("height", bodyHeight);
-    return position;
+    fp.browse()
   }
 
-  /* -------------------------------------------- */
-  /** @override */
-  _updateObject(event, formData) {
-    // Update the Actor
-    return this.object.update(formData);
+  static async #onToggleSheet(event) {
+    this._sheetMode = this.isEditMode
+      ? this.constructor.SHEET_MODES.PLAY
+      : this.constructor.SHEET_MODES.EDIT
+    this.render()
   }
+
+  static async #onEditItem(event, target) {
+    const li = target.closest("[data-item-id]")
+    const item = this.actor.items.get(li?.dataset.itemId)
+    if (item) item.sheet.render(true)
+  }
+
+  static async #onDeleteItem(event, target) {
+    const li = target.closest("[data-item-id]")
+    await TeDeumUtility.confirmDelete(this, li)
+  }
+
+  static async #onCreateItem(event, target) {
+    const type = target.dataset.type
+    await this.actor.createEmbeddedDocuments('Item', [{ name: "Nouveau " + type, type }], { renderSheet: true })
+  }
+
+  static async #onCreateBlessure(event, target) {
+    const type = target.dataset.type
+    await this.actor.createEmbeddedDocuments('Item', [{
+      name: "Nouvelle " + type, type,
+      system: { typeBlessure: "estafilade", localisation: "corps", value: 0, appliquee: true, description: "" }
+    }], { renderSheet: true })
+  }
+
+  static async #onCreateCompetence(event, target) {
+    const type = target.dataset.type
+    const caracKey = target.dataset.caracKey
+    await this.actor.createEmbeddedDocuments('Item', [{ name: "Nouvelle " + type, type, system: { caracteristique: caracKey } }], { renderSheet: true })
+  }
+
+  static async #onEquipItem(event, target) {
+    const li = target.closest("[data-item-id]")
+    if (!li?.dataset.itemId) return
+    await this.actor.equipItem(li.dataset.itemId)
+  }
+
+  static async #onModifyQuantity(event, target) {
+    const li = target.closest("[data-item-id]")
+    if (!li?.dataset.itemId) return
+    const item = this.actor.items.get(li.dataset.itemId)
+    if (!item) return
+    const delta = parseInt(target.dataset.qty) || 0
+    await this.actor.incDecQuantity(li.dataset.itemId, delta)
+  }
+
+  static async #onRollCompetence(event, target) {
+    const li = target.closest("[data-item-id]")
+    if (!li?.dataset.itemId) return
+    await this.actor.rollCompetence(li.dataset.itemId)
+  }
+
+  static async #onRollArme(event, target) {
+    const li = target.closest("[data-item-id]")
+    if (!li?.dataset.itemId) return
+    await this.actor.rollArme(li.dataset.itemId)
+  }
+
+  static async #onRollDegats(event, target) {
+    const li = target.closest("[data-item-id]")
+    if (!li?.dataset.itemId) return
+    await this.actor.rollDegatsArme(li.dataset.itemId)
+  }
+
+  // #endregion
 }

modules/actors/tedeum-actor.js

@@ -14,8 +14,8 @@ export class TeDeumActor extends Actor {
   /**
    * Override the create() function to provide additional SoS functionality.
    *
-   * This overrided create() function adds initial items 
-   * Namely: Basic skills, money, 
+   * This overrided create() function adds initial items
+   * Namely: Basic skills, money,
    *
    * @param {Object} data        Barebones actor data which this function adds onto.
    * @param {Object} options     (Unused) Additional options which customize the creation workflow.
@@ -34,12 +34,24 @@ export class TeDeumActor extends Actor {
       return actor;
     }
 
+    if (data.type == 'pj' || data.type == 'pnj') {
+      const skills = await TeDeumUtility.loadCompendium("fvtt-te-deum.competences")
+      data.items = data.items || []
+      for (let skill of skills) {
+        if (skill.system.isBase || skill.system.score == 1) {
+          data.items.push(skill.toObject())
+        }
+      }
+    }
+
     return super.create(data, options);
   }
 
   /* -------------------------------------------- */
   async prepareData() {
     super.prepareData()
+
+
   }
 
   /* -------------------------------------------- */
@@ -53,6 +65,95 @@ export class TeDeumActor extends Actor {
     super._preUpdate(changed, options, user);
   }
 
+  /* -------------------------------------------- */
+  getCompetenceScore(compName) {
+    let competence = this.items.find(item => item.type == "competence" && item.name.toLowerCase() == compName.toLowerCase())
+    if (competence) {
+      if (competence.system.isBase) {
+        return this.system.caracteristiques[competence.system.caracteristique].value
+      }
+      return competence.system.score
+    }
+    return 0
+  }
+
+  /* -------------------------------------------- */
+  getMeilleureCompetenceMainGauche(comp) {
+    let compScore = this.getCompetenceScore(comp.name)
+    let mainGaucheScore = this.getCompetenceScore("main gauche")
+    if (mainGaucheScore < compScore) {
+      ui.notifications.info(`${this.name} : Utilisation de la compétence Main Gauche au lieu de ${comp.name}`)
+      let mainGaucheComp = this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "main gauche")
+      if (!mainGaucheComp) {
+        // Create a fake competence object
+        mainGaucheComp = foundry.utils.duplicate(comp)
+        mainGaucheComp.name = "Main Gauche"
+        mainGaucheComp.system.isBase = false
+        mainGaucheComp.system.score = 0
+        mainGaucheComp.system.caracteristique = "adresse"
+        mainGaucheComp.system.description = "Compétence Main Gauche (automatique)"
+        mainGaucheComp.system.isMainGauche = true
+        return mainGaucheComp
+      } else {
+        return mainGaucheComp
+      }
+    } else {
+      return comp
+    }
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(changed, options, userId) {
+    let updates = []
+    let memoriser = this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mémoriser")
+    let newScore = this.getCommonBaseValue(this.system.caracteristiques.adresse.value)
+    if (memoriser && memoriser?.system.score != newScore) {
+      updates.push({ _id: memoriser.id, "system.score": Number(newScore) })
+    }
+
+    let perception = this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "perception")
+    newScore = this.getCommonBaseValue(this.system.caracteristiques.sensibilite.value)
+    if (perception && perception.system.score != newScore) {
+      updates.push({ _id: perception.id, "system.score": Number(newScore) })
+    }
+
+    let charme = this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "charme")
+    newScore = this.getCommonBaseValue(this.system.caracteristiques.entregent.value)
+    if (charme && charme?.system.score != newScore) {
+      updates.push({ _id: charme.id, "system.score": Number(newScore) })
+    }
+
+    let endurance = this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "endurance")
+    newScore = this.getCommonBaseValue(this.system.caracteristiques.complexion.value)
+    if (endurance && endurance?.system.score != newScore) {
+      updates.push({ _id: endurance.id, "system.score": Number(newScore) })
+    }
+
+    let course = this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "course")
+    newScore = this.getCommonBaseValue(this.system.caracteristiques.adresse.value)
+    if (course && course?.system.score != newScore) {
+      updates.push({ _id: course.id, "system.score": Number(newScore) })
+    }
+
+    let initiative = this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "initiative")
+    newScore = this.getCommonBaseValue(this.system.caracteristiques.adresse.value)
+    if (initiative && initiative?.system.score != newScore) {
+      updates.push({ _id: initiative.id, "system.score": Number(newScore) })
+    }
+
+    let effort = this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "effort")
+    newScore = this.getCommonBaseValue(this.system.caracteristiques.puissance.value)
+    if (effort && effort?.system.score != newScore) {
+      updates.push({ _id: effort.id, "system.score": Number(newScore) })
+    }
+
+    if (updates.length > 0) {
+      this.updateEmbeddedDocuments('Item', updates)
+    }
+
+    super._onUpdate(changed, options, userId);
+  }
+
   /* -------------------------------------------- */
   async _preCreate(data, options, user) {
     await super._preCreate(data, options, user);
@@ -65,62 +166,248 @@ export class TeDeumActor extends Actor {
     this.updateSource({ prototypeToken });
   }
 
+  /* -------------------------------------------- */
+  getCommonBaseValue(value) {
+    return game.system.tedeum.config.COMMON_VALUE[value]?.value || 0
+  }
+  getInitiativeValue() {
+    return game.system.tedeum.config.COMMON_VALUE[this.system.caracteristiques.adresse.value]?.value || 0
+  }
   /* -------------------------------------------- */
   getBonusDegats() {
     return game.system.tedeum.config.BONUS_DEGATS[this.system.caracteristiques.puissance.value]
   }
   /* -------------------------------------------- */
+  getAttaqueBonusDegats(rollData = undefined) {
+    let base = game.system.tedeum.config.BONUS_DEGATS[this.system.caracteristiques.puissance.value].value
+    let additionalBonus = 0
+    if (rollData) {
+      // Spécificité armes naturelle avec gantelet
+      if (rollData?.arme?.system.specificites?.poing?.hasSpec && this.items.find(item => item.type == "armure" && item.name.toLowerCase() == "gantelet" && item.system.equipe)) {
+        additionalBonus += 1
+        rollData.gantelet = true
+      }
+      if (rollData.isChargeAPied) {
+        additionalBonus += this.getCompetenceScore("course")
+      } else if (rollData.isChargeACheval) {
+        additionalBonus += this.getCompetenceScore("equitation")
+      }
+    }
+    return base + additionalBonus
+  }
+  /* -------------------------------------------- */
   getNbArmures() {
     return game.system.tedeum.config.MAX_ARMURES_LOURDES[this.system.caracteristiques.puissance.value]
   }
   getNbActions() {
     return game.system.tedeum.config.ACTIONS_PAR_TOUR[this.system.caracteristiques.adresse.value]
   }
-
+  getInitiative() {
+    return game.system.tedeum.config.ACTIONS_PAR_TOUR[this.system.caracteristiques.adresse.value]
+  }
+  getNbArmuresLourdesActuel() {
+    let armures = this.getArmures()
+    let nb = 0
+    for (let armure of armures) {
+      if (armure.system.equipe) {
+        nb += armure.system.coutArmureLourde
+      }
+    }
+    return nb
+  }
+  /* -------------------------------------------- */
+  getEducations() {
+    let educations = this.items.filter(item => item.type == 'education')
+    return educations
+  }
   /* -------------------------------------------- */
   getCompetences() {
-    let comp = duplicate(this.items.filter(item => item.type == 'competence') || [])
+    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'competence') || [])
     return comp;
   }
   /* -------------------------------------------- */
   getGraces() {
-    let comp = duplicate(this.items.filter(item => item.type == 'grace') || [])
+    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'grace') || [])
     TeDeumUtility.sortArrayObjectsByName(comp)
     return comp;
   }
   getArmes() {
-    let comp = duplicate(this.items.filter(item => item.type == 'arme') || [])
+    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'arme') || [])
     TeDeumUtility.sortArrayObjectsByName(comp)
     return comp;
   }
   getEquipements() {
-    let comp = duplicate(this.items.filter(item => item.type == 'equipement') || [])
+    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'equipement') || [])
+    TeDeumUtility.sortArrayObjectsByName(comp)
+    return comp;
+  }
+  getSimples() {
+    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'simple') || [])
     TeDeumUtility.sortArrayObjectsByName(comp)
     return comp;
   }
   getArmures() {
-    let comp = duplicate(this.items.filter(item => item.type == 'armure') || [])
+    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'armure') || [])
+    TeDeumUtility.sortArrayObjectsByName(comp)
+    return comp;
+  }
+  getBlessures() {
+    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'blessure') || [])
+    for (let c of comp) {
+      let blessDef = game.system.tedeum.config.blessures[c.system.typeBlessure]
+      c.malus = blessDef.modifier
+    }
+    TeDeumUtility.sortArrayObjectsByName(comp)
+    return comp;
+  }
+  getMaladies() {
+    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'maladie') || [])
+    for (let c of comp) {
+      c.malus = "N/A"
+      if (c.system.appliquee) {
+        let malDef = game.system.tedeum.config.virulence[c.system.virulence]
+        c.malus = malDef.modifier
+      }
+    }
+    TeDeumUtility.sortArrayObjectsByName(comp)
+    return comp;
+  }
+  getPoisons() {
+    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'poison') || [])
+    for (let c of comp) {
+      c.malus = "N/A"
+      if (c.system.appliquee) {
+        let poisDef = game.system.tedeum.config.virulencePoison[c.system.virulence]
+        c.malus = poisDef.modifier
+      }
+    }
     TeDeumUtility.sortArrayObjectsByName(comp)
     return comp;
   }
-
   /* -------------------------------------------- */
-  calculMalusBlessures() {
-    let modifierBlessures = 0
-    let nbBlessures = 0
-    // Cumul des malus de blessures
-    for (let locKey in this.system.localisation) {
-      let loc = this.system.localisation[locKey]
-      let bDef = game.system.tedeum.config.blessures[loc.blessures]
-      modifierBlessures += bDef.modifier
-      nbBlessures += bDef.count
+  getSanteModifier() {
+    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'maladie') || [])
+    let modTotal = 0
+    for (let c of comp) {
+      if (c.system.appliquee) {
+        let maladieDef = game.system.tedeum.config.virulence[c.system.virulence]
+        modTotal += maladieDef.modifier
+      }
+    }
+    let simples = foundry.utils.duplicate(this.items.filter(item => item.type == 'simple') || [])
+    for (let c of simples) {
+      if (c.system.appliquee) {
+        let simpleDef = game.system.tedeum.config.virulencePoison[c.system.virulence]
+        modTotal += simpleDef.modifier
+      }
+    }
+    let blessures = foundry.utils.duplicate(this.items.filter(item => item.type == 'blessure') || [])
+    for (let c of blessures) {
+      let blessDef = game.system.tedeum.config.blessures[c.system.typeBlessure]
+      modTotal += blessDef.modifier
     }
     // Si le nombre de blessures est supérieur au score d'endurance, alors malus supplémentaire
-    let endurance = this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "endurance")
-    if ( nbBlessures > endurance.system.score) {
-      modifierBlessures += -1
+    let enduranceScore = this.getCompetenceScore("endurance")
+    if (blessures.length > enduranceScore) {
+      modTotal += -1
     }
-    return modifierBlessures    
+    return modTotal
+  }
+  /* -------------------------------------------- */
+  async appliquerBlessure(blessureId, locId, comment = "") {
+    let blessure = game.system.tedeum.config.blessures[blessureId]
+    if (!blessure) {
+      ui.notifications.warn("Type de blessure inconnu : " + blessureId)
+      console.error("Type de blessure inconnu : " + blessureId)
+      return
+    }
+    // Create a new blessure object
+    let blessureObj = {
+      name: blessure.label,
+      type: "blessure",
+      system: {
+        typeBlessure: blessureId,
+        localisation: locId || "maindroite",
+        value: blessure.value,
+        appliquee: true,
+        description: comment,
+      }
+    }
+    this.createEmbeddedDocuments('Item', [blessureObj]);
+  }
+
+  /* -------------------------------------------- */
+  getArmorDegatsModifier(rollData, combat) {
+    let loc = combat[rollData.loc.id]
+    // Sans armure
+    if (loc.armures.length == 0) {
+      return rollData.arme.system.degatsArmure.sansarmure
+    }
+    // Avec armure de cuir
+    if (loc.armures.find(a => a.system.typeArmure == "cuir")) {
+      return rollData.arme.system.degatsArmure.cuir
+    }
+    // Avec armure de maille
+    if (loc.armures.find(a => a.system.typeArmure == "maille")) {
+      return rollData.arme.system.degatsArmure.mailles
+    }
+    // Avec armure de plate
+    if (loc.armures.find(a => a.system.typeArmure == "plate")) {
+      return rollData.arme.system.degatsArmure.plates
+    }
+    return 0
+  }
+
+  /* -------------------------------------------- */
+  async appliquerDegats(rollData) {
+    let combat = this.prepareCombat()
+    rollData.defenderName = this.name
+    let touche = combat[rollData.loc.id].touche
+    let armorDegatModifier = this.getArmorDegatsModifier(rollData, combat)
+    rollData.degats += armorDegatModifier
+    rollData.armorDegatModifier = armorDegatModifier
+
+    let blessureId = "indemne"
+    if (rollData.degats > 0 && rollData.degats > touche) {
+      let diff = rollData.degats - touche
+      for (let bId in game.system.tedeum.config.blessures) {
+        let blessure = game.system.tedeum.config.blessures[bId]
+        if (diff >= blessure.degatsMin && diff <= blessure.degatsMax) {
+          if (rollData.isReussiteCritique) {
+            bId = game.system.tedeum.config.blessuresOrder[blessure.value + 1]
+          }
+          blessureId = bId
+          break
+        }
+      }
+    }
+    if (rollData.isReussiteCritique && blessureId == "indemne") { // Critical success without degats => lightest blessure
+      blessureId = "estafilade"
+    }
+    console.log("Appliquer dégats", rollData, combat, blessureId)
+    if (blessureId != "indemne") {
+      let blessure = game.system.tedeum.config.blessures[blessureId]
+      // Create a new blessure object
+      let blessureObj = {
+        name: blessure.label,
+        type: "blessure",
+        system: {
+          typeBlessure: blessureId,
+          localisation: rollData.loc.id,
+          value: blessure.value,
+          appliquee: true,
+          description: "Blessure infligée par un coup de " + rollData.arme.name + " de " + rollData.alias,
+        }
+      }
+      rollData.blessure = blessureObj
+      rollData.touche = touche
+      this.createEmbeddedDocuments('Item', [blessureObj]);
+    }
+    // Display the relevant chat message
+    let msg = await TeDeumUtility.createChatWithRollMode(rollData.alias, {
+      content: await foundry.applications.handlebars.renderTemplate(`systems/fvtt-te-deum/templates/chat/chat-blessure-result.hbs`, rollData)
+    })
+    await msg.setFlag("world", "te-deum-rolldata", rollData)
   }
 
   /* -------------------------------------------- */
@@ -128,17 +415,22 @@ export class TeDeumActor extends Actor {
     c.key = key
     c.name = game.system.tedeum.config.caracteristiques[key].label
     c.generalqualite = game.system.tedeum.config.descriptionValeur[c.value].qualite
-    c.qualite = game.system.tedeum.config.descriptionValeur[c.value][key]
+    if (this.system.genre.toLowerCase() == "homme") {
+      c.qualite = game.system.tedeum.config.descriptionValeur[c.value][key]
+    } else {
+      c.qualite = game.system.tedeum.config.descriptionValeurFemme[c.value][key]
+    }
     c.dice = game.system.tedeum.config.descriptionValeur[c.value].dice
     c.negativeDice = game.system.tedeum.config.descriptionValeur[c.value].negativeDice
   }
 
   /* -------------------------------------------- */
   prepareCaracteristiques() {
-    let carac = foundry.utils.deepClone(this.system.caracteristiques) 
+    let carac = foundry.utils.deepClone(this.system.caracteristiques)
     for (let key in carac) {
       let c = carac[key]
       this.updateCarac(c, key)
+      c.description = game.system.tedeum.config.caracteristiques[key].description
     }
     return carac
   }
@@ -146,22 +438,56 @@ export class TeDeumActor extends Actor {
   prepareProvidence() {
     let providence = foundry.utils.deepClone(this.system.providence)
     providence.name = "Providence"
-    providence.qualite = game.system.tedeum.config.providence[providence.value].labelM 
+    if (this.system.genre.toLowerCase() == "homme") {
+      providence.qualite = game.system.tedeum.config.providence[providence.value].labelM
+    } else {
+      providence.qualite = game.system.tedeum.config.providence[providence.value].labelF
+    }
     providence.dice = game.system.tedeum.config.providence[providence.value].diceValue
+    providence.description = "La Providence représente la Volonté Divine à l'œuvre pour guider ou sauver un être humain. Les PJ montent dans l’échelle de la Providence en menant à bien leurs missions et en se montrant vertueux. Les points de Providence peuvent servir à augmenter temporairement une caractéris- tique, à modifier la gravité d'une blessure, et à résister au vieillissement. Chaque person- nage commence avec un score initial de 1 en Providence (au niveau Pauvre pécheur)."
     return providence
   }
-  
+  /* -------------------------------------------- */
+  prepareCombat() {
+    let combatLoc = foundry.utils.deepClone(this.system.localisation)
+    for (let key in combatLoc) {
+      combatLoc[key] = foundry.utils.mergeObject(combatLoc[key], game.system.tedeum.config.LOCALISATION[key])
+      combatLoc[key].armures = []
+      combatLoc[key].blessures = []
+      combatLoc[key].protectionTotal = 0
+      let armures = this.getArmures()
+      for (let armure of armures) {
+        if (armure.system.equipe && armure.system.localisation[key].protege) {
+          combatLoc[key].armures.push(armure)
+          combatLoc[key].protectionTotal += armure.system.protection
+        }
+      }
+      let blessures = this.getBlessures()
+      for (let blessure of blessures) {
+        if (blessure.system.localisation == key) {
+          combatLoc[key].blessures.push(blessure)
+        }
+      }
+      let endurance = this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "endurance")
+      combatLoc[key].endurance = endurance.system.score + game.system.tedeum.config.LOCALISATION[key].locMod
+      combatLoc[key].touche = combatLoc[key].endurance + combatLoc[key].protectionTotal
+    }
+    return combatLoc
+  }
   /* -------------------------------------------- */
   modifyProvidence(value) {
     let providence = foundry.utils.duplicate(this.system.providence)
     providence.value = Math.min(Math.max(providence.value + value, 0), 6)
-    this.update( { "system.providence": providence } )
+    this.update({ "system.providence": providence })
   }
+
   /* -------------------------------------------- */
-  modifyXP(key, value) {
+  async modifyXP(key, value) {
     let xp = this.system.caracteristiques[key].experience
     xp = Math.max(xp + value, 0)
-    this.update( { [`system.caracteristiques.${key}.experience`]: xp } )
+    await this.update({ [`system.caracteristiques.${key}.experience`]: xp })
+    this.sheet?.render(true)
+    ui.notifications.info(`+${value} XP en ${game.system.tedeum.config.caracteristiques[key].label}`)
   }
 
   /* -------------------------------------------- */
@@ -174,7 +500,8 @@ export class TeDeumActor extends Actor {
       let caracDice = game.system.tedeum.config.descriptionValeur[this.system.caracteristiques[c.system.caracteristique].value].dice
       c.system.formula = caracDice + "+" + c.system.score
     })
-    return foundry.utils.deepClone( comp || {} )
+    comp = comp.sort((a, b) => a.name.localeCompare(b.name))
+    return foundry.utils.deepClone(comp || {})
   }
 
   /* -------------------------------------------- */
@@ -192,7 +519,7 @@ export class TeDeumActor extends Actor {
   getItemById(id) {
     let item = this.items.find(item => item.id == id);
     if (item) {
-      item = duplicate(item)
+      item = foundry.utils.duplicate(item)
     }
     return item;
   }
@@ -200,29 +527,58 @@ export class TeDeumActor extends Actor {
   /* -------------------------------------------- */
   async equipItem(itemId) {
     let item = this.items.find(item => item.id == itemId)
-    if (item?.system) {
-      if (item.type == "armure") {
-        let armor = this.items.find(item => item.id != itemId && item.type == "armor" && item.system.equipped)
-        if (armor) {
-          ui.notifications.warn("You already have an armor equipped!")
-          return
+    if (!this.checkArmure(item)) {
+      return
+    }
+    let update = { _id: item.id, "system.equipe": !item.system.equipe };
+    await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+  }
+
+  /* ------------------------------------------- */
+  checkArmure(item) {
+    if (item.type != "armure") {
+      return true
+    }
+    if (item.system.equipe) {
+      return true
+    }
+    let nbArmuresLourdes = this.getNbArmuresLourdesActuel()
+    if (nbArmuresLourdes + item.system.coutArmureLourde > this.getNbArmures().value) {
+      ui.notifications.warn("Impossible d'équiper cette armure, nombre d'armures lourdes maximum atteint")
+      return false
+    }
+
+    // Loop thru localisation
+    let armures = this.getArmures()
+    for (let loc in item.system.localisation) {
+      if (item.system.localisation[loc].protege) {
+        for (let armure of armures) {
+          if (armure.system.equipe && armure.system.localisation[loc].protege) {
+            let flag = true
+            //console.log("Check armure", armure, item)=
+            if (item.system.typeArmure == "cuir") {
+              flag = armure.system.superposableCuir
+            }
+            if (item.system.typeArmure == "maille") {
+              flag = armure.system.superposableMaille
+            }
+            if (item.system.typeArmure == "plate") {
+              flag = armure.system.superposablePlate
+            }
+            if (!flag) {
+              ui.notifications.warn("Impossible d'équiper cette armure, non superposable")
+              return flag
+            }
+          }
         }
       }
-      if (item.type == "shield") {
-        let shield = this.items.find(item => item.id != itemId && item.type == "shield" && item.system.equipped)
-        if (shield) {
-          ui.notifications.warn("You already have a shield equipped!")
-          return
-        }
-      }
-      let update = { _id: item.id, "system.equipped": !item.system.equipped };
-      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+      return true
     }
   }
 
   /* ------------------------------------------- */
   async buildContainerTree() {
-    let equipments = duplicate(this.items.filter(item => item.type == "equipment") || [])
+    let equipments = foundry.utils.duplicate(this.items.filter(item => item.type == "equipment") || [])
     for (let equip1 of equipments) {
       if (equip1.system.iscontainer) {
         equip1.system.contents = []
@@ -278,10 +634,17 @@ export class TeDeumActor extends Actor {
   }
 
   /* -------------------------------------------- */
-  getInitiativeScore(combatId, combatantId) {
-    let init = Math.floor((this.system.attributs.physique.value + this.system.attributs.habilite.value) / 2)
-    let subValue = new Roll("1d20").roll({ async: false })
-    return init + (subValue.total / 100)
+  getInitiativeScore() {
+    let initiative = this.getInitiativeValue()
+    // Vérifie les armes avec bonus d'initiative
+    let armes = this.getArmes()
+    for (let arme of armes) {
+      if (arme.system.equipe && Number(arme.system.initiativeBonus) && Number(arme.system.initiativeBonus) != 0) {
+        ui.notifications.info("L'arme " + arme.name + " vous confère un bonus d'initiative de " + arme.system.initiativeBonus)
+        initiative += arme.system.initiativeBonus
+      }
+    }
+    return initiative
   }
 
   /* -------------------------------------------- */
@@ -308,7 +671,7 @@ export class TeDeumActor extends Actor {
       }
     }
   }
-  
+
   /* -------------------------------------------- */
   getCommonRollData() {
     let rollData = TeDeumUtility.getBasicRollData()
@@ -317,7 +680,7 @@ export class TeDeumActor extends Actor {
     rollData.actorId = this.id
     rollData.img = this.img
     rollData.providence = this.prepareProvidence()
-    rollData.malusBlessures = this.calculMalusBlessures()
+    rollData.santeModifier = this.getSanteModifier()
 
     return rollData
   }
@@ -325,12 +688,12 @@ export class TeDeumActor extends Actor {
   /* -------------------------------------------- */
   getCommonCompetence(compId) {
     let rollData = this.getCommonRollData()
-    
-    let competence = duplicate(this.items.find(it => it.type =="competence" && it.id == compId))
+
+    let competence = foundry.utils.duplicate(this.items.find(it => it.type == "competence" && it.id == compId))
 
     rollData.competence = competence
     let c = foundry.utils.duplicate(this.system.caracteristiques[competence.system.caracteristique])
-    this.updateCarac( c, competence.system.caracteristique)
+    this.updateCarac(c, competence.system.caracteristique)
     rollData.carac = c
     rollData.img = competence.img
 
@@ -342,20 +705,77 @@ export class TeDeumActor extends Actor {
     let rollData = this.getCommonCompetence(compId)
     rollData.mode = "competence"
     rollData.title = rollData.competence.name
+    rollData.compScore = rollData.competence.system.isBase ? this.system.caracteristiques[rollData.competence.system.caracteristique].value : rollData.competence.system.score
     this.startRoll(rollData).catch("Error on startRoll")
   }
 
-
   /* -------------------------------------------- */
-  rollArme(armeId) {
+  async rollDegatsArme(armeId) {
     let weapon = this.items.get(armeId)
     if (weapon) {
-      weapon = duplicate(weapon)
+      let bDegats = { value: 0 }
+      if (weapon.system.typeArme == "melee") {
+        bDegats = this.getBonusDegats()
+      }
+      let formula = weapon.system.degats + "+" + bDegats.value
+      let degatsRoll = await new Roll(formula).roll()
+      await TeDeumUtility.showDiceSoNice(degatsRoll, game.settings.get("core", "rollMode"))
+      let rollData = this.getCommonRollData()
+      rollData.mode = "degats"
+      rollData.formula = formula
+      rollData.arme = foundry.utils.duplicate(weapon)
+      rollData.degatsRoll = foundry.utils.duplicate(degatsRoll)
+      rollData.degats = degatsRoll.total
+
+      let msg = await TeDeumUtility.createChatWithRollMode(rollData.alias, {
+        content: await foundry.applications.handlebars.renderTemplate(`systems/fvtt-te-deum/templates/chat/chat-degats-result.hbs`, rollData)
+      })
+      await msg.setFlag("world", "te-deum-rolldata", rollData)
+      console.log("Rolldata result", rollData)
+    }
+  }
+
+  /* -------------------------------------------- */
+  rollArme(armeId, compName = undefined) {
+    let weapon = this.items.get(armeId)
+    if (weapon) {
+      weapon = foundry.utils.duplicate(weapon)
       let rollData = this.getCommonRollData()
       rollData.mode = "arme"
+      rollData.isTir = weapon.system.typeArme == "tir"
       rollData.arme = weapon
       rollData.img = weapon.img
       rollData.title = weapon.name
+      rollData.porteeTir = "courte"
+      rollData.porteeLabel = game.system.tedeum.config.ARME_PORTEES.courte.label
+      rollData.isViser = false
+      rollData.isMouvement = false
+
+      // Display warning if not target defined
+      if (!rollData.defenderTokenId) {
+        ui.notifications.warn("Vous attaquez avec une arme : afin de bénéficier des automatisations, il est conseillé de selectionner une cible")
+      }
+
+      // Setup competence + carac
+      if (!compName) {
+        let compIdx = weapon.system.competence
+        compName = game.system.tedeum.config.armeCompetences[compIdx]?.label
+      }
+      let competence = this.items.find(item => item.type == "competence" && item.name.toLowerCase() == compName.toLowerCase())
+      if (competence) {
+        rollData.competence = competence
+        rollData.compScore = rollData.competence.system.isBase ? this.system.caracteristiques[rollData.competence.system.caracteristique].value : rollData.competence.system.score
+        let c = foundry.utils.duplicate(this.system.caracteristiques[competence.system.caracteristique])
+        this.updateCarac(c, competence.system.caracteristique)
+        rollData.carac = c
+        rollData.allongeLabel = game.system.tedeum.config.armeAllonges[weapon.system.allonge].label
+        rollData.allongeId = "courte"
+        rollData.allonges = foundry.utils.duplicate(game.system.tedeum.config.allonges[weapon.system.allonge])
+
+      } else {
+        ui.notifications.warn("Impossible de trouver la compétence " + compName)
+        return
+      }
       this.startRoll(rollData).catch("Error on startRoll")
     } else {
       ui.notifications.warn("Impossible de trouver l'arme concernée ")
@@ -365,8 +785,7 @@ export class TeDeumActor extends Actor {
   /* -------------------------------------------- */
   async startRoll(rollData) {
     console.log("startRoll", rollData)
-    let rollDialog = await TeDeumRollDialog.create(this, rollData)
-    rollDialog.render(true)
+    await TeDeumRollDialog.create(this, rollData)
   }
 
 }

modules/app/tedeum-character-creator.js

@@ -0,0 +1,669 @@
+import { TeDeumUtility } from "../common/tedeum-utility.js";
+import { TeDeumActor } from "../actors/tedeum-actor.js";
+export class TeDeumCharacterCreator {
+
+  /*--------------------------------------------*/
+  async init() {
+    this.stages = {}
+    this.currentStage = "origineSociale"
+    this.sexe = undefined
+    this.origineSociale = undefined
+    this.religion = undefined
+    this.caracBonus = {}
+    this.competenceBonus = {}
+    this.suiviReponses = []
+    this.competences = TeDeumUtility.getCompetencesForDropDown()
+    this.choiceSummary = {}
+
+    for (let k in game.system.tedeum.config.caracteristiques) {
+      this.caracBonus[k] = { value: 0 }
+    }
+
+    for (let stage in game.system.tedeum.config.etapesEducation) {
+      this.stages[stage] = { selectedItem: null, items: [] }
+    }
+
+    const educations = await TeDeumUtility.loadCompendium("fvtt-te-deum.education")
+    for (let edu of educations) {
+      this.stages[edu.system.etape].items.push(edu)
+    }
+
+    this.processStage()
+  }
+
+  /*--------------------------------------------*/
+  increaseCompetence(compName) {
+    if (compName === "" || compName == undefined || compName == "undefined") { return }
+    compName = compName.toLowerCase()
+    if (!this.competenceBonus[compName]) {
+      this.competenceBonus[compName] = { value: 1 }
+    } else {
+      this.competenceBonus[compName].value += 1
+    }
+    this.choiceSummary[this.currentStage].competences[compName] = 1
+  }
+
+  /*--------------------------------------------*/
+  processReponses(question) {
+    let fullResponses = []
+    for (let key in question.reponses) {
+      let response = question.reponses[key]
+      fullResponses.push({ id: key, label: `${response.reponse} (${TeDeumUtility.upperFirst( response.compName)} +1)` })
+    }
+    return fullResponses
+  }
+
+  /*--------------------------------------------*/
+  processReponsesRadio(question) {
+    let fullResponses = {}
+    let selected = true
+    for (let key in question.reponses) {
+      let response = question.reponses[key]
+      if (response.toSelect) {
+        fullResponses[key] = { label: `${response.reponse}`, competences: response.compList, selected }
+      } else {
+        fullResponses[key] = { label: `${response.reponse} (${response.compName} +1)`, selected }
+      }
+      selected = false
+    }
+    return fullResponses
+  }
+
+  /*--------------------------------------------*/
+  async askStageName(context) {
+    const content = await foundry.applications.handlebars.renderTemplate("systems/fvtt-te-deum/templates/dialogs/character-creator-select-stage-name.hbs", context)
+    const choiceResult = await foundry.applications.api.DialogV2.wait({
+      window: { title: context.title },
+      classes: ["fvtt-te-deum"],
+      content,
+      buttons: [
+        {
+          label: context.label,
+          callback: (event, button, dialog) => {
+            const output = Array.from(button.form.elements).reduce((obj, input) => {
+              if (input.name) obj[input.name] = input.value
+              return obj
+            }, {})
+            return output
+          },
+        },
+      ],
+      actions: {
+      },
+      rejectClose: false, // Click on Close button will not launch an error
+      render: (event, dialog) => {
+        $(".stage-selector").change(event => {
+          let stageId = event.target.value
+          let stage = context.choices.find(item => item.id === stageId)
+          let link = `<a class="content-link" draggable="true" data-link=""
+              data-uuid="Compendium.fvtt-te-deum.education.Item.${stageId}" data-id="${stageId}" data-type="Item"
+              data-pack="fvtt-te-deum.education" data-tooltip="Education Objet"><i class="fas fa-suitcase"></i>${stage.name}</a>`
+          $(".stage-main-details").html(`Voir le détail : ${link}`)
+        })
+
+        document.getElementById("stage-selector").dispatchEvent(new Event('change'))
+
+      }
+    })
+    return choiceResult
+  }
+
+  /*--------------------------------------------*/
+  processCompetences(compList) {
+    for (let compName in compList) {
+      this.increaseCompetence(compName)
+    }
+  }
+
+  /*--------------------------------------------*/
+  async askQuestionnaire(stage, context) {
+    context.subtitle = "Questionnaire"
+    this.choiceSummary[this.currentStage].questionnaire = {}
+
+    for (let key in stage.system.questionnaire) {
+      let question = stage.system.questionnaire[key]
+      if (question.question === "") { break }
+
+      context.question = question.question
+      context.responses = this.processReponses(question)
+      context.responsesRadio = this.processReponsesRadio(question)
+      context.competences = {}
+      context.responseKey = "reponse1" // By default
+
+      const content = await foundry.applications.handlebars.renderTemplate("systems/fvtt-te-deum/templates/dialogs/character-creator-select-questions.hbs", context)
+      const choiceResult = await foundry.applications.api.DialogV2.wait({
+        window: { title: context.title },
+        classes: ["fvtt-te-deum"],
+        content,
+        buttons: [
+          {
+            label: context.label,
+            callback: (event, button, dialog) => {
+              const output = Array.from(button.form.elements).reduce((obj, input) => {
+                if (input.name) obj[input.name] = input.value
+                return obj
+              }, {})
+              return output
+            },
+          },
+        ],
+        actions: {
+        },
+        rejectClose: false, // Click on Close button will not launch an error
+        render: (event, dialog) => {
+          $(".questionnaire-radio").click(event => {
+            let responseKey = $(event.target).data("response-key")
+            context.responseKey = responseKey
+          })
+          $(".questionnaire-select-competence").change(event => {
+            // Get the responseKey data
+            let responseKey = $(event.target).data("response-key")
+            let compName = event.target.value
+            console.log("Questionnaire Change", responseKey, compName)
+            context.competences[responseKey] = compName.toLowerCase()
+          })
+        }
+      })
+      if (choiceResult == null) {
+        this.currentStage = "cancelled"
+        return
+      }
+
+      let selectedResponse = question.reponses[context.responseKey]
+      let compName = context.competences[context.responseKey] || selectedResponse.compName
+      this.increaseCompetence(compName)
+
+      this.suiviReponses.push({ key: this.currentStage, etape: stage.name, question: question.question, reponse: selectedResponse.reponse, compName: compName })
+    }
+  }
+
+  /*------------- -------------------------------*/
+  async askCompetences(stage, context) {
+    context.subtitle = "Choix des Compétences"
+    this.choiceSummary[this.currentStage].competences = {}
+
+    context.fixedCompetences = {}
+    context.selectCompetences = {}
+    for (let compKey in stage.system.competences) {
+      let comp = stage.system.competences[compKey]
+      if (comp.valid && comp.compName !== "") {
+        if (comp.toSelect) {
+          context.hasSelectCompetences = true
+          context.selectCompetences[comp.compName] = TeDeumUtility.upperFirst(comp.compName)
+        } else {
+          context.fixedCompetences[comp.compName] = TeDeumUtility.upperFirst(comp.compName)
+        }
+      }
+    }
+
+    const content = await foundry.applications.handlebars.renderTemplate("systems/fvtt-te-deum/templates/dialogs/character-creator-select-competences.hbs", context)
+    const choiceResult = await foundry.applications.api.DialogV2.wait({
+      window: { title: context.title },
+      classes: ["fvtt-te-deum"],
+      content,
+      buttons: [
+        {
+          label: context.label,
+          callback: (event, button, dialog) => {
+            const output = Array.from(button.form.elements).reduce((obj, input) => {
+              if (input.name) obj[input.name] = input.value
+              return obj
+            }, {})
+            return output
+          },
+        },
+      ],
+      actions: {
+      },
+      rejectClose: false, // Click on Close button will not launch an error
+      render: (event, dialog) => {
+      }
+    })
+    if (choiceResult == null) {
+      this.currentStage = "cancelled"
+      return
+    }
+    context.fixedCompetences[choiceResult.selectedCompetence] = choiceResult.selectedCompetence
+    this.processCompetences(context.fixedCompetences)
+
+    // Handle specific case when multiple skills can be selected (ie compagnon case)
+    if ( stage.system.hasCompetencesOpt ) {
+      context.fixedCompetences = []
+      context.hasSelectCompetences = true
+      for (let i = 0; i < stage.system.competencesOptNumber; i++) {
+        context.competences = {}
+        context.selectCompetences = {}
+        for (let compKey in stage.system.competencesOpt) {
+          let comp = stage.system.competencesOpt[compKey]
+          if (comp.compName !== "") {
+            context.selectCompetences[comp.compName] = TeDeumUtility.upperFirst(comp.compName)
+          }
+        }
+
+        const content = await foundry.applications.handlebars.renderTemplate("systems/fvtt-te-deum/templates/dialogs/character-creator-select-competences.hbs", context)
+        const choiceResult = await foundry.applications.api.DialogV2.wait({
+          window: { title: context.title },
+          classes: ["fvtt-te-deum"],
+          content,
+          buttons: [
+            {
+              label: context.label,
+              callback: (event, button, dialog) => {
+                const output = Array.from(button.form.elements).reduce((obj, input) => {
+                  if (input.name) obj[input.name] = input.value
+                  return obj
+                }, {})
+                return output
+              },
+            },
+          ],
+          actions: {
+          },
+          rejectClose: false, // Click on Close button will not launch an error
+          render: (event, dialog) => {
+          }
+        })
+        if (choiceResult == null) {
+          this.currentStage = "cancelled"
+          return
+        }
+        context.fixedCompetences[choiceResult.selectedCompetence] = choiceResult.selectedCompetence
+        this.processCompetences(context.fixedCompetences)
+      }
+    }
+
+  }
+
+  /*------------- -------------------------------*/
+  async askCarac(stage, context) {
+    context.subtitle = "Choix des Caractéristiques"
+    this.choiceSummary[this.currentStage] = {
+      caracBonus : {},
+      competences : {}
+    }
+
+    let selected = []
+    for (let i = 0; i < stage.system.nbChoixCarac; i++) {
+      context.caracList = []
+      for (let caracKey in stage.system.caracteristiques) {
+        let carac = stage.system.caracteristiques[caracKey]
+        if (selected.includes(carac.caracId)) { continue }
+        context.caracList.push(game.system.tedeum.config.caracteristiques[carac.caracId])
+      }
+
+      const content = await foundry.applications.handlebars.renderTemplate("systems/fvtt-te-deum/templates/dialogs/character-creator-select-carac.hbs", context)
+      const choiceResult = await foundry.applications.api.DialogV2.wait({
+        window: { title: context.title },
+        classes: ["fvtt-te-deum"],
+        content,
+        buttons: [
+          {
+            label: context.label,
+            callback: (event, button, dialog) => {
+              const output = Array.from(button.form.elements).reduce((obj, input) => {
+                if (input.name) obj[input.name] = input.value
+                return obj
+              }, {})
+              return output
+            },
+          },
+        ],
+        actions: {
+        },
+        rejectClose: false, // Click on Close button will not launch an error
+        render: (event, dialog) => {
+        }
+      })
+      if (choiceResult == null) {
+        this.currentStage = "cancelled"
+        return
+      }
+      this.caracBonus[choiceResult.carac].value += 1
+      selected.push(choiceResult.carac)
+      this.choiceSummary[this.currentStage].caracBonus[choiceResult.carac] = 1
+    }
+  }
+
+  /*--------------------------------------------*/
+  async renderOrigineSociale(stage) {
+    let context = {
+      title: "Création de personnage",
+      subtitle: "Origine Sociale",
+      sexeChoice: { "Homme": "Homme", "Femme": "Femme" },
+      religionChoice: { "catholique": "Catholique", "protestante": "Protestante" },
+      origineChoice: game.system.tedeum.config.origineSociale
+    }
+
+    const content = await foundry.applications.handlebars.renderTemplate("systems/fvtt-te-deum/templates/dialogs/character-creator-origine.hbs", context)
+    const label = "Valider le choix de l'Origine Sociale"
+    const choiceResult = await foundry.applications.api.DialogV2.wait({
+      window: { title: context.title },
+      classes: ["fvtt-te-deum"],
+      content,
+      buttons: [
+        {
+          label: label,
+          callback: (event, button, dialog) => {
+            const output = Array.from(button.form.elements).reduce((obj, input) => {
+              if (input.name) obj[input.name] = input.value
+              return obj
+            }, {})
+            return output
+          },
+        },
+      ],
+      actions: {
+      },
+      rejectClose: false, // Click on Close button will not launch an error
+      render: (event, dialog) => { }
+    })
+
+    if (choiceResult == null) {
+      this.currentStage = "cancelled"
+      return
+    }
+
+    this.sexe = choiceResult.sexe
+    this.religion = choiceResult.religion
+    this.origineSociale = foundry.utils.duplicate(game.system.tedeum.config.origineSociale[choiceResult.origineSociale])
+    for (let key in this.origineSociale.caracteristiques) {
+      this.caracBonus[key].value += this.origineSociale.caracteristiques[key]
+    }
+    this.choiceSummary['origineSociale'] = {
+      sexe: this.sexe,
+      religion: this.religion,
+      origineSociale: this.origineSociale.label,
+      caracBonus: this.caracBonus,
+    }
+    this.currentStage = "pouponniere"
+
+  }
+
+  /*--------------------------------------------*/
+  async renderPouponniere(stage) {
+
+    // Filter available pouponniere from origineSociale
+    let pouponniereItems = stage.items.filter(item => item.system.accessible[this.origineSociale.id].isaccessible)
+
+    let context = {
+      title: "Création de personnage - La Pouponnière",
+      subtitle: "Choix de la Pouponnière",
+      label: "Valider le choix de la Pouponnière",
+      hasGenre: false,
+      choices: pouponniereItems,
+      caracBonus: this.caracBonus,
+      competenceBonus: this.competenceBonus
+    }
+    let choiceResult = await this.askStageName(context)
+    if (choiceResult == null) {
+      this.currentStage = "cancelled"
+      return
+    }
+
+    this.pouponniere = foundry.utils.duplicate(stage.items.find(item => item.id === choiceResult.selectedItem))
+    context.title = `La Pouponnière - ${this.pouponniere.name}`
+    TeDeumUtility.prepareEducationContent(this.pouponniere);
+    this.choiceSummary['pouponniere'] = {}
+
+    context.label = "Valider l'augmentation de caracteristique"
+    await this.askCarac(this.pouponniere, context)
+
+    context.label = "Valider l'augmentation de compétences"
+    await this.askCompetences(this.pouponniere, context)
+
+    context.label = "Valider cette réponse"
+    await this.askQuestionnaire(this.pouponniere, context)
+
+    this.currentStage = "petitsgrimauds"
+  }
+
+  /*--------------------------------------------*/
+  async renderPetitsGrimauds(stage) {
+    // Filter available pouponniere from origineSociale
+    let grimaudsItems = stage.items.filter(item => item.system.accessible[this.origineSociale.id].isaccessible && (item.system.genre === this.sexe || item.system.genre === "Mixte"))
+
+    let context = {
+      title: "Les Petits Grimauds",
+      label: "Valider le choix des Petits Grimauds",
+      hasGenre: true,
+      choices: grimaudsItems,
+      caracBonus: this.caracBonus,
+      competenceBonus: this.competenceBonus
+    }
+
+    let choiceResult = await this.askStageName(context)
+    if (choiceResult == null) {
+      this.currentStage = "cancelled"
+      return
+    }
+
+    this.grimauds = foundry.utils.duplicate(stage.items.find(item => item.id === choiceResult.selectedItem))
+    context.title = `LesPetits Grimauds - ${this.grimauds.name}`
+    TeDeumUtility.prepareEducationContent(this.grimauds);
+
+    context.label = "Valider l'augmentation de caracteristique"
+    await this.askCarac(this.grimauds, context)
+    context.label = "Valider l'augmentation de compétences"
+    await this.askCompetences(this.grimauds, context)
+
+    context.label = "Valider cette réponse"
+    await this.askQuestionnaire(this.grimauds, context)
+
+    this.currentStage = "rosevie"
+  }
+
+  /*--------------------------------------------*/
+  async renderRosesDeLaVie(stage) {
+    // Filter available pouponniere from origineSociale
+    let rosesItems = stage.items.filter(item => item.system.accessible[this.origineSociale.id].isaccessible && (item.system.genre === this.sexe || item.system.genre === "Mixte"))
+
+    let context = {
+      title: "Création de personnage - Les Roses de la Vie",
+      label: "Valider le choix des Roses de la Vie",
+      choices: rosesItems,
+      hasGenre: true,
+      caracBonus: this.caracBonus,
+      competenceBonus: this.competenceBonus
+
+    }
+
+    let choiceResult = await this.askStageName(context)
+    if (choiceResult == null) {
+      this.currentStage = "cancelled"
+      return
+    }
+
+    this.roses = foundry.utils.duplicate(stage.items.find(item => item.id === choiceResult.selectedItem))
+    context.title = `Les Roses de la Vie - ${this.roses.name}`
+    TeDeumUtility.prepareEducationContent(this.roses);
+
+    context.label = "Valider l'augmentation de caracteristique"
+    await this.askCarac(this.roses, context)
+    context.label = "Valider l'augmentation de compétences"
+    await this.askCompetences(this.roses, context)
+
+    context.label = "Valider cette réponse"
+    await this.askQuestionnaire(this.roses, context)
+
+    this.currentStage = "ageviril"
+  }
+
+  /*--------------------------------------------*/
+  async renderAgeViril(stage) {
+    let virilDebouche = this.roses.system.debouches
+    let ageVirilItems = []
+    for (let key in virilDebouche) {
+      let debouche = virilDebouche[key]
+      if (debouche.debouche === "") { continue }
+      let deboucheItem = stage.items.find(item => item.name.toLowerCase().includes(debouche.debouche.toLowerCase()))
+      if (deboucheItem) {
+        ageVirilItems.push(deboucheItem)
+      } else {
+        console.log(`Debouche ${debouche.debouche} not found !`)
+      }
+    }
+
+    let context = {
+      title: "Création de personnage - L'Age Viril",
+      label: "Valider le choix de l'Age Viril",
+      choices: ageVirilItems,
+      hasGenre: false,
+      caracBonus: this.caracBonus,
+      competenceBonus: this.competenceBonus
+    }
+
+    let choiceResult = await this.askStageName(context)
+    if (choiceResult == null) {
+      this.currentStage = "cancelled"
+      return
+    }
+
+    this.ageViril = foundry.utils.duplicate(stage.items.find(item => item.id === choiceResult.selectedItem))
+    context.title = `L'Age Viril - ${this.ageViril.name}`
+    TeDeumUtility.prepareEducationContent(this.ageViril);
+
+    context.label = "Valider l'augmentation de caracteristique"
+    await this.askCarac(this.ageViril, context)
+    context.label = "Valider l'augmentation de compétences"
+    await this.askCompetences(this.ageViril, context)
+
+    this.currentStage = "finished"
+  }
+
+  /*--------------------------------------------*/
+  async processStage() {
+    while (this.currentStage !== "finished") {
+      let stage = this.stages[this.currentStage]
+      switch (this.currentStage) {
+        case "origineSociale":
+          await this.renderOrigineSociale(stage)
+          break
+        case "pouponniere":
+          await this.renderPouponniere(stage)
+          break
+        case "petitsgrimauds":
+          await this.renderPetitsGrimauds(stage)
+          break
+        case "rosevie":
+          await this.renderRosesDeLaVie(stage)
+          break
+        case "ageviril":
+          await this.renderAgeViril(stage)
+          break
+        case "cancelled":
+          return
+          break
+      }
+    }
+
+    console.log("Carac Bonus", this.caracBonus)
+    console.log("Competence Bonus", this.competenceBonus)
+    let actor = await TeDeumActor.create({name: "Nouveau personnage", type: "pj"})
+    let updates = {}
+    for (let key in this.caracBonus) {
+      updates[`system.caracteristiques.${key}.value`] = Number(this.caracBonus[key].value)+1
+    }
+    updates['system.genre'] = this.sexe
+    updates['system.religion'] = TeDeumUtility.upperFirst(this.religion)
+    updates['system.statutocial'] = this.origineSociale.label
+    updates['system.equipmentfree'] = this.ageViril.system.trousseau
+    actor.update( updates);
+
+    // Process competences : increase know skills
+    let updateComp = []
+    let toAdd = []
+    for (let compName in this.competenceBonus) {
+      let comp = actor.items.find(  i => i.type == "competence" && i.name.toLowerCase() === compName.toLowerCase())
+      if (comp) {
+        updateComp.push({ _id: comp._id, "system.score": comp.system.score + this.competenceBonus[compName].value })
+      } else {
+        toAdd.push( compName)
+      }
+    }
+    actor.updateEmbeddedDocuments("Item", updateComp)
+
+    // Process adding skills
+    let compendiumSkill = TeDeumUtility.getCompetences()
+    let compToAdd = [ this.pouponniere, this.grimauds, this.roses, this.ageViril ]
+    for (let compName of toAdd) {
+      let comp = compendiumSkill.find( i => i.name.toLowerCase() === compName.toLowerCase())
+      comp.system.score = this.competenceBonus[compName].value
+      compToAdd.push(comp)
+    }
+    await actor.createEmbeddedDocuments('Item', compToAdd)
+
+    let newArgent = this.origineSociale.cagnotte * this.ageViril.system.cagnotteMultiplier
+    newArgent /= this.ageViril.system.cagnotteDivider
+    await actor.update({ [`system.fortune.${this.origineSociale.cagnotteUnit}`]: newArgent})
+
+    let histoire = ""
+    for ( let key in this.choiceSummary) {
+      let stageSummary = this.choiceSummary[key]
+      if (stageSummary.sexe) {
+        histoire += `<h3>Origine Sociale</h3>`
+        histoire += `<p>${stageSummary.sexe} - ${stageSummary.religion} - ${stageSummary.origineSociale}</p>`
+      } else {
+        histoire += `<h3>${game.system.tedeum.config.etapesEducation[key].label}</h3>`
+      }
+      if (stageSummary.caracBonus) {
+        histoire += `<p><strong>Caractéristiques : </strong><ul>`
+        for (let caracKey in stageSummary.caracBonus) {
+          histoire += `<li>${TeDeumUtility.upperFirst(caracKey)} +1</li>`
+        }
+        histoire += `</ul></p>`
+      }
+      if (stageSummary.competences) {
+        histoire += `<p><strong>Compétences : </strong><ul>`
+        for (let compName in stageSummary.competences) {
+          histoire += `<li>${TeDeumUtility.upperFirst(compName)} +1</li>`
+        }
+        histoire += `</ul></p>`
+      }
+      let questions = this.suiviReponses.filter( r => r.key === key)
+      if (questions.length > 0) {
+        histoire += `<p><strong>Réponses au questionnaire : </strong><ul>`
+        for (let question of questions) {
+          histoire += `<li>${question.question} : <i>${question.reponse}</i> (${TeDeumUtility.upperFirst(question.compName)}+1)</li>`
+        }
+        histoire += `</ul></p>`
+      }
+    }
+    await actor.update({ "system.histoire": histoire})
+    actor.render(true)
+
+    context.pointsCompetence = {
+      "savoir": { score: actor.getCompetenceScore("Mémoriser"), label: "Savoir" },
+      "sensibilite": { score: actor.getCompetenceScore("Perception"), label: "Sensibilité" },
+      "entregent": { score: actor.getCompetenceScore("Charme"), label: "Entregent" },
+      "puissance": { score: actor.getCompetenceScore("Effort"), label: "Puissance" },
+      "complexion": { score: actor.getCompetenceScore("Endurance"), label: "Complexion" },
+      "adresse": { score: actor.getCompetenceScore("Initiative"),   label: "Adresse" },
+    }
+
+    const content = await foundry.applications.handlebars.renderTemplate("systems/fvtt-te-deum/templates/dialogs/character-creator-finished.hbs", context)
+    const label = "Terminer"
+    const choiceResult = await foundry.applications.api.DialogV2.wait({
+      window: { title: context.title },
+      classes: ["fvtt-te-deum"],
+      content,
+      buttons: [
+        {
+          label: label,
+          callback: (event, button, dialog) => {
+            const output = Array.from(button.form.elements).reduce((obj, input) => {
+              if (input.name) obj[input.name] = input.value
+              return obj
+            }, {})
+            return output
+          },
+        },
+      ],
+      actions: {
+      },
+      rejectClose: false, // Click on Close button will not launch an error
+      render: (event, dialog) => { }
+    })
+
+  }
+
+}

modules/app/tedeum-combat.js

@@ -2,22 +2,42 @@ import { TeDeumUtility } from "../common/tedeum-utility.js";
 
 /* -------------------------------------------- */
 export class TeDeumCombat extends Combat {
-  
+
   /* -------------------------------------------- */
-  async rollInitiative(ids, formula = undefined, messageOptions = {} ) {
+  async rollInitiative(ids, formula = undefined, messageOptions = {}) {
+    //console.log("Roll INIT !")
     ids = typeof ids === "string" ? [ids] : ids;
-    for (let cId = 0; cId < ids.length; cId++) {
-      const c = this.combatants.get(ids[cId]);
-      let id = c._id || c.id;
-      let initBonus = c.actor ? c.actor.getInitiativeScore( this.id, id ) : -1;
-      await this.updateEmbeddedDocuments("Combatant", [ { _id: id, initiative: initBonus } ]);
+    for (let cId of ids) {
+      const c = this.combatants.get(cId);
+      let initBonus = c.actor ? c.actor.getInitiativeScore(this.id, cId) : -1;
+      console.log("Init Bonus : ", c.name, initBonus)
+      await this.updateEmbeddedDocuments("Combatant", [{ _id: cId, initiative: initBonus }]);
     }
 
     return this;
   }
 
   /* -------------------------------------------- */
-  _onUpdate(changed, options, userId) {
+  async modifyAction(combatantId, delta, isMainGauche = false) {
+    let combatant = this.combatants.get(combatantId)
+    if (!combatant) return;
+    let ca = combatant.getFlag("world", "available-actions")
+    if (!ca) {
+      ca = { nbActions: 1, nbActionsMainGauche: 0 }
+    }
+    if (isMainGauche) {
+      ca.nbActionsMainGauche += delta
+    } else {
+      ca.nbActions += delta
+    }
+    if (ca.nbActionsMainGauche < 0) ca.nbActionsMainGauche = 0
+    if (ca.nbActions < 0) ca.nbActions = 0
+    console.log("Modify Action : ", combatant.name, ca)
+    if (game.user.isGM) {
+      await TeDeumUtility.updateCombatantActions(combatant, ca)
+    } else {
+      game.socket.emit("system.fvtt-te-deum", { msg: "msg_modify_combat_action", data: { combatantId: combatantId, ca: ca } })
+    }
   }
 
   /* -------------------------------------------- */

modules/common/tedeum-config.js

@@ -9,30 +9,46 @@ export const TEDEUM_CONFIG = {
   { value: 7 }, { value: 9 }, { value: 11 }],
   ACTIONS_PAR_TOUR: [{}, { value: 1 }, { value: 2 }, { value: 2 },
   { value: 3 }, { value: 3 }, { value: 4 }],
+  COMMON_VALUE: [{}, { value: 1 }, { value: 2 }, { value: 3 },
+  { value: 4 }, { value: 5 }, { value: 6 }],
   COUT_XP: [{}, { value: 10 }, { value: 10 }, { value: 10 },
   { value: 10 }, { value: 30 }, { value: 50 }],
 
   LOCALISATION: {
-    "pieddroit": { label: "Pied Droit", value: 1, id: "pieddroit", nbArmure: 1 },
-    "jambedroite": { label: "Jambe Droite", value: 1, id: "jambedroite", nbArmure: 1 },
-    "jambegauche": { label: "Jambe Gauche", value: 1, id: "jambegauche", nbArmure: 1 },
-    "piedgauche": { label: "Pied Gauche", value: 1, id: "piedgauche", nbArmure: 1 },
-    "piedgauche": { label: "Pied Gauche", value: 1, id: "piedgauche", nbArmure: 1 },
-    "maindroite": { label: "Main Droite", value: 1, id: "maindroite", nbArmure: 1 },
-    "maingauche": { label: "Main Gauche", value: 1, id: "maingauche", nbArmure: 1 },
-    "brasdroit": { label: "Bras Droit", value: 1, id: "brasdroit", nbArmure: 2 },
-    "brasgauche": { label: "Bras Gauche", value: 1, id: "brasgauche", nbArmure: 2 },
-    "corps": { label: "Corps", value: 1, id: "corps", nbArmure: 2 },
-    "tete": { label: "Tête", value: 1, id: "tete", nbArmure: 2 },
+    "pieddroit": { label: "Pied Droit", value: 1, locMod: 0, id: "pieddroit", categorie: "pied", nbArmure: 1, score: { min: 1, max: 1 }, coord: { top: 500, left: 0 } },
+    "jambedroite": { label: "Jambe Droite", value: 1, locMod: -1, id: "jambedroite", categorie: "jambe", nbArmure: 1, score: { min: 3, max: 4 }, coord: { top: 400, left: 100 } },
+    "jambegauche": { label: "Jambe Gauche", value: 1, locMod: -1, id: "jambegauche", categorie: "jambe", nbArmure: 1, score: { min: 5, max: 6 }, coord: { top: 400, left: 300 } },
+    "piedgauche": { label: "Pied Gauche", value: 1, locMod: 0, id: "piedgauche", categorie: "pied", nbArmure: 1, score: { min: 2, max: 2 }, coord: { top: 500, left: 400 } },
+    "maindroite": { label: "Main Droite", value: 1, locMod: 0, id: "maindroite", categorie: "main", nbArmure: 1, score: { min: 7, max: 7 }, coord: { top: 0, left: 0 } },
+    "maingauche": { label: "Main Gauche", value: 1, locMod: 0, id: "maingauche", categorie: "main", nbArmure: 1, score: { min: 8, max: 8 }, coord: { top: 0, left: 400 } },
+    "brasdroit": { label: "Bras Droit", value: 1, locMod: -1, id: "brasdroit", categorie: "bras", nbArmure: 2, score: { min: 9, max: 10 }, coord: { top: 200, left: 0 } },
+    "brasgauche": { label: "Bras Gauche", value: 1, locMod: -1, id: "brasgauche", categorie: "bras", nbArmure: 2, score: { min: 11, max: 12 }, coord: { top: 200, left: 400 } },
+    "corps": { label: "Corps", value: 1, id: "corps", categorie: "corps", locMod: -2, nbArmure: 2, score: { min: 13, max: 17 }, coord: { top: 200, left: 200 } },
+    "tete": { label: "Tête", value: 1, id: "tete", categorie: "tete", locMod: -2, nbArmure: 2, score: { min: 18, max: 20 }, coord: { top: 0, left: 200 } },
+  },
+
+  ATTAQUE_CIBLEES: {
+    "aucune": { label: "Aucune", id: "aucune", locMod: 0, description: "Attaque non ciblée" },
+    "pieddroit": { label: "Pied Droit", id: "pieddroit", locMod: 0, description: "Attaque ciblée sur le pied droit" },
+    "jambedroite": { label: "Jambe Droite", id: "jambedroite", locMod: -1, description: "Attaque ciblée sur la jambe droite" },
+    "jambegauche": { label: "Jambe Gauche", id: "jambegauche", locMod: -1, description: "Attaque ciblée sur la jambe gauche" },
+    "piedgauche": { label: "Pied Gauche", id: "piedgauche", locMod: 0, description: "Attaque ciblée sur le pied gauche" },
+    "maindroite": { label: "Main Droite", id: "maindroite", locMod: 0, description: "Attaque ciblée sur la main droite" },
+    "maingauche": { label: "Main Gauche", id: "maingauche", locMod: 0, description: "Attaque ciblée sur la main gauche" },
+    "brasdroit": { label: "Bras Droit", id: "brasdroit", locMod: -1, description: "Attaque ciblée sur le bras droit" },
+    "brasgauche": { label: "Bras Gauche", id: "brasgauche", locMod: -1, description: "Attaque ciblée sur le bras gauche" },
+    "corps": { label: "Corps", id: "corps", locMod: -2, description: "Attaque ciblée sur le corps" },
+    "tete": { label: "Tête", id: "tete", locMod: -2, description: "Attaque ciblée sur la tête" },
   },
 
   ARME_SPECIFICITE: {
-    "encombrante": { label: "Encombrante", id: "encombrante", melee: true, tir: true},
+    "poing": { label: "Poings", id: "poing", melee: true, tir: false },
+    "pied": { label: "Pieds", id: "pied", melee: true, tir: false },
+    "encombrante": { label: "Encombrante", id: "encombrante", melee: true, tir: true },
     "maintiendistance": { label: "Maintien à distance", id: "maintiendistance", melee: true, tir: false },
-    "coupassomant": { label: "Coup assomant", id: "coupassomant", melee: true, tir: false},
-    "peutlancer": { label: "Peut être lancée", id: "peutlancer", melee: true, tir: false},
-    "pasboutportant": { label: "Inutilisable à bout portant", id: "pasboutportant", melee: false, tir: true},
-    "rechargearquebusade": { label: "Retrancher l'Arquebusade au temps de recharge", id: "rechargearquebusade", melee: false, tir: true },
+    "coupassomant": { label: "Coup assomant", id: "coupassomant", melee: true, tir: false },
+    "peutlancer": { label: "Peut être lancée", id: "peutlancer", melee: true, tir: false },
+    "pasboutportant": { label: "Inutilisable à bout portant", id: "pasboutportant", melee: false, tir: true },
     "mitraille": { label: "Mitraille", id: "mitraille", melee: false, tir: true },
     "degatscharge": { label: "Dégâts accrus à la charge", id: "degatscharge", melee: true, tir: false },
     "crochecavalier": { label: "Croche-cavalier", id: "crochecavalier", melee: true, tir: false },
@@ -43,18 +59,23 @@ export const TEDEUM_CONFIG = {
   },
 
   ARME_PORTEES: {
-    "brulepourpoint": { label: "Brûle-pourpoint", difficulty: "facile", id: "brulepourpoint"},
-    "courte": { label: "Courte", difficulty: "pardefaut", id: "courte"},
-    "moyenne": { label: "Moyenne", difficulty: "difficile", id: "moyenne"},
-    "longue": { label: "Longue", difficulty: "perilleux", id: "longue"},
-    "extreme": { label: "Extrême", difficulty: "desespere", id: "extreme"},
+    "brulepourpoint": { label: "Brûle-pourpoint (5)", difficulty: "facile", id: "brulepourpoint" },
+    "courte": { label: "Courte (7)", difficulty: "pardefaut", id: "courte" },
+    "moyenne": { label: "Moyenne (11)", difficulty: "difficile", id: "moyenne" },
+    "longue": { label: "Longue (13)", difficulty: "perilleux", id: "longue" },
+    "extreme": { label: "Extrême (15)", difficulty: "desespere", id: "extreme" },
+  },
+
+  genre: {
+    Homme: { label: "Homme", value: "Homme" },
+    Femme: { label: "Femme", value: "Femme" }
   },
 
   descriptionValeurOdd: {
     1: { valeur: 1, qualite: "Mauvais", dice: "d4", negativeDice: "d20", savoir: "Sot", sensibilite: "Obtus", entregent: "Rustaud", puissance: "Menu", complexion: "Anémique", adresse: "Empesé" },
-    2: { valeur: 2, qualite: "Médiocre", dice: "d6", negativeDice: "d12", savoir: "Limité", sensibilite: "Etriqué", entregent: "Frustre", puissance: "Délicat", complexion: "Languide", adresse: "Gauche" },
+    2: { valeur: 2, qualite: "Médiocre", dice: "d6", negativeDice: "d12", savoir: "Limité", sensibilite: "Etriqué", entregent: "Fruste", puissance: "Délicat", complexion: "Languide", adresse: "Gauche" },
     3: { valeur: 3, qualite: "Correct", dice: "d8", negativeDice: "d10", savoir: "Mêlé", sensibilite: "Ouvert", entregent: "Badin", puissance: "Membru", complexion: "Dispos", adresse: "Ingambe" },
-    4: { valeur: 4,  qualite: "Bon", dice: "d10", negativeDice: "d8", savoir: "Lettré", sensibilite: "Fin", entregent: "Disert", puissance: "Vigoureux", complexion: "Gaillard", adresse: "Leste" },
+    4: { valeur: 4, qualite: "Bon", dice: "d10", negativeDice: "d8", savoir: "Lettré", sensibilite: "Fin", entregent: "Disert", puissance: "Vigoureux", complexion: "Gaillard", adresse: "Leste" },
     5: { valeur: 5, qualite: "Bon", dice: "d10", negativeDice: "d8", savoir: "Lettré", sensibilite: "Fin", entregent: "Disert", puissance: "Vigoureux", complexion: "Gaillard", adresse: "Leste" },
     6: { valeur: 6, qualite: "Bon", dice: "d10", negativeDice: "d8", savoir: "Lettré", sensibilite: "Fin", entregent: "Disert", puissance: "Vigoureux", complexion: "Gaillard", adresse: "Leste" },
     7: { valeur: 7, qualite: "Excellent", dice: "d12", negativeDice: "d6", savoir: "Docte", sensibilite: "Subtil", entregent: "Galant", puissance: "Musculeux", complexion: "Sanguin", adresse: "Preste" },
@@ -66,29 +87,42 @@ export const TEDEUM_CONFIG = {
   },
   descriptionValeur: {
     1: { valeur: 1, qualite: "Mauvais", dice: "d4", negativeDice: "d20", savoir: "Sot", sensibilite: "Obtus", entregent: "Rustaud", puissance: "Menu", complexion: "Anémique", adresse: "Empesé" },
-    2: { valeur: 2, qualite: "Médiocre", dice: "d6", negativeDice: "d12", savoir: "Limité", sensibilite: "Etriqué", entregent: "Frustre", puissance: "Délicat", complexion: "Languide", adresse: "Gauche" },
+    2: { valeur: 2, qualite: "Médiocre", dice: "d6", negativeDice: "d12", savoir: "Limité", sensibilite: "Etriqué", entregent: "Fruste", puissance: "Délicat", complexion: "Languide", adresse: "Gauche" },
     3: { valeur: 3, qualite: "Correct", dice: "d8", negativeDice: "d10", savoir: "Mêlé", sensibilite: "Ouvert", entregent: "Badin", puissance: "Membru", complexion: "Dispos", adresse: "Ingambe" },
     4: { valeur: 4, qualite: "Bon", dice: "d10", negativeDice: "d8", savoir: "Lettré", sensibilite: "Fin", entregent: "Disert", puissance: "Vigoureux", complexion: "Gaillard", adresse: "Leste" },
     5: { valeur: 5, qualite: "Excellent", dice: "d12", negativeDice: "d6", savoir: "Docte", sensibilite: "Subtil", entregent: "Galant", puissance: "Musculeux", complexion: "Sanguin", adresse: "Preste" },
     6: { valeur: 6, qualite: "Admirable", dice: "d20", negativeDice: "d4", savoir: "Humaniste", sensibilite: "Spirituel", entregent: "Sémillant", puissance: "Hercule", complexion: "Aguerri", adresse: "Alerte" },
   },
-  diceValeur: [ "d4", "d6", "d8", "d10", "d12", "d20" ],
-  degatsArmure : {    
-    sansarmure : { label: "Sans armure"},
-    cuir : { label: "Cuir"},
-    plates : { label: "Plates"},
-    mailles : { label: "Mailles"},
+  descriptionValeurFemme: {
+    1: { valeur: 1, qualite: "Mauvais", dice: "d4", negativeDice: "d20", savoir: "Sotte", sensibilite: "Obtuse", entregent: "Rustaude", puissance: "Menue", complexion: "Anémique", adresse: "Empesée" },
+    2: { valeur: 2, qualite: "Médiocre", dice: "d6", negativeDice: "d12", savoir: "Limitée", sensibilite: "Etriquée", entregent: "Fruste", puissance: "Délicate", complexion: "Languide", adresse: "Gauche" },
+    3: { valeur: 3, qualite: "Correct", dice: "d8", negativeDice: "d10", savoir: "Mêlée", sensibilite: "Ouverte", entregent: "Badine", puissance: "Membrue", complexion: "Dispose", adresse: "Ingambe" },
+    4: { valeur: 4, qualite: "Bon", dice: "d10", negativeDice: "d8", savoir: "Lettrée", sensibilite: "Fine", entregent: "Diserte", puissance: "Vigoureuse", complexion: "Gaillarde", adresse: "Leste" },
+    5: { valeur: 5, qualite: "Excellent", dice: "d12", negativeDice: "d6", savoir: "Docte", sensibilite: "Subtile", entregent: "Galante", puissance: "Musculeuse", complexion: "Sanguine", adresse: "Preste" },
+    6: { valeur: 6, qualite: "Admirable", dice: "d20", negativeDice: "d4", savoir: "Humaniste", sensibilite: "Spirituelle", entregent: "Sémillante", puissance: "Hercule", complexion: "Aguerrie", adresse: "Alerte" },
+  },
+  diceValeur: ["d4", "d6", "d8", "d10", "d12", "d20"],
+  degatsArmure: {
+    sansarmure: { label: "Sans armure" },
+    cuir: { label: "Cuir" },
+    plates: { label: "Plates" },
+    mailles: { label: "Mailles" },
   },
 
   caracteristiques: {
-    savoir: { id: "savoir", value: "savoir", label: "Savoir" },
-    sensibilite: { id: "sensibilite", value: "sensibilite", label: "Sensibilité" },
-    entregent: { id: "entregent", value: "entregent", label: "Entregent" },
-    complexion: { id: "complexion", value: "complexion", label: "Complexion" },
-    puissance: { id: "puissance", value: "puissance", label: "Puissance" },
-    adresse: { id: "adresse", value: "adresse", label: "Adresse" },
+    savoir: { id: "savoir", value: "savoir", label: "Savoir", description: "Cette caractéristique correspond à la capacité d'abstraction intellectuelle ainsi qu'à la culture générale du personnage. Elle permet d'évaluer la compétence de base Mémoriser." },
+    sensibilite: { id: "sensibilite", value: "sensibilite", label: "Sensibilité", description: "Cette caractéristique correspond à l'ouverture du personnage sur le monde. Elle englobe l'altruisme, la spiritualité et la créativité du personnage. Elle permet d'évaluer la compétence de base Perception." },
+    entregent: { id: "entregent", value: "entregent", label: "Entregent", description: "Cette caractéristique correspond à l'ensemble des prédispositions sociales du personnage. Elle englobe le charisme et le respect des usages. Elle permet d'évaluer la compétence de base Charme." },
+    complexion: { id: "complexion", value: "complexion", label: "Complexion", description: "Cette caractéristique permet d'évaluer la santé et la résistance physique du per- sonnage. Elle permet de calculer la com- pétence de base Endurance, capitale dans la résolution des blessures, la résistance à la douleur, au poison et aux maladies." },
+    puissance: { id: "puissance", value: "puissance", label: "Puissance", description: "Cette caractéristique correspond à la force physique du personnage. Elle permet d'évaluer la compétence de base Effort, le bonus de dégâts au corps à corps, ainsi que le nombre de pièces d'armure lourde qu'un per- sonnage peut endosser sans être trop ralenti." },
+    adresse: { id: "adresse", value: "adresse", label: "Adresse", description: "Cette caractéristique correspond à la rapidité et la dextérité du personnage. Elle livre le nombre d'actions qu'un personnage peut accomplir en un tour de combat et permet d'évaluer les compétences de base Initiative & Course." },
+  },
+  allonges: {
+    courte: { courte: { label: "Courte (0)", malus: 0 }, moyenne: { label: "Moyenne (-1)", malus: -1 }, longue: { label: "Longue (-2)", malus: -2 }, treslongue: { label: "Très longue (0, 2 Esquives)", malus: 0, esquive: 2 } },
+    moyenne: { courte: { label: "Courte (0)", malus: 0 }, moyenne: { label: "Moyenne (0)", malus: 0 }, longue: { label: "Longue (-1)", malus: -1 }, treslongue: { label: "Très longue (0, 2 Esquives)", malus: 0, esquive: 2 } },
+    longue: { courte: { label: "Courte (-2)", malus: -2 }, moyenne: { label: "Moyenne (-1)", malus: -1 }, longue: { label: "Longue (0)", malus: 0 }, treslongue: { label: "Très longue (-1, 2 Esquives)", malus: -1, esquive: 1 } },
+    treslongue: { courte: { label: "Courte (0, 2 Esquives)", malus: 0, esquive: 2 }, moyenne: { label: "Moyenne (0, 2 Esquives)", malus: 0, esquive: 2 }, longue: { label: "Longue (0, 1 Esquive)", malus: 0, esquive: 1 }, treslongue: { label: "Très longue (0)", malus: 0 } },
   },
-
   providence: [
     { labelM: "Brebis égarée", labelF: "Brebis égarée", value: 0, diceValue: "0" },
     { labelM: "Pauvre pêcheur", labelF: "Pauvre pêcheresse", value: 1, diceValue: "d4" },
@@ -98,16 +132,25 @@ export const TEDEUM_CONFIG = {
     { labelM: "Oint du Seigneur", labelF: "Ointe du Seigneur", value: 5, diceValue: "d12" },
     { labelM: "Dans la main de Dieu", labelF: "Dans la main de Dieu", value: 6, diceValue: "d20" },
   ],
-
+  armureTypes: {
+    cuir: { label: "Cuir", value: "cuir" },
+    maille: { label: "Maille", value: "maille" },
+    plate: { label: "Plate", value: "plate" },
+  },
   armeTypes: {
     melee: { label: "Mêlée", value: "melee" },
     tir: { label: "Tir", value: "tir" }
   },
+  genreEducation: {
+    "homme": { label: "Homme", value: "Homme" },
+    "femme": { label: "Femme", value: "Femme" },
+    "mixte": { label: "Mixte", value: "Mixte" }
+  },
   armeAllonges: {
     courte: { label: "Courte", value: "courte" },
     moyenne: { label: "Moyenne", value: "moyenne" },
     longue: { label: "Longue", value: "longue" },
-    treslongue: { label: "Très longue", value: "treslongue"}
+    treslongue: { label: "Très longue", value: "treslongue" }
   },
   armeCompetences: {
     bagarre: { label: "Bagarre", value: "bagarre" },
@@ -118,52 +161,84 @@ export const TEDEUM_CONFIG = {
     archerie: { label: "Archerie", value: "archerie" },
     arquebusade: { label: "Arquebusade", value: "arquebusade" }
   },
+  competencesRecharge: {
+    aucune: { label: "Aucune", value: "aucune" },
+    archerie: { label: "Archerie", value: "archerie" },
+    arquebusade: { label: "Arquebusade", value: "arquebusade" }
+  },
   difficulte: {
-    routine: { label: "Routine", value: 3 },
-    facile: { label: "Facile", value: 5 },
-    pardefaut: { label: "Par Défaut", value: 7 },
-    malaise: { label: "Malaisé", value: 9 },
-    difficile: { label: "difficile", value: 11 },
-    perilleux: { label: "Perilleux", value: 13 },
-    desespere: { label: "Désespéré", value: 15 }
+    aucune: { label: "Aucune", key: "aucune", value: 0 },
+    routine: { label: "Routine (3)", key: "routine", value: 3 },
+    facile: { label: "Facile (5)", key: "facile", value: 5 },
+    pardefaut: { label: "Par Défaut (7)", key: "pardefaut", value: 7 },
+    malaise: { label: "Malaisé (9)", key: "malaise", value: 9 },
+    difficile: { label: "Difficile (11)", key: "difficile", value: 11 },
+    perilleux: { label: "Perilleux (13)", key: "perilleux", value: 13 },
+    desespere: { label: "Désespéré (15)", key: "desespere", value: 15 }
   },
   monnaie: {
     denier: { label: "Deniers", id: "denier", value: 1 },
     sol: { label: "Sols", id: "sol", value: 10 },
     livre: { label: "Livres", id: "livre", value: 100 }
   },
+  monnaieUnit: {
+    "1": { label: "Deniers", id: "denier", value: 1 },
+    "10": { label: "Sols", id: "sol", value: 10 },
+    "100": { label: "Livres", id: "livre", value: 100 }
+  },
   etapesEducation: {
-    pouponniere: { label: "La Pouponnière", value: "pouponniere", agemin: 0, agemax: 6, nbCompetences: 2, nbCaracteristiques: 3, hasQuestionnaire: true, hasMultiplier: false },
-    petitsgrimauds: { label: "La classe des Petits Grimauds", value: "petitsgrimauds", agemin: 7, agemax: 12,nbCompetences: 2, nbCaracteristiques: 3, hasQuestionnaire: true, hasMultiplier: false },
-    rosevie: { label: "Les Roses de la Vie", value: "rosevie", agemin: 13, agemax: 16, nbCompetences: 2, nbCaracteristiques: 3, hasQuestionnaire: true, hasMultiplier: false },
-    ageviril: { label: "L'Age Viril", value: "ageviril", agemin: 17, agemax: 17, nbCompetences: 9, nbCaracteristiques: 2, hasQuestionnaire: false, hasMultiplier: true },
+    pouponniere: { label: "La Pouponnière", value: "pouponniere", agemin: 0, agemax: 6, nbCompetences: 2, nbCaracteristiques: 3, hasGenre: false, hasQuestionnaire: true, hasDebouches: false, hasMultiplier: false, canCompetencesOpt: false },
+    petitsgrimauds: { label: "La classe des Petits Grimauds", value: "petitsgrimauds", agemin: 7, agemax: 12, nbCompetences: 10, hasGenre: true, nbCaracteristiques: 3, hasDebouches: false, hasQuestionnaire: true, hasMultiplier: false, canCompetencesOpt: false },
+    rosevie: { label: "Les Roses de la Vie", value: "rosevie", agemin: 13, agemax: 16, nbCompetences: 2, nbCaracteristiques: 3, hasGenre: true, hasQuestionnaire: true, hasDebouches: true, hasMultiplier: false, canCompetencesOpt: false },
+    ageviril: { label: "L'Age Viril", value: "ageviril", agemin: 17, agemax: 17, nbCompetences: 9, nbCaracteristiques: 2, hasGenre: false, hasQuestionnaire: false, hasDebouches: false, hasMultiplier: true, canCompetencesOpt: true },
   },
   origineSociale: {
-    noblesseepee: { label: "Noblesse d'épée", id: "noblesseepee", value: 1 },
-    noblessecloche: { label: "Noblesse de cloche", id: "noblessecloche", value: 2 },
-    hautenoblesse: { label: "Haute noblesse (Illégitime)", id: "hautenoblesse", value: 3 },
-    hautebourgeoisie: { label: "Haute bourgeoisie", id: "hautebourgeoisie", value: 4 },
-    petitebourgeoisie: { label: "Petite bourgeoisie (Marchands)", id: "petitebourgeoisie", value: 5 },
-    artisan: { label: "Artisans", id: "artisan", value: 6 },
-    laboureur: { label: "Laboureurs", id: "laboureur", value: 7 },
-    domesticite: { label: "Domesticité", id: "domesticite", value: 8 },
-    paysannerie: { label: "Paysannerie", id: "paysannerie", value: 9 },
-    gueux: { label: "Gueux", id: "gueux", value: 10 },
+    noblesseepee: { label: "Noblesse d'épée", id: "noblesseepee", caracteristiques: { entregent: 1, puissance: 1 }, cagnotte: 10, cagnotteUnit: "livres", value: 1 },
+    noblessecloche: { label: "Noblesse de cloche", id: "noblessecloche", caracteristiques: { entregent: 1, savoir: 1 }, cagnotte: 50, cagnotteUnit: "livres", value: 2 },
+    hautenoblesse: { label: "Haute noblesse (Illégitime)", id: "hautenoblesse", caracteristiques: { complexion: 1, puissance: 1 }, cagnotte: 20, cagnotteUnit: "livres", value: 3 },
+    hautebourgeoisie: { label: "Haute bourgeoisie", id: "hautebourgeoisie", caracteristiques: { savoir: 1, sensibilite: 1 }, cagnotte: 60, cagnotteUnit: "livres", value: 4 },
+    petitebourgeoisie: { label: "Petite bourgeoisie (Marchands)", caracteristiques: { entregent: 1, sensibilite: 1 }, cagnotte: 20, cagnotteUnit: "livres", id: "petitebourgeoisie", value: 5 },
+    artisan: { label: "Artisans", id: "artisan", caracteristiques: { adresse: 1, sensibilite: 1 }, cagnotte: 10, cagnotteUnit: "livres", value: 6 },
+    laboureur: { label: "Laboureurs", id: "laboureur", caracteristiques: { entregent: 1, complexion: 1 }, cagnotte: 10, cagnotteUnit: "livres", value: 7 },
+    domesticite: { label: "Domesticité", id: "domesticite", caracteristiques: { entregent: 1, adresse: 1 }, cagnotte: 2, cagnotteUnit: "sous", value: 8 },
+    paysannerie: { label: "Paysannerie", id: "paysannerie", caracteristiques: { puissance: 1, complexion: 1 }, cagnotte: 1, cagnotteUnit: "sous", value: 9 },
+    gueux: { label: "Gueux", id: "gueux", caracteristiques: { adresse: 1, complexion: 1 }, cagnotte: 4, cagnotteUnit: "deniers", value: 10 },
   },
   bonusMalus: [
-    { value: "-2", label: "-2 niveaux"  },
-    { value: "-1", label: "-1 niveau"  },
-    { value: "0", label: "Aucun"  },
-    { value: "1", label: "+1 niveau"  },
-    { value: "2", label: "+2 niveaux"  }
-  ], 
-  blessures: [
-    { value: 0, label: "Indemne", degatsMax: -1, count: 0, modifier: 0 },
-    { value: 1, label: "Estafilade/Contusion", degatsMax: 2, count: 1, modifier: 0 },
-    { value: 2, label: "Plaie", degatsMax: 4, count: 1, modifier: -1 },
-    { value: 3, label: "Plaie béante", degatsMax: 6, count: 1, modifier: -2 },
-    { value: 4, label: "Plaie atroce", degatsMax: 6, count: 1, horsCombat: true, modifier: -12 },
-    { value: 5, label: "Tué net", degatsMax: 100, count: 1, horsCombat: true, mort: true, modifier: -12 }
-  ]
-
+    { value: "-2", label: "-2 niveaux" },
+    { value: "-1", label: "-1 niveau" },
+    { value: "0", label: "Aucun" },
+    { value: "1", label: "+1 niveau" },
+    { value: "2", label: "+2 niveaux" }
+  ],
+  blessuresOrder: ["indemne", "estafilade", "plaie", "plaiebeante", "plaieatroce", "tuenet", "tuenet", "tuenet", "tuenet", "tuenet"],
+  blessures: {
+    indemne: { value: 0, label: "Indemne", key: "indemne", degatsMax: -1, count: 0, modifier: 0 },
+    estafilade: { value: 1, label: "Estafilade", key: "estafilade", degatsMin: 0, degatsMax: 2, count: 1, modifier: 0 },
+    plaie: { value: 2, label: "Plaie", key: "plaie", degatsMin: 3, degatsMax: 4, count: 1, modifier: -1 },
+    plaiebeante: { value: 3, label: "Plaie béante", key: "plaiebeante", degatsMin: 5, degatsMax: 6, count: 1, modifier: -2 },
+    plaieatroce: { value: 4, label: "Plaie atroce", key: "plaieatroce", degatsMin: 7, degatsMax: 8, count: 1, horsCombat: true, modifier: -12 },
+    tuenet: { value: 5, label: "Tué net", key: "tuenet", degatsMin: 9, degatsMax: 100, count: 1, horsCombat: true, mort: true, modifier: -100 }
+  },
+  virulence: {
+    aucune: { label: "Aucune", value: "aucune", modifier: 0 },
+    fatigue: { label: "Fatigue", value: "fatigue", modifier: 0 },
+    epuisement: { label: "Epuisement", value: "epuisement", modifier: -1 },
+    souffrance: { label: "Souffrance", value: "souffrance", modifier: -2 },
+    agonie: { label: "Agonie", value: "agonie", modifier: -3 }
+  },
+  fievre: {
+    aucune: { label: "Aucune", value: "aucune" },
+    legere: { label: "Légère", value: "legere" },
+    forte: { label: "Forte", value: "forte" },
+    grave: { label: "Grave", value: "grave" }
+  },
+  virulencePoison: {
+    aucune: { label: "Aucune", value: "aucune", modifier: 0 },
+    nausee: { label: "Nausées & Vertiges", value: "nausee", modifier: 0 },
+    inflammation: { label: "Inflammations & Vomissements", value: "inflammation", modifier: -1 },
+    elancement: { label: "Elancements & Hémorragies", value: "elancement", modifier: -2 },
+    convulsion: { label: "Convulsions & Délire hallucinatoire", value: "convulsion", modifier: -3 },
+    mort: { label: "Inconscience & Mort", value: "mort", modifier: -12 }
+  }
 }

modules/common/tedeum-utility.js

@@ -1,12 +1,81 @@
 /* -------------------------------------------- */
 
 /* -------------------------------------------- */
+const ECRYME_WELCOME_MESSAGE_URL = "https://www.uberwald.me/gitea/public/fvtt-te-deum/raw/branch/main/welcome-message-tedeum.html"
+
 export class TeDeumUtility {
 
   /* -------------------------------------------- */
   static async init() {
-    Hooks.on('renderChatLog', (log, html, data) => TeDeumUtility.chatListeners(html));
-    //Hooks.on("getChatLogEntryContext", (html, options) => TeDeumUtility.chatMenuManager(html, options));
+
+    CONFIG.Actor.compendiumBanner = "systems/fvtt-te-deum/images/ui/compendium_banner.webp"
+    CONFIG.Item.compendiumBanner = "systems/fvtt-te-deum/images/ui/compendium_banner.webp"
+    CONFIG.Scene.compendiumBanner = "systems/fvtt-te-deum/images/ui/compendium_banner.webp"
+    CONFIG.JournalEntry.compendiumBanner = "systems/fvtt-te-deum/images/ui/compendium_banner.webp"
+    CONFIG.Macro.compendiumBanner = "systems/fvtt-te-deum/images/ui/compendium_banner.webp"
+    CONFIG.Adventure.compendiumBanner = "systems/fvtt-te-deum/images/ui/compendium_banner.webp"
+  }
+
+  static installHooks() {
+    Hooks.on('renderChatMessageHTML', (message, html) => {
+      TeDeumUtility.chatListeners(html);
+      TeDeumUtility.onRenderChatMessage(message, html);
+    });
+
+    Hooks.on("renderActorDirectory", (app, html, data) => {
+      if (game.user.can('ACTOR_CREATE')) {
+        const button = document.createElement('button');
+        button.style.width = '60%';
+        button.classList.add('tedeum-create-character');
+        button.innerHTML = 'Créer un Personnage'
+        button.addEventListener('click', () => {
+          let cr = new game.system.tedeum.TeDeumCharacterCreator();
+          cr.init()
+        })
+        $(html).find('.header-actions').after(button)
+      }
+    })
+
+    Hooks.on("combatStart", async (combat, updateData, options) => {
+      this.resetCombatActions(combat)
+    });
+
+    Hooks.on("combatRound", (combat, updateData, updateOptions) => {
+      // List all actors related to combatant
+      if (game.user.isGM) {
+        this.resetCombatActions(combat)
+      }
+    })
+
+    Hooks.on("getCombatTrackerContextOptions", (html, options) => {
+      console.log("Get Combat Tracker Context", html, options)
+      this.pushCombatOptions(html, options);
+    });
+
+  }
+
+  /* -------------------------------------------- */
+  static pushCombatOptions(html, options) {
+    options.push({ name: "Actions +1", condition: true, icon: '<i class="fas fa-plus"></i>', callback: target => { game.combat.modifyAction($(target).data('combatant-id'), 1); } })
+    options.push({ name: "Actions -1", condition: true, icon: '<i class="fas fa-minus"></i>', callback: target => { game.combat.modifyAction($(target).data('combatant-id'), -1); } })
+    options.push({ name: "Actions MG +1", condition: true, icon: '<i class="fas fa-plus"></i>', callback: target => { game.combat.modifyAction($(target).data('combatant-id'), 1, true); } })
+    options.push({ name: "Actions MG -1", condition: true, icon: '<i class="fas fa-minus"></i>', callback: target => { game.combat.modifyAction($(target).data('combatant-id'), -1, true); } })
+  }
+
+  /* -------------------------------------------- */
+  static async resetCombatActions(combat) {
+    if (game.user.isGM) {
+      for (let c of combat.combatants) {
+        let actor = game.actors.get(c.actorId)
+        if (actor) {
+          let nbActions = actor.getNbActions()?.value || 0
+          let isMainGauche = (actor.getCompetenceScore("Main gauche") > 0)
+          let nbActionsMainGauche = isMainGauche ? nbActions : 0
+          await c.setFlag("world", "available-actions", { nbActions, nbActionsMainGauche })
+          await c.update({ name: `${c.token.name} (${nbActions} / ${nbActionsMainGauche})` })
+        }
+      }
+    }
   }
 
   /* -------------------------------------------- */
@@ -46,31 +115,91 @@ export class TeDeumUtility {
         accum += block.fn(i);
       return accum;
     })
-    Handlebars.registerHelper('getConfigLabel', function (configName, key) {      
+    Handlebars.registerHelper('getConfigLabel', function (configName, key) {
+      //console.log("getConfigLabel", configName, key)
+      return game.system.tedeum.config[configName][key].label
+    })
+    Handlebars.registerHelper('getConfigLabelArray', function (configName, key) {
       //console.log("getConfigLabel", configName, key)
       return game.system.tedeum.config[configName][key].label
     })
     Handlebars.registerHelper('isSpecArmeType', function (key, armeType) {
       return game.system.tedeum.config.ARME_SPECIFICITE[key][armeType]
     })
-    
-    Handlebars.registerHelper('getConfigLabelWithGender', function (configName, key, genderKey) {      
-      return game.system.tedeum.config[configName][key]["label"+genderKey]
+
+    Handlebars.registerHelper('getConfigLabelWithGender', function (configName, key, genderKey) {
+      return game.system.tedeum.config[configName][key]["label" + genderKey]
     })
-    Handlebars.registerHelper('getCaracDescription', function (key, value) {      
+    Handlebars.registerHelper('getCaracDescription', function (key, value) {
       return game.system.tedeum.config.descriptionValeur[Number(value)][key]
     })
+    Handlebars.registerHelper('getEducationEtape', function (key) {
+      return game.system.tedeum.config.etapesEducation[key].label
+    })
 
     Handlebars.registerHelper('isGM', function () {
       return game.user.isGM
     })
+    Handlebars.registerHelper('monnaie', function (value) {
+      let monnaie = game.system.tedeum.config.monnaieUnit[String(value)]
+      if (monnaie) {
+        return monnaie.label
+      }
+      return value
+    })
+    // Handle v12 removal of this helper
+    Handlebars.registerHelper('select', function (selected, options) {
+      const escapedValue = RegExp.escape(Handlebars.escapeExpression(selected));
+      const rgx = new RegExp(' value=[\"\']' + escapedValue + '[\"\']');
+      const html = options.fn(this);
+      return html.replace(rgx, "$& selected");
+    });
+
 
     // Load compendium data
     const competences = await TeDeumUtility.loadCompendium("fvtt-te-deum.competences")
     this.competences = competences.map(i => i.toObject())
     this.competencesList = {}
     for (let i of this.competences) {
-      this.competencesList[i.name.toLowerCase()] = {name:i.name, id: i._id} 
+      this.competencesList[i.name.toLowerCase()] = { name: i.name, id: i._id }
+    }
+    this.competencesList = Object.entries(this.competencesList).sort().reduce((o, [k, v]) => (o[k] = v, o), {})
+  }
+
+  /* -------------------------------------------- */
+  static async importDefaultScene() {
+    let exists = game.scenes.find(j => j.name == "Te Deum");
+    if (!exists) {
+      const scenes = await TeDeumUtility.loadCompendium("fvtt-te-deum.scenes")
+      let newDocuments = scenes.filter(i => i.name == "Te Deum");
+      if (newDocuments) {
+        await game.scenes.documentClass.create(newDocuments);
+        game.scenes.find(i => i.name == "Te Deum").activate();
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  static welcomeMessage() {
+    if (game.user.isGM) {
+      // Try to fetch the welcome message from the github repo "welcome-message-ecryme.html"
+      fetch(ECRYME_WELCOME_MESSAGE_URL)
+        .then(response => response.text())
+        .then(html => {
+          ChatMessage.create({
+            user: game.user.id,
+            whisper: [game.user.id],
+            content: html
+          });
+        })
+        .catch(error => {
+          console.error("Error fetching welcome message:", error);
+          ChatMessage.create({
+            user: game.user.id,
+            whisper: [game.user.id],
+            content: "<b>Bienvenue dans Ecryme RPG !</b><br>Visitez le site officiel pour plus d'informations."
+          });
+        });
     }
   }
 
@@ -85,22 +214,26 @@ export class TeDeumUtility {
 
   /*-------------------------------------------- */
   static prepareEducationContent(formData) {
-    let nbCompetences = game.system.tedeum.config.etapesEducation[formData.system.etape].nbCompetences
+    let etape = game.system.tedeum.config.etapesEducation[formData.system.etape]
+    let nbCompetences = etape.nbCompetences
     for (let key in formData.system.competences) {
       formData.system.competences[key].valid = false
     }
     for (let i = 1; i <= nbCompetences; i++) {
       formData.system.competences[`comp${i}`].valid = true
     }
-    let nbCaracteristiques = game.system.tedeum.config.etapesEducation[formData.system.etape].nbCaracteristiques
+    let nbCaracteristiques = etape.nbCaracteristiques
     for (let key in formData.system.caracteristiques) {
       formData.system.caracteristiques[key].valid = false
     }
     for (let i = 1; i <= nbCaracteristiques; i++) {
       formData.system.caracteristiques[`carac${i}`].valid = true
     }
-    formData.hasQuestionnaire = game.system.tedeum.config.etapesEducation[formData.system.etape].hasQuestionnaire;
-    formData.hasMultiplier = game.system.tedeum.config.etapesEducation[formData.system.etape].hasMultiplier;
+    formData.hasQuestionnaire = etape.hasQuestionnaire;
+    formData.hasMultiplier = etape.hasMultiplier;
+    formData.hasDebouches = etape.hasDebouches;
+    formData.canCompetencesOpt = etape.canCompetencesOpt;
+    formData.hasGenre = etape.hasGenre;
   }
 
   /*-------------------------------------------- */
@@ -133,47 +266,150 @@ export class TeDeumUtility {
     return actor
   }
 
+  /* -------------------------------------------- */
+  static async manageOpposition(rollData) {
+    if (!this.currentOpposition) {
+      // Store rollData as current GM opposition
+      this.currentOpposition = rollData
+      ui.notifications.info("Opposition démarrée avec " + rollData.alias);
+    } else {
+      // Perform the opposition
+      let isAttackWinner = true
+      let rWinner, rLooser
+      if (this.currentOpposition.total <= rollData.total) {
+        rWinner = foundry.utils.duplicate(rollData)
+        rLooser = foundry.utils.duplicate(this.currentOpposition)
+        isAttackWinner = false
+      } else {
+        rWinner = foundry.utils.duplicate(this.currentOpposition)
+        rLooser = foundry.utils.duplicate(rollData)
+        isAttackWinner = true
+      }
+      this.currentOpposition = undefined // Reset opposition
+      let oppositionData = {
+        winner: rWinner,
+        looser: rLooser
+      }
+      // Update difficulty
+      rWinner.difficulty = rLooser.total
+      rLooser.difficulty = rWinner.total
+      await this.computeResults(rWinner)
+      await this.computeResults(rLooser)
+      // Auto XP management when opposed
+      if (rWinner.isReussiteCritique) {
+        let actor = this.getActorFromRollData(rWinner)
+        actor.modifyXP(rWinner.carac.key, 1)
+      }
+      if (rLooser.isEchecCritique) {
+        let actor = this.getActorFromRollData(rLooser)
+        actor.modifyXP(rLooser.carac.key, 1)
+      }
+
+      let msg = await this.createChatWithRollMode(rollData.alias, {
+        content: await foundry.applications.handlebars.renderTemplate(`systems/fvtt-te-deum/templates/chat/chat-opposition-result.hbs`, oppositionData)
+      })
+      await msg.setFlag("world", "te-deum-rolldata", rollData)
+
+      // Si le gagnant est l'attaquant, appliquer les dégats sur la victime
+      if (isAttackWinner && rWinner.isSuccess && rWinner.mode == "arme" && rWinner.arme?.system.typeArme == "melee" && rWinner.defenderTokenId) {
+        await this.appliquerDegats(rWinner)
+      }
+
+      console.log("Opposition result", rollData, isAttackWinner, oppositionData)
+    }
+  }
+
+  /* -------------------------------------------- */
+  static getTokenActorFromId(tokenId) {
+    for (let scene of game.scenes) {
+      const tokenDoc = scene.tokens.get(tokenId)
+      if (tokenDoc) return tokenDoc.actor
+    }
+    return null
+  }
+
+  /* -------------------------------------------- */
+  static async appliquerDegats(rollData) {
+    await this.processAttaqueMelee(rollData)
+    let defenderActor = this.getTokenActorFromId(rollData.defenderTokenId)
+    if (defenderActor) {
+      if (game.user.isGM || defenderActor.isOwner) {
+        await defenderActor.appliquerDegats(rollData)
+      } else {
+        // Send a socket message — seul le premier MJ actif le traitera
+        game.socket.emit("system.fvtt-te-deum", { name: "msg_apply_damage", data: { rollData } });
+      }
+      // Attaque naturelle avec dégats inférieur à -2
+      if ((rollData?.arme?.system.specificites?.poing?.hasSpec || rollData?.arme?.system.specificites?.pied?.hasSpec) && rollData.degats < -2) {
+        let attacker = this.getActorFromRollData(rollData)
+        attacker.appliquerBlessure("estafilade", "maindroite", "Contusion suite à une attaque naturelle")
+        ui.notifications.info(`${attacker.name} subit 1 contusion en infligeant ${rollData.degats} dégâts à mains nues`)
+      }
+    } else {
+      ui.notifications.error("Impossible de trouver la cible de l'attaque, aucun degats appliqué")
+    }
+  }
+
   /* -------------------------------------------- */  /* -------------------------------------------- */
   static async chatListeners(html) {
 
-    html.on("click", '.button-select-confront', event => {
+    $(html).on("click", '.chat-command-opposition', event => {
       let messageId = TeDeumUtility.findChatMessageId(event.currentTarget)
       let message = game.messages.get(messageId)
       let rollData = message.getFlag("world", "te-deum-rolldata")
-      ui.notifications.info( game.i18n.localize("ECRY.chat.confrontselect"))
-      TeDeumUtility.manageConfrontation(rollData)
+      if (rollData) {
+        TeDeumUtility.manageOpposition(rollData, messageId)
+      }
     })
-    html.on("click", '.button-apply-cephaly-difficulty', event => {
+    $(html).on("click", '.chat-command-appliquer-degats', event => {
       let messageId = TeDeumUtility.findChatMessageId(event.currentTarget)
       let message = game.messages.get(messageId)
       let rollData = message.getFlag("world", "te-deum-rolldata")
-      let difficulty = $("#" + rollData.rollId + "-cephaly-difficulty").val()
-      TeDeumUtility.manageCephalyDifficulty(rollData, difficulty)
+      if (rollData) {
+        TeDeumUtility.appliquerDegats(rollData, messageId)
+      }
     })
-    html.on("click", '.button-apply-impact', event => {
+    $(html).on("click", '.chat-command-gain-xp', async event => {
       let messageId = TeDeumUtility.findChatMessageId(event.currentTarget)
       let message = game.messages.get(messageId)
-      let actor = game.actors.get($(event.currentTarget).data("actor-id"))
-      actor.modifyImpact($(event.currentTarget).data("impact-type"), $(event.currentTarget).data("impact"), 1)
-    })
-    html.on("click", '.button-apply-bonus', event => {
-      let messageId = TeDeumUtility.findChatMessageId(event.currentTarget)
-      let message = game.messages.get(messageId)
-      let actor = game.actors.get($(event.currentTarget).data("actor-id"))
-      actor.modifyConfrontBonus($(event.currentTarget).data("bonus"))
+      let rollData = message.getFlag("world", "te-deum-rolldata")
+      if (rollData) {
+        let actor = TeDeumUtility.getActorFromRollData(rollData)
+        actor.modifyXP(rollData.carac.key, 1)
+        event.currentTarget.style.display = 'none'; // feedback immédiat local
+        await message.setFlag("world", "te-deum-xp-used", true) // sync tous les clients
+      }
     })
+  }
 
+  /* -------------------------------------------- */
+  static onRenderChatMessage(message, html) {
+    if (message.getFlag("world", "te-deum-xp-used")) {
+      const btn = html.querySelector('.chat-command-gain-xp');
+      if (btn) btn.style.display = 'none';
+    }
   }
 
   /* -------------------------------------------- */
   static async preloadHandlebarsTemplates() {
-    
+
     const templatePaths = [
       'systems/fvtt-te-deum/templates/actors/editor-notes-gm.hbs',
       'systems/fvtt-te-deum/templates/items/partial-item-nav.hbs',
-      'systems/fvtt-te-deum/templates/items/partial-item-description.hbs'
+      'systems/fvtt-te-deum/templates/items/partial-item-description.hbs',
+      'systems/fvtt-te-deum/templates/dialogs/partial-creator-status.hbs',
+      'systems/fvtt-te-deum/templates/items/item-arme-sheet.hbs',
+      'systems/fvtt-te-deum/templates/items/item-armure-sheet.hbs',
+      'systems/fvtt-te-deum/templates/items/item-blessure-sheet.hbs',
+      'systems/fvtt-te-deum/templates/items/item-competence-sheet.hbs',
+      'systems/fvtt-te-deum/templates/items/item-education-sheet.hbs',
+      'systems/fvtt-te-deum/templates/items/item-equipement-sheet.hbs',
+      'systems/fvtt-te-deum/templates/items/item-grace-sheet.hbs',
+      'systems/fvtt-te-deum/templates/items/item-maladie-sheet.hbs',
+      'systems/fvtt-te-deum/templates/items/item-origine-sheet.hbs',
+      'systems/fvtt-te-deum/templates/items/item-simple-sheet.hbs',
     ]
-    return loadTemplates(templatePaths);
+    return foundry.applications.handlebars.loadTemplates(templatePaths);
   }
 
   /* -------------------------------------------- */
@@ -248,14 +484,36 @@ export class TeDeumUtility {
     console.log("SOCKET MESSAGE", msg)
     if (msg.name == "msg_gm_chat_message") {
       let rollData = msg.data.rollData
-      if ( game.user.isGM ) {
+      if (game.user.isGM) {
         let chatMsg = await this.createChatMessage(rollData.alias, "blindroll", {
-          content: await renderTemplate(msg.data.template, rollData),
+          content: await foundry.applications.handlebars.renderTemplate(msg.data.template, rollData),
           whisper: game.user.id
         })
         chatMsg.setFlag("world", "tedeum-rolldata", rollData)
       }
     }
+    if (msg.name == "msg_modify_combat_action") {
+      if (game.user.isGM) {
+        let { combatantId, ca } = msg.data
+        let combatant = game.combat.combatants.get(combatantId)
+        if (combatant) {
+          console.log("sock - Modify Combat Action : ", combatant.name, ca)
+          await TeDeumUtility.updateCombatantActions(combatant, ca)
+        }
+      }
+    }
+    if (msg.name == "msg_apply_damage") {
+      const firstGM = game.users.find(u => u.isGM && u.active)
+      if (game.user === firstGM) {
+        let rollData = msg.data.rollData
+        let defenderActor = TeDeumUtility.getTokenActorFromId(rollData.defenderTokenId)
+        if (defenderActor) {
+          await defenderActor.appliquerDegats(rollData)
+        } else {
+          ui.notifications.error("Impossible de trouver la cible de l'attaque, aucun degats appliqué")
+        }
+      }
+    }
   }
 
   /* -------------------------------------------- */
@@ -340,10 +598,13 @@ export class TeDeumUtility {
       }
     }
     if (rollData.diceSum == 1) {
-      let critiqueRoll = await new Roll(rollData.carac.negativeDice).roll()
+      let critiqueRoll = await new Roll(rollData.carac.negativeDice)
+      rollData.isSuccess = false
+      await critiqueRoll.evaluate()
       await this.showDiceSoNice(critiqueRoll, game.settings.get("core", "rollMode"))
       rollData.critiqueRoll = foundry.utils.duplicate(critiqueRoll)
-      if (critiqueRoll.total > rollData.competence.score) {        
+      rollData.critiqueTotal = critiqueRoll.total
+      if (critiqueRoll.total > rollData.competence.system.score) {
         rollData.isEchecCritique = true
       }
     }
@@ -352,16 +613,37 @@ export class TeDeumUtility {
   /* -------------------------------------------- */
   static modifyDice(dice, bonusMalus) {
     let newIndex = game.system.tedeum.config.diceValeur.indexOf(dice) + Number(bonusMalus)
+    if (newIndex < 0) {
+      ui.notifications.error("Vos blessures ou maladies vous empêchent de réaliser cette action, vous êtes trop faibles")
+      return undefined
+    }
     newIndex = Math.min(Math.max(newIndex, 0), game.system.tedeum.config.diceValeur.length - 1)
     return game.system.tedeum.config.diceValeur[newIndex]
   }
-  
+
   /* -------------------------------------------- */
   static computeRollFormula(rollData, actor, isConfrontation = false) {
     let diceFormula = ""
     if (rollData.competence) {
-      let diceBase = this.modifyDice(rollData.carac.dice, rollData.bonusMalus+rollData.malusBlessures)
-      diceFormula = diceBase + "x + " + rollData.competence.system.score
+      let localModifier = 0
+      if (rollData.isViser) {
+        localModifier += 1
+      }
+      if (rollData.isMouvement) {
+        localModifier -= 1
+      }
+      if (rollData.arme && rollData.allongeId) {
+        localModifier += rollData.allonges[rollData.allongeId].malus
+        rollData.allongeMalus = rollData.allonges[rollData.allongeId].malus
+        rollData.nbEsquives = rollData.allonges[rollData.allongeId]?.esquive || 0
+      }
+      if (rollData.attaqueCiblee && rollData.attaqueCiblee != "aucune") {
+        localModifier -= 1
+        rollData.loc = foundry.utils.duplicate(game.system.tedeum.config.LOCALISATION[rollData.attaqueCiblee])
+      }
+      let diceBase = this.modifyDice(rollData.carac.dice, localModifier + Number(rollData.bonusMalus) + rollData.santeModifier)
+      if (!diceBase) return;
+      diceFormula = diceBase + "x + " + rollData.compScore
     }
     if (rollData.enableProvidence) {
       diceFormula += " + " + rollData.providence.dice
@@ -369,17 +651,116 @@ export class TeDeumUtility {
     return diceFormula
   }
 
+  /* -------------------------------------------- */
+  static async getLocalisation(rollData) {
+    let locRoll
+    if (rollData.loc) {
+      locRoll = await new Roll(String(rollData.loc.score.min)).roll()
+    } else {
+      locRoll = await new Roll("1d20").roll()
+      await this.showDiceSoNice(locRoll, game.settings.get("core", "rollMode"))
+      for (let key in game.system.tedeum.config.LOCALISATION) {
+        let loc = game.system.tedeum.config.LOCALISATION[key]
+        if (locRoll.total >= loc.score.min && locRoll.total <= loc.score.max) {
+          rollData.loc = foundry.utils.duplicate(loc)
+          break
+        }
+      }
+    }
+    rollData.locRoll = foundry.utils.duplicate(locRoll)
+  }
+
+  /* -------------------------------------------- */
+  static async processAttaqueMelee(rollData) {
+    await this.getLocalisation(rollData)
+    let actor = game.actors.get(rollData.actorId)
+    let bDegats = actor.getAttaqueBonusDegats(rollData)
+    rollData.degatsFormula = rollData.arme.system.degats + "+" + bDegats
+    let degatsRoll = await new Roll(rollData.degatsFormula).roll()
+    await this.showDiceSoNice(degatsRoll, game.settings.get("core", "rollMode"))
+    rollData.degatsRoll = foundry.utils.duplicate(degatsRoll)
+    rollData.degats = degatsRoll.total
+  }
+
+  /* -------------------------------------------- */
+  static async processAttaqueDistance(rollData) {
+    if (rollData.arme?.system.typeArme != "tir") {
+      return
+    }
+    if (rollData.isSuccess) {
+      // Roll the location
+      await this.getLocalisation(rollData)
+      // Now the degats
+      let degatsRoll = await new Roll(rollData.arme.system.degats).roll()
+      await this.showDiceSoNice(degatsRoll, game.settings.get("core", "rollMode"))
+      rollData.degatsRoll = foundry.utils.duplicate(degatsRoll)
+      rollData.degats = degatsRoll.total
+    }
+  }
+
+  /* -------------------------------------------- */
+  static async updateCombatantActions(combatant, ca) {
+    await combatant.setFlag("world", "available-actions", ca)
+    await combatant.update({ name: `${combatant.token.name} (${ca.nbActions} / ${ca.nbActionsMainGauche})` })
+  }
+
+  /* -------------------------------------------- */
+  static async manageCombatActions(actor, rollData) {
+    let combat = game.combats.active
+    if (!combat) return;
+    let combatant = combat.getCombatantByActor(actor)
+    if (!combatant) return;
+    let ca = combatant.getFlag("world", "available-actions")
+    if (!ca) return;
+    if (rollData.mode == "arme" && rollData.isMainGauche) {
+      if (ca.nbActionsMainGauche > 0) {
+        ca.nbActionsMainGauche -= 1
+        ca.nbActions = Math.max(ca.nbActions - 1, 0)
+      } else {
+        ui.notifications.error(`${actor.name} n'a plus d'actions disponibles à la main gauche pour ce round`)
+      }
+    }
+    if (ca.nbActions > 0) {
+      ca.nbActions -= 1
+    } else {
+      ui.notifications.error(`${actor.name} n'a plus d'actions disponibles pour ce round`)
+    }
+    console.log("Manage combat actions 1", actor.name, combatant)
+    if (game.user.isGM) {
+      await this.updateCombatantActions(combatant, ca)
+    } else {
+      // Send a socket message
+      game.socket.emit("system.fvtt-te-deum", { name: "msg_modify_combat_action", data: { combatantId: combatant.id, ca } });
+    }
+    rollData.hasActions = true
+    rollData.remainingActions = ca.nbActions
+    rollData.remainingActionsMainGauche = ca.nbActionsMainGauche
+  }
+
   /* -------------------------------------------- */
   static async rollTeDeum(rollData) {
 
     let actor = game.actors.get(rollData.actorId)
     // Fix difficulty
     if (!rollData.difficulty || rollData.difficulty == "-") {
-      rollData.difficulty = 7
+      rollData.difficulty = "pardefaut"
     }
     rollData.difficulty = game.system.tedeum.config.difficulte[rollData.difficulty].value
 
+    // Compute the real competence score
+    if (rollData.competence) {
+      if (rollData.isMainGauche) {
+        rollData.competence = actor.getMeilleureCompetenceMainGauche(rollData.competence)
+      }
+      if (rollData.competence.system.isBase) {
+        rollData.compScore = actor.system.caracteristiques[rollData.competence.system.caracteristique].value
+      } else {
+        rollData.compScore = rollData.competence.system.score
+      }
+    }
     let diceFormula = this.computeRollFormula(rollData, actor)
+    if (!diceFormula) return;
+    console.log("RollData", rollData, diceFormula)
 
     // Performs roll
     let myRoll = await new Roll(diceFormula).roll()
@@ -391,8 +772,12 @@ export class TeDeumUtility {
 
     await this.computeResults(rollData)
 
+    await this.processAttaqueDistance(rollData)
+
+    await this.manageCombatActions(actor, rollData)
+
     let msg = await this.createChatWithRollMode(rollData.alias, {
-      content: await renderTemplate(`systems/fvtt-te-deum/templates/chat/chat-generic-result.hbs`, rollData)
+      content: await foundry.applications.handlebars.renderTemplate(`systems/fvtt-te-deum/templates/chat/chat-generic-result.hbs`, rollData)
     })
     await msg.setFlag("world", "te-deum-rolldata", rollData)
     console.log("Rolldata result", rollData)
@@ -401,10 +786,6 @@ export class TeDeumUtility {
     if (rollData.enableProvidence) {
       actor.modifyProvidence(-1)
     }
-    // Manage XP 
-    if (rollData.isReussiteCritique || rollData.isEchecCritique) {
-      actor.modifyXP(rollData.carac.key, 1)
-    }
   }
 
   /* -------------------------------------------- */
@@ -471,7 +852,7 @@ export class TeDeumUtility {
     }
     return array;
   }
-  
+
   /* -------------------------------------------- */
   static async createChatMessage(name, rollMode, chatOptions) {
     switch (rollMode) {
@@ -493,15 +874,15 @@ export class TeDeumUtility {
   /* -------------------------------------------- */
   static getBasicRollData() {
     let rollData = {
-      rollId: randomID(16),
+      rollId: foundry.utils.randomID(16),
       type: "roll-data",
       rollMode: game.settings.get("core", "rollMode"),
       difficulty: "pardefaut",
-      bonusMalus : "0",
-      isReroll : false,
-      enableProvidence : false,
+      bonusMalus: "0",
+      isReroll: false,
+      enableProvidence: false,
       malusBlessures: 0,
-      config: duplicate(game.system.tedeum.config)
+      config: foundry.utils.duplicate(game.system.tedeum.config)
     }
     TeDeumUtility.updateWithTarget(rollData)
     return rollData
@@ -522,7 +903,7 @@ export class TeDeumUtility {
 
   /* -------------------------------------------- */
   static async confirmDelete(actorSheet, li) {
-    let itemId = li.data("item-id");
+    let itemId = li.dataset ? li.dataset.itemId : li.data("item-id");
     let msgTxt = "<p>Etes vous certain de supprimer cet item ?";
     let buttons = {
       delete: {
@@ -530,7 +911,12 @@ export class TeDeumUtility {
         label: "Oui, aucun souci",
         callback: () => {
           actorSheet.actor.deleteEmbeddedDocuments("Item", [itemId]);
-          li.slideUp(200, () => actorSheet.render(false));
+          if (li.slideUp) {
+            li.slideUp(200, () => actorSheet.render(false));
+          } else {
+            li.style.display = "none";
+            actorSheet.render(false);
+          }
         }
       },
       cancel: {

modules/data/tedeum-schema-arme.js

@@ -1,17 +1,17 @@
-export  class TeDeumArmeSchema extends foundry.abstract.TypeDataModel {
+export class TeDeumArmeSchema extends foundry.abstract.TypeDataModel {
   static defineSchema() {
     const fields = foundry.data.fields;
     const requiredInteger = { required: true, nullable: false, integer: true };
     const requiredDouble = { required: true, nullable: false, integer: false };
     const schema = {};
 
-    schema.typeArme = new fields.StringField({required: true, choices: ["melee", "tir"], initial: "melee"});
-    schema.allonge = new fields.StringField({required: true, choices: ["courte", "moyenne", "longue", "treslongue"], initial: "courte"});
+    schema.typeArme = new fields.StringField({ required: true, choices: ["melee", "tir"], initial: "melee" });
+    schema.allonge = new fields.StringField({ required: true, choices: ["courte", "moyenne", "longue", "treslongue"], initial: "courte" });
 
     schema.specificites = new fields.SchemaField(
       Object.values((game.system.tedeum.config.ARME_SPECIFICITE)).reduce((obj, spec) => {
         obj[spec.id] = new fields.SchemaField({
-          hasSpec: new fields.BooleanField({initial: false}),
+          hasSpec: new fields.BooleanField({ initial: false }),
         });
         return obj;
       }, {})
@@ -26,30 +26,35 @@ export  class TeDeumArmeSchema extends foundry.abstract.TypeDataModel {
       }, {})
     );
 
-    schema.degatsArmure = new fields.SchemaField( {
-      sansarmure : new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
-      cuir : new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
-      plates : new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
-      mailles : new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+    schema.degatsArmure = new fields.SchemaField({
+      sansarmure: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      cuir: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      plates: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      mailles: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
     });
-    
+
     schema.tempsRecharge = new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 });
+    schema.competenceRecharge = new fields.StringField({ required: false, choices: ["aucune", "archerie", "arquebusade"], initial: "aucune", blank: true });
     schema.valeurEchecCritique = new fields.NumberField({ ...requiredInteger, initial: 1, min: 1 });
 
-    schema.initiativeBonus = new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 });
+    schema.initiativeBonus = new fields.NumberField({ ...requiredInteger, initial: 0 });
+
+    schema.degats = new fields.StringField({ required: false, blank: true, initial: "0" });
+    schema.degatscrosse = new fields.StringField({ required: false, blank: true, initial: "0" });
 
-    schema.degats = new fields.StringField({ required: false, blank: true, initial: undefined });
     let comp = []
     for (let key of Object.keys(game.system.tedeum.config.armeCompetences)) {
       comp.push(key);
     }
-    schema.competence = new fields.StringField({ required: true, choices:comp, initial: "bagarre" });
-    schema.competence2 = new fields.StringField({ required: false, choices:comp, initial: "", blank: true });
+    schema.competence = new fields.StringField({ required: true, choices: comp, initial: "bagarre" });
+    schema.competence2 = new fields.StringField({ required: false, choices: comp, initial: "", blank: true });
 
     schema.prix = new fields.NumberField({ ...requiredDouble, initial: 0, min: 0 });
     schema.monnaie = new fields.StringField({ required: true, blank: false, initial: "denier" });
 
-    schema.description = new fields.HTMLField({ required: true, blank: true });
+    schema.equipe = new fields.BooleanField({ initial: false }),
+
+      schema.description = new fields.HTMLField({ required: true, blank: true });
 
     return schema;
   }

modules/data/tedeum-schema-armure.js

@@ -6,6 +6,8 @@ export class TeDeumArmureSchema extends foundry.abstract.TypeDataModel {
 
     const schema = {};
 
+    schema.typeArmure = new fields.StringField({required: true, choices: ["cuir", "maille", "plate"], initial: "cuir"});
+
     schema.localisation = new fields.SchemaField(
       Object.values(game.system.tedeum.config.LOCALISATION).reduce((obj, loc) => {
         obj[loc.id] = new fields.SchemaField({
@@ -15,10 +17,18 @@ export class TeDeumArmureSchema extends foundry.abstract.TypeDataModel {
       }, {})
     );
     
+    schema.coutArmureLourde = new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 });
+
+    schema.superposableCuir = new fields.BooleanField({initial: false});
+    schema.superposableMaille = new fields.BooleanField({initial: false});
+    schema.superposablePlate = new fields.BooleanField({initial: false});
+
     schema.protection = new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 });
 
     schema.prix = new fields.NumberField({ ...requiredDouble, initial: 0, min: 0 });
     schema.monnaie = new fields.StringField({ required: true, blank: false, initial: "denier" });
+    
+    schema.equipe = new fields.BooleanField({initial: false}),         
 
     schema.description = new fields.HTMLField({ required: true, blank: true });
 

modules/data/tedeum-schema-blessure.js

@@ -0,0 +1,15 @@
+export class TeDeumBlessureSchema extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    const fields = foundry.data.fields;
+    const requiredInteger = { required: true, nullable: false, integer: true };
+    const schema = {};
+
+    schema.typeBlessure = new fields.StringField({ required: true, choices: ["indemne", "estafilade", "plaie", "plaiebeante", "plaieatroce", "tuenet"], initial: "estafilade" });
+    schema.value = new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 })
+    schema.localisation = new fields.StringField({ required: true, choices: ["piedgauche", "pieddroit", "jambegauche", "jambedroite", "maingauche", "maindroite", "brasgauche", "brasdroit", "tete", "corps"], initial: "corps" });
+
+    schema.description = new fields.HTMLField({ required: true, blank: true });
+
+    return schema;
+  }
+}

modules/data/tedeum-schema-education.js

@@ -14,35 +14,68 @@ export class TeDeumEducationSchema extends foundry.abstract.TypeDataModel {
         return obj;
       }, {})
     );
+
+    schema.genre = new fields.StringField({required: true, initial: "Homme", choices: ["masculin", "mixte", "Homme", "Femme", "Mixte"]});
+
+    schema.nbChoixCarac = new fields.NumberField({ ...requiredInteger, initial: 1, min: 1 });
     schema.caracteristiques = new fields.SchemaField(Array.fromRange(3, 1).reduce((caracs, i) => {
       caracs[`carac${i}`] = new fields.SchemaField({
         caracId: new fields.StringField({ required: true, blank: false, initial: "entregent" })
       });
       return caracs;
     }, {}));
-    schema.competences = new fields.SchemaField(Array.fromRange(9, 1).reduce((comps, i) => {
+
+    schema.competences = new fields.SchemaField(Array.fromRange(10, 1).reduce((comps, i) => {
+      comps[`comp${i}`] = new fields.SchemaField({
+        compName: new fields.StringField({ required: true, blank: true, initial: "" }),
+        toSelect: new fields.BooleanField({ initial: false })
+      });
+      return comps;
+    }, {}));
+
+    schema.hasCompetencesOpt = new fields.BooleanField({initial: false})
+    schema.competencesOptNumber = new fields.NumberField({ ...requiredInteger, initial: 1, min:0 })
+    schema.competencesOpt = new fields.SchemaField(Array.fromRange(14, 1).reduce((comps, i) => {
       comps[`comp${i}`] = new fields.SchemaField({
         compName: new fields.StringField({ required: true, blank: true, initial: "" })
       });
       return comps;
     }, {}));
-    schema.questionnaire = new fields.SchemaField(Array.fromRange(4, 1).reduce((questions, i) => {
+
+    schema.questionnaire = new fields.SchemaField(Array.fromRange(8, 1).reduce((questions, i) => {
       questions[`question${i}`] = new fields.SchemaField({
         question: new fields.StringField({ required: true, blank: true, initial: "" }),
         reponses: new fields.SchemaField( Array.fromRange(6, 1).reduce((resp, i) => {
           resp[`reponse${i}`] = new fields.SchemaField({
             num: new fields.NumberField({ ...requiredInteger, initial: i, min:i }),
             reponse: new fields.StringField({ required: true, blank: true, initial: "" }),
-            compName: new fields.StringField({ required: true, blank: true, initial: "" })
+            compName: new fields.StringField({ required: true, blank: true, initial: "" }),
+            toSelect: new fields.BooleanField({ initial: false }),
+            compList: new fields.SchemaField(Array.fromRange(16, 1).reduce((comps, i) => {
+              comps[`comp${i}`] = new fields.SchemaField({
+                compName: new fields.StringField({ required: true, blank: true, initial: "" }),
+              });
+              return comps;
+            }, {}))
           });
           return resp;
         }, {}))
       });
       return questions;
     }, {}));
+
+    schema.debouches = new fields.SchemaField(Array.fromRange(24, 1).reduce((debouches, i) => {
+      debouches[`debouche${i}`] = new fields.SchemaField({
+        debouche: new fields.StringField({ required: true, blank: true, initial: "" })
+      })
+      return debouches;
+    }, {}));
+
     schema.cagnotteMultiplier = new fields.NumberField({ ...requiredDouble, initial: 1.0, min: 0 });
- 
+    schema.cagnotteDivider = new fields.NumberField({ ...requiredDouble, initial: 1.0, min: 0 });
+
     schema.description = new fields.HTMLField({ required: true, blank: true });
+    schema.trousseau = new fields.StringField({ required: true, blank: true, initial: "" });
 
     return schema;
   }

modules/data/tedeum-schema-equipement.js

@@ -13,4 +13,10 @@ export class TeDeumEquipementSchema extends foundry.abstract.TypeDataModel {
 
     return schema;
   }
+
+  get monnaieLabel() {
+    console.log("monnaieLabel", this.monnaie,game.system.tedeum.config.monnaieUnit)
+    return game.system.tedeum.config.monnaieUnit[String(this.monnaie)]?.label;
+  }
+
 }

modules/data/tedeum-schema-maladie.js

@@ -0,0 +1,19 @@
+export class TeDeumMaladieSchema extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    const fields = foundry.data.fields;
+    const requiredInteger = { required: true, nullable: false, integer: true };
+    const schema = {};
+
+    schema.transmission = new fields.HTMLField({ required: true, blank: true });
+    schema.difficulteEndurance = new fields.StringField({required:true, initial:"routine"});
+    schema.virulence = new fields.StringField({required: true, choices: ["fatigue", "epuisement", "souffrance", "agonie"], initial: "fatigue"});
+    schema.fievre = new fields.StringField({required: true, choices: ["aucune", "legere", "forte", "grave"], initial: "aucune"});
+    schema.symptomes = new fields.HTMLField({ required: true, blank: true });
+    schema.complications = new fields.HTMLField({ required: true, blank: true });
+    schema.appliquee = new fields.BooleanField({initial: false});
+
+    schema.description = new fields.HTMLField({ required: true, blank: true });
+
+    return schema;
+  }
+}

modules/data/tedeum-schema-pj.js

@@ -23,29 +23,37 @@ export class TeDeumPJSchema extends foundry.abstract.TypeDataModel {
 
     schema.localisation = new fields.SchemaField(
       Object.values(game.system.tedeum.config.LOCALISATION).reduce((obj, loc) => {
-        obj[loc.id] =new fields.SchemaField({
-          blessures: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0, max: 20 })          
+        obj[loc.id] = new fields.SchemaField({
+          armure: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0, max: 20 }),
+          touche:  new fields.NumberField({ ...requiredInteger, initial: 0, min: 0, max: 20 }),
+          blessures: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0, max: 20 })
         });
         return obj;
       }, {})
     );
 
     schema.fortune = new fields.SchemaField({
-      "ecu": new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }), 
+      "ecus": new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
       "livres": new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }) ,
       "sous": new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }) ,
-      "deniers": new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }) 
+      "deniers": new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 })
     });
 
     schema.description = new fields.HTMLField({required: true, blank: true});
+    schema.notes = new fields.HTMLField({required: true, blank: true});
     schema.connaissances = new fields.HTMLField({required: true, blank: true});
+    schema.histoire = new fields.HTMLField({required: true, blank: true});
     schema.vetements = new fields.HTMLField({required: true, blank: true});
-    //schema.descriptiongraces = new fields.HTMLField({required: true, blank: true});
-    schema.genre = new fields.StringField({required: true, choices: ["Homme", "Femme"], initial: "Femme"});
-    schema.age = new fields.StringField({ required: false, blank: true, initial: undefined });
-    schema.statutocial = new fields.StringField({ required: false, blank: true, initial: undefined });
-    schema.chargestitre = new fields.StringField({ required: false, blank: true, initial: undefined });
-    schema.charges = new fields.StringField({ required: false, blank: true, initial: undefined });
+    schema.equipmentfree = new fields.HTMLField({required: true, blank: true});
+
+    schema.genre = new fields.StringField({required: true, choices: game.system.tedeum.config.genre, initial: "Femme"});
+    schema.age = new fields.StringField({ required: false, blank: true, initial: "" });
+    schema.datenaissance = new fields.StringField({ required: false, blank: true, initial: "" });
+    schema.statutocial = new fields.StringField({ required: false, blank: true, initial: "" });
+    schema.chargestitre = new fields.StringField({ required: false, blank: true, initial: "" });
+    schema.charges = new fields.StringField({ required: false, blank: true, initial: "" });
+    schema.religion = new fields.StringField({ required: false, blank: true, initial: "" });
+    schema.lieunaissance = new fields.StringField({ required: false, blank: true, initial: "" });
 
     return schema;
   }

modules/data/tedeum-schema-simple.js

@@ -0,0 +1,20 @@
+export class TeDeumMaladieSchema extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    const fields = foundry.data.fields;
+    const requiredInteger = { required: true, nullable: false, integer: true };
+    const schema = {};
+
+    schema.difficulteEndurance = new fields.StringField({required:true, initial:"aucun"});
+    schema.virulence = new fields.StringField({required: true, choices: ["nausee", "inflammation", "elancement", "convulsion", "mort"], initial: "aucune"});
+    schema.vertus = new fields.HTMLField({ required: true, blank: true });
+    schema.toxicite = new fields.HTMLField({ required: true, blank: true });
+    schema.appliquee = new fields.BooleanField({initial: false}),
+
+    schema.prix = new fields.NumberField({ ...requiredDouble, initial: 0, min: 0 });
+    schema.monnaie = new fields.StringField({ required: true, blank: false, initial: "denier" });
+
+    schema.description = new fields.HTMLField({ required: true, blank: true });
+
+    return schema;
+  }
+}

modules/dialogs/tedeum-roll-dialog.js

@@ -1,75 +1,103 @@
 import { TeDeumUtility } from "../common/tedeum-utility.js";
 
-export class TeDeumRollDialog extends Dialog {
+const { HandlebarsApplicationMixin } = foundry.applications.api
+
+/* -------------------------------------------- */
+export class TeDeumRollDialog extends HandlebarsApplicationMixin(foundry.applications.api.ApplicationV2) {
+
+  static DEFAULT_OPTIONS = {
+    classes: ["fvtt-te-deum", "te-deum-roll-dialog"],
+    window: { title: "Lancer !", resizable: false },
+    position: { width: 540 },
+    actions: {
+      roll: TeDeumRollDialog.#onRoll,
+      cancel: TeDeumRollDialog.#onCancel,
+    }
+  }
+
+  static PARTS = {
+    content: { template: "systems/fvtt-te-deum/templates/dialogs/roll-dialog-generic.hbs" }
+  }
+
+  /* -------------------------------------------- */
+  constructor(actor, rollData, options = {}) {
+    super(options)
+    this.actor = actor
+    this.rollData = rollData
+  }
 
   /* -------------------------------------------- */
   static async create(actor, rollData) {
-
-    let options = { classes: ["tedeum-roll-dialog"], width: 540, height: 'fit-content', 'z-index': 99999 }
-    let html = await renderTemplate('systems/fvtt-te-deum/templates/dialogs/roll-dialog-generic.hbs', rollData);
-    return new TeDeumRollDialog(actor, rollData, html, options);
+    const dialog = new TeDeumRollDialog(actor, rollData)
+    dialog.render(true)
+    return dialog
   }
 
   /* -------------------------------------------- */
-  constructor(actor, rollData, html, options, close = undefined) {
-    let conf = {
-      title: "Lancer !",
-      content: html,
-      buttons: {
-        roll: {
-          icon: '<i class="fas fa-check"></i>',
-          label: "Lancer",
-          callback: () => { this.roll() }
-        },
-        cancel: {
-          icon: '<i class="fas fa-times"></i>',
-          label: "Annuler",
-          callback: () => { this.close() }
-        }
-      },
-      close: close
-    }
-
-    super(conf, options);
-
-    this.actor = actor;
-    this.rollData = rollData;
-  }
-
-  /* -------------------------------------------- */
-  roll() {
-    TeDeumUtility.rollTeDeum(this.rollData)
+  async _prepareContext() {
+    return { ...this.rollData }
   }
 
   /* -------------------------------------------- */
   async refreshDialog() {
-    const content = await renderTemplate("systems/fvtt-te-deum/templates/dialogs/roll-dialog-generic.hbs", this.rollData)
-    this.data.content = content
-    this.render(true)
+    this.render()
   }
 
   /* -------------------------------------------- */
-  activateListeners(html) {
-    super.activateListeners(html);
+  static #onRoll(event, target) {
+    TeDeumUtility.rollTeDeum(this.rollData)
+    this.close()
+  }
 
-    let dialog = this;
-    function onLoad() {
-    }
-    $(function () { onLoad(); });
+  /* -------------------------------------------- */
+  static #onCancel(event, target) {
+    this.close()
+  }
 
-    html.find('#bonusMalusPerso').change((event) => {
+  /* -------------------------------------------- */
+  _onRender(context, options) {
+    super._onRender(context, options)
+
+    const html = this.element
+
+    html.querySelector('#bonusMalusPerso')?.addEventListener('change', (event) => {
       this.rollData.bonusMalusPerso = Number(event.currentTarget.value)
     })
-    html.find('#roll-difficulty').change((event) => {
+    html.querySelector('#roll-allonge')?.addEventListener('change', (event) => {
+      this.rollData.allongeId = event.currentTarget.value
+    })
+    html.querySelector('#roll-main-gauche')?.addEventListener('change', (event) => {
+      this.rollData.isMainGauche = event.currentTarget.checked
+    })
+    html.querySelector('#roll-difficulty')?.addEventListener('change', (event) => {
       this.rollData.difficulty = String(event.currentTarget.value) || "pardefaut"
     })
-    html.find('#roll-bonus-malus').change((event) => {
+    html.querySelector('#roll-attaque-ciblee')?.addEventListener('change', (event) => {
+      this.rollData.attaqueCiblee = event.currentTarget.value || "0"
+    })
+    html.querySelector('#roll-bonus-malus')?.addEventListener('change', (event) => {
       this.rollData.bonusMalus = event.currentTarget.value || "0"
     })
-    html.find('#roll-enable-providence').change((event) => {
+    html.querySelector('#roll-enable-providence')?.addEventListener('change', (event) => {
       this.rollData.enableProvidence = event.currentTarget.checked
     })
-    
-    
+    html.querySelector('#roll-portee-tir')?.addEventListener('change', (event) => {
+      this.rollData.porteeTir = event.currentTarget.value
+      this.rollData.difficulty = game.system.tedeum.config.ARME_PORTEES[this.rollData.porteeTir].difficulty
+      this.rollData.porteeLabel = game.system.tedeum.config.ARME_PORTEES[this.rollData.porteeTir].label
+      this.refreshDialog()
+    })
+    html.querySelector('#roll-tir-viser')?.addEventListener('change', (event) => {
+      this.rollData.isViser = event.currentTarget.checked
+    })
+    html.querySelector('#roll-tir-mouvement')?.addEventListener('change', (event) => {
+      this.rollData.isMouvement = event.currentTarget.checked
+    })
+    html.querySelector('#roll-charge-a-pied')?.addEventListener('change', (event) => {
+      this.rollData.isChargeAPied = event.currentTarget.checked
+    })
+    html.querySelector('#roll-charge-a-cheval')?.addEventListener('change', (event) => {
+      this.rollData.isChargeACheval = event.currentTarget.checked
+    })
   }
-}
+}

modules/items/tedeum-item-sheet.js

@@ -1,173 +1,154 @@
 import { TeDeumUtility } from "../common/tedeum-utility.js";
 
+const { HandlebarsApplicationMixin } = foundry.applications.api
+
 /**
- * Extend the basic ItemSheet with some very simple modifications
- * @extends {ItemSheet}
+ * Feuille d'item Te Deum - AppV2
  */
-export class TeDeumItemSheet extends ItemSheet {
+export class TeDeumItemSheet extends HandlebarsApplicationMixin(foundry.applications.sheets.ItemSheetV2) {
 
   /** @override */
-  static get defaultOptions() {
-    return mergeObject(super.defaultOptions, {
-      classes: ["fvtt-te-deum", "sheet", "item"],
-      template: "systems/fvtt-te-deum/templates/item-sheet.hbs",
-      dragDrop: [{ dragSelector: null, dropSelector: null }],
+  static DEFAULT_OPTIONS = {
+    classes: ["fvtt-te-deum", "sheet", "item"],
+    position: {
       width: 620,
       height: 580,
-      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "description" }]
-    });
+    },
+    form: {
+      submitOnChange: true,
+      closeOnSubmit: false,
+    },
+    window: {
+      resizable: true,
+    },
+    actions: {
+      editImage: TeDeumItemSheet.#onEditImage,
+      postItem: TeDeumItemSheet.#onPostItem,
+      deleteSubitem: TeDeumItemSheet.#onDeleteSubitem,
+      viewSubitem: TeDeumItemSheet.#onViewSubitem,
+    },
   }
 
-  /* -------------------------------------------- */
-  _getHeaderButtons() {
-    let buttons = super._getHeaderButtons();
-    // Add "Post to chat" button
-    // We previously restricted this to GM and editable items only. If you ever find this comment because it broke something: eh, sorry!
-    buttons.unshift(
-      {
-        class: "post",
-        icon: "fas fa-comment",
-        onclick: ev => { }
-      })
-    return buttons
+  // Static PARTS pointing to the dynamic wrapper template
+  static PARTS = {
+    sheet: { template: "systems/fvtt-te-deum/templates/items/item-sheet.hbs" },
   }
 
-  /* -------------------------------------------- */
-  async getData() {
+  tabGroups = { primary: "description" }
 
-    let formData = {
+  /* -------------------------------------------- */
+  /** @override */
+  async _prepareContext() {
+    const item = this.document
+    const TextEditor = foundry.applications.ux.TextEditor.implementation
+    const enrich = async (val) => val !== undefined ? await TextEditor.enrichHTML(val ?? "", { async: true }) : ""
+    const context = {
       title: this.title,
-      id: this.id,
-      type: this.object.type,
-      img: this.object.img,
-      name: this.object.name,
+      id: item.id,
+      type: item.type,
+      img: item.img,
+      name: item.name,
       editable: this.isEditable,
       cssClass: this.isEditable ? "editable" : "locked",
-      system: duplicate(this.object.system),
-      config: duplicate(game.system.tedeum.config),
+      system: foundry.utils.duplicate(item.system),
+      systemFields: item.system.schema.fields,
+      config: foundry.utils.duplicate(game.system.tedeum.config),
       competences: TeDeumUtility.getCompetencesForDropDown(),
-      limited: this.object.limited,
-      options: this.options,
-      owner: this.document.isOwner,
-      description: await TextEditor.enrichHTML(this.object.system.description, { async: true }),
-      notes: await TextEditor.enrichHTML(this.object.system.notes, { async: true }),
-      isGM: game.user.isGM
+      limited: item.limited,
+      owner: item.isOwner,
+      enrichedDescription: await enrich(item.system.description),
+      enrichedTransmission: await enrich(item.system.transmission),
+      enrichedSymptomes: await enrich(item.system.symptomes),
+      enrichedComplications: await enrich(item.system.complications),
+      enrichedVertus: await enrich(item.system.vertus),
+      enrichedToxicite: await enrich(item.system.toxicite),
+      isGM: game.user.isGM,
+      itemPartialName: `systems/fvtt-te-deum/templates/items/item-${item.type}-sheet.hbs`,
     }
-    
-    if (this.object.type == "education") {
-      TeDeumUtility.prepareEducationContent(formData);
+    if (item.type === "education") {
+      TeDeumUtility.prepareEducationContent(context)
     }
-
-    this.options.editable = !(this.object.origin == "embeddedItem");
-    console.log("ITEM DATA", formData, this);
-    return formData;
-  }
-
-
-  /* -------------------------------------------- */
-  _getHeaderButtons() {
-    let buttons = super._getHeaderButtons();
-    buttons.unshift({
-      class: "post",
-      icon: "fas fa-comment",
-      onclick: ev => this.postItem()
-    });
-    return buttons
+    return context
   }
 
   /* -------------------------------------------- */
-  postItem() {
-    let chatData = duplicate(this.item)
+  /** @override */
+  _onRender(context, options) {
+    super._onRender(context, options)
+
+    // Tab navigation
+    const nav = this.element.querySelector('nav.tabs[data-group]')
+    if (nav) {
+      const group = nav.dataset.group
+      const activeTab = this.tabGroups[group] || "description"
+      nav.querySelectorAll('[data-tab]').forEach(link => {
+        const tab = link.dataset.tab
+        link.classList.toggle('active', tab === activeTab)
+        link.addEventListener('click', event => {
+          event.preventDefault()
+          this.tabGroups[group] = tab
+          this.render()
+        })
+      })
+      this.element.querySelectorAll(`[data-group="${group}"][data-tab]`).forEach(content => {
+        content.classList.toggle('active', content.dataset.tab === activeTab)
+      })
+    }
+
+    // Ignore Enter key in inputs
+    this.element.addEventListener('keydown', e => {
+      if (e.keyCode === 13 && e.target.tagName !== 'TEXTAREA') e.preventDefault()
+    })
+  }
+
+  // #region Static action handlers
+
+  static async #onEditImage(event, target) {
+    const fp = new FilePicker({
+      type: "image",
+      current: this.document.img,
+      callback: path => this.document.update({ img: path }),
+    })
+    fp.browse()
+  }
+
+  static async #onPostItem(event, target) {
+    const chatData = foundry.utils.duplicate(this.item)
     if (this.actor) {
-      chatData.actor = { id: this.actor.id };
+      chatData.actor = { id: this.actor.id }
     }
-    // Don't post any image for the item (which would leave a large gap) if the default image is used
-    if (chatData.img.includes("/blank.png")) {
-      chatData.img = null;
+    if (chatData.img?.includes("/blank.png")) {
+      chatData.img = null
     }
-    // JSON object for easy creation
-    chatData.jsondata = JSON.stringify(
-      {
-        compendium: "postedItem",
-        payload: chatData,
-      });
-
-    renderTemplate('systems/fvtt-te-deum/templates/post-item.html', chatData).then(html => {
-      let chatOptions = TeDeumUtility.chatDataSetup(html);
-      ChatMessage.create(chatOptions)
-    });
+    chatData.jsondata = JSON.stringify({ compendium: "postedItem", payload: chatData })
+    const html = await foundry.applications.handlebars.renderTemplate(
+      'systems/fvtt-te-deum/templates/post-item.html', chatData
+    )
+    ChatMessage.create(TeDeumUtility.chatDataSetup(html))
   }
 
-  /* -------------------------------------------- */
-  async viewSubitem(ev) {
-    let levelIndex = Number($(ev.currentTarget).parents(".item").data("level-index"))
-    let choiceIndex = Number($(ev.currentTarget).parents(".item").data("choice-index"))
-    let featureId = $(ev.currentTarget).parents(".item").data("feature-id")
-    
-    let itemData = this.object.system.levels[levelIndex].choices[choiceIndex].features[featureId]
-
-    if (itemData.name != 'None') {
-      let item = await Item.create(itemData, { temporary: true });
-      item.system.origin = "embeddedItem";
-      new TeDeumItemSheet(item).render(true);
+  static async #onDeleteSubitem(event, target) {
+    const field = target.dataset.type
+    const idx = parseInt(target.dataset.index)
+    const oldArray = this.document.system[field]
+    if (Array.isArray(oldArray) && oldArray[idx]?.name !== 'None') {
+      const newArray = oldArray.filter((_, i) => i !== idx)
+      this.document.update({ [`system.${field}`]: newArray })
     }
   }
 
-  /* -------------------------------------------- */
-  async deleteSubitem(ev) {
-    let field = $(ev.currentTarget).data('type');
-    let idx = Number($(ev.currentTarget).data('index'));
-    let oldArray = this.object.system[field];
-    let itemData = this.object.system[field][idx];
-    if (itemData.name != 'None') {
-      let newArray = [];
-      for (let i = 0; i < oldArray.length; i++) {
-        if (i != idx) {
-          newArray.push(oldArray[i]);
-        }
-      }
-      this.object.update({ [`system.${field}`]: newArray });
+  static async #onViewSubitem(event, target) {
+    const li = target.closest(".item")
+    const levelIndex = parseInt(li?.dataset.levelIndex)
+    const choiceIndex = parseInt(li?.dataset.choiceIndex)
+    const featureId = li?.dataset.featureId
+    const itemData = this.document.system.levels?.[levelIndex]?.choices?.[choiceIndex]?.features?.[featureId]
+    if (itemData?.name !== 'None') {
+      const item = await Item.create(itemData, { temporary: true })
+      item.system.origin = "embeddedItem"
+      new TeDeumItemSheet(item).render(true)
     }
   }
 
-  /* -------------------------------------------- */
-  /** @override */
-  activateListeners(html) {
-    super.activateListeners(html);
-
-    // Everything below here is only needed if the sheet is editable
-    if (!this.options.editable) return;
-
-
-    // Update Inventory Item
-    html.find('.item-edit').click(ev => {
-      const li = $(ev.currentTarget).parents(".item");
-      const item = this.object.options.actor.getOwnedItem(li.data("item-id"));
-      item.sheet.render(true);
-    });
-
-    html.find('.delete-subitem').click(ev => {
-      this.deleteSubitem(ev);
-    });
-
-    // Update Inventory Item
-    html.find('.item-delete').click(ev => {
-      const li = $(ev.currentTarget).parents(".item");
-      let itemId = li.data("item-id");
-      let itemType = li.data("item-type");
-    });
-
- }
-
-  /* -------------------------------------------- */
-  get template() {
-    let type = this.item.type;
-    return `systems/fvtt-te-deum/templates/items/item-${type}-sheet.hbs`
-  }
-
-  /* -------------------------------------------- */
-  /** @override */
-  _updateObject(event, formData) {
-    return this.object.update(formData)
-  }
+  // #endregion
 }

modules/items/tedeum-item.js

@@ -7,6 +7,9 @@ export const defaultItemImg = {
   competence: "systems/fvtt-te-deum/images/icons/competence.webp",
   education: "systems/fvtt-te-deum/images/icons/education.webp",
   grace: "systems/fvtt-te-deum/images/icons/grace.webp",
+  blessure: "systems/fvtt-te-deum/images/icons/blessure.webp",
+  maladie: "systems/fvtt-te-deum/images/icons/maladie.webp",
+  simple: "systems/fvtt-te-deum/images/icons/simple.webp",
 }
 
 /**

modules/tedeum-main.js

@@ -19,12 +19,15 @@ import { TeDeumEquipementSchema } from "./data/tedeum-schema-equipement.js";
 import { TeDeumOrigineSchema } from "./data/tedeum-schema-origine.js";
 import { TeDeumEducationSchema } from "./data/tedeum-schema-education.js";
 import { TeDeumGraceSchema } from "./data/tedeum-schema-grace.js";
+import { TeDeumBlessureSchema } from "./data/tedeum-schema-blessure.js";
+import { TeDeumMaladieSchema } from "./data/tedeum-schema-maladie.js";
 
 import { TeDeumItem } from "./items/tedeum-item.js";
 import { TeDeumItemSheet } from "./items/tedeum-item-sheet.js";
 
 import { TeDeumHotbar } from "./app/tedeum-hotbar.js"
 import { TeDeumCombat } from "./app/tedeum-combat.js";
+import { TeDeumCharacterCreator } from "./app/tedeum-character-creator.js"
 
 import { TeDeumUtility } from "./common/tedeum-utility.js";
 import { TEDEUM_CONFIG } from "./common/tedeum-config.js";
@@ -40,6 +43,7 @@ Hooks.once("init", async function () {
 
   game.system.tedeum = {
     config: TEDEUM_CONFIG,
+    TeDeumCharacterCreator,
     TeDeumHotbar
   }
   console.log(`Initializing TeDeum RPG 2`);
@@ -47,7 +51,7 @@ Hooks.once("init", async function () {
   // preload handlebars templates
   TeDeumUtility.preloadHandlebarsTemplates();
 
-  // Set an initiative formula for the system 
+  // Set an initiative formula for the system
   CONFIG.Combat.initiative = {
     formula: "1d6",
     decimals: 1
@@ -57,7 +61,7 @@ Hooks.once("init", async function () {
     TeDeumUtility.onSocketMesssage(data)
   });
 
-  //CONFIG.Combat.documentClass = TeDeumCombat
+  CONFIG.Combat.documentClass = TeDeumCombat
   CONFIG.Actor.documentClass = TeDeumActor;
   CONFIG.Item.documentClass = TeDeumItem
   CONFIG.Actor.dataModels = {
@@ -71,37 +75,32 @@ Hooks.once("init", async function () {
     armure: TeDeumArmureSchema,
     origine: TeDeumOrigineSchema,
     education: TeDeumEducationSchema,
-    grace: TeDeumGraceSchema
+    grace: TeDeumGraceSchema,
+    blessure: TeDeumBlessureSchema,
+    maladie: TeDeumMaladieSchema,
   };
-  
+
   console.log("TeDeum RPG | Ready");
 
-  Actors.unregisterSheet("core", ActorSheet);
-  Actors.registerSheet("fvtt-te-deum", TeDeumActorPJSheet, { types: ["pj"], makeDefault: true });
-  Actors.registerSheet("fvtt-te-deum", TeDeumActorPJSheet, { types: ["pnj"], makeDefault: true });
-  
-  Items.unregisterSheet("core", ItemSheet);
-  Items.registerSheet("fvtt-te-deum", TeDeumItemSheet, { makeDefault: true });
+  foundry.documents.collections.Actors.unregisterSheet("core", foundry.appv1.sheets.ActorSheet);
+  foundry.documents.collections.Actors.registerSheet("fvtt-te-deum", TeDeumActorPJSheet, { types: ["pj"], makeDefault: true });
+  foundry.documents.collections.Actors.registerSheet("fvtt-te-deum", TeDeumActorPJSheet, { types: ["pnj"], makeDefault: true });
 
-  TeDeumUtility.init() 
+  foundry.documents.collections.Items.unregisterSheet("core", foundry.appv1.sheets.ItemSheet);
+  foundry.documents.collections.Items.registerSheet("fvtt-te-deum", TeDeumItemSheet, { makeDefault: true });
+
+  TeDeumUtility.init()
+
+  TeDeumUtility.installHooks()
 });
 
-/* -------------------------------------------- */
-function welcomeMessage() {
-  if (game.user.isGM) {
-    ChatMessage.create({
-      user: game.user.id,
-      whisper: [game.user.id],
-      content: `<div id="welcome-message-tedeum"><span class="rdd-roll-part">
-      <strong>Bienvenu dans Te Deum Pour Un Massacre !</strong>` });
-  }
-}
 
 /* -------------------------------------------- */
 /*  Foundry VTT Initialization                  */
 /* -------------------------------------------- */
 Hooks.once("ready", function () {
 
+
   // User warning
   if (!game.user.isGM && game.user.character == undefined) {
     ui.notifications.info("Attention ! Aucun personnage relié au joueur !");
@@ -110,16 +109,17 @@ Hooks.once("ready", function () {
       user: game.user._id
     });
   }
-  
-  import("https://www.uberwald.me/fvtt_appcount/count-class-ready.js").then(moduleCounter=>{
+
+  import("https://www.uberwald.me/fvtt_appcount/count-class-ready.js").then(moduleCounter => {
     console.log("ClassCounter loaded", moduleCounter)
     moduleCounter.ClassCounter.registerUsageCount()
-  }).catch(err=>
+  }).catch(err =>
     console.log("No stats available, giving up.")
   )
   TeDeumUtility.ready();
 
-  welcomeMessage();
+  TeDeumUtility.importDefaultScene()
+  TeDeumUtility.welcomeMessage();
 
 })
 
@@ -137,4 +137,3 @@ Hooks.on("chatMessage", (html, content, msg) => {
   }
   return true;
 });
-

package.json

@@ -0,0 +1,21 @@
+{
+  "name": "fvtt-te-deum",
+  "version": "1.0.0",
+  "description": "Système Te Deum pour FoundryVTT",
+  "private": true,
+  "scripts": {
+    "build:css": "gulp css",
+    "watch:css": "gulp watch"
+  },
+  "devDependencies": {
+    "gulp": "^4.0.2",
+    "gulp-less": "^5.0.0",
+    "less": "^4.2.0",
+    "autoprefixer": "^10.4.20",
+    "gulp-postcss": "^9.0.1",
+    "postcss": "^8.4.49"
+  },
+  "keywords": ["foundry-vtt", "te-deum"],
+  "author": "",
+  "license": "ISC"
+}

packs/aides/CURRENT

@@ -0,0 +1 @@
+MANIFEST-000245

packs/aides/LOG

@@ -0,0 +1,7 @@
+2026/02/28-09:14:40.938346 7f56f93fe6c0 Recovering log #243
+2026/02/28-09:14:40.993306 7f56f93fe6c0 Delete type=3 #241
+2026/02/28-09:14:40.993438 7f56f93fe6c0 Delete type=0 #243
+2026/02/28-11:53:47.481993 7f54e37ef6c0 Level-0 table #248: started
+2026/02/28-11:53:47.482026 7f54e37ef6c0 Level-0 table #248: 0 bytes OK
+2026/02/28-11:53:47.487859 7f54e37ef6c0 Delete type=0 #246
+2026/02/28-11:53:47.488058 7f54e37ef6c0 Manual compaction at level-0 from '!journal!uNwJgi4kXBCiZmAH' @ 72057594037927935 : 1 .. '!journal.pages!uNwJgi4kXBCiZmAH.onhNU0mXhOpdNZJF' @ 0 : 0; will stop at (end)

packs/aides/LOG.old

@@ -0,0 +1,7 @@
+2026/02/27-17:11:33.828064 7f56f8bfd6c0 Recovering log #239
+2026/02/27-17:11:33.838170 7f56f8bfd6c0 Delete type=3 #237
+2026/02/27-17:11:33.838231 7f56f8bfd6c0 Delete type=0 #239
+2026/02/27-17:22:38.249017 7f54e37ef6c0 Level-0 table #244: started
+2026/02/27-17:22:38.249057 7f54e37ef6c0 Level-0 table #244: 0 bytes OK
+2026/02/27-17:22:38.255519 7f54e37ef6c0 Delete type=0 #242
+2026/02/27-17:22:38.255693 7f54e37ef6c0 Manual compaction at level-0 from '!journal!uNwJgi4kXBCiZmAH' @ 72057594037927935 : 1 .. '!journal.pages!uNwJgi4kXBCiZmAH.onhNU0mXhOpdNZJF' @ 0 : 0; will stop at (end)

packs/armes/CURRENT

@@ -0,0 +1 @@
+MANIFEST-000347

packs/armes/LOG

@@ -0,0 +1,7 @@
+2026/02/28-09:14:40.507166 7f56f8bfd6c0 Recovering log #345
+2026/02/28-09:14:40.569877 7f56f8bfd6c0 Delete type=3 #343
+2026/02/28-09:14:40.570013 7f56f8bfd6c0 Delete type=0 #345
+2026/02/28-11:53:47.420510 7f54e37ef6c0 Level-0 table #350: started
+2026/02/28-11:53:47.420538 7f54e37ef6c0 Level-0 table #350: 0 bytes OK
+2026/02/28-11:53:47.427480 7f54e37ef6c0 Delete type=0 #348
+2026/02/28-11:53:47.427767 7f54e37ef6c0 Manual compaction at level-0 from 'undefined' @ 72057594037927935 : 1 .. 'undefined' @ 0 : 0; will stop at (end)

packs/armes/LOG.old

@@ -0,0 +1,7 @@
+2026/02/27-17:11:33.742557 7f56f8bfd6c0 Recovering log #341
+2026/02/27-17:11:33.751671 7f56f8bfd6c0 Delete type=3 #339
+2026/02/27-17:11:33.751725 7f56f8bfd6c0 Delete type=0 #341
+2026/02/27-17:22:38.183980 7f54e37ef6c0 Level-0 table #346: started
+2026/02/27-17:22:38.184010 7f54e37ef6c0 Level-0 table #346: 0 bytes OK
+2026/02/27-17:22:38.189997 7f54e37ef6c0 Delete type=0 #344
+2026/02/27-17:22:38.202756 7f54e37ef6c0 Manual compaction at level-0 from 'undefined' @ 72057594037927935 : 1 .. 'undefined' @ 0 : 0; will stop at (end)

packs/armures/CURRENT

@@ -0,0 +1 @@
+MANIFEST-000348

packs/armures/LOG

@@ -0,0 +1,7 @@
+2026/02/28-09:14:40.573416 7f56f93fe6c0 Recovering log #346
+2026/02/28-09:14:40.630571 7f56f93fe6c0 Delete type=3 #344
+2026/02/28-09:14:40.630725 7f56f93fe6c0 Delete type=0 #346
+2026/02/28-11:53:47.408468 7f54e37ef6c0 Level-0 table #351: started
+2026/02/28-11:53:47.408492 7f54e37ef6c0 Level-0 table #351: 0 bytes OK
+2026/02/28-11:53:47.414369 7f54e37ef6c0 Delete type=0 #349
+2026/02/28-11:53:47.427738 7f54e37ef6c0 Manual compaction at level-0 from '!folders!2wTJBj3dicRKzNOE' @ 72057594037927935 : 1 .. '!items!ufvhWG5V8pX0qrtR' @ 0 : 0; will stop at (end)

packs/armures/LOG.old

@@ -0,0 +1,7 @@
+2026/02/27-17:11:33.753908 7f56f9bff6c0 Recovering log #342
+2026/02/27-17:11:33.763888 7f56f9bff6c0 Delete type=3 #340
+2026/02/27-17:11:33.763941 7f56f9bff6c0 Delete type=0 #342
+2026/02/27-17:22:38.176835 7f54e37ef6c0 Level-0 table #347: started
+2026/02/27-17:22:38.176924 7f54e37ef6c0 Level-0 table #347: 0 bytes OK
+2026/02/27-17:22:38.183841 7f54e37ef6c0 Delete type=0 #345
+2026/02/27-17:22:38.202741 7f54e37ef6c0 Manual compaction at level-0 from '!folders!2wTJBj3dicRKzNOE' @ 72057594037927935 : 1 .. '!items!ufvhWG5V8pX0qrtR' @ 0 : 0; will stop at (end)