#include "SpellAuras.h"

Inheritance diagram for Aura:

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

Public Member Functions
	Aura (SpellInfo const spellproto, WorldObject owner, Unit caster, Item castItem, ObjectGuid casterGUID, ObjectGuid itemGUID=ObjectGuid::Empty)

void	_InitEffects (uint8 effMask, Unit caster, int32 baseAmount)

virtual	~Aura ()

SpellInfo const *	GetSpellInfo () const

uint32	GetId () const

ObjectGuid	GetCastItemGUID () const

uint32	GetCastItemEntry () 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 , uint8 > &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 periodicReset=false)

void	RefreshTimersWithMods ()

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)

uint8	GetStackAmount () const

void	SetStackAmount (uint8 num)

bool	ModStackAmount (int32 num, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT, bool periodicReset=false)

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

void	SetLoadedState (int32 maxduration, int32 duration, int32 charges, uint8 stackamount, uint8 recalculateMask, int32 *amount)

bool	HasEffect (uint8 effIndex) const

bool	HasEffectType (AuraType type) const

AuraEffect *	GetEffect (uint8 effIndex) const

uint8	GetEffectMask () const

void	RecalculateAmountOfEffects ()

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

ApplicationMap const &	GetApplicationMap ()

void	GetApplicationList (std::list< AuraApplication * > &applicationList) const

AuraApplication const *	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)

bool	CanBeAppliedOn (Unit *target)

bool	CheckAreaTarget (Unit *target)

bool	CanStackWith (Aura const *existingAura) const

bool	IsAuraStronger (Aura const *newAura) const

bool	IsProcOnCooldown (TimePoint now) const

void	AddProcCooldown (TimePoint cooldownEnd)

void	AddProcCooldown (SpellProcEntry const *procEntry, TimePoint now)

void	ResetProcCooldown ()

bool	IsUsingCharges () const

void	SetUsingCharges (bool val)

void	PrepareProcToTrigger (AuraApplication *aurApp, ProcEventInfo &eventInfo, TimePoint now)

uint8	GetProcEffectMask (AuraApplication *aurApp, ProcEventInfo &eventInfo, TimePoint now) const

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

void	TriggerProcOnEvent (uint8 procEffectMask, AuraApplication *aurApp, ProcEventInfo &eventInfo)

void	ConsumeProcCharges (SpellProcEntry const *procEntry)

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	CallScriptCheckEffectProcHandlers (AuraEffect const aurEff, AuraApplication const aurApp, ProcEventInfo &eventInfo)

bool	CallScriptAfterCheckProcHandlers (AuraApplication const *aurApp, ProcEventInfo &eventInfo, bool isTriggeredAtSpellProcEvent)

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

template<class Script >
Script *	GetScript (std::string const &scriptName) const

virtual std::string	GetDebugInfo () const

void	SetTriggeredByAuraSpellInfo (SpellInfo const *triggeredByAuraSpellInfo)

SpellInfo const *	GetTriggeredByAuraSpellInfo () const

Static Public Member Functions
static uint8	BuildEffectMaskForOwner (SpellInfo const spellProto, uint8 avalibleEffectMask, WorldObject owner)

static Aura *	TryRefreshStackOrCreate (SpellInfo const spellproto, uint8 tryEffMask, WorldObject owner, Unit caster, int32 baseAmount=nullptr, Item castItem=nullptr, ObjectGuid casterGUID=ObjectGuid::Empty, bool refresh=nullptr, bool periodicReset=false)

static Aura *	TryCreate (SpellInfo const spellproto, uint8 effMask, WorldObject owner, Unit caster, int32 baseAmount=nullptr, Item *castItem=nullptr, ObjectGuid casterGUID=ObjectGuid::Empty, ObjectGuid itemGUID=ObjectGuid::Empty)

static Aura *	Create (SpellInfo const spellproto, uint8 effMask, WorldObject owner, Unit caster, int32 baseAmount, Item *castItem, ObjectGuid casterGUID, ObjectGuid itemGUID=ObjectGuid::Empty)

Public Attributes
std::list< AuraScript * >	m_loadedScripts

Protected Attributes
SpellInfo const *const	m_spellInfo

ObjectGuid const	m_casterGuid

ObjectGuid const	m_castItemGuid

uint32 const	m_castItemEntry

time_t const	m_applyTime

WorldObject *const	m_owner

int32	m_maxDuration

int32	m_duration

int32	m_timeCla

int32	m_updateTargetMapInterval

uint8 const	m_casterLevel

uint8	m_procCharges

uint8	m_stackAmount

AuraEffect *	m_effects [3]

ApplicationMap	m_applications

bool	m_isRemoved: 1

bool	m_isSingleTarget: 1

bool	m_isUsingCharges: 1

TimePoint	m_procCooldown

Private Member Functions
void	_DeleteRemovedApplications ()

Private Attributes
Unit::AuraApplicationList	m_removedApplications

SpellInfo const *	m_triggeredByAuraSpellInfo

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

Detailed Description

Member Typedef Documentation

◆ ApplicationMap

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

Constructor & Destructor Documentation

◆ Aura()

Aura::Aura	(	SpellInfo const *	spellproto,
		WorldObject *	owner,
		Unit *	caster,
		Item *	castItem,
		ObjectGuid	casterGUID,
		ObjectGuid	itemGUID = `ObjectGuid::Empty`
	)

explicit

                                                                                                                                      :
    m_spellInfo(spellproto), m_casterGuid(casterGUID ? casterGUID : caster->GetGUID()),
    m_castItemGuid(itemGUID ? itemGUID : castItem ? castItem->GetGUID() : ObjectGuid::Empty), m_castItemEntry(castItem ? castItem->GetEntry() : 0), m_applyTime(GameTime::GetGameTime().count()),
    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_triggeredByAuraSpellInfo(nullptr)
{
    if ((m_spellInfo->ManaPerSecond || m_spellInfo->ManaPerSecondPerLevel) && !m_spellInfo->HasAttribute(SPELL_ATTR2_NO_TARGET_PER_SECOND_COST))
        m_timeCla = 1 * IN_MILLISECONDS;
 
    m_maxDuration = CalcMaxDuration(caster);
    m_duration = m_maxDuration;
    m_procCharges = CalcMaxCharges(caster);
    m_isUsingCharges = m_procCharges != 0;
    memset(m_effects, 0, sizeof(m_effects));
    // m_casterLevel = cast item level/caster level, caster level should be saved to db, confirmed with sniffs
}

References CalcMaxCharges(), CalcMaxDuration(), SpellInfo::HasAttribute(), IN_MILLISECONDS, m_duration, m_effects, m_isUsingCharges, m_maxDuration, m_procCharges, m_spellInfo, m_timeCla, SpellInfo::ManaPerSecond, SpellInfo::ManaPerSecondPerLevel, and SPELL_ATTR2_NO_TARGET_PER_SECOND_COST.

◆ ~Aura()

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);
    }
 
    // free effects memory
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        delete m_effects[i];
 
    ASSERT(m_applications.empty());
    _DeleteRemovedApplications();
}

References _DeleteRemovedApplications(), ASSERT, m_applications, m_effects, m_loadedScripts, and MAX_SPELL_EFFECTS.

Member Function Documentation

◆ _ApplyEffectForTargets()

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);
        }
    }
}

References ASSERT, GetApplicationOfTarget(), GetOwner(), and m_applications.

Referenced by Spell::EffectApplyAreaAura(), Spell::EffectApplyAura(), and Spell::EffectPersistentAA().

◆ _ApplyForTarget()

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 (m_spellInfo->IsCooldownStartedOnEvent() && !m_castItemGuid && caster)
    {
        if (caster->IsPlayer())
        {
            caster->ToPlayer()->AddSpellAndCategoryCooldowns(m_spellInfo, 0, nullptr, true);
        }
        else
        {
            caster->ToCreature()->AddSpellCooldown(m_spellInfo->Id, 0, infinityCooldownDelay);
        }
    }
}

References Player::AddSpellAndCategoryCooldowns(), Creature::AddSpellCooldown(), ASSERT, Object::GetGUID(), SpellInfo::Id, infinityCooldownDelay, IsAppliedOnTarget(), SpellInfo::IsCooldownStartedOnEvent(), Object::IsPlayer(), m_applications, m_castItemGuid, m_spellInfo, Object::ToCreature(), and Object::ToPlayer().

Referenced by UnitAura::_ApplyForTarget(), and Unit::_CreateAuraApplication().

◆ _DeleteRemovedApplications()

void Aura::_DeleteRemovedApplications ( )

private

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

References m_removedApplications.

Referenced by UpdateOwner(), and ~Aura().

◆ _InitEffects()

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

{
    // shouldn't be in constructor - functions in AuraEffect::AuraEffect use polymorphism
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (effMask & (uint8(1) << i))
            m_effects[i] = new AuraEffect(this, i, baseAmount ? baseAmount + i : nullptr, caster);
        else
            m_effects[i] = nullptr;
    }
}

References m_effects, and MAX_SPELL_EFFECTS.

Referenced by DynObjAura::DynObjAura(), and UnitAura::UnitAura().

◆ _RegisterForTargets()

void Aura::_RegisterForTargets ( )

inline

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

Aura::GetCaster

Unit * GetCaster() const

Definition SpellAuras.cpp:415

Aura::UpdateTargetMap

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

Definition SpellAuras.cpp:532

Unit

Definition Unit.h:665

References GetCaster(), and UpdateTargetMap().

Referenced by Spell::DoSpellHitOnUnit(), and Spell::EffectPersistentAA().

◆ _Remove()

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

References Unit::_UnapplyAura(), ASSERT, AuraApplication::GetTarget(), m_applications, and m_isRemoved.

Referenced by DynObjAura::Remove(), DynamicObject::RemoveAura(), and Unit::RemoveOwnedAura().

◆ _UnapplyForTarget()

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())
    {
        LOG_ERROR("spells.aura", "Aura::_UnapplyForTarget, target:{}, caster:{}, spell:{} was not found in owners application map!",
                       target->GetGUID().ToString(), caster ? caster->GetGUID().ToString() : "", 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 (m_spellInfo->IsCooldownStartedOnEvent() && !m_castItemGuid && caster)
    {
        if (caster->IsPlayer())
        {
            // note: item based cooldowns and cooldown spell mods with charges ignored (unknown existed cases)
            caster->ToPlayer()->SendCooldownEvent(GetSpellInfo());
        }
        else
        {
            caster->ToCreature()->AddSpellCooldown(m_spellInfo->Id, 0, 0);
 
            if (Unit* owner = caster->GetCharmerOrOwner())
            {
                if (Player* playerOwner = owner->ToPlayer())
                {
                    WorldPacket data(SMSG_COOLDOWN_EVENT, 4 + 8);
                    data << uint32(m_spellInfo->Id);
                    data << caster->GetGUID();
                    playerOwner->SendDirectMessage(&data);
                }
            }
        }
    }
 
    if (caster && caster->IsPlayer())
    {
        if (GetSpellInfo()->IsCooldownStartedOnEvent() && !m_castItemGuid)
        {
            // note: item based cooldowns and cooldown spell mods with charges ignored (unknown existed cases)
            caster->ToPlayer()->SendCooldownEvent(GetSpellInfo());
        }
    }
}

References ABORT, Creature::AddSpellCooldown(), ASSERT, AuraApplication::GetBase(), Unit::GetCharmerOrOwner(), Object::GetGUID(), AuraApplication::GetRemoveMode(), GetSpellInfo(), SpellInfo::Id, SpellInfo::IsCooldownStartedOnEvent(), Object::IsPlayer(), LOG_ERROR, m_applications, m_castItemGuid, m_removedApplications, m_spellInfo, Player::SendCooldownEvent(), SMSG_COOLDOWN_EVENT, Object::ToCreature(), Object::ToPlayer(), and ObjectGuid::ToString().

Referenced by Unit::_UnapplyAura(), and UnitAura::_UnapplyForTarget().

◆ AddProcCooldown() [1/2]

void Aura::AddProcCooldown	(	SpellProcEntry const *	procEntry,
		TimePoint	now
	)

{
    AddProcCooldown(now + procEntry->Cooldown);
}

References AddProcCooldown(), and SpellProcEntry::Cooldown.

◆ AddProcCooldown() [2/2]

void Aura::AddProcCooldown ( TimePoint cooldownEnd )

{
    m_procCooldown = cooldownEnd;
}

References m_procCooldown.

Referenced by AddProcCooldown(), and PrepareProcToTrigger().

◆ ApplyForTargets()

void Aura::ApplyForTargets ( )

inline

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

References GetCaster(), and UpdateTargetMap().

Referenced by Unit::AddAura().

◆ BuildEffectMaskForOwner()

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

static

{
    ASSERT_NODEBUGINFO(spellProto);
    ASSERT_NODEBUGINFO(owner);
    uint8 effMask = 0;
    switch (owner->GetTypeId())
    {
        case TYPEID_UNIT:
        case TYPEID_PLAYER:
            for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
            {
                if (spellProto->Effects[i].IsUnitOwnedAuraEffect())
                    effMask |= 1 << i;
            }
            break;
        case TYPEID_DYNAMICOBJECT:
            for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
            {
                if (spellProto->Effects[i].Effect == SPELL_EFFECT_PERSISTENT_AREA_AURA)
                    effMask |= 1 << i;
            }
            break;
        default:
            break;
    }
    return effMask & avalibleEffectMask;
}

References ASSERT_NODEBUGINFO, SpellInfo::Effects, Object::GetTypeId(), MAX_SPELL_EFFECTS, SPELL_EFFECT_PERSISTENT_AREA_AURA, TYPEID_DYNAMICOBJECT, TYPEID_PLAYER, and TYPEID_UNIT.

Referenced by TryCreate(), and TryRefreshStackOrCreate().

◆ CalcDispelChance()

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);
 
    resistChance = resistChance < 0 ? 0 : resistChance;
    resistChance = resistChance > 100 ? 100 : resistChance;
    return 100 - resistChance;
}

References GetCaster(), GetId(), Unit::GetSpellModOwner(), Unit::GetTotalAuraModifier(), SPELL_AURA_MOD_DISPEL_RESIST, and SPELLMOD_RESIST_DISPEL_CHANCE.

Referenced by Spell::EffectDispelMechanic().

◆ CalcMaxCharges() [1/2]

uint8 Aura::CalcMaxCharges ( ) const

inline

144{ return CalcMaxCharges(GetCaster()); }

References CalcMaxCharges(), and GetCaster().

Referenced by Aura(), CalcMaxCharges(), ModCharges(), and ModStackAmount().

◆ CalcMaxCharges() [2/2]

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 maxProcCharges;
}

References GetId(), Unit::GetSpellModOwner(), m_spellInfo, SpellInfo::ProcCharges, SPELLMOD_CHARGES, and sSpellMgr.

Referenced by AuraScript::CalcMaxCharges().

◆ CalcMaxDuration() [1/2]

int32 Aura::CalcMaxDuration ( ) const

inline

131{ return CalcMaxDuration(GetCaster()); }

References CalcMaxDuration(), and GetCaster().

Referenced by Aura(), CalcMaxDuration(), AuraScript::CalcMaxDuration(), RefreshTimers(), and RefreshTimersWithMods().

◆ CalcMaxDuration() [2/2]

int32 Aura::CalcMaxDuration ( Unit * caster ) const

{
    Player* modOwner = nullptr;
    int32 maxDuration;
 
    if (caster)
    {
        modOwner = caster->GetSpellModOwner();
        maxDuration = caster->CalcSpellDuration(m_spellInfo);
    }
    else
        maxDuration = m_spellInfo->GetDuration();
 
    if (IsPassive() && !m_spellInfo->DurationEntry)
        maxDuration = -1;
 
    sScriptMgr->OnCalcMaxDuration(this, maxDuration);
 
    // IsPermanent() checks max duration (which we are supposed to calculate here)
    if (maxDuration != -1 && modOwner)
        modOwner->ApplySpellMod(GetId(), SPELLMOD_DURATION, maxDuration);
    return maxDuration;
}

