ThreatManager Class Reference

#include "ThreatManager.h"

Classes
class	Heap
class	ThreatListIterator

Public Member Functions
	ThreatManager (Unit *owner)
	~ThreatManager ()
void	Initialize ()
void	Update (uint32 tdiff)
Unit *	GetOwner () const
bool	CanHaveThreatList () const
Unit *	GetCurrentVictim ()
Unit *	GetLastVictim () const
Unit *	GetAnyTarget () const
bool	IsThreatListEmpty (bool includeOffline=false) const
bool	IsThreatenedBy (ObjectGuid const &who, bool includeOffline=false) const
bool	IsThreatenedBy (Unit const *who, bool includeOffline=false) const
float	GetThreat (Unit const *who, bool includeOffline=false) const
size_t	GetThreatListSize () const
uint32	GetThreatListPlayerCount (bool includeOffline=false) const
Acore::IteratorPair< ThreatListIterator >	GetUnsortedThreatList () const
Acore::IteratorPair< ThreatListIterator >	GetSortedThreatList () const
std::vector< ThreatReference * >	GetModifiableThreatList ()
bool	IsThreateningAnyone (bool includeOffline=false) const
bool	IsThreateningTo (ObjectGuid const &who, bool includeOffline=false) const
bool	IsThreateningTo (Unit const *who, bool includeOffline=false) const
auto const &	GetThreatenedByMeList () const
void	EvaluateSuppressed (bool canExpire=false)
void	AddThreat (Unit *target, float amount, SpellInfo const *spell=nullptr, bool ignoreModifiers=false, bool ignoreRedirects=false)
	== AFFECT MY THREAT LIST ==
void	ScaleThreat (Unit *target, float factor)
void	ModifyThreatByPercent (Unit *target, int32 percent)
void	ResetThreat (Unit *target)
void	MatchUnitThreatToHighestThreat (Unit *target)
void	TauntUpdate ()
void	ResetAllThreat ()
void	ClearThreat (Unit *target)
void	ClearThreat (ThreatReference *ref)
void	ClearAllThreat ()
void	FixateTarget (Unit *target)
void	ClearFixate ()
Unit *	GetFixateTarget () const
void	ForwardThreatForAssistingMe (Unit *assistant, float baseAmount, SpellInfo const *spell=nullptr, bool ignoreModifiers=false)
	== AFFECT OTHERS' THREAT LISTS ==
void	ResetAllMyThreatOnOthers ()
void	RemoveMeFromThreatLists ()
void	UpdateMyTempModifiers ()
void	UpdateMySpellSchoolModifiers ()
void	SetTauntStateForTesting (Unit *target, uint32 state)
void	UpdateVictimForTesting ()
void	RegisterRedirectThreat (uint32 spellId, ObjectGuid const &victim, uint32 pct)
	== REDIRECT SYSTEM ==
void	UnregisterRedirectThreat (uint32 spellId)
void	UnregisterRedirectThreat (uint32 spellId, ObjectGuid const &victim)
bool	HasRedirects () const
void	ResetAllRedirects ()
	ThreatManager (ThreatManager const &)=delete
ThreatManager &	operator= (ThreatManager const &)=delete

Static Public Member Functions
static bool	CanHaveThreatList (Unit const *who)

Static Public Attributes
static const uint32	THREAT_UPDATE_INTERVAL = 1000u

Private Member Functions
void	SendClearAllThreatToClients () const
void	SendRemoveToClients (Unit const *victim) const
void	SendThreatListToClients (bool newHighest) const
void	PutThreatListRef (ObjectGuid const &guid, ThreatReference *ref)
	== MY THREAT LIST ==
void	PurgeThreatListRef (ObjectGuid const &guid)
void	ProcessAIUpdates ()
void	RegisterForAIUpdate (ObjectGuid const &guid)
void	UpdateVictim ()
ThreatReference const *	ReselectVictim ()
void	PutThreatenedByMeRef (ObjectGuid const &guid, ThreatReference *ref)
	== OTHERS' THREAT LISTS ==
void	PurgeThreatenedByMeRef (ObjectGuid const &guid)
void	UpdateRedirectInfo ()

Static Private Member Functions
static bool	CompareReferencesLT (ThreatReference const *a, ThreatReference const *b, float aWeight)
static float	CalculateModifiedThreat (float threat, Unit const *victim, SpellInfo const *spell)

Private Attributes
Unit *const	_owner
bool	_ownerCanHaveThreatList
bool	_needClientUpdate
uint32	_updateTimer
std::unique_ptr< Heap >	_sortedThreatList
std::unordered_map< ObjectGuid, ThreatReference * >	_myThreatListEntries
std::vector< ObjectGuid >	_needsAIUpdate
ThreatReference const *	_currentVictimRef
ThreatReference const *	_fixateRef
std::unordered_map< ObjectGuid, ThreatReference * >	_threatenedByMe
std::array< float, MAX_SPELL_SCHOOL >	_singleSchoolModifiers
std::unordered_map< std::underlying_type< SpellSchoolMask >::type, float >	_multiSchoolModifiers
std::vector< std::pair< ObjectGuid, uint32 > >	_redirectInfo
std::unordered_map< uint32, std::unordered_map< ObjectGuid, uint32 > >	_redirectRegistry

Static Private Attributes
static const CompareThreatLessThan	CompareThreat

Friends
class	ThreatReference
class	ThreatReferenceImpl
struct	CompareThreatLessThan
class	debug_commandscript

Detailed Description

Constructor & Destructor Documentation

ThreatManager() [1/2]

ThreatManager::ThreatManager

(

Unit *

owner

)

                                        : _owner(owner), _ownerCanHaveThreatList(false), _needClientUpdate(false), _updateTimer(THREAT_UPDATE_INTERVAL),
    _sortedThreatList(std::make_unique<Heap>()), _currentVictimRef(nullptr), _fixateRef(nullptr)
{
    for (int8 i = 0; i < MAX_SPELL_SCHOOL; ++i)
        _singleSchoolModifiers[i] = 1.0f;
}

References _singleSchoolModifiers, and MAX_SPELL_SCHOOL.

~ThreatManager()

ThreatManager::~ThreatManager

(

)

{
    ASSERT(_myThreatListEntries.empty(), "ThreatManager::~ThreatManager - %s: we still have %zu things threatening us, one of them is %s.", _owner->GetGUID().ToString().c_str(), _myThreatListEntries.size(), _myThreatListEntries.begin()->first.ToString().c_str());
    ASSERT(_sortedThreatList->empty(), "ThreatManager::~ThreatManager - %s: we still have %zu things threatening us, one of them is %s.", _owner->GetGUID().ToString().c_str(), _sortedThreatList->size(), (*_sortedThreatList->begin())->GetVictim()->GetGUID().ToString().c_str());
    ASSERT(_threatenedByMe.empty(), "ThreatManager::~ThreatManager - %s: we are still threatening %zu things, one of them is %s.", _owner->GetGUID().ToString().c_str(), _threatenedByMe.size(), _threatenedByMe.begin()->first.ToString().c_str());
}

References _myThreatListEntries, _owner, _sortedThreatList, _threatenedByMe, ASSERT, Object::GetGUID(), and ObjectGuid::ToString().

ThreatManager() [2/2]

ThreatManager::ThreatManager ( ThreatManager const &  )

delete

Member Function Documentation

AddThreat()

void ThreatManager::AddThreat	(	Unit *	target,
		float	amount,
		SpellInfo const *	spell = nullptr,
		bool	ignoreModifiers = false,
		bool	ignoreRedirects = false
	)

== AFFECT MY THREAT LIST ==

