DAtaModels + Appv2 migration : OK

.github/copilot-instructions.md

@@ -0,0 +1,105 @@
+# Copilot Instructions — fvtt-mournblade-cyd2
+
+## Project overview
+
+This is a **FoundryVTT game system** (v13+) for the French tabletop RPG *Mournblade CYD 2.0* by Titam France/Sombres Projets. The system ID is `fvtt-mournblade-cyd2`. There is no build step — JavaScript ES modules are loaded directly by FoundryVTT. All user-visible strings are in French.
+
+## No build / test / lint tooling
+
+There is no `package.json`, `Makefile`, or test suite. Development is done by placing the repository inside FoundryVTT's `Data/systems/` directory and reloading the application. The only files the engine processes are those declared in `system.json`.
+
+## Architecture
+
+### Entry point and lifecycle
+
+`modules/mournblade-cyd2-main.js` is the sole ES module declared in `system.json`. It:
+- Registers all document classes and actor/item sheets in the `init` hook
+- Calls `MournbladeCYD2Utility.init()`, `MournbladeCYD2Automation.init()`, `MournbladeCYD2TokenHud.init()` in `init`
+- Loads compendium skills into created actors, imports a default scene, and posts a welcome message in `ready`
+- Exposes `game.system.mournbladecyd2` with `{ MournbladeCYD2Utility, MournbladeCYD2Automation, config: MOURNBLADECYD2_CONFIG }`
+
+### Module responsibilities
+
+| File | Class | Role |
+|---|---|---|
+| `mournblade-cyd2-actor.js` | `MournbladeCYD2Actor` | Extends `Actor`. All game logic: stat derivation, weapon preparation, roll helpers, adversity/soul management |
+| `mournblade-cyd2-actor-sheet.js` | `MournbladeCYD2ActorSheet` | Extends `foundry.appv1.sheets.ActorSheet`. Sheet for `personnage` |
+| `mournblade-cyd2-creature-sheet.js` | `MournbladeCYD2CreatureSheet` | Sheet for `creature` (NPC/monster) |
+| `mournblade-cyd2-item.js` | `MournbladeCYD2Item` | Extends `Item`. Assigns default icon per type on creation |
+| `mournblade-cyd2-item-sheet.js` | `MournbladeCYD2ItemSheet` | Single sheet class for all item types |
+| `mournblade-cyd2-utility.js` | `MournbladeCYD2Utility` | Static utility class: Handlebars helpers, chat listeners, compendium loading, roll execution, socket messages |
+| `mournblade-cyd2-roll-dialog.js` | `MournbladeCYD2RollDialog` | Extends `Dialog`. Roll configuration dialog (choose d10/d20, modifier, difficulty) |
+| `mournblade-cyd2-combat.js` | `MournbladeCYD2Combat` | Extends `Combat`. Custom initiative via `actor.getInitiativeScore()` |
+| `mournblade-cyd2-automation.js` | `MournbladeCYD2Automation` | Parses automation expressions on items, validates on-drop requirements |
+| `mournblade-cyd2-hud.js` | `MournbladeCYD2TokenHud` | Extends TokenHUD with adversity (bleue/rouge/noire) sub-menu |
+| `mournblade-cyd2-config.js` | `MOURNBLADECYD2_CONFIG` | Exported plain object with all select-option lists (difficulty, ranges, bonus/malus, etc.) |
+| `mournblade-cyd2-commands.js` | `MournbladeCYD2Commands` | Chat command handler (currently stubbed) |
+| `macro-replace-images.js` | — | Standalone utility macro for bulk image replacement on items/actors |
+
+### Data model (template.json)
+
+**Actor types:**
+- `personnage` — player character; templates `biodata` + `core`
+- `creature` — NPC/monster; templates `core` + `biodata` + `ressources`
+
+**Core attributes** (all at `system.attributs.<key>.value`):
+`adr` (Adresse), `pui` (Puissance), `cla` (Clairvoyance), `pre` (Présence), `tre` (Trempe)
+
+**Key actor resources:**
+- `system.sante.vigueur` / `.etat` / `.nbcombativite` — health track
+- `system.ame.nbame` / `.max` / `.etat` / `.seuilpouvoir` — soul points
+- `system.bonneaventure.base` / `.actuelle` — Bonne Aventure (luck resource)
+- `system.adversite.bleue` / `.rouge` / `.noire` — three adversity tracks
+- `system.balance.loi` / `.chaos` / `.aspect` / `.marge` — Law/Chaos alignment
+- `system.combat.*` — initiative/defense/attack bonuses, mounted state
+
+**Item types:** `talent`, `historique`, `profil`, `competence`, `arme`, `protection`, `monnaie`, `equipement`, `ressource`, `don`, `pacte`, `rune`, `runeeffect`, `tendance`, `traitchaotique`, `traitespece`
+
+All item data lives under `item.system.*`. Equipment items share the `basequip` template (`prixpo`, `prixca`, `prixsc`, `rarete`, `quantite`, `equipped`). Items that support automation have `system.isautomated` and `system.automations[]`. `competence` items have `system.predilections[]` (an array of predilection objects used for reroll bonuses, handled in the item sheet and chat listeners).
+
+**Other actor fields:** `system.subactors[]` — an array for linked sub-actors (defined in the `core` template but managed at the sheet level).
+
+## Key conventions
+
+### Foundry API usage
+- Actor/item data is always accessed via `actor.system.*` and `item.system.*` (Foundry v10+ data model).
+- Deep clone with `foundry.utils.duplicate()`, merge with `foundry.utils.mergeObject()`.
+- Render Handlebars templates with `foundry.applications.handlebars.renderTemplate(path, data)`.
+- Enrich HTML (rich text fields) with `foundry.applications.ux.TextEditor.implementation.enrichHTML(text, { async: true })`.
+- Register/unregister sheets via `foundry.documents.collections.Actors` and `foundry.documents.collections.Items`.
+
+### Roll data pattern
+Rolls pass a `rollData` plain object through the dialog, the roll function, and into the chat message. The object is stored on chat messages as a flag: `message.getFlag("world", "mournblade-cyd2-roll")`. Chat click handlers retrieve this flag to re-roll or apply damage.
+
+### Sheet `getData()` pattern
+Both actor sheets build a `formData` object in `getData()` that flattens actor data for the template — calling `this.actor.getWeapons()`, `getTalents()`, etc. (all defined on the Actor class) and passing `game.system.mournbladecyd2.config` as `config`. Always add new derived/display data in `getData()`, not directly in templates.
+
+### Handlebars templates
+- Templates live in `templates/` and are path-referenced as `systems/fvtt-mournblade-cyd2/templates/<name>.html`.
+- Partials must be listed in `MournbladeCYD2Utility.preloadHandlebarsTemplates()` to work as `{{> partial-name}}`.
+- Custom Handlebars helpers are registered in `MournbladeCYD2Utility.init()`: `count`, `includes`, `upper`, `lower`, `upperFirst`, `notEmpty`, `mul`.
+
+### Assets and paths
+- All asset references inside JS/HTML use the runtime path `systems/fvtt-mournblade-cyd2/assets/...`.
+- Item default icons are defined in `defaultItemImg` in `mournblade-cyd2-item.js`, keyed by item type.
+
+### Compendium access
+Load compendium contents with `MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.<packname>")`. Pack names match the `name` fields in `system.json` (e.g., `skills`, `armes`, `pnj-creatures`).
+
+### Automation system
+The `automation` item template (`system.isautomated`, `system.automations[]`) supports three **event types** processed by `MournbladeCYD2Automation.processAutomations(event, item, actor)`:
+- `on-drop` — validates attribute/competence prerequisites when an item is dropped onto an actor
+- `prepare-roll` — modifies roll data before a roll is made
+- `bonus-permanent` — applies a standing bonus (e.g., `bonusname: "bonus-defensif"`) checked in `actor.getBonusDefenseFromTalents()`
+
+Each automation entry's effect uses the expression format parsed by XRegExp in `mournblade-cyd2-automation.js`:
+```
+<effectType>:<objectType>(<objectPath>) <value> {<label>}
+```
+Example: `modifier:Actor(attributs.adr) 2 {Bonus Adresse}`. Top-level effect types: `modifier`, `cost`, `provide`.
+
+### Localization
+Only `lang/fr.json` exists. Keys follow the structure `TYPES.Actor.*`, `TYPES.Item.*`, and `MOURNBLADE.ui.*`. All game text is French.
+
+### Socket
+The system registers `game.socket.on("system.fvtt-mournblade-cyd2", ...)` for GM-side operations. Socket messages are dispatched/handled in `MournbladeCYD2Utility.onSocketMesssage()` (note the triple-s typo — keep it consistent).

.gitignore

@@ -0,0 +1,3 @@
+node_modules/
+styles/mournblade-cyd2.css.map
+package-lock.json

.history/README_20251025234409.md

