#include <SpellInfo.h>

Classes
struct	CostData

struct	ScalingInfo

Public Member Functions
SpellTargetRestrictionsEntry const *	GetSpellTargetRestrictions () const

SpellAuraOptionsEntry const *	GetSpellAuraOptions () const

SpellAuraRestrictionsEntry const *	GetSpellAuraRestrictions () const

SpellCastingRequirementsEntry const *	GetSpellCastingRequirements () const

SpellCategoriesEntry const *	GetSpellCategories () const

SpellClassOptionsEntry const *	GetSpellClassOptions () const

SpellCooldownsEntry const *	GetSpellCooldowns () const

SpellEquippedItemsEntry const *	GetSpellEquippedItems () const

SpellInterruptsEntry const *	GetSpellInterrupts () const

SpellLevelsEntry const *	GetSpellLevels () const

SpellReagentsEntry const *	GetSpellReagents () const

SpellScalingEntry const *	GetSpellScaling () const

SpellShapeshiftEntry const *	GetSpellShapeshift () const

SpellTotemsEntry const *	GetSpellTotems () const

SpellMiscEntry const *	GetSpellMisc () const

	SpellInfo (SpellEntry const *spellEntry, SpellEffectEntryMap const &effectsMap, SpellVisualMap &&visuals)

	~SpellInfo ()

uint32	GetCategory () const

bool	HasEffect (uint32 difficulty, SpellEffectName effect) const

bool	HasEffect (SpellEffectName effect) const

bool	HasAura (uint32 difficulty, AuraType aura) const

bool	HasAreaAuraEffect (uint32 difficulty) const

bool	HasAreaAuraEffect () 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 (SpellCustomAttributes customAttribute) const

bool	IsExplicitDiscovery () const

bool	IsLootCrafting () const

bool	IsQuestTame () const

bool	IsProfessionOrRiding (uint32 difficulty=DIFFICULTY_NONE) const

bool	IsProfession (uint32 difficulty=DIFFICULTY_NONE) const

bool	IsPrimaryProfession (uint32 difficulty=DIFFICULTY_NONE) const

bool	IsPrimaryProfessionFirstRank (uint32 difficulty=DIFFICULTY_NONE) const

bool	IsAbilityLearnedWithProfession () const

bool	IsAbilityOfSkillType (uint32 skillType) const

bool	IsAffectingArea (uint32 difficulty) const

bool	IsTargetingArea (uint32 difficulty) const

bool	NeedsExplicitUnitTarget () const

bool	NeedsToBeTriggeredByCaster (SpellInfo const *triggeringSpell, uint32 difficulty) const

bool	IsPassive () const

bool	IsAutocastable () const

bool	IsStackableWithRanks () const

bool	IsPassiveStackableWithRanks (uint32 difficulty) const

bool	IsMultiSlotAura () const

bool	IsStackableOnOneSlotWithDifferentCasters () const

bool	IsCooldownStartedOnEvent () const

bool	IsDeathPersistent () const

bool	IsRequiringDeadTarget () const

bool	IsAllowingDeadTarget () const

bool	CanBeUsedInCombat () const

bool	IsPositive () const

bool	IsPositiveEffect (uint8 effIndex) const

bool	IsChanneled () const

bool	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 const *player=NULL) const

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

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

SpellCastResult	CheckVehicle (Unit const *caster) const

bool	CheckTargetCreatureType (Unit const *target) const

SpellSchoolMask	GetSchoolMask () const

uint32	GetAllEffectsMechanicMask () const

uint32	GetEffectMechanicMask (uint32 effIndex) const

uint32	GetSpellMechanicMaskByEffectMask (uint32 effectMask) const

Mechanics	GetEffectMechanic (uint32 effIndex, uint32 difficulty) const

uint32	GetDispelMask () const

uint32	GetExplicitTargetMask () const

AuraStateType	GetAuraState (uint32 difficulty) const

SpellSpecificType	GetSpellSpecific () const

float	GetMinRange (bool positive=false) const

float	GetMaxRange (bool positive=false, Unit caster=NULL, Spell spell=NULL) const

int32	GetDuration () const

int32	GetMaxDuration () const

uint32	GetMaxTicks (uint32 difficulty) const

uint32	CalcCastTime (uint8 level=0, Spell *spell=NULL) const

uint32	GetRecoveryTime () const

std::vector< CostData >	CalcPowerCost (Unit const *caster, SpellSchoolMask schoolMask) 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 (Difficulty difficulty) const

uint32	GetSpellVisual (Difficulty difficulty, Player *forPlayer=nullptr) const

void	_InitializeExplicitTargetMask ()

bool	_IsPositiveEffect (uint32 effIndex, bool deep) const

bool	_IsPositiveSpell () const

void	_UnloadImplicitTargetConditionLists ()

void	_UnloadSpellEffects ()

SpellEffectInfoVector	GetEffectsForDifficulty (uint32 difficulty) const

SpellEffectInfo const *	GetEffect (uint32 difficulty, uint32 index) const

SpellEffectInfo const *	GetEffect (uint32 index) const

SpellEffectInfo const *	GetEffect (WorldObject const *obj, uint32 index) const

Static Public Member Functions
static uint32	GetDispelMask (DispelType type)

static bool	_IsPositiveTarget (uint32 targetA, uint32 targetB)

Public Attributes
uint32	Id

SpellCategoryEntry const *	CategoryEntry

uint32	Dispel

uint32	Mechanic

uint32	Attributes

uint32	AttributesEx

uint32	AttributesEx2

uint32	AttributesEx3

uint32	AttributesEx4

uint32	AttributesEx5

uint32	AttributesEx6

uint32	AttributesEx7

uint32	AttributesEx8

uint32	AttributesEx9

uint32	AttributesEx10

uint32	AttributesEx11

uint32	AttributesEx12

uint32	AttributesEx13

uint32	AttributesCu

uint64	Stances

uint64	StancesNot

uint32	Targets

uint32	TargetCreatureType

uint32	RequiresSpellFocus

uint32	FacingCasterFlags

uint32	CasterAuraState

uint32	TargetAuraState

uint32	ExcludeCasterAuraState

uint32	ExcludeTargetAuraState

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

std::vector< SpellPowerEntry const * >	PowerCosts

uint32	RuneCostID

SpellRangeEntry const *	RangeEntry

float	Speed

uint32	StackAmount

uint32	Totem [2]

int32	Reagent [MAX_SPELL_REAGENTS]

uint32	ReagentCount [MAX_SPELL_REAGENTS]

int32	EquippedItemClass

int32	EquippedItemSubClassMask

int32	EquippedItemInventoryTypeMask

uint32	TotemCategory [2]

uint32	SpellVisual [2]

uint32	SpellIconID

uint32	ActiveIconID

char *	SpellName

char *	Rank

uint32	MaxTargetLevel

uint32	MaxAffectedTargets

uint32	SpellFamilyName

flag128	SpellFamilyFlags

uint32	DmgClass

uint32	PreventionType

int32	RequiredAreasID

uint32	SchoolMask

SpellCategoryEntry const *	ChargeCategoryEntry

uint32	SpellDifficultyId

uint32	SpellScalingId

uint32	SpellAuraOptionsId

uint32	SpellAuraRestrictionsId

uint32	SpellCastingRequirementsId

uint32	SpellCategoriesId

uint32	SpellClassOptionsId

uint32	SpellCooldownsId

uint32	SpellEquippedItemsId

uint32	SpellInterruptsId

uint32	SpellLevelsId

uint32	SpellReagentsId

uint32	SpellShapeshiftId

uint32	SpellTargetRestrictionsId

uint32	SpellTotemsId

uint32	SpellMiscId

struct SpellInfo::ScalingInfo	Scaling

uint32	ExplicitTargetMask

SpellChainNode const *	ChainEntry

SpellEffectInfoMap	_effects

SpellVisualMap	_visuals

bool	_hasPowerDifficultyData

Constructor & Destructor Documentation