{
    // step 1: we can shortcut if the spell has one of the NO_THREAT attrs set - nothing will happen
    if (spell)
    {
        if (spell->HasAttribute(SPELL_ATTR1_NO_THREAT))
            return;
        if (!_owner->IsEngaged() && spell->HasAttribute(SPELL_ATTR3_SUPPRESS_TARGET_PROCS))
            return;
    }
 
    // while riding a vehicle, all threat goes to the vehicle, not the pilot
    if (Unit* vehicle = target->GetVehicleBase())
    {
        AddThreat(vehicle, amount, spell, ignoreModifiers, ignoreRedirects);
        if (target->HasUnitTypeMask(UNIT_MASK_ACCESSORY)) // accessories are fully treated as components of the parent and cannot have threat
            return;
        amount = 0.0f;
    }
 
    // if we cannot actually have a threat list, we instead just set combat state and avoid creating threat refs altogether
    if (!CanHaveThreatList())
    {
        CombatManager& combatMgr = _owner->GetCombatManager();
        if (!combatMgr.SetInCombatWith(target))
            return;
        // traverse redirects and put them in combat, too
        for (auto const& pair : target->GetThreatMgr()._redirectInfo)
            if (!combatMgr.IsInCombatWith(pair.first))
                if (Unit* redirTarget = ObjectAccessor::GetUnit(*_owner, pair.first))
                    combatMgr.SetInCombatWith(redirTarget);
        return;
    }
 
    // apply threat modifiers to the amount
    if (!ignoreModifiers)
        amount = CalculateModifiedThreat(amount, target, spell);
 
    // the owner's AI sees the threat once, before any of it is redirected; the redirected shares are not reported again
    if (!ignoreRedirects)
    {
        if (Creature* creatureOwner = _owner->ToCreature())
            if (creatureOwner->IsAIEnabled)
                creatureOwner->AI()->CalculateThreat(target, amount, spell);
    }
 
    // if we're increasing threat, send some/all of it to redirection targets instead if applicable
    if (!ignoreRedirects && amount > 0.0f)
    {
        auto const& redirInfo = target->GetThreatMgr()._redirectInfo;
        if (!redirInfo.empty())
        {
            float const origAmount = amount;
            // intentional iteration by index - there's a nested AddThreat call further down that might cause AI calls which might modify redirect info through spells
            for (size_t i = 0; i < redirInfo.size(); ++i)
            {
                auto const pair = redirInfo[i]; // (victim,pct)
                Unit* redirTarget = nullptr;
                auto it = _myThreatListEntries.find(pair.first); // try to look it up in our threat list first (faster)
                if (it != _myThreatListEntries.end())
                    redirTarget = it->second->_victim;
                else
                    redirTarget = ObjectAccessor::GetUnit(*_owner, pair.first);
 
                if (redirTarget)
                {
                    float amountRedirected = CalculatePct(origAmount, pair.second);
                    AddThreat(redirTarget, amountRedirected, spell, true, true);
                    amount -= amountRedirected;
                }
            }
        }
    }
 
    // ensure we're in combat (threat implies combat!)
    if (!_owner->GetCombatManager().SetInCombatWith(target)) // if this returns false, we're not actually in combat, and thus cannot have threat!
        return;                                              // typical causes: bad scripts trying to add threat to GMs, dead targets etc
 
    // ok, now we actually apply threat
    // check if we already have an entry - if we do, just increase threat for that entry and we're done
    auto it = _myThreatListEntries.find(target->GetGUID());
    if (it != _myThreatListEntries.end())
    {
        ThreatReference* const ref = it->second;
 
        // SUPPRESSED threat states don't go back to ONLINE until threat is caused by them (retail behavior)
        if (ref->GetOnlineState() == ThreatReference::ONLINE_STATE_SUPPRESSED)
            if (!ref->ShouldBeSuppressed())
            {
                ref->_online = ThreatReference::ONLINE_STATE_ONLINE;
                ref->HeapNotifyIncreased();
            }
 
        if (ref->IsOnline())
            ref->AddThreat(amount);
 
        return;
    }
 
    // ok, we're now in combat - create the threat list reference and push it to the respective managers
    ThreatReference* ref = new ThreatReferenceImpl(this, target);
    PutThreatListRef(target->GetGUID(), ref);
    target->GetThreatMgr().PutThreatenedByMeRef(_owner->GetGUID(), ref);
 
    ref->UpdateOffline();
    if (ref->IsOnline()) // we only add the threat if the ref is currently available
        ref->AddThreat(amount);
    // Note: AI update registration is handled inside UpdateOffline() when transitioning from OFFLINE
 
    if (!_currentVictimRef)
        UpdateVictim();
    else
        ProcessAIUpdates();
}

References _currentVictimRef, _myThreatListEntries, ThreatReference::_online, _owner, _redirectInfo, ThreatReference::AddThreat(), AddThreat(), CalculateModifiedThreat(), CalculatePct(), CanHaveThreatList(), Unit::GetCombatManager(), Object::GetGUID(), ThreatReference::GetOnlineState(), Unit::GetThreatMgr(), ObjectAccessor::GetUnit(), Unit::GetVehicleBase(), SpellInfo::HasAttribute(), Unit::HasUnitTypeMask(), ThreatReference::HeapNotifyIncreased(), Unit::IsEngaged(), CombatManager::IsInCombatWith(), ThreatReference::IsOnline(), ThreatReference::ONLINE_STATE_ONLINE, ThreatReference::ONLINE_STATE_SUPPRESSED, ProcessAIUpdates(), PutThreatenedByMeRef(), PutThreatListRef(), CombatManager::SetInCombatWith(), ThreatReference::ShouldBeSuppressed(), SPELL_ATTR1_NO_THREAT, SPELL_ATTR3_SUPPRESS_TARGET_PROCS, ThreatReferenceImpl, Object::ToCreature(), UNIT_MASK_ACCESSORY, ThreatReference::UpdateOffline(), and UpdateVictim().

Referenced by AddThreat(), Unit::AddThreat(), ScriptedAI::DoAddThreat(), Spell::EffectThreat(), Unit::EngageWithTarget(), TemporaryThreatModifierEvent::Execute(), ForwardThreatForAssistingMe(), spell_pet_guard_dog::HandleProc(), Spell::HandleThreatSpells(), MatchUnitThreatToHighestThreat(), SmartScript::ProcessAction(), boss_priestess_lackey_commonAI::RecalculateThreat(), boss_faction_championsAI::RecalculateThreat(), boss_drakkisath::UpdateAI(), boss_grilek::boss_grilekAI::UpdateAI(), boss_gothik::boss_gothikAI::UpdateAI(), and boss_netherspite::UpdatePortals().

CalculateModifiedThreat()

float ThreatManager::CalculateModifiedThreat ( float  threat, Unit const *  victim, SpellInfo const *  spell  )

staticprivate

{
    // modifiers by spell
    if (spell)
    {
        if (SpellThreatEntry const* threatEntry = sSpellMgr->GetSpellThreatEntry(spell->Id))
            if (threatEntry->pctMod != 1.0f) // flat/AP modifiers handled in Spell::HandleThreatSpells
                threat *= threatEntry->pctMod;
 
        if (Player* modOwner = victim->GetSpellModOwner())
            modOwner->ApplySpellMod(spell->Id, SPELLMOD_THREAT, threat);
    }
 
    // modifiers by effect school
    ThreatManager const& victimMgr = victim->GetThreatMgr();
    SpellSchoolMask const mask = spell ? spell->GetSchoolMask() : SPELL_SCHOOL_MASK_NORMAL;
    switch (mask)
    {
        case SPELL_SCHOOL_MASK_NORMAL:
            threat *= victimMgr._singleSchoolModifiers[SPELL_SCHOOL_NORMAL];
            break;
        case SPELL_SCHOOL_MASK_HOLY:
            threat *= victimMgr._singleSchoolModifiers[SPELL_SCHOOL_HOLY];
            break;
        case SPELL_SCHOOL_MASK_FIRE:
            threat *= victimMgr._singleSchoolModifiers[SPELL_SCHOOL_FIRE];
            break;
        case SPELL_SCHOOL_MASK_NATURE:
            threat *= victimMgr._singleSchoolModifiers[SPELL_SCHOOL_NATURE];
            break;
        case SPELL_SCHOOL_MASK_FROST:
            threat *= victimMgr._singleSchoolModifiers[SPELL_SCHOOL_FROST];
            break;
        case SPELL_SCHOOL_MASK_SHADOW:
            threat *= victimMgr._singleSchoolModifiers[SPELL_SCHOOL_SHADOW];
            break;
        case SPELL_SCHOOL_MASK_ARCANE:
            threat *= victimMgr._singleSchoolModifiers[SPELL_SCHOOL_ARCANE];
            break;
        default:
        {
            auto it = victimMgr._multiSchoolModifiers.find(mask);
            if (it != victimMgr._multiSchoolModifiers.end())
            {
                threat *= it->second;
                break;
            }
            float mod = victim->GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_THREAT, mask);
            victimMgr._multiSchoolModifiers[mask] = mod;
            threat *= mod;
            break;
        }
    }
    return threat;
}

