CombatManager Class Reference

#include "CombatManager.h"

Public Member Functions
	CombatManager (Unit *owner)
	~CombatManager ()
void	Update (uint32 tdiff)
Unit *	GetOwner () const
EvadeState	GetEvadeState () const
void	SetEvadeState (EvadeState state)
bool	IsEvadingHome () const
bool	IsInEvadeMode () const
bool	IsEvadeRegen () const
void	StartEvadeTimer ()
void	ContinueEvadeRegen ()
void	StopEvade ()
bool	HasCombat () const
bool	HasPvECombat () const
bool	HasPvECombatWithPlayers () const
std::unordered_map< ObjectGuid, CombatReference * > const &	GetPvECombatRefs () const
bool	HasPvPCombat () const
std::unordered_map< ObjectGuid, PvPCombatReference * > const &	GetPvPCombatRefs () const
Unit *	GetAnyTarget () const
bool	SetInCombatWith (Unit *who, bool addSecondUnitSuppressed=false)
bool	IsInCombatWith (ObjectGuid const &who) const
bool	IsInCombatWith (Unit const *who) const
void	InheritCombatStatesFrom (Unit const *who)
void	EndCombatBeyondRange (float range, bool includingPvP=false)
void	SuppressPvPCombat ()
void	RestartPvPCombatTimers ()
void	EndAllPvECombat ()
void	RevalidateCombat ()
void	EndAllPvPCombat ()
void	EndAllCombat ()
	CombatManager (CombatManager const &)=delete
CombatManager &	operator= (CombatManager const &)=delete

Static Public Member Functions
static bool	CanBeginCombat (Unit const *a, Unit const *b)

Static Public Attributes
static constexpr uint32	EVADE_TIMER_DURATION = 10 * IN_MILLISECONDS
static constexpr uint32	EVADE_REGEN_DELAY = 5 * IN_MILLISECONDS

Private Member Functions
void	PutReference (ObjectGuid const &guid, CombatReference *ref)
void	PurgeReference (ObjectGuid const &guid, bool pvp)
bool	UpdateOwnerCombatState () const

Static Private Member Functions
static void	NotifyAICombat (Unit *me, Unit *other)

Private Attributes
Unit *const	_owner
EvadeState	_evadeState
uint32	_evadeTimer
std::unordered_map< ObjectGuid, CombatReference * >	_pveRefs
std::unordered_map< ObjectGuid, PvPCombatReference * >	_pvpRefs

Friends
struct	CombatReference
struct	PvPCombatReference

Detailed Description

Constructor & Destructor Documentation

CombatManager() [1/2]

CombatManager::CombatManager ( Unit *  owner )

inline

: _owner(owner), _evadeState(EVADE_STATE_NONE), _evadeTimer(0) { }

~CombatManager()

CombatManager::~CombatManager

(

)

{
    ASSERT(_pveRefs.empty(), "CombatManager::~CombatManager - %s: we still have %zu PvE combat references, one of them is with %s", _owner->GetGUID().ToString().c_str(), _pveRefs.size(), _pveRefs.begin()->first.ToString().c_str());
    ASSERT(_pvpRefs.empty(), "CombatManager::~CombatManager - %s: we still have %zu PvP combat references, one of them is with %s", _owner->GetGUID().ToString().c_str(), _pvpRefs.size(), _pvpRefs.begin()->first.ToString().c_str());
}

References _owner, _pveRefs, _pvpRefs, ASSERT, Object::GetGUID(), and ObjectGuid::ToString().

CombatManager() [2/2]

CombatManager::CombatManager ( CombatManager const &  )

delete

Member Function Documentation

CanBeginCombat()

bool CombatManager::CanBeginCombat ( Unit const *  a, Unit const *  b  )

static