SpellInfo::SpellInfo	(	SpellEntry const *	spellEntry,
		SpellEffectEntryMap const &	effectsMap,
		SpellVisualMap &&	visuals
	)

  : _hasPowerDifficultyData(false)
 {
  Id = spellEntry->ID;
 
  // SpellDifficultyEntry
  for (SpellEffectEntryMap::value_type const& itr : effectsMap)
  {
  SpellEffectEntryVector const& effects = itr.second;
  _effects[itr.first].resize(effects.size());
 
  for (size_t i = 0; i < effects.size(); ++i)
  {
  if (SpellEffectEntry const* effect = effects[i])
  _effects[itr.first][effect->EffectIndex] = new SpellEffectInfo(spellEntry, this, effect->EffectIndex, effect);
  }
  }
 
  SpellName = spellEntry->Name_lang;
  Rank = nullptr;
  RuneCostID = spellEntry->RuneCostID;
  SpellDifficultyId = 0;
  SpellScalingId = spellEntry->ScalingID;
  SpellAuraOptionsId = spellEntry->AuraOptionsID;
  SpellAuraRestrictionsId = spellEntry->AuraRestrictionsID;
  SpellCastingRequirementsId = spellEntry->CastingRequirementsID;
  SpellCategoriesId = spellEntry->CategoriesID;
  SpellClassOptionsId = spellEntry->ClassOptionsID;
  SpellCooldownsId = spellEntry->CooldownsID;
  SpellEquippedItemsId = spellEntry->EquippedItemsID;
  SpellInterruptsId = spellEntry->InterruptsID;
  SpellLevelsId = spellEntry->LevelsID;
  SpellReagentsId = spellEntry->ReagentsID;
  SpellShapeshiftId = spellEntry->ShapeshiftID;
  SpellTargetRestrictionsId = spellEntry->TargetRestrictionsID;
  SpellTotemsId = spellEntry->TotemsID;
  SpellMiscId = spellEntry->MiscID;
 
  // SpellMiscEntry
  SpellMiscEntry const* _misc = GetSpellMisc();
  Attributes = _misc ? _misc->Attributes : 0;
  AttributesEx = _misc ? _misc->AttributesEx : 0;
  AttributesEx2 = _misc ? _misc->AttributesExB : 0;
  AttributesEx3 = _misc ? _misc->AttributesExC : 0;
  AttributesEx4 = _misc ? _misc->AttributesExD : 0;
  AttributesEx5 = _misc ? _misc->AttributesExE : 0;
  AttributesEx6 = _misc ? _misc->AttributesExF : 0;
  AttributesEx7 = _misc ? _misc->AttributesExG : 0;
  AttributesEx8 = _misc ? _misc->AttributesExH : 0;
  AttributesEx9 = _misc ? _misc->AttributesExI : 0;
  AttributesEx10 = _misc ? _misc->AttributesExJ : 0;
  AttributesEx11 = _misc ? _misc->AttributesExK : 0;
  AttributesEx12 = _misc ? _misc->AttributesExL : 0;
  AttributesEx13 = _misc ? _misc->AttributesExM : 0;
  CastTimeEntry = _misc ? (_misc->CastingTimeIndex ? sSpellCastTimesStore.LookupEntry(_misc->CastingTimeIndex) : NULL) : NULL;
  DurationEntry = _misc ? (_misc->DurationIndex ? sSpellDurationStore.LookupEntry(_misc->DurationIndex) : NULL) : NULL;
  RangeEntry = _misc ? (_misc->RangeIndex ? sSpellRangeStore.LookupEntry(_misc->RangeIndex) : NULL) : NULL;
  Speed = _misc ? _misc->Speed : 0;
  SchoolMask = _misc ? _misc->SchoolMask : 0;
  AttributesCu = 0;
  SpellIconID = _misc ? _misc->SpellIconID : 0;
  ActiveIconID = _misc ? _misc->ActiveIconID : 0;
 
  _visuals = std::move(visuals);
 
  // SpellScalingEntry
  SpellScalingEntry const* _scaling = GetSpellScaling();
  Scaling.CastTimeMin = _scaling ? _scaling->CastTimeMin : 0;
  Scaling.CastTimeMax = _scaling ?_scaling->CastTimeMax : 0;
  Scaling.CastTimeMaxLevel = _scaling ? _scaling->CastTimeMaxLevel : 0;
  Scaling.Class = _scaling ? _scaling->ScalingClass : 0;
  Scaling.NerfFactor = _scaling ? _scaling->NerfFactor : 0;
  Scaling.NerfMaxLevel = _scaling ? _scaling->NerfMaxLevel : 0;
  Scaling.MaxScalingLevel = _scaling ? _scaling->MaxScalingLevel : 0;
  Scaling.ScalesFromItemLevel = _scaling ? _scaling->ScalesFromItemLevel : 0;
 
  // SpellAuraOptionsEntry
  SpellAuraOptionsEntry const* _options = GetSpellAuraOptions();
  ProcFlags = _options ? _options->ProcTypeMask : 0;
  ProcChance = _options ? _options->ProcChance : 0;
  ProcCharges = _options ? _options->ProcCharges : 0;
  StackAmount = _options ? _options->CumulativeAura : 0;
 
  // SpellAuraRestrictionsEntry
  SpellAuraRestrictionsEntry const* _aura = GetSpellAuraRestrictions();
  CasterAuraState = _aura ? _aura->CasterAuraState : 0;
  TargetAuraState = _aura ? _aura->TargetAuraState : 0;
  ExcludeCasterAuraState = _aura ? _aura->ExcludeCasterAuraState : 0;
  ExcludeTargetAuraState = _aura ? _aura->ExcludeTargetAuraState : 0;
  CasterAuraSpell = _aura ? _aura->CasterAuraSpell : 0;
  TargetAuraSpell = _aura ? _aura->TargetAuraSpell : 0;
  ExcludeCasterAuraSpell = _aura ? _aura->ExcludeCasterAuraSpell : 0;
  ExcludeTargetAuraSpell = _aura ? _aura->ExcludeTargetAuraSpell : 0;
 
  // SpellCastingRequirementsEntry
  SpellCastingRequirementsEntry const* _castreq = GetSpellCastingRequirements();
  RequiresSpellFocus = _castreq ? _castreq->RequiresSpellFocus : 0;
  FacingCasterFlags = _castreq ? _castreq->FacingCasterFlags : 0;
  RequiredAreasID = _castreq ? _castreq->RequiredAreasID : -1;
 
  // SpellCategoriesEntry
  SpellCategoriesEntry const* _categorie = GetSpellCategories();
  CategoryEntry = _categorie ? sSpellCategoryStore.LookupEntry(_categorie->Category) : NULL;
  Dispel = _categorie ? _categorie->DispelType : 0;
  Mechanic = _categorie ? _categorie->Mechanic : 0;
  StartRecoveryCategory = _categorie ? _categorie->StartRecoveryCategory : 0;
  DmgClass = _categorie ? _categorie->DefenseType : 0;
  PreventionType = _categorie ? _categorie->PreventionType : 0;
  ChargeCategoryEntry = _categorie ? sSpellCategoryStore.LookupEntry(_categorie->ChargeCategory) : 0;
 
  // SpellClassOptionsEntry
  SpellClassOptionsEntry const* _class = GetSpellClassOptions();
  SpellFamilyName = _class ? _class->SpellClassSet : 0;
  SpellFamilyFlags = _class ? _class->SpellClassMask : flag128();
 
  // SpellCooldownsEntry
  SpellCooldownsEntry const* _cooldowns = GetSpellCooldowns();
  RecoveryTime = _cooldowns ? _cooldowns->RecoveryTime : 0;
  CategoryRecoveryTime = _cooldowns ? _cooldowns->CategoryRecoveryTime : 0;
  StartRecoveryTime = _cooldowns ? _cooldowns->StartRecoveryTime : 0;
 
  // SpellEquippedItemsEntry
  SpellEquippedItemsEntry const* _equipped = GetSpellEquippedItems();
  EquippedItemClass = _equipped ? _equipped->EquippedItemClass : -1;
  EquippedItemSubClassMask = _equipped ?_equipped->EquippedItemSubClassMask : -1;
  EquippedItemInventoryTypeMask = _equipped ? _equipped->EquippedItemInventoryTypeMask : -1;
 
  // SpellInterruptsEntry
  SpellInterruptsEntry const* _interrupt = GetSpellInterrupts();
  InterruptFlags = _interrupt ? _interrupt->InterruptFlags : 0;
  // TODO: 6.x these flags have 2 parts
  AuraInterruptFlags = _interrupt ? _interrupt->AuraInterruptFlags[0] : 0;
  ChannelInterruptFlags = _interrupt ? _interrupt->ChannelInterruptFlags[0] : 0;
 
  // SpellLevelsEntry
  SpellLevelsEntry const* _levels = GetSpellLevels();
  MaxLevel = _levels ? _levels->MaxLevel : 0;
  BaseLevel = _levels ? _levels->BaseLevel : 0;
  SpellLevel = _levels ? _levels->SpellLevel : 0;
 
  // SpellPowerEntry
  PowerCosts = sDB2Manager.GetSpellPowers(Id, DIFFICULTY_NONE, &_hasPowerDifficultyData);
 
  // SpellReagentsEntry
  SpellReagentsEntry const* _reagents = GetSpellReagents();
  for (uint8 i = 0; i < MAX_SPELL_REAGENTS; ++i)
  Reagent[i] = _reagents ? _reagents->Reagent[i] : 0;
  for (uint8 i = 0; i < MAX_SPELL_REAGENTS; ++i)
  ReagentCount[i] = _reagents ? _reagents->ReagentCount[i] : 0;
 
  // SpellShapeshiftEntry
  SpellShapeshiftEntry const* _shapeshift = GetSpellShapeshift();
  Stances = _shapeshift ? MAKE_PAIR64(_shapeshift->ShapeshiftMask[0], _shapeshift->ShapeshiftMask[1]) : 0;
  StancesNot = _shapeshift ? MAKE_PAIR64(_shapeshift->ShapeshiftExclude[0], _shapeshift->ShapeshiftExclude[1]) : 0;
 
  // SpellTargetRestrictionsEntry
  SpellTargetRestrictionsEntry const* _target = GetSpellTargetRestrictions();
  Targets = _target ? _target->Targets : 0;
  TargetCreatureType = _target ? _target->TargetCreatureType : 0;
  MaxAffectedTargets = _target ? _target->MaxAffectedTargets : 0;
  MaxTargetLevel = _target ? _target->MaxTargetLevel : 0;
 
  // SpellTotemsEntry
  SpellTotemsEntry const* _totem = GetSpellTotems();
  for (uint8 i = 0; i < 2; ++i)
  TotemCategory[i] = _totem ? _totem->RequiredTotemCategoryID[i] : 0;
  for (uint8 i = 0; i < 2; ++i)
  Totem[i] = _totem ? _totem->Totem[i] : 0;
 
  ChainEntry = NULL;
  ExplicitTargetMask = 0;
 }

Here is the call graph for this function:

SpellInfo::~SpellInfo ( )

 {
  _UnloadImplicitTargetConditionLists();
  _UnloadSpellEffects();
 }

Here is the call graph for this function:

Member Function Documentation