References _multiSchoolModifiers, _singleSchoolModifiers, SpellInfo::GetSchoolMask(), Unit::GetSpellModOwner(), Unit::GetThreatMgr(), Unit::GetTotalAuraMultiplierByMiscMask(), SpellInfo::Id, SPELL_AURA_MOD_THREAT, SPELL_SCHOOL_ARCANE, SPELL_SCHOOL_FIRE, SPELL_SCHOOL_FROST, SPELL_SCHOOL_HOLY, SPELL_SCHOOL_MASK_ARCANE, SPELL_SCHOOL_MASK_FIRE, SPELL_SCHOOL_MASK_FROST, SPELL_SCHOOL_MASK_HOLY, SPELL_SCHOOL_MASK_NATURE, SPELL_SCHOOL_MASK_NORMAL, SPELL_SCHOOL_MASK_SHADOW, SPELL_SCHOOL_NATURE, SPELL_SCHOOL_NORMAL, SPELL_SCHOOL_SHADOW, SPELLMOD_THREAT, and sSpellMgr.

Referenced by AddThreat().

CanHaveThreatList() [1/2]

bool ThreatManager::CanHaveThreatList ( ) const

inline

{ return _ownerCanHaveThreatList; }

Referenced by AddThreat(), Initialize(), and Update().

CanHaveThreatList() [2/2]

bool ThreatManager::CanHaveThreatList ( Unit const *  who )

static

{
    if (!who)
        return false;
 
    Creature const* cWho = who->ToCreature();
    // only creatures can have threat list
    if (!cWho)
        return false;
 
    // pets, totems and triggers cannot have threat list
    if (cWho->IsPet() || cWho->IsTotem() || cWho->IsTrigger())
        return false;
 
    // summons cannot have a threat list if they were summoned by a player
    if (cWho->HasUnitTypeMask(UNIT_MASK_MINION | UNIT_MASK_GUARDIAN))
        if (TempSummon const* tWho = cWho->ToTempSummon())
            if (tWho->GetSummonerGUID().IsPlayer())
                return false;
 
    // accessories are fully treated as components of the parent and cannot have threat
    if (cWho->HasUnitTypeMask(UNIT_MASK_ACCESSORY))
        return false;
 
    return true;
}

References Unit::HasUnitTypeMask(), Unit::IsPet(), Unit::IsTotem(), Creature::IsTrigger(), Object::ToCreature(), Unit::ToTempSummon(), UNIT_MASK_ACCESSORY, UNIT_MASK_GUARDIAN, and UNIT_MASK_MINION.

Referenced by Unit::CanHaveThreatList(), and debug_commandscript::HandleDebugThreatListCommand().

ClearAllThreat()

void ThreatManager::ClearAllThreat

(

)

{
    if (!_myThreatListEntries.empty())
    {
        SendClearAllThreatToClients();
        do
            _myThreatListEntries.begin()->second->UnregisterAndFree();
        while (!_myThreatListEntries.empty());
    }
}

References _myThreatListEntries, and SendClearAllThreatToClients().

Referenced by TestCreature::CleanupCombatState(), boss_eadric::boss_eadricAI::DamageTaken(), boss_paletress::boss_paletressAI::DamageTaken(), boss_grand_champion::boss_grand_championAI::DamageTaken(), npc_tapoke_slim_jahn::npc_tapoke_slim_jahnAI::DamageTaken(), npc_dark_nucleus::npc_dark_nucleusAI::DamageTaken(), boss_kiljaeden::DamageTaken(), npc_weegli_blastfuse::npc_weegli_blastfuseAI::DoAction(), npc_crok_scourgebane::npc_crok_scourgebaneAI::DoAction(), npc_spark_of_ionar::DoAction(), npc_taskmaster_fizzule::npc_taskmaster_fizzuleAI::DoFriend(), CombatManager::EndAllPvECombat(), npc_tirion_fordring_tft::npc_tirion_fordringAI::EnterEvadeMode(), GuardAI::EnterEvadeMode(), boss_doomrel::EnterEvadeMode(), npc_varian_wrynn::npc_varian_wrynnAI::EnterEvadeMode(), npc_thrall_bfu::npc_thrall_bfuAI::EnterEvadeMode(), npc_pos_freed_slave::npc_pos_freed_slaveAI::EnterEvadeMode(), npc_high_overlord_saurfang_igb::npc_high_overlord_saurfang_igbAI::EnterEvadeMode(), npc_muradin_bronzebeard_igb::npc_muradin_bronzebeard_igbAI::EnterEvadeMode(), gunship_npc_AI::EnterEvadeMode(), npc_gunship_boarding_addAI::EnterEvadeMode(), npc_terenas_menethil::npc_terenas_menethilAI::EnterEvadeMode(), violet_hold_trashAI::EnterEvadeMode(), npc_escortAI::EnterEvadeMode(), FollowerAI::EnterEvadeMode(), npc_crystalline_frayer::EnterSeedPod(), npc_raging_flames::FixateRandomTarget(), spell_q11919_q11940_drake_hunt_aura::HandleEffectRemove(), PetAI::HandleReturnMovement(), boss_urom::boss_uromAI::LeaveCombat(), npc_snobold_vassal::npc_snobold_vassalAI::LoseCarrier(), spell_halion_twilight_phasing_aura::OnApply(), spell_halion_twilight_phasing_aura::OnRemove(), boss_thorim_start_npcs::SetGUID(), spell_putricide_ooze_channel::StartAttack(), npc_unkor_the_ruthless::npc_unkor_the_ruthlessAI::Submit(), npc_highlord_darion_mograine::UpdateAI(), boss_malygos::UpdateAI(), and npc_aeranas::npc_aeranasAI::UpdateAI().

ClearFixate()

void ThreatManager::ClearFixate ( )

inline

{ FixateTarget(nullptr); }

Referenced by npc_pet_hunter_snake_trap::UpdateAI().

ClearThreat() [1/2]

void ThreatManager::ClearThreat

(

ThreatReference *

ref

)

{
    SendRemoveToClients(ref->_victim);
    ref->UnregisterAndFree();
    if (!_currentVictimRef)
        UpdateVictim();
}

References _currentVictimRef, ThreatReference::_victim, SendRemoveToClients(), ThreatReference::UnregisterAndFree(), and UpdateVictim().

ClearThreat() [2/2]

void ThreatManager::ClearThreat

(

Unit *

target

)

{
    auto it = _myThreatListEntries.find(target->GetGUID());
    if (it != _myThreatListEntries.end())
        ClearThreat(it->second);
}

References _myThreatListEntries, ClearThreat(), and Object::GetGUID().

Referenced by ThreatReference::ClearThreat(), ClearThreat(), CombatReference::EndCombat(), and UnitAI::EvadeTimerExpired().

CompareReferencesLT()

bool ThreatManager::CompareReferencesLT ( ThreatReference const *  a, ThreatReference const *  b, float  aWeight  )

staticprivate

{
    if (a->_online != b->_online) // online state precedence (ONLINE > SUPPRESSED > OFFLINE)
        return a->_online < b->_online;
    if (a->_taunted != b->_taunted) // taunt state precedence (TAUNT > NONE > DETAUNT)
        return a->_taunted < b->_taunted;
    return (a->GetThreat() * aWeight < b->GetThreat());
}

References ThreatReference::_online, ThreatReference::_taunted, ThreatReference::GetThreat(), and GetThreat().

Referenced by CompareThreatLessThan::operator()(), and ReselectVictim().

EvaluateSuppressed()

void ThreatManager::EvaluateSuppressed

(

bool

canExpire = false

)

{
    for (auto const& pair : _threatenedByMe)
    {
        bool const shouldBeSuppressed = pair.second->ShouldBeSuppressed();
        if (pair.second->IsOnline() && shouldBeSuppressed)
        {
            pair.second->_online = ThreatReference::ONLINE_STATE_SUPPRESSED;
            pair.second->HeapNotifyDecreased();
        }
        else if (canExpire && pair.second->IsSuppressed() && !shouldBeSuppressed)
        {
            pair.second->_online = ThreatReference::ONLINE_STATE_ONLINE;
            pair.second->HeapNotifyIncreased();
        }
    }
}

References _threatenedByMe, ThreatReference::ONLINE_STATE_ONLINE, and ThreatReference::ONLINE_STATE_SUPPRESSED.