References Player::ApplySpellMod(), Unit::CalcSpellDuration(), SpellInfo::DurationEntry, SpellInfo::GetDuration(), GetId(), Unit::GetSpellModOwner(), IsPassive(), m_spellInfo, SPELLMOD_DURATION, and sScriptMgr.

◆ CalcProcChance()

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())
    {
        // If PPM exists calculate chance from PPM
        if ((eventInfo.GetDamageInfo() || eventInfo.GetHealInfo()) && procEntry.ProcsPerMinute != 0)
        {
            SpellInfo const* procSpell = eventInfo.GetSpellInfo();
            uint32 attackSpeed = 0;
            if (!procSpell || procSpell->DmgClass == SPELL_DAMAGE_CLASS_MELEE || procSpell->IsRangedWeaponSpell())
            {
                attackSpeed = caster->GetAttackTime(eventInfo.GetDamageInfo()->GetAttackType());
            }
            else // spells use their cast time for PPM calculations
            {
                if (procSpell->CastTimeEntry)
                    attackSpeed = procSpell->CastTimeEntry->CastTime;
 
                // instants and fast spells use 1.5s cast speed
                if (attackSpeed < 1500)
                    attackSpeed = 1500;
            }
            chance = caster->GetPPMProcChance(attackSpeed, procEntry.ProcsPerMinute, 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);
    }
 
    // proc chance is reduced by an additional 3.333% per level past 60
    if ((procEntry.AttributesMask & PROC_ATTR_REDUCE_PROC_60) && eventInfo.GetActor()->GetLevel() > 60)
        chance = std::max(0.f, (1.f - ((eventInfo.GetActor()->GetLevel() - 60) * 1.f / 30.f)) * chance);
 
    return chance;
}

References SpellProcEntry::AttributesMask, SpellCastTimesEntry::CastTime, SpellInfo::CastTimeEntry, SpellProcEntry::Chance, SpellInfo::DmgClass, ProcEventInfo::GetActor(), DamageInfo::GetAttackType(), GetCaster(), ProcEventInfo::GetDamageInfo(), ProcEventInfo::GetHealInfo(), GetId(), Unit::GetLevel(), ProcEventInfo::GetSpellInfo(), GetSpellInfo(), Unit::GetSpellModOwner(), SpellInfo::IsRangedWeaponSpell(), PROC_ATTR_REDUCE_PROC_60, SpellProcEntry::ProcsPerMinute, SPELL_DAMAGE_CLASS_MELEE, and SPELLMOD_CHANCE_OF_SUCCESS.

Referenced by GetProcEffectMask().

◆ CallScriptAfterCheckProcHandlers()

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

{
    bool result = isTriggeredAtSpellProcEvent;
    for (std::list<AuraScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
    {
        (*scritr)->_PrepareScriptCall(AURA_SCRIPT_HOOK_AFTER_CHECK_PROC, aurApp);
        std::list<AuraScript::AfterCheckProcHandler>::iterator hookItrEnd = (*scritr)->DoAfterCheckProc.end(), hookItr = (*scritr)->DoAfterCheckProc.begin();
        for (; hookItr != hookItrEnd; ++hookItr)
            result &= hookItr->Call(*scritr, eventInfo, isTriggeredAtSpellProcEvent);
 
        (*scritr)->_FinishScriptCall();
    }
 
    return result;
}

References AURA_SCRIPT_HOOK_AFTER_CHECK_PROC, and m_loadedScripts.

◆ CallScriptAfterDispel()

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

References AURA_SCRIPT_HOOK_AFTER_DISPEL, and m_loadedScripts.

Referenced by Unit::RemoveAurasDueToSpellByDispel().

◆ CallScriptAfterEffectApplyHandlers()

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

References AURA_SCRIPT_HOOK_EFFECT_AFTER_APPLY, AuraEffect::GetEffIndex(), m_loadedScripts, and m_spellInfo.

Referenced by AuraEffect::HandleEffect().

◆ CallScriptAfterEffectProcHandlers()

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

References AURA_SCRIPT_HOOK_EFFECT_AFTER_PROC, AuraEffect::GetEffIndex(), m_loadedScripts, and m_spellInfo.

Referenced by AuraEffect::HandleProc().

◆ CallScriptAfterEffectRemoveHandlers()

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

References AURA_SCRIPT_HOOK_EFFECT_AFTER_REMOVE, AuraEffect::GetEffIndex(), m_loadedScripts, and m_spellInfo.

Referenced by AuraEffect::HandleEffect().

◆ CallScriptAfterProcHandlers()

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

References AURA_SCRIPT_HOOK_AFTER_PROC, and m_loadedScripts.

Referenced by TriggerProcOnEvent().

◆ CallScriptCheckAreaTargetHandlers()

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;
}

References AURA_SCRIPT_HOOK_CHECK_AREA_TARGET, and m_loadedScripts.

Referenced by CheckAreaTarget().

◆ CallScriptCheckEffectProcHandlers()

bool Aura::CallScriptCheckEffectProcHandlers	(	AuraEffect const *	aurEff,
		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_EFFECT_PROC, aurApp);
        std::list<AuraScript::CheckEffectProcHandler>::iterator effEndItr = (*scritr)->DoCheckEffectProc.end(), effItr = (*scritr)->DoCheckEffectProc.begin();
        for (; effItr != effEndItr; ++effItr)
            if (effItr->IsEffectAffected(m_spellInfo, aurEff->GetEffIndex()))
                result &= effItr->Call(*scritr, aurEff, eventInfo);
 
        (*scritr)->_FinishScriptCall();
    }
 
    return result;
}

References AURA_SCRIPT_HOOK_CHECK_EFFECT_PROC, AuraEffect::GetEffIndex(), m_loadedScripts, and m_spellInfo.

Referenced by AuraEffect::CheckEffectProc().

◆ CallScriptCheckProcHandlers()

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;
}

References AURA_SCRIPT_HOOK_CHECK_PROC, and m_loadedScripts.

Referenced by GetProcEffectMask().

◆ CallScriptDispel()

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

References AURA_SCRIPT_HOOK_DISPEL, and m_loadedScripts.

Referenced by Unit::RemoveAurasDueToSpellByDispel().

◆ CallScriptEffectAbsorbHandlers()

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

References AURA_SCRIPT_HOOK_EFFECT_ABSORB, AuraEffect::GetEffIndex(), m_loadedScripts, and m_spellInfo.

Referenced by Unit::CalcAbsorbResist().

◆ CallScriptEffectAfterAbsorbHandlers()

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

References AURA_SCRIPT_HOOK_EFFECT_AFTER_ABSORB, AuraEffect::GetEffIndex(), m_loadedScripts, and m_spellInfo.

Referenced by Unit::CalcAbsorbResist().

◆ CallScriptEffectAfterManaShieldHandlers()

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

References AURA_SCRIPT_HOOK_EFFECT_AFTER_MANASHIELD, AuraEffect::GetEffIndex(), m_loadedScripts, and m_spellInfo.

Referenced by Unit::CalcAbsorbResist().

◆ CallScriptEffectApplyHandlers()

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;
}

References AURA_SCRIPT_HOOK_EFFECT_APPLY, AuraEffect::GetEffIndex(), m_loadedScripts, and m_spellInfo.

Referenced by AuraEffect::HandleEffect().

◆ CallScriptEffectCalcAmountHandlers()

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

References AURA_SCRIPT_HOOK_EFFECT_CALC_AMOUNT, AuraEffect::GetEffIndex(), m_loadedScripts, and m_spellInfo.

Referenced by AuraEffect::CalculateAmount().

◆ CallScriptEffectCalcPeriodicHandlers()

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

References AURA_SCRIPT_HOOK_EFFECT_CALC_PERIODIC, AuraEffect::GetEffIndex(), m_loadedScripts, and m_spellInfo.

Referenced by AuraEffect::CalculatePeriodic().

◆ CallScriptEffectCalcSpellModHandlers()

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

References AURA_SCRIPT_HOOK_EFFECT_CALC_SPELLMOD, AuraEffect::GetEffIndex(), m_loadedScripts, and m_spellInfo.

Referenced by AuraEffect::CalculateSpellMod().

◆ CallScriptEffectManaShieldHandlers()

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

References AURA_SCRIPT_HOOK_EFFECT_MANASHIELD, AuraEffect::GetEffIndex(), m_loadedScripts, and m_spellInfo.

Referenced by Unit::CalcAbsorbResist().

◆ CallScriptEffectPeriodicHandlers()

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;
}

References AURA_SCRIPT_HOOK_EFFECT_PERIODIC, AuraEffect::GetEffIndex(), m_loadedScripts, and m_spellInfo.

Referenced by AuraEffect::PeriodicTick().

◆ CallScriptEffectProcHandlers()

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;
}

References AURA_SCRIPT_HOOK_EFFECT_PROC, AuraEffect::GetEffIndex(), m_loadedScripts, and m_spellInfo.

Referenced by AuraEffect::HandleProc().

◆ CallScriptEffectRemoveHandlers()

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;
}

References AURA_SCRIPT_HOOK_EFFECT_REMOVE, AuraEffect::GetEffIndex(), m_loadedScripts, and m_spellInfo.

Referenced by AuraEffect::HandleEffect().

◆ CallScriptEffectSplitHandlers()

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

References AURA_SCRIPT_HOOK_EFFECT_SPLIT, AuraEffect::GetEffIndex(), m_loadedScripts, and m_spellInfo.

◆ CallScriptEffectUpdatePeriodicHandlers()

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

References AURA_SCRIPT_HOOK_EFFECT_UPDATE_PERIODIC, AuraEffect::GetEffIndex(), m_loadedScripts, and m_spellInfo.

Referenced by AuraEffect::UpdatePeriodic().

◆ CallScriptPrepareProcHandlers()

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;
}

References AURA_SCRIPT_HOOK_PREPARE_PROC, and m_loadedScripts.

Referenced by PrepareProcToTrigger().

◆ CallScriptProcHandlers()

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;
}

References AURA_SCRIPT_HOOK_PROC, and m_loadedScripts.

Referenced by TriggerProcOnEvent().

◆ CanBeAppliedOn()

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;
        // not selfcasted single target auras mustn't be applied
        if (GetCasterGUID() != GetOwner()->GetGUID() && GetSpellInfo()->IsSingleTarget())
            return false;
        return true;
    }
    else
        return CheckAreaTarget(target);
}

References CheckAreaTarget(), GetCasterGUID(), GetOwner(), GetSpellInfo(), Unit::IsDuringRemoveFromWorld(), Object::IsInWorld(), and IsSingleTarget().

Referenced by UpdateTargetMap().

◆ CanBeSaved()

bool Aura::CanBeSaved ( ) const

{
    SpellInfo const* spellInfo = GetSpellInfo();
 
    if (spellInfo->HasAttribute(SPELL_ATTR0_CU_FORCE_AURA_SAVING))
    {
        return true;
    }
 
    if (spellInfo->HasAttribute(SPELL_ATTR0_CU_AURA_CANNOT_BE_SAVED))
    {
        return false;
    }
 
    if (IsPassive() || (spellInfo->HasAttribute(SPELL_ATTR0_DO_NOT_DISPLAY) && spellInfo->Stances))
    {
        return false;
    }
 
    // Xinef: do not save channel auras
    if (GetSpellInfo()->IsChanneled())
    {
        return false;
    }
 
    // Xinef: Check if aura is single target, not only spell info
    if (GetCasterGUID() != GetOwner()->GetGUID() && (GetSpellInfo()->IsSingleTarget() || IsSingleTarget()))
    {
        return false;
    }
 
    // don't save auras removed by proc system
    if (IsUsingCharges() && !GetCharges())
    {
        return false;
    }
 
    return true;
}

References GetCasterGUID(), GetCharges(), GetOwner(), GetSpellInfo(), SpellInfo::HasAttribute(), IsPassive(), IsSingleTarget(), IsUsingCharges(), SPELL_ATTR0_CU_AURA_CANNOT_BE_SAVED, SPELL_ATTR0_CU_FORCE_AURA_SAVING, SPELL_ATTR0_DO_NOT_DISPLAY, and SpellInfo::Stances.

◆ CanBeSentToClient()

bool Aura::CanBeSentToClient ( ) const

{
    return !IsPassive() || GetSpellInfo()->HasAreaAuraEffect() || HasEffectType(SPELL_AURA_ABILITY_IGNORE_AURASTATE);
}

References GetSpellInfo(), SpellInfo::HasAreaAuraEffect(), HasEffectType(), IsPassive(), and SPELL_AURA_ABILITY_IGNORE_AURASTATE.

Referenced by Spell::EffectSummonPet().

◆ CanStackWith()

bool Aura::CanStackWith ( Aura const * existingAura ) const

{
    // Can stack with self
    if (this == existingAura)
        return true;
 
    SpellInfo const* existingSpellInfo = existingAura->GetSpellInfo();
    bool sameCaster = GetCasterGUID() == existingAura->GetCasterGUID();
 
    // Dynobj auras always stack
    // xinef: dont allow different ranks (or the same rank) of same spell to stack (many flamestrikes for example)
    if (existingAura->GetType() == DYNOBJ_AURA_TYPE)
    {
        // xinef: desecration lag fix - bound this condition to periodics
        if (sameCaster && GetSpellInfo()->Id == existingSpellInfo->Id && GetSpellInfo()->HasAura(SPELL_AURA_PERIODIC_DAMAGE))
            return false;
        return true;
    }
 
    // passive auras don't stack with another rank of the spell cast by same caster
    // Exception: item-sourced auras from different items can stack (e.g., weapon imbues on MH/OH)
    if (IsPassive() && sameCaster && (m_spellInfo->IsDifferentRankOf(existingSpellInfo) || (m_spellInfo->Id == existingSpellInfo->Id && m_castItemGuid.IsEmpty())))
    {
        // Allow stacking if both auras are from different items
        if (!(GetCastItemGUID() && existingAura->GetCastItemGUID() && GetCastItemGUID() != existingAura->GetCastItemGUID()))
            return false;
    }
 
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        // prevent remove triggering aura by triggered aura
        if (existingSpellInfo->Effects[i].TriggerSpell == GetId()
                // prevent remove triggered aura by triggering aura refresh
                || m_spellInfo->Effects[i].TriggerSpell == existingAura->GetId())
            return true;
    }
 
    // 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_DOT_STACKING_RULE))
            return true;
 
        // check same periodic auras
        for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        {
            switch (m_spellInfo->Effects[i].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:
                    // periodic auras which target areas are not allowed to stack this way (replenishment for example)
                    if (m_spellInfo->Effects[i].IsTargetingArea() || existingSpellInfo->Effects[i].IsTargetingArea())
                        break;
                    return true;
                default:
                    break;
            }
        }
    }
 
    uint8 VehicleAura1 = 0;
    uint8 VehicleAura2 = 0;
    uint8 i = 0;
    while (i < MAX_SPELL_EFFECTS && !(VehicleAura1 && VehicleAura2))
    {
        if (m_spellInfo->Effects[i].ApplyAuraName == SPELL_AURA_CONTROL_VEHICLE)
            VehicleAura1 = i + 1;
        if (existingSpellInfo->Effects[i].ApplyAuraName == SPELL_AURA_CONTROL_VEHICLE)
            VehicleAura2 = i + 1;
 
        ++i;
    }
 
    if (VehicleAura1 && VehicleAura2)
    {
        Vehicle* veh = nullptr;
        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;
 
        // xinef: allow direct auras to stack if there is no passenger in this slot
        if (AuraEffect* aurEff = GetEffect(VehicleAura1 - 1))
            if (aurEff->GetAmount() > 0)
                if (!veh->GetPassenger(aurEff->GetAmount() - 1))
                    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) && !(m_spellInfo->SpellFamilyName == SPELLFAMILY_HUNTER && m_spellInfo->SpellFamilyFlags[1] & 0x80000000))
    {
        // don't allow passive area auras to stack
        if (m_spellInfo->IsMultiSlotAura() && !IsArea())
            return true;
 
        // Allow item-sourced auras from different items to stack (e.g., weapon imbues on MH/OH, enchant procs)
        if ((IsPassive() || m_spellInfo->HasAttribute(SPELL_ATTR0_CU_ENCHANT_PROC)) && GetCastItemGUID() && existingAura->GetCastItemGUID() && GetCastItemGUID() != existingAura->GetCastItemGUID())
            return true;
 
        // same spell with same caster should not stack
        return false;
    }
 
    return true;
}

