CombatEventHandler.h

Go to the documentation of this file.

#pragma once
 
#include "arcdps_structs_slim.h"
#include "EventSequencer.h"
 
#include <cstdint>
#include <format>
#include <string>
 
namespace ArcdpsExtension {
    class CombatEventHandler {
    public:
        explicit CombatEventHandler()
            : mSequencer([this](cbtevent* ev, ag* src, ag* dst, const char* skillname, uint64_t id, uint64_t revision) -> uintptr_t { EventInternal(ev, src, dst, skillname, id, revision); return 0; }) {
        }
        virtual ~CombatEventHandler() {
            Shutdown();
        }
 
        void Event(cbtevent* pEvent, ag* pSrc, ag* pDst, const char* pSkillname, uint64_t pId, uint64_t pRevision = 1);
 
        bool EventsPending();
 
        void Reset() {
            mSequencer.Reset();
        }
 
        void Shutdown() {
            mSequencer.Shutdown();
        }
 
    protected:
        virtual void EventInternal(cbtevent* pEvent, ag* pSrc, ag* pDst, const char* pSkillname, uint64_t pId, uint64_t pRevision);
 
        virtual void AgentAdded(const std::string& pAccountName, const std::string& pCharacterName, uintptr_t pId, uintptr_t pInstanceId, Prof pProfession, uint32_t pElite, bool pSelf, uint16_t pTeam, uint8_t pSubgroup) {
            Log("AgentAdded");
        }
 
        virtual void AgentRemoved(const std::string& pAccountName, const std::string& pCharacterName, uintptr_t pId, bool pSelf) {
            Log("AgentRemoved");
        }
 
        virtual void TargetChange(uintptr_t pId) {
            Log("TargetChange");
        }
 
        virtual void EnterCombat(uint64_t pTime, uintptr_t pAgentId, uint8_t pSubgroup, const ag& pAgent) {
            Log("EnterCombat");
        }
 
        virtual void ExitCombat(uint64_t pTime, uintptr_t pAgentId, const ag& pAgent) {
            Log("ExitCombat");
        }
 
        virtual void ChangeUp(uint64_t pTime, uintptr_t pAgentId, const ag& pAgent) {
            Log("ChangeUp");
        }
 
        virtual void ChangeDead(uint64_t pTime, uintptr_t pAgentId, const ag& pAgent) {
            Log("ChangeDead");
        }
 
        virtual void ChangeDown(uint64_t pTime, uintptr_t pAgentId, const ag& pAgent) {
            Log("ChangeDown");
        }
 
        virtual void LogStart(uint64_t pTime, uint32_t pServerTime, uint32_t pLocalTime, uintptr_t pSpeciesId) {
            Log("LogStart");
        }
 
        virtual void LogEnd(uint64_t pTime, uint32_t pServerTime, uint32_t pLocalTime, uintptr_t pSpeciesId) {
            Log("LogEnd");
        }
 
        virtual void LogNpcUpdate(uint64_t pTime, uint32_t pServerTime, uint32_t pLocalTime, uintptr_t pSpeciesId) {
            Log("LogNpcUpdate");
        }
 
        virtual void WeaponSwap(uint64_t pTime, uintptr_t pAgentId, WeaponSet pWeaponSet, const ag& pAgent) {
            Log("WeaponSwap");
        }
 
        virtual void Reward(uint64_t pTime, uintptr_t pSelfId, uintptr_t pRewardId, int32_t pRewardType) {
            Log("Reward");
        }
 
        virtual void TeamChange(uint64_t pTime, uintptr_t pAgentId, uintptr_t pNewTeam, const ag& pAgent) {
            Log("TeamChange");
        }
 
        virtual void StackActive(uint64_t pTime, uintptr_t pAgentId, uintptr_t pStackId, const ag& pAgent) {
            Log("StackActive");
        }
 
        virtual void StackReset(uint64_t pTime, uintptr_t pAgentId, uintptr_t pDuration, uint32_t pStackId, const ag& pAgent) {
            Log(std::format("StackReset|agentName {}|duration {}|stackId {}", pAgent.name, pDuration, pStackId));
        }
 
        virtual void StatReset(uint64_t pTime) {
            Log("StatReset");
        }
 
        virtual void Extension(uint64_t pTime, cbtevent* pEvent, ag* pSrc, ag* pDst, const char* pSkillname, uint64_t pId) {
            Log("Extension");
        }
 
        virtual void Delayed(uint64_t pTime, cbtevent* pEvent, ag* pSrc, ag* pDst, const char* pSkillname, uint64_t pId) {
            Log("Delayed");
        }
 
        virtual void InstanceStart(uint64_t pTime, uintptr_t pStartTime) {
            Log("InstanceStart");
        }
 
        virtual void Tickrate(uint64_t pTime, uintptr_t pData) {
            Log("Tickrate");
        }
 
        virtual void Last90BeforeDown(uint64_t pTime, uintptr_t pEnemyAgent, uintptr_t pSinceTime) {
            Log("Last90BeforeDown");
        }
 
        virtual void Activation(uint64_t pTime, cbtevent* pEvent, const ag& pSrc, const ag& pDst, const char* pSkillname, uint64_t pId) {
            Log("Activation");
        }
 
        virtual void BuffRemove(uint64_t pTime, const cbtevent* pEvent, const ag& pSrc, const ag& pDst, const char* pSkillname, uint64_t pId, uint32_t pStackId) {
            Log("BuffRemove");
        }
 
        virtual void BuffDamage(uint64_t pTime, cbtevent* pEvent, const ag& pSrc, const ag& pDst, const char* pSkillname, uint64_t pId) {
            Log("BuffDamage");
        }
 
        virtual void BuffApply(uint64_t pTime, const cbtevent* pEvent, const ag& pSrc, const ag& pDst, const char* pSkillname, uint64_t pId, uint32_t pStackId) {
            Log("BuffApply");
        }
 
        virtual void Strike(uint64_t pTime, cbtevent* pEvent, const ag& pSrc, const ag& pDst, const char* pSkillname, uint64_t pId) {
            Log("Strike");
        }
 
        virtual void BuffInitial(uint64_t pTime, cbtevent* pEvent, const ag& pSrc, const ag& pDst, const char* pSkillname, uint64_t pId, uint32_t pStackId) {
            Log("BuffInitial");
        }
 
        virtual void Log(const std::string& pText) {}
 
        uint64_t mLastEventTime = 0;
 
    private:
        EventSequencer mSequencer;
 
        void BuffEvent(cbtevent* pEvent, ag* pSrc, ag* pDst, const char* pSkillname, uint64_t pId);
    };
} // namespace ArcdpsExtension