@@ -0,0 +1,29 @@
+# Système Foundry pour Hawkmoon (French RPG, Titam France/Sombres Projets)
+
+## EN
+
+Unofficial system for Hawkmoon (French version from Titam France).
+
+This system has been approved by Département des Sombres Projets ( http://www.titam-france.fr/ ), thanks !
+
+Books are mandatory to play and are available at : http://www.titam-france.fr
+
+## FR
+
+Système non-officiel pour le JDR Hawkmoon (Titam France/Sombres Projets).
+
+Ce système a été autorisé par le Département des Sombres Projets ( http://www.titam-france.fr/ ), merci à eux !
+
+Les livres du jeu sont nécessaires pour jouer, et sont disponibles ici : http://www.titam-france.fr
+
+# Credits 
+
+Hawkmoon, le jeu de rôle du Troisième Millénaire, is a property of Titam France/Sombres Projets.
+
+# Developmement 
+
+LeRatierBretonnien
+
+# Tests, icones et saisie des données
+
+Prêtre, Blondin, Zechrub/Chris, Kyllian, Lightbringer

.history/README_20251026002959.md

@@ -0,0 +1,29 @@
+# Système Foundry pour Mournblade (French RPG, Titam France/Sombres Projets)
+
+## EN
+
+Unofficial system for Hawkmoon (French version from Titam France).
+
+This system has been approved by Département des Sombres Projets ( http://www.titam-france.fr/ ), thanks !
+
+Books are mandatory to play and are available at : http://www.titam-france.fr
+
+## FR
+
+Système non-officiel pour le JDR Hawkmoon (Titam France/Sombres Projets).
+
+Ce système a été autorisé par le Département des Sombres Projets ( http://www.titam-france.fr/ ), merci à eux !
+
+Les livres du jeu sont nécessaires pour jouer, et sont disponibles ici : http://www.titam-france.fr
+
+# Credits
+
+Hawkmoon, le jeu de rôle du Troisième Millénaire, is a property of Titam France/Sombres Projets.
+
+# Developmement
+
+LeRatierBretonnien
+
+# Tests, icones et saisie des données
+
+Prêtre, Blondin, Zechrub/Chris, Kyllian, Lightbringer

.history/README_20251026003003.md

@@ -0,0 +1,29 @@
+# Système Foundry pour Mournblade avec le (French RPG, Titam France/Sombres Projets)
+
+## EN
+
+Unofficial system for Hawkmoon (French version from Titam France).
+
+This system has been approved by Département des Sombres Projets ( http://www.titam-france.fr/ ), thanks !
+
+Books are mandatory to play and are available at : http://www.titam-france.fr
+
+## FR
+
+Système non-officiel pour le JDR Hawkmoon (Titam France/Sombres Projets).
+
+Ce système a été autorisé par le Département des Sombres Projets ( http://www.titam-france.fr/ ), merci à eux !
+
+Les livres du jeu sont nécessaires pour jouer, et sont disponibles ici : http://www.titam-france.fr
+
+# Credits
+
+Hawkmoon, le jeu de rôle du Troisième Millénaire, is a property of Titam France/Sombres Projets.
+
+# Developmement
+
+LeRatierBretonnien
+
+# Tests, icones et saisie des données
+
+Prêtre, Blondin, Zechrub/Chris, Kyllian, Lightbringer

.history/README_20251026003006.md

@@ -0,0 +1,29 @@
+# Système Foundry pour Mournblade avec le règles CY (French RPG, Titam France/Sombres Projets)
+
+## EN
+
+Unofficial system for Hawkmoon (French version from Titam France).
+
+This system has been approved by Département des Sombres Projets ( http://www.titam-france.fr/ ), thanks !
+
+Books are mandatory to play and are available at : http://www.titam-france.fr
+
+## FR
+
+Système non-officiel pour le JDR Hawkmoon (Titam France/Sombres Projets).
+
+Ce système a été autorisé par le Département des Sombres Projets ( http://www.titam-france.fr/ ), merci à eux !
+
+Les livres du jeu sont nécessaires pour jouer, et sont disponibles ici : http://www.titam-france.fr
+
+# Credits
+
+Hawkmoon, le jeu de rôle du Troisième Millénaire, is a property of Titam France/Sombres Projets.
+
+# Developmement
+
+LeRatierBretonnien
+
+# Tests, icones et saisie des données
+
+Prêtre, Blondin, Zechrub/Chris, Kyllian, Lightbringer

.history/README_20251026003011.md

@@ -0,0 +1,29 @@
+# Système Foundry pour Mournblade avec le règles CYD 2.. (French RPG, Titam France/Sombres Projets)
+
+## EN
+
+Unofficial system for Hawkmoon (French version from Titam France).
+
+This system has been approved by Département des Sombres Projets ( http://www.titam-france.fr/ ), thanks !
+
+Books are mandatory to play and are available at : http://www.titam-france.fr
+
+## FR
+
+Système non-officiel pour le JDR Hawkmoon (Titam France/Sombres Projets).
+
+Ce système a été autorisé par le Département des Sombres Projets ( http://www.titam-france.fr/ ), merci à eux !
+
+Les livres du jeu sont nécessaires pour jouer, et sont disponibles ici : http://www.titam-france.fr
+
+# Credits
+
+Hawkmoon, le jeu de rôle du Troisième Millénaire, is a property of Titam France/Sombres Projets.
+
+# Developmement
+
+LeRatierBretonnien
+
+# Tests, icones et saisie des données
+
+Prêtre, Blondin, Zechrub/Chris, Kyllian, Lightbringer

.history/README_20251026003013.md

@@ -0,0 +1,29 @@
+# Système Foundry pour Mournblade avec le règles CYD 2.0 (French RPG, Titam France/Sombres Projets)
+
+## EN
+
+Unofficial system for Hawkmoon (French version from Titam France).
+
+This system has been approved by Département des Sombres Projets ( http://www.titam-france.fr/ ), thanks !
+
+Books are mandatory to play and are available at : http://www.titam-france.fr
+
+## FR
+
+Système non-officiel pour le JDR Hawkmoon (Titam France/Sombres Projets).
+
+Ce système a été autorisé par le Département des Sombres Projets ( http://www.titam-france.fr/ ), merci à eux !
+
+Les livres du jeu sont nécessaires pour jouer, et sont disponibles ici : http://www.titam-france.fr
+
+# Credits
+
+Hawkmoon, le jeu de rôle du Troisième Millénaire, is a property of Titam France/Sombres Projets.
+
+# Developmement
+
+LeRatierBretonnien
+
+# Tests, icones et saisie des données
+
+Prêtre, Blondin, Zechrub/Chris, Kyllian, Lightbringer

.history/README_20251026003038.md

@@ -0,0 +1,29 @@
+# Système Foundry pour Mournblade avec le règles CYD 2.0 (French RPG, Titam France/Sombres Projets)
+
+## EN
+
+Unofficial system for M (French version from Titam France).
+
+This system has been approved by Département des Sombres Projets ( http://www.titam-france.fr/ ), thanks !
+
+Books are mandatory to play and are available at : http://www.titam-france.fr
+
+## FR
+
+Système non-officiel pour le JDR Hawkmoon (Titam France/Sombres Projets).
+
+Ce système a été autorisé par le Département des Sombres Projets ( http://www.titam-france.fr/ ), merci à eux !
+
+Les livres du jeu sont nécessaires pour jouer, et sont disponibles ici : http://www.titam-france.fr
+
+# Credits
+
+Hawkmoon, le jeu de rôle du Troisième Millénaire, is a property of Titam France/Sombres Projets.
+
+# Developmement
+
+LeRatierBretonnien
+
+# Tests, icones et saisie des données
+
+Prêtre, Blondin, Zechrub/Chris, Kyllian, Lightbringer

.history/README_20251026003041.md

@@ -0,0 +1,29 @@
+# Système Foundry pour Mournblade avec le règles CYD 2.0 (French RPG, Titam France/Sombres Projets)
+
+## EN
+
+Unofficial system for Mournblade (French version from Titam France).
+
+This system has been approved by Département des Sombres Projets ( http://www.titam-france.fr/ ), thanks !
+
+Books are mandatory to play and are available at : http://www.titam-france.fr
+
+## FR
+
+Système non-officiel pour le JDR Hawkmoon (Titam France/Sombres Projets).
+
+Ce système a été autorisé par le Département des Sombres Projets ( http://www.titam-france.fr/ ), merci à eux !
+
+Les livres du jeu sont nécessaires pour jouer, et sont disponibles ici : http://www.titam-france.fr
+
+# Credits
+
+Hawkmoon, le jeu de rôle du Troisième Millénaire, is a property of Titam France/Sombres Projets.
+
+# Developmement
+
+LeRatierBretonnien
+
+# Tests, icones et saisie des données
+
+Prêtre, Blondin, Zechrub/Chris, Kyllian, Lightbringer

.history/README_20251026003045.md

@@ -0,0 +1,29 @@
+# Système Foundry pour Mournblade avec le règles CYD 2.0 (French RPG, Titam France/Sombres Projets)
+
+## EN
+
+Unofficial system for Mournblade CYD 2.0 (French version from Titam France).
+
+This system has been approved by Département des Sombres Projets ( http://www.titam-france.fr/ ), thanks !
+
+Books are mandatory to play and are available at : http://www.titam-france.fr
+
+## FR
+
+Système non-officiel pour le JDR Hawkmoon (Titam France/Sombres Projets).
+
+Ce système a été autorisé par le Département des Sombres Projets ( http://www.titam-france.fr/ ), merci à eux !
+
+Les livres du jeu sont nécessaires pour jouer, et sont disponibles ici : http://www.titam-france.fr
+
+# Credits
+
+Hawkmoon, le jeu de rôle du Troisième Millénaire, is a property of Titam France/Sombres Projets.
+
+# Developmement
+
+LeRatierBretonnien
+
+# Tests, icones et saisie des données
+
+Prêtre, Blondin, Zechrub/Chris, Kyllian, Lightbringer

.history/README_20251026003051.md

@@ -0,0 +1,29 @@
+# Système Foundry pour Mournblade avec le règles CYD 2.0 (French RPG, Titam France/Sombres Projets)
+
+## EN
+
+Unofficial system for Mournblade CYD 2.0 (French version from Titam France).
+
+This system has been approved by Département des Sombres Projets ( http://www.titam-france.fr/ ), thanks !
+
+Books are mandatory to play and are available at : http://www.titam-france.fr
+
+## FR
+
+Système non-officiel pour le JDR Mournblade (Titam France/Sombres Projets).
+
+Ce système a été autorisé par le Département des Sombres Projets ( http://www.titam-france.fr/ ), merci à eux !
+
+Les livres du jeu sont nécessaires pour jouer, et sont disponibles ici : http://www.titam-france.fr
+
+# Credits
+
+Hawkmoon, le jeu de rôle du Troisième Millénaire, is a property of Titam France/Sombres Projets.
+
+# Developmement
+
+LeRatierBretonnien
+
+# Tests, icones et saisie des données
+
+Prêtre, Blondin, Zechrub/Chris, Kyllian, Lightbringer

.history/README_20251026003057.md

@@ -0,0 +1,29 @@
+# Système Foundry pour Mournblade avec le règles CYD 2.0 (French RPG, Titam France/Sombres Projets)
+
+## EN
+
+Unofficial system for Mournblade CYD 2.0 (French version from Titam France).
+
+This system has been approved by Département des Sombres Projets ( http://www.titam-france.fr/ ), thanks !
+
+Books are mandatory to play and are available at : http://www.titam-france.fr
+
+## FR
+
+Système non-officiel pour le JDR Mournblade (Titam France/Sombres Projets).
+
+Ce système a été autorisé par le Département des Sombres Projets ( http://www.titam-france.fr/ ), merci à eux !
+
+Les livres du jeu sont nécessaires pour jouer, et sont disponibles ici : http://www.titam-france.fr
+
+# Credits
+
+Mournblade, le jeu de rôle du Troisième Millénaire, is a property of Titam France/Sombres Projets.
+
+# Developmement
+
+LeRatierBretonnien
+
+# Tests, icones et saisie des données
+
+Prêtre, Blondin, Zechrub/Chris, Kyllian, Lightbringer

.history/README_20251026003102.md

@@ -0,0 +1,29 @@
+# Système Foundry pour Mournblade avec le règles CYD 2.0 (French RPG, Titam France/Sombres Projets)
+
+## EN
+
+Unofficial system for Mournblade CYD 2.0 (French version from Titam France).
+
+This system has been approved by Département des Sombres Projets ( http://www.titam-france.fr/ ), thanks !
+
+Books are mandatory to play and are available at : http://www.titam-france.fr
+
+## FR
+
+Système non-officiel pour le JDR Mournblade (Titam France/Sombres Projets).
+
+Ce système a été autorisé par le Département des Sombres Projets ( http://www.titam-france.fr/ ), merci à eux !
+
+Les livres du jeu sont nécessaires pour jouer, et sont disponibles ici : http://www.titam-france.fr
+
+# Credits
+
+Mournblade, le jeu de rôle du Troisième Millénaire, is a property of Titam France/Sombres Projets.
+
+# Developpement
+
+LeRatierBretonnien
+
+# Tests, icones et saisie des données
+
+Prêtre, Blondin, Zechrub/Chris, Kyllian, Lightbringer

.history/README_20251026003110.md

@@ -0,0 +1,29 @@
+# Système Foundry pour Mournblade avec le règles CYD 2.0 (French RPG, Titam France/Sombres Projets)
+
+## EN
+
+Unofficial system for Mournblade CYD 2.0 (French version from Titam France).
+
+This system has been approved by Département des Sombres Projets ( http://www.titam-france.fr/ ), thanks !
+
+Books are mandatory to play and are available at : http://www.titam-france.fr
+
+## FR
+
+Système non-officiel pour le JDR Mournblade (Titam France/Sombres Projets).
+
+Ce système a été autorisé par le Département des Sombres Projets ( http://www.titam-france.fr/ ), merci à eux !
+
+Les livres du jeu sont nécessaires pour jouer, et sont disponibles ici : http://www.titam-france.fr
+
+# Credits
+
+Mournblade, le jeu de rôle du Troisième Millénaire, is a property of Titam France/Sombres Projets.
+
+# Developpement
+
+LeRatierBretonnien
+
+# Tests, icones et saisie des données
+
+Prêtre, Blondin, Zechrub/Chris, Kyllian, Lightbringer

.history/lang/fr_20251026000859.json

@@ -0,0 +1,38 @@
+{
+  "TYPES": {
+    "Actor": {
+      "personnage": "Personnage",
+      "cellule": "Cellule",
+      "creature": "Créature"
+    },
+    "Item": {
+      "artefact": "Artefact",
+      "arme": "Arme",
+      "talent": "Talent",
+      "historique": "Historique",
+      "profil": "Profil",
+      "competence": "Compétence",
+      "protection": "Protection",
+      "monnaie": "Monnaie",
+      "equipement": "Equipement",
+      "ressource": "Ressource",
+      "contact": "Contact",
+      "mutation": "Mutation",
+      "don": "Don",
+      "pacte": "Pacte",
+      "rune": "Rune",
+      "runeeffect": "Effet de Rune",
+      "tendance": "Tendance",
+      "traitchaotique": "Trait Chaotique",
+      "traitespece": "Trait d'Espèce"
+    }
+  },
+  "HAWKMOON": {
+    "ui": {
+      "editContact": "Modifier le contact",
+      "deleteContact": "Supprimer le contact",
+      "editTrait": "Modifier le trait",
+      "deleteTrait": "Supprimer le trait"
+    }
+  }
+}

.history/lang/fr_20251026001011.json

@@ -0,0 +1,38 @@
+{
+  "TYPES": {
+    "Actor": {
+      "personnage": "Personnage",
+      "cellule": "Cellule",
+      "creature": "Créature"
+    },
+    "Item": {
+      "artefact": "Artefact",
+      "arme": "Arme",
+      "talent": "Talent",
+      "historique": "Historique",
+      "profil": "Profil",
+      "competence": "Compétence",
+      "protection": "Protection",
+      "monnaie": "Monnaie",
+      "equipement": "Equipement",
+      "ressource": "Ressource",
+      "contact": "Contact",
+      "mutation": "Mutation",
+      "don": "Don",
+      "pacte": "Pacte",
+      "rune": "Rune",
+      "runeeffect": "Effet de Rune",
+      "tendance": "Tendance",
+      "traitchaotique": "Trait Chaotique",
+      "traitespece": "Trait d'Espèce"
+    }
+  },
+  "HAWKMOON": {
+    "ui": {
+      "editContact": "Modifier le contact",
+      "deleteContact": "Supprimer le contact",
+      "editTrait": "Modifier le trait",
+      "deleteTrait": "Supprimer le trait"
+    }
+  }
+}

.history/lang/fr_20251026004844.json

@@ -0,0 +1,38 @@
+{
+  "TYPES": {
+    "Actor": {
+      "personnage": "Personnage",
+      "cellule": "Cellule",
+      "creature": "Créature"
+    },
+    "Item": {
+      "artefact": "Artefact",
+      "arme": "Arme",
+      "talent": "Talent",
+      "historique": "Historique",
+      "profil": "Profil",
+      "competence": "Compétence",
+      "protection": "Protection",
+      "monnaie": "Monnaie",
+      "equipement": "Equipement",
+      "ressource": "Ressource",
+      "contact": "Contact",
+      "mutation": "Mutation",
+      "don": "Don",
+      "pacte": "Pacte",
+      "rune": "Rune",
+      "runeeffect": "Effet de Rune",
+      "tendance": "Tendance",
+      "traitchaotique": "Trait Chaotique",
+      "traitespece": "Trait d'Espèce"
+    }
+  },
+  "MOURNBLADE": {
+    "ui": {
+      "editContact": "Modifier le contact",
+      "deleteContact": "Supprimer le contact",
+      "editTrait": "Modifier le trait",
+      "deleteTrait": "Supprimer le trait"
+    }
+  }
+}

.history/lang/fr_20251026004905.json

@@ -0,0 +1,38 @@
+{
+  "TYPES": {
+    "Actor": {
+      "personnage": "Personnage",
+      "cellule": "Cellule",
+      "creature": "Créature"
+    },
+    "Item": {
+      "artefact": "Artefact",
+      "arme": "Arme",
+      "talent": "Talent",
+      "historique": "Historique",
+      "profil": "Profil",
+      "competence": "Compétence",
+      "protection": "Protection",
+      "monnaie": "Monnaie",
+      "equipement": "Equipement",
+      "ressource": "Ressource",
+      "contact": "Contact",
+      "mutation": "Mutation",
+      "don": "Don",
+      "pacte": "Pacte",
+      "rune": "Rune",
+      "runeeffect": "Effet de Rune",
+      "tendance": "Tendance",
+      "traitchaotique": "Trait Chaotique",
+      "traitespece": "Trait d'Espèce"
+    }
+  },
+  "MOURNBLADE": {
+    "ui": {
+      "editContact": "Modifier le contact",
+      "deleteContact": "Supprimer le contact",
+      "editTrait": "Modifier le trait",
+      "deleteTrait": "Supprimer le trait"
+    }
+  }
+}

.history/lang/fr_20251026095913.json

@@ -0,0 +1,37 @@
+{
+  "TYPES": {
+    "Actor": {
+      "personnage": "Personnage",
+      "creature": "Créature"
+    },
+    "Item": {
+      "artefact": "Artefact",
+      "arme": "Arme",
+      "talent": "Talent",
+      "historique": "Historique",
+      "profil": "Profil",
+      "competence": "Compétence",
+      "protection": "Protection",
+      "monnaie": "Monnaie",
+      "equipement": "Equipement",
+      "ressource": "Ressource",
+      "contact": "Contact",
+      "mutation": "Mutation",
+      "don": "Don",
+      "pacte": "Pacte",
+      "rune": "Rune",
+      "runeeffect": "Effet de Rune",
+      "tendance": "Tendance",
+      "traitchaotique": "Trait Chaotique",
+      "traitespece": "Trait d'Espèce"
+    }
+  },
+  "MOURNBLADE": {
+    "ui": {
+      "editContact": "Modifier le contact",
+      "deleteContact": "Supprimer le contact",
+      "editTrait": "Modifier le trait",
+      "deleteTrait": "Supprimer le trait"
+    }
+  }
+}

.history/lang/fr_20251026100139.json

@@ -0,0 +1,37 @@
+{
+  "TYPES": {
+    "Actor": {
+      "personnage": "Personnage",
+      "creature": "Créature"
+    },
+    "Item": {
+      "artefact": "Artefact",
+      "arme": "Arme",
+      "talent": "Talent",
+      "historique": "Historique",
+      "profil": "Profil",
+      "competence": "Compétence",
+      "protection": "Protection",
+      "monnaie": "Monnaie",
+      "equipement": "Equipement",
+      "ressource": "Ressource",
+      "contact": "Contact",
+      "mutation": "Mutation",
+      "don": "Don",
+      "pacte": "Pacte",
+      "rune": "Rune",
+      "runeeffect": "Effet de Rune",
+      "tendance": "Tendance",
+      "traitchaotique": "Trait Chaotique",
+      "traitespece": "Trait d'Espèce"
+    }
+  },
+  "MOURNBLADE": {
+    "ui": {
+      "editContact": "Modifier le contact",
+      "deleteContact": "Supprimer le contact",
+      "editTrait": "Modifier le trait",
+      "deleteTrait": "Supprimer le trait"
+    }
+  }
+}

.history/lang/fr_20251026132312.json

@@ -0,0 +1,36 @@
+{
+  "TYPES": {
+    "Actor": {
+      "personnage": "Personnage",
+      "creature": "Créature"
+    },
+    "Item": {
+      "arme": "Arme",
+      "talent": "Talent",
+      "historique": "Historique",
+      "profil": "Profil",
+      "competence": "Compétence",
+      "protection": "Protection",
+      "monnaie": "Monnaie",
+      "equipement": "Equipement",
+      "ressource": "Ressource",
+      "contact": "Contact",
+      "mutation": "Mutation",
+      "don": "Don",
+      "pacte": "Pacte",
+      "rune": "Rune",
+      "runeeffect": "Effet de Rune",
+      "tendance": "Tendance",
+      "traitchaotique": "Trait Chaotique",
+      "traitespece": "Trait d'Espèce"
+    }
+  },
+  "MOURNBLADE": {
+    "ui": {
+      "editContact": "Modifier le contact",
+      "deleteContact": "Supprimer le contact",
+      "editTrait": "Modifier le trait",
+      "deleteTrait": "Supprimer le trait"
+    }
+  }
+}

.history/lang/fr_20251026132458.json

@@ -0,0 +1,36 @@
+{
+  "TYPES": {
+    "Actor": {
+      "personnage": "Personnage",
+      "creature": "Créature"
+    },
+    "Item": {
+      "arme": "Arme",
+      "talent": "Talent",
+      "historique": "Historique",
+      "profil": "Profil",
+      "competence": "Compétence",
+      "protection": "Protection",
+      "monnaie": "Monnaie",
+      "equipement": "Equipement",
+      "ressource": "Ressource",
+      "contact": "Contact",
+      "mutation": "Mutation",
+      "don": "Don",
+      "pacte": "Pacte",
+      "rune": "Rune",
+      "runeeffect": "Effet de Rune",
+      "tendance": "Tendance",
+      "traitchaotique": "Trait Chaotique",
+      "traitespece": "Trait d'Espèce"
+    }
+  },
+  "MOURNBLADE": {
+    "ui": {
+      "editContact": "Modifier le contact",
+      "deleteContact": "Supprimer le contact",
+      "editTrait": "Modifier le trait",
+      "deleteTrait": "Supprimer le trait"
+    }
+  }
+}

.history/lang/fr_20251026132800.json

@@ -0,0 +1,35 @@
+{
+  "TYPES": {
+    "Actor": {
+      "personnage": "Personnage",
+      "creature": "Créature"
+    },
+    "Item": {
+      "arme": "Arme",
+      "talent": "Talent",
+      "historique": "Historique",
+      "profil": "Profil",
+      "competence": "Compétence",
+      "protection": "Protection",
+      "monnaie": "Monnaie",
+      "equipement": "Equipement",
+      "ressource": "Ressource",
+      "contact": "Contact",
+      "don": "Don",
+      "pacte": "Pacte",
+      "rune": "Rune",
+      "runeeffect": "Effet de Rune",
+      "tendance": "Tendance",
+      "traitchaotique": "Trait Chaotique",
+      "traitespece": "Trait d'Espèce"
+    }
+  },
+  "MOURNBLADE": {
+    "ui": {
+      "editContact": "Modifier le contact",
+      "deleteContact": "Supprimer le contact",
+      "editTrait": "Modifier le trait",
+      "deleteTrait": "Supprimer le trait"
+    }
+  }
+}

.history/lang/fr_20251026132940.json

@@ -0,0 +1,35 @@
+{
+  "TYPES": {
+    "Actor": {
+      "personnage": "Personnage",
+      "creature": "Créature"
+    },
+    "Item": {
+      "arme": "Arme",
+      "talent": "Talent",
+      "historique": "Historique",
+      "profil": "Profil",
+      "competence": "Compétence",
+      "protection": "Protection",
+      "monnaie": "Monnaie",
+      "equipement": "Equipement",
+      "ressource": "Ressource",
+      "contact": "Contact",
+      "don": "Don",
+      "pacte": "Pacte",
+      "rune": "Rune",
+      "runeeffect": "Effet de Rune",
+      "tendance": "Tendance",
+      "traitchaotique": "Trait Chaotique",
+      "traitespece": "Trait d'Espèce"
+    }
+  },
+  "MOURNBLADE": {
+    "ui": {
+      "editContact": "Modifier le contact",
+      "deleteContact": "Supprimer le contact",
+      "editTrait": "Modifier le trait",
+      "deleteTrait": "Supprimer le trait"
+    }
+  }
+}

.history/lang/fr_20251026133304.json

@@ -0,0 +1,34 @@
+{
+  "TYPES": {
+    "Actor": {
+      "personnage": "Personnage",
+      "creature": "Créature"
+    },
+    "Item": {
+      "arme": "Arme",
+      "talent": "Talent",
+      "historique": "Historique",
+      "profil": "Profil",
+      "competence": "Compétence",
+      "protection": "Protection",
+      "monnaie": "Monnaie",
+      "equipement": "Equipement",
+      "ressource": "Ressource",
+      "don": "Don",
+      "pacte": "Pacte",
+      "rune": "Rune",
+      "runeeffect": "Effet de Rune",
+      "tendance": "Tendance",
+      "traitchaotique": "Trait Chaotique",
+      "traitespece": "Trait d'Espèce"
+    }
+  },
+  "MOURNBLADE": {
+    "ui": {
+      "editContact": "Modifier le contact",
+      "deleteContact": "Supprimer le contact",
+      "editTrait": "Modifier le trait",
+      "deleteTrait": "Supprimer le trait"
+    }
+  }
+}

.history/lang/fr_20251026133310.json

@@ -0,0 +1,32 @@
+{
+  "TYPES": {
+    "Actor": {
+      "personnage": "Personnage",
+      "creature": "Créature"
+    },
+    "Item": {
+      "arme": "Arme",
+      "talent": "Talent",
+      "historique": "Historique",
+      "profil": "Profil",
+      "competence": "Compétence",
+      "protection": "Protection",
+      "monnaie": "Monnaie",
+      "equipement": "Equipement",
+      "ressource": "Ressource",
+      "don": "Don",
+      "pacte": "Pacte",
+      "rune": "Rune",
+      "runeeffect": "Effet de Rune",
+      "tendance": "Tendance",
+      "traitchaotique": "Trait Chaotique",
+      "traitespece": "Trait d'Espèce"
+    }
+  },
+  "MOURNBLADE": {
+    "ui": {
+      "editTrait": "Modifier le trait",
+      "deleteTrait": "Supprimer le trait"
+    }
+  }
+}

.history/lang/fr_20251026133355.json

@@ -0,0 +1,32 @@
+{
+  "TYPES": {
+    "Actor": {
+      "personnage": "Personnage",
+      "creature": "Créature"
+    },
+    "Item": {
+      "arme": "Arme",
+      "talent": "Talent",
+      "historique": "Historique",
+      "profil": "Profil",
+      "competence": "Compétence",
+      "protection": "Protection",
+      "monnaie": "Monnaie",
+      "equipement": "Equipement",
+      "ressource": "Ressource",
+      "don": "Don",
+      "pacte": "Pacte",
+      "rune": "Rune",
+      "runeeffect": "Effet de Rune",
+      "tendance": "Tendance",
+      "traitchaotique": "Trait Chaotique",
+      "traitespece": "Trait d'Espèce"
+    }
+  },
+  "MOURNBLADE": {
+    "ui": {
+      "editTrait": "Modifier le trait",
+      "deleteTrait": "Supprimer le trait"
+    }
+  }
+}

.history/macro-replace-images_20251026112045.js

@@ -0,0 +1,116 @@
+/**
+ * Macro pour remplacer les chemins d'images dans les compendiums
+ * Remplace "fvtt-hawkmoon-cyd" par "fvtt-mournblade-cyd2" dans tous les champs 'img'
+ */
+
+(async () => {
+  // Confirmation avant de procéder
+  let confirm = await Dialog.confirm({
+    title: "Remplacement des chemins d'images",
+    content: `<p>Cette macro va :</p>
+      <ul>
+        <li>Déverrouiller tous les compendiums</li>
+        <li>Remplacer "fvtt-hawkmoon-cyd" par "fvtt-mournblade-cyd2" dans tous les champs 'img'</li>
+        <li>Reverrouiller les compendiums</li>
+      </ul>
+      <p><strong>Voulez-vous continuer ?</strong></p>`,
+    defaultYes: false
+  });
+
+  if (!confirm) {
+    ui.notifications.info("Opération annulée");
+    return;
+  }
+
+  ui.notifications.info("Début du traitement des compendiums...");
+
+  let totalUpdated = 0;
+  let compendiumsProcessed = 0;
+
+  // Parcourir tous les compendiums
+  for (let pack of game.packs) {
+    // Filtrer uniquement les compendiums du système mournblade
+    if (!pack.metadata.packageName.includes("mournblade")) continue;
+
+    console.log(`Traitement du compendium: ${pack.metadata.label}`);
+    compendiumsProcessed++;
+
+    try {
+      // Unlock le compendium
+      await pack.configure({ locked: false });
+
+      // Récupérer tous les documents du compendium
+      let documents = await pack.getDocuments();
+      let updatedInPack = 0;
+
+      for (let doc of documents) {
+        let needsUpdate = false;
+        let updateData = {};
+
+        // Vérifier le champ img principal
+        if (doc.img && doc.img.includes("fvtt-hawkmoon-cyd")) {
+          updateData.img = doc.img.replace(/fvtt-hawkmoon-cyd/g, "fvtt-mournblade-cyd2");
+          needsUpdate = true;
+        }
+
+        // Pour les acteurs, vérifier aussi prototypeToken.texture.src
+        if (doc.documentName === "Actor" && doc.prototypeToken?.texture?.src) {
+          if (doc.prototypeToken.texture.src.includes("fvtt-hawkmoon-cyd")) {
+            updateData["prototypeToken.texture.src"] = doc.prototypeToken.texture.src.replace(/fvtt-hawkmoon-cyd/g, "fvtt-mournblade-cyd2");
+            needsUpdate = true;
+          }
+        }
+
+        // Pour les items contenus dans les acteurs
+        if (doc.documentName === "Actor" && doc.items) {
+          for (let item of doc.items) {
+            if (item.img && item.img.includes("fvtt-hawkmoon-cyd")) {
+              // Note: Les items embarqués nécessitent une approche différente
+              needsUpdate = true;
+            }
+          }
+        }
+
+        // Pour les scènes, vérifier background.src et les tokens
+        if (doc.documentName === "Scene") {
+          if (doc.background?.src && doc.background.src.includes("fvtt-hawkmoon-cyd")) {
+            updateData["background.src"] = doc.background.src.replace(/fvtt-hawkmoon-cyd/g, "fvtt-mournblade-cyd2");
+            needsUpdate = true;
+          }
+        }
+
+        // Effectuer la mise à jour si nécessaire
+        if (needsUpdate) {
+          await doc.update(updateData);
+          updatedInPack++;
+          console.log(`  - Mise à jour: ${doc.name}`);
+        }
+      }
+
+      // Lock le compendium
+      await pack.configure({ locked: true });
+
+      if (updatedInPack > 0) {
+        ui.notifications.info(`${pack.metadata.label}: ${updatedInPack} document(s) mis à jour`);
+        totalUpdated += updatedInPack;
+      }
+
+    } catch (error) {
+      console.error(`Erreur lors du traitement de ${pack.metadata.label}:`, error);
+      ui.notifications.error(`Erreur sur ${pack.metadata.label}: ${error.message}`);
+      
+      // Tenter de reverrouiller en cas d'erreur
+      try {
+        await pack.configure({ locked: true });
+      } catch (lockError) {
+        console.error(`Impossible de reverrouiller ${pack.metadata.label}:`, lockError);
+      }
+    }
+  }
+
+  ui.notifications.info(`Traitement terminé ! ${totalUpdated} document(s) mis à jour dans ${compendiumsProcessed} compendium(s).`);
+  console.log(`=== Résumé ===`);
+  console.log(`Compendiums traités: ${compendiumsProcessed}`);
+  console.log(`Total de documents mis à jour: ${totalUpdated}`);
+
+})();

.history/macro-replace-images_20251026112109.js

@@ -0,0 +1,116 @@
+/**
+ * Macro pour remplacer les chemins d'images dans les compendiums
+ * Remplace "fvtt-hawkmoon-cyd" par "fvtt-mournblade-cyd2" dans tous les champs 'img'
+ */
+
+(async () => {
+  // Confirmation avant de procéder
+  let confirm = await Dialog.confirm({
+    title: "Remplacement des chemins d'images",
+    content: `<p>Cette macro va :</p>
+      <ul>
+        <li>Déverrouiller tous les compendiums</li>
+        <li>Remplacer "fvtt-hawkmoon-cyd" par "fvtt-mournblade-cyd2" dans tous les champs 'img'</li>
+        <li>Reverrouiller les compendiums</li>
+      </ul>
+      <p><strong>Voulez-vous continuer ?</strong></p>`,
+    defaultYes: false
+  });
+
+  if (!confirm) {
+    ui.notifications.info("Opération annulée");
+    return;
+  }
+
+  ui.notifications.info("Début du traitement des compendiums...");
+
+  let totalUpdated = 0;
+  let compendiumsProcessed = 0;
+
+  // Parcourir tous les compendiums
+  for (let pack of game.packs) {
+    // Filtrer uniquement les compendiums du système mournblade
+    if (!pack.metadata.packageName.includes("mournblade")) continue;
+
+    console.log(`Traitement du compendium: ${pack.metadata.label}`);
+    compendiumsProcessed++;
+
+    try {
+      // Unlock le compendium
+      await pack.configure({ locked: false });
+
+      // Récupérer tous les documents du compendium
+      let documents = await pack.getDocuments();
+      let updatedInPack = 0;
+
+      for (let doc of documents) {
+        let needsUpdate = false;
+        let updateData = {};
+
+        // Vérifier le champ img principal
+        if (doc.img && doc.img.includes("fvtt-hawkmoon-cyd")) {
+          updateData.img = doc.img.replace(/fvtt-hawkmoon-cyd/g, "fvtt-mournblade-cyd2");
+          needsUpdate = true;
+        }
+
+        // Pour les acteurs, vérifier aussi prototypeToken.texture.src
+        if (doc.documentName === "Actor" && doc.prototypeToken?.texture?.src) {
+          if (doc.prototypeToken.texture.src.includes("fvtt-hawkmoon-cyd")) {
+            updateData["prototypeToken.texture.src"] = doc.prototypeToken.texture.src.replace(/fvtt-hawkmoon-cyd/g, "fvtt-mournblade-cyd2");
+            needsUpdate = true;
+          }
+        }
+
+        // Pour les items contenus dans les acteurs
+        if (doc.documentName === "Actor" && doc.items) {
+          for (let item of doc.items) {
+            if (item.img && item.img.includes("fvtt-hawkmoon-cyd")) {
+              // Note: Les items embarqués nécessitent une approche différente
+              needsUpdate = true;
+            }
+          }
+        }
+
+        // Pour les scènes, vérifier background.src et les tokens
+        if (doc.documentName === "Scene") {
+          if (doc.background?.src && doc.background.src.includes("fvtt-hawkmoon-cyd")) {
+            updateData["background.src"] = doc.background.src.replace(/fvtt-hawkmoon-cyd/g, "fvtt-mournblade-cyd2");
+            needsUpdate = true;
+          }
+        }
+
+        // Effectuer la mise à jour si nécessaire
+        if (needsUpdate) {
+          await doc.update(updateData);
+          updatedInPack++;
+          console.log(`  - Mise à jour: ${doc.name}`);
+        }
+      }
+
+      // Lock le compendium
+      await pack.configure({ locked: true });
+
+      if (updatedInPack > 0) {
+        ui.notifications.info(`${pack.metadata.label}: ${updatedInPack} document(s) mis à jour`);
+        totalUpdated += updatedInPack;
+      }
+
+    } catch (error) {
+      console.error(`Erreur lors du traitement de ${pack.metadata.label}:`, error);
+      ui.notifications.error(`Erreur sur ${pack.metadata.label}: ${error.message}`);
+
+      // Tenter de reverrouiller en cas d'erreur
+      try {
+        await pack.configure({ locked: true });
+      } catch (lockError) {
+        console.error(`Impossible de reverrouiller ${pack.metadata.label}:`, lockError);
+      }
+    }
+  }
+
+  ui.notifications.info(`Traitement terminé ! ${totalUpdated} document(s) mis à jour dans ${compendiumsProcessed} compendium(s).`);
+  console.log(`=== Résumé ===`);
+  console.log(`Compendiums traités: ${compendiumsProcessed}`);
+  console.log(`Total de documents mis à jour: ${totalUpdated}`);
+
+})();

.history/modules/mournblade-cyd2-actor-sheet_20251026001316.js

@@ -0,0 +1,222 @@
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2Automation } from "./mournblade-cyd2-automation.js";
+
+/* -------------------------------------------- */
+export class MournbladeCYD2ActorSheet extends foundry.appv1.sheets.ActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+
+    return foundry.utils.mergeObject(super.defaultOptions, {
+      classes: ["fvtt-mournblade-cyd2", "sheet", "actor"],
+      template: "systems/fvtt-mournblade-cyd2/templates/actor-sheet.html",
+      width: 640,
+      height: 720,
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "stats" }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
+      editScore: false
+    })
+  }
+
+  /* -------------------------------------------- */
+  async getData() {
+    const objectData = foundry.utils.duplicate(this.object)
+
+    let formData = {
+      title: this.title,
+      id: objectData.id,
+      type: objectData.type,
+      img: objectData.img,
+      name: objectData.name,
+      editable: this.isEditable,
+      cssClass: this.isEditable ? "editable" : "locked",
+      system: objectData.system,
+      effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
+      limited: this.object.limited,
+      skills: this.actor.getSkills(),
+      armes: foundry.utils.duplicate(this.actor.getWeapons()),
+      monnaies: foundry.utils.duplicate(this.actor.getMonnaies()),
+      protections: foundry.utils.duplicate(this.actor.getArmors()),
+      historiques: foundry.utils.duplicate(this.actor.getHistoriques() || []),
+      talents: foundry.utils.duplicate(this.actor.getTalents() || []),
+      mutations: foundry.utils.duplicate(this.actor.getMutations() || []),
+      dons: foundry.utils.duplicate(this.actor.getDons() || []),
+      pactes: foundry.utils.duplicate(this.actor.getPactes() || []),
+      tendances: foundry.utils.duplicate(this.actor.getTendances() || []),
+      runes: foundry.utils.duplicate(this.actor.getRunes() || []),
+      traitsChaotiques: foundry.utils.duplicate(this.actor.getTraitsChaotiques() || []),
+      traitsEspeces: foundry.utils.duplicate(this.actor.getTraitsEspeces() || []),
+      talentsCell: this.getCelluleTalents(),
+      profils: foundry.utils.duplicate(this.actor.getProfils()  || []),
+      combat: this.actor.getCombatValues(),
+      equipements: foundry.utils.duplicate(this.actor.getEquipments()),
+      artefacts: foundry.utils.duplicate(this.actor.getArtefacts()),
+      richesse: this.actor.computeRichesse(),
+      coupDevastateur: this.actor.items.find(it => it.type =="talent" && it.name.toLowerCase() == "coup devastateur" && !it.system.used),
+      valeurEquipement: this.actor.computeValeurEquipement(),
+      nbCombativite: this.actor.system.sante.nbcombativite,
+      combativiteList: MournbladeCYD2Utility.getCombativiteList(this.actor.system.sante.nbcombativite),
+      initiative: this.actor.getFlag("world", "last-initiative") || -1,
+      description: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.description, {async: true}),
+      habitat: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.habitat, {async: true}),
+      options: this.options,
+      owner: this.document.isOwner,
+      editScore: this.options.editScore,
+      isGM: game.user.isGM,
+      config: game.system.mournbladecyd2.config
+    }
+    this.formData = formData;
+
+    console.log("PC : ", formData, this.object);
+    return formData;
+  }
+
+  /* -------------------------------------------- */
+  getCelluleTalents( )  {
+    let talents = []
+    for(let cellule of game.actors) {
+      if (cellule.type == "cellule") {
+        let found = cellule.system.members.find( it => it.id == this.actor.id)
+        if (found) {
+          talents = talents.concat( cellule.getTalents() )
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  /** @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")
+      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");
+      MournbladeCYD2Utility.confirmDelete(this, li);
+    })
+    html.find('.edit-item-data').change(ev => {
+      const li = $(ev.currentTarget).parents(".item")
+      let itemId    = li.data("item-id")
+      let itemType  = li.data("item-type")
+      let itemField = $(ev.currentTarget).data("item-field")
+      let dataType = $(ev.currentTarget).data("dtype")
+      let value = ev.currentTarget.value
+      this.actor.editItemField(itemId, itemType, itemField, dataType, value)
+    })
+
+    html.find('.adversite-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      let adv = li.data("adversite")
+      let value = Number($(event.currentTarget).data("adversite-value"))
+      this.actor.incDecAdversite(adv, value)
+    })
+
+    html.find('.quantity-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      const value = Number($(event.currentTarget).data("quantite-value"))
+      this.actor.incDecQuantity( li.data("item-id"), value );
+    })
+
+    html.find('.roll-initiative').click((event) => {
+      this.actor.rollAttribut("adr", true)
+    })
+
+    html.find('.roll-attribut').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = li.data("attr-key")
+      this.actor.rollAttribut(attrKey, false)
+    })
+    html.find('.roll-competence').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = $(event.currentTarget).data("attr-key")
+      let compId  = li.data("item-id")
+      this.actor.rollCompetence(attrKey, compId)
+    })
+    html.find('.roll-arme-offensif').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId  = li.data("item-id")
+      this.actor.rollArmeOffensif(armeId)
+    })
+
+    html.find('.roll-assommer').click((event) => {
+      this.actor.rollAssommer()
+    })
+    html.find('.roll-coup-bas').click((event) => {
+      this.actor.rollCoupBas()
+    })
+    html.find('.roll-immobiliser').click((event) => {
+      this.actor.rollImmobiliser()
+    })
+    html.find('.roll-repousser').click((event) => {
+      this.actor.rollRepousser()
+    })
+    html.find('.roll-desengager').click((event) => {
+      this.actor.rollDesengager()
+    })
+
+    html.find('.roll-arme-degats').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId  = li.data("item-id")
+      this.actor.rollArmeDegats(armeId)
+    })
+
+    html.find('.item-add').click((event) => {
+      const itemType = $(event.currentTarget).data("type")
+      this.actor.createEmbeddedDocuments('Item', [{ name: `Nouveau ${itemType}`, type: itemType }], { renderSheet: true })
+    })
+
+    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);
+    });
+
+  }
+
+  /* -------------------------------------------- */
+  /** @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;
+  }
+
+  /* -------------------------------------------- */
+  async _onDropItem(event, dragData) {
+    let data = event.dataTransfer.getData('text/plain')
+    let dataItem = JSON.parse( data)
+    let item = fromUuidSync(dataItem.uuid)
+    if (item.pack) {
+      item = await MournbladeCYD2Utility.searchItem(item)
+    }
+    let autoresult = MournbladeCYD2Automation.processAutomations("on-drop", item, this.actor)
+    if (  autoresult.isValid ) {
+      super._onDropItem(event, dragData)
+    } else {
+      ui.notifications.warn( autoresult.warningMessage)
+    }
+  }
+
+}

.history/modules/mournblade-cyd2-actor-sheet_20251026001548.js

@@ -0,0 +1,222 @@
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2Automation } from "./mournblade-cyd2-automation.js";
+
+/* -------------------------------------------- */
+export class MournbladeCYD2ActorSheet extends foundry.appv1.sheets.ActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+
+    return foundry.utils.mergeObject(super.defaultOptions, {
+      classes: ["fvtt-mournblade-cyd2", "sheet", "actor"],
+      template: "systems/fvtt-mournblade-cyd2/templates/actor-sheet.html",
+      width: 640,
+      height: 720,
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "stats" }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
+      editScore: false
+    })
+  }
+
+  /* -------------------------------------------- */
+  async getData() {
+    const objectData = foundry.utils.duplicate(this.object)
+
+    let formData = {
+      title: this.title,
+      id: objectData.id,
+      type: objectData.type,
+      img: objectData.img,
+      name: objectData.name,
+      editable: this.isEditable,
+      cssClass: this.isEditable ? "editable" : "locked",
+      system: objectData.system,
+      effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
+      limited: this.object.limited,
+      skills: this.actor.getSkills(),
+      armes: foundry.utils.duplicate(this.actor.getWeapons()),
+      monnaies: foundry.utils.duplicate(this.actor.getMonnaies()),
+      protections: foundry.utils.duplicate(this.actor.getArmors()),
+      historiques: foundry.utils.duplicate(this.actor.getHistoriques() || []),
+      talents: foundry.utils.duplicate(this.actor.getTalents() || []),
+      mutations: foundry.utils.duplicate(this.actor.getMutations() || []),
+      dons: foundry.utils.duplicate(this.actor.getDons() || []),
+      pactes: foundry.utils.duplicate(this.actor.getPactes() || []),
+      tendances: foundry.utils.duplicate(this.actor.getTendances() || []),
+      runes: foundry.utils.duplicate(this.actor.getRunes() || []),
+      traitsChaotiques: foundry.utils.duplicate(this.actor.getTraitsChaotiques() || []),
+      traitsEspeces: foundry.utils.duplicate(this.actor.getTraitsEspeces() || []),
+      talentsCell: this.getCelluleTalents(),
+      profils: foundry.utils.duplicate(this.actor.getProfils() || []),
+      combat: this.actor.getCombatValues(),
+      equipements: foundry.utils.duplicate(this.actor.getEquipments()),
+      artefacts: foundry.utils.duplicate(this.actor.getArtefacts()),
+      richesse: this.actor.computeRichesse(),
+      coupDevastateur: this.actor.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup devastateur" && !it.system.used),
+      valeurEquipement: this.actor.computeValeurEquipement(),
+      nbCombativite: this.actor.system.sante.nbcombativite,
+      combativiteList: MournbladeCYD2Utility.getCombativiteList(this.actor.system.sante.nbcombativite),
+      initiative: this.actor.getFlag("world", "last-initiative") || -1,
+      description: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.description, { async: true }),
+      habitat: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.habitat, { async: true }),
+      options: this.options,
+      owner: this.document.isOwner,
+      editScore: this.options.editScore,
+      isGM: game.user.isGM,
+      config: game.system.mournbladecyd2.config
+    }
+    this.formData = formData;
+
+    console.log("PC : ", formData, this.object);
+    return formData;
+  }
+
+  /* -------------------------------------------- */
+  getCelluleTalents() {
+    let talents = []
+    for (let cellule of game.actors) {
+      if (cellule.type == "cellule") {
+        let found = cellule.system.members.find(it => it.id == this.actor.id)
+        if (found) {
+          talents = talents.concat(cellule.getTalents())
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  /** @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")
+      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");
+      MournbladeCYD2Utility.confirmDelete(this, li);
+    })
+    html.find('.edit-item-data').change(ev => {
+      const li = $(ev.currentTarget).parents(".item")
+      let itemId = li.data("item-id")
+      let itemType = li.data("item-type")
+      let itemField = $(ev.currentTarget).data("item-field")
+      let dataType = $(ev.currentTarget).data("dtype")
+      let value = ev.currentTarget.value
+      this.actor.editItemField(itemId, itemType, itemField, dataType, value)
+    })
+
+    html.find('.adversite-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      let adv = li.data("adversite")
+      let value = Number($(event.currentTarget).data("adversite-value"))
+      this.actor.incDecAdversite(adv, value)
+    })
+
+    html.find('.quantity-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      const value = Number($(event.currentTarget).data("quantite-value"))
+      this.actor.incDecQuantity(li.data("item-id"), value);
+    })
+
+    html.find('.roll-initiative').click((event) => {
+      this.actor.rollAttribut("adr", true)
+    })
+
+    html.find('.roll-attribut').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = li.data("attr-key")
+      this.actor.rollAttribut(attrKey, false)
+    })
+    html.find('.roll-competence').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = $(event.currentTarget).data("attr-key")
+      let compId = li.data("item-id")
+      this.actor.rollCompetence(attrKey, compId)
+    })
+    html.find('.roll-arme-offensif').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeOffensif(armeId)
+    })
+
+    html.find('.roll-assommer').click((event) => {
+      this.actor.rollAssommer()
+    })
+    html.find('.roll-coup-bas').click((event) => {
+      this.actor.rollCoupBas()
+    })
+    html.find('.roll-immobiliser').click((event) => {
+      this.actor.rollImmobiliser()
+    })
+    html.find('.roll-repousser').click((event) => {
+      this.actor.rollRepousser()
+    })
+    html.find('.roll-desengager').click((event) => {
+      this.actor.rollDesengager()
+    })
+
+    html.find('.roll-arme-degats').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeDegats(armeId)
+    })
+
+    html.find('.item-add').click((event) => {
+      const itemType = $(event.currentTarget).data("type")
+      this.actor.createEmbeddedDocuments('Item', [{ name: `Nouveau ${itemType}`, type: itemType }], { renderSheet: true })
+    })
+
+    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);
+    });
+
+  }
+
+  /* -------------------------------------------- */
+  /** @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;
+  }
+
+  /* -------------------------------------------- */
+  async _onDropItem(event, dragData) {
+    let data = event.dataTransfer.getData('text/plain')
+    let dataItem = JSON.parse(data)
+    let item = fromUuidSync(dataItem.uuid)
+    if (item.pack) {
+      item = await MournbladeCYD2Utility.searchItem(item)
+    }
+    let autoresult = MournbladeCYD2Automation.processAutomations("on-drop", item, this.actor)
+    if (autoresult.isValid) {
+      super._onDropItem(event, dragData)
+    } else {
+      ui.notifications.warn(autoresult.warningMessage)
+    }
+  }
+
+}

.history/modules/mournblade-cyd2-actor-sheet_20251026002630.js

@@ -0,0 +1,224 @@
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2Automation } from "./mournblade-cyd2-automation.js";
+
+/* -------------------------------------------- */
+export class MournbladeCYD2ActorSheet extends foundry.appv1.sheets.ActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+
+    return foundry.utils.mergeObject(super.defaultOptions, {
+      classes: ["fvtt-mournblade-cyd2", "sheet", "actor"],
+      template: "systems/fvtt-mournblade-cyd2/templates/actor-sheet.html",
+      width: 640,
+      height: 720,
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "stats" }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
+      editScore: false
+    })
+  }
+
+  /* -------------------------------------------- */
+  async getData() {
+    const objectData = foundry.utils.duplicate(this.object)
+
+    let formData = {
+      title: this.title,
+      id: objectData.id,
+      type: objectData.type,
+      img: objectData.img,
+      name: objectData.name,
+      editable: this.isEditable,
+      cssClass: this.isEditable ? "editable" : "locked",
+      system: objectData.system,
+      effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
+      limited: this.object.limited,
+      skills: this.actor.getSkills(),
+      armes: foundry.utils.duplicate(this.actor.getWeapons()),
+      monnaies: foundry.utils.duplicate(this.actor.getMonnaies()),
+      protections: foundry.utils.duplicate(this.actor.getArmors()),
+      historiques: foundry.utils.duplicate(this.actor.getHistoriques() || []),
+      talents: foundry.utils.duplicate(this.actor.getTalents() || []),
+      mutations: foundry.utils.duplicate(this.actor.getMutations() || []),
+      dons: foundry.utils.duplicate(this.actor.getDons() || []),
+      pactes: foundry.utils.duplicate(this.actor.getPactes() || []),
+      tendances: foundry.utils.duplicate(this.actor.getTendances() || []),
+      runes: foundry.utils.duplicate(this.actor.getRunes() || []),
+      traitsChaotiques: foundry.utils.duplicate(this.actor.getTraitsChaotiques() || []),
+      traitsEspeces: foundry.utils.duplicate(this.actor.getTraitsEspeces() || []),
+      aspect: this.actor.getAspect(),
+      marge: this.actor.getMarge(),
+      talentsCell: this.getCelluleTalents(),
+      profils: foundry.utils.duplicate(this.actor.getProfils() || []),
+      combat: this.actor.getCombatValues(),
+      equipements: foundry.utils.duplicate(this.actor.getEquipments()),
+      artefacts: foundry.utils.duplicate(this.actor.getArtefacts()),
+      richesse: this.actor.computeRichesse(),
+      coupDevastateur: this.actor.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup devastateur" && !it.system.used),
+      valeurEquipement: this.actor.computeValeurEquipement(),
+      nbCombativite: this.actor.system.sante.nbcombativite,
+      combativiteList: MournbladeCYD2Utility.getCombativiteList(this.actor.system.sante.nbcombativite),
+      initiative: this.actor.getFlag("world", "last-initiative") || -1,
+      description: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.description, { async: true }),
+      habitat: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.habitat, { async: true }),
+      options: this.options,
+      owner: this.document.isOwner,
+      editScore: this.options.editScore,
+      isGM: game.user.isGM,
+      config: game.system.mournbladecyd2.config
+    }
+    this.formData = formData;
+
+    console.log("PC : ", formData, this.object);
+    return formData;
+  }
+
+  /* -------------------------------------------- */
+  getCelluleTalents() {
+    let talents = []
+    for (let cellule of game.actors) {
+      if (cellule.type == "cellule") {
+        let found = cellule.system.members.find(it => it.id == this.actor.id)
+        if (found) {
+          talents = talents.concat(cellule.getTalents())
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  /** @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")
+      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");
+      MournbladeCYD2Utility.confirmDelete(this, li);
+    })
+    html.find('.edit-item-data').change(ev => {
+      const li = $(ev.currentTarget).parents(".item")
+      let itemId = li.data("item-id")
+      let itemType = li.data("item-type")
+      let itemField = $(ev.currentTarget).data("item-field")
+      let dataType = $(ev.currentTarget).data("dtype")
+      let value = ev.currentTarget.value
+      this.actor.editItemField(itemId, itemType, itemField, dataType, value)
+    })
+
+    html.find('.adversite-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      let adv = li.data("adversite")
+      let value = Number($(event.currentTarget).data("adversite-value"))
+      this.actor.incDecAdversite(adv, value)
+    })
+
+    html.find('.quantity-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      const value = Number($(event.currentTarget).data("quantite-value"))
+      this.actor.incDecQuantity(li.data("item-id"), value);
+    })
+
+    html.find('.roll-initiative').click((event) => {
+      this.actor.rollAttribut("adr", true)
+    })
+
+    html.find('.roll-attribut').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = li.data("attr-key")
+      this.actor.rollAttribut(attrKey, false)
+    })
+    html.find('.roll-competence').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = $(event.currentTarget).data("attr-key")
+      let compId = li.data("item-id")
+      this.actor.rollCompetence(attrKey, compId)
+    })
+    html.find('.roll-arme-offensif').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeOffensif(armeId)
+    })
+
+    html.find('.roll-assommer').click((event) => {
+      this.actor.rollAssommer()
+    })
+    html.find('.roll-coup-bas').click((event) => {
+      this.actor.rollCoupBas()
+    })
+    html.find('.roll-immobiliser').click((event) => {
+      this.actor.rollImmobiliser()
+    })
+    html.find('.roll-repousser').click((event) => {
+      this.actor.rollRepousser()
+    })
+    html.find('.roll-desengager').click((event) => {
+      this.actor.rollDesengager()
+    })
+
+    html.find('.roll-arme-degats').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeDegats(armeId)
+    })
+
+    html.find('.item-add').click((event) => {
+      const itemType = $(event.currentTarget).data("type")
+      this.actor.createEmbeddedDocuments('Item', [{ name: `Nouveau ${itemType}`, type: itemType }], { renderSheet: true })
+    })
+
+    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);
+    });
+
+  }
+
+  /* -------------------------------------------- */
+  /** @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;
+  }
+
+  /* -------------------------------------------- */
+  async _onDropItem(event, dragData) {
+    let data = event.dataTransfer.getData('text/plain')
+    let dataItem = JSON.parse(data)
+    let item = fromUuidSync(dataItem.uuid)
+    if (item.pack) {
+      item = await MournbladeCYD2Utility.searchItem(item)
+    }
+    let autoresult = MournbladeCYD2Automation.processAutomations("on-drop", item, this.actor)
+    if (autoresult.isValid) {
+      super._onDropItem(event, dragData)
+    } else {
+      ui.notifications.warn(autoresult.warningMessage)
+    }
+  }
+
+}

.history/modules/mournblade-cyd2-actor-sheet_20251026002719.js

@@ -0,0 +1,224 @@
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2Automation } from "./mournblade-cyd2-automation.js";
+
+/* -------------------------------------------- */
+export class MournbladeCYD2ActorSheet extends foundry.appv1.sheets.ActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+
+    return foundry.utils.mergeObject(super.defaultOptions, {
+      classes: ["fvtt-mournblade-cyd2", "sheet", "actor"],
+      template: "systems/fvtt-mournblade-cyd2/templates/actor-sheet.html",
+      width: 640,
+      height: 720,
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "stats" }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
+      editScore: false
+    })
+  }
+
+  /* -------------------------------------------- */
+  async getData() {
+    const objectData = foundry.utils.duplicate(this.object)
+
+    let formData = {
+      title: this.title,
+      id: objectData.id,
+      type: objectData.type,
+      img: objectData.img,
+      name: objectData.name,
+      editable: this.isEditable,
+      cssClass: this.isEditable ? "editable" : "locked",
+      system: objectData.system,
+      effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
+      limited: this.object.limited,
+      skills: this.actor.getSkills(),
+      armes: foundry.utils.duplicate(this.actor.getWeapons()),
+      monnaies: foundry.utils.duplicate(this.actor.getMonnaies()),
+      protections: foundry.utils.duplicate(this.actor.getArmors()),
+      historiques: foundry.utils.duplicate(this.actor.getHistoriques() || []),
+      talents: foundry.utils.duplicate(this.actor.getTalents() || []),
+      mutations: foundry.utils.duplicate(this.actor.getMutations() || []),
+      dons: foundry.utils.duplicate(this.actor.getDons() || []),
+      pactes: foundry.utils.duplicate(this.actor.getPactes() || []),
+      tendances: foundry.utils.duplicate(this.actor.getTendances() || []),
+      runes: foundry.utils.duplicate(this.actor.getRunes() || []),
+      traitsChaotiques: foundry.utils.duplicate(this.actor.getTraitsChaotiques() || []),
+      traitsEspeces: foundry.utils.duplicate(this.actor.getTraitsEspeces() || []),
+      aspect: this.actor.getAspect(),
+      marge: this.actor.getMarge(),
+      talentsCell: this.getCelluleTalents(),
+      profils: foundry.utils.duplicate(this.actor.getProfils() || []),
+      combat: this.actor.getCombatValues(),
+      equipements: foundry.utils.duplicate(this.actor.getEquipments()),
+      artefacts: foundry.utils.duplicate(this.actor.getArtefacts()),
+      richesse: this.actor.computeRichesse(),
+      coupDevastateur: this.actor.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup devastateur" && !it.system.used),
+      valeurEquipement: this.actor.computeValeurEquipement(),
+      nbCombativite: this.actor.system.sante.nbcombativite,
+      combativiteList: MournbladeCYD2Utility.getCombativiteList(this.actor.system.sante.nbcombativite),
+      initiative: this.actor.getFlag("world", "last-initiative") || -1,
+      description: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.description, { async: true }),
+      habitat: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.habitat, { async: true }),
+      options: this.options,
+      owner: this.document.isOwner,
+      editScore: this.options.editScore,
+      isGM: game.user.isGM,
+      config: game.system.mournbladecyd2.config
+    }
+    this.formData = formData;
+
+    console.log("PC : ", formData, this.object);
+    return formData;
+  }
+
+  /* -------------------------------------------- */
+  getCelluleTalents() {
+    let talents = []
+    for (let cellule of game.actors) {
+      if (cellule.type == "cellule") {
+        let found = cellule.system.members.find(it => it.id == this.actor.id)
+        if (found) {
+          talents = talents.concat(cellule.getTalents())
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  /** @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")
+      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");
+      MournbladeCYD2Utility.confirmDelete(this, li);
+    })
+    html.find('.edit-item-data').change(ev => {
+      const li = $(ev.currentTarget).parents(".item")
+      let itemId = li.data("item-id")
+      let itemType = li.data("item-type")
+      let itemField = $(ev.currentTarget).data("item-field")
+      let dataType = $(ev.currentTarget).data("dtype")
+      let value = ev.currentTarget.value
+      this.actor.editItemField(itemId, itemType, itemField, dataType, value)
+    })
+
+    html.find('.adversite-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      let adv = li.data("adversite")
+      let value = Number($(event.currentTarget).data("adversite-value"))
+      this.actor.incDecAdversite(adv, value)
+    })
+
+    html.find('.quantity-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      const value = Number($(event.currentTarget).data("quantite-value"))
+      this.actor.incDecQuantity(li.data("item-id"), value);
+    })
+
+    html.find('.roll-initiative').click((event) => {
+      this.actor.rollAttribut("adr", true)
+    })
+
+    html.find('.roll-attribut').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = li.data("attr-key")
+      this.actor.rollAttribut(attrKey, false)
+    })
+    html.find('.roll-competence').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = $(event.currentTarget).data("attr-key")
+      let compId = li.data("item-id")
+      this.actor.rollCompetence(attrKey, compId)
+    })
+    html.find('.roll-arme-offensif').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeOffensif(armeId)
+    })
+
+    html.find('.roll-assommer').click((event) => {
+      this.actor.rollAssommer()
+    })
+    html.find('.roll-coup-bas').click((event) => {
+      this.actor.rollCoupBas()
+    })
+    html.find('.roll-immobiliser').click((event) => {
+      this.actor.rollImmobiliser()
+    })
+    html.find('.roll-repousser').click((event) => {
+      this.actor.rollRepousser()
+    })
+    html.find('.roll-desengager').click((event) => {
+      this.actor.rollDesengager()
+    })
+
+    html.find('.roll-arme-degats').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeDegats(armeId)
+    })
+
+    html.find('.item-add').click((event) => {
+      const itemType = $(event.currentTarget).data("type")
+      this.actor.createEmbeddedDocuments('Item', [{ name: `Nouveau ${itemType}`, type: itemType }], { renderSheet: true })
+    })
+
+    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);
+    });
+
+  }
+
+  /* -------------------------------------------- */
+  /** @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;
+  }
+
+  /* -------------------------------------------- */
+  async _onDropItem(event, dragData) {
+    let data = event.dataTransfer.getData('text/plain')
+    let dataItem = JSON.parse(data)
+    let item = fromUuidSync(dataItem.uuid)
+    if (item.pack) {
+      item = await MournbladeCYD2Utility.searchItem(item)
+    }
+    let autoresult = MournbladeCYD2Automation.processAutomations("on-drop", item, this.actor)
+    if (autoresult.isValid) {
+      super._onDropItem(event, dragData)
+    } else {
+      ui.notifications.warn(autoresult.warningMessage)
+    }
+  }
+
+}

.history/modules/mournblade-cyd2-actor-sheet_20251026082045.js

@@ -0,0 +1,226 @@
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2Automation } from "./mournblade-cyd2-automation.js";
+
+/* -------------------------------------------- */
+export class MournbladeCYD2ActorSheet extends foundry.appv1.sheets.ActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+
+    return foundry.utils.mergeObject(super.defaultOptions, {
+      classes: ["fvtt-mournblade-cyd2", "sheet", "actor"],
+      template: "systems/fvtt-mournblade-cyd2/templates/actor-sheet.html",
+      width: 640,
+      height: 720,
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "stats" }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
+      editScore: false
+    })
+  }
+
+  /* -------------------------------------------- */
+  async getData() {
+    const objectData = foundry.utils.duplicate(this.object)
+
+    let formData = {
+      title: this.title,
+      id: objectData.id,
+      type: objectData.type,
+      img: objectData.img,
+      name: objectData.name,
+      editable: this.isEditable,
+      cssClass: this.isEditable ? "editable" : "locked",
+      system: objectData.system,
+      effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
+      limited: this.object.limited,
+      skills: this.actor.getSkills(),
+      armes: foundry.utils.duplicate(this.actor.getWeapons()),
+      monnaies: foundry.utils.duplicate(this.actor.getMonnaies()),
+      protections: foundry.utils.duplicate(this.actor.getArmors()),
+      historiques: foundry.utils.duplicate(this.actor.getHistoriques() || []),
+      talents: foundry.utils.duplicate(this.actor.getTalents() || []),
+      mutations: foundry.utils.duplicate(this.actor.getMutations() || []),
+      dons: foundry.utils.duplicate(this.actor.getDons() || []),
+      pactes: foundry.utils.duplicate(this.actor.getPactes() || []),
+      tendances: foundry.utils.duplicate(this.actor.getTendances() || []),
+      runes: foundry.utils.duplicate(this.actor.getRunes() || []),
+      traitsChaotiques: foundry.utils.duplicate(this.actor.getTraitsChaotiques() || []),
+      traitsEspeces: foundry.utils.duplicate(this.actor.getTraitsEspeces() || []),
+      aspect: this.actor.getAspect(),
+      marge: this.actor.getMarge(),
+      talentsCell: this.getCelluleTalents(),
+      profils: foundry.utils.duplicate(this.actor.getProfils() || []),
+      combat: this.actor.getCombatValues(),
+      equipements: foundry.utils.duplicate(this.actor.getEquipments()),
+      artefacts: foundry.utils.duplicate(this.actor.getArtefacts()),
+      richesse: this.actor.computeRichesse(),
+      coupDevastateur: this.actor.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup devastateur" && !it.system.used),
+      valeurEquipement: this.actor.computeValeurEquipement(),
+      nbCombativite: this.actor.system.sante.nbcombativite,
+      combativiteList: MournbladeCYD2Utility.getCombativiteList(this.actor.system.sante.nbcombativite),
+      nbAme: this.actor.system.ame.nbame,
+      ameList: MournbladeCYD2Utility.getAmeList(this.actor.system.ame.nbame),
+      initiative: this.actor.getFlag("world", "last-initiative") || -1,
+      description: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.description, { async: true }),
+      habitat: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.habitat, { async: true }),
+      options: this.options,
+      owner: this.document.isOwner,
+      editScore: this.options.editScore,
+      isGM: game.user.isGM,
+      config: game.system.mournbladecyd2.config
+    }
+    this.formData = formData;
+
+    console.log("PC : ", formData, this.object);
+    return formData;
+  }
+
+  /* -------------------------------------------- */
+  getCelluleTalents() {
+    let talents = []
+    for (let cellule of game.actors) {
+      if (cellule.type == "cellule") {
+        let found = cellule.system.members.find(it => it.id == this.actor.id)
+        if (found) {
+          talents = talents.concat(cellule.getTalents())
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  /** @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")
+      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");
+      MournbladeCYD2Utility.confirmDelete(this, li);
+    })
+    html.find('.edit-item-data').change(ev => {
+      const li = $(ev.currentTarget).parents(".item")
+      let itemId = li.data("item-id")
+      let itemType = li.data("item-type")
+      let itemField = $(ev.currentTarget).data("item-field")
+      let dataType = $(ev.currentTarget).data("dtype")
+      let value = ev.currentTarget.value
+      this.actor.editItemField(itemId, itemType, itemField, dataType, value)
+    })
+
+    html.find('.adversite-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      let adv = li.data("adversite")
+      let value = Number($(event.currentTarget).data("adversite-value"))
+      this.actor.incDecAdversite(adv, value)
+    })
+
+    html.find('.quantity-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      const value = Number($(event.currentTarget).data("quantite-value"))
+      this.actor.incDecQuantity(li.data("item-id"), value);
+    })
+
+    html.find('.roll-initiative').click((event) => {
+      this.actor.rollAttribut("adr", true)
+    })
+
+    html.find('.roll-attribut').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = li.data("attr-key")
+      this.actor.rollAttribut(attrKey, false)
+    })
+    html.find('.roll-competence').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = $(event.currentTarget).data("attr-key")
+      let compId = li.data("item-id")
+      this.actor.rollCompetence(attrKey, compId)
+    })
+    html.find('.roll-arme-offensif').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeOffensif(armeId)
+    })
+
+    html.find('.roll-assommer').click((event) => {
+      this.actor.rollAssommer()
+    })
+    html.find('.roll-coup-bas').click((event) => {
+      this.actor.rollCoupBas()
+    })
+    html.find('.roll-immobiliser').click((event) => {
+      this.actor.rollImmobiliser()
+    })
+    html.find('.roll-repousser').click((event) => {
+      this.actor.rollRepousser()
+    })
+    html.find('.roll-desengager').click((event) => {
+      this.actor.rollDesengager()
+    })
+
+    html.find('.roll-arme-degats').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeDegats(armeId)
+    })
+
+    html.find('.item-add').click((event) => {
+      const itemType = $(event.currentTarget).data("type")
+      this.actor.createEmbeddedDocuments('Item', [{ name: `Nouveau ${itemType}`, type: itemType }], { renderSheet: true })
+    })
+
+    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);
+    });
+
+  }
+
+  /* -------------------------------------------- */
+  /** @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;
+  }
+
+  /* -------------------------------------------- */
+  async _onDropItem(event, dragData) {
+    let data = event.dataTransfer.getData('text/plain')
+    let dataItem = JSON.parse(data)
+    let item = fromUuidSync(dataItem.uuid)
+    if (item.pack) {
+      item = await MournbladeCYD2Utility.searchItem(item)
+    }
+    let autoresult = MournbladeCYD2Automation.processAutomations("on-drop", item, this.actor)
+    if (autoresult.isValid) {
+      super._onDropItem(event, dragData)
+    } else {
+      ui.notifications.warn(autoresult.warningMessage)
+    }
+  }
+
+}

.history/modules/mournblade-cyd2-actor-sheet_20251026082310.js

@@ -0,0 +1,226 @@
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2Automation } from "./mournblade-cyd2-automation.js";
+
+/* -------------------------------------------- */
+export class MournbladeCYD2ActorSheet extends foundry.appv1.sheets.ActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+
+    return foundry.utils.mergeObject(super.defaultOptions, {
+      classes: ["fvtt-mournblade-cyd2", "sheet", "actor"],
+      template: "systems/fvtt-mournblade-cyd2/templates/actor-sheet.html",
+      width: 640,
+      height: 720,
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "stats" }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
+      editScore: false
+    })
+  }
+
+  /* -------------------------------------------- */
+  async getData() {
+    const objectData = foundry.utils.duplicate(this.object)
+
+    let formData = {
+      title: this.title,
+      id: objectData.id,
+      type: objectData.type,
+      img: objectData.img,
+      name: objectData.name,
+      editable: this.isEditable,
+      cssClass: this.isEditable ? "editable" : "locked",
+      system: objectData.system,
+      effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
+      limited: this.object.limited,
+      skills: this.actor.getSkills(),
+      armes: foundry.utils.duplicate(this.actor.getWeapons()),
+      monnaies: foundry.utils.duplicate(this.actor.getMonnaies()),
+      protections: foundry.utils.duplicate(this.actor.getArmors()),
+      historiques: foundry.utils.duplicate(this.actor.getHistoriques() || []),
+      talents: foundry.utils.duplicate(this.actor.getTalents() || []),
+      mutations: foundry.utils.duplicate(this.actor.getMutations() || []),
+      dons: foundry.utils.duplicate(this.actor.getDons() || []),
+      pactes: foundry.utils.duplicate(this.actor.getPactes() || []),
+      tendances: foundry.utils.duplicate(this.actor.getTendances() || []),
+      runes: foundry.utils.duplicate(this.actor.getRunes() || []),
+      traitsChaotiques: foundry.utils.duplicate(this.actor.getTraitsChaotiques() || []),
+      traitsEspeces: foundry.utils.duplicate(this.actor.getTraitsEspeces() || []),
+      aspect: this.actor.getAspect(),
+      marge: this.actor.getMarge(),
+      talentsCell: this.getCelluleTalents(),
+      profils: foundry.utils.duplicate(this.actor.getProfils() || []),
+      combat: this.actor.getCombatValues(),
+      equipements: foundry.utils.duplicate(this.actor.getEquipments()),
+      artefacts: foundry.utils.duplicate(this.actor.getArtefacts()),
+      richesse: this.actor.computeRichesse(),
+      coupDevastateur: this.actor.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup devastateur" && !it.system.used),
+      valeurEquipement: this.actor.computeValeurEquipement(),
+      nbCombativite: this.actor.system.sante.nbcombativite,
+      combativiteList: MournbladeCYD2Utility.getCombativiteList(this.actor.system.sante.nbcombativite),
+      nbAme: this.actor.system.ame.nbame,
+      ameList: MournbladeCYD2Utility.getAmeList(this.actor.system.ame.nbame),
+      initiative: this.actor.getFlag("world", "last-initiative") || -1,
+      description: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.description, { async: true }),
+      habitat: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.habitat, { async: true }),
+      options: this.options,
+      owner: this.document.isOwner,
+      editScore: this.options.editScore,
+      isGM: game.user.isGM,
+      config: game.system.mournbladecyd2.config
+    }
+    this.formData = formData;
+
+    console.log("PC : ", formData, this.object);
+    return formData;
+  }
+
+  /* -------------------------------------------- */
+  getCelluleTalents() {
+    let talents = []
+    for (let cellule of game.actors) {
+      if (cellule.type == "cellule") {
+        let found = cellule.system.members.find(it => it.id == this.actor.id)
+        if (found) {
+          talents = talents.concat(cellule.getTalents())
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  /** @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")
+      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");
+      MournbladeCYD2Utility.confirmDelete(this, li);
+    })
+    html.find('.edit-item-data').change(ev => {
+      const li = $(ev.currentTarget).parents(".item")
+      let itemId = li.data("item-id")
+      let itemType = li.data("item-type")
+      let itemField = $(ev.currentTarget).data("item-field")
+      let dataType = $(ev.currentTarget).data("dtype")
+      let value = ev.currentTarget.value
+      this.actor.editItemField(itemId, itemType, itemField, dataType, value)
+    })
+
+    html.find('.adversite-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      let adv = li.data("adversite")
+      let value = Number($(event.currentTarget).data("adversite-value"))
+      this.actor.incDecAdversite(adv, value)
+    })
+
+    html.find('.quantity-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      const value = Number($(event.currentTarget).data("quantite-value"))
+      this.actor.incDecQuantity(li.data("item-id"), value);
+    })
+
+    html.find('.roll-initiative').click((event) => {
+      this.actor.rollAttribut("adr", true)
+    })
+
+    html.find('.roll-attribut').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = li.data("attr-key")
+      this.actor.rollAttribut(attrKey, false)
+    })
+    html.find('.roll-competence').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = $(event.currentTarget).data("attr-key")
+      let compId = li.data("item-id")
+      this.actor.rollCompetence(attrKey, compId)
+    })
+    html.find('.roll-arme-offensif').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeOffensif(armeId)
+    })
+
+    html.find('.roll-assommer').click((event) => {
+      this.actor.rollAssommer()
+    })
+    html.find('.roll-coup-bas').click((event) => {
+      this.actor.rollCoupBas()
+    })
+    html.find('.roll-immobiliser').click((event) => {
+      this.actor.rollImmobiliser()
+    })
+    html.find('.roll-repousser').click((event) => {
+      this.actor.rollRepousser()
+    })
+    html.find('.roll-desengager').click((event) => {
+      this.actor.rollDesengager()
+    })
+
+    html.find('.roll-arme-degats').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeDegats(armeId)
+    })
+
+    html.find('.item-add').click((event) => {
+      const itemType = $(event.currentTarget).data("type")
+      this.actor.createEmbeddedDocuments('Item', [{ name: `Nouveau ${itemType}`, type: itemType }], { renderSheet: true })
+    })
+
+    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);
+    });
+
+  }
+
+  /* -------------------------------------------- */
+  /** @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;
+  }
+
+  /* -------------------------------------------- */
+  async _onDropItem(event, dragData) {
+    let data = event.dataTransfer.getData('text/plain')
+    let dataItem = JSON.parse(data)
+    let item = fromUuidSync(dataItem.uuid)
+    if (item.pack) {
+      item = await MournbladeCYD2Utility.searchItem(item)
+    }
+    let autoresult = MournbladeCYD2Automation.processAutomations("on-drop", item, this.actor)
+    if (autoresult.isValid) {
+      super._onDropItem(event, dragData)
+    } else {
+      ui.notifications.warn(autoresult.warningMessage)
+    }
+  }
+
+}

.history/modules/mournblade-cyd2-actor-sheet_20251026082630.js

@@ -0,0 +1,227 @@
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2Automation } from "./mournblade-cyd2-automation.js";
+
+/* -------------------------------------------- */
+export class MournbladeCYD2ActorSheet extends foundry.appv1.sheets.ActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+
+    return foundry.utils.mergeObject(super.defaultOptions, {
+      classes: ["fvtt-mournblade-cyd2", "sheet", "actor"],
+      template: "systems/fvtt-mournblade-cyd2/templates/actor-sheet.html",
+      width: 640,
+      height: 720,
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "stats" }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
+      editScore: false
+    })
+  }
+
+  /* -------------------------------------------- */
+  async getData() {
+    const objectData = foundry.utils.duplicate(this.object)
+
+    let formData = {
+      title: this.title,
+      id: objectData.id,
+      type: objectData.type,
+      img: objectData.img,
+      name: objectData.name,
+      editable: this.isEditable,
+      cssClass: this.isEditable ? "editable" : "locked",
+      system: objectData.system,
+      effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
+      limited: this.object.limited,
+      skills: this.actor.getSkills(),
+      armes: foundry.utils.duplicate(this.actor.getWeapons()),
+      monnaies: foundry.utils.duplicate(this.actor.getMonnaies()),
+      protections: foundry.utils.duplicate(this.actor.getArmors()),
+      historiques: foundry.utils.duplicate(this.actor.getHistoriques() || []),
+      talents: foundry.utils.duplicate(this.actor.getTalents() || []),
+      mutations: foundry.utils.duplicate(this.actor.getMutations() || []),
+      dons: foundry.utils.duplicate(this.actor.getDons() || []),
+      pactes: foundry.utils.duplicate(this.actor.getPactes() || []),
+      tendances: foundry.utils.duplicate(this.actor.getTendances() || []),
+      runes: foundry.utils.duplicate(this.actor.getRunes() || []),
+      traitsChaotiques: foundry.utils.duplicate(this.actor.getTraitsChaotiques() || []),
+      traitsEspeces: foundry.utils.duplicate(this.actor.getTraitsEspeces() || []),
+      aspect: this.actor.getAspect(),
+      marge: this.actor.getMarge(),
+      talentsCell: this.getCelluleTalents(),
+      profils: foundry.utils.duplicate(this.actor.getProfils() || []),
+      combat: this.actor.getCombatValues(),
+      equipements: foundry.utils.duplicate(this.actor.getEquipments()),
+      artefacts: foundry.utils.duplicate(this.actor.getArtefacts()),
+      richesse: this.actor.computeRichesse(),
+      coupDevastateur: this.actor.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup devastateur" && !it.system.used),
+      valeurEquipement: this.actor.computeValeurEquipement(),
+      nbCombativite: this.actor.system.sante.nbcombativite,
+      combativiteList: MournbladeCYD2Utility.getCombativiteList(this.actor.system.sante.nbcombativite),
+      nbAme: this.actor.system.ame.nbame,
+      ameMax: this.actor.getAmeMax(),
+      ameList: MournbladeCYD2Utility.getAmeList(this.actor.system.ame.nbame, this.actor.getAmeMax()),
+      initiative: this.actor.getFlag("world", "last-initiative") || -1,
+      description: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.description, { async: true }),
+      habitat: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.habitat, { async: true }),
+      options: this.options,
+      owner: this.document.isOwner,
+      editScore: this.options.editScore,
+      isGM: game.user.isGM,
+      config: game.system.mournbladecyd2.config
+    }
+    this.formData = formData;
+
+    console.log("PC : ", formData, this.object);
+    return formData;
+  }
+
+  /* -------------------------------------------- */
+  getCelluleTalents() {
+    let talents = []
+    for (let cellule of game.actors) {
+      if (cellule.type == "cellule") {
+        let found = cellule.system.members.find(it => it.id == this.actor.id)
+        if (found) {
+          talents = talents.concat(cellule.getTalents())
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  /** @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")
+      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");
+      MournbladeCYD2Utility.confirmDelete(this, li);
+    })
+    html.find('.edit-item-data').change(ev => {
+      const li = $(ev.currentTarget).parents(".item")
+      let itemId = li.data("item-id")
+      let itemType = li.data("item-type")
+      let itemField = $(ev.currentTarget).data("item-field")
+      let dataType = $(ev.currentTarget).data("dtype")
+      let value = ev.currentTarget.value
+      this.actor.editItemField(itemId, itemType, itemField, dataType, value)
+    })
+
+    html.find('.adversite-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      let adv = li.data("adversite")
+      let value = Number($(event.currentTarget).data("adversite-value"))
+      this.actor.incDecAdversite(adv, value)
+    })
+
+    html.find('.quantity-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      const value = Number($(event.currentTarget).data("quantite-value"))
+      this.actor.incDecQuantity(li.data("item-id"), value);
+    })
+
+    html.find('.roll-initiative').click((event) => {
+      this.actor.rollAttribut("adr", true)
+    })
+
+    html.find('.roll-attribut').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = li.data("attr-key")
+      this.actor.rollAttribut(attrKey, false)
+    })
+    html.find('.roll-competence').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = $(event.currentTarget).data("attr-key")
+      let compId = li.data("item-id")
+      this.actor.rollCompetence(attrKey, compId)
+    })
+    html.find('.roll-arme-offensif').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeOffensif(armeId)
+    })
+
+    html.find('.roll-assommer').click((event) => {
+      this.actor.rollAssommer()
+    })
+    html.find('.roll-coup-bas').click((event) => {
+      this.actor.rollCoupBas()
+    })
+    html.find('.roll-immobiliser').click((event) => {
+      this.actor.rollImmobiliser()
+    })
+    html.find('.roll-repousser').click((event) => {
+      this.actor.rollRepousser()
+    })
+    html.find('.roll-desengager').click((event) => {
+      this.actor.rollDesengager()
+    })
+
+    html.find('.roll-arme-degats').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeDegats(armeId)
+    })
+
+    html.find('.item-add').click((event) => {
+      const itemType = $(event.currentTarget).data("type")
+      this.actor.createEmbeddedDocuments('Item', [{ name: `Nouveau ${itemType}`, type: itemType }], { renderSheet: true })
+    })
+
+    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);
+    });
+
+  }
+
+  /* -------------------------------------------- */
+  /** @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;
+  }
+
+  /* -------------------------------------------- */
+  async _onDropItem(event, dragData) {
+    let data = event.dataTransfer.getData('text/plain')
+    let dataItem = JSON.parse(data)
+    let item = fromUuidSync(dataItem.uuid)
+    if (item.pack) {
+      item = await MournbladeCYD2Utility.searchItem(item)
+    }
+    let autoresult = MournbladeCYD2Automation.processAutomations("on-drop", item, this.actor)
+    if (autoresult.isValid) {
+      super._onDropItem(event, dragData)
+    } else {
+      ui.notifications.warn(autoresult.warningMessage)
+    }
+  }
+
+}

.history/modules/mournblade-cyd2-actor-sheet_20251026082724.js

@@ -0,0 +1,227 @@
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2Automation } from "./mournblade-cyd2-automation.js";
+
+/* -------------------------------------------- */
+export class MournbladeCYD2ActorSheet extends foundry.appv1.sheets.ActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+
+    return foundry.utils.mergeObject(super.defaultOptions, {
+      classes: ["fvtt-mournblade-cyd2", "sheet", "actor"],
+      template: "systems/fvtt-mournblade-cyd2/templates/actor-sheet.html",
+      width: 640,
+      height: 720,
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "stats" }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
+      editScore: false
+    })
+  }
+
+  /* -------------------------------------------- */
+  async getData() {
+    const objectData = foundry.utils.duplicate(this.object)
+
+    let formData = {
+      title: this.title,
+      id: objectData.id,
+      type: objectData.type,
+      img: objectData.img,
+      name: objectData.name,
+      editable: this.isEditable,
+      cssClass: this.isEditable ? "editable" : "locked",
+      system: objectData.system,
+      effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
+      limited: this.object.limited,
+      skills: this.actor.getSkills(),
+      armes: foundry.utils.duplicate(this.actor.getWeapons()),
+      monnaies: foundry.utils.duplicate(this.actor.getMonnaies()),
+      protections: foundry.utils.duplicate(this.actor.getArmors()),
+      historiques: foundry.utils.duplicate(this.actor.getHistoriques() || []),
+      talents: foundry.utils.duplicate(this.actor.getTalents() || []),
+      mutations: foundry.utils.duplicate(this.actor.getMutations() || []),
+      dons: foundry.utils.duplicate(this.actor.getDons() || []),
+      pactes: foundry.utils.duplicate(this.actor.getPactes() || []),
+      tendances: foundry.utils.duplicate(this.actor.getTendances() || []),
+      runes: foundry.utils.duplicate(this.actor.getRunes() || []),
+      traitsChaotiques: foundry.utils.duplicate(this.actor.getTraitsChaotiques() || []),
+      traitsEspeces: foundry.utils.duplicate(this.actor.getTraitsEspeces() || []),
+      aspect: this.actor.getAspect(),
+      marge: this.actor.getMarge(),
+      talentsCell: this.getCelluleTalents(),
+      profils: foundry.utils.duplicate(this.actor.getProfils() || []),
+      combat: this.actor.getCombatValues(),
+      equipements: foundry.utils.duplicate(this.actor.getEquipments()),
+      artefacts: foundry.utils.duplicate(this.actor.getArtefacts()),
+      richesse: this.actor.computeRichesse(),
+      coupDevastateur: this.actor.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup devastateur" && !it.system.used),
+      valeurEquipement: this.actor.computeValeurEquipement(),
+      nbCombativite: this.actor.system.sante.nbcombativite,
+      combativiteList: MournbladeCYD2Utility.getCombativiteList(this.actor.system.sante.nbcombativite),
+      nbAme: this.actor.system.ame.nbame,
+      ameMax: this.actor.getAmeMax(),
+      ameList: MournbladeCYD2Utility.getAmeList(this.actor.system.ame.nbame, this.actor.getAmeMax()),
+      initiative: this.actor.getFlag("world", "last-initiative") || -1,
+      description: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.description, { async: true }),
+      habitat: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.habitat, { async: true }),
+      options: this.options,
+      owner: this.document.isOwner,
+      editScore: this.options.editScore,
+      isGM: game.user.isGM,
+      config: game.system.mournbladecyd2.config
+    }
+    this.formData = formData;
+
+    console.log("PC : ", formData, this.object);
+    return formData;
+  }
+
+  /* -------------------------------------------- */
+  getCelluleTalents() {
+    let talents = []
+    for (let cellule of game.actors) {
+      if (cellule.type == "cellule") {
+        let found = cellule.system.members.find(it => it.id == this.actor.id)
+        if (found) {
+          talents = talents.concat(cellule.getTalents())
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  /** @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")
+      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");
+      MournbladeCYD2Utility.confirmDelete(this, li);
+    })
+    html.find('.edit-item-data').change(ev => {
+      const li = $(ev.currentTarget).parents(".item")
+      let itemId = li.data("item-id")
+      let itemType = li.data("item-type")
+      let itemField = $(ev.currentTarget).data("item-field")
+      let dataType = $(ev.currentTarget).data("dtype")
+      let value = ev.currentTarget.value
+      this.actor.editItemField(itemId, itemType, itemField, dataType, value)
+    })
+
+    html.find('.adversite-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      let adv = li.data("adversite")
+      let value = Number($(event.currentTarget).data("adversite-value"))
+      this.actor.incDecAdversite(adv, value)
+    })
+
+    html.find('.quantity-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      const value = Number($(event.currentTarget).data("quantite-value"))
+      this.actor.incDecQuantity(li.data("item-id"), value);
+    })
+
+    html.find('.roll-initiative').click((event) => {
+      this.actor.rollAttribut("adr", true)
+    })
+
+    html.find('.roll-attribut').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = li.data("attr-key")
+      this.actor.rollAttribut(attrKey, false)
+    })
+    html.find('.roll-competence').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = $(event.currentTarget).data("attr-key")
+      let compId = li.data("item-id")
+      this.actor.rollCompetence(attrKey, compId)
+    })
+    html.find('.roll-arme-offensif').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeOffensif(armeId)
+    })
+
+    html.find('.roll-assommer').click((event) => {
+      this.actor.rollAssommer()
+    })
+    html.find('.roll-coup-bas').click((event) => {
+      this.actor.rollCoupBas()
+    })
+    html.find('.roll-immobiliser').click((event) => {
+      this.actor.rollImmobiliser()
+    })
+    html.find('.roll-repousser').click((event) => {
+      this.actor.rollRepousser()
+    })
+    html.find('.roll-desengager').click((event) => {
+      this.actor.rollDesengager()
+    })
+
+    html.find('.roll-arme-degats').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeDegats(armeId)
+    })
+
+    html.find('.item-add').click((event) => {
+      const itemType = $(event.currentTarget).data("type")
+      this.actor.createEmbeddedDocuments('Item', [{ name: `Nouveau ${itemType}`, type: itemType }], { renderSheet: true })
+    })
+
+    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);
+    });
+
+  }
+
+  /* -------------------------------------------- */
+  /** @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;
+  }
+
+  /* -------------------------------------------- */
+  async _onDropItem(event, dragData) {
+    let data = event.dataTransfer.getData('text/plain')
+    let dataItem = JSON.parse(data)
+    let item = fromUuidSync(dataItem.uuid)
+    if (item.pack) {
+      item = await MournbladeCYD2Utility.searchItem(item)
+    }
+    let autoresult = MournbladeCYD2Automation.processAutomations("on-drop", item, this.actor)
+    if (autoresult.isValid) {
+      super._onDropItem(event, dragData)
+    } else {
+      ui.notifications.warn(autoresult.warningMessage)
+    }
+  }
+
+}

.history/modules/mournblade-cyd2-actor-sheet_20251026083617.js

@@ -0,0 +1,228 @@
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2Automation } from "./mournblade-cyd2-automation.js";
+
+/* -------------------------------------------- */
+export class MournbladeCYD2ActorSheet extends foundry.appv1.sheets.ActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+
+    return foundry.utils.mergeObject(super.defaultOptions, {
+      classes: ["fvtt-mournblade-cyd2", "sheet", "actor"],
+      template: "systems/fvtt-mournblade-cyd2/templates/actor-sheet.html",
+      width: 640,
+      height: 720,
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "stats" }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
+      editScore: false
+    })
+  }
+
+  /* -------------------------------------------- */
+  async getData() {
+    const objectData = foundry.utils.duplicate(this.object)
+
+    let formData = {
+      title: this.title,
+      id: objectData.id,
+      type: objectData.type,
+      img: objectData.img,
+      name: objectData.name,
+      editable: this.isEditable,
+      cssClass: this.isEditable ? "editable" : "locked",
+      system: objectData.system,
+      effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
+      limited: this.object.limited,
+      skills: this.actor.getSkills(),
+      armes: foundry.utils.duplicate(this.actor.getWeapons()),
+      monnaies: foundry.utils.duplicate(this.actor.getMonnaies()),
+      protections: foundry.utils.duplicate(this.actor.getArmors()),
+      historiques: foundry.utils.duplicate(this.actor.getHistoriques() || []),
+      talents: foundry.utils.duplicate(this.actor.getTalents() || []),
+      mutations: foundry.utils.duplicate(this.actor.getMutations() || []),
+      dons: foundry.utils.duplicate(this.actor.getDons() || []),
+      pactes: foundry.utils.duplicate(this.actor.getPactes() || []),
+      tendances: foundry.utils.duplicate(this.actor.getTendances() || []),
+      runes: foundry.utils.duplicate(this.actor.getRunes() || []),
+      traitsChaotiques: foundry.utils.duplicate(this.actor.getTraitsChaotiques() || []),
+      traitsEspeces: foundry.utils.duplicate(this.actor.getTraitsEspeces() || []),
+      aspect: this.actor.getAspect(),
+      marge: this.actor.getMarge(),
+      talentsCell: this.getCelluleTalents(),
+      profils: foundry.utils.duplicate(this.actor.getProfils() || []),
+      combat: this.actor.getCombatValues(),
+      equipements: foundry.utils.duplicate(this.actor.getEquipments()),
+      artefacts: foundry.utils.duplicate(this.actor.getArtefacts()),
+      richesse: this.actor.computeRichesse(),
+      coupDevastateur: this.actor.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup devastateur" && !it.system.used),
+      valeurEquipement: this.actor.computeValeurEquipement(),
+      nbCombativite: this.actor.system.sante.nbcombativite,
+      combativiteList: MournbladeCYD2Utility.getCombativiteList(this.actor.system.sante.nbcombativite),
+      nbAme: this.actor.system.ame.nbame,
+      ameMax: this.actor.getAmeMax(),
+      ameList: MournbladeCYD2Utility.getAmeList(this.actor.system.ame.nbame, this.actor.getAmeMax()),
+      ameMaxList: MournbladeCYD2Utility.getAmeMaxList(this.actor.system.ame.nbame),
+      initiative: this.actor.getFlag("world", "last-initiative") || -1,
+      description: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.description, { async: true }),
+      habitat: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.habitat, { async: true }),
+      options: this.options,
+      owner: this.document.isOwner,
+      editScore: this.options.editScore,
+      isGM: game.user.isGM,
+      config: game.system.mournbladecyd2.config
+    }
+    this.formData = formData;
+
+    console.log("PC : ", formData, this.object);
+    return formData;
+  }
+
+  /* -------------------------------------------- */
+  getCelluleTalents() {
+    let talents = []
+    for (let cellule of game.actors) {
+      if (cellule.type == "cellule") {
+        let found = cellule.system.members.find(it => it.id == this.actor.id)
+        if (found) {
+          talents = talents.concat(cellule.getTalents())
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  /** @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")
+      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");
+      MournbladeCYD2Utility.confirmDelete(this, li);
+    })
+    html.find('.edit-item-data').change(ev => {
+      const li = $(ev.currentTarget).parents(".item")
+      let itemId = li.data("item-id")
+      let itemType = li.data("item-type")
+      let itemField = $(ev.currentTarget).data("item-field")
+      let dataType = $(ev.currentTarget).data("dtype")
+      let value = ev.currentTarget.value
+      this.actor.editItemField(itemId, itemType, itemField, dataType, value)
+    })
+
+    html.find('.adversite-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      let adv = li.data("adversite")
+      let value = Number($(event.currentTarget).data("adversite-value"))
+      this.actor.incDecAdversite(adv, value)
+    })
+
+    html.find('.quantity-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      const value = Number($(event.currentTarget).data("quantite-value"))
+      this.actor.incDecQuantity(li.data("item-id"), value);
+    })
+
+    html.find('.roll-initiative').click((event) => {
+      this.actor.rollAttribut("adr", true)
+    })
+
+    html.find('.roll-attribut').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = li.data("attr-key")
+      this.actor.rollAttribut(attrKey, false)
+    })
+    html.find('.roll-competence').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = $(event.currentTarget).data("attr-key")
+      let compId = li.data("item-id")
+      this.actor.rollCompetence(attrKey, compId)
+    })
+    html.find('.roll-arme-offensif').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeOffensif(armeId)
+    })
+
+    html.find('.roll-assommer').click((event) => {
+      this.actor.rollAssommer()
+    })
+    html.find('.roll-coup-bas').click((event) => {
+      this.actor.rollCoupBas()
+    })
+    html.find('.roll-immobiliser').click((event) => {
+      this.actor.rollImmobiliser()
+    })
+    html.find('.roll-repousser').click((event) => {
+      this.actor.rollRepousser()
+    })
+    html.find('.roll-desengager').click((event) => {
+      this.actor.rollDesengager()
+    })
+
+    html.find('.roll-arme-degats').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeDegats(armeId)
+    })
+
+    html.find('.item-add').click((event) => {
+      const itemType = $(event.currentTarget).data("type")
+      this.actor.createEmbeddedDocuments('Item', [{ name: `Nouveau ${itemType}`, type: itemType }], { renderSheet: true })
+    })
+
+    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);
+    });
+
+  }
+
+  /* -------------------------------------------- */
+  /** @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;
+  }
+
+  /* -------------------------------------------- */
+  async _onDropItem(event, dragData) {
+    let data = event.dataTransfer.getData('text/plain')
+    let dataItem = JSON.parse(data)
+    let item = fromUuidSync(dataItem.uuid)
+    if (item.pack) {
+      item = await MournbladeCYD2Utility.searchItem(item)
+    }
+    let autoresult = MournbladeCYD2Automation.processAutomations("on-drop", item, this.actor)
+    if (autoresult.isValid) {
+      super._onDropItem(event, dragData)
+    } else {
+      ui.notifications.warn(autoresult.warningMessage)
+    }
+  }
+
+}

.history/modules/mournblade-cyd2-actor-sheet_20251026083658.js

@@ -0,0 +1,228 @@
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2Automation } from "./mournblade-cyd2-automation.js";
+
+/* -------------------------------------------- */
+export class MournbladeCYD2ActorSheet extends foundry.appv1.sheets.ActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+
+    return foundry.utils.mergeObject(super.defaultOptions, {
+      classes: ["fvtt-mournblade-cyd2", "sheet", "actor"],
+      template: "systems/fvtt-mournblade-cyd2/templates/actor-sheet.html",
+      width: 640,
+      height: 720,
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "stats" }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
+      editScore: false
+    })
+  }
+
+  /* -------------------------------------------- */
+  async getData() {
+    const objectData = foundry.utils.duplicate(this.object)
+
+    let formData = {
+      title: this.title,
+      id: objectData.id,
+      type: objectData.type,
+      img: objectData.img,
+      name: objectData.name,
+      editable: this.isEditable,
+      cssClass: this.isEditable ? "editable" : "locked",
+      system: objectData.system,
+      effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
+      limited: this.object.limited,
+      skills: this.actor.getSkills(),
+      armes: foundry.utils.duplicate(this.actor.getWeapons()),
+      monnaies: foundry.utils.duplicate(this.actor.getMonnaies()),
+      protections: foundry.utils.duplicate(this.actor.getArmors()),
+      historiques: foundry.utils.duplicate(this.actor.getHistoriques() || []),
+      talents: foundry.utils.duplicate(this.actor.getTalents() || []),
+      mutations: foundry.utils.duplicate(this.actor.getMutations() || []),
+      dons: foundry.utils.duplicate(this.actor.getDons() || []),
+      pactes: foundry.utils.duplicate(this.actor.getPactes() || []),
+      tendances: foundry.utils.duplicate(this.actor.getTendances() || []),
+      runes: foundry.utils.duplicate(this.actor.getRunes() || []),
+      traitsChaotiques: foundry.utils.duplicate(this.actor.getTraitsChaotiques() || []),
+      traitsEspeces: foundry.utils.duplicate(this.actor.getTraitsEspeces() || []),
+      aspect: this.actor.getAspect(),
+      marge: this.actor.getMarge(),
+      talentsCell: this.getCelluleTalents(),
+      profils: foundry.utils.duplicate(this.actor.getProfils() || []),
+      combat: this.actor.getCombatValues(),
+      equipements: foundry.utils.duplicate(this.actor.getEquipments()),
+      artefacts: foundry.utils.duplicate(this.actor.getArtefacts()),
+      richesse: this.actor.computeRichesse(),
+      coupDevastateur: this.actor.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup devastateur" && !it.system.used),
+      valeurEquipement: this.actor.computeValeurEquipement(),
+      nbCombativite: this.actor.system.sante.nbcombativite,
+      combativiteList: MournbladeCYD2Utility.getCombativiteList(this.actor.system.sante.nbcombativite),
+      nbAme: this.actor.system.ame.nbame,
+      ameMax: this.actor.getAmeMax(),
+      ameList: MournbladeCYD2Utility.getAmeList(this.actor.system.ame.nbame, this.actor.getAmeMax()),
+      ameMaxList: MournbladeCYD2Utility.getAmeMaxList(this.actor.system.ame.nbame),
+      initiative: this.actor.getFlag("world", "last-initiative") || -1,
+      description: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.description, { async: true }),
+      habitat: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.habitat, { async: true }),
+      options: this.options,
+      owner: this.document.isOwner,
+      editScore: this.options.editScore,
+      isGM: game.user.isGM,
+      config: game.system.mournbladecyd2.config
+    }
+    this.formData = formData;
+
+    console.log("PC : ", formData, this.object);
+    return formData;
+  }
+
+  /* -------------------------------------------- */
+  getCelluleTalents() {
+    let talents = []
+    for (let cellule of game.actors) {
+      if (cellule.type == "cellule") {
+        let found = cellule.system.members.find(it => it.id == this.actor.id)
+        if (found) {
+          talents = talents.concat(cellule.getTalents())
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  /** @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")
+      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");
+      MournbladeCYD2Utility.confirmDelete(this, li);
+    })
+    html.find('.edit-item-data').change(ev => {
+      const li = $(ev.currentTarget).parents(".item")
+      let itemId = li.data("item-id")
+      let itemType = li.data("item-type")
+      let itemField = $(ev.currentTarget).data("item-field")
+      let dataType = $(ev.currentTarget).data("dtype")
+      let value = ev.currentTarget.value
+      this.actor.editItemField(itemId, itemType, itemField, dataType, value)
+    })
+
+    html.find('.adversite-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      let adv = li.data("adversite")
+      let value = Number($(event.currentTarget).data("adversite-value"))
+      this.actor.incDecAdversite(adv, value)
+    })
+
+    html.find('.quantity-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      const value = Number($(event.currentTarget).data("quantite-value"))
+      this.actor.incDecQuantity(li.data("item-id"), value);
+    })
+
+    html.find('.roll-initiative').click((event) => {
+      this.actor.rollAttribut("adr", true)
+    })
+
+    html.find('.roll-attribut').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = li.data("attr-key")
+      this.actor.rollAttribut(attrKey, false)
+    })
+    html.find('.roll-competence').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = $(event.currentTarget).data("attr-key")
+      let compId = li.data("item-id")
+      this.actor.rollCompetence(attrKey, compId)
+    })
+    html.find('.roll-arme-offensif').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeOffensif(armeId)
+    })
+
+    html.find('.roll-assommer').click((event) => {
+      this.actor.rollAssommer()
+    })
+    html.find('.roll-coup-bas').click((event) => {
+      this.actor.rollCoupBas()
+    })
+    html.find('.roll-immobiliser').click((event) => {
+      this.actor.rollImmobiliser()
+    })
+    html.find('.roll-repousser').click((event) => {
+      this.actor.rollRepousser()
+    })
+    html.find('.roll-desengager').click((event) => {
+      this.actor.rollDesengager()
+    })
+
+    html.find('.roll-arme-degats').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeDegats(armeId)
+    })
+
+    html.find('.item-add').click((event) => {
+      const itemType = $(event.currentTarget).data("type")
+      this.actor.createEmbeddedDocuments('Item', [{ name: `Nouveau ${itemType}`, type: itemType }], { renderSheet: true })
+    })
+
+    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);
+    });
+
+  }
+
+  /* -------------------------------------------- */
+  /** @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;
+  }
+
+  /* -------------------------------------------- */
+  async _onDropItem(event, dragData) {
+    let data = event.dataTransfer.getData('text/plain')
+    let dataItem = JSON.parse(data)
+    let item = fromUuidSync(dataItem.uuid)
+    if (item.pack) {
+      item = await MournbladeCYD2Utility.searchItem(item)
+    }
+    let autoresult = MournbladeCYD2Automation.processAutomations("on-drop", item, this.actor)
+    if (autoresult.isValid) {
+      super._onDropItem(event, dragData)
+    } else {
+      ui.notifications.warn(autoresult.warningMessage)
+    }
+  }
+
+}

.history/modules/mournblade-cyd2-actor-sheet_20251026095818.js

@@ -0,0 +1,227 @@
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2Automation } from "./mournblade-cyd2-automation.js";
+
+/* -------------------------------------------- */
+export class MournbladeCYD2ActorSheet extends foundry.appv1.sheets.ActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+
+    return foundry.utils.mergeObject(super.defaultOptions, {
+      classes: ["fvtt-mournblade-cyd2", "sheet", "actor"],
+      template: "systems/fvtt-mournblade-cyd2/templates/actor-sheet.html",
+      width: 640,
+      height: 720,
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "stats" }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
+      editScore: false
+    })
+  }
+
+  /* -------------------------------------------- */
+  async getData() {
+    const objectData = foundry.utils.duplicate(this.object)
+
+    let formData = {
+      title: this.title,
+      id: objectData.id,
+      type: objectData.type,
+      img: objectData.img,
+      name: objectData.name,
+      editable: this.isEditable,
+      cssClass: this.isEditable ? "editable" : "locked",
+      system: objectData.system,
+      effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
+      limited: this.object.limited,
+      skills: this.actor.getSkills(),
+      armes: foundry.utils.duplicate(this.actor.getWeapons()),
+      monnaies: foundry.utils.duplicate(this.actor.getMonnaies()),
+      protections: foundry.utils.duplicate(this.actor.getArmors()),
+      historiques: foundry.utils.duplicate(this.actor.getHistoriques() || []),
+      talents: foundry.utils.duplicate(this.actor.getTalents() || []),
+      mutations: foundry.utils.duplicate(this.actor.getMutations() || []),
+      dons: foundry.utils.duplicate(this.actor.getDons() || []),
+      pactes: foundry.utils.duplicate(this.actor.getPactes() || []),
+      tendances: foundry.utils.duplicate(this.actor.getTendances() || []),
+      runes: foundry.utils.duplicate(this.actor.getRunes() || []),
+      traitsChaotiques: foundry.utils.duplicate(this.actor.getTraitsChaotiques() || []),
+      traitsEspeces: foundry.utils.duplicate(this.actor.getTraitsEspeces() || []),
+      aspect: this.actor.getAspect(),
+      marge: this.actor.getMarge(),
+      profils: foundry.utils.duplicate(this.actor.getProfils() || []),
+      combat: this.actor.getCombatValues(),
+      equipements: foundry.utils.duplicate(this.actor.getEquipments()),
+      artefacts: foundry.utils.duplicate(this.actor.getArtefacts()),
+      richesse: this.actor.computeRichesse(),
+      coupDevastateur: this.actor.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup devastateur" && !it.system.used),
+      valeurEquipement: this.actor.computeValeurEquipement(),
+      nbCombativite: this.actor.system.sante.nbcombativite,
+      combativiteList: MournbladeCYD2Utility.getCombativiteList(this.actor.system.sante.nbcombativite),
+      nbAme: this.actor.system.ame.nbame,
+      ameMax: this.actor.getAmeMax(),
+      ameList: MournbladeCYD2Utility.getAmeList(this.actor.system.ame.nbame, this.actor.getAmeMax()),
+      ameMaxList: MournbladeCYD2Utility.getAmeMaxList(this.actor.system.ame.nbame),
+      initiative: this.actor.getFlag("world", "last-initiative") || -1,
+      description: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.description, { async: true }),
+      habitat: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.habitat, { async: true }),
+      options: this.options,
+      owner: this.document.isOwner,
+      editScore: this.options.editScore,
+      isGM: game.user.isGM,
+      config: game.system.mournbladecyd2.config
+    }
+    this.formData = formData;
+
+    console.log("PC : ", formData, this.object);
+    return formData;
+  }
+
+  /* -------------------------------------------- */
+  getCelluleTalents() {
+    let talents = []
+    for (let cellule of game.actors) {
+      if (cellule.type == "cellule") {
+        let found = cellule.system.members.find(it => it.id == this.actor.id)
+        if (found) {
+          talents = talents.concat(cellule.getTalents())
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  /** @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")
+      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");
+      MournbladeCYD2Utility.confirmDelete(this, li);
+    })
+    html.find('.edit-item-data').change(ev => {
+      const li = $(ev.currentTarget).parents(".item")
+      let itemId = li.data("item-id")
+      let itemType = li.data("item-type")
+      let itemField = $(ev.currentTarget).data("item-field")
+      let dataType = $(ev.currentTarget).data("dtype")
+      let value = ev.currentTarget.value
+      this.actor.editItemField(itemId, itemType, itemField, dataType, value)
+    })
+
+    html.find('.adversite-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      let adv = li.data("adversite")
+      let value = Number($(event.currentTarget).data("adversite-value"))
+      this.actor.incDecAdversite(adv, value)
+    })
+
+    html.find('.quantity-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      const value = Number($(event.currentTarget).data("quantite-value"))
+      this.actor.incDecQuantity(li.data("item-id"), value);
+    })
+
+    html.find('.roll-initiative').click((event) => {
+      this.actor.rollAttribut("adr", true)
+    })
+
+    html.find('.roll-attribut').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = li.data("attr-key")
+      this.actor.rollAttribut(attrKey, false)
+    })
+    html.find('.roll-competence').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = $(event.currentTarget).data("attr-key")
+      let compId = li.data("item-id")
+      this.actor.rollCompetence(attrKey, compId)
+    })
+    html.find('.roll-arme-offensif').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeOffensif(armeId)
+    })
+
+    html.find('.roll-assommer').click((event) => {
+      this.actor.rollAssommer()
+    })
+    html.find('.roll-coup-bas').click((event) => {
+      this.actor.rollCoupBas()
+    })
+    html.find('.roll-immobiliser').click((event) => {
+      this.actor.rollImmobiliser()
+    })
+    html.find('.roll-repousser').click((event) => {
+      this.actor.rollRepousser()
+    })
+    html.find('.roll-desengager').click((event) => {
+      this.actor.rollDesengager()
+    })
+
+    html.find('.roll-arme-degats').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeDegats(armeId)
+    })
+
+    html.find('.item-add').click((event) => {
+      const itemType = $(event.currentTarget).data("type")
+      this.actor.createEmbeddedDocuments('Item', [{ name: `Nouveau ${itemType}`, type: itemType }], { renderSheet: true })
+    })
+
+    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);
+    });
+
+  }
+
+  /* -------------------------------------------- */
+  /** @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;
+  }
+
+  /* -------------------------------------------- */
+  async _onDropItem(event, dragData) {
+    let data = event.dataTransfer.getData('text/plain')
+    let dataItem = JSON.parse(data)
+    let item = fromUuidSync(dataItem.uuid)
+    if (item.pack) {
+      item = await MournbladeCYD2Utility.searchItem(item)
+    }
+    let autoresult = MournbladeCYD2Automation.processAutomations("on-drop", item, this.actor)
+    if (autoresult.isValid) {
+      super._onDropItem(event, dragData)
+    } else {
+      ui.notifications.warn(autoresult.warningMessage)
+    }
+  }
+
+}

.history/modules/mournblade-cyd2-actor-sheet_20251026095829.js

@@ -0,0 +1,213 @@
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2Automation } from "./mournblade-cyd2-automation.js";
+
+/* -------------------------------------------- */
+export class MournbladeCYD2ActorSheet extends foundry.appv1.sheets.ActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+
+    return foundry.utils.mergeObject(super.defaultOptions, {
+      classes: ["fvtt-mournblade-cyd2", "sheet", "actor"],
+      template: "systems/fvtt-mournblade-cyd2/templates/actor-sheet.html",
+      width: 640,
+      height: 720,
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "stats" }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
+      editScore: false
+    })
+  }
+
+  /* -------------------------------------------- */
+  async getData() {
+    const objectData = foundry.utils.duplicate(this.object)
+
+    let formData = {
+      title: this.title,
+      id: objectData.id,
+      type: objectData.type,
+      img: objectData.img,
+      name: objectData.name,
+      editable: this.isEditable,
+      cssClass: this.isEditable ? "editable" : "locked",
+      system: objectData.system,
+      effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
+      limited: this.object.limited,
+      skills: this.actor.getSkills(),
+      armes: foundry.utils.duplicate(this.actor.getWeapons()),
+      monnaies: foundry.utils.duplicate(this.actor.getMonnaies()),
+      protections: foundry.utils.duplicate(this.actor.getArmors()),
+      historiques: foundry.utils.duplicate(this.actor.getHistoriques() || []),
+      talents: foundry.utils.duplicate(this.actor.getTalents() || []),
+      mutations: foundry.utils.duplicate(this.actor.getMutations() || []),
+      dons: foundry.utils.duplicate(this.actor.getDons() || []),
+      pactes: foundry.utils.duplicate(this.actor.getPactes() || []),
+      tendances: foundry.utils.duplicate(this.actor.getTendances() || []),
+      runes: foundry.utils.duplicate(this.actor.getRunes() || []),
+      traitsChaotiques: foundry.utils.duplicate(this.actor.getTraitsChaotiques() || []),
+      traitsEspeces: foundry.utils.duplicate(this.actor.getTraitsEspeces() || []),
+      aspect: this.actor.getAspect(),
+      marge: this.actor.getMarge(),
+      profils: foundry.utils.duplicate(this.actor.getProfils() || []),
+      combat: this.actor.getCombatValues(),
+      equipements: foundry.utils.duplicate(this.actor.getEquipments()),
+      artefacts: foundry.utils.duplicate(this.actor.getArtefacts()),
+      richesse: this.actor.computeRichesse(),
+      coupDevastateur: this.actor.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup devastateur" && !it.system.used),
+      valeurEquipement: this.actor.computeValeurEquipement(),
+      nbCombativite: this.actor.system.sante.nbcombativite,
+      combativiteList: MournbladeCYD2Utility.getCombativiteList(this.actor.system.sante.nbcombativite),
+      nbAme: this.actor.system.ame.nbame,
+      ameMax: this.actor.getAmeMax(),
+      ameList: MournbladeCYD2Utility.getAmeList(this.actor.system.ame.nbame, this.actor.getAmeMax()),
+      ameMaxList: MournbladeCYD2Utility.getAmeMaxList(this.actor.system.ame.nbame),
+      initiative: this.actor.getFlag("world", "last-initiative") || -1,
+      description: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.description, { async: true }),
+      habitat: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.habitat, { async: true }),
+      options: this.options,
+      owner: this.document.isOwner,
+      editScore: this.options.editScore,
+      isGM: game.user.isGM,
+      config: game.system.mournbladecyd2.config
+    }
+    this.formData = formData;
+
+    console.log("PC : ", formData, this.object);
+    return formData;
+  }
+
+  /* -------------------------------------------- */
+  /** @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")
+      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");
+      MournbladeCYD2Utility.confirmDelete(this, li);
+    })
+    html.find('.edit-item-data').change(ev => {
+      const li = $(ev.currentTarget).parents(".item")
+      let itemId = li.data("item-id")
+      let itemType = li.data("item-type")
+      let itemField = $(ev.currentTarget).data("item-field")
+      let dataType = $(ev.currentTarget).data("dtype")
+      let value = ev.currentTarget.value
+      this.actor.editItemField(itemId, itemType, itemField, dataType, value)
+    })
+
+    html.find('.adversite-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      let adv = li.data("adversite")
+      let value = Number($(event.currentTarget).data("adversite-value"))
+      this.actor.incDecAdversite(adv, value)
+    })
+
+    html.find('.quantity-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      const value = Number($(event.currentTarget).data("quantite-value"))
+      this.actor.incDecQuantity(li.data("item-id"), value);
+    })
+
+    html.find('.roll-initiative').click((event) => {
+      this.actor.rollAttribut("adr", true)
+    })
+
+    html.find('.roll-attribut').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = li.data("attr-key")
+      this.actor.rollAttribut(attrKey, false)
+    })
+    html.find('.roll-competence').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = $(event.currentTarget).data("attr-key")
+      let compId = li.data("item-id")
+      this.actor.rollCompetence(attrKey, compId)
+    })
+    html.find('.roll-arme-offensif').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeOffensif(armeId)
+    })
+
+    html.find('.roll-assommer').click((event) => {
+      this.actor.rollAssommer()
+    })
+    html.find('.roll-coup-bas').click((event) => {
+      this.actor.rollCoupBas()
+    })
+    html.find('.roll-immobiliser').click((event) => {
+      this.actor.rollImmobiliser()
+    })
+    html.find('.roll-repousser').click((event) => {
+      this.actor.rollRepousser()
+    })
+    html.find('.roll-desengager').click((event) => {
+      this.actor.rollDesengager()
+    })
+
+    html.find('.roll-arme-degats').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeDegats(armeId)
+    })
+
+    html.find('.item-add').click((event) => {
+      const itemType = $(event.currentTarget).data("type")
+      this.actor.createEmbeddedDocuments('Item', [{ name: `Nouveau ${itemType}`, type: itemType }], { renderSheet: true })
+    })
+
+    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);
+    });
+
+  }
+
+  /* -------------------------------------------- */
+  /** @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;
+  }
+
+  /* -------------------------------------------- */
+  async _onDropItem(event, dragData) {
+    let data = event.dataTransfer.getData('text/plain')
+    let dataItem = JSON.parse(data)
+    let item = fromUuidSync(dataItem.uuid)
+    if (item.pack) {
+      item = await MournbladeCYD2Utility.searchItem(item)
+    }
+    let autoresult = MournbladeCYD2Automation.processAutomations("on-drop", item, this.actor)
+    if (autoresult.isValid) {
+      super._onDropItem(event, dragData)
+    } else {
+      ui.notifications.warn(autoresult.warningMessage)
+    }
+  }
+
+}