void SpellInfo::_InitializeExplicitTargetMask ( )

 {
  bool srcSet = false;
  bool dstSet = false;
  uint32 targetMask = Targets;
  // prepare target mask using effect target entries
  for (SpellEffectInfoMap::const_iterator itr = _effects.begin(); itr != _effects.end(); ++itr)
  {
  for (SpellEffectInfo const* effect : itr->second)
  {
  if (!effect || !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:

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

 {
  // not found a single positive spell with this attribute
  if (Attributes & SPELL_ATTR0_NEGATIVE_1)
  return false;
 
  switch (SpellFamilyName)
  {
  case SPELLFAMILY_GENERIC:
  switch (Id)
  {
  case 29214: // Wrath of the Plaguebringer
  case 34700: // Allergic Reaction
  case 54836: // Wrath of the Plaguebringer
  return false;
  case 30877: // Tag Murloc
  case 61716: // Rabbit Costume
  case 61734: // Noblegarden Bunny
  case 62344: // Fists of Stone
  case 61819: // Manabonked! (item)
  case 61834: // Manabonked! (minigob)
  case 73523: // Rigor Mortis
  return true;
  default:
  break;
  }
  break;
  case SPELLFAMILY_MAGE:
  // Ignite
  if (SpellIconID == 45)
  return true;
  break;
  case SPELLFAMILY_PRIEST:
  switch (Id)
  {
  case 64844: // Divine Hymn
  case 64904: // Hymn of Hope
  case 47585: // Dispersion
  return true;
  default:
  break;
  }
  break;
  case SPELLFAMILY_ROGUE:
  switch (Id)
  {
  // Envenom must be considered as a positive effect even though it deals damage
  case 32645: // Envenom
  return true;
  default:
  break;
  }
  break;
  default:
  break;
  }
 
  switch (Mechanic)
  {
  case MECHANIC_IMMUNE_SHIELD:
  return true;
  default:
  break;
  }
 
  // Special case: effects which determine positivity of whole spell
  for (SpellEffectInfoMap::const_iterator itr = _effects.begin(); itr != _effects.end(); ++itr)
  {
  for (SpellEffectInfo const* effect : itr->second)
  {
  if (effect && effect->IsAura() && effect->ApplyAuraName == SPELL_AURA_MOD_STEALTH)
  return true;
  }
  }
 
  for (SpellEffectInfoMap::const_iterator itr = _effects.begin(); itr != _effects.end(); ++itr)
  {
  for (SpellEffectInfo const* effect : itr->second)
  {
  if (!effect || effect->EffectIndex != effIndex)
  continue;
 
  switch (effect->Effect)
  {
  case SPELL_EFFECT_DUMMY:
  // some explicitly required dummy effect sets
  switch (Id)
  {
  case 28441:
  return false; // AB Effect 000
  default:
  break;
  }
  break;
  // always positive effects (check before target checks that provided non-positive result in some case for positive effects)
  case SPELL_EFFECT_HEAL:
  case SPELL_EFFECT_LEARN_SPELL:
  case SPELL_EFFECT_SKILL_STEP:
  case SPELL_EFFECT_HEAL_PCT:
  case SPELL_EFFECT_ENERGIZE_PCT:
  return true;
  case SPELL_EFFECT_APPLY_AREA_AURA_ENEMY:
  return false;
 
  // non-positive aura use
  case SPELL_EFFECT_APPLY_AURA:
  case SPELL_EFFECT_APPLY_AREA_AURA_FRIEND:
  {
  switch (effect->ApplyAuraName)
  {
  case SPELL_AURA_MOD_DAMAGE_DONE: // dependent from bas point sign (negative -> negative)
  case SPELL_AURA_MOD_STAT:
  case SPELL_AURA_MOD_SKILL:
  case SPELL_AURA_MOD_SKILL_2:
  case SPELL_AURA_MOD_DODGE_PERCENT:
  case SPELL_AURA_MOD_HEALING_PCT:
  case SPELL_AURA_MOD_HEALING_DONE:
  case SPELL_AURA_MOD_DAMAGE_PERCENT_DONE:
  if (effect->CalcValue() < 0)
  return false;
  break;
  case SPELL_AURA_MOD_DAMAGE_TAKEN: // dependent from bas point sign (positive -> negative)
  if (effect->CalcValue() > 0)
  return false;
  break;
  case SPELL_AURA_MOD_CRIT_PCT:
  case SPELL_AURA_MOD_SPELL_CRIT_CHANCE:
  if (effect->CalcValue() > 0)
  return true; // some expected positive spells have SPELL_ATTR1_NEGATIVE
  break;
  case SPELL_AURA_ADD_TARGET_TRIGGER:
  return true;
  case SPELL_AURA_PERIODIC_TRIGGER_SPELL_WITH_VALUE:
  case SPELL_AURA_PERIODIC_TRIGGER_SPELL:
  if (!deep)
  {
  if (SpellInfo const* spellTriggeredProto = sSpellMgr->GetSpellInfo(effect->TriggerSpell))
  {
  // negative targets of main spell return early
  for (SpellEffectInfoMap::const_iterator it = spellTriggeredProto->_effects.begin(); it != spellTriggeredProto->_effects.end(); ++it)
  {
  for (SpellEffectInfo const* eff : itr->second)
  {
  if (!eff || !eff->Effect)
  continue;
  // if non-positive trigger cast targeted to positive target this main cast is non-positive
  // this will place this spell auras as debuffs
  if (_IsPositiveTarget(eff->TargetA.GetTarget(), eff->TargetB.GetTarget()) && !spellTriggeredProto->_IsPositiveEffect(eff->EffectIndex, true))
  return false;
  }
  }
  }
  }
  case SPELL_AURA_PROC_TRIGGER_SPELL:
  // many positive auras have negative triggered spells at damage for example and this not make it negative (it can be canceled for example)
  break;
  case SPELL_AURA_MOD_STUN: //have positive and negative spells, we can't sort its correctly at this moment.
  {
  bool more = false;
  for (SpellEffectInfoMap::const_iterator i = _effects.begin(); i != _effects.end(); ++i)
  {
  for (SpellEffectInfo const* eff : i->second)
  {
  if (eff && eff->EffectIndex != 0)
  {
  more = true;
  break;
  }
  }
  }
  if (effIndex == 0 && !more)
  return false; // but all single stun aura spells is negative
  break;
  }
  case SPELL_AURA_MOD_PACIFY_SILENCE:
  if (Id == 24740) // Wisp Costume
  return true;
  return false;
  case SPELL_AURA_MOD_ROOT:
  case SPELL_AURA_MOD_SILENCE:
  case SPELL_AURA_GHOST:
  case SPELL_AURA_PERIODIC_LEECH:
  case SPELL_AURA_MOD_STALKED:
  case SPELL_AURA_PERIODIC_DAMAGE_PERCENT:
  case SPELL_AURA_PREVENT_RESURRECTION:
  return false;
  case SPELL_AURA_PERIODIC_DAMAGE: // used in positive spells also.
  // part of negative spell if cast at self (prevent cancel)
  if (effect->TargetA.GetTarget() == TARGET_UNIT_CASTER)
  return false;
  break;
  case SPELL_AURA_MOD_DECREASE_SPEED: // used in positive spells also
  // part of positive spell if cast at self
  if (effect->TargetA.GetTarget() != TARGET_UNIT_CASTER)
  return false;
  // but not this if this first effect (didn't find better check)
  if (Attributes & SPELL_ATTR0_NEGATIVE_1 && effIndex == 0)
  return false;
  break;
  case SPELL_AURA_MECHANIC_IMMUNITY:
  {
  // non-positive immunities
  switch (effect->MiscValue)
  {
  case MECHANIC_BANDAGE:
  case MECHANIC_SHIELD:
  case MECHANIC_MOUNT:
  case MECHANIC_INVULNERABILITY:
  return false;
  default:
  break;
  }
  break;
  }
  case SPELL_AURA_ADD_FLAT_MODIFIER: // mods
  case SPELL_AURA_ADD_PCT_MODIFIER:
  {
  // non-positive mods
  switch (effect->MiscValue)
  {
  case SPELLMOD_COST: // dependent from bas point sign (negative -> positive)
  if (effect->CalcValue() > 0)
  {
  if (!deep)
  {
  bool negative = true;
  for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
  {
  if (i != effIndex)
  if (_IsPositiveEffect(i, true))
  {
  negative = false;
  break;
  }
  }
  if (negative)
  return false;
  }
  }
  break;
  default:
  break;
  }
  break;
  }
  default:
  break;
  }
  break;
  }
  default:
  break;
  }
 
  // non-positive targets
  if (!_IsPositiveTarget(effect->TargetA.GetTarget(), effect->TargetB.GetTarget()))
  return false;
 
  // negative spell if triggered spell is negative
  if (!deep && !effect->ApplyAuraName && effect->TriggerSpell)
  {
  if (SpellInfo const* spellTriggeredProto = sSpellMgr->GetSpellInfo(effect->TriggerSpell))
  if (!spellTriggeredProto->_IsPositiveSpell())
  return false;
  }
  }
  }
  // ok, positive
  return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SpellInfo::_IsPositiveSpell ( ) const

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

static

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

Here is the caller graph for this function:

void SpellInfo::_UnloadImplicitTargetConditionLists ( )

 {
     // find the same instances of ConditionList and delete them.
     for (uint32 d = 0; d < MAX_DIFFICULTY; ++d)
     {
         for (uint32 i = 0; i < _effects.size(); ++i)
         {
             if (SpellEffectInfo const* effect = GetEffect(d, i))
             {
                 ConditionContainer* cur = effect->ImplicitTargetConditions;
                 if (!cur)
                     continue;
                 for (uint8 j = i; j < _effects.size(); ++j)
                 {
                     if (SpellEffectInfo const* eff = GetEffect(d, j))
                     {
                         if (eff->ImplicitTargetConditions == cur)
                             const_cast<SpellEffectInfo*>(eff)->ImplicitTargetConditions = NULL;
                     }
                 }
                 delete cur;
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SpellInfo::_UnloadSpellEffects ( )

 {
     for (SpellEffectInfoMap::value_type& i : _effects)
         for (size_t j = 0; j < i.second.size(); ++j)
             delete i.second[j];
     _effects.clear();
 }

Here is the caller graph for this function:

uint32 SpellInfo::CalcCastTime	(	uint8	level = `0`,
		Spell *	spell = `NULL`
	)		const

 {
     int32 castTime = 0;
     if (!level && spell)
         level = spell->GetCaster()->getLevel();
 
     // not all spells have cast time index and this is all is pasiive abilities
     if (level && Scaling.CastTimeMax > 0)
     {
         castTime = Scaling.CastTimeMax;
         if (Scaling.CastTimeMaxLevel > level)
             castTime = Scaling.CastTimeMin + int32(level - 1) * (Scaling.CastTimeMax - Scaling.CastTimeMin) / (Scaling.CastTimeMaxLevel - 1);
     }
     else if (CastTimeEntry)
         castTime = CastTimeEntry->CastTime;
 
     if (!castTime)
         return 0;
 
     if (spell)
         spell->GetCaster()->ModSpellCastTime(this, castTime, spell);
 
     if (Attributes & SPELL_ATTR0_REQ_AMMO && (!IsAutoRepeatRangedSpell()) && !(AttributesEx9 & 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:

std::vector< SpellInfo::CostData > SpellInfo::CalcPowerCost	(	Unit const *	caster,
		SpellSchoolMask	schoolMask
	)		const

 {
     std::vector<CostData> costs;
     auto collector = [this, caster, schoolMask, &costs](std::vector<SpellPowerEntry const*> const& powers)
     {
         costs.reserve(powers.size());
         int32 healthCost = 0;
 
 
         for (SpellPowerEntry const* power : powers)
         {
             if (power->RequiredAura && !caster->HasAura(power->RequiredAura))
                 continue;
 
             // Spell drain all exist power on cast (Only paladin lay of Hands)
             if (AttributesEx & SPELL_ATTR1_DRAIN_ALL_POWER)
             {
                 // If power type - health drain all
                 if (power->PowerType == POWER_HEALTH)
                 {
                     healthCost = caster->GetHealth();
                     continue;
                 }
                 // Else drain all power
                 if (power->PowerType < MAX_POWERS)
                 {
                     CostData cost;
                     cost.Power = Powers(power->PowerType);
                     cost.Amount = caster->GetPower(cost.Power);
                     costs.push_back(cost);
                     continue;
                 }
 
                 TC_LOG_ERROR("spells", "SpellInfo::CalcPowerCost: Unknown power type '%d' in spell %d", power->PowerType, Id);
                 continue;
             }
 
             // Base powerCost
             int32 powerCost = power->ManaCost;
             // PCT cost from total amount
             if (power->ManaCostPercentage)
             {
                 switch (power->PowerType)
                 {
                     // health as power used
                     case POWER_HEALTH:
                         powerCost += int32(CalculatePct(caster->GetMaxHealth(), power->ManaCostPercentage));
                         break;
                     case POWER_MANA:
                         powerCost += int32(CalculatePct(caster->GetCreateMana(), power->ManaCostPercentage));
                         break;
                     case POWER_RAGE:
                     case POWER_FOCUS:
                     case POWER_ENERGY:
                         powerCost += int32(CalculatePct(caster->GetMaxPower(Powers(power->PowerType)), power->ManaCostPercentage));
                         break;
                     case POWER_RUNES:
                     case POWER_RUNIC_POWER:
                         TC_LOG_DEBUG("spells", "CalculateManaCost: Not implemented yet!");
                         break;
                     default:
                         TC_LOG_ERROR("spells", "CalculateManaCost: Unknown power type '%d' in spell %d", power->PowerType, Id);
                         continue;
                 }
             }
 
             if (power->HealthCostPercentage)
                 healthCost += int32(CalculatePct(caster->GetMaxHealth(), power->HealthCostPercentage));
 
             // Flat mod from caster auras by spell school and power type
             Unit::AuraEffectList const& auras = caster->GetAuraEffectsByType(SPELL_AURA_MOD_POWER_COST_SCHOOL);
             for (Unit::AuraEffectList::const_iterator i = auras.begin(); i != auras.end(); ++i)
             {
                 if (!((*i)->GetMiscValue() & schoolMask))
                     continue;
 
                 if (!((*i)->GetMiscValueB() & (1 << power->PowerType)))
                     continue;
 
                 powerCost += (*i)->GetAmount();
             }
 
             // Shiv - costs 20 + weaponSpeed*10 energy (apply only to non-triggered spell with energy cost)
             if (AttributesEx4 & SPELL_ATTR4_SPELL_VS_EXTEND_COST)
             {
                 uint32 speed = 0;
                 if (SpellShapeshiftFormEntry const* ss = sSpellShapeshiftFormStore.LookupEntry(caster->GetShapeshiftForm()))
                     speed = ss->CombatRoundTime;
                 else
                 {
                     WeaponAttackType slot = BASE_ATTACK;
                     if (AttributesEx3 & SPELL_ATTR3_REQ_OFFHAND)
                         slot = OFF_ATTACK;
 
                     speed = caster->GetAttackTime(slot);
                 }
 
                 powerCost += speed / 100;
             }
 
             // Apply cost mod by spell
             if (Player* modOwner = caster->GetSpellModOwner())
             {
                 if (power->PowerIndex == 0)
                     modOwner->ApplySpellMod(Id, SPELLMOD_COST, powerCost);
                 else if (power->PowerIndex == 1)
                     modOwner->ApplySpellMod(Id, SPELLMOD_SPELL_COST2, powerCost);
             }
 
             if (!caster->IsControlledByPlayer() && G3D::fuzzyEq(power->ManaCostPercentage, 0.0f) && SpellLevel)
             {
                 if (Attributes & SPELL_ATTR0_LEVEL_DAMAGE_CALCULATION)
                 {
                     GtNPCManaCostScalerEntry const* spellScaler = sGtNPCManaCostScalerStore.EvaluateTable(SpellLevel - 1, 0);
                     GtNPCManaCostScalerEntry const* casterScaler = sGtNPCManaCostScalerStore.EvaluateTable(caster->getLevel() - 1, 0);
                     if (spellScaler && casterScaler)
                         powerCost *= casterScaler->ratio / spellScaler->ratio;
                 }
             }
 
             // PCT mod from user auras by spell school and power type
             Unit::AuraEffectList const& aurasPct = caster->GetAuraEffectsByType(SPELL_AURA_MOD_POWER_COST_SCHOOL_PCT);
             for (Unit::AuraEffectList::const_iterator i = aurasPct.begin(); i != aurasPct.end(); ++i)
             {
                 if (!((*i)->GetMiscValue() & schoolMask))
                     continue;
 
                 if (!((*i)->GetMiscValueB() & (1 << power->PowerType)))
                     continue;
 
                 powerCost += CalculatePct(powerCost, (*i)->GetAmount());
             }
 
             if (power->PowerType == POWER_HEALTH)
             {
                 healthCost += powerCost;
                 continue;
             }
 
             bool found = false;
             for (CostData& cost : costs)
             {
                 if (cost.Power == Powers(power->PowerType))
                 {
                     cost.Amount += powerCost;
                     found = true;
                 }
             }
 
             if (!found)
             {
                 CostData cost;
                 cost.Power = Powers(power->PowerType);
                 cost.Amount = powerCost;
                 costs.push_back(cost);
             }
         }
 
         if (healthCost > 0)
         {
             CostData cost;
             cost.Power = POWER_HEALTH;
             cost.Amount = healthCost;
             costs.push_back(cost);
         }
     };
 
     if (!_hasPowerDifficultyData) // optimization - use static data for 99.5% cases (4753 of 4772 in build 6.1.0.19702)
         collector(PowerCosts);
     else
         collector(sDB2Manager.GetSpellPowers(Id, caster->GetMap()->GetDifficultyID()));
 
     // POWER_RUNES is handled by SpellRuneCost.db2, and cost.Amount is always 0 (see Spell::TakeRunePower)
     costs.erase(std::remove_if(costs.begin(), costs.end(), [](CostData const& cost) { return cost.Power != POWER_RUNES && cost.Amount <= 0; }), costs.end());
     return costs;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SpellInfo::CanBeUsedInCombat ( ) const

 {
     return !(Attributes & SPELL_ATTR0_CANT_USED_IN_COMBAT);
 }

Here is the caller graph for this function:

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

 {
     // These spells (like Mass Dispel) can dispell all auras, except death persistent ones (like Dungeon and Battleground Deserter)
     if (Attributes & SPELL_ATTR0_UNAFFECTED_BY_INVULNERABILITY && !aura->IsDeathPersistent())
         return true;
 
     // These auras (Cyclone for example) are not dispelable
     if (aura->HasAttribute(SPELL_ATTR1_UNAFFECTED_BY_SCHOOL_IMMUNE))
         return false;
 
     // Divine Shield etc can dispel auras if they don't ignore school immunity
     if (HasAttribute(SPELL_ATTR1_DISPEL_AURAS_ON_IMMUNITY) && !aura->IsDeathPersistent())
         return true;
 
     // These auras (like Divine Shield) can't be dispelled
     if (aura->HasAttribute(SPELL_ATTR0_UNAFFECTED_BY_INVULNERABILITY))
         return false;
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // these spells pierce all avalible spells (Resurrection Sickness for example)
     if (Attributes & SPELL_ATTR0_UNAFFECTED_BY_INVULNERABILITY)
         return true;
 
     // these spells (Cyclone for example) can pierce all...         // ...but not these (Divine shield, Ice block, Cyclone and Banish for example)
     if ((AttributesEx & SPELL_ATTR1_UNAFFECTED_BY_SCHOOL_IMMUNE) && !(aura && (aura->Mechanic == MECHANIC_IMMUNE_SHIELD || aura->Mechanic == MECHANIC_INVULNERABILITY || aura->Mechanic == MECHANIC_BANISH)))
         return true;
 
     return false;
 }

Here is the caller graph for this function:

SpellCastResult SpellInfo::CheckExplicitTarget	(	Unit const *	caster,
		WorldObject const *	target,
		Item const *	itemTarget = `NULL`
	)		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))
         {
             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 && caster->IsInPartyWith(unitTarget))
                 || (neededTargets & TARGET_FLAG_UNIT_RAID && caster->IsInRaidWith(unitTarget)))
                     if (caster->_IsValidAssistTarget(unitTarget, this))
                         return SPELL_CAST_OK;
             if (neededTargets & TARGET_FLAG_UNIT_MINIPET)
                 if (unitTarget->GetGUID() == caster->GetCritterGUID())
                     return SPELL_CAST_OK;
             if (neededTargets & TARGET_FLAG_UNIT_PASSENGER)
                 if (unitTarget->IsOnVehicle(caster))
                     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:

SpellCastResult SpellInfo::CheckLocation	(	uint32	map_id,
		uint32	zone_id,
		uint32	area_id,
		Player const *	player = `NULL`
	)		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 (AttributesEx4 & SPELL_ATTR4_CAST_ONLY_IN_OUTLAND)
     {
         uint32 v_map = GetVirtualMapForMapAndZone(map_id, zone_id);
         MapEntry const* mapEntry = sMapStore.LookupEntry(v_map);
         if (!mapEntry || mapEntry->ExpansionID < 1 || !mapEntry->IsContinent())
             return SPELL_FAILED_INCORRECT_AREA;
     }
 
     // raid instance limitation
     if (AttributesEx6 & SPELL_ATTR6_NOT_IN_RAID_INSTANCE)
     {
         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 24171:                                         // Resurrection Impact Visual
         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 == 4197 || (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 : GetEffectsForDifficulty(player->GetMap()->GetDifficultyID()))
         {
             if (!effect || !effect->IsAura())
                 continue;
 
             switch (effect->ApplyAuraName)
             {
                 case SPELL_AURA_FLY:
                 {
                     SkillLineAbilityMapBounds bounds = sSpellMgr->GetSkillLineAbilityMapBounds(Id);
                     for (SkillLineAbilityMap::const_iterator skillIter = bounds.first; skillIter != bounds.second; ++skillIter)
                     {
                         if (skillIter->second->SkillLine == SKILL_MOUNTS)
                             if (!player->CanFlyInZone(map_id, zone_id))
                                 return SPELL_FAILED_INCORRECT_AREA;
                     }
                     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;
                 }
             }
         }
     }
 
     return SPELL_CAST_OK;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SpellCastResult SpellInfo::CheckShapeshift ( uint32 form ) const

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

 {
     // talents that learn spells can have stance requirements that need ignore
     // (this requirement only for client-side stance show in talent description)
     /* TODO: 6.x fix this in proper way (probably spell flags/attributes?)
     if (GetTalentSpellCost(Id) > 0 &&
         (Effects[0].Effect == SPELL_EFFECT_LEARN_SPELL || Effects[1].Effect == SPELL_EFFECT_LEARN_SPELL || Effects[2].Effect == SPELL_EFFECT_LEARN_SPELL))
         return SPELL_CAST_OK;*/
 
     //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 = NULL;
     if (form > 0)
     {
         shapeInfo = sSpellShapeshiftFormStore.LookupEntry(form);
         if (!shapeInfo)
         {
             TC_LOG_ERROR("spells", "GetErrorAtShapeshiftedCast: unknown shapeshift %u", form);
             return SPELL_CAST_OK;
         }
         actAsShifted = !(shapeInfo->Flags & 1);            // shapeshift acts as normal form for spells
     }
 
     if (actAsShifted)
     {
         if (Attributes & SPELL_ATTR0_NOT_SHAPESHIFT) // not while shapeshifted
             return SPELL_FAILED_NOT_SHAPESHIFT;
         else if (Stances != 0)                   // needs other shapeshift
             return SPELL_FAILED_ONLY_SHAPESHIFT;
     }
     else
     {
         // needs shapeshift
         if (!(AttributesEx2 & SPELL_ATTR2_NOT_NEED_SHAPESHIFT) && Stances != 0)
             return SPELL_FAILED_ONLY_SHAPESHIFT;
     }
 
     // Check if stance disables cast of not-stance spells
     // Example: cannot cast any other spells in zombie or ghoul form
     if (shapeInfo && shapeInfo->Flags & 0x400)
     {
         if (!(stanceMask & Stances))
             return SPELL_FAILED_ONLY_SHAPESHIFT;
     }
 
     return SPELL_CAST_OK;
 }

Here is the caller graph for this function:

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

 {
     if (AttributesEx & SPELL_ATTR1_CANT_TARGET_SELF && caster == target)
         return SPELL_FAILED_BAD_TARGETS;
 
     // check visibility - ignore stealth for implicit (area) targets
     if (!(AttributesEx6 & SPELL_ATTR6_CAN_TARGET_INVISIBLE) && !caster->CanSeeOrDetect(target, implicit))
         return SPELL_FAILED_BAD_TARGETS;
 
     Unit const* unitTarget = target->ToUnit();
 
     // creature/player specific target checks
     if (unitTarget)
     {
         if (AttributesEx & SPELL_ATTR1_CANT_TARGET_IN_COMBAT)
         {
             if (unitTarget->IsInCombat())
                 return SPELL_FAILED_TARGET_AFFECTING_COMBAT;
             // player with active pet counts as a player in combat
             else if (Player const* player = unitTarget->ToPlayer())
                 if (Pet* pet = player->GetPet())
                     if (pet->GetVictim() && !pet->HasUnitState(UNIT_STATE_CONTROLLED))
                         return SPELL_FAILED_TARGET_AFFECTING_COMBAT;
         }
 
         // only spells with SPELL_ATTR3_ONLY_TARGET_GHOSTS can target ghosts
         if (((AttributesEx3 & SPELL_ATTR3_ONLY_TARGET_GHOSTS) != 0) != unitTarget->HasAuraType(SPELL_AURA_GHOST))
         {
             if (AttributesEx3 & SPELL_ATTR3_ONLY_TARGET_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 (AttributesEx2 & SPELL_ATTR2_CANT_TARGET_TAPPED)
                     if (Creature const* targetCreature = unitTarget->ToCreature())
                         if (targetCreature->hasLootRecipient() && !targetCreature->isTappedBy(caster->ToPlayer()))
                             return SPELL_FAILED_CANT_CAST_ON_TAPPED;
 
                 if (AttributesCu & SPELL_ATTR0_CU_PICKPOCKET)
                 {
                      if (unitTarget->GetTypeId() == TYPEID_PLAYER)
                          return SPELL_FAILED_BAD_TARGETS;
                      else if ((unitTarget->GetCreatureTypeMask() & CREATURE_TYPEMASK_HUMANOID_OR_UNDEAD) == 0)
                          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 (AttributesEx3 & SPELL_ATTR3_ONLY_TARGET_PLAYERS && !unitTarget->ToPlayer())
        return SPELL_FAILED_TARGET_NOT_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 && AttributesEx6 & SPELL_ATTR6_CANT_TARGET_CROWD_CONTROLLED && !unitTarget->CanFreeMove())
        return SPELL_FAILED_BAD_TARGETS;
 
     // checked in Unit::IsValidAttack/AssistTarget, shouldn't be checked for ENTRY targets
     //if (!(AttributesEx6 & SPELL_ATTR6_CAN_TARGET_UNTARGETABLE) && target->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE))
     //    return SPELL_FAILED_BAD_TARGETS;
 
     //if (!(AttributesEx6 & SPELL_ATTR6_CAN_TARGET_POSSESSED_FRIENDS)
 
     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->IsControlledByPlayer() || !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) && !(AttributesCu & 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 (!caster->IsVehicle() && !(caster->GetCharmerOrOwner() == target))
     {
         if (TargetAuraState && !unitTarget->HasAuraState(AuraStateType(TargetAuraState), this, caster))
             return SPELL_FAILED_TARGET_AURASTATE;
 
         if (ExcludeTargetAuraState && unitTarget->HasAuraState(AuraStateType(ExcludeTargetAuraState), this, caster))
             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))
     if (HasEffect(caster->GetMap()->GetDifficultyID(), SPELL_EFFECT_SELF_RESURRECT) || HasEffect(caster->GetMap()->GetDifficultyID(), SPELL_EFFECT_RESURRECT) || HasEffect(caster->GetMap()->GetDifficultyID(), SPELL_EFFECT_RESURRECT_NEW))
             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:

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:

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 : GetEffectsForDifficulty(caster->GetMap()->GetDifficultyID()))
         {
             if (effect && effect->ApplyAuraName == 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(caster->GetMap()->GetDifficultyID(), 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 (!(AttributesEx6 & SPELL_ATTR6_CASTABLE_WHILE_ON_VEHICLE) && !(Attributes & SPELL_ATTR0_CASTABLE_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 : GetEffectsForDifficulty(caster->GetMap()->GetDifficultyID()))
             {
                 if (!effect || effect->Effect != SPELL_EFFECT_SUMMON)
                     continue;
 
                 SummonPropertiesEntry const* props = sSummonPropertiesStore.LookupEntry(effect->MiscValueB);
                 if (props && props->Category != 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:

uint32 SpellInfo::GetAllEffectsMechanicMask ( ) const

 {
     uint32 mask = 0;
     if (Mechanic)
         mask |= 1 << Mechanic;
     for (SpellEffectInfoMap::const_iterator itr = _effects.begin(); itr != _effects.end(); ++itr)
     {
         for (SpellEffectInfo const* effect : itr->second)
         {
             if (effect && effect->IsEffect() && effect->Mechanic)
                 mask |= 1 << effect->Mechanic;
         }
     }
     return mask;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // ignore passive spells
     if (IsPassive())
         return this;
 
     bool needRankSelection = false;
     for (SpellEffectInfo const* effect : GetEffectsForDifficulty(DIFFICULTY_NONE))
     {
         if (effect && IsPositiveEffect(effect->Effect) &&
             (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 != NULL; nextSpellInfo = nextSpellInfo->GetPrevRankSpell())
     {
         // if found appropriate level
         if (uint32(level + 10) >= nextSpellInfo->SpellLevel)
             return nextSpellInfo;
 
         // one rank less then
     }
 
     // not found
     return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

AuraStateType SpellInfo::GetAuraState ( uint32 difficulty ) const

 {
     // Seals
     if (GetSpellSpecific() == SPELL_SPECIFIC_SEAL)
         return AURA_STATE_JUDGEMENT;
 
     // Conflagrate aura state on Immolate and Shadowflame
     if (SpellFamilyName == SPELLFAMILY_WARLOCK &&
         // Immolate
         ((SpellFamilyFlags[0] & 4) ||
         // Shadowflame
         (SpellFamilyFlags[2] & 2)))
         return AURA_STATE_CONFLAGRATE;
 
     // Faerie Fire (druid versions)
     if (SpellFamilyName == SPELLFAMILY_DRUID && SpellFamilyFlags[0] & 0x400)
         return AURA_STATE_FAERIE_FIRE;
 
     // Sting (hunter's pet ability)
     if (GetCategory() == 1133)
         return AURA_STATE_FAERIE_FIRE;
 
     // Victorious
     if (SpellFamilyName == SPELLFAMILY_WARRIOR &&  SpellFamilyFlags[1] & 0x00040000)
         return AURA_STATE_WARRIOR_VICTORY_RUSH;
 
     // Swiftmend state on Regrowth & Rejuvenation
     if (SpellFamilyName == SPELLFAMILY_DRUID && SpellFamilyFlags[0] & 0x50)
         return AURA_STATE_SWIFTMEND;
 
     // Deadly poison aura state
     if (SpellFamilyName == SPELLFAMILY_ROGUE && SpellFamilyFlags[0] & 0x10000)
         return AURA_STATE_DEADLY_POISON;
 
     // Enrage aura state
     if (Dispel == DISPEL_ENRAGE)
         return AURA_STATE_ENRAGE;
 
     // Bleeding aura state
     if (GetAllEffectsMechanicMask() & 1<<MECHANIC_BLEED)
         return AURA_STATE_BLEEDING;
 
     if (GetSchoolMask() & SPELL_SCHOOL_MASK_FROST)
         for (SpellEffectInfo const* effect : GetEffectsForDifficulty(difficulty))
             if (effect && effect->IsAura() && (effect->ApplyAuraName == SPELL_AURA_MOD_STUN
                 || effect->ApplyAuraName == SPELL_AURA_MOD_ROOT))
                     return AURA_STATE_FROZEN;
 
     switch (Id)
     {
         case 71465: // Divine Surge
         case 50241: // Evasive Charges
             return AURA_STATE_UNKNOWN22;
         default:
             break;
     }
 
     return AURA_STATE_NONE;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 SpellInfo::GetCategory ( ) const

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

Here is the caller graph for this function:

uint32 SpellInfo::GetDispelMask ( ) const

 {
     return GetDispelMask(DispelType(Dispel));
 }

Here is the caller graph for this function:

uint32 SpellInfo::GetDispelMask ( DispelType type )

static

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

int32 SpellInfo::GetDuration ( ) const

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

Here is the call graph for this function:

Here is the caller graph for this function:

SpellEffectInfo const * SpellInfo::GetEffect	(	uint32	difficulty,
		uint32	index
	)		const

 {
     DifficultyEntry const* difficultyEntry = sDifficultyStore.LookupEntry(difficulty);
     while (difficultyEntry)
     {
         SpellEffectInfoMap::const_iterator itr = _effects.find(difficulty);
         if (itr != _effects.end())
             if (itr->second.size() > index && itr->second[index])
                 return itr->second[index];
 
         difficultyEntry = sDifficultyStore.LookupEntry(difficultyEntry->FallbackDifficultyID);
     }
 
     SpellEffectInfoMap::const_iterator itr = _effects.find(DIFFICULTY_NONE);
     if (itr != _effects.end())
         if (itr->second.size() > index)
             return itr->second[index];
 
     return nullptr;
 }

SpellEffectInfo const* SpellInfo::GetEffect ( uint32 index ) const

inline

587 { return GetEffect(DIFFICULTY_NONE, index); }

DIFFICULTY_NONE

Definition: DBCEnums.h:404

SpellInfo::GetEffect

SpellEffectInfo const * GetEffect(uint32 difficulty, uint32 index) const

Definition: SpellInfo.cpp:3348

Here is the call graph for this function:

Here is the caller graph for this function:

SpellEffectInfo const* SpellInfo::GetEffect	(	WorldObject const *	obj,
		uint32	index
	)		const

inline

588 { return GetEffect(obj->GetMap()->GetDifficultyID(), index); }

SpellInfo::GetEffect

SpellEffectInfo const * GetEffect(uint32 difficulty, uint32 index) const

Definition: SpellInfo.cpp:3348

Here is the call graph for this function:

Here is the caller graph for this function:

Mechanics SpellInfo::GetEffectMechanic	(	uint32	effIndex,
		uint32	difficulty
	)		const

 {
     SpellEffectInfo const* effect = GetEffect(difficulty, effIndex);
     if (effect && effect->IsEffect() && effect->Mechanic)
         return Mechanics(effect->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:

uint32 SpellInfo::GetEffectMechanicMask ( uint32 effIndex ) const

 {
     uint32 mask = 0;
     if (Mechanic)
         mask |= 1 << Mechanic;
     for (SpellEffectInfoMap::const_iterator itr = _effects.begin(); itr != _effects.end(); ++itr)
     {
         for (SpellEffectInfo const* effect : itr->second)
         {
             if (effect && effect->EffectIndex == effIndex && effect->IsEffect() && effect->Mechanic)
                 mask |= 1 << effect->Mechanic;
         }
     }
     return mask;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SpellEffectInfoVector SpellInfo::GetEffectsForDifficulty ( uint32 difficulty ) const

 {
     SpellEffectInfoVector effList;
 
     // DIFFICULTY_NONE effects are the default effects, always active if current difficulty's effects don't overwrite
     SpellEffectInfoMap::const_iterator itr = _effects.find(DIFFICULTY_NONE);
     if (itr != _effects.end())
         effList = itr->second;
 
     // downscale difficulty if original was not found
     // DIFFICULTY_NONE is already in our list
     DifficultyEntry const* difficultyEntry = sDifficultyStore.LookupEntry(difficulty);
     while (difficultyEntry)
     {
         SpellEffectInfoMap::const_iterator effectItr = _effects.find(difficulty);
         if (effectItr != _effects.end())
         {
             for (SpellEffectInfo const* effect : effectItr->second)
             {
                 // overwrite any existing effect from DIFFICULTY_NONE
                 if (effect)
                 {
                     if (effect->EffectIndex >= effList.size())
                         effList.resize(effect->EffectIndex + 1);
 
                     if (!effList[effect->EffectIndex])
                         effList[effect->EffectIndex] = effect;
                 }
             }
         }
 
         difficultyEntry = sDifficultyStore.LookupEntry(difficultyEntry->FallbackDifficultyID);
     }
 
     return effList;
 }

uint32 SpellInfo::GetExplicitTargetMask ( ) const

 {
     return ExplicitTargetMask;
 }

Here is the caller graph for this function:

SpellInfo const * SpellInfo::GetFirstRankSpell ( ) const

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

Here is the caller graph for this function:

SpellInfo const * SpellInfo::GetLastRankSpell ( ) const

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

int32 SpellInfo::GetMaxDuration ( ) const

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!RangeEntry)
         return 0.0f;
     float range;
     if (positive)
         range = RangeEntry->MaxRangeFriend;
     else
         range = RangeEntry->MaxRangeHostile;
     if (caster)
         if (Player* modOwner = caster->GetSpellModOwner())
             modOwner->ApplySpellMod(Id, SPELLMOD_RANGE, range, spell);
     return range;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 SpellInfo::GetMaxTicks ( uint32 difficulty ) const

 {
     int32 DotDuration = GetDuration();
     if (DotDuration == 0)
         return 1;
 
     // 200% limit
     if (DotDuration > 30000)
         DotDuration = 30000;
 
     for (SpellEffectInfo const* effect : GetEffectsForDifficulty(difficulty))
     {
         if (effect && effect->Effect == SPELL_EFFECT_APPLY_AURA)
             switch (effect->ApplyAuraName)
             {
                 case SPELL_AURA_PERIODIC_DAMAGE:
                 case SPELL_AURA_PERIODIC_HEAL:
                 case SPELL_AURA_PERIODIC_LEECH:
                     if (effect->ApplyAuraPeriod != 0)
                         return DotDuration / effect->ApplyAuraPeriod;
                     break;
             }
     }
 
     return 6;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!RangeEntry)
         return 0.0f;
     if (positive)
         return RangeEntry->MinRangeFriend;
     return RangeEntry->MinRangeHostile;
 }

Here is the caller graph for this function:

SpellInfo const * SpellInfo::GetNextRankSpell ( ) const

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

Here is the caller graph for this function:

SpellInfo const * SpellInfo::GetPrevRankSpell ( ) const

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

uint8 SpellInfo::GetRank ( ) const

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

Here is the caller graph for this function:

uint32 SpellInfo::GetRecoveryTime ( ) const

 {
     return RecoveryTime > CategoryRecoveryTime ? RecoveryTime : CategoryRecoveryTime;
 }

Here is the caller graph for this function:

SpellSchoolMask SpellInfo::GetSchoolMask ( ) const

 {
     return SpellSchoolMask(SchoolMask);
 }

Here is the caller graph for this function:

SpellAuraOptionsEntry const * SpellInfo::GetSpellAuraOptions ( ) const

 {
     return SpellAuraOptionsId ? sSpellAuraOptionsStore.LookupEntry(SpellAuraOptionsId) : NULL;
 }

Here is the caller graph for this function:

SpellAuraRestrictionsEntry const * SpellInfo::GetSpellAuraRestrictions ( ) const

 {
     return SpellAuraRestrictionsId ? sSpellAuraRestrictionsStore.LookupEntry(SpellAuraRestrictionsId) : NULL;
 }

Here is the caller graph for this function:

SpellCastingRequirementsEntry const * SpellInfo::GetSpellCastingRequirements ( ) const

 {
     return SpellCastingRequirementsId ? sSpellCastingRequirementsStore.LookupEntry(SpellCastingRequirementsId) : NULL;
 }

Here is the caller graph for this function:

SpellCategoriesEntry const * SpellInfo::GetSpellCategories ( ) const

 {
     return SpellCategoriesId ? sSpellCategoriesStore.LookupEntry(SpellCategoriesId) : NULL;
 }

Here is the caller graph for this function:

SpellClassOptionsEntry const * SpellInfo::GetSpellClassOptions ( ) const

 {
     return SpellClassOptionsId ? sSpellClassOptionsStore.LookupEntry(SpellClassOptionsId) : NULL;
 }

Here is the caller graph for this function:

SpellCooldownsEntry const * SpellInfo::GetSpellCooldowns ( ) const

 {
     return SpellCooldownsId ? sSpellCooldownsStore.LookupEntry(SpellCooldownsId) : NULL;
 }

Here is the caller graph for this function:

SpellEquippedItemsEntry const * SpellInfo::GetSpellEquippedItems ( ) const

 {
     return SpellEquippedItemsId ? sSpellEquippedItemsStore.LookupEntry(SpellEquippedItemsId) : NULL;
 }

Here is the caller graph for this function:

SpellInterruptsEntry const * SpellInfo::GetSpellInterrupts ( ) const

 {
     return SpellInterruptsId ? sSpellInterruptsStore.LookupEntry(SpellInterruptsId) : NULL;
 }

Here is the caller graph for this function:

SpellLevelsEntry const * SpellInfo::GetSpellLevels ( ) const

 {
     return SpellLevelsId ? sSpellLevelsStore.LookupEntry(SpellLevelsId) : NULL;
 }

Here is the caller graph for this function:

uint32 SpellInfo::GetSpellMechanicMaskByEffectMask ( uint32 effectMask ) const

 {
     uint32 mask = 0;
     if (Mechanic)
         mask |= 1 << Mechanic;
     for (SpellEffectInfoMap::const_iterator itr = _effects.begin(); itr != _effects.end(); ++itr)
     {
         for (SpellEffectInfo const* effect : itr->second)
         {
             if (effect && (effectMask & (1 << effect->EffectIndex)) && effect->Mechanic)
                 mask |= 1 << effect->Mechanic;
         }
     }
     return mask;
 }

Here is the caller graph for this function:

SpellMiscEntry const * SpellInfo::GetSpellMisc ( ) const

 {
     return SpellMiscId ? sSpellMiscStore.LookupEntry(SpellMiscId) : NULL;
 }

Here is the caller graph for this function:

SpellReagentsEntry const * SpellInfo::GetSpellReagents ( ) const

 {
     return SpellReagentsId ? sSpellReagentsStore.LookupEntry(SpellReagentsId) : NULL;
 }

Here is the caller graph for this function:

SpellScalingEntry const * SpellInfo::GetSpellScaling ( ) const

 {
     return SpellScalingId ? sSpellScalingStore.LookupEntry(SpellScalingId) : NULL;
 }

Here is the caller graph for this function:

SpellShapeshiftEntry const * SpellInfo::GetSpellShapeshift ( ) const

 {
     return SpellShapeshiftId ? sSpellShapeshiftStore.LookupEntry(SpellShapeshiftId) : NULL;
 }

Here is the caller graph for this function:

SpellSpecificType SpellInfo::GetSpellSpecific ( ) const

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

 {
     switch (SpellFamilyName)
     {
         case SPELLFAMILY_GENERIC:
         {
             // Food / Drinks (mostly)
             if (AuraInterruptFlags & AURA_INTERRUPT_FLAG_NOT_SEATED)
             {
                 bool food = false;
                 bool drink = false;
                 for (SpellEffectInfoMap::const_iterator itr = _effects.begin(); itr != _effects.end(); ++itr)
                 {
                     for (SpellEffectInfo const* effect : itr->second)
                     {
                         if (!effect || !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;
                     case 12880: // Enrage (Enrage)
                     case 57518: // Enrage (Wrecking Crew)
                         return SPELL_SPECIFIC_WARRIOR_ENRAGE;
                 }
             }
             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;
             SpellEffectInfo const* effect = GetEffect(DIFFICULTY_NONE, EFFECT_0);
             if (effect && (SpellFamilyFlags[0] & 0x1000000) && effect->ApplyAuraName == 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;
 
             // Judgement
             if (Id == 20271)
                 return SPELL_SPECIFIC_JUDGEMENT;
 
             // only paladin auras have this (for palaldin class family)
             if (SpellFamilyFlags[2] & 0x00000020)
                 return SPELL_SPECIFIC_AURA;
 
             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 (SpellEffectInfoMap::const_iterator itr = _effects.begin(); itr != _effects.end(); ++itr)
     {
         for (SpellEffectInfo const* effect : itr->second)
         {
             if (effect && effect->Effect == 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;
                 case SPELL_AURA_TRACK_RESOURCES:
                 case SPELL_AURA_TRACK_STEALTHED:
                     return SPELL_SPECIFIC_TRACKER;
                 }
             }
         }
     }
     return SPELL_SPECIFIC_NORMAL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SpellTargetRestrictionsEntry const * SpellInfo::GetSpellTargetRestrictions ( ) const

 {
     return SpellTargetRestrictionsId ? sSpellTargetRestrictionsStore.LookupEntry(SpellTargetRestrictionsId) : NULL;
 }

Here is the caller graph for this function:

SpellTotemsEntry const * SpellInfo::GetSpellTotems ( ) const

 {
     return SpellTotemsId ? sSpellTotemsStore.LookupEntry(SpellTotemsId) : NULL;
 }

Here is the caller graph for this function:

uint32 SpellInfo::GetSpellVisual	(	Difficulty	difficulty,
		Player *	forPlayer = `nullptr`
	)		const

 {
     if (SpellXSpellVisualEntry const* visual = sSpellXSpellVisualStore.LookupEntry(GetSpellXSpellVisualId(difficulty)))
     {
         //if (visual->SpellVisualID[1] && forPlayer->GetViolenceLevel() operator 2)
         //    return visual->SpellVisualID[1];
 
         return visual->SpellVisualID[0];
     }
 
     return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 SpellInfo::GetSpellXSpellVisualId ( Difficulty difficulty ) const

 {
     DifficultyEntry const* difficultyEntry = sDifficultyStore.LookupEntry(difficulty);
     while (difficultyEntry)
     {
         auto itr = _visuals.find(difficulty);
         if (itr != _visuals.end())
             for (SpellXSpellVisualEntry const* visual : itr->second)
                 if (!visual->PlayerConditionID)
                     return visual->ID;
 
         difficultyEntry = sDifficultyStore.LookupEntry(difficultyEntry->FallbackDifficultyID);
     }
 
     auto itr = _visuals.find(DIFFICULTY_NONE);
     if (itr != _visuals.end())
         for (SpellXSpellVisualEntry const* visual : itr->second)
             if (!visual->PlayerConditionID)
                 return visual->ID;
 
     return 0;
 }

Here is the caller graph for this function:

bool SpellInfo::HasAreaAuraEffect ( uint32 difficulty ) const

 {
     SpellEffectInfoVector effects = GetEffectsForDifficulty(difficulty);
     for (SpellEffectInfo const* effect : effects)
     {
         if (effect && effect->IsAreaAuraEffect())
             return true;
     }
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SpellInfo::HasAreaAuraEffect ( ) const

 {
     for (SpellEffectInfoMap::const_iterator itr = _effects.begin(); itr != _effects.end(); ++itr)
     {
         for (SpellEffectInfo const* effect : itr->second)
         {
             if (effect && effect->IsAreaAuraEffect())
                 return true;
         }
     }
     return false;
 }

Here is the call graph for this function:

bool SpellInfo::HasAttribute ( SpellAttr0 attribute ) const

inline

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

SpellInfo::Attributes

uint32 Attributes

Definition: SpellInfo.h:333

bool SpellInfo::HasAttribute ( SpellAttr1 attribute ) const

inline

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

SpellInfo::AttributesEx

uint32 AttributesEx

Definition: SpellInfo.h:334

bool SpellInfo::HasAttribute ( SpellAttr2 attribute ) const

inline

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

SpellInfo::AttributesEx2

uint32 AttributesEx2

Definition: SpellInfo.h:335

bool SpellInfo::HasAttribute ( SpellAttr3 attribute ) const

inline

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

SpellInfo::AttributesEx3

uint32 AttributesEx3

Definition: SpellInfo.h:336

bool SpellInfo::HasAttribute ( SpellAttr4 attribute ) const

inline

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

SpellInfo::AttributesEx4

uint32 AttributesEx4

Definition: SpellInfo.h:337

bool SpellInfo::HasAttribute ( SpellAttr5 attribute ) const

inline

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

SpellInfo::AttributesEx5

uint32 AttributesEx5

Definition: SpellInfo.h:338

bool SpellInfo::HasAttribute ( SpellAttr6 attribute ) const

inline

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

SpellInfo::AttributesEx6

uint32 AttributesEx6

Definition: SpellInfo.h:339

bool SpellInfo::HasAttribute ( SpellAttr7 attribute ) const

inline

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

SpellInfo::AttributesEx7

uint32 AttributesEx7

Definition: SpellInfo.h:340

bool SpellInfo::HasAttribute ( SpellAttr8 attribute ) const

inline

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

SpellInfo::AttributesEx8

uint32 AttributesEx8

Definition: SpellInfo.h:341

bool SpellInfo::HasAttribute ( SpellAttr9 attribute ) const

inline

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

SpellInfo::AttributesEx9

uint32 AttributesEx9

Definition: SpellInfo.h:342

bool SpellInfo::HasAttribute ( SpellAttr10 attribute ) const

inline

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

SpellInfo::AttributesEx10

uint32 AttributesEx10

Definition: SpellInfo.h:343

bool SpellInfo::HasAttribute ( SpellAttr11 attribute ) const

inline

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

SpellInfo::AttributesEx11

uint32 AttributesEx11

Definition: SpellInfo.h:344

bool SpellInfo::HasAttribute ( SpellAttr12 attribute ) const

inline

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

SpellInfo::AttributesEx12

uint32 AttributesEx12

Definition: SpellInfo.h:345

bool SpellInfo::HasAttribute ( SpellAttr13 attribute ) const

inline

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

SpellInfo::AttributesEx13

uint32 AttributesEx13

Definition: SpellInfo.h:346

bool SpellInfo::HasAttribute ( SpellCustomAttributes customAttribute ) const

inline

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

SpellInfo::AttributesCu

uint32 AttributesCu

Definition: SpellInfo.h:347

bool SpellInfo::HasAura	(	uint32	difficulty,
		AuraType	aura
	)		const

 {
     SpellEffectInfoVector effects = GetEffectsForDifficulty(difficulty);
     for (SpellEffectInfo const* effect : effects)
     {
         if (effect && effect->IsAura(aura))
             return true;
     }
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SpellInfo::HasEffect	(	uint32	difficulty,
		SpellEffectName	effect
	)		const

 {
     SpellEffectInfoVector effects = GetEffectsForDifficulty(difficulty);
     for (SpellEffectInfo const* eff : effects)
     {
         if (eff && eff->IsEffect(effect))
             return true;
     }
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SpellInfo::HasEffect ( SpellEffectName effect ) const

 {
     for (SpellEffectInfoMap::const_iterator itr = _effects.begin(); itr != _effects.end(); ++itr)
     {
         for (SpellEffectInfo const* eff : itr->second)
         {
             if (eff && eff->IsEffect(effect))
                 return true;
         }
     }
     return false;
 }

Here is the call graph for this function:

bool SpellInfo::IsAbilityLearnedWithProfession ( ) const

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

Here is the caller graph for this function:

bool SpellInfo::IsAbilityOfSkillType ( uint32 skillType ) const

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

Here is the caller graph for this function:

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

 {
     if (!IsAffectedBySpellMods())
         return false;
 
     SpellInfo const* affectSpell = sSpellMgr->GetSpellInfo(mod->spellId);
     // False if affect_spell == NULL or spellFamily not equal
     if (!affectSpell || affectSpell->SpellFamilyName != SpellFamilyName)
         return false;
 
     // true
     if (mod->mask & SpellFamilyFlags)
         return true;
 
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SpellInfo::IsAffectedBySpellMods ( ) const

 {
     return !(AttributesEx3 & SPELL_ATTR3_NO_DONE_BONUS);
 }

Here is the caller graph for this function:

bool SpellInfo::IsAffectingArea ( uint32 difficulty ) const

 {
     SpellEffectInfoVector effects = GetEffectsForDifficulty(difficulty);
     for (SpellEffectInfo const* effect : effects)
     {
         if (effect && 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:

bool SpellInfo::IsAllowingDeadTarget ( ) const

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

Here is the caller graph for this function:

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_JUDGEMENT:
         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:

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:

bool SpellInfo::IsAutocastable ( ) const

 {
     if (Attributes & SPELL_ATTR0_PASSIVE)
         return false;
     if (AttributesEx & SPELL_ATTR1_UNAUTOCASTABLE_BY_PET)
         return false;
     return true;
 }

Here is the caller graph for this function:

bool SpellInfo::IsAutoRepeatRangedSpell ( ) const

 {
     return (AttributesEx2 & SPELL_ATTR2_AUTOREPEAT_FLAG) != 0;
 }

Here is the caller graph for this function:

bool SpellInfo::IsBreakingStealth ( ) const

 {
     return !(AttributesEx & SPELL_ATTR1_NOT_BREAK_STEALTH);
 }

Here is the caller graph for this function:

bool SpellInfo::IsChanneled ( ) const

 {
     return (AttributesEx & (SPELL_ATTR1_CHANNELED_1 | SPELL_ATTR1_CHANNELED_2)) != 0;
 }

Here is the caller graph for this function:

bool SpellInfo::IsCooldownStartedOnEvent ( ) const

 {
     return Attributes & SPELL_ATTR0_DISABLED_WHILE_ACTIVE || (CategoryEntry && CategoryEntry->Flags & SPELL_CATEGORY_FLAG_COOLDOWN_STARTS_ON_EVENT);
 }

Here is the caller graph for this function:

bool SpellInfo::IsDeathPersistent ( ) const

 {
     return (AttributesEx3 & SPELL_ATTR3_DEATH_PERSISTENT) != 0;
 }

Here is the caller graph for this function:

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:

bool SpellInfo::IsExplicitDiscovery ( ) const

 {
     SpellEffectInfo const* effect0 = GetEffect(DIFFICULTY_NONE, EFFECT_0);
     SpellEffectInfo const* effect1 = GetEffect(DIFFICULTY_NONE, EFFECT_1);
 
     return ((effect0 && (effect0->Effect == SPELL_EFFECT_CREATE_RANDOM_ITEM || effect0->Effect == SPELL_EFFECT_CREATE_ITEM_2))
         && effect1 && effect1->Effect == SPELL_EFFECT_SCRIPT_EFFECT)
         || Id == 64323;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

Here is the caller graph for this function:

bool SpellInfo::IsLootCrafting ( ) const

 {
     SpellEffectInfo const* effect0 = GetEffect(DIFFICULTY_NONE, EFFECT_0);
     return effect0 && (effect0->Effect == SPELL_EFFECT_CREATE_RANDOM_ITEM ||
         // different random cards from Inscription (121==Virtuoso Inking Set category) r without explicit item
         (effect0->Effect == SPELL_EFFECT_CREATE_ITEM_2 &&
         ((TotemCategory[0] != 0 || (Totem[0] != 0 && SpellIconID == 1)) || effect0->ItemType == 0)));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SpellInfo::IsMultiSlotAura ( ) const

 {
     return IsPassive() || Id == 55849 || Id == 40075 || Id == 44413; // Power Spark, Fel Flak Fire, Incanter's Absorption
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SpellInfo::IsPassive ( ) const

 {
     return (Attributes & SPELL_ATTR0_PASSIVE) != 0;
 }

Here is the caller graph for this function:

bool SpellInfo::IsPassiveStackableWithRanks ( uint32 difficulty ) const

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

Here is the call graph for this function:

Here is the caller graph for this function:

bool SpellInfo::IsPositive ( ) const

 {
     return !(AttributesCu & SPELL_ATTR0_CU_NEGATIVE);
 }

Here is the caller graph for this function:

bool SpellInfo::IsPositiveEffect ( uint8 effIndex ) const

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

Here is the caller graph for this function:

bool SpellInfo::IsPrimaryProfession ( uint32 difficulty = DIFFICULTY_NONE ) const

 {
     SpellEffectInfoVector effects = GetEffectsForDifficulty(difficulty);
     for(SpellEffectInfo const* effect : effects)
     {
         if (effect && effect->Effect == SPELL_EFFECT_SKILL)
         {
             uint32 skill = effect->MiscValue;
 
             if (IsPrimaryProfessionSkill(skill))
                 return true;
         }
     }
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SpellInfo::IsPrimaryProfessionFirstRank ( uint32 difficulty = DIFFICULTY_NONE ) const

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

Here is the call graph for this function:

bool SpellInfo::IsProfession ( uint32 difficulty = DIFFICULTY_NONE ) const

 {
     SpellEffectInfoVector effects = GetEffectsForDifficulty(difficulty);
     for (SpellEffectInfo const* effect : effects)
     {
         if (effect && effect->Effect == SPELL_EFFECT_SKILL)
         {
             uint32 skill = effect->MiscValue;
 
             if (IsProfessionSkill(skill))
                 return true;
         }
     }
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SpellInfo::IsProfessionOrRiding ( uint32 difficulty = DIFFICULTY_NONE ) const

 {
     SpellEffectInfoVector effects = GetEffectsForDifficulty(difficulty);
     for (SpellEffectInfo const* effect : effects)
     {
         if ((effect && effect->Effect == SPELL_EFFECT_SKILL))
         {
             uint32 skill = effect->MiscValue;
 
             if (IsProfessionOrRidingSkill(skill))
                 return true;
         }
     }
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SpellInfo::IsQuestTame ( ) const

 {
     SpellEffectInfo const* effect0 = GetEffect(DIFFICULTY_NONE, EFFECT_0);
     SpellEffectInfo const* effect1 = GetEffect(DIFFICULTY_NONE, EFFECT_1);
     return effect0 && effect1 && effect0->Effect == SPELL_EFFECT_THREAT && effect1->Effect == SPELL_EFFECT_APPLY_AURA && effect1->ApplyAuraName == SPELL_AURA_DUMMY;
 }

Here is the call graph for this function:

bool SpellInfo::IsRangedWeaponSpell ( ) const

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

Here is the caller graph for this function:

bool SpellInfo::IsRanked ( ) const

 {
     return ChainEntry != NULL;
 }

Here is the caller graph for this function:

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

bool SpellInfo::IsRequiringDeadTarget ( ) const

 {
     return (AttributesEx3 & SPELL_ATTR3_ONLY_TARGET_GHOSTS) != 0;
 }

Here is the caller graph for this function:

bool SpellInfo::IsSingleTarget ( ) const

 {
     // all other single target spells have if it has AttributesEx5
     if (AttributesEx5 & SPELL_ATTR5_SINGLE_TARGET_SPELL)
         return true;
 
     switch (GetSpellSpecific())
     {
         case SPELL_SPECIFIC_JUDGEMENT:
             return true;
         default:
             break;
     }
 
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SpellInfo::IsStackableOnOneSlotWithDifferentCasters ( ) const

TODO: Re-verify meaning of SPELL_ATTR3_STACK_FOR_DIFF_CASTERS and update conditions here

 {
     return StackAmount > 1 && !IsChanneled() && !(AttributesEx3 & SPELL_ATTR3_STACK_FOR_DIFF_CASTERS);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SpellInfo::IsStackableWithRanks ( ) const

 {
     if (IsPassive())
         return false;
 
     if (IsProfessionOrRiding())
         return false;
 
     if (IsAbilityLearnedWithProfession())
         return false;
 
     // All stance spells. if any better way, change it.
     SpellEffectInfoVector effects = GetEffectsForDifficulty(DIFFICULTY_NONE);
     for (SpellEffectInfo const* effect : effects)
     {
         if (!effect)
             continue;
 
         switch (SpellFamilyName)
         {
             case SPELLFAMILY_PALADIN:
                 // Paladin aura Spell
                 if (effect->Effect == SPELL_EFFECT_APPLY_AREA_AURA_RAID)
                     return false;
                 break;
             case SPELLFAMILY_DRUID:
                 // Druid form Spell
                 if (effect->Effect == SPELL_EFFECT_APPLY_AURA &&
                     effect->ApplyAuraName == SPELL_AURA_MOD_SHAPESHIFT)
                     return false;
                 break;
         }
     }
 
     return true;
 }

Here is the call graph for this function:

bool SpellInfo::IsTargetingArea ( uint32 difficulty ) const

 {
     SpellEffectInfoVector effects = GetEffectsForDifficulty(difficulty);
     for (SpellEffectInfo const* effect : effects)
     {
         if (effect && effect->IsEffect() && effect->IsTargetingArea())
             return true;
     }
     return false;
 }

Here is the call graph for this function:

bool SpellInfo::NeedsComboPoints ( ) const

 {
     return (AttributesEx & (SPELL_ATTR1_REQ_COMBO_POINTS1 | SPELL_ATTR1_REQ_COMBO_POINTS2)) != 0;
 }

Here is the caller graph for this function:

bool SpellInfo::NeedsExplicitUnitTarget ( ) const

 {
     return (GetExplicitTargetMask() & TARGET_FLAG_UNIT_MASK) != 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SpellInfo::NeedsToBeTriggeredByCaster	(	SpellInfo const *	triggeringSpell,
		uint32	difficulty
	)		const

 {
     if (NeedsExplicitUnitTarget())
         return true;
 
     /*
     for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
     {
         if (Effects[i].IsEffect())
         {
             if (Effects[i].TargetA.GetSelectionCategory() == TARGET_SELECT_CATEGORY_CHANNEL
                 || Effects[i].TargetB.GetSelectionCategory() == TARGET_SELECT_CATEGORY_CHANNEL)
                 return true;
         }
     }
     */
 
     if (triggeringSpell->IsChanneled())
     {
         uint32 mask = 0;
         SpellEffectInfoVector effects = GetEffectsForDifficulty(difficulty);
         for (SpellEffectInfo const* effect : effects)
         {
             if (!effect)
                 continue;
 
             if (effect->TargetA.GetTarget() != TARGET_UNIT_CASTER && effect->TargetA.GetTarget() != TARGET_DEST_CASTER
                 && effect->TargetB.GetTarget() != TARGET_UNIT_CASTER && effect->TargetB.GetTarget() != TARGET_DEST_CASTER)
             {
                 mask |= effect->GetProvidedTargetMask();
             }
         }
 
         if (mask & TARGET_FLAG_UNIT_MASK)
             return true;
     }
 
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

SpellEffectInfoMap SpellInfo::_effects

bool SpellInfo::_hasPowerDifficultyData

SpellVisualMap SpellInfo::_visuals

uint32 SpellInfo::ActiveIconID

uint32 SpellInfo::Attributes

uint32 SpellInfo::AttributesCu

uint32 SpellInfo::AttributesEx

uint32 SpellInfo::AttributesEx10

uint32 SpellInfo::AttributesEx11

uint32 SpellInfo::AttributesEx12

uint32 SpellInfo::AttributesEx13

uint32 SpellInfo::AttributesEx2

uint32 SpellInfo::AttributesEx3

uint32 SpellInfo::AttributesEx4

uint32 SpellInfo::AttributesEx5

uint32 SpellInfo::AttributesEx6

uint32 SpellInfo::AttributesEx7

uint32 SpellInfo::AttributesEx8

uint32 SpellInfo::AttributesEx9

uint32 SpellInfo::AuraInterruptFlags

uint32 SpellInfo::BaseLevel

uint32 SpellInfo::CasterAuraSpell

uint32 SpellInfo::CasterAuraState

SpellCastTimesEntry const* SpellInfo::CastTimeEntry

SpellCategoryEntry const* SpellInfo::CategoryEntry

uint32 SpellInfo::CategoryRecoveryTime

SpellChainNode const* SpellInfo::ChainEntry

uint32 SpellInfo::ChannelInterruptFlags

SpellCategoryEntry const* SpellInfo::ChargeCategoryEntry

uint32 SpellInfo::Dispel

uint32 SpellInfo::DmgClass

SpellDurationEntry const* SpellInfo::DurationEntry

int32 SpellInfo::EquippedItemClass

int32 SpellInfo::EquippedItemInventoryTypeMask

int32 SpellInfo::EquippedItemSubClassMask

uint32 SpellInfo::ExcludeCasterAuraSpell

uint32 SpellInfo::ExcludeCasterAuraState

uint32 SpellInfo::ExcludeTargetAuraSpell

uint32 SpellInfo::ExcludeTargetAuraState

uint32 SpellInfo::ExplicitTargetMask

uint32 SpellInfo::FacingCasterFlags

uint32 SpellInfo::Id

uint32 SpellInfo::InterruptFlags

uint32 SpellInfo::MaxAffectedTargets

uint32 SpellInfo::MaxLevel

uint32 SpellInfo::MaxTargetLevel

uint32 SpellInfo::Mechanic

std::vector<SpellPowerEntry const*> SpellInfo::PowerCosts

uint32 SpellInfo::PreventionType

uint32 SpellInfo::ProcChance

uint32 SpellInfo::ProcCharges

uint32 SpellInfo::ProcFlags

SpellRangeEntry const* SpellInfo::RangeEntry

char* SpellInfo::Rank

int32 SpellInfo::Reagent[MAX_SPELL_REAGENTS]

uint32 SpellInfo::ReagentCount[MAX_SPELL_REAGENTS]

uint32 SpellInfo::RecoveryTime

int32 SpellInfo::RequiredAreasID

uint32 SpellInfo::RequiresSpellFocus

uint32 SpellInfo::RuneCostID

struct SpellInfo::ScalingInfo SpellInfo::Scaling

uint32 SpellInfo::SchoolMask

float SpellInfo::Speed

uint32 SpellInfo::SpellAuraOptionsId

uint32 SpellInfo::SpellAuraRestrictionsId

uint32 SpellInfo::SpellCastingRequirementsId

uint32 SpellInfo::SpellCategoriesId

uint32 SpellInfo::SpellClassOptionsId

uint32 SpellInfo::SpellCooldownsId

uint32 SpellInfo::SpellDifficultyId

uint32 SpellInfo::SpellEquippedItemsId

flag128 SpellInfo::SpellFamilyFlags

uint32 SpellInfo::SpellFamilyName

uint32 SpellInfo::SpellIconID

uint32 SpellInfo::SpellInterruptsId

uint32 SpellInfo::SpellLevel

uint32 SpellInfo::SpellLevelsId

uint32 SpellInfo::SpellMiscId

char* SpellInfo::SpellName

uint32 SpellInfo::SpellReagentsId

uint32 SpellInfo::SpellScalingId

uint32 SpellInfo::SpellShapeshiftId

uint32 SpellInfo::SpellTargetRestrictionsId

uint32 SpellInfo::SpellTotemsId

uint32 SpellInfo::SpellVisual[2]

uint32 SpellInfo::StackAmount

uint64 SpellInfo::Stances

uint64 SpellInfo::StancesNot

uint32 SpellInfo::StartRecoveryCategory

uint32 SpellInfo::StartRecoveryTime

uint32 SpellInfo::TargetAuraSpell

uint32 SpellInfo::TargetAuraState

uint32 SpellInfo::TargetCreatureType

uint32 SpellInfo::Targets

uint32 SpellInfo::Totem[2]

uint32 SpellInfo::TotemCategory[2]

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

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

Classes

Public Member Functions

Static Public Member Functions

Public Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation