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

Reviewed-on: #662
v10.7.20 - la cuirasse de Sémolosse
2023-07-12 08:09:06 +02:00 · 2023-07-12 00:46:46 +02:00 · 2023-07-12 00:39:21 +02:00 · 2023-06-19 15:36:32 +02:00 · 2023-06-15 02:02:00 +02:00 · 2023-06-15 01:59:17 +02:00
40 changed files with 816 additions and 476 deletions
--- a/changelog.md
+++ b/changelog.md
@ -1,37 +1,63 @@
-# v10.7 - L'os de Semolosse
+# v10.7 - L'os de Sémolosse

-## v10.7.18 - le repos de Semolosse
+## v10.7.20 - la poigne de Sémolosse
+- correction de méthodes qui filtrent les items
+  - recherche de cases TMR
+  - recherche de tâches de lecture
+  - recherche d'armure (pour le malus armure)
+  - recherche de potions
+
+## v10.7.20 - la poigne de Sémolosse
+- correction de l'empoignade
+  - les items d'empoignade sont ajoutés par le MJ quand nécessaire
+  - seul le joueur propriétaire du personnage peut effectuer ses choix et actions d'empoignade
+  - les caractéristiques du défenseur sont utilisées pour la défense
+  - la difficulté d'attaque est imposée au défenseur
+  - les attaques particulières sont en finesse (p133)
+  - on peut entraîner au sol dès 2 points d'empoignade
+  - les actions liée à l'immobilisation sont proposées en fin de round
+
+## v10.7.19 - les fantômes de Sémolosse
+- les créatures ont maintenant le droit d'avoir des compétences de tir, lancer, mêlée, armes naturelles, parade.
+- les créatures armées utilisent la bonne phase d'initiative
+- correction des possessions
+  - la difficulté de la défense est imposée par l'attaque
+  - une attaque particulière de possession est en finesse
+  - le rêve actuel des personnages est bien utilisé
+- correction des achats par le MJ sans acteur sélectionné
+
+## v10.7.18 - le repos de Sémolosse
 - correction des dates de blessures qui ne marchaient plus

-## v10.7.17 - le doigt du destin de Semolosse
+## v10.7.17 - le doigt du destin de Sémolosse
 - correction de la validation d'encaissement par le MJ

-## v10.7.16 - la morsure de Semolosse
+## v10.7.16 - la morsure de Sémolosse
 - correction de l'affichage des objets suite à confusion
 - correction de liens dans la liste des équipements

-## v10.7.14 - l'expérience de Semolosse
+## v10.7.14 - l'expérience de Sémolosse
 - Affichage des personnages accordés sur les fiches des entités
 - Refonte du journal d'expérience
  - disponible pour les personnages des joueurs
  - explication "comptable" des changements (dépense ou ajout, changements de niveaux, ...)
 - tri alphabétique des différentes listes (sorts, recettes, oeuvres, ...)

-## v10.7.13 - l'armure de Semolosse
+## v10.7.13 - l'armure de Sémolosse
 - Fix: en cas d'armure variable, la détérioration diminue le dé d'armure

 ## v10.7.12
 - Fix: si le MJ gère les changements de jours, l'option "sieste" de la fenêtre de repos est prise par défaut si chateau dormant n'est pas passé

-## v10.7.11 - Le Pugilat de Semolosse
+## v10.7.11 - Le Pugilat de Sémolosse
 - Fix sur la projection au sol.

-## v10.7.10 - Le Pugilat de Semolosse
+## v10.7.10 - Le Pugilat de Sémolosse
 - Gestion de l'empoignade
 - Corrections sur l'initiative
 - Correction sur l'equipement des vêtements et bijoux

-##  v10.7.9 - Le Pugilat de Semolosse
+##  v10.7.9 - Le Pugilat de Sémolosse

 - Gestion assistée de l'empoignade
  1. On selectionne sa cible (ie le token qui va être empoigné)
@ -97,14 +123,14 @@
 - Horloge
  - A l'heure de Couronne pile, les aiguilles des heures et des minutes pointent sur couronne (comme une montre) au lieu d'avoir l'aiguille des heures 15° à gauche

-## v10.7.2 - les maux de dents de Semolosse
+## v10.7.2 - les maux de dents de Sémolosse
 - correction des récupérations de blessures
 - la fin de château dormant se passe normalement

-## v10.7.1 - L'os de Semolosse
+## v10.7.1 - L'os de Sémolosse
 - Fix rapide sur les jets de carac qui n'étaient plus possibles

-## v10.7.0 - L'os de Semolosse
+## v10.7.0 - L'os de Sémolosse
 - gestion des blessures en items
 - soins du token ciblé par menu contextuel (comme le combat)
 - automatisation des soins et de l'affichage de l'avancement des soins
--- a/module/actor.js
+++ b/module/actor.js
@ -38,13 +38,14 @@ import { RdDItemBlessure } from "./item/blessure.js";
 import { AppAstrologie } from "./sommeil/app-astrologie.js";
 import { RdDEmpoignade } from "./rdd-empoignade.js";
 import { ExperienceLog, XP_TOPIC } from "./actor/experience-log.js";
+import { TYPES } from "./item.js";

 const POSSESSION_SANS_DRACONIC = {
  img: 'systems/foundryvtt-reve-de-dragon/icons/entites/possession.webp',
  name: 'Sans draconic',
  system: {
    niveau: 0,
-    defaut_carac: "reve",
+    defaut_carac: "reve-actuel",
  }
 };

