#include "SpellInfo.h"

Public Member Functions
	SpellInfo (SpellEntry const *spellEntry)

	~SpellInfo ()

uint32	GetCategory () const

bool	HasEffect (SpellEffects effect) const

bool	HasEffectMechanic (Mechanics mechanic) const

bool	HasAura (AuraType aura) const

bool	HasAnyAura () const

bool	HasAreaAuraEffect () const

bool	HasOnlyDamageEffects () const

bool	HasAttribute (SpellAttr0 attribute) const

bool	HasAttribute (SpellAttr1 attribute) const

bool	HasAttribute (SpellAttr2 attribute) const

bool	HasAttribute (SpellAttr3 attribute) const

bool	HasAttribute (SpellAttr4 attribute) const

bool	HasAttribute (SpellAttr5 attribute) const

bool	HasAttribute (SpellAttr6 attribute) const

bool	HasAttribute (SpellAttr7 attribute) const

bool	HasAttribute (SpellCustomAttributes customAttribute) const

bool	IsExplicitDiscovery () const

bool	IsLootCrafting () const

bool	IsQuestTame () const

bool	IsProfessionOrRiding () const

bool	IsProfession () const

bool	IsPrimaryProfession () const

bool	IsPrimaryProfessionFirstRank () const

bool	IsAbilityLearnedWithProfession () const

bool	IsAbilityOfSkillType (uint32 skillType) const

bool	IsAffectingArea () const

bool	CanBeRedirectedBySpellMagnet () const

bool	IsTargetingArea () const

bool	NeedsExplicitUnitTarget () const

bool	NeedsToBeTriggeredByCaster (SpellInfo const *triggeringSpell, uint8 effIndex=MAX_SPELL_EFFECTS) const

bool	IsChannelCategorySpell () const

bool	IsSelfCast () const

bool	IsPassive () const

bool	IsAutocastable () const

bool	ComputeIsCritCapable () const

bool	IsCritCapable () const

bool	RequireCooldownInfo () const

void	SetCritCapable (bool val)

bool	ComputeIsStackableWithRanks () const

bool	IsStackableWithRanks () const

void	SetStackableWithRanks (bool val)

bool	IsSpellValid () const

void	SetSpellValid (bool val)

bool	IsPassiveStackableWithRanks () const

bool	IsMultiSlotAura () const

bool	IsCooldownStartedOnEvent () const

bool	IsDeathPersistent () const

bool	IsRequiringDeadTarget () const

bool	IsAllowingDeadTarget () const

bool	CanBeUsedInCombat () const

bool	IsPositive () const

bool	IsPositiveEffect (uint8 effIndex) const

bool	IsChanneled () const

bool	IsActionAllowedChannel () const

bool	NeedsComboPoints () const

bool	IsBreakingStealth () const

bool	IsRangedWeaponSpell () const

bool	IsAutoRepeatRangedSpell () const

bool	HasInitialAggro () const

bool	IsAffected (uint32 familyName, flag96 const &familyFlags) const

bool	IsAffectedBySpellMods () const

bool	IsAffectedBySpellMod (SpellModifier const *mod) const

bool	CanPierceImmuneAura (SpellInfo const *auraSpellInfo) const

bool	CanDispelAura (SpellInfo const *auraSpellInfo) const

void	ApplyAllSpellImmunitiesTo (Unit target, SpellEffectInfo const effect, bool apply) const

bool	CanSpellProvideImmunityAgainstAura (SpellInfo const *auraSpellInfo) const

bool	CanSpellCastOverrideAuraEffect (AuraEffect const *aurEff) const

bool	IsSingleTarget () const

bool	IsAuraExclusiveBySpecificWith (SpellInfo const *spellInfo) const

bool	IsAuraExclusiveBySpecificPerCasterWith (SpellInfo const *spellInfo) const

SpellCastResult	CheckShapeshift (uint32 form) const

SpellCastResult	CheckLocation (uint32 map_id, uint32 zone_id, uint32 area_id, Player *player=nullptr, bool strict=true) const

SpellCastResult	CheckTarget (WorldObject const caster, WorldObject const target, bool implicit=true, Unit const *originalCaster=nullptr) const

SpellCastResult	CheckExplicitTarget (WorldObject const caster, WorldObject const target, Item const *itemTarget=nullptr) const

bool	CheckTargetCreatureType (Unit const *target) const

bool	IsAuraEffectEqual (SpellInfo const *otherSpellInfo) const

bool	ValidateAttribute6SpellDamageMods (Unit const caster, AuraEffect const auraEffect, bool isDot) const

SpellSchoolMask	GetSchoolMask () const

uint64	GetAllEffectsMechanicMask () const

uint64	GetEffectMechanicMask (uint8 effIndex) const

uint64	GetSpellMechanicMaskByEffectMask (uint32 effectMask) const

Mechanics	GetEffectMechanic (uint8 effIndex) const

bool	HasAnyEffectMechanic () const

ImmunityInfo const *	GetImmunityInfo (uint8 effIndex) const

uint32	GetDispelMask () const

uint32	GetExplicitTargetMask () const

AuraStateType	GetAuraState () const

SpellSpecificType	GetSpellSpecific () const

float	GetMinRange (bool positive=false) const

float	GetMaxRange (bool positive=false, WorldObject caster=nullptr, Spell spell=nullptr) const

int32	GetDuration () const

int32	GetMaxDuration () const

uint32	GetMaxTicks () const

uint32	CalcCastTime (WorldObject caster=nullptr, Spell spell=nullptr) const

uint32	GetRecoveryTime () const

int32	CalcPowerCost (WorldObject const caster, SpellSchoolMask schoolMask, Spell spell=nullptr) const

bool	IsRanked () const

uint8	GetRank () const

SpellInfo const *	GetFirstRankSpell () const

SpellInfo const *	GetLastRankSpell () const

SpellInfo const *	GetNextRankSpell () const

SpellInfo const *	GetPrevRankSpell () const

SpellInfo const *	GetAuraRankForLevel (uint8 level) const

bool	IsRankOf (SpellInfo const *spellInfo) const

bool	IsDifferentRankOf (SpellInfo const *spellInfo) const

bool	IsHighRankOf (SpellInfo const *spellInfo) const

std::array< SpellEffectInfo, MAX_SPELL_EFFECTS > const &	GetEffects () const

SpellEffectInfo const &	GetEffect (SpellEffIndex index) const

void	_InitializeExplicitTargetMask ()

bool	_IsPositiveEffect (uint8 effIndex, bool deep) const

bool	_IsPositiveSpell () const

AuraStateType	LoadAuraState () const

SpellSpecificType	LoadSpellSpecific () const

void	_UnloadImplicitTargetConditionLists ()

void	_LoadImmunityInfo ()

std::array< SpellEffectInfo, MAX_SPELL_EFFECTS > &	_GetEffects ()

SpellEffectInfo &	_GetEffect (SpellEffIndex index)

Static Public Member Functions
static uint32	GetDispelMask (DispelType type)

static bool	_IsPositiveTarget (uint32 targetA, uint32 targetB)

Public Attributes
uint32	Id

SpellCategoryEntry const *	CategoryEntry

uint32	Dispel

uint32	Mechanic

uint32	Attributes

uint32	AttributesEx

uint32	AttributesEx2

uint32	AttributesEx3

uint32	AttributesEx4

uint32	AttributesEx5

uint32	AttributesEx6

uint32	AttributesEx7

uint32	AttributesCu

uint32	Stances

uint32	StancesNot

uint32	Targets

uint32	TargetCreatureType

uint32	RequiresSpellFocus

uint32	FacingCasterFlags

uint32	CasterAuraState

uint32	TargetAuraState

uint32	CasterAuraStateNot

uint32	TargetAuraStateNot

uint32	CasterAuraSpell

uint32	TargetAuraSpell

uint32	ExcludeCasterAuraSpell

uint32	ExcludeTargetAuraSpell

SpellCastTimesEntry const *	CastTimeEntry

uint32	RecoveryTime

uint32	CategoryRecoveryTime

uint32	StartRecoveryCategory

uint32	StartRecoveryTime

uint32	InterruptFlags

uint32	AuraInterruptFlags

uint32	ChannelInterruptFlags

uint32	ProcFlags

uint32	ProcChance

uint32	ProcCharges

uint32	MaxLevel

uint32	BaseLevel

uint32	SpellLevel

SpellDurationEntry const *	DurationEntry

uint32	PowerType

uint32	ManaCost

uint32	ManaCostPerlevel

uint32	ManaPerSecond

uint32	ManaPerSecondPerLevel

uint32	ManaCostPercentage

uint32	RuneCostID

SpellRangeEntry const *	RangeEntry

float	Speed

uint32	StackAmount

std::array< uint32, 2 >	Totem

std::array< int32, MAX_SPELL_REAGENTS >	Reagent

std::array< uint32, MAX_SPELL_REAGENTS >	ReagentCount

int32	EquippedItemClass

int32	EquippedItemSubClassMask

int32	EquippedItemInventoryTypeMask

std::array< uint32, 2 >	TotemCategory

std::array< uint32, 2 >	SpellVisual

uint32	SpellIconID

uint32	ActiveIconID

uint32	SpellPriority

std::array< char const *, 16 >	SpellName

std::array< char const *, 16 >	Rank

uint32	MaxTargetLevel

uint32	MaxAffectedTargets

uint32	SpellFamilyName

flag96	SpellFamilyFlags

uint32	DmgClass

uint32	PreventionType

int32	AreaGroupId

uint32	SchoolMask

std::array< SpellEffectInfo, MAX_SPELL_EFFECTS >	Effects

uint32	ExplicitTargetMask

SpellChainNode const *	ChainEntry

AuraStateType	_auraState

SpellSpecificType	_spellSpecific

bool	_isStackableWithRanks

bool	_isSpellValid

bool	_isCritCapable

bool	_requireCooldownInfo

float	JumpDistance

SpellDiminishInfo	_diminishInfoNonTriggered

SpellDiminishInfo	_diminishInfoTriggered

ImmunityInfo	_immunityInfo [MAX_SPELL_EFFECTS]

Friends
class	SpellMgr

Detailed Description

Constructor & Destructor Documentation

◆ SpellInfo()

SpellInfo::SpellInfo ( SpellEntry const * spellEntry )

{
    Id = spellEntry->Id;
    CategoryEntry = spellEntry->Category ? sSpellCategoryStore.LookupEntry(spellEntry->Category) : nullptr;
    Dispel = spellEntry->Dispel;
    Mechanic = spellEntry->Mechanic;
    Attributes = spellEntry->Attributes;
    AttributesEx = spellEntry->AttributesEx;
    AttributesEx2 = spellEntry->AttributesEx2;
    AttributesEx3 = spellEntry->AttributesEx3;
    AttributesEx4 = spellEntry->AttributesEx4;
    AttributesEx5 = spellEntry->AttributesEx5;
    AttributesEx6 = spellEntry->AttributesEx6;
    AttributesEx7 = spellEntry->AttributesEx7;
    AttributesCu = 0;
    Stances = spellEntry->Stances;
    StancesNot = spellEntry->StancesNot;
    Targets = spellEntry->Targets;
    TargetCreatureType = spellEntry->TargetCreatureType;
    RequiresSpellFocus = spellEntry->RequiresSpellFocus;
    FacingCasterFlags = spellEntry->FacingCasterFlags;
    CasterAuraState = spellEntry->CasterAuraState;
    TargetAuraState = spellEntry->TargetAuraState;
    CasterAuraStateNot = spellEntry->CasterAuraStateNot;
    TargetAuraStateNot = spellEntry->TargetAuraStateNot;
    CasterAuraSpell = spellEntry->CasterAuraSpell;
    TargetAuraSpell = spellEntry->TargetAuraSpell;
    ExcludeCasterAuraSpell = spellEntry->ExcludeCasterAuraSpell;
    ExcludeTargetAuraSpell = spellEntry->ExcludeTargetAuraSpell;
    CastTimeEntry = spellEntry->CastingTimeIndex ? sSpellCastTimesStore.LookupEntry(spellEntry->CastingTimeIndex) : nullptr;
    RecoveryTime = spellEntry->RecoveryTime;
    CategoryRecoveryTime = spellEntry->CategoryRecoveryTime;
    StartRecoveryCategory = spellEntry->StartRecoveryCategory;
    StartRecoveryTime = spellEntry->StartRecoveryTime;
    InterruptFlags = spellEntry->InterruptFlags;
    AuraInterruptFlags = spellEntry->AuraInterruptFlags;
    ChannelInterruptFlags = spellEntry->ChannelInterruptFlags;
    ProcFlags = spellEntry->ProcFlags;
    ProcChance = spellEntry->ProcChance;
    ProcCharges = spellEntry->ProcCharges;
    MaxLevel = spellEntry->MaxLevel;
    BaseLevel = spellEntry->BaseLevel;
    SpellLevel = spellEntry->SpellLevel;
    DurationEntry = spellEntry->DurationIndex ? sSpellDurationStore.LookupEntry(spellEntry->DurationIndex) : nullptr;
    PowerType = spellEntry->PowerType;
    ManaCost = spellEntry->ManaCost;
    ManaCostPerlevel = spellEntry->ManaCostPerlevel;
    ManaPerSecond = spellEntry->ManaPerSecond;
    ManaPerSecondPerLevel = spellEntry->ManaPerSecondPerLevel;
    ManaCostPercentage = spellEntry->ManaCostPercentage;
    RuneCostID = spellEntry->RuneCostID;
    RangeEntry = spellEntry->RangeIndex ? sSpellRangeStore.LookupEntry(spellEntry->RangeIndex) : nullptr;
    Speed = spellEntry->Speed;
    StackAmount = spellEntry->StackAmount;
    Totem = spellEntry->Totem;
    Reagent = spellEntry->Reagent;
    ReagentCount = spellEntry->ReagentCount;
    EquippedItemClass = spellEntry->EquippedItemClass;
    EquippedItemSubClassMask = spellEntry->EquippedItemSubClassMask;
    EquippedItemInventoryTypeMask = spellEntry->EquippedItemInventoryTypeMask;
    TotemCategory = spellEntry->TotemCategory;
    SpellVisual = spellEntry->SpellVisual;
    SpellIconID = spellEntry->SpellIconID;
    ActiveIconID = spellEntry->ActiveIconID;
    SpellPriority = spellEntry->SpellPriority;
    SpellName = spellEntry->SpellName;
    Rank = spellEntry->Rank;
    MaxTargetLevel = spellEntry->MaxTargetLevel;
    MaxAffectedTargets = spellEntry->MaxAffectedTargets;
    SpellFamilyName = spellEntry->SpellFamilyName;
    SpellFamilyFlags = spellEntry->SpellFamilyFlags;
    DmgClass = spellEntry->DmgClass;
    PreventionType = spellEntry->PreventionType;
    AreaGroupId = spellEntry->AreaGroupId;
    SchoolMask = spellEntry->SchoolMask;
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        Effects[i] = SpellEffectInfo(spellEntry, this, i);
 
    ChainEntry = nullptr;
    ExplicitTargetMask = 0;
 
    // Mine
    _isStackableWithRanks = false;
    _isSpellValid = true;
    _isCritCapable = false;
    _requireCooldownInfo = false;
    JumpDistance = 0.0f;
}

References _isCritCapable, _isSpellValid, _isStackableWithRanks, _requireCooldownInfo, ActiveIconID, SpellEntry::ActiveIconID, AreaGroupId, SpellEntry::AreaGroupId, Attributes, SpellEntry::Attributes, AttributesCu, AttributesEx, SpellEntry::AttributesEx, AttributesEx2, SpellEntry::AttributesEx2, AttributesEx3, SpellEntry::AttributesEx3, AttributesEx4, SpellEntry::AttributesEx4, AttributesEx5, SpellEntry::AttributesEx5, AttributesEx6, SpellEntry::AttributesEx6, AttributesEx7, SpellEntry::AttributesEx7, AuraInterruptFlags, SpellEntry::AuraInterruptFlags, BaseLevel, SpellEntry::BaseLevel, CasterAuraSpell, SpellEntry::CasterAuraSpell, CasterAuraState, SpellEntry::CasterAuraState, CasterAuraStateNot, SpellEntry::CasterAuraStateNot, SpellEntry::CastingTimeIndex, CastTimeEntry, SpellEntry::Category, CategoryEntry, CategoryRecoveryTime, SpellEntry::CategoryRecoveryTime, ChainEntry, ChannelInterruptFlags, SpellEntry::ChannelInterruptFlags, Dispel, SpellEntry::Dispel, DmgClass, SpellEntry::DmgClass, DurationEntry, SpellEntry::DurationIndex, Effects, EquippedItemClass, SpellEntry::EquippedItemClass, EquippedItemInventoryTypeMask, SpellEntry::EquippedItemInventoryTypeMask, EquippedItemSubClassMask, SpellEntry::EquippedItemSubClassMask, ExcludeCasterAuraSpell, SpellEntry::ExcludeCasterAuraSpell, ExcludeTargetAuraSpell, SpellEntry::ExcludeTargetAuraSpell, ExplicitTargetMask, FacingCasterFlags, SpellEntry::FacingCasterFlags, Id, SpellEntry::Id, InterruptFlags, SpellEntry::InterruptFlags, JumpDistance, ManaCost, SpellEntry::ManaCost, ManaCostPercentage, SpellEntry::ManaCostPercentage, ManaCostPerlevel, SpellEntry::ManaCostPerlevel, ManaPerSecond, SpellEntry::ManaPerSecond, ManaPerSecondPerLevel, SpellEntry::ManaPerSecondPerLevel, MAX_SPELL_EFFECTS, MaxAffectedTargets, SpellEntry::MaxAffectedTargets, MaxLevel, SpellEntry::MaxLevel, MaxTargetLevel, SpellEntry::MaxTargetLevel, Mechanic, SpellEntry::Mechanic, SpellEntry::PowerType, PreventionType, SpellEntry::PreventionType, ProcChance, SpellEntry::ProcChance, ProcCharges, SpellEntry::ProcCharges, SpellEntry::ProcFlags, RangeEntry, SpellEntry::RangeIndex, Rank, SpellEntry::Rank, Reagent, SpellEntry::Reagent, ReagentCount, SpellEntry::ReagentCount, RecoveryTime, SpellEntry::RecoveryTime, RequiresSpellFocus, SpellEntry::RequiresSpellFocus, RuneCostID, SpellEntry::RuneCostID, SchoolMask, SpellEntry::SchoolMask, Speed, SpellEntry::Speed, SpellFamilyFlags, SpellEntry::SpellFamilyFlags, SpellFamilyName, SpellEntry::SpellFamilyName, SpellIconID, SpellEntry::SpellIconID, SpellLevel, SpellEntry::SpellLevel, SpellName, SpellEntry::SpellName, SpellPriority, SpellEntry::SpellPriority, SpellVisual, SpellEntry::SpellVisual, sSpellCastTimesStore, sSpellCategoryStore, sSpellDurationStore, sSpellRangeStore, StackAmount, SpellEntry::StackAmount, Stances, SpellEntry::Stances, StancesNot, SpellEntry::StancesNot, StartRecoveryCategory, SpellEntry::StartRecoveryCategory, StartRecoveryTime, SpellEntry::StartRecoveryTime, TargetAuraSpell, SpellEntry::TargetAuraSpell, TargetAuraState, SpellEntry::TargetAuraState, TargetAuraStateNot, SpellEntry::TargetAuraStateNot, TargetCreatureType, SpellEntry::TargetCreatureType, SpellEntry::Targets, SpellEntry::Totem, and SpellEntry::TotemCategory.

◆ ~SpellInfo()

SpellInfo::~SpellInfo ( )

{
    _UnloadImplicitTargetConditionLists();
}

References _UnloadImplicitTargetConditionLists().

Member Function Documentation

◆ _GetEffect()

SpellEffectInfo & SpellInfo::_GetEffect ( SpellEffIndex index )

inline

584{ ASSERT(index < Effects.size()); return Effects[index]; }

ASSERT

#define ASSERT

Definition Errors.h:68

References ASSERT.

◆ _GetEffects()

std::array< SpellEffectInfo, MAX_SPELL_EFFECTS > & SpellInfo::_GetEffects ( )

inline

583{ return Effects; }

◆ _InitializeExplicitTargetMask()

void SpellInfo::_InitializeExplicitTargetMask ( )

{
    bool srcSet = false;
    bool dstSet = false;
    uint32 targetMask = Targets;
    // prepare target mask using effect target entries
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (!Effects[i].IsEffect())
            continue;
        targetMask |= Effects[i].TargetA.GetExplicitTargetMask(srcSet, dstSet);
        targetMask |= Effects[i].TargetB.GetExplicitTargetMask(srcSet, dstSet);
 
        // add explicit target flags based on spell effects which have EFFECT_IMPLICIT_TARGET_EXPLICIT and no valid target provided
        if (Effects[i].GetImplicitTargetType() != EFFECT_IMPLICIT_TARGET_EXPLICIT)
            continue;
 
        // extend explicit target mask only if valid targets for effect could not be provided by target types
        uint32 effectTargetMask = Effects[i].GetMissingTargetMask(srcSet, dstSet, targetMask);
 
        // don't add explicit object/dest flags when spell has no max range
        if (GetMaxRange(true) == 0.0f && GetMaxRange(false) == 0.0f)
            effectTargetMask &= ~(TARGET_FLAG_UNIT_MASK | TARGET_FLAG_GAMEOBJECT | TARGET_FLAG_CORPSE_MASK | TARGET_FLAG_DEST_LOCATION);
        targetMask |= effectTargetMask;
    }
    ExplicitTargetMask = targetMask;
}

References EFFECT_IMPLICIT_TARGET_EXPLICIT, Effects, ExplicitTargetMask, GetMaxRange(), MAX_SPELL_EFFECTS, TARGET_FLAG_CORPSE_MASK, TARGET_FLAG_DEST_LOCATION, TARGET_FLAG_GAMEOBJECT, TARGET_FLAG_UNIT_MASK, and Targets.

Referenced by SpellMgr::LoadSpellInfoCustomAttributes().

◆ _IsPositiveEffect()

bool SpellInfo::_IsPositiveEffect	(	uint8	effIndex,
		bool	deep
	)		const