{
    // Checks combat validity before initial reference creation.
    // For the combat to be valid...
    // ...the two units need to be different
    if (a == b)
        return false;
    // ...the two units need to be in the world
    if (!a->IsInWorld() || !b->IsInWorld())
        return false;
    // ...the two units need to both be alive
    if (!a->IsAlive() || !b->IsAlive())
        return false;
    // ...the two units need to be on the same map
    if (a->GetMap() != b->GetMap())
        return false;
    // ...the two units need to be in the same phase
    if (!a->InSamePhase(b))
        return false;
    if (a->HasUnitState(UNIT_STATE_EVADE) || b->HasUnitState(UNIT_STATE_EVADE))
        return false;
    if (a->HasUnitState(UNIT_STATE_IN_FLIGHT) || b->HasUnitState(UNIT_STATE_IN_FLIGHT))
        return false;
    // ... both units must be allowed to enter combat
    if (a->IsCombatDisallowed() || b->IsCombatDisallowed())
        return false;
    // ...not friendly, unless one side is hostile (asymmetric aggressor wins)
    if ((a->IsFriendlyTo(b) || b->IsFriendlyTo(a)) && !a->IsHostileTo(b) && !b->IsHostileTo(a))
        return false;
    Player const* playerA = a->GetCharmerOrOwnerPlayerOrPlayerItself();
    Player const* playerB = b->GetCharmerOrOwnerPlayerOrPlayerItself();
    // ...neither of the two units must be (owned by) a player with .gm on
    if ((playerA && playerA->IsGameMaster()) || (playerB && playerB->IsGameMaster()))
        return false;
    return true;
}

References Unit::GetCharmerOrOwnerPlayerOrPlayerItself(), WorldObject::GetMap(), Unit::HasUnitState(), WorldObject::InSamePhase(), Unit::IsAlive(), Unit::IsCombatDisallowed(), Unit::IsFriendlyTo(), Player::IsGameMaster(), Unit::IsHostileTo(), Object::IsInWorld(), UNIT_STATE_EVADE, and UNIT_STATE_IN_FLIGHT.

Referenced by RevalidateCombat(), and SetInCombatWith().

ContinueEvadeRegen()

void CombatManager::ContinueEvadeRegen ( )

inline

{ _evadeTimer = EVADE_REGEN_DELAY; }

Referenced by UnitAI::EvadeTimerExpired().

EndAllCombat()

void CombatManager::EndAllCombat ( )

inline

{ EndAllPvECombat(); EndAllPvPCombat(); }

Referenced by TestCreature::CleanupCombatState(), and Unit::ClearInCombat().

EndAllPvECombat()

void CombatManager::EndAllPvECombat

(

)

{
    // cannot have threat without combat
    _owner->GetThreatMgr().RemoveMeFromThreatLists();
    _owner->GetThreatMgr().ClearAllThreat();
    while (!_pveRefs.empty())
        _pveRefs.begin()->second->EndCombat();
}

References _owner, _pveRefs, ThreatManager::ClearAllThreat(), Unit::GetThreatMgr(), and ThreatManager::RemoveMeFromThreatLists().

Referenced by Unit::ClearInCombat(), and Unit::CombatStop().

EndAllPvPCombat()

void CombatManager::EndAllPvPCombat

(

)

{
    while (!_pvpRefs.empty())
        _pvpRefs.begin()->second->EndCombat();
}

References _pvpRefs.

EndCombatBeyondRange()

void CombatManager::EndCombatBeyondRange	(	float	range,
		bool	includingPvP = false
	)

{
    auto it = _pveRefs.begin(), end = _pveRefs.end();
    while (it != end)
    {
        CombatReference* const ref = it->second;
        if (!ref->first->IsWithinDistInMap(ref->second, range))
        {
            it = _pveRefs.erase(it), end = _pveRefs.end(); // erase manually here to avoid iterator invalidation
            ref->EndCombat();
        }
        else
            ++it;
    }
 
    if (!includingPvP)
        return;
 
    auto it2 = _pvpRefs.begin(), end2 = _pvpRefs.end();
    while (it2 != end2)
    {
        CombatReference* const ref = it2->second;
        if (!ref->first->IsWithinDistInMap(ref->second, range))
        {
            it2 = _pvpRefs.erase(it2), end2 = _pvpRefs.end(); // erase manually here to avoid iterator invalidation
            ref->EndCombat();
        }
        else
            ++it2;
    }
}

References _pveRefs, _pvpRefs, CombatReference::EndCombat(), CombatReference::first, WorldObject::IsWithinDistInMap(), and CombatReference::second.

Referenced by Player::Update().

GetAnyTarget()

Unit * CombatManager::GetAnyTarget

(

)

const

{
    for (auto const& pair : _pveRefs)
        if (!pair.second->IsSuppressedFor(_owner))
            return pair.second->GetOther(_owner);
    for (auto const& pair : _pvpRefs)
        if (!pair.second->IsSuppressedFor(_owner))
            return pair.second->GetOther(_owner);
    return nullptr;
}

References _owner, _pveRefs, and _pvpRefs.

Referenced by Creature::CallForHelp(), and UpdateOwnerCombatState().

GetEvadeState()

