ThreatContainer Class Reference

#include "ThreatMgr.h"

Public Types
typedef std::list< HostileReference * >	StorageType

Public Member Functions
	ThreatContainer ()=default
	~ThreatContainer ()
HostileReference *	AddThreat (Unit *victim, float threat)
void	ModifyThreatByPercent (Unit *victim, int32 percent)
HostileReference *	SelectNextVictim (Creature *attacker, HostileReference *currentVictim) const
HostileReference *	SelectNextVictimTieBreaker (Creature *attacker, ThreatContainer::StorageType::const_iterator currentIter, bool noPriorityTargetFound) const
bool	IsPreferredTarget (Creature *attacker, Unit *target) const
void	setDirty (bool isDirty)
bool	isDirty () const
bool	empty () const
HostileReference *	getMostHated () const
HostileReference *	getReferenceByTarget (Unit const *victim) const
HostileReference *	getReferenceByTarget (ObjectGuid const &guid) const
StorageType const &	GetThreatList () const

Private Member Functions
void	remove (HostileReference *hostileRef)
void	addReference (HostileReference *hostileRef)
void	clearReferences ()
void	update ()

Private Attributes
StorageType	iThreatList
bool	iDirty {false}

Friends
class	ThreatMgr

Detailed Description

Member Typedef Documentation

StorageType

typedef std::list<HostileReference*> ThreatContainer::StorageType

Constructor & Destructor Documentation

ThreatContainer()

ThreatContainer::ThreatContainer ( )

default

~ThreatContainer()

ThreatContainer::~ThreatContainer ( )

inline

{ clearReferences(); }

References clearReferences().

Member Function Documentation

addReference()

void ThreatContainer::addReference ( HostileReference *  hostileRef )

inlineprivate

    {
        iThreatList.push_back(hostileRef);
    }

References iThreatList.

Referenced by ThreatMgr::_addThreat(), and ThreatMgr::processThreatEvent().

AddThreat()

HostileReference * ThreatContainer::AddThreat	(	Unit *	victim,
		float	threat
	)

{
    HostileReference* ref = getReferenceByTarget(victim);
    if (ref)
        ref->AddThreat(threat);
    return ref;
}

References HostileReference::AddThreat(), and getReferenceByTarget().

Referenced by ThreatMgr::_addThreat().

clearReferences()

void ThreatContainer::clearReferences ( )

private

{
    for (ThreatContainer::StorageType::const_iterator i = iThreatList.begin(); i != iThreatList.end(); ++i)
    {
        (*i)->unlink();
        delete (*i);
    }
 
    iThreatList.clear();
}

References iThreatList.

Referenced by ThreatMgr::clearReferences(), and ~ThreatContainer().

empty()

bool ThreatContainer::empty ( ) const

inline

    {
        return iThreatList.empty();
    }

References iThreatList.

Referenced by ThreatMgr::areThreatListsEmpty(), Spell::EffectTaunt(), and ThreatMgr::isThreatListEmpty().

getMostHated()

HostileReference * ThreatContainer::getMostHated ( ) const

inline

    {
        return iThreatList.empty() ? nullptr : iThreatList.front();
    }

References iThreatList.

Referenced by Spell::EffectTaunt().

getReferenceByTarget() [1/2]

HostileReference * ThreatContainer::getReferenceByTarget

(

ObjectGuid const &

guid

)

const

{
    for (ThreatContainer::StorageType::const_iterator i = iThreatList.begin(); i != iThreatList.end(); ++i)
    {
        HostileReference* ref = (*i);
        if (ref && ref->getUnitGuid() == guid)
        {
            return ref;
        }
    }
 
    return nullptr;
}

References HostileReference::getUnitGuid(), and iThreatList.

getReferenceByTarget() [2/2]

HostileReference * ThreatContainer::getReferenceByTarget

(

Unit const *

victim

)

const

{
    if (!victim)
        return nullptr;
 
    return getReferenceByTarget(victim->GetGUID());
}

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

Referenced by AddThreat(), Spell::EffectTaunt(), ThreatMgr::FindReference(), getReferenceByTarget(), ThreatMgr::GetThreat(), ThreatMgr::getThreatWithoutTemp(), ModifyThreatByPercent(), boss_priestess_lackey_commonAI::RecalculateThreat(), boss_faction_championsAI::RecalculateThreat(), ThreatMgr::tauntApply(), and ThreatMgr::tauntFadeOut().

GetThreatList()

StorageType const & ThreatContainer::GetThreatList ( ) const