.history/modules/mournblade-cyd2-actor-sheet_20251026100139.js

@@ -0,0 +1,213 @@
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2Automation } from "./mournblade-cyd2-automation.js";
+
+/* -------------------------------------------- */
+export class MournbladeCYD2ActorSheet extends foundry.appv1.sheets.ActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+
+    return foundry.utils.mergeObject(super.defaultOptions, {
+      classes: ["fvtt-mournblade-cyd2", "sheet", "actor"],
+      template: "systems/fvtt-mournblade-cyd2/templates/actor-sheet.html",
+      width: 640,
+      height: 720,
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "stats" }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
+      editScore: false
+    })
+  }
+
+  /* -------------------------------------------- */
+  async getData() {
+    const objectData = foundry.utils.duplicate(this.object)
+
+    let formData = {
+      title: this.title,
+      id: objectData.id,
+      type: objectData.type,
+      img: objectData.img,
+      name: objectData.name,
+      editable: this.isEditable,
+      cssClass: this.isEditable ? "editable" : "locked",
+      system: objectData.system,
+      effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
+      limited: this.object.limited,
+      skills: this.actor.getSkills(),
+      armes: foundry.utils.duplicate(this.actor.getWeapons()),
+      monnaies: foundry.utils.duplicate(this.actor.getMonnaies()),
+      protections: foundry.utils.duplicate(this.actor.getArmors()),
+      historiques: foundry.utils.duplicate(this.actor.getHistoriques() || []),
+      talents: foundry.utils.duplicate(this.actor.getTalents() || []),
+      mutations: foundry.utils.duplicate(this.actor.getMutations() || []),
+      dons: foundry.utils.duplicate(this.actor.getDons() || []),
+      pactes: foundry.utils.duplicate(this.actor.getPactes() || []),
+      tendances: foundry.utils.duplicate(this.actor.getTendances() || []),
+      runes: foundry.utils.duplicate(this.actor.getRunes() || []),
+      traitsChaotiques: foundry.utils.duplicate(this.actor.getTraitsChaotiques() || []),
+      traitsEspeces: foundry.utils.duplicate(this.actor.getTraitsEspeces() || []),
+      aspect: this.actor.getAspect(),
+      marge: this.actor.getMarge(),
+      profils: foundry.utils.duplicate(this.actor.getProfils() || []),
+      combat: this.actor.getCombatValues(),
+      equipements: foundry.utils.duplicate(this.actor.getEquipments()),
+      artefacts: foundry.utils.duplicate(this.actor.getArtefacts()),
+      richesse: this.actor.computeRichesse(),
+      coupDevastateur: this.actor.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup devastateur" && !it.system.used),
+      valeurEquipement: this.actor.computeValeurEquipement(),
+      nbCombativite: this.actor.system.sante.nbcombativite,
+      combativiteList: MournbladeCYD2Utility.getCombativiteList(this.actor.system.sante.nbcombativite),
+      nbAme: this.actor.system.ame.nbame,
+      ameMax: this.actor.getAmeMax(),
+      ameList: MournbladeCYD2Utility.getAmeList(this.actor.system.ame.nbame, this.actor.getAmeMax()),
+      ameMaxList: MournbladeCYD2Utility.getAmeMaxList(this.actor.system.ame.nbame),
+      initiative: this.actor.getFlag("world", "last-initiative") || -1,
+      description: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.description, { async: true }),
+      habitat: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.habitat, { async: true }),
+      options: this.options,
+      owner: this.document.isOwner,
+      editScore: this.options.editScore,
+      isGM: game.user.isGM,
+      config: game.system.mournbladecyd2.config
+    }
+    this.formData = formData;
+
+    console.log("PC : ", formData, this.object);
+    return formData;
+  }
+
+  /* -------------------------------------------- */
+  /** @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")
+      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");
+      MournbladeCYD2Utility.confirmDelete(this, li);
+    })
+    html.find('.edit-item-data').change(ev => {
+      const li = $(ev.currentTarget).parents(".item")
+      let itemId = li.data("item-id")
+      let itemType = li.data("item-type")
+      let itemField = $(ev.currentTarget).data("item-field")
+      let dataType = $(ev.currentTarget).data("dtype")
+      let value = ev.currentTarget.value
+      this.actor.editItemField(itemId, itemType, itemField, dataType, value)
+    })
+
+    html.find('.adversite-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      let adv = li.data("adversite")
+      let value = Number($(event.currentTarget).data("adversite-value"))
+      this.actor.incDecAdversite(adv, value)
+    })
+
+    html.find('.quantity-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      const value = Number($(event.currentTarget).data("quantite-value"))
+      this.actor.incDecQuantity(li.data("item-id"), value);
+    })
+
+    html.find('.roll-initiative').click((event) => {
+      this.actor.rollAttribut("adr", true)
+    })
+
+    html.find('.roll-attribut').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = li.data("attr-key")
+      this.actor.rollAttribut(attrKey, false)
+    })
+    html.find('.roll-competence').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = $(event.currentTarget).data("attr-key")
+      let compId = li.data("item-id")
+      this.actor.rollCompetence(attrKey, compId)
+    })
+    html.find('.roll-arme-offensif').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeOffensif(armeId)
+    })
+
+    html.find('.roll-assommer').click((event) => {
+      this.actor.rollAssommer()
+    })
+    html.find('.roll-coup-bas').click((event) => {
+      this.actor.rollCoupBas()
+    })
+    html.find('.roll-immobiliser').click((event) => {
+      this.actor.rollImmobiliser()
+    })
+    html.find('.roll-repousser').click((event) => {
+      this.actor.rollRepousser()
+    })
+    html.find('.roll-desengager').click((event) => {
+      this.actor.rollDesengager()
+    })
+
+    html.find('.roll-arme-degats').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeDegats(armeId)
+    })
+
+    html.find('.item-add').click((event) => {
+      const itemType = $(event.currentTarget).data("type")
+      this.actor.createEmbeddedDocuments('Item', [{ name: `Nouveau ${itemType}`, type: itemType }], { renderSheet: true })
+    })
+
+    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);
+    });
+
+  }
+
+  /* -------------------------------------------- */
+  /** @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;
+  }
+
+  /* -------------------------------------------- */
+  async _onDropItem(event, dragData) {
+    let data = event.dataTransfer.getData('text/plain')
+    let dataItem = JSON.parse(data)
+    let item = fromUuidSync(dataItem.uuid)
+    if (item.pack) {
+      item = await MournbladeCYD2Utility.searchItem(item)
+    }
+    let autoresult = MournbladeCYD2Automation.processAutomations("on-drop", item, this.actor)
+    if (autoresult.isValid) {
+      super._onDropItem(event, dragData)
+    } else {
+      ui.notifications.warn(autoresult.warningMessage)
+    }
+  }
+
+}

