SpellEffectInfo Class Reference

#include <SpellInfo.h>

Classes
struct	ScalingInfo
struct	StaticData

Public Member Functions
	SpellEffectInfo ()
	SpellEffectInfo (SpellEntry const *spellEntry, SpellInfo const *spellInfo, uint8 effIndex, SpellEffectEntry const *effect)
bool	IsEffect () const
bool	IsEffect (SpellEffectName 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, float *variance=nullptr, int32 itemLevel=-1) const
int32	CalcBaseValue (int32 value) const
float	CalcValueMultiplier (Unit *caster, Spell *spell=NULL) const
float	CalcDamageMultiplier (Unit *caster, Spell *spell=NULL) const
bool	HasRadius () const
bool	HasMaxRadius () const
float	CalcRadius (Unit *caster=NULL, Spell *=NULL) 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	EffectIndex
uint32	Effect
uint32	ApplyAuraName
uint32	ApplyAuraPeriod
int32	DieSides
float	RealPointsPerLevel
int32	BasePoints
float	PointsPerResource
float	Amplitude
float	ChainAmplitude
float	BonusCoefficient
int32	MiscValue
int32	MiscValueB
Mechanics	Mechanic
float	PositionFacing
SpellImplicitTargetInfo	TargetA
SpellImplicitTargetInfo	TargetB
SpellRadiusEntry const *	RadiusEntry
SpellRadiusEntry const *	MaxRadiusEntry
uint32	ChainTargets
uint32	ItemType
uint32	TriggerSpell
flag128	SpellClassMask
float	BonusCoefficientFromAP
std::vector< Condition * > *	ImplicitTargetConditions
struct SpellEffectInfo::ScalingInfo	Scaling

Private Attributes
SpellInfo const *	_spellInfo

Static Private Attributes
static StaticData	_data [TOTAL_SPELL_EFFECTS]

Constructor & Destructor Documentation

SpellEffectInfo::SpellEffectInfo ( )

inline

 : _spellInfo(NULL), EffectIndex(0), Effect(0), ApplyAuraName(0), ApplyAuraPeriod(0), DieSides(0),
 RealPointsPerLevel(0), BasePoints(0), PointsPerResource(0), Amplitude(0), ChainAmplitude(0),
 BonusCoefficient(0), MiscValue(0), MiscValueB(0), Mechanic(MECHANIC_NONE), PositionFacing(0),
 RadiusEntry(NULL), ChainTargets(0), ItemType(0), TriggerSpell(0), BonusCoefficientFromAP(0.0f), ImplicitTargetConditions(NULL) { }

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

{
 _spellInfo = spellInfo;
 EffectIndex = _effect ? _effect->EffectIndex : effIndex;
 Effect = _effect ? _effect->Effect : 0;
 ApplyAuraName = _effect ? _effect->EffectAura : 0;
 ApplyAuraPeriod = _effect ? _effect->EffectAuraPeriod : 0;
 DieSides = _effect ? _effect->EffectDieSides : 0;
 RealPointsPerLevel = _effect ? _effect->EffectRealPointsPerLevel : 0.0f;
 BasePoints = _effect ? _effect->EffectBasePoints : 0;
 PointsPerResource = _effect ? _effect->EffectPointsPerResource : 0.0f;
 Amplitude = _effect ? _effect->EffectAmplitude : 0.0f;
 ChainAmplitude = _effect ? _effect->EffectChainAmplitude : 0.0f;
 BonusCoefficient = _effect ? _effect->EffectBonusCoefficient : 0.0f;
 MiscValue = _effect ? _effect->EffectMiscValue : 0;
 MiscValueB = _effect ? _effect->EffectMiscValueB : 0;
 Mechanic = Mechanics(_effect ? _effect->EffectMechanic : 0);
 PositionFacing = _effect ? _effect->EffectPosFacing : 0.0f;
 TargetA = SpellImplicitTargetInfo(_effect ? _effect->ImplicitTarget[0] : 0);
 TargetB = SpellImplicitTargetInfo(_effect ? _effect->ImplicitTarget[1] : 0);
 RadiusEntry = _effect && _effect->EffectRadiusIndex ? sSpellRadiusStore.LookupEntry(_effect->EffectRadiusIndex) : NULL;
 MaxRadiusEntry = _effect && _effect->EffectRadiusMaxIndex ? sSpellRadiusStore.LookupEntry(_effect->EffectRadiusMaxIndex) : NULL;
 ChainTargets = _effect ? _effect->EffectChainTargets : 0;
 ItemType = _effect ? _effect->EffectItemType : 0;
 TriggerSpell = _effect ? _effect->EffectTriggerSpell : 0;
 SpellClassMask = _effect ? _effect->EffectSpellClassMask : flag128();
 BonusCoefficientFromAP = _effect ? _effect->BonusCoefficientFromAP : 0.0f;
 ImplicitTargetConditions = NULL;

 uint32 _effectScalingId = _effect ? sSpellEffectScallingByEffectId.find(_effect->ID) != sSpellEffectScallingByEffectId.end() ? sSpellEffectScallingByEffectId[_effect->ID] : 0 : 0;
 SpellEffectScalingEntry const* _effectScalingEntry = sSpellEffectScalingStore.LookupEntry(_effectScalingId);

 Scaling.Coefficient = _effectScalingEntry ? _effectScalingEntry->Coefficient : 0.0f;
 Scaling.Variance = _effectScalingEntry ? _effectScalingEntry->Variance : 0.0f;
 Scaling.ResourceCoefficient = _effectScalingEntry ? _effectScalingEntry->ResourceCoefficient : 0.0f;
}

