Merge from v1.5 possession fix

2022-07-02 09:02:31 +02:00
parent 09c4e691c7 70c26ebfe0
commit 0d288c56d4
7 changed files with 116 additions and 124 deletions
--- a/module/actor.js
+++ b/module/actor.js
@ -369,12 +369,27 @@ export class RdDActor extends Actor {
    const list = this.getDraconicList()
    return duplicate(list[0])
  }
-  getDraconicOrZero() {
-    const list = this.getDraconicList().filter(it => it.system.niveau >= 0);
-    if (list.length == 0) {
-      return { name: "Aucun", system: { niveau: 0 } };
+  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]);
    }
-    return duplicate(list[0]);
+    const draconics = this.getDraconicList().filter(it => it.system.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.system.possessionid == possessionId);
  }

  getDemiReve() {
@ -779,7 +794,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,
@ -2519,7 +2534,7 @@ export class RdDActor extends Actor {
    if (rollData.competence.type == 'competencecreature') {
      if (rollData.competence.system.iscombat) {
        if (rollData.competence.system.ispossession) {
-          RdDPossession.managePossession(this, rollData.competence)
+          RdDPossession.onAttaquePossession(this, rollData.competence)
        } else {
          const arme = RdDItemCompetenceCreature.toArme(rollData.competence)
          RdDCombat.createUsingTarget(this)?.attaque(competence, arme)
@ -2547,8 +2562,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)
  }

  /* -------------------------------------------- */
@ -3179,7 +3194,7 @@ export class RdDActor extends Actor {
    let competence = this.getCompetence(arme.system.competence)
    if (arme || (competence.type == 'competencecreature' && competence.system.iscombat)) {
      if (competence.system.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
@ -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) {
-    let poss = attacker.items.find( poss => poss.type == 'possession' && poss.system.possedeid == defender.id);
+  static searchPossessionFromEntite(attacker, defender) {
+    let poss = attacker.items.find(poss => poss.type == 'possession' && poss.system.possedeid == defender.id);
    if (!poss) {
-      poss = defender.items.find( poss => poss.type == 'possession' && poss.system.possedeid == defender.id);
+      poss = defender.items.find(poss => poss.type == 'possession' && poss.system.possedeid == defender.id);
    }
    return poss && duplicate(poss) || undefined;
  }

  /* -------------------------------------------- */
-  static updateEtatPossession( possession ) {
+  static updateEtatPossession(possession) {
    possession.ptsConjuration = 0
    possession.ptsPossession = 0
    console.log("Possession", possession)
-    if ( possession.system.compteur > 0) {
+    if (possession.system.compteur > 0) {
      possession.ptsPossession = possession.system.compteur
-    } 
-    if ( possession.system.compteur < 0) {
+    }
+    if (possession.system.compteur < 0) {
      possession.ptsConjuration = Math.abs(possession.system.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.system.possedeid)
-    if ( !rollData.rolled.isSuccess ) {
-      if( rollData.isECNIDefender) {
+    if (!rollData.rolled.isSuccess) {
+      if (rollData.isECNIDefender) {
        rollData.possession.system.compteur--
      } else {
        rollData.possession.system.compteur++
@ -59,55 +59,46 @@ export class RdDPossession {
      let update = { _id: rollData.possession._id, "system.compteur": rollData.possession.system.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.items.find( item => item.type =='possession' && item.system.possessionid == possessionId)
-    if ( !possession ) {    
-      possession = defender.items.find( item => item.type =='possession' && item.system.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.system.carac.reve,
    }
-    rollData.actor = defender
-    if ( defender.type == "personnage") {
-      rollData.competence = duplicate(defender.getDraconicOrZero())
-      rollData.competence.system.defaut_carac = 'reve-actuel'
-      rollData.forceCarac = { 'reve-actuel': { label: "Rêve Actuel", value: defender.getReveActuel() } }
-      rollData.selectedCarac = defender.system.carac.reve
-      rollData.isECNIDefender = false
-    } else {
-      rollData.competence = duplicate(defender.getCompetence("Possession"))
+
+    if (rollData.isECNIDefender) {
      rollData.competence.system.defaut_carac = "reve"
      rollData.forceCarac = { 'reve': { label: "Rêve", value: defender.system.carac.reve.value } }
-      rollData.selectedCarac = defender.system.carac.reve
-      rollData.isECNIDefender = true
-      //RdDItemCompetenceCreature.setRollDataCreature( rollData )
+    } else {
+      rollData.competence.system.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,54 +112,38 @@ 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
        ? "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,
-      possesseur: attacker.name,
-      attackerId: attacker.id,
-      defenderId: defender.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
@ -693,7 +693,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