#include <SpellInfo.h>

Classes
struct	ScalingInfo

Public Member Functions
	SpellInfo (SpellNameEntry const *spellName, ::Difficulty difficulty, SpellInfoLoadHelper const &data)

	SpellInfo (SpellNameEntry const *spellName, ::Difficulty difficulty, std::vector< SpellEffectEntry > const &effects)

	SpellInfo (SpellInfo const &)=delete

	SpellInfo (SpellInfo &&)=delete

	~SpellInfo ()

SpellInfo &	operator= (SpellInfo const &)=delete

SpellInfo &	operator= (SpellInfo &&) noexcept=delete

uint32	GetCategory () const

bool	HasEffect (SpellEffectName effect) const

bool	HasAura (AuraType aura) const

bool	HasAreaAuraEffect () const

bool	HasOnlyDamageEffects () const

bool	HasTargetType (::Targets target) 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 (SpellAttr8 attribute) const

bool	HasAttribute (SpellAttr9 attribute) const

bool	HasAttribute (SpellAttr10 attribute) const

bool	HasAttribute (SpellAttr11 attribute) const

bool	HasAttribute (SpellAttr12 attribute) const

bool	HasAttribute (SpellAttr13 attribute) const

bool	HasAttribute (SpellAttr14 attribute) const

bool	HasAttribute (SpellCustomAttributes customAttribute) const

bool	CanBeInterrupted (WorldObject const interruptCaster, Unit const interruptTarget, bool ignoreImmunity=false) const

bool	HasAnyAuraInterruptFlag () const

bool	HasAuraInterruptFlag (SpellAuraInterruptFlags flag) const

bool	HasAuraInterruptFlag (SpellAuraInterruptFlags2 flag) const

bool	HasChannelInterruptFlag (SpellAuraInterruptFlags flag) const

bool	HasChannelInterruptFlag (SpellAuraInterruptFlags2 flag) const

bool	IsExplicitDiscovery () const

bool	IsLootCrafting () const

bool	IsProfession () const

bool	IsPrimaryProfession () const

bool	IsPrimaryProfessionFirstRank () const

bool	IsAbilityOfSkillType (uint32 skillType) const

bool	IsAffectingArea () const

bool	IsTargetingArea () const

bool	NeedsExplicitUnitTarget () const

bool	NeedsToBeTriggeredByCaster (SpellInfo const *triggeringSpell) const

bool	IsPassive () const

bool	IsAutocastable () const

bool	IsStackableWithRanks () const

bool	IsPassiveStackableWithRanks () const

bool	IsMultiSlotAura () const

bool	IsStackableOnOneSlotWithDifferentCasters () const

bool	IsCooldownStartedOnEvent () const

bool	IsDeathPersistent () const

bool	IsRequiringDeadTarget () const

bool	IsAllowingDeadTarget () const

bool	IsGroupBuff () const

bool	CanBeUsedInCombat () const

bool	IsPositive () const

bool	IsPositiveEffect (uint8 effIndex) const

bool	IsChanneled () const

bool	IsMoveAllowedChannel () const

bool	NeedsComboPoints () const

bool	IsNextMeleeSwingSpell () const

bool	IsRangedWeaponSpell () const

bool	IsAutoRepeatRangedSpell () const

bool	HasInitialAggro () const

bool	HasHitDelay () const

WeaponAttackType	GetAttackType () const

bool	IsItemFitToSpellRequirements (Item const *item) const

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

bool	IsAffectedBySpellMods () const

bool	IsAffectedBySpellMod (SpellModifier const *mod) const

bool	CanPierceImmuneAura (SpellInfo const *auraSpellInfo) const

bool	CanDispelAura (SpellInfo const *auraSpellInfo) 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 const *player=nullptr) const

SpellCastResult	CheckTarget (WorldObject const caster, WorldObject const target, bool implicit=true) const

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

SpellCastResult	CheckVehicle (Unit const *caster) const

bool	CheckTargetCreatureType (Unit const *target) const

SpellSchoolMask	GetSchoolMask () const

uint64	GetAllEffectsMechanicMask () const

uint64	GetEffectMechanicMask (SpellEffIndex effIndex) const

uint64	GetSpellMechanicMaskByEffectMask (uint32 effectMask) const