Referenced by Spell::EffectSanctuary(), AuraEffect::HandleAuraModDmgImmunity(), AuraEffect::HandleAuraModSchoolImmunity(), AuraEffect::HandleAuraModStun(), AuraEffect::HandleModConfuse(), Player::SetInWater(), and TauntUpdate().

FixateTarget()

void ThreatManager::FixateTarget

(

Unit *

target

)

{
    if (target)
    {
        auto it = _myThreatListEntries.find(target->GetGUID());
        if (it != _myThreatListEntries.end())
        {
            _fixateRef = it->second;
            return;
        }
    }
    _fixateRef = nullptr;
}

References _fixateRef, _myThreatListEntries, and Object::GetGUID().

Referenced by npc_pet_hunter_snake_trap::UpdateAI().

ForwardThreatForAssistingMe()

void ThreatManager::ForwardThreatForAssistingMe	(	Unit *	assistant,
		float	baseAmount,
		SpellInfo const *	spell = nullptr,
		bool	ignoreModifiers = false
	)

== AFFECT OTHERS' THREAT LISTS ==

{
    if (spell && spell->HasAttribute(SPELL_ATTR1_NO_THREAT)) // shortcut, none of the calls would do anything
        return;
    if (_threatenedByMe.empty())
        return;
 
    std::vector<Creature*> canBeThreatened, cannotBeThreatened;
    for (auto const& pair : _threatenedByMe)
    {
        Creature* owner = pair.second->GetOwner();
        if (!owner->HasUnitState(UNIT_STATE_CONTROLLED))
            canBeThreatened.push_back(owner);
        else
            cannotBeThreatened.push_back(owner);
    }
 
    if (!canBeThreatened.empty()) // targets under CC cannot gain assist threat - split evenly among the rest
    {
        float const perTarget = baseAmount / canBeThreatened.size();
        for (Creature* threatened : canBeThreatened)
            threatened->GetThreatMgr().AddThreat(assistant, perTarget, spell, ignoreModifiers);
    }
 
    for (Creature* threatened : cannotBeThreatened)
        threatened->GetThreatMgr().AddThreat(assistant, 0.0f, spell, true);
}

References _threatenedByMe, AddThreat(), Unit::GetOwner(), Unit::GetThreatMgr(), SpellInfo::HasAttribute(), Unit::HasUnitState(), SPELL_ATTR1_NO_THREAT, and UNIT_STATE_CONTROLLED.

Referenced by Spell::DoAllEffectOnTarget(), Spell::DoSpellHitOnUnit(), Spell::EffectDispel(), Spell::EffectDispelMechanic(), Unit::EnergizeBySpell(), AuraEffect::HandleObsModPowerAuraTick(), AuraEffect::HandlePeriodicEnergizeAuraTick(), AuraEffect::HandlePeriodicHealAurasTick(), AuraEffect::HandlePeriodicHealthLeechAuraTick(), and Spell::HandleThreatSpells().

GetAnyTarget()

Unit * ThreatManager::GetAnyTarget

(

)

const

{
    for (ThreatReference const* ref : *_sortedThreatList)
        if (!ref->IsOffline())
            return ref->GetVictim();
    return nullptr;
}

References _sortedThreatList, and Unit::GetVictim().

Referenced by Creature::CallForHelp(), and npc_icc_orb_controller::SetGUID().

GetCurrentVictim()

Unit * ThreatManager::GetCurrentVictim

(

)

{
    if (!_currentVictimRef || _currentVictimRef->ShouldBeOffline())
        UpdateVictim();
    ASSERT(!_currentVictimRef || _currentVictimRef->IsAvailable());
    return _currentVictimRef ? _currentVictimRef->GetVictim() : nullptr;
}

References _currentVictimRef, ASSERT, ThreatReference::GetVictim(), ThreatReference::IsAvailable(), ThreatReference::ShouldBeOffline(), and UpdateVictim().

Referenced by Creature::CallForHelp(), Spell::EffectTaunt(), npc_onyxian_whelp::IsSummonedBy(), boss_talon_king_ikiss::JustEngagedWith(), boss_teron_gorefiend::JustEngagedWith(), NonTankTargetSelector::operator()(), Creature::SelectVictim(), and instance_naxxramas::SetBossState().

GetFixateTarget()

Unit * ThreatManager::GetFixateTarget

(

)

const

{
    if (_fixateRef)
        return _fixateRef->GetVictim();
    else
        return nullptr;
}

References _fixateRef, and ThreatReference::GetVictim().

Referenced by debug_commandscript::HandleDebugThreatListCommand(), and npc_pet_hunter_snake_trap::UpdateAI().

GetLastVictim()

Unit * ThreatManager::GetLastVictim

(

)

const

{
    if (_currentVictimRef && !_currentVictimRef->ShouldBeOffline())
        return _currentVictimRef->GetVictim();
    return nullptr;
}

References _currentVictimRef, ThreatReference::GetVictim(), and ThreatReference::ShouldBeOffline().

Referenced by PowerUsersSelector::operator()(), and MalleableGooSelector::operator()().

GetModifiableThreatList()

std::vector< ThreatReference * > ThreatManager::GetModifiableThreatList

(

)

{
    std::vector<ThreatReference*> list;
    list.reserve(_myThreatListEntries.size());
    for (auto it = _sortedThreatList->ordered_begin(), end = _sortedThreatList->ordered_end(); it != end; ++it)
        list.push_back(const_cast<ThreatReference*>(*it));
    return list;
}

References _myThreatListEntries, and _sortedThreatList.

Referenced by SmartScript::ProcessAction().

GetOwner()

Unit * ThreatManager::GetOwner ( ) const

inline

{ return _owner; }

GetSortedThreatList()

Acore::IteratorPair< ThreatManager::ThreatListIterator > ThreatManager::GetSortedThreatList

(

)

const

{
    auto itr = _sortedThreatList->ordered_begin();
    auto end = _sortedThreatList->ordered_end();
    std::function<ThreatReference const* ()> generator = [itr, end]() mutable -> ThreatReference const*
    {
        if (itr == end)
            return nullptr;
 
        return *(itr++);
    };
    std::function<ThreatReference const* ()> endGenerator = []() -> ThreatReference const* { return nullptr; };
    return { ThreatListIterator{ std::move(generator) }, ThreatListIterator{ std::move(endGenerator) } };
}

References _sortedThreatList.

Referenced by boss_hazzarah::CanAIAttack(), boss_renataki::boss_renatakiAI::CanAIAttack(), debug_commandscript::HandleDebugThreatListCommand(), and UnitAI::SelectTargetList().

GetThreat()

float ThreatManager::GetThreat	(	Unit const *	who,
		bool	includeOffline = false
	)		const

{
    auto it = _myThreatListEntries.find(who->GetGUID());
    if (it == _myThreatListEntries.end())
        return 0.0f;
    return (includeOffline || it->second->IsAvailable()) ? it->second->GetThreat() : 0.0f;
}

References _myThreatListEntries, and Object::GetGUID().

Referenced by boss_mor_grayhoof::CastRandomSpell(), CompareReferencesLT(), ScriptedAI::DoGetThreat(), MatchUnitThreatToHighestThreat(), Creature::ModifyThreatPercentTemp(), boss_priestess_lackey_commonAI::RecalculateThreat(), boss_faction_championsAI::RecalculateThreat(), boss_drakkisath::UpdateAI(), and boss_thaddius_summon::boss_thaddius_summonAI::UpdateAI().

GetThreatenedByMeList()

auto const & ThreatManager::GetThreatenedByMeList ( ) const

inline

{ return _threatenedByMe; }

Referenced by Vehicle::AddPassenger(), Spell::EffectSanctuary(), debug_commandscript::HandleDebugHostileRefListCommand(), debug_commandscript::HandleDebugThreatListCommand(), AuraEffect::HandleFeignDeath(), npc_pet_mage_mirror_image::InitializeAI(), and Creature::SelectVictim().

GetThreatListPlayerCount()

uint32 ThreatManager::GetThreatListPlayerCount

(

bool

includeOffline = false

)

const

{
    uint32 returnValue = 0;
    for (ThreatReference const* ref : *_sortedThreatList)
    {
        if (!includeOffline && !ref->IsAvailable())
            continue;
        if (ref->GetVictim()->IsPlayer())
            ++returnValue;
    }
    return returnValue;
}

