Fix possession

On peut maintenant lutter pour les haut-rêvants
Les messages ont été clarifiés

module/actor.js

@@ -372,12 +372,27 @@ export class RdDActor extends Actor {
     const list = this.getDraconicList();
     return duplicate(list[0]);
   }
-  getDraconicOrZero() {
+  getDraconicOuPossession() {
-    const list = this.getDraconicList().filter(it => Misc.data(it).data.niveau >= 0);
+    const possessions = this.items.filter(it => Misc.data(it).type == 'competencecreature' && Misc.templateData(it).ispossession)
-    if (list.length == 0) {
+      .sort(Misc.descending(it => Misc.templateData(it).niveau));
-      return { name: "Aucun", data: { niveau: 0 } };
+    if (possessions.length>0) {
+      return duplicate(possessions[0]);
     }
-    return duplicate(list[0]);
+    const draconics = this.getDraconicList().filter(it => Misc.data(it).data.niveau >= 0);
+    if (draconics.length> 0) {
+      return duplicate(draconics[0]);
+    }
+    return {
+      img: 'systems/foundryvtt-reve-de-dragon/icons/entites/possession.webp',
+      name: 'Sans draconic',
+      data: {
+        niveau: 0,
+        defaut_carac: "reve",
+      }
+    };
+  }
+  getPossession(possessionId) {
+    return this.items.find(it => it.type == 'possession' && it.data.data.possessionid == possessionId);
   }
 
   getDemiReve() {
@@ -783,7 +798,7 @@ export class RdDActor extends Actor {
   async combattreReveDeDragon(force) {
     let rollData = {
       actor: this,
-      competence: duplicate(this.getDraconicOrZero()),
+      competence: duplicate(this.getDraconicOuPossession()),
       canClose: false,
       rencontre: duplicate(TMRRencontres.getRencontre('rdd')),
       tmr: true,
@@ -2538,7 +2553,7 @@ export class RdDActor extends Actor {
     if (rollData.competence.type == 'competencecreature') {
       if (rollData.competence.data.iscombat) {
         if (rollData.competence.data.ispossession) {
-          RdDPossession.managePossession(this, rollData.competence)
+          RdDPossession.onAttaquePossession(this, rollData.competence)
         } else {
           const arme = RdDItemCompetenceCreature.toArme(rollData.competence)
           RdDCombat.createUsingTarget(this)?.attaque(competence, arme)
@@ -2566,8 +2581,8 @@ export class RdDActor extends Actor {
 
   /* -------------------------------------------- */
   conjurerPossession(possession) {
-    let draconic = this.getBestDraconic();
+    let draconic = this.getDraconicOuPossession();
-    RdDPossession.managePossession(this, draconic, possession)
+    RdDPossession.onAttaquePossession(this, draconic, possession)
   }
 
   /* -------------------------------------------- */
@@ -3206,7 +3221,7 @@ export class RdDActor extends Actor {
     let competence = Misc.data(this.getCompetence(arme.data.competence));
     if (arme || (competence.type == 'competencecreature' && competence.data.iscombat)) {
       if (competence.data.ispossession) {
-        RdDPossession.managePossession(this, competence);
+        RdDPossession.onAttaquePossession(this, competence);
       } else {
         RdDCombat.createUsingTarget(this)?.attaque(competence, arme);
       }

module/rdd-possession.js

@@ -14,44 +14,44 @@ Donc la compétence Possession ne peut être démarrée que par le MJ.
 export class RdDPossession {
 
   /* -------------------------------------------- */
-  static init() {    
+  static init() {
   }
 
   /* -------------------------------------------- */
-  static searchPossessionFromEntite( attacker, defender) {
+  static searchPossessionFromEntite(attacker, defender) {
-    let poss = attacker.data.items.find( poss => poss.type == 'possession' && poss.data.data.possedeid == defender.data._id);
+    let poss = attacker.data.items.find(poss => poss.type == 'possession' && poss.data.data.possedeid == defender.data._id);
     if (!poss) {
-      poss = defender.data.items.find( poss => poss.type == 'possession' && poss.data.data.possedeid == defender.data._id);
+      poss = defender.data.items.find(poss => poss.type == 'possession' && poss.data.data.possedeid == defender.data._id);
     }
     return poss && duplicate(poss) || undefined;
   }
 
   /* -------------------------------------------- */
-  static updateEtatPossession( possession ) {
+  static updateEtatPossession(possession) {
     possession.ptsConjuration = 0
     possession.ptsPossession = 0
     console.log("Possession", possession)
-    if ( possession.data.compteur > 0) {
+    if (possession.data.compteur > 0) {
       possession.ptsPossession = possession.data.compteur
-    } 
+    }
-    if ( possession.data.compteur < 0) {
+    if (possession.data.compteur < 0) {
       possession.ptsConjuration = Math.abs(possession.data.compteur)
-    } 
+    }
     possession.isPosseder = false
     possession.isConjurer = false
-    if (possession.ptsPossession >= 2 ) {
+    if (possession.ptsPossession >= 2) {
       possession.isPosseder = true
     }
-    if (possession.ptsConjuration >= 2 ) {      
+    if (possession.ptsConjuration >= 2) {
       possession.isConjurer = true
     }
   }
 
   /* -------------------------------------------- */
-  static async resultConjuration( rollData) {
+  static async resultConjuration(rollData) {
     let actor = game.actors.get(rollData.possession.data.possedeid)
-    if ( !rollData.rolled.isSuccess ) {
+    if (!rollData.rolled.isSuccess) {
-      if( rollData.isECNIDefender) {
+      if (rollData.isECNIDefender) {
         rollData.possession.data.compteur--
       } else {
         rollData.possession.data.compteur++
@@ -59,55 +59,46 @@ export class RdDPossession {
       let update = { _id: rollData.possession._id, "data.compteur": rollData.possession.data.compteur }
       await actor.updateEmbeddedDocuments('Item', [update])
     }
-      
+
     this.updateEtatPossession(rollData.possession)
     await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-possession.html')
-    if ( rollData.possession.isPosseder || rollData.possession.isConjurer) {
+    if (rollData.possession.isPosseder || rollData.possession.isConjurer) {
       actor.deleteEmbeddedDocuments("Item", [rollData.possession._id])
     }
   }
 
   /* -------------------------------------------- */
-  static async onDefensePossession( attackerId, defenderId, possessionId) {
+  static async onDefensePossession(attackerId, defenderId, possessionId) {
     let attacker = game.actors.get(attackerId)
     let defender = game.actors.get(defenderId)
-
+    let possession = attacker.getPossession(possessionId) ?? defender.getPossession(possessionId) ;
-    let possession = attacker.items.find( item => item.type =='possession' && item.data.data.possessionid == possessionId)
+    if (!possession) {
-    if ( !possession ) {    
+      ui.notifications.warn("Une erreur s'est produite : Aucune possession trouvée !!")
-      possession = defender.items.find( item => item.type =='possession' && item.data.data.possessionid == possessionId)
+      return
-      if ( !possession) {
-        ui.notifications.warn("Une erreur s'est produite : Aucune possession trouvée !!")
-        return
-      }
     }
-    possession = duplicate(possession)
-
     // Update for draconic roll
     let rollData = {
-      possession: possession
+      mode: "conjuration",
+      isECNIDefender: defender.type == "entite",
+      possession: duplicate(possession),
+      attacker: attacker,
+      defender: defender,
+      competence: defender.getDraconicOuPossession(),
+      selectedCarac: defender.data.data.carac.reve,
     }
-    rollData.actor = defender
+
-    if ( defender.type == "personnage") {
+    if (rollData.isECNIDefender) {
-      rollData.competence = duplicate(defender.getDraconicOrZero())
-      rollData.competence.data.defaut_carac = 'reve-actuel'
-      rollData.forceCarac = { 'reve-actuel': { label: "Rêve Actuel", value: defender.getReveActuel() } }
-      rollData.selectedCarac = defender.data.data.carac.reve
-      rollData.isECNIDefender = false
-    } else {
-      rollData.competence = duplicate(defender.getCompetence("Possession"))
       rollData.competence.data.defaut_carac = "reve"
       rollData.forceCarac = { 'reve': { label: "Rêve", value: defender.data.data.carac.reve.value } }
-      rollData.selectedCarac = defender.data.data.carac.reve
+    } else {
-      rollData.isECNIDefender = true
+      rollData.competence.data.defaut_carac = 'reve-actuel'
-      //RdDItemCompetenceCreature.setRollDataCreature( rollData )
+      rollData.forceCarac = { 'reve-actuel': { label: "Rêve Actuel", value: defender.getReveActuel() } }
     }
-    rollData.mode =  "conjuration"
-    rollData.possesseur = attacker.name
 
     const dialog = await RdDRoll.create(defender, rollData,
       {
         html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-defense-possession.html',
-        options: { height: 400 }
+        options: { height: 450 }
       },
       {
         name: 'conjurer',
@@ -121,54 +112,38 @@ export class RdDPossession {
   }
 
   /* -------------------------------------------- */
-  static async _onRollPossession( rollData, isSuccess ) {
+  static async onAttaquePossession(attacker, competence, possession = undefined) {
-    let possession = rollData.possession
-    possession.isSuccess = isSuccess
-    this.updateEtatPossession( possession)
-    await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-possession.html');
-  }
-
-  /* -------------------------------------------- */
-  static async managePossession(attacker, competence, possession=undefined) {    
-    
     const target = RdDCombat.getTarget()
     if (target == undefined) {
       ui.notifications.warn((game.user.targets?.size ?? 0) > 1
         ? "Vous devez choisir <strong>une seule</strong> cible à posséder!"
         : "Vous devez choisir une cible à posséder!");
       return;
-    }    
-    
-    const defender = target.actor;
-    if ( !possession) {
-      possession = this.searchPossessionFromEntite( attacker, defender)
-      if ( !possession) {
-        possession = await this.createPossession(attacker, defender)
-      }
     }
-    possession = duplicate(possession);
 
+    const defender = target.actor;
+    possession = duplicate(possession ?? this.searchPossessionFromEntite(attacker, defender) ??(await this.createPossession(attacker, defender)));
+    
     this.updateEtatPossession(possession)
     let rollData = {
-      competence: competence.data.data.niveau >=0 ? competence : RdDPossession.competenceNonHautRevant(),
+      mode: "possession",
+      isECNIDefender: defender.type == "entite",
+      competence: competence,
       possession: possession,
-      possede: defender.name,
+      attacker: attacker,
-      possesseur: attacker.name,
+      defender: defender
-      attackerId: attacker.data._id,
-      defenderId: defender.data._id,
-      mode: "possession"
     };
-    if ( attacker.isCreature()) {
+    if (attacker.isCreature()) {
       RdDItemCompetenceCreature.setRollDataCreature(rollData)
     }
 
-    const dialog = await RdDRoll.create( attacker, rollData,
+    const dialog = await RdDRoll.create(attacker, rollData,
       {
         html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-competence.html',
         options: { height: 540 }
       }, {
       name: 'jet-possession',
-      label: 'Possession: ',
+      label: rollData.isECNIDefender ? 'Conjurer la possession' : 'Possession',
       callbacks: [
         { condition: r => (r.rolled.isSuccess), action: async r => await this._onRollPossession(r, true) },
         { condition: r => (r.rolled.isEchec), action: async r => await this._onRollPossession(r, false) },
@@ -177,21 +152,15 @@ export class RdDPossession {
     dialog.render(true)
   }
 
-  static competenceNonHautRevant() {
+  /* -------------------------------------------- */
-    return {
+  static async _onRollPossession(rollData, isSuccess) {
-      img: 'systems/foundryvtt-reve-de-dragon/icons/competence_vigilance.webp',
+    rollData.possession.isSuccess = isSuccess;
-      name: 'non Haut-rêvant',
+    this.updateEtatPossession(rollData.possession);
-      data: {
+    await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-possession.html');
-        data: {
-          niveau: 0,
-          defaut_carac: "reve",
-        }
-      }
-    };
   }
 
   /* -------------------------------------------- */
-  static async createPossession( attacker, defender ) {
+  static async createPossession(attacker, defender) {
     let possessionData = {
       name: "Possession en cours de " + attacker.name, type: 'possession',
       img: "systems/foundryvtt-reve-de-dragon/icons/entites/possession2.webp",

module/rdd-utility.js

@@ -694,7 +694,7 @@ export class RdDUtility {
       actor.tmrApp.lancerSortEnReserve(coord, sortId);
     });
 
-    // gestion bouton tchat Acheter
+    // gestion bouton tchat Possession
     html.on("click", '.defense-possession', event => {
       let attackerId = event.currentTarget.attributes['data-attackerId'].value
       let defenderId = event.currentTarget.attributes['data-defenderId'].value

templates/actor-sheet.html

@@ -321,6 +321,7 @@
         {{!-- Liste de blessures --}}
         {{> "systems/foundryvtt-reve-de-dragon/templates/actor-liste-blessures-partial.html" this}}
 
+        {{#if maladiesPoisons.length}}
         {{!-- Maladies & Poison --}}
         <h3 class="blessures-title">Maladies & Poisons:</h3>
         <ul class="item-list alterne-list">
@@ -354,28 +355,30 @@
           </li>
           {{/each}}
           </ul>
+        {{/if}}
 
-          {{!-- Possession --}}
+        {{#if possessions.length}}
-          <h3 class="blessures-title">Possession:</h3>
+        {{!-- Possession --}}
-          <ul class="item-list alterne-list">
+        <h3 class="blessures-title">Possession:</h3>
-            <li class="competence-header flexrow">
+        <ul class="item-list alterne-list">
-              <span class="competence-title flex-grow competence-label">Nom</span>
+          <li class="competence-header flexrow">
-              <span class="competence-title competence-label">Type</span>
+            <span class="competence-title flex-grow competence-label">Nom</span>
-            </li>
+            <span class="competence-title competence-label">Type</span>
+          </li>
           {{#each possessions as |possession  key|}}
-            <li class="item flexrow list-item" data-item-id="{{possession._id}}">
+          <li class="item flexrow list-item" data-item-id="{{possession._id}}">
-                <span class="competence-label">
+              <span class="competence-label">
-                  <a class="sheet-possession-attack">{{possession.name}} (Conjurer)</a>
+                <a class="sheet-possession-attack">{{possession.name}} (Conjurer)</a>
-                </span>
+              </span>
-                <span class="competence-label">{{possession.data.type}}</span>
+              <span class="competence-label">{{possession.data.type}}</span>
-                <div class="item-controls">
+              <div class="item-controls">
-                  <a class="item-control item-edit" title="Modifier"><i class="fas fa-edit"></i></a>
+                <a class="item-control item-edit" title="Modifier"><i class="fas fa-edit"></i></a>
-                  <a class="item-control item-delete" title="Supprimer"><i class="fas fa-trash"></i></a>
+                <a class="item-control item-delete" title="Supprimer"><i class="fas fa-trash"></i></a>
-                </div>          
+              </div>          
-            </li>
+          </li>
-            {{/each}}
+          {{/each}}
-            </ul>
+          </ul>
-  
+        {{/if}}
       </div>
 
       {{!-- Connaissances Tab --}}

templates/chat-resultat-possession.html

@@ -1,29 +1,30 @@
 <img class="chat-icon" src="{{competence.img}}" />
 <h4>
   {{#if (eq mode "possession")}}
-    {{alias}} tente de posséder {{possede}}
+    {{attacker.name}} tente de {{#if isECNIDefender}}conjurer la possession de{{else}}posséder{{/if}} {{defender.name}}
   {{else}}
-    {{alias}} tente de conjurer la possession de {{possesseur}}
+    {{defender.name}} tente de {{#if isECNIDefender}}résister à{{else}}conjurer la possession de{{/if}} {{attacker.name}}
   {{/if}}
 </h4>
 {{> "systems/foundryvtt-reve-de-dragon/templates/chat-infojet.html"}}
 
 <hr>
-
 <div>
   <span class='chat-card-button-area'>
     <br>
     {{#if (eq mode "possession")}}
       {{#if possession.isSuccess}}
-        <a class='defense-possession chat-card-button' data-attackerId='{{attackerId}}'
+        <a class='defense-possession chat-card-button'
-                data-defenderId='{{defenderId}}' data-possessionId='{{possession.data.possessionid}}'>Résister à la possession</a>
+            data-attackerId='{{attacker.id}}'
-              </a>
+            data-defenderId='{{defender.id}}'
+            data-possessionId='{{possession.data.possessionid}}'>Résister à la possession</a>
+        </a>
       {{else}}
         La Tentative de Possession a échouée !
       {{/if}}
     {{else}}
       {{#if rolled.isSuccess}}
-        La Tentative de Possession a été conjurée ! {{alias}} résiste à la tentative de possession.
+        La Tentative de Possession a été conjurée ! {{defender.name}} résiste à la tentative de possession.
       {{else}}
         La Tentative de Possession n'a pas pu être conjurée !
       {{/if}}

templates/dialog-roll-defense-possession.html

@@ -1,5 +1,9 @@
 <form class="skill-roll-dialog">
-  <h2>Conjuration d'une Possession {{possession.name}}!</h2>
+  <h2>
+    {{defender.name}} tente de
+    {{#if isECNIDefender}}maintenir{{else}}résister à{{/if}}
+    la possession de {{attacker.name}}
+  </h2>
   <div class="grid grid-2col">
     <div class="flex-group-left">
       <img class="chat-icon" src="{{competence.img}}" alt="{{competence.name}}"/>