Mechanics	GetEffectMechanic (SpellEffIndex 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	CalcDuration (WorldObject const *caster=nullptr) const

int32	GetDuration () const

int32	GetMaxDuration () const

uint32	GetMaxTicks () const

uint32	CalcCastTime (Spell *spell=nullptr) const

uint32	GetRecoveryTime () const

Optional< SpellPowerCost >	CalcPowerCost (Powers powerType, bool optionalCost, WorldObject const caster, SpellSchoolMask schoolMask, Spell spell=nullptr) const

Optional< SpellPowerCost >	CalcPowerCost (SpellPowerEntry const power, bool optionalCost, WorldObject const caster, SpellSchoolMask schoolMask, Spell *spell=nullptr) const

std::vector< SpellPowerCost >	CalcPowerCost (WorldObject const caster, SpellSchoolMask schoolMask, Spell spell=nullptr) const

float	CalcProcPPM (Unit *caster, int32 itemLevel) 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

uint32	GetSpellXSpellVisualId (WorldObject const caster=nullptr, WorldObject const viewer=nullptr) const

uint32	GetSpellVisual (WorldObject const caster=nullptr, WorldObject const viewer=nullptr) const

std::vector< SpellEffectInfo > const &	GetEffects () const

SpellEffectInfo const &	GetEffect (SpellEffIndex index) const

DiminishingGroup	GetDiminishingReturnsGroupForSpell () const

DiminishingReturnsType	GetDiminishingReturnsGroupType () const

DiminishingLevels	GetDiminishingReturnsMaxLevel () const

int32	GetDiminishingReturnsLimitDuration () const

void	ApplyAllSpellImmunitiesTo (Unit *target, SpellEffectInfo const &spellEffectInfo, bool apply) const

bool	CanSpellProvideImmunityAgainstAura (SpellInfo const *auraSpellInfo) const

bool	SpellCancelsAuraEffect (AuraEffect const *aurEff) const

uint64	GetAllowedMechanicMask () const

uint64	GetMechanicImmunityMask (Unit const *caster) const

bool	MeetsFutureSpellPlayerCondition (Player const *player) const

bool	HasLabel (uint32 labelId) const

Static Public Member Functions
static uint32	GetDispelMask (DispelType type)

Public Attributes
uint32 const	Id = 0

::Difficulty const	Difficulty = DIFFICULTY_NONE

uint32	CategoryId = 0

uint32	Dispel = 0

uint32	Mechanic = 0

uint32	Attributes = 0

uint32	AttributesEx = 0

uint32	AttributesEx2 = 0

uint32	AttributesEx3 = 0

uint32	AttributesEx4 = 0

uint32	AttributesEx5 = 0

uint32	AttributesEx6 = 0

uint32	AttributesEx7 = 0

uint32	AttributesEx8 = 0

uint32	AttributesEx9 = 0

uint32	AttributesEx10 = 0

uint32	AttributesEx11 = 0

uint32	AttributesEx12 = 0

uint32	AttributesEx13 = 0

uint32	AttributesEx14 = 0

uint32	AttributesCu = 0

std::bitset< MAX_SPELL_EFFECTS >	NegativeEffects

uint64	Stances = 0

uint64	StancesNot = 0

uint32	Targets = 0

uint32	TargetCreatureType = 0

uint32	RequiresSpellFocus = 0

uint32	FacingCasterFlags = 0

uint32	CasterAuraState = 0

uint32	TargetAuraState = 0

uint32	ExcludeCasterAuraState = 0

uint32	ExcludeTargetAuraState = 0

uint32	CasterAuraSpell = 0

uint32	TargetAuraSpell = 0

uint32	ExcludeCasterAuraSpell = 0

uint32	ExcludeTargetAuraSpell = 0

AuraType	CasterAuraType = SPELL_AURA_NONE

AuraType	TargetAuraType = SPELL_AURA_NONE

AuraType	ExcludeCasterAuraType = SPELL_AURA_NONE

AuraType	ExcludeTargetAuraType = SPELL_AURA_NONE

SpellCastTimesEntry const *	CastTimeEntry = nullptr

uint32	RecoveryTime = 0

uint32	CategoryRecoveryTime = 0

uint32	StartRecoveryCategory = 0

uint32	StartRecoveryTime = 0

uint32	CooldownAuraSpellId = 0

EnumFlag< SpellInterruptFlags >	InterruptFlags = SpellInterruptFlags::None

EnumFlag< SpellAuraInterruptFlags >	AuraInterruptFlags = SpellAuraInterruptFlags::None

EnumFlag< SpellAuraInterruptFlags2 >	AuraInterruptFlags2 = SpellAuraInterruptFlags2::None

EnumFlag< SpellAuraInterruptFlags >	ChannelInterruptFlags = SpellAuraInterruptFlags::None

EnumFlag< SpellAuraInterruptFlags2 >	ChannelInterruptFlags2 = SpellAuraInterruptFlags2::None

ProcFlagsInit	ProcFlags

uint32	ProcChance = 0

uint32	ProcCharges = 0

uint32	ProcCooldown = 0

float	ProcBasePPM = 0.0f

std::vector< SpellProcsPerMinuteModEntry const * >	ProcPPMMods

uint32	MaxLevel = 0

uint32	BaseLevel = 0

uint32	SpellLevel = 0

SpellDurationEntry const *	DurationEntry = nullptr

std::array< SpellPowerEntry const *, MAX_POWERS_PER_SPELL >	PowerCosts = {}

SpellRangeEntry const *	RangeEntry = nullptr

float	Speed = 0.0f

float	LaunchDelay = 0.0f

uint32	StackAmount = 0

std::array< int32, MAX_SPELL_TOTEMS >	Totem = {}

std::array< uint16, MAX_SPELL_TOTEMS >	TotemCategory = {}

std::array< int32, MAX_SPELL_REAGENTS >	Reagent = {}

std::array< int16, MAX_SPELL_REAGENTS >	ReagentCount = {}

std::vector< SpellReagentsCurrencyEntry const * >	ReagentsCurrency

int32	EquippedItemClass = -1

int32	EquippedItemSubClassMask = 0

int32	EquippedItemInventoryTypeMask = 0

uint32	IconFileDataId = 0

uint32	ActiveIconFileDataId = 0

uint32	ContentTuningId = 0

uint32	ShowFutureSpellPlayerConditionID = 0

LocalizedString const *	SpellName = nullptr

float	ConeAngle = 0.0f

float	Width = 0.0f

uint32	MaxTargetLevel = 0

uint32	MaxAffectedTargets = 0

uint32	SpellFamilyName = 0

flag128	SpellFamilyFlags

uint32	DmgClass = 0

uint32	PreventionType = 0

int32	RequiredAreasID = -1

uint32	SchoolMask = 0

uint32	ChargeCategoryId = 0

std::unordered_set< uint32 >	Labels

struct SpellInfo::ScalingInfo	Scaling

uint32	ExplicitTargetMask = 0

SpellChainNode const *	ChainEntry = nullptr

Private Member Functions
void	_InitializeExplicitTargetMask ()

void	_InitializeSpellPositivity ()

void	_LoadSpellSpecific ()

void	_LoadAuraState ()

void	_LoadSpellDiminishInfo ()

void	_LoadImmunityInfo ()

void	_UnloadImplicitTargetConditionLists ()

Private Attributes
std::vector< SpellEffectInfo >	_effects

SpellVisualVector	_visuals

SpellSpecificType	_spellSpecific = SPELL_SPECIFIC_NORMAL

AuraStateType	_auraState = AURA_STATE_NONE

SpellDiminishInfo	_diminishInfo

uint64	_allowedMechanicMask = 0

Friends
class	SpellMgr

Constructor & Destructor Documentation

◆ SpellInfo() [1/4]

SpellInfo::SpellInfo	(	SpellNameEntry const *	spellName,
		::Difficulty	difficulty,
		SpellInfoLoadHelper const &	data
	)

explicit

 : Id(spellName->ID), Difficulty(difficulty)
{
 _effects.reserve(32);
 for (SpellEffectEntry const* spellEffect : data.Effects)
 {
 if (!spellEffect)
 continue;
 
 Trinity::Containers::EnsureWritableVectorIndex(_effects, spellEffect->EffectIndex, SpellEffectInfo(this)) = SpellEffectInfo(this, *spellEffect);
 }
 
 // Correct EffectIndex for blank effects
 for (size_t i = 0; i < _effects.size(); ++i)
 _effects[i].EffectIndex = SpellEffIndex(i);
 
 _effects.shrink_to_fit();
 
 SpellName = &spellName->Name;
 
 // SpellMiscEntry
 if (SpellMiscEntry const* _misc = data.Misc)
 {
 Attributes = _misc->Attributes[0];
 AttributesEx = _misc->Attributes[1];
 AttributesEx2 = _misc->Attributes[2];
 AttributesEx3 = _misc->Attributes[3];
 AttributesEx4 = _misc->Attributes[4];
 AttributesEx5 = _misc->Attributes[5];
 AttributesEx6 = _misc->Attributes[6];
 AttributesEx7 = _misc->Attributes[7];
 AttributesEx8 = _misc->Attributes[8];
 AttributesEx9 = _misc->Attributes[9];
 AttributesEx10 = _misc->Attributes[10];
 AttributesEx11 = _misc->Attributes[11];
 AttributesEx12 = _misc->Attributes[12];
 AttributesEx13 = _misc->Attributes[13];
 AttributesEx14 = _misc->Attributes[14];
 CastTimeEntry = sSpellCastTimesStore.LookupEntry(_misc->CastingTimeIndex);
 DurationEntry = sSpellDurationStore.LookupEntry(_misc->DurationIndex);
 RangeEntry = sSpellRangeStore.LookupEntry(_misc->RangeIndex);
 Speed = _misc->Speed;
 LaunchDelay = _misc->LaunchDelay;
 SchoolMask = _misc->SchoolMask;
 IconFileDataId = _misc->SpellIconFileDataID;
 ActiveIconFileDataId = _misc->ActiveIconFileDataID;
 ContentTuningId = _misc->ContentTuningID;
 ShowFutureSpellPlayerConditionID = _misc->ShowFutureSpellPlayerConditionID;
 }
 
 // SpellScalingEntry
 if (SpellScalingEntry const* _scaling = data.Scaling)
 {
 Scaling.MinScalingLevel = _scaling->MinScalingLevel;
 Scaling.MaxScalingLevel = _scaling->MaxScalingLevel;
 Scaling.ScalesFromItemLevel = _scaling->ScalesFromItemLevel;
 }
 
 // SpellAuraOptionsEntry
 if (SpellAuraOptionsEntry const* _options = data.AuraOptions)
 {
 ProcFlags = _options->ProcTypeMask;
 ProcChance = _options->ProcChance;
 ProcCharges = _options->ProcCharges;
 ProcCooldown = _options->ProcCategoryRecovery;
 StackAmount = _options->CumulativeAura;
 if (SpellProcsPerMinuteEntry const* _ppm = sSpellProcsPerMinuteStore.LookupEntry(_options->SpellProcsPerMinuteID))
 {
 ProcBasePPM = _ppm->BaseProcRate;
 ProcPPMMods = sDB2Manager.GetSpellProcsPerMinuteMods(_ppm->ID);
 }
 }
 
 // SpellAuraRestrictionsEntry
 if (SpellAuraRestrictionsEntry const* _aura = data.AuraRestrictions)
 {
 CasterAuraState = _aura->CasterAuraState;
 TargetAuraState = _aura->TargetAuraState;
 ExcludeCasterAuraState = _aura->ExcludeCasterAuraState;
 ExcludeTargetAuraState = _aura->ExcludeTargetAuraState;
 CasterAuraSpell = _aura->CasterAuraSpell;
 TargetAuraSpell = _aura->TargetAuraSpell;
 ExcludeCasterAuraSpell = _aura->ExcludeCasterAuraSpell;
 ExcludeTargetAuraSpell = _aura->ExcludeTargetAuraSpell;
 CasterAuraType = AuraType(_aura->CasterAuraType);
 TargetAuraType = AuraType(_aura->TargetAuraType);
 ExcludeCasterAuraType = AuraType(_aura->ExcludeCasterAuraType);
 ExcludeTargetAuraType = AuraType(_aura->ExcludeTargetAuraType);
 }
 
 // SpellCastingRequirementsEntry
 if (SpellCastingRequirementsEntry const* _castreq = data.CastingRequirements)
 {
 RequiresSpellFocus = _castreq->RequiresSpellFocus;
 FacingCasterFlags = _castreq->FacingCasterFlags;
 RequiredAreasID = _castreq->RequiredAreasID;
 }
 
 // SpellCategoriesEntry
 if (SpellCategoriesEntry const* _categories = data.Categories)
 {
 CategoryId = _categories->Category;
 Dispel = _categories->DispelType;
 Mechanic = _categories->Mechanic;
 StartRecoveryCategory = _categories->StartRecoveryCategory;
 DmgClass = _categories->DefenseType;
 PreventionType = _categories->PreventionType;
 ChargeCategoryId = _categories->ChargeCategory;
 }
 
 // SpellClassOptionsEntry
 if (SpellClassOptionsEntry const* _class = data.ClassOptions)
 {
 SpellFamilyName = _class->SpellClassSet;
 SpellFamilyFlags = _class->SpellClassMask;
 }
 
 // SpellCooldownsEntry
 if (SpellCooldownsEntry const* _cooldowns = data.Cooldowns)
 {
 RecoveryTime = _cooldowns->RecoveryTime;
 CategoryRecoveryTime = _cooldowns->CategoryRecoveryTime;
 StartRecoveryTime = _cooldowns->StartRecoveryTime;
 CooldownAuraSpellId = _cooldowns->AuraSpellID;
 }
 
 // SpellEquippedItemsEntry
 if (SpellEquippedItemsEntry const* _equipped = data.EquippedItems)
 {
 EquippedItemClass = _equipped->EquippedItemClass;
 EquippedItemSubClassMask = _equipped->EquippedItemSubclass;
 EquippedItemInventoryTypeMask = _equipped->EquippedItemInvTypes;
 }
 
 // SpellInterruptsEntry
 if (SpellInterruptsEntry const* _interrupt = data.Interrupts)
 {
 InterruptFlags = SpellInterruptFlags(_interrupt->InterruptFlags);
 AuraInterruptFlags = SpellAuraInterruptFlags(_interrupt->AuraInterruptFlags[0]);
 AuraInterruptFlags2 = SpellAuraInterruptFlags2(_interrupt->AuraInterruptFlags[1]);
 ChannelInterruptFlags = SpellAuraInterruptFlags(_interrupt->ChannelInterruptFlags[0]);
 ChannelInterruptFlags2 = SpellAuraInterruptFlags2(_interrupt->ChannelInterruptFlags[1]);
 }
 
 for (SpellLabelEntry const* label : data.Labels)
 Labels.insert(label->LabelID);
 
 // SpellLevelsEntry
 if (SpellLevelsEntry const* _levels = data.Levels)
 {
 MaxLevel = _levels->MaxLevel;
 BaseLevel = _levels->BaseLevel;
 SpellLevel = _levels->SpellLevel;
 }
 
 // SpellPowerEntry
 PowerCosts = data.Powers;
 
 // SpellReagentsEntry
 if (SpellReagentsEntry const* _reagents = data.Reagents)
 {
 Reagent = _reagents->Reagent;
 ReagentCount = _reagents->ReagentCount;
 }
 
 ReagentsCurrency = data.ReagentsCurrency;
 
 // SpellShapeshiftEntry
 if (SpellShapeshiftEntry const* _shapeshift = data.Shapeshift)
 {
 Stances = MAKE_PAIR64(_shapeshift->ShapeshiftMask[0], _shapeshift->ShapeshiftMask[1]);
 StancesNot = MAKE_PAIR64(_shapeshift->ShapeshiftExclude[0], _shapeshift->ShapeshiftExclude[1]);
 }
 
 // SpellTargetRestrictionsEntry
 if (SpellTargetRestrictionsEntry const* _target = data.TargetRestrictions)
 {
 ConeAngle = _target->ConeDegrees;
 Width = _target->Width;
 Targets = _target->Targets;
 TargetCreatureType = _target->TargetCreatureType;
 MaxAffectedTargets = _target->MaxTargets;
 MaxTargetLevel = _target->MaxTargetLevel;
 }
 
 // SpellTotemsEntry
 if (SpellTotemsEntry const* _totem = data.Totems)
 {
 TotemCategory = _totem->RequiredTotemCategoryID;
 Totem = _totem->Totem;
 }
 
 _visuals = data.Visuals;
}

Here is the call graph for this function:

◆ SpellInfo() [2/4]

SpellInfo::SpellInfo	(	SpellNameEntry const *	spellName,
		::Difficulty	difficulty,
		std::vector< SpellEffectEntry > const &	effects
	)

explicit

 : Id(spellName->ID), Difficulty(difficulty)
{
 SpellName = &spellName->Name;
 
 _effects.reserve(32);
 for (SpellEffectEntry const& spellEffect : effects)
 Trinity::Containers::EnsureWritableVectorIndex(_effects, spellEffect.EffectIndex, SpellEffectInfo(this)) = SpellEffectInfo(this, spellEffect);
 
 // Correct EffectIndex for blank effects
 for (size_t i = 0; i < _effects.size(); ++i)
 _effects[i].EffectIndex = SpellEffIndex(i);
 
 _effects.shrink_to_fit();
}

Here is the call graph for this function:

◆ SpellInfo() [3/4]

SpellInfo::SpellInfo ( SpellInfo const & )

delete

◆ SpellInfo() [4/4]

SpellInfo::SpellInfo ( SpellInfo && )

delete

◆ ~SpellInfo()

SpellInfo::~SpellInfo ( )

{
 _UnloadImplicitTargetConditionLists();
}

Here is the call graph for this function:

Member Function Documentation

◆ _InitializeExplicitTargetMask()

void SpellInfo::_InitializeExplicitTargetMask ( )

private

{
 bool srcSet = false;
 bool dstSet = false;
 uint32 targetMask = Targets;
 // prepare target mask using effect target entries
 for (SpellEffectInfo const& effect : GetEffects())
 {
 if (!effect.IsEffect())
 continue;
 
 targetMask |= effect.TargetA.GetExplicitTargetMask(srcSet, dstSet);
 targetMask |= effect.TargetB.GetExplicitTargetMask(srcSet, dstSet);
 
 // add explicit target flags based on spell effects which have EFFECT_IMPLICIT_TARGET_EXPLICIT and no valid target provided
 if (effect.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 = effect.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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _InitializeSpellPositivity()

void SpellInfo::_InitializeSpellPositivity ( )

private

{
 std::unordered_set<std::pair<SpellInfo const*, SpellEffIndex /*effIndex*/>> visited;
 
 for (SpellEffectInfo const& effect : GetEffects())
 if (!_isPositiveEffectImpl(this, effect, visited))
 NegativeEffects[effect.EffectIndex] = true;
 
 // additional checks after effects marked
 for (SpellEffectInfo const& effect : GetEffects())
 {
 if (!effect.IsEffect() || !IsPositiveEffect(effect.EffectIndex))
 continue;
 
 switch (effect.ApplyAuraName)
 {
 // has other non positive effect?
 // then it should be marked negative if has same target as negative effect (ex 8510, 8511, 8893, 10267)
 case SPELL_AURA_DUMMY:
 case SPELL_AURA_MOD_STUN:
 case SPELL_AURA_MOD_FEAR:
 case SPELL_AURA_MOD_TAUNT:
 case SPELL_AURA_TRANSFORM:
 case SPELL_AURA_MOD_ATTACKSPEED:
 case SPELL_AURA_MOD_DECREASE_SPEED:
 {
 for (size_t j = effect.EffectIndex + 1; j < GetEffects().size(); ++j)
 if (!IsPositiveEffect(j)
 && effect.TargetA.GetTarget() == GetEffect(SpellEffIndex(j)).TargetA.GetTarget()
 && effect.TargetB.GetTarget() == GetEffect(SpellEffIndex(j)).TargetB.GetTarget())
 NegativeEffects[effect.EffectIndex] = true;
 break;
 }
 default:
 break;
 }
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _LoadAuraState()

void SpellInfo::_LoadAuraState ( )

private

{
 _auraState = [this]()->AuraStateType
 {
 // Faerie Fire (Feral)
 if (GetCategory() == 1133)
 return AURA_STATE_FAERIE_FIRE;
 
 // Swiftmend state on Regrowth, Rejuvenation, Wild Growth
 if (SpellFamilyName == SPELLFAMILY_DRUID && (SpellFamilyFlags[0] & 0x50 || SpellFamilyFlags[1] & 0x4000000))
 return AURA_STATE_DRUID_PERIODIC_HEAL;
 
 // Deadly poison aura state
 if (SpellFamilyName == SPELLFAMILY_ROGUE && SpellFamilyFlags[0] & 0x10000)
 return AURA_STATE_ROGUE_POISONED;
 
 // Enrage aura state
 if (Dispel == DISPEL_ENRAGE)
 return AURA_STATE_ENRAGED;
 
 // Bleeding aura state
 if (GetAllEffectsMechanicMask() & (1 << MECHANIC_BLEED))
 return AURA_STATE_BLEED;
 
 if (GetSchoolMask() & SPELL_SCHOOL_MASK_FROST)
 for (SpellEffectInfo const& effect : GetEffects())
 if (effect.IsAura(SPELL_AURA_MOD_STUN) || effect.IsAura(SPELL_AURA_MOD_ROOT) || effect.IsAura(SPELL_AURA_MOD_ROOT_2))
 return AURA_STATE_FROZEN;
 
 switch (Id)
 {
 case 1064: // Dazed
 return AURA_STATE_DAZED;
 case 32216: // Victorious
 return AURA_STATE_VICTORIOUS;
 case 71465: // Divine Surge
 case 50241: // Evasive Charges
 return AURA_STATE_RAID_ENCOUNTER;
 case 6950: // Faerie Fire
 case 9806: // Phantom Strike
 case 9991: // Touch of Zanzil
 case 13424: // Faerie Fire
 case 13752: // Faerie Fire
 case 16432: // Plague Mist
 case 20656: // Faerie Fire
 case 25602: // Faerie Fire
 case 32129: // Faerie Fire
 case 35325: // Glowing Blood
 case 35328: // Lambent Blood
 case 35329: // Vibrant Blood
 case 35331: // Black Blood
 case 49163: // Perpetual Instability
 case 65863: // Faerie Fire
 case 79559: // Luxscale Light
 case 82855: // Dazzling
 case 102953: // In the Rumpus
 case 127907: // Phosphorescence
 case 127913: // Phosphorescence
 case 129007: // Zijin Sting
 case 130159: // Fae Touch
 case 142537: // Spotter Smoke
 case 168455: // Spotted!
 case 176905: // Super Sticky Glitter Bomb
 case 189502: // Marked
 case 201785: // Intruder Alert!
 case 201786: // Intruder Alert!
 case 201935: // Spotted!
 case 239233: // Smoke Bomb
 case 319400: // Glitter Burst
 case 321470: // Dimensional Shifter Mishap
 case 331134: // Spotted
 return AURA_STATE_FAERIE_FIRE;
 default:
 break;
 }
 
 return AURA_STATE_NONE;
 }();
}

Here is the call graph for this function:

◆ _LoadImmunityInfo()

void SpellInfo::_LoadImmunityInfo ( )

private

{
 std::unique_ptr<SpellEffectInfo::ImmunityInfo> workBuffer = std::make_unique<SpellEffectInfo::ImmunityInfo>();
 
 for (SpellEffectInfo& effect : _effects)
 {
 uint32 schoolImmunityMask = 0;
 uint32 applyHarmfulAuraImmunityMask = 0;
 uint64 mechanicImmunityMask = 0;
 uint32 dispelImmunity = 0;
 uint32 damageImmunityMask = 0;
 
 int32 miscVal = effect.MiscValue;
 int32 amount = effect.CalcValue();
 
 SpellEffectInfo::ImmunityInfo& immuneInfo = *workBuffer;
 
 switch (effect.ApplyAuraName)
 {
 case SPELL_AURA_MECHANIC_IMMUNITY_MASK:
 {
 switch (miscVal)
 {
 case 96: // Free Friend, Uncontrollable Frenzy, Warlord's Presence
 {
 mechanicImmunityMask |= IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK;
 
 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_2);
 break;
 }
 case 1615: // Incite Rage, Wolf Spirit, Overload, Lightning Tendrils
 {
 switch (Id)
 {
 case 43292: // Incite Rage
 case 49172: // Wolf Spirit
 mechanicImmunityMask |= IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK;
 
 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_2);
 [[fallthrough]];
 case 61869: // Overload
 case 63481:
 case 61887: // Lightning Tendrils
 case 63486:
 mechanicImmunityMask |= (1 << MECHANIC_INTERRUPT) | (1 << MECHANIC_SILENCE);
 
 immuneInfo.SpellEffectImmune.insert(SPELL_EFFECT_KNOCK_BACK);
 immuneInfo.SpellEffectImmune.insert(SPELL_EFFECT_KNOCK_BACK_DEST);
 break;
  default:
 break;
 }
 break;
 }
 case 679: // Mind Control, Avenging Fury
 {
 if (Id == 57742) // Avenging Fury
 {
 mechanicImmunityMask |= IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK;
 
 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_2);
 }
 break;
 }
 case 1557: // Startling Roar, Warlord Roar, Break Bonds, Stormshield
 {
 if (Id == 64187) // Stormshield
 {
 mechanicImmunityMask |= (1 << MECHANIC_STUN);
 immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_STUN);
 }
 else
 {
 mechanicImmunityMask |= IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK;
 
 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_2);
 }
 break;
 }
 case 1614: // Fixate
 case 1694: // Fixated, Lightning Tendrils
 {
 immuneInfo.SpellEffectImmune.insert(SPELL_EFFECT_ATTACK_ME);
 immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_TAUNT);
 break;
 }
 case 1630: // Fervor, Berserk
 {
 if (Id == 64112) // Berserk
 {
 immuneInfo.SpellEffectImmune.insert(SPELL_EFFECT_ATTACK_ME);
 immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_TAUNT);
 }
 else
 {
 mechanicImmunityMask |= IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK;
 
 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_2);
 }
 break;
 }
 case 477: // Bladestorm
 case 1733: // Bladestorm, Killing Spree
 {
 if (!amount)
 {
 mechanicImmunityMask |= IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK;
 
 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_2);
 }
 break;
 }
 case 878: // Whirlwind, Fog of Corruption, Determination
 {
 if (Id == 66092) // Determination
 {
  mechanicImmunityMask |= (1 << MECHANIC_SNARE) | (1 << MECHANIC_STUN)
 | (1 << MECHANIC_DISORIENTED) | (1 << 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);
 
 // These flag can be recognized wrong:
 if (miscVal & (1 << 6))
 immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_DECREASE_SPEED);
 if (miscVal & (1 << 0))
 {
 immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_ROOT);
 immuneInfo.AuraTypeImmune.insert(SPELL_AURA_MOD_ROOT_2);
 }
 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 42292: // PvP trinket
 case 59752: // Every Man for Himself
 mechanicImmunityMask |= IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK;
 immuneInfo.AuraTypeImmune.insert(SPELL_AURA_USE_NORMAL_MOVEMENT_SPEED);
 break;
 case 34471: // The Beast Within
 case 19574: // Bestial Wrath
 case 46227: // Medallion of Immunity
 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 |= (1 << MECHANIC_SNARE) | (1 << MECHANIC_ROOT) | (1 << MECHANIC_STUN);
 break;
 default:
 if (miscVal < 1)
 break;
 
 mechanicImmunityMask |= UI64LIT(1) << miscVal;
 break;
 }
 break;
 }
 case SPELL_AURA_EFFECT_IMMUNITY:
 {
 immuneInfo.SpellEffectImmune.insert(static_cast<SpellEffectName>(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:
 {
 dispelImmunity = uint32(miscVal);
 break;
 }
 default:
 break;
 }
 
 immuneInfo.SchoolImmuneMask = schoolImmunityMask;
 immuneInfo.ApplyHarmfulAuraImmuneMask = applyHarmfulAuraImmunityMask;
 immuneInfo.MechanicImmuneMask = mechanicImmunityMask;
 immuneInfo.DispelImmune = dispelImmunity;
 immuneInfo.DamageSchoolMask = damageImmunityMask;
 
 immuneInfo.AuraTypeImmune.shrink_to_fit();
 immuneInfo.SpellEffectImmune.shrink_to_fit();
 
 if (immuneInfo.SchoolImmuneMask
 || immuneInfo.ApplyHarmfulAuraImmuneMask
 || immuneInfo.MechanicImmuneMask
 || immuneInfo.DispelImmune
 || immuneInfo.DamageSchoolMask
 || !immuneInfo.AuraTypeImmune.empty()
 || !immuneInfo.SpellEffectImmune.empty())
 {
 effect._immunityInfo = workBuffer.release();
 workBuffer = std::make_unique<SpellEffectInfo::ImmunityInfo>();
 }
 
 _allowedMechanicMask |= immuneInfo.MechanicImmuneMask;
 }
 
 if (HasAttribute(SPELL_ATTR5_ALLOW_WHILE_STUNNED))
 {
 switch (Id)
 {
 case 22812: // Barkskin
 case 47585: // Dispersion
 _allowedMechanicMask |=
 (1 << MECHANIC_STUN) |
 (1 << MECHANIC_FREEZE) |
 (1 << MECHANIC_KNOCKOUT) |
 (1 << MECHANIC_SLEEP);
 break;
 case 49039: // Lichborne, don't allow normal stuns
 break;
 default:
 _allowedMechanicMask |= (1 << MECHANIC_STUN);
 break;
 }
 }
 
 if (HasAttribute(SPELL_ATTR5_ALLOW_WHILE_CONFUSED))
 _allowedMechanicMask |= (1 << MECHANIC_DISORIENTED);
 
 if (HasAttribute(SPELL_ATTR5_ALLOW_WHILE_FLEEING))
 {
 switch (Id)
 {
 case 22812: // Barkskin
 case 47585: // Dispersion
 _allowedMechanicMask |= (1 << MECHANIC_FEAR) | (1 << MECHANIC_HORROR);
 break;
 default:
 _allowedMechanicMask |= (1 << MECHANIC_FEAR);
 break;
 }
 }
}

Here is the call graph for this function:

◆ _LoadSpellDiminishInfo()

void SpellInfo::_LoadSpellDiminishInfo ( )

private

{
 auto diminishingGroupCompute = [this]() -> DiminishingGroup
 {
 if (IsPositive())
 return DIMINISHING_NONE;
 
 if (HasAura(SPELL_AURA_MOD_TAUNT))
 return DIMINISHING_TAUNT;
 
 switch (Id)
 {
 case 20549: // War Stomp (Racial - Tauren)
 case 24394: // Intimidation
 case 118345: // Pulverize (Primal Earth Elemental)
 case 118905: // Static Charge (Capacitor Totem)
 return DIMINISHING_STUN;
 case 107079: // Quaking Palm
 return DIMINISHING_INCAPACITATE;
 case 155145: // Arcane Torrent (Racial - Blood Elf)
 return DIMINISHING_SILENCE;
 case 108199: // Gorefiend's Grasp
 case 191244: // Sticky Bomb
 return DIMINISHING_AOE_KNOCKBACK;
 default:
 break;
 }
 
 // Explicit Diminishing Groups
 switch (SpellFamilyName)
 {
 case SPELLFAMILY_GENERIC:
 // Frost Tomb
 if (Id == 48400)
 return DIMINISHING_NONE;
 // Gnaw
 else if (Id == 47481)
 return DIMINISHING_STUN;
 // ToC Icehowl Arctic Breath
 else if (Id == 66689)
 return DIMINISHING_NONE;
 // Black Plague
 else if (Id == 64155)
 return DIMINISHING_NONE;
 // Screams of the Dead (King Ymiron)
 else if (Id == 51750)
 return DIMINISHING_NONE;
 // Crystallize (Keristrasza heroic)
 else if (Id == 48179)
 return DIMINISHING_NONE;
 break;
 case SPELLFAMILY_MAGE:
 {
 // Frost Nova -- 122
 if (SpellFamilyFlags[0] & 0x40)
 return DIMINISHING_ROOT;
 // Freeze (Water Elemental) -- 33395
 if (SpellFamilyFlags[2] & 0x200)
 return DIMINISHING_ROOT;
 
 // Dragon's Breath -- 31661
 if (SpellFamilyFlags[0] & 0x800000)
 return DIMINISHING_INCAPACITATE;
 // Polymorph -- 118
 if (SpellFamilyFlags[0] & 0x1000000)
 return DIMINISHING_INCAPACITATE;
 // Ring of Frost -- 82691
 if (SpellFamilyFlags[2] & 0x40)
 return DIMINISHING_INCAPACITATE;
 // Ice Nova -- 157997
 if (SpellFamilyFlags[2] & 0x800000)
 return DIMINISHING_INCAPACITATE;
 break;
 }
 case SPELLFAMILY_WARRIOR:
 {
 // Shockwave -- 132168
 if (SpellFamilyFlags[1] & 0x8000)
 return DIMINISHING_STUN;
 // Storm Bolt -- 132169
 if (SpellFamilyFlags[2] & 0x1000)
 return DIMINISHING_STUN;
 
 // Intimidating Shout -- 5246
 if (SpellFamilyFlags[0] & 0x40000)
 return DIMINISHING_DISORIENT;
 break;
 }
 case SPELLFAMILY_WARLOCK:
 {
 // Mortal Coil -- 6789
 if (SpellFamilyFlags[0] & 0x80000)
 return DIMINISHING_INCAPACITATE;
 // Banish -- 710
 if (SpellFamilyFlags[1] & 0x8000000)
 return DIMINISHING_INCAPACITATE;
 
 // Fear -- 118699
 if (SpellFamilyFlags[1] & 0x400)
 return DIMINISHING_DISORIENT;
 // Howl of Terror -- 5484
 if (SpellFamilyFlags[1] & 0x8)
 return DIMINISHING_DISORIENT;
 
 // Shadowfury -- 30283
 if (SpellFamilyFlags[1] & 0x1000)
 return DIMINISHING_STUN;
 // Summon Infernal -- 22703
 if (SpellFamilyFlags[0] & 0x1000)
 return DIMINISHING_STUN;
 
 // 170995 -- Cripple
 if (Id == 170995)
 return DIMINISHING_LIMITONLY;
 break;
 }
 case SPELLFAMILY_WARLOCK_PET:
 {
 // Fellash -- 115770
 // Whiplash -- 6360
 if (SpellFamilyFlags[0] & 0x8000000)
 return DIMINISHING_AOE_KNOCKBACK;
 
 // Mesmerize (Shivarra pet) -- 115268
 // Seduction (Succubus pet) -- 6358
 if (SpellFamilyFlags[0] & 0x2000000)
 return DIMINISHING_DISORIENT;
 
 // Axe Toss (Felguard pet) -- 89766
 if (SpellFamilyFlags[1] & 0x4)
 return DIMINISHING_STUN;
 break;
 }
 case SPELLFAMILY_DRUID:
 {
 // Maim -- 22570
 if (SpellFamilyFlags[1] & 0x80)
 return DIMINISHING_STUN;
 // Mighty Bash -- 5211
 if (SpellFamilyFlags[0] & 0x2000)
 return DIMINISHING_STUN;
 // Rake -- 163505 -- no flags on the stun
 if (Id == 163505)
 return DIMINISHING_STUN;
 
 // Incapacitating Roar -- 99, no flags on the stun, 14
 if (SpellFamilyFlags[1] & 0x1)
 return DIMINISHING_INCAPACITATE;
 
 // Cyclone -- 33786
 if (SpellFamilyFlags[1] & 0x20)
 return DIMINISHING_DISORIENT;
 
 // Solar Beam -- 81261
 if (Id == 81261)
 return DIMINISHING_SILENCE;
 
 // Typhoon -- 61391
 if (SpellFamilyFlags[1] & 0x1000000)
 return DIMINISHING_AOE_KNOCKBACK;
 // Ursol's Vortex -- 118283, no family flags
 if (Id == 118283)
 return DIMINISHING_AOE_KNOCKBACK;
 
 // Entangling Roots -- 339
 if (SpellFamilyFlags[0] & 0x200)
 return DIMINISHING_ROOT;
 // Mass Entanglement -- 102359
 if (SpellFamilyFlags[2] & 0x4)
 return DIMINISHING_ROOT;
 break;
 }
 case SPELLFAMILY_ROGUE:
 {
 // Between the Eyes -- 199804
 if (SpellFamilyFlags[0] & 0x800000)
 return DIMINISHING_STUN;
 // Cheap Shot -- 1833
 if (SpellFamilyFlags[0] & 0x400)
 return DIMINISHING_STUN;
 // Kidney Shot -- 408
 if (SpellFamilyFlags[0] & 0x200000)
 return DIMINISHING_STUN;
 
 // Gouge -- 1776
 if (SpellFamilyFlags[0] & 0x8)
 return DIMINISHING_INCAPACITATE;
 // Sap -- 6770
 if (SpellFamilyFlags[0] & 0x80)
 return DIMINISHING_INCAPACITATE;
 
 // Blind -- 2094
 if (SpellFamilyFlags[0] & 0x1000000)
 return DIMINISHING_DISORIENT;
 
 // Garrote -- 1330
 if (SpellFamilyFlags[1] & 0x20000000)
 return DIMINISHING_SILENCE;
 break;
 }
 case SPELLFAMILY_HUNTER:
 {
 // Charge (Tenacity pet) -- 53148, no flags
 if (Id == 53148)
 return DIMINISHING_ROOT;
 // Ranger's Net -- 200108
 // Tracker's Net -- 212638
 if (Id == 200108 || Id == 212638)
 return DIMINISHING_ROOT;
 
 // Binding Shot -- 117526, no flags
 if (Id == 117526)
 return DIMINISHING_STUN;
 
 // Freezing Trap -- 3355
 if (SpellFamilyFlags[0] & 0x8)
 return DIMINISHING_INCAPACITATE;
 // Wyvern Sting -- 19386
 if (SpellFamilyFlags[1] & 0x1000)
 return DIMINISHING_INCAPACITATE;
 
 // Bursting Shot -- 224729
 if (SpellFamilyFlags[2] & 0x40)
 return DIMINISHING_DISORIENT;
 // Scatter Shot -- 213691
 if (SpellFamilyFlags[2] & 0x8000)
 return DIMINISHING_DISORIENT;
 
 // Spider Sting -- 202933
 if (Id == 202933)
 return DIMINISHING_SILENCE;
 break;
 }
 case SPELLFAMILY_PALADIN:
 {
 // Repentance -- 20066
 if (SpellFamilyFlags[0] & 0x4)
 return DIMINISHING_INCAPACITATE;
 
 // Blinding Light -- 105421
 if (Id == 105421)
 return DIMINISHING_DISORIENT;
 
 // Avenger's Shield -- 31935
 if (SpellFamilyFlags[0] & 0x4000)
 return DIMINISHING_SILENCE;
 
 // Hammer of Justice -- 853
 if (SpellFamilyFlags[0] & 0x800)
 return DIMINISHING_STUN;
 break;
 }
 case SPELLFAMILY_SHAMAN:
 {
 // Hex -- 51514
 // Hex -- 196942 (Voodoo Totem)
 if (SpellFamilyFlags[1] & 0x8000)
 return DIMINISHING_INCAPACITATE;
 
 // Thunderstorm -- 51490
 if (SpellFamilyFlags[1] & 0x2000)
 return DIMINISHING_AOE_KNOCKBACK;
 
 // Earthgrab Totem -- 64695
 if (SpellFamilyFlags[2] & 0x4000)
 return DIMINISHING_ROOT;
 
 // Lightning Lasso -- 204437
 if (SpellFamilyFlags[3] & 0x2000000)
 return DIMINISHING_STUN;
 break;
 }
 case SPELLFAMILY_DEATHKNIGHT:
 {
  // Chains of Ice -- 96294
 if (Id == 96294)
 return DIMINISHING_ROOT;
 
 // Blinding Sleet -- 207167
 if (Id == 207167)
 return DIMINISHING_DISORIENT;
 
 // Strangulate -- 47476
 if (SpellFamilyFlags[0] & 0x200)
 return DIMINISHING_SILENCE;
 
 // Asphyxiate -- 108194
 if (SpellFamilyFlags[2] & 0x100000)
 return DIMINISHING_STUN;
 // Gnaw (Ghoul) -- 91800, no flags
 if (Id == 91800)
 return DIMINISHING_STUN;
 // Monstrous Blow (Ghoul w/ Dark Transformation active) -- 91797
 if (Id == 91797)
 return DIMINISHING_STUN;
 // Winter is Coming -- 207171
 if (Id == 207171)
 return DIMINISHING_STUN;
 break;
 }
 case SPELLFAMILY_PRIEST:
 {
 // Holy Word: Chastise -- 200200
 if (SpellFamilyFlags[2] & 0x20 && GetSpellVisual() == 52021)
 return DIMINISHING_STUN;
 // Mind Bomb -- 226943
 if (Id == 226943)
 return DIMINISHING_STUN;
 
 // Mind Control -- 605
 if (SpellFamilyFlags[0] & 0x20000 && GetSpellVisual() == 39068)
 return DIMINISHING_INCAPACITATE;
 // Holy Word: Chastise -- 200196
 if (SpellFamilyFlags[2] & 0x20 && GetSpellVisual() == 52019)
 return DIMINISHING_INCAPACITATE;
 
 // Psychic Scream -- 8122
 if (SpellFamilyFlags[0] & 0x10000)
 return DIMINISHING_DISORIENT;
 
 // Silence -- 15487
 if (SpellFamilyFlags[1] & 0x200000 && GetSpellVisual() == 39025)
 return DIMINISHING_SILENCE;
 
 // Shining Force -- 204263
 if (Id == 204263)
 return DIMINISHING_AOE_KNOCKBACK;
 break;
 }
 case SPELLFAMILY_MONK:
 {
 // Disable -- 116706, no flags
 if (Id == 116706)
 return DIMINISHING_ROOT;
 
 // Fists of Fury -- 120086
 if (SpellFamilyFlags[1] & 0x800000 && !(SpellFamilyFlags[2] & 0x8))
 return DIMINISHING_STUN;
 // Leg Sweep -- 119381
 if (SpellFamilyFlags[1] & 0x200)
 return DIMINISHING_STUN;
 
 // Incendiary Breath (honor talent) -- 202274, no flags
 if (Id == 202274)
 return DIMINISHING_INCAPACITATE;
 // Paralysis -- 115078
 if (SpellFamilyFlags[2] & 0x800000)
 return DIMINISHING_INCAPACITATE;
 
 // Song of Chi-Ji -- 198909
 if (Id == 198909)
 return DIMINISHING_DISORIENT;
 break;
 }
 case SPELLFAMILY_DEMON_HUNTER:
 {
 switch (Id)
 {
 case 179057: // Chaos Nova
 case 211881: // Fel Eruption
 case 200166: // Metamorphosis
 case 205630: // Illidan's Grasp
 return DIMINISHING_STUN;
 case 217832: // Imprison
 case 221527: // Imprison
 return DIMINISHING_INCAPACITATE;
 default:
 break;
 }
 break;
 }
 default:
 break;
 }
 
 return DIMINISHING_NONE;
 };
 
 auto diminishingTypeCompute = [](DiminishingGroup group) -> DiminishingReturnsType
 {
 switch (group)
 {
 case DIMINISHING_TAUNT:
 case DIMINISHING_STUN:
 return DRTYPE_ALL;
 case DIMINISHING_LIMITONLY:
 case DIMINISHING_NONE:
 return DRTYPE_NONE;
 default:
 return DRTYPE_PLAYER;
 }
 };
 
 auto diminishingMaxLevelCompute = [](DiminishingGroup group) -> DiminishingLevels
 {
 switch (group)
 {
 case DIMINISHING_TAUNT:
 return DIMINISHING_LEVEL_TAUNT_IMMUNE;
 case DIMINISHING_AOE_KNOCKBACK:
 return DIMINISHING_LEVEL_2;
 default:
 return DIMINISHING_LEVEL_IMMUNE;
 }
 };
 
 auto diminishingLimitDurationCompute = [this]() -> int32
 {
 // Explicit diminishing duration
 switch (SpellFamilyName)
 {
 case SPELLFAMILY_MAGE:
 {
 // Dragon's Breath - 3 seconds in PvP
 if (SpellFamilyFlags[0] & 0x800000)
 return 3 * IN_MILLISECONDS;
 break;
 }
 case SPELLFAMILY_WARLOCK:
 {
 // Cripple - 4 seconds in PvP
 if (Id == 170995)
 return 4 * IN_MILLISECONDS;
 break;
 }
 case SPELLFAMILY_HUNTER:
 {
 // Binding Shot - 3 seconds in PvP
 if (Id == 117526)
 return 3 * IN_MILLISECONDS;
 
 // Wyvern Sting - 6 seconds in PvP
 if (SpellFamilyFlags[1] & 0x1000)
 return 6 * IN_MILLISECONDS;
 break;
 }
 case SPELLFAMILY_MONK:
 {
 // Paralysis - 4 seconds in PvP regardless of if they are facing you
 if (SpellFamilyFlags[2] & 0x800000)
 return 4 * IN_MILLISECONDS;
 break;
 }
 case SPELLFAMILY_DEMON_HUNTER:
 {
 switch (Id)
 {
 case 217832: // Imprison
 case 221527: // Imprison
 return 4 * IN_MILLISECONDS;
 default:
 break;
 }
 break;
 }
 default:
 break;
 }
 
 return 8 * IN_MILLISECONDS;
 };
 
 SpellDiminishInfo diminishInfo;
 diminishInfo.DiminishGroup = diminishingGroupCompute();
 diminishInfo.DiminishReturnType = diminishingTypeCompute(diminishInfo.DiminishGroup);
 diminishInfo.DiminishMaxLevel = diminishingMaxLevelCompute(diminishInfo.DiminishGroup);
 diminishInfo.DiminishDurationLimit = diminishingLimitDurationCompute();
 
 _diminishInfo = diminishInfo;
}

