foundryvtt-reve-de-dragon/module/rdd-empoignade.js

/* -------------------------------------------- */
import { RdDResolutionTable } from "./rdd-resolution-table.js";
import { RdDRoll } from "./rdd-roll.js";
import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
import { ChatUtility } from "./chat-utility.js";
import { STATUSES } from "./settings/status-effects.js";
import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
import { TYPES } from "./item.js";

/* -------------------------------------------- */

/* -------------------------------------------- */
export class RdDEmpoignade {

  /* -------------------------------------------- */
  static init() {
  }

  /* -------------------------------------------- */
  static registerChatCallbacks(html) {
    html.on("click", '.defense-empoignade-cac', event => {
      const chatMessage = ChatUtility.getChatMessage(event);
      const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
      let defenseMode = event.currentTarget.attributes['data-defense-mode'].value
      RdDEmpoignade.onDefenseEmpoignade(rollData, defenseMode, "Corps à corps", "melee")
    });
    html.on("click", '.defense-empoignade-esquive', event => {
      const chatMessage = ChatUtility.getChatMessage(event);
      const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
      let defenseMode = event.currentTarget.attributes['data-defense-mode'].value
      RdDEmpoignade.onDefenseEmpoignade(rollData, defenseMode, "Esquive", "derobee")
    });
    html.on("click", '.empoignade-poursuivre', event => {
      let attackerId = event.currentTarget.attributes['data-attackerId'].value
      let defenderId = event.currentTarget.attributes['data-defenderId'].value
      RdDEmpoignade.onAttaqueEmpoignadeValidee(game.actors.get(attackerId), game.actors.get(defenderId))
    });
    html.on("click", '.empoignade-entrainer-sol', event => {
      const chatMessage = ChatUtility.getChatMessage(event);
      const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
      RdDEmpoignade.entrainerAuSol(rollData)
      ChatUtility.removeChatMessageId(chatMessage.id)
    });
    html.on("click", '.empoignade-projeter-sol', event => {
      const chatMessage = ChatUtility.getChatMessage(event);
      const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
      RdDEmpoignade.projeterAuSol(rollData)
      ChatUtility.removeChatMessageId(chatMessage.id)
    });
    html.on("change", '.empoignade-perte-endurance', event => {
      const chatMessage = ChatUtility.getChatMessage(event);
      const rollData = RdDEmpoignade.$readRollEmpoignade(chatMessage);
      if (event.currentTarget.value && event.currentTarget.value != "none") {
        RdDEmpoignade.perteEndurance(rollData, event.currentTarget.value)
        ChatUtility.removeChatMessageId(chatMessage.id)
      }
    });
  }

  /* -------------------------------------------- */
  static checkEmpoignadeEnCours(actor) {
    // TODO: autoriser la perception? la comédie/séduction?
    if (RdDEmpoignade.isEmpoignadeEnCours(actor)) {
      ui.notifications.warn("Une empoignade est en cours ! Normalement, vous ne pouvez rien faire d'autre que continuer l'empoignade ou la rompre.")
      return true;
    }
    return false;
  }

  /* -------------------------------------------- */
  static $storeRollEmpoignade(msg, rollData) {
    RdDEmpoignade.$reduceActorToIds(rollData);
    ChatUtility.setMessageData(msg, "empoignade-roll-data", rollData);
  }

  static $reduceActorToIds(rollData) {
    rollData.attacker = { id: rollData.attacker.id };
    rollData.defender = { id: rollData.defender.id };
  }

  /* -------------------------------------------- */
  static $readRollEmpoignade(msg) {
    const rollData = ChatUtility.getMessageData(msg, 'empoignade-roll-data');
    RdDEmpoignade.$replaceIdsWithActors(rollData);
    return rollData
  }

  static $replaceIdsWithActors(rollData) {
    rollData.attacker = game.actors.get(rollData.attacker.id);
    rollData.defender = game.actors.get(rollData.defender.id);
  }

  /* -------------------------------------------- */
  static isEmpoignadeEnCours(actor) {
    return actor.itemTypes[TYPES.empoignade].find(it => it.system.pointsemp > 0)
  }

  /* -------------------------------------------- */
  static getEmpoignadeById(actor, id) {
    let emp = actor.itemTypes[TYPES.empoignade].find(it => it.system.empoignadeid == id)
    return emp && foundry.utils.duplicate(emp) || undefined;
  }

