SpellEffectInfo Class Reference

#include "SpellInfo.h"

Classes
struct	StaticData

Public Member Functions
	SpellEffectInfo ()
	SpellEffectInfo (SpellEntry const *spellEntry, SpellInfo const *spellInfo, uint8 effIndex)
bool	IsEffect () const
bool	IsEffect (SpellEffects effectName) const
bool	IsAura () const
bool	IsAura (AuraType aura) const
bool	IsTargetingArea () const
bool	IsAreaAuraEffect () const
bool	IsFarUnitTargetEffect () const
bool	IsFarDestTargetEffect () const
bool	IsUnitOwnedAuraEffect () const
int32	CalcValue (Unit const *caster=nullptr, int32 const *basePoints=nullptr, Unit const *target=nullptr) const
int32	CalcBaseValue (int32 value) const
float	CalcValueMultiplier (Unit *caster, Spell *spell=nullptr) const
float	CalcDamageMultiplier (Unit *caster, Spell *spell=nullptr) const
bool	HasRadius () const
float	CalcRadius (Unit *caster=nullptr, Spell *=nullptr) const
uint32	GetProvidedTargetMask () const
uint32	GetMissingTargetMask (bool srcSet=false, bool destSet=false, uint32 mask=0) const
SpellEffectImplicitTargetTypes	GetImplicitTargetType () const
SpellTargetObjectTypes	GetUsedTargetObjectType () const

Public Attributes
uint32	Effect
uint32	ApplyAuraName
uint32	Amplitude
int32	DieSides
float	RealPointsPerLevel
int32	BasePoints
float	PointsPerComboPoint
float	ValueMultiplier
float	DamageMultiplier
float	BonusMultiplier
int32	MiscValue
int32	MiscValueB
Mechanics	Mechanic
SpellImplicitTargetInfo	TargetA
SpellImplicitTargetInfo	TargetB
SpellRadiusEntry const *	RadiusEntry
uint32	ChainTarget
uint32	ItemType
uint32	TriggerSpell
flag96	SpellClassMask
std::list< Condition * > *	ImplicitTargetConditions

Private Attributes
SpellInfo const *	_spellInfo
uint8	_effIndex

Static Private Attributes
static std::array< StaticData, TOTAL_SPELL_EFFECTS >	_data

Detailed Description

Constructor & Destructor Documentation

SpellEffectInfo() [1/2]

SpellEffectInfo::SpellEffectInfo ( )

inline

                      : _spellInfo(nullptr), _effIndex(0), Effect(0), ApplyAuraName(0), Amplitude(0), DieSides(0),
        RealPointsPerLevel(0), BasePoints(0), PointsPerComboPoint(0), ValueMultiplier(0), DamageMultiplier(0),
        BonusMultiplier(0), MiscValue(0), MiscValueB(0), Mechanic(MECHANIC_NONE), RadiusEntry(nullptr), ChainTarget(0),
        ItemType(0), TriggerSpell(0), ImplicitTargetConditions(nullptr) {}

SpellEffectInfo() [2/2]

SpellEffectInfo::SpellEffectInfo	(	SpellEntry const *	spellEntry,
		SpellInfo const *	spellInfo,
		uint8	effIndex
	)

{
    _spellInfo = spellInfo;
    _effIndex = effIndex;
    Effect = spellEntry->Effect[effIndex];
    ApplyAuraName = spellEntry->EffectApplyAuraName[effIndex];
    Amplitude = spellEntry->EffectAmplitude[effIndex];
    DieSides = spellEntry->EffectDieSides[effIndex];
    RealPointsPerLevel = spellEntry->EffectRealPointsPerLevel[effIndex];
    BasePoints = spellEntry->EffectBasePoints[effIndex];
    PointsPerComboPoint = spellEntry->EffectPointsPerComboPoint[effIndex];
    ValueMultiplier = spellEntry->EffectValueMultiplier[effIndex];
    DamageMultiplier = spellEntry->EffectDamageMultiplier[effIndex];
    BonusMultiplier = spellEntry->EffectBonusMultiplier[effIndex];
    MiscValue = spellEntry->EffectMiscValue[effIndex];
    MiscValueB = spellEntry->EffectMiscValueB[effIndex];
    Mechanic = Mechanics(spellEntry->EffectMechanic[effIndex]);
    TargetA = SpellImplicitTargetInfo(spellEntry->EffectImplicitTargetA[effIndex]);
    TargetB = SpellImplicitTargetInfo(spellEntry->EffectImplicitTargetB[effIndex]);
    RadiusEntry = spellEntry->EffectRadiusIndex[effIndex] ? sSpellRadiusStore.LookupEntry(spellEntry->EffectRadiusIndex[effIndex]) : nullptr;
    ChainTarget = spellEntry->EffectChainTarget[effIndex];
    ItemType = spellEntry->EffectItemType[effIndex];
    TriggerSpell = spellEntry->EffectTriggerSpell[effIndex];
    SpellClassMask = spellEntry->EffectSpellClassMask[effIndex];
    ImplicitTargetConditions = nullptr;
}

References _effIndex, _spellInfo, Amplitude, ApplyAuraName, BasePoints, BonusMultiplier, ChainTarget, DamageMultiplier, DieSides, Effect, SpellEntry::Effect, SpellEntry::EffectAmplitude, SpellEntry::EffectApplyAuraName, SpellEntry::EffectBasePoints, SpellEntry::EffectBonusMultiplier, SpellEntry::EffectChainTarget, SpellEntry::EffectDamageMultiplier, SpellEntry::EffectDieSides, SpellEntry::EffectImplicitTargetA, SpellEntry::EffectImplicitTargetB, SpellEntry::EffectItemType, SpellEntry::EffectMechanic, SpellEntry::EffectMiscValue, SpellEntry::EffectMiscValueB, SpellEntry::EffectPointsPerComboPoint, SpellEntry::EffectRadiusIndex, SpellEntry::EffectRealPointsPerLevel, SpellEntry::EffectSpellClassMask, SpellEntry::EffectTriggerSpell, SpellEntry::EffectValueMultiplier, ImplicitTargetConditions, ItemType, Mechanic, MiscValue, MiscValueB, PointsPerComboPoint, RadiusEntry, RealPointsPerLevel, SpellClassMask, sSpellRadiusStore, TargetA, TargetB, TriggerSpell, and ValueMultiplier.

Member Function Documentation

CalcBaseValue()

int32 SpellEffectInfo::CalcBaseValue

(

int32

value

)

const

{
    if (DieSides == 0)
        return value;
    else
        return value - 1;
}

References DieSides.

CalcDamageMultiplier()

float SpellEffectInfo::CalcDamageMultiplier	(	Unit *	caster,
		Spell *	spell = nullptr
	)		const

{
    float multiplier = DamageMultiplier;
    if (Player* modOwner = (caster ? caster->GetSpellModOwner() : nullptr))
        modOwner->ApplySpellMod(_spellInfo->Id, SPELLMOD_DAMAGE_MULTIPLIER, multiplier, spell);
    return multiplier;
}

References _spellInfo, DamageMultiplier, Unit::GetSpellModOwner(), SpellInfo::Id, and SPELLMOD_DAMAGE_MULTIPLIER.

CalcRadius()

float SpellEffectInfo::CalcRadius	(	Unit *	caster = nullptr,
		Spell *	spell = nullptr
	)		const

{
    if (!HasRadius())
        return 0.0f;
 
    float radius = RadiusEntry->RadiusMin;
    if (caster)
    {
        radius += RadiusEntry->RadiusPerLevel * caster->GetLevel();
        radius = std::min(radius, RadiusEntry->RadiusMax);
        if (Player* modOwner = caster->GetSpellModOwner())
            modOwner->ApplySpellMod(_spellInfo->Id, SPELLMOD_RADIUS, radius, spell);
    }
 
    return radius;
}

References _spellInfo, Unit::GetLevel(), Unit::GetSpellModOwner(), HasRadius(), SpellInfo::Id, RadiusEntry, SpellRadiusEntry::RadiusMax, SpellRadiusEntry::RadiusMin, SpellRadiusEntry::RadiusPerLevel, and SPELLMOD_RADIUS.

CalcValue()

int32 SpellEffectInfo::CalcValue	(	Unit const *	caster = nullptr,
		int32 const *	basePoints = nullptr,
		Unit const *	target = nullptr
	)		const

{
    float basePointsPerLevel = RealPointsPerLevel;
    int32 basePoints = bp ? *bp : BasePoints;
    int32 randomPoints = int32(DieSides);
 
    // base amount modification based on spell lvl vs caster lvl
    // xinef: added basePointsPerLevel check
    if (caster && basePointsPerLevel != 0.0f)
    {
        int32 level = int32(caster->GetLevel());
        if (level > int32(_spellInfo->MaxLevel) && _spellInfo->MaxLevel > 0)
            level = int32(_spellInfo->MaxLevel);
        else if (level < int32(_spellInfo->BaseLevel))
            level = int32(_spellInfo->BaseLevel);
 
        // xinef: if base level is greater than spell level, reduce by base level (eg. pilgrims foods)
        level -= int32(std::max(_spellInfo->BaseLevel, _spellInfo->SpellLevel));
        basePoints += int32(level * basePointsPerLevel);
    }
 
    // roll in a range <1;EffectDieSides> as of patch 3.3.3
    switch (randomPoints)
    {
        case 0:
            break;
        case 1:
            basePoints += 1;
            break;                     // range 1..1
        default:
            // range can have positive (1..rand) and negative (rand..1) values, so order its for irand
            int32 randvalue = (randomPoints >= 1)
                              ? irand(1, randomPoints)
                              : irand(randomPoints, 1);
 
            basePoints += randvalue;
            break;
    }
 
    float value = float(basePoints);
 
    // random damage
    if (caster)
    {
        // bonus amount from combo points
        if (uint8 comboPoints = caster->GetComboPoints())
        {
            value += PointsPerComboPoint * comboPoints;
        }
 
        value = caster->ApplyEffectModifiers(_spellInfo, _effIndex, value);
 
        // amount multiplication based on caster's level
        if (!caster->IsControlledByPlayer() &&
                _spellInfo->SpellLevel && _spellInfo->SpellLevel != caster->GetLevel() &&
                !basePointsPerLevel && _spellInfo->HasAttribute(SPELL_ATTR0_SCALES_WITH_CREATURE_LEVEL))
        {
            bool canEffectScale = false;
            switch (Effect)
            {
                case SPELL_EFFECT_SCHOOL_DAMAGE:
                case SPELL_EFFECT_DUMMY:
                case SPELL_EFFECT_POWER_DRAIN:
                case SPELL_EFFECT_HEALTH_LEECH:
                case SPELL_EFFECT_HEAL:
                case SPELL_EFFECT_WEAPON_DAMAGE:
                case SPELL_EFFECT_POWER_BURN:
                case SPELL_EFFECT_SCRIPT_EFFECT:
                case SPELL_EFFECT_NORMALIZED_WEAPON_DMG:
                case SPELL_EFFECT_FORCE_CAST_WITH_VALUE:
                case SPELL_EFFECT_TRIGGER_SPELL_WITH_VALUE:
                case SPELL_EFFECT_TRIGGER_MISSILE_SPELL_WITH_VALUE:
                    canEffectScale = true;
                    break;
                default:
                    break;
            }
 
            switch (ApplyAuraName)
            {
                case SPELL_AURA_PERIODIC_DAMAGE:
                case SPELL_AURA_DUMMY:
                case SPELL_AURA_PERIODIC_HEAL:
                case SPELL_AURA_DAMAGE_SHIELD:
                case SPELL_AURA_PROC_TRIGGER_DAMAGE:
                case SPELL_AURA_PERIODIC_LEECH:
                case SPELL_AURA_PERIODIC_MANA_LEECH:
                case SPELL_AURA_SCHOOL_ABSORB:
                case SPELL_AURA_PERIODIC_TRIGGER_SPELL_WITH_VALUE:
                    canEffectScale = true;
                    break;
                default:
                    break;
            }
 
            if ((sSpellMgr->GetSpellInfo(_spellInfo->Effects[_effIndex].TriggerSpell) && sSpellMgr->GetSpellInfo(_spellInfo->Effects[_effIndex].TriggerSpell)->HasAttribute(SPELL_ATTR0_SCALES_WITH_CREATURE_LEVEL)) && _spellInfo->HasAttribute(SPELL_ATTR0_SCALES_WITH_CREATURE_LEVEL))
                canEffectScale = false;
 
            if (canEffectScale)
            {
                CreatureTemplate const* cInfo = caster->ToCreature()->GetCreatureTemplate();
 
                CreatureBaseStats const* pCBS = sObjectMgr->GetCreatureBaseStats(caster->GetLevel(), caster->getClass());
                float CBSPowerCreature = pCBS->BaseDamage[cInfo->expansion];
                CreatureBaseStats const* spellCBS = sObjectMgr->GetCreatureBaseStats(_spellInfo->SpellLevel, caster->getClass());
                float CBSPowerSpell = spellCBS->BaseDamage[cInfo->expansion];
                value *= CBSPowerCreature / CBSPowerSpell;
            }
        }
    }
 
    return int32(value);
}