Here is the call graph for this function:

◆ _LoadSpellSpecific()

void SpellInfo::_LoadSpellSpecific ( )

private

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

{
 _spellSpecific = [this]()->SpellSpecificType
 {
 switch (SpellFamilyName)
 {
 case SPELLFAMILY_GENERIC:
 {
 // Food / Drinks (mostly)
 if (HasAuraInterruptFlag(SpellAuraInterruptFlags::Standing))
 {
 bool food = false;
 bool drink = false;
 for (SpellEffectInfo const& effect : GetEffects())
 {
 if (!effect.IsAura())
 continue;
 switch (effect.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;
 default:
 break;
 }
 }
 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) && GetEffect(EFFECT_0).IsAura(SPELL_AURA_MOD_CONFUSE))
 return SPELL_SPECIFIC_MAGE_POLYMORPH;
 
 break;
 }
 case SPELLFAMILY_WARRIOR:
 {
 if (Id == 12292) // Death Wish
 return SPELL_SPECIFIC_WARRIOR_ENRAGE;
 
 break;
 }
 case SPELLFAMILY_WARLOCK:
 {
 // Warlock (Bane of Doom | Bane of Agony | Bane of Havoc)
 if (Id == 603 || Id == 980 || Id == 80240)
 return SPELL_SPECIFIC_BANE;
 
 // 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 & flag128(0x00200000, 0x00000000, 0x00001010, 0x00000000))
 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] & 0xA2000800)
 return SPELL_SPECIFIC_SEAL;
 
 if (SpellFamilyFlags[0] & 0x00002190)
 return SPELL_SPECIFIC_HAND;
 
 // only paladin auras have this (for palaldin class family)
 switch (Id)
 {
 case 465: // Devotion Aura
 case 32223: // Crusader Aura
 case 183435: // Retribution Aura
 case 317920: // Concentration Aura
 return SPELL_SPECIFIC_AURA;
 default:
 break;
 }
 
 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
 || Id == 23552)
 return SPELL_SPECIFIC_ELEMENTAL_SHIELD;
 
 break;
 }
 case SPELLFAMILY_DEATHKNIGHT:
 if (Id == 48266 || Id == 48263 || Id == 48265)
 return SPELL_SPECIFIC_PRESENCE;
 break;
 }
 
 for (SpellEffectInfo const& effect : GetEffects())
 {
 if (effect.IsEffect(SPELL_EFFECT_APPLY_AURA))
 {
 switch (effect.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;
 }();
}

Here is the call graph for this function:

◆ _UnloadImplicitTargetConditionLists()

void SpellInfo::_UnloadImplicitTargetConditionLists ( )

private

{
 // find the same instances of ConditionList and delete them.
 for (SpellEffectInfo const& effect : _effects)
 {
 ConditionContainer* cur = effect.ImplicitTargetConditions;
 if (!cur)
 continue;
 
 for (size_t j = effect.EffectIndex; j < _effects.size(); ++j)
 if (_effects[j].ImplicitTargetConditions == cur)
 _effects[j].ImplicitTargetConditions = nullptr;
 
 delete cur;
 }
}

Here is the caller graph for this function:

◆ ApplyAllSpellImmunitiesTo()

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

{
 SpellEffectInfo::ImmunityInfo const* immuneInfo = spellEffectInfo.GetImmunityInfo();
 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, schoolImmunity](AuraApplication const* aurApp) -> bool
 {
 SpellInfo const* auraSpellInfo = aurApp->GetBase()->GetSpellInfo();
 return ((auraSpellInfo->GetSchoolMask() & schoolImmunity) != 0 && // Check for school mask
 CanDispelAura(auraSpellInfo) &&
 (IsPositive() != aurApp->IsPositive()) && // Check spell vs aura possitivity
 !auraSpellInfo->IsPassive() && // Don't remove passive auras
 auraSpellInfo->Id != Id); // Don't remove self
 });
 }
 
 if (apply && schoolImmunity & SPELL_SCHOOL_MASK_NORMAL)
 target->RemoveAurasWithInterruptFlags(SpellAuraInterruptFlags::InvulnerabilityBuff);
 }
 
 if (uint64 mechanicImmunity = immuneInfo->MechanicImmuneMask)
 {
 for (uint32 i = 0; i < MAX_MECHANIC; ++i)
 if (mechanicImmunity & (UI64LIT(1) << i))
 target->ApplySpellImmune(Id, IMMUNITY_MECHANIC, i, apply);
 
 if (HasAttribute(SPELL_ATTR1_IMMUNITY_PURGES_EFFECT))
 {
 if (apply)
 target->RemoveAurasWithMechanic(mechanicImmunity, AURA_REMOVE_BY_DEFAULT, Id);
 else
 {
 std::vector<Aura*> aurasToUpdateTargets;
 target->RemoveAppliedAuras([mechanicImmunity, &aurasToUpdateTargets](AuraApplication const* aurApp)
 {
 Aura* aura = aurApp->GetBase();
 if (aura->GetSpellInfo()->GetAllEffectsMechanicMask() & mechanicImmunity)
 aurasToUpdateTargets.push_back(aura);
 
 // only update targets, don't remove anything
 return false;
 });
 
 for (Aura* aura : aurasToUpdateTargets)
 aura->UpdateTargetMap(aura->GetCaster());
 }
 }
 }
 
 if (uint32 dispelImmunity = immuneInfo->DispelImmune)
 {
 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);
 
 if (apply && damageImmunity & SPELL_SCHOOL_MASK_NORMAL)
 target->RemoveAurasWithInterruptFlags(SpellAuraInterruptFlags::InvulnerabilityBuff);
 }
 
 for (AuraType auraType : immuneInfo->AuraTypeImmune)
 {
 target->ApplySpellImmune(Id, IMMUNITY_STATE, auraType, apply);
 if (apply && HasAttribute(SPELL_ATTR1_IMMUNITY_PURGES_EFFECT))
 target->RemoveAurasByType(auraType, [](AuraApplication const* aurApp) -> bool
 {
 // if the aura has SPELL_ATTR0_NO_IMMUNITIES, then it cannot be removed by immunity
 return !aurApp->GetBase()->GetSpellInfo()->HasAttribute(SPELL_ATTR0_NO_IMMUNITIES);
 });
 }
 
 for (SpellEffectName effectType : immuneInfo->SpellEffectImmune)
 target->ApplySpellImmune(Id, IMMUNITY_EFFECT, effectType, apply);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalcCastTime()

uint32 SpellInfo::CalcCastTime ( Spell * spell = nullptr ) const