{
    // not found a single positive spell with this attribute
    if (HasAttribute(SPELL_ATTR0_AURA_IS_DEBUFF))
        return false;
 
    switch (Mechanic)
    {
        case MECHANIC_IMMUNE_SHIELD:
            return true;
        default:
            break;
    }
 
    // Special case: effects which determine positivity of whole spell
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (Effects[i].IsAura() && Effects[i].ApplyAuraName == SPELL_AURA_MOD_STEALTH)
            return true;
    }
 
    switch (Effects[effIndex].Effect)
    {
        // always positive effects (check before target checks that provided non-positive result in some case for positive effects)
        case SPELL_EFFECT_HEAL:
        case SPELL_EFFECT_LEARN_SPELL:
        case SPELL_EFFECT_SKILL_STEP:
        case SPELL_EFFECT_HEAL_PCT:
        case SPELL_EFFECT_ENERGIZE_PCT:
            return true;
        case SPELL_EFFECT_APPLY_AREA_AURA_ENEMY:
            return false;
        case SPELL_EFFECT_GAMEOBJECT_DAMAGE:
            return false;
        case SPELL_EFFECT_SCHOOL_DAMAGE:
            {
                bool only = true;
                for (int i = EFFECT_0; i <= EFFECT_2; ++i)
                {
                    if (Effects[effIndex].Effect > 0 && Effects[effIndex].Effect != SPELL_EFFECT_SCHOOL_DAMAGE)
                        only = false;
                    if (Effects[effIndex].Effect == SPELL_EFFECT_GAMEOBJECT_DAMAGE)
                        return false;
                }
                // effects with school damage only cannot be positive...
                if (only)
                    return false;
                break;
            }
        case SPELL_EFFECT_KNOCK_BACK:
        case SPELL_EFFECT_KNOCK_BACK_DEST:
            {
                for (int i = EFFECT_0; i <= EFFECT_2; ++i)
                    if (Effects[effIndex].Effect == SPELL_EFFECT_GAMEOBJECT_DAMAGE)
                        return false;
                break;
            }
        // non-positive aura use
        case SPELL_EFFECT_APPLY_AURA:
        case SPELL_EFFECT_APPLY_AREA_AURA_FRIEND:
            {
                switch (Effects[effIndex].ApplyAuraName)
                {
                    case SPELL_AURA_MOD_DAMAGE_DONE:            // dependent from bas point sign (negative -> negative)
                    case SPELL_AURA_MOD_STAT:
                    case SPELL_AURA_MOD_SKILL:
                    case SPELL_AURA_MOD_DODGE_PERCENT:
                    case SPELL_AURA_MOD_HEALING_PCT:
                    case SPELL_AURA_MOD_HEALING_DONE:
                    case SPELL_AURA_MOD_DAMAGE_PERCENT_DONE:
                        if (Effects[effIndex].CalcValue() < 0)
                            return false;
                        break;
                    case SPELL_AURA_MOD_DAMAGE_TAKEN:           // dependent from bas point sign (positive -> negative)
                        if (Effects[effIndex].CalcValue() > 0)
                            return false;
                        break;
                    case SPELL_AURA_MOD_CRIT_PCT:
                    case SPELL_AURA_MOD_SPELL_CRIT_CHANCE:
                        if (Effects[effIndex].CalcValue() > 0)
                            return true;                        // some expected positive spells have SPELL_ATTR1_NEGATIVE
                        break;
                    case SPELL_AURA_ADD_TARGET_TRIGGER:
                        return true;
                    case SPELL_AURA_PERIODIC_TRIGGER_SPELL_WITH_VALUE:
                    case SPELL_AURA_PERIODIC_TRIGGER_SPELL_FROM_CLIENT:
                    case SPELL_AURA_PERIODIC_TRIGGER_SPELL:
                        if (!deep)
                        {
                            if (SpellInfo const* spellTriggeredProto = sSpellMgr->GetSpellInfo(Effects[effIndex].TriggerSpell))
                            {
                                // negative targets of main spell return early
                                for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
                                {
                                    if (!spellTriggeredProto->Effects[i].Effect)
                                        continue;
                                    // if non-positive trigger cast targeted to positive target this main cast is non-positive
                                    // this will place this spell auras as debuffs
                                    if (_IsPositiveTarget(spellTriggeredProto->Effects[i].TargetA.GetTarget(), spellTriggeredProto->Effects[i].TargetB.GetTarget()) && !spellTriggeredProto->_IsPositiveEffect(i, true))
                                        return false;
                                }
                            }
                        }
                    case SPELL_AURA_PROC_TRIGGER_SPELL:
                        // many positive auras have negative triggered spells at damage for example and this not make it negative (it can be canceled for example)
                        break;
                    case SPELL_AURA_MOD_STUN:                   //have positive and negative spells, we can't sort its correctly at this moment.
                        if (effIndex == 0 && Effects[1].Effect == 0 && Effects[2].Effect == 0)
                            return false;                       // but all single stun aura spells is negative
                        break;
                    case SPELL_AURA_MOD_PACIFY_SILENCE:
                        if (Id == 24740)             // Wisp Costume
                            return true;
                        return false;
                    case SPELL_AURA_MOD_ROOT:
                    case SPELL_AURA_MOD_FEAR:
                    case SPELL_AURA_MOD_SILENCE:
                    case SPELL_AURA_GHOST:
                    case SPELL_AURA_PERIODIC_LEECH:
                    case SPELL_AURA_MOD_STALKED:
                    case SPELL_AURA_PERIODIC_DAMAGE_PERCENT:
                    case SPELL_AURA_PREVENT_RESURRECTION:
                        return false;
                    case SPELL_AURA_PERIODIC_DAMAGE:            // used in positive spells also.
                        // part of negative spell if casted at self (prevent cancel)
                        if (Effects[effIndex].TargetA.GetTarget() == TARGET_UNIT_CASTER)
                            return false;
                        break;
                    case SPELL_AURA_MOD_DECREASE_SPEED:         // used in positive spells also
                        // part of positive spell if casted at self
                        if (Effects[effIndex].TargetA.GetTarget() != TARGET_UNIT_CASTER)
                            return false;
                        // but not this if this first effect (didn't find better check)
                        if (HasAttribute(SPELL_ATTR0_AURA_IS_DEBUFF) && effIndex == 0)
                            return false;
                        break;
                    case SPELL_AURA_MECHANIC_IMMUNITY:
                        {
                            // non-positive immunities
                            switch (Effects[effIndex].MiscValue)
                            {
                                case MECHANIC_BANDAGE:
                                case MECHANIC_SHIELD:
                                case MECHANIC_MOUNT:
                                case MECHANIC_INVULNERABILITY:
                                    return false;
                                default:
                                    break;
                            }
                            break;
                        }
                    case SPELL_AURA_ADD_FLAT_MODIFIER:          // mods
                    case SPELL_AURA_ADD_PCT_MODIFIER:
                        {
                            // non-positive mods
                            switch (Effects[effIndex].MiscValue)
                            {
                                case SPELLMOD_COST:                 // dependent from bas point sign (negative -> positive)
                                    if (Effects[effIndex].CalcValue() > 0)
                                    {
                                        if (!deep)
                                        {
                                            bool negative = true;
                                            for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
                                            {
                                                if (i != effIndex)
                                                    if (_IsPositiveEffect(i, true))
                                                    {
                                                        negative = false;
                                                        break;
                                                    }
                                            }
                                            if (negative)
                                                return false;
                                        }
                                    }
                                    break;
                                default:
                                    break;
                            }
                            break;
                        }
                    default:
                        break;
                }
                break;
            }
        default:
            break;
    }
 
    // non-positive targets
    if (!_IsPositiveTarget(Effects[effIndex].TargetA.GetTarget(), Effects[effIndex].TargetB.GetTarget()))
        return false;
 
    // negative spell if triggered spell is negative
    if (!deep && !Effects[effIndex].ApplyAuraName && Effects[effIndex].TriggerSpell)
    {
        if (SpellInfo const* spellTriggeredProto = sSpellMgr->GetSpellInfo(Effects[effIndex].TriggerSpell))
            if (!spellTriggeredProto->_IsPositiveSpell())
                return false;
    }
 
    // ok, positive
    return true;
}

References _IsPositiveEffect(), _IsPositiveTarget(), EFFECT_0, EFFECT_2, Effects, HasAttribute(), Id, MAX_SPELL_EFFECTS, Mechanic, MECHANIC_BANDAGE, MECHANIC_IMMUNE_SHIELD, MECHANIC_INVULNERABILITY, MECHANIC_MOUNT, MECHANIC_SHIELD, SPELL_ATTR0_AURA_IS_DEBUFF, SPELL_AURA_ADD_FLAT_MODIFIER, SPELL_AURA_ADD_PCT_MODIFIER, SPELL_AURA_ADD_TARGET_TRIGGER, SPELL_AURA_GHOST, SPELL_AURA_MECHANIC_IMMUNITY, SPELL_AURA_MOD_CRIT_PCT, SPELL_AURA_MOD_DAMAGE_DONE, SPELL_AURA_MOD_DAMAGE_PERCENT_DONE, SPELL_AURA_MOD_DAMAGE_TAKEN, SPELL_AURA_MOD_DECREASE_SPEED, SPELL_AURA_MOD_DODGE_PERCENT, SPELL_AURA_MOD_FEAR, SPELL_AURA_MOD_HEALING_DONE, SPELL_AURA_MOD_HEALING_PCT, SPELL_AURA_MOD_PACIFY_SILENCE, SPELL_AURA_MOD_ROOT, SPELL_AURA_MOD_SILENCE, SPELL_AURA_MOD_SKILL, SPELL_AURA_MOD_SPELL_CRIT_CHANCE, SPELL_AURA_MOD_STALKED, SPELL_AURA_MOD_STAT, SPELL_AURA_MOD_STEALTH, SPELL_AURA_MOD_STUN, SPELL_AURA_PERIODIC_DAMAGE, SPELL_AURA_PERIODIC_DAMAGE_PERCENT, SPELL_AURA_PERIODIC_LEECH, SPELL_AURA_PERIODIC_TRIGGER_SPELL, SPELL_AURA_PERIODIC_TRIGGER_SPELL_FROM_CLIENT, SPELL_AURA_PERIODIC_TRIGGER_SPELL_WITH_VALUE, SPELL_AURA_PREVENT_RESURRECTION, SPELL_AURA_PROC_TRIGGER_SPELL, SPELL_EFFECT_APPLY_AREA_AURA_ENEMY, SPELL_EFFECT_APPLY_AREA_AURA_FRIEND, SPELL_EFFECT_APPLY_AURA, SPELL_EFFECT_ENERGIZE_PCT, SPELL_EFFECT_GAMEOBJECT_DAMAGE, SPELL_EFFECT_HEAL, SPELL_EFFECT_HEAL_PCT, SPELL_EFFECT_KNOCK_BACK, SPELL_EFFECT_KNOCK_BACK_DEST, SPELL_EFFECT_LEARN_SPELL, SPELL_EFFECT_SCHOOL_DAMAGE, SPELL_EFFECT_SKILL_STEP, SPELLMOD_COST, sSpellMgr, and TARGET_UNIT_CASTER.

Referenced by _IsPositiveEffect(), _IsPositiveSpell(), WorldSession::HandlePetActionHelper(), and SpellMgr::LoadSpellInfoCustomAttributes().

◆ _IsPositiveSpell()

bool SpellInfo::_IsPositiveSpell ( ) const

{
    // spells with at least one negative effect are considered negative
    // some self-applied spells have negative effects but in self casting case negative check ignored.
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if (!_IsPositiveEffect(i, true))
            return false;
    return true;
}

References _IsPositiveEffect(), and MAX_SPELL_EFFECTS.

Referenced by Spell::HandleThreatSpells().

◆ _IsPositiveTarget()

bool SpellInfo::_IsPositiveTarget	(	uint32	targetA,
		uint32	targetB
	)

static

{
    // non-positive targets
    switch (targetA)
    {
        case TARGET_UNIT_NEARBY_ENEMY:
        case TARGET_UNIT_TARGET_ENEMY:
        case TARGET_UNIT_SRC_AREA_ENEMY:
        case TARGET_UNIT_DEST_AREA_ENEMY:
        case TARGET_UNIT_CONE_ENEMY_24:
        case TARGET_UNIT_CONE_ENEMY_54:
        case TARGET_UNIT_CONE_ENEMY_104:
        case TARGET_DEST_DYNOBJ_ENEMY:
        case TARGET_DEST_TARGET_ENEMY:
            return false;
        default:
            break;
    }
    if (targetB)
        return _IsPositiveTarget(targetB, 0);
    return true;
}

References _IsPositiveTarget(), TARGET_DEST_DYNOBJ_ENEMY, TARGET_DEST_TARGET_ENEMY, TARGET_UNIT_CONE_ENEMY_104, TARGET_UNIT_CONE_ENEMY_24, TARGET_UNIT_CONE_ENEMY_54, TARGET_UNIT_DEST_AREA_ENEMY, TARGET_UNIT_NEARBY_ENEMY, TARGET_UNIT_SRC_AREA_ENEMY, and TARGET_UNIT_TARGET_ENEMY.

Referenced by _IsPositiveEffect(), and _IsPositiveTarget().

◆ _LoadImmunityInfo()

void SpellInfo::_LoadImmunityInfo ( )

{
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        SpellEffectInfo& effectInfo = Effects[i];
        if (!effectInfo.Effect)
            continue;
 
        uint32 schoolImmunityMask = 0;
        uint32 applyHarmfulAuraImmunityMask = 0;
        uint64 mechanicImmunityMask = 0;
        uint32 dispelImmunityMask = 0;
        uint32 damageImmunityMask = 0;
 
        int32 miscVal = effectInfo.MiscValue;
        int32 amount   = effectInfo.CalcValue();
 
        ImmunityInfo& immuneInfo = _immunityInfo[i];
 
        switch (effectInfo.ApplyAuraName)
        {
            case SPELL_AURA_MECHANIC_IMMUNITY_MASK:
            {
                switch (miscVal)
                {
                    case 27:
                        mechanicImmunityMask |= (1ULL << MECHANIC_SILENCE);
                        immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_SILENCE);
                        break;
                    case 96:
                    case 1615:
                    {
                        if (amount)
                        {
                            mechanicImmunityMask |= (1ULL << MECHANIC_SNARE) | (1ULL << MECHANIC_ROOT)
                                                     | (1ULL << MECHANIC_FEAR) | (1ULL << MECHANIC_STUN)
                                                     | (1ULL << MECHANIC_SLEEP) | (1ULL << MECHANIC_CHARM)
                                                     | (1ULL << MECHANIC_SAPPED) | (1ULL << MECHANIC_HORROR)
                                                     | (1ULL << MECHANIC_POLYMORPH) | (1ULL << MECHANIC_DISORIENTED)
                                                     | (1ULL << MECHANIC_FREEZE) | (1ULL << MECHANIC_TURN);
 
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_STUN);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_DECREASE_SPEED);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_ROOT);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_CONFUSE);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_FEAR);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_ROOT);
                        }
                        break;
                    }
                    case 679:
                    {
                        if (Id == 57742)
                        {
                            mechanicImmunityMask |= (1ULL << MECHANIC_SNARE) | (1ULL << MECHANIC_ROOT)
                                                     | (1ULL << MECHANIC_FEAR) | (1ULL << MECHANIC_STUN)
                                                     | (1ULL << MECHANIC_SLEEP) | (1ULL << MECHANIC_CHARM)
                                                     | (1ULL << MECHANIC_SAPPED) | (1ULL << MECHANIC_HORROR)
                                                     | (1ULL << MECHANIC_POLYMORPH) | (1ULL << MECHANIC_DISORIENTED)
                                                     | (1ULL << MECHANIC_FREEZE) | (1ULL << MECHANIC_TURN);
 
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_STUN);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_DECREASE_SPEED);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_ROOT);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_CONFUSE);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_FEAR);
                        }
                        break;
                    }
                    case 1557:
                    {
                        if (Id == 64187)
                        {
                            mechanicImmunityMask |= (1ULL << MECHANIC_STUN);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_STUN);
                        }
                        else
                        {
                            mechanicImmunityMask |= (1ULL << MECHANIC_SNARE) | (1ULL << MECHANIC_ROOT)
                                                     | (1ULL << MECHANIC_FEAR) | (1ULL << MECHANIC_STUN)
                                                     | (1ULL << MECHANIC_SLEEP) | (1ULL << MECHANIC_CHARM)
                                                     | (1ULL << MECHANIC_SAPPED) | (1ULL << MECHANIC_HORROR)
                                                     | (1ULL << MECHANIC_POLYMORPH) | (1ULL << MECHANIC_DISORIENTED)
                                                     | (1ULL << MECHANIC_FREEZE) | (1ULL << MECHANIC_TURN);
 
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_STUN);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_DECREASE_SPEED);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_ROOT);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_CONFUSE);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_FEAR);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_ROOT);
                        }
                        break;
                    }
                    case 1614:
                    case 1694:
                    {
                        immuneInfo.SpellEffectImmune.insert(SPELL_EFFECT_ATTACK_ME);
                        immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_TAUNT);
                        break;
                    }
                    case 1630:
                    {
                        if (Id == 64112)
                        {
                            immuneInfo.SpellEffectImmune.insert(SPELL_EFFECT_ATTACK_ME);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_TAUNT);
                        }
                        else
                        {
                            mechanicImmunityMask |= (1ULL << MECHANIC_SNARE) | (1ULL << MECHANIC_ROOT)
                                                     | (1ULL << MECHANIC_FEAR) | (1ULL << MECHANIC_STUN)
                                                     | (1ULL << MECHANIC_SLEEP) | (1ULL << MECHANIC_CHARM)
                                                     | (1ULL << MECHANIC_SAPPED) | (1ULL << MECHANIC_HORROR)
                                                     | (1ULL << MECHANIC_POLYMORPH) | (1ULL << MECHANIC_DISORIENTED)
                                                     | (1ULL << MECHANIC_FREEZE) | (1ULL << MECHANIC_TURN);
 
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_STUN);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_DECREASE_SPEED);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_ROOT);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_CONFUSE);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_FEAR);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_ROOT);
                        }
                        break;
                    }
                    case 477:
                    case 1733:
                    {
                        if (!amount)
                        {
                            mechanicImmunityMask |= (1ULL << MECHANIC_SNARE) | (1ULL << MECHANIC_ROOT)
                                                     | (1ULL << MECHANIC_FEAR) | (1ULL << MECHANIC_STUN)
                                                     | (1ULL << MECHANIC_SLEEP) | (1ULL << MECHANIC_CHARM)
                                                     | (1ULL << MECHANIC_SAPPED) | (1ULL << MECHANIC_HORROR)
                                                     | (1ULL << MECHANIC_POLYMORPH) | (1ULL << MECHANIC_DISORIENTED)
                                                     | (1ULL << MECHANIC_FREEZE) | (1ULL << MECHANIC_TURN);
 
                            immuneInfo.SpellEffectImmune.insert(SPELL_EFFECT_KNOCK_BACK);
                            immuneInfo.SpellEffectImmune.insert(SPELL_EFFECT_KNOCK_BACK_DEST);
 
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_STUN);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_DECREASE_SPEED);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_ROOT);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_CONFUSE);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_FEAR);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_ROOT);
                        }
                        break;
                    }
                    case 878:
                    {
                        if (Id == 66092)
                        {
                            mechanicImmunityMask |= (1ULL << MECHANIC_SNARE) | (1ULL << MECHANIC_STUN)
                                                     | (1ULL << MECHANIC_DISORIENTED) | (1ULL << MECHANIC_FREEZE);
 
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_STUN);
                            immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_DECREASE_SPEED);
                        }
                        break;
                    }
                    default:
                        break;
                }
 
                if (immuneInfo.AuraTypeImmune.empty())
                {
                    if (miscVal & (1 << 10))
                        immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_STUN);
                    if (miscVal & (1 << 1))
                        immuneInfo.AuraTypeImmune.insert(SPELL_AURA_TRANSFORM);
 
                    if (miscVal & (1 << 6))
                        immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_DECREASE_SPEED);
                    if (miscVal & (1 << 0))
                    {
                        immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_ROOT);
                    }
                    if (miscVal & (1 << 2))
                        immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_CONFUSE);
                    if (miscVal & (1 << 9))
                        immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_FEAR);
                    if (miscVal & (1 << 7))
                        immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_DISARM);
                }
                break;
            }
            case SPELL_AURA_MECHANIC_IMMUNITY:
            {
                switch (Id)
                {
                    case 34471: // The Beast Within
                    case 19574: // Bestial Wrath
                    case 42292: // PvP trinket
                    case 46227: // Medallion of Immunity
                    case 59752: // Every Man for Himself
                    case 53490: // Bullheaded
                    case 65547: // PvP Trinket
                    case 134946: // Supremacy of the Alliance
                    case 134956: // Supremacy of the Horde
                    case 195710: // Honorable Medallion
                    case 208683: // Gladiator's Medallion
                        mechanicImmunityMask |= IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK;
                        break;
                    case 54508: // Demonic Empowerment
                        mechanicImmunityMask |= (1ULL << MECHANIC_SNARE) | (1ULL << MECHANIC_ROOT) | (1ULL << MECHANIC_STUN);
                        break;
                    default:
                        if (miscVal < 1)
                            break;
 
                        mechanicImmunityMask |= 1ULL << miscVal;
                        break;
                }
                break;
            }
            case SPELL_AURA_EFFECT_IMMUNITY:
            {
                immuneInfo.SpellEffectImmune.insert(static_cast<SpellEffects>(miscVal));
                break;
            }
            case SPELL_AURA_STATE_IMMUNITY:
            {
                immuneInfo.AuraTypeImmune.insert(static_cast<AuraType>(miscVal));
                break;
            }
            case SPELL_AURA_SCHOOL_IMMUNITY:
            {
                schoolImmunityMask |= uint32(miscVal);
                break;
            }
            case SPELL_AURA_MOD_IMMUNE_AURA_APPLY_SCHOOL:
            {
                applyHarmfulAuraImmunityMask |= uint32(miscVal);
                break;
            }
            case SPELL_AURA_DAMAGE_IMMUNITY:
            {
                damageImmunityMask |= uint32(miscVal);
                break;
            }
            case SPELL_AURA_DISPEL_IMMUNITY:
            {
                dispelImmunityMask = uint32(miscVal);
                break;
            }
            default:
                break;
        }
 
        immuneInfo.SchoolImmuneMask = schoolImmunityMask;
        immuneInfo.ApplyHarmfulAuraImmuneMask = applyHarmfulAuraImmunityMask;
        immuneInfo.MechanicImmuneMask = mechanicImmunityMask;
        immuneInfo.DispelImmuneMask = dispelImmunityMask;
        immuneInfo.DamageSchoolMask = damageImmunityMask;
    }
}