References _effIndex, _spellInfo, ApplyAuraName, Unit::ApplyEffectModifiers(), CreatureBaseStats::BaseDamage, SpellInfo::BaseLevel, BasePoints, DieSides, Effect, SpellInfo::Effects, CreatureTemplate::expansion, Unit::getClass(), Unit::GetComboPoints(), Creature::GetCreatureTemplate(), Unit::GetLevel(), SpellInfo::HasAttribute(), irand(), Unit::IsControlledByPlayer(), SpellInfo::MaxLevel, PointsPerComboPoint, RealPointsPerLevel, sObjectMgr, SPELL_ATTR0_SCALES_WITH_CREATURE_LEVEL, SPELL_AURA_DAMAGE_SHIELD, SPELL_AURA_DUMMY, SPELL_AURA_PERIODIC_DAMAGE, SPELL_AURA_PERIODIC_HEAL, SPELL_AURA_PERIODIC_LEECH, SPELL_AURA_PERIODIC_MANA_LEECH, SPELL_AURA_PERIODIC_TRIGGER_SPELL_WITH_VALUE, SPELL_AURA_PROC_TRIGGER_DAMAGE, SPELL_AURA_SCHOOL_ABSORB, SPELL_EFFECT_DUMMY, SPELL_EFFECT_FORCE_CAST_WITH_VALUE, SPELL_EFFECT_HEAL, SPELL_EFFECT_HEALTH_LEECH, SPELL_EFFECT_NORMALIZED_WEAPON_DMG, SPELL_EFFECT_POWER_BURN, SPELL_EFFECT_POWER_DRAIN, SPELL_EFFECT_SCHOOL_DAMAGE, SPELL_EFFECT_SCRIPT_EFFECT, SPELL_EFFECT_TRIGGER_MISSILE_SPELL_WITH_VALUE, SPELL_EFFECT_TRIGGER_SPELL_WITH_VALUE, SPELL_EFFECT_WEAPON_DAMAGE, SpellInfo::SpellLevel, sSpellMgr, and Object::ToCreature().

Referenced by spell_dragonblight_corrosive_spit::AfterApply(), spell_dragonblight_corrosive_spit::PeriodicTick(), spell_lich_king_whisper::Validate(), and spell_dragonblight_corrosive_spit::Validate().

CalcValueMultiplier()

float SpellEffectInfo::CalcValueMultiplier	(	Unit *	caster,
		Spell *	spell = nullptr
	)		const

{
    float multiplier = ValueMultiplier;
    if (Player* modOwner = (caster ? caster->GetSpellModOwner() : nullptr))
        modOwner->ApplySpellMod(_spellInfo->Id, SPELLMOD_VALUE_MULTIPLIER, multiplier, spell);
    return multiplier;
}

References _spellInfo, Unit::GetSpellModOwner(), SpellInfo::Id, SPELLMOD_VALUE_MULTIPLIER, and ValueMultiplier.

GetImplicitTargetType()

SpellEffectImplicitTargetTypes SpellEffectInfo::GetImplicitTargetType

(

)

const

{
    return _data[Effect].ImplicitTargetType;
}

References _data, and Effect.

GetMissingTargetMask()

uint32 SpellEffectInfo::GetMissingTargetMask	(	bool	srcSet = false,
		bool	destSet = false,
		uint32	mask = 0
	)		const

{
    uint32 effImplicitTargetMask = GetTargetFlagMask(GetUsedTargetObjectType());
    uint32 providedTargetMask = GetTargetFlagMask(TargetA.GetObjectType()) | GetTargetFlagMask(TargetB.GetObjectType()) | mask;
 
    // remove all flags covered by effect target mask
    if (providedTargetMask & TARGET_FLAG_UNIT_MASK)
        effImplicitTargetMask &= ~(TARGET_FLAG_UNIT_MASK);
    if (providedTargetMask & TARGET_FLAG_CORPSE_MASK)
        effImplicitTargetMask &= ~(TARGET_FLAG_UNIT_MASK | TARGET_FLAG_CORPSE_MASK);
    if (providedTargetMask & TARGET_FLAG_GAMEOBJECT_ITEM)
        effImplicitTargetMask &= ~(TARGET_FLAG_GAMEOBJECT_ITEM | TARGET_FLAG_GAMEOBJECT | TARGET_FLAG_ITEM);
    if (providedTargetMask & TARGET_FLAG_GAMEOBJECT)
        effImplicitTargetMask &= ~(TARGET_FLAG_GAMEOBJECT | TARGET_FLAG_GAMEOBJECT_ITEM);
    if (providedTargetMask & TARGET_FLAG_ITEM)
        effImplicitTargetMask &= ~(TARGET_FLAG_ITEM | TARGET_FLAG_GAMEOBJECT_ITEM);
    if (dstSet || providedTargetMask & TARGET_FLAG_DEST_LOCATION)
        effImplicitTargetMask &= ~(TARGET_FLAG_DEST_LOCATION);
    if (srcSet || providedTargetMask & TARGET_FLAG_SOURCE_LOCATION)
        effImplicitTargetMask &= ~(TARGET_FLAG_SOURCE_LOCATION);
 
    return effImplicitTargetMask;
}

References SpellImplicitTargetInfo::GetObjectType(), GetTargetFlagMask(), GetUsedTargetObjectType(), TARGET_FLAG_CORPSE_MASK, TARGET_FLAG_DEST_LOCATION, TARGET_FLAG_GAMEOBJECT, TARGET_FLAG_GAMEOBJECT_ITEM, TARGET_FLAG_ITEM, TARGET_FLAG_SOURCE_LOCATION, TARGET_FLAG_UNIT_MASK, TargetA, and TargetB.

GetProvidedTargetMask()

uint32 SpellEffectInfo::GetProvidedTargetMask

(

)

const

{
    return GetTargetFlagMask(TargetA.GetObjectType()) | GetTargetFlagMask(TargetB.GetObjectType());
}

References SpellImplicitTargetInfo::GetObjectType(), GetTargetFlagMask(), TargetA, and TargetB.

GetUsedTargetObjectType()

SpellTargetObjectTypes SpellEffectInfo::GetUsedTargetObjectType

(

)

const

{
    return _data[Effect].UsedTargetObjectType;
}

References _data, and Effect.

Referenced by GetMissingTargetMask().

HasRadius()

bool SpellEffectInfo::HasRadius

(

)

const

{
    return RadiusEntry != nullptr;
}

References RadiusEntry.

Referenced by CalcRadius().

IsAreaAuraEffect()

bool SpellEffectInfo::IsAreaAuraEffect

(

)

const

{
    if (Effect == SPELL_EFFECT_APPLY_AREA_AURA_PARTY    ||
            Effect == SPELL_EFFECT_APPLY_AREA_AURA_RAID     ||
            Effect == SPELL_EFFECT_APPLY_AREA_AURA_FRIEND   ||
            Effect == SPELL_EFFECT_APPLY_AREA_AURA_ENEMY    ||
            Effect == SPELL_EFFECT_APPLY_AREA_AURA_PET      ||
            Effect == SPELL_EFFECT_APPLY_AREA_AURA_OWNER)
        return true;
    return false;
}