Referenced by Unit::_RemoveNoStackAurasDueToAura(), and UpdateTargetMap().

◆ CheckAreaTarget()

bool Aura::CheckAreaTarget ( Unit * target )

{
    return CallScriptCheckAreaTargetHandlers(target);
}

References CallScriptCheckAreaTargetHandlers().

Referenced by CanBeAppliedOn().

◆ ConsumeProcCharges()

void Aura::ConsumeProcCharges ( SpellProcEntry const * procEntry )

{
    // Remove aura if we've used last charge to proc
    if (procEntry->AttributesMask & PROC_ATTR_USE_STACKS_FOR_CHARGES)
    {
        ModStackAmount(-1);
    }
    else if (IsUsingCharges())
    {
        if (!GetCharges())
            Remove();
    }
}

References SpellProcEntry::AttributesMask, GetCharges(), IsUsingCharges(), ModStackAmount(), PROC_ATTR_USE_STACKS_FOR_CHARGES, and Remove().

Referenced by TriggerProcOnEvent().

◆ Create()

Aura * Aura::Create	(	SpellInfo const *	spellproto,
		uint8	effMask,
		WorldObject *	owner,
		Unit *	caster,
		int32 *	baseAmount,
		Item *	castItem,
		ObjectGuid	casterGUID,
		ObjectGuid	itemGUID = `ObjectGuid::Empty`
	)

static

{
    ASSERT_NODEBUGINFO(effMask);
    ASSERT_NODEBUGINFO(spellproto);
    ASSERT_NODEBUGINFO(owner);
    ASSERT_NODEBUGINFO(caster || casterGUID);
    ASSERT_NODEBUGINFO(effMask <= MAX_EFFECT_MASK);
    // try to get caster of aura
    if (casterGUID)
    {
        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->IsUnit())
        if (!owner->IsInWorld() || ((Unit*)owner)->IsDuringRemoveFromWorld())
            // owner not in world so don't allow to own not self casted single target auras
            if (casterGUID != owner->GetGUID() && spellproto->IsSingleTarget())
                return nullptr;
 
    Aura* aura = nullptr;
    switch (owner->GetTypeId())
    {
        case TYPEID_UNIT:
        case TYPEID_PLAYER:
            aura = new UnitAura(spellproto, effMask, owner, caster, baseAmount, castItem, casterGUID, itemGUID);
            break;
        case TYPEID_DYNAMICOBJECT:
            aura = new DynObjAura(spellproto, effMask, owner, caster, baseAmount, castItem, casterGUID, itemGUID);
            break;
        default:
            ABORT();
            return nullptr;
    }
    // aura can be removed in Unit::_AddAura call
    if (aura->IsRemoved())
        return nullptr;
    return aura;
}

References ABORT, ASSERT_NODEBUGINFO, Object::GetGUID(), Object::GetTypeId(), ObjectAccessor::GetUnit(), Object::IsInWorld(), IsRemoved(), SpellInfo::IsSingleTarget(), Object::IsUnit(), MAX_EFFECT_MASK, Object::ToUnit(), TYPEID_DYNAMICOBJECT, TYPEID_PLAYER, and TYPEID_UNIT.

Referenced by TryCreate(), and TryRefreshStackOrCreate().

◆ DropCharge()

bool Aura::DropCharge ( AuraRemoveMode removeMode = AURA_REMOVE_BY_DEFAULT )

inline

146{ return ModCharges(-1, removeMode); }

Aura::ModCharges

bool ModCharges(int32 num, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)

Definition SpellAuras.cpp:920

References ModCharges().

Referenced by AuraScript::DropCharge(), spell_sha_static_shock::HandleProc(), and Player::RemoveSpellMods().

◆ FillTargetMap()

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

pure virtual

Implemented in UnitAura, and DynObjAura.

Referenced by UpdateTargetMap().

◆ GetApplicationList()

void Aura::GetApplicationList ( std::list< AuraApplication * > & 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);
    }
}

References m_applications.

Referenced by SetStackAmount().

◆ GetApplicationMap()

ApplicationMap const & Aura::GetApplicationMap ( )

inline

182{return m_applications;}

References m_applications.

Referenced by AuraEffect::GetApplicationList(), AuraEffect::GetTargetList(), and Unit::RemoveAreaAurasDueToLeaveWorld().

◆ GetApplicationOfTarget() [1/2]

AuraApplication * Aura::GetApplicationOfTarget ( ObjectGuid guid )

inline

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

References m_applications.

◆ GetApplicationOfTarget() [2/2]

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

inline

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

References m_applications.

Referenced by Unit::_ApplyAuraEffect(), _ApplyEffectForTargets(), Unit::_UnapplyAura(), Unit::CalcAbsorbResist(), Spell::DoSpellHitOnUnit(), Spell::EffectDispelMechanic(), Spell::EffectStealBeneficialBuff(), GetCaster(), AuraEffect::HandleEffect(), Unit::IsHighestExclusiveAuraEffect(), Unit::RemoveAura(), Unit::RemoveAura(), Unit::RemoveAurasByType(), Unit::RestoreDisplayId(), and UpdateTargetMap().

◆ GetApplyTime()

time_t Aura::GetApplyTime ( ) const

inline

128{ return m_applyTime; }

References m_applyTime.

Referenced by Player::DuelComplete(), AuraScript::GetApplyTime(), and spell_rog_glyph_of_backstab::HandleProc().

◆ GetCaster()

Unit * Aura::GetCaster ( ) const

{
    if (GetOwner()->GetGUID() == GetCasterGUID())
        return GetUnitOwner();
    if (AuraApplication const* aurApp = GetApplicationOfTarget(GetCasterGUID()))
        return aurApp->GetTarget();
 
    return ObjectAccessor::GetUnit(*GetOwner(), GetCasterGUID());
}

References GetApplicationOfTarget(), GetCasterGUID(), GetOwner(), ObjectAccessor::GetUnit(), and GetUnitOwner().

Referenced by Unit::_ApplyAura(), Unit::_CreateAuraApplication(), _RegisterForTargets(), Unit::_UnapplyAura(), SpellInfo::ApplyAllSpellImmunitiesTo(), ApplyForTargets(), CalcDispelChance(), CalcMaxCharges(), CalcMaxDuration(), CalcProcChance(), AuraEffect::GetCaster(), AuraScript::GetCaster(), RecalculateAmountOfEffects(), RefreshDuration(), RefreshTimers(), RefreshTimersWithMods(), Unit::RemoveAurasDueToSpellByDispel(), Unit::RemoveAurasDueToSpellBySteal(), SetDuration(), SetLoadedState(), SetStackAmount(), UnregisterSingleTarget(), UpdateOwner(), and UpdateTargetMap().

◆ GetCasterGUID()

ObjectGuid Aura::GetCasterGUID ( ) const

inline

105{ return m_casterGuid; }

References m_casterGuid.

Referenced by Unit::_AddAura(), AuraApplication::_InitFlags(), Unit::_UnapplyAura(), AuraEffect::ApplySpellMod(), AuraApplication::BuildUpdatePacket(), CanBeAppliedOn(), CanBeSaved(), CanStackWith(), Unit::DelayOwnedAuras(), Player::DuelComplete(), Spell::EffectDispelMechanic(), Unit::GetAuraApplication(), GetCaster(), AuraEffect::GetCasterGUID(), AuraScript::GetCasterGUID(), GetDebugInfo(), HandleAuraSpecificMods(), spell_item_luffa::HandleEffect(), ArenaSpectator::HandleResetCommand(), spell_hun_chimera_shot::HandleScriptEffect(), Unit::HasNegativeAuraWithAttribute(), IsRemovedOnShapeLost(), list_commandscript::ListAurasCommand(), Unit::RemoveAura(), Unit::RemoveAuraFromStack(), Unit::RemoveAurasByType(), Unit::RemoveAurasDueToSpell(), Unit::RemoveAurasDueToSpellByDispel(), Unit::RemoveAurasDueToSpellBySteal(), Unit::RemoveAurasWithFamily(), Player::RemoveItemDependentAurasAndCasts(), Unit::RemoveNotOwnSingleTargetAuras(), and ArenaSpectator::ShouldSendAura().

◆ GetCasterLevel()

uint8 Aura::GetCasterLevel ( ) const

inline

154{ return m_casterLevel; }

References m_casterLevel.

Referenced by AuraApplication::BuildUpdatePacket(), spell_item_luffa::CheckCast(), and spell_item_luffa::HandleEffect().

◆ GetCastItemEntry()

uint32 Aura::GetCastItemEntry ( ) const

inline

104{ return m_castItemEntry; }

References m_castItemEntry.

◆ GetCastItemGUID()

ObjectGuid Aura::GetCastItemGUID ( ) const

inline

103{ return m_castItemGuid; }

References m_castItemGuid.

Referenced by Player::ActivateSpec(), CanStackWith(), Unit::GetAuraApplication(), AuraEffect::HandlePeriodicHealAurasTick(), and SpellInfo::ValidateAttribute6SpellDamageMods().

◆ GetCharges()

uint8 Aura::GetCharges ( ) const

inline

141{ return m_procCharges; }

References m_procCharges.

Referenced by Player::ApplyModToSpell(), AuraApplication::BuildUpdatePacket(), CanBeSaved(), ConsumeProcCharges(), Spell::EffectStealBeneficialBuff(), AuraScript::GetCharges(), Unit::GetDispellableAuraList(), GetProcEffectMask(), Unit::HandleAuraRaidProcFromCharge(), Unit::HandleAuraRaidProcFromChargeWithValue(), AuraEffect::HandleRaidProcFromChargeAuraProc(), AuraEffect::HandleRaidProcFromChargeWithValueAuraProc(), ArenaSpectator::HandleResetCommand(), Player::IsAffectedBySpellmod(), list_commandscript::ListAurasCommand(), and Unit::RemoveAurasDueToSpellBySteal().

◆ GetDebugInfo()

std::string Aura::GetDebugInfo ( ) const

virtual

{
    std::stringstream sstr;
    sstr << std::boolalpha
        << "Id: " << GetId() << " Caster: " << GetCasterGUID().ToString()
        << "\nOwner: " << (GetOwner() ? GetOwner()->GetDebugInfo() : "NULL");
    return sstr.str();
}

References GetCasterGUID(), WorldObject::GetDebugInfo(), GetId(), GetOwner(), and ObjectGuid::ToString().

◆ GetDuration()

int32 Aura::GetDuration ( ) const

inline

133{ return m_duration; }

References m_duration.

Referenced by Battleground::_ProcessJoin(), Pet::_SaveAuras(), Player::_SaveAuras(), spell_rog_stealth_buff_tracker< RemoveSpellId >::AfterApply(), AuraApplication::BuildUpdatePacket(), AuraEffect::CalculatePeriodic(), AuraEffect::CheckEffectProc(), Unit::DelayOwnedAuras(), Spell::DoTriggersOnSpellHit(), Spell::EffectHeal(), Unit::GetDiseasesByCaster(), DynamicObject::GetDuration(), AuraScript::GetDuration(), deserter_commandscript::HandleDeserterAdd(), spell_rog_glyph_of_backstab::HandleProc(), spell_sha_t10_elemental_4p_bonus::HandleProc(), ArenaSpectator::HandleResetCommand(), spell_dk_glyph_of_scourge_strike_script::HandleScriptEffect(), spell_dru_glyph_of_starfire::HandleScriptEffect(), IsAuraStronger(), IsExpired(), list_commandscript::ListAurasCommand(), npc_air_force_bots::npc_air_force_botsAI::MoveInLineOfSight(), spell_hor_shared_suffering_aura::OnRemove(), Unit::RemoveAurasDueToSpellByDispel(), Unit::RemoveAurasDueToSpellBySteal(), boss_anomalus::SetData(), and npc_tournament_training_dummy::npc_tournament_training_dummyAI::UpdateAI().

◆ GetDynobjOwner()

DynamicObject * Aura::GetDynobjOwner ( ) const

inline

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

Aura::GetType

AuraObjectType GetType() const

Definition SpellAuras.cpp:425

DynamicObject

Definition DynamicObject.h:35

References ASSERT, DYNOBJ_AURA_TYPE, GetType(), and m_owner.

Referenced by DynObjAura::DynObjAura(), Spell::EffectPersistentAA(), DynObjAura::FillTargetMap(), and AuraScript::GetDynobjOwner().

◆ GetEffect()

AuraEffect * Aura::GetEffect ( uint8 effIndex ) const

inline

176{ ASSERT (effIndex < MAX_SPELL_EFFECTS); return m_effects[effIndex]; }

References ASSERT, m_effects, and MAX_SPELL_EFFECTS.

Referenced by AuraApplication::_HandleEffect(), Pet::_SaveAuras(), Player::_SaveAuras(), AuraEffect::ApplySpellMod(), spell_gen_arena_drink::CalcAmount(), spell_gen_arena_drink::CalcPeriodic(), CanStackWith(), Spell::CheckCasterAuras(), Unit::GetAuraEffect(), AuraScript::GetEffect(), GetProcEffectMask(), spell_muru_summon_blood_elves_periodic_aura::HandleApply(), spell_gen_baby_murloc_passive::HandleApply(), HandleAuraSpecificMods(), spell_optic_link_aura::HandleEffectPeriodic(), spell_warl_improved_demonic_tactics::HandlePeriodic(), spell_hun_chimera_shot::HandleScriptEffect(), HasEffect(), IsAuraStronger(), Unit::IsHighestExclusiveAura(), spell_hadronox_summon_periodic_aura::OnApply(), spell_kalecgos_curse_of_boundless_agony_aura::OnPeriodic(), Unit::RemoveAurasDueToSpellBySteal(), ArenaSpectator::ShouldSendAura(), TriggerProcOnEvent(), spell_black_temple_shadow_inferno_aura::Update(), and spell_gen_arena_drink::UpdatePeriodic().

◆ GetEffectMask()

uint8 Aura::GetEffectMask ( ) const

inline

177{ uint8 effMask = 0; for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i) if (m_effects[i]) effMask |= 1 << i; return effMask; }

References m_effects, and MAX_SPELL_EFFECTS.

Referenced by Unit::GetAuraApplication(), ArenaSpectator::HandleResetCommand(), Unit::IsHighestExclusiveAura(), Unit::IsHighestExclusiveAuraEffect(), Unit::RemoveAura(), Unit::RemoveAurasDueToSpell(), and Unit::RemoveAurasDueToSpellByDispel().

◆ GetId()

uint32 Aura::GetId ( ) const

{
    return GetSpellInfo()->Id;
}

References GetSpellInfo(), and SpellInfo::Id.

Referenced by Unit::_AddAura(), Unit::_UnapplyAura(), Unit::_UnapplyAura(), Player::ActivateSpec(), WorldSession::BuildPartyMemberStatsChangedPacket(), AuraApplication::BuildUpdatePacket(), CalcDispelChance(), CalcMaxCharges(), CalcMaxDuration(), CalcProcChance(), CanStackWith(), Unit::DelayOwnedAuras(), Spell::EffectDispelMechanic(), GetDebugInfo(), AuraScript::GetId(), GetProcEffectMask(), HandleAuraSpecificMods(), spell_item_powerful_anti_venom::HandleDummy(), spell_item_strong_anti_venom::HandleDummy(), spell_item_anti_venom::HandleDummy(), spell_item_luffa::HandleEffect(), Unit::IsPetAura(), list_commandscript::ListAurasCommand(), boss_taldaram::OnAuraRemove(), boss_high_nethermancer_zerevor::OnAuraRemove(), boss_loken::OnAuraRemove(), PrepareProcToTrigger(), Unit::RemoveAura(), Unit::RemoveAurasDueToSpellByDispel(), Unit::RemoveAurasDueToSpellBySteal(), Unit::RemoveAurasWithInterruptFlags(), Unit::RemoveAurasWithMechanic(), Unit::RemoveOwnedAura(), SetDuration(), TriggerProcOnEvent(), UnregisterSingleTarget(), UpdateOwner(), and UpdateTargetMap().

◆ GetMaxDuration()

int32 Aura::GetMaxDuration ( ) const

inline

129{ return m_maxDuration; }

References m_maxDuration.

Referenced by AuraApplication::BuildUpdatePacket(), AuraEffect::CheckEffectProc(), Spell::DoSpellHitOnUnit(), Unit::GetDiseasesByCaster(), AuraScript::GetMaxDuration(), AuraEffect::GetTotalTicks(), HandleAuraSpecificMods(), spell_rog_glyph_of_backstab::HandleProc(), spell_sha_t10_elemental_4p_bonus::HandleProc(), ArenaSpectator::HandleResetCommand(), spell_dk_glyph_of_scourge_strike_script::HandleScriptEffect(), spell_dru_glyph_of_starfire::HandleScriptEffect(), IsPermanent(), list_commandscript::ListAurasCommand(), RefreshDuration(), and Unit::RemoveAurasDueToSpellBySteal().

◆ GetOwner()

WorldObject * Aura::GetOwner ( ) const

inline

107{ return m_owner; }

References m_owner.

Referenced by _ApplyEffectForTargets(), Unit::_CreateAuraApplication(), Unit::_UnapplyAura(), CanBeAppliedOn(), CanBeSaved(), CanStackWith(), Spell::EffectApplyAreaAura(), Spell::EffectApplyAura(), GetCaster(), GetDebugInfo(), AuraScript::GetOwner(), Unit::IsHighestExclusiveAuraEffect(), Unit::RemoveAura(), Unit::RemoveOwnedAura(), UnregisterSingleTarget(), and UpdateTargetMap().

◆ GetProcEffectMask()

uint8 Aura::GetProcEffectMask	(	AuraApplication *	aurApp,
		ProcEventInfo &	eventInfo,
		TimePoint	now
	)		const

{
    SpellProcEntry const* procEntry = sSpellMgr->GetSpellProcEntry(GetId());
 
    // only auras with spell proc entry can trigger proc
    if (!procEntry)
        return 0;
 
    // check spell triggering us
    if (Spell const* spell = eventInfo.GetProcSpell())
    {
        // Do not allow auras to proc from effect triggered from itself
        if (spell->GetTriggeredByAuraSpellInfo() == m_spellInfo)
            return 0;
 
        // check if aura can proc when spell is triggered (exception for hunter auto shot & wands)
        // Kill/killed/death events should not be blocked by the triggered-spell check -
        // the kill itself is the proc trigger, not the spell that dealt the killing blow
        if (!GetSpellInfo()->HasAttribute(SPELL_ATTR3_CAN_PROC_FROM_PROCS) &&
            !(procEntry->AttributesMask & PROC_ATTR_TRIGGERED_CAN_PROC) &&
            !(eventInfo.GetTypeMask() & AUTO_ATTACK_PROC_FLAG_MASK) &&
            !(eventInfo.GetTypeMask() & (PROC_FLAG_KILL | PROC_FLAG_KILLED | PROC_FLAG_DEATH)))
        {
            if (spell->IsTriggered() && !spell->GetSpellInfo()->HasAttribute(SPELL_ATTR3_NOT_A_PROC))
                return 0;
        }
 
        // do not allow aura proc if proc is caused by a spell cast by item
        if (spell->m_CastItem && (procEntry->AttributesMask & PROC_ATTR_CANT_PROC_FROM_ITEM_CAST))
            return 0;
    }
 
    // Don't consume stealth charges from friendly spells
    if (m_spellInfo->HasAura(SPELL_AURA_MOD_STEALTH))
    {
        if (SpellInfo const* spellInfo = eventInfo.GetSpellInfo())
            if (spellInfo->IsPositive() || !eventInfo.GetActor()->IsHostileTo(aurApp->GetTarget()) || spellInfo->HasAttribute(SPELL_ATTR0_CU_DONT_BREAK_STEALTH))
                return 0;
    }
 
    // check if we have charges to proc with
    if (IsUsingCharges() && !GetCharges())
        return 0;
 
    // check proc cooldown
    if (IsProcOnCooldown(now))
        return 0;
 
    // do checks against db data
    if (!sSpellMgr->CanSpellTriggerProcOnEvent(*procEntry, eventInfo))
        return 0;
 
    // check if spell was affected by this aura's spellmod (used by Arcane Potency and similar effects)
    // only applies when consuming charges or stacks
    if ((procEntry->AttributesMask & PROC_ATTR_REQ_SPELLMOD) && (IsUsingCharges() || (procEntry->AttributesMask & PROC_ATTR_USE_STACKS_FOR_CHARGES)))
    {
        Spell const* procSpell = eventInfo.GetProcSpell();
        if (!procSpell || procSpell->m_appliedMods.find(const_cast<Aura*>(this)) == procSpell->m_appliedMods.end())
            return 0;
    }
 
    // do checks using conditions table
    ConditionList conditions = sConditionMgr->GetConditionsForNotGroupedEntry(CONDITION_SOURCE_TYPE_SPELL_PROC, GetId());
    ConditionSourceInfo condInfo = ConditionSourceInfo(eventInfo.GetActor(), eventInfo.GetActionTarget());
    if (!sConditionMgr->IsObjectMeetToConditions(condInfo, conditions))
        return 0;
 
    // AuraScript Hook
    if (!const_cast<Aura*>(this)->CallScriptCheckProcHandlers(aurApp, eventInfo))
        return 0;
 
    // At least one effect has to pass checks to proc aura
    uint8 procEffectMask = aurApp->GetEffectMask();
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (AuraEffect* aurEff = GetEffect(i))
        {
            if (procEffectMask & (1 << i))
            {
                if ((procEntry->DisableEffectsMask & (1u << i)) || !aurEff->CheckEffectProc(aurApp, eventInfo))
                    procEffectMask &= ~(1 << i);
            }
        }
    }
 
    if (!procEffectMask)
        return 0;
 
    // Check if current equipment meets aura requirements
    // do that only for passive spells
    Unit* target = aurApp->GetTarget();
    if (IsPassive() && target->IsPlayer() && GetSpellInfo()->EquippedItemClass != -1)
    {
        if (!GetSpellInfo()->HasAttribute(SPELL_ATTR3_NO_PROC_EQUIP_REQUIREMENT))
        {
            Item* item = nullptr;
            if (GetSpellInfo()->EquippedItemClass == ITEM_CLASS_WEAPON)
            {
                if (target->ToPlayer()->IsInFeralForm())
                    return 0;
 
                if (DamageInfo const* damageInfo = eventInfo.GetDamageInfo())
                {
                    switch (damageInfo->GetAttackType())
                    {
                        case BASE_ATTACK:
                            item = target->ToPlayer()->GetUseableItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND);
                            break;
                        case OFF_ATTACK:
                            item = target->ToPlayer()->GetUseableItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
                            break;
                        default:
                            item = target->ToPlayer()->GetUseableItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_RANGED);
                            break;
                    }
                }
            }
            else if (GetSpellInfo()->EquippedItemClass == ITEM_CLASS_ARMOR)
            {
                // Check if player is wearing shield
                item = target->ToPlayer()->GetUseableItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
            }
 
            if (!item || item->IsBroken() || !item->IsFitToSpellRequirements(GetSpellInfo()))
                return 0;
        }
    }
 
    float procChance = CalcProcChance(*procEntry, eventInfo);
 
    if (roll_chance_f(procChance))
        return procEffectMask;
 
    return 0;
}

References SpellProcEntry::AttributesMask, AUTO_ATTACK_PROC_FLAG_MASK, BASE_ATTACK, CalcProcChance(), CallScriptCheckProcHandlers(), CONDITION_SOURCE_TYPE_SPELL_PROC, SpellProcEntry::DisableEffectsMask, EQUIPMENT_SLOT_MAINHAND, EQUIPMENT_SLOT_OFFHAND, EQUIPMENT_SLOT_RANGED, SpellInfo::EquippedItemClass, ProcEventInfo::GetActionTarget(), ProcEventInfo::GetActor(), GetCharges(), ProcEventInfo::GetDamageInfo(), GetEffect(), AuraApplication::GetEffectMask(), GetId(), ProcEventInfo::GetProcSpell(), ProcEventInfo::GetSpellInfo(), GetSpellInfo(), AuraApplication::GetTarget(), ProcEventInfo::GetTypeMask(), Player::GetUseableItemByPos(), SpellInfo::HasAttribute(), SpellInfo::HasAura(), INVENTORY_SLOT_BAG_0, Item::IsBroken(), Item::IsFitToSpellRequirements(), Unit::IsHostileTo(), Unit::IsInFeralForm(), IsPassive(), Object::IsPlayer(), IsProcOnCooldown(), IsUsingCharges(), ITEM_CLASS_ARMOR, ITEM_CLASS_WEAPON, Spell::m_appliedMods, m_spellInfo, MAX_SPELL_EFFECTS, OFF_ATTACK, PROC_ATTR_CANT_PROC_FROM_ITEM_CAST, PROC_ATTR_REQ_SPELLMOD, PROC_ATTR_TRIGGERED_CAN_PROC, PROC_ATTR_USE_STACKS_FOR_CHARGES, PROC_FLAG_DEATH, PROC_FLAG_KILL, PROC_FLAG_KILLED, roll_chance_f(), sConditionMgr, SPELL_ATTR0_CU_DONT_BREAK_STEALTH, SPELL_ATTR3_CAN_PROC_FROM_PROCS, SPELL_ATTR3_NO_PROC_EQUIP_REQUIREMENT, SPELL_ATTR3_NOT_A_PROC, SPELL_AURA_MOD_STEALTH, sSpellMgr, and Object::ToPlayer().

◆ GetScript()

template<class Script >

Script * Aura::GetScript ( std::string const & scriptName ) const

inline

    {
        return dynamic_cast<Script*>(GetScriptByName(scriptName));
    }

References GetScriptByName().

◆ GetScriptByName()

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 nullptr;
}

References m_loadedScripts.

Referenced by GetScript(), and spell_rog_mutilate::HandleAfterCast().

◆ GetSpellInfo()

SpellInfo const * Aura::GetSpellInfo ( ) const

inline

100{ return m_spellInfo; }

References m_spellInfo.

Referenced by Unit::_AddAura(), Unit::_ApplyAura(), Unit::_CreateAuraApplication(), Pet::_SaveAuras(), Unit::_UnapplyAura(), _UnapplyForTarget(), SpellInfo::ApplyAllSpellImmunitiesTo(), AuraEffect::ApplySpellMod(), AuraApplication::BuildUpdatePacket(), CalcProcChance(), CanBeAppliedOn(), CanBeSaved(), CanBeSentToClient(), CanStackWith(), Player::CheckAreaExploreAndOutdoor(), spell_item_luffa::CheckCast(), Spell::CheckCasterAuras(), Spell::DoSpellHitOnUnit(), Spell::EffectDispelMechanic(), Spell::EffectStealBeneficialBuff(), UnitAura::FillTargetMap(), DynObjAura::FillTargetMap(), Unit::GetDiseasesByCaster(), Unit::GetDispellableAuraList(), GetId(), GetProcEffectMask(), AuraScript::GetSpellInfo(), AuraEffect::HandleAuraDummy(), HandleAuraSpecificMods(), spell_item_powerful_anti_venom::HandleDummy(), spell_item_strong_anti_venom::HandleDummy(), spell_item_anti_venom::HandleDummy(), spell_item_luffa::HandleEffect(), ArenaSpectator::HandleResetCommand(), spell_gen_clear_debuffs::HandleScript(), spell_dru_glyph_of_starfire::HandleScriptEffect(), spell_hun_chimera_shot::HandleScriptEffect(), HasMoreThanOneEffectForType(), Unit::HasNegativeAuraWithAttribute(), IsArea(), IsDeathPersistent(), Unit::IsHighestExclusiveAura(), IsPassive(), IsSingleTargetWith(), list_commandscript::ListAurasCommand(), Player::LoadFromDB(), spell_hor_shared_suffering_aura::OnRemove(), Unit::RemoveAllAurasExceptType(), Unit::RemoveAllAurasOnDeath(), Unit::RemoveAllAurasRequiringDeadTarget(), Unit::RemoveArenaAuras(), Unit::RemoveAurasByShapeShift(), Unit::RemoveAurasDueToSpellByDispel(), Unit::RemoveAurasDueToSpellBySteal(), Unit::RemoveAurasWithFamily(), Unit::RemoveAurasWithInterruptFlags(), Unit::RemoveAurasWithMechanic(), Unit::RemoveEvadeAuras(), Player::RemoveItemDependentAurasAndCasts(), Unit::RemoveMovementImpairingAuras(), Player::RemoveSpellMods(), Player::RestoreSpellMods(), ArenaSpectator::ShouldSendAura(), Unit::SpellPctDamageModsDone(), and UpdateTargetMap().

◆ GetStackAmount()

uint8 Aura::GetStackAmount ( ) const

inline

148{ return m_stackAmount; }

References m_stackAmount.

Referenced by AuraApplication::BuildUpdatePacket(), AuraEffect::CalculateAmount(), boss_freya::DoAction(), Spell::EffectSchoolDMG(), Spell::EffectStealBeneficialBuff(), Unit::GetDispellableAuraList(), AuraScript::GetStackAmount(), AuraEffect::HandleAuraLinked(), HandleAuraSpecificMods(), spell_brewfest_main_ram_buff::HandleEffectPeriodic(), spell_sindragosa_frost_breath::HandleInfusion(), spell_item_trinket_stack< StackSpell, TriggerSpell >::HandleProc(), spell_item_tiny_abomination_in_a_jar::HandleProc(), spell_item_tiny_abomination_in_a_jar_hero::HandleProc(), ArenaSpectator::HandleResetCommand(), spell_festergut_gastric_bloat::HandleScript(), spell_rotface_large_ooze_combine::HandleScript(), spell_gen_bonked::HandleScript(), spell_hun_chimera_shot::HandleScriptEffect(), spell_pal_seal_of_vengeance_aura::HandleSeal(), list_commandscript::ListAurasCommand(), ModStackAmount(), spell_gen_defend::RefreshVisualShields(), Unit::SpellPctDamageModsDone(), and npc_tournament_training_dummy::npc_tournament_training_dummyAI::UpdateAI().

◆ GetTriggeredByAuraSpellInfo()

SpellInfo const * Aura::GetTriggeredByAuraSpellInfo ( ) const