{
 int32 castTime = 0;
 if (CastTimeEntry)
 castTime = std::max(CastTimeEntry->Base, CastTimeEntry->Minimum);
 
 if (castTime <= 0)
 return 0;
 
 if (spell)
 spell->GetCaster()->ModSpellCastTime(this, castTime, spell);
 
 if (HasAttribute(SPELL_ATTR0_USES_RANGED_SLOT) && !IsAutoRepeatRangedSpell() && !HasAttribute(SPELL_ATTR9_AIMED_SHOT))
 castTime += 500;
 
 return (castTime > 0) ? uint32(castTime) : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalcDuration()

int32 SpellInfo::CalcDuration ( WorldObject const * caster = nullptr ) const

{
 int32 duration = GetDuration();
 
 if (caster)
 if (Player* modOwner = caster->GetSpellModOwner())
 modOwner->ApplySpellMod(this, SpellModOp::Duration, duration);
 
 return duration;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalcPowerCost() [1/3]

Optional< SpellPowerCost > SpellInfo::CalcPowerCost	(	Powers	powerType,
		bool	optionalCost,
		WorldObject const *	caster,
		SpellSchoolMask	schoolMask,
		Spell *	spell = `nullptr`
	)		const

{
 // gameobject casts don't use power
 Unit const* unitCaster = caster->ToUnit();
 if (!unitCaster)
 return {};
 
 auto itr = std::find_if(PowerCosts.cbegin(), PowerCosts.cend(), [powerType](SpellPowerEntry const* spellPowerEntry)
 {
 return spellPowerEntry && spellPowerEntry->PowerType == powerType;
 });
 if (itr == PowerCosts.cend())
 return {};
 
 return CalcPowerCost(*itr, optionalCost, caster, schoolMask, spell);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalcPowerCost() [2/3]

Optional< SpellPowerCost > SpellInfo::CalcPowerCost	(	SpellPowerEntry const *	power,
		bool	optionalCost,
		WorldObject const *	caster,
		SpellSchoolMask	schoolMask,
		Spell *	spell = `nullptr`
	)		const

{
 // gameobject casts don't use power
 Unit const* unitCaster = caster->ToUnit();
 if (!unitCaster)
 return {};
 
 if (power->RequiredAuraSpellID && !unitCaster->HasAura(power->RequiredAuraSpellID))
 return {};
 
 // Spell drain all exist power on cast (Only paladin lay of Hands)
 if (HasAttribute(SPELL_ATTR1_USE_ALL_MANA))
 {
 // If power type - health drain all
 if (power->PowerType == POWER_HEALTH)
 {
 SpellPowerCost cost;
 cost.Power = POWER_HEALTH;
 cost.Amount = unitCaster->GetHealth();
 return cost;
 }
 // Else drain all power
 if (power->PowerType < MAX_POWERS)
 {
 SpellPowerCost cost;
 cost.Power = Powers(power->PowerType);
 cost.Amount = unitCaster->GetPower(cost.Power);
 return cost;
 }
 
 TC_LOG_ERROR("spells", "SpellInfo::CalcPowerCost: Unknown power type '{}' in spell {}", power->PowerType, Id);
 return {};
 }
 
 // Base powerCost
 int32 powerCost = 0;
 if (!optionalCost)
 {
 powerCost = power->ManaCost;
 // PCT cost from total amount
 if (power->PowerCostPct)
 {
 switch (power->PowerType)
 {
 // health as power used
 case POWER_HEALTH:
 if (G3D::fuzzyEq(power->PowerCostPct, 0.0f))
 powerCost += int32(CalculatePct(unitCaster->GetMaxHealth(), power->PowerCostMaxPct));
 else
 powerCost += int32(CalculatePct(unitCaster->GetMaxHealth(), power->PowerCostPct));
 break;
 case POWER_MANA:
 powerCost += int32(CalculatePct(unitCaster->GetCreateMana(), power->PowerCostPct));
 break;
 case POWER_ALTERNATE_POWER:
 TC_LOG_ERROR("spells", "SpellInfo::CalcPowerCost: Unknown power type POWER_ALTERNATE_POWER in spell {}", Id);
 return {};
 default:
 {
 if (PowerTypeEntry const* powerTypeEntry = sDB2Manager.GetPowerTypeEntry(Powers(power->PowerType)))
 {
 powerCost += int32(CalculatePct(powerTypeEntry->MaxBasePower, power->PowerCostPct));
 break;
 }
 
 TC_LOG_ERROR("spells", "SpellInfo::CalcPowerCost: Unknown power type '{}' in spell {}", power->PowerType, Id);
 return {};
 }
 }
 }
 }
 else
 {
 powerCost = int32(power->OptionalCost);
 
 if (power->OptionalCostPct)
 {
 switch (power->PowerType)
 {
 // health as power used
 case POWER_HEALTH:
 powerCost += int32(CalculatePct(unitCaster->GetMaxHealth(), power->OptionalCostPct));
 break;
 case POWER_MANA:
 powerCost += int32(CalculatePct(unitCaster->GetCreateMana(), power->OptionalCostPct));
 break;
 case POWER_ALTERNATE_POWER:
 TC_LOG_ERROR("spells", "SpellInfo::CalcPowerCost: Unsupported power type POWER_ALTERNATE_POWER in spell {} for optional cost percent", Id);
 return {};
 default:
 {
 if (PowerTypeEntry const* powerTypeEntry = sDB2Manager.GetPowerTypeEntry(Powers(power->PowerType)))
 {
 powerCost += int32(CalculatePct(powerTypeEntry->MaxBasePower, power->OptionalCostPct));
 break;
 }
 
 TC_LOG_ERROR("spells", "SpellInfo::CalcPowerCost: Unknown power type '{}' in spell {} for optional cost percent", power->PowerType, Id);
 return {};
 }
 }
 }
 
 powerCost += unitCaster->GetTotalAuraModifier(SPELL_AURA_MOD_ADDITIONAL_POWER_COST, [this, power](AuraEffect const* aurEff) -> bool
 {
 return aurEff->GetMiscValue() == power->PowerType
 && aurEff->IsAffectingSpell(this);
 });
 }
 
 bool initiallyNegative = powerCost < 0;
 
 // Shiv - costs 20 + weaponSpeed*10 energy (apply only to non-triggered spell with energy cost)
 if (HasAttribute(SPELL_ATTR4_WEAPON_SPEED_COST_SCALING))
 {
 uint32 speed = 0;
 if (SpellShapeshiftFormEntry const* ss = sSpellShapeshiftFormStore.LookupEntry(unitCaster->GetShapeshiftForm()))
 speed = ss->CombatRoundTime;
 else
 {
 WeaponAttackType slot = BASE_ATTACK;
 if (!HasAttribute(SPELL_ATTR3_REQUIRES_MAIN_HAND_WEAPON) && HasAttribute(SPELL_ATTR3_REQUIRES_OFF_HAND_WEAPON))
 slot = OFF_ATTACK;
 
 speed = unitCaster->GetBaseAttackTime(slot);
 }
 
 powerCost += speed / 100;
 }
 
 if (power->PowerType != POWER_HEALTH)
 {
 if (!optionalCost)
 {
 // Flat mod from caster auras by spell school and power type
 for (AuraEffect const* aura : unitCaster->GetAuraEffectsByType(SPELL_AURA_MOD_POWER_COST_SCHOOL))
 {
 if (!(aura->GetMiscValue() & schoolMask))
 continue;
 
 if (!(aura->GetMiscValueB() & (1 << power->PowerType)))
 continue;
 
 powerCost += aura->GetAmount();
 }
 }
 
 // PCT mod from user auras by spell school and power type
 for (auto schoolCostPct : unitCaster->GetAuraEffectsByType(SPELL_AURA_MOD_POWER_COST_SCHOOL_PCT))
 {
 if (!(schoolCostPct->GetMiscValue() & schoolMask))
 continue;
 
 if (!(schoolCostPct->GetMiscValueB() & (1 << power->PowerType)))
 continue;
 
 powerCost += CalculatePct(powerCost, schoolCostPct->GetAmount());
 }
 }
 
 // Apply cost mod by spell
 if (Player* modOwner = unitCaster->GetSpellModOwner())
 {
 Optional<SpellModOp> mod;
 switch (power->OrderIndex)
 {
 case 0:
 mod = SpellModOp::PowerCost0;
 break;
 case 1:
 mod = SpellModOp::PowerCost1;
 break;
 case 2:
 mod = SpellModOp::PowerCost2;
 break;
 default:
 break;
 }
 
 if (mod)
 {
 if (!optionalCost)
 modOwner->ApplySpellMod(this, *mod, powerCost, spell);
 else
 {
 // optional cost ignores flat modifiers
 int32 flatMod = 0;
 float pctMod = 1.0f;
 modOwner->GetSpellModValues(this, *mod, spell, powerCost, &flatMod, &pctMod);
 powerCost = int32(powerCost * pctMod);
 }
 }
 }
 
 if (!unitCaster->IsControlledByPlayer() && G3D::fuzzyEq(power->PowerCostPct, 0.0f) && SpellLevel && power->PowerType == POWER_MANA)
 {
 if (HasAttribute(SPELL_ATTR0_SCALES_WITH_CREATURE_LEVEL))
 {
 GtNpcManaCostScalerEntry const* spellScaler = sNpcManaCostScalerGameTable.GetRow(SpellLevel);
 GtNpcManaCostScalerEntry const* casterScaler = sNpcManaCostScalerGameTable.GetRow(unitCaster->GetLevel());
 if (spellScaler && casterScaler)
 powerCost *= casterScaler->Scaler / spellScaler->Scaler;
 }
 }
 
 if (power->PowerType == POWER_MANA)
 powerCost = float(powerCost) * (1.0f + unitCaster->m_unitData->ManaCostMultiplier);
 
 // power cost cannot become negative if initially positive
 if (initiallyNegative != (powerCost < 0))
 powerCost = 0;
 
 SpellPowerCost cost;
 cost.Power = Powers(power->PowerType);
 cost.Amount = powerCost;
 return cost;
}

Here is the call graph for this function:

◆ CalcPowerCost() [3/3]

std::vector< SpellPowerCost > SpellInfo::CalcPowerCost	(	WorldObject const *	caster,
		SpellSchoolMask	schoolMask,
		Spell *	spell = `nullptr`
	)		const

{
 std::vector<SpellPowerCost> costs;
 if (caster->IsUnit())
 {
 costs.reserve(MAX_POWERS_PER_SPELL);
 
 auto getOrCreatePowerCost = [&](Powers powerType) -> SpellPowerCost&
 {
 auto itr = std::find_if(costs.begin(), costs.end(), [powerType](SpellPowerCost const& cost)
 {
 return cost.Power == powerType;
 });
 if (itr != costs.end())
 return *itr;
 
 SpellPowerCost cost;
 cost.Power = powerType;
 cost.Amount = 0;
 costs.push_back(cost);
 return costs.back();
 };
 
 for (SpellPowerEntry const* power : PowerCosts)
 {
 if (!power)
 continue;
 
 if (Optional<SpellPowerCost> cost = CalcPowerCost(power, false, caster, schoolMask, spell))
 getOrCreatePowerCost(cost->Power).Amount += cost->Amount;
 
 if (Optional<SpellPowerCost> optionalCost = CalcPowerCost(power, true, caster, schoolMask, spell))
 {
 SpellPowerCost& cost = getOrCreatePowerCost(optionalCost->Power);
 int32 remainingPower = caster->ToUnit()->GetPower(optionalCost->Power) - cost.Amount;
 if (remainingPower > 0)
 cost.Amount += std::min(optionalCost->Amount, remainingPower);
 }
 }
 }
 
 return costs;
}

Here is the call graph for this function:

◆ CalcProcPPM()

float SpellInfo::CalcProcPPM	(	Unit *	caster,
		int32	itemLevel
	)		const

{
 float ppm = ProcBasePPM;
 if (!caster)
 return ppm;
 
 for (SpellProcsPerMinuteModEntry const* mod : ProcPPMMods)
 {
 switch (mod->Type)
 {
 case SPELL_PPM_MOD_HASTE:
 {
 ppm *= 1.0f + CalcPPMHasteMod(mod, caster);
 break;
 }
 case SPELL_PPM_MOD_CRIT:
 {
 ppm *= 1.0f + CalcPPMCritMod(mod, caster);
 break;
 }
 case SPELL_PPM_MOD_CLASS:
 {
 if (caster->GetClassMask() & mod->Param)
 ppm *= 1.0f + mod->Coeff;
 break;
 }
 case SPELL_PPM_MOD_SPEC:
 {
 if (Player* plrCaster = caster->ToPlayer())
 if (plrCaster->GetPrimarySpecialization() == uint32(mod->Param))
 ppm *= 1.0f + mod->Coeff;
 break;
 }
 case SPELL_PPM_MOD_RACE:
 {
 if (caster->GetRaceMask() & mod->Param)
 ppm *= 1.0f + mod->Coeff;
 break;
 }
 case SPELL_PPM_MOD_ITEM_LEVEL:
 {
 ppm *= 1.0f + CalcPPMItemLevelMod(mod, itemLevel);
 break;
 }
 case SPELL_PPM_MOD_BATTLEGROUND:
 {
 if (caster->GetMap()->IsBattlegroundOrArena())
 ppm *= 1.0f + mod->Coeff;
 break;
 }
 default:
 break;
 }
 }
 
 return ppm;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CanBeInterrupted()

bool SpellInfo::CanBeInterrupted	(	WorldObject const *	interruptCaster,
		Unit const *	interruptTarget,
		bool	ignoreImmunity = `false`
	)		const

{
 return HasAttribute(SPELL_ATTR7_CAN_ALWAYS_BE_INTERRUPTED)
 || HasChannelInterruptFlag(SpellAuraInterruptFlags::Damage | SpellAuraInterruptFlags::EnteringCombat)
 || (interruptTarget->IsPlayer() && InterruptFlags.HasFlag(SpellInterruptFlags::DamageCancelsPlayerOnly))
 || InterruptFlags.HasFlag(SpellInterruptFlags::DamageCancels)
 || (interruptCaster && interruptCaster->IsUnit() && interruptCaster->ToUnit()->HasAuraTypeWithMiscvalue(SPELL_AURA_ALLOW_INTERRUPT_SPELL, Id))
 || ((!(interruptTarget->GetMechanicImmunityMask() & (1 << MECHANIC_INTERRUPT)) || ignoreImmunity)
 && !interruptTarget->HasAuraTypeWithAffectMask(SPELL_AURA_PREVENT_INTERRUPT, this)
 && PreventionType & SPELL_PREVENTION_TYPE_SILENCE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CanBeUsedInCombat()

bool SpellInfo::CanBeUsedInCombat ( ) const

{
 return !HasAttribute(SPELL_ATTR0_NOT_IN_COMBAT_ONLY_PEACEFUL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CanDispelAura()

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

{
 // These auras (like Divine Shield) can't be dispelled
 if (auraSpellInfo->HasAttribute(SPELL_ATTR0_NO_IMMUNITIES))
 return false;
 
 // These spells (like Mass Dispel) can dispel all auras
 if (HasAttribute(SPELL_ATTR0_NO_IMMUNITIES))
 return true;
 
 // These auras (Cyclone for example) are not dispelable
 if ((auraSpellInfo->HasAttribute(SPELL_ATTR1_IMMUNITY_TO_HOSTILE_AND_FRIENDLY_EFFECTS) && auraSpellInfo->Mechanic != MECHANIC_NONE)
 || auraSpellInfo->HasAttribute(SPELL_ATTR2_NO_SCHOOL_IMMUNITIES))
 return false;
 
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CanPierceImmuneAura()

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

{
 // aura can't be pierced
 if (!auraSpellInfo || auraSpellInfo->HasAttribute(SPELL_ATTR0_NO_IMMUNITIES))
 return false;
 
 // these spells pierce all available spells (Resurrection Sickness for example)
 if (HasAttribute(SPELL_ATTR0_NO_IMMUNITIES))
 return true;
 
 // these spells (Cyclone for example) can pierce all...
 if (HasAttribute(SPELL_ATTR1_IMMUNITY_TO_HOSTILE_AND_FRIENDLY_EFFECTS) || HasAttribute(SPELL_ATTR2_NO_SCHOOL_IMMUNITIES))
 {
 // ...but not these (Divine shield, Ice block, Cyclone and Banish for example)
 if (auraSpellInfo->Mechanic != MECHANIC_IMMUNE_SHIELD &&
 auraSpellInfo->Mechanic != MECHANIC_INVULNERABILITY &&
 (auraSpellInfo->Mechanic != MECHANIC_BANISH || (IsRankOf(auraSpellInfo) && auraSpellInfo->Dispel != DISPEL_NONE))) // Banish shouldn't be immune to itself, but Cyclone should
 return true;
 }
 
 // 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CanSpellProvideImmunityAgainstAura()

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

{
 if (!auraSpellInfo)
 return false;
 
 for (SpellEffectInfo const& effectInfo : _effects)
 {
 if (!effectInfo.IsEffect())
 continue;
 
 SpellEffectInfo::ImmunityInfo const* immuneInfo = effectInfo.GetImmunityInfo();
 if (!immuneInfo)
 continue;
 
 if (!auraSpellInfo->HasAttribute(SPELL_ATTR1_IMMUNITY_TO_HOSTILE_AND_FRIENDLY_EFFECTS) && !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 & (UI64LIT(1) << auraSpellInfo->Mechanic)) != 0)
 return true;
 
 if (uint32 dispelImmunity = immuneInfo->DispelImmune)
 if (auraSpellInfo->Dispel == dispelImmunity)
 return true;
 
 bool immuneToAllEffects = true;
 for (SpellEffectInfo const& auraSpellEffectInfo : auraSpellInfo->GetEffects())
 {
 if (!auraSpellEffectInfo.IsEffect())
 continue;
 
 auto spellImmuneItr = immuneInfo->SpellEffectImmune.find(auraSpellEffectInfo.Effect);
 if (spellImmuneItr == immuneInfo->SpellEffectImmune.end())
 {
 immuneToAllEffects = false;
 break;
 }
 
 if (uint32 mechanic = auraSpellEffectInfo.Mechanic)
 {
 if (!(immuneInfo->MechanicImmuneMask & (UI64LIT(1) << mechanic)))
 {
 immuneToAllEffects = false;
 break;
 }
 }
 
 if (!auraSpellInfo->HasAttribute(SPELL_ATTR3_ALWAYS_HIT))
 {
 if (AuraType auraName = auraSpellEffectInfo.ApplyAuraName)
 {
 bool isImmuneToAuraEffectApply = false;
 auto auraImmuneItr = immuneInfo->AuraTypeImmune.find(auraName);
 if (auraImmuneItr != immuneInfo->AuraTypeImmune.end())
 isImmuneToAuraEffectApply = true;
 
 if (!isImmuneToAuraEffectApply && !auraSpellInfo->IsPositiveEffect(auraSpellEffectInfo.EffectIndex) && !auraSpellInfo->HasAttribute(SPELL_ATTR2_NO_SCHOOL_IMMUNITIES))
 {
 if (uint32 applyHarmfulAuraImmunityMask = immuneInfo->ApplyHarmfulAuraImmuneMask)
 if ((auraSpellInfo->GetSchoolMask() & applyHarmfulAuraImmunityMask) != 0)
 isImmuneToAuraEffectApply = true;
 }
 
 if (!isImmuneToAuraEffectApply)
 {
 immuneToAllEffects = false;
 break;
 }
 }
 }
 }
 
 if (immuneToAllEffects)
 return true;
 }
 
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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;
 }
 
 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))
 {
 Unit const* unitCaster = caster->ToUnit();
 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) && unitCaster)
 if (unitTarget->GetGUID() == unitCaster->GetCritterGUID())
 return SPELL_CAST_OK;
 if ((neededTargets & TARGET_FLAG_UNIT_PASSENGER) && unitCaster)
 if (unitTarget->IsOnVehicle(unitCaster))
 return SPELL_CAST_OK;
 return SPELL_FAILED_BAD_TARGETS;
 }
 }
 return SPELL_CAST_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CheckLocation()

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

{
 // normal case
 if (RequiredAreasID > 0)
 {
 bool found = false;
 std::vector<uint32> areaGroupMembers = sDB2Manager.GetAreasForGroup(RequiredAreasID);
 for (uint32 areaId : areaGroupMembers)
 {
 if (areaId == zone_id || areaId == area_id)
 {
 found = true;
 break;
 }
 }
 
 if (!found)
 return SPELL_FAILED_INCORRECT_AREA;
 }
 
 // continent limitation (virtual continent)
 if (HasAttribute(SPELL_ATTR4_ONLY_FLYING_AREAS))
 {
 uint32 mountFlags = 0;
 if (player && player->HasAuraType(SPELL_AURA_MOUNT_RESTRICTIONS))
 {
 for (AuraEffect const* auraEffect : player->GetAuraEffectsByType(SPELL_AURA_MOUNT_RESTRICTIONS))
 mountFlags |= auraEffect->GetMiscValue();
 }
 else if (AreaTableEntry const* areaTable = sAreaTableStore.LookupEntry(area_id))
 mountFlags = areaTable->MountFlags;
 
 if (!(mountFlags & AREA_MOUNT_FLAG_FLYING_ALLOWED))
 return SPELL_FAILED_INCORRECT_AREA;
 
 if (player)
 {
 uint32 mapToCheck = map_id;
 if (MapEntry const* mapEntry = sMapStore.LookupEntry(map_id))
 mapToCheck = mapEntry->CosmeticParentMapID;
 
 if ((mapToCheck == 1116 || mapToCheck == 1464) && !player->HasSpell(191645)) // Draenor Pathfinder
 return SPELL_FAILED_INCORRECT_AREA;
 else if (mapToCheck == 1220 && !player->HasSpell(233368)) // Broken Isles Pathfinder
 return SPELL_FAILED_INCORRECT_AREA;
 else if ((mapToCheck == 1642 || mapToCheck == 1643) && !player->HasSpell(278833)) // Battle for Azeroth Pathfinder
 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 == 489 && player && player->InBattleground() ? SPELL_CAST_OK : SPELL_FAILED_REQUIRES_AREA;
 case 34976: // Netherstorm Flag
 return map_id == 566 && 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 44521: // Preparation
 {
 if (!player)
 return SPELL_FAILED_REQUIRES_AREA;
 
 MapEntry const* mapEntry = sMapStore.LookupEntry(map_id);
 if (!mapEntry)
 return SPELL_FAILED_INCORRECT_AREA;
 
 if (!mapEntry->IsBattleground())
 return SPELL_FAILED_REQUIRES_AREA;
 
 Battleground* bg = player->GetBattleground();
 return bg && bg->GetStatus() == STATUS_WAIT_JOIN ? 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;
 }
 case 32727: // Arena Preparation
 {
 if (!player)
 return SPELL_FAILED_REQUIRES_AREA;
 
 MapEntry const* mapEntry = sMapStore.LookupEntry(map_id);
 if (!mapEntry)
 return SPELL_FAILED_INCORRECT_AREA;
 
 if (!mapEntry->IsBattleArena())
 return SPELL_FAILED_REQUIRES_AREA;
 
 Battleground* bg = player->GetBattleground();
 return bg && bg->GetStatus() == STATUS_WAIT_JOIN ? SPELL_CAST_OK : SPELL_FAILED_REQUIRES_AREA;
 }
 }
 
 // aura limitations
 if (player)
 {
 for (SpellEffectInfo const& effect : GetEffects())
 {
 if (!effect.IsAura())
 continue;
 
 switch (effect.ApplyAuraName)
 {
 case SPELL_AURA_MOD_SHAPESHIFT:
 {
 if (SpellShapeshiftFormEntry const* spellShapeshiftForm = sSpellShapeshiftFormStore.LookupEntry(effect.MiscValue))
 if (uint32 mountType = spellShapeshiftForm->MountTypeID)
 if (!player->GetMountCapability(mountType))
 return SPELL_FAILED_NOT_HERE;
 break;
 }
 case SPELL_AURA_MOUNTED:
 {
 uint32 mountType = effect.MiscValueB;
 if (MountEntry const* mountEntry = sDB2Manager.GetMount(Id))
 mountType = mountEntry->MountTypeID;
 if (mountType && !player->GetMountCapability(mountType))
 return SPELL_FAILED_NOT_HERE;
 break;
 }
 default:
 break;
 }
 }
 }
 
 return SPELL_CAST_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CheckShapeshift()

SpellCastResult SpellInfo::CheckShapeshift ( uint32 form ) const

{
 // talents that learn spells can have stance requirements that need ignore
 // (this requirement only for client-side stance show in talent description)
 /* TODO: 6.x fix this in proper way (probably spell flags/attributes?)
 if (GetTalentSpellCost(Id) > 0 && HasEffect(SPELL_EFFECT_LEARN_SPELL))
 return SPELL_CAST_OK;*/
 
 //if (HasAttribute(SPELL_ATTR13_ACTIVATES_REQUIRED_SHAPESHIFT))
 // return SPELL_CAST_OK;
 
 uint64 stanceMask = (form ? UI64LIT(1) << (form - 1) : 0);
 
 if (stanceMask & StancesNot) // can explicitly not be cast in this stance
 return SPELL_FAILED_NOT_SHAPESHIFT;
 
 if (stanceMask & Stances) // can explicitly be cast in this stance
 return SPELL_CAST_OK;
 
 bool actAsShifted = false;
 SpellShapeshiftFormEntry const* shapeInfo = nullptr;
 if (form > 0)
 {
 shapeInfo = sSpellShapeshiftFormStore.LookupEntry(form);
 if (!shapeInfo)
 {
 TC_LOG_ERROR("spells", "GetErrorAtShapeshiftedCast: unknown shapeshift {}", form);
 return SPELL_CAST_OK;
 }
 actAsShifted = !shapeInfo->GetFlags().HasFlag(SpellShapeshiftFormFlags::Stance);
 }
 
 if (actAsShifted)
 {
 if (HasAttribute(SPELL_ATTR0_NOT_SHAPESHIFTED) || (shapeInfo && shapeInfo->GetFlags().HasFlag(SpellShapeshiftFormFlags::CanOnlyCastShapeshiftSpells))) // not while shapeshifted
 return SPELL_FAILED_NOT_SHAPESHIFT;
 else if (Stances != 0) // needs other shapeshift
 return SPELL_FAILED_ONLY_SHAPESHIFT;
 }
 else
 {
 // needs shapeshift
 if (!HasAttribute(SPELL_ATTR2_ALLOW_WHILE_NOT_SHAPESHIFTED_CASTER_FORM) && Stances != 0)
 return SPELL_FAILED_ONLY_SHAPESHIFT;
 }
 
 return SPELL_CAST_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CheckTarget()

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

{
 if (HasAttribute(SPELL_ATTR1_EXCLUDE_CASTER) && caster == target)
 return SPELL_FAILED_BAD_TARGETS;
 
 // check visibility - ignore invisibility/stealth for implicit (area) targets
 if (!HasAttribute(SPELL_ATTR6_IGNORE_PHASE_SHIFT) && !caster->CanSeeOrDetect(target, implicit))
 return SPELL_FAILED_BAD_TARGETS;
 
 Unit const* unitTarget = target->ToUnit();
 
 // creature/player specific target checks
 if (unitTarget)
 {
 // spells cannot be cast if target has a pet in combat either
 if (HasAttribute(SPELL_ATTR1_ONLY_PEACEFUL_TARGETS) && (unitTarget->IsInCombat() || unitTarget->HasUnitFlag(UNIT_FLAG_PET_IN_COMBAT)))
 return SPELL_FAILED_TARGET_AFFECTING_COMBAT;
 
 // only spells with SPELL_ATTR3_ONLY_TARGET_GHOSTS can target ghosts
 if (HasAttribute(SPELL_ATTR3_ONLY_ON_GHOSTS) != unitTarget->HasAuraType(SPELL_AURA_GHOST))
 {
 if (HasAttribute(SPELL_ATTR3_ONLY_ON_GHOSTS))
 return SPELL_FAILED_TARGET_NOT_GHOST;
 else
 return SPELL_FAILED_BAD_TARGETS;
 }
 
 if (caster != unitTarget)
 {
 if (caster->GetTypeId() == TYPEID_PLAYER)
 {
 // Do not allow these spells to target creatures not tapped by us (Banish, Polymorph, many quest spells)
 if (HasAttribute(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 (!targetCreature->CanHaveLoot() || !LootTemplates_Pickpocketing.HaveLootFor(targetCreature->GetCreatureTemplate()->pickpocketLootId))
 return SPELL_FAILED_TARGET_NO_POCKETS;
 }
 
 // Not allow disarm unarmed player
 if (Mechanic == MECHANIC_DISARM)
 {
 if (unitTarget->GetTypeId() == TYPEID_PLAYER)
 {
 Player const* player = unitTarget->ToPlayer();
 if (!player->GetWeaponForAttack(BASE_ATTACK) || !player->IsUseEquipedWeapon(true))
 return SPELL_FAILED_TARGET_NO_WEAPONS;
 }
 else if (!unitTarget->GetVirtualItemId(0))
 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_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;
 }
 else if (HasAttribute(SPELL_ATTR5_NOT_ON_PLAYER))
 return SPELL_FAILED_TARGET_IS_PLAYER;
 
 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 && HasAttribute(SPELL_ATTR6_DO_NOT_CHAIN_TO_CROWD_CONTROLLED_TARGETS) && !unitTarget->CanFreeMove())
 return SPELL_FAILED_BAD_TARGETS;
 
 // checked in Unit::IsValidAttack/AssistTarget, shouldn't be checked for ENTRY targets
 //if (!HasAttribute(SPELL_ATTR6_CAN_TARGET_UNTARGETABLE) && target->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_UNINTERACTIBLE))
 // return SPELL_FAILED_BAD_TARGETS;
 
 if (!CheckTargetCreatureType(unitTarget))
 {
 if (target->GetTypeId() == TYPEID_PLAYER)
 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->GetTypeId() == TYPEID_PLAYER)
 {
 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->HasUnitState(UNIT_STATE_IN_FLIGHT) && !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 (Unit const* unitCaster = caster->ToUnit())
 {
 if (!unitCaster->IsVehicle() && !(unitCaster->GetCharmerOrOwner() == target))
 {
 if (TargetAuraState && !unitTarget->HasAuraState(AuraStateType(TargetAuraState), this, unitCaster))
 return SPELL_FAILED_TARGET_AURASTATE;
 
 if (ExcludeTargetAuraState && unitTarget->HasAuraState(AuraStateType(ExcludeTargetAuraState), this, unitCaster))
 return SPELL_FAILED_TARGET_AURASTATE;
 }
 }
 
 if (TargetAuraSpell && !unitTarget->HasAura(TargetAuraSpell))
 return SPELL_FAILED_TARGET_AURASTATE;
 
 if (ExcludeTargetAuraSpell && unitTarget->HasAura(ExcludeTargetAuraSpell))
 return SPELL_FAILED_TARGET_AURASTATE;
 
 if (unitTarget->HasAuraType(SPELL_AURA_PREVENT_RESURRECTION) && !HasAttribute(SPELL_ATTR7_BYPASS_NO_RESURRECT_AURA))
 if (HasEffect(SPELL_EFFECT_SELF_RESURRECT) || HasEffect(SPELL_EFFECT_RESURRECT))
 return SPELL_FAILED_TARGET_CANNOT_BE_RESURRECTED;
 
 if (HasAttribute(SPELL_ATTR8_BATTLE_RESURRECTION))
 if (Map* map = caster->GetMap())
 if (InstanceMap* iMap = map->ToInstanceMap())
 if (InstanceScript* instance = iMap->GetInstanceScript())
 if (instance->GetCombatResurrectionCharges() == 0 && instance->IsEncounterInProgress())
 return SPELL_FAILED_TARGET_CANNOT_BE_RESURRECTED;
 
 return SPELL_CAST_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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->GetTypeId() == TYPEID_PLAYER)
 return false;
 else
 return true;
 }
 
 // if target is magnet (i.e Grounding Totem) the check is skipped
 if (target->IsMagnet())
 return true;
 
 uint32 creatureType = target->GetCreatureTypeMask();
 return !TargetCreatureType || !creatureType || (creatureType & TargetCreatureType);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CheckVehicle()

SpellCastResult SpellInfo::CheckVehicle ( Unit const * caster ) const

{
 // All creatures should be able to cast as passengers freely, restriction and attribute are only for players
 if (caster->GetTypeId() != TYPEID_PLAYER)
 return SPELL_CAST_OK;
 
 Vehicle* vehicle = caster->GetVehicle();
 if (vehicle)
 {
 uint16 checkMask = 0;
 for (SpellEffectInfo const& effect : GetEffects())
 {
 if (effect.IsAura(SPELL_AURA_MOD_SHAPESHIFT))
 {
 SpellShapeshiftFormEntry const* shapeShiftFromEntry = sSpellShapeshiftFormStore.LookupEntry(effect.MiscValue);
 if (shapeShiftFromEntry && (shapeShiftFromEntry->Flags & 1) == 0) // unk flag
 checkMask |= VEHICLE_SEAT_FLAG_UNCONTROLLED;
 break;
 }
 }
 
 if (HasAura(SPELL_AURA_MOUNTED))
 checkMask |= VEHICLE_SEAT_FLAG_CAN_CAST_MOUNT_SPELL;
 
 if (!checkMask)
 checkMask = VEHICLE_SEAT_FLAG_CAN_ATTACK;
 
 VehicleSeatEntry const* vehicleSeat = vehicle->GetSeatForPassenger(caster);
 if (!HasAttribute(SPELL_ATTR6_ALLOW_WHILE_RIDING_VEHICLE) && !HasAttribute(SPELL_ATTR0_ALLOW_WHILE_MOUNTED)
 && (vehicleSeat->Flags & checkMask) != checkMask)
 return SPELL_FAILED_CANT_DO_THAT_RIGHT_NOW;
 
 // Can only summon uncontrolled minions/guardians when on controlled vehicle
 if (vehicleSeat->Flags & (VEHICLE_SEAT_FLAG_CAN_CONTROL | VEHICLE_SEAT_FLAG_UNK2))
 {
 for (SpellEffectInfo const& effect : GetEffects())
 {
 if (!effect.IsEffect(SPELL_EFFECT_SUMMON))
 continue;
 
 SummonPropertiesEntry const* props = sSummonPropertiesStore.LookupEntry(effect.MiscValueB);
 if (props && props->Control != SUMMON_CATEGORY_WILD)
 return SPELL_FAILED_CANT_DO_THAT_RIGHT_NOW;
 }
 }
 }
 
 return SPELL_CAST_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetAllEffectsMechanicMask()

uint64 SpellInfo::GetAllEffectsMechanicMask ( ) const

{
 uint64 mask = 0;
 if (Mechanic)
 mask |= UI64LIT(1) << Mechanic;
 
 for (SpellEffectInfo const& effect : GetEffects())
 if (effect.IsEffect() && effect.Mechanic)
 mask |= UI64LIT(1) << effect.Mechanic;
 
 return mask;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetAllowedMechanicMask()

uint64 SpellInfo::GetAllowedMechanicMask ( ) const

{
 return _allowedMechanicMask;
}

Here is the caller graph for this function:

◆ GetAttackType()

WeaponAttackType SpellInfo::GetAttackType ( ) const

{
 WeaponAttackType result;
 switch (DmgClass)
 {
 case SPELL_DAMAGE_CLASS_MELEE:
 if (HasAttribute(SPELL_ATTR3_REQUIRES_OFF_HAND_WEAPON))
 result = OFF_ATTACK;
 else
 result = BASE_ATTACK;
 break;
 case SPELL_DAMAGE_CLASS_RANGED:
 result = IsRangedWeaponSpell() ? RANGED_ATTACK : BASE_ATTACK;
 break;
 default:
 // Wands
 if (IsAutoRepeatRangedSpell())
 result = RANGED_ATTACK;
 else
 result = BASE_ATTACK;
 break;
 }
 
 return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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_AURA_IS_DEBUFF) || HasAttribute(SPELL_ATTR2_ALLOW_LOW_LEVEL_BUFF) || HasAttribute(SPELL_ATTR3_ONLY_PROC_ON_CASTER))
 return this;
 
 bool needRankSelection = false;
 for (SpellEffectInfo const& effect : GetEffects())
 {
 if (IsPositiveEffect(effect.EffectIndex) &&
 (effect.Effect == SPELL_EFFECT_APPLY_AURA ||
 effect.Effect == SPELL_EFFECT_APPLY_AREA_AURA_PARTY ||
 effect.Effect == SPELL_EFFECT_APPLY_AREA_AURA_RAID) &&
 !effect.Scaling.Coefficient)
 {
 needRankSelection = true;
 break;
 }
 }
 
 // not required
 if (!needRankSelection)
 return this;
 
 for (SpellInfo const* 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetAuraState()

AuraStateType SpellInfo::GetAuraState ( ) const

{
 return _auraState;
}

Here is the caller graph for this function:

◆ GetCategory()

uint32 SpellInfo::GetCategory ( ) const

{
 return CategoryId;
}

Here is the caller graph for this function:

◆ GetDiminishingReturnsGroupForSpell()

DiminishingGroup SpellInfo::GetDiminishingReturnsGroupForSpell ( ) const

{
 return _diminishInfo.DiminishGroup;
}

Here is the caller graph for this function:

◆ GetDiminishingReturnsGroupType()

DiminishingReturnsType SpellInfo::GetDiminishingReturnsGroupType ( ) const

{
 return _diminishInfo.DiminishReturnType;
}

Here is the caller graph for this function:

◆ GetDiminishingReturnsLimitDuration()

int32 SpellInfo::GetDiminishingReturnsLimitDuration ( ) const

{
 return _diminishInfo.DiminishDurationLimit;
}

Here is the caller graph for this function:

◆ GetDiminishingReturnsMaxLevel()

DiminishingLevels SpellInfo::GetDiminishingReturnsMaxLevel ( ) const

{
 return _diminishInfo.DiminishMaxLevel;
}

Here is the caller graph for this function:

◆ GetDispelMask() [1/2]

uint32 SpellInfo::GetDispelMask ( ) const

{
 return GetDispelMask(DispelType(Dispel));
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

◆ GetDuration()

int32 SpellInfo::GetDuration ( ) const

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetEffect()

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

inline

574{ ASSERT(index < _effects.size()); return _effects[index]; }

ASSERT

#define ASSERT

Definition: Errors.h:68

Here is the caller graph for this function:

◆ GetEffectMechanic()

Mechanics SpellInfo::GetEffectMechanic ( SpellEffIndex effIndex ) const

{
 if (GetEffect(effIndex).IsEffect() && GetEffect(effIndex).Mechanic)
 return GetEffect(effIndex).Mechanic;
 
 if (Mechanic)
 return Mechanics(Mechanic);
 
 return MECHANIC_NONE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetEffectMechanicMask()

uint64 SpellInfo::GetEffectMechanicMask ( SpellEffIndex effIndex ) const

{
 uint64 mask = 0;
 if (Mechanic)
 mask |= UI64LIT(1) << Mechanic;
 
 if (GetEffect(effIndex).IsEffect() && GetEffect(effIndex).Mechanic)
 mask |= UI64LIT(1) << GetEffect(effIndex).Mechanic;
 
 return mask;
}

Here is the call graph for this function:

◆ GetEffects()

std::vector< SpellEffectInfo > const & SpellInfo::GetEffects ( ) const

inline

573{ return _effects; }

◆ GetExplicitTargetMask()

uint32 SpellInfo::GetExplicitTargetMask ( ) const

{
 return ExplicitTargetMask;
}

Here is the caller graph for this function:

◆ GetFirstRankSpell()

SpellInfo const * SpellInfo::GetFirstRankSpell ( ) const

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

Here is the caller graph for this function:

◆ GetLastRankSpell()

SpellInfo const * SpellInfo::GetLastRankSpell ( ) const

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

◆ GetMaxDuration()

int32 SpellInfo::GetMaxDuration ( ) const

{
 if (!DurationEntry)
 return IsPassive() ? -1 : 0;
 return (DurationEntry->MaxDuration == -1) ? -1 : abs(DurationEntry->MaxDuration);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMaxRange()

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMaxTicks()

uint32 SpellInfo::GetMaxTicks ( ) const

{
 uint32 totalTicks = 0;
 int32 DotDuration = GetDuration();
 
 for (SpellEffectInfo const& effect : GetEffects())
 {
 if (effect.IsEffect(SPELL_EFFECT_APPLY_AURA))
 {
 switch (effect.ApplyAuraName)
 {
 case SPELL_AURA_PERIODIC_DAMAGE:
 case SPELL_AURA_PERIODIC_DAMAGE_PERCENT:
 case SPELL_AURA_PERIODIC_HEAL:
 case SPELL_AURA_OBS_MOD_HEALTH:
 case SPELL_AURA_OBS_MOD_POWER:
 case SPELL_AURA_PERIODIC_TRIGGER_SPELL_FROM_CLIENT:
 case SPELL_AURA_POWER_BURN:
 case SPELL_AURA_PERIODIC_LEECH:
 case SPELL_AURA_PERIODIC_MANA_LEECH:
 case SPELL_AURA_PERIODIC_ENERGIZE:
 case SPELL_AURA_PERIODIC_DUMMY:
 case SPELL_AURA_PERIODIC_TRIGGER_SPELL:
 case SPELL_AURA_PERIODIC_TRIGGER_SPELL_WITH_VALUE:
 case SPELL_AURA_PERIODIC_HEALTH_FUNNEL:
 // skip infinite periodics
 if (effect.ApplyAuraPeriod > 0 && DotDuration > 0)
 {
 totalTicks = static_cast<uint32>(DotDuration) / effect.ApplyAuraPeriod;
 if (HasAttribute(SPELL_ATTR5_EXTRA_INITIAL_PERIOD))
 ++totalTicks;
 }
 break;
 default:
 break;
 }
 }
 }
 
 return totalTicks;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMechanicImmunityMask()

uint64 SpellInfo::GetMechanicImmunityMask ( Unit const * caster ) const

{
 uint64 casterMechanicImmunityMask = caster->GetMechanicImmunityMask();
 uint64 mechanicImmunityMask = 0;
 
 if (CanBeInterrupted(nullptr, caster, true))
 {
 if (casterMechanicImmunityMask & (1 << MECHANIC_SILENCE))
 mechanicImmunityMask |= (1 << MECHANIC_SILENCE);
 
 if (casterMechanicImmunityMask & (1 << MECHANIC_INTERRUPT))
 mechanicImmunityMask |= (1 << MECHANIC_INTERRUPT);
 }
 
 return mechanicImmunityMask;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMinRange()

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

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

Here is the caller graph for this function:

◆ GetNextRankSpell()

SpellInfo const * SpellInfo::GetNextRankSpell ( ) const

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

Here is the caller graph for this function:

◆ GetPrevRankSpell()

SpellInfo const * SpellInfo::GetPrevRankSpell ( ) const

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

Here is the caller graph for this function:

◆ GetRank()

uint8 SpellInfo::GetRank ( ) const

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

Here is the caller graph for this function:

◆ GetRecoveryTime()

uint32 SpellInfo::GetRecoveryTime ( ) const

{
 return RecoveryTime > CategoryRecoveryTime ? RecoveryTime : CategoryRecoveryTime;
}

Here is the caller graph for this function:

◆ GetSchoolMask()

SpellSchoolMask SpellInfo::GetSchoolMask ( ) const

{
 return SpellSchoolMask(SchoolMask);
}

Here is the caller graph for this function:

◆ GetSpellMechanicMaskByEffectMask()

uint64 SpellInfo::GetSpellMechanicMaskByEffectMask ( uint32 effectMask ) const

{
 uint64 mask = 0;
 if (Mechanic)
 mask |= UI64LIT(1) << Mechanic;
 
 for (SpellEffectInfo const& effect : GetEffects())
 if ((effectMask & (1 << effect.EffectIndex)) && effect.Mechanic)
 mask |= UI64LIT(1) << effect.Mechanic;
 
 return mask;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetSpellSpecific()

SpellSpecificType SpellInfo::GetSpellSpecific ( ) const

{
 return _spellSpecific;
};

Here is the caller graph for this function:

◆ GetSpellVisual()

uint32 SpellInfo::GetSpellVisual	(	WorldObject const *	caster = `nullptr`,
		WorldObject const *	viewer = `nullptr`
	)		const

{
 if (SpellXSpellVisualEntry const* visual = sSpellXSpellVisualStore.LookupEntry(GetSpellXSpellVisualId(caster, viewer)))
 {
 //if (visual->LowViolenceSpellVisualID && forPlayer->GetViolenceLevel() operator 2)
 // return visual->LowViolenceSpellVisualID;
 
 return visual->SpellVisualID;
 }
 
 return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetSpellXSpellVisualId()

uint32 SpellInfo::GetSpellXSpellVisualId	(	WorldObject const *	caster = `nullptr`,
		WorldObject const *	viewer = `nullptr`
	)		const

{
 for (SpellXSpellVisualEntry const* visual : _visuals)
 {
 if (PlayerConditionEntry const* playerCondition = sPlayerConditionStore.LookupEntry(visual->CasterPlayerConditionID))
 if (!caster || !caster->IsPlayer() || !ConditionMgr::IsPlayerMeetingCondition(caster->ToPlayer(), playerCondition))
 continue;
 
 if (UnitConditionEntry const* unitCondition = sUnitConditionStore.LookupEntry(visual->CasterUnitConditionID))
 if (!caster || !caster->IsUnit() || !ConditionMgr::IsUnitMeetingCondition(caster->ToUnit(), Object::ToUnit(viewer), unitCondition))
 continue;
 
 return visual->ID;
 }
 
 return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasAnyAuraInterruptFlag()

bool SpellInfo::HasAnyAuraInterruptFlag ( ) const

{
 return AuraInterruptFlags != SpellAuraInterruptFlags::None || AuraInterruptFlags2 != SpellAuraInterruptFlags2::None;
}

Here is the caller graph for this function:

◆ HasAreaAuraEffect()

bool SpellInfo::HasAreaAuraEffect ( ) const

{
 for (SpellEffectInfo const& effect : GetEffects())
 if (effect.IsAreaAuraEffect())
 return true;
 
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasAttribute() [1/16]

bool SpellInfo::HasAttribute ( SpellAttr0 attribute ) const

inline

445{ return !!(Attributes & attribute); }

◆ HasAttribute() [2/16]

bool SpellInfo::HasAttribute ( SpellAttr1 attribute ) const

inline

446{ return !!(AttributesEx & attribute); }

◆ HasAttribute() [3/16]

bool SpellInfo::HasAttribute ( SpellAttr10 attribute ) const

inline

455{ return !!(AttributesEx10 & attribute); }

◆ HasAttribute() [4/16]

bool SpellInfo::HasAttribute ( SpellAttr11 attribute ) const

inline

456{ return !!(AttributesEx11 & attribute); }

◆ HasAttribute() [5/16]

bool SpellInfo::HasAttribute ( SpellAttr12 attribute ) const

inline

457{ return !!(AttributesEx12 & attribute); }

◆ HasAttribute() [6/16]

bool SpellInfo::HasAttribute ( SpellAttr13 attribute ) const

inline

458{ return !!(AttributesEx13 & attribute); }

◆ HasAttribute() [7/16]

bool SpellInfo::HasAttribute ( SpellAttr14 attribute ) const

inline

459{ return !!(AttributesEx14 & attribute); }

◆ HasAttribute() [8/16]

bool SpellInfo::HasAttribute ( SpellAttr2 attribute ) const

inline

447{ return !!(AttributesEx2 & attribute); }

◆ HasAttribute() [9/16]

bool SpellInfo::HasAttribute ( SpellAttr3 attribute ) const

inline

448{ return !!(AttributesEx3 & attribute); }

◆ HasAttribute() [10/16]

bool SpellInfo::HasAttribute ( SpellAttr4 attribute ) const

inline

449{ return !!(AttributesEx4 & attribute); }

◆ HasAttribute() [11/16]

bool SpellInfo::HasAttribute ( SpellAttr5 attribute ) const

inline

450{ return !!(AttributesEx5 & attribute); }

◆ HasAttribute() [12/16]

bool SpellInfo::HasAttribute ( SpellAttr6 attribute ) const

inline

451{ return !!(AttributesEx6 & attribute); }

◆ HasAttribute() [13/16]

bool SpellInfo::HasAttribute ( SpellAttr7 attribute ) const

inline

452{ return !!(AttributesEx7 & attribute); }

◆ HasAttribute() [14/16]

bool SpellInfo::HasAttribute ( SpellAttr8 attribute ) const

inline

453{ return !!(AttributesEx8 & attribute); }

◆ HasAttribute() [15/16]

bool SpellInfo::HasAttribute ( SpellAttr9 attribute ) const

inline

454{ return !!(AttributesEx9 & attribute); }

◆ HasAttribute() [16/16]

bool SpellInfo::HasAttribute ( SpellCustomAttributes customAttribute ) const

inline

460{ return !!(AttributesCu & customAttribute); }

SpellInfo::AttributesCu

uint32 AttributesCu

Definition: SpellInfo.h:346

◆ HasAura()

bool SpellInfo::HasAura ( AuraType aura ) const

{
 for (SpellEffectInfo const& effect : GetEffects())
 if (effect.IsAura(aura))
 return true;
 
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasAuraInterruptFlag() [1/2]

bool SpellInfo::HasAuraInterruptFlag ( SpellAuraInterruptFlags flag ) const

inline

465{ return AuraInterruptFlags.HasFlag(flag); }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasAuraInterruptFlag() [2/2]

bool SpellInfo::HasAuraInterruptFlag ( SpellAuraInterruptFlags2 flag ) const

inline

466{ return AuraInterruptFlags2.HasFlag(flag); }

Here is the call graph for this function:

◆ HasChannelInterruptFlag() [1/2]

bool SpellInfo::HasChannelInterruptFlag ( SpellAuraInterruptFlags flag ) const

inline

468{ return ChannelInterruptFlags.HasFlag(flag); }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasChannelInterruptFlag() [2/2]

bool SpellInfo::HasChannelInterruptFlag ( SpellAuraInterruptFlags2 flag ) const

inline

469{ return ChannelInterruptFlags2.HasFlag(flag); }

Here is the call graph for this function:

◆ HasEffect()

bool SpellInfo::HasEffect ( SpellEffectName effect ) const

{
 for (SpellEffectInfo const& eff : GetEffects())
 if (eff.IsEffect(effect))
 return true;
 
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasHitDelay()

bool SpellInfo::HasHitDelay ( ) const

{
 return Speed > 0.0f || LaunchDelay > 0.0f;
}

Here is the caller graph for this function:

◆ HasInitialAggro()

bool SpellInfo::HasInitialAggro ( ) const

{
 return !(HasAttribute(SPELL_ATTR1_NO_THREAT) || HasAttribute(SPELL_ATTR2_NO_INITIAL_THREAT) || HasAttribute(SPELL_ATTR4_NO_HARMFUL_THREAT));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasLabel()

bool SpellInfo::HasLabel ( uint32 labelId ) const

{
 return Labels.find(labelId) != Labels.end();
}

Here is the caller graph for this function:

◆ HasOnlyDamageEffects()

bool SpellInfo::HasOnlyDamageEffects ( ) const

{
 for (SpellEffectInfo const& effect : GetEffects())
 {
 if (effect.IsEffect())
 {
 switch (effect.Effect)
 {
 case SPELL_EFFECT_WEAPON_DAMAGE:
 case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL:
 case SPELL_EFFECT_NORMALIZED_WEAPON_DMG:
 case SPELL_EFFECT_WEAPON_PERCENT_DAMAGE:
 case SPELL_EFFECT_SCHOOL_DAMAGE:
 case SPELL_EFFECT_ENVIRONMENTAL_DAMAGE:
 case SPELL_EFFECT_HEALTH_LEECH:
 case SPELL_EFFECT_DAMAGE_FROM_MAX_HEALTH_PCT:
 continue;
 default:
 return false;
 }
 }
 }
 
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasTargetType()

bool SpellInfo::HasTargetType ( ::Targets target ) const

{
 for (SpellEffectInfo const& effect : GetEffects())
 if (effect.TargetA.GetTarget() == target || effect.TargetB.GetTarget() == target)
 return true;
 
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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 == int32(skillType))
 return true;
 
 return false;
}

◆ IsAffected()

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

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

Here is the caller graph for this function:

◆ IsAffectedBySpellMod()

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

{
 if (!IsAffectedBySpellMods())
 return false;
 
 SpellInfo const* affectSpell = sSpellMgr->GetSpellInfo(mod->spellId, Difficulty);
 if (!affectSpell)
 return false;
 
 switch (mod->type)
 {
 case SPELLMOD_FLAT:
 case SPELLMOD_PCT:
 // TEMP: dont use IsAffected - !familyName and !familyFlags are not valid options for spell mods
 // TODO: investigate if the !familyName and !familyFlags conditions are even valid for all other (nonmod) uses of SpellInfo::IsAffected
 return affectSpell->SpellFamilyName == SpellFamilyName && static_cast<SpellModifierByClassMask const*>(mod)->mask & SpellFamilyFlags;
 case SPELLMOD_LABEL_FLAT:
 return HasLabel(static_cast<SpellFlatModifierByLabel const*>(mod)->value.LabelID);
 case SPELLMOD_LABEL_PCT:
 return HasLabel(static_cast<SpellPctModifierByLabel const*>(mod)->value.LabelID);
 default:
 break;
 }
 
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsAffectedBySpellMods()

bool SpellInfo::IsAffectedBySpellMods ( ) const

{
 return !HasAttribute(SPELL_ATTR3_IGNORE_CASTER_MODIFIERS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsAffectingArea()

bool SpellInfo::IsAffectingArea ( ) const

{
 for (SpellEffectInfo const& effect : GetEffects())
 if (effect.IsEffect() && (effect.IsTargetingArea() || effect.IsEffect(SPELL_EFFECT_PERSISTENT_AREA_AURA) || effect.IsAreaAuraEffect()))
 return true;
 
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsAllowingDeadTarget()

bool SpellInfo::IsAllowingDeadTarget ( ) const

{
 if (HasAttribute(SPELL_ATTR2_ALLOW_DEAD_TARGET) || Targets & (TARGET_FLAG_CORPSE_ALLY | TARGET_FLAG_CORPSE_ENEMY | TARGET_FLAG_UNIT_DEAD))
 return true;
 
 for (SpellEffectInfo const& effect : GetEffects())
 {
 if (!effect.IsEffect())
 continue;
 
 if (effect.TargetA.GetObjectType() == TARGET_OBJECT_TYPE_CORPSE || effect.TargetB.GetObjectType() == TARGET_OBJECT_TYPE_CORPSE)
 return true;
 }
 
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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_BANE:
 case SPELL_SPECIFIC_ASPECT:
 case SPELL_SPECIFIC_WARLOCK_CORRUPTION:
 return spellSpec == spellInfo->GetSpellSpecific();
 default:
 return false;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsAuraExclusiveBySpecificWith()

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

{
 SpellSpecificType spellSpec1 = GetSpellSpecific();
 SpellSpecificType spellSpec2 = spellInfo->GetSpellSpecific();
 switch (spellSpec1)
 {
 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_WARRIOR_ENRAGE:
 case SPELL_SPECIFIC_MAGE_ARCANE_BRILLANCE:
 case SPELL_SPECIFIC_PRIEST_DIVINE_SPIRIT:
 return spellSpec1 == spellSpec2;
 case SPELL_SPECIFIC_FOOD:
 return spellSpec2 == SPELL_SPECIFIC_FOOD
 || spellSpec2 == SPELL_SPECIFIC_FOOD_AND_DRINK;
 case SPELL_SPECIFIC_DRINK:
 return spellSpec2 == SPELL_SPECIFIC_DRINK
 || spellSpec2 == SPELL_SPECIFIC_FOOD_AND_DRINK;
 case SPELL_SPECIFIC_FOOD_AND_DRINK:
 return spellSpec2 == SPELL_SPECIFIC_FOOD
 || spellSpec2 == SPELL_SPECIFIC_DRINK
 || spellSpec2 == SPELL_SPECIFIC_FOOD_AND_DRINK;
 default:
 return false;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsAutocastable()

bool SpellInfo::IsAutocastable ( ) const

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsAutoRepeatRangedSpell()

bool SpellInfo::IsAutoRepeatRangedSpell ( ) const

{
 return HasAttribute(SPELL_ATTR2_AUTO_REPEAT);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsChanneled()

bool SpellInfo::IsChanneled ( ) const

{
 return HasAttribute(SpellAttr1(SPELL_ATTR1_IS_CHANNELLED | SPELL_ATTR1_IS_SELF_CHANNELLED));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsCooldownStartedOnEvent()

bool SpellInfo::IsCooldownStartedOnEvent ( ) const

{
 if (HasAttribute(SPELL_ATTR0_COOLDOWN_ON_EVENT))
 return true;
 
 SpellCategoryEntry const* category = sSpellCategoryStore.LookupEntry(CategoryId);
 return category && category->Flags & SPELL_CATEGORY_FLAG_COOLDOWN_STARTS_ON_EVENT;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsDeathPersistent()

bool SpellInfo::IsDeathPersistent ( ) const

{
 return HasAttribute(SPELL_ATTR3_ALLOW_AURA_WHILE_DEAD);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsDifferentRankOf()

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsExplicitDiscovery()

bool SpellInfo::IsExplicitDiscovery ( ) const

{
 if (GetEffects().size() < 2)
 return 

Classes

Public Member Functions

Static Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Friends

Constructor & Destructor Documentation

◆ SpellInfo() [1/4]

◆ SpellInfo() [2/4]

◆ SpellInfo() [3/4]

◆ SpellInfo() [4/4]

◆ ~SpellInfo()

Member Function Documentation

◆ _InitializeExplicitTargetMask()

◆ _InitializeSpellPositivity()

◆ _LoadAuraState()

◆ _LoadImmunityInfo()

◆ _LoadSpellDiminishInfo()

◆ _LoadSpellSpecific()

◆ _UnloadImplicitTargetConditionLists()

◆ ApplyAllSpellImmunitiesTo()

◆ CalcCastTime()

◆ CalcDuration()

◆ CalcPowerCost() [1/3]

◆ CalcPowerCost() [2/3]

◆ CalcPowerCost() [3/3]

◆ CalcProcPPM()

◆ CanBeInterrupted()

◆ CanBeUsedInCombat()

◆ CanDispelAura()

◆ CanPierceImmuneAura()

◆ CanSpellProvideImmunityAgainstAura()

◆ CheckExplicitTarget()

◆ CheckLocation()

◆ CheckShapeshift()

◆ CheckTarget()

◆ CheckTargetCreatureType()

◆ CheckVehicle()

◆ GetAllEffectsMechanicMask()

◆ GetAllowedMechanicMask()

◆ GetAttackType()

◆ GetAuraRankForLevel()

◆ GetAuraState()

◆ GetCategory()

◆ GetDiminishingReturnsGroupForSpell()

◆ GetDiminishingReturnsGroupType()

◆ GetDiminishingReturnsLimitDuration()

◆ GetDiminishingReturnsMaxLevel()

◆ GetDispelMask() [1/2]

◆ GetDispelMask() [2/2]

◆ GetDuration()

◆ GetEffect()

◆ GetEffectMechanic()

◆ GetEffectMechanicMask()

◆ GetEffects()

◆ GetExplicitTargetMask()

◆ GetFirstRankSpell()

◆ GetLastRankSpell()

◆ GetMaxDuration()

◆ GetMaxRange()

◆ GetMaxTicks()

◆ GetMechanicImmunityMask()

◆ GetMinRange()

◆ GetNextRankSpell()

◆ GetPrevRankSpell()

◆ GetRank()

◆ GetRecoveryTime()

◆ GetSchoolMask()

◆ GetSpellMechanicMaskByEffectMask()

◆ GetSpellSpecific()

◆ GetSpellVisual()

◆ GetSpellXSpellVisualId()

◆ HasAnyAuraInterruptFlag()

◆ HasAreaAuraEffect()

◆ HasAttribute() [1/16]

◆ HasAttribute() [2/16]

◆ HasAttribute() [3/16]

◆ HasAttribute() [4/16]

◆ HasAttribute() [5/16]