References _sortedThreatList.

GetThreatListSize()

size_t ThreatManager::GetThreatListSize

(

)

const

{
    return _sortedThreatList->size();
}

References _sortedThreatList.

Referenced by boss_hazzarah::CanAIAttack(), boss_renataki::boss_renatakiAI::CanAIAttack(), UnitAI::EvadeTimerExpired(), boss_jindo::JustSummoned(), boss_bug_trio::MovementInform(), boss_jeklik::PathEndReached(), SmartScript::ProcessAction(), UnitAI::SelectTarget(), UnitAI::SelectTargetList(), boss_hakkar::boss_hakkarAI::UpdateAI(), boss_jindo::UpdateAI(), and NPCStaveQuestAI::ValidThreatlist().

GetUnsortedThreatList()

Acore::IteratorPair< ThreatManager::ThreatListIterator > ThreatManager::GetUnsortedThreatList

(

)

const

{
    auto itr = _myThreatListEntries.begin();
    auto end = _myThreatListEntries.end();
    std::function<ThreatReference const* ()> generator = [itr, end]() mutable -> ThreatReference const*
    {
        if (itr == end)
            return nullptr;
 
        return (itr++)->second;
    };
    std::function<ThreatReference const* ()> endGenerator = []() -> ThreatReference const* { return nullptr; };
    return { ThreatListIterator{ std::move(generator) }, ThreatListIterator{ std::move(endGenerator) } };
}

References _myThreatListEntries, and Acore::IteratorPair< iterator >::begin().

Referenced by boss_ouro::CastBoulderIfReady(), boss_lady_deathwhisper::boss_lady_deathwhisperAI::DamageTaken(), boss_ysondre::boss_ysondreAI::DamageTaken(), UnitAI::DoAddAuraToAllHostilePlayers(), UnitAI::DoCastToAllHostilePlayers(), boss_faction_championsAI::EnemiesInRange(), boss_supremus::FindHatefulStrikeTarget(), SmartScript::GetTargets(), spell_kaelthas_nether_beam::HandleScriptEffect(), HasTargetableThreat(), boss_thaddius::boss_thaddiusAI::IsAnyPlayerInMeleeRange(), NPCStaveQuestAI::IsFairFight(), boss_hadronox::IsInCombatWithPlayer(), boss_attumen::IsSummonedBy(), boss_blackheart_the_inciter::JustEngagedWith(), SmartScript::ProcessEvent(), boss_priestess_lackey_commonAI::RecalculateThreat(), boss_faction_championsAI::RecalculateThreat(), boss_faction_championsAI::SelectEnemyCaster(), UnitAI::SelectTargetList(), npc_scholomance_occultist::npc_scholomance_occultistAI::SelectUnitCasting(), npc_frostwing_vrykul::npc_frostwing_vrykulAI::SpellHitTarget(), NPCStaveQuestAI::StorePlayerGUID(), boss_nefarian::UpdateAI(), boss_mandokir::boss_mandokirAI::UpdateAI(), boss_renataki::boss_renatakiAI::UpdateAI(), boss_kelthuzad::boss_kelthuzadAI::UpdateAI(), boss_sapphiron::boss_sapphironAI::UpdateAI(), and boss_the_lurker_below::UpdateAI().

HasRedirects()

bool ThreatManager::HasRedirects ( ) const

inline

{ return !_redirectRegistry.empty(); }

Referenced by spell_hun_misdirection::CheckProc().

Initialize()

void ThreatManager::Initialize

(

)

{
    _ownerCanHaveThreatList = ThreatManager::CanHaveThreatList(_owner);
}

References _owner, _ownerCanHaveThreatList, and CanHaveThreatList().

Referenced by Pet::Create(), Creature::InitEntry(), and TestCreature::InitializeThreatManager().

IsThreatenedBy() [1/2]

bool ThreatManager::IsThreatenedBy	(	ObjectGuid const &	who,
		bool	includeOffline = false
	)		const

{
    auto it = _myThreatListEntries.find(who);
    if (it == _myThreatListEntries.end())
        return false;
    return (includeOffline || it->second->IsAvailable());
}

References _myThreatListEntries.

Referenced by UnitAI::EvadeTimerExpired(), Unit::IsThreatenedBy(), and IsThreatenedBy().

IsThreatenedBy() [2/2]

bool ThreatManager::IsThreatenedBy	(	Unit const *	who,
		bool	includeOffline = false
	)		const

{ return IsThreatenedBy(who->GetGUID(), includeOffline); }

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

IsThreateningAnyone()

bool ThreatManager::IsThreateningAnyone

(

bool

includeOffline = false

)

const

{
    if (includeOffline)
        return !_threatenedByMe.empty();
    for (auto const& pair : _threatenedByMe)
        if (pair.second->IsAvailable())
            return true;
    return false;
}

References _threatenedByMe.

Referenced by WorldSession::HandleMoveWorldportAck().

IsThreateningTo() [1/2]

bool ThreatManager::IsThreateningTo	(	ObjectGuid const &	who,
		bool	includeOffline = false
	)		const

{
    auto it = _threatenedByMe.find(who);
    if (it == _threatenedByMe.end())
        return false;
    return (includeOffline || it->second->IsAvailable());
}

References _threatenedByMe.

Referenced by IsThreateningTo().

IsThreateningTo() [2/2]

bool ThreatManager::IsThreateningTo	(	Unit const *	who,
		bool	includeOffline = false
	)		const

{ return IsThreateningTo(who->GetGUID(), includeOffline); }

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

IsThreatListEmpty()

bool ThreatManager::IsThreatListEmpty

(

bool

includeOffline = false

)

const

{
    if (includeOffline)
        return _sortedThreatList->empty();
    for (ThreatReference const* ref : *_sortedThreatList)
        if (ref->IsAvailable())
            return false;
    return true;
}

References _sortedThreatList.

Referenced by ScriptedAI::DoResetThreatList(), Spell::EffectTaunt(), boss_murmur::EnterEvadeMode(), boss_alar::EnterEvadeMode(), StartMovementEvent::Execute(), debug_commandscript::HandleDebugThreatListCommand(), Unit::IsThreatened(), Update(), and npc_raging_spirit::npc_raging_spiritAI::UpdateAI().

MatchUnitThreatToHighestThreat()

void ThreatManager::MatchUnitThreatToHighestThreat

(

Unit *

target

)

{
    if (_sortedThreatList->empty())
        return;
 
    auto it = _sortedThreatList->ordered_begin(), end = _sortedThreatList->ordered_end();
    ThreatReference const* highest = *it;
    if (!highest->IsAvailable())
        return;
 
    if (highest->IsTaunting() && ((++it) != end)) // might need to skip this - max threat could be the preceding element (there is only one taunt element)
    {
        ThreatReference const* a = *it;
        if (a->IsAvailable() && a->GetThreat() > highest->GetThreat())
            highest = a;
    }
 
    float const threatDiff = highest->GetThreat() - GetThreat(target, true);
    AddThreat(target, threatDiff, nullptr, true, true);
 
    // a suppressed reference ignores AddThreat, but a taunt still matches the highest threat
    if (threatDiff > 0.0f && !target->GetVehicleBase())
        if (ThreatReference* ref = Acore::Containers::MapGetValuePtr(_myThreatListEntries, target->GetGUID()))
            if (ref->IsSuppressed())
                ref->AddThreat(threatDiff);
}

References _myThreatListEntries, _sortedThreatList, AddThreat(), Object::GetGUID(), ThreatReference::GetThreat(), GetThreat(), Unit::GetVehicleBase(), ThreatReference::IsAvailable(), ThreatReference::IsTaunting(), and Acore::Containers::MapGetValuePtr().

Referenced by Spell::EffectTaunt().

ModifyThreatByPercent()

void ThreatManager::ModifyThreatByPercent ( Unit *  target, int32  percent  )

inline

{ if (percent) ScaleThreat(target, 0.01f * float(100 + percent)); }

Referenced by boss_mor_grayhoof::CastRandomSpell(), ScriptedAI::DoModifyThreatByPercent(), Spell::EffectModifyThreatPercent(), TemporaryThreatModifierEvent::Execute(), spell_enveloping_webs::HandleOnHit(), spell_arcane_vacuum::HandleOnHit(), spell_gurtogg_eject::HandleScriptEffect(), Creature::ModifyThreatPercentTemp(), SmartScript::ProcessAction(), boss_ouro::SpellHitTarget(), boss_drakkisath::UpdateAI(), boss_hakkar::boss_hakkarAI::UpdateAI(), boss_mandokir::boss_mandokirAI::UpdateAI(), and boss_thaddius_summon::boss_thaddius_summonAI::UpdateAI().