References Effect, SPELL_EFFECT_APPLY_AREA_AURA_ENEMY, SPELL_EFFECT_APPLY_AREA_AURA_FRIEND, SPELL_EFFECT_APPLY_AREA_AURA_OWNER, SPELL_EFFECT_APPLY_AREA_AURA_PARTY, SPELL_EFFECT_APPLY_AREA_AURA_PET, and SPELL_EFFECT_APPLY_AREA_AURA_RAID.

Referenced by IsUnitOwnedAuraEffect().

IsAura() [1/2]

bool SpellEffectInfo::IsAura

(

)

const

{
    return (IsUnitOwnedAuraEffect() || Effect == SPELL_EFFECT_PERSISTENT_AREA_AURA) && ApplyAuraName != 0;
}

References ApplyAuraName, Effect, IsUnitOwnedAuraEffect(), and SPELL_EFFECT_PERSISTENT_AREA_AURA.

Referenced by IsAura().

IsAura() [2/2]

bool SpellEffectInfo::IsAura

(

AuraType

aura

)

const

{
    return IsAura() && ApplyAuraName == uint32(aura);
}

References ApplyAuraName, and IsAura().

IsEffect() [1/2]

bool SpellEffectInfo::IsEffect

(

)

const

{
    return Effect != 0;
}

References Effect.

IsEffect() [2/2]

bool SpellEffectInfo::IsEffect

(

SpellEffects

effectName

)

const

{
    return Effect == effectName;
}

References Effect.

IsFarDestTargetEffect()

bool SpellEffectInfo::IsFarDestTargetEffect

(

)

const

{
    return Effect == SPELL_EFFECT_TELEPORT_UNITS;
}

References Effect, and SPELL_EFFECT_TELEPORT_UNITS.

IsFarUnitTargetEffect()

bool SpellEffectInfo::IsFarUnitTargetEffect

(

)

const

{
    return (Effect == SPELL_EFFECT_SUMMON_PLAYER)
           || (Effect == SPELL_EFFECT_SUMMON_RAF_FRIEND)
           || (Effect == SPELL_EFFECT_RESURRECT)
           || (Effect == SPELL_EFFECT_RESURRECT_NEW)
           /*|| (Effect == SPELL_EFFECT_SKIN_PLAYER_CORPSE) Xinef: This is not Far Unit Target Effect*/;
}

References Effect, SPELL_EFFECT_RESURRECT, SPELL_EFFECT_RESURRECT_NEW, SPELL_EFFECT_SUMMON_PLAYER, and SPELL_EFFECT_SUMMON_RAF_FRIEND.

IsTargetingArea()

bool SpellEffectInfo::IsTargetingArea

(

)

const

{
    return TargetA.IsArea() || TargetB.IsArea();
}

References SpellImplicitTargetInfo::IsArea(), TargetA, and TargetB.

IsUnitOwnedAuraEffect()

bool SpellEffectInfo::IsUnitOwnedAuraEffect

(

)

const

{
    return IsAreaAuraEffect() || Effect == SPELL_EFFECT_APPLY_AURA;
}

References Effect, IsAreaAuraEffect(), and SPELL_EFFECT_APPLY_AURA.

Referenced by IsAura().

Member Data Documentation

_data

std::array< SpellEffectInfo::StaticData, TOTAL_SPELL_EFFECTS > SpellEffectInfo::_data

staticprivate

{
    TARGET_FLAG_NONE            = 0x00000000,
    TARGET_FLAG_UNUSED_1        = 0x00000001,               // not used
    TARGET_FLAG_UNIT            = 0x00000002,               // pguid
    TARGET_FLAG_UNIT_RAID       = 0x00000004,               // not sent, used to validate target (if raid member)
    TARGET_FLAG_UNIT_PARTY      = 0x00000008,               // not sent, used to validate target (if party member)
    TARGET_FLAG_ITEM            = 0x00000010,               // pguid
    TARGET_FLAG_SOURCE_LOCATION = 0x00000020,               // pguid, 3 float
    TARGET_FLAG_DEST_LOCATION   = 0x00000040,               // pguid, 3 float
    TARGET_FLAG_UNIT_ENEMY      = 0x00000080,               // not sent, used to validate target (if enemy)
    TARGET_FLAG_UNIT_ALLY       = 0x00000100,               // not sent, used to validate target (if ally)
    TARGET_FLAG_CORPSE_ENEMY    = 0x00000200,               // pguid
    TARGET_FLAG_UNIT_DEAD       = 0x00000400,               // not sent, used to validate target (if dead creature)
    TARGET_FLAG_GAMEOBJECT      = 0x00000800,               // pguid, used with TARGET_GAMEOBJECT_TARGET
    TARGET_FLAG_TRADE_ITEM      = 0x00001000,               // pguid
    TARGET_FLAG_STRING          = 0x00002000,               // string
    TARGET_FLAG_GAMEOBJECT_ITEM = 0x00004000,               // not sent, used with TARGET_GAMEOBJECT_ITEM_TARGET
    TARGET_FLAG_CORPSE_ALLY     = 0x00008000,               // pguid
    TARGET_FLAG_UNIT_MINIPET    = 0x00010000,               // pguid, used to validate target (if non combat pet)
    TARGET_FLAG_GLYPH_SLOT      = 0x00020000,               // used in glyph spells
    TARGET_FLAG_DEST_TARGET     = 0x00040000,               // sometimes appears with DEST_TARGET spells (may appear or not for a given spell)
    TARGET_FLAG_UNUSED20        = 0x00080000,               // uint32 counter, loop { vec3 - screen position (?), guid }, not used so far
    TARGET_FLAG_UNIT_PASSENGER  = 0x00100000,               // guessed, used to validate target (if vehicle passenger)
 
    TARGET_FLAG_UNIT_MASK = TARGET_FLAG_UNIT | TARGET_FLAG_UNIT_RAID | TARGET_FLAG_UNIT_PARTY
                            | TARGET_FLAG_UNIT_ENEMY | TARGET_FLAG_UNIT_ALLY | TARGET_FLAG_UNIT_DEAD | TARGET_FLAG_UNIT_MINIPET | TARGET_FLAG_UNIT_PASSENGER,
    TARGET_FLAG_GAMEOBJECT_MASK = TARGET_FLAG_GAMEOBJECT | TARGET_FLAG_GAMEOBJECT_ITEM,
    TARGET_FLAG_CORPSE_MASK = TARGET_FLAG_CORPSE_ALLY | TARGET_FLAG_CORPSE_ENEMY,
    TARGET_FLAG_ITEM_MASK = TARGET_FLAG_TRADE_ITEM | TARGET_FLAG_ITEM | TARGET_FLAG_GAMEOBJECT_ITEM,
};
 