References _immunityInfo, SpellEffectInfo::ApplyAuraName, ImmunityInfo::ApplyHarmfulAuraImmuneMask, ImmunityInfo::AuraTypeImmune, SpellEffectInfo::CalcValue(), ImmunityInfo::DamageSchoolMask, ImmunityInfo::DispelImmuneMask, SpellEffectInfo::Effect, Effects, Id, IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK, MAX_SPELL_EFFECTS, MECHANIC_CHARM, MECHANIC_DISORIENTED, MECHANIC_FEAR, MECHANIC_FREEZE, MECHANIC_HORROR, MECHANIC_POLYMORPH, MECHANIC_ROOT, MECHANIC_SAPPED, MECHANIC_SILENCE, MECHANIC_SLEEP, MECHANIC_SNARE, MECHANIC_STUN, MECHANIC_TURN, ImmunityInfo::MechanicImmuneMask, SpellEffectInfo::MiscValue, ImmunityInfo::SchoolImmuneMask, SPELL_AURA_DAMAGE_IMMUNITY, SPELL_AURA_DISPEL_IMMUNITY, SPELL_AURA_EFFECT_IMMUNITY, SPELL_AURA_MECHANIC_IMMUNITY, SPELL_AURA_MECHANIC_IMMUNITY_MASK, SPELL_AURA_MOD_CONFUSE, SPELL_AURA_MOD_DECREASE_SPEED, SPELL_AURA_MOD_DISARM, SPELL_AURA_MOD_FEAR, SPELL_AURA_MOD_IMMUNE_AURA_APPLY_SCHOOL, SPELL_AURA_MOD_ROOT, SPELL_AURA_MOD_SILENCE, SPELL_AURA_MOD_STUN, SPELL_AURA_MOD_TAUNT, SPELL_AURA_SCHOOL_IMMUNITY, SPELL_AURA_STATE_IMMUNITY, SPELL_AURA_TRANSFORM, SPELL_EFFECT_ATTACK_ME, SPELL_EFFECT_KNOCK_BACK, SPELL_EFFECT_KNOCK_BACK_DEST, and ImmunityInfo::SpellEffectImmune.

◆ _UnloadImplicitTargetConditionLists()

void SpellInfo::_UnloadImplicitTargetConditionLists ( )

{
    // find the same instances of ConditionList and delete them.
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        ConditionList* cur = Effects[i].ImplicitTargetConditions;
        if (!cur)
            continue;
        for (uint8 j = i; j < MAX_SPELL_EFFECTS; ++j)
        {
            if (Effects[j].ImplicitTargetConditions == cur)
                Effects[j].ImplicitTargetConditions = nullptr;
        }
        delete cur;
    }
}

References Effects, and MAX_SPELL_EFFECTS.

Referenced by ~SpellInfo().

◆ ApplyAllSpellImmunitiesTo()

void SpellInfo::ApplyAllSpellImmunitiesTo	(	Unit *	target,
		SpellEffectInfo const *	effect,
		bool	apply
	)		const

{
    ImmunityInfo const* immuneInfo = nullptr;
    if (effect)
    {
        uint8 effIndex = effect->EffectIndex;
        if (effIndex < MAX_SPELL_EFFECTS)
            immuneInfo = &_immunityInfo[effIndex];
    }
 
    if (!immuneInfo)
        return;
 
    if (uint32 schoolImmunity = immuneInfo->SchoolImmuneMask)
    {
        target->ApplySpellImmune(Id, IMMUNITY_SCHOOL, schoolImmunity, apply);
 
        if (apply && HasAttribute(SPELL_ATTR1_IMMUNITY_PURGES_EFFECT))
{
            target->RemoveAppliedAuras([this, target, schoolImmunity](AuraApplication const* aurApp) -> bool
            {
                SpellInfo const* auraSpellInfo = aurApp->GetBase()->GetSpellInfo();
                if (auraSpellInfo->Id == Id)                                     // Don't remove self
                    return false;
                if (auraSpellInfo->IsPassive())                                  // Don't remove passive auras
                    return false;
                if (!(auraSpellInfo->GetSchoolMask() & schoolImmunity))          // Check for school mask
                    return false;
                if (!CanDispelAura(auraSpellInfo))
                    return false;
                if (!HasAttribute(SPELL_ATTR1_IMMUNITY_TO_HOSTILE_AND_FRIENDLY_EFFECTS))
                {
                    Unit* existingAuraCaster = aurApp->GetBase()->GetCaster();
                    if (existingAuraCaster && existingAuraCaster->IsFriendlyTo(target)) // Don't remove friendly auras
                        return false;
                }
                return true;
            });
        }
    }
 
    if (uint64 mechanicImmunity = immuneInfo->MechanicImmuneMask)
    {
        for (uint32 i = 0; i < MAX_MECHANIC; ++i)
            if (mechanicImmunity & (1ULL << i))
                target->ApplySpellImmune(Id, IMMUNITY_MECHANIC, i, apply);
 
        if (apply && HasAttribute(SPELL_ATTR1_IMMUNITY_PURGES_EFFECT))
            target->RemoveAurasWithMechanic(mechanicImmunity, AURA_REMOVE_BY_DEFAULT, Id);
    }
 
    if (uint32 dispelImmunity = immuneInfo->DispelImmuneMask)
    {
        target->ApplySpellImmune(Id, IMMUNITY_DISPEL, dispelImmunity, apply);
 
        if (apply && HasAttribute(SPELL_ATTR1_IMMUNITY_PURGES_EFFECT))
        {
            target->RemoveAppliedAuras([dispelImmunity](AuraApplication const* aurApp) -> bool
            {
                SpellInfo const* spellInfo = aurApp->GetBase()->GetSpellInfo();
                if (spellInfo->Dispel == dispelImmunity)
                    return true;
 
                return false;
            });
        }
    }
 
    if (uint32 damageImmunity = immuneInfo->DamageSchoolMask)
        target->ApplySpellImmune(Id, IMMUNITY_DAMAGE, damageImmunity, apply);
 
    for (AuraType auraType : immuneInfo->AuraTypeImmune)
    {
        target->ApplySpellImmune(Id, IMMUNITY_STATE, auraType, apply);
        if (apply && HasAttribute(SPELL_ATTR1_IMMUNITY_PURGES_EFFECT))
        {
            target->RemoveAppliedAuras([this, auraType](AuraApplication const* aurApp) -> bool
            {
                Aura const* aura = aurApp->GetBase();
                if (!aura->GetSpellInfo()->HasAura(auraType))
                    return false;
                return CanDispelAura(aura->GetSpellInfo());
            });
        }
    }
 
    for (SpellEffects effectType : immuneInfo->SpellEffectImmune)
        target->ApplySpellImmune(Id, IMMUNITY_EFFECT, effectType, apply);
}

References _immunityInfo, Unit::ApplySpellImmune(), AURA_REMOVE_BY_DEFAULT, ImmunityInfo::AuraTypeImmune, CanDispelAura(), ImmunityInfo::DamageSchoolMask, Dispel, ImmunityInfo::DispelImmuneMask, SpellEffectInfo::EffectIndex, AuraApplication::GetBase(), Aura::GetCaster(), GetSchoolMask(), Aura::GetSpellInfo(), HasAttribute(), HasAura(), Id, IMMUNITY_DAMAGE, IMMUNITY_DISPEL, IMMUNITY_EFFECT, IMMUNITY_MECHANIC, IMMUNITY_SCHOOL, IMMUNITY_STATE, Unit::IsFriendlyTo(), IsPassive(), MAX_MECHANIC, MAX_SPELL_EFFECTS, ImmunityInfo::MechanicImmuneMask, Unit::RemoveAppliedAuras(), Unit::RemoveAurasWithMechanic(), ImmunityInfo::SchoolImmuneMask, SPELL_ATTR1_IMMUNITY_PURGES_EFFECT, SPELL_ATTR1_IMMUNITY_TO_HOSTILE_AND_FRIENDLY_EFFECTS, and ImmunityInfo::SpellEffectImmune.

Referenced by AuraEffect::HandleAuraModDispelImmunity(), AuraEffect::HandleAuraModDmgImmunity(), AuraEffect::HandleModMechanicImmunity(), and AuraEffect::HandleModStateImmunityMask().

◆ CalcCastTime()

uint32 SpellInfo::CalcCastTime	(	WorldObject *	caster = `nullptr`,
		Spell *	spell = `nullptr`
	)		const

{
    // not all spells have cast time index and this is all is pasiive abilities
    if (!CastTimeEntry)
        return 0;
 
    int32 castTime = CastTimeEntry->CastTime;
    if (HasAttribute(SPELL_ATTR0_USES_RANGED_SLOT) && (!IsAutoRepeatRangedSpell()))
        castTime += 500;
 
    if (caster)
        caster->ModSpellCastTime(this, castTime, spell);
 
    return (castTime > 0) ? uint32(castTime) : 0;
}

References SpellCastTimesEntry::CastTime, CastTimeEntry, HasAttribute(), IsAutoRepeatRangedSpell(), WorldObject::ModSpellCastTime(), and SPELL_ATTR0_USES_RANGED_SLOT.

Referenced by Spell::_cast(), Unit::CalculateDefaultCoefficient(), Unit::GetCastingTimeForBonus(), Spell::prepare(), and Player::PrepareCharmAISpells().

◆ CalcPowerCost()

int32 SpellInfo::CalcPowerCost	(	WorldObject const *	caster,
		SpellSchoolMask	schoolMask,
		Spell *	spell = `nullptr`
	)		const

{
    // non-Unit casters have no resource pool, so every cost below collapses to zero
    Unit const* unitCaster = caster ? caster->ToUnit() : nullptr;
    if (!unitCaster)
        return 0;
 
    // Spell drain all exist power on cast (Only paladin lay of Hands)
    if (AttributesEx & SPELL_ATTR1_USE_ALL_MANA)
    {
        // If power type - health drain all
        if (PowerType == POWER_HEALTH)
            return unitCaster->GetHealth();
        // Else drain all power
        if (PowerType < MAX_POWERS)
            return unitCaster->GetPower(Powers(PowerType));
        LOG_ERROR("spells", "SpellInfo::CalcPowerCost: Unknown power type '{}' in spell {}", PowerType, Id);
        return 0;
    }
 
    // Base powerCost
    int32 powerCost = ManaCost;
    // PCT cost from total amount
    if (ManaCostPercentage)
    {
        switch (PowerType)
        {
            // health as power used
            case POWER_HEALTH:
                powerCost += int32(CalculatePct(unitCaster->GetCreateHealth(), ManaCostPercentage));
                break;
            case POWER_MANA:
                powerCost += int32(CalculatePct(unitCaster->GetCreateMana(), ManaCostPercentage));
                break;
            case POWER_RAGE:
            case POWER_FOCUS:
            case POWER_ENERGY:
            case POWER_HAPPINESS:
                powerCost += int32(CalculatePct(unitCaster->GetMaxPower(Powers(PowerType)), ManaCostPercentage));
                break;
            case POWER_RUNE:
            case POWER_RUNIC_POWER:
                LOG_DEBUG("spells.aura", "CalculateManaCost: Not implemented yet!");
                break;
            default:
                LOG_ERROR("spells", "CalculateManaCost: Unknown power type '{}' in spell {}", PowerType, Id);
                return 0;
        }
    }
    SpellSchools school = GetFirstSchoolInMask(schoolMask);
    // Flat mod from caster auras by spell school
    powerCost += unitCaster->GetInt32Value(static_cast<uint16>(UNIT_FIELD_POWER_COST_MODIFIER) + school);
 
    // Shiv - costs 20 + weaponSpeed*10 energy (apply only to non-triggered spell with energy cost)
    if (AttributesEx4 & SPELL_ATTR4_WEAPON_SPEED_COST_SCALING)
    {
        uint32 speed = 0;
        if (SpellShapeshiftFormEntry const* ss = sSpellShapeshiftFormStore.LookupEntry(unitCaster->GetShapeshiftForm()))
            speed = ss->attackSpeed;
        else
        {
            WeaponAttackType slot = BASE_ATTACK;
            if (AttributesEx3 & SPELL_ATTR3_REQUIRES_OFF_HAND_WEAPON)
                slot = OFF_ATTACK;
 
            speed = unitCaster->GetAttackTime(slot);
        }
 
        powerCost += speed / 100;
    }
 
    // Apply cost mod by spell
    if (Player* modOwner = unitCaster->GetSpellModOwner())
        modOwner->ApplySpellMod(Id, SPELLMOD_COST, powerCost, spell);
 
    if (!unitCaster->IsControlledByPlayer())
    {
        if (HasAttribute(SPELL_ATTR0_SCALES_WITH_CREATURE_LEVEL))
        {
            GtNPCManaCostScalerEntry const* spellScaler = sGtNPCManaCostScalerStore.LookupEntry(SpellLevel - 1);
            GtNPCManaCostScalerEntry const* casterScaler = sGtNPCManaCostScalerStore.LookupEntry(unitCaster->GetLevel() - 1);
            if (spellScaler && casterScaler)
                powerCost *= casterScaler->ratio / spellScaler->ratio;
        }
    }
 
    // PCT mod from user auras by school
    powerCost = int32(powerCost * (1.0f + unitCaster->GetFloatValue(static_cast<uint16>(UNIT_FIELD_POWER_COST_MULTIPLIER) + school)));
    if (powerCost < 0)
        powerCost = 0;
    return powerCost;
}

References AttributesEx, AttributesEx3, AttributesEx4, BASE_ATTACK, CalculatePct(), Unit::GetAttackTime(), Unit::GetCreateHealth(), Unit::GetCreateMana(), GetFirstSchoolInMask(), Object::GetFloatValue(), Unit::GetHealth(), Object::GetInt32Value(), Unit::GetLevel(), Unit::GetMaxPower(), Unit::GetPower(), Unit::GetShapeshiftForm(), Unit::GetSpellModOwner(), HasAttribute(), Id, Unit::IsControlledByPlayer(), LOG_DEBUG, LOG_ERROR, ManaCost, ManaCostPercentage, MAX_POWERS, OFF_ATTACK, POWER_ENERGY, POWER_FOCUS, POWER_HAPPINESS, POWER_HEALTH, POWER_MANA, POWER_RAGE, POWER_RUNE, POWER_RUNIC_POWER, GtNPCManaCostScalerEntry::ratio, sGtNPCManaCostScalerStore, SPELL_ATTR0_SCALES_WITH_CREATURE_LEVEL, SPELL_ATTR1_USE_ALL_MANA, SPELL_ATTR3_REQUIRES_OFF_HAND_WEAPON, SPELL_ATTR4_WEAPON_SPEED_COST_SCALING, SpellLevel, SPELLMOD_COST, sSpellShapeshiftFormStore, Object::ToUnit(), UNIT_FIELD_POWER_COST_MODIFIER, and UNIT_FIELD_POWER_COST_MULTIPLIER.

Referenced by PetAI::_canMeleeAttack(), Spell::CheckPetCast(), Spell::EffectCastButtons(), spell_warr_execute::HandleEffect(), spell_dru_t3_8p_bonus::HandleProc(), spell_hun_glyph_of_arcane_shot::HandleProc(), spell_mage_burnout::HandleProc(), spell_sha_item_mana_surge::HandleProc(), SmartAI::IsMainSpellPrevented(), Spell::prepare(), and SmartScript::ProcessAction().

◆ CanBeRedirectedBySpellMagnet()

bool SpellInfo::CanBeRedirectedBySpellMagnet ( ) const

{
    // Patch 1.2 notes: Spell Reflection no longer reflects abilities.
    return !HasAttribute(SPELL_ATTR0_IS_ABILITY)
        && !HasAttribute(SPELL_ATTR1_NO_REDIRECTION)
        && !HasAttribute(SPELL_ATTR0_NO_IMMUNITIES)
        && !IsAffectingArea();
}

References HasAttribute(), IsAffectingArea(), SPELL_ATTR0_IS_ABILITY, SPELL_ATTR0_NO_IMMUNITIES, and SPELL_ATTR1_NO_REDIRECTION.

Referenced by AuraEffect::CheckEffectProc(), and Unit::GetMagicHitRedirectTarget().

◆ CanBeUsedInCombat()

bool SpellInfo::CanBeUsedInCombat ( ) const

{
    return !(HasAttribute(SPELL_ATTR0_NOT_IN_COMBAT_ONLY_PEACEFUL));
}

References HasAttribute(), and SPELL_ATTR0_NOT_IN_COMBAT_ONLY_PEACEFUL.

Referenced by Spell::CheckCast(), WorldSession::HandleUseItemOpcode(), and PetAI::UpdateAI().

◆ CanDispelAura()

bool SpellInfo::CanDispelAura ( SpellInfo const * auraSpellInfo ) const

{
    // Xinef: Passive auras cannot be dispelled
    if (auraSpellInfo->IsPassive())
        return false;
 
    // These auras (like Divine Shield) can't be dispelled
    if (auraSpellInfo->HasAttribute(SPELL_ATTR0_NO_IMMUNITIES))
        return false;
 
    return true;
}

References HasAttribute(), IsPassive(), and SPELL_ATTR0_NO_IMMUNITIES.

Referenced by ApplyAllSpellImmunitiesTo(), and AuraEffect::HandleAuraModSchoolImmunity().

◆ CanPierceImmuneAura()

bool SpellInfo::CanPierceImmuneAura ( SpellInfo const * auraSpellInfo ) const

{
    // Dispels other auras on immunity, check if this spell makes the unit immune to aura
    if (HasAttribute(SPELL_ATTR1_IMMUNITY_PURGES_EFFECT) && CanSpellProvideImmunityAgainstAura(auraSpellInfo))
        return true;
 
    return false;
}

References CanSpellProvideImmunityAgainstAura(), HasAttribute(), and SPELL_ATTR1_IMMUNITY_PURGES_EFFECT.

Referenced by Unit::HasSchoolImmunityForMask(), and Unit::IsImmunedToDamage().

◆ CanSpellCastOverrideAuraEffect()

bool SpellInfo::CanSpellCastOverrideAuraEffect ( AuraEffect const * aurEff ) const

{
    if (!HasAttribute(SPELL_ATTR1_IMMUNITY_PURGES_EFFECT))
        return false;
 
    if (aurEff->GetSpellInfo()->HasAttribute(SPELL_ATTR0_NO_IMMUNITIES))
        return false;
 
    SpellEffectInfo const* aurEffInfo = &aurEff->GetSpellInfo()->Effects[aurEff->GetEffIndex()];
 
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        SpellEffectInfo const& effectInfo = Effects[i];
        if (!effectInfo.Effect)
            continue;
 
        if (effectInfo.Effect != SPELL_EFFECT_APPLY_AURA)
            continue;
 
        uint32 const miscValue = static_cast<uint32>(effectInfo.MiscValue);
        switch (effectInfo.ApplyAuraName)
        {
            case SPELL_AURA_STATE_IMMUNITY:
                if (miscValue != aurEffInfo->ApplyAuraName)
                    continue;
                break;
            case SPELL_AURA_SCHOOL_IMMUNITY:
            case SPELL_AURA_MOD_IMMUNE_AURA_APPLY_SCHOOL:
                if (aurEff->GetSpellInfo()->HasAttribute(SPELL_ATTR2_NO_SCHOOL_IMMUNITIES) || !(aurEff->GetSpellInfo()->SchoolMask & miscValue))
                    continue;
                break;
            case SPELL_AURA_DISPEL_IMMUNITY:
                if (miscValue != aurEff->GetSpellInfo()->Dispel)
                    continue;
                break;
            case SPELL_AURA_MECHANIC_IMMUNITY:
                if (miscValue != aurEff->GetSpellInfo()->Mechanic)
                {
                    if (miscValue != aurEffInfo->Mechanic)
                        continue;
                }
                break;
            default:
                continue;
        }
 
        return true;
    }
 
    return false;
}

References SpellEffectInfo::ApplyAuraName, Dispel, SpellEffectInfo::Effect, Effects, AuraEffect::GetEffIndex(), AuraEffect::GetSpellInfo(), HasAttribute(), MAX_SPELL_EFFECTS, SpellEffectInfo::Mechanic, Mechanic, SpellEffectInfo::MiscValue, SchoolMask, SPELL_ATTR0_NO_IMMUNITIES, SPELL_ATTR1_IMMUNITY_PURGES_EFFECT, SPELL_ATTR2_NO_SCHOOL_IMMUNITIES, SPELL_AURA_DISPEL_IMMUNITY, SPELL_AURA_MECHANIC_IMMUNITY, SPELL_AURA_MOD_IMMUNE_AURA_APPLY_SCHOOL, SPELL_AURA_SCHOOL_IMMUNITY, SPELL_AURA_STATE_IMMUNITY, and SPELL_EFFECT_APPLY_AURA.

◆ CanSpellProvideImmunityAgainstAura()

bool SpellInfo::CanSpellProvideImmunityAgainstAura ( SpellInfo const * auraSpellInfo ) const