{
    return m_triggeredByAuraSpellInfo;
}

References m_triggeredByAuraSpellInfo.

Referenced by Player::ActivateSpec(), Spell::EffectApplyGlyph(), HandleAuraSpecificMods(), and WorldSession::HandleRemoveGlyph().

◆ GetType()

AuraObjectType Aura::GetType ( ) const

{
    if (!m_owner)
    {
        LOG_ERROR("spells", "Aura::GetType m_owner is null!");
        return UNIT_AURA_TYPE;
    }
 
    return (m_owner->IsDynamicObject()) ? DYNOBJ_AURA_TYPE : UNIT_AURA_TYPE;
}

References DYNOBJ_AURA_TYPE, Object::IsDynamicObject(), LOG_ERROR, m_owner, and UNIT_AURA_TYPE.

Referenced by CanStackWith(), GetDynobjOwner(), AuraScript::GetType(), GetUnitOwner(), Spell::handle_immediate(), IsProcOnCooldown(), Unit::RemoveAuraFromStack(), and UpdateTargetMap().

◆ GetUnitOwner()

Unit * Aura::GetUnitOwner ( ) const

inline

◆ HandleAllEffects()

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

{
    ASSERT (!IsRemoved());
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if (m_effects[i] && !IsRemoved())
            m_effects[i]->HandleEffect(aurApp, mode, apply);
}

References ASSERT, AuraEffect::HandleEffect(), IsRemoved(), m_effects, and MAX_SPELL_EFFECTS.

Referenced by Player::CheckAreaExploreAndOutdoor(), and Player::LoadFromDB().

◆ HandleAuraSpecificMods()

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

Todo:: : This should be moved to similar function in spell::hit

Todo:: : Not sure whether the fallthrough was a mistake (forgetting a break) or intended. This should be double-checked.

{
    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) && !apply)
                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, nullptr, nullptr, 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->IsPlayer())
                            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->IsPlayer())
                            target->ToPlayer()->RemoveSpellCooldown(20252, true);
                        break;
                }
                break;
            case SPELLFAMILY_MAGE:
                if (!caster)
                    break;
                if (GetSpellInfo()->SpellFamilyFlags[0] & 0x00000001 && GetSpellInfo()->SpellFamilyFlags[2] & 0x00000008)
                {
                    // Glyph of Fireball
                    if (caster->HasAura(56368))
                        SetDuration(0);
                }
                else if (GetSpellInfo()->SpellFamilyFlags[0] & 0x00000020 && GetSpellInfo()->SpellVisual[0] == 13)
                {
                    // Glyph of Frostbolt
                    if (caster->HasAura(56370))
                        SetDuration(0);
                }
                else if (GetSpellInfo()->SpellFamilyFlags[0] & 0x01000000)
                {
                    // Polymorph Sound - Sheep && Penguin
                    if (GetSpellInfo()->SpellIconID == 82 && GetSpellInfo()->SpellVisual[0] == 12978)
                    {
                        // Glyph of the Penguin
                        if (caster->HasAura(52648))
                            caster->CastSpell(target, 61635, true);
                        else
                            caster->CastSpell(target, 61634, true);
                    }
 
                    if (Creature* creatureTarget = target->ToCreature())
                    {
                        creatureTarget->CallAssistance(caster);
                    }
                }
                switch (GetId())
                {
                    case 44544: // Fingers of Frost
                        {
                            // See if we already have the indicator aura. If not, create one.
                            if (Aura* aur = target->GetAura(74396))
                            {
                                // Aura already there. Refresh duration and set original charges
                                aur->SetCharges(2);
                                aur->RefreshDuration();
                            }
                            else
                                target->AddAura(74396, target);
                        }
                        break;
                    case 12494: // Frostbite, synchronise with Fingers of Frost
                    {
                        // Find Fingers of Frost
                        if (AuraEffect* aurEff = caster->GetAuraEffect(SPELL_AURA_PROC_TRIGGER_SPELL, SPELLFAMILY_MAGE, 2947, EFFECT_0))
                        {
                            if (SpellInfo const* triggeringSpellInfo = GetTriggeredByAuraSpellInfo())
                            {
                                uint8 fbRank = sSpellMgr->GetSpellRank(triggeringSpellInfo->Id);
                                uint8 fofRank = sSpellMgr->GetSpellRank(aurEff->GetId());
                                uint8 chance = uint8(std::ceil(fofRank * fbRank * 16.6f));
 
                                if (roll_chance_i(chance))
                                {
                                    caster->CastSpell(caster, aurEff->GetSpellInfo()->Effects[EFFECT_0].TriggerSpell, true);
                                }
                            }
                        }
                        break;
                    }
                    default:
                        break;
                }
                break;
            case SPELLFAMILY_DRUID:
                if (!caster)
                    break;
                // Rejuvenation
                if (GetSpellInfo()->SpellFamilyFlags[0] & 0x10 && GetEffect(0))
                {
                    // Druid T8 Restoration 4P Bonus
                    if (caster->GetAuraEffectDummy(64760))
                    {
                        uint32 damage = GetEffect(0)->GetAmount();
                        damage = target->SpellHealingBonusTaken(caster, GetSpellInfo(), damage, DOT);
 
                        int32 basepoints0 = damage;
                        caster->CastCustomSpell(target, 64801, &basepoints0, nullptr, nullptr, true, nullptr, GetEffect(0));
                    }
                }
                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, 1))
                    {
                        uint32 damage = GetEffect(0)->GetAmount();
                        damage = target->SpellDamageBonusTaken(caster, GetSpellInfo(), damage, DOT);
                        int32 basepoints0 = aurEff->GetAmount() * GetEffect(0)->GetTotalTicks() * int32(damage) / 100;
                        int32 heal = int32(CalculatePct(basepoints0, 15));
 
                        caster->CastCustomSpell(target, 63675, &basepoints0, nullptr, nullptr, true, nullptr, GetEffect(0));
                        caster->CastCustomSpell(caster, 75999, &heal, nullptr, nullptr, true, nullptr, 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, 0, GetEffect(0));
                    }
                }
                break;
            case SPELLFAMILY_ROGUE:
                // Sprint (skip non player casted 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;
            case SPELLFAMILY_SHAMAN:
            {
                // Ghost Wolf Speed (PvP 58 lvl set)
                if (GetSpellInfo()->SpellFamilyFlags[0] & 0x00000800 && target->HasAura(22801) && target->GetLevel() <= 60)
                {
                    int32 bp0 = 15;
                    target->CastCustomSpell(target, 47017, &bp0, 0, 0, true);
                }
                break;
            }
            case SPELLFAMILY_DEATHKNIGHT:
                if (!caster)
                    break;
                // Frost Fever and Blood Plague
                if (GetSpellInfo()->SpellFamilyFlags[2] & 0x2)
                {
                    // Can't proc on self
                    if (GetCasterGUID() == target->GetGUID())
                        break;
 
                    AuraEffect* aurEff = nullptr;
                    // Ebon Plaguebringer / Crypt Fever
                    Unit::AuraEffectList const& TalentAuras = caster->GetAuraEffectsByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
                    for (Unit::AuraEffectList::const_iterator itr = TalentAuras.begin(); itr != TalentAuras.end(); ++itr)
                    {
                        if ((*itr)->GetMiscValue() == 7282)
                        {
                            aurEff = *itr;
                            // Ebon Plaguebringer - end search if found
                            if ((*itr)->GetSpellInfo()->SpellIconID == 1766)
                                break;
                        }
                    }
                    if (aurEff)
                    {
                        uint32 spellId = 0;
                        switch (aurEff->GetId())
                        {
                            // Ebon Plague
                            case 51161:
                                spellId = 51735;
                                break;
                            case 51160:
                                spellId = 51734;
                                break;
                            case 51099:
                                spellId = 51726;
                                break;
                            // Crypt Fever
                            case 49632:
                                spellId = 50510;
                                break;
                            case 49631:
                                spellId = 50509;
                                break;
                            case 49032:
                                spellId = 50508;
                                break;
                            default:
                                LOG_ERROR("spells.aura", "Aura::HandleAuraSpecificMods: Unknown rank of Crypt Fever/Ebon Plague ({}) found", aurEff->GetId());
                        }
                        caster->CastSpell(target, spellId, true, 0, GetEffect(0));
                    }
                }
                // Unholy blight
                if (GetId() == 50536)
                {
                    if (caster->IsFriendlyTo(target))
                        SetDuration(0);
                }
                break;
            case SPELLFAMILY_POTION:
                // Alchemy: Mixology
                if (caster && caster->HasAura(53042) && caster->IsPlayer() && !caster->ToPlayer()->GetSession()->PlayerLoading())
                {
                    if (sSpellMgr->IsSpellMemberOfSpellGroup(GetId(), SPELL_GROUP_ELIXIR_BATTLE) || sSpellMgr->IsSpellMemberOfSpellGroup(GetId(), SPELL_GROUP_ELIXIR_GUARDIAN))
                    {
                        if (caster->HasSpell(GetSpellInfo()->Effects[EFFECT_0].TriggerSpell))
                        {
                            for (int i = 0; i < MAX_SPELL_EFFECTS; ++i)
                                if (GetEffect(i))
                                    GetEffect(i)->SetAmount(CalculatePct(GetEffect(i)->GetAmount(), 100 + sSpellMgr->GetSpellMixologyBonus(GetId())));
 
                            SetMaxDuration(caster->CalcSpellDuration(GetSpellInfo()) * 2);
                            SetDuration(GetMaxDuration());
                        }
                    }
                }
                break;
        }
    }
    // mods at aura remove
    else
    {
        switch (GetSpellInfo()->SpellFamilyName)
        {
            case SPELLFAMILY_GENERIC:
                if (!caster)
                    break;
                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;
                    case 72368: // Shared Suffering
                    case 72369:
                        if (AuraEffect* aurEff = GetEffect(0))
                        {
                            int32 remainingDamage = aurEff->GetAmount() * (aurEff->GetTotalTicks() - aurEff->GetTickNumber());
                            if (remainingDamage > 0)
                                caster->CastCustomSpell(caster, 72373, nullptr, &remainingDamage, nullptr, true);
                        }
                        break;
                }
                break;
            case SPELLFAMILY_MAGE:
            {
                // Polymorph
                if (GetSpellInfo()->SpellFamilyFlags[0] & 0x01000000)
                {
                    if (Creature* creatureTarget = target->ToCreature())
                    {
                        creatureTarget->SetNoCallAssistance(false);
                    }
                }
                switch (GetId())
                {
                    case 66: // Invisibility
                        if (removeMode != AURA_REMOVE_BY_EXPIRE)
                            break;
                        target->CastSpell(target, 32612, true, nullptr, GetEffect(1));
                        target->CombatStop();
                        break;
                    case 74396: // Fingers of Frost
                        // Remove the IGNORE_AURASTATE aura
                        target->RemoveAurasDueToSpell(44544);
                        break;
                    case 44401: // Missile Barrage
                    case 48108: // Hot Streak
                    case 57761: // Fireball!
                        if (removeMode != AURA_REMOVE_BY_EXPIRE || aurApp->GetBase()->IsExpired())
                            break;
                        if (target->HasAura(70752)) // Item - Mage T10 2P Bonus
                            target->CastSpell(target, 70753, true); // Pushing the Limit
                        break;
                    default:
                        break;
                }
                if (!caster)
                    break;
                // Ice barrier - dispel/absorb remove
                if (removeMode == AURA_REMOVE_BY_ENEMY_SPELL && GetSpellInfo()->SpellFamilyFlags[1] & 0x1)
                {
                    // Shattered Barrier
                    if (AuraEffect* absorb = GetEffect(EFFECT_0))
                        if (absorb->GetAmount() <= 0) // removed by damage, not dispel
                            if (AuraEffect* dummy = caster->GetDummyAuraEffect(SPELLFAMILY_MAGE, 2945, 0))
                                if (roll_chance_i(dummy->GetSpellInfo()->ProcChance))
                                    caster->CastSpell(target, 55080, true, nullptr, GetEffect(0));
                }
                break;
            }
            case SPELLFAMILY_WARRIOR:
                if (!caster)
                    break;
                [[fallthrough]]; 
            case SPELLFAMILY_WARLOCK:
                if (!caster)
                    break;
                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:
                                LOG_ERROR("spells.aura", "Aura::HandleAuraSpecificMods: Unknown rank of Improved Fear ({}) found", aurEff->GetId());
                        }
                        if (spellId)
                            caster->CastSpell(target, spellId, true);
                    }
                }
                break;
            case SPELLFAMILY_PRIEST:
                if (!caster)
                    break;
                // Shadow word: Pain // Vampiric Touch
                if (removeMode == AURA_REMOVE_BY_ENEMY_SPELL && (GetSpellInfo()->SpellFamilyFlags[0] & 0x00008000 || GetSpellInfo()->SpellFamilyFlags[1] & 0x00000400))
                {
                    // Shadow Affinity
                    if (AuraEffect const* aurEff = caster->GetDummyAuraEffect(SPELLFAMILY_PRIEST, 178, 1))
                    {
                        int32 basepoints0 = aurEff->GetAmount() * caster->GetCreateMana() / 100;
                        caster->CastCustomSpell(caster, 64103, &basepoints0, nullptr, nullptr, true, nullptr, GetEffect(0));
                    }
                }
                // Power word: shield
                else if (removeMode == AURA_REMOVE_BY_ENEMY_SPELL && GetSpellInfo()->SpellFamilyFlags[0] & 0x00000001)
                {
                    // Rapture
                    if (Aura const* aura = caster->GetAuraOfRankedSpell(47535))
                    {
                        // check cooldown
                        if (caster->IsPlayer())
                        {
                            if (caster->ToPlayer()->HasSpellCooldown(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->ToPlayer()->GetSpellCooldownDelay(aura->GetId()) <= 11500)
                                    break;
                            }
                            else    // and add if needed
                                caster->ToPlayer()->AddSpellCooldown(aura->GetId(), 0, 12 * IN_MILLISECONDS);
                        }
 
                        // effect on caster
                        if (AuraEffect const* aurEff = aura->GetEffect(0))
                        {
                            float multiplier = (float)aurEff->GetAmount();
                            if (aurEff->GetId() == 47535)
                                multiplier -= 0.5f;
                            else if (aurEff->GetId() == 47537)
                                multiplier += 0.5f;
 
                            int32 basepoints0 = int32(CalculatePct(caster->GetMaxPower(POWER_MANA), multiplier));
                            caster->CastCustomSpell(caster, 47755, &basepoints0, nullptr, nullptr, true);
                        }
                        // effect on aura target
                        if (AuraEffect const* aurEff = aura->GetEffect(1))
                        {
                            if (!roll_chance_i(aurEff->GetAmount()))
                                break;
 
                            int32 triggeredSpellId = 0;
                            switch (target->getPowerType())
                            {
                                case POWER_MANA:
                                    {
                                        int32 basepoints0 = int32(CalculatePct(target->GetMaxPower(POWER_MANA), 2));
                                        caster->CastCustomSpell(target, 63654, &basepoints0, nullptr, nullptr, true);
                                        break;
                                    }
                                case POWER_RAGE:
                                    triggeredSpellId = 63653;
                                    break;
                                case POWER_ENERGY:
                                    triggeredSpellId = (!target->HasAura(70405) ? 63655 : 0);
                                    break;
                                case POWER_RUNIC_POWER:
                                    triggeredSpellId = 63652;
                                    break;
                                default:
                                    break;
                            }
                            if (triggeredSpellId)
                                caster->CastSpell(target, triggeredSpellId, true);
                        }
                    }
                }
                switch (GetId())
                {
                    case 47788: // Guardian Spirit
                    {
                        if (removeMode != AURA_REMOVE_BY_EXPIRE)
                            break;
                        if (!caster->IsPlayer())
                            break;
 
                        Player* player = caster->ToPlayer();
                        // Glyph of Guardian Spirit
                        if (AuraEffect* aurEff = player->GetAuraEffect(63231, 0))
                        {
                            if (!player->HasSpellCooldown(47788))
                                break;
 
                            player->AddSpellCooldown(GetSpellInfo()->Id, 0, aurEff->GetAmount()*IN_MILLISECONDS);
 
                            WorldPacket data(SMSG_MODIFY_COOLDOWN, 4 + 8 + 4);
                            data << uint32(GetId());                  // Spell ID
                            data << player->GetGUID();                // Player GUID
                            data << int32(-110000);                   // Cooldown mod in milliseconds
                            player->SendDirectMessage(&data);
                        }
                        break;
                    }
                    case 47585: // Dispersion (fixed bug invisible as a Shadow Priest)
                    {
                        if (target->IsMounted())
                        {
                            target->CastSpell(target, 53444, true);
                        }
                        break;
                    }
                }
                break;
            case SPELLFAMILY_ROGUE:
                // Remove Vanish on stealth remove
                if (GetId() == 1784)
                {
                    target->RemoveAurasWithFamily(SPELLFAMILY_ROGUE, 0x800, 0, 0, ObjectGuid::Empty);
                    target->RemoveAurasDueToSpell(18461);
                }
                break;
            case SPELLFAMILY_SHAMAN:
            {
                // Ghost Wolf Speed (PvP 58 lvl set)
                if (GetSpellInfo()->SpellFamilyFlags[0] & 0x00000800)
                {
                    target->RemoveAurasDueToSpell(47017);
                }
                // Lightning Shield vs The Earthshatterer 8/9 set bonus
                if (GetSpellInfo()->SpellFamilyFlags[0] & 0x00000400)
                {
                    target->RemoveAurasDueToSpell(28820);
                }
                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->IsPlayer())
                        break;
                    if (!target->ToPlayer()->IsClass(CLASS_DEATH_KNIGHT, CLASS_CONTEXT_ABILITY))
                        break;
 
                    // aura removed - remove death runes
                    target->ToPlayer()->RemoveRunesByAuraEffect(GetEffect(0));
                }
                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_HUNTER:
                // Glyph of Freezing Trap
                if ((GetSpellInfo()->SpellFamilyFlags[0] & 0x00000008) && caster && caster->HasAura(56845))
                {
                    target->CastSpell(target, 61394, true);
                }
                break;
        }
    }
 
    // mods at aura apply or remove
    switch (GetSpellInfo()->SpellFamilyName)
    {
        case SPELLFAMILY_ROGUE:
            // Stealth
            if (GetSpellInfo()->SpellFamilyFlags[0] & 0x00400000)
            {
                // Master of Subtlety
                if (AuraEffect const* aurEff = target->GetAuraEffectOfRankedSpell(31221, 0))
                {
                    if (!apply)
                        target->CastSpell(target, 31666, true);
                    else
                    {
                        // Remove counter aura
                        target->RemoveAurasDueToSpell(31666);
 
                        int32 amount = aurEff->GetAmount();
                        target->CastCustomSpell(target, 31665, &amount, nullptr, nullptr, true);
                    }
                }
                // Overkill
                if (target->HasAura(58426))
                {
                    if (!apply)
                        target->CastSpell(target, 58428, true);
                    else
                    {
                        // Remove counter aura
                        target->RemoveAurasDueToSpell(58428);
 
                        target->CastSpell(target, 58427, true);
                    }
                }
            }
            break;
        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;
                case 34026: // Kill Command
                    // Dungeon Set 3
                    if (caster->HasAura(37483))
                    {
                        if (apply)
                        {
                            caster->CastSpell(caster, 37482, true);
                        }
                    }
                    break;
            }
            break;
        case SPELLFAMILY_PALADIN:
            switch (GetId())
            {
                case 31842: // Divine Illumination
                    // Item - Paladin T10 Holy 2P Bonus
                    if (caster && caster->HasAura(70755))
                    {
                        if (apply)
                            target->CastSpell(target, 71166, true);
                        else
                            target->RemoveAurasDueToSpell(71166);
                    }
                    break;
            }
            break;
    }
}