enum SpellTargetSelectionCategories
{
    TARGET_SELECT_CATEGORY_NYI,
    TARGET_SELECT_CATEGORY_DEFAULT,
    TARGET_SELECT_CATEGORY_CHANNEL,
    TARGET_SELECT_CATEGORY_NEARBY,
    TARGET_SELECT_CATEGORY_CONE,
    TARGET_SELECT_CATEGORY_AREA,
    TARGET_SELECT_CATEGORY_TRAJ,
};
 
enum SpellTargetReferenceTypes
{
    TARGET_REFERENCE_TYPE_NONE,
    TARGET_REFERENCE_TYPE_CASTER,
    TARGET_REFERENCE_TYPE_TARGET,
    TARGET_REFERENCE_TYPE_LAST,
    TARGET_REFERENCE_TYPE_SRC,
    TARGET_REFERENCE_TYPE_DEST,
};
 
enum SpellTargetObjectTypes
{
    TARGET_OBJECT_TYPE_NONE = 0,
    TARGET_OBJECT_TYPE_SRC,
    TARGET_OBJECT_TYPE_DEST,
    TARGET_OBJECT_TYPE_UNIT,
    TARGET_OBJECT_TYPE_UNIT_AND_DEST,
    TARGET_OBJECT_TYPE_GOBJ,
    TARGET_OBJECT_TYPE_GOBJ_ITEM,
    TARGET_OBJECT_TYPE_ITEM,
    TARGET_OBJECT_TYPE_CORPSE,
    // only for effect target type
    TARGET_OBJECT_TYPE_CORPSE_ENEMY,
    TARGET_OBJECT_TYPE_CORPSE_ALLY,
};
 
enum SpellTargetCheckTypes
{
    TARGET_CHECK_DEFAULT,
    TARGET_CHECK_ENTRY,
    TARGET_CHECK_ENEMY,
    TARGET_CHECK_ALLY,
    TARGET_CHECK_PARTY,
    TARGET_CHECK_RAID,
    TARGET_CHECK_RAID_CLASS,
    TARGET_CHECK_PASSENGER,
    TARGET_CHECK_CORPSE,
};
 
enum SpellTargetDirectionTypes
{
    TARGET_DIR_NONE,
    TARGET_DIR_FRONT,
    TARGET_DIR_BACK,
    TARGET_DIR_RIGHT,
    TARGET_DIR_LEFT,
    TARGET_DIR_FRONT_RIGHT,
    TARGET_DIR_BACK_RIGHT,
    TARGET_DIR_BACK_LEFT,
    TARGET_DIR_FRONT_LEFT,
    TARGET_DIR_RANDOM,
    TARGET_DIR_ENTRY,
};
 
enum SpellEffectImplicitTargetTypes
{
    EFFECT_IMPLICIT_TARGET_NONE = 0,
    EFFECT_IMPLICIT_TARGET_EXPLICIT,
    EFFECT_IMPLICIT_TARGET_CASTER,
};
 
// Spell clasification
enum SpellSpecificType
{
    SPELL_SPECIFIC_NORMAL                        = 0,
    SPELL_SPECIFIC_SEAL                          = 1,
    SPELL_SPECIFIC_AURA                          = 3,
    SPELL_SPECIFIC_STING                         = 4,
    SPELL_SPECIFIC_CURSE                         = 5,
    SPELL_SPECIFIC_ASPECT                        = 6,
    SPELL_SPECIFIC_TRACKER                       = 7,
    SPELL_SPECIFIC_WARLOCK_ARMOR                 = 8,
    SPELL_SPECIFIC_MAGE_ARMOR                    = 9,
    SPELL_SPECIFIC_ELEMENTAL_SHIELD              = 10,
    SPELL_SPECIFIC_MAGE_POLYMORPH                = 11,
    SPELL_SPECIFIC_JUDGEMENT                     = 13,
    SPELL_SPECIFIC_WARLOCK_CORRUPTION            = 17,
    SPELL_SPECIFIC_FOOD                          = 19,
    SPELL_SPECIFIC_DRINK                         = 20,
    SPELL_SPECIFIC_FOOD_AND_DRINK                = 21,
    SPELL_SPECIFIC_PRESENCE                      = 22,
    SPELL_SPECIFIC_CHARM                         = 23,
    SPELL_SPECIFIC_SCROLL                        = 24,
    SPELL_SPECIFIC_MAGE_ARCANE_BRILLANCE         = 25,
    SPELL_SPECIFIC_PRIEST_DIVINE_SPIRIT          = 26,
    SPELL_SPECIFIC_HAND                          = 27,
};
 
enum SpellCustomAttributes
{
    SPELL_ATTR0_CU_ENCHANT_PROC                  = 0x00000001,
    SPELL_ATTR0_CU_CONE_BACK                     = 0x00000002,
    SPELL_ATTR0_CU_CONE_LINE                     = 0x00000004,
    SPELL_ATTR0_CU_SHARE_DAMAGE                  = 0x00000008,
    SPELL_ATTR0_CU_NO_INITIAL_THREAT             = 0x00000010,
    SPELL_ATTR0_CU_AURA_CC                       = 0x00000020,
    SPELL_ATTR0_CU_DONT_BREAK_STEALTH            = 0x00000040,
    SPELL_ATTR0_CU_NO_PVP_FLAG                   = 0x00000080,
    SPELL_ATTR0_CU_DIRECT_DAMAGE                 = 0x00000100,
    SPELL_ATTR0_CU_CHARGE                        = 0x00000200,
    SPELL_ATTR0_CU_PICKPOCKET                    = 0x00000400,
    SPELL_ATTR0_CU_IGNORE_EVADE                  = 0x00000800,
    SPELL_ATTR0_CU_NEGATIVE_EFF0                 = 0x00001000,
    SPELL_ATTR0_CU_NEGATIVE_EFF1                 = 0x00002000,
    SPELL_ATTR0_CU_NEGATIVE_EFF2                 = 0x00004000,
    SPELL_ATTR0_CU_IGNORE_ARMOR                  = 0x00008000,
    SPELL_ATTR0_CU_REQ_TARGET_FACING_CASTER      = 0x00010000,
    SPELL_ATTR0_CU_REQ_CASTER_BEHIND_TARGET      = 0x00020000,
    SPELL_ATTR0_CU_ALLOW_INFLIGHT_TARGET         = 0x00040000,
    SPELL_ATTR0_CU_NEEDS_AMMO_DATA               = 0x00080000,
    SPELL_ATTR0_CU_BINARY_SPELL                  = 0x00100000,
    SPELL_ATTR0_CU_NO_POSITIVE_TAKEN_BONUS       = 0x00200000,
    SPELL_ATTR0_CU_SINGLE_AURA_STACK             = 0x00400000,
    SPELL_ATTR0_CU_SCHOOLMASK_NORMAL_WITH_MAGIC  = 0x00800000,
    SPELL_ATTR0_CU_AURA_CANNOT_BE_SAVED          = 0x01000000,
    SPELL_ATTR0_CU_POSITIVE_EFF0                 = 0x02000000,
    SPELL_ATTR0_CU_POSITIVE_EFF1                 = 0x04000000,
    SPELL_ATTR0_CU_POSITIVE_EFF2                 = 0x08000000,
    SPELL_ATTR0_CU_FORCE_SEND_CATEGORY_COOLDOWNS = 0x10000000,
    SPELL_ATTR0_CU_FORCE_AURA_SAVING             = 0x20000800,
    SPELL_ATTR0_CU_ONLY_ONE_AREA_AURA            = 0x20000000,
    SPELL_ATTR0_CU_ENCOUNTER_REWARD              = 0x40000000,
    SPELL_ATTR0_CU_BYPASS_MECHANIC_IMMUNITY      = 0x80000000,
 
