ThreatMgr Class Reference

#include "ThreatMgr.h"

Public Member Functions
	ThreatMgr (Unit *owner)
	~ThreatMgr ()
Unit *	SelectVictim ()
Unit *	GetCurrentVictim () const
Unit *	GetAnyTarget () const
void	clearReferences ()
void	AddThreat (Unit *victim, float threat, SpellSchoolMask schoolMask=SPELL_SCHOOL_MASK_NORMAL, SpellInfo const *threatSpell=nullptr)
void	DoAddThreat (Unit *victim, float threat)
void	ModifyThreatByPercent (Unit *victim, int32 percent)
float	GetThreat (Unit *victim, bool alsoSearchOfflineList=false)
float	GetThreatListSize () const
float	getThreatWithoutTemp (Unit *victim, bool alsoSearchOfflineList=false)
bool	isThreatListEmpty () const
bool	areThreatListsEmpty () const
Acore::IteratorPair< std::list< ThreatReference * >::const_iterator >	GetSortedThreatList () const
Acore::IteratorPair< std::list< ThreatReference * >::const_iterator >	GetUnsortedThreatList () const
void	processThreatEvent (ThreatRefStatusChangeEvent *threatRefStatusChangeEvent)
bool	isNeedUpdateToClient (uint32 time)
HostileReference *	getCurrentVictim () const
Unit *	GetOwner () const
Unit *	getHostileTarget ()
void	tauntApply (Unit *taunter)
void	tauntFadeOut (Unit *taunter)
void	setCurrentVictim (HostileReference *hostileRef)
void	setDirty (bool isDirty)
void	ResetThreat (Unit const *who)
void	ResetAllThreat ()
void	ClearThreat (Unit const *who)
void	ClearAllThreat ()
template<class PREDICATE >
void	resetAggro (PREDICATE predicate)
ThreatContainer::StorageType const &	GetThreatList () const
ThreatContainer::StorageType const &	GetOfflineThreatList () const
ThreatContainer &	GetOnlineContainer ()
ThreatContainer &	GetOfflineContainer ()

Private Member Functions
HostileReference *	FindReference (Unit const *who, bool includeOffline) const
void	_addThreat (Unit *victim, float threat)

Private Attributes
HostileReference *	iCurrentVictim
Unit *	iOwner
uint32	iUpdateTimer
ThreatContainer	iThreatContainer
ThreatContainer	iThreatOfflineContainer

Friends
class	HostileReference

Detailed Description

Constructor & Destructor Documentation

ThreatMgr()

ThreatMgr::ThreatMgr ( Unit *  owner )

explicit

                                : iCurrentVictim(nullptr), iOwner(owner), iUpdateTimer(THREAT_UPDATE_INTERVAL)
{
}

~ThreatMgr()

ThreatMgr::~ThreatMgr ( )

inline

{ clearReferences(); }

References clearReferences().

Member Function Documentation

_addThreat()

void ThreatMgr::_addThreat ( Unit *  victim, float  threat  )

private

{
    HostileReference* ref = iThreatContainer.AddThreat(victim, threat);
    // Ref is not in the online refs, search the offline refs next
    if (!ref)
        ref = iThreatOfflineContainer.AddThreat(victim, threat);
 
    if (!ref) // there was no ref => create a new one
    {
        // threat has to be 0 here
        HostileReference* hostileRef = new HostileReference(victim, this, 0);
        iThreatContainer.addReference(hostileRef);
        hostileRef->AddThreat(threat); // now we add the real threat
        if (victim->IsPlayer() && victim->ToPlayer()->IsGameMaster())
            hostileRef->setOnlineOfflineState(false); // GM is always offline
    }
}

References ThreatContainer::addReference(), HostileReference::AddThreat(), ThreatContainer::AddThreat(), HostileReference, Player::IsGameMaster(), Object::IsPlayer(), iThreatContainer, iThreatOfflineContainer, HostileReference::setOnlineOfflineState(), and Object::ToPlayer().

Referenced by DoAddThreat().

AddThreat()

void ThreatMgr::AddThreat	(	Unit *	victim,
		float	threat,
		SpellSchoolMask	schoolMask = SPELL_SCHOOL_MASK_NORMAL,
		SpellInfo const *	threatSpell = nullptr
	)