References Player::ActivateTaxiPathTo(), Unit::AddAura(), Player::AddSpellCooldown(), Unit::ApplySpellImmune(), AURA_REMOVE_BY_DEATH, AURA_REMOVE_BY_ENEMY_SPELL, AURA_REMOVE_BY_EXPIRE, Unit::CalcSpellDuration(), CalculatePct(), Unit::CastCustomSpell(), Unit::CastSpell(), CLASS_CONTEXT_ABILITY, CLASS_DEATH_KNIGHT, Unit::CombatStop(), DOT, EFFECT_0, ObjectGuid::Empty, AuraEffect::GetAmount(), Unit::GetAura(), Unit::GetAuraEffect(), Unit::GetAuraEffectDummy(), Unit::GetAuraEffectOfRankedSpell(), Unit::GetAuraEffectsByType(), Unit::GetAuraOfRankedSpell(), AuraApplication::GetBase(), GetCasterGUID(), Unit::GetCreateMana(), Unit::GetDummyAuraEffect(), GetEffect(), Object::GetGUID(), AuraEffect::GetId(), GetId(), Unit::GetLevel(), GetMaxDuration(), Unit::GetMaxPower(), Unit::GetOwner(), Unit::getPowerType(), AuraApplication::GetRemoveMode(), Player::GetSession(), Player::GetSpellCooldownDelay(), GetSpellInfo(), GetStackAmount(), AuraApplication::GetTarget(), AuraEffect::GetTotalTicks(), GetTriggeredByAuraSpellInfo(), GetUnitOwner(), WorldObject::GetZoneAndAreaId(), Unit::HasAura(), Unit::HasSpell(), Player::HasSpellCooldown(), SpellInfo::Id, IMMUNITY_ID, IN_MILLISECONDS, Player::IsClass(), IsExpired(), Unit::IsFriendlyTo(), Unit::IsMounted(), Object::IsPlayer(), LOG_ERROR, m_spellInfo, MAX_SPELL_EFFECTS, WorldSession::PlayerLoading(), POWER_ENERGY, POWER_MANA, POWER_RAGE, POWER_RUNIC_POWER, Unit::RemoveAura(), Unit::RemoveAurasDueToSpell(), Unit::RemoveAurasWithFamily(), Player::RemoveRunesByAuraEffect(), Player::RemoveSpellCooldown(), roll_chance_i(), Player::SendDirectMessage(), AuraEffect::SetAmount(), SetDuration(), SetMaxDuration(), SMSG_MODIFY_COOLDOWN, SPELL_AURA_DUMMY, SPELL_AURA_OVERRIDE_CLASS_SCRIPTS, SPELL_AURA_PERIODIC_DUMMY, SPELL_AURA_PROC_TRIGGER_SPELL, SPELL_GROUP_ELIXIR_BATTLE, SPELL_GROUP_ELIXIR_GUARDIAN, SPELL_LINK_AURA, Unit::SpellDamageBonusTaken(), SPELLFAMILY_DEATHKNIGHT, SPELLFAMILY_DRUID, SPELLFAMILY_GENERIC, SPELLFAMILY_HUNTER, SPELLFAMILY_MAGE, SPELLFAMILY_PALADIN, SPELLFAMILY_POTION, SPELLFAMILY_PRIEST, SPELLFAMILY_ROGUE, SPELLFAMILY_SHAMAN, SPELLFAMILY_WARLOCK, SPELLFAMILY_WARRIOR, SpellInfo::SpellFamilyFlags, SpellInfo::SpellFamilyName, Unit::SpellHealingBonusTaken(), SpellInfo::SpellIconID, SpellInfo::SpellVisual, sSpellMgr, Object::ToCreature(), and Object::ToPlayer().

Referenced by Unit::_ApplyAura(), Unit::_UnapplyAura(), and SetStackAmount().

◆ HasEffect()

bool Aura::HasEffect ( uint8 effIndex ) const

inline

174{ return bool(GetEffect(effIndex)); }

References GetEffect().

Referenced by Unit::_ApplyAuraEffect(), UnitAura::FillTargetMap(), DynObjAura::FillTargetMap(), AuraScript::HasEffect(), HasEffectType(), HasMoreThanOneEffectForType(), IsArea(), RecalculateAmountOfEffects(), and SetStackAmount().

◆ HasEffectType()

bool Aura::HasEffectType ( AuraType type ) const

{
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (HasEffect(i) && m_effects[i]->GetAuraType() == type)
            return true;
    }
    return false;
}

References HasEffect(), m_effects, and MAX_SPELL_EFFECTS.

Referenced by Unit::_AddAura(), Battleground::_ProcessJoin(), CanBeSentToClient(), AuraScript::HasEffectType(), IsSingleTargetWith(), and Unit::RemoveAura().

◆ HasMoreThanOneEffectForType()

bool Aura::HasMoreThanOneEffectForType ( AuraType auraType ) const

{
    uint32 count = 0;
    for (SpellEffectInfo const& spellEffectInfo : GetSpellInfo()->GetEffects())
        if (HasEffect(spellEffectInfo.EffectIndex) && spellEffectInfo.ApplyAuraName == auraType)
            ++count;
 
    return count > 1;
}

References SpellInfo::GetEffects(), GetSpellInfo(), and HasEffect().

Referenced by Unit::IsHighestExclusiveAuraEffect().

◆ IsAppliedOnTarget()

bool Aura::IsAppliedOnTarget ( ObjectGuid guid ) const

inline

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

References m_applications.

Referenced by _ApplyForTarget(), and Unit::_CreateAuraApplication().

◆ IsArea()

bool Aura::IsArea ( ) const

{
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (HasEffect(i) && GetSpellInfo()->Effects[i].IsAreaAuraEffect())
            return true;
    }
    return false;
}

References GetSpellInfo(), HasEffect(), and MAX_SPELL_EFFECTS.

Referenced by CanStackWith(), Unit::IsHighestExclusiveAuraEffect(), and UpdateTargetMap().

◆ IsAuraStronger()

bool Aura::IsAuraStronger ( Aura const * newAura ) const

{
    for (uint8 i = EFFECT_0; i < MAX_SPELL_EFFECTS; ++i)
    {
        AuraEffect* thisEffect = GetEffect(i);
        if (!thisEffect)
            continue;
 
        AuraEffect* newEffect = nullptr;
        for (uint8 j = EFFECT_0; j < MAX_SPELL_EFFECTS; ++j)
        {
            newEffect = newAura->GetEffect(j);
            if (!newEffect || thisEffect->GetAuraType() != newEffect->GetAuraType() || thisEffect->GetMiscValue() != newEffect->GetMiscValue())
                continue;
 
            // xinef: assume that all spells are either positive or negative, otherwise they should not be in one group
            int32 curValue = std::abs(thisEffect->GetAmount());
            if (curValue < std::abs(newEffect->GetAmount()))
                return true;
 
            if (curValue == std::abs(newEffect->GetAmount()))
                if (!IsPassive() && !IsPermanent() && GetDuration() < newAura->GetDuration())
                    return true;
        }
    }
 
    return false;
}

References EFFECT_0, AuraEffect::GetAmount(), AuraEffect::GetAuraType(), GetDuration(), GetEffect(), AuraEffect::GetMiscValue(), IsPassive(), IsPermanent(), and MAX_SPELL_EFFECTS.

◆ IsDeathPersistent()

bool Aura::IsDeathPersistent ( ) const

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

References GetSpellInfo(), and SpellInfo::IsDeathPersistent().

Referenced by AuraScript::IsDeathPersistent(), and Unit::RemoveAllAurasOnDeath().

◆ IsExpired()

bool Aura::IsExpired ( ) const

inline

138{ return !GetDuration();}

References GetDuration().

Referenced by HandleAuraSpecificMods(), AuraScript::IsExpired(), and DynamicObject::Update().

◆ IsPassive()

bool Aura::IsPassive ( ) const

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

References GetSpellInfo(), and SpellInfo::IsPassive().

Referenced by AuraEffect::ApplySpellMod(), CalcMaxDuration(), AuraEffect::CalculatePeriodic(), CanBeSaved(), CanBeSentToClient(), CanStackWith(), Player::CheckAreaExploreAndOutdoor(), Spell::EffectStealBeneficialBuff(), Spell::EffectSummonPet(), Unit::GetDispellableAuraList(), GetProcEffectMask(), IsAuraStronger(), AuraScript::IsPassive(), list_commandscript::ListAurasCommand(), Spell::prepare(), Unit::RemoveAllAurasOnDeath(), Unit::RemoveAllAurasRequiringDeadTarget(), Unit::RemoveArenaAuras(), and Unit::RemoveEvadeAuras().

◆ IsPermanent()

bool Aura::IsPermanent ( ) const

inline

139{ return GetMaxDuration() == -1; }

References GetMaxDuration().

Referenced by Battleground::_ProcessJoin(), Pet::_SaveAuras(), AuraEffect::ApplySpellMod(), IsAuraStronger(), AuraScript::IsPermanent(), and Unit::RemoveAurasDueToSpellBySteal().

◆ IsProcOnCooldown()

bool Aura::IsProcOnCooldown ( TimePoint now ) const

{
    if (GetType() == UNIT_AURA_TYPE)
        if (Player* player = GetUnitOwner()->ToPlayer())
            if (player->GetCommandStatus(CHEAT_COOLDOWN))
                return false;
 
    return m_procCooldown > now;
}

References CHEAT_COOLDOWN, GetType(), GetUnitOwner(), m_procCooldown, and UNIT_AURA_TYPE.

Referenced by GetProcEffectMask().

◆ IsRemoved()

bool Aura::IsRemoved ( ) const

inline

162{ return m_isRemoved; }

References m_isRemoved.

Referenced by Unit::_AddAura(), Unit::_CreateAuraApplication(), Create(), SpellScript::GetHitAura(), HandleAllEffects(), spell_rog_glyph_of_backstab::HandleProc(), RecalculateAmountOfEffects(), UnitAura::Remove(), DynObjAura::Remove(), DynamicObject::RemoveAura(), Unit::RemoveAura(), Unit::RemoveAura(), Unit::RemoveOwnedAura(), Unit::RemoveOwnedAura(), DynamicObject::Update(), and UpdateTargetMap().

◆ IsRemovedOnShapeLost()

bool Aura::IsRemovedOnShapeLost ( Unit * target ) const

{
    return (GetCasterGUID() == target->GetGUID() && m_spellInfo->Stances && !m_spellInfo->HasAttribute(SPELL_ATTR2_ALLOW_WHILE_NOT_SHAPESHIFTED) && !m_spellInfo->HasAttribute(SPELL_ATTR0_NOT_SHAPESHIFTED));
}

References GetCasterGUID(), Object::GetGUID(), SpellInfo::HasAttribute(), m_spellInfo, SPELL_ATTR0_NOT_SHAPESHIFTED, SPELL_ATTR2_ALLOW_WHILE_NOT_SHAPESHIFTED, and SpellInfo::Stances.

◆ IsSingleTarget()

bool Aura::IsSingleTarget ( ) const

inline

165{return m_isSingleTarget; }

References m_isSingleTarget.

Referenced by Unit::_AddAura(), CanBeAppliedOn(), CanBeSaved(), Unit::RemoveAurasDueToSpellBySteal(), Unit::RemoveNotOwnSingleTargetAuras(), and Unit::RemoveOwnedAura().

◆ IsSingleTargetWith()

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;
}