{
    if (!auraSpellInfo)
        return false;
 
    for (SpellEffectInfo const& effectInfo : Effects)
    {
        if (!effectInfo.Effect)
            continue;
 
        ImmunityInfo const* immuneInfo = effectInfo.GetImmunityInfo();
        if (!immuneInfo)
            continue;
 
        if (!auraSpellInfo->HasAttribute(SPELL_ATTR2_NO_SCHOOL_IMMUNITIES))
        {
            if (uint32 schoolImmunity = immuneInfo->SchoolImmuneMask)
                if ((auraSpellInfo->SchoolMask & schoolImmunity) != 0)
                    return true;
        }
 
        if (uint64 mechanicImmunity = immuneInfo->MechanicImmuneMask)
            if ((mechanicImmunity & (1ULL << auraSpellInfo->Mechanic)) != 0)
                return true;
 
        if (uint32 dispelImmunity = immuneInfo->DispelImmuneMask)
            if (auraSpellInfo->Dispel == dispelImmunity)
                return true;
 
        bool immuneToAllEffects = true;
        for (SpellEffectInfo const& auraSpellEffectInfo : auraSpellInfo->Effects)
        {
            if (!auraSpellEffectInfo.Effect)
                continue;
 
            uint32 effectName = auraSpellEffectInfo.Effect;
            if (!effectName)
                continue;
 
            if (immuneInfo->SpellEffectImmune.find(static_cast<SpellEffects>(effectName)) == immuneInfo->SpellEffectImmune.cend())
            {
                immuneToAllEffects = false;
                break;
            }
 
            if (uint32 mechanic = auraSpellEffectInfo.Mechanic)
            {
                if (!(immuneInfo->MechanicImmuneMask & (1ULL << mechanic)))
                {
                    immuneToAllEffects = false;
                    break;
                }
            }
 
            if (uint32 auraName = auraSpellEffectInfo.ApplyAuraName)
            {
                bool isImmuneToAuraEffectApply = false;
                if (immuneInfo->AuraTypeImmune.find(static_cast<AuraType>(auraName)) != immuneInfo->AuraTypeImmune.cend())
                    isImmuneToAuraEffectApply = true;
 
                if (!isImmuneToAuraEffectApply && !auraSpellInfo->IsPositiveEffect(auraSpellEffectInfo.EffectIndex) &&
                    !auraSpellInfo->HasAttribute(SPELL_ATTR2_NO_SCHOOL_IMMUNITIES))
                {
                    if (uint32 applyHarmfulAuraImmuneMask = immuneInfo->ApplyHarmfulAuraImmuneMask)
                        if ((auraSpellInfo->SchoolMask & applyHarmfulAuraImmuneMask) != 0)
                            isImmuneToAuraEffectApply = true;
                }
 
                if (!isImmuneToAuraEffectApply)
                {
                    immuneToAllEffects = false;
                    break;
                }
            }
        }
 
        if (immuneToAllEffects)
            return true;
    }
 
    return false;
}

References ImmunityInfo::ApplyHarmfulAuraImmuneMask, ImmunityInfo::AuraTypeImmune, Dispel, ImmunityInfo::DispelImmuneMask, Effects, HasAttribute(), IsPositiveEffect(), Mechanic, ImmunityInfo::MechanicImmuneMask, ImmunityInfo::SchoolImmuneMask, SchoolMask, SPELL_ATTR2_NO_SCHOOL_IMMUNITIES, and ImmunityInfo::SpellEffectImmune.

Referenced by CanPierceImmuneAura().

◆ CheckExplicitTarget()

SpellCastResult SpellInfo::CheckExplicitTarget	(	WorldObject const *	caster,
		WorldObject const *	target,
		Item const *	itemTarget = `nullptr`
	)		const

{
    uint32 neededTargets = GetExplicitTargetMask();
    if (!target)
    {
        if (neededTargets & (TARGET_FLAG_UNIT_MASK | TARGET_FLAG_GAMEOBJECT_MASK | TARGET_FLAG_CORPSE_MASK))
            if (!(neededTargets & TARGET_FLAG_GAMEOBJECT_ITEM) || !itemTarget)
                return SPELL_FAILED_BAD_TARGETS;
        return SPELL_CAST_OK;
    }
 
    Unit const* unitCaster = caster->ToUnit();
    if (Unit const* unitTarget = target->ToUnit())
    {
        if (neededTargets & (TARGET_FLAG_UNIT_ENEMY | TARGET_FLAG_UNIT_ALLY | TARGET_FLAG_UNIT_RAID | TARGET_FLAG_UNIT_PARTY | TARGET_FLAG_UNIT_MINIPET | TARGET_FLAG_UNIT_PASSENGER))
        {
            if (neededTargets & TARGET_FLAG_UNIT_ENEMY)
                if (caster->IsValidAttackTarget(unitTarget, this))
                    return SPELL_CAST_OK;
            if (neededTargets & TARGET_FLAG_UNIT_ALLY
                    || (neededTargets & TARGET_FLAG_UNIT_PARTY && unitCaster && unitCaster->IsInPartyWith(unitTarget))
                    || (neededTargets & TARGET_FLAG_UNIT_RAID && unitCaster && unitCaster->IsInRaidWith(unitTarget)))
                if (caster->IsValidAssistTarget(unitTarget, this))
                    return SPELL_CAST_OK;
            if (neededTargets & TARGET_FLAG_UNIT_MINIPET)
                if (unitCaster && unitTarget->GetGUID() == unitCaster->GetCritterGUID())
                    return SPELL_CAST_OK;
            if (neededTargets & TARGET_FLAG_UNIT_PASSENGER)
                if (unitCaster && unitTarget->IsOnVehicle(unitCaster))
                    return SPELL_CAST_OK;
            return SPELL_FAILED_BAD_TARGETS;
        }
    }
    return SPELL_CAST_OK;
}

References Unit::GetCritterGUID(), GetExplicitTargetMask(), Object::GetGUID(), Unit::IsInPartyWith(), Unit::IsInRaidWith(), Unit::IsOnVehicle(), WorldObject::IsValidAssistTarget(), WorldObject::IsValidAttackTarget(), SPELL_CAST_OK, SPELL_FAILED_BAD_TARGETS, TARGET_FLAG_CORPSE_MASK, TARGET_FLAG_GAMEOBJECT_ITEM, TARGET_FLAG_GAMEOBJECT_MASK, TARGET_FLAG_UNIT_ALLY, TARGET_FLAG_UNIT_ENEMY, TARGET_FLAG_UNIT_MASK, TARGET_FLAG_UNIT_MINIPET, TARGET_FLAG_UNIT_PARTY, TARGET_FLAG_UNIT_PASSENGER, TARGET_FLAG_UNIT_RAID, and Object::ToUnit().

Referenced by Spell::CheckCast(), Unit::GetMagicHitRedirectTarget(), Unit::GetMeleeHitRedirectTarget(), and Spell::InitExplicitTargets().

◆ CheckLocation()

SpellCastResult SpellInfo::CheckLocation	(	uint32	map_id,
		uint32	zone_id,
		uint32	area_id,
		Player *	player = `nullptr`,
		bool	strict = `true`
	)		const

{
    // normal case
    if (AreaGroupId > 0)
    {
        bool found = false;
        AreaGroupEntry const* groupEntry = sAreaGroupStore.LookupEntry(AreaGroupId);
        while (groupEntry)
        {
            for (uint8 i = 0; i < MAX_GROUP_AREA_IDS; ++i)
                if (groupEntry->AreaId[i] == zone_id || groupEntry->AreaId[i] == area_id)
                    found = true;
            if (found || !groupEntry->nextGroup)
                break;
            // Try search in next group
            groupEntry = sAreaGroupStore.LookupEntry(groupEntry->nextGroup);
        }
 
        if (!found)
            return SPELL_FAILED_INCORRECT_AREA;
    }
 
    // continent limitation (virtual continent)
    if (HasAttribute(SPELL_ATTR4_ONLY_FLYING_AREAS) && (area_id || zone_id))
    {
        AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(area_id);
        if (!areaEntry)
        {
            areaEntry = sAreaTableStore.LookupEntry(zone_id);
        }
 
        if (!areaEntry || !areaEntry->IsFlyable() || (strict && (areaEntry->flags & AREA_FLAG_NO_FLY_ZONE) != 0) || !player->canFlyInZone(map_id, zone_id, this))
        {
            return SPELL_FAILED_INCORRECT_AREA;
        }
    }
 
    // raid instance limitation
    if (HasAttribute(SPELL_ATTR6_NOT_IN_RAID_INSTANCES))
    {
        MapEntry const* mapEntry = sMapStore.LookupEntry(map_id);
        if (!mapEntry || mapEntry->IsRaid())
            return SPELL_FAILED_NOT_IN_RAID_INSTANCE;
    }
 
    // DB base check (if non empty then must fit at least single for allow)
    SpellAreaMapBounds saBounds = sSpellMgr->GetSpellAreaMapBounds(Id);
    if (saBounds.first != saBounds.second)
    {
        for (SpellAreaMap::const_iterator itr = saBounds.first; itr != saBounds.second; ++itr)
        {
            if (itr->second.IsFitToRequirements(player, zone_id, area_id))
                return SPELL_CAST_OK;
        }
        return SPELL_FAILED_INCORRECT_AREA;
    }
 
    // bg spell checks
    switch (Id)
    {
        case 23333:                                         // Warsong Flag
        case 23335:                                         // Silverwing Flag
            return map_id == MAP_WARSONG_GULCH && player && player->InBattleground() ? SPELL_CAST_OK : SPELL_FAILED_REQUIRES_AREA;
        case 34976:                                         // Netherstorm Flag
            return map_id == MAP_EYE_OF_THE_STORM && player && player->InBattleground() ? SPELL_CAST_OK : SPELL_FAILED_REQUIRES_AREA;
        case 2584:                                          // Waiting to Resurrect
        case 22011:                                         // Spirit Heal Channel
        case 22012:                                         // Spirit Heal
        case 42792:                                         // Recently Dropped Flag
        case 43681:                                         // Inactive
        case 44535:                                         // Spirit Heal (mana)
            {
                MapEntry const* mapEntry = sMapStore.LookupEntry(map_id);
                if (!mapEntry)
                    return SPELL_FAILED_INCORRECT_AREA;
 
                return zone_id == AREA_WINTERGRASP || (mapEntry->IsBattleground() && player && player->InBattleground()) ? SPELL_CAST_OK : SPELL_FAILED_REQUIRES_AREA;
            }
        case 32724:                                         // Gold Team (Alliance)
        case 32725:                                         // Green Team (Alliance)
        case 35774:                                         // Gold Team (Horde)
        case 35775:                                         // Green Team (Horde)
            {
                MapEntry const* mapEntry = sMapStore.LookupEntry(map_id);
                if (!mapEntry)
                    return SPELL_FAILED_INCORRECT_AREA;
 
                return mapEntry->IsBattleArena() && player && player->InBattleground() ? SPELL_CAST_OK : SPELL_FAILED_REQUIRES_AREA;
            }
    }
 
    return SPELL_CAST_OK;
}

References AREA_FLAG_NO_FLY_ZONE, AREA_WINTERGRASP, AreaGroupId, AreaGroupEntry::AreaId, Player::canFlyInZone(), AreaTableEntry::flags, HasAttribute(), Id, Player::InBattleground(), MapEntry::IsBattleArena(), MapEntry::IsBattleground(), AreaTableEntry::IsFlyable(), MapEntry::IsRaid(), MAP_EYE_OF_THE_STORM, MAP_WARSONG_GULCH, MAX_GROUP_AREA_IDS, AreaGroupEntry::nextGroup, sAreaGroupStore, sAreaTableStore, sMapStore, SPELL_ATTR4_ONLY_FLYING_AREAS, SPELL_ATTR6_NOT_IN_RAID_INSTANCES, SPELL_CAST_OK, SPELL_FAILED_INCORRECT_AREA, SPELL_FAILED_NOT_IN_RAID_INSTANCE, SPELL_FAILED_REQUIRES_AREA, and sSpellMgr.

Referenced by Spell::CheckCast().

◆ CheckShapeshift()

SpellCastResult SpellInfo::CheckShapeshift ( uint32 form ) const

Todo:: : Find a way to disable use of these spells clientside

{
    // talents that learn spells can have stance requirements that need ignore
    // (this requirement only for client-side stance show in talent description)
    if (GetTalentSpellCost(Id) > 0 &&
            (Effects[0].Effect == SPELL_EFFECT_LEARN_SPELL || Effects[1].Effect == SPELL_EFFECT_LEARN_SPELL || Effects[2].Effect == SPELL_EFFECT_LEARN_SPELL))
        return SPELL_CAST_OK;
 
    uint32 stanceMask = (form ? 1 << (form - 1) : 0);
 
    if (stanceMask & StancesNot)                 // can explicitly not be casted in this stance
        return SPELL_FAILED_NOT_SHAPESHIFT;
 
    if (stanceMask & Stances)                    // can explicitly be casted in this stance
        return SPELL_CAST_OK;
 
    bool actAsShifted = false;
    SpellShapeshiftFormEntry const* shapeInfo = nullptr;
    if (form > 0)
    {
        shapeInfo = sSpellShapeshiftFormStore.LookupEntry(form);
        if (!shapeInfo)
        {
            LOG_ERROR("spells", "GetErrorAtShapeshiftedCast: unknown shapeshift {}", form);
            return SPELL_CAST_OK;
        }
        actAsShifted = !(shapeInfo->flags1 & SHAPESHIFT_FLAG_STANCE);            // shapeshift acts as normal form for spells
    }
 
    if (actAsShifted)
    {
        if (HasAttribute(SPELL_ATTR0_NOT_SHAPESHIFTED)) // not while shapeshifted
            return SPELL_FAILED_NOT_SHAPESHIFT;
        else if (Stances != 0)                   // needs other shapeshift
            return SPELL_FAILED_ONLY_SHAPESHIFT;
    }
    else
    {
        // needs shapeshift
        if (!(AttributesEx2 & SPELL_ATTR2_ALLOW_WHILE_NOT_SHAPESHIFTED) && Stances != 0)
            return SPELL_FAILED_ONLY_SHAPESHIFT;
    }
 
    // Check if stance disables cast of not-stance spells
    // Example: cannot cast any other spells in zombie or ghoul form
    if (shapeInfo && (shapeInfo->flags1 & SHAPESHIFT_FLAG_CAN_ONLY_CAST_SHAPESHIFT_SPELLS))
    {
        if (!(stanceMask & Stances))
            return SPELL_FAILED_ONLY_SHAPESHIFT;
    }
 
    return SPELL_CAST_OK;
}

References AttributesEx2, Effects, SpellShapeshiftFormEntry::flags1, GetTalentSpellCost(), HasAttribute(), Id, LOG_ERROR, SHAPESHIFT_FLAG_CAN_ONLY_CAST_SHAPESHIFT_SPELLS, SHAPESHIFT_FLAG_STANCE, SPELL_ATTR0_NOT_SHAPESHIFTED, SPELL_ATTR2_ALLOW_WHILE_NOT_SHAPESHIFTED, SPELL_CAST_OK, SPELL_EFFECT_LEARN_SPELL, SPELL_FAILED_NOT_SHAPESHIFT, SPELL_FAILED_ONLY_SHAPESHIFT, sSpellShapeshiftFormStore, Stances, and StancesNot.

Referenced by Player::ApplyEquipSpell(), AuraEffect::ApplySpellMod(), and Spell::CheckCast().

◆ CheckTarget()

SpellCastResult SpellInfo::CheckTarget	(	WorldObject const *	caster,
		WorldObject const *	target,
		bool	implicit = `true`,
		Unit const *	originalCaster = `nullptr`
	)		const

{
    if (AttributesEx & SPELL_ATTR1_EXCLUDE_CASTER && caster == target)
        return SPELL_FAILED_BAD_TARGETS;
 
    // check visibility - ignore stealth for implicit (area) targets
    if (!(AttributesEx6 & SPELL_ATTR6_IGNORE_PHASE_SHIFT) && !caster->CanSeeOrDetect(target, implicit))
        return SPELL_FAILED_BAD_TARGETS;
 
    Unit const* unitCaster = caster->ToUnit();
 
    Unit const* unitTarget = target->ToUnit();
 
    // creature/player specific target checks
    if (unitTarget)
    {
        // can't assist player which is dueling someone, also for spells with generic unit targets (e.g. Devour Magic)
        // boarding a dueling player's passenger mount is not an assist
        // owner is taken from the original caster of aura-triggered casts, so a duelist's Prayer of Mending can still
        // jump back to them (spellclicks set the clicker as original caster, so they keep using the caster)
        Unit const* assistingUnit = originalCaster ? originalCaster : unitCaster;
        if (unitCaster && unitCaster != unitTarget && !HasAura(SPELL_AURA_CONTROL_VEHICLE))
            if (Player const* targetPlayerOwner = unitTarget->GetAffectingPlayer())
                if (targetPlayerOwner->duel)
                    if (Player const* casterPlayerOwner = assistingUnit->GetAffectingPlayer())
                        if (casterPlayerOwner != targetPlayerOwner
                                && !unitCaster->IsValidAttackTarget(unitTarget, this))
                            return SPELL_FAILED_TARGET_DUELING;
 
        // xinef: spells cannot be cast if player is in fake combat also
        if (AttributesEx & SPELL_ATTR1_ONLY_PEACEFUL_TARGETS && (unitTarget->IsInCombat() || unitTarget->IsPetInCombat()))
            return SPELL_FAILED_TARGET_AFFECTING_COMBAT;
 
        if (HasAttribute(SPELL_ATTR3_NOT_ON_AOE_IMMUNE))
            if (auto creature = unitTarget->ToCreature())
                if (CreatureImmunities const* immunities = sSpellMgr->GetCreatureImmunities(creature->GetCreatureTemplate()->CreatureImmunitiesId))
                    if (immunities->ImmuneAoE)
                        return SPELL_FAILED_BAD_TARGETS;
 
        // only spells with SPELL_ATTR3_ONLY_ON_GHOSTS can target ghosts
        if (IsRequiringDeadTarget())
        {
            if (!unitTarget->HasGhostAura())
                return SPELL_FAILED_TARGET_NOT_GHOST;
            if (!IsDeathPersistent() && !IsAllowingDeadTarget())
                return SPELL_FAILED_BAD_TARGETS;
        }
 
        if (caster != unitTarget)
        {
            if (caster->IsPlayer())
            {
                // Do not allow these spells to target creatures not tapped by us (Banish, Polymorph, many quest spells)
                if (AttributesEx2 & SPELL_ATTR2_CANNOT_CAST_ON_TAPPED)
                    if (Creature const* targetCreature = unitTarget->ToCreature())
                        if (targetCreature->hasLootRecipient() && !targetCreature->isTappedBy(caster->ToPlayer()))
                            return SPELL_FAILED_CANT_CAST_ON_TAPPED;
 
                if (HasAttribute(SPELL_ATTR0_CU_PICKPOCKET))
                {
                    Creature const* targetCreature = unitTarget->ToCreature();
                    if (!targetCreature)
                        return SPELL_FAILED_BAD_TARGETS;
 
                    if (!LootTemplates_Pickpocketing.HaveLootFor(targetCreature->GetCreatureTemplate()->pickpocketLootId))
                        return SPELL_FAILED_TARGET_NO_POCKETS;
                }
 
                // Not allow disarm unarmed player
                if (Mechanic == MECHANIC_DISARM)
                {
                    bool valid = false;
                    for (uint8 i = BASE_ATTACK; i < MAX_ATTACK; ++i)
                    {
                        AuraType disarmAuraType = SPELL_AURA_MOD_DISARM;
                        switch (i)
                        {
                            case OFF_ATTACK:
                                disarmAuraType = SPELL_AURA_MOD_DISARM_OFFHAND;
                                break;
                            case RANGED_ATTACK:
                                disarmAuraType = SPELL_AURA_MOD_DISARM_RANGED;
                                break;
                        }
 
                        if (HasAura(disarmAuraType))
                        {
                            if (Player const* player = unitTarget->ToPlayer())
                            {
                                if (player->GetWeaponForAttack(WeaponAttackType(i), true))
                                {
                                    valid = true;
                                    break;
                                }
                            }
                            else if (unitTarget->GetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + i))
                            {
                                valid = true;
                                break;
                            }
                        }
                    }
 
                    if (!valid)
                    {
                        return SPELL_FAILED_TARGET_NO_WEAPONS;
                    }
                }
            }
        }
    }
    // corpse specific target checks
    else if (Corpse const* corpseTarget = target->ToCorpse())
    {
        // cannot target bare bones
        if (corpseTarget->GetType() == CORPSE_BONES)
            return SPELL_FAILED_BAD_TARGETS;
        // we have to use owner for some checks (aura preventing resurrection for example)
        if (Player* owner = ObjectAccessor::FindPlayer(corpseTarget->GetOwnerGUID()))
            unitTarget = owner;
        // we're not interested in corpses without owner
        else
            return SPELL_FAILED_BAD_TARGETS;
    }
    // other types of objects - always valid
    else return SPELL_CAST_OK;
 
    // corpseOwner and unit specific target checks
    if (unitTarget->IsPlayer())
    {
        if (HasAttribute(SPELL_ATTR5_NOT_ON_PLAYER))
            return SPELL_FAILED_TARGET_IS_PLAYER;
    }
    else
    {
        if (HasAttribute(SPELL_ATTR3_ONLY_ON_PLAYER))
            return SPELL_FAILED_TARGET_NOT_PLAYER;
 
        if (HasAttribute(SPELL_ATTR5_NOT_ON_PLAYER_CONTROLLED_NPC) && unitTarget->IsControlledByPlayer())
            return SPELL_FAILED_TARGET_IS_PLAYER_CONTROLLED;
    }
 
    if (!IsAllowingDeadTarget() && !unitTarget->IsAlive())
        return SPELL_FAILED_TARGETS_DEAD;
 
    // check this flag only for implicit targets (chain and area), allow to explicitly target units for spells like Shield of Righteousness
    if (implicit && AttributesEx6 & SPELL_ATTR6_DO_NOT_CHAIN_TO_CROWD_CONTROLLED_TARGETS && unitTarget->HasUnitState(UNIT_STATE_CONTROLLED))
        return SPELL_FAILED_BAD_TARGETS;
 
    // checked in Unit::IsValidAttack/AssistTarget, shouldn't be checked for ENTRY targets
    //if (!(AttributesEx6 & SPELL_ATTR6_CAN_TARGET_UNTARGETABLE) && target->HasUnitFlag(UNIT_FLAG_NOT_SELECTABLE))
    //    return SPELL_FAILED_BAD_TARGETS;
 
    //if (!(AttributesEx6 & SPELL_ATTR6_NO_AURA_LOG)
 
    if (!CheckTargetCreatureType(unitTarget))
    {
        if (target->IsPlayer())
            return SPELL_FAILED_TARGET_IS_PLAYER;
        else
            return SPELL_FAILED_BAD_TARGETS;
    }
 
    // check GM mode and GM invisibility - only for player casts (npc casts are controlled by AI) and negative spells
    if (unitTarget != caster && (caster->GetAffectingPlayer() || !IsPositive()) && unitTarget->IsPlayer())
    {
        if (!unitTarget->ToPlayer()->IsVisible())
            return SPELL_FAILED_BM_OR_INVISGOD;
 
        if (unitTarget->ToPlayer()->IsGameMaster())
            return SPELL_FAILED_BM_OR_INVISGOD;
    }
 
    // not allow casting on flying player
    if (unitTarget->IsInFlight() && !HasAttribute(SPELL_ATTR0_CU_ALLOW_INFLIGHT_TARGET))
        return SPELL_FAILED_BAD_TARGETS;
 
    /* TARGET_UNIT_MASTER gets blocked here for passengers, because the whole idea of this check is to
    not allow passengers to be implicitly hit by spells, however this target type should be an exception,
    if this is left it kills spells that award kill credit from vehicle to master (few spells),
    the use of these 2 covers passenger target check, logically, if vehicle cast this to master it should always hit
    him, because it would be it's passenger, there's no such case where this gets to fail legitimacy, this problem
    cannot be solved from within the check in other way since target type cannot be called for the spell currently
    Spell examples: [ID - 52864 Devour Water, ID - 52862 Devour Wind, ID - 49370 Wyrmrest Defender: Destabilize Azure Dragonshrine Effect] */
    if ((!unitCaster || !(unitCaster->IsCreature() && unitCaster->IsVehicle())) && (!unitCaster || unitCaster->GetCharmerOrOwner() != target))
    {
        if (TargetAuraState && !unitTarget->HasAuraState(AuraStateType(TargetAuraState), this, unitCaster))
            return SPELL_FAILED_TARGET_AURASTATE;
 
        if (TargetAuraStateNot && unitTarget->HasAuraState(AuraStateType(TargetAuraStateNot), this, unitCaster))
            return SPELL_FAILED_TARGET_AURASTATE;
    }
 
    if (TargetAuraSpell && !unitTarget->HasAura(sSpellMgr->GetSpellIdForDifficulty(TargetAuraSpell, caster)))
        return SPELL_FAILED_TARGET_AURASTATE;
 
    if (ExcludeTargetAuraSpell && unitTarget->HasAura(sSpellMgr->GetSpellIdForDifficulty(ExcludeTargetAuraSpell, caster)))
        return SPELL_FAILED_TARGET_AURASTATE;
 
    if (unitTarget->HasPreventResurectionAura() && !HasAttribute(SPELL_ATTR7_BYPASS_NO_RESURRECTION_AURA))
        if (HasEffect(SPELL_EFFECT_SELF_RESURRECT) || HasEffect(SPELL_EFFECT_RESURRECT) || HasEffect(SPELL_EFFECT_RESURRECT_NEW))
            return SPELL_FAILED_TARGET_CANNOT_BE_RESURRECTED;
 
    return SPELL_CAST_OK;
}