  /* -------------------------------------------- */
  static getEmpoignade(attacker, defender) {
    let emp = attacker.itemTypes[TYPES.empoignade].find(it =>
      (it.system.empoigneurid == attacker.id && it.system.empoigneid == defender.id) ||
      (it.system.empoigneurid == defender.id && it.system.empoigneid == attacker.id)
    )
    if (emp) {
      return foundry.utils.duplicate(emp);
    }
    return undefined;
  }

  /* -------------------------------------------- */
  static getMalusTaille(emp, attacker, defender) {
    // Si pas empoigné, alors 0
    if (emp.system.pointsemp == 0) {
      return 0
    }
    // p135: Malus de -1 par point de taille de différence de taille au delà de 1 (donc -2 pour une différence de 3, ...)
    const diffTaille = attacker.system.carac.taille.value - defender.system.carac.taille.value;
    const diffTailleAbs = Math.abs(diffTaille)
    const signDiff = diffTaille > 0 ? 1 : -1

    if (diffTailleAbs > 2) {
      return signDiff * (diffTailleAbs - 1)
    }
    return 0
  }

  static isActionAutorisee(mode, attacker, defender) {
    const acting = RdDEmpoignade.isActionDefenseur(mode) ? defender : attacker;
    if (acting.getUserLevel(game.user) < CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER) {
      ui.notifications.warn(`Vous n'êtes pas autorisé à choisir l'action de ${acting.name}`)
      return false;
    }
    return true
  }

  static isActionDefenseur(mode) {
    switch (mode) {
      case "liberer":
      case "contrer-empoigner":
        return true;
    }
    return false;
  }

