ThreatManager Class Reference

#include <ThreatManager.h>

Public Member Functions
	ThreatManager (Unit *owner)
	~ThreatManager ()
void	clearReferences ()
void	addThreat (Unit *victim, float threat, SpellSchoolMask schoolMask=SPELL_SCHOOL_MASK_NORMAL, SpellInfo const *threatSpell=NULL)
void	doAddThreat (Unit *victim, float threat)
void	modifyThreatPercent (Unit *victim, int32 percent)
float	getThreat (Unit *victim, bool alsoSearchOfflineList=false)
bool	isThreatListEmpty () const
void	processThreatEvent (ThreatRefStatusChangeEvent *threatRefStatusChangeEvent)
bool	isNeedUpdateToClient (uint32 time)
HostileReference *	getCurrentVictim () const
Unit *	GetOwner () const
Unit *	getHostilTarget ()
void	tauntApply (Unit *taunter)
void	tauntFadeOut (Unit *taunter)
void	setCurrentVictim (HostileReference *hostileRef)
void	setDirty (bool isDirty)
void	resetAllAggro ()
template<class PREDICATE >
void	resetAggro (PREDICATE predicate)
ThreatContainer::StorageType const &	getThreatList () const
ThreatContainer::StorageType const &	getOfflineThreatList () const
ThreatContainer &	getOnlineContainer ()
ThreatContainer &	getOfflineContainer ()

Private Member Functions
void	_addThreat (Unit *victim, float threat)

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

Friends
class	HostileReference

Constructor & Destructor Documentation

ThreatManager::ThreatManager ( Unit *  owner )

explicit

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

ThreatManager::~ThreatManager ( )

inline

{ clearReferences(); }

Member Function Documentation

void ThreatManager::_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->GetTypeId() == TYPEID_PLAYER && victim->ToPlayer()->IsGameMaster())
 hostileRef->setOnlineOfflineState(false); // GM is always offline
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ThreatManager::addThreat	(	Unit *	victim,
		float	threat,
		SpellSchoolMask	schoolMask = SPELL_SCHOOL_MASK_NORMAL,
		SpellInfo const *	threatSpell = NULL
	)