.history/modules/mournblade-cyd2-actor-sheet_20251026132141.js

@@ -0,0 +1,212 @@
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2Automation } from "./mournblade-cyd2-automation.js";
+
+/* -------------------------------------------- */
+export class MournbladeCYD2ActorSheet extends foundry.appv1.sheets.ActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+
+    return foundry.utils.mergeObject(super.defaultOptions, {
+      classes: ["fvtt-mournblade-cyd2", "sheet", "actor"],
+      template: "systems/fvtt-mournblade-cyd2/templates/actor-sheet.html",
+      width: 640,
+      height: 720,
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "stats" }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
+      editScore: false
+    })
+  }
+
+  /* -------------------------------------------- */
+  async getData() {
+    const objectData = foundry.utils.duplicate(this.object)
+
+    let formData = {
+      title: this.title,
+      id: objectData.id,
+      type: objectData.type,
+      img: objectData.img,
+      name: objectData.name,
+      editable: this.isEditable,
+      cssClass: this.isEditable ? "editable" : "locked",
+      system: objectData.system,
+      effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
+      limited: this.object.limited,
+      skills: this.actor.getSkills(),
+      armes: foundry.utils.duplicate(this.actor.getWeapons()),
+      monnaies: foundry.utils.duplicate(this.actor.getMonnaies()),
+      protections: foundry.utils.duplicate(this.actor.getArmors()),
+      historiques: foundry.utils.duplicate(this.actor.getHistoriques() || []),
+      talents: foundry.utils.duplicate(this.actor.getTalents() || []),
+      mutations: foundry.utils.duplicate(this.actor.getMutations() || []),
+      dons: foundry.utils.duplicate(this.actor.getDons() || []),
+      pactes: foundry.utils.duplicate(this.actor.getPactes() || []),
+      tendances: foundry.utils.duplicate(this.actor.getTendances() || []),
+      runes: foundry.utils.duplicate(this.actor.getRunes() || []),
+      traitsChaotiques: foundry.utils.duplicate(this.actor.getTraitsChaotiques() || []),
+      traitsEspeces: foundry.utils.duplicate(this.actor.getTraitsEspeces() || []),
+      aspect: this.actor.getAspect(),
+      marge: this.actor.getMarge(),
+      profils: foundry.utils.duplicate(this.actor.getProfils() || []),
+      combat: this.actor.getCombatValues(),
+      equipements: foundry.utils.duplicate(this.actor.getEquipments()),
+      richesse: this.actor.computeRichesse(),
+      coupDevastateur: this.actor.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup devastateur" && !it.system.used),
+      valeurEquipement: this.actor.computeValeurEquipement(),
+      nbCombativite: this.actor.system.sante.nbcombativite,
+      combativiteList: MournbladeCYD2Utility.getCombativiteList(this.actor.system.sante.nbcombativite),
+      nbAme: this.actor.system.ame.nbame,
+      ameMax: this.actor.getAmeMax(),
+      ameList: MournbladeCYD2Utility.getAmeList(this.actor.system.ame.nbame, this.actor.getAmeMax()),
+      ameMaxList: MournbladeCYD2Utility.getAmeMaxList(this.actor.system.ame.nbame),
+      initiative: this.actor.getFlag("world", "last-initiative") || -1,
+      description: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.description, { async: true }),
+      habitat: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.habitat, { async: true }),
+      options: this.options,
+      owner: this.document.isOwner,
+      editScore: this.options.editScore,
+      isGM: game.user.isGM,
+      config: game.system.mournbladecyd2.config
+    }
+    this.formData = formData;
+
+    console.log("PC : ", formData, this.object);
+    return formData;
+  }
+
+  /* -------------------------------------------- */
+  /** @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")
+      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");
+      MournbladeCYD2Utility.confirmDelete(this, li);
+    })
+    html.find('.edit-item-data').change(ev => {
+      const li = $(ev.currentTarget).parents(".item")
+      let itemId = li.data("item-id")
+      let itemType = li.data("item-type")
+      let itemField = $(ev.currentTarget).data("item-field")
+      let dataType = $(ev.currentTarget).data("dtype")
+      let value = ev.currentTarget.value
+      this.actor.editItemField(itemId, itemType, itemField, dataType, value)
+    })
+
+    html.find('.adversite-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      let adv = li.data("adversite")
+      let value = Number($(event.currentTarget).data("adversite-value"))
+      this.actor.incDecAdversite(adv, value)
+    })
+
+    html.find('.quantity-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      const value = Number($(event.currentTarget).data("quantite-value"))
+      this.actor.incDecQuantity(li.data("item-id"), value);
+    })
+
+    html.find('.roll-initiative').click((event) => {
+      this.actor.rollAttribut("adr", true)
+    })
+
+    html.find('.roll-attribut').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = li.data("attr-key")
+      this.actor.rollAttribut(attrKey, false)
+    })
+    html.find('.roll-competence').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = $(event.currentTarget).data("attr-key")
+      let compId = li.data("item-id")
+      this.actor.rollCompetence(attrKey, compId)
+    })
+    html.find('.roll-arme-offensif').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeOffensif(armeId)
+    })
+
+    html.find('.roll-assommer').click((event) => {
+      this.actor.rollAssommer()
+    })
+    html.find('.roll-coup-bas').click((event) => {
+      this.actor.rollCoupBas()
+    })
+    html.find('.roll-immobiliser').click((event) => {
+      this.actor.rollImmobiliser()
+    })
+    html.find('.roll-repousser').click((event) => {
+      this.actor.rollRepousser()
+    })
+    html.find('.roll-desengager').click((event) => {
+      this.actor.rollDesengager()
+    })
+
+    html.find('.roll-arme-degats').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeDegats(armeId)
+    })
+
+    html.find('.item-add').click((event) => {
+      const itemType = $(event.currentTarget).data("type")
+      this.actor.createEmbeddedDocuments('Item', [{ name: `Nouveau ${itemType}`, type: itemType }], { renderSheet: true })
+    })
+
+    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);
+    });
+
+  }
+
+  /* -------------------------------------------- */
+  /** @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;
+  }
+
+  /* -------------------------------------------- */
+  async _onDropItem(event, dragData) {
+    let data = event.dataTransfer.getData('text/plain')
+    let dataItem = JSON.parse(data)
+    let item = fromUuidSync(dataItem.uuid)
+    if (item.pack) {
+      item = await MournbladeCYD2Utility.searchItem(item)
+    }
+    let autoresult = MournbladeCYD2Automation.processAutomations("on-drop", item, this.actor)
+    if (autoresult.isValid) {
+      super._onDropItem(event, dragData)
+    } else {
+      ui.notifications.warn(autoresult.warningMessage)
+    }
+  }
+
+}