  /* -------------------------------------------- */
  static async onAttaqueEmpoignade(attacker, defender) {
    if (!RdDEmpoignade.isActionAutorisee("empoigner", attacker, defender)) {
      return
    }
    let empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)
    const isNouvelle = empoignade == undefined;
    empoignade = empoignade ?? (await RdDEmpoignade.createEmpoignade(attacker, defender))
    //console.log("W.", empoignade, defender.hasArmeeMeleeEquipee())
    if ((isNouvelle || empoignade.system.pointsemp == 0) && defender.hasArmeeMeleeEquipee()) {
      ChatUtility.createChatWithRollMode(attacker.name, {
        content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-empoignade-valider.html`, { attacker: attacker, defender: defender })
      })
    } else {
      await this.onAttaqueEmpoignadeValidee(attacker, defender)
    }
  }

  /* -------------------------------------------- */
  static async onAttaqueEmpoignadeValidee(attacker, defender) {
    let empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)
    const isNouvelle = empoignade == undefined;
    empoignade = empoignade ?? (await RdDEmpoignade.createEmpoignade(attacker, defender))

    let mode = (empoignade && empoignade.system.empoigneurid == attacker.id) ? "empoigner" : "liberer"

    if (!RdDEmpoignade.isActionAutorisee(mode, attacker, defender)) {
      return
    }

    let rollData = {
      mode, empoignade, attacker, defender,
      isEmpoignade: true,
      competence: attacker.getCompetenceCorpsACorps(),
      selectedCarac: attacker.system.carac.melee,
      malusTaille: RdDEmpoignade.getMalusTaille(empoignade, attacker, defender)
    }
    if (attacker.isCreatureEntite()) {
      RdDItemCompetenceCreature.setRollDataCreature(rollData)
    }
    if (empoignade.system.pointsemp >= 2) {
      if (!empoignade.system.ausol) {
        let msg = await RdDResolutionTable.displayRollData(rollData, attacker, 'chat-empoignade-entrainer.html');
        RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
      }
    } else {
      await RdDEmpoignade.$rollAttaqueEmpoignade(attacker, rollData, isNouvelle);
    }
  }

  /* -------------------------------------------- */
  static async onAttaqueEmpoignadeFromItem(empoignade) {
    let attacker = game.actors.get(empoignade.system.empoigneurid)
    let defender = game.actors.get(empoignade.system.empoigneid)
    await this.onAttaqueEmpoignadeValidee(attacker, defender)
  }

  static async onImmobilisation(attacker, defender, empoignade) {
    const rollData = {
      mode: "immobilise",
      empoignade, attacker, defender,
      isEmpoignade: true,
      competence: attacker.getCompetenceCorpsACorps()
    }
    const msg = await ChatMessage.create({
      whisper: ChatUtility.getWhisperRecipientsAndGMs(attacker.name),
      content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-empoignade-immobilise.html`, rollData)
    })
    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
  }

  /* -------------------------------------------- */
  static async $rollAttaqueEmpoignade(attacker, rollData, isNouvelle = false) {
    const dialog = await RdDRoll.create(attacker, rollData,
      { html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-competence.html' },
      {
        name: 'jet-empoignade',
        label: 'Empoigner',
        callbacks: [{ action: async (r) => await RdDEmpoignade.$onRollEmpoignade(r, isNouvelle) },]
      });
    dialog.render(true);
  }

  /* -------------------------------------------- */
  static async $onRollEmpoignade(rollData, isNouvelle = false) {
    let attacker = game.actors.get(rollData.attacker.id)
    let defender = game.actors.get(rollData.defender.id)


    if (rollData.rolled.isSuccess && isNouvelle) {
      const objectEmpoignade = rollData.empoignade.toObject();
      // Creer l'empoignade sur attaquant/defenseur
      attacker.creerObjetParMJ(objectEmpoignade);
      defender.creerObjetParMJ(objectEmpoignade);
    }

    rollData.empoignade.isSuccess = rollData.rolled.isSuccess;
    if (rollData.rolled.isPart) {
      rollData.particuliere = "finesse";
    }
    let msg = await RdDResolutionTable.displayRollData(rollData, defender, 'chat-empoignade-resultat.html');
    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
  }

  /* -------------------------------------------- */
  static async onDefenseEmpoignade(attackerRoll, mode, competenceName = "Corps à corps", carac = "melee") {
    let attacker = game.actors.get(attackerRoll.attacker.id)
    let defender = game.actors.get(attackerRoll.defender.id)
    if (!RdDEmpoignade.isActionAutorisee(mode, attacker, defender)) {
      return
    }

    let empoignade = this.getEmpoignade(attacker, defender)

    if (!empoignade) {
      ui.notifications.warn("Une erreur s'est produite : Aucune empoignade trouvée !!")
      return
    }

    empoignade = foundry.utils.duplicate(empoignade)
    let defenderRoll = {
      mode, attacker, defender, empoignade, attackerRoll,
      diffLibre: attackerRoll.diffLibre,
      attaqueParticuliere: attackerRoll.particuliere,
      competence: defender.getCompetence(competenceName),
      surprise: defender.getSurprise(true),
      carac: defender.system.carac,
      selectedCarac: defender.system.carac[carac],
      malusTaille: RdDEmpoignade.getMalusTaille(empoignade, defender, attacker),
      show: {}
    };
    await RdDEmpoignade.$rollDefenseEmpoignade(defender, defenderRoll);
  }

  /* -------------------------------------------- */
  static async $rollDefenseEmpoignade(defender, defenderRoll) {
    const dialog = await RdDRoll.create(defender, defenderRoll,
      { html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-defense-empoignade.html' },
      {
        name: 'empoignade',
        label: 'Contrer',
        callbacks: [
          { action: async (r) => await RdDEmpoignade.$onRollContrerLiberer(r) }
        ]
      }
    );
    dialog.render(true);
  }

  /* -------------------------------------------- */
  static async $onRollContrerLiberer(rollData) {
    let empoignade = rollData.empoignade
    
    if (rollData.mode == "contrer-empoigner" && !rollData.rolled.isSuccess) {
      empoignade.system.pointsemp++
      RdDEmpoignade.$updateEtatEmpoignade(empoignade)
    }
    if (rollData.mode == "contrer-liberer" && !rollData.rolled.isSuccess) {
      empoignade.system.pointsemp--
      RdDEmpoignade.$updateEtatEmpoignade(empoignade)
    }
    
    await RdDResolutionTable.displayRollData(rollData, rollData.defender, 'chat-empoignade-resultat.html')
    if (empoignade.system.pointsemp >= 2) {
      let msg = await RdDResolutionTable.displayRollData(rollData, rollData.attacker, 'chat-empoignade-entrainer.html');
      RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
    }
  }

  /* -------------------------------------------- */
  static async $updateEtatEmpoignade(empoignade) {
    console.log("UPDATE Empoignade", empoignade)

    let defender = game.actors.get(empoignade.system.empoigneid)
    let emp = RdDEmpoignade.getEmpoignadeById(defender, empoignade.system.empoignadeid)
    let update = { _id: emp._id, "system.pointsemp": empoignade.system.pointsemp, "system.ausol": empoignade.system.ausol }
    await defender.updateEmbeddedDocuments('Item', [update])

    let attacker = game.actors.get(empoignade.system.empoigneurid)
    emp = RdDEmpoignade.getEmpoignadeById(attacker, empoignade.system.empoignadeid)
    update = { _id: emp._id, "system.pointsemp": empoignade.system.pointsemp, "system.ausol": empoignade.system.ausol }
    await attacker.updateEmbeddedDocuments('Item', [update])
  }

  /* -------------------------------------------- */
  static async $deleteEmpoignade(empoignade) {
    console.log("DELETE Empoignade", empoignade)

    let defender = game.actors.get(empoignade.system.empoigneid)
    let emp = RdDEmpoignade.getEmpoignadeById(defender, empoignade.system.empoignadeid)
    await defender.deleteEmbeddedDocuments('Item', [emp._id])
  }

  /* -------------------------------------------- */
  static async entrainerAuSol(rollData) {
    let attacker = game.actors.get(rollData.attacker.id)
    let defender = game.actors.get(rollData.defender.id)
    if (!RdDEmpoignade.isActionAutorisee("immobilise", attacker, defender)) {
      return
    }
    let empoignade = this.getEmpoignade(attacker, defender)

    empoignade.system.ausol = true
    await this.$updateEtatEmpoignade(empoignade)

    await attacker.setEffect(STATUSES.StatusProne, true);
    await defender.setEffect(STATUSES.StatusProne, true);

    let msg = await RdDResolutionTable.displayRollData(rollData, attacker, 'chat-empoignade-entrainer-sol.html');
    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
  }

  /* -------------------------------------------- */
  static async projeterAuSol(rollData) {
    let attacker = game.actors.get(rollData.attacker.id)
    let defender = game.actors.get(rollData.defender.id)
    if (!RdDEmpoignade.isActionAutorisee("immobilise", attacker, defender)) {
      return
    }
    let empoignade = this.getEmpoignade(attacker, defender)

    await defender.setEffect(STATUSES.StatusProne, true);
    await this.$deleteEmpoignade(empoignade)

    let msg = await RdDResolutionTable.displayRollData(rollData, attacker, 'chat-empoignade-projeter-sol.html');
    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
  }

  /* -------------------------------------------- */
  static async perteEndurance(rollData, perteMode) {
    let attacker = game.actors.get(rollData.attacker.id)
    let defender = game.actors.get(rollData.defender.id)
    if (!RdDEmpoignade.isActionAutorisee("immobilise", attacker, defender)) {
      return
    }
    let empoignade = this.getEmpoignade(attacker, defender)

    //console.log("Perte d'endurance :!!!", perteMode)
    let endValue = defender.system.sante.endurance.value
    if (perteMode == "end0") {
      await defender.santeIncDec("endurance", -endValue);
    }
    if (perteMode == "end1") {
      await defender.santeIncDec("endurance", -(endValue - 1));
    }
    if (perteMode == "endmoitie") {
      await defender.santeIncDec("endurance", -Math.floor(endValue / 2));
    }
    if (perteMode == "endquart") {
      await defender.santeIncDec("endurance", -(3 * Math.floor(endValue / 4)));
    }
    let msg = await RdDResolutionTable.displayRollData(rollData, attacker, 'chat-empoignade-perte-endurance.html');
    RdDEmpoignade.$storeRollEmpoignade(msg, rollData);
  }

  /* -------------------------------------------- */
  static async deleteAllEmpoignades() {
    for (let actor of game.actors) {
      let empIds = actor.itemTypes["empoignade"].map(it => it.id)
      await actor.deleteEmbeddedDocuments('Item', empIds)
    }
  }

  /* -------------------------------------------- */
  static async deleteLinkedEmpoignade(actorId, empoignade) {
    let actorDeleteId = (actorId == empoignade.system.empoigneurid) ? empoignade.system.empoigneid : empoignade.system.empoigneurid
    let actor = game.actors.get(actorDeleteId)
    let emp = this.getEmpoignadeById(actor, empoignade.system.empoignadeid)
    if (emp) {
      await actor.deleteEmbeddedDocuments('Item', [emp._id])
    }
  }

  /* -------------------------------------------- */
  static async createEmpoignade(attacker, defender) {
    return await Item.create({
      name: "Empoignade en cours de " + attacker.name + ' sur ' + defender.name,
      type: 'empoignade',
      img: "systems/foundryvtt-reve-de-dragon/icons/entites/possession2.webp",
      system: { description: "", empoignadeid: foundry.utils.randomID(16), compteempoigne: 0, empoigneurid: attacker.id, empoigneid: defender.id, ptsemp: 0, empoigneurname: attacker.name, empoignename: defender.name }
    },
      {
        temporary: true
      })
  }
}