Méthode rollPossession pour attaque possession

- Ajout d'une méthode pour ouvrir le dialogue en mode possession - gestion des information de possession - fenêtre défense possession - préparation des messages de tchat
2025-12-01 00:51:44 +01:00
parent fd3f988a4f
commit 706aa657b1
15 changed files with 270 additions and 55 deletions
--- a/module/rdd-possession-v2.mjs
+++ b/module/rdd-possession-v2.mjs
@@ -0,0 +1,132 @@
+import { ITEM_TYPES, RDD_CONFIG } from "./constants.js";
+import { RdDRollResult } from "./rdd-roll-result.js";
+import { RollBasicParts } from "./roll/roll-basic-parts.mjs";
+import { ChatUtility } from "./chat-utility.js";
+import RollDialog from "./roll/roll-dialog.mjs";
+
+export const ACTIONS_POSSESSION = {
+  ATTAQUE: 'attaque',
+  POSSEDER: 'posseder',
+  CONJURER: 'conjurer',
+  DEFENSE: 'defense',
+  DEFENSE_POSSESSION: 'defense-possession',
+  DEFENSE_CONJURATION: 'defense-conjuration'
+}
+
+export class RdDPossessionV2 {
+
+  static init() {
+  }
+
+  static $isInverse(entite, victime) {
+    return !entite.isEntiteNonIncarnee() && victime.isEntiteNonIncarnee()
+  }
+
+  /* -------------------------------------------- */
+  static findPossession(entite, victime) {
+    if (RdDPossessionV2.$isInverse(entite, victime)) {
+      return RdDPossessionV2.findPossession(victime, entite)
+    }
+    return victime.itemTypes[ITEM_TYPES.possession].find(poss => poss.system.entiteid == entite.id)
+  }
+
+  static async createPossession(entite, victime) {
+    if (RdDPossessionV2.$isInverse(entite, victime)) {
+      return await RdDPossessionV2.createPossession(victime, entite)
+    }
+    const existing = RdDPossessionV2.findPossession(entite, victime)
+    if (!existing) {
+      await victime.createEmbeddedDocuments('Item', [{
+        name: `Possession de ${entite.name}`,
+        type: ITEM_TYPES.possession,
+        img: RDD_CONFIG.icons.possession,
+        system: { entiteid: entite.id, victimeid: victime.id, compteur: 0 }
+      }])
+    }
+  }
+
+  static getPossessionDetails(rollData, action) {
+    const isEntite = rollData.active.actor.isEntiteNonIncarnee() && !rollData.opponent.actor.isEntiteNonIncarnee()
+    const itemPossession = RdDPossessionV2.findPossession(rollData.active.actor, rollData.opponent.actor)
+    const compteur = itemPossession?.system.compteur ?? 0
+    const isAttaque = RdDPossessionV2.isAttaque(action)
+    action = RdDPossessionV2.$getAction(isAttaque, isEntite)
+
+    return {
+      action: action,
+      isEntite: isEntite,
+      isAttaque: isAttaque,
+      isPersonnage: rollData.active.actor.isPersonnage(),
+      isCompteurPossession: Math.sign(compteur) >= 0,
+      compteur: Math.abs(compteur)
+    }
+  }
+
+  static $getAction(isAttaque, isEntite) {
+    if (isAttaque) {
+      return isEntite ? ACTIONS_POSSESSION.POSSEDER : ACTIONS_POSSESSION.CONJURER
+    }
+    return isEntite ? ACTIONS_POSSESSION.DEFENSE_CONJURATION : ACTIONS_POSSESSION.DEFENSE_POSSESSION
+  }
+
+  static actionTitle(action) {
+    switch (action) {
+      case ACTIONS_POSSESSION.POSSEDER: return "tente de posséder"
+      case ACTIONS_POSSESSION.CONJURER: return "tente de conjurer"
+      case ACTIONS_POSSESSION.DEFENSE_POSSESSION: return "résiste à la possession de"
+      case ACTIONS_POSSESSION.DEFENSE_CONJURATION: return "résiste à la conjuration de"
+      case ACTIONS_POSSESSION.DEFENSE: return "résiste à "
+    }
+    return "lutte contre"
+  }
+
+  static isAttaque(action) {
+    return ![ACTIONS_POSSESSION.DEFENSE, ACTIONS_POSSESSION.DEFENSE_POSSESSION, ACTIONS_POSSESSION.DEFENSE_CONJURATION].includes(action)
+  }
+
+  static async addPointPossession(entite, victime, add) {
+    if (RdDPossessionV2.$isInverse(entite, victime)) {
+      return await RdDPossessionV2.addPointPossession(victime, entite, /* negate?*/ add)
+    }
+    const existing = RdDPossessionV2.findPossession(entite, victime)
+    if (!existing) {
+      return
+    }
+    const points = add ? 1 : -1
+    const compteur = (existing.system.compteur ?? 0) + points
+    await victime.updateEmbeddedDocuments('Item', [{ id: existing.id, 'system.compteur': compteur }])
+  }
+
+  static callbacksOnDefensePossession() {
+    return [async roll => {
+
+    }]
+  }
+
+  static async chatMessageDefensePossession(attackerRoll) {
+
+    const defense = RollBasicParts.prepareDefense(attackerRoll)
+    defense.type = {
+      possession: RdDPossessionV2.getPossessionDetails(defense, ACTIONS_POSSESSION.DEFENSE)
+    }
+
+    const chatDemandeDefense = await ChatMessage.create({
+      // message privé: du défenseur à lui même (et aux GMs)
+      speaker: ChatMessage.getSpeaker({ actor: defense.active.actor, token: defense.active.token }),
+      alias: attackerRoll.active.name,
+      whisper: ChatUtility.getOwners(defense.active.actor),
+      content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-demande-defense-possession.hbs', defense)
+    });
+    ChatUtility.setMessageData(chatDemandeDefense, 'demande-defense', true)
+    // // flag pour garder les jets d'attaque/defense
+    ChatUtility.setMessageData(chatDemandeDefense, 'rollData', {
+      ids: defense.ids,
+      attackerRoll: RollDialog.saveParts(attackerRoll),
+      passeArme: defense.passeArme
+    })
+  }
+
+  static async chatMarquerPointPossession(roll) {
+  }
+
+}