fvtt-pegasus-rpg/modules/pegasus-combat.js

import { PegasusUtility } from "./pegasus-utility.js";

/* -------------------------------------------- */
export class PegasusCombatTracker extends CombatTracker {

  /* -------------------------------------------- */
  static get defaultOptions() {
    let path = "systems/fvtt-pegasus-rpg/templates/pegasus-combat-tracker.html";
    return foundry.utils.mergeObject(super.defaultOptions, {
      template: path,
    });
  }

  /* -------------------------------------------- */
  async getData() {
    let combatData = await super.getData()
    for (let t of combatData.turns) {
      let c = game.combat.combatants.get(t.id)
      t.displayTIC = (c.actor.isOwner && c.actor.hasPlayerOwner && !game.user.isGM) || (c.actor.type == "npc" && !c.actor.hasPlayerOwner && game.user.isGM) 
      let TICs = c.getFlag("world", "TICs")
      if (TICs) {
        t.TICs = TICs
      } else {
        t.TICs = []
      }
    }
    //console.log("CBT", combatData)
    return combatData
  }

  /* -------------------------------------------- */
  activateListeners(html) {
    super.activateListeners(html)

    html.find('.combat-tracker-tic').click(ev => {
      let ticNum = $(ev.currentTarget).data("tic-num")
      let combatantId = $(ev.currentTarget).data("combatant-id")
      game.combat.revealTIC(ticNum, combatantId)
    })

    html.find('.reset-npc-initiative').click(ev => {
      game.combat.resetNPCInitiative()
    })
    html.find('.select-combat-actor').click(ev => {
      let combatantId = $(ev.currentTarget).data("combatant-id")
      game.combat.selectActor(combatantId)
    })


  }

}

/* -------------------------------------------- */
export class PegasusCombat extends Combat {

  /* -------------------------------------------- */
  async rollInitiative(ids, formula = undefined, messageOptions = {}) {
    ids = typeof ids === "string" ? [ids] : ids;
    for (let cId = 0; cId < ids.length; cId++) {
      const c = this.combatants.get(ids[cId]);
      let id = c._id || c.id;
      let initBonus = c.actor ? c.actor.getInitiativeScore(this.id, id) : -1;
      await this.updateEmbeddedDocuments("Combatant", [{ _id: id, initiative: initBonus }]);
    }

    return this;
  }

  /* -------------------------------------------- */
  async resetNPCInitiative() {
    for (let c of this.combatants) {
      if (c.actor && c.actor.type == "npc") {
        await this.updateEmbeddedDocuments("Combatant", [{ _id: c.id, initiative: -1 }]);
      }
    }
  }

  /* -------------------------------------------- */
  isCharacter(combatantId) {
    const combatant = game.combat.combatants.get(combatantId)
    if (combatant) {
      return combatant.actor.type == "character"
    }
    return false
  }

  /* -------------------------------------------- */
  selectActor(combatantId) {
    const combatant = game.combat.combatants.get(combatantId)
    if (combatant) {
      let TICs = combatant.getFlag("world", "TICs") || []
      let allRevealed = true
      for(let tic of TICs) {
        if (!tic.revealed ) {
          allRevealed = false
        }
      }
      let msg = `<div>${combatant.actor.name} has been nominated to act, ${combatant.actor.name} choose which TIC you wish to activate!</div`
      if ( allRevealed) {
        msg = `<div>${combatant.actor.name} has used all its TIC's please choose a different character.</div`
      }
      let chatData = {
        user: game.user.id,
        alias: combatant.actor.name,
        rollMode: game.settings.get("core", "rollMode"),
        content: msg
        }
      ChatMessage.create(chatData);
    }
  }

  /* -------------------------------------------- */
  async setTic(combatantId, rollData) {
    if (!combatantId) {
      return
    }
    const combatant = game.combat.combatants.get(combatantId)
    if (combatant) {
      await combatant.setFlag("world", "TICs", rollData.TICs)
    }
  }

  /* -------------------------------------------- */
  async revealTIC(num, combatantId) {
    console.log('revealTIC', num, combatantId)
    if (num == undefined || combatantId == undefined) {
      return
    }
    const combatant = game.combat.combatants.get(combatantId)
    if (combatant) {
      console.log('revealTIC', num, combatantId, combatant)
      let ticData = combatant.getFlag("world", "TICs")
      if (ticData) {
        console.log('revealTIC', num, combatantId, ticData)
        num = Number(num)
        if ( ticData[num].revealed && ticData[num].displayed ) {
          let chatData = {
            user: game.user.id,
            alias: combatant.actor.name,
            rollMode: game.settings.get("core", "rollMode"),
            whisper: [game.user.id].concat(ChatMessage.getWhisperRecipients('GM')),
            content: `<div>${combatant.actor.name} : This Action has already been performed please choose a different TIC</div`
          };
          ChatMessage.create(chatData);
          return
        }
        ticData[num].revealed = true
        ticData[num].displayed = true
        combatant.setFlag("world", "TICs", ticData).then(() => {
          let chatData = {
            user: game.user.id,
            alias: combatant.actor.name,
            rollMode: game.settings.get("core", "rollMode"),
            content: `<div>${combatant.actor.name} is performing ${ticData[num].text}</div`
          };
          ChatMessage.create(chatData);
          // Manage if all TIC has been ACTED
          let allRevealed = true
          for (let c of this.combatants) {
            let TICs = c.getFlag("world", "TICs")
            if (TICs) {
              for (let t of TICs) {
                if (!t.revealed) {
                  allRevealed = false
                }
              }
            }
          }
          // If all TIC has been ACTED, display a message
          if (allRevealed) {
            let chatData = {
              user: game.user.id,
              rollMode: game.settings.get("core", "rollMode"),
              content: `<div>All Characters have acted, All Characters who do not have Stun gain 1 Momentum!</div`
            }
            ChatMessage.create(chatData);
          }
        })
      }
    }
  }

  /* -------------------------------------------- */
  nextRound() {
    for (let c of this.combatants) {
      let TICs = duplicate(c.getFlag("world", "TICs"))
      for (let t of TICs) {
        t.displayed = false
        t.revealed = false
        t.text = ""
      }
      c.setFlag("world", "TICs", TICs)
    }
    super.nextRound()
  }

  /* -------------------------------------------- */
  _onUpdate(changed, options, userId) {
  }

  /* -------------------------------------------- */
  static async checkTurnPosition() {
    while (game.combat.turn > 0) {
      await game.combat.previousTurn()
    }
  }

  /* -------------------------------------------- */
  static async decInitBy10(combatantId, value) {
    const combatant = game.combat.combatants.get(combatantId)
    let initValue = combatant.initiative + value
    await game.combat.setInitiative(combatantId, initValue)
    setTimeout(this.checkTurnPosition, 400) // The setInitiative is no more blocking for unknown reason
  }

}