foundryvtt-reve-de-dragon/module/rdd-possession-v2.mjs

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) {
  }

}