Member Function Documentation

int32 SpellEffectInfo::CalcBaseValue

(

int32

value

)

const

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

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

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

Here is the call graph for this function:

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

{
 const SpellRadiusEntry* entry = RadiusEntry;
 if (!HasRadius() && HasMaxRadius())
 entry = MaxRadiusEntry;

 if (!entry)
 return 0.0f;

 float radius = entry->RadiusMin;

 // Client uses max if min is 0
 if (radius == 0.0f)
 radius = entry->RadiusMax;

 if (caster)
 {
 radius += entry->RadiusPerLevel * caster->getLevel();
 radius = std::min(radius, entry->RadiusMax);
 if (Player* modOwner = caster->GetSpellModOwner())
 modOwner->ApplySpellMod(_spellInfo->Id, SPELLMOD_RADIUS, radius, spell);
 }

 return radius;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int32 SpellEffectInfo::CalcValue	(	Unit const *	caster = nullptr,
		int32 const *	basePoints = nullptr,
		Unit const *	target = nullptr,
		float *	variance = nullptr,
		int32	itemLevel = -1
	)		const

{
 float basePointsPerLevel = RealPointsPerLevel;
 int32 basePoints = bp ? *bp : BasePoints;
 float comboDamage = PointsPerResource;

 // base amount modification based on spell lvl vs caster lvl
 if (Scaling.Coefficient != 0.0f)
 {
 uint32 level = _spellInfo->SpellLevel;
 if (target && _spellInfo->IsPositiveEffect(EffectIndex) && (Effect == SPELL_EFFECT_APPLY_AURA))
 level = target->getLevel();
 else if (caster)
 level = caster->getLevel();

 if (!_spellInfo->HasAttribute(SPELL_ATTR11_SCALES_WITH_ITEM_LEVEL) && _spellInfo->HasAttribute(SPELL_ATTR10_UNK12))
 level = _spellInfo->BaseLevel;

 if (_spellInfo->Scaling.MaxScalingLevel && _spellInfo->Scaling.MaxScalingLevel > level)
 level = _spellInfo->Scaling.MaxScalingLevel;

 float value = 0.0f;
 if (level > 0)
 {
 if (!_spellInfo->Scaling.Class)
 return 0;

 if (!_spellInfo->Scaling.ScalesFromItemLevel)
 {
 if (!_spellInfo->HasAttribute(SPELL_ATTR11_SCALES_WITH_ITEM_LEVEL))
 {
 if (GtSpellScalingEntry const* gtScaling = sGtSpellScalingStore.EvaluateTable(level - 1, (_spellInfo->Scaling.Class > 0 ? _spellInfo->Scaling.Class : ((MAX_CLASSES - 1 /*last class*/) - _spellInfo->Scaling.Class)) - 1))
 value = gtScaling->value;
 }
 else
 value = GetRandomPropertyPoints(itemLevel != -1 ? uint32(itemLevel) : 1u, ITEM_QUALITY_RARE, INVTYPE_CHEST, 0);
 }
 else
 value = GetRandomPropertyPoints(_spellInfo->Scaling.ScalesFromItemLevel, ITEM_QUALITY_RARE, INVTYPE_CHEST, 0);

 if (level < _spellInfo->Scaling.CastTimeMaxLevel && _spellInfo->Scaling.CastTimeMax)
 value *= float(_spellInfo->Scaling.CastTimeMin + (level - 1) * (_spellInfo->Scaling.CastTimeMax - _spellInfo->Scaling.CastTimeMin) / (_spellInfo->Scaling.CastTimeMaxLevel - 1)) / float(_spellInfo->Scaling.CastTimeMax);

 if (level < _spellInfo->Scaling.NerfMaxLevel)
 value *= ((((1.0f - _spellInfo->Scaling.NerfFactor) * (level - 1)) / (_spellInfo->Scaling.NerfMaxLevel - 1)) + _spellInfo->Scaling.NerfFactor);
 }

 value *= Scaling.Coefficient;
 if (value != 0.0f && value < 1.0f)
 value = 1.0f;

 if (Scaling.Variance)
 {
 float delta = fabs(Scaling.Variance * 0.5f);
 float valueVariance = frand(-delta, delta);
 value += value * valueVariance;

 if (variance)
 *variance = valueVariance;
 }

 basePoints = int32(value);

 if (Scaling.ResourceCoefficient)
 comboDamage = Scaling.ResourceCoefficient * value;
 }
 else
 {
 if (caster)
 {
 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);
 level -= int32(_spellInfo->SpellLevel);
 basePoints += int32(level * basePointsPerLevel);
 }

 // roll in a range <1;EffectDieSides> as of patch 3.3.3
 int32 randomPoints = int32(DieSides);
 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 (caster->m_movedPlayer && comboDamage)
 if (uint32 comboPoints = caster->m_movedPlayer->GetComboPoints())
 value += comboDamage * comboPoints;

 value = caster->ApplyEffectModifiers(_spellInfo, EffectIndex, value);

 // amount multiplication based on caster's level
 if (!caster->IsControlledByPlayer() &&
 _spellInfo->SpellLevel && _spellInfo->SpellLevel != caster->getLevel() &&
 !basePointsPerLevel && (_spellInfo->HasAttribute(SPELL_ATTR0_LEVEL_DAMAGE_CALCULATION)))
 {
 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)
 {
 GtNPCManaCostScalerEntry const* spellScaler = sGtNPCManaCostScalerStore.EvaluateTable(_spellInfo->SpellLevel - 1, 0);
 GtNPCManaCostScalerEntry const* casterScaler = sGtNPCManaCostScalerStore.EvaluateTable(caster->getLevel() - 1, 0);
 if (spellScaler && casterScaler)
 value *= casterScaler->ratio / spellScaler->ratio;
 }
 }
 }

 return int32(value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

SpellEffectImplicitTargetTypes SpellEffectInfo::GetImplicitTargetType

(

)

const

{
 return _data[Effect].ImplicitTargetType;
}

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 SpellEffectInfo::GetProvidedTargetMask

(

)

const

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

Here is the call graph for this function:

Here is the caller graph for this function:

SpellTargetObjectTypes SpellEffectInfo::GetUsedTargetObjectType

(

)

const

{
 return _data[Effect].UsedTargetObjectType;
}

Here is the caller graph for this function:

bool SpellEffectInfo::HasMaxRadius

(

)

const

{
 return MaxRadiusEntry != NULL;
}

Here is the caller graph for this function:

bool SpellEffectInfo::HasRadius

(

)

const

{
 return RadiusEntry != NULL;
}

Here is the caller graph for this function:

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

Here is the caller graph for this function:

bool SpellEffectInfo::IsAura

(

)

const

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

Here is the call graph for this function:

Here is the caller graph for this function:

bool SpellEffectInfo::IsAura

(

AuraType

aura

)

const

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

Here is the call graph for this function:

bool SpellEffectInfo::IsEffect

(

)

const

{
 return Effect != 0;
}

Here is the caller graph for this function:

bool SpellEffectInfo::IsEffect

(

SpellEffectName

effectName

)

const

{
 return Effect == uint32(effectName);
}

bool SpellEffectInfo::IsFarDestTargetEffect

(

)

const

{
 return Effect == SPELL_EFFECT_TELEPORT_UNITS;
}

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

bool SpellEffectInfo::IsTargetingArea

(

)

const

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

Here is the call graph for this function:

Here is the caller graph for this function:

bool SpellEffectInfo::IsUnitOwnedAuraEffect

(

)

const

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

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

SpellEffectInfo::StaticData SpellEffectInfo::_data

staticprivate

SpellInfo const* SpellEffectInfo::_spellInfo

private

float SpellEffectInfo::Amplitude

uint32 SpellEffectInfo::ApplyAuraName

uint32 SpellEffectInfo::ApplyAuraPeriod

int32 SpellEffectInfo::BasePoints

float SpellEffectInfo::BonusCoefficient

float SpellEffectInfo::BonusCoefficientFromAP

float SpellEffectInfo::ChainAmplitude

uint32 SpellEffectInfo::ChainTargets

int32 SpellEffectInfo::DieSides

uint32 SpellEffectInfo::Effect

uint32 SpellEffectInfo::EffectIndex

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

uint32 SpellEffectInfo::ItemType

SpellRadiusEntry const* SpellEffectInfo::MaxRadiusEntry

Mechanics SpellEffectInfo::Mechanic

int32 SpellEffectInfo::MiscValue

int32 SpellEffectInfo::MiscValueB

float SpellEffectInfo::PointsPerResource

float SpellEffectInfo::PositionFacing

SpellRadiusEntry const* SpellEffectInfo::RadiusEntry

float SpellEffectInfo::RealPointsPerLevel

struct SpellEffectInfo::ScalingInfo SpellEffectInfo::Scaling

flag128 SpellEffectInfo::SpellClassMask

SpellImplicitTargetInfo SpellEffectInfo::TargetA

SpellImplicitTargetInfo SpellEffectInfo::TargetB

uint32 SpellEffectInfo::TriggerSpell

---

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

• src/server/game/Spells/SpellInfo.h
• src/server/game/Spells/SpellInfo.cpp