EvadeState CombatManager::GetEvadeState ( ) const

inline

{ return _evadeState; }

GetOwner()

Unit * CombatManager::GetOwner ( ) const

inline

{ return _owner; }

GetPvECombatRefs()

std::unordered_map< ObjectGuid, CombatReference * > const & CombatManager::GetPvECombatRefs ( ) const

inline

{ return _pveRefs; }

Referenced by debug_commandscript::HandleDebugCombatListCommand(), debug_commandscript::HandleDebugHostileRefListCommand(), boss_flame_leviathan::IsInCombatWithPlayer(), Unit::SetImmuneToNPC(), Unit::SetImmuneToPC(), Unit::StopAttackFaction(), BossAI::TeleportCheaters(), npc_pet_hunter_snake_trap::UpdateAI(), and npc_training_dummy::UpdateAI().

GetPvPCombatRefs()

std::unordered_map< ObjectGuid, PvPCombatReference * > const & CombatManager::GetPvPCombatRefs ( ) const

inline

{ return _pvpRefs; }

Referenced by debug_commandscript::HandleDebugCombatListCommand(), debug_commandscript::HandleDebugHostileRefListCommand(), Unit::SetImmuneToPC(), and npc_pet_hunter_snake_trap::UpdateAI().

HasCombat()

bool CombatManager::HasCombat ( ) const

inline

{ return HasPvECombat() || HasPvPCombat(); }

Referenced by debug_commandscript::HandleDebugCombatListCommand(), debug_commandscript::HandleDebugHostileRefListCommand(), and UpdateOwnerCombatState().

HasPvECombat()

bool CombatManager::HasPvECombat

(

)

const

{
    for (auto const& [guid, ref] : _pveRefs)
        if (!ref->IsSuppressedFor(_owner))
            return true;
    return false;
}

References _owner, and _pveRefs.

HasPvECombatWithPlayers()

bool CombatManager::HasPvECombatWithPlayers

(

)

const

{
    for (std::pair<ObjectGuid const, CombatReference*> const& reference : _pveRefs)
        if (!reference.second->IsSuppressedFor(_owner) && reference.second->GetOther(_owner)->IsPlayer())
            return true;
 
    return false;
}

References _owner, and _pveRefs.

HasPvPCombat()

bool CombatManager::HasPvPCombat

(

)

const

{
    for (auto const& pair : _pvpRefs)
        if (!pair.second->IsSuppressedFor(_owner))
            return true;
    return false;
}

References _owner, and _pvpRefs.

InheritCombatStatesFrom()

void CombatManager::InheritCombatStatesFrom

(

Unit const *

who

)

{
    CombatManager const& mgr = who->GetCombatManager();
    for (auto& ref : mgr._pveRefs)
    {
        if (!IsInCombatWith(ref.first))
        {
            Unit* target = ref.second->GetOther(who);
            if ((_owner->IsImmuneToPC() && target->HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED)) ||
                (_owner->IsImmuneToNPC() && !target->HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED)))
                continue;
            SetInCombatWith(target);
        }
    }
    for (auto& ref : mgr._pvpRefs)
    {
        Unit* target = ref.second->GetOther(who);
        if ((_owner->IsImmuneToPC() && target->HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED)) ||
            (_owner->IsImmuneToNPC() && !target->HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED)))
            continue;
        SetInCombatWith(target);
    }
}

References _owner, _pveRefs, _pvpRefs, Unit::GetCombatManager(), Unit::HasUnitFlag(), Unit::IsImmuneToNPC(), Unit::IsImmuneToPC(), IsInCombatWith(), SetInCombatWith(), and UNIT_FLAG_PLAYER_CONTROLLED.

Referenced by Spell::DoSpellHitOnUnit().

IsEvadeRegen()

bool CombatManager::IsEvadeRegen ( ) const

inline

{ return (_evadeTimer > 0 && _evadeTimer <= EVADE_REGEN_DELAY) || _evadeState != EVADE_STATE_NONE; }

References EVADE_STATE_NONE.

Referenced by Creature::IsNotReachableAndNeedRegen().

IsEvadingHome()

bool CombatManager::IsEvadingHome ( ) const

inline

{ return _evadeState == EVADE_STATE_HOME; }

References EVADE_STATE_HOME.

IsInCombatWith() [1/2]

bool CombatManager::IsInCombatWith

(

ObjectGuid const &

who

)

const

{
    return (_pveRefs.find(guid) != _pveRefs.end()) || (_pvpRefs.find(guid) != _pvpRefs.end());
}

