2022-07-02 08:53:30 +02:00
6 changed files with 114 additions and 122 deletions
--- a/module/actor.js
+++ b/module/actor.js
@ -372,12 +372,27 @@ export class RdDActor extends Actor {
    const list = this.getDraconicList();
    return duplicate(list[0]);
  }
-  getDraconicOrZero() {
-    const list = this.getDraconicList().filter(it => Misc.data(it).data.niveau >= 0);
-    if (list.length == 0) {
-      return { name: "Aucun", data: { niveau: 0 } };
+  getDraconicOuPossession() {
+    const possessions = this.items.filter(it => Misc.data(it).type == 'competencecreature' && Misc.templateData(it).ispossession)
+      .sort(Misc.descending(it => Misc.templateData(it).niveau));
+    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();
-    RdDPossession.managePossession(this, draconic, possession)
+    let draconic = this.getDraconicOuPossession();
+    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);
      }
--- a/module/rdd-possession.js
+++ b/module/rdd-possession.js
@ -18,40 +18,40 @@ export class RdDPossession {
  }

  /* -------------------------------------------- */
-  static searchPossessionFromEntite( attacker, defender) {
-    let poss = attacker.data.items.find( poss => poss.type == 'possession' && poss.data.data.possedeid == defender.data._id);
+  static searchPossessionFromEntite(attacker, defender) {
+    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.isECNIDefender) {
+    if (!rollData.rolled.isSuccess) {
+      if (rollData.isECNIDefender) {
        rollData.possession.data.compteur--
      } else {
        rollData.possession.data.compteur++
@ -62,52 +62,43 @@ export class RdDPossession {

    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.items.find( item => item.type =='possession' && item.data.data.possessionid == possessionId)
-    if ( !possession ) {    
-      possession = defender.items.find( item => item.type =='possession' && item.data.data.possessionid == possessionId)
-      if ( !possession) {
-        ui.notifications.warn("Une erreur s'est produite : Aucune possession trouvée !!")
-        return
-      }
+    let possession = attacker.getPossession(possessionId) ?? defender.getPossession(possessionId) ;
+    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") {
-      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"))
+
+    if (rollData.isECNIDefender) {
      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
-      rollData.isECNIDefender = true
-      //RdDItemCompetenceCreature.setRollDataCreature( rollData )
+    } else {
+      rollData.competence.data.defaut_carac = 'reve-actuel'
+      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,16 +112,7 @@ export class RdDPossession {
  }

  /* -------------------------------------------- */
-  static async _onRollPossession( rollData, isSuccess ) {
-    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) {    
-    
+  static async onAttaquePossession(attacker, competence, possession = undefined) {
    const target = RdDCombat.getTarget()
    if (target == undefined) {
      ui.notifications.warn((game.user.targets?.size ?? 0) > 1
@ -140,35 +122,28 @@ export class RdDPossession {
    }

    const defender = target.actor;
-    if ( !possession) {
-      possession = this.searchPossessionFromEntite( attacker, defender)
-      if ( !possession) {
-        possession = await this.createPossession(attacker, defender)
-      }
-    }
-    possession = duplicate(possession);
+    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,
-      possesseur: attacker.name,
-      attackerId: attacker.data._id,
-      defenderId: defender.data._id,
-      mode: "possession"
+      attacker: attacker,
+      defender: defender
    };
-    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 {
-      img: 'systems/foundryvtt-reve-de-dragon/icons/competence_vigilance.webp',
-      name: 'non Haut-rêvant',
-      data: {
-        data: {
-          niveau: 0,
-          defaut_carac: "reve",
-        }
-      }
-    };
+  /* -------------------------------------------- */
+  static async _onRollPossession(rollData, isSuccess) {
+    rollData.possession.isSuccess = isSuccess;
+    this.updateEtatPossession(rollData.possession);
+    await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-possession.html');
  }

  /* -------------------------------------------- */
-  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",
--- a/module/rdd-utility.js
+++ b/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
--- a/templates/actor-sheet.html
+++ b/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 --}}
-          <h3 class="blessures-title">Possession:</h3>
-          <ul class="item-list alterne-list">
-            <li class="competence-header flexrow">
-              <span class="competence-title flex-grow competence-label">Nom</span>
-              <span class="competence-title competence-label">Type</span>
-            </li>
+        {{#if possessions.length}}
+        {{!-- Possession --}}
+        <h3 class="blessures-title">Possession:</h3>
+        <ul class="item-list alterne-list">
+          <li class="competence-header flexrow">
+            <span class="competence-title flex-grow competence-label">Nom</span>
+            <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}}">
-                <span class="competence-label">
-                  <a class="sheet-possession-attack">{{possession.name}} (Conjurer)</a>
-                </span>
-                <span class="competence-label">{{possession.data.type}}</span>
-                <div class="item-controls">
-                  <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>
-                </div>          
-            </li>
-            {{/each}}
-            </ul>
-  
+          <li class="item flexrow list-item" data-item-id="{{possession._id}}">
+              <span class="competence-label">
+                <a class="sheet-possession-attack">{{possession.name}} (Conjurer)</a>
+              </span>
+              <span class="competence-label">{{possession.data.type}}</span>
+              <div class="item-controls">
+                <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>
+              </div>          
+          </li>
+          {{/each}}
+          </ul>
+        {{/if}}
      </div>

      {{!-- Connaissances Tab --}}
--- a/templates/chat-resultat-possession.html
+++ b/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}}'
-                data-defenderId='{{defenderId}}' data-possessionId='{{possession.data.possessionid}}'>Résister à la possession</a>
-              </a>
+        <a class='defense-possession chat-card-button'
+            data-attackerId='{{attacker.id}}'
+            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}}
--- a/templates/dialog-roll-defense-possession.html
+++ b/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}}"/>