{
    if (!ThreatCalcHelper::isValidProcess(victim, iOwner, threatSpell))
        return;
 
    threat = ThreatCalcHelper::calcThreat(victim, threat, schoolMask, threatSpell);
    if (Creature* hatingCreature = iOwner->ToCreature())
    {
        if (hatingCreature->IsAIEnabled)
        {
            hatingCreature->AI()->CalculateThreat(victim, threat, threatSpell);
        }
    }
 
    DoAddThreat(victim, threat);
}

References ThreatCalcHelper::calcThreat(), DoAddThreat(), iOwner, ThreatCalcHelper::isValidProcess(), and Object::ToCreature().

Referenced by HostileReference::AddThreat(), Unit::AddThreat(), ScriptedAI::DoAddThreat(), TemporaryThreatModifierEvent::Execute(), npc_frostwing_vrykul::npc_frostwing_vrykulAI::SpellHitTarget(), boss_drakkisath::boss_drakkisathAI::UpdateAI(), boss_grilek::boss_grilekAI::UpdateAI(), boss_gothik::boss_gothikAI::UpdateAI(), and boss_netherspite::UpdatePortals().

areThreatListsEmpty()

bool ThreatMgr::areThreatListsEmpty ( ) const

inline

{ return iThreatContainer.empty() && iThreatOfflineContainer.empty(); }

References ThreatContainer::empty(), iThreatContainer, and iThreatOfflineContainer.

ClearAllThreat()

void ThreatMgr::ClearAllThreat

(

)

{
    if (iOwner->CanHaveThreatList(true) && !isThreatListEmpty())
        iOwner->SendClearThreatListOpcode();
    clearReferences();
}

References Unit::CanHaveThreatList(), clearReferences(), iOwner, isThreatListEmpty(), and Unit::SendClearThreatListOpcode().

Referenced by CreatureAI::_EnterEvadeMode(), Unit::CleanupBeforeRemoveFromMap(), boss_grand_champion::boss_grand_championAI::DamageTaken(), npc_magister_aledis::DamageTaken(), npc_tapoke_slim_jahn::npc_tapoke_slim_jahnAI::DamageTaken(), npc_dark_nucleus::npc_dark_nucleusAI::DamageTaken(), npc_crok_scourgebane::npc_crok_scourgebaneAI::DoAction(), npc_spark_of_ionar::DoAction(), npc_taskmaster_fizzule::npc_taskmaster_fizzuleAI::DoFriend(), npc_unkor_the_ruthless::npc_unkor_the_ruthlessAI::DoNice(), npc_tirion_fordring_tft::npc_tirion_fordringAI::EnterEvadeMode(), GuardAI::EnterEvadeMode(), boss_doomrel::boss_doomrelAI::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_pet_hunter_snake_trap::EnterEvadeMode(), npc_escortAI::EnterEvadeMode(), FollowerAI::EnterEvadeMode(), npc_crystalline_frayer::EnterSeedPod(), npc_raging_flames::FixateRandomTarget(), spell_q11919_q11940_drake_hunt_aura::HandleEffectRemove(), PetAI::HandleReturnMovement(), boss_high_astromancer_solarian::JustEngagedWith(), Unit::Kill(), boss_urom::boss_uromAI::LeaveCombat(), Unit::setDeathState(), spell_putricide_ooze_channel::StartAttack(), npc_highlord_darion_mograine::npc_highlord_darion_mograineAI::UpdateAI(), npc_snobold_vassal::npc_snobold_vassalAI::UpdateAI(), boss_malygos::UpdateAI(), and npc_aeranas::npc_aeranasAI::UpdateAI().

clearReferences()

void ThreatMgr::clearReferences

(

)

{
    iThreatContainer.clearReferences();
    iThreatOfflineContainer.clearReferences();
    iCurrentVictim = nullptr;
    iUpdateTimer = THREAT_UPDATE_INTERVAL;
}

References ThreatContainer::clearReferences(), iCurrentVictim, iThreatContainer, iThreatOfflineContainer, iUpdateTimer, and THREAT_UPDATE_INTERVAL.