References _pveRefs, and _pvpRefs.

Referenced by ThreatManager::AddThreat(), npc_training_dummy::DamageTaken(), InheritCombatStatesFrom(), IsInCombatWith(), Unit::IsInCombatWith(), and SetInCombatWith().

IsInCombatWith() [2/2]

bool CombatManager::IsInCombatWith

(

Unit const *

who

)

const

{
    return IsInCombatWith(who->GetGUID());
}

References Object::GetGUID(), and IsInCombatWith().

IsInEvadeMode()

bool CombatManager::IsInEvadeMode ( ) const

inline

{ return _evadeTimer > 0 || _evadeState != EVADE_STATE_NONE; }

References EVADE_STATE_NONE.

NotifyAICombat()

void CombatManager::NotifyAICombat ( Unit *  me, Unit *  other  )

staticprivate

{
    if (UnitAI* ai = me->GetAI())
        ai->JustEnteredCombat(other);
}

References Unit::GetAI().

Referenced by CombatReference::Refresh(), and SetInCombatWith().

operator=()

CombatManager & CombatManager::operator= ( CombatManager const &  )

delete

PurgeReference()

void CombatManager::PurgeReference ( ObjectGuid const &  guid, bool  pvp  )

private

{
    if (pvp)
        _pvpRefs.erase(guid);
    else
        _pveRefs.erase(guid);
}

References _pveRefs, and _pvpRefs.

Referenced by CombatReference::EndCombat().

PutReference()

void CombatManager::PutReference ( ObjectGuid const &  guid, CombatReference *  ref  )

private

{
    if (ref->_isPvP)
    {
        auto& inMap = _pvpRefs[guid];
        ASSERT(!inMap, "Duplicate combat state at %p being inserted for %s vs %s - memory leak!", (void*)ref, _owner->GetGUID().ToString().c_str(), guid.ToString().c_str());
        inMap = static_cast<PvPCombatReference*>(ref);
    }
    else
    {
        auto& inMap = _pveRefs[guid];
        ASSERT(!inMap, "Duplicate combat state at %p being inserted for %s vs %s - memory leak!", (void*)ref, _owner->GetGUID().ToString().c_str(), guid.ToString().c_str());
        inMap = ref;
    }
}

References CombatReference::_isPvP, _owner, _pveRefs, _pvpRefs, ASSERT, Object::GetGUID(), and ObjectGuid::ToString().

Referenced by SetInCombatWith().

RestartPvPCombatTimers()

void CombatManager::RestartPvPCombatTimers

(

)

{
    for (auto const& pair : _pvpRefs)
        pair.second->RefreshTimer();
}

References _pvpRefs.

Referenced by Unit::Kill(), and Unit::setDeathState().

RevalidateCombat()

void CombatManager::RevalidateCombat

(

)

{
    // EndCombat's combat-exit handling (AI, scripts, aura removal) can end or create more of our refs, so no
    // iterator may be held across it: collect the invalid guids first, then look each one up again
    auto endInvalidCombat = [this](auto& refs)
    {
        std::vector<ObjectGuid> invalid;
        for (auto const& [guid, ref] : refs)
            if (!CanBeginCombat(_owner, ref->GetOther(_owner)))
                invalid.push_back(guid);
 
        for (ObjectGuid const& guid : invalid)
            if (auto* ref = Acore::Containers::MapGetValuePtr(refs, guid))
                if (!CanBeginCombat(_owner, ref->GetOther(_owner)))
                    ref->EndCombat();
    };
 
    endInvalidCombat(_pveRefs);
    endInvalidCombat(_pvpRefs);
}

References _owner, _pveRefs, _pvpRefs, CanBeginCombat(), and Acore::Containers::MapGetValuePtr().

Referenced by Unit::RemoveCharmedBy().

SetEvadeState()

void CombatManager::SetEvadeState

(

EvadeState

state

)

{
    if (_evadeState == state)
        return;
 
    if (state == EVADE_STATE_NONE)
        _evadeTimer = 0;
 
    _evadeState = state;
 
    // Propagate evade state to controlled units (pets, guardians, etc.)
    if (!_owner->HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED))
    {
        for (Unit* controlled : _owner->m_Controlled)
            controlled->GetCombatManager().SetEvadeState(state);
    }
}

References _evadeState, _evadeTimer, _owner, EVADE_STATE_NONE, Unit::HasUnitFlag(), Unit::m_Controlled, and UNIT_FLAG_PLAYER_CONTROLLED.