@ -109,7 +110,7 @@ export class RdDActor extends RdDBaseActor {

  canReceive(item) {
    if (this.isCreature()) {
-      return item.type == 'competencecreature' || item.isInventaire();
+      return item.type == TYPES.competencecreature || item.isInventaire();
    }
    if (this.isEntite()) {
      return item.type == 'competencecreature';
@ -270,25 +271,26 @@ export class RdDActor extends RdDBaseActor {
  }

  getDraconicOuPossession() {
-    const possessions = this.items.filter(it => it.type == 'competencecreature' && it.system.ispossession)
-      .sort(Misc.descending(it => it.system.niveau));
-    if (possessions.length > 0) {
-      return duplicate(possessions[0]);
+    const possession = this.items.filter(it => it.type == TYPES.competencecreature && it.system.categorie == 'possession')
+      .sort(Misc.descending(it => it.system.niveau))
+      .find(it => true);
+    if (possession) {
+      return possession.clone();
    }
-    const draconics = [...this.getDraconicList().filter(it => it.system.niveau >= 0),
+    const draconics = [...this.getDraconicList().filter(it => it.system.niveau >= 0).map(it => it.clone()),
      POSSESSION_SANS_DRACONIC]
      .sort(Misc.descending(it => it.system.niveau));
-    return duplicate(draconics[0]);
+    return draconics[0];
  }

  getPossession(possessionId) {
-    return this.items.find(it => it.type == 'possession' && it.system.possessionid == possessionId);
+    return this.items.find(it => it.type == TYPES.possession && it.system.possessionid == possessionId);
  }
  getPossessions() {
-    return this.items.filter(it => it.type == 'possession');
+    return this.items.filter(it => it.type == TYPES.possession);
  }
  getEmpoignades() {
-    return this.items.filter(it => it.type == 'empoignade');
+    return this.items.filter(it => it.type == TYPES.empoignade);
  }
  getDemiReve() {
    return this.system.reve.tmrpos.coord;
@ -296,7 +298,7 @@ export class RdDActor extends RdDBaseActor {

  /* -------------------------------------------- */
  async verifierPotionsEnchantees() {
-    let potionsEnchantees = this.filterItems(it => it.type == 'potion' && it.system.categorie.toLowerCase().includes('enchant'));
+    let potionsEnchantees = this.filterItems(it => it.system.categorie.toLowerCase().includes('enchant'), 'potion');
    for (let potion of potionsEnchantees) {
      if (!potion.system.prpermanent) {
        console.log(potion);
@ -778,7 +780,7 @@ export class RdDActor extends RdDBaseActor {
  async combattreReveDeDragon(force) {
    let rollData = {
      actor: this,
-      competence: duplicate(this.getDraconicOuPossession()),
+      competence: this.getDraconicOuPossession(),
      canClose: false,
      rencontre: await game.system.rdd.rencontresTMR.getReveDeDragon(force),
      tmr: true,
@ -959,9 +961,9 @@ export class RdDActor extends RdDBaseActor {

  /* -------------------------------------------- */
  async updateCompetence(idOrName, compValue) {
-    let competence = this.getCompetence(idOrName);
+    const competence = this.getCompetence(idOrName);
    if (competence) {
-      let toNiveau = compValue ?? RdDItemCompetence.getNiveauBase(competence.system.categorie);
+      const toNiveau = compValue ?? RdDItemCompetence.getNiveauBase(competence.system.categorie, competence.getCategories());
      this.notifyCompetencesTronc(competence, toNiveau);
      const fromNiveau = competence.system.niveau;
      await this.updateEmbeddedDocuments('Item', [{ _id: competence.id, 'system.niveau': toNiveau }]);
@ -1122,7 +1124,7 @@ export class RdDActor extends RdDBaseActor {
  /* -------------------------------------------- */
  async computeMalusArmure() {
    if (this.isPersonnage()) {
-      const malusArmure = this.filterItems(it => it.type == 'armure' && it.system.equipe)
+      const malusArmure = this.filterItems(it => it.system.equipe, 'armure')
        .map(it => it.system.malus ?? 0)
        .reduce(Misc.sum(), 0);
      // Mise à jour éventuelle du malus armure
@ -1295,8 +1297,7 @@ export class RdDActor extends RdDBaseActor {

  /* -------------------------------------------- */
  buildTMRInnaccessible() {
-    const tmrInnaccessibles = this.filterItems(it => Draconique.isCaseTMR(it) &&
-      EffetsDraconiques.isInnaccessible(it));
+    const tmrInnaccessibles = this.filterItems(it => Draconique.isCaseTMR(it) && EffetsDraconiques.isInnaccessible(it));
    return tmrInnaccessibles.map(it => it.system.coord);
  }

@ -1360,21 +1361,46 @@ export class RdDActor extends RdDBaseActor {

  /* -------------------------------------------- */
  async finDeRound(options = { terminer: false }) {
+    await this.$finDeRoundSuppressionEffetsTermines(options);
+    await this.$finDeRoundBlessuresGraves();
+    await this.$finDeRoundSupprimerObsoletes();
+    await this.$finDeRoundEmpoignade();
+  }
+
+  async $finDeRoundSuppressionEffetsTermines(options) {
    for (let effect of this.getEffects()) {
      if (effect.duration.type !== 'none' && (effect.duration.remaining <= 0 || options.terminer)) {
        await effect.delete();
        ChatMessage.create({ content: `${this.name} n'est plus ${Misc.lowerFirst(game.i18n.localize(effect.system.label))} !` });
      }
    }
+  }
+
+  async $finDeRoundBlessuresGraves() {
    if (this.isPersonnage() || this.isCreature()) {
-      const nbGraves = this.filterItems(it => it.isGrave(), 'blessure').length
+      const nbGraves = this.filterItems(it => it.isGrave(), 'blessure').length;
      if (nbGraves > 0) {
        // Gestion blessure graves : -1 pt endurance par blessure grave
-        await this.santeIncDec("endurance", - nbGraves);
+        await this.santeIncDec("endurance", -nbGraves);
      }
    }
  }

+  async $finDeRoundSupprimerObsoletes() {
+    const obsoletes = []
+      .concat(this.itemTypes[TYPES.empoignade].filter(it => it.system.pointsemp <= 0))
+      .concat(this.itemTypes[TYPES.possession].filter(it => it.system.compteur < -2 || it.system.compteur > 2))
+      .map(it => it.id);
+    await this.deleteEmbeddedDocuments('Item', obsoletes);
+  }
+
+  async $finDeRoundEmpoignade(){
+    const immobilisations = this.itemTypes[TYPES.empoignade].filter(it => it.system.pointsemp >= 2 && it.system.empoigneurid == this.id);
+    immobilisations.forEach(emp => RdDEmpoignade.onImmobilisation(this, 
+      game.actors.get(emp.system.empoigneid),
+      emp
+    ))
+  }
  /* -------------------------------------------- */
  async setSonne(sonne = true) {
    if (this.isEntite()) {
@ -2299,14 +2325,14 @@ export class RdDActor extends RdDBaseActor {
      carac: this.system.carac,
      competence: this.getCompetence(idOrName)
    }
-    if (rollData.competence.type == 'competencecreature') {
-      if (rollData.competence.system.iscombat && options.tryTarget && Targets.hasTargets()) {
+    if (rollData.competence.type == TYPES.competencecreature) {
+      const arme = RdDItemCompetenceCreature.armeCreature(rollData.competence)
+      if (arme && options.tryTarget && Targets.hasTargets()) {
        Targets.selectOneToken(target => {
-          if (rollData.competence.system.ispossession) {
+          if (arme.action == "possession") {
            RdDPossession.onAttaquePossession(target, this, rollData.competence)
          }
          else {
-            const arme = RdDItemCompetenceCreature.armeNaturelle(rollData.competence)
            RdDCombat.rddCombatTarget(target, this).attaque(competence, arme)
          }
        });
@ -2336,8 +2362,7 @@ export class RdDActor extends RdDBaseActor {
  /* -------------------------------------------- */
  async creerTacheDepuisLivre(item, options = { renderSheet: true }) {
    const nomTache = "Lire " + item.name;
-    const filterTacheLecture = it => it.type == 'tache' && it.name == nomTache;
-    let tachesExistantes = this.filterItems(filterTacheLecture);
+    let tachesExistantes = findTache(nomTache);
    if (tachesExistantes.length == 0) {
      const tache = {
        name: nomTache, type: 'tache',
@ -2353,13 +2378,17 @@ export class RdDActor extends RdDBaseActor {
        }
      }
      await this.createEmbeddedDocuments('Item', [tache], options);
-      tachesExistantes = this.filterItems(filterTacheLecture);
+      tachesExistantes = findTache(nomTache)
    }
    return tachesExistantes.length > 0 ? tachesExistantes[0] : undefined;
+
+    function findTache(name) {
+      return this.filterItems(it => it.name == name, 'tache');
+    }
  }

  blessuresASoigner() {
-    // TODO or not TODO: filtrer les blessures poour lesquels on ne peut plus faire de premiers soins?
+    // TODO or not TODO: filtrer les blessures pour lesquelles on ne peut plus faire de premiers soins?
    return this.filterItems(it => it.system.gravite > 0 && it.system.gravite <= 6 && !(it.system.premierssoins.done && it.system.soinscomplets.done), 'blessure')
  }

@ -3053,7 +3082,7 @@ export class RdDActor extends RdDBaseActor {


      const competence = this.getCompetence(arme.system.competence)
-      if (competence.system.ispossession) {
+      if (competence.isCompetencePossession()) {
        return RdDPossession.onAttaquePossession(target, this, competence);
      }
      RdDCombat.rddCombatTarget(target, this).attaque(competence, arme);
@ -3133,9 +3162,7 @@ export class RdDActor extends RdDBaseActor {

  /* -------------------------------------------- */
  conjurerPossession(possession) {
-    // TODO: choix de la compétence de draconic ou de possession
-    let draconic = this.getDraconicOuPossession();
-    RdDPossession.onConjurerPossession(this, draconic, possession)
+    RdDPossession.onConjurerPossession(this, possession)
  }

  /* -------------------------------------------- */
--- a/module/actor/base-actor-sheet.js
+++ b/module/actor/base-actor-sheet.js
@ -3,7 +3,8 @@ import { Misc } from "../misc.js";
 import { DialogSplitItem } from "../dialog-split-item.js";
 import { RdDSheetUtility } from "../rdd-sheet-utility.js";
 import { Monnaie } from "../item-monnaie.js";
-import { RdDItem } from "../item.js";
+import { RdDItem, TYPES } from "../item.js";
+import { RdDItemCompetenceCreature } from "../item-competencecreature.js";

 /* -------------------------------------------- */
 /**
@ -53,6 +54,8 @@ export class RdDBaseActorSheet extends ActorSheet {
    this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.inventaires);
    this._appliquerRechercheObjets(formData.conteneurs, formData.inventaires);
    formData.conteneurs = RdDUtility.conteneursRacine(formData.conteneurs);
+    formData.competences.filter(it => it.type == TYPES.competencecreature)
+      .forEach(it => it.isdommages = RdDItemCompetenceCreature.isDommages(it))
    return formData;
  }

@ -125,27 +128,27 @@ export class RdDBaseActorSheet extends ActorSheet {
      .map(t => Misc.arrayOrEmpty(itemTypes[t]))
      .reduce((a, b) => a.concat(b), [])
      .sort(Misc.ascending(it => it.name));
-    }
-    
-    /* -------------------------------------------- */  /** @override */
-    activateListeners(html) {
-      super.activateListeners(html);
-      this.html = html;
-      
-      this.html.find('.conteneur-name a').click(async event => {
-        RdDUtility.toggleAfficheContenu(this.getItemId(event));
-        this.render(true);
-      });
-      this.html.find('.item-edit').click(async event => this.getItem(event)?.sheet.render(true))
-      this.html.find('.item-montrer').click(async event => this.getItem(event)?.postItemToChat());
-      this.html.find('.actor-montrer').click(async event => this.actor.postActorToChat());
-      this.html.find('.recherche')
-        .each((index, field) => {
-          this._rechercheSelectArea(field);
-        })
-        .keyup(async event => this._rechercherKeyup(event))
-        .change(async event => this._rechercherKeyup(event));
-    this.html.find('.recherche').prop( "disabled", false );
+  }
+
+  /* -------------------------------------------- */  /** @override */
+  activateListeners(html) {
+    super.activateListeners(html);
+    this.html = html;
+
+    this.html.find('.conteneur-name a').click(async event => {
+      RdDUtility.toggleAfficheContenu(this.getItemId(event));
+      this.render(true);
+    });
+    this.html.find('.item-edit').click(async event => this.getItem(event)?.sheet.render(true))
+    this.html.find('.item-montrer').click(async event => this.getItem(event)?.postItemToChat());
+    this.html.find('.actor-montrer').click(async event => this.actor.postActorToChat());
+    this.html.find('.recherche')
+      .each((index, field) => {
+        this._rechercheSelectArea(field);
+      })
+      .keyup(async event => this._rechercherKeyup(event))
+      .change(async event => this._rechercherKeyup(event));
+    this.html.find('.recherche').prop("disabled", false);
    // Everything below here is only needed if the sheet is editable
    if (!this.options.editable) return;

--- a/module/actor/base-actor.js
+++ b/module/actor/base-actor.js
@ -119,7 +119,7 @@ export class RdDBaseActor extends Actor {
  }

  listItems(type = undefined) { return (type ? this.itemTypes[type] : this.items); }
-  filterItems(filter, type = undefined) { return type ? this.itemTypes[type]?.filter(filter) ?? [] : []; }
+  filterItems(filter, type = undefined) { return (type ? this.itemTypes[type] : this.items)?.filter(filter); }
  findItemLike(idOrName, type) {
    return this.getItem(idOrName, type)
      ?? Misc.findFirstLike(idOrName, this.listItems(type), { description: Misc.typeName('Item', type) });
@ -144,6 +144,18 @@ export class RdDBaseActor extends Actor {
      .forEach(async it => await it.onFinPeriodeTemporel(oldTimestamp, newTimestamp))
  }

+  async creerObjetParMJ(object){
+    if (!Misc.isUniqueConnectedGM()) {
+      RdDBaseActor.remoteActorCall({
+        actorId: this.id,
+        method: 'creerObjetParMJ',
+        args: [object]
+      });
+      return;
+    }
+    await this.createEmbeddedDocuments('Item', [object])
+  }
+
  /* -------------------------------------------- */
  getFortune() {
    return Monnaie.getFortune(this.itemTypes['monnaie']);
@ -248,13 +260,12 @@ export class RdDBaseActor extends Actor {
    const vendeur = achat.vendeurId ? game.actors.get(achat.vendeurId) : undefined;
    const acheteur = achat.acheteurId ? game.actors.get(achat.acheteurId) : undefined;
    const quantite = (achat.choix.nombreLots ?? 1) * (achat.vente.tailleLot);
-    const itemVendu = vendeur?.getItem(achat.vente.item._id) ?? game.items.get(achat.vente.item._id) ?? achat.vente.item;
+    const itemVendu = vendeur?.getItem(achat.vente.item._id) ?? game.items.get(achat.vente.item._id);
    if (!itemVendu) {
-      ui.notifications.warn("Erreur sur achat: rien à acheter<br>Si possible, transmettez les logs de la console aux développeurs");
-      console.log('Erreur sur achat: rien à acheter', achat);
+      ChatUtility.notifyUser(achat.userId, 'warn', vendeur ? `Le vendeur n'a pas plus de ${achat.vente.item.name} !`: `Impossible de retrouver: ${achat.vente.item.name} !`);
      return;
    }
-    if (!this.verifierQuantite(vendeur, itemVendu, quantite)) {
+    if (vendeur && !this.verifierQuantite(itemVendu, quantite)) {
      ChatUtility.notifyUser(achat.userId, 'warn', `Le vendeur n'a pas assez de ${itemVendu.name} !`);
      return
    }
@ -265,7 +276,7 @@ export class RdDBaseActor extends Actor {
    await this.decrementerVente(vendeur, itemVendu, quantite, cout);
    if (acheteur) {
      await acheteur.depenserSols(cout);
-      const createdItemId = await acheteur.creerQuantiteItem(achat.vente.item, quantite);
+      const createdItemId = await acheteur.creerQuantiteItem(itemVendu, quantite);
      await acheteur.consommerNourritureAchetee(achat, achat.vente, createdItemId);
    }
    if (cout > 0) {
@ -306,9 +317,9 @@ export class RdDBaseActor extends Actor {
    return this.getFortune() >= cout;
  }

-  verifierQuantite(vendeur, item, quantiteTotal) {
-    const disponible = vendeur?.getQuantiteDisponible(item);
-    return disponible == undefined || disponible >= quantiteTotal;
+  verifierQuantite(item, quantiteDemande) {
+    const disponible = item?.getQuantite();
+    return disponible == undefined || disponible >= quantiteDemande;
  }

  async consommerNourritureAchetee(achat, vente, createdItemId) {
--- a/module/actor/commerce.js
+++ b/module/actor/commerce.js
@ -22,7 +22,7 @@ export class RdDCommerce extends RdDBaseActor {
  }

  getQuantiteDisponible(item) {
-    return this.system.illimite || item.isService() ? undefined : item.getQuantite();
+    return (this.system.illimite || item?.isService()) ? undefined : item.getQuantite();
  }

  verifierFortune(cout) {
--- a/module/chat-utility.js
+++ b/module/chat-utility.js
@ -78,11 +78,7 @@ export class ChatUtility {

  /* -------------------------------------------- */
  static async createChatWithRollMode(name, chatOptions) {
-    return await ChatUtility.createChatMessage(name, game.settings.get("core", "rollMode"), chatOptions);
-  }
-
-  /* -------------------------------------------- */
-  static async createChatMessage(name, rollMode, chatOptions) {
+    let rollMode = game.settings.get("core", "rollMode")
    switch (rollMode) {
      case "blindroll": // GM only
        if (!game.user.isGM) {
--- a/module/item-arme.js
+++ b/module/item-arme.js
@ -1,4 +1,5 @@
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js"
+import { TYPES } from "./item.js";
 import { RdDCombatManager } from "./rdd-combat.js";

 const nomCategorieParade = {
@ -19,7 +20,7 @@ const nomCategorieParade = {
 export class RdDItemArme extends Item {

  static isArme(item) {
-    return (item.type == 'competencecreature' && item.system.iscombat) || item.type == 'arme';
+    return RdDItemCompetenceCreature.getCategorieAttaque(item) || item.type == 'arme';
  }

  /* -------------------------------------------- */
@ -27,7 +28,7 @@ export class RdDItemArme extends Item {
    switch (arme ? arme.type : '') {
      case 'arme': return arme;
      case 'competencecreature':
-        return RdDItemCompetenceCreature.armeNaturelle(arme);
+        return RdDItemCompetenceCreature.armeCreature(arme);
    }
    return RdDItemArme.mainsNues();
  }
--- a/module/item-competence.js
+++ b/module/item-competence.js
@ -23,7 +23,7 @@ const limitesArchetypes = [
 ];

 /* -------------------------------------------- */
-const categorieCompetences = {
+const categoriesCompetences = {
  "generale": { base: -4, label: "Générales" },
  "particuliere": { base: -8, label: "Particulières" },
  "specialisee": { base: -11, label: "Spécialisées" },
@ -49,16 +49,16 @@ const competence_xp_cumul = _buildCumulXP();

 export class RdDItemCompetence extends Item {
  /* -------------------------------------------- */
-  static getCategorieCompetences() {
-    return categorieCompetences;
-  }
-  /* -------------------------------------------- */
-  static getNiveauBase(category) {
-    return categorieCompetences[category].base;
+  static getCategories() {
+    return categoriesCompetences;
  }
  /* -------------------------------------------- */
  static getLabelCategorie(category) {
-    return categorieCompetences[category].label;
+    return categoriesCompetences[category].label;
+  }
+  /* -------------------------------------------- */
+  static getNiveauBase(category, categories = categoriesCompetences) {
+    return categories[category]?.base ?? 0;
  }

  /* -------------------------------------------- */
@ -192,7 +192,7 @@ export class RdDItemCompetence extends Item {

  /* -------------------------------------------- */
  static isNiveauBase(item) {
-    return Number(item.system.niveau) == RdDItemCompetence.getNiveauBase(item.system.categorie);
+    return Number(item.system.niveau) == RdDItemCompetence.getNiveauBase(item.system.categorie, item.getCategories());
  }

  /* -------------------------------------------- */
--- a/module/item-competencecreature.js
+++ b/module/item-competencecreature.js
@ -1,51 +1,97 @@

+import { RdDItem, TYPES } from "./item.js";
 import { RdDCombatManager } from "./rdd-combat.js";

+const categories = {
+  "generale": { base: 0, label: "Générale" },
+  "naturelle": { base: 0, label: "Arme naturelle" },
+  "melee": { base: 0, label: "Mêlée" },
+  "parade": { base: 0, label: "Parade" },
+  "tir": { base: 0, label: "Tir" },
+  "lancer": { base: 0, label: "Lancer" },
+  "possession": { base: 0, label: "Possession" },
+}
+
 /* -------------------------------------------- */
 export class RdDItemCompetenceCreature extends Item {

-  /* -------------------------------------------- */
-  static setRollDataCreature(rollData) {
-    rollData.competence = rollData.competence
-    rollData.carac = { "carac_creature": { label: rollData.competence.name, value: rollData.competence.system.carac_value } }
-    rollData.competence.system.defaut_carac = "carac_creature"
-    rollData.competence.system.categorie = "creature"
-    rollData.selectedCarac =  rollData.carac.carac_creature
-    if (rollData.competence.system.iscombat) {
-      rollData.arme = RdDItemCompetenceCreature.armeNaturelle(rollData.competence);
-    }
+  static getCategories() {
+    return categories;
  }

  /* -------------------------------------------- */
-  static armeNaturelle(competencecreature) {
-    if (RdDItemCompetenceCreature.isCompetenceAttaque(competencecreature)) {
-      // si c'est un Item compétence: cloner pour ne pas modifier lma compétence
-      let arme = (competencecreature instanceof Item) ? competencecreature.clone():  competencecreature;
-      mergeObject(arme.system,
+  static setRollDataCreature(rollData) {
+    rollData.carac = { "carac_creature": { label: rollData.competence.name, value: rollData.competence.system.carac_value } }
+    rollData.competence.system.defaut_carac = "carac_creature"
+    rollData.selectedCarac = rollData.carac.carac_creature
+    rollData.arme = RdDItemCompetenceCreature.armeCreature(rollData.competence);
+  }
+
+  /* -------------------------------------------- */
+  static armeCreature(item) {
+    const categorieAttaque = RdDItemCompetenceCreature.getCategorieAttaque(item)
+    if (categorieAttaque != undefined) {
+      // si c'est un Item compétence: cloner pour ne pas modifier la compétence
+      let arme = item.clone();
+      mergeObject(arme,
        {
-          competence: arme.name,
-          initiative: RdDCombatManager.calculInitiative(competencecreature.system.niveau, competencecreature.system.carac_value),
-          niveau: competencecreature.system.niveau,
-          equipe: true,
-          resistance: 100,
-          dommagesReels: arme.system.dommages,
-          penetration: 0,
-          force: 0,
-          rapide: true,
-          cac: competencecreature.system.isnaturelle ? "naturelle" : "",
-          action: 'attaque'
+          action: item.isCompetencePossession() ? 'possession' : 'attaque',
+          system: {
+            competence: arme.name,
+            cac: categorieAttaque == "naturelle" ? "naturelle" : "",
+            niveau: item.system.niveau,
+            initiative: RdDCombatManager.calculInitiative(item.system.niveau, item.system.carac_value),
+            equipe: true,
+            resistance: 100,
+            dommagesReels: arme.system.dommages,
+            penetration: 0,
+            force: 0,
+            rapide: true,
+          }
        });
      return arme;
    }
-    console.error("RdDItemCompetenceCreature.toActionArme(", competencecreature, ") : impossible de transformer l'Item en arme");
    return undefined;
  }

  /* -------------------------------------------- */
-  static isCompetenceAttaque(item) {
-    return item.type == 'competencecreature' && item.system.iscombat;
+  static getCategorieAttaque(item) {
+    if (item.type == TYPES.competencecreature) {
+      switch (item.system.categorie) {
+        case "melee":
+        case "tir":
+        case "lancer":
+        case "naturelle":
+        case "possession":
+          return item.system.categorie
+      }
+    }
+    return undefined
  }
-  
+  static isDommages(item) {
+    if (item.type == TYPES.competencecreature) {
+      switch (item.system.categorie) {
+        case "melee":
+        case "tir":
+        case "lancer":
+        case "naturelle":
+          return true
+      }
+    }
+    return false
+  }
+  static isParade(item) {
+    if (item.type == TYPES.competencecreature) {
+      switch (item.system.categorie) {
+        case "melee":
+        case "naturelle":
+        case "parade":
+          return true
+      }
+    }
+    return false
+  }
+
  /* -------------------------------------------- */
  static isCompetenceParade(item) {
    return item.type == 'competencecreature' && item.system.categorie_parade !== "";
--- a/module/item-sheet.js
+++ b/module/item-sheet.js
@ -11,6 +11,8 @@ import { RdDSheetUtility } from "./rdd-sheet-utility.js";
 import { SystemCompendiums } from "./settings/system-compendiums.js";
 import { Misc } from "./misc.js";
 import { RdDTimestamp } from "./time/rdd-timestamp.js";
+import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
+import { TYPES } from "./item.js";

 /**
 * Extend the basic ItemSheet for RdD specific items
@ -98,9 +100,13 @@ export class RdDItemSheet extends ItemSheet {
      isComestible: this.item.getUtilisationCuisine(),
      options: RdDSheetUtility.mergeDocumentRights(this.options, this.item, this.isEditable)
    }
+    if (this.item.type == TYPES.competencecreature) {
+      formData.isparade = RdDItemCompetenceCreature.isParade(this.item)
+      formData.isdommages = RdDItemCompetenceCreature.isDommages(this.item)
+    }

    const competences = await SystemCompendiums.getCompetences('personnage');
-    formData.categorieCompetences = RdDItemCompetence.getCategorieCompetences()
+    formData.categories = this.item.getCategories()
    if (this.item.type == 'tache' || this.item.type == 'livre' || this.item.type == 'meditation' || this.item.type == 'oeuvre') {
      formData.caracList = duplicate(game.system.model.Actor.personnage.carac)
      formData.caracList["reve-actuel"] = duplicate(game.system.model.Actor.personnage.reve.reve)
@ -249,7 +255,8 @@ export class RdDItemSheet extends ItemSheet {
    event.preventDefault();

    if (this.item.isCompetence()) {
-      let level = RdDItemCompetence.getNiveauBase(event.currentTarget.value);
+      const categorie = event.currentTarget.value;
+      const level =  RdDItemCompetence.getNiveauBase(categorie, this.item.getCategories());
      this.item.system.base = level;
      this.html.find('[name="system.base"]').val(level);
    }
--- a/module/item.js
+++ b/module/item.js
@ -6,6 +6,8 @@ import { RdDTimestamp } from "./time/rdd-timestamp.js";
 import { RdDUtility } from "./rdd-utility.js";
 import { SystemCompendiums } from "./settings/system-compendiums.js";
 import { RdDRaretes } from "./item/raretes.js";
+import { RdDItemCompetence } from "./item-competence.js";
+import { RdDItemCompetenceCreature } from "./item-competencecreature.js";

 export const TYPES = {
  competence: 'competence',
@ -218,6 +220,7 @@ export class RdDItem extends Item {
  isService() { return this.type == TYPES.service; }

  isCompetence() { return typesObjetsCompetence.includes(this.type) }
+  isCompetencePossession() { return TYPES.competencecreature == this.type && this.system.categorie == "possession" }
  isTemporel() { return typesObjetsTemporels.includes(this.type) }
  isOeuvre() { return typesObjetsOeuvres.includes(this.type) }
  isDraconique() { return RdDItem.getItemTypesDraconiques().includes(this.type) }
@ -234,6 +237,13 @@ export class RdDItem extends Item {
  isPresentDansMilieux(milieux) {
    return this.getEnvironnements(milieux).length > 0
  }
+  getCategories() {
+    switch (this.type) {
+      case TYPES.competence: return RdDItemCompetence.getCategories()
+      case TYPES.competencecreature: return RdDItemCompetenceCreature.getCategories()
+    }
+    return {}
+  }

  getEnvironnements(milieux = undefined) {
    const environnements = this.isInventaire() ? this.system.environnement : undefined;
@ -370,7 +380,7 @@ export class RdDItem extends Item {
  }

  getEncTotal() {
-    return (this.isService() ? 0 : this.getQuantite()) * this.getEnc();
+    return (this.getQuantite() ?? 0) * this.getEnc();
  }

  getEnc() {
--- a/module/migrations.js
+++ b/module/migrations.js
@ -2,7 +2,7 @@ import { RdDBaseActor } from "./actor/base-actor.js";
 import { LOG_HEAD, SYSTEM_RDD } from "./constants.js";
 import { Grammar } from "./grammar.js";
 import { Monnaie } from "./item-monnaie.js";
-import { RdDItem } from "./item.js";
+import { RdDItem, TYPES } from "./item.js";
 import { RdDTimestamp } from "./time/rdd-timestamp.js";
 import { RdDRaretes } from "./item/raretes.js";

@ -13,7 +13,7 @@ class Migration {

  async applyItemsUpdates(computeUpdates) {
    await game.actors.forEach(async (actor) => {
-      const actorItemUpdates = computeUpdates(actor.items);
+      const actorItemUpdates = computeUpdates(actor.items).filter(it => it != undefined);
      if (actorItemUpdates.length > 0) {
        console.log(
          this.code,
@ -24,7 +24,7 @@ class Migration {
      }
    });

-    const itemUpdates = computeUpdates(game.items);
+    const itemUpdates = computeUpdates(game.items).filter(it => it != undefined);
    if (itemUpdates.length > 0) {
      console.log(this.code, "Applying updates on items", itemUpdates);
      await Item.updateDocuments(itemUpdates);
@ -65,7 +65,6 @@ class _1_5_34_migrationPngWebp {
  }
 }

-
 class _10_0_16_MigrationSortsReserve extends Migration {
  get code() { return "creation-item-sort-reserve"; }
  get version() { return "10.0.16"; }
@ -370,6 +369,7 @@ class _10_4_6_ServicesEnCommerces extends Migration {
    return itemToCreate;
  }
 }
+
 class _10_5_0_UpdatePeriodicite extends Migration {
  get code() { return "migration-periodicite-poisons-maladies"; }
  get version() { return "10.5.0"; }
@ -458,6 +458,62 @@ class _10_7_0_MigrationBlessures extends Migration {
  }
 }

+class _10_7_19_CategorieCompetenceCreature extends Migration {
+  get code() { return "categorie-competence-creature"; }
+  get version() { return "10.7.19"; }
+
+  async migrate() {
+    await this.applyItemsUpdates(items => items
+      .filter(it => TYPES.competencecreature == it.type)
+      .map(it => this.migrateCompetenceCreature(it))
+    );
+  }
+
+  migrateCompetenceCreature(it) {
+    const categorie = this.getCategorie(it)
+    if (categorie == it.system.categorie) {
+      return undefined
+    }
+    return { _id: it.id, 'system.categorie': categorie }
+  }
+
+  getCategorie(it) {
+    if (it.system.ispossession) {
+      return 'possession'
+    }
+    switch (it.system.categorie) {
+      case "melee":
+        if (it.system.isnaturelle) {
+          return 'naturelle'
+        }
+        return 'melee'
+      case "particuliere": case "specialisee": case "connaissance":
+        return "generale"
+      default:
+        return it.system.categorie
+    }
+  }
+}
+
+class _10_7_19_PossessionsEntiteVictime extends Migration {
+  get code() { return "possessions-entite-victime"; }
+  get version() { return "10.7.19"; }
+
+  async migrate() {
+    await this.applyItemsUpdates(items => items
+      .filter(it => TYPES.possession == it.type)
+      .map(it => this.migratePossession(it))
+    );
+  }
+
+  migratePossession(it) {
+    return { _id: it.id,
+      'system.entite.actorid': it.system.possesseurid,
+      'system.victime.actorid': it.system.possedeid
+    }
+  }
+}
+
 export class Migrations {
  static getMigrations() {
    return [
@ -474,6 +530,8 @@ export class Migrations {
      new _10_4_6_ServicesEnCommerces(),
      new _10_5_0_UpdatePeriodicite(),
      new _10_7_0_MigrationBlessures(),
+      new _10_7_19_CategorieCompetenceCreature(),
+      new _10_7_19_PossessionsEntiteVictime(),
    ];
  }

@ -490,7 +548,7 @@ export class Migrations {
  migrate() {
    const currentVersion = game.settings.get(SYSTEM_RDD, "systemMigrationVersion");
    if (isNewerVersion(game.system.version, currentVersion)) {
-      //if (true) { /* comment previous and uncomment here to test before upgrade  */
+      // if (true) { /* comment previous and uncomment here to test before upgrade  */
      const migrations = Migrations.getMigrations().filter(m => isNewerVersion(m.version, currentVersion));
      if (migrations.length > 0) {
        migrations.sort((a, b) => this.compareVersions(a, b));
--- a/module/rdd-bonus.js
+++ b/module/rdd-bonus.js
@ -1,4 +1,5 @@
 import { RdDCarac } from "./rdd-carac.js";
+import { RdDPossession } from "./rdd-possession.js";

 const conditionsTactiques = [
  { type: '', descr: '', dmg: 0, attaque: 0, parade: 0, esquive: true },
@ -27,6 +28,9 @@ export class RdDBonus {
    if (rollData.isEmpoignade && rollData.rolled?.isPart) {
      return true
    }
+    if (RdDPossession.isDefensePossession(rollData)) {
+      return RdDPossession.isPossessionFinesse(rollData)
+    }
    return rollData.attackerRoll?.particuliere == 'finesse';
  }

@ -74,7 +78,7 @@ export class RdDBonus {

  /* -------------------------------------------- */
  static _dmgArme(rollData) {
-    if ( rollData.arme) {
+    if (rollData.arme) {
      let dmgBase = rollData.arme.system.dommagesReels ?? Number(rollData.arme.system.dommages ?? 0);
      //Le bonus dégats magiques ne peut pas faire dépasser le bonus de l'arme (cf p.278)
      return dmgBase + Math.min(dmgBase, rollData.arme.system.magique ? rollData.arme.system.ecaille_efficacite : 0);
--- a/module/rdd-combat.js
+++ b/module/rdd-combat.js
@ -87,7 +87,7 @@ export class RdDCombatManager extends Combat {
      let rollFormula = formula ?? RdDCombatManager.formuleInitiative(2, 10, 0, 0);
      if (!formula) {
        if (combatant.actor.type == 'creature' || combatant.actor.type == 'entite') {
-          const competence = combatant.actor.items.find(it => it.system.iscombat)
+          const competence = combatant.actor.items.find(it => RdDItemCompetenceCreature.getCategorieAttaque(it))
          if (competence) {
            rollFormula = RdDCombatManager.formuleInitiative(2, competence.system.carac_value, competence.system.niveau, 0);
          }
@ -230,15 +230,15 @@ export class RdDCombatManager extends Combat {
  }

  static listActionsCreature(competences) {
-    return competences.filter(it => RdDItemCompetenceCreature.isCompetenceAttaque(it))
-      .map(it => RdDItemCompetenceCreature.armeNaturelle(it));
+    return competences.map(it => RdDItemCompetenceCreature.armeCreature(it))
+      .filter(it => it != undefined);
  }

  static listActionsPossessions(actor) {
    return RdDCombatManager._indexActions(actor.getPossessions().map(p => {
      return {
        name: p.name,
-        action: 'conjurer',
+        action: 'possession',
        system: {
          competence: p.name,
          possessionid: p.system.possessionid,
@ -255,7 +255,7 @@ export class RdDCombatManager extends Combat {
      return actions;
    }
    if (actor.isCreatureEntite()) {
-      actions = actions.concat(RdDCombatManager.listActionsCreature(actor.itemTypes['competencecreature']));
+      actions = RdDCombatManager.listActionsCreature(actor.itemTypes['competencecreature']);
    } else if (actor.isPersonnage()) {
      // Recupération des items 'arme'
      const armes = actor.itemTypes['arme'].filter(it => RdDItemArme.isArmeUtilisable(it))
@ -263,7 +263,7 @@ export class RdDCombatManager extends Combat {
        .concat(RdDItemArme.mainsNues());

      const competences = actor.itemTypes['competence'];
-      actions = actions.concat(RdDCombatManager.listActionsArmes(armes, competences, actor.system.carac));
+      actions = RdDCombatManager.listActionsArmes(armes, competences, actor.system.carac);

      if (actor.system.attributs.hautrevant.value) {
        actions.push({ name: "Draconic", action: 'haut-reve', system: { initOnly: true, competence: "Draconic" } });
@ -351,7 +351,7 @@ export class RdDCombatManager extends Combat {
    } else if (combatant.actor.getSurprise() == "demi") {
      initOffset = 0;
      initInfo = "Demi Surprise"
-    } else if (action.action == 'conjurer') {
+    } else if (action.action == 'possession') {
      initOffset = 10;
      caracForInit = combatant.actor.getReveActuel();
      initInfo = "Possession"
@ -790,7 +790,7 @@ export class RdDCombat {
      passeArme: randomID(16),
      mortalite: arme?.system.mortalite,
      coupsNonMortels: false,
-      competence: competence,
+      competence: competence.clone(),
      surprise: this.attacker.getSurprise(true),
      surpriseDefenseur: this.defender.getSurprise(true),
      targetToken: Targets.extractTokenData(this.target),
@ -1045,7 +1045,7 @@ export class RdDCombat {
      passeArme: attackerRoll.passeArme,
      diffLibre: attackerRoll.diffLibre,
      attackerRoll: attackerRoll,
-      competence: this.defender.getCompetence(competenceParade),
+      competence: this.defender.getCompetence(competenceParade).clone(),
      arme: armeParade,
      surprise: this.defender.getSurprise(true),
      needParadeSignificative: ReglesOptionelles.isUsing('categorieParade') && RdDItemArme.needParadeSignificative(attackerRoll.arme, armeParade),
@ -1126,7 +1126,7 @@ export class RdDCombat {
      passeArme: attackerRoll.passeArme,
      diffLibre: attackerRoll.diffLibre,
      attackerRoll: attackerRoll,
-      competence: competence,
+      competence: competence.clone(),
      surprise: this.defender.getSurprise(true),
      surpriseDefenseur: this.defender.getSurprise(true),
      carac: this.defender.system.carac,
--- a/module/rdd-empoignade.js
+++ b/module/rdd-empoignade.js
@ -4,6 +4,8 @@ import { RdDRoll } from "./rdd-roll.js";
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
 import { ChatUtility } from "./chat-utility.js";
 import { STATUSES } from "./settings/status-effects.js";
+import { ReglesOptionelles } from "./settings/regles-optionelles.js";
+import { TYPES } from "./item.js";

 /* -------------------------------------------- */

@ -14,6 +16,47 @@ export class RdDEmpoignade {
  static init() {
  }

+  /* -------------------------------------------- */
+  static registerChatCallbacks(html) {
+    html.on("click", '.defense-empoignade-cac', event => {
+      const chatMessage = ChatUtility.getChatMessage(event);
+      const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
+      let defenseMode = event.currentTarget.attributes['data-defense-mode'].value
+      RdDEmpoignade.onDefenseEmpoignade(rollData, defenseMode, "Corps à corps", "melee")
+    });
+    html.on("click", '.defense-empoignade-esquive', event => {
+      const chatMessage = ChatUtility.getChatMessage(event);
+      const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
+      let defenseMode = event.currentTarget.attributes['data-defense-mode'].value
+      RdDEmpoignade.onDefenseEmpoignade(rollData, defenseMode, "Esquive", "derobee")
+    });
+    html.on("click", '.empoignade-poursuivre', event => {
+      let attackerId = event.currentTarget.attributes['data-attackerId'].value
+      let defenderId = event.currentTarget.attributes['data-defenderId'].value
+      RdDEmpoignade.onAttaqueEmpoignadeValidee(game.actors.get(attackerId), game.actors.get(defenderId))
+    });
+    html.on("click", '.empoignade-entrainer-sol', event => {
+      const chatMessage = ChatUtility.getChatMessage(event);
+      const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
+      RdDEmpoignade.entrainerAuSol(rollData)
+      ChatUtility.removeChatMessageId(chatMessage.id)
+    });
+    html.on("click", '.empoignade-projeter-sol', event => {
+      const chatMessage = ChatUtility.getChatMessage(event);
+      const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
+      RdDEmpoignade.projeterAuSol(rollData)
+      ChatUtility.removeChatMessageId(chatMessage.id)
+    });
+    html.on("change", '.empoignade-perte-endurance', event => {
+      const chatMessage = ChatUtility.getChatMessage(event);
+      const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
+      if (event.currentTarget.value && event.currentTarget.value != "none") {
+        RdDEmpoignade.perteEndurance(rollData, event.currentTarget.value)
+        ChatUtility.removeChatMessageId(chatMessage.id)
+      }
+    });
+  }
+
  /* -------------------------------------------- */
  static checkEmpoignadeEnCours(actor) {
    // TODO: autoriser la perception? la comédie/séduction?
@ -24,74 +67,92 @@ export class RdDEmpoignade {
    return false;
  }

+  /* -------------------------------------------- */
+  static $storeRollEmpoignade(msg, rollData) {
+    RdDEmpoignade.$reduceActorToIds(rollData);
+    ChatUtility.setMessageData(msg, "empoignade-roll-data", rollData);
+  }
+
+  static $reduceActorToIds(rollData) {
+    rollData.attacker = { id: rollData.attacker.id };
+    rollData.defender = { id: rollData.defender.id };
+  }
+
+  /* -------------------------------------------- */
+  static $readRollEmpoignade(msg) {
+    const rollData = ChatUtility.getMessageData(msg, 'empoignade-roll-data');
+    RdDEmpoignade.$replaceIdsWithActors(rollData);
+    return rollData
+  }
+
+  static $replaceIdsWithActors(rollData) {
+    rollData.attacker = game.actors.get(rollData.attacker.id);
+    rollData.defender = game.actors.get(rollData.defender.id);
+  }
+
  /* -------------------------------------------- */
  static isEmpoignadeEnCours(actor) {
-    return actor.itemTypes['empoignade'].find(it => it.system.pointsemp > 0)
+    return actor.itemTypes[TYPES.empoignade].find(it => it.system.pointsemp > 0)
  }

  /* -------------------------------------------- */
  static getEmpoignadeById(actor, id) {
-    let emp = actor.itemTypes['empoignade'].find(it => it.system.empoignadeid == id)
+    let emp = actor.itemTypes[TYPES.empoignade].find(it => it.system.empoignadeid == id)
    return emp && duplicate(emp) || undefined;
  }

  /* -------------------------------------------- */
  static getEmpoignade(attacker, defender) {
-    let emp = attacker.itemTypes['empoignade'].find(it => it.system.empoigneurid == attacker.id && it.system.empoigneid == defender.id)
-    if (!emp) {
-      emp = attacker.itemTypes['empoignade'].find(it => it.system.empoigneurid == defender.id && it.system.empoigneid == attacker.id)
-    }
+    let emp = attacker.itemTypes[TYPES.empoignade].find(it =>
+      (it.system.empoigneurid == attacker.id && it.system.empoigneid == defender.id) ||
+      (it.system.empoigneurid == defender.id && it.system.empoigneid == attacker.id)
+    )
    if (emp) {
      return duplicate(emp);
    }
    return undefined;
  }
+
  /* -------------------------------------------- */
  static getMalusTaille(emp, attacker, defender) {
    // Si pas empoigné, alors 0
    if (emp.system.pointsemp == 0) {
      return 0
    }
-    // Malus de -1 si différence de taille de 2 ou plus (p 135)
-    if (attacker.system.carac.taille.value < defender.system.carac.taille.value - 1) {
-      return attacker.system.carac.taille.value - (defender.system.carac.taille.value - 1)
+    // p135: Malus de -1 par point de taille de différence de taille au delà de 1 (donc -2 pour une différence de 3, ...)
+    const diffTaille = attacker.system.carac.taille.value - defender.system.carac.taille.value;
+    const diffTailleAbs = Math.abs(diffTaille)
+    const signDiff = diffTaille > 0 ? 1 : -1
+
+    if (diffTailleAbs > 2) {
+      return signDiff * (diffTailleAbs - 1)
    }
    return 0
  }

-  /* -------------------------------------------- */
-  static async onAttaqueEmpoignadeValidee(attacker, defender) {
-    let empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)
-    const isNouvelle = empoignade == undefined;
-    empoignade = empoignade ?? (await RdDEmpoignade.createEmpoignade(attacker, defender))
+  static isActionAutorisee(mode, attacker, defender) {
+    const acting = RdDEmpoignade.isActionDefenseur(mode) ? defender : attacker;
+    if (acting.getUserLevel(game.user) < CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER) {
+      ui.notifications.warn(`Vous n'êtes pas autorisé à choisir l'action de ${acting.name}`)
+      return false;
+    }
+    return true
+  }

-    let mode = (empoignade && empoignade.system.empoigneurid == attacker.id) ? "empoigner" : "liberer"
-
-    let rollData = {
-      mode: mode,
-      isEmpoignade: true,
-      competence: attacker.getCompetence("Corps à corps"),
-      selectedCarac: attacker.system.carac.melee,
-      empoignade: empoignade,
-      attackerId: attacker.id,
-      attackerName: attacker.name,
-      defenderName: defender.name,
-      defenderId: defender.id,
-      malusTaille: RdDEmpoignade.getMalusTaille(empoignade, attacker, defender)
-    }
-    if (attacker.isCreatureEntite()) {
-      RdDItemCompetenceCreature.setRollDataCreature(rollData)
-    }
-    if (empoignade.system.pointsemp >= 2) {
-      let msg = await RdDResolutionTable.displayRollData(rollData, attacker, 'chat-empoignade-actions.html');
-      ChatUtility.setMessageData(msg, "empoignade-roll-data", rollData)
-    } else {
-      await RdDEmpoignade.$rollAttaqueEmpoignade(attacker, rollData, isNouvelle);
+  static isActionDefenseur(mode) {
+    switch (mode) {
+      case "liberer":
+      case "contrer-empoigner":
+        return true;
    }
+    return false;
  }

  /* -------------------------------------------- */
  static async onAttaqueEmpoignade(attacker, defender) {
+    if (!RdDEmpoignade.isActionAutorisee("empoigner", attacker, defender)) {
+      return
+    }
    let empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)
    const isNouvelle = empoignade == undefined;
    empoignade = empoignade ?? (await RdDEmpoignade.createEmpoignade(attacker, defender))
@ -105,6 +166,38 @@ export class RdDEmpoignade {
    }
  }

+  /* -------------------------------------------- */
+  static async onAttaqueEmpoignadeValidee(attacker, defender) {
+    let empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)
+    const isNouvelle = empoignade == undefined;
+    empoignade = empoignade ?? (await RdDEmpoignade.createEmpoignade(attacker, defender))
+
+    let mode = (empoignade && empoignade.system.empoigneurid == attacker.id) ? "empoigner" : "liberer"
+
+    if (!RdDEmpoignade.isActionAutorisee(mode, attacker, defender)) {
+      return
+    }
+
+    let rollData = {
+      mode, empoignade, attacker, defender,
+      isEmpoignade: true,
+      competence: attacker.getCompetence("Corps à corps").clone(),
+      selectedCarac: attacker.system.carac.melee,
+      malusTaille: RdDEmpoignade.getMalusTaille(empoignade, attacker, defender)
+    }
+    if (attacker.isCreatureEntite()) {
+      RdDItemCompetenceCreature.setRollDataCreature(rollData)
+    }
+    if (empoignade.system.pointsemp >= 2) {
+      if (!empoignade.system.ausol) {
+        let msg = await RdDResolutionTable.displayRollData(rollData, attacker, 'chat-empoignade-entrainer.html');
+        RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
+      }
+    } else {
+      await RdDEmpoignade.$rollAttaqueEmpoignade(attacker, rollData, isNouvelle);
+    }
+  }
+
  /* -------------------------------------------- */
  static async onAttaqueEmpoignadeFromItem(empoignade) {
    let attacker = game.actors.get(empoignade.system.empoigneurid)
@ -112,6 +205,20 @@ export class RdDEmpoignade {
    await this.onAttaqueEmpoignadeValidee(attacker, defender)
  }

+  static async onImmobilisation(attacker, defender, empoignade) {
+    const rollData = {
+      mode: "immobilise",
+      empoignade, attacker, defender,
+      isEmpoignade: true,
+      competence: attacker.getCompetence("Corps à corps").clone()
+    }
+    const msg = await ChatMessage.create({
+      whisper: ChatUtility.getWhisperRecipientsAndGMs(attacker.name),
+      content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-empoignade-immobilise.html`, rollData)
+    })
+    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
+  }
+
  /* -------------------------------------------- */
  static async $rollAttaqueEmpoignade(attacker, rollData, isNouvelle = false) {
    const dialog = await RdDRoll.create(attacker, rollData,
@ -119,35 +226,40 @@ export class RdDEmpoignade {
      {
        name: 'jet-empoignade',
        label: 'Empoigner',
-        callbacks: [
-          { condition: r => (r.rolled.isSuccess), action: async (r) => await RdDEmpoignade.$onRollEmpoignade(r, true, isNouvelle) },
-          { condition: r => (r.rolled.isEchec), action: async (r) => await RdDEmpoignade.$onRollEmpoignade(r, false, isNouvelle) },
-        ]
+        callbacks: [{ action: async (r) => await RdDEmpoignade.$onRollEmpoignade(r, isNouvelle) },]
      });
    dialog.render(true);
  }

  /* -------------------------------------------- */
-  static async $onRollEmpoignade(rollData, isSuccess, isNouvelle = false) {
-    let attacker = game.actors.get(rollData.attackerId)
-    let defender = game.actors.get(rollData.defenderId)
+  static async $onRollEmpoignade(rollData, isNouvelle = false) {
+    let attacker = game.actors.get(rollData.attacker.id)
+    let defender = game.actors.get(rollData.defender.id)

-    let empoignade = rollData.empoignade
-    empoignade.isSuccess = isSuccess;

-    if (isSuccess && isNouvelle) {
+    if (rollData.rolled.isSuccess && isNouvelle) {
+      const objectEmpoignade = rollData.empoignade.toObject();
      // Creer l'empoignade sur attaquant/defenseur
-      await attacker.createEmbeddedDocuments('Item', [empoignade.toObject()])
-      await defender.createEmbeddedDocuments('Item', [empoignade.toObject()])
+      attacker.creerObjetParMJ(objectEmpoignade);
+      defender.creerObjetParMJ(objectEmpoignade);
+    }
+
+    rollData.empoignade.isSuccess = rollData.rolled.isSuccess;
+    if (rollData.rolled.isPart) {
+      rollData.particuliere = "finesse";
    }
    let msg = await RdDResolutionTable.displayRollData(rollData, attacker, 'chat-empoignade-resultat.html');
-    ChatUtility.setMessageData(msg, "empoignade-roll-data", rollData)
+    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
  }

  /* -------------------------------------------- */
-  static async onDefenseEmpoignade(rollData, defenseMode, competenceName = "Corps à corps", carac = "melee") {
-    let attacker = game.actors.get(rollData.attackerId)
-    let defender = game.actors.get(rollData.defenderId)
+  static async onDefenseEmpoignade(attackerRoll, mode, competenceName = "Corps à corps", carac = "melee") {
+    let attacker = game.actors.get(attackerRoll.attacker.id)
+    let defender = game.actors.get(attackerRoll.defender.id)
+    if (!RdDEmpoignade.isActionAutorisee(mode, attacker, defender)) {
+      return
+    }
+
    let empoignade = this.getEmpoignade(attacker, defender)

    if (!empoignade) {
@ -156,18 +268,23 @@ export class RdDEmpoignade {
    }

    empoignade = duplicate(empoignade)
-    rollData.mode = defenseMode
-    rollData.empoignade = empoignade
-    rollData.competence = defender.getCompetence(competenceName),
-      rollData.selectedCarac = defender.system.carac[carac],
-      rollData.malusTaille = RdDEmpoignade.getMalusTaille(empoignade, defender, attacker)
-
-    await RdDEmpoignade.$rollDefenseEmpoignade(defender, rollData);
+    let defenderRoll = {
+      mode, attacker, defender, empoignade, attackerRoll,
+      diffLibre: attackerRoll.diffLibre,
+      attaqueParticuliere: attackerRoll.particuliere,
+      competence: defender.getCompetence(competenceName).clone(),
+      surprise: defender.getSurprise(true),
+      carac: defender.system.carac,
+      selectedCarac: defender.system.carac[carac],
+      malusTaille: RdDEmpoignade.getMalusTaille(empoignade, defender, attacker),
+      show: {}
+    };
+    await RdDEmpoignade.$rollDefenseEmpoignade(defender, defenderRoll);
  }

  /* -------------------------------------------- */
-  static async $rollDefenseEmpoignade(defender, rollData) {
-    const dialog = await RdDRoll.create(defender, rollData,
+  static async $rollDefenseEmpoignade(defender, defenderRoll) {
+    const dialog = await RdDRoll.create(defender, defenderRoll,
      { html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-defense-empoignade.html' },
      {
        name: 'empoignade',
@ -183,7 +300,7 @@ export class RdDEmpoignade {
  /* -------------------------------------------- */
  static async $onRollContrerLiberer(rollData) {
    let empoignade = rollData.empoignade
-
+    
    if (rollData.mode == "contrer-empoigner" && !rollData.rolled.isSuccess) {
      empoignade.system.pointsemp++
      RdDEmpoignade.$updateEtatEmpoignade(empoignade)
@ -192,13 +309,12 @@ export class RdDEmpoignade {
      empoignade.system.pointsemp--
      RdDEmpoignade.$updateEtatEmpoignade(empoignade)
    }
-
-    if (empoignade.system.pointsemp >= 2) {
-      let attacker = game.actors.get(empoignade.system.empoigneurid)
-      let msg = await RdDResolutionTable.displayRollData(rollData, attacker, 'chat-empoignade-actions.html');
-      ChatUtility.setMessageData(msg, "empoignade-roll-data", rollData)
-    }
+    
    await RdDResolutionTable.displayRollData(rollData, rollData.defender, 'chat-empoignade-resultat.html')
+    if (empoignade.system.pointsemp >= 2) {
+      let msg = await RdDResolutionTable.displayRollData(rollData, rollData.attacker, 'chat-empoignade-entrainer.html');
+      RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
+    }
  }

  /* -------------------------------------------- */
@ -223,16 +339,15 @@ export class RdDEmpoignade {
    let defender = game.actors.get(empoignade.system.empoigneid)
    let emp = RdDEmpoignade.getEmpoignadeById(defender, empoignade.system.empoignadeid)
    await defender.deleteEmbeddedDocuments('Item', [emp._id])
-
-    //let attacker = game.actors.get(empoignade.system.empoigneurid)
-    //emp = RdDEmpoignade.getEmpoignadeById(attacker, empoignade.system.empoignadeid)
-    //await attacker.deleteEmbeddedDocuments('Item', [emp._id])
  }

  /* -------------------------------------------- */
  static async entrainerAuSol(rollData) {
-    let attacker = game.actors.get(rollData.attackerId)
-    let defender = game.actors.get(rollData.defenderId)
+    let attacker = game.actors.get(rollData.attacker.id)
+    let defender = game.actors.get(rollData.defender.id)
+    if (!RdDEmpoignade.isActionAutorisee("immobilise", attacker, defender)) {
+      return
+    }
    let empoignade = this.getEmpoignade(attacker, defender)

    empoignade.system.ausol = true
@ -242,25 +357,32 @@ export class RdDEmpoignade {
    await defender.setEffect(STATUSES.StatusProne, true);

    let msg = await RdDResolutionTable.displayRollData(rollData, attacker, 'chat-empoignade-entrainer-sol.html');
-    ChatUtility.setMessageData(msg, "empoignade-roll-data", rollData)
+    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
  }

  /* -------------------------------------------- */
  static async projeterAuSol(rollData) {
-    let attacker = game.actors.get(rollData.attackerId)
-    let defender = game.actors.get(rollData.defenderId)
+    let attacker = game.actors.get(rollData.attacker.id)
+    let defender = game.actors.get(rollData.defender.id)
+    if (!RdDEmpoignade.isActionAutorisee("immobilise", attacker, defender)) {
+      return
+    }
    let empoignade = this.getEmpoignade(attacker, defender)

    await defender.setEffect(STATUSES.StatusProne, true);
    await this.$deleteEmpoignade(empoignade)

    let msg = await RdDResolutionTable.displayRollData(rollData, attacker, 'chat-empoignade-projeter-sol.html');
-    ChatUtility.setMessageData(msg, "empoignade-roll-data", rollData)
+    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
  }
+
  /* -------------------------------------------- */
  static async perteEndurance(rollData, perteMode) {
-    let attacker = game.actors.get(rollData.attackerId)
-    let defender = game.actors.get(rollData.defenderId)
+    let attacker = game.actors.get(rollData.attacker.id)
+    let defender = game.actors.get(rollData.defender.id)
+    if (!RdDEmpoignade.isActionAutorisee("immobilise", attacker, defender)) {
+      return
+    }
    let empoignade = this.getEmpoignade(attacker, defender)

    //console.log("Perte d'endurance :!!!", perteMode)
@ -278,7 +400,7 @@ export class RdDEmpoignade {
      await defender.santeIncDec("endurance", -(3 * Math.floor(endValue / 4)));
    }
    let msg = await RdDResolutionTable.displayRollData(rollData, attacker, 'chat-empoignade-perte-endurance.html');
-    ChatUtility.setMessageData(msg, "empoignade-roll-data", rollData)
+    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
  }

  /* -------------------------------------------- */
--- a/module/rdd-possession.js
+++ b/module/rdd-possession.js
@ -1,9 +1,9 @@
 /* -------------------------------------------- */
-import { RdDCombat } from "./rdd-combat.js";
 import { RdDResolutionTable } from "./rdd-resolution-table.js";
 import { RdDRoll } from "./rdd-roll.js";
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
 import { Targets } from "./targets.js";
+import { TYPES } from "./item.js";

 /* -------------------------------------------- */
 /* On part du principe qu'une entité démarre tjs 
@ -20,9 +20,9 @@ export class RdDPossession {

  /* -------------------------------------------- */
  static searchPossessionFromEntite(attacker, defender) {
-    let poss = attacker.items.find(poss => poss.type == 'possession' && poss.system.possedeid == defender.id);
+    let poss = attacker.items.find(poss => poss.type == TYPES.possession && poss.system.victime.actorid == defender.id);
    if (!poss) {
-      poss = defender.items.find(poss => poss.type == 'possession' && poss.system.possedeid == defender.id);
+      poss = defender.items.find(poss => poss.type == TYPES.possession && poss.system.victime.actorid == defender.id);
    }
    return poss && duplicate(poss) || undefined;
  }
@ -31,39 +31,40 @@ export class RdDPossession {
  static async onAttaquePossession(target, attacker, competence, suitePossession = undefined) {
    const defender = target.actor;
    const fromEntite = RdDPossession.searchPossessionFromEntite(attacker, defender);
-    const isNouvelle = !suitePossession && ! fromEntite;
+    const isNouvelle = !suitePossession && !fromEntite;
    const possession = (suitePossession ?? fromEntite ?? (await RdDPossession.createPossession(attacker, defender)));
-    
+
    RdDPossession.$updateEtatPossession(possession)

    let rollData = {
-      mode: "possession",
+      mode: "attaque",
      isECNIDefender: false,
-      competence: competence,
+      competence: competence.clone(),
      possession: possession,
      attacker: attacker,
      defender: defender,
      targetToken: Targets.extractTokenData(target)
    };
-    if (attacker.isCreatureEntite()) {
-      RdDItemCompetenceCreature.setRollDataCreature(rollData)
-    }
-    
+    RdDPossession.selectCompetenceDraconicOuPossession(rollData, attacker)
+
    await RdDPossession.$rollAttaquePossession(attacker, rollData, isNouvelle);
  }
-  
+
  /* -------------------------------------------- */
-  static async onConjurerPossession(attacker, competence, possession) {
+  static async onConjurerPossession(attacker, possession) {
    possession = duplicate(possession);
    RdDPossession.$updateEtatPossession(possession)
+
+    const defender = game.actors.get(possession.system.entite.actorid);
    let rollData = {
-      mode: "possession",
+      mode: "attaque",
      isECNIDefender: true,
-      competence: competence,
      possession: possession,
      attacker: attacker,
-      defender: game.actors.get(possession.system.possesseurid)
+      defender: defender,
    };
+    RdDPossession.selectCompetenceDraconicOuPossession(rollData, attacker)
+
    await RdDPossession.$rollAttaquePossession(attacker, rollData);
  }

@ -71,7 +72,7 @@ export class RdDPossession {
  static async onDefensePossession(attackerId, defenderId, possessionId) {
    let attacker = game.actors.get(attackerId)
    let possession = attacker?.getPossession(possessionId)
-    defenderId = defenderId ?? possession?.system.possesseurid ?? undefined
+    defenderId = defenderId ?? possession?.system.entite.actorid ?? undefined
    let defender = game.actors.get(defenderId)
    possession = possession ?? defender?.getPossession(possessionId) ?? undefined;

@ -82,19 +83,29 @@ export class RdDPossession {
    possession = duplicate(possession)
    // Update for draconic roll
    let rollData = {
-      mode: "conjuration",
+      mode: "defense",
      isECNIDefender: defender.type == "entite",
      possession: possession,
      attacker: attacker,
      defender: defender,
-      competence: defender.getDraconicOuPossession(),
-      selectedCarac: defender.system.carac.reve,
-      forceCarac: { 'reve-actuel': { label: "Rêve Actuel", value: defender.getReveActuel() } }
    }
-    rollData.competence.system.defaut_carac = 'reve-actuel'
-
+    RdDPossession.selectCompetenceDraconicOuPossession(rollData, defender)
+    rollData.diffLibre = RdDPossession.getInfoAttaque(rollData).diffLibre
+    
    await RdDPossession.$rollDefensePossession(defender, rollData);
  }
+  
+  static selectCompetenceDraconicOuPossession(rollData, rollingActor) {
+    rollData.competence = rollingActor.getDraconicOuPossession();
+    if (rollingActor.isCreatureEntite()) {
+      RdDItemCompetenceCreature.setRollDataCreature(rollData)
+    }
+    else {
+      rollData.selectedCarac = rollingActor.system.carac.reve
+      rollData.forceCarac = { 'reve-actuel': { label: "Rêve Actuel", value: rollingActor.getReveActuel() } }
+      rollData.competence.system.defaut_carac = 'reve-actuel'
+    }
+  }

  /* -------------------------------------------- */
  static async $rollAttaquePossession(attacker, rollData, isNouvelle = false) {
@ -104,21 +115,22 @@ export class RdDPossession {
        name: 'jet-possession',
        label: rollData.isECNIDefender ? 'Conjurer la possession' : 'Possession',
        callbacks: [
-          { condition: r => (r.rolled.isSuccess), action: async (r) => await RdDPossession.$onRollPossession(r, true, isNouvelle) },
-          { condition: r => (r.rolled.isEchec), action: async (r) => await RdDPossession.$onRollPossession(r, false, isNouvelle) },
+          { action: async (r) => await RdDPossession.$onRollPossession(r, isNouvelle) },
        ]
      });
-      dialog.render(true);
+    dialog.render(true);
  }

  /* -------------------------------------------- */
-  static async $onRollPossession(rollData, isSuccess, isNouvelle = false) {
-    rollData.possession.isSuccess = isSuccess;
-    RdDPossession.$updateEtatPossession(rollData.possession);
+  static async $onRollPossession(rollData, isNouvelle = false) {
+    rollData.possession.isSuccess = rollData.rolled.isSuccess;
+    RdDPossession.$updateEtatPossession(rollData.possession, rollData);
    if (isNouvelle) {
      // Creer la possession sur le defenseur
-      rollData.defender.createEmbeddedDocuments('Item', [rollData.possession.toObject()])
+      await rollData.defender.createEmbeddedDocuments('Item', [rollData.possession.toObject()])
    }
+    const possession = (rollData.isECNIDefender ? rollData.attacker : rollData.defender).getPossession(rollData.possession.system.possessionid)
+    RdDPossession.storePossessionAttaque(possession, rollData)
    await RdDResolutionTable.displayRollData(rollData, rollData.attacker, 'chat-resultat-possession.html');
  }

@ -127,35 +139,42 @@ export class RdDPossession {
    const dialog = await RdDRoll.create(defender, rollData,
      { html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-defense-possession.html' },
      {
-        name: 'conjurer',
+        name: 'possession',
        label: 'Conjurer une Possession',
        callbacks: [
          { action: async (r) => await RdDPossession.$onRollConjuration(r) }
-        ]  
-      }  
-    );  
+        ]
+      }
+    );
    dialog.render(true);
-  }  
+  }

  /* -------------------------------------------- */
  static async $onRollConjuration(rollData) {
-    let actor = game.actors.get(rollData.possession.system.possedeid)
+    let victime = game.actors.get(rollData.possession.system.victime.actorid)
+    let compteur = rollData.possession.system.compteur
    if (!rollData.rolled.isSuccess) {
      if (rollData.isECNIDefender) {
-        rollData.possession.system.compteur--
+        compteur--
      } else {
-        rollData.possession.system.compteur++
+        compteur++
      }
-      let update = { _id: rollData.possession._id, "system.compteur": rollData.possession.system.compteur }
-      await actor.updateEmbeddedDocuments('Item', [update])
    }
-
+    const possession = victime.getPossession(rollData.possession.system.possessionid)
+    await possession.update({
+      system: {
+        compteur: compteur,
+        entite: { diffLibre: 0, finesse: false },
+        victime: { diffLibre: 0, finesse: false }
+      }
+    })
+    rollData.possession = possession
    RdDPossession.$updateEtatPossession(rollData.possession)

-    await RdDResolutionTable.displayRollData(rollData,rollData.defender, 'chat-resultat-possession.html')
+    await RdDResolutionTable.displayRollData(rollData, rollData.defender, 'chat-resultat-possession.html')
    if (rollData.possession.isPosseder || rollData.possession.isConjurer) {
      // conjuration
-      actor.deleteEmbeddedDocuments("Item", [rollData.possession._id])
+      victime.deleteEmbeddedDocuments("Item", [rollData.possession._id])
    }
  }

@ -180,13 +199,43 @@ export class RdDPossession {
    }
  }

+  /* -------------------------------------------- */
+  static isPossessionFinesse(rollData) {
+    return RdDPossession.getInfoAttaque(rollData).finesse
+  }
+  /* -------------------------------------------- */
+  static getInfoAttaque(rollData) {
+    return rollData.possession.system[rollData.isECNIDefender ? 'victime' : 'entite'];
+  }
+  /* -------------------------------------------- */
+  static isDefensePossession(rollData) {
+    return rollData.possession && rollData.mode == "defense"
+  }
+  /* -------------------------------------------- */
+  static storePossessionAttaque(possession, rollData = undefined) {
+    const attaquant = rollData?.isECNIDefender ? 'victime' : 'entite'
+    possession.update({
+      [`system.${attaquant}`]: {
+        diffLibre: rollData?.diffLibre ?? 0,
+        finesse: rollData?.rolled.isPart ?? false
+      }
+    })
+  }
+
  /* -------------------------------------------- */
  static async createPossession(attacker, defender) {
    return await Item.create({
-        name: "Possession en cours de " + attacker.name, type: 'possession',
-        img: "systems/foundryvtt-reve-de-dragon/icons/entites/possession2.webp",
-        system: { description: "", typepossession: attacker.name, possede: false, possessionid: randomID(16), possesseurid: attacker.id, possedeid: defender.id, date: 0, compteur: 0 }
-      },
+      name: "Possession en cours de " + attacker.name, type: 'possession',
+      img: "systems/foundryvtt-reve-de-dragon/icons/entites/possession2.webp",
+      system: {
+        description: "", typepossession: attacker.name,
+        possede: false,
+        possessionid: randomID(16),
+        entite: { actorid: attacker.id },
+        victime: { actorid: defender.id },
+        compteur: 0
+      }
+    },
      {
        temporary: true
      })
--- a/module/rdd-resolution-table.js
+++ b/module/rdd-resolution-table.js
@ -91,13 +91,17 @@ export class RdDResolutionTable {

  /* -------------------------------------------- */
  static async displayRollData(rollData, actor = undefined, template = 'chat-resultat-general.html') {
-    return await ChatUtility.createChatWithRollMode(actor?.userName ?? game.user.name, {
-      content: await RdDResolutionTable.buildRollDataHtml(rollData, actor, template)
+    return await ChatUtility.createChatWithRollMode(RdDResolutionTable.actorChatName(actor), {
+      content: await RdDResolutionTable.buildRollDataHtml(rollData, template)
    });
  }

+  static actorChatName(actor) {
+    return actor?.userName ?? game.user.name;
+  }
+
  /* -------------------------------------------- */
-  static async buildRollDataHtml(rollData, actor, template = 'chat-resultat-general.html') {
+  static async buildRollDataHtml(rollData, template = 'chat-resultat-general.html') {
    rollData.show = rollData.show || {};
    return await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/${template}`, rollData);
  }
--- a/module/rdd-token-hud.js
+++ b/module/rdd-token-hud.js
@ -75,8 +75,8 @@ export class RdDTokenHud {
      (event) => {
        const actionIndex = event.currentTarget.attributes['data-action-index']?.value;
        const action = hudData.actions[actionIndex];
-        if (action.action == 'conjurer') {
-          const possession = combatant.actor.getPossession(action.system.possessionid);
+        const possession = action.action == 'possession' ? combatant.actor.getPossession(action.system.possessionid) : undefined;
+        if (possession) {
          combatant.actor.conjurerPossession(possession);
        }
        else {
--- a/module/rdd-utility.js
+++ b/module/rdd-utility.js
@ -182,7 +182,7 @@ export class RdDUtility {
      'systems/foundryvtt-reve-de-dragon/templates/enum-caracteristiques.html',
      'systems/foundryvtt-reve-de-dragon/templates/enum-base-competence.html',
      'systems/foundryvtt-reve-de-dragon/templates/enum-aspect-tarot.html',
-      'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-competence.html',
+      'systems/foundryvtt-reve-de-dragon/templates/enum-categories.html',
      'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-ingredient.html',
      'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-parade.html',
      'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-potion.html',
@ -668,6 +668,7 @@ export class RdDUtility {
  /* -------------------------------------------- */
  static async chatListeners(html) {
    RdDCombat.registerChatCallbacks(html);
+    RdDEmpoignade.registerChatCallbacks(html);

    // Gestion spécifique message passeurs
    html.on("click", '.tmr-passeur-coord a', event => {
@ -694,44 +695,6 @@ export class RdDUtility {
      RdDPossession.onDefensePossession(attackerId, defenderId, possessionId)
    });

-    html.on("click", '.defense-empoignade-cac', event => {
-      const chatMessage = ChatUtility.getChatMessage(event);
-      const rollData = ChatUtility.getMessageData(chatMessage, 'empoignade-roll-data');
-      let defenseMode = event.currentTarget.attributes['data-defense-mode'].value
-      RdDEmpoignade.onDefenseEmpoignade(rollData, defenseMode, "Corps à corps", "melee")
-    });
-    html.on("click", '.defense-empoignade-esquive', event => {
-      const chatMessage = ChatUtility.getChatMessage(event);
-      const rollData = ChatUtility.getMessageData(chatMessage, 'empoignade-roll-data');
-      let defenseMode = event.currentTarget.attributes['data-defense-mode'].value
-      RdDEmpoignade.onDefenseEmpoignade(rollData, defenseMode, "Esquive", "derobee")
-    });
-    html.on("click", '.empoignade-poursuivre', event => {
-      let attackerId = event.currentTarget.attributes['data-attackerId'].value
-      let defenderId = event.currentTarget.attributes['data-defenderId'].value
-      RdDEmpoignade.onAttaqueEmpoignadeValidee(game.actors.get(attackerId), game.actors.get(defenderId)) 
-    });
-    html.on("click", '.empoignade-entrainer-sol', event => {
-      const chatMessage = ChatUtility.getChatMessage(event);
-      const rollData = ChatUtility.getMessageData(chatMessage, 'empoignade-roll-data');
-      RdDEmpoignade.entrainerAuSol(rollData) 
-      ChatUtility.removeChatMessageId(chatMessage.id)
-    });
-    html.on("click", '.empoignade-projeter-sol', event => {
-      const chatMessage = ChatUtility.getChatMessage(event);
-      const rollData = ChatUtility.getMessageData(chatMessage, 'empoignade-roll-data');
-      RdDEmpoignade.projeterAuSol(rollData) 
-      ChatUtility.removeChatMessageId(chatMessage.id)
-    });
-    html.on("change", '.empoignade-perte-endurance', event => {
-      const chatMessage = ChatUtility.getChatMessage(event);
-      const rollData = ChatUtility.getMessageData(chatMessage, 'empoignade-roll-data');
-      if (event.currentTarget.value && event.currentTarget.value != "none") {
-        RdDEmpoignade.perteEndurance(rollData, event.currentTarget.value) 
-        ChatUtility.removeChatMessageId(chatMessage.id)  
-      }
-    });
-        
    // gestion bouton tchat Acheter
    html.on("click", '.button-acheter', event => {
      const venteData = DialogItemAchat.preparerAchat(event.currentTarget);
--- a/module/rolldata-ajustements.js
+++ b/module/rolldata-ajustements.js
@ -5,6 +5,7 @@ import { RdDItemSort } from "./item-sort.js";
 import { Misc } from "./misc.js";
 import { RdDBonus } from "./rdd-bonus.js";
 import { RdDCarac } from "./rdd-carac.js";
+import { RdDPossession } from "./rdd-possession.js";
 import { RdDUtility } from "./rdd-utility.js";
 import { ReglesOptionelles } from "./settings/regles-optionelles.js";

@ -30,7 +31,7 @@ export const referenceAjustements = {
  },
  diffLibre: {
    isUsed: (rollData, actor) => rollData.diffLibre != undefined,
-    getLabel: (rollData, actor) => rollData.selectedSort?.name ?? rollData.attackerRoll ? 'Imposée' : 'Libre',
+    getLabel: (rollData, actor) => rollData.selectedSort?.name ?? rollData.attackerRoll ?? RdDPossession.isDefensePossession(rollData) ? 'Imposée' : 'Libre',
    getValue: (rollData, actor) => rollData.selectedSort
      ? RdDItemSort.getDifficulte(rollData.selectedSort, rollData.diffLibre)
      : rollData.diffLibre ?? rollData.competence?.system.default_diffLibre ?? 0
--- a/packs/animaux.db
+++ b/packs/animaux.db
--- a/packs/entites-de-cauchemar.db
+++ b/packs/entites-de-cauchemar.db
--- a/packs/invocations.db
+++ b/packs/invocations.db
--- a/system.json
+++ b/system.json
@ -1,8 +1,8 @@
 {
  "id": "foundryvtt-reve-de-dragon",
  "title": "Rêve de Dragon",
-  "version": "10.7.18",
-  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-10.7.18.zip",
+  "version": "10.7.21",
+  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-10.7.21.zip",
  "manifest": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/v10/system.json",
  "compatibility": {
    "minimum": "10",
--- a/template.json
+++ b/template.json
@ -586,11 +586,11 @@
    },
    "competencecreature": {
      "templates": ["description"],
-      "categorie_parade": "",
+      "carac_value": 0,
      "niveau": 0,
      "default_diffLibre": 0,
      "categorie": "",
-      "carac_value": 0,
+      "categorie_parade": "",
      "iscombat": false,
      "isnaturelle": true,
      "ispossession": false,
@ -611,10 +611,17 @@
      "typepossession": "",
      "possede": false,
      "possessionid": "",
-      "possesseurid": "",
-      "possedeid": "",
-      "compteur": 0,
-      "date": 0
+      "entite": {
+        "actorid": "",
+        "diffLibre": 0,
+        "finesse": false 
+      },
+      "victime": {
+        "actorid": "",
+        "diffLibre": 0,
+        "finesse": false 
+      },
+      "compteur": 0
    },
    "blessure": {
      "templates": ["temporel"],
--- a/templates/actor/comp-creature.html
+++ b/templates/actor/comp-creature.html
@ -9,18 +9,24 @@
    <input class="competence-carac creature-carac" type="text" compname="{{comp.name}}" name="{{comp._id}}.carac"
      value="{{comp.system.carac_value}}" data-dtype="number"
      {{#unless @root.options.vueDetaillee}}disabled{{/unless}}/>
-    <input class="competence-value creature-niveau" type="text" compname="{{comp.name}}" name="{{comp._id}}.niveau"
-      value="{{numberFormat comp.system.niveau decimals=0 sign=true}}" data-dtype="number"
-      {{#unless @root.options.vueDetaillee}}disabled{{/unless}}/>
-    <input class="competence-damage creature-dommages" type="text" compname="{{comp.name}}" name="{{comp._id}}.dommages"
-      value="{{numberFormat comp.system.dommages decimals=0 sign=true}}" data-dtype="number" 
-      {{#unless @root.options.vueDetaillee}}disabled{{/unless}}/>
-      {{#if @root.options.vueDetaillee}}
-      <div class="item-controls">
-        <a class="item-edit" title="Edit Item"><i class="fas fa-edit"></i></a>
-        <a class="item-delete" title="Delete Item"><i class="fas fa-trash"></i></a>
-      </div>
-      {{/if}}
+    <input class="competence-value creature-niveau" type="text" data-dtype="number"
+      compname="{{comp.name}}" name="{{comp._id}}.niveau"
+      value="{{numberFormat comp.system.niveau decimals=0 sign=true}}" 
+      {{#unless @root.options.vueDetaillee}}disabled{{/unless}}
+      />
+    <input class="competence-damage creature-dommages" type="text" data-dtype="number" 
+      {{#if comp.isdommages}}
+        compname="{{comp.name}}" name="{{comp._id}}.dommages"
+        value="{{numberFormat comp.system.dommages decimals=0 sign=true}}" 
+        {{#unless @root.options.vueDetaillee}}disabled{{/unless}}
+      {{else}}disabled{{/if}}
+      />
+    {{#if @root.options.vueDetaillee}}
+    <div class="item-controls">
+      <a class="item-edit" title="Edit Item"><i class="fas fa-edit"></i></a>
+      <a class="item-delete" title="Delete Item"><i class="fas fa-trash"></i></a>
+    </div>
+    {{/if}}
  </li>
  {{/each}}
 </ol>
--- a/templates/chat-empoignade-actions.html
+++ b/templates/chat-empoignade-actions.html
@ -1,39 +0,0 @@
-<img class="chat-icon" src="{{competence.img}}" />
-<h4>
-  {{attackerName}} a empoigné {{defenderName}}
-</h4>
-<hr>
-<div>
-
-  <span class='chat-card-button-area'>
-      Au round suivant l'acquisition des 2 points d'Emp, {{attackerName}} peut faire perdre autant de points d'Endurance qu'il souhaite à {{defenderName}}
-      <br>
-      <a class='empoignade-perte-endurance chat-card-button'>
-        <select class='empoignade-perte-endurance'>
-          <option value="none">Faire perdre de l'endurance (selectionnez)</option>
-          <option value="end0">Endurance à 0</option>
-          <option value="end1">Endurance à 1</option>
-          <option value="endmoitie">La moitié de l'endurance</option>
-          <option value="endquart">Le quart de l'endurance</option>
-        </select>
-      </a>
-      
-      {{#if empoignade.system.ausol}}
-
-      {{else}}
-        <br>
-        Dès l'acquisition des 2 points d'Emp, {{attackerName}} peut entraîner {{defenderName}} au sol. Les deux protagonistes restent empoignés.
-        <br>
-        <a class='empoignade-entrainer-sol chat-card-button'>
-          Entraîner au sol
-        </a>
-        <br>
-        A la fin du round ou les 2 points d'Emp sont acquis, {{attackerName}} peut projeter {{defenderName}} au sol. Les deux protagonistes ne sont plus empoignés.
-        <br>
-        <a class='empoignade-projeter-sol chat-card-button'>
-          Projeter au sol
-        </a>
-      {{/if}}
-
-
-</div>
--- a/templates/chat-empoignade-entrainer-sol.html
+++ b/templates/chat-empoignade-entrainer-sol.html
@ -1,7 +1,8 @@
 <img class="chat-icon" src="{{competence.img}}" />
 <h4>
-  {{attackerName}} a entraîné {{defenderName}} au sol. L'empoignade peut continuer.
+  {{attacker.name}} a entraîné {{defender.name}} au sol
 </h4>
 <hr>
 <div>
+  L'empoignade peut continuer.
 </div>
--- a/templates/chat-empoignade-entrainer.html
+++ b/templates/chat-empoignade-entrainer.html
@ -0,0 +1,16 @@
+<img class="chat-icon" src="{{competence.img}}" />
+<h4>
+  {{attacker.name}} a empoigné {{defender.name}}
+</h4>
+<hr>
+<div>
+  <span class='chat-card-button-area'>
+    {{attacker.name}} vient d'obtenir 2 points d'Emp, et peut
+      entraîner {{defender.name}} au sol. Les deux protagonistes
+      restent empoignés.
+      <br>
+      <a class='empoignade-entrainer-sol chat-card-button'>
+        Entraîner au sol
+      </a>
+  </span>
+</div>
--- a/templates/chat-empoignade-immobilise.html
+++ b/templates/chat-empoignade-immobilise.html
@ -0,0 +1,35 @@
+<img class="chat-icon" src="{{competence.img}}" />
+<h4>
+  {{attacker.name}} a empoigné {{defender.name}}
+</h4>
+<hr>
+<div>
+  <span class='chat-card-button-area'>
+    <p>
+      {{attacker.name}} a obtenu 2 points d'Emp à la fin du round précédent, et peut:
+      
+      <ul><li>
+        faire perdre des points d'Endurance à {{defender.name}}
+        <br>
+        <a class='empoignade-perte-endurance chat-card-button'>
+          <select class='empoignade-perte-endurance'>
+            <option value="none">Faire perdre de l'endurance (selectionnez)</option>
+            <option value="end0">Endurance à 0</option>
+            <option value="end1">Endurance à 1</option>
+            <option value="endmoitie">La moitié de l'endurance</option>
+            <option value="endquart">Le quart de l'endurance</option>
+          </select>
+        </a>
+      {{#if empoignade.system.ausol}}
+      {{else}}
+      </li><li>
+          projeter {{defender.name}} au sol. Les deux protagonistes ne sont plus empoignés.
+          <br>
+          <a class='empoignade-projeter-sol chat-card-button'>
+            Projeter au sol
+          </a>
+        {{/if}}
+      </li></ul>
+    </p>
+  </span>
+</div>
--- a/templates/chat-empoignade-perte-endurance.html
+++ b/templates/chat-empoignade-perte-endurance.html
@ -1,7 +1,8 @@
 <img class="chat-icon" src="{{competence.img}}" />
 <h4>
-  {{attackerName}} a fait perdre de l'endurance à {{defenderName}}, qui reste immobilisé. L'empoignade peut continuer.
+  {{attacker.name}} a fait perdre de l'endurance à {{defender.name}}
 </h4>
 <hr>
 <div>
+  {{defender.name}} reste immobilisé. L'empoignade peut continuer.
 </div>
--- a/templates/chat-empoignade-projeter-sol.html
+++ b/templates/chat-empoignade-projeter-sol.html
@ -1,7 +1,8 @@
 <img class="chat-icon" src="{{competence.img}}" />
 <h4>
-  {{attackerName}} a projeté {{defenderName}} au sol. L'empoignade est terminée et a été supprimée.
+  {{attacker.name}} a projeté {{defender.name}} au sol
 </h4>
 <hr>
 <div>
+  L'empoignade est terminée et a été supprimée.
 </div>
--- a/templates/chat-empoignade-resultat.html
+++ b/templates/chat-empoignade-resultat.html
@ -1,16 +1,17 @@
 <img class="chat-icon" src="{{competence.img}}" />
 <h4>
+  {{log 'rollData' this}}
  {{#if (eq mode "empoigner")}}
-    {{attackerName}} tente d'empoigner {{defenderName}}
+    {{attacker.name}} tente d'empoigner {{defender.name}}
  {{/if}}
  {{#if (eq mode "contrer-empoigner")}}
-    {{defenderName}} tente de contrer l'empoignade de {{attackerName}}
+    {{defender.name}} tente de contrer l'empoignade de {{attacker.name}}
  {{/if}}
  {{#if (eq mode "liberer")}}
-    {{attackerName}} tente de se libérer de l'empoignade de {{defenderName}}
+    {{attacker.name}} tente de se libérer de l'empoignade de {{defender.name}}
  {{/if}}
  {{#if (eq mode "contrer-liberer")}}
-    {{defenderName}} tente de contrer la libération de {{attackerName}}
+    {{defender.name}} tente de contrer la libération de {{attacker.name}}
  {{/if}}
 </h4>
 {{> "systems/foundryvtt-reve-de-dragon/templates/chat-infojet.html"}}
@ -20,7 +21,7 @@

  {{#if (gte empoignade.system.pointsemp 2)}}    
  
-  <br><strong>{{defenderName}} est empoigné et immobilisé par {{attackerName}} !</strong>
+  <br><strong>{{defender.name}} est empoigné et immobilisé par {{attacker.name}} !</strong>

  {{else}}
    <span class='chat-card-button-area'>
@ -29,16 +30,12 @@
      {{#if (eq mode "empoigner")}}
        {{#if empoignade.isSuccess}}
          <a class='defense-empoignade-cac chat-card-button'
-              data-attackerId='{{attacker.id}}' 
-              data-defenderId='{{defender.id}}' 
              data-diff-libre='{{diffLibre}}' 
              data-defense-mode="contrer-empoigner">
          Contrer l'empoignade (Corps à Corps)
          </a>
            {{#if (eq empoignade.system.pointsemp 0)}}
              <a class='defense-empoignade-esquive chat-card-button'
-                  data-attackerId='{{attacker.id}}'
-                  data-defenderId='{{defender.id}}'
                  data-diff-libre='{{diffLibre}}' 
                  data-defense-mode="contrer-empoigner">
                  Contrer l'empoignade (Esquive)
@ -52,8 +49,6 @@
      {{#if (eq mode "liberer")}}
        {{#if empoignade.isSuccess}}
          <a class='defense-empoignade-cac chat-card-button'
-            data-attackerId='{{attacker.id}}'
-            data-defenderId='{{defender.id}}'
            data-diff-libre='{{diffLibre}}' 
            data-defense-mode="contrer-liberer">
            Contrer la libération (Corps à Corps)
@ -78,8 +73,7 @@
          La tentative de contrer la libération est un échec!
        {{/if}}
      {{/if}}
-
-      <br>Points d'Emp: {{empoignade.system.pointsemp}}
-
+    </span>
+  <br>Points d'Emp: {{empoignade.system.pointsemp}}
  {{/if}}
 </div>
--- a/templates/chat-empoignade-valider.html
+++ b/templates/chat-empoignade-valider.html
@ -1,10 +1,9 @@
 <img class="chat-icon" src="{{competence.img}}" />
 <h4>
-  {{attackerName}} tente d'empoigner {{defenderName}}
+  {{attacker.name}} tente d'empoigner {{defender.name}}
 </h4>
 <hr>
 <div>
-
  <span class='chat-card-button-area'>
    <br>
    <strong>{{attacker.name}} tente d'empoigner {{defender.name}}, qui est équipé d'une arme de mêlée. {{defender.name}}
@ -16,5 +15,5 @@
      data-defenderId='{{defender.id}}'>
      Poursuivre l'empoignade
    </a>
-
+  </span>
 </div>
--- a/templates/chat-resultat-possession.html
+++ b/templates/chat-resultat-possession.html
@ -1,6 +1,6 @@
 <img class="chat-icon" src="{{competence.img}}" />
 <h4>
-  {{#if (eq mode "possession")}}
+  {{#if (eq mode "attaque")}}
    {{attacker.name}} tente de {{#if isECNIDefender}}conjurer la possession de{{else}}posséder{{/if}} {{defender.name}}
  {{else}}
    {{defender.name}} tente de {{#if isECNIDefender}}résister à{{else}}conjurer la possession de{{/if}} {{attacker.name}}
@ -12,7 +12,7 @@
 <div>
  <span class='chat-card-button-area'>
    <br>
-    {{#if (eq mode "possession")}}
+    {{#if (eq mode "attaque")}}
      {{#if possession.isSuccess}}
        <a class='defense-possession chat-card-button'
            data-attackerId='{{attacker.id}}'
--- a/templates/dialog-roll-defense-empoignade.html
+++ b/templates/dialog-roll-defense-empoignade.html
@ -1,6 +1,6 @@
 <form class="skill-roll-dialog">
  <h2>
-    {{defenderName}} tente de contrer l'empoignade de {{attackerName}}
+    {{defender.name}} tente de contrer l'empoignade de {{attacker.name}}
  </h2>
  <div class="grid grid-2col">
    <div class="flex-group-left">
--- a/templates/enum-categorie-competencecreature.html
+++ b/templates/enum-categorie-competencecreature.html
@ -0,0 +1,3 @@
+{{#each @root.categoriesCompetencesCreature as |categorie key|}}
+<option value="{{@key}}">{{categorie.label}}</option>
+{{/each}}
--- a/templates/enum-categorie-competence.html
+++ b/templates/enum-categorie-competence.html
@ -1,3 +1,3 @@
-{{#each @root.categorieCompetences as |categorie key|}}
+{{#each @root.categories as |categorie key|}}
 <option value="{{@key}}">{{categorie.label}}</option>
 {{/each}}
--- a/templates/item-competence-sheet.html
+++ b/templates/item-competence-sheet.html
@ -18,7 +18,7 @@
        <label for="system.categorie">Catégorie </label>
        <select name="system.categorie" class="categorie" data-dtype="String">
              {{#select system.categorie}}
-              {{>"systems/foundryvtt-reve-de-dragon/templates/enum-categorie-competence.html"}}
+              {{>"systems/foundryvtt-reve-de-dragon/templates/enum-categories.html"}}
              {{/select}}
        </select>
      </div>
--- a/templates/item-competencecreature-sheet.html
+++ b/templates/item-competencecreature-sheet.html
@ -6,50 +6,38 @@
      <label for="system.categorie">Catégorie</label>
      <select name="system.categorie" class="categorie" data-dtype="String">
          {{#select system.categorie}}
-          {{>"systems/foundryvtt-reve-de-dragon/templates/enum-categorie-competence.html"}}
+          {{>"systems/foundryvtt-reve-de-dragon/templates/enum-categories.html"}}
          {{/select}}
      </select>
    </div>
    <div class="form-group">
-      <label for="niveau">Valeur de Caractéristique </label>
+      <label for="niveau">Valeur de Caractéristique</label>
      <input class="attribute-value" type="text" name="system.carac_value" value="{{system.carac_value}}" data-dtype="Number"/>
    </div>
    <div class="form-group">
-      <label for="niveau">Niveau </label>
+      <label for="niveau">Niveau</label>
      <input class="attribute-value" type="text" name="system.niveau" value="{{system.niveau}}" data-dtype="Number"/>
    </div>
    <div class="form-group">
      <label for="default_diffLibre">Difficulté libre par défaut</label>
      <input class="attribute-value" type="text" name="system.default_diffLibre" value="{{system.default_diffLibre}}" data-dtype="Number"/>
    </div>
-    <div class="form-group">
-      <label for="system.ispossession">Attaque de possession</label>
-      <input class="attribute-value" type="checkbox" name="system.ispossession" {{#if system.ispossession}}checked{{/if}}/>
-    </div>
-    {{#unless system.ispossession}}
-    <div class="form-group">
-        <label for="system.iscombat">Compétence d'attaque</label>
-        <input class="attribute-value" type="checkbox" name="system.iscombat" {{#if system.iscombat}}checked{{/if}}/>
-      </div>
-      {{#if system.iscombat}}
-      <div class="form-group">
-        <label for="system.isnaturelle">Arme naturelle</label>
-        <input class="attribute-value" type="checkbox" name="system.isnaturelle" {{#if system.isnaturelle}}checked{{/if}}/>
-      </div>
+    {{#if isdommages}}
      <div class="form-group">
        <label for="niveau">Dommages (+dom)</label>
        <input class="attribute-value" type="text" name="system.dommages" value="{{system.dommages}}" data-dtype="Number"/>
      </div>
-      {{/if}}
+    {{/if}}
+    {{#if isparade}}
      <div class="form-group">
-        <label>Catégorie parade </label>
+        <label>Catégorie parade</label>
        <select name="system.categorie_parade" id="categorie_parade" data-dtype="String">
          {{#select system.categorie_parade}}
          {{>"systems/foundryvtt-reve-de-dragon/templates/enum-categorie-parade.html"}}
          {{/select}}
        </select>
      </div>
-    {{/unless}}
+    {{/if}}

    {{>"systems/foundryvtt-reve-de-dragon/templates/partial-item-description.html"}}
    </section>
Author	SHA1	Message	Date
uberwald	54df875451	Merge pull request 'v10.7.20 - la cuirasse de Sémolosse' (#662 ) from VincentVk/foundryvtt-reve-de-dragon:v10 into v10 Reviewed-on: #662	2023-07-12 08:09:06 +02:00
Vincent Vandemeulebrouck	253a1bd433	v10.7.20 - la cuirasse de Sémolosse - correction de méthodes qui filtrent les items - recherche de cases TMR - recherche de tâches de lecture - recherche d'armure (pour le malus armure) - recherche de potions	2023-07-12 00:46:46 +02:00
Vincent Vandemeulebrouck	e58d88fab6	Fix: filterItem ne marchait plus sans type	2023-07-12 00:39:21 +02:00
uberwald	41d2404de2	Merge pull request 'v10.7.20 - la poigne de Sémolosse' (#655 ) from VincentVk/foundryvtt-reve-de-dragon:v10 into v10 Reviewed-on: #655	2023-06-19 15:36:32 +02:00
Vincent Vandemeulebrouck	631ee0b801	v10.7.20 - La poigne de Sémolosse	2023-06-15 02:02:00 +02:00
Vincent Vandemeulebrouck	ed9c574cd2	Fin d'empoignade En cours de round en atteignant 2 points d'empoignade, on peut uniquement entraîner au sol. En fin de round, si la victime est immobilisée, on peut projeter, ou faire perdre de l'endurance	2023-06-15 01:59:17 +02:00
Vincent Vandemeulebrouck	bb624e8e96	Restreindre les actions d'empoignade Seul le propriétaire du défenseur peut effecuer les contres d'empoignade ou tenter de se libérer. Seul le propriétaire de l'empoigneur peut tenter d'empêcher la libération du défenseur, de projeter au sol, ou de faire perdre de l'endurance.	2023-06-15 01:03:33 +02:00
Vincent Vandemeulebrouck	40f2ac8714	Correction malus de taille empoignade	2023-06-15 00:30:11 +02:00
Vincent Vandemeulebrouck	804fa3b784	Fix empoignade - les items d'empoignade sont ajoutés par le MJ - les caractéristiques du défenseur sont utilisées pour la défense - la difficulté d'attaque est imposée au défenseur - les particulières sont en finesse (p133)	2023-06-15 00:30:11 +02:00
uberwald	d35e47824d	Merge pull request 'v10.7.19 - les fantômes de Semolosse' (#653 ) from VincentVk/foundryvtt-reve-de-dragon:v10 into v10 Reviewed-on: #653	2023-06-14 08:27:49 +02:00
Vincent Vandemeulebrouck	37d3fa5bc5	Version 10.7.19 - les fantômes de Semolosse	2023-06-14 02:10:59 +02:00
Vincent Vandemeulebrouck	8a12eb865c	Migration des compendiums	2023-06-14 02:10:59 +02:00
Vincent Vandemeulebrouck	5baa94b3f0	Gestion des difficultés de Possession - gestion de la difficulté imposée sur la défense - gestion des particulières en attaque considérées en finesse - utilisation du rêve actuel pour les personnages	2023-06-14 02:10:59 +02:00
Vincent Vandemeulebrouck	37c2b6432d	Catégories des compétences de créatures Les créatures peuvent avoir des compétences d'armes (lancer, mêlée, tir, armes naturelles), de parade, de possession, et générales. Les initiatives sont cohérentes. Les possessions sont en phase 10 d'initiative.	2023-06-14 02:10:59 +02:00
Vincent Vandemeulebrouck	fc63835a71	Fix commerce achat MJ sans personnage Correction sur les achats: l'objet acheté vient forcément soit d'un personnage-vendeur, soit des Items globaux. Ne pas essayer d'acheter autrement car on aurait des données d'item non structurées, et donc ça ne fonctionnerait pas.	2023-06-14 02:10:59 +02:00