.history/modules/mournblade-cyd2-actor-sheet_20251026132457.js

@@ -0,0 +1,212 @@
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2Automation } from "./mournblade-cyd2-automation.js";
+
+/* -------------------------------------------- */
+export class MournbladeCYD2ActorSheet extends foundry.appv1.sheets.ActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+
+    return foundry.utils.mergeObject(super.defaultOptions, {
+      classes: ["fvtt-mournblade-cyd2", "sheet", "actor"],
+      template: "systems/fvtt-mournblade-cyd2/templates/actor-sheet.html",
+      width: 640,
+      height: 720,
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "stats" }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
+      editScore: false
+    })
+  }
+
+  /* -------------------------------------------- */
+  async getData() {
+    const objectData = foundry.utils.duplicate(this.object)
+
+    let formData = {
+      title: this.title,
+      id: objectData.id,
+      type: objectData.type,
+      img: objectData.img,
+      name: objectData.name,
+      editable: this.isEditable,
+      cssClass: this.isEditable ? "editable" : "locked",
+      system: objectData.system,
+      effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
+      limited: this.object.limited,
+      skills: this.actor.getSkills(),
+      armes: foundry.utils.duplicate(this.actor.getWeapons()),
+      monnaies: foundry.utils.duplicate(this.actor.getMonnaies()),
+      protections: foundry.utils.duplicate(this.actor.getArmors()),
+      historiques: foundry.utils.duplicate(this.actor.getHistoriques() || []),
+      talents: foundry.utils.duplicate(this.actor.getTalents() || []),
+      mutations: foundry.utils.duplicate(this.actor.getMutations() || []),
+      dons: foundry.utils.duplicate(this.actor.getDons() || []),
+      pactes: foundry.utils.duplicate(this.actor.getPactes() || []),
+      tendances: foundry.utils.duplicate(this.actor.getTendances() || []),
+      runes: foundry.utils.duplicate(this.actor.getRunes() || []),
+      traitsChaotiques: foundry.utils.duplicate(this.actor.getTraitsChaotiques() || []),
+      traitsEspeces: foundry.utils.duplicate(this.actor.getTraitsEspeces() || []),
+      aspect: this.actor.getAspect(),
+      marge: this.actor.getMarge(),
+      profils: foundry.utils.duplicate(this.actor.getProfils() || []),
+      combat: this.actor.getCombatValues(),
+      equipements: foundry.utils.duplicate(this.actor.getEquipments()),
+      richesse: this.actor.computeRichesse(),
+      coupDevastateur: this.actor.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup devastateur" && !it.system.used),
+      valeurEquipement: this.actor.computeValeurEquipement(),
+      nbCombativite: this.actor.system.sante.nbcombativite,
+      combativiteList: MournbladeCYD2Utility.getCombativiteList(this.actor.system.sante.nbcombativite),
+      nbAme: this.actor.system.ame.nbame,
+      ameMax: this.actor.getAmeMax(),
+      ameList: MournbladeCYD2Utility.getAmeList(this.actor.system.ame.nbame, this.actor.getAmeMax()),
+      ameMaxList: MournbladeCYD2Utility.getAmeMaxList(this.actor.system.ame.nbame),
+      initiative: this.actor.getFlag("world", "last-initiative") || -1,
+      description: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.description, { async: true }),
+      habitat: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.habitat, { async: true }),
+      options: this.options,
+      owner: this.document.isOwner,
+      editScore: this.options.editScore,
+      isGM: game.user.isGM,
+      config: game.system.mournbladecyd2.config
+    }
+    this.formData = formData;
+
+    console.log("PC : ", formData, this.object);
+    return formData;
+  }
+
+  /* -------------------------------------------- */
+  /** @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")
+      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");
+      MournbladeCYD2Utility.confirmDelete(this, li);
+    })
+    html.find('.edit-item-data').change(ev => {
+      const li = $(ev.currentTarget).parents(".item")
+      let itemId = li.data("item-id")
+      let itemType = li.data("item-type")
+      let itemField = $(ev.currentTarget).data("item-field")
+      let dataType = $(ev.currentTarget).data("dtype")
+      let value = ev.currentTarget.value
+      this.actor.editItemField(itemId, itemType, itemField, dataType, value)
+    })
+
+    html.find('.adversite-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      let adv = li.data("adversite")
+      let value = Number($(event.currentTarget).data("adversite-value"))
+      this.actor.incDecAdversite(adv, value)
+    })
+
+    html.find('.quantity-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      const value = Number($(event.currentTarget).data("quantite-value"))
+      this.actor.incDecQuantity(li.data("item-id"), value);
+    })
+
+    html.find('.roll-initiative').click((event) => {
+      this.actor.rollAttribut("adr", true)
+    })
+
+    html.find('.roll-attribut').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = li.data("attr-key")
+      this.actor.rollAttribut(attrKey, false)
+    })
+    html.find('.roll-competence').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = $(event.currentTarget).data("attr-key")
+      let compId = li.data("item-id")
+      this.actor.rollCompetence(attrKey, compId)
+    })
+    html.find('.roll-arme-offensif').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeOffensif(armeId)
+    })
+
+    html.find('.roll-assommer').click((event) => {
+      this.actor.rollAssommer()
+    })
+    html.find('.roll-coup-bas').click((event) => {
+      this.actor.rollCoupBas()
+    })
+    html.find('.roll-immobiliser').click((event) => {
+      this.actor.rollImmobiliser()
+    })
+    html.find('.roll-repousser').click((event) => {
+      this.actor.rollRepousser()
+    })
+    html.find('.roll-desengager').click((event) => {
+      this.actor.rollDesengager()
+    })
+
+    html.find('.roll-arme-degats').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeDegats(armeId)
+    })
+
+    html.find('.item-add').click((event) => {
+      const itemType = $(event.currentTarget).data("type")
+      this.actor.createEmbeddedDocuments('Item', [{ name: `Nouveau ${itemType}`, type: itemType }], { renderSheet: true })
+    })
+
+    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);
+    });
+
+  }
+
+  /* -------------------------------------------- */
+  /** @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;
+  }
+
+  /* -------------------------------------------- */
+  async _onDropItem(event, dragData) {
+    let data = event.dataTransfer.getData('text/plain')
+    let dataItem = JSON.parse(data)
+    let item = fromUuidSync(dataItem.uuid)
+    if (item.pack) {
+      item = await MournbladeCYD2Utility.searchItem(item)
+    }
+    let autoresult = MournbladeCYD2Automation.processAutomations("on-drop", item, this.actor)
+    if (autoresult.isValid) {
+      super._onDropItem(event, dragData)
+    } else {
+      ui.notifications.warn(autoresult.warningMessage)
+    }
+  }
+
+}

.history/modules/mournblade-cyd2-actor-sheet_20251026132705.js

@@ -0,0 +1,211 @@
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2Automation } from "./mournblade-cyd2-automation.js";
+
+/* -------------------------------------------- */
+export class MournbladeCYD2ActorSheet extends foundry.appv1.sheets.ActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+
+    return foundry.utils.mergeObject(super.defaultOptions, {
+      classes: ["fvtt-mournblade-cyd2", "sheet", "actor"],
+      template: "systems/fvtt-mournblade-cyd2/templates/actor-sheet.html",
+      width: 640,
+      height: 720,
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "stats" }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
+      editScore: false
+    })
+  }
+
+  /* -------------------------------------------- */
+  async getData() {
+    const objectData = foundry.utils.duplicate(this.object)
+
+    let formData = {
+      title: this.title,
+      id: objectData.id,
+      type: objectData.type,
+      img: objectData.img,
+      name: objectData.name,
+      editable: this.isEditable,
+      cssClass: this.isEditable ? "editable" : "locked",
+      system: objectData.system,
+      effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
+      limited: this.object.limited,
+      skills: this.actor.getSkills(),
+      armes: foundry.utils.duplicate(this.actor.getWeapons()),
+      monnaies: foundry.utils.duplicate(this.actor.getMonnaies()),
+      protections: foundry.utils.duplicate(this.actor.getArmors()),
+      historiques: foundry.utils.duplicate(this.actor.getHistoriques() || []),
+      talents: foundry.utils.duplicate(this.actor.getTalents() || []),
+      dons: foundry.utils.duplicate(this.actor.getDons() || []),
+      pactes: foundry.utils.duplicate(this.actor.getPactes() || []),
+      tendances: foundry.utils.duplicate(this.actor.getTendances() || []),
+      runes: foundry.utils.duplicate(this.actor.getRunes() || []),
+      traitsChaotiques: foundry.utils.duplicate(this.actor.getTraitsChaotiques() || []),
+      traitsEspeces: foundry.utils.duplicate(this.actor.getTraitsEspeces() || []),
+      aspect: this.actor.getAspect(),
+      marge: this.actor.getMarge(),
+      profils: foundry.utils.duplicate(this.actor.getProfils() || []),
+      combat: this.actor.getCombatValues(),
+      equipements: foundry.utils.duplicate(this.actor.getEquipments()),
+      richesse: this.actor.computeRichesse(),
+      coupDevastateur: this.actor.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup devastateur" && !it.system.used),
+      valeurEquipement: this.actor.computeValeurEquipement(),
+      nbCombativite: this.actor.system.sante.nbcombativite,
+      combativiteList: MournbladeCYD2Utility.getCombativiteList(this.actor.system.sante.nbcombativite),
+      nbAme: this.actor.system.ame.nbame,
+      ameMax: this.actor.getAmeMax(),
+      ameList: MournbladeCYD2Utility.getAmeList(this.actor.system.ame.nbame, this.actor.getAmeMax()),
+      ameMaxList: MournbladeCYD2Utility.getAmeMaxList(this.actor.system.ame.nbame),
+      initiative: this.actor.getFlag("world", "last-initiative") || -1,
+      description: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.description, { async: true }),
+      habitat: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.habitat, { async: true }),
+      options: this.options,
+      owner: this.document.isOwner,
+      editScore: this.options.editScore,
+      isGM: game.user.isGM,
+      config: game.system.mournbladecyd2.config
+    }
+    this.formData = formData;
+
+    console.log("PC : ", formData, this.object);
+    return formData;
+  }
+
+  /* -------------------------------------------- */
+  /** @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")
+      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");
+      MournbladeCYD2Utility.confirmDelete(this, li);
+    })
+    html.find('.edit-item-data').change(ev => {
+      const li = $(ev.currentTarget).parents(".item")
+      let itemId = li.data("item-id")
+      let itemType = li.data("item-type")
+      let itemField = $(ev.currentTarget).data("item-field")
+      let dataType = $(ev.currentTarget).data("dtype")
+      let value = ev.currentTarget.value
+      this.actor.editItemField(itemId, itemType, itemField, dataType, value)
+    })
+
+    html.find('.adversite-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      let adv = li.data("adversite")
+      let value = Number($(event.currentTarget).data("adversite-value"))
+      this.actor.incDecAdversite(adv, value)
+    })
+
+    html.find('.quantity-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      const value = Number($(event.currentTarget).data("quantite-value"))
+      this.actor.incDecQuantity(li.data("item-id"), value);
+    })
+
+    html.find('.roll-initiative').click((event) => {
+      this.actor.rollAttribut("adr", true)
+    })
+
+    html.find('.roll-attribut').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = li.data("attr-key")
+      this.actor.rollAttribut(attrKey, false)
+    })
+    html.find('.roll-competence').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = $(event.currentTarget).data("attr-key")
+      let compId = li.data("item-id")
+      this.actor.rollCompetence(attrKey, compId)
+    })
+    html.find('.roll-arme-offensif').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeOffensif(armeId)
+    })
+
+    html.find('.roll-assommer').click((event) => {
+      this.actor.rollAssommer()
+    })
+    html.find('.roll-coup-bas').click((event) => {
+      this.actor.rollCoupBas()
+    })
+    html.find('.roll-immobiliser').click((event) => {
+      this.actor.rollImmobiliser()
+    })
+    html.find('.roll-repousser').click((event) => {
+      this.actor.rollRepousser()
+    })
+    html.find('.roll-desengager').click((event) => {
+      this.actor.rollDesengager()
+    })
+
+    html.find('.roll-arme-degats').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeDegats(armeId)
+    })
+
+    html.find('.item-add').click((event) => {
+      const itemType = $(event.currentTarget).data("type")
+      this.actor.createEmbeddedDocuments('Item', [{ name: `Nouveau ${itemType}`, type: itemType }], { renderSheet: true })
+    })
+
+    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);
+    });
+
+  }
+
+  /* -------------------------------------------- */
+  /** @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;
+  }
+
+  /* -------------------------------------------- */
+  async _onDropItem(event, dragData) {
+    let data = event.dataTransfer.getData('text/plain')
+    let dataItem = JSON.parse(data)
+    let item = fromUuidSync(dataItem.uuid)
+    if (item.pack) {
+      item = await MournbladeCYD2Utility.searchItem(item)
+    }
+    let autoresult = MournbladeCYD2Automation.processAutomations("on-drop", item, this.actor)
+    if (autoresult.isValid) {
+      super._onDropItem(event, dragData)
+    } else {
+      ui.notifications.warn(autoresult.warningMessage)
+    }
+  }
+
+}

.history/modules/mournblade-cyd2-actor-sheet_20251026132939.js

@@ -0,0 +1,211 @@
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2Automation } from "./mournblade-cyd2-automation.js";
+
+/* -------------------------------------------- */
+export class MournbladeCYD2ActorSheet extends foundry.appv1.sheets.ActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+
+    return foundry.utils.mergeObject(super.defaultOptions, {
+      classes: ["fvtt-mournblade-cyd2", "sheet", "actor"],
+      template: "systems/fvtt-mournblade-cyd2/templates/actor-sheet.html",
+      width: 640,
+      height: 720,
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "stats" }],
+      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
+      editScore: false
+    })
+  }
+
+  /* -------------------------------------------- */
+  async getData() {
+    const objectData = foundry.utils.duplicate(this.object)
+
+    let formData = {
+      title: this.title,
+      id: objectData.id,
+      type: objectData.type,
+      img: objectData.img,
+      name: objectData.name,
+      editable: this.isEditable,
+      cssClass: this.isEditable ? "editable" : "locked",
+      system: objectData.system,
+      effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
+      limited: this.object.limited,
+      skills: this.actor.getSkills(),
+      armes: foundry.utils.duplicate(this.actor.getWeapons()),
+      monnaies: foundry.utils.duplicate(this.actor.getMonnaies()),
+      protections: foundry.utils.duplicate(this.actor.getArmors()),
+      historiques: foundry.utils.duplicate(this.actor.getHistoriques() || []),
+      talents: foundry.utils.duplicate(this.actor.getTalents() || []),
+      dons: foundry.utils.duplicate(this.actor.getDons() || []),
+      pactes: foundry.utils.duplicate(this.actor.getPactes() || []),
+      tendances: foundry.utils.duplicate(this.actor.getTendances() || []),
+      runes: foundry.utils.duplicate(this.actor.getRunes() || []),
+      traitsChaotiques: foundry.utils.duplicate(this.actor.getTraitsChaotiques() || []),
+      traitsEspeces: foundry.utils.duplicate(this.actor.getTraitsEspeces() || []),
+      aspect: this.actor.getAspect(),
+      marge: this.actor.getMarge(),
+      profils: foundry.utils.duplicate(this.actor.getProfils() || []),
+      combat: this.actor.getCombatValues(),
+      equipements: foundry.utils.duplicate(this.actor.getEquipments()),
+      richesse: this.actor.computeRichesse(),
+      coupDevastateur: this.actor.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup devastateur" && !it.system.used),
+      valeurEquipement: this.actor.computeValeurEquipement(),
+      nbCombativite: this.actor.system.sante.nbcombativite,
+      combativiteList: MournbladeCYD2Utility.getCombativiteList(this.actor.system.sante.nbcombativite),
+      nbAme: this.actor.system.ame.nbame,
+      ameMax: this.actor.getAmeMax(),
+      ameList: MournbladeCYD2Utility.getAmeList(this.actor.system.ame.nbame, this.actor.getAmeMax()),
+      ameMaxList: MournbladeCYD2Utility.getAmeMaxList(this.actor.system.ame.nbame),
+      initiative: this.actor.getFlag("world", "last-initiative") || -1,
+      description: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.description, { async: true }),
+      habitat: await foundry.applications.ux.TextEditor.implementation.enrichHTML(this.object.system.biodata.habitat, { async: true }),
+      options: this.options,
+      owner: this.document.isOwner,
+      editScore: this.options.editScore,
+      isGM: game.user.isGM,
+      config: game.system.mournbladecyd2.config
+    }
+    this.formData = formData;
+
+    console.log("PC : ", formData, this.object);
+    return formData;
+  }
+
+  /* -------------------------------------------- */
+  /** @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")
+      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");
+      MournbladeCYD2Utility.confirmDelete(this, li);
+    })
+    html.find('.edit-item-data').change(ev => {
+      const li = $(ev.currentTarget).parents(".item")
+      let itemId = li.data("item-id")
+      let itemType = li.data("item-type")
+      let itemField = $(ev.currentTarget).data("item-field")
+      let dataType = $(ev.currentTarget).data("dtype")
+      let value = ev.currentTarget.value
+      this.actor.editItemField(itemId, itemType, itemField, dataType, value)
+    })
+
+    html.find('.adversite-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      let adv = li.data("adversite")
+      let value = Number($(event.currentTarget).data("adversite-value"))
+      this.actor.incDecAdversite(adv, value)
+    })
+
+    html.find('.quantity-modify').click(event => {
+      const li = $(event.currentTarget).parents(".item")
+      const value = Number($(event.currentTarget).data("quantite-value"))
+      this.actor.incDecQuantity(li.data("item-id"), value);
+    })
+
+    html.find('.roll-initiative').click((event) => {
+      this.actor.rollAttribut("adr", true)
+    })
+
+    html.find('.roll-attribut').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = li.data("attr-key")
+      this.actor.rollAttribut(attrKey, false)
+    })
+    html.find('.roll-competence').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let attrKey = $(event.currentTarget).data("attr-key")
+      let compId = li.data("item-id")
+      this.actor.rollCompetence(attrKey, compId)
+    })
+    html.find('.roll-arme-offensif').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeOffensif(armeId)
+    })
+
+    html.find('.roll-assommer').click((event) => {
+      this.actor.rollAssommer()
+    })
+    html.find('.roll-coup-bas').click((event) => {
+      this.actor.rollCoupBas()
+    })
+    html.find('.roll-immobiliser').click((event) => {
+      this.actor.rollImmobiliser()
+    })
+    html.find('.roll-repousser').click((event) => {
+      this.actor.rollRepousser()
+    })
+    html.find('.roll-desengager').click((event) => {
+      this.actor.rollDesengager()
+    })
+
+    html.find('.roll-arme-degats').click((event) => {
+      const li = $(event.currentTarget).parents(".item")
+      let armeId = li.data("item-id")
+      this.actor.rollArmeDegats(armeId)
+    })
+
+    html.find('.item-add').click((event) => {
+      const itemType = $(event.currentTarget).data("type")
+      this.actor.createEmbeddedDocuments('Item', [{ name: `Nouveau ${itemType}`, type: itemType }], { renderSheet: true })
+    })
+
+    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);
+    });
+
+  }
+
+  /* -------------------------------------------- */
+  /** @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;
+  }
+
+  /* -------------------------------------------- */
+  async _onDropItem(event, dragData) {
+    let data = event.dataTransfer.getData('text/plain')
+    let dataItem = JSON.parse(data)
+    let item = fromUuidSync(dataItem.uuid)
+    if (item.pack) {
+      item = await MournbladeCYD2Utility.searchItem(item)
+    }
+    let autoresult = MournbladeCYD2Automation.processAutomations("on-drop", item, this.actor)
+    if (autoresult.isValid) {
+      super._onDropItem(event, dragData)
+    } else {
+      ui.notifications.warn(autoresult.warningMessage)
+    }
+  }
+
+}

.history/modules/mournblade-cyd2-actor_20251026001301.js

@@ -0,0 +1,811 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026001548.js

@@ -0,0 +1,811 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026002613.js

@@ -0,0 +1,822 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026002719.js

@@ -0,0 +1,822 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026082021.js

@@ -0,0 +1,828 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+      
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026082036.js

@@ -0,0 +1,847 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+      
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026082126.js

@@ -0,0 +1,852 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+      
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026082146.js