Referenced by HomeMovementGenerator< Creature >::DoFinalize(), HomeMovementGenerator< Creature >::DoInitialize(), and StopEvade().

SetInCombatWith()

bool CombatManager::SetInCombatWith	(	Unit *	who,
		bool	addSecondUnitSuppressed = false
	)

{
    // Are we already in combat? If yes, refresh pvp combat
    if (PvPCombatReference* existingPvpRef = Acore::Containers::MapGetValuePtr(_pvpRefs, who->GetGUID()))
    {
        // a ref kept alive past a death runs out on its own - don't extend it or pull the corpse back into combat
        if (!_owner->IsAlive() || !who->IsAlive())
            return true;
        existingPvpRef->RefreshTimer();
        existingPvpRef->Refresh();
        return true;
    }
    if (CombatReference* existingPveRef = Acore::Containers::MapGetValuePtr(_pveRefs, who->GetGUID()))
    {
        existingPveRef->Refresh();
        return true;
    }
 
    // Otherwise, check validity...
    if (!CombatManager::CanBeginCombat(_owner, who))
        return false;
 
    // ...then create new reference
    CombatReference* ref;
    if (_owner->IsControlledByPlayer() && who->IsControlledByPlayer())
        ref = new PvPCombatReference(_owner, who);
    else
        ref = new CombatReference(_owner, who);
 
    if (addSecondUnitSuppressed)
        ref->Suppress(who);
 
    // ...and insert it into both managers
    PutReference(who->GetGUID(), ref);
    who->GetCombatManager().PutReference(_owner->GetGUID(), ref);
 
    // now, sequencing is important - first we update the combat state, which will set both units in combat and do non-AI combat start stuff
    bool const needSelfAI  = UpdateOwnerCombatState();
    bool const needOtherAI = who->GetCombatManager().UpdateOwnerCombatState();
 
    // then, we finally notify the AI (if necessary) and let it safely do whatever it feels like
    if (needSelfAI)
        NotifyAICombat(_owner, who);
    if (needOtherAI)
        NotifyAICombat(who, _owner);
 
    return IsInCombatWith(who);
}

References _owner, _pveRefs, _pvpRefs, CanBeginCombat(), CombatReference, Unit::GetCombatManager(), Object::GetGUID(), Unit::IsAlive(), Unit::IsControlledByPlayer(), IsInCombatWith(), Acore::Containers::MapGetValuePtr(), NotifyAICombat(), PutReference(), PvPCombatReference, CombatReference::Suppress(), and UpdateOwnerCombatState().

Referenced by ThreatManager::AddThreat(), InheritCombatStatesFrom(), and Unit::SetInCombatWith().

StartEvadeTimer()

void CombatManager::StartEvadeTimer ( )

inline

{ _evadeTimer = EVADE_TIMER_DURATION; }

Referenced by Creature::SetCannotReachTarget().

StopEvade()

void CombatManager::StopEvade

(

)

{
    _evadeTimer = 0;
    SetEvadeState(EVADE_STATE_NONE);
}

References _evadeTimer, EVADE_STATE_NONE, and SetEvadeState().

Referenced by Creature::SetCannotReachTarget().

SuppressPvPCombat()

void CombatManager::SuppressPvPCombat

(

)

{
    for (auto const& pair : _pvpRefs)
        pair.second->Suppress(_owner);
    if (UpdateOwnerCombatState())
        if (UnitAI* ownerAI = _owner->GetAI())
            ownerAI->JustExitedCombat();
}

References _owner, _pvpRefs, Unit::GetAI(), and UpdateOwnerCombatState().

Referenced by Unit::ClearInCombat(), and Unit::CombatStop().

Update()

void CombatManager::Update

(

uint32

tdiff

)

{
    // Update evade timer
    if (_evadeTimer)
    {
        if (_evadeTimer <= tdiff)
        {
            _evadeTimer = 0;
            // Timer expired - trigger evade check via AI
            if (UnitAI* ai = _owner->GetAI())
                ai->EvadeTimerExpired();
        }
        else
            _evadeTimer -= tdiff;
    }
 
    auto it = _pvpRefs.begin(), end = _pvpRefs.end();
    while (it != end)
    {
        PvPCombatReference* const ref = it->second;
        if (ref->first == _owner && !ref->Update(tdiff)) // only update if we're the first unit involved (otherwise double decrement)
        {
            it = _pvpRefs.erase(it), end = _pvpRefs.end(); // remove it from our refs first to prevent invalidation
            ref->EndCombat(); // this will remove it from the other side
        }
        else
            ++it;
    }
}