Referenced by ClearAllThreat(), boss_eadric::boss_eadricAI::DamageTaken(), boss_paletress::boss_paletressAI::DamageTaken(), spell_halion_twilight_phasing_aura::OnApply(), spell_halion_twilight_phasing_aura::OnRemove(), and ~ThreatMgr().

ClearThreat()

void ThreatMgr::ClearThreat ( Unit const *  who )

inline

{ if (auto* ref = FindReference(who, true)) ref->removeReference(); }

References FindReference().

DoAddThreat()

void ThreatMgr::DoAddThreat	(	Unit *	victim,
		float	threat
	)

{
    uint32 redirectThreadPct = victim->GetRedirectThreatPercent();
    Unit* redirectTarget = victim->GetRedirectThreatTarget();
 
    // Personal Spawns from same summoner can aggro each other
    if (TempSummon* tempSummonVictim = victim->ToTempSummon())
    {
        if (tempSummonVictim->IsVisibleBySummonerOnly())
        {
            if (!GetOwner()->ToTempSummon() ||
                !GetOwner()->ToTempSummon()->IsVisibleBySummonerOnly() ||
                tempSummonVictim->GetSummonerGUID() != GetOwner()->ToTempSummon()->GetSummonerGUID())
            {
                redirectThreadPct = 100;
                redirectTarget = tempSummonVictim->GetSummonerUnit();
            }
        }
    }
 
    // must check > 0.0f, otherwise dead loop
    if (threat > 0.0f && redirectThreadPct)
    {
        if (redirectTarget)
        {
            float redirectThreat = CalculatePct(threat, redirectThreadPct);
            threat -= redirectThreat;
            if (ThreatCalcHelper::isValidProcess(redirectTarget, GetOwner()))
                _addThreat(redirectTarget, redirectThreat);
        }
    }
 
    _addThreat(victim, threat);
}

References _addThreat(), CalculatePct(), GetOwner(), Unit::GetRedirectThreatPercent(), Unit::GetRedirectThreatTarget(), ThreatCalcHelper::isValidProcess(), and Unit::ToTempSummon().

Referenced by AddThreat(), Spell::EffectTaunt(), and HostileRefMgr::threatAssist().

FindReference()

HostileReference * ThreatMgr::FindReference ( Unit const *  who, bool  includeOffline  ) const

inlineprivate

{ if (auto* ref = iThreatContainer.getReferenceByTarget(who)) return ref; if (includeOffline) if (auto* ref = iThreatOfflineContainer.getReferenceByTarget(who)) return ref; return nullptr; }

References ThreatContainer::getReferenceByTarget(), iThreatContainer, and iThreatOfflineContainer.

Referenced by ClearThreat(), and ResetThreat().

GetAnyTarget()

Unit * ThreatMgr::GetAnyTarget ( ) const

inline

{ auto const& list = GetThreatList(); if (!list.empty()) return list.front()->getTarget(); return nullptr; }

References GetThreatList().

GetCurrentVictim()

Unit * ThreatMgr::GetCurrentVictim ( ) const

inline

{ if (ThreatReference* ref = getCurrentVictim()) return ref->GetVictim(); else return nullptr; }

References getCurrentVictim(), and Unit::GetVictim().

Referenced by boss_talon_king_ikiss::JustEngagedWith(), boss_teron_gorefiend::JustEngagedWith(), NonTankTargetSelector::operator()(), PowerUsersSelector::operator()(), and MalleableGooSelector::operator()().

getCurrentVictim()

HostileReference * ThreatMgr::getCurrentVictim ( ) const

inline

{ return iCurrentVictim; }

References iCurrentVictim.

Referenced by GetCurrentVictim(), getHostileTarget(), processThreatEvent(), and tauntApply().

getHostileTarget()

Unit * ThreatMgr::getHostileTarget

(

)

{
    iThreatContainer.update();
    HostileReference* nextVictim = iThreatContainer.SelectNextVictim(GetOwner()->ToCreature(), getCurrentVictim());
    setCurrentVictim(nextVictim);
    return getCurrentVictim() != nullptr ? getCurrentVictim()->getTarget() : nullptr;
}

References getCurrentVictim(), GetOwner(), Reference< TO, FROM >::getTarget(), iThreatContainer, ThreatContainer::SelectNextVictim(), setCurrentVictim(), and ThreatContainer::update().

Referenced by SelectVictim(), and Creature::SelectVictim().

GetOfflineContainer()

ThreatContainer & ThreatMgr::GetOfflineContainer ( )

inline

{ return iThreatOfflineContainer; }

References iThreatOfflineContainer.

GetOfflineThreatList()

ThreatContainer::StorageType const & ThreatMgr::GetOfflineThreatList ( ) const

inline

{ return iThreatOfflineContainer.GetThreatList(); }

References ThreatContainer::GetThreatList(), and iThreatOfflineContainer.

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

GetOnlineContainer()

ThreatContainer & ThreatMgr::GetOnlineContainer ( )

inline

{ return iThreatContainer; }

References iThreatContainer.

Referenced by boss_hazzarah::CanAIAttack(), boss_renataki::boss_renatakiAI::CanAIAttack(), Spell::EffectTaunt(), boss_priestess_lackey_commonAI::RecalculateThreat(), and boss_faction_championsAI::RecalculateThreat().

GetOwner()

Unit * ThreatMgr::GetOwner ( ) const

inline

{ return iOwner; }

References iOwner.

Referenced by HostileRefMgr::deleteReference(), HostileRefMgr::deleteReferencesForFaction(), HostileRefMgr::deleteReferencesOutOfRange(), DoAddThreat(), getHostileTarget(), HostileReference::GetOwner(), debug_commandscript::HandleDebugHostileRefListCommand(), npc_pet_mage_mirror_image::InitializeAI(), processThreatEvent(), HostileRefMgr::setOnlineOfflineState(), Unit::SetPhaseMask(), and HostileRefMgr::threatAssist().

GetSortedThreatList()

Acore::IteratorPair< std::list< ThreatReference * >::const_iterator > ThreatMgr::GetSortedThreatList ( ) const

inline

{ auto& list = iThreatContainer.GetThreatList(); return { list.cbegin(), list.cend() }; }

References ThreatContainer::GetThreatList(), and iThreatContainer.

Referenced by GetUnsortedThreatList(), and UnitAI::SelectTargetList().

GetThreat()

float ThreatMgr::GetThreat	(	Unit *	victim,
		bool	alsoSearchOfflineList = false
	)

{
    float threat = 0.0f;
    HostileReference* ref = iThreatContainer.getReferenceByTarget(victim);
    if (!ref && alsoSearchOfflineList)
        ref = iThreatOfflineContainer.getReferenceByTarget(victim);
    if (ref)
        threat = ref->GetThreat();
    return threat;
}

References ThreatContainer::getReferenceByTarget(), HostileReference::GetThreat(), iThreatContainer, and iThreatOfflineContainer.

Referenced by boss_mor_grayhoof::CastRandomSpell(), ScriptedAI::DoGetThreat(), Spell::EffectTaunt(), Creature::ModifyThreatPercentTemp(), processThreatEvent(), boss_priestess_lackey_commonAI::RecalculateThreat(), boss_faction_championsAI::RecalculateThreat(), tauntApply(), boss_drakkisath::boss_drakkisathAI::UpdateAI(), and boss_thaddius_summon::boss_thaddius_summonAI::UpdateAI().

GetThreatList()

ThreatContainer::StorageType const & ThreatMgr::GetThreatList ( ) const

inline

{ return iThreatContainer.GetThreatList(); }

References ThreatContainer::GetThreatList(), and iThreatContainer.

Referenced by boss_lady_deathwhisper::boss_lady_deathwhisperAI::DamageTaken(), boss_ysondre::boss_ysondreAI::DamageTaken(), UnitAI::DoAddAuraToAllHostilePlayers(), UnitAI::DoCastToAllHostilePlayers(), boss_faction_championsAI::EnemiesInRange(), boss_ragnaros::boss_ragnarosAI::EnterEvadeMode(), boss_murmur::EnterEvadeMode(), boss_alar::EnterEvadeMode(), boss_ouro::EnterEvadeMode(), boss_supremus::FindHatefulStrikeTarget(), GetAnyTarget(), SmartScript::GetTargets(), GetThreatListSize(), debug_commandscript::HandleDebugThreatListCommand(), boss_thaddius::boss_thaddiusAI::IsAnyPlayerInMeleeRange(), Unit::IsInCombatWith(), boss_hadronox::IsInCombatWithPlayer(), boss_blackheart_the_inciter::JustEngagedWith(), SmartScript::ProcessAction(), SmartScript::ProcessEvent(), boss_priestess_lackey_commonAI::RecalculateThreat(), boss_faction_championsAI::RecalculateThreat(), boss_faction_championsAI::SelectEnemyCaster(), npc_scholomance_occultist::npc_scholomance_occultistAI::SelectUnitCasting(), Unit::SendChangeCurrentVictimOpcode(), Unit::SendThreatListUpdate(), Unit::SetPhaseMask(), npc_frostwing_vrykul::npc_frostwing_vrykulAI::SpellHitTarget(), BossAI::TeleportCheaters(), boss_nefarian::UpdateAI(), boss_mandokir::boss_mandokirAI::UpdateAI(), boss_renataki::boss_renatakiAI::UpdateAI(), npc_green_dragon_combat_trigger::npc_green_dragon_combat_triggerAI::UpdateAI(), boss_kelthuzad::boss_kelthuzadAI::UpdateAI(), boss_patchwerk::boss_patchwerkAI::UpdateAI(), boss_sapphiron::boss_sapphironAI::UpdateAI(), and boss_the_lurker_below::UpdateAI().

GetThreatListSize()

float ThreatMgr::GetThreatListSize ( ) const

inline

{ return GetThreatList().size(); }

References GetThreatList().

Referenced by boss_hazzarah::CanAIAttack(), boss_renataki::boss_renatakiAI::CanAIAttack(), boss_jindo::JustSummoned(), boss_bug_trio::MovementInform(), StoneGripTargetSelector::operator()(), boss_jeklik::PathEndReached(), SmartScript::ProcessAction(), UnitAI::SelectTarget(), UnitAI::SelectTargetList(), Creature::Update(), boss_hakkar::boss_hakkarAI::UpdateAI(), boss_jindo::UpdateAI(), and HostileRefMgr::UpdateVisibility().

getThreatWithoutTemp()

float ThreatMgr::getThreatWithoutTemp	(	Unit *	victim,
		bool	alsoSearchOfflineList = false
	)

{
    float threat = 0.0f;
    HostileReference* ref = iThreatContainer.getReferenceByTarget(victim);
    if (!ref && alsoSearchOfflineList)
        ref = iThreatOfflineContainer.getReferenceByTarget(victim);
    if (ref)
        threat = ref->GetThreat() - ref->getTempThreatModifier();
    return threat;
}

References ThreatContainer::getReferenceByTarget(), HostileReference::getTempThreatModifier(), HostileReference::GetThreat(), iThreatContainer, and iThreatOfflineContainer.

GetUnsortedThreatList()

Acore::IteratorPair< std::list< ThreatReference * >::const_iterator > ThreatMgr::GetUnsortedThreatList ( ) const

inline

{ return GetSortedThreatList(); }

References GetSortedThreatList().

Referenced by boss_attumen::IsSummonedBy(), and UnitAI::SelectTargetList().

isNeedUpdateToClient()

bool ThreatMgr::isNeedUpdateToClient

(

uint32

time

)

{
    if (isThreatListEmpty())
        return false;
 
    if (time >= iUpdateTimer)
    {
        iUpdateTimer = THREAT_UPDATE_INTERVAL;
        return true;
    }
    iUpdateTimer -= time;
    return false;
}

References isThreatListEmpty(), iUpdateTimer, and THREAT_UPDATE_INTERVAL.

isThreatListEmpty()

bool ThreatMgr::isThreatListEmpty ( ) const

inline

{ return iThreatContainer.empty(); }

References ThreatContainer::empty(), and iThreatContainer.

Referenced by ClearAllThreat(), ScriptedAI::DoResetThreatList(), StartMovementEvent::Execute(), isNeedUpdateToClient(), Creature::SelectVictim(), Unit::TauntFadeOut(), npc_raging_spirit::npc_raging_spiritAI::UpdateAI(), and CreatureAI::UpdateVictim().

ModifyThreatByPercent()

void ThreatMgr::ModifyThreatByPercent	(	Unit *	victim,
		int32	percent
	)

{
    iThreatContainer.ModifyThreatByPercent(victim, percent);
}

References iThreatContainer, and ThreatContainer::ModifyThreatByPercent().

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

processThreatEvent()

void ThreatMgr::processThreatEvent

(

ThreatRefStatusChangeEvent *

threatRefStatusChangeEvent

)

{
    threatRefStatusChangeEvent->setThreatMgr(this);     // now we can set the threat manager
 
    HostileReference* hostileRef = threatRefStatusChangeEvent->getReference();
 
    switch (threatRefStatusChangeEvent->getType())
    {
        case UEV_THREAT_REF_THREAT_CHANGE:
            if ((getCurrentVictim() == hostileRef && threatRefStatusChangeEvent->getFValue() < 0.0f) ||
                    (getCurrentVictim() != hostileRef && threatRefStatusChangeEvent->getFValue() > 0.0f))
                setDirty(true);                             // the order in the threat list might have changed
            break;
        case UEV_THREAT_REF_ONLINE_STATUS:
            if (!hostileRef->IsOnline())
            {
                if (hostileRef == getCurrentVictim())
                {
                    setCurrentVictim(nullptr);
                    setDirty(true);
                }
                if (GetOwner() && GetOwner()->IsInWorld())
                    if (Unit* target = ObjectAccessor::GetUnit(*GetOwner(), hostileRef->getUnitGuid()))
                        if (GetOwner()->IsInMap(target))
                            GetOwner()->SendRemoveFromThreatListOpcode(hostileRef);
                iThreatContainer.remove(hostileRef);
                iThreatOfflineContainer.addReference(hostileRef);
            }
            else
            {
                if (getCurrentVictim() && hostileRef->GetThreat() > (1.1f * getCurrentVictim()->GetThreat()))
                    setDirty(true);
                iThreatContainer.addReference(hostileRef);
                iThreatOfflineContainer.remove(hostileRef);
            }
            break;
        case UEV_THREAT_REF_REMOVE_FROM_LIST:
            if (hostileRef == getCurrentVictim())
            {
                setCurrentVictim(nullptr);
                setDirty(true);
            }
            iOwner->SendRemoveFromThreatListOpcode(hostileRef);
            if (hostileRef->IsOnline())
                iThreatContainer.remove(hostileRef);
            else
                iThreatOfflineContainer.remove(hostileRef);
            break;
    }
}

References ThreatContainer::addReference(), getCurrentVictim(), ThreatRefStatusChangeEvent::getFValue(), GetOwner(), ThreatRefStatusChangeEvent::getReference(), HostileReference::GetThreat(), GetThreat(), UnitBaseEvent::getType(), ObjectAccessor::GetUnit(), HostileReference::getUnitGuid(), iOwner, HostileReference::IsOnline(), iThreatContainer, iThreatOfflineContainer, ThreatContainer::remove(), Unit::SendRemoveFromThreatListOpcode(), setCurrentVictim(), setDirty(), ThreatRefStatusChangeEvent::setThreatMgr(), UEV_THREAT_REF_ONLINE_STATUS, UEV_THREAT_REF_REMOVE_FROM_LIST, and UEV_THREAT_REF_THREAT_CHANGE.

Referenced by HostileReference::fireStatusChanged().

resetAggro()

template<class PREDICATE >

void ThreatMgr::resetAggro ( PREDICATE  predicate )

inline

    {
        ThreatContainer::StorageType& threatList = iThreatContainer.iThreatList;
        if (threatList.empty())
            return;
 
        for (auto& ref : threatList)
        {
            if (predicate(ref->getTarget()))
            {
                ref->SetThreat(0);
                setDirty(true);
            }
        }
    }

References iThreatContainer, ThreatContainer::iThreatList, and setDirty().

Referenced by boss_gothik::boss_gothikAI::UpdateAI().

ResetAllThreat()

void ThreatMgr::ResetAllThreat

(

)

{
    ThreatContainer::StorageType& threatList = iThreatContainer.iThreatList;
    if (threatList.empty())
        return;
 
    for (HostileReference* ref : threatList)
    {
        // Reset temp threat before setting threat back to 0.
        ref->resetTempThreat();
        ref->SetThreat(0.f);
    }
 
    setDirty(true);
}

References iThreatContainer, ThreatContainer::iThreatList, and setDirty().