@@ -0,0 +1,867 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+      
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé
+    if (ame.etat == this.system.ame.nbame - 3 || ame.etat == this.system.ame.nbame - 2 || ame.etat == this.system.ame.nbame - 1) {
+      if (ame.etat == this.system.ame.nbame - 3) {
+        ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+      } else if (ame.etat == this.system.ame.nbame - 2) {
+        ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+      } else if (ame.etat == this.system.ame.nbame - 1) {
+        ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026082203.js

@@ -0,0 +1,882 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+      
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    ame.etat = Math.max(ame.etat, 0)
+    ame.etat = Math.min(ame.etat, this.system.ame.nbame - 1)
+    this.update({ 'system.ame': ame })
+    if (ame.etat == this.system.ame.nbame - 1) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé
+    if (ame.etat == this.system.ame.nbame - 3 || ame.etat == this.system.ame.nbame - 2 || ame.etat == this.system.ame.nbame - 1) {
+      if (ame.etat == this.system.ame.nbame - 3) {
+        ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+      } else if (ame.etat == this.system.ame.nbame - 2) {
+        ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+      } else if (ame.etat == this.system.ame.nbame - 1) {
+        ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026082310.js

@@ -0,0 +1,882 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    ame.etat = Math.max(ame.etat, 0)
+    ame.etat = Math.min(ame.etat, this.system.ame.nbame - 1)
+    this.update({ 'system.ame': ame })
+    if (ame.etat == this.system.ame.nbame - 1) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé
+    if (ame.etat == this.system.ame.nbame - 3 || ame.etat == this.system.ame.nbame - 2 || ame.etat == this.system.ame.nbame - 1) {
+      if (ame.etat == this.system.ame.nbame - 3) {
+        ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+      } else if (ame.etat == this.system.ame.nbame - 2) {
+        ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+      } else if (ame.etat == this.system.ame.nbame - 1) {
+        ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026082551.js

@@ -0,0 +1,884 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    ame.etat = Math.max(ame.etat, 0)
+    // L'état ne peut pas dépasser le maximum actuel d'âme
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame - 1)
+    ame.etat = Math.min(ame.etat, maxAme)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé
+    if (ame.etat == this.system.ame.nbame - 3 || ame.etat == this.system.ame.nbame - 2 || ame.etat == this.system.ame.nbame - 1) {
+      if (ame.etat == this.system.ame.nbame - 3) {
+        ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+      } else if (ame.etat == this.system.ame.nbame - 2) {
+        ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+      } else if (ame.etat == this.system.ame.nbame - 1) {
+        ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026082604.js

@@ -0,0 +1,888 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    ame.etat = Math.max(ame.etat, 0)
+    // L'état ne peut pas dépasser le maximum actuel d'âme
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame - 1)
+    ame.etat = Math.min(ame.etat, maxAme)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame - 1)
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé en fonction du maximum actuel
+    // Les seuils sont calculés par rapport au maximum d'âme actuel
+    if (maxAme >= 2 && ame.etat >= maxAme - 2) {
+      if (ame.etat == maxAme - 2) {
+        ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+      } else if (ame.etat == maxAme - 1) {
+        ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+      } else if (ame.etat >= maxAme) {
+        ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+      }
+    } else if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026082619.js

@@ -0,0 +1,893 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    return Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    ame.etat = Math.max(ame.etat, 0)
+    // L'état ne peut pas dépasser le maximum actuel d'âme
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame - 1)
+    ame.etat = Math.min(ame.etat, maxAme)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame - 1)
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé en fonction du maximum actuel
+    // Les seuils sont calculés par rapport au maximum d'âme actuel
+    if (maxAme >= 2 && ame.etat >= maxAme - 2) {
+      if (ame.etat == maxAme - 2) {
+        ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+      } else if (ame.etat == maxAme - 1) {
+        ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+      } else if (ame.etat >= maxAme) {
+        ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+      }
+    } else if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026082724.js

@@ -0,0 +1,893 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    return Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    ame.etat = Math.max(ame.etat, 0)
+    // L'état ne peut pas dépasser le maximum actuel d'âme
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame - 1)
+    ame.etat = Math.min(ame.etat, maxAme)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame - 1)
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé en fonction du maximum actuel
+    // Les seuils sont calculés par rapport au maximum d'âme actuel
+    if (maxAme >= 2 && ame.etat >= maxAme - 2) {
+      if (ame.etat == maxAme - 2) {
+        ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+      } else if (ame.etat == maxAme - 1) {
+        ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+      } else if (ame.etat >= maxAme) {
+        ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+      }
+    } else if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026083107.js

@@ -0,0 +1,907 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // S'assurer que l'état ne dépasse pas le maximum actuel d'âme
+      let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+      if (changed.system.ame.etat > maxAme) {
+        changed.system.ame.etat = maxAme
+      }
+      if (changed.system.ame.etat < 0) {
+        changed.system.ame.etat = 0
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le maximum d'âme change, s'assurer que l'état actuel ne le dépasse pas
+    if (changed?.system?.ame?.max && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat > changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    return Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    ame.etat = Math.max(ame.etat, 0)
+    // L'état ne peut pas dépasser le maximum actuel d'âme
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame - 1)
+    ame.etat = Math.min(ame.etat, maxAme)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame - 1)
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé en fonction du maximum actuel
+    // Les seuils sont calculés par rapport au maximum d'âme actuel
+    if (maxAme >= 2 && ame.etat >= maxAme - 2) {
+      if (ame.etat == maxAme - 2) {
+        ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+      } else if (ame.etat == maxAme - 1) {
+        ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+      } else if (ame.etat >= maxAme) {
+        ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+      }
+    } else if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026083143.js

@@ -0,0 +1,907 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // S'assurer que l'état ne dépasse pas le maximum actuel d'âme
+      let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+      if (changed.system.ame.etat > maxAme) {
+        changed.system.ame.etat = maxAme
+      }
+      if (changed.system.ame.etat < 0) {
+        changed.system.ame.etat = 0
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le maximum d'âme change, s'assurer que l'état actuel ne le dépasse pas
+    if (changed?.system?.ame?.max && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat > changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    return Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    ame.etat = Math.max(ame.etat, 0)
+    // L'état ne peut pas dépasser le maximum actuel d'âme
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+    ame.etat = Math.min(ame.etat, maxAme)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame - 1)
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé en fonction du maximum actuel
+    // Les seuils sont calculés par rapport au maximum d'âme actuel
+    if (maxAme >= 2 && ame.etat >= maxAme - 2) {
+      if (ame.etat == maxAme - 2) {
+        ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+      } else if (ame.etat == maxAme - 1) {
+        ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+      } else if (ame.etat >= maxAme) {
+        ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+      }
+    } else if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026083155.js

@@ -0,0 +1,907 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // S'assurer que l'état ne dépasse pas le maximum actuel d'âme
+      let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+      if (changed.system.ame.etat > maxAme) {
+        changed.system.ame.etat = maxAme
+      }
+      if (changed.system.ame.etat < 0) {
+        changed.system.ame.etat = 0
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le maximum d'âme change, s'assurer que l'état actuel ne le dépasse pas
+    if (changed?.system?.ame?.max && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat > changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    return Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    ame.etat = Math.max(ame.etat, 0)
+    // L'état ne peut pas dépasser le maximum actuel d'âme
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+    ame.etat = Math.min(ame.etat, maxAme)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame - 1)
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé en fonction du maximum actuel
+    // Les seuils sont calculés par rapport au maximum d'âme actuel
+    if (maxAme >= 2 && ame.etat >= maxAme - 2) {
+      if (ame.etat == maxAme - 2) {
+        ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+      } else if (ame.etat == maxAme - 1) {
+        ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+      } else if (ame.etat >= maxAme) {
+        ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+      }
+    } else if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026083156.js

@@ -0,0 +1,907 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // S'assurer que l'état ne dépasse pas le maximum actuel d'âme
+      let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+      if (changed.system.ame.etat > maxAme) {
+        changed.system.ame.etat = maxAme
+      }
+      if (changed.system.ame.etat < 0) {
+        changed.system.ame.etat = 0
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le maximum d'âme change, s'assurer que l'état actuel ne le dépasse pas
+    if (changed?.system?.ame?.max && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat > changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    return Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    ame.etat = Math.max(ame.etat, 0)
+    // L'état ne peut pas dépasser le maximum actuel d'âme
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+    ame.etat = Math.min(ame.etat, maxAme)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé en fonction du maximum actuel
+    // Les seuils sont calculés par rapport au maximum d'âme actuel
+    if (maxAme >= 3 && ame.etat >= maxAme - 2) {
+      if (ame.etat == maxAme - 2) {
+        ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+      } else if (ame.etat == maxAme - 1) {
+        ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+      } else if (ame.etat >= maxAme) {
+        ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+      }
+    } else if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026083157.js

@@ -0,0 +1,907 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // S'assurer que l'état ne dépasse pas le maximum actuel d'âme
+      let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+      if (changed.system.ame.etat > maxAme) {
+        changed.system.ame.etat = maxAme
+      }
+      if (changed.system.ame.etat < 0) {
+        changed.system.ame.etat = 0
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le maximum d'âme change, s'assurer que l'état actuel ne le dépasse pas
+    if (changed?.system?.ame?.max && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat > changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    return Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    ame.etat = Math.max(ame.etat, 0)
+    // L'état ne peut pas dépasser le maximum actuel d'âme
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+    ame.etat = Math.min(ame.etat, maxAme)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé en fonction du maximum actuel
+    // Les seuils sont calculés par rapport au maximum d'âme actuel
+    if (maxAme >= 3 && ame.etat >= maxAme - 2) {
+      if (ame.etat == maxAme - 2) {
+        ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+      } else if (ame.etat == maxAme - 1) {
+        ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+      } else if (ame.etat >= maxAme) {
+        ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+      }
+    } else if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026083444.js

@@ -0,0 +1,893 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    return Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    ame.etat = Math.max(ame.etat, 0)
+    // L'état ne peut pas dépasser le maximum actuel d'âme
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+    ame.etat = Math.min(ame.etat, maxAme)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé en fonction du maximum actuel
+    // Les seuils sont calculés par rapport au maximum d'âme actuel
+    if (maxAme >= 3 && ame.etat >= maxAme - 2) {
+      if (ame.etat == maxAme - 2) {
+        ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+      } else if (ame.etat == maxAme - 1) {
+        ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+      } else if (ame.etat >= maxAme) {
+        ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+      }
+    } else if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026083447.js

@@ -0,0 +1,893 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    return Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    ame.etat = Math.max(ame.etat, 0)
+    // L'état ne peut pas dépasser le maximum actuel d'âme
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame - 1)
+    ame.etat = Math.min(ame.etat, maxAme)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé en fonction du maximum actuel
+    // Les seuils sont calculés par rapport au maximum d'âme actuel
+    if (maxAme >= 3 && ame.etat >= maxAme - 2) {
+      if (ame.etat == maxAme - 2) {
+        ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+      } else if (ame.etat == maxAme - 1) {
+        ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+      } else if (ame.etat >= maxAme) {
+        ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+      }
+    } else if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026083449.js

@@ -0,0 +1,893 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    return Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    ame.etat = Math.max(ame.etat, 0)
+    // L'état ne peut pas dépasser le maximum actuel d'âme
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame - 1)
+    ame.etat = Math.min(ame.etat, maxAme)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame - 1)
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé en fonction du maximum actuel
+    // Les seuils sont calculés par rapport au maximum d'âme actuel
+    if (maxAme >= 2 && ame.etat >= maxAme - 2) {
+      if (ame.etat == maxAme - 2) {
+        ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+      } else if (ame.etat == maxAme - 1) {
+        ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+      } else if (ame.etat >= maxAme) {
+        ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+      }
+    } else if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026083504.js

@@ -0,0 +1,893 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    return Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    ame.etat = Math.max(ame.etat, 0)
+    // L'état ne peut pas dépasser le maximum actuel d'âme
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame - 1)
+    ame.etat = Math.min(ame.etat, maxAme)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame - 1)
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé en fonction du maximum actuel
+    // Les seuils sont calculés par rapport au maximum d'âme actuel
+    if (maxAme >= 2 && ame.etat >= maxAme - 2) {
+      if (ame.etat == maxAme - 2) {
+        ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+      } else if (ame.etat == maxAme - 1) {
+        ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+      } else if (ame.etat >= maxAme) {
+        ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+      }
+    } else if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026083833.js

@@ -0,0 +1,904 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // Limiter l'état d'Âme au maximum défini
+      let maxAme = this.system.ame.max || this.system.ame.nbame
+      if (changed.system.ame.etat > maxAme) {
+        changed.system.ame.etat = maxAme
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat > changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    return Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    ame.etat = Math.max(ame.etat, 0)
+    // L'état ne peut pas dépasser le maximum actuel d'âme
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame - 1)
+    ame.etat = Math.min(ame.etat, maxAme)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame - 1)
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé en fonction du maximum actuel
+    // Les seuils sont calculés par rapport au maximum d'âme actuel
+    if (maxAme >= 2 && ame.etat >= maxAme - 2) {
+      if (ame.etat == maxAme - 2) {
+        ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+      } else if (ame.etat == maxAme - 1) {
+        ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+      } else if (ame.etat >= maxAme) {
+        ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+      }
+    } else if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026083905.js

@@ -0,0 +1,904 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // Limiter l'état d'Âme au maximum défini
+      let maxAme = this.system.ame.max || this.system.ame.nbame
+      if (changed.system.ame.etat > maxAme) {
+        changed.system.ame.etat = maxAme
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat > changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    return Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    ame.etat = Math.max(ame.etat, 0)
+    // L'état ne peut pas dépasser le maximum actuel d'âme
+    let maxAme = this.system.ame.max || this.system.ame.nbame
+    ame.etat = Math.min(ame.etat, maxAme)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let maxAme = Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame - 1)
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé en fonction du maximum actuel
+    // Les seuils sont calculés par rapport au maximum d'âme actuel
+    if (maxAme >= 2 && ame.etat >= maxAme - 2) {
+      if (ame.etat == maxAme - 2) {
+        ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+      } else if (ame.etat == maxAme - 1) {
+        ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+      } else if (ame.etat >= maxAme) {
+        ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+      }
+    } else if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026083918.js

@@ -0,0 +1,904 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // Limiter l'état d'Âme au maximum défini
+      let maxAme = this.system.ame.max || this.system.ame.nbame
+      if (changed.system.ame.etat > maxAme) {
+        changed.system.ame.etat = maxAme
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat > changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    return Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    ame.etat = Math.max(ame.etat, 0)
+    // L'état ne peut pas dépasser le maximum actuel d'âme
+    let maxAme = this.system.ame.max || this.system.ame.nbame
+    ame.etat = Math.min(ame.etat, maxAme)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let maxAme = this.system.ame.max || this.system.ame.nbame
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé en fonction du maximum actuel
+    // Les seuils sont calculés par rapport au maximum d'âme actuel
+    if (maxAme >= 3 && ame.etat >= maxAme - 2) {
+      if (ame.etat == maxAme - 2) {
+        ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+      } else if (ame.etat == maxAme - 1) {
+        ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+      } else if (ame.etat >= maxAme) {
+        ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+      }
+    } else if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026083937.js

@@ -0,0 +1,904 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // Limiter l'état d'Âme au maximum défini
+      let maxAme = this.system.ame.max || this.system.ame.nbame
+      if (changed.system.ame.etat > maxAme) {
+        changed.system.ame.etat = maxAme
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat > changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    return Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    ame.etat = Math.max(ame.etat, 0)
+    // L'état ne peut pas dépasser le maximum actuel d'âme
+    let maxAme = this.system.ame.max || this.system.ame.nbame
+    ame.etat = Math.min(ame.etat, maxAme)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let maxAme = this.system.ame.max || this.system.ame.nbame
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé en fonction du maximum actuel
+    // Les seuils sont calculés par rapport au maximum d'âme actuel
+    if (maxAme >= 3 && ame.etat >= maxAme - 2) {
+      if (ame.etat == maxAme - 2) {
+        ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+      } else if (ame.etat == maxAme - 1) {
+        ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+      } else if (ame.etat >= maxAme) {
+        ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+      }
+    } else if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026084242.js

@@ -0,0 +1,908 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // L'état d'Âme ne peut pas être inférieur au minimum (max dans le système)
+      let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+      if (changed.system.ame.etat < minAme) {
+        changed.system.ame.etat = minAme
+      }
+      // L'état d'Âme ne peut pas dépasser nbame (Brisé)
+      if (changed.system.ame.etat > this.system.ame.nbame) {
+        changed.system.ame.etat = this.system.ame.nbame
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max !== undefined && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat < changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    return Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    ame.etat = Math.max(ame.etat, 0)
+    // L'état ne peut pas dépasser le maximum actuel d'âme
+    let maxAme = this.system.ame.max || this.system.ame.nbame
+    ame.etat = Math.min(ame.etat, maxAme)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let maxAme = this.system.ame.max || this.system.ame.nbame
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé en fonction du maximum actuel
+    // Les seuils sont calculés par rapport au maximum d'âme actuel
+    if (maxAme >= 3 && ame.etat >= maxAme - 2) {
+      if (ame.etat == maxAme - 2) {
+        ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+      } else if (ame.etat == maxAme - 1) {
+        ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+      } else if (ame.etat >= maxAme) {
+        ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+      }
+    } else if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026084254.js

@@ -0,0 +1,909 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // L'état d'Âme ne peut pas être inférieur au minimum (max dans le système)
+      let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+      if (changed.system.ame.etat < minAme) {
+        changed.system.ame.etat = minAme
+      }
+      // L'état d'Âme ne peut pas dépasser nbame (Brisé)
+      if (changed.system.ame.etat > this.system.ame.nbame) {
+        changed.system.ame.etat = this.system.ame.nbame
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max !== undefined && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat < changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    return Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    // L'état ne peut pas être inférieur au minimum (max dans le système)
+    let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+    ame.etat = Math.max(ame.etat, minAme)
+    // L'état ne peut pas dépasser nbame (Brisé)
+    ame.etat = Math.min(ame.etat, this.system.ame.nbame)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= this.system.ame.nbame) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let maxAme = this.system.ame.max || this.system.ame.nbame
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé en fonction du maximum actuel
+    // Les seuils sont calculés par rapport au maximum d'âme actuel
+    if (maxAme >= 3 && ame.etat >= maxAme - 2) {
+      if (ame.etat == maxAme - 2) {
+        ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+      } else if (ame.etat == maxAme - 1) {
+        ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+      } else if (ame.etat >= maxAme) {
+        ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+      }
+    } else if (ame.etat >= maxAme) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026084306.js

@@ -0,0 +1,907 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // L'état d'Âme ne peut pas être inférieur au minimum (max dans le système)
+      let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+      if (changed.system.ame.etat < minAme) {
+        changed.system.ame.etat = minAme
+      }
+      // L'état d'Âme ne peut pas dépasser nbame (Brisé)
+      if (changed.system.ame.etat > this.system.ame.nbame) {
+        changed.system.ame.etat = this.system.ame.nbame
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max !== undefined && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat < changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    return Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    // L'état ne peut pas être inférieur au minimum (max dans le système)
+    let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+    ame.etat = Math.max(ame.etat, minAme)
+    // L'état ne peut pas dépasser nbame (Brisé)
+    ame.etat = Math.min(ame.etat, this.system.ame.nbame)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= this.system.ame.nbame) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let traumatiseValue = this.system.ame.nbame - 2
+    let tresTraumatiseValue = this.system.ame.nbame - 1
+    let briseValue = this.system.ame.nbame
+    
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé
+    if (ame.etat == traumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+    } else if (ame.etat == tresTraumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+    } else if (ame.etat >= briseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026084418.js

@@ -0,0 +1,907 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // L'état d'Âme ne peut pas être inférieur au minimum (max dans le système)
+      let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+      if (changed.system.ame.etat < minAme) {
+        changed.system.ame.etat = minAme
+      }
+      // L'état d'Âme ne peut pas dépasser nbame (Brisé)
+      if (changed.system.ame.etat > this.system.ame.nbame) {
+        changed.system.ame.etat = this.system.ame.nbame
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max !== undefined && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat < changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    return Math.min(this.system.ame.max || this.system.ame.nbame, this.system.ame.nbame)
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    // L'état ne peut pas être inférieur au minimum (max dans le système)
+    let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+    ame.etat = Math.max(ame.etat, minAme)
+    // L'état ne peut pas dépasser nbame (Brisé)
+    ame.etat = Math.min(ame.etat, this.system.ame.nbame)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= this.system.ame.nbame) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let traumatiseValue = this.system.ame.nbame - 2
+    let tresTraumatiseValue = this.system.ame.nbame - 1
+    let briseValue = this.system.ame.nbame
+
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé
+    if (ame.etat == traumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+    } else if (ame.etat == tresTraumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+    } else if (ame.etat >= briseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026084727.js

@@ -0,0 +1,908 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // L'état d'Âme ne peut pas être inférieur au minimum (max dans le système)
+      let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+      if (changed.system.ame.etat < minAme) {
+        changed.system.ame.etat = minAme
+      }
+      // L'état d'Âme ne peut pas dépasser nbame (Brisé)
+      if (changed.system.ame.etat > this.system.ame.nbame) {
+        changed.system.ame.etat = this.system.ame.nbame
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max !== undefined && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat < changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    // Utiliser une vérification stricte car 0 (Serein) est une valeur valide
+    return this.system.ame.max !== undefined ? this.system.ame.max : this.system.ame.nbame
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    // L'état ne peut pas être inférieur au minimum (max dans le système)
+    let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+    ame.etat = Math.max(ame.etat, minAme)
+    // L'état ne peut pas dépasser nbame (Brisé)
+    ame.etat = Math.min(ame.etat, this.system.ame.nbame)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= this.system.ame.nbame) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let traumatiseValue = this.system.ame.nbame - 2
+    let tresTraumatiseValue = this.system.ame.nbame - 1
+    let briseValue = this.system.ame.nbame
+
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé
+    if (ame.etat == traumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+    } else if (ame.etat == tresTraumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+    } else if (ame.etat >= briseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026084815.js

@@ -0,0 +1,908 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    if (this.type == "cellule") {
+      return arme
+    }
+
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // L'état d'Âme ne peut pas être inférieur au minimum (max dans le système)
+      let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+      if (changed.system.ame.etat < minAme) {
+        changed.system.ame.etat = minAme
+      }
+      // L'état d'Âme ne peut pas dépasser nbame (Brisé)
+      if (changed.system.ame.etat > this.system.ame.nbame) {
+        changed.system.ame.etat = this.system.ame.nbame
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max !== undefined && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat < changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    // Utiliser une vérification stricte car 0 (Serein) est une valeur valide
+    return this.system.ame.max !== undefined ? this.system.ame.max : this.system.ame.nbame
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    // L'état ne peut pas être inférieur au minimum (max dans le système)
+    let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+    ame.etat = Math.max(ame.etat, minAme)
+    // L'état ne peut pas dépasser nbame (Brisé)
+    ame.etat = Math.min(ame.etat, this.system.ame.nbame)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= this.system.ame.nbame) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let traumatiseValue = this.system.ame.nbame - 2
+    let tresTraumatiseValue = this.system.ame.nbame - 1
+    let briseValue = this.system.ame.nbame
+
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé
+    if (ame.etat == traumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+    } else if (ame.etat == tresTraumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+    } else if (ame.etat >= briseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026095752.js

@@ -0,0 +1,904 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    if (this.type == "cellule") {
+      return {
+        initBase: 0,
+        initTotal: 0,
+        bonusDegats: 0,
+        bonusDegatsTotal: 0,
+        vitesseBase: 0,
+        vitesseTotal: 0,
+        defenseBase: 0,
+        protection: 0,
+        defenseTotal: 0
+      }
+    }
+
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // L'état d'Âme ne peut pas être inférieur au minimum (max dans le système)
+      let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+      if (changed.system.ame.etat < minAme) {
+        changed.system.ame.etat = minAme
+      }
+      // L'état d'Âme ne peut pas dépasser nbame (Brisé)
+      if (changed.system.ame.etat > this.system.ame.nbame) {
+        changed.system.ame.etat = this.system.ame.nbame
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max !== undefined && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat < changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    // Utiliser une vérification stricte car 0 (Serein) est une valeur valide
+    return this.system.ame.max !== undefined ? this.system.ame.max : this.system.ame.nbame
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    // L'état ne peut pas être inférieur au minimum (max dans le système)
+    let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+    ame.etat = Math.max(ame.etat, minAme)
+    // L'état ne peut pas dépasser nbame (Brisé)
+    ame.etat = Math.min(ame.etat, this.system.ame.nbame)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= this.system.ame.nbame) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let traumatiseValue = this.system.ame.nbame - 2
+    let tresTraumatiseValue = this.system.ame.nbame - 1
+    let briseValue = this.system.ame.nbame
+
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé
+    if (ame.etat == traumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+    } else if (ame.etat == tresTraumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+    } else if (ame.etat >= briseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026095804.js

@@ -0,0 +1,890 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // L'état d'Âme ne peut pas être inférieur au minimum (max dans le système)
+      let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+      if (changed.system.ame.etat < minAme) {
+        changed.system.ame.etat = minAme
+      }
+      // L'état d'Âme ne peut pas dépasser nbame (Brisé)
+      if (changed.system.ame.etat > this.system.ame.nbame) {
+        changed.system.ame.etat = this.system.ame.nbame
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max !== undefined && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat < changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    // Utiliser une vérification stricte car 0 (Serein) est une valeur valide
+    return this.system.ame.max !== undefined ? this.system.ame.max : this.system.ame.nbame
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    // L'état ne peut pas être inférieur au minimum (max dans le système)
+    let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+    ame.etat = Math.max(ame.etat, minAme)
+    // L'état ne peut pas dépasser nbame (Brisé)
+    ame.etat = Math.min(ame.etat, this.system.ame.nbame)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= this.system.ame.nbame) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let traumatiseValue = this.system.ame.nbame - 2
+    let tresTraumatiseValue = this.system.ame.nbame - 1
+    let briseValue = this.system.ame.nbame
+
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé
+    if (ame.etat == traumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+    } else if (ame.etat == tresTraumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+    } else if (ame.etat >= briseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026100139.js

@@ -0,0 +1,890 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // L'état d'Âme ne peut pas être inférieur au minimum (max dans le système)
+      let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+      if (changed.system.ame.etat < minAme) {
+        changed.system.ame.etat = minAme
+      }
+      // L'état d'Âme ne peut pas dépasser nbame (Brisé)
+      if (changed.system.ame.etat > this.system.ame.nbame) {
+        changed.system.ame.etat = this.system.ame.nbame
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max !== undefined && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat < changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    // Utiliser une vérification stricte car 0 (Serein) est une valeur valide
+    return this.system.ame.max !== undefined ? this.system.ame.max : this.system.ame.nbame
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    // L'état ne peut pas être inférieur au minimum (max dans le système)
+    let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+    ame.etat = Math.max(ame.etat, minAme)
+    // L'état ne peut pas dépasser nbame (Brisé)
+    ame.etat = Math.min(ame.etat, this.system.ame.nbame)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= this.system.ame.nbame) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let traumatiseValue = this.system.ame.nbame - 2
+    let tresTraumatiseValue = this.system.ame.nbame - 1
+    let briseValue = this.system.ame.nbame
+
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé
+    if (ame.etat == traumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Traumatisé !</strong>` })
+    } else if (ame.etat == tresTraumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé !</strong>` })
+    } else if (ame.etat >= briseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026100634.js

@@ -0,0 +1,895 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // L'état d'Âme ne peut pas être inférieur au minimum (max dans le système)
+      let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+      if (changed.system.ame.etat < minAme) {
+        changed.system.ame.etat = minAme
+      }
+      // L'état d'Âme ne peut pas dépasser nbame (Brisé)
+      if (changed.system.ame.etat > this.system.ame.nbame) {
+        changed.system.ame.etat = this.system.ame.nbame
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max !== undefined && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat < changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    // Utiliser une vérification stricte car 0 (Serein) est une valeur valide
+    return this.system.ame.max !== undefined ? this.system.ame.max : this.system.ame.nbame
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    // L'état ne peut pas être inférieur au minimum (max dans le système)
+    let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+    ame.etat = Math.max(ame.etat, minAme)
+    // L'état ne peut pas dépasser nbame (Brisé)
+    ame.etat = Math.min(ame.etat, this.system.ame.nbame)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= this.system.ame.nbame) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let traumatiseValue = this.system.ame.nbame - 2
+    let tresTraumatiseValue = this.system.ame.nbame - 1
+    let briseValue = this.system.ame.nbame
+
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé
+    if (ame.etat == traumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Traumatisé et subit 1 adversité bleue et 1 adversité noire !</strong>` })
+      this.incDecAdversite("bleue", 1)
+      this.incDecAdversite("noire", 1)
+    } else if (ame.etat == tresTraumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé et subit 1 adversité bleue et 1 adversité noire !</strong>` })
+      this.incDecAdversite("bleue", 1)
+      this.incDecAdversite("noire", 1)
+    } else if (ame.etat >= briseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé et subit 1 adversité noire !</strong>` })
+      this.incDecAdversite("noire", 1)
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026100656.js

@@ -0,0 +1,895 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // L'état d'Âme ne peut pas être inférieur au minimum (max dans le système)
+      let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+      if (changed.system.ame.etat < minAme) {
+        changed.system.ame.etat = minAme
+      }
+      // L'état d'Âme ne peut pas dépasser nbame (Brisé)
+      if (changed.system.ame.etat > this.system.ame.nbame) {
+        changed.system.ame.etat = this.system.ame.nbame
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max !== undefined && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat < changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    // Utiliser une vérification stricte car 0 (Serein) est une valeur valide
+    return this.system.ame.max !== undefined ? this.system.ame.max : this.system.ame.nbame
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    // L'état ne peut pas être inférieur au minimum (max dans le système)
+    let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+    ame.etat = Math.max(ame.etat, minAme)
+    // L'état ne peut pas dépasser nbame (Brisé)
+    ame.etat = Math.min(ame.etat, this.system.ame.nbame)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= this.system.ame.nbame) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let traumatiseValue = this.system.ame.nbame - 2
+    let tresTraumatiseValue = this.system.ame.nbame - 1
+    let briseValue = this.system.ame.nbame
+
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé
+    if (ame.etat == traumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Traumatisé et subit 1 adversité bleue et 1 adversité noire !</strong>` })
+      this.incDecAdversite("bleue", 1)
+      this.incDecAdversite("noire", 1)
+    } else if (ame.etat == tresTraumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé et subit 1 adversité bleue et 1 adversité noire !</strong>` })
+      this.incDecAdversite("bleue", 1)
+      this.incDecAdversite("noire", 1)
+    } else if (ame.etat >= briseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé et subit 1 adversité noire !</strong>` })
+      this.incDecAdversite("noire", 1)
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026103947.js

@@ -0,0 +1,896 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      cons
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // L'état d'Âme ne peut pas être inférieur au minimum (max dans le système)
+      let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+      if (changed.system.ame.etat < minAme) {
+        changed.system.ame.etat = minAme
+      }
+      // L'état d'Âme ne peut pas dépasser nbame (Brisé)
+      if (changed.system.ame.etat > this.system.ame.nbame) {
+        changed.system.ame.etat = this.system.ame.nbame
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max !== undefined && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat < changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    // Utiliser une vérification stricte car 0 (Serein) est une valeur valide
+    return this.system.ame.max !== undefined ? this.system.ame.max : this.system.ame.nbame
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    // L'état ne peut pas être inférieur au minimum (max dans le système)
+    let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+    ame.etat = Math.max(ame.etat, minAme)
+    // L'état ne peut pas dépasser nbame (Brisé)
+    ame.etat = Math.min(ame.etat, this.system.ame.nbame)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= this.system.ame.nbame) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let traumatiseValue = this.system.ame.nbame - 2
+    let tresTraumatiseValue = this.system.ame.nbame - 1
+    let briseValue = this.system.ame.nbame
+
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé
+    if (ame.etat == traumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Traumatisé et subit 1 adversité bleue et 1 adversité noire !</strong>` })
+      this.incDecAdversite("bleue", 1)
+      this.incDecAdversite("noire", 1)
+    } else if (ame.etat == tresTraumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé et subit 1 adversité bleue et 1 adversité noire !</strong>` })
+      this.incDecAdversite("bleue", 1)
+      this.incDecAdversite("noire", 1)
+    } else if (ame.etat >= briseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé et subit 1 adversité noire !</strong>` })
+      this.incDecAdversite("noire", 1)
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026103950.js

@@ -0,0 +1,896 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      console.log("Loading skills for personnage")
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArtefacts() {
+    return this.getItemSorted(["artefact"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // L'état d'Âme ne peut pas être inférieur au minimum (max dans le système)
+      let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+      if (changed.system.ame.etat < minAme) {
+        changed.system.ame.etat = minAme
+      }
+      // L'état d'Âme ne peut pas dépasser nbame (Brisé)
+      if (changed.system.ame.etat > this.system.ame.nbame) {
+        changed.system.ame.etat = this.system.ame.nbame
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max !== undefined && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat < changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    // Utiliser une vérification stricte car 0 (Serein) est une valeur valide
+    return this.system.ame.max !== undefined ? this.system.ame.max : this.system.ame.nbame
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    // L'état ne peut pas être inférieur au minimum (max dans le système)
+    let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+    ame.etat = Math.max(ame.etat, minAme)
+    // L'état ne peut pas dépasser nbame (Brisé)
+    ame.etat = Math.min(ame.etat, this.system.ame.nbame)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= this.system.ame.nbame) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let traumatiseValue = this.system.ame.nbame - 2
+    let tresTraumatiseValue = this.system.ame.nbame - 1
+    let briseValue = this.system.ame.nbame
+
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé
+    if (ame.etat == traumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Traumatisé et subit 1 adversité bleue et 1 adversité noire !</strong>` })
+      this.incDecAdversite("bleue", 1)
+      this.incDecAdversite("noire", 1)
+    } else if (ame.etat == tresTraumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé et subit 1 adversité bleue et 1 adversité noire !</strong>` })
+      this.incDecAdversite("bleue", 1)
+      this.incDecAdversite("noire", 1)
+    } else if (ame.etat >= briseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé et subit 1 adversité noire !</strong>` })
+      this.incDecAdversite("noire", 1)
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026132127.js

@@ -0,0 +1,893 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      console.log("Loading skills for personnage")
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // L'état d'Âme ne peut pas être inférieur au minimum (max dans le système)
+      let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+      if (changed.system.ame.etat < minAme) {
+        changed.system.ame.etat = minAme
+      }
+      // L'état d'Âme ne peut pas dépasser nbame (Brisé)
+      if (changed.system.ame.etat > this.system.ame.nbame) {
+        changed.system.ame.etat = this.system.ame.nbame
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max !== undefined && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat < changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    // Utiliser une vérification stricte car 0 (Serein) est une valeur valide
+    return this.system.ame.max !== undefined ? this.system.ame.max : this.system.ame.nbame
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    // L'état ne peut pas être inférieur au minimum (max dans le système)
+    let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+    ame.etat = Math.max(ame.etat, minAme)
+    // L'état ne peut pas dépasser nbame (Brisé)
+    ame.etat = Math.min(ame.etat, this.system.ame.nbame)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= this.system.ame.nbame) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let traumatiseValue = this.system.ame.nbame - 2
+    let tresTraumatiseValue = this.system.ame.nbame - 1
+    let briseValue = this.system.ame.nbame
+
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé
+    if (ame.etat == traumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Traumatisé et subit 1 adversité bleue et 1 adversité noire !</strong>` })
+      this.incDecAdversite("bleue", 1)
+      this.incDecAdversite("noire", 1)
+    } else if (ame.etat == tresTraumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé et subit 1 adversité bleue et 1 adversité noire !</strong>` })
+      this.incDecAdversite("bleue", 1)
+      this.incDecAdversite("noire", 1)
+    } else if (ame.etat >= briseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé et subit 1 adversité noire !</strong>` })
+      this.incDecAdversite("noire", 1)
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026132457.js

@@ -0,0 +1,893 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      console.log("Loading skills for personnage")
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getMutations() {
+    return this.getItemSorted(["mutation"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // L'état d'Âme ne peut pas être inférieur au minimum (max dans le système)
+      let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+      if (changed.system.ame.etat < minAme) {
+        changed.system.ame.etat = minAme
+      }
+      // L'état d'Âme ne peut pas dépasser nbame (Brisé)
+      if (changed.system.ame.etat > this.system.ame.nbame) {
+        changed.system.ame.etat = this.system.ame.nbame
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max !== undefined && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat < changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    // Utiliser une vérification stricte car 0 (Serein) est une valeur valide
+    return this.system.ame.max !== undefined ? this.system.ame.max : this.system.ame.nbame
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    // L'état ne peut pas être inférieur au minimum (max dans le système)
+    let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+    ame.etat = Math.max(ame.etat, minAme)
+    // L'état ne peut pas dépasser nbame (Brisé)
+    ame.etat = Math.min(ame.etat, this.system.ame.nbame)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= this.system.ame.nbame) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let traumatiseValue = this.system.ame.nbame - 2
+    let tresTraumatiseValue = this.system.ame.nbame - 1
+    let briseValue = this.system.ame.nbame
+
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé
+    if (ame.etat == traumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Traumatisé et subit 1 adversité bleue et 1 adversité noire !</strong>` })
+      this.incDecAdversite("bleue", 1)
+      this.incDecAdversite("noire", 1)
+    } else if (ame.etat == tresTraumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé et subit 1 adversité bleue et 1 adversité noire !</strong>` })
+      this.incDecAdversite("bleue", 1)
+      this.incDecAdversite("noire", 1)
+    } else if (ame.etat >= briseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé et subit 1 adversité noire !</strong>` })
+      this.incDecAdversite("noire", 1)
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026132651.js

@@ -0,0 +1,890 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      console.log("Loading skills for personnage")
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // L'état d'Âme ne peut pas être inférieur au minimum (max dans le système)
+      let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+      if (changed.system.ame.etat < minAme) {
+        changed.system.ame.etat = minAme
+      }
+      // L'état d'Âme ne peut pas dépasser nbame (Brisé)
+      if (changed.system.ame.etat > this.system.ame.nbame) {
+        changed.system.ame.etat = this.system.ame.nbame
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max !== undefined && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat < changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    // Utiliser une vérification stricte car 0 (Serein) est une valeur valide
+    return this.system.ame.max !== undefined ? this.system.ame.max : this.system.ame.nbame
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    // L'état ne peut pas être inférieur au minimum (max dans le système)
+    let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+    ame.etat = Math.max(ame.etat, minAme)
+    // L'état ne peut pas dépasser nbame (Brisé)
+    ame.etat = Math.min(ame.etat, this.system.ame.nbame)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= this.system.ame.nbame) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let traumatiseValue = this.system.ame.nbame - 2
+    let tresTraumatiseValue = this.system.ame.nbame - 1
+    let briseValue = this.system.ame.nbame
+
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé
+    if (ame.etat == traumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Traumatisé et subit 1 adversité bleue et 1 adversité noire !</strong>` })
+      this.incDecAdversite("bleue", 1)
+      this.incDecAdversite("noire", 1)
+    } else if (ame.etat == tresTraumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé et subit 1 adversité bleue et 1 adversité noire !</strong>` })
+      this.incDecAdversite("bleue", 1)
+      this.incDecAdversite("noire", 1)
+    } else if (ame.etat >= briseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé et subit 1 adversité noire !</strong>` })
+      this.incDecAdversite("noire", 1)
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026132939.js

@@ -0,0 +1,890 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      console.log("Loading skills for personnage")
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getContacts() {
+    return this.getItemSorted(["contact"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // L'état d'Âme ne peut pas être inférieur au minimum (max dans le système)
+      let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+      if (changed.system.ame.etat < minAme) {
+        changed.system.ame.etat = minAme
+      }
+      // L'état d'Âme ne peut pas dépasser nbame (Brisé)
+      if (changed.system.ame.etat > this.system.ame.nbame) {
+        changed.system.ame.etat = this.system.ame.nbame
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max !== undefined && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat < changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    // Utiliser une vérification stricte car 0 (Serein) est une valeur valide
+    return this.system.ame.max !== undefined ? this.system.ame.max : this.system.ame.nbame
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    // L'état ne peut pas être inférieur au minimum (max dans le système)
+    let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+    ame.etat = Math.max(ame.etat, minAme)
+    // L'état ne peut pas dépasser nbame (Brisé)
+    ame.etat = Math.min(ame.etat, this.system.ame.nbame)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= this.system.ame.nbame) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let traumatiseValue = this.system.ame.nbame - 2
+    let tresTraumatiseValue = this.system.ame.nbame - 1
+    let briseValue = this.system.ame.nbame
+
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé
+    if (ame.etat == traumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Traumatisé et subit 1 adversité bleue et 1 adversité noire !</strong>` })
+      this.incDecAdversite("bleue", 1)
+      this.incDecAdversite("noire", 1)
+    } else if (ame.etat == tresTraumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé et subit 1 adversité bleue et 1 adversité noire !</strong>` })
+      this.incDecAdversite("bleue", 1)
+      this.incDecAdversite("noire", 1)
+    } else if (ame.etat >= briseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé et subit 1 adversité noire !</strong>` })
+      this.incDecAdversite("noire", 1)
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026133228.js