References _evadeTimer, _owner, _pvpRefs, CombatReference::EndCombat(), CombatReference::first, Unit::GetAI(), CombatReference::second, and PvPCombatReference::Update().

Referenced by Unit::Update().

UpdateOwnerCombatState()

bool CombatManager::UpdateOwnerCombatState ( ) const

private

{
    bool const combatState = HasCombat();
    if (combatState == _owner->IsInCombat())
        return false;
 
    if (combatState)
    {
        _owner->SetUnitFlag(UNIT_FLAG_IN_COMBAT);
        _owner->AtEnterCombat();
        if (!_owner->IsCreature())
            _owner->AtEngage(GetAnyTarget());
 
        if (Player* player = _owner->ToPlayer())
            sScriptMgr->OnPlayerEnterCombat(player, GetAnyTarget());
    }
    else
    {
        _owner->RemoveUnitFlag(UNIT_FLAG_IN_COMBAT);
        _owner->AtExitCombat();
        if (!_owner->IsCreature())
            _owner->AtDisengage();
 
        if (Player* player = _owner->ToPlayer())
            sScriptMgr->OnPlayerLeaveCombat(player);
    }
 
    if (Unit* master = _owner->GetCharmerOrOwner())
        master->UpdatePetCombatState();
 
    return true;
}

References _owner, Unit::AtDisengage(), Unit::AtEngage(), Unit::AtEnterCombat(), Unit::AtExitCombat(), GetAnyTarget(), Unit::GetCharmerOrOwner(), HasCombat(), Object::IsCreature(), Unit::IsInCombat(), Unit::RemoveUnitFlag(), Unit::SetUnitFlag(), sScriptMgr, Object::ToPlayer(), and UNIT_FLAG_IN_COMBAT.

Referenced by CombatReference::EndCombat(), CombatReference::Refresh(), SetInCombatWith(), CombatReference::SuppressFor(), and SuppressPvPCombat().

Friends And Related Symbol Documentation

CombatReference

friend struct CombatReference

friend

Referenced by SetInCombatWith().

PvPCombatReference

friend struct PvPCombatReference

friend

Referenced by SetInCombatWith().

Member Data Documentation

_evadeState

EvadeState CombatManager::_evadeState

private

Referenced by SetEvadeState().

_evadeTimer

uint32 CombatManager::_evadeTimer

private

Referenced by SetEvadeState(), StopEvade(), and Update().

_owner

Unit* const CombatManager::_owner

private

Referenced by EndAllPvECombat(), GetAnyTarget(), HasPvECombat(), HasPvECombatWithPlayers(), HasPvPCombat(), InheritCombatStatesFrom(), PutReference(), RevalidateCombat(), SetEvadeState(), SetInCombatWith(), SuppressPvPCombat(), Update(), UpdateOwnerCombatState(), and ~CombatManager().

_pveRefs

std::unordered_map<ObjectGuid, CombatReference*> CombatManager::_pveRefs

private

Referenced by EndAllPvECombat(), EndCombatBeyondRange(), GetAnyTarget(), HasPvECombat(), HasPvECombatWithPlayers(), InheritCombatStatesFrom(), IsInCombatWith(), PurgeReference(), PutReference(), RevalidateCombat(), SetInCombatWith(), and ~CombatManager().

_pvpRefs

std::unordered_map<ObjectGuid, PvPCombatReference*> CombatManager::_pvpRefs

private

Referenced by EndAllPvPCombat(), EndCombatBeyondRange(), GetAnyTarget(), HasPvPCombat(), InheritCombatStatesFrom(), IsInCombatWith(), PurgeReference(), PutReference(), RestartPvPCombatTimers(), RevalidateCombat(), SetInCombatWith(), SuppressPvPCombat(), Update(), and ~CombatManager().

EVADE_REGEN_DELAY

constexpr uint32 CombatManager::EVADE_REGEN_DELAY = 5 * IN_MILLISECONDS

staticconstexpr

EVADE_TIMER_DURATION

constexpr uint32 CombatManager::EVADE_TIMER_DURATION = 10 * IN_MILLISECONDS

staticconstexpr

---

The documentation for this class was generated from the following files:

• azerothcore-wotlk/src/server/game/Combat/CombatManager.h
• azerothcore-wotlk/src/server/game/Combat/CombatManager.cpp