inline

{ return iThreatList; }

References iThreatList.

Referenced by boss_hazzarah::CanAIAttack(), boss_renataki::boss_renatakiAI::CanAIAttack(), ThreatMgr::GetOfflineThreatList(), ThreatMgr::GetSortedThreatList(), and ThreatMgr::GetThreatList().

isDirty()

bool ThreatContainer::isDirty ( ) const

inline

{ return iDirty; }

References iDirty.

Referenced by setDirty().

IsPreferredTarget()

bool ThreatContainer::IsPreferredTarget	(	Creature *	attacker,
		Unit *	target
	)		const

{
    if (target->IsImmunedToDamageOrSchool(attacker->GetMeleeDamageSchoolMask()))
        return false;
 
    if (target->HasNegativeAuraWithInterruptFlag(AURA_INTERRUPT_FLAG_TAKE_DAMAGE))
        return false;
 
    if (target->HasUnitState(UNIT_STATE_CONFUSED))
        return false;
 
    if (target->HasAuraTypeWithCaster(SPELL_AURA_IGNORED, attacker->GetGUID()))
        return false;
 
    if (attacker->HasUnitState(UNIT_STATE_ROOT) && attacker->IsCombatMovementAllowed() && !attacker->IsWithinMeleeRange(target))
        return false;
 
    return true;
}

References AURA_INTERRUPT_FLAG_TAKE_DAMAGE, Object::GetGUID(), Creature::GetMeleeDamageSchoolMask(), Unit::HasAuraTypeWithCaster(), Unit::HasNegativeAuraWithInterruptFlag(), Unit::HasUnitState(), Creature::IsCombatMovementAllowed(), Unit::IsImmunedToDamageOrSchool(), Unit::IsWithinMeleeRange(), SPELL_AURA_IGNORED, UNIT_STATE_CONFUSED, and UNIT_STATE_ROOT.

Referenced by SelectNextVictim(), and SelectNextVictimTieBreaker().

ModifyThreatByPercent()

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

{
    if (HostileReference* ref = getReferenceByTarget(victim))
        ref->addThreatPercent(percent);
}

References HostileReference::addThreatPercent(), and getReferenceByTarget().

Referenced by ThreatMgr::ModifyThreatByPercent().

remove()

void ThreatContainer::remove ( HostileReference *  hostileRef )

inlineprivate

    {
        iThreatList.remove(hostileRef);
    }

References iThreatList.

Referenced by ThreatMgr::processThreatEvent().

SelectNextVictim()

HostileReference * ThreatContainer::SelectNextVictim	(	Creature *	attacker,
		HostileReference *	currentVictim
	)		const

{
    // pussywizard: pretty much remade this whole function
 
    HostileReference* currentRef = nullptr;
    bool found = false;
    bool noPriorityTargetFound = false;
 
    // pussywizard: currentVictim is needed to compare if threat was exceeded by 10%/30% for melee/range targets (only then switching current target)
    if (currentVictim)
    {
        Unit* cvUnit = currentVictim->getTarget();
        if (!attacker->CanCreatureAttack(cvUnit)) // pussywizard: if currentVictim is not valid => don't compare the threat with it, just take the highest threat valid target
            currentVictim = nullptr;
        else if (!IsPreferredTarget(attacker, cvUnit)) // pussywizard: no 10%/30% if currentVictim is immune to damage or has auras breakable by damage
            currentVictim = nullptr;
    }
 
    ThreatContainer::StorageType::const_iterator lastRef = iThreatList.end();
    --lastRef;
 
    // pussywizard: iterate from highest to lowest threat
    for (ThreatContainer::StorageType::const_iterator iter = iThreatList.begin(); iter != iThreatList.end() && !found;)
    {
        currentRef = (*iter);
 
        Unit* target = currentRef->getTarget();
        ASSERT(target); // if the ref has status online the target must be there !
 
        // pussywizard: don't go to threat comparison if this ref is immune to damage or has aura breakable on damage (second choice target)
        // pussywizard: if this is the last entry on the threat list, then all targets are second choice, set bool to true and loop threat list again, ignoring this section
        if (!noPriorityTargetFound && !IsPreferredTarget(attacker, target))
        {
            if (iter != lastRef)
            {
                ++iter;
                continue;
            }
            else
            {
                noPriorityTargetFound = true;
                iter = iThreatList.begin();
                continue;
            }
        }
 
        // pussywizard: skip not valid targets
        if (attacker->CanCreatureAttack(target))
        {
            if (currentVictim) // pussywizard: if not nullptr then target must have 10%/30% more threat
            {
                if (currentVictim == currentRef) // pussywizard: nothing found previously was good and enough, currentRef passed all necessary tests, so end now
                {
                    found = true;
                    break;
                }
 
                // pussywizard: implement 110% threat rule for targets in melee range and 130% rule for targets in ranged distances
                if (currentRef->GetThreat() > 1.3f * currentVictim->GetThreat()) // pussywizard: enough in all cases, end
                {
                    found = true;
                    break;
                }
                else if (currentRef->GetThreat() > 1.1f * currentVictim->GetThreat()) // pussywizard: enought only if target in melee range
                {
                    if (attacker->IsWithinMeleeRange(target))
                    {
                        found = true;
                        break;
                    }
                }
                else // pussywizard: nothing found previously was good and enough, this and next entries on the list have less than 110% threat, and currentVictim is present and valid as checked before the loop (otherwise it's nullptr), so end now
                {
                    currentRef = currentVictim;
                    found = true;
                    break;
                }
            }
            else // pussywizard: no currentVictim, first passing all checks is chosen (highest threat, list is sorted)
            {
                // tie-breaker if multiple targets have the same threat: select closest target
                currentRef = SelectNextVictimTieBreaker(attacker, iter, noPriorityTargetFound);
                found = true;
                break;
            }
        }
        ++iter;
    }
    if (!found)
        currentRef = nullptr;
 
    return currentRef;
}

