Aura Class Reference

#include <SpellAuras.h>

Public Types
typedef std::map< ObjectGuid, AuraApplication * >	ApplicationMap

Public Member Functions
	Aura (SpellInfo const *spellproto, WorldObject *owner, Unit *caster, Item *castItem, ObjectGuid casterGUID, int32 castItemLevel)
void	_InitEffects (uint32 effMask, Unit *caster, int32 *baseAmount)
virtual	~Aura ()
SpellInfo const *	GetSpellInfo () const
uint32	GetId () const
ObjectGuid	GetCastItemGUID () const
int32	GetCastItemLevel () const
ObjectGuid	GetCasterGUID () const
Unit *	GetCaster () const
WorldObject *	GetOwner () const
Unit *	GetUnitOwner () const
DynamicObject *	GetDynobjOwner () const
AuraObjectType	GetType () const
virtual void	_ApplyForTarget (Unit *target, Unit *caster, AuraApplication *auraApp)
virtual void	_UnapplyForTarget (Unit *target, Unit *caster, AuraApplication *auraApp)
void	_Remove (AuraRemoveMode removeMode)
virtual void	Remove (AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)=0
virtual void	FillTargetMap (std::map< Unit *, uint32 > &targets, Unit *caster)=0
void	UpdateTargetMap (Unit *caster, bool apply=true)
void	_RegisterForTargets ()
void	ApplyForTargets ()
void	_ApplyEffectForTargets (uint8 effIndex)
void	UpdateOwner (uint32 diff, WorldObject *owner)
void	Update (uint32 diff, Unit *caster)
time_t	GetApplyTime () const
int32	GetMaxDuration () const
void	SetMaxDuration (int32 duration)
int32	CalcMaxDuration () const
int32	CalcMaxDuration (Unit *caster) const
int32	GetDuration () const
void	SetDuration (int32 duration, bool withMods=false)
void	RefreshDuration (bool withMods=false)
void	RefreshTimers ()
bool	IsExpired () const
bool	IsPermanent () const
uint8	GetCharges () const
void	SetCharges (uint8 charges)
uint8	CalcMaxCharges (Unit *caster) const
uint8	CalcMaxCharges () const
bool	ModCharges (int32 num, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)
bool	DropCharge (AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)
void	ModChargesDelayed (int32 num, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)
void	DropChargeDelayed (uint32 delay, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)
uint8	GetStackAmount () const
void	SetStackAmount (uint8 num)
bool	ModStackAmount (int32 num, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)
void	RefreshSpellMods ()
uint8	GetCasterLevel () const
bool	HasMoreThanOneEffectForType (AuraType auraType) const
bool	IsArea () const
bool	IsPassive () const
bool	IsDeathPersistent () const
bool	IsRemovedOnShapeLost (Unit *target) const
bool	CanBeSaved () const
bool	IsRemoved () const
bool	CanBeSentToClient () const
bool	IsSingleTarget () const
bool	IsSingleTargetWith (Aura const *aura) const
void	SetIsSingleTarget (bool val)
void	UnregisterSingleTarget ()
int32	CalcDispelChance (Unit *auraTarget, bool offensive) const
AuraKey	GenerateKey (uint32 &recalculateMask) const
	Fills a helper structure containing aura primary key for character_aura, character_aura_effect, pet_aura, pet_aura_effect tables. More...
void	SetLoadedState (int32 maxDuration, int32 duration, int32 charges, uint8 stackAmount, uint32 recalculateMask, int32 *amount)
bool	HasEffect (uint8 effIndex) const
bool	HasEffectType (AuraType type) const
AuraEffect *	GetEffect (uint32 index) const
uint32	GetEffectMask () const
void	RecalculateAmountOfEffects ()
void	HandleAllEffects (AuraApplication *aurApp, uint8 mode, bool apply)
ApplicationMap const &	GetApplicationMap ()
void	GetApplicationList (Unit::AuraApplicationList &applicationList) const
const AuraApplication *	GetApplicationOfTarget (ObjectGuid guid) const
AuraApplication *	GetApplicationOfTarget (ObjectGuid guid)
bool	IsAppliedOnTarget (ObjectGuid guid) const
void	SetNeedClientUpdateForTargets () const
void	HandleAuraSpecificMods (AuraApplication const *aurApp, Unit *caster, bool apply, bool onReapply)
void	HandleAuraSpecificPeriodics (AuraApplication const *aurApp, Unit *caster)
bool	CanBeAppliedOn (Unit *target)
bool	CheckAreaTarget (Unit *target)
bool	CanStackWith (Aura const *existingAura) const
bool	IsProcOnCooldown () const
void	AddProcCooldown (uint32 msec)
bool	IsUsingCharges () const
void	SetUsingCharges (bool val)
void	PrepareProcToTrigger (AuraApplication *aurApp, ProcEventInfo &eventInfo)
bool	IsProcTriggeredOnEvent (AuraApplication *aurApp, ProcEventInfo &eventInfo) const
float	CalcProcChance (SpellProcEntry const &procEntry, ProcEventInfo &eventInfo) const
void	TriggerProcOnEvent (AuraApplication *aurApp, ProcEventInfo &eventInfo)
void	LoadScripts ()
bool	CallScriptCheckAreaTargetHandlers (Unit *target)
void	CallScriptDispel (DispelInfo *dispelInfo)
void	CallScriptAfterDispel (DispelInfo *dispelInfo)
bool	CallScriptEffectApplyHandlers (AuraEffect const *aurEff, AuraApplication const *aurApp, AuraEffectHandleModes mode)
bool	CallScriptEffectRemoveHandlers (AuraEffect const *aurEff, AuraApplication const *aurApp, AuraEffectHandleModes mode)
void	CallScriptAfterEffectApplyHandlers (AuraEffect const *aurEff, AuraApplication const *aurApp, AuraEffectHandleModes mode)
void	CallScriptAfterEffectRemoveHandlers (AuraEffect const *aurEff, AuraApplication const *aurApp, AuraEffectHandleModes mode)
bool	CallScriptEffectPeriodicHandlers (AuraEffect const *aurEff, AuraApplication const *aurApp)
void	CallScriptEffectUpdatePeriodicHandlers (AuraEffect *aurEff)
void	CallScriptEffectCalcAmountHandlers (AuraEffect const *aurEff, int32 &amount, bool &canBeRecalculated)
void	CallScriptEffectCalcPeriodicHandlers (AuraEffect const *aurEff, bool &isPeriodic, int32 &amplitude)
void	CallScriptEffectCalcSpellModHandlers (AuraEffect const *aurEff, SpellModifier *&spellMod)
void	CallScriptEffectAbsorbHandlers (AuraEffect *aurEff, AuraApplication const *aurApp, DamageInfo &dmgInfo, uint32 &absorbAmount, bool &defaultPrevented)
void	CallScriptEffectAfterAbsorbHandlers (AuraEffect *aurEff, AuraApplication const *aurApp, DamageInfo &dmgInfo, uint32 &absorbAmount)
void	CallScriptEffectManaShieldHandlers (AuraEffect *aurEff, AuraApplication const *aurApp, DamageInfo &dmgInfo, uint32 &absorbAmount, bool &defaultPrevented)
void	CallScriptEffectAfterManaShieldHandlers (AuraEffect *aurEff, AuraApplication const *aurApp, DamageInfo &dmgInfo, uint32 &absorbAmount)
void	CallScriptEffectSplitHandlers (AuraEffect *aurEff, AuraApplication const *aurApp, DamageInfo &dmgInfo, uint32 &splitAmount)
bool	CallScriptCheckProcHandlers (AuraApplication const *aurApp, ProcEventInfo &eventInfo)
bool	CallScriptPrepareProcHandlers (AuraApplication const *aurApp, ProcEventInfo &eventInfo)
bool	CallScriptProcHandlers (AuraApplication const *aurApp, ProcEventInfo &eventInfo)
void	CallScriptAfterProcHandlers (AuraApplication const *aurApp, ProcEventInfo &eventInfo)
bool	CallScriptEffectProcHandlers (AuraEffect const *aurEff, AuraApplication const *aurApp, ProcEventInfo &eventInfo)
void	CallScriptAfterEffectProcHandlers (AuraEffect const *aurEff, AuraApplication const *aurApp, ProcEventInfo &eventInfo)
AuraScript *	GetScriptByName (std::string const &scriptName) const
AuraEffectVector	GetAuraEffects () const
SpellEffectInfoVector	GetSpellEffectInfos () const
SpellEffectInfo const *	GetSpellEffectInfo (uint32 index) const

Static Public Member Functions
static uint32	BuildEffectMaskForOwner (SpellInfo const *spellProto, uint32 avalibleEffectMask, WorldObject *owner)
static Aura *	TryRefreshStackOrCreate (SpellInfo const *spellproto, uint32 tryEffMask, WorldObject *owner, Unit *caster, int32 *baseAmount=NULL, Item *castItem=NULL, ObjectGuid casterGUID=ObjectGuid::Empty, bool *refresh=NULL, int32 castItemLevel=-1)
static Aura *	TryCreate (SpellInfo const *spellproto, uint32 tryEffMask, WorldObject *owner, Unit *caster, int32 *baseAmount, Item *castItem=NULL, ObjectGuid casterGUID=ObjectGuid::Empty, int32 castItemLevel=-1)
static Aura *	Create (SpellInfo const *spellproto, uint32 effMask, WorldObject *owner, Unit *caster, int32 *baseAmount, Item *castItem, ObjectGuid casterGUID, int32 castItemLevel)

Public Attributes
std::list< AuraScript * >	m_loadedScripts

Protected Attributes
SpellInfo const *const	m_spellInfo
ObjectGuid const	m_casterGuid
ObjectGuid const	m_castItemGuid
int32	m_castItemLevel
time_t const	m_applyTime
WorldObject *const	m_owner
int32	m_maxDuration
int32	m_duration
int32	m_timeCla
std::vector< SpellPowerEntry const * >	m_periodicCosts
int32	m_updateTargetMapInterval
uint8 const	m_casterLevel
uint8	m_procCharges
uint8	m_stackAmount
ApplicationMap	m_applications
bool	m_isRemoved:1
bool	m_isSingleTarget:1
bool	m_isUsingCharges:1
ChargeDropEvent *	m_dropEvent

Private Member Functions
void	_DeleteRemovedApplications ()

Private Attributes
Unit::AuraApplicationList	m_removedApplications
AuraEffectVector	_effects
SpellEffectInfoVector	_spelEffectInfos

Friends
Aura *	Unit::_TryStackingOrRefreshingExistingAura (SpellInfo const *newAura, uint32 effMask, Unit *caster, int32 *baseAmount, Item *castItem, ObjectGuid casterGUID, int32 castItemLevel)

Member Typedef Documentation

typedef std::map<ObjectGuid, AuraApplication*> Aura::ApplicationMap

Constructor & Destructor Documentation

Aura::Aura	(	SpellInfo const *	spellproto,
		WorldObject *	owner,
		Unit *	caster,
		Item *	castItem,
		ObjectGuid	casterGUID,
		int32	castItemLevel
	)

 :
m_spellInfo(spellproto), m_casterGuid(!casterGUID.IsEmpty() ? casterGUID : caster->GetGUID()),
m_castItemGuid(castItem ? castItem->GetGUID() : ObjectGuid::Empty), m_castItemLevel(castItemLevel),
m_applyTime(time(NULL)), m_owner(owner), m_timeCla(0), m_updateTargetMapInterval(0),
m_casterLevel(caster ? caster->getLevel() : m_spellInfo->SpellLevel), m_procCharges(0), m_stackAmount(1),
m_isRemoved(false), m_isSingleTarget(false), m_isUsingCharges(false), m_dropEvent(nullptr)
{
 std::vector<SpellPowerEntry const*> powers = sDB2Manager.GetSpellPowers(GetId(), caster ? caster->GetMap()->GetDifficultyID() : DIFFICULTY_NONE);
 for (SpellPowerEntry const* power : powers)
 if (power->ManaCostPerSecond != 0 || power->ManaCostPercentagePerSecond > 0.0f)
 m_periodicCosts.push_back(power);

 if (!m_periodicCosts.empty())
 m_timeCla = 1 * IN_MILLISECONDS;

 m_maxDuration = CalcMaxDuration(caster);
 m_duration = m_maxDuration;
 m_procCharges = CalcMaxCharges(caster);
 m_isUsingCharges = m_procCharges != 0;
 // m_casterLevel = cast item level/caster level, caster level should be saved to db, confirmed with sniffs
}

Here is the call graph for this function:

Aura::~Aura ( )