Referenced by Spell::AddUnitTarget(), Spell::CheckCast(), Unit::GetMeleeHitRedirectTarget(), SpellTargetSelector::operator()(), Acore::WorldObjectSpellTargetCheck::operator()(), and Spell::SelectImplicitTrajTargets().

◆ CheckTargetCreatureType()

bool SpellInfo::CheckTargetCreatureType ( Unit const * target ) const

{
    // Curse of Doom & Exorcism: not find another way to fix spell target check :/
    if (SpellFamilyName == SPELLFAMILY_WARLOCK && GetCategory() == 1179)
    {
        // not allow cast at player
        if (target->IsPlayer())
            return false;
        else
            return true;
    }
    uint32 creatureType = target->GetCreatureTypeMask();
    return !TargetCreatureType || !creatureType || (creatureType & TargetCreatureType);
}

References GetCategory(), Unit::GetCreatureTypeMask(), Object::IsPlayer(), SPELLFAMILY_WARLOCK, SpellFamilyName, and TargetCreatureType.

Referenced by CheckTarget().

◆ ComputeIsCritCapable()

bool SpellInfo::ComputeIsCritCapable ( ) const

{
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        switch (Effects[i].Effect)
        {
            case SPELL_EFFECT_SCHOOL_DAMAGE:
            case SPELL_EFFECT_HEALTH_LEECH:
            case SPELL_EFFECT_HEAL:
            case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL:
            case SPELL_EFFECT_WEAPON_PERCENT_DAMAGE:
            case SPELL_EFFECT_WEAPON_DAMAGE:
            case SPELL_EFFECT_POWER_BURN:
            case SPELL_EFFECT_HEAL_MECHANICAL:
            case SPELL_EFFECT_NORMALIZED_WEAPON_DMG:
            case SPELL_EFFECT_HEAL_PCT:
                return true;
        }
    }
    return false;
}

References Effects, MAX_SPELL_EFFECTS, SPELL_EFFECT_HEAL, SPELL_EFFECT_HEAL_MECHANICAL, SPELL_EFFECT_HEAL_PCT, SPELL_EFFECT_HEALTH_LEECH, SPELL_EFFECT_NORMALIZED_WEAPON_DMG, SPELL_EFFECT_POWER_BURN, SPELL_EFFECT_SCHOOL_DAMAGE, SPELL_EFFECT_WEAPON_DAMAGE, SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL, and SPELL_EFFECT_WEAPON_PERCENT_DAMAGE.

◆ ComputeIsStackableWithRanks()

bool SpellInfo::ComputeIsStackableWithRanks ( ) const

{
    if (IsPassive())
        return false;
    if (PowerType != POWER_MANA && PowerType != POWER_HEALTH)
        return false;
    if (IsProfessionOrRiding())
        return false;
 
    if (IsAbilityLearnedWithProfession())
        return false;
 
    // All stance spells. if any better way, change it.
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        switch (SpellFamilyName)
        {
            case SPELLFAMILY_PALADIN:
                // Paladin aura Spell
                if (Effects[i].Effect == SPELL_EFFECT_APPLY_AREA_AURA_RAID)
                    return false;
                break;
            case SPELLFAMILY_DRUID:
                // Druid form Spell
                if (Effects[i].Effect == SPELL_EFFECT_APPLY_AURA &&
                        Effects[i].ApplyAuraName == SPELL_AURA_MOD_SHAPESHIFT)
                    return false;
                break;
        }
    }
    return true;
}

References Effects, IsAbilityLearnedWithProfession(), IsPassive(), IsProfessionOrRiding(), MAX_SPELL_EFFECTS, POWER_HEALTH, POWER_MANA, SPELL_AURA_MOD_SHAPESHIFT, SPELL_EFFECT_APPLY_AREA_AURA_RAID, SPELL_EFFECT_APPLY_AURA, SPELLFAMILY_DRUID, SPELLFAMILY_PALADIN, and SpellFamilyName.

◆ GetAllEffectsMechanicMask()

uint64 SpellInfo::GetAllEffectsMechanicMask ( ) const

{
    uint64 mask = 0;
    if (Mechanic)
        mask |= 1ULL << Mechanic;
    for (int i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if (Effects[i].IsEffect() && Effects[i].Mechanic)
            mask |= 1ULL << Effects[i].Mechanic;
    return mask;
}

References Effects, MAX_SPELL_EFFECTS, and Mechanic.

Referenced by spell_item_luffa::CheckCast(), Spell::CheckCasterAuras(), AuraEffect::CheckEffectProc(), spell_uk_second_wind::CheckProc(), spell_dk_pvp_4p_bonus::CheckProc(), spell_mage_burning_determination::CheckProc(), spell_warr_second_wind::CheckProc(), Spell::EffectDispelMechanic(), Spell::EffectTriggerSpell(), GetDiminishingReturnsGroupForSpell(), spell_item_luffa::HandleEffect(), LoadAuraState(), Unit::MeleeDamageBonusTaken(), Unit::RemoveAurasByShapeShift(), Unit::RemoveAurasWithMechanic(), and Unit::SpellDamageBonusTaken().

◆ GetAuraRankForLevel()

SpellInfo const * SpellInfo::GetAuraRankForLevel ( uint8 level ) const

{
    // ignore passive spells
    //if (IsPassive())
    //    return this;
 
    // Client ignores spell with these attributes (sub_53D9D0)
    if (HasAttribute(SPELL_ATTR0_COOLDOWN_ON_EVENT) || HasAttribute(SPELL_ATTR2_ALLOW_LOW_LEVEL_BUFF) || HasAttribute(SPELL_ATTR3_ONLY_PROC_ON_CASTER))
        return this;
 
    bool needRankSelection = false;
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (IsPositiveEffect(i) &&
                (Effects[i].Effect == SPELL_EFFECT_APPLY_AURA ||
                 Effects[i].Effect == SPELL_EFFECT_APPLY_AREA_AURA_PARTY ||
                 Effects[i].Effect == SPELL_EFFECT_APPLY_AREA_AURA_RAID))
        {
            needRankSelection = true;
            break;
        }
    }
 
    // not required
    if (!needRankSelection)
        return this;
 
    SpellInfo const* nextSpellInfo = nullptr;
 
    sScriptMgr->OnBeforeAuraRankForLevel(this, nextSpellInfo, level);
 
    if (nextSpellInfo != nullptr)
        return nextSpellInfo;
 
    for (nextSpellInfo = this; nextSpellInfo != nullptr; nextSpellInfo = nextSpellInfo->GetPrevRankSpell())
    {
        // if found appropriate level
        if (uint32(level + 10) >= nextSpellInfo->SpellLevel)
            return nextSpellInfo;
 
        // one rank less then
    }
 
    // not found
    return nullptr;
}

References Effects, GetPrevRankSpell(), HasAttribute(), IsPositiveEffect(), MAX_SPELL_EFFECTS, SPELL_ATTR0_COOLDOWN_ON_EVENT, SPELL_ATTR2_ALLOW_LOW_LEVEL_BUFF, SPELL_ATTR3_ONLY_PROC_ON_CASTER, SPELL_EFFECT_APPLY_AREA_AURA_PARTY, SPELL_EFFECT_APPLY_AREA_AURA_RAID, SPELL_EFFECT_APPLY_AURA, SpellLevel, and sScriptMgr.

Referenced by Pet::_LoadAuras(), Spell::DoSpellHitOnUnit(), and WorldSession::HandleCastSpellOpcode().

◆ GetAuraState()

AuraStateType SpellInfo::GetAuraState ( ) const

{
    return _auraState;
}

References _auraState.

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

◆ GetCategory()

uint32 SpellInfo::GetCategory ( ) const

{
    return CategoryEntry ? CategoryEntry->Id : 0;
}

References CategoryEntry, and SpellCategoryEntry::Id.

Referenced by Player::AddSpellAndCategoryCooldowns(), Creature::AddSpellCooldown(), Player::CanRequestSpellCast(), CheckTargetCreatureType(), Spell::EffectDispel(), Spell::EffectSchoolDMG(), Spell::EffectTriggerMissileSpell(), Spell::EffectTriggerSpell(), WorldSession::HandleCastSpellOpcode(), spell_hun_readiness::HandleDummy(), WorldSession::HandleItemQuerySingleOpcode(), WorldSession::HandleUseItemOpcode(), LoadAuraState(), SpellMgr::LoadSpellInfoCustomAttributes(), Acore::AbsorbAuraOrderPred::operator()(), and Unit::SpellTakenCritChance().

◆ GetDispelMask() [1/2]

uint32 SpellInfo::GetDispelMask ( ) const

{
    return GetDispelMask(DispelType(Dispel));
}

References Dispel, and GetDispelMask().

Referenced by Spell::CheckCast(), Spell::CheckCasterAuras(), Spell::EffectDispel(), Spell::EffectStealBeneficialBuff(), Spell::EffectTriggerSpell(), Unit::GetDispellableAuraList(), and GetDispelMask().

◆ GetDispelMask() [2/2]

uint32 SpellInfo::GetDispelMask ( DispelType type )

static

{
    // If dispel all
    if (type == DISPEL_ALL)
        return DISPEL_ALL_MASK;
    else
        return uint32(1 << type);
}

References DISPEL_ALL, and DISPEL_ALL_MASK.

◆ GetDuration()

int32 SpellInfo::GetDuration ( ) const

{
    if (!DurationEntry)
        return 0;
    return (DurationEntry->Duration[0] == -1) ? -1 : std::abs(DurationEntry->Duration[0]);
}

References SpellDurationEntry::Duration, and DurationEntry.

Referenced by Aura::CalcMaxDuration(), WorldObject::CalcSpellDuration(), Unit::CalculateDefaultCoefficient(), AuraEffect::CleanupTriggeredSpells(), Spell::DelayedChannel(), Spell::EffectAddFarsight(), Spell::EffectDuel(), Spell::EffectEnchantHeldItem(), Spell::EffectSummonObject(), Spell::EffectSummonObjectWild(), Spell::EffectSummonPet(), Spell::EffectSummonType(), Spell::EffectTransmitted(), UnitAI::FillAISpellInfo(), Unit::GetCastingTimeForBonus(), GetMaxTicks(), Spell::handle_immediate(), spell_wintergrasp_create_vehicle::HandleSummon(), Player::IsAffectedBySpellmod(), ObjectMgr::LoadCreatureAddons(), ObjectMgr::LoadCreatureTemplateAddons(), Pet::LoadPetFromDB(), and Spell::SummonGuardian().

◆ GetEffect()

SpellEffectInfo const & SpellInfo::GetEffect ( SpellEffIndex index ) const

inline

562{ ASSERT(index < Effects.size()); return Effects[index]; }

References ASSERT.

Referenced by spell_dragonblight_corrosive_spit::AfterApply(), spell_dragonblight_corrosive_spit::PeriodicTick(), spell_lich_king_whisper::Validate(), spell_dragonblight_corrosive_spit::Validate(), spell_the_cleansing_on_death_cast_on_master::Validate(), spell_sorlofs_booty_cannon_primer::Validate(), spell_low_health_trigger::Validate(), and spell_gen_whisper_to_controller::Validate().

◆ GetEffectMechanic()

Mechanics SpellInfo::GetEffectMechanic ( uint8 effIndex ) const

{
    if (Effects[effIndex].IsEffect() && Effects[effIndex].Mechanic)
        return Mechanics(Effects[effIndex].Mechanic);
    if (Mechanic)
        return Mechanics(Mechanic);
    return MECHANIC_NONE;
}

References Effects, Mechanic, and MECHANIC_NONE.

Referenced by Unit::GetMechanicResistChance().

◆ GetEffectMechanicMask()

uint64 SpellInfo::GetEffectMechanicMask ( uint8 effIndex ) const

{
    uint64 mask = 0;
    if (Mechanic)
        mask |= 1ULL << Mechanic;
    if (Effects[effIndex].IsEffect() && Effects[effIndex].Mechanic)
        mask |= 1ULL << Effects[effIndex].Mechanic;
    return mask;
}

References Effects, and Mechanic.

Referenced by Unit::IsDamageReducedByArmor().

◆ GetEffects()

std::array< SpellEffectInfo, MAX_SPELL_EFFECTS > const & SpellInfo::GetEffects ( ) const

inline

561{ return Effects; }

Referenced by Spell::CanAutoCast(), Trainer::Trainer::CanTeachSpell(), Aura::HasMoreThanOneEffectForType(), SpellMgr::LoadSpellGroupStackRules(), SpellMgr::LoadSpellInfoCorrections(), and Trainer::Trainer::SendSpells().

◆ GetExplicitTargetMask()

uint32 SpellInfo::GetExplicitTargetMask ( ) const

{
    return ExplicitTargetMask;
}

References ExplicitTargetMask.

Referenced by Spell::CheckCast(), CheckExplicitTarget(), Spell::EffectForceCast(), Spell::EffectTriggerMissileSpell(), Spell::EffectTriggerSpell(), Spell::InitExplicitTargets(), NeedsExplicitUnitTarget(), and Spell::SelectExplicitTargets().

◆ GetFirstRankSpell()

SpellInfo const * SpellInfo::GetFirstRankSpell ( ) const

{
    if (!ChainEntry)
        return this;
    return ChainEntry->first;
}

References ChainEntry, and SpellChainNode::first.

Referenced by SpellMgr::AddSameEffectStackRuleSpellGroups(), CharmInfo::AddSpellToActionBar(), Spell::AddUnitTarget(), SpellMgr::CheckSpellGroupStackRules(), Unit::GetHighestExclusiveSameEffectSpellGroupValue(), spell_pal_improved_aura::HandleEffectRemove(), Acore::PlayerCommand::HandleLearnSpellCommand(), Unit::IsHighestExclusiveAuraEffect(), IsRankOf(), SpellMgr::LoadSpellProcs(), and LoadSpellSpecific().

◆ GetImmunityInfo()

ImmunityInfo const * SpellInfo::GetImmunityInfo ( uint8 effIndex ) const

inline

529{ return effIndex < MAX_SPELL_EFFECTS ? &_immunityInfo[effIndex] : nullptr; }

References MAX_SPELL_EFFECTS.

Referenced by SpellEffectInfo::GetImmunityInfo().

◆ GetLastRankSpell()

SpellInfo const * SpellInfo::GetLastRankSpell ( ) const

{
    if (!ChainEntry)
        return nullptr;
    return ChainEntry->last;
}

References ChainEntry, and SpellChainNode::last.

◆ GetMaxDuration()

int32 SpellInfo::GetMaxDuration ( ) const

{
    if (!DurationEntry)
        return 0;
    return (DurationEntry->Duration[2] == -1) ? -1 : std::abs(DurationEntry->Duration[2]);
}

References SpellDurationEntry::Duration, and DurationEntry.

Referenced by WorldObject::CalcSpellDuration(), Unit::GetDiseasesByCaster(), spell_dk_unholy_blight::HandleProc(), spell_pal_infusion_of_light::HandleProc(), spell_dk_glyph_of_scourge_strike_script::HandleScriptEffect(), spell_dru_glyph_of_starfire::HandleScriptEffect(), Unit::IsHighestExclusiveAuraEffect(), Spell::prepare(), Aura::RefreshDuration(), and PetAI::UpdateAI().

◆ GetMaxRange()

float SpellInfo::GetMaxRange	(	bool	positive = `false`,
		WorldObject *	caster = `nullptr`,
		Spell *	spell = `nullptr`
	)		const

{
    if (!RangeEntry)
        return 0.0f;
    float range;
    if (positive)
        range = RangeEntry->RangeMax[1];
    else
        range = RangeEntry->RangeMax[0];
    if (Player* modOwner = caster ? caster->GetSpellModOwner() : nullptr)
        modOwner->ApplySpellMod(Id, SPELLMOD_RANGE, range, spell);
    return range;
}

References WorldObject::GetSpellModOwner(), Id, RangeEntry, SpellRangeEntry::RangeMax, and SPELLMOD_RANGE.

Referenced by PetAI::_canMeleeAttack(), _InitializeExplicitTargetMask(), ArcherAI::ArcherAI(), Spell::CheckCast(), spell_gen_cannibalize::CheckIfCorpseNear(), spell_hun_pet_carrion_feeder::CheckIfCorpseNear(), UnitAI::DoGetSpellMaxRange(), Spell::EffectTransmitted(), UnitAI::FillAISpellInfo(), WorldObject::GetSpellMaxRangeForTarget(), Unit::GetSpellMaxRangeForTarget(), spell_warl_demonic_circle_summon::HandleDummyTick(), AuraEffect::HandleFarSight(), GameObject::IsAtInteractDistance(), Creature::reachWithSpellAttack(), Creature::reachWithSpellCure(), Spell::SelectImplicitCasterDestTargets(), Spell::SelectImplicitNearbyTargets(), Spell::SelectImplicitTrajTargets(), SmartAI::SetMainSpell(), TurretAI::TurretAI(), TotemAI::UpdateAI(), and Spell::UpdateChanneledTargetList().

◆ GetMaxTicks()

uint32 SpellInfo::GetMaxTicks ( ) const

{
    int32 DotDuration = GetDuration();
    if (DotDuration == 0)
        return 1;
 
    // 200% limit
    if (DotDuration > 30000)
        DotDuration = 30000;
 
    for (uint8 x = 0; x < MAX_SPELL_EFFECTS; x++)
    {
        if (Effects[x].Effect == SPELL_EFFECT_APPLY_AURA)
            switch (Effects[x].ApplyAuraName)
            {
                case SPELL_AURA_PERIODIC_DAMAGE:
                case SPELL_AURA_PERIODIC_HEAL:
                case SPELL_AURA_PERIODIC_LEECH:
                case SPELL_AURA_PERIODIC_TRIGGER_SPELL_FROM_CLIENT:
                    if (Effects[x].Amplitude != 0)
                        return DotDuration / Effects[x].Amplitude;
                    break;
                default:
                    break;
            }
    }
 
    return 6;
}

References Effects, GetDuration(), MAX_SPELL_EFFECTS, SPELL_AURA_PERIODIC_DAMAGE, SPELL_AURA_PERIODIC_HEAL, SPELL_AURA_PERIODIC_LEECH, SPELL_AURA_PERIODIC_TRIGGER_SPELL_FROM_CLIENT, and SPELL_EFFECT_APPLY_AURA.

◆ GetMinRange()

float SpellInfo::GetMinRange ( bool positive = false ) const

{
    if (!RangeEntry)
        return 0.0f;
    if (positive)
        return RangeEntry->RangeMin[1];
    return RangeEntry->RangeMin[0];
}

References RangeEntry, and SpellRangeEntry::RangeMin.

Referenced by ArcherAI::ArcherAI(), Spell::EffectTransmitted(), WorldObject::GetSpellMinRangeForTarget(), Unit::GetSpellMinRangeForTarget(), Creature::reachWithSpellAttack(), Creature::reachWithSpellCure(), Spell::SelectImplicitCasterDestTargets(), and TurretAI::TurretAI().

◆ GetNextRankSpell()

SpellInfo const * SpellInfo::GetNextRankSpell ( ) const

{
    if (!ChainEntry)
        return nullptr;
    return ChainEntry->next;
}

References ChainEntry, and SpellChainNode::next.

Referenced by Player::addSpell(), spell_dk_rime::HandleProc(), spell_dk_sudden_doom::HandleProc(), SpellMgr::LoadSpellGroupStackRules(), SpellMgr::LoadSpellProcs(), and ObjectMgr::LoadSpellScriptNames().

◆ GetPrevRankSpell()

SpellInfo const * SpellInfo::GetPrevRankSpell ( ) const