References ASSERT, Creature::CanCreatureAttack(), Reference< TO, FROM >::getTarget(), HostileReference::GetThreat(), IsPreferredTarget(), Unit::IsWithinMeleeRange(), iThreatList, and SelectNextVictimTieBreaker().

Referenced by ThreatMgr::getHostileTarget().

SelectNextVictimTieBreaker()

HostileReference * ThreatContainer::SelectNextVictimTieBreaker	(	Creature *	attacker,
		ThreatContainer::StorageType::const_iterator	currentIter,
		bool	noPriorityTargetFound
	)		const

{
    HostileReference* bestRef = *currentIter;
    float bestThreat = bestRef->GetThreat();
    float shortestDistSq = attacker->GetExactDistSq(bestRef->getTarget());
 
    auto tieIter = std::next(currentIter);
 
    while (tieIter != iThreatList.end())
    {
        HostileReference* nextRef = *tieIter;
 
        if (!nextRef)
        {
            ++tieIter;
            continue;
        }
 
        // Threatlist is sorted, so we can stop as soon as we find a lower threat
        if (bestThreat - nextRef->GetThreat() > 0.01f)
            break;
 
        Unit* target = nextRef->getTarget();
 
        if (!target)
        {
            ++tieIter;
            continue;
        }
 
        if (attacker->CanCreatureAttack(target) && (noPriorityTargetFound || IsPreferredTarget(attacker, target)))
        {
            float distSq = attacker->GetExactDistSq(target);
            if (distSq < shortestDistSq)
            {
                bestRef = nextRef;
                shortestDistSq = distSq;
            }
        }
        ++tieIter;
    }
    return bestRef;
}

References Creature::CanCreatureAttack(), Position::GetExactDistSq(), Reference< TO, FROM >::getTarget(), HostileReference::GetThreat(), IsPreferredTarget(), and iThreatList.

Referenced by SelectNextVictim().

setDirty()

void ThreatContainer::setDirty ( bool  isDirty )

inline

{ iDirty = isDirty; }

References iDirty, and isDirty().

Referenced by ThreatMgr::setDirty().

update()

void ThreatContainer::update ( )

private

{
    if (iDirty && iThreatList.size() > 1)
        iThreatList.sort(Acore::ThreatOrderPred());
 
    iDirty = false;
}

References iDirty, and iThreatList.

Referenced by ThreatMgr::getHostileTarget().

Friends And Related Symbol Documentation

ThreatMgr

friend class ThreatMgr

friend

Member Data Documentation

iDirty

bool ThreatContainer::iDirty {false}

private

{false};

Referenced by isDirty(), setDirty(), and update().

iThreatList

StorageType ThreatContainer::iThreatList

private

Referenced by addReference(), clearReferences(), empty(), getMostHated(), getReferenceByTarget(), GetThreatList(), remove(), ThreatMgr::resetAggro(), ThreatMgr::ResetAllThreat(), SelectNextVictim(), SelectNextVictimTieBreaker(), and update().

---

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