{
 if (!ThreatCalcHelper::isValidProcess(victim, GetOwner(), threatSpell))
 return;

 doAddThreat(victim, ThreatCalcHelper::calcThreat(victim, iOwner, threat, schoolMask, threatSpell));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ThreatManager::clearReferences

(

)

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

Here is the call graph for this function:

Here is the caller graph for this function:

void ThreatManager::doAddThreat	(	Unit *	victim,
		float	threat
	)

{
 uint32 redirectThreadPct = victim->GetRedirectThreatPercent();

 // must check > 0.0f, otherwise dead loop
 if (threat > 0.0f && redirectThreadPct)
 {
 if (Unit* redirectTarget = victim->GetRedirectThreatTarget())
 {
 float redirectThreat = CalculatePct(threat, redirectThreadPct);
 threat -= redirectThreat;
 _addThreat(redirectTarget, redirectThreat);
 }
 }

 _addThreat(victim, threat);
}

Here is the call graph for this function:

Here is the caller graph for this function:

HostileReference* ThreatManager::getCurrentVictim ( ) const

inline

{ return iCurrentVictim; }

Here is the caller graph for this function:

Unit * ThreatManager::getHostilTarget

(

)

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

Here is the call graph for this function:

Here is the caller graph for this function:

ThreatContainer& ThreatManager::getOfflineContainer ( )

inline

{ return iThreatOfflineContainer; }

ThreatContainer::StorageType const& ThreatManager::getOfflineThreatList ( ) const

inline

{ return iThreatOfflineContainer.getThreatList(); }

Here is the caller graph for this function:

ThreatContainer& ThreatManager::getOnlineContainer ( )

inline

{ return iThreatContainer; }

Here is the caller graph for this function:

Unit* ThreatManager::GetOwner ( ) const

inline

{ return iOwner; }

Here is the caller graph for this function:

float ThreatManager::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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ThreatContainer::StorageType const& ThreatManager::getThreatList ( ) const

inline

{ return iThreatContainer.getThreatList(); }

bool ThreatManager::isNeedUpdateToClient

(

uint32

time

)

{
 if (isThreatListEmpty())
 return false;

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

Here is the call graph for this function:

bool ThreatManager::isThreatListEmpty ( ) const

inline

{ return iThreatContainer.empty(); }

Here is the caller graph for this function:

void ThreatManager::modifyThreatPercent	(	Unit *	victim,
		int32	percent
	)

{
 iThreatContainer.modifyThreatPercent(victim, percent);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ThreatManager::processThreatEvent

(

ThreatRefStatusChangeEvent *

threatRefStatusChangeEvent

)

{
 threatRefStatusChangeEvent->setThreatManager(this); // now we can set the threat manager

 HostileReference* hostilRef = threatRefStatusChangeEvent->getReference();

 switch (threatRefStatusChangeEvent->getType())
 {
 case UEV_THREAT_REF_THREAT_CHANGE:
 if ((getCurrentVictim() == hostilRef && threatRefStatusChangeEvent->getFValue()<0.0f) ||
 (getCurrentVictim() != hostilRef && threatRefStatusChangeEvent->getFValue()>0.0f))
 setDirty(true); // the order in the threat list might have changed
 break;
 case UEV_THREAT_REF_ONLINE_STATUS:
 if (!hostilRef->isOnline())
 {
 if (hostilRef == getCurrentVictim())
 {
 setCurrentVictim(NULL);
 setDirty(true);
 }
 iOwner->SendRemoveFromThreatListOpcode(hostilRef);
 iThreatContainer.remove(hostilRef);
 iThreatOfflineContainer.addReference(hostilRef);
 }
 else
 {
 if (getCurrentVictim() && hostilRef->getThreat() > (1.1f * getCurrentVictim()->getThreat()))
 setDirty(true);
 iThreatContainer.addReference(hostilRef);
 iThreatOfflineContainer.remove(hostilRef);
 }
 break;
 case UEV_THREAT_REF_REMOVE_FROM_LIST:
 if (hostilRef == getCurrentVictim())
 {
 setCurrentVictim(NULL);
 setDirty(true);
 }
 iOwner->SendRemoveFromThreatListOpcode(hostilRef);
 if (hostilRef->isOnline())
 iThreatContainer.remove(hostilRef);
 else
 iThreatOfflineContainer.remove(hostilRef);
 break;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class PREDICATE >

void ThreatManager::resetAggro ( PREDICATE  predicate )

inline

 {
 ThreatContainer::StorageType &threatList = iThreatContainer.iThreatList;
 if (threatList.empty())
 return;

 for (ThreatContainer::StorageType::iterator itr = threatList.begin(); itr != threatList.end(); ++itr)
 {
 HostileReference* ref = (*itr);

 if (predicate(ref->getTarget()))
 {
 ref->setThreat(0);
 setDirty(true);
 }
 }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ThreatManager::resetAllAggro

(

)

{
 ThreatContainer::StorageType &threatList = iThreatContainer.iThreatList;
 if (threatList.empty())
 return;

 for (ThreatContainer::StorageType::iterator itr = threatList.begin(); itr != threatList.end(); ++itr)
 (*itr)->setThreat(0);

 setDirty(true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ThreatManager::setCurrentVictim

(

HostileReference *

hostileRef

)

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

Here is the call graph for this function:

Here is the caller graph for this function:

void ThreatManager::setDirty ( bool  isDirty )

inline

{ iThreatContainer.setDirty(isDirty); }

Here is the caller graph for this function:

void ThreatManager::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());
 }
}

Here is the call graph for this function:

void ThreatManager::tauntFadeOut

(

Unit *

taunter

)

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

Here is the call graph for this function:

Friends And Related Function Documentation

friend class HostileReference

friend

Member Data Documentation

HostileReference* ThreatManager::iCurrentVictim

private

Unit* ThreatManager::iOwner

private

ThreatContainer ThreatManager::iThreatContainer

private

ThreatContainer ThreatManager::iThreatOfflineContainer

private

uint32 ThreatManager::iUpdateTimer

private

---

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

• src/server/game/Combat/ThreatManager.h
• src/server/game/Combat/ThreatManager.cpp