{
    if (!ChainEntry)
        return nullptr;
    return ChainEntry->prev;
}

References ChainEntry, and SpellChainNode::prev.

Referenced by GetAuraRankForLevel().

◆ GetRank()

uint8 SpellInfo::GetRank ( ) const

{
    if (!ChainEntry)
        return 1;
    return ChainEntry->rank;
}

References ChainEntry, and SpellChainNode::rank.

◆ GetRecoveryTime()

uint32 SpellInfo::GetRecoveryTime ( ) const

{
    return RecoveryTime > CategoryRecoveryTime ? RecoveryTime : CategoryRecoveryTime;
}

References CategoryRecoveryTime, and RecoveryTime.

Referenced by Spell::CheckCast(), and spell_mage_cold_snap::HandleDummy().

◆ GetSchoolMask()

SpellSchoolMask SpellInfo::GetSchoolMask ( ) const

{
    return SpellSchoolMask(SchoolMask);
}

References SchoolMask.

Referenced by PetAI::_canMeleeAttack(), ApplyAllSpellImmunitiesTo(), Unit::CalcArmorReducedDamage(), AuraEffect::CalcPeriodicCritChance(), ThreatManager::CalculateModifiedThreat(), spell_mage_ice_barrier_aura::CalculateSpellAmount(), spell_mage_ice_barrier::CalculateSpellAmount(), CalculateSpellAmount(), Unit::CalculateSpellDamageTaken(), Creature::CanCastSpell(), Spell::CheckCast(), Spell::CheckCasterAuras(), AuraEffect::CheckEffectProc(), spell_karazhan_wrath_titans_aura::CheckProc(), spell_gen_adaptive_warding::CheckProc(), spell_gen_obsidian_armor::CheckProc(), spell_hun_lock_and_load::CheckTrapProc(), Unit::DealDamage(), Unit::DealDamageShieldDamage(), Spell::DoAllEffectOnTarget(), Spell::EffectCastButtons(), Spell::EffectEnvironmentalDMG(), Spell::EffectHeal(), Spell::EffectInterruptCast(), Spell::EffectWeaponDmg(), ProcEventInfo::GetSchoolMask(), AuraEffect::HandleAuraModSchoolImmunity(), spell_mage_cold_snap::HandleDummy(), AuraEffect::HandlePeriodicTriggerSpellAuraTick(), spell_karazhan_wrath_titans_aura::HandleProc(), spell_dru_t3_8p_bonus::HandleProc(), spell_gen_adaptive_warding::HandleProc(), spell_gen_obsidian_armor::HandleProc(), spell_hun_glyph_of_arcane_shot::HandleProc(), Unit::IsImmunedToAuraPeriodicTick(), Unit::IsImmunedToDamage(), Unit::IsImmunedToSpell(), Unit::IsImmunedToSpell(), Unit::IsImmunedToSpell(), Unit::IsImmunedToSpellEffect(), SmartAI::IsMainSpellPrevented(), LoadAuraState(), WorldObject::MagicSpellHitResult(), SmartScript::ProcessAction(), Player::ProhibitSpellSchool(), Unit::SendPeriodicAuraLog(), Spell::Spell(), Unit::SpellCriticalDamageBonus(), Unit::SpellDamageBonusDone(), Unit::SpellDamageBonusTaken(), Unit::SpellHealingBonusDone(), Unit::SpellHealingBonusTaken(), boss_viscidus::SpellHit(), WorldObject::SpellHitResult(), WorldObject::SpellHitResult(), and Unit::SpellPctDamageModsDone().

◆ GetSpellMechanicMaskByEffectMask()

uint64 SpellInfo::GetSpellMechanicMaskByEffectMask ( uint32 effectMask ) const

{
    uint64 mask = 0;
    if (Mechanic)
        mask |= 1ULL << Mechanic;
    for (int i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if ((effectMask & (1 << i)) && Effects[i].Mechanic)
            mask |= 1ULL << Effects[i].Mechanic;
    return mask;
}

References Effects, MAX_SPELL_EFFECTS, and Mechanic.

Referenced by WorldObject::ModSpellDuration().

◆ GetSpellSpecific()

SpellSpecificType SpellInfo::GetSpellSpecific ( ) const

{
    return _spellSpecific;
}

References _spellSpecific.

Referenced by AuraApplication::BuildUpdatePacket(), Aura::CanStackWith(), IsAuraExclusiveBySpecificPerCasterWith(), IsAuraExclusiveBySpecificWith(), Unit::IsPolymorphed(), Aura::IsSingleTargetWith(), LoadAuraState(), and Aura::UpdateTargetMap().

◆ HasAnyAura()

bool SpellInfo::HasAnyAura ( ) const

{
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if (Effects[i].IsAura())
            return true;
    return false;
}

References Effects, and MAX_SPELL_EFFECTS.

Referenced by Player::_addSpell(), and Player::removeSpell().

◆ HasAnyEffectMechanic()

bool SpellInfo::HasAnyEffectMechanic ( ) const

{
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if (Effects[i].Mechanic)
            return true;
    return false;
}

References Effects, MAX_SPELL_EFFECTS, and Mechanic.

◆ HasAreaAuraEffect()

bool SpellInfo::HasAreaAuraEffect ( ) const

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

References Effects, and MAX_SPELL_EFFECTS.

Referenced by AuraScript::_Validate(), and Aura::CanBeSentToClient().

◆ HasAttribute() [1/9]

bool SpellInfo::HasAttribute ( SpellAttr0 attribute ) const

inline

441{ return (Attributes & attribute) != 0; }

Referenced by Player::_addSpell(), Player::_addTalentAurasAndSpells(), Spell::_cast(), _IsPositiveEffect(), Unit::_IsValidAssistTarget(), Unit::_IsValidAttackTarget(), Pet::_SaveAuras(), Unit::_TryStackingOrRefreshingExistingAura(), Unit::AddAura(), Player::AddSpellAndCategoryCooldowns(), Player::addTalent(), ThreatManager::AddThreat(), ApplyAllSpellImmunitiesTo(), Player::ApplyEquipCooldown(), Aura::Aura(), AuraApplication::BuildUpdatePacket(), Unit::CalcAbsorbResist(), CalcCastTime(), CalcPowerCost(), AuraEffect::CalculatePeriodic(), Unit::CalculateSpellDamageTaken(), boss_mandokir::boss_mandokirAI::CalculateThreat(), SpellEffectInfo::CalcValue(), PetAI::CanAttack(), CanBeRedirectedBySpellMagnet(), Aura::CanBeSaved(), CanBeUsedInCombat(), CanDispelAura(), Spell::CanExecuteTriggersOnHit(), Player::canFlyInZone(), Player::CanNoReagentCast(), CanPierceImmuneAura(), CanSpellCastOverrideAuraEffect(), CanSpellProvideImmunityAgainstAura(), Aura::CanStackWith(), Spell::CheckCast(), Spell::CheckCasterAuras(), Spell::CheckEffectTarget(), Spell::CheckItems(), CheckLocation(), spell_dru_omen_of_clarity::CheckProc(), spell_item_meteoric_inspiration::CheckProc(), spell_warr_weapon_required_proc::CheckProc(), CheckShapeshift(), CheckTarget(), createProcFlags(), Unit::DealDamage(), Spell::Delayed(), Spell::DelayedChannel(), Spell::DoAllEffectOnLaunchTarget(), Spell::DoAllEffectOnTarget(), Spell::DoSpellHitOnUnit(), Spell::EffectCastButtons(), Spell::EffectCharge(), Spell::EffectEnergize(), Spell::EffectEnergizePct(), Spell::EffectForceDeselect(), Spell::EffectSanctuary(), Spell::EffectSchoolDMG(), Spell::EffectStealBeneficialBuff(), Spell::EffectTriggerSpell(), Spell::EffectWeaponDmg(), UnitAI::FillAISpellInfo(), DynObjAura::FillTargetMap(), spell_yogg_saron_lunatic_gaze::FilterTargets(), Spell::finish(), Creature::FocusTarget(), ThreatManager::ForwardThreatForAssistingMe(), GetAuraRankForLevel(), Unit::GetDispellableAuraList(), Unit::GetEffectiveResistChance(), Aura::GetProcEffectMask(), Spell::GetSearcherTypeMask(), AuraEffect::GetTotalTicks(), Spell::handle_immediate(), AuraEffect::HandleAuraModSchoolImmunity(), WorldSession::HandleCancelAuraOpcode(), WorldSession::HandleCancelChanneling(), AuraEffect::HandleFeignDeath(), Spell::HandleLaunchPhase(), AuraEffect::HandleModTotalPercentStat(), AuraEffect::HandlePeriodicDamageAurasTick(), AuraEffect::HandlePeriodicEnergizeAuraTick(), WorldSession::HandlePetAction(), AuraEffect::HandleShapeshiftBoosts(), Spell::HandleThreatSpells(), HasInitialAggro(), Unit::IgnoresSchoolImmunityFromFriendlyCaster(), IsActionAllowedChannel(), Unit::IsAreaEffectPvPBlocked(), Spell::IsAutoActionResetSpell(), IsAutocastable(), IsCooldownStartedOnEvent(), Unit::IsDamageReducedByArmor(), Unit::IsImmunedToAuraPeriodicTick(), Unit::IsImmunedToDamage(), Creature::IsImmunedToSpell(), Unit::IsImmunedToSpell(), Unit::IsImmunedToSpell(), Unit::IsImmunedToSpellEffect(), Creature::IsImmunedToSpellEffect(), Player::IsNeedCastPassiveSpellAtLearn(), Spell::IsNextMeleeSwingSpell(), IsPassive(), IsRangedWeaponSpell(), Aura::IsRemovedOnShapeLost(), Unit::isSpellBlocked(), Player::LearnTalent(), SpellMgr::LoadEnchantCustomAttr(), LoadLootTemplates_Spell(), SpellMgr::LoadSpellInfoCustomAttributes(), LoadSpellSpecific(), WorldObject::MagicSpellHitResult(), Unit::MeleeDamageBonusTaken(), Unit::MeleeSpellHitResult(), Unit::MeleeSpellMissChance(), WorldObject::ModSpellDuration(), Aura::ModStackAmount(), Acore::WorldObjectSpellConeTargetCheck::operator()(), AuraEffect::PeriodicTick(), Player::PrepareCharmAISpells(), Spell::prepareDataForTriggerSystem(), Aura::PrepareProcToTrigger(), SmartScript::ProcessAction(), Aura::RefreshDuration(), Aura::RefreshTimersWithMods(), Creature::ReleaseFocus(), Unit::RemoveAllAurasOnDeath(), Unit::RemoveArenaAuras(), Player::RemoveArenaSpellCooldowns(), Unit::RemoveAurasByShapeShift(), Unit::RemoveAurasDueToSpellByDispel(), Unit::RemoveAurasDueToSpellBySteal(), Unit::RemoveEvadeAuras(), Player::removeSpell(), Player::resetTalents(), Player::RestoreBaseRune(), Spell::SearchChainTargets(), Spell::SendResurrectRequest(), Spell::SendSpellGo(), Spell::SendSpellStart(), ArenaSpectator::ShouldSendAura(), Spell::Spell(), Unit::SpellDamageBonusDone(), Unit::SpellDamageBonusTaken(), Unit::SpellDoneCritChance(), Unit::SpellHealingBonusTaken(), WorldObject::SpellHitResult(), WorldObject::SpellHitResult(), Unit::SpellPctDamageModsDone(), Unit::SpellPctHealingModsDone(), Unit::SpellTakenCritChance(), Acore::Hyperlinks::LinkTags::enchant::StoreTo(), Spell::TakeAmmo(), Unit::TriggerAurasProcOnEvent(), Spell::TriggerGlobalCooldown(), Spell::UpdateChanneledTargetList(), and Aura::UpdateTargetMap().

◆ HasAttribute() [2/9]

bool SpellInfo::HasAttribute ( SpellAttr1 attribute ) const

inline

442{ return (AttributesEx & attribute) != 0; }

◆ HasAttribute() [3/9]

bool SpellInfo::HasAttribute ( SpellAttr2 attribute ) const

inline

443{ return (AttributesEx2 & attribute) != 0; }

◆ HasAttribute() [4/9]

bool SpellInfo::HasAttribute ( SpellAttr3 attribute ) const

inline

444{ return (AttributesEx3 & attribute) != 0; }

◆ HasAttribute() [5/9]

bool SpellInfo::HasAttribute ( SpellAttr4 attribute ) const

inline

445{ return (AttributesEx4 & attribute) != 0; }

◆ HasAttribute() [6/9]

bool SpellInfo::HasAttribute ( SpellAttr5 attribute ) const

inline

446{ return (AttributesEx5 & attribute) != 0; }

◆ HasAttribute() [7/9]

bool SpellInfo::HasAttribute ( SpellAttr6 attribute ) const

inline

447{ return (AttributesEx6 & attribute) != 0; }

◆ HasAttribute() [8/9]

bool SpellInfo::HasAttribute ( SpellAttr7 attribute ) const

inline

448{ return (AttributesEx7 & attribute) != 0; }

◆ HasAttribute() [9/9]

bool SpellInfo::HasAttribute ( SpellCustomAttributes customAttribute ) const

inline

449{ return (AttributesCu & customAttribute) != 0; }

◆ HasAura()

bool SpellInfo::HasAura ( AuraType aura ) const

{
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if (Effects[i].IsAura(aura))
            return true;
    return false;
}

References Effects, and MAX_SPELL_EFFECTS.

Referenced by Spell::_handle_finish_phase(), Pet::_SaveAuras(), ApplyAllSpellImmunitiesTo(), AuraEffect::CalculateAmount(), AuraEffect::CalculatePeriodicData(), boss_mandokir::boss_mandokirAI::CalculateThreat(), PetAI::CanAttack(), Spell::CheckCast(), spell_dru_omen_of_clarity::CheckProc(), CheckTarget(), Unit::DealDamage(), Spell::EffectHeal(), Spell::EffectSummonType(), Aura::GetProcEffectMask(), Unit::HandleSpellClick(), Unit::IsImmunedToSpell(), SpellMgr::LoadSpellGroupStackRules(), SpellMgr::LoadSpellInfoCustomAttributes(), WorldObject::ModSpellCastTime(), Unit::RemoveAllAurasExceptType(), Unit::RemoveEvadeAuras(), PetAI::SpellHit(), WorldObject::SpellHitResult(), and WorldObject::SpellHitResult().

◆ HasEffect()

bool SpellInfo::HasEffect ( SpellEffects effect ) const

{
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if (Effects[i].IsEffect(effect))
            return true;
    return false;
}

References Effects, and MAX_SPELL_EFFECTS.

Referenced by Player::_addSpell(), Player::_addTalentAurasAndSpells(), Spell::_cast(), Spell::_handle_finish_phase(), AuraScript::_Validate(), Player::addTalent(), Spell::cancel(), Spell::CheckCast(), spell_dk_dancing_rune_weapon::CheckProc(), spell_dru_omen_of_clarity::CheckProc(), spell_gen_allow_proc_from_spells_with_cost::CheckProc(), spell_item_essence_of_life::CheckProc(), CheckTarget(), Spell::DoAllEffectOnTarget(), Spell::HandleLaunchPhase(), AuraEffect::HandleShapeshiftBoosts(), IsPassiveStackableWithRanks(), Player::LearnTalent(), spell_pal_glyph_of_divinity::OnProc(), Spell::prepare(), spell_gen_mounted_charge::Register(), Player::removeSpell(), Player::resetTalents(), Player::RewardQuest(), Spell::SelectExplicitTargets(), Spell::SelectImplicitCasterDestTargets(), Spell::SendSpellGo(), Spell::Spell(), WorldObject::SpellHitResult(), WorldObject::SpellHitResult(), and PetAI::UpdateAI().

◆ HasEffectMechanic()

bool SpellInfo::HasEffectMechanic ( Mechanics mechanic ) const

{
    for (auto const& effect : Effects)
        if (effect.Mechanic == mechanic)
            return true;
 
    return false;
}

References Effects.

Referenced by spell_warr_heroic_strike::HandleOnHit(), and Unit::RemoveMovementImpairingAuras().

◆ HasInitialAggro()

bool SpellInfo::HasInitialAggro ( ) const

{
    return !(HasAttribute(SPELL_ATTR1_NO_THREAT) || HasAttribute(SPELL_ATTR3_SUPPRESS_TARGET_PROCS));
}

References HasAttribute(), SPELL_ATTR1_NO_THREAT, and SPELL_ATTR3_SUPPRESS_TARGET_PROCS.

Referenced by Unit::CalcAbsorbResist(), Unit::DealDamage(), Spell::DoAllEffectOnTarget(), and Spell::HandleLaunchPhase().

◆ HasOnlyDamageEffects()

bool SpellInfo::HasOnlyDamageEffects ( ) const

{
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (Effects[i].IsEffect())
        {
            switch (Effects[i].Effect)
            {
                case SPELL_EFFECT_SCHOOL_DAMAGE:
                case SPELL_EFFECT_HEALTH_LEECH:
                case SPELL_EFFECT_POWER_DRAIN:
                case SPELL_EFFECT_POWER_BURN:
                case SPELL_EFFECT_NORMALIZED_WEAPON_DMG:
                case SPELL_EFFECT_WEAPON_PERCENT_DAMAGE:
                    continue;
                default:
                    return false;
            }
        }
    }
    return true;
}

References Effects, MAX_SPELL_EFFECTS, SPELL_EFFECT_HEALTH_LEECH, SPELL_EFFECT_NORMALIZED_WEAPON_DMG, SPELL_EFFECT_POWER_BURN, SPELL_EFFECT_POWER_DRAIN, SPELL_EFFECT_SCHOOL_DAMAGE, and SPELL_EFFECT_WEAPON_PERCENT_DAMAGE.

Referenced by WorldObject::SpellHitResult().

◆ IsAbilityLearnedWithProfession()

bool SpellInfo::IsAbilityLearnedWithProfession ( ) const

{
    SkillLineAbilityMapBounds bounds = sSpellMgr->GetSkillLineAbilityMapBounds(Id);
 
    for (SkillLineAbilityMap::const_iterator _spell_idx = bounds.first; _spell_idx != bounds.second; ++_spell_idx)
    {
        SkillLineAbilityEntry const* pAbility = _spell_idx->second;
        if (!pAbility || pAbility->AcquireMethod != SKILL_LINE_ABILITY_LEARNED_ON_SKILL_VALUE)
            continue;
 
        if (pAbility->MinSkillLineRank > 0)
            return true;
    }
 
    return false;
}

References SkillLineAbilityEntry::AcquireMethod, Id, SkillLineAbilityEntry::MinSkillLineRank, SKILL_LINE_ABILITY_LEARNED_ON_SKILL_VALUE, and sSpellMgr.

Referenced by ComputeIsStackableWithRanks().

◆ IsAbilityOfSkillType()

bool SpellInfo::IsAbilityOfSkillType ( uint32 skillType ) const

{
    SkillLineAbilityMapBounds bounds = sSpellMgr->GetSkillLineAbilityMapBounds(Id);
 
    for (SkillLineAbilityMap::const_iterator _spell_idx = bounds.first; _spell_idx != bounds.second; ++_spell_idx)
        if (_spell_idx->second->SkillLine == uint32(skillType))
            return true;
 
    return false;
}

References Id, and sSpellMgr.

Referenced by Spell::CanOpenLock(), learn_commandscript::HandleLearnAllGMCommand(), and Item::IsFitToSpellRequirements().

◆ IsActionAllowedChannel()

bool SpellInfo::IsActionAllowedChannel ( ) const

{
    return IsChanneled() && HasAttribute(SPELL_ATTR5_ALLOW_ACTION_DURING_CHANNEL);
}

References HasAttribute(), IsChanneled(), and SPELL_ATTR5_ALLOW_ACTION_DURING_CHANNEL.

Referenced by WorldSession::HandlePetActionHelper(), Creature::IsMovementPreventedByCasting(), Spell::prepare(), Unit::SetCurrentCastedSpell(), and PetAI::UpdateAI().

◆ IsAffected()

bool SpellInfo::IsAffected	(	uint32	familyName,
		flag96 const &	familyFlags
	)		const

{
    if (!familyName)
        return true;
 
    if (familyName != SpellFamilyName)
        return false;
 
    if (familyFlags && !(familyFlags & SpellFamilyFlags))
        return false;
 
    return true;
}

References SpellFamilyFlags, and SpellFamilyName.

Referenced by IsAffectedBySpellMod(), and AuraEffect::IsAffectedOnSpell().

◆ IsAffectedBySpellMod()

bool SpellInfo::IsAffectedBySpellMod ( SpellModifier const * mod ) const

{
    // xinef: dont check duration mod
    if (mod->op != SPELLMOD_DURATION)
        if (!IsAffectedBySpellMods())
            return false;
 
    SpellInfo const* affectSpell = sSpellMgr->GetSpellInfo(mod->spellId);
 
    if (!affectSpell)
        return false;
 
    if (!sScriptMgr->OnIsAffectedBySpellModCheck(affectSpell, this, mod))
        return true;
 
    return IsAffected(affectSpell->SpellFamilyName, mod->mask);
}

References IsAffected(), IsAffectedBySpellMods(), SpellModifier::mask, SpellModifier::op, SpellFamilyName, SpellModifier::spellId, SPELLMOD_DURATION, sScriptMgr, and sSpellMgr.

Referenced by AuraEffect::ApplySpellMod(), and Player::IsAffectedBySpellmod().

◆ IsAffectedBySpellMods()

bool SpellInfo::IsAffectedBySpellMods ( ) const

{
    return !(AttributesEx3 & SPELL_ATTR3_IGNORE_CASTER_MODIFIERS);
}

References AttributesEx3, and SPELL_ATTR3_IGNORE_CASTER_MODIFIERS.

Referenced by IsAffectedBySpellMod().

◆ IsAffectingArea()

bool SpellInfo::IsAffectingArea ( ) const

{
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if (Effects[i].IsEffect() && (Effects[i].IsTargetingArea() || Effects[i].IsEffect(SPELL_EFFECT_PERSISTENT_AREA_AURA) || Effects[i].IsAreaAuraEffect()))
            return true;
    return false;
}

References Effects, IsTargetingArea(), MAX_SPELL_EFFECTS, and SPELL_EFFECT_PERSISTENT_AREA_AURA.