Referenced by npc_vengeful_shade::npc_vengeful_shadeAI::AttackStart(), boss_thorim_start_npcs::boss_thorim_start_npcsAI::DamageTaken(), ScriptedAI::DoResetThreatList(), spell_karazhan_blink::HandleDummy(), 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::npc_ulduar_iron_constructAI::SpellHit(), npc_frostwing_vrykul::npc_frostwing_vrykulAI::SpellHitTarget(), 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(), npc_molten_golem::UpdateAI(), boss_palehoof::boss_palehoofAI::UpdateAI(), and npc_frozen_orb::npc_frozen_orbAI::UpdateAI().

ResetThreat()

void ThreatMgr::ResetThreat ( Unit const *  who )

inline

{ if (auto* ref = FindReference(who, true)) ref->SetThreat(0.0f); }

References FindReference().

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

SelectVictim()

Unit * ThreatMgr::SelectVictim ( )

inline

{ return getHostileTarget(); }

References getHostileTarget().

setCurrentVictim()

void ThreatMgr::setCurrentVictim

(

HostileReference *

hostileRef

)

{
    if (pHostileReference && pHostileReference != iCurrentVictim)
    {
        iOwner->SendChangeCurrentVictimOpcode(pHostileReference);
    }
    iCurrentVictim = pHostileReference;
}

References iCurrentVictim, iOwner, and Unit::SendChangeCurrentVictimOpcode().

Referenced by Spell::EffectTaunt(), getHostileTarget(), and processThreatEvent().

setDirty()

void ThreatMgr::setDirty ( bool  isDirty )

inline

{ iThreatContainer.setDirty(isDirty); }

References iThreatContainer, and ThreatContainer::setDirty().

Referenced by processThreatEvent(), resetAggro(), and ResetAllThreat().

tauntApply()

void ThreatMgr::tauntApply

(

Unit *

taunter

)

{
    HostileReference* ref = iThreatContainer.getReferenceByTarget(taunter);
    if (getCurrentVictim() && ref && (ref->GetThreat() < getCurrentVictim()->GetThreat()))
    {
        if (ref->getTempThreatModifier() == 0.0f) // Ok, temp threat is unused
            ref->setTempThreat(getCurrentVictim()->GetThreat());
    }
}

References getCurrentVictim(), ThreatContainer::getReferenceByTarget(), HostileReference::getTempThreatModifier(), HostileReference::GetThreat(), GetThreat(), iThreatContainer, and HostileReference::setTempThreat().

tauntFadeOut()

void ThreatMgr::tauntFadeOut

(

Unit *

taunter

)

{
    HostileReference* ref = iThreatContainer.getReferenceByTarget(taunter);
    if (ref)
        ref->resetTempThreat();
}

References ThreatContainer::getReferenceByTarget(), iThreatContainer, and HostileReference::resetTempThreat().

Friends And Related Symbol Documentation

HostileReference

friend class HostileReference

friend

Referenced by _addThreat().

Member Data Documentation

iCurrentVictim

HostileReference* ThreatMgr::iCurrentVictim

private

Referenced by clearReferences(), getCurrentVictim(), and setCurrentVictim().

iOwner

Unit* ThreatMgr::iOwner

private

Referenced by AddThreat(), ClearAllThreat(), GetOwner(), processThreatEvent(), and setCurrentVictim().

iThreatContainer

ThreatContainer ThreatMgr::iThreatContainer

private

Referenced by _addThreat(), areThreatListsEmpty(), clearReferences(), FindReference(), getHostileTarget(), GetOnlineContainer(), GetSortedThreatList(), GetThreat(), GetThreatList(), getThreatWithoutTemp(), isThreatListEmpty(), ModifyThreatByPercent(), processThreatEvent(), resetAggro(), ResetAllThreat(), setDirty(), tauntApply(), and tauntFadeOut().

iThreatOfflineContainer

ThreatContainer ThreatMgr::iThreatOfflineContainer

private

Referenced by _addThreat(), areThreatListsEmpty(), clearReferences(), FindReference(), GetOfflineContainer(), GetOfflineThreatList(), GetThreat(), getThreatWithoutTemp(), and processThreatEvent().

iUpdateTimer

uint32 ThreatMgr::iUpdateTimer

private

Referenced by clearReferences(), and isNeedUpdateToClient().

---

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

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