daggerheart/module/ui/combatTracker.mjs

import { GMUpdateEvent, socketEvent } from "../helpers/socket.mjs";

export default class DhpCombatTracker extends foundry.applications.sidebar.tabs.CombatTracker {
    constructor(data, context) {
      super(data, context);

      Hooks.on(socketEvent.DhpFearUpdate, this.onFearUpdate);
    }

    get template(){
        return 'systems/daggerheart/templates/ui/combatTracker.hbs';
    }

    activateListeners(html) {
        super.activateListeners(html);
        html.on("click", ".token-action-tokens .use-action-token", this.useActionToken.bind(this));
        html.on("click", ".encounter-gm-resources .trade-actions", this.tradeActions.bind(this));
        html.on("click", ".encounter-gm-resources .trade-fear", this.tradeFear.bind(this));
        html.on("click", ".encounter-gm-resources .icon-button.up", this.increaseResource.bind(this));
        html.on("click", ".encounter-gm-resources .icon-button.down", this.decreaseResource.bind(this));
    }

    async useActionToken(event){
        event.stopPropagation();
        const combatant = event.currentTarget.dataset.combatant;
        await game.combat.useActionToken(combatant);
    }

    async tradeActions(event){
      if(event.currentTarget.classList.contains('disabled')) return;

      const currentFear = await game.settings.get(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.Resources.Fear);
      const value = currentFear+1;

      if(value <= 6){
        Hooks.callAll(socketEvent.GMUpdate,GMUpdateEvent.UpdateFear, null, value);
        await game.socket.emit(`system.${SYSTEM.id}`, {
          action: socketEvent.GMUpdate,
          data: { action: GMUpdateEvent.UpdateFear, update: value },
        });
        await game.combat.update({ "system.actions": game.combat.system.actions-2 });
      }
    }

    async tradeFear(){
      if(event.currentTarget.classList.contains('disabled')) return;

      const currentFear = await game.settings.get(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.Resources.Fear);
      const value = currentFear-1;
      if(value >= 0){
        Hooks.callAll(socketEvent.GMUpdate,GMUpdateEvent.UpdateFear, null, value);
        await game.socket.emit(`system.${SYSTEM.id}`, {
          action: socketEvent.GMUpdate,
          data: { action: GMUpdateEvent.UpdateFear, update: value },
        });
        await game.combat.update({ "system.actions": game.combat.system.actions+2 });
      }
    }

    async increaseResource(event) {
      if(event.currentTarget.dataset.type === 'action'){
        await game.combat.update({ "system.actions": game.combat.system.actions+1 });
      }

      const currentFear = await game.settings.get(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.Resources.Fear);
      const value = currentFear+1;
      if(event.currentTarget.dataset.type === 'fear' && value <= 6){
        Hooks.callAll(socketEvent.GMUpdate,GMUpdateEvent.UpdateFear, null, value);
        await game.socket.emit(`system.${SYSTEM.id}`, {
          action: socketEvent.GMUpdate,
          data: { action: GMUpdateEvent.UpdateFear, update: value },
        });
      }

      this.render();
    }

    async decreaseResource(event) {
      if(event.currentTarget.dataset.type === 'action' && game.combat.system.actions-1 >= 0){
        await game.combat.update({ "system.actions": game.combat.system.actions-1 });
      }

      const currentFear = await game.settings.get(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.Resources.Fear);
      const value = currentFear-1;
      if(event.currentTarget.dataset.type === 'fear' && value >= 0){
        Hooks.callAll(socketEvent.GMUpdate,GMUpdateEvent.UpdateFear, null, value);
        await game.socket.emit(`system.${SYSTEM.id}`, {
          action: socketEvent.GMUpdate,
          data: { action: GMUpdateEvent.UpdateFear, update: value },
        });
      }

      this.render();
    }

    async getData(options={}) {
        let context = await super.getData(options);
    
        // Get the combat encounters possible for the viewed Scene
        const combat = this.viewed;
        const hasCombat = combat !== null;
        const combats = this.combats;
        const currentIdx = combats.findIndex(c => c === combat);
        const previousId = currentIdx > 0 ? combats[currentIdx-1].id : null;
        const nextId = currentIdx < combats.length - 1 ? combats[currentIdx+1].id : null;
        const settings = game.settings.get("core", Combat.CONFIG_SETTING);
    
        // Prepare rendering data
        context = foundry.utils.mergeObject(context, {
          combats: combats,
          currentIndex: currentIdx + 1,
          combatCount: combats.length,
          hasCombat: hasCombat,
          combat,
          turns: [],
          previousId,
          nextId,
          started: this.started,
          control: false,
          settings,
          linked: combat?.scene !== null,
          labels: {}
        });
        context.labels.scope = game.i18n.localize(`COMBAT.${context.linked ? "Linked" : "Unlinked"}`);
        if ( !hasCombat ) return context;
    
        // Format information about each combatant in the encounter
        let hasDecimals = false;
        const turns = [];
        for ( let [i, combatant] of combat.turns.entries() ) {
          if ( !combatant.visible ) continue;
    
          // Prepare turn data
          const resource = combatant.permission >= CONST.DOCUMENT_OWNERSHIP_LEVELS.OBSERVER ? combatant.resource : null;
          const turn = {
            id: combatant.id,
            name: combatant.name,
            img: await this._getCombatantThumbnail(combatant),
            active: combatant.id === combat.system.activeCombatant,
            owner: combatant.isOwner,
            defeated: combatant.isDefeated,
            hidden: combatant.hidden,
            initiative: combatant.initiative,
            hasRolled: combatant.initiative !== null,
            hasResource: resource !== null,
            resource: resource,
            canPing: (combatant.sceneId === canvas.scene?.id) && game.user.hasPermission("PING_CANVAS"),
            playerCharacter: game.user?.character?.id === combatant.actor.id, 
            ownedByPlayer: combatant.hasPlayerOwner,
          };
          if ( (turn.initiative !== null) && !Number.isInteger(turn.initiative) ) hasDecimals = true;
          turn.css = [
            turn.active ? "active" : "",
            turn.hidden ? "hidden" : "",
            turn.defeated ? "defeated" : ""
          ].join(" ").trim();
    
          // Actor and Token status effects
          turn.effects = new Set();
          if ( combatant.token ) {
            combatant.token.effects.forEach(e => turn.effects.add(e));
            if ( combatant.token.overlayEffect ) turn.effects.add(combatant.token.overlayEffect);
          }
          if ( combatant.actor ) {
            for ( const effect of combatant.actor.temporaryEffects ) {
              if ( effect.statuses.has(CONFIG.specialStatusEffects.DEFEATED) ) turn.defeated = true;
              else if ( effect.icon ) turn.effects.add(effect.icon);
            }
          }
          turns.push(turn);
        }
    
        // Format initiative numeric precision
        const precision = CONFIG.Combat.initiative.decimals;
        turns.forEach(t => {
          if ( t.initiative !== null ) t.initiative = t.initiative.toFixed(hasDecimals ? precision : 0);
        });

        const fear = await game.settings.get(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.Resources.Fear);
    
        // Merge update data for rendering
        return foundry.utils.mergeObject(context, {
          round: combat.round,
          turn: combat.turn,
          turns: turns,
          control: combat.combatant?.players?.includes(game.user),
          fear: fear,
        });
      }

    onFearUpdate = async () => {
        this.render(true);
    }

    async close(options){
        Hooks.off(socketEvent.DhpFearUpdate, this.onFearUpdate);

        return super.close(options);
    }
}