Referenced by Unit::_IsValidAssistTarget(), Unit::_IsValidAttackTarget(), CanBeRedirectedBySpellMagnet(), Unit::IsAreaEffectPvPBlocked(), and WorldObject::MagicSpellHitResult().

◆ IsAllowingDeadTarget()

bool SpellInfo::IsAllowingDeadTarget ( ) const

{
    return AttributesEx2 & SPELL_ATTR2_ALLOW_DEAD_TARGET || Targets & (TARGET_FLAG_CORPSE_ALLY | TARGET_FLAG_CORPSE_ENEMY | TARGET_FLAG_UNIT_DEAD);
}

References AttributesEx2, SPELL_ATTR2_ALLOW_DEAD_TARGET, TARGET_FLAG_CORPSE_ALLY, TARGET_FLAG_CORPSE_ENEMY, and TARGET_FLAG_UNIT_DEAD.

Referenced by Unit::_CreateAuraApplication(), Unit::_IsValidAssistTarget(), Unit::_IsValidAttackTarget(), CheckTarget(), and Spell::IsValidDeadOrAliveTarget().

◆ IsAuraEffectEqual()

bool SpellInfo::IsAuraEffectEqual ( SpellInfo const * otherSpellInfo ) const

{
    uint8 matchCount = 0;
    uint8 auraCount = 0;
    for (uint8 i = EFFECT_0; i < MAX_SPELL_EFFECTS; ++i)
    {
        // xinef: skip non-aura efects
        if (!Effects[i].IsAura())
            continue;
 
        bool effectFound = false;
        for (uint8 j = EFFECT_0; j < MAX_SPELL_EFFECTS; ++j)
        {
            if (!otherSpellInfo->Effects[j].IsAura())
                continue;
 
            if (Effects[i].ApplyAuraName != otherSpellInfo->Effects[j].ApplyAuraName || Effects[i].MiscValue != otherSpellInfo->Effects[j].MiscValue)
                continue;
 
            effectFound = true;
            break;
        }
 
        if (!effectFound)
            return false;
        ++matchCount;
    }
 
    for (uint8 i = EFFECT_0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (Effects[i].IsAura())
            ++auraCount;
        if (otherSpellInfo->Effects[i].IsAura())
            ++auraCount;
    }
 
    return matchCount * 2 == auraCount;
}

References EFFECT_0, Effects, and MAX_SPELL_EFFECTS.

Referenced by Spell::DoAllEffectOnTarget().

◆ IsAuraExclusiveBySpecificPerCasterWith()

bool SpellInfo::IsAuraExclusiveBySpecificPerCasterWith ( SpellInfo const * spellInfo ) const

{
    SpellSpecificType spellSpec = GetSpellSpecific();
    switch (spellSpec)
    {
        case SPELL_SPECIFIC_SEAL:
        case SPELL_SPECIFIC_HAND:
        case SPELL_SPECIFIC_AURA:
        case SPELL_SPECIFIC_STING:
        case SPELL_SPECIFIC_CURSE:
        case SPELL_SPECIFIC_ASPECT:
        case SPELL_SPECIFIC_JUDGEMENT:
        case SPELL_SPECIFIC_WARLOCK_CORRUPTION:
            return spellSpec == spellInfo->GetSpellSpecific();
        default:
            return false;
    }
}

References GetSpellSpecific(), SPELL_SPECIFIC_ASPECT, SPELL_SPECIFIC_AURA, SPELL_SPECIFIC_CURSE, SPELL_SPECIFIC_HAND, SPELL_SPECIFIC_JUDGEMENT, SPELL_SPECIFIC_SEAL, SPELL_SPECIFIC_STING, and SPELL_SPECIFIC_WARLOCK_CORRUPTION.

Referenced by Aura::CanStackWith().

◆ IsAuraExclusiveBySpecificWith()

bool SpellInfo::IsAuraExclusiveBySpecificWith ( SpellInfo const * spellInfo ) const

{
    SpellSpecificType spellSpec1 = GetSpellSpecific();
    SpellSpecificType spellSpec2 = spellInfo->GetSpellSpecific();
 
    bool isExclusive = false;
 
    switch (spellSpec1)
    {
        case SPELL_SPECIFIC_TRACKER:
        case SPELL_SPECIFIC_WARLOCK_ARMOR:
        case SPELL_SPECIFIC_MAGE_ARMOR:
        case SPELL_SPECIFIC_ELEMENTAL_SHIELD:
        case SPELL_SPECIFIC_MAGE_POLYMORPH:
        case SPELL_SPECIFIC_PRESENCE:
        case SPELL_SPECIFIC_CHARM:
        case SPELL_SPECIFIC_SCROLL:
        case SPELL_SPECIFIC_MAGE_ARCANE_BRILLANCE:
        case SPELL_SPECIFIC_PRIEST_DIVINE_SPIRIT:
            isExclusive = spellSpec1 == spellSpec2;
            break;
        case SPELL_SPECIFIC_FOOD:
            isExclusive = spellSpec2 == SPELL_SPECIFIC_FOOD
                || spellSpec2 == SPELL_SPECIFIC_FOOD_AND_DRINK;
            break;
        case SPELL_SPECIFIC_DRINK:
            isExclusive = spellSpec2 == SPELL_SPECIFIC_DRINK
                || spellSpec2 == SPELL_SPECIFIC_FOOD_AND_DRINK;
            break;
        case SPELL_SPECIFIC_FOOD_AND_DRINK:
            isExclusive = spellSpec2 == SPELL_SPECIFIC_FOOD
                || spellSpec2 == SPELL_SPECIFIC_DRINK
                || spellSpec2 == SPELL_SPECIFIC_FOOD_AND_DRINK;
            break;
        default:
            break;
    }
 
    sScriptMgr->OnIsAuraExclusiveBySpecificWith(this, spellInfo, isExclusive);
 
    return isExclusive;
}

References GetSpellSpecific(), SPELL_SPECIFIC_CHARM, SPELL_SPECIFIC_DRINK, SPELL_SPECIFIC_ELEMENTAL_SHIELD, SPELL_SPECIFIC_FOOD, SPELL_SPECIFIC_FOOD_AND_DRINK, SPELL_SPECIFIC_MAGE_ARCANE_BRILLANCE, SPELL_SPECIFIC_MAGE_ARMOR, SPELL_SPECIFIC_MAGE_POLYMORPH, SPELL_SPECIFIC_PRESENCE, SPELL_SPECIFIC_PRIEST_DIVINE_SPIRIT, SPELL_SPECIFIC_SCROLL, SPELL_SPECIFIC_TRACKER, SPELL_SPECIFIC_WARLOCK_ARMOR, and sScriptMgr.

Referenced by Aura::CanStackWith().

◆ IsAutocastable()

bool SpellInfo::IsAutocastable ( ) const

{
    if (HasAttribute(SPELL_ATTR0_PASSIVE))
        return false;
    if (HasAttribute(SPELL_ATTR1_NO_AUTOCAST_AI))
        return false;
    return true;
}

References HasAttribute(), SPELL_ATTR0_PASSIVE, and SPELL_ATTR1_NO_AUTOCAST_AI.

Referenced by Pet::addSpell(), CharmInfo::AddSpellToActionBar(), WorldSession::HandlePetSpellAutocastOpcode(), CharmInfo::InitCharmCreateSpells(), CharmInfo::LoadPetActionBar(), and Pet::ToggleAutocast().

◆ IsAutoRepeatRangedSpell()

bool SpellInfo::IsAutoRepeatRangedSpell ( ) const

{
    return AttributesEx2 & SPELL_ATTR2_AUTO_REPEAT;
}

References AttributesEx2, and SPELL_ATTR2_AUTO_REPEAT.

Referenced by Player::AddSpellAndCategoryCooldowns(), CalcCastTime(), WorldSession::HandleCastSpellOpcode(), Spell::SendSpellGo(), Spell::SendSpellStart(), and Spell::Spell().

◆ IsBreakingStealth()

bool SpellInfo::IsBreakingStealth ( ) const

{
    return !(AttributesEx & SPELL_ATTR1_ALLOW_WHILE_STEALTHED);
}

References AttributesEx, and SPELL_ATTR1_ALLOW_WHILE_STEALTHED.

Referenced by Spell::prepare().

◆ IsChannelCategorySpell()

bool SpellInfo::IsChannelCategorySpell ( ) const

{
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if (Effects[i].TargetA.GetSelectionCategory() == TARGET_SELECT_CATEGORY_CHANNEL || Effects[i].TargetB.GetSelectionCategory() == TARGET_SELECT_CATEGORY_CHANNEL)
            return true;
    return false;
}

References Effects, MAX_SPELL_EFFECTS, and TARGET_SELECT_CATEGORY_CHANNEL.

Referenced by AuraEffect::HandlePeriodicTriggerSpellAuraTick().

◆ IsChanneled()

bool SpellInfo::IsChanneled ( ) const

{
    return (AttributesEx & (SPELL_ATTR1_IS_CHANNELED | SPELL_ATTR1_IS_SELF_CHANNELED));
}

References AttributesEx, SPELL_ATTR1_IS_CHANNELED, and SPELL_ATTR1_IS_SELF_CHANNELED.

Referenced by Spell::_cast(), Unit::CalculateDefaultCoefficient(), Spell::cancel(), Aura::CanStackWith(), spell_item_meteoric_inspiration::CheckProc(), Spell::finish(), Unit::GetCastingTimeForBonus(), Spell::GetCurrentContainer(), Spell::handle_immediate(), WorldSession::HandleCancelAuraOpcode(), WorldSession::HandlePetActionHelper(), IsActionAllowedChannel(), Spell::IsNeedSendToClient(), WorldObject::ModSpellCastTime(), NeedsToBeTriggeredByCaster(), AuraEffect::PeriodicTick(), Spell::prepare(), Spell::SelectSpellTargets(), Spell::SendSpellGo(), Spell::SendSpellStart(), and PetAI::UpdateAI().

◆ IsCooldownStartedOnEvent()

bool SpellInfo::IsCooldownStartedOnEvent ( ) const

{
    return HasAttribute(SPELL_ATTR0_COOLDOWN_ON_EVENT) || (CategoryEntry && CategoryEntry->Flags & SPELL_CATEGORY_FLAG_COOLDOWN_STARTS_ON_EVENT);
}

References CategoryEntry, SpellCategoryEntry::Flags, HasAttribute(), SPELL_ATTR0_COOLDOWN_ON_EVENT, and SPELL_CATEGORY_FLAG_COOLDOWN_STARTS_ON_EVENT.

Referenced by Aura::_ApplyForTarget(), Spell::_handle_finish_phase(), Aura::_UnapplyForTarget(), Unit::AddGameObject(), Player::AddSpellAndCategoryCooldowns(), Spell::cancel(), Pet::CastPendingSpell(), Spell::CheckCast(), Spell::finish(), WorldSession::HandlePetActionHelper(), Player::ProhibitSpellSchool(), Unit::RemoveGameObject(), Spell::SendSpellCooldown(), and Unit::SetMinion().

◆ IsCritCapable()

bool SpellInfo::IsCritCapable ( ) const

{
    return _isCritCapable;
}

References _isCritCapable.

Referenced by Unit::SpellDoneCritChance(), and Unit::SpellTakenCritChance().

◆ IsDeathPersistent()

bool SpellInfo::IsDeathPersistent ( ) const

{
    return AttributesEx3 & SPELL_ATTR3_ALLOW_AURA_WHILE_DEAD;
}

References AttributesEx3, and SPELL_ATTR3_ALLOW_AURA_WHILE_DEAD.

Referenced by Unit::_CreateAuraApplication(), CheckTarget(), and Aura::IsDeathPersistent().

◆ IsDifferentRankOf()

bool SpellInfo::IsDifferentRankOf ( SpellInfo const * spellInfo ) const

{
    if (Id == spellInfo->Id)
        return false;
    return IsRankOf(spellInfo);
}

References Id, and IsRankOf().

Referenced by Pet::addSpell(), and Aura::CanStackWith().

◆ IsExplicitDiscovery()

bool SpellInfo::IsExplicitDiscovery ( ) const

{
    return ((Effects[0].Effect == SPELL_EFFECT_CREATE_RANDOM_ITEM
             || Effects[0].Effect == SPELL_EFFECT_CREATE_ITEM_2)
            && Effects[1].Effect == SPELL_EFFECT_SCRIPT_EFFECT)
           || Id == 64323;
}

References Effects, Id, SPELL_EFFECT_CREATE_ITEM_2, SPELL_EFFECT_CREATE_RANDOM_ITEM, and SPELL_EFFECT_SCRIPT_EFFECT.

Referenced by LoadSkillDiscoveryTable().

◆ IsHighRankOf()

bool SpellInfo::IsHighRankOf ( SpellInfo const * spellInfo ) const

{
    if (ChainEntry && spellInfo->ChainEntry)
    {
        if (ChainEntry->first == spellInfo->ChainEntry->first)
            if (ChainEntry->rank > spellInfo->ChainEntry->rank)
                return true;
    }
    return false;
}

References ChainEntry, SpellChainNode::first, and SpellChainNode::rank.

Referenced by Pet::addSpell(), and Player::PrepareCharmAISpells().

◆ IsLootCrafting()

bool SpellInfo::IsLootCrafting ( ) const

{
    return (Effects[0].Effect == SPELL_EFFECT_CREATE_RANDOM_ITEM ||
            // different random cards from Inscription (121==Virtuoso Inking Set category) r without explicit item
            (Effects[0].Effect == SPELL_EFFECT_CREATE_ITEM_2 &&
             ((TotemCategory[0] != 0 || (Totem[0] != 0 && SpellIconID == 1)) || Effects[0].ItemType == 0)));
}

References Effects, SPELL_EFFECT_CREATE_ITEM_2, SPELL_EFFECT_CREATE_RANDOM_ITEM, and SpellIconID.

Referenced by SpellMgr::ComputeIsSpellValid(), Spell::EffectCreateItem2(), and LoadLootTemplates_Spell().

◆ IsMultiSlotAura()

bool SpellInfo::IsMultiSlotAura ( ) const

{
    return IsPassive() || Id == 40075; // No other way to make 40075 have more than 1 copy of aura
}

References Id, and IsPassive().

Referenced by Unit::_TryStackingOrRefreshingExistingAura(), and Aura::CanStackWith().

◆ IsPassive()

bool SpellInfo::IsPassive ( ) const

{
    return HasAttribute(SPELL_ATTR0_PASSIVE);
}

References HasAttribute(), and SPELL_ATTR0_PASSIVE.

Referenced by Player::_addSpell(), Player::_addTalentAurasAndSpells(), Unit::_TryStackingOrRefreshingExistingAura(), Pet::addSpell(), ApplyAllSpellImmunitiesTo(), Player::ApplyItemDependentAuras(), CanDispelAura(), Spell::CheckCast(), spell_dru_omen_of_clarity::CheckProc(), ComputeIsStackableWithRanks(), UnitAI::FillAISpellInfo(), WorldSession::HandleCancelAuraOpcode(), WorldSession::HandleCastSpellOpcode(), lookup_commandscript::HandleLookupSpellCommand(), lookup_commandscript::HandleLookupSpellIdCommand(), WorldSession::HandlePetActionHelper(), WorldSession::HandlePetCastSpellOpcode(), spell_gen_clear_debuffs::HandleScript(), Player::HasItemFitToSpellRequirements(), CharmInfo::InitCharmCreateSpells(), npc_oathbound_warder::InitializeAI(), CharmInfo::InitPossessCreateSpells(), IsMultiSlotAura(), Aura::IsPassive(), IsPassiveStackableWithRanks(), Spell::prepare(), Player::PrepareCharmAISpells(), Spell::SendSpellCooldown(), Spell::Spell(), CharmInfo::ToggleCreatureAutocast(), and Player::VehicleSpellInitialize().

◆ IsPassiveStackableWithRanks()

bool SpellInfo::IsPassiveStackableWithRanks ( ) const

{
    return IsPassive() && !HasEffect(SPELL_EFFECT_APPLY_AURA);
}

References HasEffect(), IsPassive(), and SPELL_EFFECT_APPLY_AURA.

◆ IsPositive()

bool SpellInfo::IsPositive ( ) const

{
    return !(AttributesCu & SPELL_ATTR0_CU_NEGATIVE) || (AttributesCu & SPELL_ATTR0_CU_POSITIVE);
}

References AttributesCu, SPELL_ATTR0_CU_NEGATIVE, and SPELL_ATTR0_CU_POSITIVE.

Referenced by Spell::_cast(), Spell::_handle_finish_phase(), Pet::_SaveAuras(), Player::CastItemCombatSpell(), spell_item_luffa::CheckCast(), Spell::CheckCast(), spell_dk_dancing_rune_weapon::CheckProc(), spell_pal_spiritual_attunement::CheckProc(), CheckTarget(), Spell::DoAllEffectOnTarget(), Spell::DoSpellHitOnUnit(), Spell::EffectCharge(), UnitAI::FillAISpellInfo(), GetDiminishingReturnsGroupForSpell(), spell_rog_deadly_poison::HandleAfterHit(), AuraEffect::HandleAuraModSchoolImmunity(), AuraEffect::HandleAuraTransform(), WorldSession::HandleCancelAuraOpcode(), WorldSession::HandleCastSpellOpcode(), spell_item_luffa::HandleEffect(), Spell::HandleLaunchPhase(), WorldSession::HandlePetActionHelper(), ArenaSpectator::HandleResetCommand(), spell_gen_clear_debuffs::HandleScript(), Unit::HasSchoolImmunityForMask(), SmartAI::InitializeAI(), GameObject::IsAtInteractDistance(), Totem::IsImmunedToSpellEffect(), WorldObject::MagicSpellHitResult(), Unit::PetSpellFail(), Spell::prepare(), Spell::PrepareTriggersExecutedOnHit(), Spell::SelectExplicitTargets(), Spell::SelectImplicitNearbyTargets(), ArenaSpectator::ShouldSendAura(), Spell::Spell(), WorldObject::SpellHitResult(), WorldObject::SpellHitResult(), Unit::SpellTakenCritChance(), PetAI::UpdateAI(), and Spell::UpdateChanneledTargetList().

◆ IsPositiveEffect()

bool SpellInfo::IsPositiveEffect ( uint8 effIndex ) const

{
    switch (effIndex)
    {
        default:
        case 0:
            return !(AttributesCu & SPELL_ATTR0_CU_NEGATIVE_EFF0) || (AttributesCu & SPELL_ATTR0_CU_POSITIVE_EFF0);
        case 1:
            return !(AttributesCu & SPELL_ATTR0_CU_NEGATIVE_EFF1) || (AttributesCu & SPELL_ATTR0_CU_POSITIVE_EFF1);
        case 2:
            return !(AttributesCu & SPELL_ATTR0_CU_NEGATIVE_EFF2) || (AttributesCu & SPELL_ATTR0_CU_POSITIVE_EFF2);
    }
}

References AttributesCu, SPELL_ATTR0_CU_NEGATIVE_EFF0, SPELL_ATTR0_CU_NEGATIVE_EFF1, SPELL_ATTR0_CU_NEGATIVE_EFF2, SPELL_ATTR0_CU_POSITIVE_EFF0, SPELL_ATTR0_CU_POSITIVE_EFF1, and SPELL_ATTR0_CU_POSITIVE_EFF2.

Referenced by CanSpellProvideImmunityAgainstAura(), Spell::DoAllEffectOnTarget(), GetAuraRankForLevel(), and Spell::prepare().

◆ IsPrimaryProfession()

bool SpellInfo::IsPrimaryProfession ( ) const

{
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (Effects[i].Effect == SPELL_EFFECT_SKILL)
        {
            uint32 skill = Effects[i].MiscValue;
 
            if (IsPrimaryProfessionSkill(skill))
                return true;
        }
    }
    return false;
}

References Effects, IsPrimaryProfessionSkill(), MAX_SPELL_EFFECTS, and SPELL_EFFECT_SKILL.

Referenced by IsPrimaryProfessionFirstRank().

◆ IsPrimaryProfessionFirstRank()

bool SpellInfo::IsPrimaryProfessionFirstRank ( ) const

{
    return IsPrimaryProfession() && GetRank() == 1;
}

References GetRank(), and IsPrimaryProfession().

Referenced by Player::_addSpell(), Trainer::Trainer::CanTeachSpell(), Player::removeSpell(), and Trainer::Trainer::SendSpells().

◆ IsProfession()

bool SpellInfo::IsProfession ( ) const

{
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (Effects[i].Effect == SPELL_EFFECT_SKILL)
        {
            uint32 skill = Effects[i].MiscValue;
 
            if (IsProfessionSkill(skill))
                return true;
        }
    }
    return false;
}

References Effects, IsProfessionSkill(), MAX_SPELL_EFFECTS, and SPELL_EFFECT_SKILL.

◆ IsProfessionOrRiding()

bool SpellInfo::IsProfessionOrRiding ( ) const

{
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (Effects[i].Effect == SPELL_EFFECT_SKILL)
        {
            uint32 skill = Effects[i].MiscValue;
 
            if (IsProfessionOrRidingSkill(skill))
                return true;
        }
    }
    return false;
}

References Effects, IsProfessionOrRidingSkill(), MAX_SPELL_EFFECTS, and SPELL_EFFECT_SKILL.

Referenced by ComputeIsStackableWithRanks().

◆ IsQuestTame()

bool SpellInfo::IsQuestTame ( ) const

{
    return Effects[0].Effect == SPELL_EFFECT_THREAT && Effects[1].Effect == SPELL_EFFECT_APPLY_AURA && Effects[1].ApplyAuraName == SPELL_AURA_DUMMY;
}

References Effects, SPELL_AURA_DUMMY, SPELL_EFFECT_APPLY_AURA, and SPELL_EFFECT_THREAT.

◆ IsRangedWeaponSpell()

bool SpellInfo::IsRangedWeaponSpell ( ) const

{
    return (SpellFamilyName == SPELLFAMILY_HUNTER && !(SpellFamilyFlags[1] & 0x10000000)) // for 53352, cannot find better way
           || (EquippedItemSubClassMask & ITEM_SUBCLASS_MASK_WEAPON_RANGED)
           || (HasAttribute(SPELL_ATTR0_USES_RANGED_SLOT)); // Xinef: added
}