    SPELL_ATTR0_CU_NEGATIVE                      = SPELL_ATTR0_CU_NEGATIVE_EFF0 | SPELL_ATTR0_CU_NEGATIVE_EFF1 | SPELL_ATTR0_CU_NEGATIVE_EFF2,
    SPELL_ATTR0_CU_POSITIVE                      = SPELL_ATTR0_CU_POSITIVE_EFF0 | SPELL_ATTR0_CU_POSITIVE_EFF1 | SPELL_ATTR0_CU_POSITIVE_EFF2,
};
 
uint32 GetTargetFlagMask(SpellTargetObjectTypes objType);
 
class SpellImplicitTargetInfo
{
private:
    Targets _target;
public:
    SpellImplicitTargetInfo() : _target(Targets(0)) {}
    SpellImplicitTargetInfo(uint32 target);
 
    bool IsArea() const;
    SpellTargetSelectionCategories GetSelectionCategory() const;
    SpellTargetReferenceTypes GetReferenceType() const;
    SpellTargetObjectTypes GetObjectType() const;
    SpellTargetCheckTypes GetCheckType() const;
    SpellTargetDirectionTypes GetDirectionType() const;
    float CalcDirectionAngle() const;
 
    Targets GetTarget() const;
    uint32 GetExplicitTargetMask(bool& srcSet, bool& dstSet) const;
 
private:
    struct StaticData
    {
        SpellTargetObjectTypes ObjectType;    // type of object returned by target type
        SpellTargetReferenceTypes ReferenceType; // defines which object is used as a reference when selecting target
        SpellTargetSelectionCategories SelectionCategory;
        SpellTargetCheckTypes SelectionCheckType; // defines selection criteria
        SpellTargetDirectionTypes DirectionType; // direction for cone and dest targets
    };
 
    static std::array<StaticData, TOTAL_SPELL_TARGETS> _data;
};
 
class SpellEffectInfo
{
    SpellInfo const* _spellInfo;
    uint8 _effIndex;
public:
    uint32    Effect;
    uint32    ApplyAuraName;
    uint32    Amplitude;
    int32     DieSides;
    float     RealPointsPerLevel;
    int32     BasePoints;
    float     PointsPerComboPoint;
    float     ValueMultiplier;
    float     DamageMultiplier;
    float     BonusMultiplier;
    int32     MiscValue;
    int32     MiscValueB;
    Mechanics Mechanic;
    SpellImplicitTargetInfo TargetA;
    SpellImplicitTargetInfo TargetB;
    SpellRadiusEntry const* RadiusEntry;
    uint32    ChainTarget;
    uint32    ItemType;
    uint32    TriggerSpell;
    flag96    SpellClassMask;
    std::list<Condition*>* ImplicitTargetConditions;
 
    SpellEffectInfo() : _spellInfo(nullptr), _effIndex(0), Effect(0), ApplyAuraName(0), Amplitude(0), DieSides(0),
        RealPointsPerLevel(0), BasePoints(0), PointsPerComboPoint(0), ValueMultiplier(0), DamageMultiplier(0),
        BonusMultiplier(0), MiscValue(0), MiscValueB(0), Mechanic(MECHANIC_NONE), RadiusEntry(nullptr), ChainTarget(0),
        ItemType(0), TriggerSpell(0), ImplicitTargetConditions(nullptr) {}
    SpellEffectInfo(SpellEntry const* spellEntry, SpellInfo const* spellInfo, uint8 effIndex);
 
    bool IsEffect() const;
    bool IsEffect(SpellEffects effectName) const;
    bool IsAura() const;
    bool IsAura(AuraType aura) const;
    bool IsTargetingArea() const;
    bool IsAreaAuraEffect() const;
    bool IsFarUnitTargetEffect() const;
    bool IsFarDestTargetEffect() const;
    bool IsUnitOwnedAuraEffect() const;
 
    int32 CalcValue(Unit const* caster = nullptr, int32 const* basePoints = nullptr, Unit const* target = nullptr) const;
    int32 CalcBaseValue(int32 value) const;
    float CalcValueMultiplier(Unit* caster, Spell* spell = nullptr) const;
    float CalcDamageMultiplier(Unit* caster, Spell* spell = nullptr) const;
 
    bool HasRadius() const;
    float CalcRadius(Unit* caster = nullptr, Spell* = nullptr) const;
 
    uint32 GetProvidedTargetMask() const;
    uint32 GetMissingTargetMask(bool srcSet = false, bool destSet = false, uint32 mask = 0) const;
 
    SpellEffectImplicitTargetTypes GetImplicitTargetType() const;
    SpellTargetObjectTypes GetUsedTargetObjectType() const;
 
private:
    struct StaticData
    {
        SpellEffectImplicitTargetTypes ImplicitTargetType; // defines what target can be added to effect target list if there's no valid target type provided for effect
        SpellTargetObjectTypes UsedTargetObjectType; // defines valid target object type for spell effect
    };
 
    static std::array<StaticData, TOTAL_SPELL_EFFECTS> _data;
};
 