operator=()

ThreatManager & ThreatManager::operator= ( ThreatManager const &  )

delete

ProcessAIUpdates()

void ThreatManager::ProcessAIUpdates ( )

private

{
    CreatureAI* ai = ASSERT_NOTNULL(_owner->ToCreature())->AI();
    std::vector<ObjectGuid> v(std::move(_needsAIUpdate)); // _needsAIUpdate is now empty in case this triggers a recursive call
    if (!ai)
        return;
    for (ObjectGuid const& guid : v)
        if (ThreatReference const* ref = Acore::Containers::MapGetValuePtr(_myThreatListEntries, guid))
            ai->JustStartedThreateningMe(ref->GetVictim());
}

References _myThreatListEntries, _needsAIUpdate, _owner, ASSERT_NOTNULL, CreatureAI::JustStartedThreateningMe(), Acore::Containers::MapGetValuePtr(), and Object::ToCreature().

Referenced by AddThreat(), and UpdateVictim().

PurgeThreatenedByMeRef()

void ThreatManager::PurgeThreatenedByMeRef ( ObjectGuid const &  guid )

private

{
    auto it = _threatenedByMe.find(guid);
    if (it != _threatenedByMe.end())
        _threatenedByMe.erase(it);
}

References _threatenedByMe.

Referenced by ThreatReference::UnregisterAndFree().

PurgeThreatListRef()

void ThreatManager::PurgeThreatListRef ( ObjectGuid const &  guid )

private

{
    auto it = _myThreatListEntries.find(guid);
    if (it == _myThreatListEntries.end())
        return;
    ThreatReference* ref = it->second;
    _myThreatListEntries.erase(it);
    _sortedThreatList->erase(static_cast<ThreatReferenceImpl*>(ref)->_handle);
 
    if (_fixateRef == ref)
        _fixateRef = nullptr;
    if (_currentVictimRef == ref)
        _currentVictimRef = nullptr;
}

References _currentVictimRef, _fixateRef, _myThreatListEntries, and _sortedThreatList.

Referenced by ThreatReference::UnregisterAndFree().

PutThreatenedByMeRef()

void ThreatManager::PutThreatenedByMeRef ( ObjectGuid const &  guid, ThreatReference *  ref  )

private

== OTHERS' THREAT LISTS ==

{
    auto& inMap = _threatenedByMe[guid];
    ASSERT(!inMap, "Duplicate threatened-by-me reference at %p being inserted on %s for %s - memory leak!", (void*)ref, _owner->GetGUID().ToString().c_str(), guid.ToString().c_str());
    inMap = ref;
}

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

Referenced by AddThreat().

PutThreatListRef()

void ThreatManager::PutThreatListRef ( ObjectGuid const &  guid, ThreatReference *  ref  )

private

== MY THREAT LIST ==

{
    _needClientUpdate = true;
    auto& inMap = _myThreatListEntries[guid];
    ASSERT(!inMap, "Duplicate threat reference at %p being inserted on %s for %s - memory leak!", (void*)ref, _owner->GetGUID().ToString().c_str(), guid.ToString().c_str());
    inMap = ref;
    static_cast<ThreatReferenceImpl*>(ref)->_handle = _sortedThreatList->push(ref);
}

References _myThreatListEntries, _needClientUpdate, _owner, _sortedThreatList, ASSERT, Object::GetGUID(), and ObjectGuid::ToString().

Referenced by AddThreat().

RegisterForAIUpdate()

void ThreatManager::RegisterForAIUpdate ( ObjectGuid const &  guid )

inlineprivate

{ _needsAIUpdate.push_back(guid); }

Referenced by ThreatReference::UpdateOffline().

RegisterRedirectThreat()

void ThreatManager::RegisterRedirectThreat	(	uint32	spellId,
		ObjectGuid const &	victim,
		uint32	pct
	)

== REDIRECT SYSTEM ==

{
    _redirectRegistry[spellId][victim] = pct;
    UpdateRedirectInfo();
}

References _redirectRegistry, and UpdateRedirectInfo().

Referenced by Spell::EffectRedirectThreat().

RemoveMeFromThreatLists()

void ThreatManager::RemoveMeFromThreatLists

(

)

{
    while (!_threatenedByMe.empty())
    {
        auto& ref = _threatenedByMe.begin()->second;
        ref->_mgr.ClearThreat(_owner);
    }
}

References _owner, and _threatenedByMe.

Referenced by PetAI::_stopAttack(), CombatManager::EndAllPvECombat(), misc_commandscript::HandleCombatStopCommand(), WorldSession::HandleMoveWorldportAck(), WorldSession::LogoutPlayer(), and Map::RemovePlayerFromMap().

ReselectVictim()

ThreatReference const * ThreatManager::ReselectVictim ( )

private

{
    if (_sortedThreatList->empty())
        return nullptr;
 
    for (auto const& pair : _myThreatListEntries)
        pair.second->UpdateOffline(); // AI notifies are processed in ::UpdateVictim caller
 
    // fixated target is always preferred
    if (_fixateRef && _fixateRef->IsAvailable())
        return _fixateRef;
 
    ThreatReference const* oldVictimRef = _currentVictimRef;
    if (oldVictimRef && oldVictimRef->IsOffline())
        oldVictimRef = nullptr;
    // in 99% of cases - we won't need to actually look at anything beyond the first element
    ThreatReference const* highest = _sortedThreatList->top();
 
    // if the highest reference is offline, the entire list is offline, and we indicate this
    if (!highest->IsAvailable())
        return nullptr;
    // if we have no old victim, or old victim is still highest, then highest is our target and we're done
    if (!oldVictimRef || highest == oldVictimRef)
        return highest;
    // if highest threat doesn't break 110% of old victim, nothing below it is going to do so either; new victim = old victim and done
    if (!ThreatManager::CompareReferencesLT(oldVictimRef, highest, 1.1f))
        return oldVictimRef;
    // if highest threat breaks 130%, it's our new target regardless of range (and we're done)
    if (ThreatManager::CompareReferencesLT(oldVictimRef, highest, 1.3f))
        return highest;
    // if it doesn't break 130%, we need to check if it's melee - if yes, it breaks 110% (we checked earlier) and is our new target
    if (_owner->IsWithinMeleeRange(highest->_victim))
        return highest;
    // If we get here, highest threat is ranged, but below 130% of current - there might be a melee that breaks 110% below us somewhere
    auto it = _sortedThreatList->ordered_begin(), end = _sortedThreatList->ordered_end();
    while (it != end)
    {
        ThreatReference const* next = *it;
        // if we've found current victim, we're done (nothing above is higher, and nothing below can be higher)
        if (next == oldVictimRef)
            return next;
        // if next isn't above 110% threat, then nothing below it can be either - we're done, old victim stays
        if (!ThreatManager::CompareReferencesLT(oldVictimRef, next, 1.1f))
            return oldVictimRef;
        // if next is melee, he's above 110% and our new victim
        if (_owner->IsWithinMeleeRange(next->_victim))
            return next;
        // otherwise the next highest target may still be a melee above 110% and we need to look further
        ++it;
    }
    // we should have found the old victim at some point in the loop above
    ASSERT(false && "Current victim not found in sorted threat list even though it has a reference - manager desync!");
    return nullptr;
}

References _currentVictimRef, _fixateRef, _myThreatListEntries, _owner, _sortedThreatList, ThreatReference::_victim, ASSERT, CompareReferencesLT(), ThreatReference::IsAvailable(), ThreatReference::IsOffline(), Unit::IsWithinMeleeRange(), and ThreatReference::UpdateOffline().

Referenced by UpdateVictim().

ResetAllMyThreatOnOthers()

void ThreatManager::ResetAllMyThreatOnOthers

(

)

{
    for (auto const& pair : _threatenedByMe)
        pair.second->ScaleThreat(0.0f);
}

References _threatenedByMe.

ResetAllRedirects()

void ThreatManager::ResetAllRedirects ( )

inline

{ _redirectRegistry.clear(); UpdateRedirectInfo(); }

ResetAllThreat()

void ThreatManager::ResetAllThreat

(

)

{
    for (auto const& pair : _myThreatListEntries)
        pair.second->ScaleThreat(0.0f);
}

References _myThreatListEntries.

Referenced by npc_vengeful_shade::npc_vengeful_shadeAI::AttackStart(), boss_thaddius_summon::boss_thaddius_summonAI::DoAction(), ScriptedAI::DoResetThreatList(), spell_karazhan_blink::HandleDummy(), spell_ulduar_random_aggro_periodic::HandleEffectPeriodic(), spell_tharon_ja_dummy_aura::HandleEffectRemove(), spell_pursue::HandleScript(), spell_leotheras_whirlwind::HandleScriptEffect(), spell_black_knight_ghoul_claw::HandleSpellHit(), npc_pet_mage_mirror_image::MySelectNextTarget(), boss_tharon_ja::boss_tharon_jaAI::Reset(), boss_talon_king_ikiss::Reset(), npc_ulduar_iron_construct::SpellHit(), boss_eck::SpellHitTarget(), boss_sartura::UpdateAI(), npc_sartura_royal_guard::UpdateAI(), npc_toc5_grand_champion_minion::npc_toc5_grand_champion_minionAI::UpdateAI(), boss_grand_champion::boss_grand_championAI::UpdateAI(), boss_gothik::boss_gothikAI::UpdateAI(), npc_molten_golem::UpdateAI(), boss_palehoof::boss_palehoofAI::UpdateAI(), and npc_frozen_orb::npc_frozen_orbAI::UpdateAI().

ResetThreat()

void ThreatManager::ResetThreat ( Unit *  target )

inline

{ ScaleThreat(target, 0.0f); }

Referenced by ScriptedAI::DoResetThreat(), spell_kaelthas_mind_control::HandleEffect(), boss_priestess_lackey_commonAI::RecalculateThreat(), and boss_faction_championsAI::RecalculateThreat().

ScaleThreat()

void ThreatManager::ScaleThreat	(	Unit *	target,
		float	factor
	)

{
    auto it = _myThreatListEntries.find(target->GetGUID());
    if (it != _myThreatListEntries.end())
        it->second->ScaleThreat(std::max<float>(factor, 0.0f));
}

References _myThreatListEntries, and Object::GetGUID().

SendClearAllThreatToClients()

void ThreatManager::SendClearAllThreatToClients ( ) const

private

{
    WorldPacket data(SMSG_THREAT_CLEAR, 8);
    data << _owner->GetPackGUID();
    _owner->SendMessageToSet(&data, false);
}

References _owner, Object::GetPackGUID(), WorldObject::SendMessageToSet(), and SMSG_THREAT_CLEAR.

Referenced by ClearAllThreat().

SendRemoveToClients()

void ThreatManager::SendRemoveToClients ( Unit const *  victim ) const

private

{
    WorldPacket data(SMSG_THREAT_REMOVE, 16);
    data << _owner->GetPackGUID();
    data << victim->GetPackGUID();
    _owner->SendMessageToSet(&data, false);
}

References _owner, Object::GetPackGUID(), WorldObject::SendMessageToSet(), and SMSG_THREAT_REMOVE.

Referenced by ClearThreat(), and ThreatReference::UpdateOffline().

SendThreatListToClients()

void ThreatManager::SendThreatListToClients ( bool  newHighest ) const

private

{
    WorldPacket data(newHighest ? SMSG_HIGHEST_THREAT_UPDATE : SMSG_THREAT_UPDATE, (_sortedThreatList->size() + 2) * 8); // guess
    data << _owner->GetPackGUID();
    if (newHighest)
        data << _currentVictimRef->GetVictim()->GetPackGUID();
    size_t countPos = data.wpos();
    data << uint32(0); // placeholder
    uint32 count = 0;
    for (ThreatReference const* ref : *_sortedThreatList)
    {
        if (!ref->IsAvailable())
            continue;
        data << ref->GetVictim()->GetPackGUID();
        data << uint32(ref->GetThreat() * 100);
        ++count;
    }
    data.put<uint32>(countPos, count);
    _owner->SendMessageToSet(&data, false);
}

References _currentVictimRef, _owner, _sortedThreatList, Object::GetPackGUID(), ThreatReference::GetVictim(), ByteBuffer::put(), WorldObject::SendMessageToSet(), SMSG_HIGHEST_THREAT_UPDATE, SMSG_THREAT_UPDATE, and ByteBuffer::wpos().

Referenced by UpdateVictim().

SetTauntStateForTesting()

void ThreatManager::SetTauntStateForTesting	(	Unit *	target,
		uint32	state
	)

{
    auto it = _myThreatListEntries.find(target->GetGUID());
    if (it != _myThreatListEntries.end())
        it->second->UpdateTauntState(
            static_cast<ThreatReference::TauntState>(state));
}

References _myThreatListEntries, and Object::GetGUID().

TauntUpdate()

void ThreatManager::TauntUpdate

(

)

{
    Unit::AuraEffectList const& tauntEffects = _owner->GetAuraEffectsByType(SPELL_AURA_MOD_TAUNT);
 
    uint32 state = ThreatReference::TAUNT_STATE_TAUNT;
    std::unordered_map<ObjectGuid, ThreatReference::TauntState> tauntStates;
    // Only the last taunt effect applied by something still on our threat list is considered
    for (auto it = tauntEffects.begin(), end = tauntEffects.end(); it != end; ++it)
        tauntStates[(*it)->GetCasterGUID()] = ThreatReference::TauntState(state++);
 
    for (auto const& pair : _myThreatListEntries)
    {
        auto it = tauntStates.find(pair.first);
        if (it != tauntStates.end())
            pair.second->UpdateTauntState(it->second);
        else
            pair.second->UpdateTauntState();
    }
 
    // taunt aura update also re-evaluates all suppressed states (retail behavior)
    EvaluateSuppressed(true);
 
    // immediately reselect victim so taunt takes effect without waiting
    // for the next THREAT_UPDATE_INTERVAL (1 s) timer tick
    UpdateVictim();
    _updateTimer = THREAT_UPDATE_INTERVAL;
}

References _myThreatListEntries, _owner, _updateTimer, EvaluateSuppressed(), Unit::GetAuraEffectsByType(), SPELL_AURA_MOD_TAUNT, ThreatReference::TAUNT_STATE_TAUNT, THREAT_UPDATE_INTERVAL, and UpdateVictim().

Referenced by AuraEffect::HandleModDetaunt(), and AuraEffect::HandleModTaunt().

UnregisterRedirectThreat() [1/2]

void ThreatManager::UnregisterRedirectThreat

(

uint32

spellId

)

{
    auto it = _redirectRegistry.find(spellId);
    if (it == _redirectRegistry.end())
        return;
    _redirectRegistry.erase(it);
    UpdateRedirectInfo();
}

References _redirectRegistry, and UpdateRedirectInfo().

Referenced by spell_rog_tricks_of_the_trade_proc::HandleRemove(), spell_warr_vigilance::HandleRemove(), spell_hun_misdirection::OnRemove(), spell_hun_misdirection_proc::OnRemove(), and spell_rog_tricks_of_the_trade_aura::OnRemove().

UnregisterRedirectThreat() [2/2]

void ThreatManager::UnregisterRedirectThreat	(	uint32	spellId,
		ObjectGuid const &	victim
	)

{
    auto it = _redirectRegistry.find(spellId);
    if (it == _redirectRegistry.end())
        return;
    auto& victimMap = it->second;
    auto it2 = victimMap.find(victim);
    if (it2 == victimMap.end())
        return;
    victimMap.erase(it2);
    if (victimMap.empty())
        _redirectRegistry.erase(it);
    UpdateRedirectInfo();
}

References _redirectRegistry, and UpdateRedirectInfo().

Update()

void ThreatManager::Update

(

uint32

tdiff

)

{
    if (!CanHaveThreatList() || IsThreatListEmpty(true))
        return;
    if (_updateTimer <= tdiff)
    {
        UpdateVictim();
        _updateTimer = THREAT_UPDATE_INTERVAL;
    }
    else
        _updateTimer -= tdiff;
}

References _updateTimer, CanHaveThreatList(), IsThreatListEmpty(), THREAT_UPDATE_INTERVAL, and UpdateVictim().

Referenced by Creature::Update().

UpdateMySpellSchoolModifiers()

void ThreatManager::UpdateMySpellSchoolModifiers

(

)

{
    for (uint8 i = 0; i < MAX_SPELL_SCHOOL; ++i)
        _singleSchoolModifiers[i] = _owner->GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_THREAT, 1 << i);
    _multiSchoolModifiers.clear();
}

References _multiSchoolModifiers, _owner, _singleSchoolModifiers, Unit::GetTotalAuraMultiplierByMiscMask(), MAX_SPELL_SCHOOL, and SPELL_AURA_MOD_THREAT.

Referenced by AuraEffect::HandleModThreat().

UpdateMyTempModifiers()

void ThreatManager::UpdateMyTempModifiers

(

)

{
    int32 mod = 0;
    for (AuraEffect const* eff : _owner->GetAuraEffectsByType(SPELL_AURA_MOD_TOTAL_THREAT))
        mod += eff->GetAmount();
 
    if (_threatenedByMe.empty())
        return;
 
    auto it = _threatenedByMe.begin();
    bool const isIncrease = (it->second->_tempModifier < mod);
    do
    {
        it->second->_tempModifier = mod;
        if (isIncrease)
            it->second->HeapNotifyIncreased();
        else
            it->second->HeapNotifyDecreased();
    } while ((++it) != _threatenedByMe.end());
}

References _owner, _threatenedByMe, Unit::GetAuraEffectsByType(), and SPELL_AURA_MOD_TOTAL_THREAT.

Referenced by AuraEffect::HandleAuraModTotalThreat().

UpdateRedirectInfo()

void ThreatManager::UpdateRedirectInfo ( )

private

{
    _redirectInfo.clear();
    uint32 totalPct = 0;
    for (auto const& pair : _redirectRegistry) // (spellid, victim -> pct)
        for (auto const& victimPair : pair.second) // (victim,pct)
        {
            uint32 thisPct = std::min<uint32>(100 - totalPct, victimPair.second);
            if (thisPct > 0)
            {
                _redirectInfo.push_back({ victimPair.first, thisPct });
                totalPct += thisPct;
                ASSERT(totalPct <= 100);
                if (totalPct == 100)
                    return;
            }
        }
}

References _redirectInfo, _redirectRegistry, and ASSERT.

Referenced by RegisterRedirectThreat(), UnregisterRedirectThreat(), and UnregisterRedirectThreat().

UpdateVictim()

void ThreatManager::UpdateVictim ( )

private

{
    ThreatReference const* const newVictim = ReselectVictim();
    bool const newHighest = newVictim && (newVictim != _currentVictimRef);
 
    _currentVictimRef = newVictim;
    if (newHighest || _needClientUpdate)
    {
        SendThreatListToClients(newHighest);
        _needClientUpdate = false;
    }
 
    ProcessAIUpdates();
}

References _currentVictimRef, _needClientUpdate, ProcessAIUpdates(), ReselectVictim(), and SendThreatListToClients().

Referenced by AddThreat(), ClearThreat(), GetCurrentVictim(), TauntUpdate(), and Update().

UpdateVictimForTesting()

void ThreatManager::UpdateVictimForTesting ( )

inline

{ UpdateVictim(); }

Friends And Related Symbol Documentation

CompareThreatLessThan

friend struct CompareThreatLessThan

friend

debug_commandscript

friend class debug_commandscript

friend

ThreatReference

friend class ThreatReference

friend

ThreatReferenceImpl

friend class ThreatReferenceImpl

friend

Referenced by AddThreat().

Member Data Documentation

_currentVictimRef

ThreatReference const* ThreatManager::_currentVictimRef

private

Referenced by AddThreat(), ClearThreat(), GetCurrentVictim(), GetLastVictim(), PurgeThreatListRef(), ReselectVictim(), SendThreatListToClients(), and UpdateVictim().

_fixateRef

ThreatReference const* ThreatManager::_fixateRef

private

Referenced by FixateTarget(), GetFixateTarget(), PurgeThreatListRef(), and ReselectVictim().

_multiSchoolModifiers

std::unordered_map<std::underlying_type<SpellSchoolMask>::type, float> ThreatManager::_multiSchoolModifiers

mutableprivate

Referenced by CalculateModifiedThreat(), debug_commandscript::HandleDebugThreatInfoCommand(), and UpdateMySpellSchoolModifiers().

_myThreatListEntries

std::unordered_map<ObjectGuid, ThreatReference*> ThreatManager::_myThreatListEntries

private

Referenced by AddThreat(), ClearAllThreat(), ClearThreat(), FixateTarget(), GetModifiableThreatList(), GetThreat(), GetUnsortedThreatList(), IsThreatenedBy(), MatchUnitThreatToHighestThreat(), ProcessAIUpdates(), PurgeThreatListRef(), PutThreatListRef(), ReselectVictim(), ResetAllThreat(), ScaleThreat(), SetTauntStateForTesting(), TauntUpdate(), and ~ThreatManager().

_needClientUpdate

bool ThreatManager::_needClientUpdate

private

Referenced by ThreatReference::AddThreat(), PutThreatListRef(), ThreatReference::ScaleThreat(), ThreatReference::UpdateTauntState(), and UpdateVictim().

_needsAIUpdate

std::vector<ObjectGuid> ThreatManager::_needsAIUpdate

private

Referenced by ProcessAIUpdates().

_owner

Unit* const ThreatManager::_owner

private

Referenced by AddThreat(), Initialize(), ProcessAIUpdates(), PutThreatenedByMeRef(), PutThreatListRef(), RemoveMeFromThreatLists(), ReselectVictim(), SendClearAllThreatToClients(), SendRemoveToClients(), SendThreatListToClients(), TauntUpdate(), ThreatReferenceImpl::ThreatReferenceImpl(), UpdateMySpellSchoolModifiers(), UpdateMyTempModifiers(), and ~ThreatManager().

_ownerCanHaveThreatList

bool ThreatManager::_ownerCanHaveThreatList

private

Referenced by Initialize().

_redirectInfo

std::vector<std::pair<ObjectGuid, uint32> > ThreatManager::_redirectInfo

private

Referenced by AddThreat(), debug_commandscript::HandleDebugThreatInfoCommand(), and UpdateRedirectInfo().

_redirectRegistry

std::unordered_map<uint32, std::unordered_map<ObjectGuid, uint32> > ThreatManager::_redirectRegistry

private

Referenced by debug_commandscript::HandleDebugThreatInfoCommand(), RegisterRedirectThreat(), UnregisterRedirectThreat(), UnregisterRedirectThreat(), and UpdateRedirectInfo().

_singleSchoolModifiers

std::array<float, MAX_SPELL_SCHOOL> ThreatManager::_singleSchoolModifiers

private

Referenced by CalculateModifiedThreat(), debug_commandscript::HandleDebugThreatInfoCommand(), ThreatManager(), and UpdateMySpellSchoolModifiers().

_sortedThreatList

std::unique_ptr<Heap> ThreatManager::_sortedThreatList

private

Referenced by GetAnyTarget(), GetModifiableThreatList(), GetSortedThreatList(), GetThreatListPlayerCount(), GetThreatListSize(), ThreatReference::HeapNotifyDecreased(), ThreatReference::HeapNotifyIncreased(), IsThreatListEmpty(), MatchUnitThreatToHighestThreat(), PurgeThreatListRef(), PutThreatListRef(), ReselectVictim(), SendThreatListToClients(), and ~ThreatManager().

_threatenedByMe

std::unordered_map<ObjectGuid, ThreatReference*> ThreatManager::_threatenedByMe

private

Referenced by EvaluateSuppressed(), ForwardThreatForAssistingMe(), IsThreateningAnyone(), IsThreateningTo(), PurgeThreatenedByMeRef(), PutThreatenedByMeRef(), RemoveMeFromThreatLists(), ResetAllMyThreatOnOthers(), UpdateMyTempModifiers(), and ~ThreatManager().

_updateTimer

uint32 ThreatManager::_updateTimer

private

Referenced by TauntUpdate(), and Update().

CompareThreat

const CompareThreatLessThan ThreatManager::CompareThreat

staticprivate

THREAT_UPDATE_INTERVAL

const uint32 ThreatManager::THREAT_UPDATE_INTERVAL = 1000u

static

Referenced by TauntUpdate(), and Update().

---

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

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