virtual

{
 // unload scripts
 while (!m_loadedScripts.empty())
 {
 std::list<AuraScript*>::iterator itr = m_loadedScripts.begin();
 (*itr)->_Unload();
 delete (*itr);
 m_loadedScripts.erase(itr);
 }

 for (AuraEffect* effect : _effects)
 delete effect;

 ASSERT(m_applications.empty());
 _DeleteRemovedApplications();
}

Here is the call graph for this function:

Member Function Documentation

void Aura::_ApplyEffectForTargets

(

uint8

effIndex

)

{
 // prepare list of aura targets
 UnitList targetList;
 for (ApplicationMap::iterator appIter = m_applications.begin(); appIter != m_applications.end(); ++appIter)
 {
 if ((appIter->second->GetEffectsToApply() & (1 << effIndex)) && !appIter->second->HasEffect(effIndex))
 targetList.push_back(appIter->second->GetTarget());
 }

 // apply effect to targets
 for (UnitList::iterator itr = targetList.begin(); itr != targetList.end(); ++itr)
 {
 if (GetApplicationOfTarget((*itr)->GetGUID()))
 {
 // owner has to be in world, or effect has to be applied to self
 ASSERT((!GetOwner()->IsInWorld() && GetOwner() == *itr) || GetOwner()->IsInMap(*itr));
 (*itr)->_ApplyAuraEffect(this, effIndex);
 }
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::_ApplyForTarget ( Unit *  target, Unit *  caster, AuraApplication *  auraApp  )

virtual

Reimplemented in UnitAura.

{
 ASSERT(target);
 ASSERT(auraApp);
 // aura mustn't be already applied on target
 ASSERT (!IsAppliedOnTarget(target->GetGUID()) && "Aura::_ApplyForTarget: aura musn't be already applied on target");

 m_applications[target->GetGUID()] = auraApp;

 // set infinity cooldown state for spells
 if (caster && caster->GetTypeId() == TYPEID_PLAYER)
 {
 if (m_spellInfo->IsCooldownStartedOnEvent())
 {
 Item* castItem = !m_castItemGuid.IsEmpty() ? caster->ToPlayer()->GetItemByGuid(m_castItemGuid) : NULL;
 caster->GetSpellHistory()->StartCooldown(m_spellInfo, castItem ? castItem->GetEntry() : 0, nullptr, true);
 }
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::_DeleteRemovedApplications ( )

private

{
 while (!m_removedApplications.empty())
 {
 delete m_removedApplications.front();
 m_removedApplications.pop_front();
 }
}

Here is the caller graph for this function:

void Aura::_InitEffects	(	uint32	effMask,
		Unit *	caster,
		int32 *	baseAmount
	)

{
 // shouldn't be in constructor - functions in AuraEffect::AuraEffect use polymorphism
 _spelEffectInfos = m_spellInfo->GetEffectsForDifficulty(GetOwner()->GetMap()->GetDifficultyID());

 ASSERT(!_spelEffectInfos.empty());

 _effects.resize(GetSpellEffectInfos().size());

 for (SpellEffectInfo const* effect : GetSpellEffectInfos())
 {
 if (effect && effMask & (1 << effect->EffectIndex))
 _effects[effect->EffectIndex] = new AuraEffect(this, effect->EffectIndex, baseAmount ? baseAmount + effect->EffectIndex : NULL, caster);
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::_RegisterForTargets ( )

inline

{Unit* caster = GetCaster(); UpdateTargetMap(caster, false);}

Here is the caller graph for this function:

void Aura::_Remove

(

AuraRemoveMode

removeMode

)

{
 ASSERT (!m_isRemoved);
 m_isRemoved = true;
 ApplicationMap::iterator appItr = m_applications.begin();
 for (appItr = m_applications.begin(); appItr != m_applications.end();)
 {
 AuraApplication * aurApp = appItr->second;
 Unit* target = aurApp->GetTarget();
 target->_UnapplyAura(aurApp, removeMode);
 appItr = m_applications.begin();
 }

 if (m_dropEvent)
 {
 m_dropEvent->to_Abort = true;
 m_dropEvent = nullptr;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::_UnapplyForTarget ( Unit *  target, Unit *  caster, AuraApplication *  auraApp  )

virtual

Todo:

Figure out why this happens

Reimplemented in UnitAura.

{
 ASSERT(target);
 ASSERT(auraApp->GetRemoveMode());
 ASSERT(auraApp);

 ApplicationMap::iterator itr = m_applications.find(target->GetGUID());

 if (itr == m_applications.end())
 {
 TC_LOG_ERROR("spells", "Aura::_UnapplyForTarget, target: %s, caster:%s, spell:%u was not found in owners application map!",
 target->GetGUID().ToString().c_str(), caster ? caster->GetGUID().ToString().c_str() : "Empty", auraApp->GetBase()->GetSpellInfo()->Id);
 ABORT();
 }

 // aura has to be already applied
 ASSERT(itr->second == auraApp);
 m_applications.erase(itr);

 m_removedApplications.push_back(auraApp);

 // reset cooldown state for spells
 if (caster && GetSpellInfo()->IsCooldownStartedOnEvent())
 // note: item based cooldowns and cooldown spell mods with charges ignored (unknown existed cases)
 caster->GetSpellHistory()->SendCooldownEvent(GetSpellInfo());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::AddProcCooldown

(

uint32

msec

)

{
 //m_procCooldown = time(NULL) + msec;
}

Here is the caller graph for this function:

void Aura::ApplyForTargets ( )

inline

{Unit* caster = GetCaster(); UpdateTargetMap(caster, true);}

uint32 Aura::BuildEffectMaskForOwner ( SpellInfo const *  spellProto, uint32  avalibleEffectMask, WorldObject *  owner  )

static

{
 ASSERT(spellProto);
 ASSERT(owner);
 uint32 effMask = 0;
 switch (owner->GetTypeId())
 {
 case TYPEID_UNIT:
 case TYPEID_PLAYER:
 for (SpellEffectInfo const* effect : spellProto->GetEffectsForDifficulty(owner->GetMap()->GetDifficultyID()))
 {
 if (effect && effect->IsUnitOwnedAuraEffect())
 effMask |= 1 << effect->EffectIndex;
 }
 break;
 case TYPEID_DYNAMICOBJECT:
 for (SpellEffectInfo const* effect : spellProto->GetEffectsForDifficulty(owner->GetMap()->GetDifficultyID()))
 {
 if (effect && effect->Effect == SPELL_EFFECT_PERSISTENT_AREA_AURA)
 effMask |= 1 << effect->EffectIndex;
 }
 break;
 default:
 break;
 }
 return effMask & avalibleEffectMask;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Aura::CalcDispelChance	(	Unit *	auraTarget,
		bool	offensive
	)		const

{
 // we assume that aura dispel chance is 100% on start
 // need formula for level difference based chance
 int32 resistChance = 0;

 // Apply dispel mod from aura caster
 if (Unit* caster = GetCaster())
 if (Player* modOwner = caster->GetSpellModOwner())
 modOwner->ApplySpellMod(GetId(), SPELLMOD_RESIST_DISPEL_CHANCE, resistChance);

 // Dispel resistance from target SPELL_AURA_MOD_DISPEL_RESIST
 // Only affects offensive dispels
 if (offensive && auraTarget)
 resistChance += auraTarget->GetTotalAuraModifier(SPELL_AURA_MOD_DISPEL_RESIST);

 RoundToInterval(resistChance, 0, 100);
 return 100 - resistChance;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8 Aura::CalcMaxCharges

(

Unit *

caster

)

const

{
 uint32 maxProcCharges = m_spellInfo->ProcCharges;
 if (SpellProcEntry const* procEntry = sSpellMgr->GetSpellProcEntry(GetId()))
 maxProcCharges = procEntry->charges;

 if (caster)
 if (Player* modOwner = caster->GetSpellModOwner())
 modOwner->ApplySpellMod(GetId(), SPELLMOD_CHARGES, maxProcCharges);

 return uint8(maxProcCharges);
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8 Aura::CalcMaxCharges ( ) const

inline

{ return CalcMaxCharges(GetCaster()); }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Aura::CalcMaxDuration ( ) const

inline

{ return CalcMaxDuration(GetCaster()); }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Aura::CalcMaxDuration

(

Unit *

caster

)

const

{
 Player* modOwner = NULL;
 int32 maxDuration;

 if (caster)
 {
 modOwner = caster->GetSpellModOwner();
 maxDuration = caster->CalcSpellDuration(m_spellInfo);
 }
 else
 maxDuration = m_spellInfo->GetDuration();

 if (IsPassive() && !m_spellInfo->DurationEntry)
 maxDuration = -1;

 // IsPermanent() checks max duration (which we are supposed to calculate here)
 if (maxDuration != -1 && modOwner)
 modOwner->ApplySpellMod(GetId(), SPELLMOD_DURATION, maxDuration);

 return maxDuration;
}

Here is the call graph for this function:

float Aura::CalcProcChance	(	SpellProcEntry const &	procEntry,
		ProcEventInfo &	eventInfo
	)		const

{
 float chance = procEntry.chance;
 // calculate chances depending on unit with caster's data
 // so talents modifying chances and judgements will have properly calculated proc chance
 if (Unit* caster = GetCaster())
 {
 // calculate ppm chance if present and we're using weapon
 if (eventInfo.GetDamageInfo() && procEntry.ratePerMinute != 0)
 {
 uint32 WeaponSpeed = caster->GetAttackTime(eventInfo.GetDamageInfo()->GetAttackType());
 chance = caster->GetPPMProcChance(WeaponSpeed, procEntry.ratePerMinute, GetSpellInfo());
 }
 // apply chance modifer aura, applies also to ppm chance (see improved judgement of light spell)
 if (Player* modOwner = caster->GetSpellModOwner())
 modOwner->ApplySpellMod(GetId(), SPELLMOD_CHANCE_OF_SUCCESS, chance);
 }
 return chance;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::CallScriptAfterDispel

(

DispelInfo *

dispelInfo

)

{
 for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
 {
 (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_AFTER_DISPEL);
 std::list<AuraScript::AuraDispelHandler>::iterator hookItrEnd = (*scritr)->AfterDispel.end(), hookItr = (*scritr)->AfterDispel.begin();
 for (; hookItr != hookItrEnd; ++hookItr)
 hookItr->Call(*scritr, dispelInfo);

 (*scritr)->_FinishScriptCall();
 }
}

Here is the caller graph for this function:

void Aura::CallScriptAfterEffectApplyHandlers	(	AuraEffect const *	aurEff,
		AuraApplication const *	aurApp,
		AuraEffectHandleModes	mode
	)

{
 for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
 {
 (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_EFFECT_AFTER_APPLY, aurApp);
 std::list<AuraScript::EffectApplyHandler>::iterator effEndItr = (*scritr)->AfterEffectApply.end(), effItr = (*scritr)->AfterEffectApply.begin();
 for (; effItr != effEndItr; ++effItr)
 if (effItr->IsEffectAffected(m_spellInfo, aurEff->GetEffIndex()))
 effItr->Call(*scritr, aurEff, mode);

 (*scritr)->_FinishScriptCall();
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::CallScriptAfterEffectProcHandlers	(	AuraEffect const *	aurEff,
		AuraApplication const *	aurApp,
		ProcEventInfo &	eventInfo
	)

{
 for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
 {
 (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_EFFECT_AFTER_PROC, aurApp);
 std::list<AuraScript::EffectProcHandler>::iterator effEndItr = (*scritr)->AfterEffectProc.end(), effItr = (*scritr)->AfterEffectProc.begin();
 for (; effItr != effEndItr; ++effItr)
 if (effItr->IsEffectAffected(m_spellInfo, aurEff->GetEffIndex()))
 effItr->Call(*scritr, aurEff, eventInfo);

        (*scritr)->_FinishScriptCall();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::CallScriptAfterEffectRemoveHandlers	(	AuraEffect const *	aurEff,
		AuraApplication const *	aurApp,
		AuraEffectHandleModes	mode
	)

{
    for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
    {
        (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_EFFECT_AFTER_REMOVE, aurApp);
        std::list<AuraScript::EffectApplyHandler>::iterator effEndItr = (*scritr)->AfterEffectRemove.end(), effItr = (*scritr)->AfterEffectRemove.begin();
        for (; effItr != effEndItr; ++effItr)
            if (effItr->IsEffectAffected(m_spellInfo, aurEff->GetEffIndex()))
                effItr->Call(*scritr, aurEff, mode);

        (*scritr)->_FinishScriptCall();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::CallScriptAfterProcHandlers	(	AuraApplication const *	aurApp,
		ProcEventInfo &	eventInfo
	)

{
    for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
    {
        (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_AFTER_PROC, aurApp);
        std::list<AuraScript::AuraProcHandler>::iterator hookItrEnd = (*scritr)->AfterProc.end(), hookItr = (*scritr)->AfterProc.begin();
        for (; hookItr != hookItrEnd; ++hookItr)
            hookItr->Call(*scritr, eventInfo);

        (*scritr)->_FinishScriptCall();
    }
}

Here is the caller graph for this function:

bool Aura::CallScriptCheckAreaTargetHandlers

(

Unit *

target

)

{
    bool result = true;
    for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
    {
        (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_CHECK_AREA_TARGET);
        std::list<AuraScript::CheckAreaTargetHandler>::iterator hookItrEnd = (*scritr)->DoCheckAreaTarget.end(), hookItr = (*scritr)->DoCheckAreaTarget.begin();
        for (; hookItr != hookItrEnd; ++hookItr)
            result &= hookItr->Call(*scritr, target);

        (*scritr)->_FinishScriptCall();
    }
    return result;
}

Here is the caller graph for this function:

bool Aura::CallScriptCheckProcHandlers	(	AuraApplication const *	aurApp,
		ProcEventInfo &	eventInfo
	)

{
    bool result = true;
    for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
    {
        (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_CHECK_PROC, aurApp);
        std::list<AuraScript::CheckProcHandler>::iterator hookItrEnd = (*scritr)->DoCheckProc.end(), hookItr = (*scritr)->DoCheckProc.begin();
        for (; hookItr != hookItrEnd; ++hookItr)
            result &= hookItr->Call(*scritr, eventInfo);

        (*scritr)->_FinishScriptCall();
    }

    return result;
}

Here is the caller graph for this function:

void Aura::CallScriptDispel

(

DispelInfo *

dispelInfo

)

{
    for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
    {
        (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_DISPEL);
        std::list<AuraScript::AuraDispelHandler>::iterator hookItrEnd = (*scritr)->OnDispel.end(), hookItr = (*scritr)->OnDispel.begin();
        for (; hookItr != hookItrEnd; ++hookItr)
            hookItr->Call(*scritr, dispelInfo);

        (*scritr)->_FinishScriptCall();
    }
}

Here is the caller graph for this function:

void Aura::CallScriptEffectAbsorbHandlers	(	AuraEffect *	aurEff,
		AuraApplication const *	aurApp,
		DamageInfo &	dmgInfo,
		uint32 &	absorbAmount,
		bool &	defaultPrevented
	)

{
    for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
    {
        (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_EFFECT_ABSORB, aurApp);
        std::list<AuraScript::EffectAbsorbHandler>::iterator effEndItr = (*scritr)->OnEffectAbsorb.end(), effItr = (*scritr)->OnEffectAbsorb.begin();
        for (; effItr != effEndItr; ++effItr)

            if (effItr->IsEffectAffected(m_spellInfo, aurEff->GetEffIndex()))
                effItr->Call(*scritr, aurEff, dmgInfo, absorbAmount);

        if (!defaultPrevented)
            defaultPrevented = (*scritr)->_IsDefaultActionPrevented();

        (*scritr)->_FinishScriptCall();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::CallScriptEffectAfterAbsorbHandlers	(	AuraEffect *	aurEff,
		AuraApplication const *	aurApp,
		DamageInfo &	dmgInfo,
		uint32 &	absorbAmount
	)

{
    for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
    {
        (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_EFFECT_AFTER_ABSORB, aurApp);
        std::list<AuraScript::EffectAbsorbHandler>::iterator effEndItr = (*scritr)->AfterEffectAbsorb.end(), effItr = (*scritr)->AfterEffectAbsorb.begin();
        for (; effItr != effEndItr; ++effItr)
            if (effItr->IsEffectAffected(m_spellInfo, aurEff->GetEffIndex()))
                effItr->Call(*scritr, aurEff, dmgInfo, absorbAmount);

        (*scritr)->_FinishScriptCall();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::CallScriptEffectAfterManaShieldHandlers	(	AuraEffect *	aurEff,
		AuraApplication const *	aurApp,
		DamageInfo &	dmgInfo,
		uint32 &	absorbAmount
	)

{
    for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
    {
        (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_EFFECT_AFTER_MANASHIELD, aurApp);
        std::list<AuraScript::EffectManaShieldHandler>::iterator effEndItr = (*scritr)->AfterEffectManaShield.end(), effItr = (*scritr)->AfterEffectManaShield.begin();
        for (; effItr != effEndItr; ++effItr)
            if (effItr->IsEffectAffected(m_spellInfo, aurEff->GetEffIndex()))
                effItr->Call(*scritr, aurEff, dmgInfo, absorbAmount);

        (*scritr)->_FinishScriptCall();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Aura::CallScriptEffectApplyHandlers	(	AuraEffect const *	aurEff,
		AuraApplication const *	aurApp,
		AuraEffectHandleModes	mode
	)

{
    bool preventDefault = false;
    for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
    {
        (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_EFFECT_APPLY, aurApp);
        std::list<AuraScript::EffectApplyHandler>::iterator effEndItr = (*scritr)->OnEffectApply.end(), effItr = (*scritr)->OnEffectApply.begin();
        for (; effItr != effEndItr; ++effItr)
            if (effItr->IsEffectAffected(m_spellInfo, aurEff->GetEffIndex()))
                effItr->Call(*scritr, aurEff, mode);

        if (!preventDefault)
            preventDefault = (*scritr)->_IsDefaultActionPrevented();

        (*scritr)->_FinishScriptCall();
    }

    return preventDefault;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::CallScriptEffectCalcAmountHandlers	(	AuraEffect const *	aurEff,
		int32 &	amount,
		bool &	canBeRecalculated
	)

{
    for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
    {
        (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_EFFECT_CALC_AMOUNT);
        std::list<AuraScript::EffectCalcAmountHandler>::iterator effEndItr = (*scritr)->DoEffectCalcAmount.end(), effItr = (*scritr)->DoEffectCalcAmount.begin();
        for (; effItr != effEndItr; ++effItr)
            if (effItr->IsEffectAffected(m_spellInfo, aurEff->GetEffIndex()))
                effItr->Call(*scritr, aurEff, amount, canBeRecalculated);

        (*scritr)->_FinishScriptCall();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::CallScriptEffectCalcPeriodicHandlers	(	AuraEffect const *	aurEff,
		bool &	isPeriodic,
		int32 &	amplitude
	)

{
    for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
    {
        (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_EFFECT_CALC_PERIODIC);
        std::list<AuraScript::EffectCalcPeriodicHandler>::iterator effEndItr = (*scritr)->DoEffectCalcPeriodic.end(), effItr = (*scritr)->DoEffectCalcPeriodic.begin();
        for (; effItr != effEndItr; ++effItr)
            if (effItr->IsEffectAffected(m_spellInfo, aurEff->GetEffIndex()))
                effItr->Call(*scritr, aurEff, isPeriodic, amplitude);

        (*scritr)->_FinishScriptCall();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::CallScriptEffectCalcSpellModHandlers	(	AuraEffect const *	aurEff,
		SpellModifier *&	spellMod
	)

{
    for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
    {
        (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_EFFECT_CALC_SPELLMOD);
        std::list<AuraScript::EffectCalcSpellModHandler>::iterator effEndItr = (*scritr)->DoEffectCalcSpellMod.end(), effItr = (*scritr)->DoEffectCalcSpellMod.begin();
        for (; effItr != effEndItr; ++effItr)
            if (effItr->IsEffectAffected(m_spellInfo, aurEff->GetEffIndex()))
                effItr->Call(*scritr, aurEff, spellMod);

        (*scritr)->_FinishScriptCall();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::CallScriptEffectManaShieldHandlers	(	AuraEffect *	aurEff,
		AuraApplication const *	aurApp,
		DamageInfo &	dmgInfo,
		uint32 &	absorbAmount,
		bool &	defaultPrevented
	)

{
    for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
    {
        (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_EFFECT_MANASHIELD, aurApp);
        std::list<AuraScript::EffectManaShieldHandler>::iterator effEndItr = (*scritr)->OnEffectManaShield.end(), effItr = (*scritr)->OnEffectManaShield.begin();
        for (; effItr != effEndItr; ++effItr)
            if (effItr->IsEffectAffected(m_spellInfo, aurEff->GetEffIndex()))
                effItr->Call(*scritr, aurEff, dmgInfo, absorbAmount);

        (*scritr)->_FinishScriptCall();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Aura::CallScriptEffectPeriodicHandlers	(	AuraEffect const *	aurEff,
		AuraApplication const *	aurApp
	)

{
    bool preventDefault = false;
    for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
    {
        (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_EFFECT_PERIODIC, aurApp);
        std::list<AuraScript::EffectPeriodicHandler>::iterator effEndItr = (*scritr)->OnEffectPeriodic.end(), effItr = (*scritr)->OnEffectPeriodic.begin();
        for (; effItr != effEndItr; ++effItr)
            if (effItr->IsEffectAffected(m_spellInfo, aurEff->GetEffIndex()))
                effItr->Call(*scritr, aurEff);

        if (!preventDefault)
            preventDefault = (*scritr)->_IsDefaultActionPrevented();

        (*scritr)->_FinishScriptCall();
    }

    return preventDefault;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Aura::CallScriptEffectProcHandlers	(	AuraEffect const *	aurEff,
		AuraApplication const *	aurApp,
		ProcEventInfo &	eventInfo
	)

{
    bool preventDefault = false;
    for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
    {
        (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_EFFECT_PROC, aurApp);
        std::list<AuraScript::EffectProcHandler>::iterator effEndItr = (*scritr)->OnEffectProc.end(), effItr = (*scritr)->OnEffectProc.begin();
        for (; effItr != effEndItr; ++effItr)
            if (effItr->IsEffectAffected(m_spellInfo, aurEff->GetEffIndex()))
                effItr->Call(*scritr, aurEff, eventInfo);

        if (!preventDefault)
            preventDefault = (*scritr)->_IsDefaultActionPrevented();

        (*scritr)->_FinishScriptCall();
    }
    return preventDefault;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Aura::CallScriptEffectRemoveHandlers	(	AuraEffect const *	aurEff,
		AuraApplication const *	aurApp,
		AuraEffectHandleModes	mode
	)

{
    bool preventDefault = false;
    for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
    {
        (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_EFFECT_REMOVE, aurApp);
        std::list<AuraScript::EffectApplyHandler>::iterator effEndItr = (*scritr)->OnEffectRemove.end(), effItr = (*scritr)->OnEffectRemove.begin();
        for (; effItr != effEndItr; ++effItr)
            if (effItr->IsEffectAffected(m_spellInfo, aurEff->GetEffIndex()))
                effItr->Call(*scritr, aurEff, mode);

        if (!preventDefault)
            preventDefault = (*scritr)->_IsDefaultActionPrevented();

        (*scritr)->_FinishScriptCall();
    }
    return preventDefault;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::CallScriptEffectSplitHandlers	(	AuraEffect *	aurEff,
		AuraApplication const *	aurApp,
		DamageInfo &	dmgInfo,
		uint32 &	splitAmount
	)

{
    for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
    {
        (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_EFFECT_SPLIT, aurApp);
        std::list<AuraScript::EffectSplitHandler>::iterator effEndItr = (*scritr)->OnEffectSplit.end(), effItr = (*scritr)->OnEffectSplit.begin();
        for (; effItr != effEndItr; ++effItr)
            if (effItr->IsEffectAffected(m_spellInfo, aurEff->GetEffIndex()))
                effItr->Call(*scritr, aurEff, dmgInfo, splitAmount);

        (*scritr)->_FinishScriptCall();
    }
}

Here is the call graph for this function:

void Aura::CallScriptEffectUpdatePeriodicHandlers

(

AuraEffect *

aurEff

)

{
    for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
    {
        (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_EFFECT_UPDATE_PERIODIC);
        std::list<AuraScript::EffectUpdatePeriodicHandler>::iterator effEndItr = (*scritr)->OnEffectUpdatePeriodic.end(), effItr = (*scritr)->OnEffectUpdatePeriodic.begin();
        for (; effItr != effEndItr; ++effItr)
            if (effItr->IsEffectAffected(m_spellInfo, aurEff->GetEffIndex()))
                effItr->Call(*scritr, aurEff);

        (*scritr)->_FinishScriptCall();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Aura::CallScriptPrepareProcHandlers	(	AuraApplication const *	aurApp,
		ProcEventInfo &	eventInfo
	)

{
    bool prepare = true;
    for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
    {
        (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_PREPARE_PROC, aurApp);
        std::list<AuraScript::AuraProcHandler>::iterator effEndItr = (*scritr)->DoPrepareProc.end(), effItr = (*scritr)->DoPrepareProc.begin();
        for (; effItr != effEndItr; ++effItr)
            effItr->Call(*scritr, eventInfo);

        if (prepare)
            prepare = !(*scritr)->_IsDefaultActionPrevented();

        (*scritr)->_FinishScriptCall();
    }

    return prepare;
}

Here is the caller graph for this function:

bool Aura::CallScriptProcHandlers	(	AuraApplication const *	aurApp,
		ProcEventInfo &	eventInfo
	)

{
    bool handled = false;
    for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
    {
        (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_PROC, aurApp);
        std::list<AuraScript::AuraProcHandler>::iterator hookItrEnd = (*scritr)->OnProc.end(), hookItr = (*scritr)->OnProc.begin();
        for (; hookItr != hookItrEnd; ++hookItr)
            hookItr->Call(*scritr, eventInfo);

        handled |= (*scritr)->_IsDefaultActionPrevented();
        (*scritr)->_FinishScriptCall();
    }

    return handled;
}

Here is the caller graph for this function:

bool Aura::CanBeAppliedOn

(

Unit *

target

)

{
    // unit not in world or during remove from world
    if (!target->IsInWorld() || target->IsDuringRemoveFromWorld())
    {
        // area auras mustn't be applied
        if (GetOwner() != target)
            return false;
        // do not apply non-selfcast single target auras
        if (GetCasterGUID() != GetOwner()->GetGUID() && GetSpellInfo()->IsSingleTarget())
            return false;
        return true;
    }
    else
        return CheckAreaTarget(target);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Aura::CanBeSaved

(

)

const

{
    if (IsPassive())
        return false;

    if (GetCasterGUID() != GetOwner()->GetGUID())
        if (GetSpellInfo()->IsSingleTarget())
            return false;

    // Can't be saved - aura handler relies on calculated amount and changes it
    if (HasEffectType(SPELL_AURA_CONVERT_RUNE))
        return false;

    // No point in saving this, since the stable dialog can't be open on aura load anyway.
    if (HasEffectType(SPELL_AURA_OPEN_STABLE))
        return false;

    // Can't save vehicle auras, it requires both caster & target to be in world
    if (HasEffectType(SPELL_AURA_CONTROL_VEHICLE))
        return false;

    // Incanter's Absorbtion - considering the minimal duration and problems with aura stacking
    // we skip saving this aura
    // Also for some reason other auras put as MultiSlot crash core on keeping them after restart,
    // so put here only these for which you are sure they get removed
    switch (GetId())
    {
        case 44413: // Incanter's Absorption
        case 40075: // Fel Flak Fire
        case 55849: // Power Spark
            return false;
    }

    // When a druid logins, he doesnt have either eclipse power, nor the marker auras, nor the eclipse buffs. Dont save them.
    if (GetId() == 67483 || GetId() == 67484 || GetId() == 48517 || GetId() == 48518)
        return false;

    // don't save auras removed by proc system
    if (IsUsingCharges() && !GetCharges())
        return false;

    return true;
}

Here is the call graph for this function:

bool Aura::CanBeSentToClient

(

)

const

{
    return !IsPassive() || GetSpellInfo()->HasAreaAuraEffect(GetOwner() ? GetOwner()->GetMap()->GetDifficultyID() : DIFFICULTY_NONE)
        || HasEffectType(SPELL_AURA_ABILITY_IGNORE_AURASTATE)
        || HasEffectType(SPELL_AURA_CAST_WHILE_WALKING)
        || HasEffectType(SPELL_AURA_MOD_MAX_CHARGES)
        || HasEffectType(SPELL_AURA_CHARGE_RECOVERY_MOD)
        || HasEffectType(SPELL_AURA_CHARGE_RECOVERY_MULTIPLIER);
}

Here is the call graph for this function:

bool Aura::CanStackWith

(

Aura const *

existingAura

)

const

{
    // Can stack with self
    if (this == existingAura)
        return true;

    // Dynobj auras always stack
    if (GetType() == DYNOBJ_AURA_TYPE || existingAura->GetType() == DYNOBJ_AURA_TYPE)
        return true;

    SpellInfo const* existingSpellInfo = existingAura->GetSpellInfo();
    bool sameCaster = GetCasterGUID() == existingAura->GetCasterGUID();

    // passive auras don't stack with another rank of the spell cast by same caster
    if (IsPassive() && sameCaster && m_spellInfo->IsDifferentRankOf(existingSpellInfo))
        return false;

    for (SpellEffectInfo const* effect : existingAura->GetSpellEffectInfos())
    {
        // prevent remove triggering aura by triggered aura
        if (effect && effect->TriggerSpell == GetId())
            return true;
    }

    for (SpellEffectInfo const* effect : GetSpellEffectInfos())
    {
        // prevent remove triggered aura by triggering aura refresh
        if (effect && effect->TriggerSpell == existingAura->GetId())
            return true;
    }

    // Check for custom server setting to allow tracking both Herbs and Minerals
    // Note: The following are client limitations and cannot be coded for:
    //  * The minimap tracking icon will display whichever skill is activated second
    //  * The minimap tracking list will only show a check mark next to the last skill activated
    //    Sometimes this bugs out and doesn't switch the check mark. It has no effect on the actual tracking though.
    //  * The minimap dots are yellow for both resources
    if (m_spellInfo->HasAura(GetOwner()->GetMap()->GetDifficultyID(), SPELL_AURA_TRACK_RESOURCES) && existingSpellInfo->HasAura(GetOwner()->GetMap()->GetDifficultyID(), SPELL_AURA_TRACK_RESOURCES))
        return sWorld->getBoolConfig(CONFIG_ALLOW_TRACK_BOTH_RESOURCES);

    // check spell specific stack rules
    if (m_spellInfo->IsAuraExclusiveBySpecificWith(existingSpellInfo)
        || (sameCaster && m_spellInfo->IsAuraExclusiveBySpecificPerCasterWith(existingSpellInfo)))
        return false;

    // check spell group stack rules
    switch (sSpellMgr->CheckSpellGroupStackRules(m_spellInfo, existingSpellInfo))
    {
        case SPELL_GROUP_STACK_RULE_EXCLUSIVE:
        case SPELL_GROUP_STACK_RULE_EXCLUSIVE_HIGHEST: // if it reaches this point, existing aura is lower/equal
            return false;
        case SPELL_GROUP_STACK_RULE_EXCLUSIVE_FROM_SAME_CASTER:
            if (sameCaster)
                return false;
            break;
        case SPELL_GROUP_STACK_RULE_DEFAULT:
        case SPELL_GROUP_STACK_RULE_EXCLUSIVE_SAME_EFFECT:
        default:
            break;
    }

    if (m_spellInfo->SpellFamilyName != existingSpellInfo->SpellFamilyName)
        return true;

    if (!sameCaster)
    {
        // Channeled auras can stack if not forbidden by db or aura type
        if (existingAura->GetSpellInfo()->IsChanneled())
            return true;

        if (m_spellInfo->HasAttribute(SPELL_ATTR3_STACK_FOR_DIFF_CASTERS))
            return true;

        // check same periodic auras
        for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        {
            SpellEffectInfo const* effect = GetSpellEffectInfo(i);
            if (!effect)
                continue;
            switch (effect->ApplyAuraName)
            {
                // DOT or HOT from different casters will stack
                case SPELL_AURA_PERIODIC_DAMAGE:
                case SPELL_AURA_PERIODIC_DUMMY:
                case SPELL_AURA_PERIODIC_HEAL:
                case SPELL_AURA_PERIODIC_TRIGGER_SPELL:
                case SPELL_AURA_PERIODIC_ENERGIZE:
                case SPELL_AURA_PERIODIC_MANA_LEECH:
                case SPELL_AURA_PERIODIC_LEECH:
                case SPELL_AURA_POWER_BURN:
                case SPELL_AURA_OBS_MOD_POWER:
                case SPELL_AURA_OBS_MOD_HEALTH:
                case SPELL_AURA_PERIODIC_TRIGGER_SPELL_WITH_VALUE:
                    {
                        SpellEffectInfo const* existingEffect = GetSpellEffectInfo(i);
                        // periodic auras which target areas are not allowed to stack this way (replenishment for example)
                        if (effect->IsTargetingArea() || (existingEffect && existingEffect->IsTargetingArea()))
                            break;
                    }
                    return true;
                default:
                    break;
            }
        }
    }

    if (HasEffectType(SPELL_AURA_CONTROL_VEHICLE) && existingAura->HasEffectType(SPELL_AURA_CONTROL_VEHICLE))
    {
        Vehicle* veh = NULL;
        if (GetOwner()->ToUnit())
            veh = GetOwner()->ToUnit()->GetVehicleKit();

        if (!veh)           // We should probably just let it stack. Vehicle system will prevent undefined behaviour later
            return true;

        if (!veh->GetAvailableSeatCount())
            return false;   // No empty seat available

        return true; // Empty seat available (skip rest)
    }

    // spell of same spell rank chain
    if (m_spellInfo->IsRankOf(existingSpellInfo))
    {
        // don't allow passive area auras to stack
        if (m_spellInfo->IsMultiSlotAura() && !IsArea())
            return true;
        if (!GetCastItemGUID().IsEmpty() && !existingAura->GetCastItemGUID().IsEmpty())
            if (GetCastItemGUID() != existingAura->GetCastItemGUID() && (m_spellInfo->HasAttribute(SPELL_ATTR0_CU_ENCHANT_PROC)))
                return true;
        // same spell with same caster should not stack
        return false;
    }

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Aura::CheckAreaTarget

(

Unit *

target

)

{
    return CallScriptCheckAreaTargetHandlers(target);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Aura * Aura::Create ( SpellInfo const *  spellproto, uint32  effMask, WorldObject *  owner, Unit *  caster, int32 *  baseAmount, Item *  castItem, ObjectGuid  casterGUID, int32  castItemLevel  )

static

{
    ASSERT(effMask);
    ASSERT(spellproto);
    ASSERT(owner);
    ASSERT(caster || !casterGUID.IsEmpty());
    ASSERT(effMask <= MAX_EFFECT_MASK);
    // try to get caster of aura
    if (!casterGUID.IsEmpty())
    {
        if (owner->GetGUID() == casterGUID)
            caster = owner->ToUnit();
        else
            caster = ObjectAccessor::GetUnit(*owner, casterGUID);
    }
    else
        casterGUID = caster->GetGUID();

    // check if aura can be owned by owner
    if (owner->isType(TYPEMASK_UNIT))
        if (!owner->IsInWorld() || ((Unit*)owner)->IsDuringRemoveFromWorld())
            // owner not in world so don't allow to own not self cast single target auras
            if (casterGUID != owner->GetGUID() && spellproto->IsSingleTarget())
                return NULL;

    Aura* aura = NULL;
    switch (owner->GetTypeId())
    {
        case TYPEID_UNIT:
        case TYPEID_PLAYER:
            aura = new UnitAura(spellproto, effMask, owner, caster, baseAmount, castItem, casterGUID, castItemLevel);
            break;
        case TYPEID_DYNAMICOBJECT:
            aura = new DynObjAura(spellproto, effMask, owner, caster, baseAmount, castItem, casterGUID, castItemLevel);
            break;
        default:
            ABORT();
            return NULL;
    }
    // aura can be removed in Unit::_AddAura call
    if (aura->IsRemoved())
        return NULL;
    return aura;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Aura::DropCharge ( AuraRemoveMode  removeMode = AURA_REMOVE_BY_DEFAULT )

inline

{ return ModCharges(-1, removeMode); }

Here is the caller graph for this function:

void Aura::DropChargeDelayed	(	uint32	delay,
		AuraRemoveMode	removeMode = AURA_REMOVE_BY_DEFAULT
	)

{
    // aura is already during delayed charge drop
    if (m_dropEvent)
        return;
    // only units have events
    Unit* owner = m_owner->ToUnit();
    if (!owner)
        return;

    m_dropEvent = new ChargeDropEvent(this, removeMode);
    owner->m_Events.AddEvent(m_dropEvent, owner->m_Events.CalculateTime(delay));
}

Here is the call graph for this function:

virtual void Aura::FillTargetMap ( std::map< Unit *, uint32 > &  targets, Unit *  caster  )

pure virtual

Implemented in DynObjAura, and UnitAura.

Here is the caller graph for this function:

AuraKey Aura::GenerateKey

(

uint32 &

recalculateMask

)

const

Fills a helper structure containing aura primary key for character_aura, character_aura_effect, pet_aura, pet_aura_effect tables.

Parameters

[out]

recalculateMask

Mask of effects that can be recalculated to store in database - not part of aura key.

Returns

Aura key.

{
    AuraKey key;
    key.Caster = GetCasterGUID();
    key.Item = GetCastItemGUID();
    key.SpellId = GetId();
    key.EffectMask = 0;
    recalculateMask = 0;
    for (uint32 i = 0; i < _effects.size(); ++i)
    {
        if (AuraEffect const* effect = _effects[i])
        {
            key.EffectMask |= 1 << i;
            if (effect->CanBeRecalculated())
                recalculateMask |= 1 << i;
        }
    }

    return key;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::GetApplicationList

(

Unit::AuraApplicationList &

applicationList

)

const

{
    for (Aura::ApplicationMap::const_iterator appIter = m_applications.begin(); appIter != m_applications.end(); ++appIter)
    {
        if (appIter->second->GetEffectMask())
            applicationList.push_back(appIter->second);
    }
}

Here is the caller graph for this function:

ApplicationMap const& Aura::GetApplicationMap ( )

inline

{ return m_applications; }

Here is the caller graph for this function:

const AuraApplication* Aura::GetApplicationOfTarget ( ObjectGuid  guid ) const

inline

{ ApplicationMap::const_iterator itr = m_applications.find(guid); if (itr != m_applications.end()) return itr->second; return NULL; }

Here is the caller graph for this function:

AuraApplication* Aura::GetApplicationOfTarget ( ObjectGuid  guid )

inline

{ ApplicationMap::iterator itr = m_applications.find(guid); if (itr != m_applications.end()) return itr->second; return NULL; }

time_t Aura::GetApplyTime ( ) const

inline

{ return m_applyTime; }

Here is the caller graph for this function:

AuraEffectVector Aura::GetAuraEffects ( ) const

inline

{ return _effects; }

Here is the caller graph for this function:

Unit * Aura::GetCaster

(

)

const

{
    if (GetOwner()->GetGUID() == GetCasterGUID())
        return GetUnitOwner();
    if (AuraApplication const* aurApp = GetApplicationOfTarget(GetCasterGUID()))
        return aurApp->GetTarget();

    return ObjectAccessor::GetUnit(*GetOwner(), GetCasterGUID());
}

Here is the call graph for this function:

Here is the caller graph for this function:

ObjectGuid Aura::GetCasterGUID ( ) const

inline

{ return m_casterGuid; }

Here is the caller graph for this function:

uint8 Aura::GetCasterLevel ( ) const

inline

{ return m_casterLevel; }

Here is the caller graph for this function:

ObjectGuid Aura::GetCastItemGUID ( ) const

inline

{ return m_castItemGuid; }

Here is the caller graph for this function:

int32 Aura::GetCastItemLevel ( ) const

inline

{ return m_castItemLevel; }

Here is the caller graph for this function:

uint8 Aura::GetCharges ( ) const

inline

{ return m_procCharges; }

Here is the caller graph for this function:

int32 Aura::GetDuration ( ) const

inline

{ return m_duration; }

Here is the caller graph for this function:

DynamicObject* Aura::GetDynobjOwner ( ) const

inline

{ ASSERT(GetType() == DYNOBJ_AURA_TYPE); return (DynamicObject*)m_owner; }

Here is the caller graph for this function:

AuraEffect * Aura::GetEffect

(

uint32

index

)

const

{
    if (index >= _effects.size())
        return nullptr;

    return _effects[index];
}

Here is the caller graph for this function:

uint32 Aura::GetEffectMask

(

)

const

{
    uint32 effMask = 0;
    for (AuraEffect* effect : GetAuraEffects())
        if (effect)
            effMask |= 1 << effect->GetEffIndex();
    return effMask;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Aura::GetId ( void  ) const

inline

{ return GetSpellInfo()->Id; }

Here is the caller graph for this function:

int32 Aura::GetMaxDuration ( ) const

inline

{ return m_maxDuration; }

Here is the caller graph for this function:

WorldObject* Aura::GetOwner ( ) const

inline

{ return m_owner; }

Here is the caller graph for this function:

AuraScript * Aura::GetScriptByName

(

std::string const &

scriptName

)

const

{
    for (std::list<AuraScript*>::const_iterator itr = m_loadedScripts.begin(); itr != m_loadedScripts.end(); ++itr)
        if ((*itr)->_GetScriptName()->compare(scriptName) == 0)
            return *itr;
    return NULL;
}

SpellEffectInfo const * Aura::GetSpellEffectInfo

(

uint32

index

)

const

{
    if (index >= _spelEffectInfos.size())
        return nullptr;

    return _spelEffectInfos[index];
}

Here is the caller graph for this function:

SpellEffectInfoVector Aura::GetSpellEffectInfos ( ) const

inline

{ return _spelEffectInfos; }

Here is the caller graph for this function:

SpellInfo const* Aura::GetSpellInfo ( ) const

inline

{ return m_spellInfo; }

Here is the caller graph for this function:

uint8 Aura::GetStackAmount ( ) const

inline

{ return m_stackAmount; }

Here is the caller graph for this function:

AuraObjectType Aura::GetType

(

)

const

{
    return (m_owner->GetTypeId() == TYPEID_DYNAMICOBJECT) ? DYNOBJ_AURA_TYPE : UNIT_AURA_TYPE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Unit* Aura::GetUnitOwner ( ) const

inline

{ ASSERT(GetType() == UNIT_AURA_TYPE); return (Unit*)m_owner; }

Here is the caller graph for this function:

void Aura::HandleAllEffects	(	AuraApplication *	aurApp,
		uint8	mode,
		bool	apply
	)

{
    ASSERT (!IsRemoved());
    for (AuraEffect* effect : GetAuraEffects())
        if (effect && !IsRemoved())
            effect->HandleEffect(aurApp, mode, apply);
}

Here is the call graph for this function:

void Aura::HandleAuraSpecificMods	(	AuraApplication const *	aurApp,
		Unit *	caster,
		bool	apply,
		bool	onReapply
	)

{
    Unit* target = aurApp->GetTarget();
    AuraRemoveMode removeMode = aurApp->GetRemoveMode();
    // handle spell_area table
    SpellAreaForAreaMapBounds saBounds = sSpellMgr->GetSpellAreaForAuraMapBounds(GetId());
    if (saBounds.first != saBounds.second)
    {
        uint32 zone, area;
        target->GetZoneAndAreaId(zone, area);

        for (SpellAreaForAreaMap::const_iterator itr = saBounds.first; itr != saBounds.second; ++itr)
        {
            // some auras remove at aura remove
            if (!itr->second->IsFitToRequirements(target->ToPlayer(), zone, area))
                target->RemoveAurasDueToSpell(itr->second->spellId);
            // some auras applied at aura apply
            else if (itr->second->autocast)
            {
                if (!target->HasAura(itr->second->spellId))
                    target->CastSpell(target, itr->second->spellId, true);
            }
        }
    }

    // handle spell_linked_spell table
    if (!onReapply)
    {
        // apply linked auras
        if (apply)
        {
            if (std::vector<int32> const* spellTriggered = sSpellMgr->GetSpellLinked(GetId() + SPELL_LINK_AURA))
            {
                for (std::vector<int32>::const_iterator itr = spellTriggered->begin(); itr != spellTriggered->end(); ++itr)
                {
                    if (*itr < 0)
                        target->ApplySpellImmune(GetId(), IMMUNITY_ID, -(*itr), true);
                    else if (caster)
                        caster->AddAura(*itr, target);
                }
            }
        }
        else
        {
            // remove linked auras
            if (std::vector<int32> const* spellTriggered = sSpellMgr->GetSpellLinked(-(int32)GetId()))
            {
                for (std::vector<int32>::const_iterator itr = spellTriggered->begin(); itr != spellTriggered->end(); ++itr)
                {
                    if (*itr < 0)
                        target->RemoveAurasDueToSpell(-(*itr));
                    else if (removeMode != AURA_REMOVE_BY_DEATH)
                        target->CastSpell(target, *itr, true, NULL, NULL, GetCasterGUID());
                }
            }
            if (std::vector<int32> const* spellTriggered = sSpellMgr->GetSpellLinked(GetId() + SPELL_LINK_AURA))
            {
                for (std::vector<int32>::const_iterator itr = spellTriggered->begin(); itr != spellTriggered->end(); ++itr)
                {
                    if (*itr < 0)
                        target->ApplySpellImmune(GetId(), IMMUNITY_ID, -(*itr), false);
                    else
                        target->RemoveAura(*itr, GetCasterGUID(), 0, removeMode);
                }
            }
        }
    }
    else if (apply)
    {
        // modify stack amount of linked auras
        if (std::vector<int32> const* spellTriggered = sSpellMgr->GetSpellLinked(GetId() + SPELL_LINK_AURA))
        {
            for (std::vector<int32>::const_iterator itr = spellTriggered->begin(); itr != spellTriggered->end(); ++itr)
                if (*itr > 0)
                    if (Aura* triggeredAura = target->GetAura(*itr, GetCasterGUID()))
                        triggeredAura->ModStackAmount(GetStackAmount() - triggeredAura->GetStackAmount());
        }
    }

    // mods at aura apply
    if (apply)
    {
        switch (GetSpellInfo()->SpellFamilyName)
        {
            case SPELLFAMILY_GENERIC:
                switch (GetId())
                {
                    case 32474: // Buffeting Winds of Susurrus
                        if (target->GetTypeId() == TYPEID_PLAYER)
                            target->ToPlayer()->ActivateTaxiPathTo(506, GetId());
                        break;
                    case 33572: // Gronn Lord's Grasp, becomes stoned
                        if (GetStackAmount() >= 5 && !target->HasAura(33652))
                            target->CastSpell(target, 33652, true);
                        break;
                    case 50836: //Petrifying Grip, becomes stoned
                        if (GetStackAmount() >= 5 && !target->HasAura(50812))
                            target->CastSpell(target, 50812, true);
                        break;
                    case 60970: // Heroic Fury (remove Intercept cooldown)
                        if (target->GetTypeId() == TYPEID_PLAYER)
                            target->GetSpellHistory()->ResetCooldown(20252, true);
                        break;
                }
                break;
            case SPELLFAMILY_DRUID:
                if (!caster)
                    break;
                // Rejuvenation
                if (GetSpellInfo()->SpellFamilyFlags[0] & 0x10 && GetEffect(EFFECT_0))
                {
                    // Druid T8 Restoration 4P Bonus
                    if (caster->HasAura(64760))
                    {
                        int32 heal = GetEffect(EFFECT_0)->GetAmount();
                        caster->CastCustomSpell(target, 64801, &heal, NULL, NULL, true, NULL, GetEffect(EFFECT_0));
                    }
                }
                break;
            case SPELLFAMILY_MAGE:
                if (!caster)
                    break;
                switch (GetId())
                {
                    case 12536: // Clearcasting
                    case 12043: // Presence of Mind
                        // Arcane Potency
                        if (AuraEffect const* aurEff = caster->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_MAGE, 2120, 0))
                        {
                            uint32 spellId = 0;

                            switch (aurEff->GetId())
                            {
                                case 31571: spellId = 57529; break;
                                case 31572: spellId = 57531; break;
                                default:
                                    TC_LOG_ERROR("spells", "Aura::HandleAuraSpecificMods: Unknown rank of Arcane Potency (%d) found", aurEff->GetId());
                            }
                            if (spellId)
                                caster->CastSpell(caster, spellId, true);
                        }
                        break;
                    default:
                        break;
                }
                break;
            case SPELLFAMILY_PRIEST:
                if (!caster)
                    break;
                // Devouring Plague
                if (GetSpellInfo()->SpellFamilyFlags[0] & 0x02000000 && GetEffect(0))
                {
                    // Improved Devouring Plague
                    if (AuraEffect const* aurEff = caster->GetDummyAuraEffect(SPELLFAMILY_PRIEST, 3790, 0))
                    {
                        uint32 damage = caster->SpellDamageBonusDone(target, GetSpellInfo(), GetEffect(0)->GetAmount(), DOT, GetEffect(0)->GetSpellEffectInfo());
                        damage *= caster->SpellDamagePctDone(target, GetSpellInfo(), SPELL_DIRECT_DAMAGE);
                        damage = target->SpellDamageBonusTaken(caster, GetSpellInfo(), damage, DOT, GetEffect(0)->GetSpellEffectInfo());
                        int32 basepoints0 = aurEff->GetAmount() * GetEffect(0)->GetTotalTicks() * int32(damage) / 100;
                        int32 heal = int32(CalculatePct(basepoints0, 15));

                        caster->CastCustomSpell(target, 63675, &basepoints0, NULL, NULL, true, NULL, GetEffect(0));
                        caster->CastCustomSpell(caster, 75999, &heal, NULL, NULL, true, NULL, GetEffect(0));
                    }
                }
                // Power Word: Shield
                else if (m_spellInfo->SpellFamilyFlags[0] & 0x1 && m_spellInfo->SpellFamilyFlags[2] & 0x400 && GetEffect(0))
                {
                    // Glyph of Power Word: Shield
                    if (AuraEffect* glyph = caster->GetAuraEffect(55672, 0))
                    {
                        // instantly heal m_amount% of the absorb-value
                        int32 heal = glyph->GetAmount() * GetEffect(0)->GetAmount()/100;
                        caster->CastCustomSpell(GetUnitOwner(), 56160, &heal, nullptr, nullptr, true, nullptr, GetEffect(0));
                    }
                }
                break;
            case SPELLFAMILY_ROGUE:
                // Sprint (skip non player cast spells by category)
                if (GetSpellInfo()->SpellFamilyFlags[0] & 0x40 && GetSpellInfo()->GetCategory() == 44)
                    // in official maybe there is only one icon?
                    if (target->HasAura(58039)) // Glyph of Blurred Speed
                        target->CastSpell(target, 61922, true); // Sprint (waterwalk)
                break;
        }
    }
    // mods at aura remove
    else
    {
        switch (GetSpellInfo()->SpellFamilyName)
        {
            case SPELLFAMILY_GENERIC:
                switch (GetId())
                {
                    case 61987: // Avenging Wrath
                        // Remove the immunity shield marker on Avenging Wrath removal if Forbearance is not present
                        if (target->HasAura(61988) && !target->HasAura(25771))
                            target->RemoveAura(61988);
                        break;
                    default:
                        break;
                }
                break;
            case SPELLFAMILY_MAGE:
                switch (GetId())
                {
                    case 66: // Invisibility
                        if (removeMode != AURA_REMOVE_BY_EXPIRE)
                            break;
                        target->CastSpell(target, 32612, true, NULL, GetEffect(1));
                        target->CombatStop();
                        break;
                    default:
                        break;
                }
                break;
            case SPELLFAMILY_WARLOCK:
                if (!caster)
                    break;
                // Improved Fear
                if (GetSpellInfo()->SpellFamilyFlags[1] & 0x00000400)
                {
                    if (AuraEffect* aurEff = caster->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_WARLOCK, 98, 0))
                    {
                        uint32 spellId = 0;
                        switch (aurEff->GetId())
                        {
                            case 53759: spellId = 60947; break;
                            case 53754: spellId = 60946; break;
                            default:
                                TC_LOG_ERROR("spells", "Aura::HandleAuraSpecificMods: Unknown rank of Improved Fear (%d) found", aurEff->GetId());
                        }
                        if (spellId)
                            caster->CastSpell(target, spellId, true);
                    }
                }
                break;
            case SPELLFAMILY_PRIEST:
                if (!caster)
                    break;
                // Power word: shield
                if (removeMode == AURA_REMOVE_BY_ENEMY_SPELL && GetSpellInfo()->SpellFamilyFlags[0] & 0x00000001)
                {
                    // Rapture
                    if (Aura const* aura = caster->GetAuraOfRankedSpell(47535))
                    {
                        // check cooldown
                        if (caster->GetTypeId() == TYPEID_PLAYER)
                        {
                            if (caster->GetSpellHistory()->HasCooldown(aura->GetId()))
                            {
                                // This additional check is needed to add a minimal delay before cooldown in in effect
                                // to allow all bubbles broken by a single damage source proc mana return
                                if (caster->GetSpellHistory()->GetRemainingCooldown(aura->GetSpellInfo()) <= 11 * IN_MILLISECONDS)
                                    break;
                            }
                            else    // and add if needed
                                caster->GetSpellHistory()->AddCooldown(aura->GetId(), 0, std::chrono::seconds(12));
                        }

                        // effect on caster
                        if (AuraEffect const* aurEff = aura->GetEffect(0))
                        {
                            float multiplier = float(aurEff->GetAmount());
                            int32 basepoints0 = int32(CalculatePct(caster->GetMaxPower(POWER_MANA), multiplier));
                            caster->CastCustomSpell(caster, 47755, &basepoints0, NULL, NULL, true);
                        }
                    }
                }
                break;
            case SPELLFAMILY_ROGUE:
                // Remove Vanish on stealth remove
                if (GetId() == 1784)
                    target->RemoveAurasWithFamily(SPELLFAMILY_ROGUE, flag128(0x0000800, 0, 0, 0), target->GetGUID());
                break;
            case SPELLFAMILY_PALADIN:
                // Remove the immunity shield marker on Forbearance removal if AW marker is not present
                if (GetId() == 25771 && target->HasAura(61988) && !target->HasAura(61987))
                    target->RemoveAura(61988);
                break;
            case SPELLFAMILY_DEATHKNIGHT:
                // Blood of the North
                // Reaping
                // Death Rune Mastery
                if (GetSpellInfo()->SpellIconID == 3041 || GetSpellInfo()->SpellIconID == 22 || GetSpellInfo()->SpellIconID == 2622)
                {
                    if (!GetEffect(0) || GetEffect(0)->GetAuraType() != SPELL_AURA_PERIODIC_DUMMY)
                        break;
                    if (target->GetTypeId() != TYPEID_PLAYER)
                        break;
                    if (target->ToPlayer()->getClass() != CLASS_DEATH_KNIGHT)
                        break;

                     // aura removed - remove death runes
                    target->ToPlayer()->RemoveRunesByAuraEffect(GetEffect(0));
                }
                break;
            case SPELLFAMILY_HUNTER:
                // Glyph of Freezing Trap
                if (GetSpellInfo()->SpellFamilyFlags[0] & 0x00000008)
                    if (caster && caster->HasAura(56845))
                        target->CastSpell(target, 61394, true);
                break;
        }
    }

    // mods at aura apply or remove
    switch (GetSpellInfo()->SpellFamilyName)
    {
        case SPELLFAMILY_HUNTER:
            switch (GetId())
            {
                case 19574: // Bestial Wrath
                    // The Beast Within cast on owner if talent present
                    if (Unit* owner = target->GetOwner())
                    {
                        // Search talent
                        if (owner->HasAura(34692))
                        {
                            if (apply)
                                owner->CastSpell(owner, 34471, true, 0, GetEffect(0));
                            else
                                owner->RemoveAurasDueToSpell(34471);
                        }
                    }
                    break;
            }
            break;
        case SPELLFAMILY_PALADIN:
            switch (GetId())
            {
                case 31842: // Divine Favor
                    // Item - Paladin T10 Holy 2P Bonus
                    if (target->HasAura(70755))
                    {
                        if (apply)
                            target->CastSpell(target, 71166, true);
                        else
                            target->RemoveAurasDueToSpell(71166);
                    }
                    break;
            }
            break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::HandleAuraSpecificPeriodics	(	AuraApplication const *	aurApp,
		Unit *	caster
	)

{
    Unit* target = aurApp->GetTarget();

    if (!caster || aurApp->GetRemoveMode())
        return;

    for (AuraEffect* effect : GetAuraEffects())
    {
        if (!effect || effect->IsAreaAuraEffect() || effect->IsEffect(SPELL_EFFECT_PERSISTENT_AREA_AURA))
            continue;

        switch (effect->GetSpellEffectInfo()->ApplyAuraName)
        {
            case SPELL_AURA_PERIODIC_DAMAGE:
            case SPELL_AURA_PERIODIC_DAMAGE_PERCENT:
            case SPELL_AURA_PERIODIC_LEECH:
            {
                // ignore non positive values (can be result apply spellmods to aura damage
                uint32 damage = std::max(effect->GetAmount(), 0);

                // Script Hook For HandlePeriodicDamageAurasTick -- Allow scripts to change the Damage pre class mitigation calculations
                sScriptMgr->ModifyPeriodicDamageAurasTick(target, caster, damage);

                effect->SetDonePct(caster->SpellDamagePctDone(target, m_spellInfo, DOT)); // Calculate done percentage first!
                effect->SetDamage(caster->SpellDamageBonusDone(target, m_spellInfo, damage, DOT, effect->GetSpellEffectInfo(), GetStackAmount()) * effect->GetDonePct());
                effect->SetCritChance(caster->GetUnitSpellCriticalChance(target, m_spellInfo, m_spellInfo->GetSchoolMask()));
                break;
            }
            case SPELL_AURA_PERIODIC_HEAL:
            case SPELL_AURA_OBS_MOD_HEALTH:
            {
                // ignore non positive values (can be result apply spellmods to aura damage
                uint32 damage = std::max(effect->GetAmount(), 0);

                // Script Hook For HandlePeriodicDamageAurasTick -- Allow scripts to change the Damage pre class mitigation calculations
                sScriptMgr->ModifyPeriodicDamageAurasTick(target, caster, damage);

                effect->SetDonePct(caster->SpellHealingPctDone(target, m_spellInfo)); // Calculate done percentage first!
                effect->SetDamage(caster->SpellHealingBonusDone(target, m_spellInfo, damage, DOT, effect->GetSpellEffectInfo(), GetStackAmount()) * effect->GetDonePct());
                effect->SetCritChance(caster->GetUnitSpellCriticalChance(target, m_spellInfo, m_spellInfo->GetSchoolMask()));
                break;
            }
            default:
                break;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Aura::HasEffect ( uint8  effIndex ) const

inline

{ return GetEffect(effIndex) != NULL; }

Here is the caller graph for this function:

bool Aura::HasEffectType

(

AuraType

type

)

const

{
    for (AuraEffect* effect : GetAuraEffects())
    {
        if (effect && effect->GetAuraType() == type)
            return true;
    }
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Aura::HasMoreThanOneEffectForType

(

AuraType

auraType

)

const

{
    uint32 count = 0;
    for (SpellEffectInfo const* effect : GetSpellEffectInfos())
        if (effect && HasEffect(effect->EffectIndex) && AuraType(effect->ApplyAuraName) == auraType)
            ++count;

    return count > 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Aura::IsAppliedOnTarget ( ObjectGuid  guid ) const

inline

{ return m_applications.find(guid) != m_applications.end(); }

Here is the caller graph for this function:

bool Aura::IsArea

(

)

const

{
    for (SpellEffectInfo const* effect : GetSpellEffectInfos())
        if (effect && HasEffect(effect->EffectIndex) && effect->IsAreaAuraEffect())
            return true;

    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Aura::IsDeathPersistent

(

)

const

{
    return GetSpellInfo()->IsDeathPersistent();
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Aura::IsExpired ( ) const

inline

{ return !GetDuration() && !m_dropEvent; }

Here is the caller graph for this function:

bool Aura::IsPassive

(

)

const

{
    return GetSpellInfo()->IsPassive();
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Aura::IsPermanent ( ) const

inline

{ return GetMaxDuration() == -1; }

Here is the caller graph for this function:

bool Aura::IsProcOnCooldown

(

)

const

{
    /*if (m_procCooldown)
    {
        if (m_procCooldown > time(NULL))
            return true;
    }*/
    return false;
}

Here is the caller graph for this function:

bool Aura::IsProcTriggeredOnEvent	(	AuraApplication *	aurApp,
		ProcEventInfo &	eventInfo
	)		const

Todo:

Todo:

Todo:

this needs to be unified for all kinds of auras

{
    SpellProcEntry const* procEntry = sSpellMgr->GetSpellProcEntry(GetId());
    // only auras with spell proc entry can trigger proc
    if (!procEntry)
        return false;

    // check if we have charges to proc with
    if (IsUsingCharges() && !GetCharges())
        return false;

    // check proc cooldown
    if (IsProcOnCooldown())
        return false;

    // something about triggered spells triggering, and add extra attack effect

    // do checks against db data
    if (!sSpellMgr->CanSpellTriggerProcOnEvent(*procEntry, eventInfo))
        return false;

    // do checks using conditions table
    if (!sConditionMgr->IsObjectMeetingNotGroupedConditions(CONDITION_SOURCE_TYPE_SPELL_PROC, GetId(), eventInfo.GetActor(), eventInfo.GetActionTarget()))
        return false;

    // AuraScript Hook
    bool check = const_cast<Aura*>(this)->CallScriptCheckProcHandlers(aurApp, eventInfo);
    if (!check)
        return false;

    // do allow additional requirements for procs
    // this is needed because this is the last moment in which you can prevent aura charge drop on proc
    // and possibly a way to prevent default checks (if there're going to be any)

    // Check if current equipment meets aura requirements
    // do that only for passive spells
    Unit* target = aurApp->GetTarget();
    if (IsPassive() && target->GetTypeId() == TYPEID_PLAYER)
    {
        if (GetSpellInfo()->EquippedItemClass == ITEM_CLASS_WEAPON)
        {
            if (target->ToPlayer()->IsInFeralForm())
                return false;

            if (eventInfo.GetDamageInfo())
            {
                WeaponAttackType attType = eventInfo.GetDamageInfo()->GetAttackType();
                Item* item = NULL;
                if (attType == BASE_ATTACK || attType == RANGED_ATTACK)
                    item = target->ToPlayer()->GetUseableItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND);
                else if (attType == OFF_ATTACK)
                    item = target->ToPlayer()->GetUseableItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);

                if (!item || item->IsBroken() || item->GetTemplate()->GetClass() != ITEM_CLASS_WEAPON || !((1 << item->GetTemplate()->GetSubClass()) & GetSpellInfo()->EquippedItemSubClassMask))
                    return false;
            }
        }
        else if (GetSpellInfo()->EquippedItemClass == ITEM_CLASS_ARMOR)
        {
            // Check if player is wearing shield
            Item* item = target->ToPlayer()->GetUseableItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
            if (!item || item->IsBroken() || item->GetTemplate()->GetClass() != ITEM_CLASS_ARMOR || !((1 << item->GetTemplate()->GetSubClass()) & GetSpellInfo()->EquippedItemSubClassMask))
                return false;
        }
    }

    return roll_chance_f(CalcProcChance(*procEntry, eventInfo));
}

Here is the call graph for this function:

bool Aura::IsRemoved ( ) const

inline

{ return m_isRemoved; }

Here is the caller graph for this function:

bool Aura::IsRemovedOnShapeLost ( Unit *  target ) const

inline

        {
            return GetCasterGUID() == target->GetGUID()
                    && m_spellInfo->Stances
                    && !(m_spellInfo->AttributesEx2 & SPELL_ATTR2_NOT_NEED_SHAPESHIFT)
                    && !(m_spellInfo->Attributes & SPELL_ATTR0_NOT_SHAPESHIFT);
        }

Here is the call graph for this function:

bool Aura::IsSingleTarget ( ) const

inline

{return m_isSingleTarget; }

Here is the caller graph for this function:

bool Aura::IsSingleTargetWith

(

Aura const *

aura

)

const

{
    // Same spell?
    if (GetSpellInfo()->IsRankOf(aura->GetSpellInfo()))
        return true;

    SpellSpecificType spec = GetSpellInfo()->GetSpellSpecific();
    // spell with single target specific types
    switch (spec)
    {
        case SPELL_SPECIFIC_JUDGEMENT:
        case SPELL_SPECIFIC_MAGE_POLYMORPH:
            if (aura->GetSpellInfo()->GetSpellSpecific() == spec)
                return true;
            break;
        default:
            break;
    }

    if (HasEffectType(SPELL_AURA_CONTROL_VEHICLE) && aura->HasEffectType(SPELL_AURA_CONTROL_VEHICLE))
        return true;

    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Aura::IsUsingCharges ( ) const

inline

{ return m_isUsingCharges; }

Here is the caller graph for this function:

void Aura::LoadScripts

(

)

{
    sScriptMgr->CreateAuraScripts(m_spellInfo->Id, m_loadedScripts);
    for (std::list<AuraScript*>::iterator itr = m_loadedScripts.begin(); itr != m_loadedScripts.end();)
    {
        if (!(*itr)->_Load(this))
        {
            std::list<AuraScript*>::iterator bitr = itr;
            ++itr;
            delete (*bitr);
            m_loadedScripts.erase(bitr);
            continue;
        }
        TC_LOG_DEBUG("spells", "Aura::LoadScripts: Script `%s` for aura `%u` is loaded now", (*itr)->_GetScriptName()->c_str(), m_spellInfo->Id);
        (*itr)->Register();
        ++itr;
    }
}

Here is the caller graph for this function:

bool Aura::ModCharges	(	int32	num,
		AuraRemoveMode	removeMode = AURA_REMOVE_BY_DEFAULT
	)

{
    if (IsUsingCharges())
    {
        int32 charges = m_procCharges + num;
        int32 maxCharges = CalcMaxCharges();

        // limit charges (only on charges increase, charges may be changed manually)
        if ((num > 0) && (charges > int32(maxCharges)))
            charges = maxCharges;
        // we're out of charges, remove
        else if (charges <= 0)
        {
            Remove(removeMode);
            return true;
        }

        SetCharges(charges);
    }

    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::ModChargesDelayed	(	int32	num,
		AuraRemoveMode	removeMode = AURA_REMOVE_BY_DEFAULT
	)

{
    m_dropEvent = nullptr;
    ModCharges(num, removeMode);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Aura::ModStackAmount	(	int32	num,
		AuraRemoveMode	removeMode = AURA_REMOVE_BY_DEFAULT
	)

{
    int32 stackAmount = m_stackAmount + num;

    // limit the stack amount (only on stack increase, stack amount may be changed manually)
    if ((num > 0) && (stackAmount > int32(m_spellInfo->StackAmount)))
    {
        // not stackable aura - set stack amount to 1
        if (!m_spellInfo->StackAmount)
            stackAmount = 1;
        else
            stackAmount = m_spellInfo->StackAmount;
    }
    // we're out of stacks, remove
    else if (stackAmount <= 0)
    {
        Remove(removeMode);
        return true;
    }

    bool refresh = stackAmount >= GetStackAmount();

    // Update stack amount
    SetStackAmount(stackAmount);

    if (refresh)
    {
        RefreshSpellMods();
        RefreshTimers();

        // reset charges
        SetCharges(CalcMaxCharges());
        // FIXME: not a best way to synchronize charges, but works
        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
            if (AuraEffect* aurEff = GetEffect(i))
                if (aurEff->GetAuraType() == SPELL_AURA_ADD_FLAT_MODIFIER || aurEff->GetAuraType() == SPELL_AURA_ADD_PCT_MODIFIER)
                    if (SpellModifier* mod = aurEff->GetSpellModifier())
                        mod->charges = GetCharges();
    }

    SetNeedClientUpdateForTargets();
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::PrepareProcToTrigger	(	AuraApplication *	aurApp,
		ProcEventInfo &	eventInfo
	)

{
    bool prepare = CallScriptPrepareProcHandlers(aurApp, eventInfo);
    if (!prepare)
        return;

    // take one charge, aura expiration will be handled in Aura::TriggerProcOnEvent (if needed)
    if (IsUsingCharges())
    {
        --m_procCharges;
        SetNeedClientUpdateForTargets();
    }

    SpellProcEntry const* procEntry = sSpellMgr->GetSpellProcEntry(GetId());

    ASSERT(procEntry);

    // cooldowns should be added to the whole aura (see 51698 area aura)
    AddProcCooldown(procEntry->cooldown);
}

Here is the call graph for this function:

void Aura::RecalculateAmountOfEffects

(

)

{
    ASSERT (!IsRemoved());
    Unit* caster = GetCaster();
    for (AuraEffect* effect : GetAuraEffects())
        if (effect && !IsRemoved())
            effect->RecalculateAmount(caster);
}

Here is the call graph for this function:

void Aura::RefreshDuration

(

bool

withMods = false

)

{
    Unit* caster = GetCaster();
    if (withMods && caster)
    {
        int32 duration = m_spellInfo->GetMaxDuration();
        // Calculate duration of periodics affected by haste.
        if (caster->HasAuraTypeWithAffectMask(SPELL_AURA_PERIODIC_HASTE, m_spellInfo) || m_spellInfo->HasAttribute(SPELL_ATTR5_HASTE_AFFECT_DURATION))
            duration = int32(duration * caster->GetFloatValue(UNIT_MOD_CAST_SPEED));

        SetMaxDuration(duration);
        SetDuration(duration);
    }
    else
        SetDuration(GetMaxDuration());

    if (!m_periodicCosts.empty())
        m_timeCla = 1 * IN_MILLISECONDS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::RefreshSpellMods

(

)

{
    for (Aura::ApplicationMap::const_iterator appIter = m_applications.begin(); appIter != m_applications.end(); ++appIter)
        if (Player* player = appIter->second->GetTarget()->ToPlayer())
            player->RestoreAllSpellMods(0, this);
}

Here is the caller graph for this function:

void Aura::RefreshTimers

(

)

{
    m_maxDuration = CalcMaxDuration();
    bool resetPeriodic = true;
    if (m_spellInfo->HasAttribute(SPELL_ATTR8_DONT_RESET_PERIODIC_TIMER))
    {
        int32 minPeriod = m_maxDuration;
        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
            if (AuraEffect const* eff = GetEffect(i))
                if (int32 period = eff->GetPeriod())
                    minPeriod = std::min(period, minPeriod);

        // If only one tick remaining, roll it over into new duration
        if (GetDuration() <= minPeriod)
        {
            m_maxDuration += GetDuration();
            resetPeriodic = false;
        }
    }

    RefreshDuration();
    Unit* caster = GetCaster();
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if (HasEffect(i))
            GetEffect(i)->CalculatePeriodic(caster, resetPeriodic, false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void Aura::Remove ( AuraRemoveMode  removeMode = AURA_REMOVE_BY_DEFAULT )

pure virtual

Implemented in DynObjAura, and UnitAura.

Here is the caller graph for this function:

void Aura::SetCharges

(

uint8

charges

)

{
    if (m_procCharges == charges)
        return;

    m_procCharges = charges;
    m_isUsingCharges = m_procCharges != 0;
    SetNeedClientUpdateForTargets();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::SetDuration	(	int32	duration,
		bool	withMods = false
	)

{
    if (withMods)
        if (Unit* caster = GetCaster())
            if (Player* modOwner = caster->GetSpellModOwner())
                modOwner->ApplySpellMod(GetId(), SPELLMOD_DURATION, duration);

    m_duration = duration;
    SetNeedClientUpdateForTargets();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::SetIsSingleTarget ( bool  val )

inline

{ m_isSingleTarget = val; }

Here is the caller graph for this function:

void Aura::SetLoadedState	(	int32	maxDuration,
		int32	duration,
		int32	charges,
		uint8	stackAmount,
		uint32	recalculateMask,
		int32 *	amount
	)

{
    m_maxDuration = maxDuration;
    m_duration = duration;
    m_procCharges = charges;
    m_isUsingCharges = m_procCharges != 0;
    m_stackAmount = stackAmount;
    Unit* caster = GetCaster();
    for (AuraEffect* effect : GetAuraEffects())
    {
        if (!effect)
            continue;

        effect->SetAmount(amount[effect->GetEffIndex()]);
        effect->SetCanBeRecalculated((recalculateMask & (1 << effect->GetEffIndex())) != 0);
        effect->CalculatePeriodic(caster, false, true);
        effect->CalculateSpellMod();
        effect->RecalculateAmount(caster);
    }
}

Here is the call graph for this function:

void Aura::SetMaxDuration ( int32  duration )

inline

{ m_maxDuration = duration; }

Here is the caller graph for this function:

void Aura::SetNeedClientUpdateForTargets

(

)

const

{
    for (ApplicationMap::const_iterator appIter = m_applications.begin(); appIter != m_applications.end(); ++appIter)
        appIter->second->SetNeedClientUpdate();
}

Here is the caller graph for this function:

void Aura::SetStackAmount

(

uint8

num

)

{
    m_stackAmount = stackAmount;
    Unit* caster = GetCaster();

    std::list<AuraApplication*> applications;
    GetApplicationList(applications);

    for (std::list<AuraApplication*>::const_iterator apptItr = applications.begin(); apptItr != applications.end(); ++apptItr)
        if (!(*apptItr)->GetRemoveMode())
            HandleAuraSpecificMods(*apptItr, caster, false, true);

        for (AuraEffect* effect : GetAuraEffects())
            if (effect)
                effect->ChangeAmount(effect->CalculateAmount(caster), false, true);

    for (std::list<AuraApplication*>::const_iterator apptItr = applications.begin(); apptItr != applications.end(); ++apptItr)
        if (!(*apptItr)->GetRemoveMode())
        {
            HandleAuraSpecificMods(*apptItr, caster, true, true);
            HandleAuraSpecificPeriodics(*apptItr, caster);
        }

    SetNeedClientUpdateForTargets();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::SetUsingCharges ( bool  val )

inline

{ m_isUsingCharges = val; }

Here is the caller graph for this function:

void Aura::TriggerProcOnEvent	(	AuraApplication *	aurApp,
		ProcEventInfo &	eventInfo
	)

{
    CallScriptProcHandlers(aurApp, eventInfo);

    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if (aurApp->HasEffect(i))
            // OnEffectProc / AfterEffectProc hooks handled in AuraEffect::HandleProc()
            GetEffect(i)->HandleProc(aurApp, eventInfo);

    CallScriptAfterProcHandlers(aurApp, eventInfo);

    // Remove aura if we've used last charge to proc
    if (IsUsingCharges() && !GetCharges())
        Remove();
}

Here is the call graph for this function:

Aura * Aura::TryCreate ( SpellInfo const *  spellproto, uint32  tryEffMask, WorldObject *  owner, Unit *  caster, int32 *  baseAmount, Item *  castItem = NULL, ObjectGuid  casterGUID = ObjectGuid::Empty, int32  castItemLevel = -1  )

static

{
    ASSERT(spellproto);
    ASSERT(owner);
    ASSERT(caster || !casterGUID.IsEmpty());
    ASSERT(tryEffMask <= MAX_EFFECT_MASK);
    uint32 effMask = Aura::BuildEffectMaskForOwner(spellproto, tryEffMask, owner);
    if (!effMask)
        return NULL;
    return Create(spellproto, effMask, owner, caster, baseAmount, castItem, casterGUID, castItemLevel);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Aura * Aura::TryRefreshStackOrCreate ( SpellInfo const *  spellproto, uint32  tryEffMask, WorldObject *  owner, Unit *  caster, int32 *  baseAmount = NULL, Item *  castItem = NULL, ObjectGuid  casterGUID = ObjectGuid::Empty, bool *  refresh = NULL, int32  castItemLevel = -1  )

static

{
    ASSERT(spellproto);
    ASSERT(owner);
    ASSERT(caster || !casterGUID.IsEmpty());
    ASSERT(tryEffMask <= MAX_EFFECT_MASK);
    if (refresh)
        *refresh = false;
    uint32 effMask = Aura::BuildEffectMaskForOwner(spellproto, tryEffMask, owner);
    if (!effMask)
        return NULL;

    if (Aura* foundAura = owner->ToUnit()->_TryStackingOrRefreshingExistingAura(spellproto, effMask, caster, baseAmount, castItem, casterGUID, castItemLevel))
    {
        // we've here aura, which script triggered removal after modding stack amount
        // check the state here, so we won't create new Aura object
        if (foundAura->IsRemoved())
            return NULL;

        if (refresh)
            *refresh = true;
        return foundAura;
    }
    else
        return Create(spellproto, effMask, owner, caster, baseAmount, castItem, casterGUID, castItemLevel);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::UnregisterSingleTarget

(

)

{
    ASSERT(m_isSingleTarget);
    Unit* caster = GetCaster();
    ASSERT(caster);
    caster->GetSingleCastAuras().remove(this);
    SetIsSingleTarget(false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::Update	(	uint32	diff,
		Unit *	caster
	)

{
    if (m_duration > 0)
    {
        m_duration -= diff;
        if (m_duration < 0)
            m_duration = 0;

        // handle manaPerSecond/manaPerSecondPerLevel
        if (m_timeCla)
        {
            if (m_timeCla > int32(diff))
                m_timeCla -= diff;
            else if (caster)
            {
                if (!m_periodicCosts.empty())
                {
                    m_timeCla += 1000 - diff;

                    for (SpellPowerEntry const* power : m_periodicCosts)
                    {
                        if (power->RequiredAura && !caster->HasAura(power->RequiredAura))
                            continue;

                        int32 manaPerSecond = power->ManaCostPerSecond;
                        Powers powertype = Powers(power->PowerType);
                        if (powertype != POWER_HEALTH)
                            manaPerSecond += int32(CalculatePct(caster->GetMaxPower(powertype), power->ManaCostPercentagePerSecond));
                        else
                            manaPerSecond += int32(CalculatePct(caster->GetMaxHealth(), power->ManaCostPercentagePerSecond));

                        if (manaPerSecond)
                        {
                            if (powertype == POWER_HEALTH)
                            {
                                if (int32(caster->GetHealth()) > manaPerSecond)
                                    caster->ModifyHealth(-manaPerSecond);
                                else
                                    Remove();
                            }
                            else if (int32(caster->GetPower(powertype)) >= manaPerSecond)
                                caster->ModifyPower(powertype, -manaPerSecond);
                            else
                                Remove();
                        }
                    }
                }
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::UpdateOwner	(	uint32	diff,
		WorldObject *	owner
	)

{
    ASSERT(owner == m_owner);

    Unit* caster = GetCaster();
    // Apply spellmods for channeled auras
    // used for example when triggered spell of spell:10 is modded
    Spell* modSpell = NULL;
    Player* modOwner = NULL;
    if (caster)
    {
        modOwner = caster->GetSpellModOwner();
        if (modOwner)
        {
            modSpell = modOwner->FindCurrentSpellBySpellId(GetId());
            if (modSpell)
                modOwner->SetSpellModTakingSpell(modSpell, true);
        }
    }

    Update(diff, caster);

    if (m_updateTargetMapInterval <= int32(diff))
        UpdateTargetMap(caster);
    else
        m_updateTargetMapInterval -= diff;

    // update aura effects
    for (AuraEffect* effect : GetAuraEffects())
        if (effect)
            effect->Update(diff, caster);

    // remove spellmods after effects update
    if (modSpell)
        modOwner->SetSpellModTakingSpell(modSpell, false);

    _DeleteRemovedApplications();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Aura::UpdateTargetMap	(	Unit *	caster,
		bool	apply = true
	)

Todo:

There is a crash caused by shadowfiend load addon

{
    if (IsRemoved())
        return;

    m_updateTargetMapInterval = UPDATE_TARGET_MAP_INTERVAL;

    // fill up to date target list
    //       target, effMask
    std::map<Unit*, uint32> targets;

    FillTargetMap(targets, caster);

    UnitList targetsToRemove;

    // mark all auras as ready to remove
    for (ApplicationMap::iterator appIter = m_applications.begin(); appIter != m_applications.end();++appIter)
    {
        std::map<Unit*, uint32>::iterator existing = targets.find(appIter->second->GetTarget());
        // not found in current area - remove the aura
        if (existing == targets.end())
            targetsToRemove.push_back(appIter->second->GetTarget());
        else
        {
            // needs readding - remove now, will be applied in next update cycle
            // (dbcs do not have auras which apply on same type of targets but have different radius, so this is not really needed)
            if (appIter->second->GetEffectMask() != existing->second || !CanBeAppliedOn(existing->first))
                targetsToRemove.push_back(appIter->second->GetTarget());
            // nothing todo - aura already applied
            // remove from auras to register list
            targets.erase(existing);
        }
    }

    // register auras for units
    for (std::map<Unit*, uint32>::iterator itr = targets.begin(); itr!= targets.end();)
    {
        // aura mustn't be already applied on target
        if (AuraApplication * aurApp = GetApplicationOfTarget(itr->first->GetGUID()))
        {
            // the core created 2 different units with same guid
            // this is a major failue, which i can't fix right now
            // let's remove one unit from aura list
            // this may cause area aura "bouncing" between 2 units after each update
            // but because we know the reason of a crash we can remove the assertion for now
            if (aurApp->GetTarget() != itr->first)
            {
                // remove from auras to register list
                targets.erase(itr++);
                continue;
            }
            else
            {
                // ok, we have one unit twice in target map (impossible, but...)
                ABORT();
            }
        }

        bool addUnit = true;
        // check target immunities
        for (uint8 effIndex = 0; effIndex < MAX_SPELL_EFFECTS; ++effIndex)
        {
            if (itr->first->IsImmunedToSpellEffect(GetSpellInfo(), effIndex))
                itr->second &= ~(1 << effIndex);
        }
        if (!itr->second
            || itr->first->IsImmunedToSpell(GetSpellInfo())
            || !CanBeAppliedOn(itr->first))
            addUnit = false;

        if (addUnit && !itr->first->IsHighestExclusiveAura(this, true))
            addUnit = false;

        if (addUnit)
        {
            // persistent area aura does not hit flying targets
            if (GetType() == DYNOBJ_AURA_TYPE)
            {
                if (itr->first->IsInFlight())
                    addUnit = false;
            }
            // unit auras can not stack with each other
            else // (GetType() == UNIT_AURA_TYPE)
            {
                // Allow to remove by stack when aura is going to be applied on owner
                if (itr->first != GetOwner())
                {
                    // check if not stacking aura already on target
                    // this one prevents unwanted usefull buff loss because of stacking and prevents overriding auras periodicaly by 2 near area aura owners
                    for (Unit::AuraApplicationMap::iterator iter = itr->first->GetAppliedAuras().begin(); iter != itr->first->GetAppliedAuras().end(); ++iter)
                    {
                        Aura const* aura = iter->second->GetBase();
                        if (!CanStackWith(aura))
                        {
                            addUnit = false;
                            break;
                        }
                    }
                }
            }
        }
        if (!addUnit)
            targets.erase(itr++);
        else
        {
            // owner has to be in world, or effect has to be applied to self
            if (!GetOwner()->IsSelfOrInSameMap(itr->first))
            {
                TC_LOG_FATAL("spells", "Aura %u: Owner %s (map %u) is not in the same map as target %s (map %u).", GetSpellInfo()->Id,
                    GetOwner()->GetName().c_str(), GetOwner()->IsInWorld() ? GetOwner()->GetMap()->GetId() : uint32(-1),
                    itr->first->GetName().c_str(), itr->first->IsInWorld() ? itr->first->GetMap()->GetId() : uint32(-1));
                ABORT();
            }
            itr->first->_CreateAuraApplication(this, itr->second);
            ++itr;
        }
    }

    // remove auras from units no longer needing them
    for (UnitList::iterator itr = targetsToRemove.begin(); itr != targetsToRemove.end();++itr)
        if (AuraApplication * aurApp = GetApplicationOfTarget((*itr)->GetGUID()))
            (*itr)->_UnapplyAura(aurApp, AURA_REMOVE_BY_DEFAULT);

    if (!apply)
        return;

    // apply aura effects for units
    for (std::map<Unit*, uint32>::iterator itr = targets.begin(); itr!= targets.end();++itr)
    {
        if (AuraApplication * aurApp = GetApplicationOfTarget(itr->first->GetGUID()))
        {
            // owner has to be in world, or effect has to be applied to self
            ASSERT((!GetOwner()->IsInWorld() && GetOwner() == itr->first) || GetOwner()->IsInMap(itr->first));
            itr->first->_ApplyAura(aurApp, itr->second);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

Aura* Unit::_TryStackingOrRefreshingExistingAura ( SpellInfo const *  newAura, uint32  effMask, Unit *  caster, int32 *  baseAmount, Item *  castItem, ObjectGuid  casterGUID, int32  castItemLevel  )

friend

Member Data Documentation

AuraEffectVector Aura::_effects

private

SpellEffectInfoVector Aura::_spelEffectInfos

private

ApplicationMap Aura::m_applications

protected

time_t const Aura::m_applyTime

protected

ObjectGuid const Aura::m_casterGuid

protected

uint8 const Aura::m_casterLevel

protected

ObjectGuid const Aura::m_castItemGuid

protected

int32 Aura::m_castItemLevel

protected

ChargeDropEvent* Aura::m_dropEvent

protected

int32 Aura::m_duration

protected

bool Aura::m_isRemoved

protected

bool Aura::m_isSingleTarget

protected

bool Aura::m_isUsingCharges

protected

std::list<AuraScript*> Aura::m_loadedScripts

int32 Aura::m_maxDuration

protected

WorldObject* const Aura::m_owner

protected

std::vector<SpellPowerEntry const*> Aura::m_periodicCosts

protected

uint8 Aura::m_procCharges

protected

Unit::AuraApplicationList Aura::m_removedApplications

private

SpellInfo const* const Aura::m_spellInfo

protected

uint8 Aura::m_stackAmount

protected

int32 Aura::m_timeCla

protected

int32 Aura::m_updateTargetMapInterval

protected

---

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

• src/server/game/Spells/Auras/SpellAuras.h
• src/server/game/Spells/Auras/SpellAuras.cpp