class AC_GAME_API SpellInfo
{
friend class SpellMgr;
 
public:
    uint32 Id;
    SpellCategoryEntry const* CategoryEntry;
    uint32 Dispel;
    uint32 Mechanic;
    uint32 Attributes;
    uint32 AttributesEx;
    uint32 AttributesEx2;
    uint32 AttributesEx3;
    uint32 AttributesEx4;
    uint32 AttributesEx5;
    uint32 AttributesEx6;
    uint32 AttributesEx7;
    uint32 AttributesCu;
    uint32 Stances;
    uint32 StancesNot;
    uint32 Targets;
    uint32 TargetCreatureType;
    uint32 RequiresSpellFocus;
    uint32 FacingCasterFlags;
    uint32 CasterAuraState;
    uint32 TargetAuraState;
    uint32 CasterAuraStateNot;
    uint32 TargetAuraStateNot;
    uint32 CasterAuraSpell;
    uint32 TargetAuraSpell;
    uint32 ExcludeCasterAuraSpell;
    uint32 ExcludeTargetAuraSpell;
    SpellCastTimesEntry const* CastTimeEntry;
    uint32 RecoveryTime;
    uint32 CategoryRecoveryTime;
    uint32 StartRecoveryCategory;
    uint32 StartRecoveryTime;
    uint32 InterruptFlags;
    uint32 AuraInterruptFlags;
    uint32 ChannelInterruptFlags;
    uint32 ProcFlags;
    uint32 ProcChance;
    uint32 ProcCharges;
    uint32 MaxLevel;
    uint32 BaseLevel;
    uint32 SpellLevel;
    SpellDurationEntry const* DurationEntry;
    uint32 PowerType;
    uint32 ManaCost;
    uint32 ManaCostPerlevel;
    uint32 ManaPerSecond;
    uint32 ManaPerSecondPerLevel;
    uint32 ManaCostPercentage;
    uint32 RuneCostID;
    SpellRangeEntry const* RangeEntry;
    float  Speed;
    uint32 StackAmount;
    std::array<uint32, 2> Totem;
    std::array<int32, MAX_SPELL_REAGENTS>  Reagent;
    std::array<uint32, MAX_SPELL_REAGENTS> ReagentCount;
    int32  EquippedItemClass;
    int32  EquippedItemSubClassMask;
    int32  EquippedItemInventoryTypeMask;
    std::array<uint32, 2> TotemCategory;
    std::array<uint32, 2> SpellVisual;
    uint32 SpellIconID;
    uint32 ActiveIconID;
    uint32 SpellPriority;
    std::array<char const*, 16> SpellName;
    std::array<char const*, 16> Rank;
    uint32 MaxTargetLevel;
    uint32 MaxAffectedTargets;
    uint32 SpellFamilyName;
    flag96 SpellFamilyFlags;
    uint32 DmgClass;
    uint32 PreventionType;
    int32  AreaGroupId;
    uint32 SchoolMask;
    std::array<SpellEffectInfo, MAX_SPELL_EFFECTS> Effects;
    uint32 ExplicitTargetMask;
    SpellChainNode const* ChainEntry;
 
    // Mine
    AuraStateType _auraState;
    SpellSpecificType _spellSpecific;
    bool _isStackableWithRanks;
    bool _isSpellValid;
    bool _isCritCapable;
    bool _requireCooldownInfo;
 
    SpellInfo(SpellEntry const* spellEntry);
    ~SpellInfo();
 
    uint32 GetCategory() const;
    bool HasEffect(SpellEffects effect) const;
    bool HasEffectMechanic(Mechanics mechanic) const;
    bool HasAura(AuraType aura) const;
    bool HasAnyAura() const;
    bool HasAreaAuraEffect() const;
 
    inline bool HasAttribute(SpellAttr0 attribute) const { return (Attributes & attribute) != 0; }
    inline bool HasAttribute(SpellAttr1 attribute) const { return (AttributesEx & attribute) != 0; }
    inline bool HasAttribute(SpellAttr2 attribute) const { return (AttributesEx2 & attribute) != 0; }
    inline bool HasAttribute(SpellAttr3 attribute) const { return (AttributesEx3 & attribute) != 0; }
    inline bool HasAttribute(SpellAttr4 attribute) const { return (AttributesEx4 & attribute) != 0; }
    inline bool HasAttribute(SpellAttr5 attribute) const { return (AttributesEx5 & attribute) != 0; }
    inline bool HasAttribute(SpellAttr6 attribute) const { return (AttributesEx6 & attribute) != 0; }
    inline bool HasAttribute(SpellAttr7 attribute) const { return (AttributesEx7 & attribute) != 0; }
    inline bool HasAttribute(SpellCustomAttributes customAttribute) const { return (AttributesCu & customAttribute) != 0; }
 
    bool IsExplicitDiscovery() const;
    bool IsLootCrafting() const;
    bool IsQuestTame() const;
    bool IsProfessionOrRiding() const;
    bool IsProfession() const;
    bool IsPrimaryProfession() const;
    bool IsPrimaryProfessionFirstRank() const;
    bool IsAbilityLearnedWithProfession() const;
    bool IsAbilityOfSkillType(uint32 skillType) const;
 
    bool IsAffectingArea() const;
    bool IsTargetingArea() const;
    bool NeedsExplicitUnitTarget() const;
    bool NeedsToBeTriggeredByCaster(SpellInfo const* triggeringSpell, uint8 effIndex = MAX_SPELL_EFFECTS) const;
    bool IsChannelCategorySpell() const;
    bool IsSelfCast() const;
 
    bool IsPassive() const;
    bool IsAutocastable() const;
    bool ComputeIsCritCapable() const;
    bool IsCritCapable() const;
    bool RequireCooldownInfo() const;
    void SetCritCapable(bool val);
    bool ComputeIsStackableWithRanks() const;
    bool IsStackableWithRanks() const;
    void SetStackableWithRanks(bool val);
    bool IsSpellValid() const;
    void SetSpellValid(bool val);
    bool IsPassiveStackableWithRanks() const;
    bool IsMultiSlotAura() const;
    bool IsCooldownStartedOnEvent() const;
    bool IsDeathPersistent() const;
    bool IsRequiringDeadTarget() const;
    bool IsAllowingDeadTarget() const;
    bool CanBeUsedInCombat() const;
    bool IsPositive() const;
    bool IsPositiveEffect(uint8 effIndex) const;
    bool IsChanneled() const;
    [[nodiscard]] bool IsActionAllowedChannel() const;
    bool NeedsComboPoints() const;
    bool IsBreakingStealth() const;
    bool IsRangedWeaponSpell() const;
    bool IsAutoRepeatRangedSpell() const;
 
    bool IsAffectedBySpellMods() const;
    bool IsAffectedBySpellMod(SpellModifier const* mod) const;
 
    bool CanPierceImmuneAura(SpellInfo const* aura) const;
    bool CanDispelAura(SpellInfo const* aura) const;
 
    bool IsSingleTarget() const;
    bool IsAuraExclusiveBySpecificWith(SpellInfo const* spellInfo) const;
    bool IsAuraExclusiveBySpecificPerCasterWith(SpellInfo const* spellInfo) const;
 
    SpellCastResult CheckShapeshift(uint32 form) const;
    SpellCastResult CheckLocation(uint32 map_id, uint32 zone_id, uint32 area_id, Player* player = nullptr, bool strict = true) const;
    SpellCastResult CheckTarget(Unit const* caster, WorldObject const* target, bool implicit = true) const;
    SpellCastResult CheckExplicitTarget(Unit const* caster, WorldObject const* target, Item const* itemTarget = nullptr) const;
    bool CheckTargetCreatureType(Unit const* target) const;
 
