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 (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, 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, and Object::ToCreature().

Referenced by spell_dragonblight_corrosive_spit::AfterApply(), spell_dragonblight_corrosive_spit::PeriodicTick(), 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

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(), and SpellEffectInfo().

BasePoints

int32 SpellEffectInfo::BasePoints

Referenced by CalcValue(), spell_zereketh_seed_of_corruption::HandleProc(), 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(), 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().