References GetSpellInfo(), SpellInfo::GetSpellSpecific(), HasEffectType(), SPELL_AURA_CONTROL_VEHICLE, SPELL_SPECIFIC_JUDGEMENT, and SPELL_SPECIFIC_MAGE_POLYMORPH.

Referenced by Unit::_AddAura().

◆ IsUsingCharges()

bool Aura::IsUsingCharges ( ) const

inline

200{ return m_isUsingCharges; }

References m_isUsingCharges.

Referenced by Player::ApplyModToSpell(), CanBeSaved(), ConsumeProcCharges(), GetProcEffectMask(), Player::IsAffectedBySpellmod(), ModCharges(), PrepareProcToTrigger(), Player::RemoveSpellMods(), Player::RestoreSpellMods(), and Unit::SpellBaseDamageBonusTaken().

◆ LoadScripts()

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;
        }
        LOG_DEBUG("spells.aura", "Aura::LoadScripts: Script `{}` for aura `{}` is loaded now", (*itr)->_GetScriptName()->c_str(), m_spellInfo->Id);
        (*itr)->Register();
        ++itr;
    }
}

References SpellInfo::Id, LOG_DEBUG, m_loadedScripts, m_spellInfo, and sScriptMgr.

Referenced by DynObjAura::DynObjAura(), and UnitAura::UnitAura().

◆ ModCharges()

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;
}

References CalcMaxCharges(), IsUsingCharges(), m_procCharges, Remove(), and SetCharges().

Referenced by DropCharge(), AuraScript::ModCharges(), Unit::RemoveAurasDueToSpellByDispel(), and Unit::RemoveAurasDueToSpellBySteal().

◆ ModStackAmount()

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

{
    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() && (m_spellInfo->StackAmount || !m_spellInfo->HasAttribute(SPELL_ATTR1_AURA_UNIQUE));
 
    // Update stack amount
    if (refresh)
    {
        RefreshSpellMods();
        RefreshTimers(periodicReset);
 
        // reset charges
        SetCharges(CalcMaxCharges());
    }
 
    SetStackAmount(stackAmount);
 
    SetNeedClientUpdateForTargets();
    return false;
}

References CalcMaxCharges(), GetStackAmount(), SpellInfo::HasAttribute(), m_spellInfo, m_stackAmount, RefreshSpellMods(), RefreshTimers(), Remove(), SetCharges(), SetNeedClientUpdateForTargets(), SetStackAmount(), SPELL_ATTR1_AURA_UNIQUE, and SpellInfo::StackAmount.

Referenced by spell_the_lich_king_necrotic_plague_jump::AddMissingStack(), ConsumeProcCharges(), Spell::DoSpellHitOnUnit(), misc_commandscript::HandleAuraStacksCommand(), spell_charge_shield_bomber::HandleDummy(), spell_freya_attuned_to_nature_dose_reduction::HandleScript(), AuraScript::ModStackAmount(), Unit::RemoveAuraFromStack(), Unit::RemoveAurasDueToSpellByDispel(), and Unit::RemoveAurasDueToSpellBySteal().

◆ PrepareProcToTrigger()

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

{
    bool prepare = CallScriptPrepareProcHandlers(aurApp, eventInfo);
    if (!prepare)
        return;
 
    // take one charge, aura expiration will be handled in Aura::TriggerProcOnEvent (if needed)
    if (IsUsingCharges() && (!eventInfo.GetSpellInfo() || !eventInfo.GetSpellInfo()->HasAttribute(SPELL_ATTR6_DO_NOT_CONSUME_RESOURCES)))
    {
        --m_procCharges;
        SetNeedClientUpdateForTargets();
    }
 
    SpellProcEntry const* procEntry = sSpellMgr->GetSpellProcEntry(GetId());
 
    ASSERT(procEntry);
 
    // cooldowns should be added to the whole aura (see 51698 area aura)
    AddProcCooldown(now + procEntry->Cooldown);
}

References AddProcCooldown(), ASSERT, CallScriptPrepareProcHandlers(), SpellProcEntry::Cooldown, GetId(), ProcEventInfo::GetSpellInfo(), SpellInfo::HasAttribute(), IsUsingCharges(), m_procCharges, SetNeedClientUpdateForTargets(), SPELL_ATTR6_DO_NOT_CONSUME_RESOURCES, and sSpellMgr.

◆ RecalculateAmountOfEffects()

void Aura::RecalculateAmountOfEffects ( )

{
    ASSERT (!IsRemoved());
    Unit* caster = GetCaster();
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if (HasEffect(i))
            m_effects[i]->RecalculateAmount(caster);
}

References ASSERT, GetCaster(), HasEffect(), IsRemoved(), m_effects, MAX_SPELL_EFFECTS, and AuraEffect::RecalculateAmount().

◆ RefreshDuration()

void Aura::RefreshDuration ( bool withMods = false )

Todo:

Look to convert to std::chrono

{
    Unit* caster = GetCaster();
 
    if (!caster)
        return;
 
    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_SPELL_HASTE_AFFECTS_PERIODIC))
            duration = int32(duration * caster->GetFloatValue(UNIT_MOD_CAST_SPEED));
        SetMaxDuration(duration);
 
        SetDuration(duration);
    }
    else
        SetDuration(GetMaxDuration());
 
    if ((m_spellInfo->ManaPerSecond || m_spellInfo->ManaPerSecondPerLevel) && !m_spellInfo->HasAttribute(SPELL_ATTR2_NO_TARGET_PER_SECOND_COST))
        m_timeCla = 1 * IN_MILLISECONDS;
 
    // also reset periodic counters
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if (AuraEffect* aurEff = m_effects[i])
            aurEff->ResetTicks();
}

References GetCaster(), Object::GetFloatValue(), GetMaxDuration(), SpellInfo::GetMaxDuration(), SpellInfo::HasAttribute(), Unit::HasAuraTypeWithAffectMask(), IN_MILLISECONDS, m_effects, m_spellInfo, m_timeCla, SpellInfo::ManaPerSecond, SpellInfo::ManaPerSecondPerLevel, MAX_SPELL_EFFECTS, SetDuration(), SetMaxDuration(), SPELL_ATTR2_NO_TARGET_PER_SECOND_COST, SPELL_ATTR5_SPELL_HASTE_AFFECTS_PERIODIC, SPELL_AURA_PERIODIC_HASTE, and UNIT_MOD_CAST_SPEED.

Referenced by spell_hun_chimera_shot::HandleScriptEffect(), boss_shirrak_the_dead_watcher::JustEngagedWith(), AuraScript::RefreshDuration(), RefreshTimers(), RefreshTimersWithMods(), and AuraEffect::UpdatePeriodic().

◆ RefreshSpellMods()

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);
}

References Unit::GetTarget(), and m_applications.

Referenced by ModStackAmount().

◆ RefreshTimers()

void Aura::RefreshTimers ( bool periodicReset = false )

{
    m_maxDuration = CalcMaxDuration();
    RefreshDuration();
    Unit* caster = GetCaster();
 
    if (!caster)
    {
        return;
    }
 
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (AuraEffect* aurEff = m_effects[i])
        {
            aurEff->CalculatePeriodic(caster, periodicReset, false);
            aurEff->CalculatePeriodicData();
        }
    }
}

References CalcMaxDuration(), GetCaster(), m_effects, m_maxDuration, MAX_SPELL_EFFECTS, and RefreshDuration().

Referenced by ModStackAmount().

◆ RefreshTimersWithMods()

void Aura::RefreshTimersWithMods ( )

{
    Unit* caster = GetCaster();
    m_maxDuration = CalcMaxDuration();
    if ((caster && caster->HasAuraTypeWithAffectMask(SPELL_AURA_PERIODIC_HASTE, m_spellInfo)) || m_spellInfo->HasAttribute(SPELL_ATTR5_SPELL_HASTE_AFFECTS_PERIODIC))
    {
        m_maxDuration = int32(m_maxDuration * caster->GetFloatValue(UNIT_MOD_CAST_SPEED));
    }
 
    // xinef: we should take ModSpellDuration into account, but none of the spells using this function is affected by contents of ModSpellDuration
    RefreshDuration();
 
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (AuraEffect* aurEff = m_effects[i])
        {
            aurEff->CalculatePeriodic(caster, false, false);
        }
    }
}

References CalcMaxDuration(), GetCaster(), Object::GetFloatValue(), SpellInfo::HasAttribute(), Unit::HasAuraTypeWithAffectMask(), m_effects, m_maxDuration, m_spellInfo, MAX_SPELL_EFFECTS, RefreshDuration(), SPELL_ATTR5_SPELL_HASTE_AFFECTS_PERIODIC, SPELL_AURA_PERIODIC_HASTE, and UNIT_MOD_CAST_SPEED.

◆ Remove()

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

pure virtual

◆ ResetProcCooldown()

void Aura::ResetProcCooldown ( )

{
    m_procCooldown = std::chrono::steady_clock::now();
}

References m_procCooldown.

◆ SetCharges()

void Aura::SetCharges ( uint8 charges )

{
    if (m_procCharges == charges)
        return;
    m_procCharges = charges;
    m_isUsingCharges = m_procCharges != 0;
    SetNeedClientUpdateForTargets();
}

References m_isUsingCharges, m_procCharges, and SetNeedClientUpdateForTargets().

Referenced by AuraEffect::HandleAuraDummy(), Unit::HandleAuraRaidProcFromCharge(), Unit::HandleAuraRaidProcFromChargeWithValue(), AuraEffect::HandleRaidProcFromChargeAuraProc(), AuraEffect::HandleRaidProcFromChargeWithValueAuraProc(), ModCharges(), ModStackAmount(), and AuraScript::SetCharges().

◆ SetDuration()

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

References GetCaster(), GetId(), Unit::GetSpellModOwner(), m_duration, SetNeedClientUpdateForTargets(), and SPELLMOD_DURATION.

Referenced by AuraEffect::CalculatePeriodic(), Unit::DelayOwnedAuras(), Spell::DoSpellHitOnUnit(), Spell::EffectScriptEffect(), Unit::GetDiseasesByCaster(), Spell::handle_immediate(), HandleAuraSpecificMods(), deserter_commandscript::HandleDeserterAdd(), spell_serpentshrine_cavern_coilfang_water::HandlePeriodic(), spell_rog_glyph_of_backstab::HandleProc(), spell_sha_t10_elemental_4p_bonus::HandleProc(), spell_dk_glyph_of_scourge_strike_script::HandleScriptEffect(), spell_dru_glyph_of_starfire::HandleScriptEffect(), Spell::prepare(), RefreshDuration(), AuraScript::SetDuration(), and DynamicObject::SetDuration().

◆ SetIsSingleTarget()

void Aura::SetIsSingleTarget ( bool val )

inline

167{ m_isSingleTarget = val; }

References m_isSingleTarget.

Referenced by Unit::_AddAura(), Unit::RemoveAurasDueToSpellBySteal(), and UnregisterSingleTarget().

◆ SetLoadedState()

void Aura::SetLoadedState	(	int32	maxduration,
		int32	duration,
		int32	charges,
		uint8	stackamount,
		uint8	recalculateMask,
		int32 *	amount
	)

{
    m_maxDuration = maxduration;
    m_duration = duration;
    m_procCharges = charges;
    m_isUsingCharges = m_procCharges != 0;
    m_stackAmount = stackamount;
    Unit* caster = GetCaster();
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if (m_effects[i])
        {
            m_effects[i]->SetAmount(amount[i]);
            m_effects[i]->SetCanBeRecalculated(recalculateMask & (1 << i));
            m_effects[i]->CalculatePeriodic(caster, false, true);
            m_effects[i]->CalculateSpellMod();
            m_effects[i]->RecalculateAmount(caster);
        }
}

References AuraEffect::CalculatePeriodic(), AuraEffect::CalculateSpellMod(), GetCaster(), m_duration, m_effects, m_isUsingCharges, m_maxDuration, m_procCharges, m_stackAmount, MAX_SPELL_EFFECTS, AuraEffect::RecalculateAmount(), AuraEffect::SetAmount(), and AuraEffect::SetCanBeRecalculated().

◆ SetMaxDuration()

void Aura::SetMaxDuration ( int32 duration )

inline

130{ m_maxDuration = duration; }

References m_maxDuration.

Referenced by Spell::DoSpellHitOnUnit(), Spell::EffectScriptEffect(), Unit::GetDiseasesByCaster(), Spell::handle_immediate(), HandleAuraSpecificMods(), spell_sha_t10_elemental_4p_bonus::HandleProc(), spell_dk_glyph_of_scourge_strike_script::HandleScriptEffect(), spell_dru_glyph_of_starfire::HandleScriptEffect(), RefreshDuration(), and AuraScript::SetMaxDuration().

◆ SetNeedClientUpdateForTargets()

void Aura::SetNeedClientUpdateForTargets ( ) const

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

References m_applications.

Referenced by Unit::DelayOwnedAuras(), ModStackAmount(), PrepareProcToTrigger(), SetCharges(), SetDuration(), and SetStackAmount().

◆ SetStackAmount()

void Aura::SetStackAmount ( uint8 num )