@@ -0,0 +1,887 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      console.log("Loading skills for personnage")
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // L'état d'Âme ne peut pas être inférieur au minimum (max dans le système)
+      let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+      if (changed.system.ame.etat < minAme) {
+        changed.system.ame.etat = minAme
+      }
+      // L'état d'Âme ne peut pas dépasser nbame (Brisé)
+      if (changed.system.ame.etat > this.system.ame.nbame) {
+        changed.system.ame.etat = this.system.ame.nbame
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max !== undefined && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat < changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    // Utiliser une vérification stricte car 0 (Serein) est une valeur valide
+    return this.system.ame.max !== undefined ? this.system.ame.max : this.system.ame.nbame
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    // L'état ne peut pas être inférieur au minimum (max dans le système)
+    let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+    ame.etat = Math.max(ame.etat, minAme)
+    // L'état ne peut pas dépasser nbame (Brisé)
+    ame.etat = Math.min(ame.etat, this.system.ame.nbame)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= this.system.ame.nbame) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let traumatiseValue = this.system.ame.nbame - 2
+    let tresTraumatiseValue = this.system.ame.nbame - 1
+    let briseValue = this.system.ame.nbame
+
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé
+    if (ame.etat == traumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Traumatisé et subit 1 adversité bleue et 1 adversité noire !</strong>` })
+      this.incDecAdversite("bleue", 1)
+      this.incDecAdversite("noire", 1)
+    } else if (ame.etat == tresTraumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé et subit 1 adversité bleue et 1 adversité noire !</strong>` })
+      this.incDecAdversite("bleue", 1)
+      this.incDecAdversite("noire", 1)
+    } else if (ame.etat >= briseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé et subit 1 adversité noire !</strong>` })
+      this.incDecAdversite("noire", 1)
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-actor_20251026133244.js

@@ -0,0 +1,887 @@
+/* -------------------------------------------- */
+import { MournbladeCYD2Utility } from "./mournblade-cyd2-utility.js";
+import { MournbladeCYD2RollDialog } from "./mournblade-cyd2-roll-dialog.js";
+
+/* -------------------------------------------- */
+const __degatsBonus = [-2, -2, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 8, 9, 9, 10, 10]
+const __vitesseBonus = [-2, -2, -1, -1, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
+
+/* -------------------------------------------- */
+/**
+ * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
+ * @extends {Actor}
+ */
+export class MournbladeCYD2Actor extends Actor {
+
+  /* -------------------------------------------- */
+  /**
+   * Override the create() function to provide additional SoS functionality.
+   *
+   * 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.
+   *
+   */
+
+  static async create(data, options) {
+
+    // Case of compendium global import
+    if (data instanceof Array) {
+      return super.create(data, options);
+    }
+    // If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
+    if (data.items) {
+      let actor = super.create(data, options);
+      return actor;
+    }
+
+    if (data.type == 'personnage') {
+      console.log("Loading skills for personnage")
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills")
+      data.items = skills.map(i => i.toObject())
+    }
+    if (data.type == 'creature') {
+      const skills = await MournbladeCYD2Utility.loadCompendium("fvtt-mournblade-cyd2.skills-creatures")
+      data.items = skills.map(i => i.toObject())
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-mournblade-cyd2/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+    }
+
+    return super.create(data, options);
+  }
+
+  /* -------------------------------------------- */
+  getBonusDefenseFromTalents() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  prepareArme(arme) {
+    arme = foundry.utils.duplicate(arme)
+    let combat = this.getCombatValues()
+    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
+      let bonusDefense = this.getBonusDefenseFromTalents()
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
+      arme.system.attrKey = "pui"
+      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
+      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff + (this.system.combat.monte ? 3 : 0)
+      arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense + bonusDefense + (this.system.combat.monte ? 3 : 0)
+      console.log("Arme", arme.system.totalDefensif, combat, arme.system.competence.system.niveau, arme.system.seuildefense, bonusDefense)
+      arme.system.isdefense = true
+      arme.system.isMelee = true
+      arme.system.isDistance = false
+    }
+    if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
+      arme.system.competence = foundry.utils.duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
+      arme.system.attrKey = "adr"
+      arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
+      arme.system.totalDegats = arme.system.degats
+      arme.system.isMelee = false
+      arme.system.isDistance = true
+      if (arme.system.isdefense) {
+        arme.system.totalDefensif = combat.defenseTotal + arme.system.competence.system.niveau + arme.system.seuildefense
+      }
+    }
+    return arme
+  }
+
+  /* -------------------------------------------- */
+  getItemSorted(types) {
+    let items = this.items.filter(item => types.includes(item.type)) || []
+    MournbladeCYD2Utility.sortArrayObjectsByName(items)
+    return items
+  }
+  getWeapons() {
+    let armes = []
+    for (let arme of this.items) {
+      if (arme.type == "arme") {
+        armes.push(this.prepareArme(arme))
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(armes)
+    return armes
+  }
+  getMonnaies() {
+    return this.getItemSorted(["monnaie"])
+  }
+  getEquipments() {
+    return this.getItemSorted(["equipement"])
+  }
+  getArmors() {
+    return this.getItemSorted(["protection"])
+  }
+  getHistoriques() {
+    return this.getItemSorted(["historique"])
+  }
+  getProfils() {
+    return this.getItemSorted(["profil"])
+  }
+  getTalents() {
+    return this.getItemSorted(["talent"])
+  }
+  getRessources() {
+    return this.getItemSorted(["ressource"])
+  }
+  getDons() {
+    return this.getItemSorted(["don"])
+  }
+  getPactes() {
+    return this.getItemSorted(["pacte"])
+  }
+  getTendances() {
+    return this.getItemSorted(["tendance"])
+  }
+  getRunes() {
+    return this.getItemSorted(["rune"])
+  }
+  getTraitsChaotiques() {
+    return this.getItemSorted(["traitchaotique"])
+  }
+  getTraitsEspeces() {
+    return this.getItemSorted(["traitespece"])
+  }
+
+  /* -------------------------------------------- */
+  getAspect() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? this.system.balance.loi : this.system.balance.chaos
+  }
+  getMarge() {
+    return Math.abs(this.system.balance.loi - this.system.balance.chaos)
+  }
+  getAlignement() {
+    return (this.system.balance.loi > this.system.balance.chaos) ? "loyal" : "chaotique"
+  }
+
+  /* -------------------------------------------- */
+  getSkills() {
+    let comp = []
+    for (let item of this.items) {
+      item = foundry.utils.duplicate(item)
+      if (item.type == "competence") {
+        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
+        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
+        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
+        if (item.system.niveau == 0) {
+          item.system.attribut1total -= 3
+          item.system.attribut2total -= 3
+          item.system.attribut3total -= 3
+        }
+        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
+        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
+        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
+        comp.push(item)
+      }
+    }
+    MournbladeCYD2Utility.sortArrayObjectsByName(comp)
+    return comp
+  }
+
+  /* -----------------------  --------------------- */
+  addMember(actorId) {
+    let members = foundry.utils.duplicate(this.system.members)
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
+  }
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
+  }
+
+  /* -------------------------------------------- */
+  getDefenseBase() {
+    return Math.max(this.system.attributs.tre.value, this.system.attributs.adr.value)
+  }
+
+  /* -------------------------------------------- */
+  getVitesseBase() {
+    return 5 + __vitesseBonus[this.system.attributs.adr.value]
+  }
+  /* -------------------------------------------- */
+  getProtection() {
+    let equipProtection = 0
+    for (let armor of this.items) {
+      if (armor.type == "protection" && armor.system.equipped) {
+        equipProtection += Number(armor.system.protection)
+      }
+    }
+    if (equipProtection < 4) {
+      return 4 + equipProtection // Cas des boucliers + sans armure
+    }
+    return equipProtection // Uniquement la protection des armures + boucliers
+  }
+
+  /* -------------------------------------------- */
+  getCombatValues() {
+    let combat = {
+      initBase: this.system.attributs.adr.value,
+      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
+      bonusDegats: this.getBonusDegats(),
+      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
+      vitesseBase: this.getVitesseBase(),
+      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
+      defenseBase: this.getDefenseBase(),
+      protection: this.getProtection(),
+      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite() + (this.system.combat.defensetotale ? 3 : 0)
+    }
+    return combat
+  }
+
+  /* -------------------------------------------- */
+  prepareBaseData() {
+  }
+
+  /* -------------------------------------------- */
+  async prepareData() {
+    super.prepareData();
+  }
+
+  /* -------------------------------------------- */
+  prepareDerivedData() {
+
+    if (this.type == 'personnage') {
+      let talentBonus = this.getVigueurBonus()
+      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus + this.system.sante.vigueurmodifier
+      if (vigueur != this.system.sante.vigueur) {
+        this.update({ 'system.sante.vigueur': vigueur })
+      }
+
+      let seuilPouvoirBonus = this.getSeuilPouvoirBonus()
+      let seuilPouvoir = Math.floor((this.system.attributs.tre.value + this.system.attributs.cla.value) / 2) + seuilPouvoirBonus + this.system.ame.seuilpouvoirmodifier
+      if (seuilPouvoir != this.system.ame.seuilpouvoir) {
+        this.update({ 'system.ame.seuilpouvoir': seuilPouvoir })
+      }
+    }
+    super.prepareDerivedData()
+  }
+
+  /* -------------------------------------------- */
+  _preUpdate(changed, options, user) {
+    if (changed?.system?.sante?.etat && changed?.system?.sante?.etat != this.system.sante.etat) {
+      setTimeout(() => {
+        this.processCombativite(changed.system.sante)
+      }, 800)
+    }
+    if (changed?.system?.ame?.etat && changed?.system?.ame?.etat != this.system.ame.etat) {
+      // L'état d'Âme ne peut pas être inférieur au minimum (max dans le système)
+      let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+      if (changed.system.ame.etat < minAme) {
+        changed.system.ame.etat = minAme
+      }
+      // L'état d'Âme ne peut pas dépasser nbame (Brisé)
+      if (changed.system.ame.etat > this.system.ame.nbame) {
+        changed.system.ame.etat = this.system.ame.nbame
+      }
+      setTimeout(() => {
+        this.processAme(changed.system.ame)
+      }, 800)
+    }
+    // Si le max d'Âme change, ajuster l'état actuel si nécessaire
+    if (changed?.system?.ame?.max !== undefined && changed.system.ame.max != this.system.ame.max) {
+      if (this.system.ame.etat < changed.system.ame.max) {
+        changed.system.ame.etat = changed.system.ame.max
+      }
+    }
+    super._preUpdate(changed, options, user);
+  }
+
+  /* -------------------------------------------- */
+  _onUpdate(data, options, user) {
+    super._onUpdate(data, options, user);
+  }
+  /* -------------------------------------------- */
+  getItemById(id) {
+    let item = this.items.find(item => item.id == id);
+    if (item) {
+      item = foundry.utils.duplicate(item)
+    }
+    return item;
+  }
+
+  /* -------------------------------------------- */
+  async equipItem(itemId) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item && item.system) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped }
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  editItemField(itemId, itemType, itemField, dataType, value) {
+    let item = this.items.find(item => item.id == itemId)
+    if (item) {
+      console.log("Item ", item, itemField, dataType, value)
+      if (dataType.toLowerCase() == "number") {
+        value = Number(value)
+      } else {
+        value = String(value)
+      }
+      let update = { _id: item.id, [`system.${itemField}`]: value };
+      this.updateEmbeddedDocuments("Item", [update])
+    }
+  }
+
+  /* -------------------------------------------- */
+  checkAttribut(attribut, minLevel) {
+    let attr = this.system.attributs.find(at => at.labelnorm == attribut.toLowerCase())
+    if (attr && attr.value >= minLevel) {
+      return { isValid: true, attr: foundry.utils.duplicate(attr) }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  checkAttributOrCompetenceLevel(compName, minLevel) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase() && i.system.niveau >= minLevel)
+    if (comp) {
+      return { isValid: true, item: foundry.utils.duplicate(comp) }
+    } else {
+      for (let attrKey in this.system.attributs) {
+        if (this.system.attributs[attrKey].label.toLowerCase() == compName.toLowerCase() && this.system.attributs[attrKey].value >= minLevel) {
+          return { isValid: true, item: foundry.utils.duplicate(this.system.attributs[attrKey]) }
+        }
+      }
+    }
+    return { isValid: false, warningMessage: `Prérequis insuffisant : la compétence/attribut ${compName} doit être de niveau ${minLevel} au minimum` }
+  }
+  /* -------------------------------------------- */
+  addCompetenceBonus(compName, bonus, baCost) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      comp = foundry.utils.duplicate(comp)
+      comp.system.bonus = bonus
+      comp.system.baCost = baCost
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false, warningMessage: `Compétence ${compName} non trouvée` }
+  }
+  /* -------------------------------------------- */
+  checkIfCompetence(compName) {
+    let comp = this.items.find(i => i.type == "competence" && i.name.toLowerCase() == compName.toLowerCase())
+    if (comp) {
+      return { isValid: true, item: comp }
+    }
+    return { isValid: false }
+  }
+  /* -------------------------------------------- */
+  getVigueur() {
+    return this.system.sante.vigueur
+  }
+
+  /* -------------------------------------------- */
+  getVigueurBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "vigueur") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoir() {
+    return this.system.ame.seuilpouvoir
+  }
+
+  /* -------------------------------------------- */
+  getSeuilPouvoirBonus() {
+    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
+    let bonus = 0
+    for (let talent of talents) {
+      for (let auto of talent.system.automations) {
+        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "seuilpouvoir") {
+          bonus += Number(auto.bonus || 0)
+        }
+      }
+    }
+    return bonus
+  }
+
+  /* -------------------------------------------- */
+  getAmeMax() {
+    // Utiliser une vérification stricte car 0 (Serein) est une valeur valide
+    return this.system.ame.max !== undefined ? this.system.ame.max : this.system.ame.nbame
+  }
+
+  /* -------------------------------------------- */
+  getBonneAventure() {
+    return this.system.bonneaventure.actuelle
+  }
+  /* -------------------------------------------- */
+  checkBonneAventure(cost) {
+    return (this.system.bonneaventure.actuelle >= cost)
+  }
+  /* -------------------------------------------- */
+  changeBonneAventure(value) {
+    let newBA = this.system.bonneaventure.actuelle
+    newBA += value
+    this.update({ 'system.bonneaventure.actuelle': newBA })
+  }
+
+  /* -------------------------------------------- */
+  getEclat() {
+    return this.system.eclat.value
+  }
+
+  /* -------------------------------------------- */
+  changeEclat(value) {
+    let newE = this.system.eclat.value
+    newE += value
+    this.update({ 'system.eclat.value': newE })
+  }
+
+  /* -------------------------------------------- */
+  compareName(a, b) {
+    if (a.name < b.name) {
+      return -1;
+    }
+    if (a.name > b.name) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getAttribute(attrKey) {
+    return this.system.attributes[attrKey]
+  }
+
+  /* -------------------------------------------- */
+  getBonusDegats() {
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  changeEtatCombativite(value) {
+    if (value === "vaincu") {
+      value = 200
+    }
+    let sante = foundry.utils.duplicate(this.system.sante)
+    sante.etat += Number(value)
+    sante.etat = Math.max(sante.etat, 0)
+    sante.etat = Math.min(sante.etat, this.system.sante.nbcombativite)
+    this.update({ 'system.sante': sante })
+    if (sante.etat == this.system.sante.nbcombativite) {
+      ChatMessage.create({ content: `<strong>${this.name} est vaincu !</strong>` })
+    }
+    // Duplicated ! this.processCombativite(sante)
+  }
+
+  /* -------------------------------------------- */
+  changeEtatAme(value) {
+    if (value === "brise") {
+      value = 200
+    }
+    let ame = foundry.utils.duplicate(this.system.ame)
+    ame.etat += Number(value)
+    // L'état ne peut pas être inférieur au minimum (max dans le système)
+    let minAme = this.system.ame.max !== undefined ? this.system.ame.max : 0
+    ame.etat = Math.max(ame.etat, minAme)
+    // L'état ne peut pas dépasser nbame (Brisé)
+    ame.etat = Math.min(ame.etat, this.system.ame.nbame)
+    this.update({ 'system.ame': ame })
+    if (ame.etat >= this.system.ame.nbame) {
+      ChatMessage.create({ content: `<strong>${this.name} est brisé !</strong>` })
+    }
+  }
+
+  /* -------------------------------------------- */
+  processCombativite(sante) {
+    sante = sante || foundry.utils.duplicate(this.system.sante)
+    // Gestion des états affaibli et très affaibli
+    if (sante.etat == this.system.sante.nbcombativite - 2 || sante.etat == this.system.sante.nbcombativite - 1) {
+      if (sante.etat == this.system.sante.nbcombativite - 2 && this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "encaissement")) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Encaissement. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else if (sante.etat == this.system.sante.nbcombativite - 1 && this.items.find(item => item.type == "talent" && item.name.toLowerCase().includes("vaillant"))) {
+        ChatMessage.create({ content: `<strong>${this.name} ne subit pas les 2 adversités rouge grâce à Vaillant. Pensez à les ajouter à la fin de la scène !</strong>` })
+      } else {
+        ChatMessage.create({ content: `<strong>${this.name} subit 2 adversités rouge !</strong>` })
+        this.incDecAdversite("rouge", 2)
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  processAme(ame) {
+    ame = ame || foundry.utils.duplicate(this.system.ame)
+    let traumatiseValue = this.system.ame.nbame - 2
+    let tresTraumatiseValue = this.system.ame.nbame - 1
+    let briseValue = this.system.ame.nbame
+
+    // Gestion des états Traumatisé, Très Traumatisé et Brisé
+    if (ame.etat == traumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Traumatisé et subit 1 adversité bleue et 1 adversité noire !</strong>` })
+      this.incDecAdversite("bleue", 1)
+      this.incDecAdversite("noire", 1)
+    } else if (ame.etat == tresTraumatiseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Très Traumatisé et subit 1 adversité bleue et 1 adversité noire !</strong>` })
+      this.incDecAdversite("bleue", 1)
+      this.incDecAdversite("noire", 1)
+    } else if (ame.etat >= briseValue) {
+      ChatMessage.create({ content: `<strong>${this.name} est Brisé et subit 1 adversité noire !</strong>` })
+      this.incDecAdversite("noire", 1)
+    }
+  }
+
+  /* -------------------------------------------- */
+  async equipGear(equipmentId) {
+    let item = this.items.find(item => item.id == equipmentId);
+    if (item?.system?.data) {
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
+      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSubActors() {
+    let subActors = [];
+    for (let id of this.system.subactors) {
+      subActors.push(foundry.utils.duplicate(game.actors.get(id)));
+    }
+    return subActors;
+  }
+  /* -------------------------------------------- */
+  async addSubActor(subActorId) {
+    let subActors = foundry.utils.duplicate(this.system.subactors);
+    subActors.push(subActorId);
+    await this.update({ 'system.subactors': subActors });
+  }
+  /* -------------------------------------------- */
+  async delSubActor(subActorId) {
+    let newArray = [];
+    for (let id of this.system.subactors) {
+      if (id != subActorId) {
+        newArray.push(id);
+      }
+    }
+    await this.update({ 'system.subactors': newArray });
+  }
+
+  /* -------------------------------------------- */
+  getTotalAdversite() {
+    return this.system.adversite.bleue + this.system.adversite.rouge + this.system.adversite.noire
+  }
+
+  /* -------------------------------------------- */
+  async incDecAdversite(adv, incDec = 0) {
+    let adversite = foundry.utils.duplicate(this.system.adversite)
+    adversite[adv] += Number(incDec)
+    adversite[adv] = Math.max(adversite[adv], 0)
+    adversite[adv] = Math.min(adversite[adv], 20)
+    this.update({ 'system.adversite': adversite })
+  }
+  /* -------------------------------------------- */
+  async incDecQuantity(objetId, incDec = 0) {
+    let objetQ = this.items.get(objetId)
+    if (objetQ) {
+      let newQ = objetQ.system.quantite + incDec
+      newQ = Math.max(newQ, 0)
+      await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantite': newQ }]); // pdates one EmbeddedEntity
+    }
+  }
+
+  /* -------------------------------------------- */
+  computeRichesse() {
+    let valueSC = 0
+    for (let monnaie of this.items) {
+      if (monnaie.type == "monnaie") {
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  computeValeurEquipement() {
+    let valueSC = 0
+    for (let equip of this.items) {
+      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
+      }
+    }
+    return MournbladeCYD2Utility.computeMonnaieDetails(valueSC)
+  }
+
+  /* -------------------------------------------- */
+  getCompetence(compId) {
+    return this.items.get(compId)
+  }
+
+  /* -------------------------------------------- */
+  async setPredilectionUsed(compId, predIdx) {
+    let comp = this.items.get(compId)
+    let pred = foundry.utils.duplicate(comp.system.predilections)
+    pred[predIdx].used = true
+    await this.updateEmbeddedDocuments('Item', [{ _id: compId, 'system.predilections': pred }])
+  }
+
+  /* -------------------------------------------- */
+  getInitiativeScore() {
+    let init = this.getFlag("world", "last-initiative")
+    return init || -1
+  }
+
+  /* -------------------------------------------- */
+  getBestAttackValue() {
+    let attackList = this.items.filter(item => (item.type == "arme" || item.type == "talent") && item.system.equipped)
+    let maxOff = 0
+    let bestArme
+    for (let arme of attackList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalOffensif > maxOff) {
+        maxOff = arme.system.totalOffensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  getBestDefenseValue() {
+    let defenseList = this.items.filter(item => (item.type == "arme") && item.system.equipped)
+    let maxDef = 0
+    let bestArme
+    for (let arme of defenseList) {
+      if (arme.type == "arme") {
+        arme = this.prepareArme(arme)
+      }
+      if (arme.system.totalDefensif > maxDef) {
+        maxDef = arme.system.totalDefensif
+        bestArme = foundry.utils.duplicate(arme)
+      }
+    }
+    return bestArme
+  }
+
+  /* -------------------------------------------- */
+  searchRelevantTalents(competence) {
+    let talents = []
+
+    for (let talent of this.items) {
+      if (talent.type == "talent" && talent.system.isautomated && talent.system.automations.length > 0) {
+        for (let auto of talent.system.automations) {
+          if (auto.eventtype === "prepare-roll") {
+            if (auto.competence.toLowerCase() == competence.name.toLowerCase()) {
+              talent = foundry.utils.duplicate(talent)
+              talent.system.bonus = auto.bonus
+              talent.system.baCost = auto.baCost
+              talents.push(talent)
+            }
+          }
+        }
+      }
+    }
+    return talents
+  }
+
+  /* -------------------------------------------- */
+  buildListeAdversites() {
+    return []
+  }
+
+  /* -------------------------------------------- */
+  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+    let rollData = MournbladeCYD2Utility.getBasicRollData()
+    rollData.alias = this.name
+    rollData.actorImg = this.img
+    rollData.actorId = this.id
+    rollData.tokenId = this.token?.id
+    rollData.img = this.img
+    rollData.attributs = MournbladeCYD2Utility.getAttributs()
+    rollData.maitriseId = "none"
+    rollData.nbEclat = this.system.eclat.value
+    rollData.nbBA = this.system.bonneaventure.actuelle
+    rollData.nbAdversites = this.getTotalAdversite()
+    rollData.talents = []
+    rollData.attrKey2 = "none"
+    rollData.coupDevastateur = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "coup dévastateur" && !it.system.used)
+    rollData.hasAmbidextre = this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "ambidextre")
+    rollData.hasFeinte = this.system.bonneaventure.actuelle > 0 && this.items.find(it => it.type == "talent" && it.name.toLowerCase() == "feinte")
+    rollData.isMonte = this.system.combat.monte
+    rollData.config = game.system.mournbladecyd2.config
+
+    if (attrKey) {
+      rollData.attrKey = attrKey
+      if (attrKey != "tochoose") {
+        rollData.actionImg = "systems/fvtt-mournblade-cyd2/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
+        rollData.attr = foundry.utils.duplicate(this.system.attributs[attrKey])
+      }
+    }
+    if (compId) {
+      rollData.competence = foundry.utils.duplicate(this.items.get(compId) || {})
+      let maitrises = [{ key: "none", label: "Aucune" }]
+      rollData.competence.system.predilections.forEach(function (item) {
+        if (item.maitrise) {
+          maitrises.push({ key: item.id, label: item.name });
+        }
+      })
+      rollData.maitrises = maitrises // rollData.competence.system.predilections.filter(p => p.maitrise)
+      rollData.actionImg = rollData.competence?.img
+      rollData.talents = this.searchRelevantTalents(rollData.competence)
+    }
+    if (compName) {
+      rollData.competence = foundry.utils.duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
+      rollData.actionImg = rollData.competence?.img
+    }
+    return rollData
+  }
+
+  /* -------------------------------------------- */
+  async rollAttribut(attrKey, isInit = false) {
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
+    rollData.isInit = isInit
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(attrKey, compId) {
+    let rollData = this.getCommonRollData(attrKey, compId)
+    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
+    console.log("RollDatra", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeOffensif(armeId) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
+    rollData.arme = arme
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    console.log("ARME!", rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollAssommer() {
+    let rollData = this.getCommonRollData("pui", undefined, "Filouterie")
+    rollData.assomer = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollCoupBas() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.coupBas = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollImmobiliser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.immobiliser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollRepousser() {
+    let rollData = this.getCommonRollData("pui", undefined, "Mêlée")
+    rollData.repousser = true
+    rollData.conditionsCommunes = true
+    rollData.cibleconsciente = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+  /* -------------------------------------------- */
+  async rollDesengager() {
+    let rollData = this.getCommonRollData("adr", undefined, "Mouvements")
+    rollData.desengager = true
+    rollData.conditionsCommunes = true
+    MournbladeCYD2Utility.updateWithTarget(rollData)
+    let rollDialog = await MournbladeCYD2RollDialog.create(this, rollData)
+    rollDialog.render(true)
+  }
+
+  /* -------------------------------------------- */
+  async rollArmeDegats(armeId, targetVigueur = undefined, rollDataInput = undefined) {
+    let arme = this.items.get(armeId)
+    if (arme.type == "arme") {
+      arme = this.prepareArme(arme)
+    }
+    console.log("DEGATS", arme, targetVigueur, rollDataInput)
+    let roll
+    let bonus = 0
+    let bonus2 = 0
+
+    if (rollDataInput?.applyCoupDevastateur) {
+      bonus2 = Math.floor(this.system.attributs.pui.value / 2)
+      let talent = this.items.find(item => item.type == "talent" && item.name.toLowerCase() == "coup dévastateur")
+      this.updateEmbeddedDocuments('Item', [{ _id: talent.id, 'system.used': true }])
+    }
+
+    if (rollDataInput?.isHeroique) {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 5
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 6
+      }
+      roll = await new Roll("2d10rr10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    } else {
+      if (rollDataInput?.attaqueCharge) {
+        bonus = 3
+      }
+      if (rollDataInput?.chargeCavalerie) {
+        bonus = 4
+      }
+      roll = await new Roll("1d10+" + arme.system.totalDegats + "+" + bonus + "+" + bonus2).roll()
+    }
+    await MournbladeCYD2Utility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
+    let nbEtatPerdus = 0
+    if (targetVigueur) {
+      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
+    }
+    //console.log(roll)
+    let rollData = {
+      arme: arme,
+      finalResult: roll.total,
+      formula: roll.formula,
+      alias: this.name,
+      actorImg: this.img,
+      actorId: this.id,
+      defenderTokenId: rollDataInput?.defenderTokenId,
+      actionImg: arme.img,
+      targetVigueur: targetVigueur,
+      nbEtatPerdus: nbEtatPerdus
+    }
+    MournbladeCYD2Utility.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-mournblade-cyd2/templates/chat-degats-result.html`, rollData)
+    })
+
+    if (rollDataInput?.defenderTokenId && nbEtatPerdus) {
+      MournbladeCYD2Utility.applyCombativite(rollDataInput, nbEtatPerdus)
+    }
+
+  }
+}

.history/modules/mournblade-cyd2-config_20251026082216.js

@@ -0,0 +1,144 @@
+export const MOURNBLADECYD2_CONFIG = {
+
+  optionsDifficulte: [
+    { key: "0", label: "Aucune/Inconnue" },
+    { key: "5", label: "Facile (5)" },
+    { key: "6", label: "(6)" },
+    { key: "7", label: "(7)" },
+    { key: "8", label: "(8)" },
+    { key: "9", label: "(9)" },
+    { key: "10", label: "Moyenne (10)" },
+    { key: "11", label: "(11)" },
+    { key: "12", label: "(12)" },
+    { key: "13", label: "(13)" },
+    { key: "14", label: "(14)" },
+    { key: "15", label: "Ardue (15)" },
+    { key: "16", label: "(16)" },
+    { key: "17", label: "(17)" },
+    { key: "18", label: "(18)" },
+    { key: "19", label: "(19)" },
+    { key: "20", label: "Hasardeuse (20)" },
+    { key: "21", label: "(21)" },
+    { key: "22", label: "(22)" },
+    { key: "23", label: "(23)" },
+    { key: "24", label: "(24)" },
+    { key: "25", label: "Insensée (25)" },
+    { key: "26", label: "(26)" },
+    { key: "27", label: "(27)" },
+    { key: "28", label: "(28)" },
+    { key: "29", label: "(29)" },
+    { key: "30", label: "Pure Folie (30)" }
+  ],
+  optionsDistanceTir: [
+    { key: "porteecourte", label: "Courte ({protectionDefenseur}+5)" },
+    { key: "porteemoyenne", label: "Moyenne ({protectionDefenseur}+9)" },
+    { key: "porteelongue", label: "Longue ({protectionDefenseur}+14)" }
+  ],
+  optionsBonusMalus: [
+    { key: "-10", label: "-10" },
+    { key: "-9", label: "-9" },
+    { key: "-8", label: "-8" },
+    { key: "-7", label: "-7" },
+    { key: "-6", label: "-6" },
+    { key: "-5", label: "-5" },
+    { key: "-4", label: "-4" },
+    { key: "-3", label: "-3" },
+    { key: "-2", label: "-2" },
+    { key: "-1", label: "-1" },
+    { key: "0", label: "0" },
+    { key: "1", label: "+1" },
+    { key: "2", label: "+2" },
+    { key: "3", label: "+3" },
+    { key: "4", label: "+4" },
+    { key: "5", label: "+5" },
+    { key: "6", label: "+6" },
+    { key: "7", label: "+7" },
+    { key: "8", label: "+8" },
+    { key: "9", label: "+9" },
+    { key: "10", label: "+10" }
+  ],
+  optionsTailleCible: [
+    { key: "normal", label: "Normal (SD+0)" },
+    { key: "main", label: "Main (SD+10)" },
+    { key: "enfant", label: "Enfant (SD+3)" },
+    { key: "maison", label: "Maison (SD-10)" }
+  ],
+  optionsCouvert: [
+    { key: "aucun", label: "Aucun" },
+    { key: "leger", label: "Léger (SD+5)" },
+    { key: "complet", label: "Quasi complet (SD+10)" }
+  ],
+  optionsTireurDeplacement: [
+    { key: "immobile", label: "Immobile (SD+0)" },
+    { key: "lent", label: "Lent (SD+3)" },
+    { key: "rapide", label: "Rapide (SD+5)" }
+  ],
+  optionsSoutiens: [
+    { key: "0", label: "Aucun" },
+    { key: "1", label: "Un soutien (+3)" },
+    { key: "2", label: "Deux soutiens (+4)" },
+    { key: "3", label: "Trois soutiens (+5)" }
+  ],
+  optionsStatutResistant: [
+    { key: "commun", label: "Commun" },
+    { key: "clandestin", label: "Clandestin" },
+    { key: "insurge", label: "Insurgé" }
+  ],
+  optionsTypeArme: [
+    {key: "contact", label: "Arme de contact"},
+    {key: "contactjet", label: "Arme de contact et de Jet"},
+    {key: "jet", label: "Arme de Jet"},
+    {key: "tir", label: "Arme de Tir"}
+  ],
+  optionsArtefactBranche: [
+    {key: "alchimie", label: "Alchimie"},
+    {key: "biologie", label: "Biologie"},
+    {key: "electricite", label: "Electricité"},
+    {key: "mecanique", label: "Mécanique"},
+    {key: "scienceesprit", label: "Science de l'Esprit"}
+  ],
+  optionsArtefactBranche2: [
+    {key: "none", label: "Aucune"},
+    {key: "alchimie", label: "Alchimie"},
+    {key: "biologie", label: "Biologie"},
+    {key: "electricite", label: "Electricité"},
+    {key: "mecanique", label: "Mécanique"},
+    {key: "scienceesprit", label: "Science de l'Esprit"}
+  ],
+  optionsTypeContact: [
+    {key: "contact", label: "Contact"},
+    {key: "allie", label: "Allié"}
+  ],
+  optionsTypeMutation: [
+    {key: "tares_communes", label: "Tares et Malformations communes"},
+    {key: "evolutions_communes", label: "Evolutions communes"},
+    {key: "tares_rares", label: "Tares et Malformations rares"},
+    {key: "evolutions_rares", label: "Evolutions rares"},
+    {key: "tares_majeures", label: "Tares et Maformations majeures"},
+    {key: "evolutions_majeures", label: "Evolutions majeures"},
+    {key: "tares_except", label: "Tares et Malformations exceptionnelles"},
+    {key: "evolutions_except", label: "Evolutions exceptionnelles"}
+  ],
+  optionsTypeTalent: [
+    {key: "personnage", label: "Personnage"},
+    {key: "cellule", label: "Cellule"},
+    {key: "traitespece", label: "Trait d'espèce"}
+  ],
+  optionsUseTalent: [
+    {key: "permanent", label: "Permanent"},
+    {key: "sceance", label: "Une fois par scéance"},
+    {key: "scenario", label: "Une fois par scénario"},
+    {key: "jour", label: "Une fois par jour"},
+    {key: "unique", label: "Unique"}
+  ],
+  optionsAutomationEvent: [
+    {key: "on-drop", label: "Drop sur l'acteur"},
+    {key: "prepare-roll", label: "Préparation d'un jet"},
+    {key: "bonus-permanent", label: "Bonus permanent"}
+  ],
+  optionsBonusPermanent: [
+    {key: "vigueur", label: "Vigueur"},
+    {key: "seuilpouvoir", label: "Seuil de Pouvoir"},
+    {key: "bonus-defensif", label: "Bonus au Seuil de Défense"}
+  ]
+}

.history/modules/mournblade-cyd2-config_20251026082310.js