References EquippedItemSubClassMask, HasAttribute(), ITEM_SUBCLASS_MASK_WEAPON_RANGED, SPELL_ATTR0_USES_RANGED_SLOT, SPELLFAMILY_HUNTER, SpellFamilyFlags, and SpellFamilyName.

Referenced by Aura::CalcProcChance(), Spell::handle_immediate(), Unit::MeleeSpellHitResult(), Spell::Spell(), Unit::SpellDamageBonusDone(), and Unit::SpellHealingBonusDone().

◆ IsRanked()

bool SpellInfo::IsRanked ( ) const

{
    return ChainEntry != nullptr;
}

References ChainEntry.

Referenced by Pet::addSpell(), Player::addSpell(), and Player::IsUnlearnNeededForSpell().

◆ IsRankOf()

bool SpellInfo::IsRankOf ( SpellInfo const * spellInfo ) const

{
    return GetFirstRankSpell() == spellInfo->GetFirstRankSpell();
}

References GetFirstRankSpell().

Referenced by Aura::CanStackWith(), spell_pal_light_s_beacon::HandleProc(), IsDifferentRankOf(), spell_item_meteoric_inspiration::IsPenanceChannel(), spell_dk_will_of_the_necropolis::Validate(), spell_pal_holy_shock::Validate(), spell_pri_penance::Validate(), and spell_sha_fire_nova::Validate().

◆ IsRequiringDeadTarget()

bool SpellInfo::IsRequiringDeadTarget ( ) const

{
    return AttributesEx3 & SPELL_ATTR3_ONLY_ON_GHOSTS;
}

References AttributesEx3, and SPELL_ATTR3_ONLY_ON_GHOSTS.

Referenced by CheckTarget(), Spell::IsValidDeadOrAliveTarget(), and Unit::RemoveAllAurasRequiringDeadTarget().

◆ IsSelfCast()

bool SpellInfo::IsSelfCast ( ) const

{
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if (Effects[i].Effect && Effects[i].TargetA.GetTarget() != TARGET_UNIT_CASTER)
            return false;
    return true;
}

References Effects, MAX_SPELL_EFFECTS, and TARGET_UNIT_CASTER.

Referenced by Spell::CheckCast(), and Player::RewardQuest().

◆ IsSingleTarget()

bool SpellInfo::IsSingleTarget ( ) const

{
    // all other single target spells have if it has AttributesEx5
    if (AttributesEx5 & SPELL_ATTR5_LIMIT_N)
        return true;
 
    return false;
}

References AttributesEx5, and SPELL_ATTR5_LIMIT_N.

Referenced by Unit::_AddAura(), and Aura::Create().

◆ IsSpellValid()

bool SpellInfo::IsSpellValid ( ) const

{
    return _isSpellValid;
}

References _isSpellValid.

Referenced by SpellMgr::IsSpellValid().

◆ IsStackableWithRanks()

bool SpellInfo::IsStackableWithRanks ( ) const

{
    return _isStackableWithRanks;
}

References _isStackableWithRanks.

Referenced by Player::addSpell(), and Player::IsUnlearnNeededForSpell().

◆ IsTargetingArea()

bool SpellInfo::IsTargetingArea ( ) const

{
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        if (Effects[i].IsEffect() && Effects[i].IsTargetingArea())
            return true;
    return false;
}

References Effects, IsTargetingArea(), and MAX_SPELL_EFFECTS.

Referenced by Spell::CheckCast(), spell_dk_dancing_rune_weapon::CheckProc(), spell_gen_proc_from_direct_damage::CheckProc(), Spell::HandleLaunchPhase(), IsAffectingArea(), IsTargetingArea(), and npc_oculus_drake::npc_oculus_drakeAI::SpellHitTarget().

◆ LoadAuraState()

AuraStateType SpellInfo::LoadAuraState ( ) const

{
    // Seals
    if (GetSpellSpecific() == SPELL_SPECIFIC_SEAL)
        return AURA_STATE_JUDGEMENT;
 
    // Conflagrate aura state on Immolate and Shadowflame
    if (SpellFamilyName == SPELLFAMILY_WARLOCK &&
            // Immolate
            ((SpellFamilyFlags[0] & 4) ||
             // Shadowflame
             (SpellFamilyFlags[2] & 2)))
        return AURA_STATE_CONFLAGRATE;
 
    // Faerie Fire (druid versions)
    if (SpellFamilyName == SPELLFAMILY_DRUID && SpellFamilyFlags[0] & 0x400)
        return AURA_STATE_FAERIE_FIRE;
 
    // Sting (hunter's pet ability)
    if (GetCategory() == 1133)
        return AURA_STATE_FAERIE_FIRE;
 
    // Victorious
    if (SpellFamilyName == SPELLFAMILY_WARRIOR &&  SpellFamilyFlags[1] & 0x00040000)
        return AURA_STATE_WARRIOR_VICTORY_RUSH;
 
    // Swiftmend state on Regrowth & Rejuvenation
    if (SpellFamilyName == SPELLFAMILY_DRUID && SpellFamilyFlags[0] & 0x50)
        return AURA_STATE_SWIFTMEND;
 
    // Deadly poison aura state
    if (SpellFamilyName == SPELLFAMILY_ROGUE && SpellFamilyFlags[0] & 0x10000)
        return AURA_STATE_DEADLY_POISON;
 
    // Enrage aura state
    if (Dispel == DISPEL_ENRAGE)
        return AURA_STATE_ENRAGE;
 
    // Bleeding aura state
    if (GetAllEffectsMechanicMask() & (1ULL << MECHANIC_BLEED))
        return AURA_STATE_BLEEDING;
 
    // Banished aura state
    if (Mechanic == MECHANIC_BANISH)
        return AURA_STATE_BANISHED;
 
    if (GetSchoolMask() & SPELL_SCHOOL_MASK_FROST)
        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
            if (Effects[i].IsAura() && (Effects[i].ApplyAuraName == SPELL_AURA_MOD_STUN
                                        || Effects[i].ApplyAuraName == SPELL_AURA_MOD_ROOT))
                return AURA_STATE_FROZEN;
 
    switch (Id)
    {
        case 71465: // Divine Surge
        case 50241: // Oculus, Drake spell Evasive Maneuvers
            return AURA_STATE_UNKNOWN22;
        case 9991:  // Touch of Zanzil
        case 35331: // Black Blood
        case 9806:  // Phantom Strike
        case 35325: // Glowing Blood
        case 35328: // Lambent Blood
        case 35329: // Vibrant Blood
        case 16498: // Faerie Fire
        case 6950:
        case 20656:
        case 25602:
        case 32129:
        case 49163: // Perpetual Instability (Element 115)
            return AURA_STATE_FAERIE_FIRE;
        default:
            break;
    }
 
    return AURA_STATE_NONE;
}

References AURA_STATE_BANISHED, AURA_STATE_BLEEDING, AURA_STATE_CONFLAGRATE, AURA_STATE_DEADLY_POISON, AURA_STATE_ENRAGE, AURA_STATE_FAERIE_FIRE, AURA_STATE_FROZEN, AURA_STATE_JUDGEMENT, AURA_STATE_NONE, AURA_STATE_SWIFTMEND, AURA_STATE_UNKNOWN22, AURA_STATE_WARRIOR_VICTORY_RUSH, Dispel, DISPEL_ENRAGE, Effects, GetAllEffectsMechanicMask(), GetCategory(), GetSchoolMask(), GetSpellSpecific(), Id, MAX_SPELL_EFFECTS, Mechanic, MECHANIC_BANISH, MECHANIC_BLEED, SPELL_AURA_MOD_ROOT, SPELL_AURA_MOD_STUN, SPELL_SCHOOL_MASK_FROST, SPELL_SPECIFIC_SEAL, SPELLFAMILY_DRUID, SPELLFAMILY_ROGUE, SPELLFAMILY_WARLOCK, SPELLFAMILY_WARRIOR, SpellFamilyFlags, and SpellFamilyName.

Referenced by SpellMgr::LoadSpellSpecificAndAuraState().

◆ LoadSpellSpecific()

SpellSpecificType SpellInfo::LoadSpellSpecific ( ) const

@workaround For non-stacking tracking spells (We need generic solution)

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

{
    switch (SpellFamilyName)
    {
        case SPELLFAMILY_GENERIC:
            {
                // Food / Drinks (mostly)
                if (AuraInterruptFlags & AURA_INTERRUPT_FLAG_NOT_SEATED)
                {
                    bool food = false;
                    bool drink = false;
                    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
                    {
                        if (!Effects[i].IsAura())
                            continue;
                        switch (Effects[i].ApplyAuraName)
                        {
                            // Food
                            case SPELL_AURA_MOD_REGEN:
                            case SPELL_AURA_OBS_MOD_HEALTH:
                                food = true;
                                break;
                            // Drink
                            case SPELL_AURA_MOD_POWER_REGEN:
                            case SPELL_AURA_OBS_MOD_POWER:
                                drink = true;
                                break;
                            default:
                                break;
                        }
                    }
 
                    if (food && drink)
                        return SPELL_SPECIFIC_FOOD_AND_DRINK;
                    else if (food)
                        return SPELL_SPECIFIC_FOOD;
                    else if (drink)
                        return SPELL_SPECIFIC_DRINK;
                }
                // scrolls effects
                else
                {
                    SpellInfo const* firstRankSpellInfo = GetFirstRankSpell();
                    switch (firstRankSpellInfo->Id)
                    {
                        case 8118: // Strength
                        case 8099: // Stamina
                        case 8112: // Spirit
                        case 8096: // Intellect
                        case 8115: // Agility
                        case 8091: // Armor
                            return SPELL_SPECIFIC_SCROLL;
                    }
                }
                break;
            }
        case SPELLFAMILY_MAGE:
            {
                // family flags 18(Molten), 25(Frost/Ice), 28(Mage)
                if (SpellFamilyFlags[0] & 0x12040000)
                    return SPELL_SPECIFIC_MAGE_ARMOR;
 
                // Arcane brillance and Arcane intelect (normal check fails because of flags difference)
                if (SpellFamilyFlags[0] & 0x400)
                    return SPELL_SPECIFIC_MAGE_ARCANE_BRILLANCE;
 
                if ((SpellFamilyFlags[0] & 0x1000000) && Effects[0].ApplyAuraName == SPELL_AURA_MOD_CONFUSE)
                    return SPELL_SPECIFIC_MAGE_POLYMORPH;
 
                break;
            }
        case SPELLFAMILY_WARLOCK:
            {
                // only warlock curses have this
                if (Dispel == DISPEL_CURSE)
                    return SPELL_SPECIFIC_CURSE;
 
                // Warlock (Demon Armor | Demon Skin | Fel Armor)
                if (SpellFamilyFlags[1] & 0x20000020 || SpellFamilyFlags[2] & 0x00000010)
                    return SPELL_SPECIFIC_WARLOCK_ARMOR;
 
                //seed of corruption and corruption
                if (SpellFamilyFlags[1] & 0x10 || SpellFamilyFlags[0] & 0x2)
                    return SPELL_SPECIFIC_WARLOCK_CORRUPTION;
                break;
            }
        case SPELLFAMILY_PRIEST:
            {
                // Divine Spirit and Prayer of Spirit
                if (SpellFamilyFlags[0] & 0x20)
                    return SPELL_SPECIFIC_PRIEST_DIVINE_SPIRIT;
 
                break;
            }
        case SPELLFAMILY_HUNTER:
            {
                // only hunter stings have this
                if (Dispel == DISPEL_POISON)
                    return SPELL_SPECIFIC_STING;
 
                // only hunter aspects have this (but not all aspects in hunter family)
                if (SpellFamilyFlags.HasFlag(0x00380000, 0x00440000, 0x00001010))
                    return SPELL_SPECIFIC_ASPECT;
 
                break;
            }
        case SPELLFAMILY_PALADIN:
            {
                // Collection of all the seal family flags. No other paladin spell has any of those.
                if (SpellFamilyFlags[1] & 0x26000C00
                        || SpellFamilyFlags[0] & 0x0A000000)
                    return SPELL_SPECIFIC_SEAL;
 
                if (SpellFamilyFlags[0] & 0x00002190)
                    return SPELL_SPECIFIC_HAND;
 
                // Judgement of Wisdom, Judgement of Light, Judgement of Justice
                if (Id == 20184 || Id == 20185 || Id == 20186)
                    return SPELL_SPECIFIC_JUDGEMENT;
 
                // only paladin auras have this (for palaldin class family)
                if (SpellFamilyFlags[2] & 0x00000020)
                    return SPELL_SPECIFIC_AURA;
 
                // Illidari Council Paladin (Gathios the Shatterer)
                if (Id == 41459 || Id == 41469)
                    return SPELL_SPECIFIC_SEAL;
 
                break;
            }
        case SPELLFAMILY_SHAMAN:
            {
                // family flags 10 (Lightning), 42 (Earth), 37 (Water), proc shield from T2 8 pieces bonus
                if (SpellFamilyFlags[1] & 0x420
                        || (SpellFamilyFlags[0] & 0x00000400 && HasAttribute(SPELL_ATTR1_NO_THREAT))
                        || Id == 23552)
                    return SPELL_SPECIFIC_ELEMENTAL_SHIELD;
 
                break;
            }
        case SPELLFAMILY_DEATHKNIGHT:
            if (Id == 48266 || Id == 48263 || Id == 48265)
                return SPELL_SPECIFIC_PRESENCE;
            break;
    }
 
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (Effects[i].Effect == SPELL_EFFECT_APPLY_AURA)
        {
            switch (Effects[i].ApplyAuraName)
            {
                case SPELL_AURA_MOD_CHARM:
                case SPELL_AURA_MOD_POSSESS_PET:
                case SPELL_AURA_MOD_POSSESS:
                case SPELL_AURA_AOE_CHARM:
                    return SPELL_SPECIFIC_CHARM;
                case SPELL_AURA_TRACK_CREATURES:
                    if (Id == 30645) // Gas Cloud Tracking
                        return SPELL_SPECIFIC_NORMAL;
                    [[fallthrough]]; 
                case SPELL_AURA_TRACK_RESOURCES:
                case SPELL_AURA_TRACK_STEALTHED:
                    return SPELL_SPECIFIC_TRACKER;
                default:
                    break;
            }
        }
    }
 
    return SPELL_SPECIFIC_NORMAL;
}

References AURA_INTERRUPT_FLAG_NOT_SEATED, AuraInterruptFlags, Dispel, DISPEL_CURSE, DISPEL_POISON, Effects, GetFirstRankSpell(), HasAttribute(), flag96::HasFlag(), Id, MAX_SPELL_EFFECTS, SPELL_ATTR1_NO_THREAT, SPELL_AURA_AOE_CHARM, SPELL_AURA_MOD_CHARM, SPELL_AURA_MOD_CONFUSE, SPELL_AURA_MOD_POSSESS, SPELL_AURA_MOD_POSSESS_PET, SPELL_AURA_MOD_POWER_REGEN, SPELL_AURA_MOD_REGEN, SPELL_AURA_OBS_MOD_HEALTH, SPELL_AURA_OBS_MOD_POWER, SPELL_AURA_TRACK_CREATURES, SPELL_AURA_TRACK_RESOURCES, SPELL_AURA_TRACK_STEALTHED, SPELL_EFFECT_APPLY_AURA, SPELL_SPECIFIC_ASPECT, SPELL_SPECIFIC_AURA, SPELL_SPECIFIC_CHARM, SPELL_SPECIFIC_CURSE, SPELL_SPECIFIC_DRINK, SPELL_SPECIFIC_ELEMENTAL_SHIELD, SPELL_SPECIFIC_FOOD, SPELL_SPECIFIC_FOOD_AND_DRINK, SPELL_SPECIFIC_HAND, SPELL_SPECIFIC_JUDGEMENT, SPELL_SPECIFIC_MAGE_ARCANE_BRILLANCE, SPELL_SPECIFIC_MAGE_ARMOR, SPELL_SPECIFIC_MAGE_POLYMORPH, SPELL_SPECIFIC_NORMAL, SPELL_SPECIFIC_PRESENCE, SPELL_SPECIFIC_PRIEST_DIVINE_SPIRIT, SPELL_SPECIFIC_SCROLL, SPELL_SPECIFIC_SEAL, SPELL_SPECIFIC_STING, SPELL_SPECIFIC_TRACKER, SPELL_SPECIFIC_WARLOCK_ARMOR, SPELL_SPECIFIC_WARLOCK_CORRUPTION, SPELLFAMILY_DEATHKNIGHT, SPELLFAMILY_GENERIC, SPELLFAMILY_HUNTER, SPELLFAMILY_MAGE, SPELLFAMILY_PALADIN, SPELLFAMILY_PRIEST, SPELLFAMILY_SHAMAN, SPELLFAMILY_WARLOCK, SpellFamilyFlags, and SpellFamilyName.

Referenced by SpellMgr::LoadSpellSpecificAndAuraState().

◆ NeedsComboPoints()

bool SpellInfo::NeedsComboPoints ( ) const

{
    return (AttributesEx & (SPELL_ATTR1_FINISHING_MOVE_DAMAGE | SPELL_ATTR1_FINISHING_MOVE_DURATION));
}

References AttributesEx, SPELL_ATTR1_FINISHING_MOVE_DAMAGE, and SPELL_ATTR1_FINISHING_MOVE_DURATION.

Referenced by Player::PrepareCharmAISpells(), and Spell::Spell().

◆ NeedsExplicitUnitTarget()

bool SpellInfo::NeedsExplicitUnitTarget ( ) const

{
    return GetExplicitTargetMask() & TARGET_FLAG_UNIT_MASK;
}

References GetExplicitTargetMask(), and TARGET_FLAG_UNIT_MASK.

Referenced by Spell::CheckCast(), Spell::CheckPetCast(), WorldSession::HandlePetCastSpellOpcode(), CharmInfo::InitCharmCreateSpells(), NeedsToBeTriggeredByCaster(), and Spell::SendChannelStart().

◆ NeedsToBeTriggeredByCaster()

bool SpellInfo::NeedsToBeTriggeredByCaster	(	SpellInfo const *	triggeringSpell,
		uint8	effIndex = `MAX_SPELL_EFFECTS`
	)		const

{
    if (NeedsExplicitUnitTarget())
        return true;
 
    // pussywizard:
    if (effIndex < MAX_SPELL_EFFECTS && (triggeringSpell->Effects[effIndex].TargetA.GetCheckType() == TARGET_CHECK_ENTRY || triggeringSpell->Effects[effIndex].TargetB.GetCheckType() == TARGET_CHECK_ENTRY))
    {
        // xinef:
        if (Id == 60563)
            return true;
 
        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
            if (Effects[i].IsEffect() && (Effects[i].TargetA.GetCheckType() == TARGET_CHECK_ENTRY || Effects[i].TargetB.GetCheckType() == TARGET_CHECK_ENTRY))
                return true;
    }
 
    /*
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (Effects[i].IsEffect())
        {
            if (Effects[i].TargetA.GetSelectionCategory() == TARGET_SELECT_CATEGORY_CHANNEL
                || Effects[i].TargetB.GetSelectionCategory() == TARGET_SELECT_CATEGORY_CHANNEL)
                return true;
        }
    }
    */
 
    if (triggeringSpell->IsChanneled())
    {
        uint32 mask = 0;
        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        {
            if (Effects[i].TargetA.GetTarget() != TARGET_UNIT_CASTER && Effects[i].TargetA.GetTarget() != TARGET_DEST_CASTER)
                mask |= Effects[i].GetProvidedTargetMask();
        }
 
        if (mask & TARGET_FLAG_UNIT_MASK)
            return true;
    }
 
    return false;
}

References Effects, Id, IsChanneled(), MAX_SPELL_EFFECTS, NeedsExplicitUnitTarget(), TARGET_CHECK_ENTRY, TARGET_DEST_CASTER, TARGET_FLAG_UNIT_MASK, and TARGET_UNIT_CASTER.

Referenced by Spell::EffectTriggerMissileSpell(), Spell::EffectTriggerSpell(), AuraEffect::HandleAuraLinked(), and AuraEffect::HandlePeriodicTriggerSpellAuraTick().

◆ RequireCooldownInfo()

bool SpellInfo::RequireCooldownInfo ( ) const

{
    return _requireCooldownInfo;
}

References _requireCooldownInfo.

Referenced by Spell::SendSpellCooldown().

◆ SetCritCapable()

void SpellInfo::SetCritCapable ( bool val )

{
    _isCritCapable = val;
}

References _isCritCapable.

◆ SetSpellValid()

void SpellInfo::SetSpellValid ( bool val )

{
    _isSpellValid = val;
}

References _isSpellValid.

◆ SetStackableWithRanks()

void SpellInfo::SetStackableWithRanks ( bool val )

{
    _isStackableWithRanks = val;
}

References _isStackableWithRanks.

◆ ValidateAttribute6SpellDamageMods()

bool SpellInfo::ValidateAttribute6SpellDamageMods	(	Unit const *	caster,
		AuraEffect const *	auraEffect,
		bool	isDot
	)		const

{
    // Xinef: no attribute
    if (!(AttributesEx6 & SPELL_ATTR6_IGNORE_CASTER_DAMAGE_MODIFIERS))
        return true;
 
    // Xinef we have a hook to decide which auras should profit to the spell, by default no profits
    // Xinef: Scourge Strike - Trigger
    if (Id == 70890 && auraEffect)
    {
        SpellInfo const* auraInfo = auraEffect->GetSpellInfo();
        return auraInfo->SpellIconID == 3086 ||
               (auraInfo->SpellFamilyName == SPELLFAMILY_DEATHKNIGHT && (auraInfo->SpellFamilyFlags & flag96(8388608, 64, 16) || auraInfo->SpellIconID == 235 || auraInfo->SpellIconID == 154));
    }
    // Xinef: Necrosis, no profits for done and taken
    else if (Id == 51460)
        return false;
 
    // Xinef: Do not affect dots and auras obtained from items, only affected by self casted auras
    return !isDot && auraEffect && (auraEffect->GetAmount() < 0 || (auraEffect->GetCasterGUID() == caster->GetGUID() && auraEffect->GetSpellInfo()->SpellFamilyName == SpellFamilyName)) && !auraEffect->GetBase()->GetCastItemGUID();
}