    // xinef: aura stacking
    bool IsStrongerAuraActive(Unit const* caster, Unit const* target) const;
    bool IsAuraEffectEqual(SpellInfo const* otherSpellInfo) const;
    bool ValidateAttribute6SpellDamageMods(Unit const* caster, const AuraEffect* auraEffect, bool isDot) const;
 
    SpellSchoolMask GetSchoolMask() const;
    uint32 GetAllEffectsMechanicMask() const;
    uint32 GetEffectMechanicMask(uint8 effIndex) const;
    uint32 GetSpellMechanicMaskByEffectMask(uint32 effectMask) const;
    Mechanics GetEffectMechanic(uint8 effIndex) const;
    bool HasAnyEffectMechanic() const;
    uint32 GetDispelMask() const;
    static uint32 GetDispelMask(DispelType type);
    uint32 GetExplicitTargetMask() const;
 
    AuraStateType GetAuraState() const;
    SpellSpecificType GetSpellSpecific() const;
 
    float GetMinRange(bool positive = false) const;
    float GetMaxRange(bool positive = false, Unit* caster = nullptr, Spell* spell = nullptr) const;
 
    int32 GetDuration() const;
    int32 GetMaxDuration() const;
 
    uint32 GetMaxTicks() const;
 
    uint32 CalcCastTime(Unit* caster = nullptr, Spell* spell = nullptr) const;
    uint32 GetRecoveryTime() const;
 
    int32 CalcPowerCost(Unit const* caster, SpellSchoolMask schoolMask, Spell* spell = nullptr) const;
 
    bool IsRanked() const;
    uint8 GetRank() const;
    SpellInfo const* GetFirstRankSpell() const;
    SpellInfo const* GetLastRankSpell() const;
    SpellInfo const* GetNextRankSpell() const;
    SpellInfo const* GetPrevRankSpell() const;
    SpellInfo const* GetAuraRankForLevel(uint8 level) const;
    bool IsRankOf(SpellInfo const* spellInfo) const;
    bool IsDifferentRankOf(SpellInfo const* spellInfo) const;
    bool IsHighRankOf(SpellInfo const* spellInfo) const;
 
    std::array<SpellEffectInfo, MAX_SPELL_EFFECTS> const& GetEffects() const { return Effects; }
    SpellEffectInfo const& GetEffect(SpellEffIndex index) const { ASSERT(index < Effects.size()); return Effects[index]; }
 
    // loading helpers
    void _InitializeExplicitTargetMask();
    bool _IsPositiveEffect(uint8 effIndex, bool deep) const;
    bool _IsPositiveSpell() const;
    static bool _IsPositiveTarget(uint32 targetA, uint32 targetB);
 
    AuraStateType LoadAuraState() const;
    SpellSpecificType LoadSpellSpecific() const;
 
    // unloading helpers
    void _UnloadImplicitTargetConditionLists();
 
    bool CheckElixirStacking(Unit const* caster) const;
 
private:
    std::array<SpellEffectInfo, MAX_SPELL_EFFECTS>& _GetEffects() { return Effects; }
    SpellEffectInfo& _GetEffect(SpellEffIndex index) { ASSERT(index < Effects.size()); return Effects[index]; }
};
 
#endif // _SPELLINFO_H

Referenced by GetImplicitTargetType(), and GetUsedTargetObjectType().

_effIndex

uint8 SpellEffectInfo::_effIndex

private

Referenced by CalcValue(), and SpellEffectInfo().

_spellInfo

SpellInfo const* SpellEffectInfo::_spellInfo

private

Referenced by CalcDamageMultiplier(), CalcRadius(), CalcValue(), CalcValueMultiplier(), and SpellEffectInfo().

Amplitude

uint32 SpellEffectInfo::Amplitude

Referenced by SpellEffectInfo().

ApplyAuraName

uint32 SpellEffectInfo::ApplyAuraName

Referenced by CalcValue(), Spell::CheckCast(), IsAura(), IsAura(), and SpellEffectInfo().

BasePoints

int32 SpellEffectInfo::BasePoints

Referenced by CalcValue(), and SpellEffectInfo().

BonusMultiplier

float SpellEffectInfo::BonusMultiplier

Referenced by SpellEffectInfo().

ChainTarget

uint32 SpellEffectInfo::ChainTarget

Referenced by SpellEffectInfo().

DamageMultiplier

float SpellEffectInfo::DamageMultiplier

Referenced by CalcDamageMultiplier(), and SpellEffectInfo().

DieSides

int32 SpellEffectInfo::DieSides

Referenced by CalcBaseValue(), CalcValue(), and SpellEffectInfo().

Effect

uint32 SpellEffectInfo::Effect

Referenced by CalcValue(), GetImplicitTargetType(), GetUsedTargetObjectType(), IsAreaAuraEffect(), IsAura(), IsEffect(), IsEffect(), IsFarDestTargetEffect(), IsFarUnitTargetEffect(), IsUnitOwnedAuraEffect(), and SpellEffectInfo().

ImplicitTargetConditions

std::list<Condition*>* SpellEffectInfo::ImplicitTargetConditions

Referenced by SpellEffectInfo().

ItemType

uint32 SpellEffectInfo::ItemType

Referenced by SpellEffectInfo().

Mechanic

Mechanics SpellEffectInfo::Mechanic

Referenced by SpellEffectInfo().

MiscValue

int32 SpellEffectInfo::MiscValue

Referenced by Spell::CheckCast(), and SpellEffectInfo().

MiscValueB

int32 SpellEffectInfo::MiscValueB

Referenced by SpellEffectInfo().

PointsPerComboPoint

float SpellEffectInfo::PointsPerComboPoint

Referenced by CalcValue(), and SpellEffectInfo().

RadiusEntry

SpellRadiusEntry const* SpellEffectInfo::RadiusEntry

Referenced by CalcRadius(), HasRadius(), and SpellEffectInfo().

RealPointsPerLevel

float SpellEffectInfo::RealPointsPerLevel

Referenced by CalcValue(), and SpellEffectInfo().

SpellClassMask

flag96 SpellEffectInfo::SpellClassMask

Referenced by SpellEffectInfo().

TargetA

SpellImplicitTargetInfo SpellEffectInfo::TargetA

Referenced by GetMissingTargetMask(), GetProvidedTargetMask(), IsTargetingArea(), and SpellEffectInfo().

TargetB

SpellImplicitTargetInfo SpellEffectInfo::TargetB

Referenced by GetMissingTargetMask(), GetProvidedTargetMask(), IsTargetingArea(), and SpellEffectInfo().

TriggerSpell

uint32 SpellEffectInfo::TriggerSpell

Referenced by SpellEffectInfo().

ValueMultiplier

float SpellEffectInfo::ValueMultiplier

Referenced by CalcValueMultiplier(), and SpellEffectInfo().

---

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

• azerothcore-wotlk/src/server/game/Spells/SpellInfo.h
• azerothcore-wotlk/src/server/game/Spells/SpellInfo.cpp