@@ -0,0 +1,144 @@
+export const MOURNBLADECYD2_CONFIG = {
+
+  optionsDifficulte: [
+    { key: "0", label: "Aucune/Inconnue" },
+    { key: "5", label: "Facile (5)" },
+    { key: "6", label: "(6)" },
+    { key: "7", label: "(7)" },
+    { key: "8", label: "(8)" },
+    { key: "9", label: "(9)" },
+    { key: "10", label: "Moyenne (10)" },
+    { key: "11", label: "(11)" },
+    { key: "12", label: "(12)" },
+    { key: "13", label: "(13)" },
+    { key: "14", label: "(14)" },
+    { key: "15", label: "Ardue (15)" },
+    { key: "16", label: "(16)" },
+    { key: "17", label: "(17)" },
+    { key: "18", label: "(18)" },
+    { key: "19", label: "(19)" },
+    { key: "20", label: "Hasardeuse (20)" },
+    { key: "21", label: "(21)" },
+    { key: "22", label: "(22)" },
+    { key: "23", label: "(23)" },
+    { key: "24", label: "(24)" },
+    { key: "25", label: "Insensée (25)" },
+    { key: "26", label: "(26)" },
+    { key: "27", label: "(27)" },
+    { key: "28", label: "(28)" },
+    { key: "29", label: "(29)" },
+    { key: "30", label: "Pure Folie (30)" }
+  ],
+  optionsDistanceTir: [
+    { key: "porteecourte", label: "Courte ({protectionDefenseur}+5)" },
+    { key: "porteemoyenne", label: "Moyenne ({protectionDefenseur}+9)" },
+    { key: "porteelongue", label: "Longue ({protectionDefenseur}+14)" }
+  ],
+  optionsBonusMalus: [
+    { key: "-10", label: "-10" },
+    { key: "-9", label: "-9" },
+    { key: "-8", label: "-8" },
+    { key: "-7", label: "-7" },
+    { key: "-6", label: "-6" },
+    { key: "-5", label: "-5" },
+    { key: "-4", label: "-4" },
+    { key: "-3", label: "-3" },
+    { key: "-2", label: "-2" },
+    { key: "-1", label: "-1" },
+    { key: "0", label: "0" },
+    { key: "1", label: "+1" },
+    { key: "2", label: "+2" },
+    { key: "3", label: "+3" },
+    { key: "4", label: "+4" },
+    { key: "5", label: "+5" },
+    { key: "6", label: "+6" },
+    { key: "7", label: "+7" },
+    { key: "8", label: "+8" },
+    { key: "9", label: "+9" },
+    { key: "10", label: "+10" }
+  ],
+  optionsTailleCible: [
+    { key: "normal", label: "Normal (SD+0)" },
+    { key: "main", label: "Main (SD+10)" },
+    { key: "enfant", label: "Enfant (SD+3)" },
+    { key: "maison", label: "Maison (SD-10)" }
+  ],
+  optionsCouvert: [
+    { key: "aucun", label: "Aucun" },
+    { key: "leger", label: "Léger (SD+5)" },
+    { key: "complet", label: "Quasi complet (SD+10)" }
+  ],
+  optionsTireurDeplacement: [
+    { key: "immobile", label: "Immobile (SD+0)" },
+    { key: "lent", label: "Lent (SD+3)" },
+    { key: "rapide", label: "Rapide (SD+5)" }
+  ],
+  optionsSoutiens: [
+    { key: "0", label: "Aucun" },
+    { key: "1", label: "Un soutien (+3)" },
+    { key: "2", label: "Deux soutiens (+4)" },
+    { key: "3", label: "Trois soutiens (+5)" }
+  ],
+  optionsStatutResistant: [
+    { key: "commun", label: "Commun" },
+    { key: "clandestin", label: "Clandestin" },
+    { key: "insurge", label: "Insurgé" }
+  ],
+  optionsTypeArme: [
+    { key: "contact", label: "Arme de contact" },
+    { key: "contactjet", label: "Arme de contact et de Jet" },
+    { key: "jet", label: "Arme de Jet" },
+    { key: "tir", label: "Arme de Tir" }
+  ],
+  optionsArtefactBranche: [
+    { key: "alchimie", label: "Alchimie" },
+    { key: "biologie", label: "Biologie" },
+    { key: "electricite", label: "Electricité" },
+    { key: "mecanique", label: "Mécanique" },
+    { key: "scienceesprit", label: "Science de l'Esprit" }
+  ],
+  optionsArtefactBranche2: [
+    { key: "none", label: "Aucune" },
+    { key: "alchimie", label: "Alchimie" },
+    { key: "biologie", label: "Biologie" },
+    { key: "electricite", label: "Electricité" },
+    { key: "mecanique", label: "Mécanique" },
+    { key: "scienceesprit", label: "Science de l'Esprit" }
+  ],
+  optionsTypeContact: [
+    { key: "contact", label: "Contact" },
+    { key: "allie", label: "Allié" }
+  ],
+  optionsTypeMutation: [
+    { key: "tares_communes", label: "Tares et Malformations communes" },
+    { key: "evolutions_communes", label: "Evolutions communes" },
+    { key: "tares_rares", label: "Tares et Malformations rares" },
+    { key: "evolutions_rares", label: "Evolutions rares" },
+    { key: "tares_majeures", label: "Tares et Maformations majeures" },
+    { key: "evolutions_majeures", label: "Evolutions majeures" },
+    { key: "tares_except", label: "Tares et Malformations exceptionnelles" },
+    { key: "evolutions_except", label: "Evolutions exceptionnelles" }
+  ],
+  optionsTypeTalent: [
+    { key: "personnage", label: "Personnage" },
+    { key: "cellule", label: "Cellule" },
+    { key: "traitespece", label: "Trait d'espèce" }
+  ],
+  optionsUseTalent: [
+    { key: "permanent", label: "Permanent" },
+    { key: "sceance", label: "Une fois par scéance" },
+    { key: "scenario", label: "Une fois par scénario" },
+    { key: "jour", label: "Une fois par jour" },
+    { key: "unique", label: "Unique" }
+  ],
+  optionsAutomationEvent: [
+    { key: "on-drop", label: "Drop sur l'acteur" },
+    { key: "prepare-roll", label: "Préparation d'un jet" },
+    { key: "bonus-permanent", label: "Bonus permanent" }
+  ],
+  optionsBonusPermanent: [
+    { key: "vigueur", label: "Vigueur" },
+    { key: "seuilpouvoir", label: "Seuil de Pouvoir" },
+    { key: "bonus-defensif", label: "Bonus au Seuil de Défense" }
+  ]
+}

.history/modules/mournblade-cyd2-config_20251026095844.js

@@ -0,0 +1,143 @@
+export const MOURNBLADECYD2_CONFIG = {
+
+  optionsDifficulte: [
+    { key: "0", label: "Aucune/Inconnue" },
+    { key: "5", label: "Facile (5)" },
+    { key: "6", label: "(6)" },
+    { key: "7", label: "(7)" },
+    { key: "8", label: "(8)" },
+    { key: "9", label: "(9)" },
+    { key: "10", label: "Moyenne (10)" },
+    { key: "11", label: "(11)" },
+    { key: "12", label: "(12)" },
+    { key: "13", label: "(13)" },
+    { key: "14", label: "(14)" },
+    { key: "15", label: "Ardue (15)" },
+    { key: "16", label: "(16)" },
+    { key: "17", label: "(17)" },
+    { key: "18", label: "(18)" },
+    { key: "19", label: "(19)" },
+    { key: "20", label: "Hasardeuse (20)" },
+    { key: "21", label: "(21)" },
+    { key: "22", label: "(22)" },
+    { key: "23", label: "(23)" },
+    { key: "24", label: "(24)" },
+    { key: "25", label: "Insensée (25)" },
+    { key: "26", label: "(26)" },
+    { key: "27", label: "(27)" },
+    { key: "28", label: "(28)" },
+    { key: "29", label: "(29)" },
+    { key: "30", label: "Pure Folie (30)" }
+  ],
+  optionsDistanceTir: [
+    { key: "porteecourte", label: "Courte ({protectionDefenseur}+5)" },
+    { key: "porteemoyenne", label: "Moyenne ({protectionDefenseur}+9)" },
+    { key: "porteelongue", label: "Longue ({protectionDefenseur}+14)" }
+  ],
+  optionsBonusMalus: [
+    { key: "-10", label: "-10" },
+    { key: "-9", label: "-9" },
+    { key: "-8", label: "-8" },
+    { key: "-7", label: "-7" },
+    { key: "-6", label: "-6" },
+    { key: "-5", label: "-5" },
+    { key: "-4", label: "-4" },
+    { key: "-3", label: "-3" },
+    { key: "-2", label: "-2" },
+    { key: "-1", label: "-1" },
+    { key: "0", label: "0" },
+    { key: "1", label: "+1" },
+    { key: "2", label: "+2" },
+    { key: "3", label: "+3" },
+    { key: "4", label: "+4" },
+    { key: "5", label: "+5" },
+    { key: "6", label: "+6" },
+    { key: "7", label: "+7" },
+    { key: "8", label: "+8" },
+    { key: "9", label: "+9" },
+    { key: "10", label: "+10" }
+  ],
+  optionsTailleCible: [
+    { key: "normal", label: "Normal (SD+0)" },
+    { key: "main", label: "Main (SD+10)" },
+    { key: "enfant", label: "Enfant (SD+3)" },
+    { key: "maison", label: "Maison (SD-10)" }
+  ],
+  optionsCouvert: [
+    { key: "aucun", label: "Aucun" },
+    { key: "leger", label: "Léger (SD+5)" },
+    { key: "complet", label: "Quasi complet (SD+10)" }
+  ],
+  optionsTireurDeplacement: [
+    { key: "immobile", label: "Immobile (SD+0)" },
+    { key: "lent", label: "Lent (SD+3)" },
+    { key: "rapide", label: "Rapide (SD+5)" }
+  ],
+  optionsSoutiens: [
+    { key: "0", label: "Aucun" },
+    { key: "1", label: "Un soutien (+3)" },
+    { key: "2", label: "Deux soutiens (+4)" },
+    { key: "3", label: "Trois soutiens (+5)" }
+  ],
+  optionsStatutResistant: [
+    { key: "commun", label: "Commun" },
+    { key: "clandestin", label: "Clandestin" },
+    { key: "insurge", label: "Insurgé" }
+  ],
+  optionsTypeArme: [
+    { key: "contact", label: "Arme de contact" },
+    { key: "contactjet", label: "Arme de contact et de Jet" },
+    { key: "jet", label: "Arme de Jet" },
+    { key: "tir", label: "Arme de Tir" }
+  ],
+  optionsArtefactBranche: [
+    { key: "alchimie", label: "Alchimie" },
+    { key: "biologie", label: "Biologie" },
+    { key: "electricite", label: "Electricité" },
+    { key: "mecanique", label: "Mécanique" },
+    { key: "scienceesprit", label: "Science de l'Esprit" }
+  ],
+  optionsArtefactBranche2: [
+    { key: "none", label: "Aucune" },
+    { key: "alchimie", label: "Alchimie" },
+    { key: "biologie", label: "Biologie" },
+    { key: "electricite", label: "Electricité" },
+    { key: "mecanique", label: "Mécanique" },
+    { key: "scienceesprit", label: "Science de l'Esprit" }
+  ],
+  optionsTypeContact: [
+    { key: "contact", label: "Contact" },
+    { key: "allie", label: "Allié" }
+  ],
+  optionsTypeMutation: [
+    { key: "tares_communes", label: "Tares et Malformations communes" },
+    { key: "evolutions_communes", label: "Evolutions communes" },
+    { key: "tares_rares", label: "Tares et Malformations rares" },
+    { key: "evolutions_rares", label: "Evolutions rares" },
+    { key: "tares_majeures", label: "Tares et Maformations majeures" },
+    { key: "evolutions_majeures", label: "Evolutions majeures" },
+    { key: "tares_except", label: "Tares et Malformations exceptionnelles" },
+    { key: "evolutions_except", label: "Evolutions exceptionnelles" }
+  ],
+  optionsTypeTalent: [
+    { key: "personnage", label: "Personnage" },
+    { key: "traitespece", label: "Trait d'espèce" }
+  ],
+  optionsUseTalent: [
+    { key: "permanent", label: "Permanent" },
+    { key: "sceance", label: "Une fois par scéance" },
+    { key: "scenario", label: "Une fois par scénario" },
+    { key: "jour", label: "Une fois par jour" },
+    { key: "unique", label: "Unique" }
+  ],
+  optionsAutomationEvent: [
+    { key: "on-drop", label: "Drop sur l'acteur" },
+    { key: "prepare-roll", label: "Préparation d'un jet" },
+    { key: "bonus-permanent", label: "Bonus permanent" }
+  ],
+  optionsBonusPermanent: [
+    { key: "vigueur", label: "Vigueur" },
+    { key: "seuilpouvoir", label: "Seuil de Pouvoir" },
+    { key: "bonus-defensif", label: "Bonus au Seuil de Défense" }
+  ]
+}

.history/modules/mournblade-cyd2-config_20251026100139.js

@@ -0,0 +1,143 @@
+export const MOURNBLADECYD2_CONFIG = {
+
+  optionsDifficulte: [
+    { key: "0", label: "Aucune/Inconnue" },
+    { key: "5", label: "Facile (5)" },
+    { key: "6", label: "(6)" },
+    { key: "7", label: "(7)" },
+    { key: "8", label: "(8)" },
+    { key: "9", label: "(9)" },
+    { key: "10", label: "Moyenne (10)" },
+    { key: "11", label: "(11)" },
+    { key: "12", label: "(12)" },
+    { key: "13", label: "(13)" },
+    { key: "14", label: "(14)" },
+    { key: "15", label: "Ardue (15)" },
+    { key: "16", label: "(16)" },
+    { key: "17", label: "(17)" },
+    { key: "18", label: "(18)" },
+    { key: "19", label: "(19)" },
+    { key: "20", label: "Hasardeuse (20)" },
+    { key: "21", label: "(21)" },
+    { key: "22", label: "(22)" },
+    { key: "23", label: "(23)" },
+    { key: "24", label: "(24)" },
+    { key: "25", label: "Insensée (25)" },
+    { key: "26", label: "(26)" },
+    { key: "27", label: "(27)" },
+    { key: "28", label: "(28)" },
+    { key: "29", label: "(29)" },
+    { key: "30", label: "Pure Folie (30)" }
+  ],
+  optionsDistanceTir: [
+    { key: "porteecourte", label: "Courte ({protectionDefenseur}+5)" },
+    { key: "porteemoyenne", label: "Moyenne ({protectionDefenseur}+9)" },
+    { key: "porteelongue", label: "Longue ({protectionDefenseur}+14)" }
+  ],
+  optionsBonusMalus: [
+    { key: "-10", label: "-10" },
+    { key: "-9", label: "-9" },
+    { key: "-8", label: "-8" },
+    { key: "-7", label: "-7" },
+    { key: "-6", label: "-6" },
+    { key: "-5", label: "-5" },
+    { key: "-4", label: "-4" },
+    { key: "-3", label: "-3" },
+    { key: "-2", label: "-2" },
+    { key: "-1", label: "-1" },
+    { key: "0", label: "0" },
+    { key: "1", label: "+1" },
+    { key: "2", label: "+2" },
+    { key: "3", label: "+3" },
+    { key: "4", label: "+4" },
+    { key: "5", label: "+5" },
+    { key: "6", label: "+6" },
+    { key: "7", label: "+7" },
+    { key: "8", label: "+8" },
+    { key: "9", label: "+9" },
+    { key: "10", label: "+10" }
+  ],
+  optionsTailleCible: [
+    { key: "normal", label: "Normal (SD+0)" },
+    { key: "main", label: "Main (SD+10)" },
+    { key: "enfant", label: "Enfant (SD+3)" },
+    { key: "maison", label: "Maison (SD-10)" }
+  ],
+  optionsCouvert: [
+    { key: "aucun", label: "Aucun" },
+    { key: "leger", label: "Léger (SD+5)" },
+    { key: "complet", label: "Quasi complet (SD+10)" }
+  ],
+  optionsTireurDeplacement: [
+    { key: "immobile", label: "Immobile (SD+0)" },
+    { key: "lent", label: "Lent (SD+3)" },
+    { key: "rapide", label: "Rapide (SD+5)" }
+  ],
+  optionsSoutiens: [
+    { key: "0", label: "Aucun" },
+    { key: "1", label: "Un soutien (+3)" },
+    { key: "2", label: "Deux soutiens (+4)" },
+    { key: "3", label: "Trois soutiens (+5)" }
+  ],
+  optionsStatutResistant: [
+    { key: "commun", label: "Commun" },
+    { key: "clandestin", label: "Clandestin" },
+    { key: "insurge", label: "Insurgé" }
+  ],
+  optionsTypeArme: [
+    { key: "contact", label: "Arme de contact" },
+    { key: "contactjet", label: "Arme de contact et de Jet" },
+    { key: "jet", label: "Arme de Jet" },
+    { key: "tir", label: "Arme de Tir" }
+  ],
+  optionsArtefactBranche: [
+    { key: "alchimie", label: "Alchimie" },
+    { key: "biologie", label: "Biologie" },
+    { key: "electricite", label: "Electricité" },
+    { key: "mecanique", label: "Mécanique" },
+    { key: "scienceesprit", label: "Science de l'Esprit" }
+  ],
+  optionsArtefactBranche2: [
+    { key: "none", label: "Aucune" },
+    { key: "alchimie", label: "Alchimie" },
+    { key: "biologie", label: "Biologie" },
+    { key: "electricite", label: "Electricité" },
+    { key: "mecanique", label: "Mécanique" },
+    { key: "scienceesprit", label: "Science de l'Esprit" }
+  ],
+  optionsTypeContact: [
+    { key: "contact", label: "Contact" },
+    { key: "allie", label: "Allié" }
+  ],
+  optionsTypeMutation: [
+    { key: "tares_communes", label: "Tares et Malformations communes" },
+    { key: "evolutions_communes", label: "Evolutions communes" },
+    { key: "tares_rares", label: "Tares et Malformations rares" },
+    { key: "evolutions_rares", label: "Evolutions rares" },
+    { key: "tares_majeures", label: "Tares et Maformations majeures" },
+    { key: "evolutions_majeures", label: "Evolutions majeures" },
+    { key: "tares_except", label: "Tares et Malformations exceptionnelles" },
+    { key: "evolutions_except", label: "Evolutions exceptionnelles" }
+  ],
+  optionsTypeTalent: [
+    { key: "personnage", label: "Personnage" },
+    { key: "traitespece", label: "Trait d'espèce" }
+  ],
+  optionsUseTalent: [
+    { key: "permanent", label: "Permanent" },
+    { key: "sceance", label: "Une fois par scéance" },
+    { key: "scenario", label: "Une fois par scénario" },
+    { key: "jour", label: "Une fois par jour" },
+    { key: "unique", label: "Unique" }
+  ],
+  optionsAutomationEvent: [
+    { key: "on-drop", label: "Drop sur l'acteur" },
+    { key: "prepare-roll", label: "Préparation d'un jet" },
+    { key: "bonus-permanent", label: "Bonus permanent" }
+  ],
+  optionsBonusPermanent: [
+    { key: "vigueur", label: "Vigueur" },
+    { key: "seuilpouvoir", label: "Seuil de Pouvoir" },
+    { key: "bonus-defensif", label: "Bonus au Seuil de Défense" }
+  ]
+}

.history/modules/mournblade-cyd2-config_20251026132250.js

@@ -0,0 +1,128 @@
+export const MOURNBLADECYD2_CONFIG = {
+
+  optionsDifficulte: [
+    { key: "0", label: "Aucune/Inconnue" },
+    { key: "5", label: "Facile (5)" },
+    { key: "6", label: "(6)" },
+    { key: "7", label: "(7)" },
+    { key: "8", label: "(8)" },
+    { key: "9", label: "(9)" },
+    { key: "10", label: "Moyenne (10)" },
+    { key: "11", label: "(11)" },
+    { key: "12", label: "(12)" },
+    { key: "13", label: "(13)" },
+    { key: "14", label: "(14)" },
+    { key: "15", label: "Ardue (15)" },
+    { key: "16", label: "(16)" },
+    { key: "17", label: "(17)" },
+    { key: "18", label: "(18)" },
+    { key: "19", label: "(19)" },
+    { key: "20", label: "Hasardeuse (20)" },
+    { key: "21", label: "(21)" },
+    { key: "22", label: "(22)" },
+    { key: "23", label: "(23)" },
+    { key: "24", label: "(24)" },
+    { key: "25", label: "Insensée (25)" },
+    { key: "26", label: "(26)" },
+    { key: "27", label: "(27)" },
+    { key: "28", label: "(28)" },
+    { key: "29", label: "(29)" },
+    { key: "30", label: "Pure Folie (30)" }
+  ],
+  optionsDistanceTir: [
+    { key: "porteecourte", label: "Courte ({protectionDefenseur}+5)" },
+    { key: "porteemoyenne", label: "Moyenne ({protectionDefenseur}+9)" },
+    { key: "porteelongue", label: "Longue ({protectionDefenseur}+14)" }
+  ],
+  optionsBonusMalus: [
+    { key: "-10", label: "-10" },
+    { key: "-9", label: "-9" },
+    { key: "-8", label: "-8" },
+    { key: "-7", label: "-7" },
+    { key: "-6", label: "-6" },
+    { key: "-5", label: "-5" },
+    { key: "-4", label: "-4" },
+    { key: "-3", label: "-3" },
+    { key: "-2", label: "-2" },
+    { key: "-1", label: "-1" },
+    { key: "0", label: "0" },
+    { key: "1", label: "+1" },
+    { key: "2", label: "+2" },
+    { key: "3", label: "+3" },
+    { key: "4", label: "+4" },
+    { key: "5", label: "+5" },
+    { key: "6", label: "+6" },
+    { key: "7", label: "+7" },
+    { key: "8", label: "+8" },
+    { key: "9", label: "+9" },
+    { key: "10", label: "+10" }
+  ],
+  optionsTailleCible: [
+    { key: "normal", label: "Normal (SD+0)" },
+    { key: "main", label: "Main (SD+10)" },
+    { key: "enfant", label: "Enfant (SD+3)" },
+    { key: "maison", label: "Maison (SD-10)" }
+  ],
+  optionsCouvert: [
+    { key: "aucun", label: "Aucun" },
+    { key: "leger", label: "Léger (SD+5)" },
+    { key: "complet", label: "Quasi complet (SD+10)" }
+  ],
+  optionsTireurDeplacement: [
+    { key: "immobile", label: "Immobile (SD+0)" },
+    { key: "lent", label: "Lent (SD+3)" },
+    { key: "rapide", label: "Rapide (SD+5)" }
+  ],
+  optionsSoutiens: [
+    { key: "0", label: "Aucun" },
+    { key: "1", label: "Un soutien (+3)" },
+    { key: "2", label: "Deux soutiens (+4)" },
+    { key: "3", label: "Trois soutiens (+5)" }
+  ],
+  optionsStatutResistant: [
+    { key: "commun", label: "Commun" },
+    { key: "clandestin", label: "Clandestin" },
+    { key: "insurge", label: "Insurgé" }
+  ],
+  optionsTypeArme: [
+    { key: "contact", label: "Arme de contact" },
+    { key: "contactjet", label: "Arme de contact et de Jet" },
+    { key: "jet", label: "Arme de Jet" },
+    { key: "tir", label: "Arme de Tir" }
+  ],
+  optionsTypeContact: [
+    { key: "contact", label: "Contact" },
+    { key: "allie", label: "Allié" }
+  ],
+  optionsTypeMutation: [
+    { key: "tares_communes", label: "Tares et Malformations communes" },
+    { key: "evolutions_communes", label: "Evolutions communes" },
+    { key: "tares_rares", label: "Tares et Malformations rares" },
+    { key: "evolutions_rares", label: "Evolutions rares" },
+    { key: "tares_majeures", label: "Tares et Maformations majeures" },
+    { key: "evolutions_majeures", label: "Evolutions majeures" },
+    { key: "tares_except", label: "Tares et Malformations exceptionnelles" },
+    { key: "evolutions_except", label: "Evolutions exceptionnelles" }
+  ],
+  optionsTypeTalent: [
+    { key: "personnage", label: "Personnage" },
+    { key: "traitespece", label: "Trait d'espèce" }
+  ],
+  optionsUseTalent: [
+    { key: "permanent", label: "Permanent" },
+    { key: "sceance", label: "Une fois par scéance" },
+    { key: "scenario", label: "Une fois par scénario" },
+    { key: "jour", label: "Une fois par jour" },
+    { key: "unique", label: "Unique" }
+  ],
+  optionsAutomationEvent: [
+    { key: "on-drop", label: "Drop sur l'acteur" },
+    { key: "prepare-roll", label: "Préparation d'un jet" },
+    { key: "bonus-permanent", label: "Bonus permanent" }
+  ],
+  optionsBonusPermanent: [
+    { key: "vigueur", label: "Vigueur" },
+    { key: "seuilpouvoir", label: "Seuil de Pouvoir" },
+    { key: "bonus-defensif", label: "Bonus au Seuil de Défense" }
+  ]
+}

.history/modules/mournblade-cyd2-config_20251026132458.js

@@ -0,0 +1,128 @@
+export const MOURNBLADECYD2_CONFIG = {
+
+  optionsDifficulte: [
+    { key: "0", label: "Aucune/Inconnue" },
+    { key: "5", label: "Facile (5)" },
+    { key: "6", label: "(6)" },
+    { key: "7", label: "(7)" },
+    { key: "8", label: "(8)" },
+    { key: "9", label: "(9)" },
+    { key: "10", label: "Moyenne (10)" },
+    { key: "11", label: "(11)" },
+    { key: "12", label: "(12)" },
+    { key: "13", label: "(13)" },
+    { key: "14", label: "(14)" },
+    { key: "15", label: "Ardue (15)" },
+    { key: "16", label: "(16)" },
+    { key: "17", label: "(17)" },
+    { key: "18", label: "(18)" },
+    { key: "19", label: "(19)" },
+    { key: "20", label: "Hasardeuse (20)" },
+    { key: "21", label: "(21)" },
+    { key: "22", label: "(22)" },
+    { key: "23", label: "(23)" },
+    { key: "24", label: "(24)" },
+    { key: "25", label: "Insensée (25)" },
+    { key: "26", label: "(26)" },
+    { key: "27", label: "(27)" },
+    { key: "28", label: "(28)" },
+    { key: "29", label: "(29)" },
+    { key: "30", label: "Pure Folie (30)" }
+  ],
+  optionsDistanceTir: [
+    { key: "porteecourte", label: "Courte ({protectionDefenseur}+5)" },
+    { key: "porteemoyenne", label: "Moyenne ({protectionDefenseur}+9)" },
+    { key: "porteelongue", label: "Longue ({protectionDefenseur}+14)" }
+  ],
+  optionsBonusMalus: [
+    { key: "-10", label: "-10" },
+    { key: "-9", label: "-9" },
+    { key: "-8", label: "-8" },
+    { key: "-7", label: "-7" },
+    { key: "-6", label: "-6" },
+    { key: "-5", label: "-5" },
+    { key: "-4", label: "-4" },
+    { key: "-3", label: "-3" },
+    { key: "-2", label: "-2" },
+    { key: "-1", label: "-1" },
+    { key: "0", label: "0" },
+    { key: "1", label: "+1" },
+    { key: "2", label: "+2" },
+    { key: "3", label: "+3" },
+    { key: "4", label: "+4" },
+    { key: "5", label: "+5" },
+    { key: "6", label: "+6" },
+    { key: "7", label: "+7" },
+    { key: "8", label: "+8" },
+    { key: "9", label: "+9" },
+    { key: "10", label: "+10" }
+  ],
+  optionsTailleCible: [
+    { key: "normal", label: "Normal (SD+0)" },
+    { key: "main", label: "Main (SD+10)" },
+    { key: "enfant", label: "Enfant (SD+3)" },
+    { key: "maison", label: "Maison (SD-10)" }
+  ],
+  optionsCouvert: [
+    { key: "aucun", label: "Aucun" },
+    { key: "leger", label: "Léger (SD+5)" },
+    { key: "complet", label: "Quasi complet (SD+10)" }
+  ],
+  optionsTireurDeplacement: [
+    { key: "immobile", label: "Immobile (SD+0)" },
+    { key: "lent", label: "Lent (SD+3)" },
+    { key: "rapide", label: "Rapide (SD+5)" }
+  ],
+  optionsSoutiens: [
+    { key: "0", label: "Aucun" },
+    { key: "1", label: "Un soutien (+3)" },
+    { key: "2", label: "Deux soutiens (+4)" },
+    { key: "3", label: "Trois soutiens (+5)" }
+  ],
+  optionsStatutResistant: [
+    { key: "commun", label: "Commun" },
+    { key: "clandestin", label: "Clandestin" },
+    { key: "insurge", label: "Insurgé" }
+  ],
+  optionsTypeArme: [
+    { key: "contact", label: "Arme de contact" },
+    { key: "contactjet", label: "Arme de contact et de Jet" },
+    { key: "jet", label: "Arme de Jet" },
+    { key: "tir", label: "Arme de Tir" }
+  ],
+  optionsTypeContact: [
+    { key: "contact", label: "Contact" },
+    { key: "allie", label: "Allié" }
+  ],
+  optionsTypeMutation: [
+    { key: "tares_communes", label: "Tares et Malformations communes" },
+    { key: "evolutions_communes", label: "Evolutions communes" },
+    { key: "tares_rares", label: "Tares et Malformations rares" },
+    { key: "evolutions_rares", label: "Evolutions rares" },
+    { key: "tares_majeures", label: "Tares et Maformations majeures" },
+    { key: "evolutions_majeures", label: "Evolutions majeures" },
+    { key: "tares_except", label: "Tares et Malformations exceptionnelles" },
+    { key: "evolutions_except", label: "Evolutions exceptionnelles" }
+  ],
+  optionsTypeTalent: [
+    { key: "personnage", label: "Personnage" },
+    { key: "traitespece", label: "Trait d'espèce" }
+  ],
+  optionsUseTalent: [
+    { key: "permanent", label: "Permanent" },
+    { key: "sceance", label: "Une fois par scéance" },
+    { key: "scenario", label: "Une fois par scénario" },
+    { key: "jour", label: "Une fois par jour" },
+    { key: "unique", label: "Unique" }
+  ],
+  optionsAutomationEvent: [
+    { key: "on-drop", label: "Drop sur l'acteur" },
+    { key: "prepare-roll", label: "Préparation d'un jet" },
+    { key: "bonus-permanent", label: "Bonus permanent" }
+  ],
+  optionsBonusPermanent: [
+    { key: "vigueur", label: "Vigueur" },
+    { key: "seuilpouvoir", label: "Seuil de Pouvoir" },
+    { key: "bonus-defensif", label: "Bonus au Seuil de Défense" }
+  ]
+}

.history/modules/mournblade-cyd2-config_20251026132740.js

@@ -0,0 +1,118 @@
+export const MOURNBLADECYD2_CONFIG = {
+
+  optionsDifficulte: [
+    { key: "0", label: "Aucune/Inconnue" },
+    { key: "5", label: "Facile (5)" },
+    { key: "6", label: "(6)" },
+    { key: "7", label: "(7)" },
+    { key: "8", label: "(8)" },
+    { key: "9", label: "(9)" },
+    { key: "10", label: "Moyenne (10)" },
+    { key: "11", label: "(11)" },
+    { key: "12", label: "(12)" },
+    { key: "13", label: "(13)" },
+    { key: "14", label: "(14)" },
+    { key: "15", label: "Ardue (15)" },
+    { key: "16", label: "(16)" },
+    { key: "17", label: "(17)" },
+    { key: "18", label: "(18)" },
+    { key: "19", label: "(19)" },
+    { key: "20", label: "Hasardeuse (20)" },
+    { key: "21", label: "(21)" },
+    { key: "22", label: "(22)" },
+    { key: "23", label: "(23)" },
+    { key: "24", label: "(24)" },
+    { key: "25", label: "Insensée (25)" },
+    { key: "26", label: "(26)" },
+    { key: "27", label: "(27)" },
+    { key: "28", label: "(28)" },
+    { key: "29", label: "(29)" },
+    { key: "30", label: "Pure Folie (30)" }
+  ],
+  optionsDistanceTir: [
+    { key: "porteecourte", label: "Courte ({protectionDefenseur}+5)" },
+    { key: "porteemoyenne", label: "Moyenne ({protectionDefenseur}+9)" },
+    { key: "porteelongue", label: "Longue ({protectionDefenseur}+14)" }
+  ],
+  optionsBonusMalus: [
+    { key: "-10", label: "-10" },
+    { key: "-9", label: "-9" },
+    { key: "-8", label: "-8" },
+    { key: "-7", label: "-7" },
+    { key: "-6", label: "-6" },
+    { key: "-5", label: "-5" },
+    { key: "-4", label: "-4" },
+    { key: "-3", label: "-3" },
+    { key: "-2", label: "-2" },
+    { key: "-1", label: "-1" },
+    { key: "0", label: "0" },
+    { key: "1", label: "+1" },
+    { key: "2", label: "+2" },
+    { key: "3", label: "+3" },
+    { key: "4", label: "+4" },
+    { key: "5", label: "+5" },
+    { key: "6", label: "+6" },
+    { key: "7", label: "+7" },
+    { key: "8", label: "+8" },
+    { key: "9", label: "+9" },
+    { key: "10", label: "+10" }
+  ],
+  optionsTailleCible: [
+    { key: "normal", label: "Normal (SD+0)" },
+    { key: "main", label: "Main (SD+10)" },
+    { key: "enfant", label: "Enfant (SD+3)" },
+    { key: "maison", label: "Maison (SD-10)" }
+  ],
+  optionsCouvert: [
+    { key: "aucun", label: "Aucun" },
+    { key: "leger", label: "Léger (SD+5)" },
+    { key: "complet", label: "Quasi complet (SD+10)" }
+  ],
+  optionsTireurDeplacement: [
+    { key: "immobile", label: "Immobile (SD+0)" },
+    { key: "lent", label: "Lent (SD+3)" },
+    { key: "rapide", label: "Rapide (SD+5)" }
+  ],
+  optionsSoutiens: [
+    { key: "0", label: "Aucun" },
+    { key: "1", label: "Un soutien (+3)" },
+    { key: "2", label: "Deux soutiens (+4)" },
+    { key: "3", label: "Trois soutiens (+5)" }
+  ],
+  optionsStatutResistant: [
+    { key: "commun", label: "Commun" },
+    { key: "clandestin", label: "Clandestin" },
+    { key: "insurge", label: "Insurgé" }
+  ],
+  optionsTypeArme: [
+    { key: "contact", label: "Arme de contact" },
+    { key: "contactjet", label: "Arme de contact et de Jet" },
+    { key: "jet", label: "Arme de Jet" },
+    { key: "tir", label: "Arme de Tir" }
+  ],
+  optionsTypeContact: [
+    { key: "contact", label: "Contact" },
+    { key: "allie", label: "Allié" }
+  ],
+  optionsTypeTalent: [
+    { key: "personnage", label: "Personnage" },
+    { key: "traitespece", label: "Trait d'espèce" }
+  ],
+  optionsUseTalent: [
+    { key: "permanent", label: "Permanent" },
+    { key: "sceance", label: "Une fois par scéance" },
+    { key: "scenario", label: "Une fois par scénario" },
+    { key: "jour", label: "Une fois par jour" },
+    { key: "unique", label: "Unique" }
+  ],
+  optionsAutomationEvent: [
+    { key: "on-drop", label: "Drop sur l'acteur" },
+    { key: "prepare-roll", label: "Préparation d'un jet" },
+    { key: "bonus-permanent", label: "Bonus permanent" }
+  ],
+  optionsBonusPermanent: [
+    { key: "vigueur", label: "Vigueur" },
+    { key: "seuilpouvoir", label: "Seuil de Pouvoir" },
+    { key: "bonus-defensif", label: "Bonus au Seuil de Défense" }
+  ]
+}