Manage possession

module/item-competencecreature.js

@@ -9,11 +9,10 @@ export class RdDItemCompetenceCreature extends Item {
     rollData.carac = { "carac_creature": { label: rollData.competence.name, value: rollData.competence.data.carac_value } };
     rollData.competence.data.defaut_carac = "carac_creature";
     rollData.competence.data.categorie = "creature";
-    rollData.selectedCarac = rollData.carac.carac_creature;
+    rollData.selectedCarac =  rollData.carac.carac_creature;
     if (rollData.competence.data.iscombat) {
       rollData.arme = RdDItemCompetenceCreature.toArme(rollData.competence);
     }
-
   }
 
   /* -------------------------------------------- */

module/rdd-possession.js

@@ -19,24 +19,86 @@ export class RdDPossession {
 
   /* -------------------------------------------- */
   static init() {
-    this.possessionList = [];
   }
 
   /* -------------------------------------------- */
-  static searchPossessionFromEntite( attacker, target) {
-    let poss = this.possessionList.find( poss => poss.entiteId == attacker.data._id && poss.pjId == defender.data._id);
-    return poss;
+  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);
+    }
+    return poss && duplicate(poss) || undefined;
   }
 
   /* -------------------------------------------- */
-  static _onReussitePossession( r ) {
-    console.log("Success", r);
-    ui.notifications.warn("Succès du jet de Possession ! Mais La gestion des possessions n'est pas encore disponible, merci de la gérer manuellement");
+  static updateEtatPossession( possession ) {
+    possession.ptsConjuration = 0;
+    possession.ptsPossession = 0;
+    if ( possession.data.compteur > 0) {
+      possession.ptsPossession = possession.data.compteur;
+    } 
+    if ( possession.data.compteur < 0) {
+      possession.ptsConjuration = Math.abs(possession.data.compteur);
+    } 
+    if (possession.ptsPossession >= 2 ) {
+      // Possede
+    }
+    if (possession.ptsConjuration <= -2 ) {      
+      // Libere
+    }
+    console.log("Poss", possession);
   }
+
   /* -------------------------------------------- */
-  static _onEchecPossession( r ) {
-    console.log("Echec", r);
-    ui.notifications.warn("Echec du jet de Possession ! Mais La gestion des possessions n'est pas encore disponible, merci de la gérer manuellement");
+  static resultConjuration( rollData) {
+    console.log("RollData!!!", rollData);
+    if ( !rollData.rolled.isSuccess  ) {
+      rollData.possession.data.compteur++;
+    }
+    this.updateEtatPossession(rollData.possession);
+    RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-possession.html');
+  }
+
+  /* -------------------------------------------- */
+  static async onDefensePossession( actorId, possessionId) {
+    let actor = game.actors.get(actorId);
+    console.log("onDefensePossession", actor, possessionId);
+    let possession = duplicate(actor.items.find( item => item.type =='possession' && item.data.data.possessionid == possessionId));
+    let attacker = game.actors.get(possession.data.possesseurid);
+
+    // Update for draconic roll
+    let rollData = {
+      possession: possession
+    }
+    rollData.actor = actor;
+    rollData.competence = duplicate(actor.getDraconicOrZero());
+    rollData.competence.data.defaut_carac = 'reve-actuel';
+    rollData.forceCarac = { 'reve-actuel': { label: "Rêve Actuel", value: actor.getReveActuel() } }
+    rollData.mode =  "conjuration";
+    rollData.possesseur = attacker.name;
+
+    const dialog = await RdDRoll.create(actor, rollData,
+      {
+        html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-defense-possession.html',
+        options: { height: 400 }
+      },
+      {
+        name: 'conjurer',
+        label: 'Conjurer une Possession',
+        callbacks: [
+          { action: async r => this.resultConjuration(r) }
+        ]
+      }
+    );
+    dialog.render(true);
+  }
+
+  /* -------------------------------------------- */
+  static _onRollPossession( rollData, isSuccess ) {
+    let possession = rollData.possession;
+    possession.isSuccess = isSuccess;
+    this.updateEtatPossession( possession);
+    RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-possession.html');
   }
 
   /* -------------------------------------------- */
@@ -52,19 +114,24 @@ export class RdDPossession {
     
     const defender = target.actor;
     let possession = this.searchPossessionFromEntite( attacker, defender);
-    if ( possession) {
-      // Manage ongoing possession
-    } else {
-      this.createPossession(attacker, defender);
+    if ( !possession) {
+      possession = this.createPossession(attacker, defender);
     }
 
-    console.log("Creation de possession", attacker, defender, competence);
+    this.updateEtatPossession(possession);
     let rollData = {
       competence: competence,
+      possession: possession,
+      possede: defender.name,
+      possesseur: attacker.name,
+      attackerId: attacker.data._id,
+      defenderId: defender.data._id,
+      mode: "possession"
     };
     if ( attacker.isCreature()) {
       RdDItemCompetenceCreature.setRollDataCreature(rollData);
     }
+    console.log("Creation de possession2", attacker, rollData);
 
     const dialog = await RdDRoll.create( attacker, rollData,
       {
@@ -74,20 +141,23 @@ export class RdDPossession {
       name: 'jet-possession',
       label: 'Possession: ',
       callbacks: [
-        { condition: r => (r.rolled.isSuccess), action: r => this._onReussitePossession(r) },
-        { condition: r => (r.rolled.isEchec), action: r => this._onEchecPossession(r) },
+        { condition: r => (r.rolled.isSuccess), action: r => this._onRollPossession(r, true) },
+        { condition: r => (r.rolled.isEchec), action: r => this._onRollPossession(r, false) },
       ]
     });
     dialog.render(true);
   }
 
   /* -------------------------------------------- */
-  static createPossession( attacker, defender ) {
-    let poss = { entiteid: attacker.data._id, 
-                 pjId: defender.data._id,
-                 possessionCount: 0, // Negative : conjuration, Positif : possession
-               }
-    this.possessionList.push( poss);               
+  static async createPossession( attacker, defender ) {
+    let posessionData = {
+      name: "Possession en cours", type: 'possession',
+      img: "systems/foundryvtt-reve-de-dragon/icons/entites/possession2.webp",
+      data: { description: "", possede: false, possessionid: randomID(16), possesseurid: attacker.data._id, possedeid: defender.data._id, date: 0 }
+    }
+    await attacker.createEmbeddedDocuments('Item', [posessionData])
+    let poss = await defender.createEmbeddedDocuments('Item', [posessionData])
+    return duplicate(poss[0]);
   }
 
 }

module/rdd-utility.js

@@ -10,6 +10,7 @@ import { ReglesOptionelles } from "./regles-optionelles.js";
 import { RdDDice } from "./rdd-dice.js";
 import { RdDItem } from "./item.js";
 import { Monnaie } from "./item-monnaie.js";
+import { RdDPossession } from "./rdd-possession.js";
 
 /* -------------------------------------------- */
 // This table starts at 0 -> niveau -10
@@ -209,6 +210,7 @@ export class RdDUtility {
       'systems/foundryvtt-reve-de-dragon/templates/chat-resultat-tache.html',
       'systems/foundryvtt-reve-de-dragon/templates/chat-resultat-sort.html',
       'systems/foundryvtt-reve-de-dragon/templates/chat-resultat-alchimie.html',
+      'systems/foundryvtt-reve-de-dragon/templates/chat-resultat-possession.html',
       'systems/foundryvtt-reve-de-dragon/templates/chat-actor-turn-summary.html',
       'systems/foundryvtt-reve-de-dragon/templates/chat-actor-competence-xp.html',
       'systems/foundryvtt-reve-de-dragon/templates/chat-actor-carac-xp.html',
@@ -382,6 +384,7 @@ export class RdDUtility {
     formData.recettesAlchimiques = this.checkNull(formData.itemsByType['recettealchimique']);
     formData.maladies = this.checkNull(formData.itemsByType['maladie']);
     formData.poisons = this.checkNull(formData.itemsByType['poison']);
+    formData.possessions = this.checkNull(formData.itemsByType['possession']);
     formData.maladiesPoisons = formData.maladies.concat( formData.poisons);
     formData.objets = formData.conteneurs.concat(formData.materiel)
       .concat(formData.armes)
@@ -419,6 +422,7 @@ export class RdDUtility {
     return objetVersConteneur;
   }
 
+  /* -------------------------------------------- */
   static calculEncContenu(conteneur, objets) {
     const itemData = Misc.data(conteneur);
     const contenuDatas = (itemData.data.contenu ?? []).filter(id => id != undefined)
@@ -436,6 +440,7 @@ export class RdDUtility {
     return enc;
   }
 
+  /* -------------------------------------------- */
   // Construit la liste des conteneurs de niveau 1 (c'est à dire non contenu eux-même dans un conteneur)
   static conteneursRacine(conteneurs) {
     return conteneurs.filter((conteneur, index, arr) => !conteneur.estContenu);
@@ -503,6 +508,7 @@ export class RdDUtility {
     return -7;
   }
 
+  /* -------------------------------------------- */
   static calculFatigueHtml(fatigue, endurance) {
     return ReglesOptionelles.isUsing("appliquer-fatigue") ? {
       malus: RdDUtility.calculMalusFatigue(fatigue, endurance),
@@ -518,6 +524,7 @@ export class RdDUtility {
     return this.makeHTMLfatigueMatrixForSegment(fatigue, segments);
   }
 
+  /* -------------------------------------------- */
   static makeHTMLfatigueMatrixForSegment(fatigue, segments) {
     fatigue = Math.max(fatigue, 0);
     fatigue = Math.min(fatigue, segments.fatigueMax);
@@ -663,6 +670,13 @@ export class RdDUtility {
       actor.tmrApp.lancerSortEnReserve(coord, sortId);
     });
 
+    // gestion bouton tchat Acheter
+    html.on("click", '.defense-possession', event => {
+      let actorId =  event.currentTarget.attributes['data-defenderId'].value;
+      let possessionId =  event.currentTarget.attributes['data-possessionId'].value;
+      RdDPossession.onDefensePossession(actorId, possessionId);
+    });
+
     // gestion bouton tchat Acheter
     html.on("click", '.button-acheter', event => DialogItemAchat.onButtonAcheter(event));