{
    m_stackAmount = stackAmount;
    Unit* caster = GetCaster();
 
    if (!caster)
        return;
 
    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 (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if (HasEffect(i))
            m_effects[i]->ChangeAmount(m_effects[i]->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);
 
    SetNeedClientUpdateForTargets();
}

References GetApplicationList(), GetCaster(), HandleAuraSpecificMods(), HasEffect(), m_effects, m_stackAmount, MAX_SPELL_EFFECTS, and SetNeedClientUpdateForTargets().

Referenced by Spell::DoSpellHitOnUnit(), AuraEffect::HandleAuraDummy(), spell_brewfest_main_ram_buff::HandleEffectPeriodic(), spell_rotface_large_ooze_combine::HandleScript(), boss_shirrak_the_dead_watcher::JustEngagedWith(), ModStackAmount(), Unit::SetAuraStack(), and AuraScript::SetStackAmount().

◆ SetTriggeredByAuraSpellInfo()

void Aura::SetTriggeredByAuraSpellInfo ( SpellInfo const * triggeredByAuraSpellInfo )

{
    m_triggeredByAuraSpellInfo = triggeredByAuraSpellInfo;
}

References m_triggeredByAuraSpellInfo.

Referenced by Spell::DoSpellHitOnUnit(), and Spell::EffectPersistentAA().

◆ SetUsingCharges()

void Aura::SetUsingCharges ( bool val )

inline

201{ m_isUsingCharges = val; }

References m_isUsingCharges.

Referenced by AuraEffect::HandleRaidProcFromChargeAuraProc(), and AuraEffect::HandleRaidProcFromChargeWithValueAuraProc().

◆ TriggerProcOnEvent()

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

{
    bool prevented = CallScriptProcHandlers(aurApp, eventInfo);
    if (!prevented)
    {
        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        {
            if (!(procEffectMask & (1 << i)))
                continue;
 
            // OnEffectProc / AfterEffectProc hooks handled in AuraEffect::HandleProc()
            if (aurApp->HasEffect(i))
                GetEffect(i)->HandleProc(aurApp, eventInfo);
        }
 
        CallScriptAfterProcHandlers(aurApp, eventInfo);
    }
 
    ConsumeProcCharges(sSpellMgr->GetSpellProcEntry(GetId()));
}

References CallScriptAfterProcHandlers(), CallScriptProcHandlers(), ConsumeProcCharges(), GetEffect(), GetId(), AuraEffect::HandleProc(), AuraApplication::HasEffect(), MAX_SPELL_EFFECTS, and sSpellMgr.

◆ TryCreate()

Aura * Aura::TryCreate	(	SpellInfo const *	spellproto,
		uint8	effMask,
		WorldObject *	owner,
		Unit *	caster,
		int32 *	baseAmount = `nullptr`,
		Item *	castItem = `nullptr`,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		ObjectGuid	itemGUID = `ObjectGuid::Empty`
	)

static

{
    ASSERT_NODEBUGINFO(spellproto);
    ASSERT_NODEBUGINFO(owner);
    ASSERT_NODEBUGINFO(caster || casterGUID);
    ASSERT_NODEBUGINFO(tryEffMask <= MAX_EFFECT_MASK);
    uint8 effMask = Aura::BuildEffectMaskForOwner(spellproto, tryEffMask, owner);
    if (!effMask)
        return nullptr;
    return Create(spellproto, effMask, owner, caster, baseAmount, castItem, casterGUID, itemGUID);
}

References ASSERT_NODEBUGINFO, BuildEffectMaskForOwner(), Create(), and MAX_EFFECT_MASK.

Referenced by Pet::_LoadAuras(), Player::_LoadAuras(), Spell::EffectPersistentAA(), and Unit::RemoveAurasDueToSpellByDispel().

◆ TryRefreshStackOrCreate()

Aura * Aura::TryRefreshStackOrCreate	(	SpellInfo const *	spellproto,
		uint8	tryEffMask,
		WorldObject *	owner,
		Unit *	caster,
		int32 *	baseAmount = `nullptr`,
		Item *	castItem = `nullptr`,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		bool *	refresh = `nullptr`,
		bool	periodicReset = `false`
	)

static

{
    ASSERT_NODEBUGINFO(spellproto);
    ASSERT_NODEBUGINFO(owner);
    ASSERT_NODEBUGINFO(caster || casterGUID);
    ASSERT_NODEBUGINFO(tryEffMask <= MAX_EFFECT_MASK);
    if (refresh)
        *refresh = false;
    uint8 effMask = Aura::BuildEffectMaskForOwner(spellproto, tryEffMask, owner);
    if (!effMask)
        return nullptr;
    if (Aura* foundAura = owner->ToUnit()->_TryStackingOrRefreshingExistingAura(spellproto, effMask, caster, baseAmount, castItem, casterGUID, periodicReset))
    {
        // 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 nullptr;
 
        if (refresh)
            *refresh = true;
        return foundAura;
    }
    else
        return Create(spellproto, effMask, owner, caster, baseAmount, castItem, casterGUID);
}

References Unit::_TryStackingOrRefreshingExistingAura(), ASSERT_NODEBUGINFO, BuildEffectMaskForOwner(), Create(), MAX_EFFECT_MASK, and Object::ToUnit().

Referenced by Unit::AddAura(), Spell::DoSpellHitOnUnit(), misc_commandscript::HandleAuraCommand(), misc_commandscript::HandleFreezeCommand(), spell_putricide_slime_puddle::HandleScript(), Unit::HandleSpellClick(), and Unit::RemoveAurasDueToSpellBySteal().

◆ UnregisterSingleTarget()

void Aura::UnregisterSingleTarget ( )

{
    ASSERT(m_isSingleTarget);
    Unit* caster = GetCaster();
    if (!caster)
    {
        LOG_INFO("spells", "Aura::UnregisterSingleTarget: (A1) - {}, {}, {}, {}", GetId(), GetOwner()->GetTypeId(), GetOwner()->GetEntry(), GetOwner()->GetName());
        LOG_ERROR("spells", "Aura::UnregisterSingleTarget: No caster was found."); //ASSERT(caster);
    }
    else
        caster->GetSingleCastAuras().remove(this);
 
    SetIsSingleTarget(false);
}

References ASSERT, GetCaster(), GetId(), GetOwner(), Unit::GetSingleCastAuras(), LOG_ERROR, LOG_INFO, m_isSingleTarget, and SetIsSingleTarget().

Referenced by Unit::RemoveAurasDueToSpellBySteal(), and Unit::RemoveOwnedAura().

◆ Update()

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 (int32 ManaPerSecond = m_spellInfo->ManaPerSecond + m_spellInfo->ManaPerSecondPerLevel * caster->GetLevel())
                {
                    m_timeCla += 1000 - diff;
 
                    Powers powertype = Powers(m_spellInfo->PowerType);
                    if (powertype == POWER_HEALTH)
                    {
                        if (int32(caster->GetHealth()) > ManaPerSecond)
                            caster->ModifyHealth(-ManaPerSecond);
                        else
                        {
                            Remove();
                            return;
                        }
                    }
                    else
                    {
                        if (int32(caster->GetPower(powertype)) >= ManaPerSecond)
                            caster->ModifyPower(powertype, -ManaPerSecond);
                        else
                        {
                            Remove();
                            return;
                        }
                    }
                }
            }
        }
    }
}

References Unit::GetHealth(), Unit::GetLevel(), Unit::GetPower(), m_duration, m_spellInfo, m_timeCla, SpellInfo::ManaPerSecond, SpellInfo::ManaPerSecondPerLevel, Unit::ModifyHealth(), Unit::ModifyPower(), POWER_HEALTH, SpellInfo::PowerType, and Remove().

Referenced by UpdateOwner().

◆ UpdateOwner()

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

{
    if (owner != m_owner)
    {
        ABORT();
    }
 
    Unit* caster = GetCaster();
    // Apply spellmods for channeled auras
    // used for example when triggered spell of spell:10 is modded
    Spell* modSpell = nullptr;
    Player* modOwner = nullptr;
    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 (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if (m_effects[i])
            m_effects[i]->Update(diff, caster);
 
    // remove spellmods after effects update
    if (modSpell)
        modOwner->SetSpellModTakingSpell(modSpell, false);
 
    _DeleteRemovedApplications();
}

References _DeleteRemovedApplications(), ABORT, Unit::FindCurrentSpellBySpellId(), GetCaster(), GetId(), Unit::GetSpellModOwner(), m_effects, m_owner, m_updateTargetMapInterval, MAX_SPELL_EFFECTS, Player::SetSpellModTakingSpell(), AuraEffect::Update(), Update(), and UpdateTargetMap().

Referenced by DynamicObject::Update().

◆ UpdateTargetMap()

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

{
    if (IsRemoved())
        return;
 
    m_updateTargetMapInterval = UPDATE_TARGET_MAP_INTERVAL;
 
    // fill up to date target list
    //       target, effMask
    std::map<Unit*, uint8> 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*, uint8>::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
        {
            // xinef: check immunities here, so aura wont get removed on every tick and then reapplied
            if (IsArea())
                for (uint8 effIndex = 0; effIndex < MAX_SPELL_EFFECTS; ++effIndex)
                {
                    if ((existing->second & (1 << effIndex)) && existing->first->IsImmunedToSpellEffect(GetSpellInfo(), effIndex, GetCaster()))
                        existing->second &= ~(1 << effIndex);
                }
 
            // 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*, uint8>::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->second & (1 << effIndex)) && itr->first->IsImmunedToSpellEffect(GetSpellInfo(), effIndex, GetCaster()))
                itr->second &= ~(1 << effIndex);
        }
        if (!itr->second || itr->first->IsImmunedToSpell(GetSpellInfo(), GetCaster()) || !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;
 
            // Allow only 1 persistent area aura to affect our targets if a custom flag is set.
            if (itr->first->HasAura(GetId()) && GetSpellInfo()->HasAttribute(SPELL_ATTR0_CU_ONLY_ONE_AREA_AURA))
                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))
            {
                //TODO: There is a crash caused by shadowfiend load addon
                LOG_FATAL("spells.aura", "Aura {}: Owner {} (map {}) is not in the same map as target {} (map {}).", GetSpellInfo()->Id,
                               GetOwner()->GetName(), GetOwner()->IsInWorld() ? GetOwner()->GetMap()->GetId() : uint32(-1),
                               itr->first->GetName(), 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*, uint8>::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);
        }
    }
}

References ABORT, ASSERT, AURA_REMOVE_BY_DEFAULT, CanBeAppliedOn(), CanStackWith(), DYNOBJ_AURA_TYPE, FillTargetMap(), GetApplicationOfTarget(), GetCaster(), GetId(), GetOwner(), GetSpellInfo(), GetType(), SpellInfo::HasAttribute(), IsArea(), IsRemoved(), WorldObject::IsSelfOrInSameMap(), LOG_FATAL, m_applications, m_updateTargetMapInterval, MAX_SPELL_EFFECTS, SPELL_ATTR0_CU_ONLY_ONE_AREA_AURA, and UPDATE_TARGET_MAP_INTERVAL.

Referenced by _RegisterForTargets(), ApplyForTargets(), and UpdateOwner().

Friends And Related Symbol Documentation

◆ Unit::_TryStackingOrRefreshingExistingAura

Aura * Unit::_TryStackingOrRefreshingExistingAura	(	SpellInfo const *	newAura,
		uint8	effMask,
		Unit *	caster,
		int32 *	baseAmount,
		Item *	castItem,
		ObjectGuid	casterGUID,
		bool	noPeriodicReset
	)

friend

Member Data Documentation

◆ m_applications

ApplicationMap Aura::m_applications

protected

Referenced by _ApplyEffectForTargets(), _ApplyForTarget(), _Remove(), _UnapplyForTarget(), GetApplicationList(), GetApplicationMap(), GetApplicationOfTarget(), GetApplicationOfTarget(), IsAppliedOnTarget(), RefreshSpellMods(), SetNeedClientUpdateForTargets(), UpdateTargetMap(), and ~Aura().

◆ m_applyTime

time_t const Aura::m_applyTime

protected

Referenced by GetApplyTime().

◆ m_casterGuid

ObjectGuid const Aura::m_casterGuid

protected

Referenced by GetCasterGUID().

◆ m_casterLevel

uint8 const Aura::m_casterLevel

protected

Referenced by GetCasterLevel().

◆ m_castItemEntry

uint32 const Aura::m_castItemEntry

protected

Referenced by GetCastItemEntry().

◆ m_castItemGuid

ObjectGuid const Aura::m_castItemGuid

protected

Referenced by _ApplyForTarget(), _UnapplyForTarget(), CanStackWith(), and GetCastItemGUID().

◆ m_duration

int32 Aura::m_duration

protected

Referenced by Aura(), GetDuration(), SetDuration(), SetLoadedState(), and Update().

◆ m_effects

AuraEffect* Aura::m_effects[3]

protected

Referenced by _InitEffects(), Aura(), GetEffect(), GetEffectMask(), HandleAllEffects(), HasEffectType(), RecalculateAmountOfEffects(), RefreshDuration(), RefreshTimers(), RefreshTimersWithMods(), SetLoadedState(), SetStackAmount(), UpdateOwner(), and ~Aura().

◆ m_isRemoved

bool Aura::m_isRemoved

protected

Referenced by _Remove(), and IsRemoved().

◆ m_isSingleTarget

bool Aura::m_isSingleTarget

protected

Referenced by IsSingleTarget(), SetIsSingleTarget(), and UnregisterSingleTarget().

◆ m_isUsingCharges

bool Aura::m_isUsingCharges

protected

Referenced by Aura(), IsUsingCharges(), SetCharges(), SetLoadedState(), and SetUsingCharges().

◆ m_loadedScripts

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

◆ m_maxDuration

int32 Aura::m_maxDuration

protected

Referenced by Aura(), GetMaxDuration(), RefreshTimers(), RefreshTimersWithMods(), SetLoadedState(), and SetMaxDuration().

◆ m_owner

WorldObject* const Aura::m_owner

protected

Referenced by GetDynobjOwner(), GetOwner(), GetType(), GetUnitOwner(), and UpdateOwner().

◆ m_procCharges

uint8 Aura::m_procCharges

protected

Referenced by Aura(), GetCharges(), ModCharges(), PrepareProcToTrigger(), SetCharges(), and SetLoadedState().

◆ m_procCooldown

TimePoint Aura::m_procCooldown

protected

Referenced by AddProcCooldown(), IsProcOnCooldown(), and ResetProcCooldown().

◆ m_removedApplications

Unit::AuraApplicationList Aura::m_removedApplications

private

Referenced by _DeleteRemovedApplications(), and _UnapplyForTarget().

◆ m_spellInfo

SpellInfo const* const Aura::m_spellInfo

protected

◆ m_stackAmount

uint8 Aura::m_stackAmount

protected

Referenced by GetStackAmount(), ModStackAmount(), SetLoadedState(), and SetStackAmount().

◆ m_timeCla

int32 Aura::m_timeCla

protected

Referenced by Aura(), RefreshDuration(), and Update().

◆ m_triggeredByAuraSpellInfo

SpellInfo const* Aura::m_triggeredByAuraSpellInfo

private

Referenced by GetTriggeredByAuraSpellInfo(), and SetTriggeredByAuraSpellInfo().

◆ m_updateTargetMapInterval

int32 Aura::m_updateTargetMapInterval

protected

Referenced by UpdateOwner(), and UpdateTargetMap().

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

azerothcore-wotlk/src/server/game/Spells/Auras/SpellAuras.h
azerothcore-wotlk/src/server/game/Spells/Auras/SpellAuras.cpp

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ ApplicationMap

Constructor & Destructor Documentation

◆ Aura()

◆ ~Aura()

Member Function Documentation

◆ _ApplyEffectForTargets()

◆ _ApplyForTarget()

◆ _DeleteRemovedApplications()

◆ _InitEffects()

◆ _RegisterForTargets()

◆ _Remove()

◆ _UnapplyForTarget()

◆ AddProcCooldown() [1/2]

◆ AddProcCooldown() [2/2]

◆ ApplyForTargets()

◆ BuildEffectMaskForOwner()

◆ CalcDispelChance()

◆ CalcMaxCharges() [1/2]

◆ CalcMaxCharges() [2/2]

◆ CalcMaxDuration() [1/2]

◆ CalcMaxDuration() [2/2]

◆ CalcProcChance()

◆ CallScriptAfterCheckProcHandlers()

◆ CallScriptAfterDispel()

◆ CallScriptAfterEffectApplyHandlers()

◆ CallScriptAfterEffectProcHandlers()

◆ CallScriptAfterEffectRemoveHandlers()

◆ CallScriptAfterProcHandlers()

◆ CallScriptCheckAreaTargetHandlers()

◆ CallScriptCheckEffectProcHandlers()

◆ CallScriptCheckProcHandlers()

◆ CallScriptDispel()

◆ CallScriptEffectAbsorbHandlers()

◆ CallScriptEffectAfterAbsorbHandlers()

◆ CallScriptEffectAfterManaShieldHandlers()

◆ CallScriptEffectApplyHandlers()

◆ CallScriptEffectCalcAmountHandlers()

◆ CallScriptEffectCalcPeriodicHandlers()

◆ CallScriptEffectCalcSpellModHandlers()

◆ CallScriptEffectManaShieldHandlers()

◆ CallScriptEffectPeriodicHandlers()

◆ CallScriptEffectProcHandlers()

◆ CallScriptEffectRemoveHandlers()

◆ CallScriptEffectSplitHandlers()

◆ CallScriptEffectUpdatePeriodicHandlers()

◆ CallScriptPrepareProcHandlers()

◆ CallScriptProcHandlers()

◆ CanBeAppliedOn()

◆ CanBeSaved()

◆ CanBeSentToClient()

◆ CanStackWith()

◆ CheckAreaTarget()

◆ ConsumeProcCharges()

◆ Create()

◆ DropCharge()

◆ FillTargetMap()

◆ GetApplicationList()

◆ GetApplicationMap()

◆ GetApplicationOfTarget() [1/2]

◆ GetApplicationOfTarget() [2/2]

◆ GetApplyTime()

◆ GetCaster()

◆ GetCasterGUID()

◆ GetCasterLevel()

◆ GetCastItemEntry()

◆ GetCastItemGUID()

◆ GetCharges()

◆ GetDebugInfo()

◆ GetDuration()

◆ GetDynobjOwner()