#include <Spell.h>

Classes
struct	GOTargetInfo

struct	HitTriggerSpell

struct	ItemTargetInfo

struct	TargetInfo

Public Types
typedef std::set< Aura * >	UsedSpellMods

Public Member Functions
void	EffectNULL (SpellEffIndex effIndex)

void	EffectUnused (SpellEffIndex effIndex)

void	EffectDistract (SpellEffIndex effIndex)

void	EffectPull (SpellEffIndex effIndex)

void	EffectSchoolDMG (SpellEffIndex effIndex)

void	EffectEnvironmentalDMG (SpellEffIndex effIndex)

void	EffectInstaKill (SpellEffIndex effIndex)

void	EffectDummy (SpellEffIndex effIndex)

void	EffectTeleportUnits (SpellEffIndex effIndex)

void	EffectApplyAura (SpellEffIndex effIndex)

void	EffectSendEvent (SpellEffIndex effIndex)

void	EffectPowerBurn (SpellEffIndex effIndex)

void	EffectPowerDrain (SpellEffIndex effIndex)

void	EffectHeal (SpellEffIndex effIndex)

void	EffectBind (SpellEffIndex effIndex)

void	EffectHealthLeech (SpellEffIndex effIndex)

void	EffectQuestComplete (SpellEffIndex effIndex)

void	EffectCreateItem (SpellEffIndex effIndex)

void	EffectCreateItem2 (SpellEffIndex effIndex)

void	EffectCreateRandomItem (SpellEffIndex effIndex)

void	EffectPersistentAA (SpellEffIndex effIndex)

void	EffectEnergize (SpellEffIndex effIndex)

void	EffectOpenLock (SpellEffIndex effIndex)

void	EffectSummonChangeItem (SpellEffIndex effIndex)

void	EffectProficiency (SpellEffIndex effIndex)

void	EffectApplyAreaAura (SpellEffIndex effIndex)

void	EffectSummonType (SpellEffIndex effIndex)

void	EffectLearnSpell (SpellEffIndex effIndex)

void	EffectDispel (SpellEffIndex effIndex)

void	EffectDualWield (SpellEffIndex effIndex)

void	EffectPickPocket (SpellEffIndex effIndex)

void	EffectAddFarsight (SpellEffIndex effIndex)

void	EffectUntrainTalents (SpellEffIndex effIndex)

void	EffectHealMechanical (SpellEffIndex effIndex)

void	EffectJump (SpellEffIndex effIndex)

void	EffectJumpDest (SpellEffIndex effIndex)

void	EffectLeapBack (SpellEffIndex effIndex)

void	EffectQuestClear (SpellEffIndex effIndex)

void	EffectTeleUnitsFaceCaster (SpellEffIndex effIndex)

void	EffectLearnSkill (SpellEffIndex effIndex)

void	EffectPlayMovie (SpellEffIndex effIndex)

void	EffectTradeSkill (SpellEffIndex effIndex)

void	EffectEnchantItemPerm (SpellEffIndex effIndex)

void	EffectEnchantItemTmp (SpellEffIndex effIndex)

void	EffectTameCreature (SpellEffIndex effIndex)

void	EffectSummonPet (SpellEffIndex effIndex)

void	EffectLearnPetSpell (SpellEffIndex effIndex)

void	EffectWeaponDmg (SpellEffIndex effIndex)

void	EffectForceCast (SpellEffIndex effIndex)

void	EffectTriggerSpell (SpellEffIndex effIndex)

void	EffectTriggerMissileSpell (SpellEffIndex effIndex)

void	EffectThreat (SpellEffIndex effIndex)

void	EffectHealMaxHealth (SpellEffIndex effIndex)

void	EffectInterruptCast (SpellEffIndex effIndex)

void	EffectSummonObjectWild (SpellEffIndex effIndex)

void	EffectScriptEffect (SpellEffIndex effIndex)

void	EffectSanctuary (SpellEffIndex effIndex)

void	EffectAddComboPoints (SpellEffIndex effIndex)

void	EffectDuel (SpellEffIndex effIndex)

void	EffectStuck (SpellEffIndex effIndex)

void	EffectSummonPlayer (SpellEffIndex effIndex)

void	EffectActivateObject (SpellEffIndex effIndex)

void	EffectApplyGlyph (SpellEffIndex effIndex)

void	EffectEnchantHeldItem (SpellEffIndex effIndex)

void	EffectSummonObject (SpellEffIndex effIndex)

void	EffectChangeRaidMarker (SpellEffIndex effIndex)

void	EffectResurrect (SpellEffIndex effIndex)

void	EffectParry (SpellEffIndex effIndex)

void	EffectBlock (SpellEffIndex effIndex)

void	EffectLeap (SpellEffIndex effIndex)

void	EffectTransmitted (SpellEffIndex effIndex)

void	EffectDisEnchant (SpellEffIndex effIndex)

void	EffectInebriate (SpellEffIndex effIndex)

void	EffectFeedPet (SpellEffIndex effIndex)

void	EffectDismissPet (SpellEffIndex effIndex)

void	EffectReputation (SpellEffIndex effIndex)

void	EffectForceDeselect (SpellEffIndex effIndex)

void	EffectSelfResurrect (SpellEffIndex effIndex)

void	EffectSkinning (SpellEffIndex effIndex)

void	EffectCharge (SpellEffIndex effIndex)

void	EffectChargeDest (SpellEffIndex effIndex)

void	EffectProspecting (SpellEffIndex effIndex)

void	EffectMilling (SpellEffIndex effIndex)

void	EffectRenamePet (SpellEffIndex effIndex)

void	EffectSendTaxi (SpellEffIndex effIndex)

void	EffectSummonCritter (SpellEffIndex effIndex)

void	EffectKnockBack (SpellEffIndex effIndex)

void	EffectPullTowards (SpellEffIndex effIndex)

void	EffectDispelMechanic (SpellEffIndex effIndex)

void	EffectResurrectPet (SpellEffIndex effIndex)

void	EffectDestroyAllTotems (SpellEffIndex effIndex)

void	EffectDurabilityDamage (SpellEffIndex effIndex)

void	EffectSkill (SpellEffIndex effIndex)

void	EffectTaunt (SpellEffIndex effIndex)

void	EffectDurabilityDamagePCT (SpellEffIndex effIndex)

void	EffectModifyThreatPercent (SpellEffIndex effIndex)

void	EffectResurrectNew (SpellEffIndex effIndex)

void	EffectAddExtraAttacks (SpellEffIndex effIndex)

void	EffectSpiritHeal (SpellEffIndex effIndex)

void	EffectSkinPlayerCorpse (SpellEffIndex effIndex)

void	EffectStealBeneficialBuff (SpellEffIndex effIndex)

void	EffectUnlearnSpecialization (SpellEffIndex effIndex)

void	EffectHealPct (SpellEffIndex effIndex)

void	EffectEnergizePct (SpellEffIndex effIndex)

void	EffectTriggerRitualOfSummoning (SpellEffIndex effIndex)

void	EffectSummonRaFFriend (SpellEffIndex effIndex)

void	EffectUnlockGuildVaultTab (SpellEffIndex effIndex)

void	EffectKillCreditPersonal (SpellEffIndex effIndex)

void	EffectKillCredit (SpellEffIndex effIndex)

void	EffectQuestFail (SpellEffIndex effIndex)

void	EffectQuestStart (SpellEffIndex effIndex)

void	EffectRedirectThreat (SpellEffIndex effIndex)

void	EffectGameObjectDamage (SpellEffIndex effIndex)

void	EffectGameObjectRepair (SpellEffIndex effIndex)

void	EffectGameObjectSetDestructionState (SpellEffIndex effIndex)

void	EffectActivateRune (SpellEffIndex effIndex)

void	EffectCreateTamedPet (SpellEffIndex effIndex)

void	EffectDiscoverTaxi (SpellEffIndex effIndex)

void	EffectTitanGrip (SpellEffIndex effIndex)

void	EffectEnchantItemPrismatic (SpellEffIndex effIndex)

void	EffectPlayMusic (SpellEffIndex effIndex)

void	EffectSpecCount (SpellEffIndex effIndex)

void	EffectActivateSpec (SpellEffIndex effIndex)

void	EffectPlaySound (SpellEffIndex effIndex)

void	EffectRemoveAura (SpellEffIndex effIndex)

void	EffectDamageFromMaxHealthPCT (SpellEffIndex effIndex)

void	EffectCastButtons (SpellEffIndex effIndex)

void	EffectRechargeManaGem (SpellEffIndex effIndex)

void	EffectGiveCurrency (SpellEffIndex effIndex)

void	EffectResurrectWithAura (SpellEffIndex effIndex)

void	EffectCreateAreaTrigger (SpellEffIndex effIndex)

void	EffectRemoveTalent (SpellEffIndex effIndex)

void	EffectDestroyItem (SpellEffIndex effIndex)

void	EffectLearnGarrisonBuilding (SpellEffIndex effIndex)

void	EffectCreateGarrison (SpellEffIndex effIndex)

void	EffectAddGarrisonFollower (SpellEffIndex effIndex)

void	EffectActivateGarrisonBuilding (SpellEffIndex effIndex)

void	EffectHealBattlePetPct (SpellEffIndex effIndex)

void	EffectEnableBattlePets (SpellEffIndex effIndex)

void	EffectUncageBattlePet (SpellEffIndex effIndex)

void	EffectCreateHeirloomItem (SpellEffIndex effIndex)

void	EffectUpgradeHeirloom (SpellEffIndex effIndex)

	Spell (Unit caster, SpellInfo const info, TriggerCastFlags triggerFlags, ObjectGuid originalCasterGUID=ObjectGuid::Empty, bool skipCheck=false)

	~Spell ()

void	InitExplicitTargets (SpellCastTargets const &targets)

void	SelectExplicitTargets ()

void	SelectSpellTargets ()

void	SelectEffectImplicitTargets (SpellEffIndex effIndex, SpellImplicitTargetInfo const &targetType, uint32 &processedEffectMask)

void	SelectImplicitChannelTargets (SpellEffIndex effIndex, SpellImplicitTargetInfo const &targetType)

void	SelectImplicitNearbyTargets (SpellEffIndex effIndex, SpellImplicitTargetInfo const &targetType, uint32 effMask)

void	SelectImplicitConeTargets (SpellEffIndex effIndex, SpellImplicitTargetInfo const &targetType, uint32 effMask)

void	SelectImplicitAreaTargets (SpellEffIndex effIndex, SpellImplicitTargetInfo const &targetType, uint32 effMask)

void	SelectImplicitCasterDestTargets (SpellEffIndex effIndex, SpellImplicitTargetInfo const &targetType)

void	SelectImplicitTargetDestTargets (SpellEffIndex effIndex, SpellImplicitTargetInfo const &targetType)

void	SelectImplicitDestDestTargets (SpellEffIndex effIndex, SpellImplicitTargetInfo const &targetType)

void	SelectImplicitCasterObjectTargets (SpellEffIndex effIndex, SpellImplicitTargetInfo const &targetType)

void	SelectImplicitTargetObjectTargets (SpellEffIndex effIndex, SpellImplicitTargetInfo const &targetType)

void	SelectImplicitChainTargets (SpellEffIndex effIndex, SpellImplicitTargetInfo const &targetType, WorldObject *target, uint32 effMask)

void	SelectImplicitTrajTargets (SpellEffIndex effIndex)

void	SelectEffectTypeImplicitTargets (uint32 effIndex)

uint32	GetSearcherTypeMask (SpellTargetObjectTypes objType, ConditionContainer *condList)

template<class SEARCHER >
void	SearchTargets (SEARCHER &searcher, uint32 containerMask, Unit referer, Position const pos, float radius)

WorldObject *	SearchNearbyTarget (float range, SpellTargetObjectTypes objectType, SpellTargetCheckTypes selectionType, ConditionContainer *condList=NULL)

void	SearchAreaTargets (std::list< WorldObject * > &targets, float range, Position const position, Unit referer, SpellTargetObjectTypes objectType, SpellTargetCheckTypes selectionType, ConditionContainer *condList)

void	SearchChainTargets (std::list< WorldObject * > &targets, uint32 chainTargets, WorldObject target, SpellTargetObjectTypes objectType, SpellTargetCheckTypes selectType, ConditionContainer condList, bool isChainHeal)

GameObject *	SearchSpellFocus ()

void	prepare (SpellCastTargets const targets, AuraEffect const triggeredByAura=NULL)

void	cancel ()

void	update (uint32 difftime)

void	cast (bool skipCheck=false)

void	finish (bool ok=true)

void	TakePower ()

void	TakeRunePower (bool didHit)

void	TakeReagents ()

void	TakeCastItem ()

SpellCastResult	CheckCast (bool strict)

SpellCastResult	CheckPetCast (Unit *target)

void	handle_immediate ()

uint64	handle_delayed (uint64 t_offset)

void	_handle_immediate_phase ()

void	_handle_finish_phase ()

SpellCastResult	CheckItems ()

SpellCastResult	CheckRange (bool strict)

SpellCastResult	CheckPower ()

SpellCastResult	CheckRuneCost (uint32 runeCostID)

SpellCastResult	CheckCasterAuras () const

SpellCastResult	CheckArenaAndRatedBattlegroundCastRules ()

int32	CalculateDamage (uint8 i, Unit const target, float var=nullptr) const

bool	HaveTargetsForEffect (uint8 effect) const

void	Delayed ()

void	DelayedChannel ()

uint32	getState () const

void	setState (uint32 state)

void	DoCreateItem (uint32 i, uint32 itemtype, std::vector< int32 > const &bonusListIDs=std::vector< int32 >())

bool	CheckEffectTarget (Unit const target, SpellEffectInfo const effect, Position const *losPosition) const

bool	CheckEffectTarget (GameObject const target, SpellEffectInfo const effect) const

bool	CheckEffectTarget (Item const target, SpellEffectInfo const effect) const

bool	CanAutoCast (Unit *target)

void	CheckSrc ()

void	CheckDst ()

void	SendCastResult (SpellCastResult result)

void	SendPetCastResult (SpellCastResult result)

void	SendSpellStart ()

void	SendSpellGo ()

void	SendSpellCooldown ()

void	SendSpellExecuteLog ()

void	ExecuteLogEffectTakeTargetPower (uint8 effIndex, Unit *target, uint32 powerType, uint32 points, float amplitude)

void	ExecuteLogEffectExtraAttacks (uint8 effIndex, Unit *victim, uint32 numAttacks)

void	ExecuteLogEffectInterruptCast (uint8 effIndex, Unit *victim, uint32 spellId)

void	ExecuteLogEffectDurabilityDamage (uint8 effIndex, Unit *victim, int32 itemId, int32 amount)

void	ExecuteLogEffectOpenLock (uint8 effIndex, Object *obj)

void	ExecuteLogEffectCreateItem (uint8 effIndex, uint32 entry)

void	ExecuteLogEffectDestroyItem (uint8 effIndex, uint32 entry)

void	ExecuteLogEffectSummonObject (uint8 effIndex, WorldObject *obj)

void	ExecuteLogEffectUnsummonObject (uint8 effIndex, WorldObject *obj)

void	ExecuteLogEffectResurrect (uint8 effIndex, Unit *target)

void	CleanupExecuteLogList ()

void	SendInterrupted (uint8 result)

void	SendChannelUpdate (uint32 time)

void	SendChannelStart (uint32 duration)

void	SendResurrectRequest (Player *target)

void	HandleEffects (Unit pUnitTarget, Item pItemTarget, GameObject *pGOTarget, uint32 i, SpellEffectHandleMode mode)

void	HandleThreatSpells ()

int32	GetCastTime () const

bool	IsAutoRepeat () const

void	SetAutoRepeat (bool rep)

void	ReSetTimer ()

bool	IsNextMeleeSwingSpell () const

bool	IsTriggered () const

bool	IsIgnoringCooldowns () const

bool	IsChannelActive () const

bool	IsAutoActionResetSpell () const

bool	IsDeletable () const

void	SetReferencedFromCurrent (bool yes)

bool	IsInterruptable () const

void	SetExecutedCurrently (bool yes)

uint64	GetDelayStart () const

void	SetDelayStart (uint64 m_time)

uint64	GetDelayMoment () const

bool	IsNeedSendToClient () const

CurrentSpellTypes	GetCurrentContainer () const

Unit *	GetCaster () const

Unit *	GetOriginalCaster () const

SpellInfo const *	GetSpellInfo () const

std::vector< SpellInfo::CostData >	GetPowerCost () const

bool	UpdatePointers ()

void	CleanupTargetList ()

void	SetSpellValue (SpellValueMod mod, int32 value)

SpellEffectInfoVector const &	GetEffects () const

SpellEffectInfo const *	GetEffect (uint32 index) const

bool	HasEffect (SpellEffectName effect) const

SpellInfo const *	GetTriggeredByAuraSpell () const

int32	GetTimer () const

Static Public Member Functions
static void	SendCastResult (Player caster, SpellInfo const spellInfo, uint8 cast_count, SpellCastResult result, SpellCustomErrors customError=SPELL_CUSTOM_ERROR_NONE, OpcodeServer opcode=SMSG_CAST_FAILED, uint32 *misc=nullptr)

Public Attributes
SpellInfo const *const	m_spellInfo

Item *	m_CastItem

ObjectGuid	m_castItemGUID

uint32	m_castItemEntry

int32	m_castItemLevel

uint8	m_cast_count

uint32	m_castFlagsEx

union {
uint32 TalentId

uint32 GlyphSlot

struct {
uint32 Id

uint32 AbilityId

} GarrFollower

uint32 GarrMissionId

uint32 ItemId

struct {
uint32 Data [2]

} Raw

}	m_misc

uint32	m_SpellVisual

uint32	m_preCastSpell

SpellCastTargets	m_targets

int8	m_comboPointGain

SpellCustomErrors	m_customError

UsedSpellMods	m_appliedMods

Spell **	m_selfContainer

Protected Types
typedef std::list < HitTriggerSpell >	HitTriggerSpellList

Protected Member Functions
bool	HasGlobalCooldown () const

void	TriggerGlobalCooldown ()

void	CancelGlobalCooldown ()

void	SendLoot (ObjectGuid guid, LootType loottype)

bool	isDelayableNoMore ()

void	prepareDataForTriggerSystem (AuraEffect const *triggeredByAura)

void	AddUnitTarget (Unit target, uint32 effectMask, bool checkIfValid=true, bool implicit=true, Position const losPosition=nullptr)

void	AddGOTarget (GameObject *target, uint32 effectMask)

void	AddItemTarget (Item *item, uint32 effectMask)

void	AddDestTarget (SpellDestination const &dest, uint32 effIndex)

void	DoAllEffectOnTarget (TargetInfo *target)

SpellMissInfo	DoSpellHitOnUnit (Unit *unit, uint32 effectMask, bool scaleAura)

void	DoTriggersOnSpellHit (Unit *unit, uint8 effMask)

void	DoAllEffectOnTarget (GOTargetInfo *target)

void	DoAllEffectOnTarget (ItemTargetInfo *target)

bool	UpdateChanneledTargetList ()

bool	IsValidDeadOrAliveTarget (Unit const *target) const

void	HandleLaunchPhase ()

void	DoAllEffectOnLaunchTarget (TargetInfo &targetInfo, float *multiplier)

void	PrepareTargetProcessing ()

void	FinishTargetProcessing ()

void	LoadScripts ()

void	CallScriptBeforeCastHandlers ()

void	CallScriptOnCastHandlers ()

void	CallScriptAfterCastHandlers ()

SpellCastResult	CallScriptCheckCastHandlers ()

void	PrepareScriptHitHandlers ()

bool	CallScriptEffectHandlers (SpellEffIndex effIndex, SpellEffectHandleMode mode)

void	CallScriptSuccessfulDispel (SpellEffIndex effIndex)

void	CallScriptBeforeHitHandlers ()

void	CallScriptOnHitHandlers ()

void	CallScriptAfterHitHandlers ()

void	CallScriptObjectAreaTargetSelectHandlers (std::list< WorldObject * > &targets, SpellEffIndex effIndex, SpellImplicitTargetInfo const &targetType)

void	CallScriptObjectTargetSelectHandlers (WorldObject *&target, SpellEffIndex effIndex, SpellImplicitTargetInfo const &targetType)

void	CallScriptDestinationTargetSelectHandlers (SpellDestination &target, SpellEffIndex effIndex, SpellImplicitTargetInfo const &targetType)

bool	CheckScriptEffectImplicitTargets (uint32 effIndex, uint32 effIndexToCheck)

bool	CanExecuteTriggersOnHit (uint8 effMask, SpellInfo const *triggeredByAura=NULL) const

void	PrepareTriggersExecutedOnHit ()

void	SummonGuardian (uint32 i, uint32 entry, SummonPropertiesEntry const *properties, uint32 numSummons)

void	CalculateJumpSpeeds (SpellEffectInfo const *effInfo, float dist, float &speedxy, float &speedz)

void	UpdateSpellCastDataTargets (WorldPackets::Spells::SpellCastData &data)
	Writes miss and hit targets for a SMSG_SPELL_GO packet. More...

SpellCastResult	CanOpenLock (uint32 effIndex, uint32 lockid, SkillType &skillid, int32 &reqSkillValue, int32 &skillValue)

	Spell (Spell const &right)=delete

Spell &	operator= (Spell const &right)=delete

Protected Attributes
Unit *const	m_caster

SpellValue *const	m_spellValue

ObjectGuid	m_originalCasterGUID

Unit *	m_originalCaster

SpellSchoolMask	m_spellSchoolMask

WeaponAttackType	m_attackType

std::vector< SpellInfo::CostData >	m_powerCost

int32	m_casttime

int32	m_channeledDuration

bool	m_canReflect

bool	m_autoRepeat

bool	m_isDelayedInstantCast

uint8	m_runesState

uint8	m_delayAtDamageCount

uint64	m_delayStart

uint64	m_delayMoment

bool	m_immediateHandled

bool	m_referencedFromCurrentSpell

bool	m_executedCurrently

bool	m_needComboPoints

uint8	m_applyMultiplierMask

float	m_damageMultipliers [3]

Unit *	unitTarget

Item *	itemTarget

GameObject *	gameObjTarget

WorldLocation *	destTarget

int32	damage

float	variance

SpellEffectHandleMode	effectHandleMode

SpellEffectInfo const *	effectInfo

Aura *	m_spellAura

DiminishingLevels	m_diminishLevel

DiminishingGroup	m_diminishGroup

GameObject *	focusObject

int32	m_damage

int32	m_healing

uint32	m_procAttacker

uint32	m_procVictim

uint32	m_procEx

std::vector< TargetInfo >	m_UniqueTargetInfo

uint32	m_channelTargetEffectMask

std::vector< GOTargetInfo >	m_UniqueGOTargetInfo

std::vector< ItemTargetInfo >	m_UniqueItemInfo

SpellDestination	m_destTargets [MAX_SPELL_EFFECTS]

std::list< SpellScript * >	m_loadedScripts

HitTriggerSpellList	m_hitTriggerSpells

uint32	m_spellState

int32	m_timer

TriggerCastFlags	_triggeredCastFlags

SpellInfo const *	m_triggeredByAuraSpell

bool	m_skipCheck

uint32	m_auraScaleMask

PathGenerator	m_preGeneratedPath

std::vector < SpellLogEffectPowerDrainParams >	_powerDrainTargets [MAX_SPELL_EFFECTS]

std::vector < SpellLogEffectExtraAttacksParams >	_extraAttacksTargets [MAX_SPELL_EFFECTS]

std::vector < SpellLogEffectDurabilityDamageParams >	_durabilityDamageTargets [MAX_SPELL_EFFECTS]

std::vector < SpellLogEffectGenericVictimParams >	_genericVictimTargets [MAX_SPELL_EFFECTS]

std::vector < SpellLogEffectTradeSkillItemParams >	_tradeSkillTargets [MAX_SPELL_EFFECTS]

std::vector < SpellLogEffectFeedPetParams >	_feedPetTargets [MAX_SPELL_EFFECTS]

SpellEffectInfoVector	_effects

Friends
class	SpellScript

void	Unit::SetCurrentCastSpell (Spell *pSpell)

Member Typedef Documentation

typedef std::list<HitTriggerSpell> Spell::HitTriggerSpellList

protected

typedef std::set<Aura*> Spell::UsedSpellMods

Constructor & Destructor Documentation

Spell::Spell	(	Unit *	caster,
		SpellInfo const *	info,
		TriggerCastFlags	triggerFlags,
		ObjectGuid	originalCasterGUID = `ObjectGuid::Empty`,
		bool	skipCheck = `false`
	)

  :
 m_spellInfo(info), m_caster((info->HasAttribute(SPELL_ATTR6_CAST_BY_CHARMER) && caster->GetCharmerOrOwner()) ? caster->GetCharmerOrOwner() : caster),
 m_spellValue(new SpellValue(caster->GetMap()->GetDifficultyID(), m_spellInfo)), m_preGeneratedPath(PathGenerator(m_caster))
 {
  _effects = info->GetEffectsForDifficulty(caster->GetMap()->GetDifficultyID());
 
  m_customError = SPELL_CUSTOM_ERROR_NONE;
  m_skipCheck = skipCheck;
  m_selfContainer = NULL;
  m_referencedFromCurrentSpell = false;
  m_executedCurrently = false;
  m_needComboPoints = m_spellInfo->NeedsComboPoints();
  m_comboPointGain = 0;
  m_delayStart = 0;
  m_delayAtDamageCount = 0;
 
  m_applyMultiplierMask = 0;
  m_auraScaleMask = 0;
  memset(m_damageMultipliers, 0, sizeof(m_damageMultipliers));
 
  // Get data for type of attack
  switch (m_spellInfo->DmgClass)
  {
  case SPELL_DAMAGE_CLASS_MELEE:
  if (m_spellInfo->HasAttribute(SPELL_ATTR3_REQ_OFFHAND))
  m_attackType = OFF_ATTACK;
  else
  m_attackType = BASE_ATTACK;
  break;
  case SPELL_DAMAGE_CLASS_RANGED:
  m_attackType = m_spellInfo->IsRangedWeaponSpell() ? RANGED_ATTACK : BASE_ATTACK;
  break;
  default:
  // Wands
  if (m_spellInfo->HasAttribute(SPELL_ATTR2_AUTOREPEAT_FLAG))
  m_attackType = RANGED_ATTACK;
  else
  m_attackType = BASE_ATTACK;
  break;
  }
 
  m_spellSchoolMask = info->GetSchoolMask(); // Can be override for some spell (wand shoot for example)
 
  if (m_attackType == RANGED_ATTACK)
  // wand case
  if ((m_caster->getClassMask() & CLASSMASK_WAND_USERS) != 0 && m_caster->GetTypeId() == TYPEID_PLAYER)
  if (Item* pItem = m_caster->ToPlayer()->GetWeaponForAttack(RANGED_ATTACK))
  m_spellSchoolMask = SpellSchoolMask(1 << pItem->GetTemplate()->GetDamageType());
 
  if (!originalCasterGUID.IsEmpty())
  m_originalCasterGUID = originalCasterGUID;
  else
  m_originalCasterGUID = m_caster->GetGUID();
 
  if (m_originalCasterGUID == m_caster->GetGUID())
  m_originalCaster = m_caster;
  else
  {
  m_originalCaster = ObjectAccessor::GetUnit(*m_caster, m_originalCasterGUID);
  if (m_originalCaster && !m_originalCaster->IsInWorld())
  m_originalCaster = NULL;
  }
 
  m_spellState = SPELL_STATE_NULL;
  _triggeredCastFlags = triggerFlags;
  if (info->HasAttribute(SPELL_ATTR4_CAN_CAST_WHILE_CASTING))
  _triggeredCastFlags = TriggerCastFlags(uint32(_triggeredCastFlags) | TRIGGERED_IGNORE_CAST_IN_PROGRESS | TRIGGERED_CAST_DIRECTLY);
 
  m_CastItem = NULL;
  m_castItemGUID.Clear();
  m_castItemEntry = 0;
  m_castItemLevel = -1;
  m_castFlagsEx = 0;
 
  unitTarget = NULL;
  itemTarget = NULL;
  gameObjTarget = NULL;
  destTarget = NULL;
  damage = 0;
  variance = 0.0f;
  effectHandleMode = SPELL_EFFECT_HANDLE_LAUNCH;
  effectInfo = nullptr;
  m_diminishLevel = DIMINISHING_LEVEL_1;
  m_diminishGroup = DIMINISHING_NONE;
  m_damage = 0;
  m_healing = 0;
  m_procAttacker = 0;
  m_procVictim = 0;
  m_procEx = 0;
  focusObject = NULL;
  m_cast_count = 0;
  memset(m_misc.Raw.Data, 0, sizeof(m_misc.Raw.Data));
  m_SpellVisual = m_spellInfo->GetSpellXSpellVisualId(caster->GetMap()->GetDifficultyID());
  m_preCastSpell = 0;
  m_triggeredByAuraSpell = NULL;
  m_spellAura = NULL;
 
  //Auto Shot & Shoot (wand)
  m_autoRepeat = m_spellInfo->IsAutoRepeatRangedSpell();
  
  m_isDelayedInstantCast = false;
 
  m_runesState = 0;
  m_casttime = 0; // setup to correct value in Spell::prepare, must not be used before.
  m_timer = 0; // will set to castime in prepare
  m_channeledDuration = 0; // will be setup in Spell::handle_immediate
  m_immediateHandled = false;
 
  m_channelTargetEffectMask = 0;
 
  // Determine if spell can be reflected back to the caster
  // Patch 1.2 notes: Spell Reflection no longer reflects abilities
  m_canReflect = m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_MAGIC && !m_spellInfo->HasAttribute(SPELL_ATTR0_ABILITY)
  && !m_spellInfo->HasAttribute(SPELL_ATTR1_CANT_BE_REFLECTED) && !m_spellInfo->HasAttribute(SPELL_ATTR0_UNAFFECTED_BY_INVULNERABILITY)
  && !m_spellInfo->IsPassive() && !m_spellInfo->IsPositive();
 
  CleanupTargetList();
  CleanupExecuteLogList();
 
  for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
  m_destTargets[i] = SpellDestination(*m_caster);
 }

Here is the call graph for this function:

Spell::~Spell ( )

 {
  // unload scripts
  while (!m_loadedScripts.empty())
  {
  std::list<SpellScript*>::iterator itr = m_loadedScripts.begin();
  (*itr)->_Unload();
  delete (*itr);
  m_loadedScripts.erase(itr);
  }
 
  if (m_referencedFromCurrentSpell && m_selfContainer && *m_selfContainer == this)
  {
  // Clean the reference to avoid later crash.
  // If this error is repeating, we may have to add an ASSERT to better track down how we get into this case.
  TC_LOG_ERROR("spells", "SPELL: deleting spell for spell ID %u. However, spell still referenced.", m_spellInfo->Id);
  *m_selfContainer = NULL;
  }
 
  if (m_caster && m_caster->GetTypeId() == TYPEID_PLAYER)
  ASSERT(m_caster->ToPlayer()->m_spellModTakingSpell != this);
 
  delete m_spellValue;
  CleanupExecuteLogList();
 }

Here is the call graph for this function:

Spell::Spell ( Spell const & right )

protecteddelete

Member Function Documentation

void Spell::_handle_finish_phase ( )

Todo:: trigger proc phase finish here

 {
  if (m_caster->m_movedPlayer)
  {
  // Take for real after all targets are processed
  if (m_needComboPoints)
  m_caster->m_movedPlayer->ClearComboPoints();
 
  // Real add combo points from effects
  if (m_comboPointGain)
  m_caster->m_movedPlayer->GainSpellComboPoints(m_comboPointGain);
  }
 
  if (m_caster->m_extraAttacks && HasEffect(SPELL_EFFECT_ADD_EXTRA_ATTACKS))
  {
  if (Unit* victim = ObjectAccessor::GetUnit(*m_caster, m_targets.GetOrigUnitTargetGUID()))
  m_caster->HandleProcExtraAttackFor(victim);
  else
  m_caster->m_extraAttacks = 0;
  }
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::_handle_immediate_phase ( )

Todo:: finish new proc system:P

 {
  m_spellAura = NULL;
  // initialize Diminishing Returns Data
  m_diminishLevel = DIMINISHING_LEVEL_1;
  m_diminishGroup = DIMINISHING_NONE;
 
  // handle some immediate features of the spell here
  HandleThreatSpells();
 
  PrepareScriptHitHandlers();
 
  // handle effects with SPELL_EFFECT_HANDLE_HIT mode
  for (SpellEffectInfo const* effect : GetEffects())
  {
  // don't do anything for empty effect
  if (!effect || !effect->IsEffect())
  continue;
 
  // call effect handlers to handle destination hit
  HandleEffects(NULL, NULL, NULL, effect->EffectIndex, SPELL_EFFECT_HANDLE_HIT);
  }
 
  // process items
  for (std::vector<ItemTargetInfo>::iterator ihit = m_UniqueItemInfo.begin(); ihit != m_UniqueItemInfo.end(); ++ihit)
  DoAllEffectOnTarget(&(*ihit));
 
  if (!m_originalCaster)
  return;
  // Handle procs on cast
  if (m_UniqueTargetInfo.empty() && m_targets.HasDst())
  {
  uint32 procAttacker = m_procAttacker;
  if (!procAttacker)
  procAttacker |= PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS;
 
  // Proc the spells that have DEST target
  m_originalCaster->ProcDamageAndSpell(NULL, procAttacker, 0, m_procEx | PROC_EX_NORMAL_HIT, 0, BASE_ATTACK, m_spellInfo, m_triggeredByAuraSpell);
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::AddDestTarget	(	SpellDestination const &	dest,
		uint32	effIndex
	)

protected

 {
     m_destTargets[effIndex] = dest;
 }

Here is the caller graph for this function:

void Spell::AddGOTarget	(	GameObject *	target,
		uint32	effectMask
	)

protected

 {
     uint32 validEffectMask = 0;
     for (SpellEffectInfo const* effect : GetEffects())
         if (effect && (effectMask & (1 << effect->EffectIndex)) != 0 && CheckEffectTarget(go, effect))
             validEffectMask |= 1 << effect->EffectIndex;
 
     effectMask &= validEffectMask;
 
     // no effects left
     if (!effectMask)
         return;
 
     ObjectGuid targetGUID = go->GetGUID();
 
     // Lookup target in already in list
     for (std::vector<GOTargetInfo>::iterator ihit = m_UniqueGOTargetInfo.begin(); ihit != m_UniqueGOTargetInfo.end(); ++ihit)
     {
         if (targetGUID == ihit->targetGUID)                 // Found in list
         {
             ihit->effectMask |= effectMask;                 // Add only effect mask
             return;
         }
     }
 
     // This is new target calculate data for him
 
     GOTargetInfo target;
     target.targetGUID = targetGUID;
     target.effectMask = effectMask;
     target.processed  = false;                              // Effects not apply on target
 
     // Spell have speed - need calculate incoming time
     if (m_spellInfo->Speed > 0.0f)
     {
         // calculate spell incoming interval
         float dist = m_caster->GetDistance(go->GetPositionX(), go->GetPositionY(), go->GetPositionZ());
         if (dist < 5.0f)
             dist = 5.0f;
 
         if (!m_spellInfo->HasAttribute(SPELL_ATTR9_SPECIAL_DELAY_CALCULATION))
             target.timeDelay = uint64(floor(dist / m_spellInfo->Speed * 1000.0f));
         else
             target.timeDelay = uint64(m_spellInfo->Speed * 1000.0f);
 
         if (m_delayMoment == 0 || m_delayMoment > target.timeDelay)
             m_delayMoment = target.timeDelay;
     }
     else
         target.timeDelay = 0LL;
 
     // Add target to list
     m_UniqueGOTargetInfo.push_back(target);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::AddItemTarget	(	Item *	item,
		uint32	effectMask
	)

protected

 {
     uint32 validEffectMask = 0;
     for (SpellEffectInfo const* effect : GetEffects())
         if (effect && (effectMask & (1 << effect->EffectIndex)) != 0 && CheckEffectTarget(item, effect))
             validEffectMask |= 1 << effect->EffectIndex;
 
     effectMask &= validEffectMask;
 
     // no effects left
     if (!effectMask)
         return;
 
     // Lookup target in already in list
     for (std::vector<ItemTargetInfo>::iterator ihit = m_UniqueItemInfo.begin(); ihit != m_UniqueItemInfo.end(); ++ihit)
     {
         if (item == ihit->item)                            // Found in list
         {
             ihit->effectMask |= effectMask;                 // Add only effect mask
             return;
         }
     }
 
     // This is new target add data
 
     ItemTargetInfo target;
     target.item       = item;
     target.effectMask = effectMask;
 
     m_UniqueItemInfo.push_back(target);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::AddUnitTarget	(	Unit *	target,
		uint32	effectMask,
		bool	checkIfValid = `true`,
		bool	implicit = `true`,
		Position const *	losPosition = `nullptr`
	)

protected

Todo:: this is a hack

 {
     uint32 validEffectMask = 0;
     for (SpellEffectInfo const* effect : GetEffects())
         if (effect && (effectMask & (1 << effect->EffectIndex)) != 0 && CheckEffectTarget(target, effect, losPosition))
             validEffectMask |= 1 << effect->EffectIndex;
 
     effectMask &= validEffectMask;
 
     // no effects left
     if (!effectMask)
         return;
 
     if (checkIfValid)
         if (m_spellInfo->CheckTarget(m_caster, target, implicit) != SPELL_CAST_OK)
             return;
 
     // Check for effect immune skip if immuned
     for (SpellEffectInfo const* effect : GetEffects())
         if (effect && target->IsImmunedToSpellEffect(m_spellInfo, effect->EffectIndex))
             effectMask &= ~(1 << effect->EffectIndex);
 
     ObjectGuid targetGUID = target->GetGUID();
 
     // Lookup target in already in list
     for (std::vector<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
     {
         if (targetGUID == ihit->targetGUID)             // Found in list
         {
             ihit->effectMask |= effectMask;             // Immune effects removed from mask
             ihit->scaleAura = false;
             if (m_auraScaleMask && ihit->effectMask == m_auraScaleMask && m_caster != target)
             {
                 SpellInfo const* auraSpell = m_spellInfo->GetFirstRankSpell();
                 if (uint32(target->getLevel() + 10) >= auraSpell->SpellLevel)
                     ihit->scaleAura = true;
             }
             return;
         }
     }
 
     // This is new target calculate data for him
 
     // Get spell hit result on target
     TargetInfo targetInfo;
     targetInfo.targetGUID = targetGUID;                         // Store target GUID
     targetInfo.effectMask = effectMask;                         // Store all effects not immune
     targetInfo.processed  = false;                              // Effects not apply on target
     targetInfo.alive      = target->IsAlive();
     targetInfo.damage     = 0;
     targetInfo.crit       = false;
     targetInfo.scaleAura  = false;
     if (m_auraScaleMask && targetInfo.effectMask == m_auraScaleMask && m_caster != target)
     {
         SpellInfo const* auraSpell = m_spellInfo->GetFirstRankSpell();
         if (uint32(target->getLevel() + 10) >= auraSpell->SpellLevel)
             targetInfo.scaleAura = true;
     }
 
     // Calculate hit result
     if (m_originalCaster)
     {
         targetInfo.missCondition = m_originalCaster->SpellHitResult(target, m_spellInfo, m_canReflect);
         if (m_skipCheck && targetInfo.missCondition != SPELL_MISS_IMMUNE)
             targetInfo.missCondition = SPELL_MISS_NONE;
     }
     else
         targetInfo.missCondition = SPELL_MISS_EVADE; //SPELL_MISS_NONE;
 
     // Spell have speed - need calculate incoming time
     // Incoming time is zero for self casts. At least I think so.
     if (m_spellInfo->Speed > 0.0f && m_caster != target)
     {
         // calculate spell incoming interval
         float dist = m_caster->GetDistance(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ());
 
         if (dist < 5.0f)
             dist = 5.0f;
 
         if (!m_spellInfo->HasAttribute(SPELL_ATTR9_SPECIAL_DELAY_CALCULATION))
             targetInfo.timeDelay = uint64(std::floor(dist / m_spellInfo->Speed * 1000.0f));
         else
             targetInfo.timeDelay = uint64(m_spellInfo->Speed * 1000.0f);
 
         // Calculate minimum incoming time
         if (m_delayMoment == 0 || m_delayMoment > targetInfo.timeDelay)
             m_delayMoment = targetInfo.timeDelay;
     }
     else
         targetInfo.timeDelay = 0LL;
 
     // If target reflect spell back to caster
     if (targetInfo.missCondition == SPELL_MISS_REFLECT)
     {
         // Calculate reflected spell result on caster
         targetInfo.reflectResult = m_caster->SpellHitResult(m_caster, m_spellInfo, m_canReflect);
 
         if (targetInfo.reflectResult == SPELL_MISS_REFLECT)     // Impossible reflect again, so simply deflect spell
             targetInfo.reflectResult = SPELL_MISS_PARRY;
 
         // Increase time interval for reflected spells by 1.5
         targetInfo.timeDelay += targetInfo.timeDelay >> 1;
     }
     else
         targetInfo.reflectResult = SPELL_MISS_NONE;
 
     // Add target to list
     m_UniqueTargetInfo.push_back(targetInfo);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Spell::CalculateDamage	(	uint8	i,
		Unit const *	target,
		float *	var = `nullptr`
	)		const

inline

504 { return m_caster->CalculateSpellDamage(target, m_spellInfo, i, &m_spellValue->EffectBasePoints[i], var, m_castItemLevel); }

Spell::m_spellInfo

SpellInfo const *const m_spellInfo

Definition: Spell.h:547

Spell::m_caster

Unit *const m_caster

Definition: Spell.h:647

G3D::var

static void var(TextOutput &t, const std::string &name, const std::string &val)

Definition: System.cpp:1582

Spell::m_spellValue

SpellValue *const m_spellValue

Definition: Spell.h:649

Unit::CalculateSpellDamage

int32 CalculateSpellDamage(Unit const *target, SpellInfo const *spellProto, uint8 effect_index, int32 const *basePoints=nullptr, float *variance=nullptr, int32 itemLevel=-1) const

Definition: Unit.cpp:10930

SpellValue::EffectBasePoints

int32 EffectBasePoints[MAX_SPELL_EFFECTS]

Definition: Spell.h:268

Spell::m_castItemLevel

int32 m_castItemLevel

Definition: Spell.h:551

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::CalculateJumpSpeeds	(	SpellEffectInfo const *	effInfo,
		float	dist,
		float &	speedxy,
		float &	speedz
	)

protected

 {
     if (effInfo->MiscValue)
         speedZ = float(effInfo->MiscValue) / 10;
     else if (effInfo->MiscValueB)
         speedZ = float(effInfo->MiscValueB) / 10;
     else
         speedZ = 10.0f;
 
     speedXY = dist * 10.0f / speedZ;
 }

Here is the caller graph for this function:

void Spell::CallScriptAfterCastHandlers ( )

protected

 {
     for (std::list<SpellScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
     {
         (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_AFTER_CAST);
         std::list<SpellScript::CastHandler>::iterator hookItrEnd = (*scritr)->AfterCast.end(), hookItr = (*scritr)->AfterCast.begin();
         for (; hookItr != hookItrEnd; ++hookItr)
             (*hookItr).Call(*scritr);
 
         (*scritr)->_FinishScriptCall();
     }
 }

Here is the caller graph for this function:

void Spell::CallScriptAfterHitHandlers ( )

protected

 {
     for (std::list<SpellScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
     {
         (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_AFTER_HIT);
         std::list<SpellScript::HitHandler>::iterator hookItrEnd = (*scritr)->AfterHit.end(), hookItr = (*scritr)->AfterHit.begin();
         for (; hookItr != hookItrEnd; ++hookItr)
             (*hookItr).Call(*scritr);
 
         (*scritr)->_FinishScriptCall();
     }
 }

Here is the caller graph for this function:

void Spell::CallScriptBeforeCastHandlers ( )

protected

 {
     for (std::list<SpellScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
     {
         (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_BEFORE_CAST);
         std::list<SpellScript::CastHandler>::iterator hookItrEnd = (*scritr)->BeforeCast.end(), hookItr = (*scritr)->BeforeCast.begin();
         for (; hookItr != hookItrEnd; ++hookItr)
             (*hookItr).Call(*scritr);
 
         (*scritr)->_FinishScriptCall();
     }
 }

Here is the caller graph for this function:

void Spell::CallScriptBeforeHitHandlers ( )

protected

 {
     for (std::list<SpellScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
     {
         (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_BEFORE_HIT);
         std::list<SpellScript::HitHandler>::iterator hookItrEnd = (*scritr)->BeforeHit.end(), hookItr = (*scritr)->BeforeHit.begin();
         for (; hookItr != hookItrEnd; ++hookItr)
             (*hookItr).Call(*scritr);
 
         (*scritr)->_FinishScriptCall();
     }
 }

Here is the caller graph for this function:

SpellCastResult Spell::CallScriptCheckCastHandlers ( )

protected

 {
     SpellCastResult retVal = SPELL_CAST_OK;
     for (std::list<SpellScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
     {
         (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_CHECK_CAST);
         std::list<SpellScript::CheckCastHandler>::iterator hookItrEnd = (*scritr)->OnCheckCast.end(), hookItr = (*scritr)->OnCheckCast.begin();
         for (; hookItr != hookItrEnd; ++hookItr)
         {
             SpellCastResult tempResult = (*hookItr).Call(*scritr);
             if (retVal == SPELL_CAST_OK)
                 retVal = tempResult;
         }
 
         (*scritr)->_FinishScriptCall();
     }
     return retVal;
 }

Here is the caller graph for this function:

void Spell::CallScriptDestinationTargetSelectHandlers	(	SpellDestination &	target,
		SpellEffIndex	effIndex,
		SpellImplicitTargetInfo const &	targetType
	)

protected

 {
     for (std::list<SpellScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
     {
         (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_DESTINATION_TARGET_SELECT);
         std::list<SpellScript::DestinationTargetSelectHandler>::iterator hookItrEnd = (*scritr)->OnDestinationTargetSelect.end(), hookItr = (*scritr)->OnDestinationTargetSelect.begin();
         for (; hookItr != hookItrEnd; ++hookItr)
             if (hookItr->IsEffectAffected(m_spellInfo, effIndex) && targetType.GetTarget() == hookItr->GetTarget())
                 hookItr->Call(*scritr, target);
 
         (*scritr)->_FinishScriptCall();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Spell::CallScriptEffectHandlers	(	SpellEffIndex	effIndex,
		SpellEffectHandleMode	mode
	)

protected

 {
     // execute script effect handler hooks and check if effects was prevented
     bool preventDefault = false;
     for (std::list<SpellScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
     {
         std::list<SpellScript::EffectHandler>::iterator effItr, effEndItr;
         SpellScriptHookType hookType;
         switch (mode)
         {
             case SPELL_EFFECT_HANDLE_LAUNCH:
                 effItr = (*scritr)->OnEffectLaunch.begin();
                 effEndItr = (*scritr)->OnEffectLaunch.end();
                 hookType = SPELL_SCRIPT_HOOK_EFFECT_LAUNCH;
                 break;
             case SPELL_EFFECT_HANDLE_LAUNCH_TARGET:
                 effItr = (*scritr)->OnEffectLaunchTarget.begin();
                 effEndItr = (*scritr)->OnEffectLaunchTarget.end();
                 hookType = SPELL_SCRIPT_HOOK_EFFECT_LAUNCH_TARGET;
                 break;
             case SPELL_EFFECT_HANDLE_HIT:
                 effItr = (*scritr)->OnEffectHit.begin();
                 effEndItr = (*scritr)->OnEffectHit.end();
                 hookType = SPELL_SCRIPT_HOOK_EFFECT_HIT;
                 break;
             case SPELL_EFFECT_HANDLE_HIT_TARGET:
                 effItr = (*scritr)->OnEffectHitTarget.begin();
                 effEndItr = (*scritr)->OnEffectHitTarget.end();
                 hookType = SPELL_SCRIPT_HOOK_EFFECT_HIT_TARGET;
                 break;
             default:
                 ABORT();
                 return false;
         }
         (*scritr)->_PrepareScriptCall(hookType);
         for (; effItr != effEndItr; ++effItr)
             // effect execution can be prevented
             if (!(*scritr)->_IsEffectPrevented(effIndex) && (*effItr).IsEffectAffected(m_spellInfo, effIndex))
                 (*effItr).Call(*scritr, effIndex);
 
         if (!preventDefault)
             preventDefault = (*scritr)->_IsDefaultEffectPrevented(effIndex);
 
         (*scritr)->_FinishScriptCall();
     }
     return preventDefault;
 }

Here is the caller graph for this function:

void Spell::CallScriptObjectAreaTargetSelectHandlers	(	std::list< WorldObject * > &	targets,
		SpellEffIndex	effIndex,
		SpellImplicitTargetInfo const &	targetType
	)

protected

 {
     for (std::list<SpellScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
     {
         (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_OBJECT_AREA_TARGET_SELECT);
         std::list<SpellScript::ObjectAreaTargetSelectHandler>::iterator hookItrEnd = (*scritr)->OnObjectAreaTargetSelect.end(), hookItr = (*scritr)->OnObjectAreaTargetSelect.begin();
         for (; hookItr != hookItrEnd; ++hookItr)
             if (hookItr->IsEffectAffected(m_spellInfo, effIndex) && targetType.GetTarget() == hookItr->GetTarget())
                 hookItr->Call(*scritr, targets);
 
         (*scritr)->_FinishScriptCall();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::CallScriptObjectTargetSelectHandlers	(	WorldObject *&	target,
		SpellEffIndex	effIndex,
		SpellImplicitTargetInfo const &	targetType
	)

protected

 {
     for (std::list<SpellScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
     {
         (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_OBJECT_TARGET_SELECT);
         std::list<SpellScript::ObjectTargetSelectHandler>::iterator hookItrEnd = (*scritr)->OnObjectTargetSelect.end(), hookItr = (*scritr)->OnObjectTargetSelect.begin();
         for (; hookItr != hookItrEnd; ++hookItr)
             if (hookItr->IsEffectAffected(m_spellInfo, effIndex) && targetType.GetTarget() == hookItr->GetTarget())
                 hookItr->Call(*scritr, target);
 
         (*scritr)->_FinishScriptCall();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::CallScriptOnCastHandlers ( )

protected

 {
     for (std::list<SpellScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
     {
         (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_ON_CAST);
         std::list<SpellScript::CastHandler>::iterator hookItrEnd = (*scritr)->OnCast.end(), hookItr = (*scritr)->OnCast.begin();
         for (; hookItr != hookItrEnd; ++hookItr)
             (*hookItr).Call(*scritr);
 
         (*scritr)->_FinishScriptCall();
     }
 }

Here is the caller graph for this function:

void Spell::CallScriptOnHitHandlers ( )

protected

 {
     for (std::list<SpellScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
     {
         (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_HIT);
         std::list<SpellScript::HitHandler>::iterator hookItrEnd = (*scritr)->OnHit.end(), hookItr = (*scritr)->OnHit.begin();
         for (; hookItr != hookItrEnd; ++hookItr)
             (*hookItr).Call(*scritr);
 
         (*scritr)->_FinishScriptCall();
     }
 }

Here is the caller graph for this function:

void Spell::CallScriptSuccessfulDispel ( SpellEffIndex effIndex )

protected

 {
     for (std::list<SpellScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
     {
         (*scritr)->_PrepareScriptCall(SPELL_SCRIPT_HOOK_EFFECT_SUCCESSFUL_DISPEL);
         std::list<SpellScript::EffectHandler>::iterator hookItrEnd = (*scritr)->OnEffectSuccessfulDispel.end(), hookItr = (*scritr)->OnEffectSuccessfulDispel.begin();
         for (; hookItr != hookItrEnd; ++hookItr)
             hookItr->Call(*scritr, effIndex);
 
         (*scritr)->_FinishScriptCall();
     }
 }

Here is the caller graph for this function:

bool Spell::CanAutoCast ( Unit * target )

 {
     ObjectGuid targetguid = target->GetGUID();
 
     for (SpellEffectInfo const* effect : GetEffects())
     {
         if (!effect)
             continue;
 
         if (effect->Effect == SPELL_EFFECT_APPLY_AURA)
         {
             if (m_spellInfo->StackAmount <= 1)
             {
                 if (target->HasAuraEffect(m_spellInfo->Id, effect->EffectIndex))
                     return false;
             }
             else
             {
                 if (AuraEffect* aureff = target->GetAuraEffect(m_spellInfo->Id, effect->EffectIndex))
                     if (aureff->GetBase()->GetStackAmount() >= m_spellInfo->StackAmount)
                         return false;
             }
         }
         else if (effect->IsAreaAuraEffect())
         {
             if (target->HasAuraEffect(m_spellInfo->Id, effect->EffectIndex))
                 return false;
         }
     }
 
     SpellCastResult result = CheckPetCast(target);
 
     if (result == SPELL_CAST_OK || result == SPELL_FAILED_UNIT_NOT_INFRONT)
     {
         SelectSpellTargets();
         //check if among target units, our WANTED target is as well (->only self cast spells return false)
         for (std::vector<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
             if (ihit->targetGUID == targetguid)
                 return true;
     }
     return false;                                           //target invalid
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::cancel ( )

 {
     if (m_spellState == SPELL_STATE_FINISHED)
         return;
     // delayed instant casts are used for client-side visual orientation; they are treated as instant for all intents and purposes server-side, and thus cannot be interrupted by another cast
     if (m_isDelayedInstantCast)
         return;
 
     uint32 oldState = m_spellState;
     m_spellState = SPELL_STATE_FINISHED;
 
     m_autoRepeat = false;
     switch (oldState)
     {
         case SPELL_STATE_PREPARING:
             CancelGlobalCooldown();
             if (m_caster->GetTypeId() == TYPEID_PLAYER)
                 m_caster->ToPlayer()->RestoreSpellMods(this);
             // no break
         case SPELL_STATE_DELAYED:
             SendInterrupted(0);
             SendCastResult(SPELL_FAILED_INTERRUPTED);
             break;
 
         case SPELL_STATE_CASTING:
             for (std::vector<TargetInfo>::const_iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
                 if ((*ihit).missCondition == SPELL_MISS_NONE)
                     if (Unit* unit = m_caster->GetGUID() == ihit->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, ihit->targetGUID))
                         unit->RemoveOwnedAura(m_spellInfo->Id, m_originalCasterGUID, 0, AURA_REMOVE_BY_CANCEL);
 
             SendChannelUpdate(0);
             SendInterrupted(0);
             SendCastResult(SPELL_FAILED_INTERRUPTED);
 
             // spell is canceled-take mods and clear list
             if (m_caster->GetTypeId() == TYPEID_PLAYER)
                 m_caster->ToPlayer()->RemoveSpellMods(this);
 
             m_appliedMods.clear();
             break;
 
         default:
             break;
     }
 
     SetReferencedFromCurrent(false);
     if (m_selfContainer && *m_selfContainer == this)
         *m_selfContainer = NULL;
 
     m_caster->RemoveDynObject(m_spellInfo->Id);
     if (m_spellInfo->IsChanneled()) // if not channeled then the object for the current cast wasn't summoned yet
         m_caster->RemoveGameObject(m_spellInfo->Id, true);
 
     //set state back so finish will be processed
     m_spellState = oldState;
 
     finish(false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::CancelGlobalCooldown ( )

protected

 {
     if (!m_spellInfo->StartRecoveryTime)
         return;
 
     // Cancel global cooldown when interrupting current cast
     if (m_caster->GetCurrentSpell(CURRENT_GENERIC_SPELL) != this)
         return;
 
     // Only players or controlled units have global cooldown
     if (m_caster->GetTypeId() != TYPEID_PLAYER && !m_caster->GetCharmInfo())
         return;
 
     m_caster->GetSpellHistory()->CancelGlobalCooldown(m_spellInfo);
 }

Here is the caller graph for this function:

bool Spell::CanExecuteTriggersOnHit	(	uint8	effMask,
		SpellInfo const *	triggeredByAura = `NULL`
	)		const

protected

 {
     bool only_on_caster = (triggeredByAura && (triggeredByAura->HasAttribute(SPELL_ATTR4_PROC_ONLY_ON_CASTER)));
     // If triggeredByAura has SPELL_ATTR4_PROC_ONLY_ON_CASTER then it can only proc on a cast spell with TARGET_UNIT_CASTER
     for (SpellEffectInfo const* effect : GetEffects())
     {
         if (effect && ((effMask & (1 << effect->EffectIndex)) && (!only_on_caster || (effect->TargetA.GetTarget() == TARGET_UNIT_CASTER))))
             return true;
     }
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SpellCastResult Spell::CanOpenLock	(	uint32	effIndex,
		uint32	lockid,
		SkillType &	skillid,
		int32 &	reqSkillValue,
		int32 &	skillValue
	)

protected

 {
     if (!lockId)                                             // possible case for GO and maybe for items.
         return SPELL_CAST_OK;
 
     // Get LockInfo
     LockEntry const* lockInfo = sLockStore.LookupEntry(lockId);
 
     if (!lockInfo)
         return SPELL_FAILED_BAD_TARGETS;
 
     SpellEffectInfo const* effect = GetEffect(effIndex);
     if (!effect)
         return SPELL_FAILED_BAD_TARGETS; // no idea about correct error
 
     bool reqKey = false;                                    // some locks not have reqs
 
     for (int j = 0; j < MAX_LOCK_CASE; ++j)
     {
         switch (lockInfo->Type[j])
         {
             // check key item (many fit cases can be)
             case LOCK_KEY_ITEM:
                 if (lockInfo->Index[j] && m_CastItem && m_CastItem->GetEntry() == lockInfo->Index[j])
                     return SPELL_CAST_OK;
                 reqKey = true;
                 break;
                 // check key skill (only single first fit case can be)
             case LOCK_KEY_SKILL:
             {
                 reqKey = true;
 
                 // wrong locktype, skip
                 if (uint32(effect->MiscValue) != lockInfo->Index[j])
                     continue;
 
                 skillId = SkillByLockType(LockType(lockInfo->Index[j]));
 
                 if (skillId != SKILL_NONE)
                 {
                     reqSkillValue = lockInfo->Skill[j];
 
                     // castitem check: rogue using skeleton keys. the skill values should not be added in this case.
                     skillValue = m_CastItem || m_caster->GetTypeId()!= TYPEID_PLAYER ?
                         0 : m_caster->ToPlayer()->GetSkillValue(skillId);
 
                     // skill bonus provided by casting spell (mostly item spells)
                     // add the effect base points modifier from the spell cast (cheat lock / skeleton key etc.)
                     if (effect->TargetA.GetTarget() == TARGET_GAMEOBJECT_ITEM_TARGET || effect->TargetB.GetTarget() == TARGET_GAMEOBJECT_ITEM_TARGET)
                         skillValue += effect->CalcValue();
 
                     if (skillValue < reqSkillValue)
                         return SPELL_FAILED_LOW_CASTLEVEL;
                 }
 
                 return SPELL_CAST_OK;
             }
         }
     }
 
     if (reqKey)
         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:

void Spell::cast ( bool skipCheck = false )

Not own traded item (in trader trade slot) req. reagents including triggered spell case

 {
     // update pointers base at GUIDs to prevent access to non-existed already object
     if (!UpdatePointers())
     {
         // cancel the spell if UpdatePointers() returned false, something wrong happened there
         cancel();
         return;
     }
 
     // cancel at lost explicit target during cast
     if (!m_targets.GetObjectTargetGUID().IsEmpty() && !m_targets.GetObjectTarget())
     {
         cancel();
         return;
     }
 
     if (m_isDelayedInstantCast)
         SendSpellStart();
 
     if (Player* playerCaster = m_caster->ToPlayer())
     {
         // now that we've done the basic check, now run the scripts
         // should be done before the spell is actually executed
         sScriptMgr->OnPlayerSpellCast(playerCaster, this, skipCheck);
 
         // As of 3.0.2 pets begin attacking their owner's target immediately
         // Let any pets know we've attacked something. Check DmgClass for harmful spells only
         // This prevents spells such as Hunter's Mark from triggering pet attack
         if (this->GetSpellInfo()->DmgClass != SPELL_DAMAGE_CLASS_NONE)
             if (Pet* playerPet = playerCaster->GetPet())
                 if (playerPet->IsAlive() && playerPet->isControlled() && (m_targets.GetTargetMask() & TARGET_FLAG_UNIT))
                     playerPet->AI()->OwnerAttacked(m_targets.GetUnitTarget());
     }
 
     SetExecutedCurrently(true);
 
     if (!(_triggeredCastFlags & TRIGGERED_IGNORE_SET_FACING))
         if (m_caster->GetTypeId() == TYPEID_UNIT && m_targets.GetObjectTarget() && m_caster != m_targets.GetObjectTarget())
             m_caster->SetInFront(m_targets.GetObjectTarget());
 
     // Should this be done for original caster?
     if (m_caster->GetTypeId() == TYPEID_PLAYER)
     {
         // Set spell which will drop charges for triggered cast spells
         // if not successfully cast, will be remove in finish(false)
         m_caster->ToPlayer()->SetSpellModTakingSpell(this, true);
     }
 
     CallScriptBeforeCastHandlers();
 
     // skip check if done already (for instant cast spells for example)
     if (!skipCheck)
     {
         SpellCastResult castResult = CheckCast(false);
         if (castResult != SPELL_CAST_OK)
         {
             SendCastResult(castResult);
             SendInterrupted(0);
             //restore spell mods
             if (m_caster->GetTypeId() == TYPEID_PLAYER)
             {
                 m_caster->ToPlayer()->RestoreSpellMods(this);
                 // cleanup after mod system
                 // triggered spell pointer can be not removed in some cases
                 m_caster->ToPlayer()->SetSpellModTakingSpell(this, false);
             }
             finish(false);
             SetExecutedCurrently(false);
             return;
         }
 
         // additional check after cast bar completes (must not be in CheckCast)
         // if trade not complete then remember it in trade data
         if (m_targets.GetTargetMask() & TARGET_FLAG_TRADE_ITEM)
         {
             if (m_caster->GetTypeId() == TYPEID_PLAYER)
             {
                 if (TradeData* my_trade = m_caster->ToPlayer()->GetTradeData())
                 {
                     if (!my_trade->IsInAcceptProcess())
                     {
                         // Spell will be cast after completing the trade. Silently ignore at this place
                         my_trade->SetSpell(m_spellInfo->Id, m_CastItem);
                         SendCastResult(SPELL_FAILED_DONT_REPORT);
                         SendInterrupted(0);
                         m_caster->ToPlayer()->RestoreSpellMods(this);
                         // cleanup after mod system
                         // triggered spell pointer can be not removed in some cases
                         m_caster->ToPlayer()->SetSpellModTakingSpell(this, false);
                         finish(false);
                         SetExecutedCurrently(false);
                         return;
                     }
                 }
             }
         }
     }
 
     // if the spell allows the creature to turn while casting, then adjust server-side orientation to face the target now
     // client-side orientation is handled by the client itself, as the cast target is targeted due to Creature::FocusTarget
     if (m_caster->GetTypeId() == TYPEID_UNIT && !m_caster->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PLAYER_CONTROLLED))
         if (!m_spellInfo->HasAttribute(SPELL_ATTR5_DONT_TURN_DURING_CAST))
             if (WorldObject* objTarget = m_targets.GetObjectTarget())
             {
                 m_caster->SetInFront(objTarget);
                 m_caster->SetFacingToObject(objTarget);
             }
 
     SelectSpellTargets();
 
     // Spell may be finished after target map check
     if (m_spellState == SPELL_STATE_FINISHED)
     {
         SendInterrupted(0);
         //restore spell mods
         if (m_caster->GetTypeId() == TYPEID_PLAYER)
         {
             m_caster->ToPlayer()->RestoreSpellMods(this);
             // cleanup after mod system
             // triggered spell pointer can be not removed in some cases
             m_caster->ToPlayer()->SetSpellModTakingSpell(this, false);
         }
         finish(false);
         SetExecutedCurrently(false);
         return;
     }
 
     PrepareTriggersExecutedOnHit();
 
     CallScriptOnCastHandlers();
 
     // traded items have trade slot instead of guid in m_itemTargetGUID
     // set to real guid to be sent later to the client
     m_targets.UpdateTradeSlotItem();
 
     if (Player* player = m_caster->ToPlayer())
     {
         if (!(_triggeredCastFlags & TRIGGERED_IGNORE_CAST_ITEM) && m_CastItem)
         {
             player->StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_ITEM, m_CastItem->GetEntry());
             player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM, m_CastItem->GetEntry());
         }
 
         player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL, m_spellInfo->Id);
     }
 
     if (!(_triggeredCastFlags & TRIGGERED_IGNORE_POWER_AND_REAGENT_COST))
     {
         // Powers have to be taken before SendSpellGo
         TakePower();
         TakeReagents();                                         // we must remove reagents before HandleEffects to allow place crafted item in same slot
     }
     else if (Item* targetItem = m_targets.GetItemTarget())
     {
         if (targetItem->GetOwnerGUID() != m_caster->GetGUID())
             TakeReagents();
     }
 
     // CAST SPELL
     SendSpellCooldown();
 
     PrepareScriptHitHandlers();
 
     HandleLaunchPhase();
 
     // we must send smsg_spell_go packet before m_castItem delete in TakeCastItem()...
     SendSpellGo();
 
     // Okay, everything is prepared. Now we need to distinguish between immediate and evented delayed spells
     if ((m_spellInfo->Speed > 0.0f && !m_spellInfo->IsChanneled()) || m_spellInfo->HasAttribute(SPELL_ATTR4_UNK4))
     {
         // Remove used for cast item if need (it can be already NULL after TakeReagents call
         // in case delayed spell remove item at cast delay start
         TakeCastItem();
 
         // Okay, maps created, now prepare flags
         m_immediateHandled = false;
         m_spellState = SPELL_STATE_DELAYED;
         SetDelayStart(0);
 
         if (m_caster->HasUnitState(UNIT_STATE_CASTING) && !m_caster->IsNonMeleeSpellCast(false, false, true))
             m_caster->ClearUnitState(UNIT_STATE_CASTING);
     }
     else
     {
         // Immediate spell, no big deal
         handle_immediate();
     }
 
     CallScriptAfterCastHandlers();
 
     if (const std::vector<int32> *spell_triggered = sSpellMgr->GetSpellLinked(m_spellInfo->Id))
     {
         for (std::vector<int32>::const_iterator i = spell_triggered->begin(); i != spell_triggered->end(); ++i)
             if (*i < 0)
                 m_caster->RemoveAurasDueToSpell(-(*i));
             else
                 m_caster->CastSpell(m_targets.GetUnitTarget() ? m_targets.GetUnitTarget() : m_caster, *i, true);
     }
 
     if (m_caster->GetTypeId() == TYPEID_PLAYER)
     {
         m_caster->ToPlayer()->SetSpellModTakingSpell(this, false);
 
         //Clear spell cooldowns after every spell is cast if .cheat cooldown is enabled.
         if (m_caster->ToPlayer()->GetCommandStatus(CHEAT_COOLDOWN))
         {
             m_caster->GetSpellHistory()->ResetCooldown(m_spellInfo->Id, true);
             m_caster->GetSpellHistory()->RestoreCharge(m_spellInfo->ChargeCategoryEntry);
         }
     }
 
     SetExecutedCurrently(false);
 
     if (Creature* creatureCaster = m_caster->ToCreature())
         creatureCaster->ReleaseFocus(this);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SpellCastResult Spell::CheckArenaAndRatedBattlegroundCastRules ( )

 {
     bool isRatedBattleground = false; // NYI
     bool isArena = !isRatedBattleground;
 
     // check USABLE attributes
     // USABLE takes precedence over NOT_USABLE
     if (isRatedBattleground && m_spellInfo->HasAttribute(SPELL_ATTR9_USABLE_IN_RATED_BATTLEGROUNDS))
         return SPELL_CAST_OK;
 
     if (isArena && m_spellInfo->HasAttribute(SPELL_ATTR4_USABLE_IN_ARENA))
         return SPELL_CAST_OK;
 
     // check NOT_USABLE attributes
     if (m_spellInfo->HasAttribute(SPELL_ATTR4_NOT_USABLE_IN_ARENA_OR_RATED_BG))
         return isArena ? SPELL_FAILED_NOT_IN_ARENA : SPELL_FAILED_NOT_IN_RATED_BATTLEGROUND;
 
     if (isArena && m_spellInfo->HasAttribute(SPELL_ATTR9_NOT_USABLE_IN_ARENA))
             return SPELL_FAILED_NOT_IN_ARENA;
 
     // check cooldowns
     uint32 spellCooldown = m_spellInfo->GetRecoveryTime();
     if (isArena && spellCooldown > 10 * MINUTE * IN_MILLISECONDS) // not sure if still needed
         return SPELL_FAILED_NOT_IN_ARENA;
 
     if (isRatedBattleground && spellCooldown > 15 * MINUTE * IN_MILLISECONDS)
         return SPELL_FAILED_NOT_IN_RATED_BATTLEGROUND;
 
     return SPELL_CAST_OK;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SpellCastResult Spell::CheckCast ( bool strict )

Todo:: determine if there is some flag to enable/disable the check

 {
     // check death state
     if (!m_caster->IsAlive() && !m_spellInfo->HasAttribute(SPELL_ATTR0_PASSIVE) && !((m_spellInfo->HasAttribute(SPELL_ATTR0_CASTABLE_WHILE_DEAD)) || (IsTriggered() && !m_triggeredByAuraSpell)))
         return SPELL_FAILED_CASTER_DEAD;
 
     // check cooldowns to prevent cheating
     if (!m_spellInfo->IsPassive())
     {
         if (m_caster->GetTypeId() == TYPEID_PLAYER)
         {
             //can cast triggered (by aura only?) spells while have this flag
             if (!(_triggeredCastFlags & TRIGGERED_IGNORE_CASTER_AURASTATE) && m_caster->ToPlayer()->HasFlag(PLAYER_FLAGS, PLAYER_ALLOW_ONLY_ABILITY))
                 return SPELL_FAILED_SPELL_IN_PROGRESS;
 
             // check if we are using a potion in combat for the 2nd+ time. Cooldown is added only after caster gets out of combat
             if (m_caster->ToPlayer()->GetLastPotionId() && m_CastItem && (m_CastItem->IsPotion() || m_spellInfo->IsCooldownStartedOnEvent()))
                 return SPELL_FAILED_NOT_READY;
         }
 
         if (!m_caster->GetSpellHistory()->IsReady(m_spellInfo, m_castItemEntry, IsIgnoringCooldowns()))
         {
             if (m_triggeredByAuraSpell)
                 return SPELL_FAILED_DONT_REPORT;
             else
                 return SPELL_FAILED_NOT_READY;
         }
     }
 
     if (m_spellInfo->HasAttribute(SPELL_ATTR7_IS_CHEAT_SPELL) && !m_caster->HasFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_ALLOW_CHEAT_SPELLS))
     {
         m_customError = SPELL_CUSTOM_ERROR_GM_ONLY;
         return SPELL_FAILED_CUSTOM_ERROR;
     }
 
     // Check global cooldown
     if (strict && !(_triggeredCastFlags & TRIGGERED_IGNORE_GCD) && HasGlobalCooldown())
         return SPELL_FAILED_NOT_READY;
 
     // only triggered spells can be processed an ended battleground
     if (!IsTriggered() && m_caster->GetTypeId() == TYPEID_PLAYER)
         if (Battleground* bg = m_caster->ToPlayer()->GetBattleground())
             if (bg->GetStatus() == STATUS_WAIT_LEAVE)
                 return SPELL_FAILED_DONT_REPORT;
 
     if (m_caster->GetTypeId() == TYPEID_PLAYER && VMAP::VMapFactory::createOrGetVMapManager()->isLineOfSightCalcEnabled())
     {
         if (m_spellInfo->HasAttribute(SPELL_ATTR0_OUTDOORS_ONLY) &&
                 !m_caster->GetMap()->IsOutdoors(m_caster->GetPositionX(), m_caster->GetPositionY(), m_caster->GetPositionZ()))
             return SPELL_FAILED_ONLY_OUTDOORS;
 
         if (m_spellInfo->HasAttribute(SPELL_ATTR0_INDOORS_ONLY) &&
                 m_caster->GetMap()->IsOutdoors(m_caster->GetPositionX(), m_caster->GetPositionY(), m_caster->GetPositionZ()))
             return SPELL_FAILED_ONLY_INDOORS;
     }
 
     // only check at first call, Stealth auras are already removed at second call
     // for now, ignore triggered spells
     if (strict && !(_triggeredCastFlags & TRIGGERED_IGNORE_SHAPESHIFT))
     {
         bool checkForm = true;
         // Ignore form req aura
         Unit::AuraEffectList const& ignore = m_caster->GetAuraEffectsByType(SPELL_AURA_MOD_IGNORE_SHAPESHIFT);
         for (Unit::AuraEffectList::const_iterator i = ignore.begin(); i != ignore.end(); ++i)
         {
             if (!(*i)->IsAffectingSpell(m_spellInfo))
                 continue;
             checkForm = false;
             break;
         }
         if (checkForm)
         {
             // Cannot be used in this stance/form
             SpellCastResult shapeError = m_spellInfo->CheckShapeshift(m_caster->GetShapeshiftForm());
             if (shapeError != SPELL_CAST_OK)
                 return shapeError;
 
             if ((m_spellInfo->HasAttribute(SPELL_ATTR0_ONLY_STEALTHED)) && !(m_caster->HasStealthAura()))
                 return SPELL_FAILED_ONLY_STEALTHED;
         }
     }
 
     Unit::AuraEffectList const& blockSpells = m_caster->GetAuraEffectsByType(SPELL_AURA_BLOCK_SPELL_FAMILY);
     for (Unit::AuraEffectList::const_iterator blockItr = blockSpells.begin(); blockItr != blockSpells.end(); ++blockItr)
         if (uint32((*blockItr)->GetMiscValue()) == m_spellInfo->SpellFamilyName)
             return SPELL_FAILED_SPELL_UNAVAILABLE;
 
     bool reqCombat = true;
     Unit::AuraEffectList const& stateAuras = m_caster->GetAuraEffectsByType(SPELL_AURA_ABILITY_IGNORE_AURASTATE);
     for (Unit::AuraEffectList::const_iterator j = stateAuras.begin(); j != stateAuras.end(); ++j)
     {
         if ((*j)->IsAffectingSpell(m_spellInfo))
         {
             m_needComboPoints = false;
             if ((*j)->GetMiscValue() == 1)
             {
                 reqCombat=false;
                 break;
             }
         }
     }
 
     // caster state requirements
     // not for triggered spells (needed by execute)
     if (!(_triggeredCastFlags & TRIGGERED_IGNORE_CASTER_AURASTATE))
     {
         if (m_spellInfo->CasterAuraState && !m_caster->HasAuraState(AuraStateType(m_spellInfo->CasterAuraState), m_spellInfo, m_caster))
             return SPELL_FAILED_CASTER_AURASTATE;
         if (m_spellInfo->ExcludeCasterAuraState && m_caster->HasAuraState(AuraStateType(m_spellInfo->ExcludeCasterAuraState), m_spellInfo, m_caster))
             return SPELL_FAILED_CASTER_AURASTATE;
 
         // Note: spell 62473 requres casterAuraSpell = triggering spell
         if (m_spellInfo->CasterAuraSpell && !m_caster->HasAura(m_spellInfo->CasterAuraSpell))
             return SPELL_FAILED_CASTER_AURASTATE;
         if (m_spellInfo->ExcludeCasterAuraSpell && m_caster->HasAura(m_spellInfo->ExcludeCasterAuraSpell))
             return SPELL_FAILED_CASTER_AURASTATE;
 
         if (reqCombat && m_caster->IsInCombat() && !m_spellInfo->CanBeUsedInCombat())
             return SPELL_FAILED_AFFECTING_COMBAT;
     }
 
     // cancel autorepeat spells if cast start when moving
     // (not wand currently autorepeat cast delayed to moving stop anyway in spell update code)
     // Do not cancel spells which are affected by a SPELL_AURA_CAST_WHILE_WALKING effect
     if (m_caster->GetTypeId() == TYPEID_PLAYER && m_caster->ToPlayer()->isMoving() && !m_caster->HasAuraTypeWithAffectMask(SPELL_AURA_CAST_WHILE_WALKING, m_spellInfo))
     {
         // skip stuck spell to allow use it in falling case and apply spell limitations at movement
         SpellEffectInfo const* effect = GetEffect(EFFECT_0);
         if ((!m_caster->HasUnitMovementFlag(MOVEMENTFLAG_FALLING_FAR) || (effect && effect->Effect != SPELL_EFFECT_STUCK)) &&
             (IsAutoRepeat() || (m_spellInfo->AuraInterruptFlags & AURA_INTERRUPT_FLAG_NOT_SEATED) != 0))
             return SPELL_FAILED_MOVING;
     }
 
     // Check vehicle flags
     if (!(_triggeredCastFlags & TRIGGERED_IGNORE_CASTER_MOUNTED_OR_ON_VEHICLE))
     {
         SpellCastResult vehicleCheck = m_spellInfo->CheckVehicle(m_caster);
         if (vehicleCheck != SPELL_CAST_OK)
             return vehicleCheck;
     }
 
     // check spell cast conditions from database
     {
         ConditionSourceInfo condInfo = ConditionSourceInfo(m_caster, m_targets.GetObjectTarget());
         if (!sConditionMgr->IsObjectMeetingNotGroupedConditions(CONDITION_SOURCE_TYPE_SPELL, m_spellInfo->Id, condInfo))
         {
             // mLastFailedCondition can be NULL if there was an error processing the condition in Condition::Meets (i.e. wrong data for ConditionTarget or others)
             if (condInfo.mLastFailedCondition && condInfo.mLastFailedCondition->ErrorType)
             {
                 if (condInfo.mLastFailedCondition->ErrorType == SPELL_FAILED_CUSTOM_ERROR)
                     m_customError = SpellCustomErrors(condInfo.mLastFailedCondition->ErrorTextId);
                 return SpellCastResult(condInfo.mLastFailedCondition->ErrorType);
             }
             if (!condInfo.mLastFailedCondition || !condInfo.mLastFailedCondition->ConditionTarget)
                 return SPELL_FAILED_CASTER_AURASTATE;
             return SPELL_FAILED_BAD_TARGETS;
         }
     }
 
     // Don't check explicit target for passive spells (workaround) (check should be skipped only for learn case)
     // those spells may have incorrect target entries or not filled at all (for example 15332)
     // such spells when learned are not targeting anyone using targeting system, they should apply directly to caster instead
     // also, such casts shouldn't be sent to client
     if (!((m_spellInfo->HasAttribute(SPELL_ATTR0_PASSIVE)) && (!m_targets.GetUnitTarget() || m_targets.GetUnitTarget() == m_caster)))
     {
         // Check explicit target for m_originalCaster - todo: get rid of such workarounds
         SpellCastResult castResult = m_spellInfo->CheckExplicitTarget(m_originalCaster ? m_originalCaster : m_caster, m_targets.GetObjectTarget(), m_targets.GetItemTarget());
         if (castResult != SPELL_CAST_OK)
             return castResult;
     }
 
     if (Unit* target = m_targets.GetUnitTarget())
     {
         SpellCastResult castResult = m_spellInfo->CheckTarget(m_caster, target, false);
         if (castResult != SPELL_CAST_OK)
             return castResult;
 
         if (target != m_caster)
         {
             // Must be behind the target
             if ((m_spellInfo->HasAttribute(SPELL_ATTR0_CU_REQ_CASTER_BEHIND_TARGET)) && target->HasInArc(static_cast<float>(M_PI), m_caster))
                 return SPELL_FAILED_NOT_BEHIND;
 
             // Target must be facing you
             if ((m_spellInfo->HasAttribute(SPELL_ATTR0_CU_REQ_TARGET_FACING_CASTER)) && !target->HasInArc(static_cast<float>(M_PI), m_caster))
                 return SPELL_FAILED_NOT_INFRONT;
 
             if (m_caster->GetEntry() != WORLD_TRIGGER) // Ignore LOS for gameobjects casts (wrongly cast by a trigger)
             {
                 WorldObject* losTarget = m_caster;
                 if (IsTriggered() && m_triggeredByAuraSpell)
                     if (DynamicObject* dynObj = m_caster->GetDynObject(m_triggeredByAuraSpell->Id))
                         losTarget = dynObj;
 
                 if (!m_spellInfo->HasAttribute(SPELL_ATTR2_CAN_TARGET_NOT_IN_LOS) && !DisableMgr::IsDisabledFor(DISABLE_TYPE_SPELL, m_spellInfo->Id, NULL, SPELL_DISABLE_LOS) && !target->IsWithinLOSInMap(losTarget))
                     return SPELL_FAILED_LINE_OF_SIGHT;
             }
         }
     }
 
     // Check for line of sight for spells with dest
     if (m_targets.HasDst())
     {
         float x, y, z;
         m_targets.GetDstPos()->GetPosition(x, y, z);
 
         if (!m_spellInfo->HasAttribute(SPELL_ATTR2_CAN_TARGET_NOT_IN_LOS) && !DisableMgr::IsDisabledFor(DISABLE_TYPE_SPELL, m_spellInfo->Id, NULL, SPELL_DISABLE_LOS) && !m_caster->IsWithinLOS(x, y, z))
             return SPELL_FAILED_LINE_OF_SIGHT;
     }
 
     // check pet presence
     for (SpellEffectInfo const* effect : GetEffects())
     {
         if (effect && effect->TargetA.GetTarget() == TARGET_UNIT_PET)
         {
             if (!m_caster->GetGuardianPet())
             {
                 if (m_triggeredByAuraSpell)              // not report pet not existence for triggered spells
                     return SPELL_FAILED_DONT_REPORT;
                 else
                     return SPELL_FAILED_NO_PET;
             }
             break;
         }
     }
 
     // Spell cast only in battleground
     if ((m_spellInfo->HasAttribute(SPELL_ATTR3_BATTLEGROUND)) &&  m_caster->GetTypeId() == TYPEID_PLAYER)
         if (!m_caster->ToPlayer()->InBattleground())
             return SPELL_FAILED_ONLY_BATTLEGROUNDS;
 
     // do not allow spells to be cast in arenas or rated battlegrounds
     if (Player* player = m_caster->ToPlayer())
         if (player->InArena()/* || player->InRatedBattleGround() NYI*/)
         {
             SpellCastResult castResult = CheckArenaAndRatedBattlegroundCastRules();
             if (castResult != SPELL_CAST_OK)
                 return castResult;
         }
 
     // zone check
     if (m_caster->GetTypeId() == TYPEID_UNIT || !m_caster->ToPlayer()->IsGameMaster())
     {
         uint32 zone, area;
         m_caster->GetZoneAndAreaId(zone, area);
 
         SpellCastResult locRes = m_spellInfo->CheckLocation(m_caster->GetMapId(), zone, area, m_caster->ToPlayer());
         if (locRes != SPELL_CAST_OK)
             return locRes;
     }
 
     // not let players cast spells at mount (and let do it to creatures)
     if (m_caster->IsMounted() && m_caster->GetTypeId() == TYPEID_PLAYER && !(_triggeredCastFlags & TRIGGERED_IGNORE_CASTER_MOUNTED_OR_ON_VEHICLE) &&
         !m_spellInfo->IsPassive() && !m_spellInfo->HasAttribute(SPELL_ATTR0_CASTABLE_WHILE_MOUNTED))
     {
         if (m_caster->IsInFlight())
             return SPELL_FAILED_NOT_ON_TAXI;
         else
             return SPELL_FAILED_NOT_MOUNTED;
     }
 
     // check spell focus object
     if (m_spellInfo->RequiresSpellFocus)
     {
         focusObject = SearchSpellFocus();
         if (!focusObject)
             return SPELL_FAILED_REQUIRES_SPELL_FOCUS;
     }
 
     SpellCastResult castResult = SPELL_CAST_OK;
 
     // always (except passive spells) check items (only player related checks)
     if (!m_spellInfo->IsPassive())
     {
         castResult = CheckItems();
         if (castResult != SPELL_CAST_OK)
             return castResult;
     }
 
     // Triggered spells also have range check
     castResult = CheckRange(strict);
     if (castResult != SPELL_CAST_OK)
         return castResult;
 
     if (!(_triggeredCastFlags & TRIGGERED_IGNORE_POWER_AND_REAGENT_COST))
     {
         castResult = CheckPower();
         if (castResult != SPELL_CAST_OK)
             return castResult;
     }
 
     if (!(_triggeredCastFlags & TRIGGERED_IGNORE_CASTER_AURAS))
     {
         castResult = CheckCasterAuras();
         if (castResult != SPELL_CAST_OK)
             return castResult;
     }
 
     // script hook
     castResult = CallScriptCheckCastHandlers();
     if (castResult != SPELL_CAST_OK)
         return castResult;
 
     for (SpellEffectInfo const* effect : GetEffects())
     {
         if (!effect)
             continue;
         // for effects of spells that have only one target
         switch (effect->Effect)
         {
             case SPELL_EFFECT_DUMMY:
             {
                 if (m_spellInfo->Id == 19938)          // Awaken Peon
                 {
                     Unit* unit = m_targets.GetUnitTarget();
                     if (!unit || !unit->HasAura(17743))
                         return SPELL_FAILED_BAD_TARGETS;
                 }
                 else if (m_spellInfo->Id == 31789)          // Righteous Defense
                 {
                     if (m_caster->GetTypeId() != TYPEID_PLAYER)
                         return SPELL_FAILED_DONT_REPORT;
 
                     Unit* target = m_targets.GetUnitTarget();
                     if (!target || !target->IsFriendlyTo(m_caster) || target->getAttackers().empty())
                         return SPELL_FAILED_BAD_TARGETS;
 
                 }
                 break;
             }
             case SPELL_EFFECT_LEARN_SPELL:
             {
                 if (m_caster->GetTypeId() != TYPEID_PLAYER)
                     return SPELL_FAILED_BAD_TARGETS;
 
                 if (effect->TargetA.GetTarget() != TARGET_UNIT_PET)
                     break;
 
                 Pet* pet = m_caster->ToPlayer()->GetPet();
 
                 if (!pet)
                     return SPELL_FAILED_NO_PET;
 
                 SpellInfo const* learn_spellproto = sSpellMgr->GetSpellInfo(effect->TriggerSpell);
 
                 if (!learn_spellproto)
                     return SPELL_FAILED_NOT_KNOWN;
 
                 if (m_spellInfo->SpellLevel > pet->getLevel())
                     return SPELL_FAILED_LOWLEVEL;
 
                 break;
             }
             case SPELL_EFFECT_UNLOCK_GUILD_VAULT_TAB:
             {
                 if (m_caster->GetTypeId() != TYPEID_PLAYER)
                     return SPELL_FAILED_BAD_TARGETS;
                 if (Guild* guild = m_caster->ToPlayer()->GetGuild())
                     if (guild->GetLeaderGUID() != m_caster->ToPlayer()->GetGUID())
                         return SPELL_FAILED_CANT_DO_THAT_RIGHT_NOW;
                 break;
             }
             case SPELL_EFFECT_LEARN_PET_SPELL:
             {
                 // check target only for unit target case
                 if (Unit* unit = m_targets.GetUnitTarget())
                 {
                     if (m_caster->GetTypeId() != TYPEID_PLAYER)
                         return SPELL_FAILED_BAD_TARGETS;
 
                     Pet* pet = unit->ToPet();
                     if (!pet || pet->GetOwner() != m_caster)
                         return SPELL_FAILED_BAD_TARGETS;
 
                     SpellInfo const* learn_spellproto = sSpellMgr->GetSpellInfo(effect->TriggerSpell);
 
                     if (!learn_spellproto)
                         return SPELL_FAILED_NOT_KNOWN;
 
                     if (m_spellInfo->SpellLevel > pet->getLevel())
                         return SPELL_FAILED_LOWLEVEL;
                 }
                 break;
             }
             case SPELL_EFFECT_APPLY_GLYPH:
             {
                 uint32 glyphId = effect->MiscValue;
                 if (GlyphPropertiesEntry const* gp = sGlyphPropertiesStore.LookupEntry(glyphId))
                     if (m_caster->HasAura(gp->SpellID))
                         return SPELL_FAILED_UNIQUE_GLYPH;
                 break;
             }
             case SPELL_EFFECT_FEED_PET:
             {
                 if (m_caster->GetTypeId() != TYPEID_PLAYER)
                     return SPELL_FAILED_BAD_TARGETS;
 
                 Item* foodItem = m_targets.GetItemTarget();
                 if (!foodItem)
                     return SPELL_FAILED_BAD_TARGETS;
 
                 Pet* pet = m_caster->ToPlayer()->GetPet();
 
                 if (!pet)
                     return SPELL_FAILED_NO_PET;
 
                 if (!pet->HaveInDiet(foodItem->GetTemplate()))
                     return SPELL_FAILED_WRONG_PET_FOOD;
 
                 if (!pet->GetCurrentFoodBenefitLevel(foodItem->GetTemplate()->GetBaseItemLevel()))
                     return SPELL_FAILED_FOOD_LOWLEVEL;
 
                 if (m_caster->IsInCombat() || pet->IsInCombat())
                     return SPELL_FAILED_AFFECTING_COMBAT;
 
                 break;
             }
             case SPELL_EFFECT_POWER_BURN:
             case SPELL_EFFECT_POWER_DRAIN:
             {
                 // Can be area effect, Check only for players and not check if target - caster (spell can have multiply drain/burn effects)
                 if (m_caster->GetTypeId() == TYPEID_PLAYER)
                     if (Unit* target = m_targets.GetUnitTarget())
                         if (target != m_caster && target->getPowerType() != Powers(effect->MiscValue))
                             return SPELL_FAILED_BAD_TARGETS;
                 break;
             }
             case SPELL_EFFECT_CHARGE:
             
                 if (m_spellInfo->SpellFamilyName == SPELLFAMILY_WARRIOR)
                 {
                     // Warbringer - can't be handled in proc system - should be done before checkcast root check and charge effect process
                     if (strict && m_caster->IsScriptOverriden(m_spellInfo, 6953))
                         m_caster->RemoveMovementImpairingAuras();
                 }
 
                 if (m_caster->HasUnitState(UNIT_STATE_ROOT))
                     return SPELL_FAILED_ROOTED;
 
                 if (GetSpellInfo()->NeedsExplicitUnitTarget())
                 {
                     Unit* target = m_targets.GetUnitTarget();
                     if (!target)
                         return SPELL_FAILED_DONT_REPORT;
 
                     float objSize = target->GetObjectSize();
                     float range = m_spellInfo->GetMaxRange(true, m_caster, this) * 1.5f + objSize; // can't be overly strict
 
                     m_preGeneratedPath.SetPathLengthLimit(range);
                     // first try with raycast, if it fails fall back to normal path
                     float targetObjectSize = std::min(target->GetObjectSize(), 4.0f);
                     bool result = m_preGeneratedPath.CalculatePath(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ() + targetObjectSize, false, true);
                     if (m_preGeneratedPath.GetPathType() & PATHFIND_SHORT)
                         return SPELL_FAILED_OUT_OF_RANGE;
                     else if (!result || m_preGeneratedPath.GetPathType() & (PATHFIND_NOPATH | PATHFIND_INCOMPLETE))
                     {
                         result = m_preGeneratedPath.CalculatePath(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ() + targetObjectSize, false, false);
                         if (m_preGeneratedPath.GetPathType() & PATHFIND_SHORT)
                             return SPELL_FAILED_OUT_OF_RANGE;
                         else if (!result || m_preGeneratedPath.GetPathType() & (PATHFIND_NOPATH | PATHFIND_INCOMPLETE))
                             return SPELL_FAILED_NOPATH;
                     }
 
                     m_preGeneratedPath.ReducePathLenghtByDist(objSize); // move back
                 }
                 break;
             }
             case SPELL_EFFECT_SKINNING:
             {
                 if (m_caster->GetTypeId() != TYPEID_PLAYER || !m_targets.GetUnitTarget() || m_targets.GetUnitTarget()->GetTypeId() != TYPEID_UNIT)
                     return SPELL_FAILED_BAD_TARGETS;
 
                 if (!(m_targets.GetUnitTarget()->GetUInt32Value(UNIT_FIELD_FLAGS) & UNIT_FLAG_SKINNABLE))
                     return SPELL_FAILED_TARGET_UNSKINNABLE;
 
                 Creature* creature = m_targets.GetUnitTarget()->ToCreature();
                 if (!creature->IsCritter() && !creature->loot.isLooted())
                     return SPELL_FAILED_TARGET_NOT_LOOTED;
 
                 uint32 skill = creature->GetCreatureTemplate()->GetRequiredLootSkill();
 
                 int32 skillValue = m_caster->ToPlayer()->GetSkillValue(skill);
                 int32 TargetLevel = m_targets.GetUnitTarget()->getLevel();
                 int32 ReqValue = (skillValue < 100 ? (TargetLevel-10) * 10 : TargetLevel * 5);
                 if (ReqValue > skillValue)
                     return SPELL_FAILED_LOW_CASTLEVEL;
 
                 // chance for fail at orange skinning attempt
                 if ((m_selfContainer && (*m_selfContainer) == this) &&
                     skillValue < sWorld->GetConfigMaxSkillValue() &&
                     (ReqValue < 0 ? 0 : ReqValue) > irand(skillValue - 25, skillValue + 37))
                     return SPELL_FAILED_TRY_AGAIN;
 
                 break;
             }
             case SPELL_EFFECT_OPEN_LOCK:
             {
                 if (effect->TargetA.GetTarget() != TARGET_GAMEOBJECT_TARGET &&
                     effect->TargetA.GetTarget() != TARGET_GAMEOBJECT_ITEM_TARGET)
                     break;
 
                 if (m_caster->GetTypeId() != TYPEID_PLAYER  // only players can open locks, gather etc.
                     // we need a go target in case of TARGET_GAMEOBJECT_TARGET
                     || (effect->TargetA.GetTarget() == TARGET_GAMEOBJECT_TARGET && !m_targets.GetGOTarget()))
                     return SPELL_FAILED_BAD_TARGETS;
 
                 Item* pTempItem = NULL;
                 if (m_targets.GetTargetMask() & TARGET_FLAG_TRADE_ITEM)
                 {
                     if (TradeData* pTrade = m_caster->ToPlayer()->GetTradeData())
                         pTempItem = pTrade->GetTraderData()->GetItem(TradeSlots(m_targets.GetItemTargetGUID().GetRawValue().at(0)));  // at this point item target guid contains the trade slot
                 }
                 else if (m_targets.GetTargetMask() & TARGET_FLAG_ITEM)
                     pTempItem = m_caster->ToPlayer()->GetItemByGuid(m_targets.GetItemTargetGUID());
 
                 // we need a go target, or an openable item target in case of TARGET_GAMEOBJECT_ITEM_TARGET
                 if (effect->TargetA.GetTarget() == TARGET_GAMEOBJECT_ITEM_TARGET &&
                     !m_targets.GetGOTarget() &&
                     (!pTempItem || !pTempItem->GetTemplate()->GetLockID() || !pTempItem->IsLocked()))
                     return SPELL_FAILED_BAD_TARGETS;
 
                 if (m_spellInfo->Id != 1842 || (m_targets.GetGOTarget() &&
                     m_targets.GetGOTarget()->GetGOInfo()->type != GAMEOBJECT_TYPE_TRAP))
                     if (m_caster->ToPlayer()->InBattleground() && // In Battleground players can use only flags and banners
                         !m_caster->ToPlayer()->CanUseBattlegroundObject(m_targets.GetGOTarget()))
                         return SPELL_FAILED_TRY_AGAIN;
 
                 // get the lock entry
                 uint32 lockId = 0;
                 if (GameObject* go = m_targets.GetGOTarget())
                 {
                     lockId = go->GetGOInfo()->GetLockId();
                     if (!lockId)
                         return SPELL_FAILED_BAD_TARGETS;
                 }
                 else if (Item* itm = m_targets.GetItemTarget())
                     lockId = itm->GetTemplate()->GetLockID();
 
                 SkillType skillId = SKILL_NONE;
                 int32 reqSkillValue = 0;
                 int32 skillValue = 0;
 
                 // check lock compatibility
                 SpellCastResult res = CanOpenLock(effect->EffectIndex, lockId, skillId, reqSkillValue, skillValue);
                 if (res != SPELL_CAST_OK)
                     return res;
 
                 // chance for fail at orange mining/herb/LockPicking gathering attempt
                 // second check prevent fail at rechecks
                 if (skillId != SKILL_NONE && (!m_selfContainer || ((*m_selfContainer) != this)))
                 {
                     bool canFailAtMax = skillId != SKILL_HERBALISM && skillId != SKILL_MINING;
 
                     // chance for failure in orange gather / lockpick (gathering skill can't fail at maxskill)
                     if ((canFailAtMax || skillValue < sWorld->GetConfigMaxSkillValue()) && reqSkillValue > irand(skillValue - 25, skillValue + 37))
                         return SPELL_FAILED_TRY_AGAIN;
                 }
                 break;
             }
             case SPELL_EFFECT_RESURRECT_PET:
             {
                 Creature* pet = m_caster->GetGuardianPet();
 
                 if (pet && pet->IsAlive())
                     return SPELL_FAILED_ALREADY_HAVE_SUMMON;
 
                 break;
             }
             // This is generic summon effect
             case SPELL_EFFECT_SUMMON:
             {
                 SummonPropertiesEntry const* SummonProperties = sSummonPropertiesStore.LookupEntry(effect->MiscValueB);
                 if (!SummonProperties)
                     break;
                 switch (SummonProperties->Category)
                 {
                     case SUMMON_CATEGORY_PET:
                         if (!m_caster->GetPetGUID().IsEmpty())
                             return SPELL_FAILED_ALREADY_HAVE_SUMMON;
                     // intentional missing break, check both GetPetGUID() and GetCharmGUID for SUMMON_CATEGORY_PET
                     case SUMMON_CATEGORY_PUPPET:
                         if (!m_caster->GetCharmGUID().IsEmpty())
                             return SPELL_FAILED_ALREADY_HAVE_CHARM;
                         break;
                 }
                 break;
             }
             case SPELL_EFFECT_CREATE_TAMED_PET:
             {
                 if (m_targets.GetUnitTarget())
                 {
                     if (m_targets.GetUnitTarget()->GetTypeId() != TYPEID_PLAYER)
                         return SPELL_FAILED_BAD_TARGETS;
                     if (!m_targets.GetUnitTarget()->GetPetGUID().IsEmpty())
                         return SPELL_FAILED_ALREADY_HAVE_SUMMON;
                 }
                 break;
             }
             case SPELL_EFFECT_SUMMON_PET:
             {
                 if (!m_caster->GetPetGUID().IsEmpty())                  //let warlock do a replacement summon
                 {
                     if (m_caster->GetTypeId() == TYPEID_PLAYER && m_caster->getClass() == CLASS_WARLOCK)
                     {
                         if (strict)                         //starting cast, trigger pet stun (cast by pet so it doesn't attack player)
                             if (Pet* pet = m_caster->ToPlayer()->GetPet())
                                 pet->CastSpell(pet, 32752, true, NULL, NULL, pet->GetGUID());
                     }
                     else
                         return SPELL_FAILED_ALREADY_HAVE_SUMMON;
                 }
 
                 if (!m_caster->GetCharmGUID().IsEmpty())
                     return SPELL_FAILED_ALREADY_HAVE_CHARM;
                 break;
             }
             case SPELL_EFFECT_SUMMON_PLAYER:
             {
                 if (m_caster->GetTypeId() != TYPEID_PLAYER)
                     return SPELL_FAILED_BAD_TARGETS;
                 if (!m_caster->GetTarget())
                     return SPELL_FAILED_BAD_TARGETS;
 
                 Player* target = ObjectAccessor::FindPlayer(m_caster->ToPlayer()->GetTarget());
                 if (!target || m_caster->ToPlayer() == target || (!target->IsInSameRaidWith(m_caster->ToPlayer()) && m_spellInfo->Id != 48955)) // refer-a-friend spell
                     return SPELL_FAILED_BAD_TARGETS;
 
                 // check if our map is dungeon
                 MapEntry const* map = sMapStore.LookupEntry(m_caster->GetMapId());
                 if (map->IsDungeon())
                 {
                     uint32 mapId = m_caster->GetMap()->GetId();
                     Difficulty difficulty = m_caster->GetMap()->GetDifficultyID();
                     if (map->IsRaid())
                         if (InstancePlayerBind* targetBind = target->GetBoundInstance(mapId, difficulty))
                             if (InstancePlayerBind* casterBind = m_caster->ToPlayer()->GetBoundInstance(mapId, difficulty))
                                 if (targetBind->perm && targetBind->save != casterBind->save)
                                     return SPELL_FAILED_TARGET_LOCKED_TO_RAID_INSTANCE;
 
                     InstanceTemplate const* instance = sObjectMgr->GetInstanceTemplate(mapId);
                     if (!instance)
                         return SPELL_FAILED_TARGET_NOT_IN_INSTANCE;
                     if (!target->Satisfy(sObjectMgr->GetAccessRequirement(mapId, difficulty), mapId))
                         return SPELL_FAILED_BAD_TARGETS;
                 }
                 break;
             }
             // RETURN HERE
             case SPELL_EFFECT_SUMMON_RAF_FRIEND:
             {
                 if (m_caster->GetTypeId() != TYPEID_PLAYER)
                     return SPELL_FAILED_BAD_TARGETS;
 
                 Player* playerCaster = m_caster->ToPlayer();
                     //
                 if (!(playerCaster->GetTarget()))
                     return SPELL_FAILED_BAD_TARGETS;
 
                 Player* target = playerCaster->GetSelectedPlayer();
 
                 if (!target ||
                     !(target->GetSession()->GetRecruiterId() == playerCaster->GetSession()->GetAccountId() || target->GetSession()->GetAccountId() == playerCaster->GetSession()->GetRecruiterId()))
                     return SPELL_FAILED_BAD_TARGETS;
 
                 break;
             }
             case SPELL_EFFECT_LEAP:
             case SPELL_EFFECT_TELEPORT_UNITS_FACE_CASTER:
             {
               //Do not allow to cast it before BG starts.
                 if (m_caster->GetTypeId() == TYPEID_PLAYER)
                     if (Battleground const* bg = m_caster->ToPlayer()->GetBattleground())
                         if (bg->GetStatus() != STATUS_IN_PROGRESS)
                             return SPELL_FAILED_TRY_AGAIN;
                 break;
             }
             case SPELL_EFFECT_STEAL_BENEFICIAL_BUFF:
             {
                 if (m_targets.GetUnitTarget() == m_caster)
                     return SPELL_FAILED_BAD_TARGETS;
                 break;
             }
             case SPELL_EFFECT_LEAP_BACK:
             {
                 if (m_caster->HasUnitState(UNIT_STATE_ROOT))
                 {
                     if (m_caster->GetTypeId() == TYPEID_PLAYER)
                         return SPELL_FAILED_ROOTED;
                     else
                         return SPELL_FAILED_DONT_REPORT;
                 }
                 break;
             }
             case SPELL_EFFECT_TALENT_SPEC_SELECT:
             {
                 // can't change during already started arena/battleground
                 if (m_caster->GetTypeId() == TYPEID_PLAYER)
                     if (Battleground const* bg = m_caster->ToPlayer()->GetBattleground())
                         if (bg->GetStatus() == STATUS_IN_PROGRESS)
                             return SPELL_FAILED_NOT_IN_BATTLEGROUND;
                 break;
             }
             case SPELL_EFFECT_REMOVE_TALENT:
             {
                 if (m_caster->GetTypeId() != TYPEID_PLAYER)
                     return SPELL_FAILED_BAD_TARGETS;
                 TalentEntry const* talent = sTalentStore.LookupEntry(m_misc.TalentId);
                 if (!talent)
                     return SPELL_FAILED_DONT_REPORT;
                 if (m_caster->GetSpellHistory()->HasCooldown(talent->SpellID))
                     return SPELL_FAILED_CANT_UNTALENT;
                 break;
             }
             default:
                 break;
         }
     }
 
     for (SpellEffectInfo const* effect : GetEffects())
     {
         if (!effect)
             continue;
         switch (effect->ApplyAuraName)
         {
             case SPELL_AURA_MOD_POSSESS_PET:
             {
                 if (m_caster->GetTypeId() != TYPEID_PLAYER)
                     return SPELL_FAILED_NO_PET;
 
                 Pet* pet = m_caster->ToPlayer()->GetPet();
                 if (!pet)
                     return SPELL_FAILED_NO_PET;
 
                 if (!pet->GetCharmerGUID().IsEmpty())
                     return SPELL_FAILED_CHARMED;
                 break;
             }
             case SPELL_AURA_MOD_POSSESS:
             case SPELL_AURA_MOD_CHARM:
             case SPELL_AURA_AOE_CHARM:
             {
                 if (!m_caster->GetCharmerGUID().IsEmpty())
                     return SPELL_FAILED_CHARMED;
 
                 if (effect->ApplyAuraName == SPELL_AURA_MOD_CHARM
                     || effect->ApplyAuraName == SPELL_AURA_MOD_POSSESS)
                 {
                     if (!m_caster->GetPetGUID().IsEmpty())
                         return SPELL_FAILED_ALREADY_HAVE_SUMMON;
 
                     if (!m_caster->GetCharmGUID().IsEmpty())
                         return SPELL_FAILED_ALREADY_HAVE_CHARM;
                 }
 
                 if (Unit* target = m_targets.GetUnitTarget())
                 {
                     if (target->GetTypeId() == TYPEID_UNIT && target->IsVehicle())
                         return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
 
                     if (target->IsMounted())
                         return SPELL_FAILED_CANT_BE_CHARMED;
 
                     if (!target->GetCharmerGUID().IsEmpty())
                         return SPELL_FAILED_CHARMED;
 
                     if (target->GetOwner() && target->GetOwner()->GetTypeId() == TYPEID_PLAYER)
                         return SPELL_FAILED_TARGET_IS_PLAYER_CONTROLLED;
 
                     int32 value = CalculateDamage(effect->EffectIndex, target);
                     if (value && int32(target->getLevel()) > value)
                         return SPELL_FAILED_HIGHLEVEL;
                 }
 
                 break;
             }
             case SPELL_AURA_MOUNTED:
             {
                 if (m_caster->IsInWater())
                     return SPELL_FAILED_ONLY_ABOVEWATER;
 
                 // Ignore map check if spell have AreaId. AreaId already checked and this prevent special mount spells
                 bool allowMount = !m_caster->GetMap()->IsDungeon() || m_caster->GetMap()->IsBattlegroundOrArena();
                 InstanceTemplate const* it = sObjectMgr->GetInstanceTemplate(m_caster->GetMapId());
                 if (it)
                     allowMount = it->AllowMount;
                 if (m_caster->GetTypeId() == TYPEID_PLAYER && !allowMount && !m_spellInfo->RequiredAreasID)
                     return SPELL_FAILED_NO_MOUNTS_ALLOWED;
 
                 if (m_caster->IsInDisallowedMountForm())
                     return SPELL_FAILED_NOT_SHAPESHIFT;
 
                 break;
             }
             case SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS:
             {
                 if (!m_targets.GetUnitTarget())
                     return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
 
                 // can be cast at non-friendly unit or own pet/charm
                 if (m_caster->IsFriendlyTo(m_targets.GetUnitTarget()))
                     return SPELL_FAILED_TARGET_FRIENDLY;
 
                 break;
             }
             case SPELL_AURA_FLY:
             case SPELL_AURA_MOD_INCREASE_MOUNTED_FLIGHT_SPEED:
             {
                 // not allow cast fly spells if not have req. skills  (all spells is self target)
                 // allow always ghost flight spells
                 if (m_originalCaster && m_originalCaster->GetTypeId() == TYPEID_PLAYER && m_originalCaster->IsAlive())
                 {
                     Battlefield* Bf = sBattlefieldMgr->GetBattlefieldToZoneId(m_originalCaster->GetZoneId());
                     if (AreaTableEntry const* area = sAreaTableStore.LookupEntry(m_originalCaster->GetAreaId()))
                         if (area->Flags[0] & AREA_FLAG_NO_FLY_ZONE  || (Bf && !Bf->CanFlyIn()))
                             return (_triggeredCastFlags & TRIGGERED_DONT_REPORT_CAST_ERROR) ? SPELL_FAILED_DONT_REPORT : SPELL_FAILED_NOT_HERE;
                 }
                 break;
             }
             case SPELL_AURA_PERIODIC_MANA_LEECH:
             {
                 if (effect->IsTargetingArea())
                     break;
 
                 if (!m_targets.GetUnitTarget())
                     return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
 
                 if (m_caster->GetTypeId() != TYPEID_PLAYER || m_CastItem)
                     break;
 
                 if (m_targets.GetUnitTarget()->getPowerType() != POWER_MANA)
                     return SPELL_FAILED_BAD_TARGETS;
 
                 break;
             }
             default:
                 break;
         }
     }
 
     // check trade slot case (last, for allow catch any another cast problems)
     if (m_targets.GetTargetMask() & TARGET_FLAG_TRADE_ITEM)
     {
         if (m_CastItem)
             return SPELL_FAILED_ITEM_ENCHANT_TRADE_WINDOW;
 
         if (m_caster->GetTypeId() != TYPEID_PLAYER)
             return SPELL_FAILED_NOT_TRADING;
 
         TradeData* my_trade = m_caster->ToPlayer()->GetTradeData();
 
         if (!my_trade)
             return SPELL_FAILED_NOT_TRADING;
 
         if (m_targets.GetItemTargetGUID() != ObjectGuid::TradeItem)
             return SPELL_FAILED_BAD_TARGETS;
 
         if (!IsTriggered())
             if (my_trade->GetSpell())
                 return SPELL_FAILED_ITEM_ALREADY_ENCHANTED;
     }
 
     // check if caster has at least 1 combo point for spells that require combo points
     if (m_needComboPoints)
         if (Player* plrCaster = m_caster->ToPlayer())
             if (!plrCaster->GetComboPoints())
                 return SPELL_FAILED_NO_COMBO_POINTS;
 
     // all ok
     return SPELL_CAST_OK;
 }

Here is the caller graph for this function:

SpellCastResult Spell::CheckCasterAuras ( ) const

 {
     // spells totally immuned to caster auras (wsg flag drop, give marks etc)
     if (m_spellInfo->HasAttribute(SPELL_ATTR6_IGNORE_CASTER_AURAS))
         return SPELL_CAST_OK;
 
     uint8 school_immune = 0;
     uint32 mechanic_immune = 0;
     uint32 dispel_immune = 0;
 
     // Check if the spell grants school or mechanic immunity.
     // We use bitmasks so the loop is done only once and not on every aura check below.
     if (m_spellInfo->HasAttribute(SPELL_ATTR1_DISPEL_AURAS_ON_IMMUNITY))
     {
         for (SpellEffectInfo const* effect : GetEffects())
         {
             if (!effect)
                 continue;
 
             if (effect->ApplyAuraName == SPELL_AURA_SCHOOL_IMMUNITY)
                 school_immune |= uint32(effect->MiscValue);
             else if (effect->ApplyAuraName == SPELL_AURA_MECHANIC_IMMUNITY)
                 mechanic_immune |= 1 << uint32(effect->MiscValue);
             else if (effect->ApplyAuraName == SPELL_AURA_DISPEL_IMMUNITY)
                 dispel_immune |= SpellInfo::GetDispelMask(DispelType(effect->MiscValue));
         }
         // immune movement impairment and loss of control
         if (m_spellInfo->Id == 42292 || m_spellInfo->Id == 59752 || m_spellInfo->Id == 19574)
             mechanic_immune = IMMUNE_TO_MOVEMENT_IMPAIRMENT_AND_LOSS_CONTROL_MASK;
     }
 
     bool usableInStun = m_spellInfo->HasAttribute(SPELL_ATTR5_USABLE_WHILE_STUNNED);
 
     // Glyph of Pain Suppression
     // Allow Pain Suppression and Guardian Spirit to be cast while stunned
     // there is no other way to handle it
     if ((m_spellInfo->Id == 33206 || m_spellInfo->Id == 47788) && !m_caster->HasAura(63248))
         usableInStun = false;
 
     // Check whether the cast should be prevented by any state you might have.
     SpellCastResult prevented_reason = SPELL_CAST_OK;
     // Have to check if there is a stun aura. Otherwise will have problems with ghost aura apply while logging out
     uint32 unitflag = m_caster->GetUInt32Value(UNIT_FIELD_FLAGS);     // Get unit state
     if (unitflag & UNIT_FLAG_STUNNED)
     {
         // spell is usable while stunned, check if caster has only mechanic stun auras, another stun types must prevent cast spell
         if (usableInStun)
         {
             bool foundNotStun = false;
             Unit::AuraEffectList const& stunAuras = m_caster->GetAuraEffectsByType(SPELL_AURA_MOD_STUN);
             for (Unit::AuraEffectList::const_iterator i = stunAuras.begin(); i != stunAuras.end(); ++i)
             {
                 if ((*i)->GetSpellInfo()->GetAllEffectsMechanicMask() && !((*i)->GetSpellInfo()->GetAllEffectsMechanicMask() & (1<<MECHANIC_STUN)))
                 {
                     foundNotStun = true;
                     break;
                 }
             }
             if (foundNotStun && m_spellInfo->Id != 22812)
                 prevented_reason = SPELL_FAILED_STUNNED;
         }
         else
             prevented_reason = SPELL_FAILED_STUNNED;
     }
     else if (unitflag & UNIT_FLAG_CONFUSED && !m_spellInfo->HasAttribute(SPELL_ATTR5_USABLE_WHILE_CONFUSED))
         prevented_reason = SPELL_FAILED_CONFUSED;
     else if (unitflag & UNIT_FLAG_FLEEING && !m_spellInfo->HasAttribute(SPELL_ATTR5_USABLE_WHILE_FEARED))
         prevented_reason = SPELL_FAILED_FLEEING;
     else if (unitflag & UNIT_FLAG_SILENCED && m_spellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE)
         prevented_reason = SPELL_FAILED_SILENCED;
     else if (unitflag & UNIT_FLAG_PACIFIED && m_spellInfo->PreventionType == SPELL_PREVENTION_TYPE_PACIFY)
         prevented_reason = SPELL_FAILED_PACIFIED;
 
     // Attr must make flag drop spell totally immune from all effects
     if (prevented_reason != SPELL_CAST_OK)
     {
         if (school_immune || mechanic_immune || dispel_immune)
         {
             //Checking auras is needed now, because you are prevented by some state but the spell grants immunity.
             Unit::AuraApplicationMap const& auras = m_caster->GetAppliedAuras();
             for (Unit::AuraApplicationMap::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
             {
                 Aura const* aura = itr->second->GetBase();
                 SpellInfo const* auraInfo = aura->GetSpellInfo();
                 if (auraInfo->GetAllEffectsMechanicMask() & mechanic_immune)
                     continue;
                 if (auraInfo->GetSchoolMask() & school_immune && !auraInfo->HasAttribute(SPELL_ATTR1_UNAFFECTED_BY_SCHOOL_IMMUNE))
                     continue;
                 if (auraInfo->GetDispelMask() & dispel_immune)
                     continue;
 
                 //Make a second check for spell failed so the right SPELL_FAILED message is returned.
                 //That is needed when your casting is prevented by multiple states and you are only immune to some of them.
                 for (SpellEffectInfo const* effect : GetEffects())
                 {
                     if (!effect)
                         continue;
 
                     if (AuraEffect* part = aura->GetEffect(effect->EffectIndex))
                     {
                         switch (part->GetAuraType())
                         {
                             case SPELL_AURA_MOD_STUN:
                                 if (!usableInStun || !(auraInfo->GetAllEffectsMechanicMask() & (1<<MECHANIC_STUN)))
                                     return SPELL_FAILED_STUNNED;
                                 break;
                             case SPELL_AURA_MOD_CONFUSE:
                                 if (!m_spellInfo->HasAttribute(SPELL_ATTR5_USABLE_WHILE_CONFUSED))
                                     return SPELL_FAILED_CONFUSED;
                                 break;
                             case SPELL_AURA_MOD_FEAR:
                                 if (!m_spellInfo->HasAttribute(SPELL_ATTR5_USABLE_WHILE_FEARED))
                                     return SPELL_FAILED_FLEEING;
                                 break;
                             case SPELL_AURA_MOD_SILENCE:
                             case SPELL_AURA_MOD_PACIFY:
                             case SPELL_AURA_MOD_PACIFY_SILENCE:
                                 if (m_spellInfo->PreventionType == SPELL_PREVENTION_TYPE_PACIFY)
                                     return SPELL_FAILED_PACIFIED;
                                 else if (m_spellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE)
                                     return SPELL_FAILED_SILENCED;
                                 break;
                             default: break;
                         }
                     }
                 }
             }
         }
         // You are prevented from casting and the spell cast does not grant immunity. Return a failed error.
         else
             return prevented_reason;
     }
     return SPELL_CAST_OK;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::CheckDst ( )

inline

519 { if (!m_targets.HasDst()) m_targets.SetDst(*m_caster); }

Spell::m_caster

Unit *const m_caster

Definition: Spell.h:647

Spell::m_targets

SpellCastTargets m_targets

Definition: Spell.h:584

SpellCastTargets::HasDst

bool HasDst() const

Definition: Spell.h:229

SpellCastTargets::SetDst

void SetDst(float x, float y, float z, float orientation, uint32 mapId=MAPID_INVALID)

Definition: Spell.cpp:377

Here is the caller graph for this function:

bool Spell::CheckEffectTarget	(	Unit const *	target,
		SpellEffectInfo const *	effect,
		Position const *	losPosition
	)		const

Todo:: shit below shouldn't be here, but it's temporary

 {
     if (!effect->IsEffect())
         return false;
 
     switch (effect->ApplyAuraName)
     {
         case SPELL_AURA_MOD_POSSESS:
         case SPELL_AURA_MOD_CHARM:
         case SPELL_AURA_MOD_POSSESS_PET:
         case SPELL_AURA_AOE_CHARM:
             if (target->GetTypeId() == TYPEID_UNIT && target->IsVehicle())
                 return false;
             if (target->IsMounted())
                 return false;
             if (!target->GetCharmerGUID().IsEmpty())
                 return false;
             if (int32 value = CalculateDamage(effect->EffectIndex, target))
                 if ((int32)target->getLevel() > value)
                     return false;
             break;
         default:
             break;
     }
 
     // check for ignore LOS on the effect itself
     if (m_spellInfo->HasAttribute(SPELL_ATTR2_CAN_TARGET_NOT_IN_LOS) || DisableMgr::IsDisabledFor(DISABLE_TYPE_SPELL, m_spellInfo->Id, NULL, SPELL_DISABLE_LOS))
         return true;
 
     // if spell is triggered, need to check for LOS disable on the aura triggering it and inherit that behaviour
     if (IsTriggered() && m_triggeredByAuraSpell && (m_triggeredByAuraSpell->HasAttribute(SPELL_ATTR2_CAN_TARGET_NOT_IN_LOS) || DisableMgr::IsDisabledFor(DISABLE_TYPE_SPELL, m_triggeredByAuraSpell->Id, NULL, SPELL_DISABLE_LOS)))
         return true;
 
     //Check targets for LOS visibility (except spells without range limitations)
     switch (effect->Effect)
     {
         case SPELL_EFFECT_RESURRECT_NEW:
             // player far away, maybe his corpse near?
             if (target != m_caster && !target->IsWithinLOSInMap(m_caster))
             {
                 if (!m_targets.GetCorpseTargetGUID())
                     return false;
 
                 Corpse* corpse = ObjectAccessor::GetCorpse(*m_caster, m_targets.GetCorpseTargetGUID());
                 if (!corpse)
                     return false;
 
                 if (target->GetGUID() != corpse->GetOwnerGUID())
                     return false;
 
                 if (!corpse->IsWithinLOSInMap(m_caster))
                     return false;
             }
 
             // all ok by some way or another, skip normal check
             break;
         default:                                            // normal case
         {
             if (losPosition)
                 return target->IsWithinLOS(losPosition->GetPositionX(), losPosition->GetPositionY(), losPosition->GetPositionZ());
             else
             {
                 // Get GO cast coordinates if original caster -> GO
                 WorldObject* caster = NULL;
                 if (m_originalCasterGUID.IsGameObject())
                     caster = m_caster->GetMap()->GetGameObject(m_originalCasterGUID);
                 if (!caster)
                     caster = m_caster;
                 if (target != m_caster && !target->IsWithinLOSInMap(caster))
                     return false;
             }
             break;
         }
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Spell::CheckEffectTarget	(	GameObject const *	target,
		SpellEffectInfo const *	effect
	)		const

 {
     if (!effect->IsEffect())
         return false;
 
     switch (effect->Effect)
     {
         case SPELL_EFFECT_GAMEOBJECT_DAMAGE:
         case SPELL_EFFECT_GAMEOBJECT_REPAIR:
         case SPELL_EFFECT_GAMEOBJECT_SET_DESTRUCTION_STATE:
             if (target->GetGoType() != GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING)
                 return false;
             break;
         default:
             break;
     }
 
     return true;
 }

Here is the call graph for this function:

bool Spell::CheckEffectTarget	(	Item const *	target,
		SpellEffectInfo const *	effect
	)		const

 {
     if (!effect->IsEffect())
         return false;
 
     return true;
 }

Here is the call graph for this function:

SpellCastResult Spell::CheckItems ( )

Todo:: Needs review

 {
     Player* player = m_caster->ToPlayer();
     if (!player)
         return SPELL_CAST_OK;
 
     if (!m_CastItem)
     {
         if (!m_castItemGUID.IsEmpty())
             return SPELL_FAILED_ITEM_NOT_READY;
     }
     else
     {
         uint32 itemid = m_CastItem->GetEntry();
         if (!player->HasItemCount(itemid))
             return SPELL_FAILED_ITEM_NOT_READY;
 
         ItemTemplate const* proto = m_CastItem->GetTemplate();
         if (!proto)
             return SPELL_FAILED_ITEM_NOT_READY;
 
         for (uint8 i = 0; i < proto->Effects.size() && i < 5; ++i)
             if (proto->Effects[i]->Charges)
                 if (m_CastItem->GetSpellCharges(i) == 0)
                     return SPELL_FAILED_NO_CHARGES_REMAIN;
 
         // consumable cast item checks
         if (proto->GetClass() == ITEM_CLASS_CONSUMABLE && m_targets.GetUnitTarget())
         {
             // such items should only fail if there is no suitable effect at all - see Rejuvenation Potions for example
             SpellCastResult failReason = SPELL_CAST_OK;
             for (SpellEffectInfo const* effect : GetEffects())
             {
                 // skip check, pet not required like checks, and for TARGET_UNIT_PET m_targets.GetUnitTarget() is not the real target but the caster
                 if (!effect || effect->TargetA.GetTarget() == TARGET_UNIT_PET)
                     continue;
 
                 if (effect->Effect == SPELL_EFFECT_HEAL)
                 {
                     if (m_targets.GetUnitTarget()->IsFullHealth())
                     {
                         failReason = SPELL_FAILED_ALREADY_AT_FULL_HEALTH;
                         continue;
                     }
                     else
                     {
                         failReason = SPELL_CAST_OK;
                         break;
                     }
                 }
 
                 // Mana Potion, Rage Potion, Thistle Tea(Rogue), ...
                 if (effect->Effect == SPELL_EFFECT_ENERGIZE)
                 {
                     if (effect->MiscValue < 0 || effect->MiscValue >= int8(MAX_POWERS))
                     {
                         failReason = SPELL_FAILED_ALREADY_AT_FULL_POWER;
                         continue;
                     }
 
                     Powers power = Powers(effect->MiscValue);
                     if (m_targets.GetUnitTarget()->GetPower(power) == m_targets.GetUnitTarget()->GetMaxPower(power))
                     {
                         failReason = SPELL_FAILED_ALREADY_AT_FULL_POWER;
                         continue;
                     }
                     else
                     {
                         failReason = SPELL_CAST_OK;
                         break;
                     }
                 }
             }
             if (failReason != SPELL_CAST_OK)
                 return failReason;
         }
     }
 
     // check target item
     if (!m_targets.GetItemTargetGUID().IsEmpty())
     {
         if (!m_targets.GetItemTarget())
             return SPELL_FAILED_ITEM_GONE;
 
         if (!m_targets.GetItemTarget()->IsFitToSpellRequirements(m_spellInfo))
             return SPELL_FAILED_EQUIPPED_ITEM_CLASS;
     }
     // if not item target then required item must be equipped
     else
     {
         if (!(_triggeredCastFlags & TRIGGERED_IGNORE_EQUIPPED_ITEM_REQUIREMENT))
             if (!player->HasItemFitToSpellRequirements(m_spellInfo))
                 return SPELL_FAILED_EQUIPPED_ITEM_CLASS;
     }
 
     // do not take reagents for these item casts
     if (!(m_CastItem && m_CastItem->GetTemplate()->GetFlags() & ITEM_FLAG_TRIGGERED_CAST))
     {
         bool checkReagents = !(_triggeredCastFlags & TRIGGERED_IGNORE_POWER_AND_REAGENT_COST) && !player->CanNoReagentCast(m_spellInfo);
         // Not own traded item (in trader trade slot) requires reagents even if triggered spell
         if (!checkReagents)
             if (Item* targetItem = m_targets.GetItemTarget())
                 if (targetItem->GetOwnerGUID() != m_caster->GetGUID())
                     checkReagents = true;
 
         // check reagents (ignore triggered spells with reagents processed by original spell) and special reagent ignore case.
         if (checkReagents)
         {
             for (uint32 i = 0; i < MAX_SPELL_REAGENTS; i++)
             {
                 if (m_spellInfo->Reagent[i] <= 0)
                     continue;
 
                 uint32 itemid    = m_spellInfo->Reagent[i];
                 uint32 itemcount = m_spellInfo->ReagentCount[i];
 
                 // if CastItem is also spell reagent
                 if (m_CastItem && m_CastItem->GetEntry() == itemid)
                 {
                     ItemTemplate const* proto = m_CastItem->GetTemplate();
                     if (!proto)
                         return SPELL_FAILED_ITEM_NOT_READY;
                     for (uint8 s = 0; s < proto->Effects.size() && s < 5; ++s)
                     {
                         // CastItem will be used up and does not count as reagent
                         int32 charges = m_CastItem->GetSpellCharges(s);
                         if (proto->Effects[s]->Charges < 0 && abs(charges) < 2)
                         {
                             ++itemcount;
                             break;
                         }
                     }
                 }
                 if (!player->HasItemCount(itemid, itemcount))
                     return SPELL_FAILED_REAGENTS;
             }
         }
 
         // check totem-item requirements (items presence in inventory)
         uint32 totems = 2;
         for (uint8 i = 0; i < 2; ++i)
         {
             if (m_spellInfo->Totem[i] != 0)
             {
                 if (player->HasItemCount(m_spellInfo->Totem[i]))
                 {
                     totems -= 1;
                     continue;
                 }
             }
             else
                 totems -= 1;
         }
 
         if (totems != 0)
             return SPELL_FAILED_TOTEMS;
 
         // Check items for TotemCategory (items presence in inventory)
         uint32 totemCategory = 2;
         for (uint8 i = 0; i < 2; ++i)
         {
             if (m_spellInfo->TotemCategory[i] != 0)
             {
                 if (player->HasItemTotemCategory(m_spellInfo->TotemCategory[i]))
                 {
                     totemCategory -= 1;
                     continue;
                 }
             }
             else
                 totemCategory -= 1;
         }
 
         if (totemCategory != 0)
             return SPELL_FAILED_TOTEM_CATEGORY;
     }
 
     // special checks for spell effects
     for (SpellEffectInfo const* effect : GetEffects())
     {
         if (!effect)
             continue;
 
         switch (effect->Effect)
         {
             case SPELL_EFFECT_CREATE_ITEM:
             case SPELL_EFFECT_CREATE_ITEM_2:
             {
                 if (!IsTriggered() && effect->ItemType)
                 {
                     ItemPosCountVec dest;
                     InventoryResult msg = player->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, effect->ItemType, 1);
                     if (msg != EQUIP_ERR_OK)
                     {
                         ItemTemplate const* pProto = sObjectMgr->GetItemTemplate(effect->ItemType);
                         if (pProto && !(pProto->GetItemLimitCategory()))
                         {
                             player->SendEquipError(msg, NULL, NULL, effect->ItemType);
                             return SPELL_FAILED_DONT_REPORT;
                         }
                         else
                         {
                             if (!(m_spellInfo->SpellFamilyName == SPELLFAMILY_MAGE && (m_spellInfo->SpellFamilyFlags[0] & 0x40000000)))
                                 return SPELL_FAILED_TOO_MANY_OF_ITEM;
                             else if (!(player->HasItemCount(effect->ItemType)))
                                 return SPELL_FAILED_TOO_MANY_OF_ITEM;
                             else if (SpellEffectInfo const* efi = GetEffect(EFFECT_1))
                                 player->CastSpell(m_caster, efi->CalcValue(), false);        // move this to anywhere
                             return SPELL_FAILED_DONT_REPORT;
                         }
                     }
                 }
                 break;
             }
             case SPELL_EFFECT_ENCHANT_ITEM:
                 if (effect->ItemType && m_targets.GetItemTarget()
                     && (m_targets.GetItemTarget()->IsVellum()))
                 {
                     // cannot enchant vellum for other player
                     if (m_targets.GetItemTarget()->GetOwner() != m_caster)
                         return SPELL_FAILED_NOT_TRADEABLE;
                     // do not allow to enchant vellum from scroll made by vellum-prevent exploit
                     if (m_CastItem && m_CastItem->GetTemplate()->GetFlags() & ITEM_FLAG_TRIGGERED_CAST)
                         return SPELL_FAILED_TOTEM_CATEGORY;
                     ItemPosCountVec dest;
                     InventoryResult msg = player->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, effect->ItemType, 1);
                     if (msg != EQUIP_ERR_OK)
                     {
                         player->SendEquipError(msg, NULL, NULL, effect->ItemType);
                         return SPELL_FAILED_DONT_REPORT;
                     }
                 }
                 // no break
             case SPELL_EFFECT_ENCHANT_ITEM_PRISMATIC:
             {
                 Item* targetItem = m_targets.GetItemTarget();
                 if (!targetItem)
                     return SPELL_FAILED_ITEM_NOT_FOUND;
 
                 if (targetItem->GetTemplate()->GetBaseItemLevel() < m_spellInfo->BaseLevel)
                     return SPELL_FAILED_LOWLEVEL;
 
                 bool isItemUsable = false;
                 ItemTemplate const* proto = targetItem->GetTemplate();
                 for (uint8 e = 0; e < proto->Effects.size(); ++e)
                 {
                     if (proto->Effects[e]->SpellID && (
                         proto->Effects[e]->Trigger == ITEM_SPELLTRIGGER_ON_USE ||
                         proto->Effects[e]->Trigger == ITEM_SPELLTRIGGER_ON_NO_DELAY_USE))
                     {
                         isItemUsable = true;
                         break;
                     }
                 }
 
                 SpellItemEnchantmentEntry const* enchantEntry = sSpellItemEnchantmentStore.LookupEntry(effect->MiscValue);
                 // do not allow adding usable enchantments to items that have use effect already
                 if (enchantEntry)
                 {
                     for (uint8 s = 0; s < MAX_ITEM_ENCHANTMENT_EFFECTS; ++s)
                     {
                         switch (enchantEntry->Effect[s])
                         {
                             case ITEM_ENCHANTMENT_TYPE_USE_SPELL:
                                 if (isItemUsable)
                                     return SPELL_FAILED_ON_USE_ENCHANT;
                                 break;
                             case ITEM_ENCHANTMENT_TYPE_PRISMATIC_SOCKET:
                             {
                                 uint32 numSockets = 0;
                                 for (uint32 socket = 0; socket < MAX_ITEM_PROTO_SOCKETS; ++socket)
                                     if (targetItem->GetSocketColor(socket))
                                         ++numSockets;
 
                                 if (numSockets == MAX_ITEM_PROTO_SOCKETS || targetItem->GetEnchantmentId(PRISMATIC_ENCHANTMENT_SLOT))
                                     return SPELL_FAILED_MAX_SOCKETS;
                                 break;
                             }
                         }
                     }
                 }
 
                 // Not allow enchant in trade slot for some enchant type
                 if (targetItem->GetOwner() != m_caster)
                 {
                     if (!enchantEntry)
                         return SPELL_FAILED_ERROR;
                     if (enchantEntry->Flags & ENCHANTMENT_CAN_SOULBOUND)
                         return SPELL_FAILED_NOT_TRADEABLE;
                 }
                 break;
             }
             case SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY:
             {
                 Item* item = m_targets.GetItemTarget();
                 if (!item)
                     return SPELL_FAILED_ITEM_NOT_FOUND;
                 // Not allow enchant in trade slot for some enchant type
                 if (item->GetOwner() != m_caster)
                 {
                     uint32 enchant_id = effect->MiscValue;
                     SpellItemEnchantmentEntry const* pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
                     if (!pEnchant)
                         return SPELL_FAILED_ERROR;
                     if (pEnchant->Flags & ENCHANTMENT_CAN_SOULBOUND)
                         return SPELL_FAILED_NOT_TRADEABLE;
                 }
                 break;
             }
             case SPELL_EFFECT_ENCHANT_HELD_ITEM:
                 // check item existence in effect code (not output errors at offhand hold item effect to main hand for example
                 break;
             case SPELL_EFFECT_DISENCHANT:
             {
                 if (!m_targets.GetItemTarget())
                     return SPELL_FAILED_CANT_BE_DISENCHANTED;
 
                 // prevent disenchanting in trade slot
                 if (m_targets.GetItemTarget()->GetOwnerGUID() != m_caster->GetGUID())
                     return SPELL_FAILED_CANT_BE_DISENCHANTED;
 
                 ItemTemplate const* itemProto = m_targets.GetItemTarget()->GetTemplate();
                 if (!itemProto)
                     return SPELL_FAILED_CANT_BE_DISENCHANTED;
 
                 uint32 item_quality = itemProto->GetQuality();
                 // 2.0.x addon: Check player enchanting level against the item disenchanting requirements
                 uint32 item_disenchantskilllevel = itemProto->RequiredDisenchantSkill;
                 if (item_disenchantskilllevel == uint32(-1))
                     return SPELL_FAILED_CANT_BE_DISENCHANTED;
                 if (item_disenchantskilllevel > player->GetSkillValue(SKILL_ENCHANTING))
                     return SPELL_FAILED_LOW_CASTLEVEL;
                 if (item_quality > 4 || item_quality < 2)
                     return SPELL_FAILED_CANT_BE_DISENCHANTED;
                 if (itemProto->GetClass() != ITEM_CLASS_WEAPON && itemProto->GetClass() != ITEM_CLASS_ARMOR)
                     return SPELL_FAILED_CANT_BE_DISENCHANTED;
                 if (!itemProto->DisenchantID)
                     return SPELL_FAILED_CANT_BE_DISENCHANTED;
                 break;
             }
             case SPELL_EFFECT_PROSPECTING:
             {
                 if (!m_targets.GetItemTarget())
                     return SPELL_FAILED_CANT_BE_PROSPECTED;
                 //ensure item is a prospectable ore
                 if (!(m_targets.GetItemTarget()->GetTemplate()->GetFlags() & ITEM_FLAG_PROSPECTABLE))
                     return SPELL_FAILED_CANT_BE_PROSPECTED;
                 //prevent prospecting in trade slot
                 if (m_targets.GetItemTarget()->GetOwnerGUID() != m_caster->GetGUID())
                     return SPELL_FAILED_CANT_BE_PROSPECTED;
                 //Check for enough skill in jewelcrafting
                 uint32 item_prospectingskilllevel = m_targets.GetItemTarget()->GetTemplate()->GetRequiredSkillRank();
                 if (item_prospectingskilllevel >player->GetSkillValue(SKILL_JEWELCRAFTING))
                     return SPELL_FAILED_LOW_CASTLEVEL;
                 //make sure the player has the required ores in inventory
                 if (m_targets.GetItemTarget()->GetCount() < 5)
                     return SPELL_FAILED_NEED_MORE_ITEMS;
 
                 if (!LootTemplates_Prospecting.HaveLootFor(m_targets.GetItemTargetEntry()))
                     return SPELL_FAILED_CANT_BE_PROSPECTED;
 
                 break;
             }
             case SPELL_EFFECT_MILLING:
             {
                 if (!m_targets.GetItemTarget())
                     return SPELL_FAILED_CANT_BE_MILLED;
                 //ensure item is a millable herb
                 if (!(m_targets.GetItemTarget()->GetTemplate()->GetFlags() & ITEM_FLAG_MILLABLE))
                     return SPELL_FAILED_CANT_BE_MILLED;
                 //prevent milling in trade slot
                 if (m_targets.GetItemTarget()->GetOwnerGUID() != m_caster->GetGUID())
                     return SPELL_FAILED_CANT_BE_MILLED;
                 //Check for enough skill in inscription
                 uint32 item_millingskilllevel = m_targets.GetItemTarget()->GetTemplate()->GetRequiredSkillRank();
                 if (item_millingskilllevel > player->GetSkillValue(SKILL_INSCRIPTION))
                     return SPELL_FAILED_LOW_CASTLEVEL;
                 //make sure the player has the required herbs in inventory
                 if (m_targets.GetItemTarget()->GetCount() < 5)
                     return SPELL_FAILED_NEED_MORE_ITEMS;
 
                 if (!LootTemplates_Milling.HaveLootFor(m_targets.GetItemTargetEntry()))
                     return SPELL_FAILED_CANT_BE_MILLED;
 
                 break;
             }
             case SPELL_EFFECT_WEAPON_DAMAGE:
             case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL:
             {
                 if (m_attackType != RANGED_ATTACK)
                     break;
 
                 Item* pItem = player->GetWeaponForAttack(m_attackType);
                 if (!pItem || pItem->IsBroken())
                     return SPELL_FAILED_EQUIPPED_ITEM;
 
                 switch (pItem->GetTemplate()->GetSubClass())
                 {
                     case ITEM_SUBCLASS_WEAPON_THROWN:
                     {
                         uint32 ammo = pItem->GetEntry();
                         if (!player->HasItemCount(ammo))
                             return SPELL_FAILED_NO_AMMO;
                         break;
                     }
                     case ITEM_SUBCLASS_WEAPON_GUN:
                     case ITEM_SUBCLASS_WEAPON_BOW:
                     case ITEM_SUBCLASS_WEAPON_CROSSBOW:
                     case ITEM_SUBCLASS_WEAPON_WAND:
                         break;
                     default:
                         break;
                 }
                 break;
             }
             case SPELL_EFFECT_CREATE_MANA_GEM:
             {
                  uint32 item_id = effect->ItemType;
                  ItemTemplate const* pProto = sObjectMgr->GetItemTemplate(item_id);
 
                  if (!pProto)
                      return SPELL_FAILED_ITEM_AT_MAX_CHARGES;
 
                  if (Item* pitem = player->GetItemByEntry(item_id))
                  {
                      for (uint8 x = 0; x < pProto->Effects.size() && x < 5; ++x)
                          if (pProto->Effects[x]->Charges != 0 && pitem->GetSpellCharges(x) == pProto->Effects[x]->Charges)
                              return SPELL_FAILED_ITEM_AT_MAX_CHARGES;
                  }
                  break;
             }
             default:
                 break;
         }
     }
 
     // check weapon presence in slots for main/offhand weapons
     if (!(_triggeredCastFlags & TRIGGERED_IGNORE_EQUIPPED_ITEM_REQUIREMENT) && m_spellInfo->EquippedItemClass >=0)
     {
         // main hand weapon required
         if (m_spellInfo->HasAttribute(SPELL_ATTR3_MAIN_HAND))
         {
             Item* item = m_caster->ToPlayer()->GetWeaponForAttack(BASE_ATTACK);
 
             // skip spell if no weapon in slot or broken
             if (!item || item->IsBroken())
                 return (_triggeredCastFlags & TRIGGERED_DONT_REPORT_CAST_ERROR) ? SPELL_FAILED_DONT_REPORT : SPELL_FAILED_EQUIPPED_ITEM_CLASS;
 
             // skip spell if weapon not fit to triggered spell
             if (!item->IsFitToSpellRequirements(m_spellInfo))
                 return (_triggeredCastFlags & TRIGGERED_DONT_REPORT_CAST_ERROR) ? SPELL_FAILED_DONT_REPORT : SPELL_FAILED_EQUIPPED_ITEM_CLASS;
         }
 
         // offhand hand weapon required
         if (m_spellInfo->HasAttribute(SPELL_ATTR3_REQ_OFFHAND))
         {
             Item* item = m_caster->ToPlayer()->GetWeaponForAttack(OFF_ATTACK);
 
             // skip spell if no weapon in slot or broken
             if (!item || item->IsBroken())
                 return (_triggeredCastFlags & TRIGGERED_DONT_REPORT_CAST_ERROR) ? SPELL_FAILED_DONT_REPORT : SPELL_FAILED_EQUIPPED_ITEM_CLASS;
 
             // skip spell if weapon not fit to triggered spell
             if (!item->IsFitToSpellRequirements(m_spellInfo))
                 return (_triggeredCastFlags & TRIGGERED_DONT_REPORT_CAST_ERROR) ? SPELL_FAILED_DONT_REPORT : SPELL_FAILED_EQUIPPED_ITEM_CLASS;
         }
     }
 
     return SPELL_CAST_OK;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SpellCastResult Spell::CheckPetCast ( Unit * target )

 {
     if (m_caster->HasUnitState(UNIT_STATE_CASTING) && !(_triggeredCastFlags & TRIGGERED_IGNORE_CAST_IN_PROGRESS))              //prevent spellcast interruption by another spellcast
         return SPELL_FAILED_SPELL_IN_PROGRESS;
 
     // dead owner (pets still alive when owners ressed?)
     if (Unit* owner = m_caster->GetCharmerOrOwner())
         if (!owner->IsAlive())
             return SPELL_FAILED_CASTER_DEAD;
 
     if (!target && m_targets.GetUnitTarget())
         target = m_targets.GetUnitTarget();
 
     if (m_spellInfo->NeedsExplicitUnitTarget())
     {
         if (!target)
             return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
         m_targets.SetUnitTarget(target);
     }
 
     // cooldown
     if (Creature* creatureCaster = m_caster->ToCreature())
         if (!creatureCaster->GetSpellHistory()->IsReady(m_spellInfo))
             return SPELL_FAILED_NOT_READY;
 
     // Check if spell is affected by GCD
     if (m_spellInfo->StartRecoveryCategory > 0)
         if (m_caster->GetCharmInfo() && m_caster->GetSpellHistory()->HasGlobalCooldown(m_spellInfo))
             return SPELL_FAILED_NOT_READY;
 
     return CheckCast(true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SpellCastResult Spell::CheckPower ( )

 {
     // item cast not used power
     if (m_CastItem)
         return SPELL_CAST_OK;
 
     for (SpellInfo::CostData const& cost : m_powerCost)
     {
         // health as power used - need check health amount
         if (cost.Power == POWER_HEALTH)
         {
             if (int32(m_caster->GetHealth()) <= cost.Amount)
                 return SPELL_FAILED_CASTER_AURASTATE;
             continue;
         }
         // Check valid power type
         if (cost.Power >= MAX_POWERS)
         {
             TC_LOG_ERROR("spells", "Spell::CheckPower: Unknown power type '%d'", cost.Power);
             return SPELL_FAILED_UNKNOWN;
         }
 
         //check rune cost only if a spell has PowerType == POWER_RUNES
         if (cost.Power == POWER_RUNES)
         {
             SpellCastResult failReason = CheckRuneCost(m_spellInfo->RuneCostID);
             if (failReason != SPELL_CAST_OK)
                 return failReason;
         }
 
         // Check power amount
         if (int32(m_caster->GetPower(cost.Power)) < cost.Amount)
             return SPELL_FAILED_NO_POWER;
     }
 
     return SPELL_CAST_OK;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SpellCastResult Spell::CheckRange ( bool strict )

 {
     // Don't check for instant cast spells
     if (!strict && m_casttime == 0)
         return SPELL_CAST_OK;
 
     uint32 range_type = 0;
 
     if (m_spellInfo->RangeEntry)
     {
         // check needed by 68766 51693 - both spells are cast on enemies and have 0 max range
         // these are triggered by other spells - possibly we should omit range check in that case?
         if (m_spellInfo->RangeEntry->ID == 1)
             return SPELL_CAST_OK;
 
         range_type = m_spellInfo->RangeEntry->Flags;
     }
 
     Unit* target = m_targets.GetUnitTarget();
     float max_range = m_caster->GetSpellMaxRangeForTarget(target, m_spellInfo);
     float min_range = m_caster->GetSpellMinRangeForTarget(target, m_spellInfo);
 
     if (Player* modOwner = m_caster->GetSpellModOwner())
         modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_RANGE, max_range, this);
 
     if (target && target != m_caster)
     {
         if (range_type == SPELL_RANGE_MELEE)
         {
             // Because of lag, we can not check too strictly here.
             if (!m_caster->IsWithinMeleeRange(target, max_range))
                 return !(_triggeredCastFlags & TRIGGERED_DONT_REPORT_CAST_ERROR) ? SPELL_FAILED_OUT_OF_RANGE : SPELL_FAILED_DONT_REPORT;
         }
         else if (!m_caster->IsWithinCombatRange(target, max_range))
             return !(_triggeredCastFlags & TRIGGERED_DONT_REPORT_CAST_ERROR) ? SPELL_FAILED_OUT_OF_RANGE : SPELL_FAILED_DONT_REPORT; //0x5A;
 
         if (range_type == SPELL_RANGE_RANGED)
         {
             if (m_caster->IsWithinMeleeRange(target))
                 return !(_triggeredCastFlags & TRIGGERED_DONT_REPORT_CAST_ERROR) ? SPELL_FAILED_TOO_CLOSE : SPELL_FAILED_DONT_REPORT;
         }
         else if (min_range && m_caster->IsWithinCombatRange(target, min_range)) // skip this check if min_range = 0
             return !(_triggeredCastFlags & TRIGGERED_DONT_REPORT_CAST_ERROR) ? SPELL_FAILED_TOO_CLOSE : SPELL_FAILED_DONT_REPORT;
 
         if (m_caster->GetTypeId() == TYPEID_PLAYER &&
             (m_spellInfo->FacingCasterFlags & SPELL_FACING_FLAG_INFRONT) && !m_caster->HasInArc(static_cast<float>(M_PI), target))
             return !(_triggeredCastFlags & TRIGGERED_DONT_REPORT_CAST_ERROR) ? SPELL_FAILED_UNIT_NOT_INFRONT : SPELL_FAILED_DONT_REPORT;
     }
 
     if (m_targets.HasDst() && !m_targets.HasTraj())
     {
         if (!m_caster->IsWithinDist3d(m_targets.GetDstPos(), max_range))
             return SPELL_FAILED_OUT_OF_RANGE;
         if (min_range && m_caster->IsWithinDist3d(m_targets.GetDstPos(), min_range))
             return SPELL_FAILED_TOO_CLOSE;
     }
 
     return SPELL_CAST_OK;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SpellCastResult Spell::CheckRuneCost ( uint32 runeCostID )

 {
     if (std::find_if(m_powerCost.begin(), m_powerCost.end(), [](SpellInfo::CostData const& cost) { return cost.Power == POWER_RUNES; }) == m_powerCost.end() || !runeCostID)
         return SPELL_CAST_OK;
 
     Player* player = m_caster->ToPlayer();
     if (!player)
         return SPELL_CAST_OK;
 
     if (player->getClass() != CLASS_DEATH_KNIGHT)
         return SPELL_CAST_OK;
 
     SpellRuneCostEntry const* src = sSpellRuneCostStore.LookupEntry(runeCostID);
     if (!src)
         return SPELL_CAST_OK;
 
     if (src->NoRuneCost())
         return SPELL_CAST_OK;
 
     int32 runeCost[NUM_RUNE_TYPES];                         // blood, frost, unholy, death
 
     for (uint32 i = 0; i < NUM_RUNE_TYPES; ++i)
     {
         runeCost[i] = src->RuneCost[i];
         if (Player* modOwner = m_caster->GetSpellModOwner())
             modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_COST, runeCost[i], this);
     }
 
     runeCost[RUNE_DEATH] += MAX_RUNES;
 
     for (uint32 i = 0; i < MAX_RUNES; ++i)
     {
         RuneType rune = player->GetCurrentRune(i);
         if ((player->GetRuneCooldown(i) == 0) && (runeCost[rune] > 0))
             runeCost[rune]--;
     }
 
     for (uint32 i = 0; i < RUNE_DEATH; ++i)
         if (runeCost[i] > 0)
             runeCost[RUNE_DEATH] += runeCost[i];
 
     if (runeCost[RUNE_DEATH] > MAX_RUNES)
         return SPELL_FAILED_NO_POWER;                       // not sure if result code is correct
 
     return SPELL_CAST_OK;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Spell::CheckScriptEffectImplicitTargets	(	uint32	effIndex,
		uint32	effIndexToCheck
	)

protected

 {
     // Skip if there are not any script
     if (m_loadedScripts.empty())
         return true;
 
     for (std::list<SpellScript*>::iterator itr = m_loadedScripts.begin(); itr != m_loadedScripts.end(); ++itr)
     {
         std::list<SpellScript::ObjectTargetSelectHandler>::iterator targetSelectHookEnd = (*itr)->OnObjectTargetSelect.end(), targetSelectHookItr = (*itr)->OnObjectTargetSelect.begin();
         for (; targetSelectHookItr != targetSelectHookEnd; ++targetSelectHookItr)
             if (((*targetSelectHookItr).IsEffectAffected(m_spellInfo, effIndex) && !(*targetSelectHookItr).IsEffectAffected(m_spellInfo, effIndexToCheck)) ||
                 (!(*targetSelectHookItr).IsEffectAffected(m_spellInfo, effIndex) && (*targetSelectHookItr).IsEffectAffected(m_spellInfo, effIndexToCheck)))
                 return false;
 
         std::list<SpellScript::ObjectAreaTargetSelectHandler>::iterator areaTargetSelectHookEnd = (*itr)->OnObjectAreaTargetSelect.end(), areaTargetSelectHookItr = (*itr)->OnObjectAreaTargetSelect.begin();
         for (; areaTargetSelectHookItr != areaTargetSelectHookEnd; ++areaTargetSelectHookItr)
             if (((*areaTargetSelectHookItr).IsEffectAffected(m_spellInfo, effIndex) && !(*areaTargetSelectHookItr).IsEffectAffected(m_spellInfo, effIndexToCheck)) ||
                 (!(*areaTargetSelectHookItr).IsEffectAffected(m_spellInfo, effIndex) && (*areaTargetSelectHookItr).IsEffectAffected(m_spellInfo, effIndexToCheck)))
                 return false;
     }
     return true;
 }

Here is the caller graph for this function:

void Spell::CheckSrc ( )

inline

518 { if (!m_targets.HasSrc()) m_targets.SetSrc(*m_caster); }

Spell::m_caster

Unit *const m_caster

Definition: Spell.h:647

SpellCastTargets::SetSrc

void SetSrc(float x, float y, float z)

Definition: Spell.cpp:338

Spell::m_targets

SpellCastTargets m_targets

Definition: Spell.h:584

SpellCastTargets::HasSrc

bool HasSrc() const

Definition: Spell.h:228

void Spell::CleanupExecuteLogList ( )

 {
     _durabilityDamageTargets->clear();
     _extraAttacksTargets->clear();
     _feedPetTargets->clear();
     _genericVictimTargets->clear();
     _powerDrainTargets->clear();
     _tradeSkillTargets->clear();
 }

Here is the caller graph for this function:

void Spell::CleanupTargetList ( )

 {
     m_UniqueTargetInfo.clear();
     m_UniqueGOTargetInfo.clear();
     m_UniqueItemInfo.clear();
     m_delayMoment = 0;
 }

Here is the caller graph for this function:

void Spell::Delayed ( )

 {
     if (!m_caster)// || m_caster->GetTypeId() != TYPEID_PLAYER)
         return;
 
     //if (m_spellState == SPELL_STATE_DELAYED)
     //    return;                                             // spell is active and can't be time-backed
 
     if (isDelayableNoMore())                                 // Spells may only be delayed twice
         return;
 
     // spells not loosing casting time (slam, dynamites, bombs..)
     //if (!(m_spellInfo->InterruptFlags & SPELL_INTERRUPT_FLAG_DAMAGE))
     //    return;
 
     //check pushback reduce
     int32 delaytime = 500;                                  // spellcasting delay is normally 500ms
     int32 delayReduce = 100;                                // must be initialized to 100 for percent modifiers
     m_caster->ToPlayer()->ApplySpellMod(m_spellInfo->Id, SPELLMOD_NOT_LOSE_CASTING_TIME, delayReduce, this);
     delayReduce += m_caster->GetTotalAuraModifier(SPELL_AURA_REDUCE_PUSHBACK) - 100;
     if (delayReduce >= 100)
         return;
 
     AddPct(delaytime, -delayReduce);
 
     if (m_timer + delaytime > m_casttime)
     {
         delaytime = m_casttime - m_timer;
         m_timer = m_casttime;
     }
     else
         m_timer += delaytime;
 
     TC_LOG_DEBUG("spells", "Spell %u partially interrupted for (%d) ms at damage", m_spellInfo->Id, delaytime);
 
     WorldPackets::Spells::SpellDelayed spellDelayed;
     spellDelayed.Caster = m_caster->GetGUID();
     spellDelayed.ActualDelay = delaytime;
 
     m_caster->SendMessageToSet(spellDelayed.Write(), true);
 }

Here is the call graph for this function:

void Spell::DelayedChannel ( )

 {
     if (!m_caster || m_caster->GetTypeId() != TYPEID_PLAYER || getState() != SPELL_STATE_CASTING)
         return;
 
     if (isDelayableNoMore())                                    // Spells may only be delayed twice
         return;
 
     //check pushback reduce
     // should be affected by modifiers, not take the dbc duration.
     int32 duration = ((m_channeledDuration > 0) ? m_channeledDuration : m_spellInfo->GetDuration());
 
     int32 delaytime = CalculatePct(duration, 25); // channeling delay is normally 25% of its time per hit
     int32 delayReduce = 100;                                    // must be initialized to 100 for percent modifiers
     m_caster->ToPlayer()->ApplySpellMod(m_spellInfo->Id, SPELLMOD_NOT_LOSE_CASTING_TIME, delayReduce, this);
     delayReduce += m_caster->GetTotalAuraModifier(SPELL_AURA_REDUCE_PUSHBACK) - 100;
     if (delayReduce >= 100)
         return;
 
     AddPct(delaytime, -delayReduce);
 
     if (m_timer <= delaytime)
     {
         delaytime = m_timer;
         m_timer = 0;
     }
     else
         m_timer -= delaytime;
 
     TC_LOG_DEBUG("spells", "Spell %u partially interrupted for %i ms, new duration: %u ms", m_spellInfo->Id, delaytime, m_timer);
 
     for (std::vector<TargetInfo>::const_iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
         if ((*ihit).missCondition == SPELL_MISS_NONE)
             if (Unit* unit = (m_caster->GetGUID() == ihit->targetGUID) ? m_caster : ObjectAccessor::GetUnit(*m_caster, ihit->targetGUID))
                 unit->DelayOwnedAuras(m_spellInfo->Id, m_originalCasterGUID, delaytime);
 
     // partially interrupt persistent area auras
     if (DynamicObject* dynObj = m_caster->GetDynObject(m_spellInfo->Id))
         dynObj->Delay(delaytime);
 
     SendChannelUpdate(m_timer);
 }

Here is the call graph for this function:

void Spell::DoAllEffectOnLaunchTarget	(	TargetInfo &	targetInfo,
		float *	multiplier
	)

protected

 {
     Unit* unit = NULL;
     // In case spell hit target, do all effect on that target
     if (targetInfo.missCondition == SPELL_MISS_NONE)
         unit = m_caster->GetGUID() == targetInfo.targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, targetInfo.targetGUID);
     // In case spell reflect from target, do all effect on caster (if hit)
     else if (targetInfo.missCondition == SPELL_MISS_REFLECT && targetInfo.reflectResult == SPELL_MISS_NONE)
         unit = m_caster;
     if (!unit)
         return;
 
     for (SpellEffectInfo const* effect : GetEffects())
     {
         if (effect && (targetInfo.effectMask & (1<<effect->EffectIndex)))
         {
             m_damage = 0;
             m_healing = 0;
 
             HandleEffects(unit, NULL, NULL, effect->EffectIndex, SPELL_EFFECT_HANDLE_LAUNCH_TARGET);
 
             if (m_damage > 0)
             {
                 if (effect->IsTargetingArea() || effect->IsAreaAuraEffect() || effect->IsEffect(SPELL_EFFECT_PERSISTENT_AREA_AURA))
                 {
                     m_damage = int32(float(m_damage) * unit->GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_AOE_DAMAGE_AVOIDANCE, m_spellInfo->SchoolMask));
                     if (m_caster->GetTypeId() != TYPEID_PLAYER)
                         m_damage = int32(float(m_damage) * unit->GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_CREATURE_AOE_DAMAGE_AVOIDANCE, m_spellInfo->SchoolMask));
 
                     if (m_caster->GetTypeId() == TYPEID_PLAYER)
                     {
                         uint32 targetAmount = m_UniqueTargetInfo.size();
                         if (targetAmount > 10)
                             m_damage = m_damage * 10/targetAmount;
                     }
                 }
             }
 
             if (m_applyMultiplierMask & (1 << effect->EffectIndex))
             {
                 m_damage = int32(m_damage * m_damageMultipliers[effect->EffectIndex]);
                 m_damageMultipliers[effect->EffectIndex] *= multiplier[effect->EffectIndex];
             }
             targetInfo.damage += m_damage;
         }
     }
 
     targetInfo.crit = m_caster->IsSpellCrit(unit, m_spellInfo, m_spellSchoolMask, m_attackType);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::DoAllEffectOnTarget ( TargetInfo * target )

protected

Todo:: check how broad this rule should be

 {
     if (!target || target->processed)
         return;
 
     target->processed = true;                               // Target checked in apply effects procedure
 
     // Get mask of effects for target
     uint32 mask = target->effectMask;
 
     Unit* unit = m_caster->GetGUID() == target->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, target->targetGUID);
     if (!unit && target->targetGUID.IsPlayer()) // only players may be targeted across maps
     {
         uint8 farMask = 0;
         // create far target mask
         for (SpellEffectInfo const* effect : GetEffects())
             if (effect && effect->IsFarUnitTargetEffect())
                 if ((1 << effect->EffectIndex) & mask)
                     farMask |= (1 << effect->EffectIndex);
 
         if (!farMask)
             return;
 
         // find unit in world
         unit = ObjectAccessor::FindPlayer(target->targetGUID);
         if (!unit)
             return;
 
         // do far effects on the unit
         // can't use default call because of threading, do stuff as fast as possible
         for (SpellEffectInfo const* effect : GetEffects())
             if (effect && (farMask & (1 << effect->EffectIndex)))
                 HandleEffects(unit, NULL, NULL, effect->EffectIndex, SPELL_EFFECT_HANDLE_HIT_TARGET);
         return;
     }
 
     if (!unit)
         return;
 
     if (unit->IsAlive() != target->alive)
         return;
 
     if (getState() == SPELL_STATE_DELAYED && !m_spellInfo->IsPositive() && (getMSTime() - target->timeDelay) <= unit->m_lastSanctuaryTime)
         return;                                             // No missinfo in that case
 
     // Get original caster (if exist) and calculate damage/healing from him data
     Unit* caster = m_originalCaster ? m_originalCaster : m_caster;
 
     // Skip if m_originalCaster not avaiable
     if (!caster)
         return;
 
     SpellMissInfo missInfo = target->missCondition;
 
     // Need init unitTarget by default unit (can changed in code on reflect)
     // Or on missInfo != SPELL_MISS_NONE unitTarget undefined (but need in trigger subsystem)
     unitTarget = unit;
 
     // Reset damage/healing counter
     m_damage = target->damage;
     m_healing = -target->damage;
 
     // Fill base trigger info
     uint32 procAttacker = m_procAttacker;
     uint32 procVictim   = m_procVictim;
     uint32 procEx = m_procEx;
 
     m_spellAura = NULL; // Set aura to null for every target-make sure that pointer is not used for unit without aura applied
 
                             //Spells with this flag cannot trigger if effect is cast on self
     bool canEffectTrigger = !m_spellInfo->HasAttribute(SPELL_ATTR3_CANT_TRIGGER_PROC) && unitTarget->CanProc() && (CanExecuteTriggersOnHit(mask) || missInfo == SPELL_MISS_IMMUNE || missInfo == SPELL_MISS_IMMUNE2);
     Unit* spellHitTarget = NULL;
 
     if (missInfo == SPELL_MISS_NONE)                          // In case spell hit target, do all effect on that target
         spellHitTarget = unit;
     else if (missInfo == SPELL_MISS_REFLECT)                // In case spell reflect from target, do all effect on caster (if hit)
     {
         if (target->reflectResult == SPELL_MISS_NONE)       // If reflected spell hit caster -> do all effect on him
         {
             spellHitTarget = m_caster;
             if (m_caster->GetTypeId() == TYPEID_UNIT)
                 m_caster->ToCreature()->LowerPlayerDamageReq(target->damage);
         }
     }
 
     if (spellHitTarget)
     {
         SpellMissInfo missInfo2 = DoSpellHitOnUnit(spellHitTarget, mask, target->scaleAura);
         if (missInfo2 != SPELL_MISS_NONE)
         {
             if (missInfo2 != SPELL_MISS_MISS)
                 m_caster->SendSpellMiss(unit, m_spellInfo->Id, missInfo2);
             m_damage = 0;
             spellHitTarget = NULL;
         }
     }
 
     // Do not take combo points on dodge and miss
     if (missInfo != SPELL_MISS_NONE && m_needComboPoints &&
             m_targets.GetUnitTargetGUID() == target->targetGUID)
     {
         m_needComboPoints = false;
         // Restore spell mods for a miss/dodge/parry Cold Blood
         if (m_caster->GetTypeId() == TYPEID_PLAYER && (missInfo == SPELL_MISS_MISS ||
                 missInfo == SPELL_MISS_DODGE || missInfo == SPELL_MISS_PARRY))
             m_caster->ToPlayer()->RestoreSpellMods(this, 14177);
     }
 
     // Trigger info was not filled in spell::preparedatafortriggersystem - we do it now
     if (canEffectTrigger && !procAttacker && !procVictim)
     {
         bool positive = true;
         if (m_damage > 0)
             positive = false;
         else if (!m_healing)
             positive = m_spellInfo->IsPositive();
 
         switch (m_spellInfo->DmgClass)
         {
             case SPELL_DAMAGE_CLASS_MAGIC:
                 if (positive)
                 {
                     procAttacker |= PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS;
                     procVictim   |= PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_POS;
                 }
                 else
                 {
                     procAttacker |= PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG;
                     procVictim   |= PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG;
                 }
             break;
             case SPELL_DAMAGE_CLASS_NONE:
                 if (positive)
                 {
                     procAttacker |= PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_POS;
                     procVictim   |= PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_POS;
                 }
                 else
                 {
                     procAttacker |= PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_NEG;
                     procVictim   |= PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_NEG;
                 }
             break;
         }
     }
     CallScriptOnHitHandlers();
 
     // All calculated do it!
     // Do healing and triggers
     if (m_healing > 0)
     {
         bool crit = target->crit;
         uint32 addhealth = m_healing;
         if (crit)
         {
             procEx |= PROC_EX_CRITICAL_HIT;
             addhealth = caster->SpellCriticalHealingBonus(m_spellInfo, addhealth, NULL);
         }
         else
             procEx |= PROC_EX_NORMAL_HIT;
 
         int32 gain = caster->HealBySpell(unitTarget, m_spellInfo, addhealth, crit);
         unitTarget->getHostileRefManager().threatAssist(caster, float(gain) * 0.5f, m_spellInfo);
         m_healing = gain;
 
         // Do triggers for unit (reflect triggers passed on hit phase for correct drop charge)
         if (canEffectTrigger && missInfo != SPELL_MISS_REFLECT)
             caster->ProcDamageAndSpell(unitTarget, procAttacker, procVictim, procEx, addhealth, m_attackType, m_spellInfo, m_triggeredByAuraSpell);
     }
     // Do damage and triggers
     else if (m_damage > 0)
     {
         // Fill base damage struct (unitTarget - is real spell target)
         SpellNonMeleeDamage damageInfo(caster, unitTarget, m_spellInfo->Id, m_spellSchoolMask);
 
         // Add bonuses and fill damageInfo struct
         caster->CalculateSpellDamageTaken(&damageInfo, m_damage, m_spellInfo, m_attackType, target->crit);
         caster->DealDamageMods(damageInfo.target, damageInfo.damage, &damageInfo.absorb);
 
         procEx |= createProcExtendMask(&damageInfo, missInfo);
         procVictim |= PROC_FLAG_TAKEN_DAMAGE;
 
         // Do triggers for unit (reflect triggers passed on hit phase for correct drop charge)
         if (canEffectTrigger && missInfo != SPELL_MISS_REFLECT)
         {
             caster->ProcDamageAndSpell(unitTarget, procAttacker, procVictim, procEx, damageInfo.damage, m_attackType, m_spellInfo, m_triggeredByAuraSpell);
             if (caster->GetTypeId() == TYPEID_PLAYER && (m_spellInfo->HasAttribute(SPELL_ATTR0_STOP_ATTACK_TARGET)) == 0 &&
                (m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_MELEE || m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_RANGED))
                 caster->ToPlayer()->CastItemCombatSpell(unitTarget, m_attackType, procVictim, procEx);
         }
 
         m_damage = damageInfo.damage;
 
         caster->DealSpellDamage(&damageInfo, true);
 
         // Send log damage message to client
         caster->SendSpellNonMeleeDamageLog(&damageInfo);
     }
     // Passive spell hits/misses or active spells only misses (only triggers)
     else
     {
         // Fill base damage struct (unitTarget - is real spell target)
         SpellNonMeleeDamage damageInfo(caster, unitTarget, m_spellInfo->Id, m_spellSchoolMask);
         procEx |= createProcExtendMask(&damageInfo, missInfo);
         // Do triggers for unit (reflect triggers passed on hit phase for correct drop charge)
         if (canEffectTrigger && missInfo != SPELL_MISS_REFLECT)
             caster->ProcDamageAndSpell(unit, procAttacker, procVictim, procEx, 0, m_attackType, m_spellInfo, m_triggeredByAuraSpell);
 
         // Failed Pickpocket, reveal rogue
         if (missInfo == SPELL_MISS_RESIST && m_spellInfo->HasAttribute(SPELL_ATTR0_CU_PICKPOCKET) && unitTarget->GetTypeId() == TYPEID_UNIT)
         {
             m_caster->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_TALK);
             if (unitTarget->ToCreature()->IsAIEnabled)
                 unitTarget->ToCreature()->AI()->AttackStart(m_caster);
         }
     }
 
     if (missInfo != SPELL_MISS_EVADE && !m_caster->IsFriendlyTo(unit) && (!m_spellInfo->IsPositive() || HasEffect(SPELL_EFFECT_DISPEL)))
     {
         m_caster->CombatStart(unit, !m_spellInfo->HasAttribute(SPELL_ATTR3_NO_INITIAL_AGGRO));
 
         if (m_spellInfo->HasAttribute(SPELL_ATTR0_CU_AURA_CC))
             if (!unit->IsStandState())
                 unit->SetStandState(UNIT_STAND_STATE_STAND);
     }
 
     if (spellHitTarget)
     {
         //AI functions
         if (spellHitTarget->GetTypeId() == TYPEID_UNIT)
             if (spellHitTarget->ToCreature()->IsAIEnabled)
                 spellHitTarget->ToCreature()->AI()->SpellHit(m_caster, m_spellInfo);
 
         if (m_caster->GetTypeId() == TYPEID_UNIT && m_caster->ToCreature()->IsAIEnabled)
             m_caster->ToCreature()->AI()->SpellHitTarget(spellHitTarget, m_spellInfo);
 
         // Needs to be called after dealing damage/healing to not remove breaking on damage auras
         DoTriggersOnSpellHit(spellHitTarget, mask);
 
         // if target is fallged for pvp also flag caster if a player
         if (unit->IsPvP() && m_caster->GetTypeId() == TYPEID_PLAYER)
             m_caster->ToPlayer()->UpdatePvP(true);
 
         CallScriptAfterHitHandlers();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::DoAllEffectOnTarget ( GOTargetInfo * target )

protected

 {
     if (target->processed)                                  // Check target
         return;
     target->processed = true;                               // Target checked in apply effects procedure
 
     uint32 effectMask = target->effectMask;
     if (!effectMask)
         return;
 
     GameObject* go = m_caster->GetMap()->GetGameObject(target->targetGUID);
     if (!go)
         return;
 
     PrepareScriptHitHandlers();
     CallScriptBeforeHitHandlers();
 
     for (SpellEffectInfo const* effect : GetEffects())
         if (effect && (effectMask & (1 << effect->EffectIndex)))
             HandleEffects(NULL, NULL, go, effect->EffectIndex, SPELL_EFFECT_HANDLE_HIT_TARGET);
 
     CallScriptOnHitHandlers();
     CallScriptAfterHitHandlers();
 }

Here is the call graph for this function:

void Spell::DoAllEffectOnTarget ( ItemTargetInfo * target )

protected

 {
     uint32 effectMask = target->effectMask;
     if (!target->item || !effectMask)
         return;
 
     PrepareScriptHitHandlers();
     CallScriptBeforeHitHandlers();
 
     for (SpellEffectInfo const* effect : GetEffects())
         if (effect && (effectMask & (1 << effect->EffectIndex)))
             HandleEffects(NULL, target->item, NULL, effect->EffectIndex, SPELL_EFFECT_HANDLE_HIT_TARGET);
 
     CallScriptOnHitHandlers();
 
     CallScriptAfterHitHandlers();
 }

Here is the call graph for this function:

void Spell::DoCreateItem	(	uint32	i,
		uint32	itemtype,
		std::vector< int32 > const &	bonusListIDs = `std::vector<int32>()`
	)

 {
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     Player* player = unitTarget->ToPlayer();
 
     uint32 newitemid = itemtype;
     ItemTemplate const* pProto = sObjectMgr->GetItemTemplate(newitemid);
     if (!pProto)
     {
         player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL);
         return;
     }
 
     // bg reward have some special in code work
     uint32 bgType = 0;
     switch (m_spellInfo->Id)
     {
         case SPELL_AV_MARK_WINNER:
         case SPELL_AV_MARK_LOSER:
             bgType = BATTLEGROUND_AV;
             break;
         case SPELL_WS_MARK_WINNER:
         case SPELL_WS_MARK_LOSER:
             bgType = BATTLEGROUND_WS;
             break;
         case SPELL_AB_MARK_WINNER:
         case SPELL_AB_MARK_LOSER:
             bgType = BATTLEGROUND_AB;
             break;
         default:
             break;
     }
 
     uint32 num_to_add = damage;
 
     if (num_to_add < 1)
         num_to_add = 1;
     if (num_to_add > pProto->GetMaxStackSize())
         num_to_add = pProto->GetMaxStackSize();
 
     /* == gem perfection handling == */
 
     // the chance of getting a perfect result
     float perfectCreateChance = 0.0f;
     // the resulting perfect item if successful
     uint32 perfectItemType = itemtype;
     // get perfection capability and chance
     if (CanCreatePerfectItem(player, m_spellInfo->Id, perfectCreateChance, perfectItemType))
         if (roll_chance_f(perfectCreateChance)) // if the roll succeeds...
             newitemid = perfectItemType;        // the perfect item replaces the regular one
 
     /* == gem perfection handling over == */
 
 
     /* == profession specialization handling == */
 
     // init items_count to 1, since 1 item will be created regardless of specialization
     int items_count=1;
     // the chance to create additional items
     float additionalCreateChance=0.0f;
     // the maximum number of created additional items
     uint8 additionalMaxNum=0;
     // get the chance and maximum number for creating extra items
     if (CanCreateExtraItems(player, m_spellInfo->Id, additionalCreateChance, additionalMaxNum))
         // roll with this chance till we roll not to create or we create the max num
         while (roll_chance_f(additionalCreateChance) && items_count <= additionalMaxNum)
             ++items_count;
 
     // really will be created more items
     num_to_add *= items_count;
 
     /* == profession specialization handling over == */
 
 
     // can the player store the new item?
     ItemPosCountVec dest;
     uint32 no_space = 0;
     InventoryResult msg = player->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, newitemid, num_to_add, &no_space);
     if (msg != EQUIP_ERR_OK)
     {
         // convert to possible store amount
         if (msg == EQUIP_ERR_INV_FULL || msg == EQUIP_ERR_ITEM_MAX_COUNT)
             num_to_add -= no_space;
         else
         {
             // if not created by another reason from full inventory or unique items amount limitation
             player->SendEquipError(msg, NULL, NULL, newitemid);
             return;
         }
     }
 
     if (num_to_add)
     {
         // create the new item and store it
         Item* pItem = player->StoreNewItem(dest, newitemid, true, Item::GenerateItemRandomPropertyId(newitemid), GuidSet(), bonusListIDs);
 
         // was it successful? return error if not
         if (!pItem)
         {
             player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL);
             return;
         }
 
         // set the "Crafted by ..." property of the item
         if (pItem->GetTemplate()->GetClass() != ITEM_CLASS_CONSUMABLE && pItem->GetTemplate()->GetClass() != ITEM_CLASS_QUEST && newitemid != 6265 && newitemid != 6948)
             pItem->SetGuidValue(ITEM_FIELD_CREATOR, player->GetGUID());
 
         // send info to the client
         player->SendNewItem(pItem, num_to_add, true, bgType == 0);
 
         if (pItem->GetQuality() > ITEM_QUALITY_EPIC || (pItem->GetQuality() == ITEM_QUALITY_EPIC && pItem->GetItemLevel(player) >= MinNewsItemLevel))
             if (Guild* guild = player->GetGuild())
                 guild->AddGuildNews(GUILD_NEWS_ITEM_CRAFTED, player->GetGUID(), 0, pProto->GetId());
 
 
         // we succeeded in creating at least one item, so a levelup is possible
         if (bgType == 0)
             player->UpdateCraftSkill(m_spellInfo->Id);
     }
 
 /*
     // for battleground marks send by mail if not add all expected
     if (no_space > 0 && bgType)
     {
         if (Battleground* bg = sBattlegroundMgr->GetBattlegroundTemplate(BattlegroundTypeId(bgType)))
             bg->SendRewardMarkByMail(player, newitemid, no_space);
     }
 */
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SpellMissInfo Spell::DoSpellHitOnUnit	(	Unit *	unit,
		uint32	effectMask,
		bool	scaleAura
	)

protected

Todo:: This is a hack. But we do not know what types of stealth should be interrupted by CC

Todo:: this cause soul transfer bugged

 {
     if (!unit || !effectMask)
         return SPELL_MISS_EVADE;
 
     // For delayed spells immunity may be applied between missile launch and hit - check immunity for that case
     if (m_spellInfo->Speed && (unit->IsImmunedToDamage(m_spellInfo) || unit->IsImmunedToSpell(m_spellInfo)))
         return SPELL_MISS_IMMUNE;
 
     // disable effects to which unit is immune
     SpellMissInfo returnVal = SPELL_MISS_IMMUNE;
     for (SpellEffectInfo const* effect : GetEffects())
         if (effect && (effectMask & (1 << effect->EffectIndex)))
             if (unit->IsImmunedToSpellEffect(m_spellInfo, effect->EffectIndex))
                 effectMask &= ~(1 << effect->EffectIndex);
 
     if (!effectMask)
         return returnVal;
 
     PrepareScriptHitHandlers();
     CallScriptBeforeHitHandlers();
 
     if (Player* player = unit->ToPlayer())
     {
         player->StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_SPELL_TARGET, m_spellInfo->Id);
         player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, m_spellInfo->Id, 0, 0, m_caster);
         player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2, m_spellInfo->Id);
     }
 
     if (Player* player = m_caster->ToPlayer())
     {
         player->StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_SPELL_CASTER, m_spellInfo->Id);
         player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2, m_spellInfo->Id, 0, 0, unit);
     }
 
     if (m_caster != unit)
     {
         // Recheck  UNIT_FLAG_NON_ATTACKABLE for delayed spells
         if (m_spellInfo->Speed > 0.0f && unit->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE) && unit->GetCharmerOrOwnerGUID() != m_caster->GetGUID())
             return SPELL_MISS_EVADE;
 
         if (m_caster->_IsValidAttackTarget(unit, m_spellInfo))
         {
             unit->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_HITBYSPELL);
             if ((m_spellInfo->HasAttribute(SPELL_ATTR0_CU_AURA_CC)) && unit->IsControlledByPlayer())
                 unit->RemoveAurasByType(SPELL_AURA_MOD_STEALTH);
         }
         else if (m_caster->IsFriendlyTo(unit))
         {
             // for delayed spells ignore negative spells (after duel end) for friendly targets
             // 63881 - Malady of the Mind jump spell (Yogg-Saron)
             if (m_spellInfo->Speed > 0.0f && unit->GetTypeId() == TYPEID_PLAYER && !m_spellInfo->IsPositive() && m_spellInfo->Id != 63881)
                 return SPELL_MISS_EVADE;
 
             // assisting case, healing and resurrection
             if (unit->HasUnitState(UNIT_STATE_ATTACK_PLAYER))
             {
                 m_caster->SetContestedPvP();
                 if (m_caster->GetTypeId() == TYPEID_PLAYER)
                     m_caster->ToPlayer()->UpdatePvP(true);
             }
             if (unit->IsInCombat() && !m_spellInfo->HasAttribute(SPELL_ATTR3_NO_INITIAL_AGGRO))
             {
                 m_caster->SetInCombatState(unit->GetCombatTimer() > 0, unit);
                 unit->getHostileRefManager().threatAssist(m_caster, 0.0f);
             }
         }
     }
 
     uint8 aura_effmask = 0;
     for (SpellEffectInfo const* effect : GetEffects())
         if (effect && (effectMask & (1 << effect->EffectIndex) && effect->IsUnitOwnedAuraEffect()))
             aura_effmask |= 1 << effect->EffectIndex;
 
     // Get Data Needed for Diminishing Returns, some effects may have multiple auras, so this must be done on spell hit, not aura add
     m_diminishGroup = GetDiminishingReturnsGroupForSpell(m_spellInfo);
     if (m_diminishGroup && aura_effmask)
     {
         m_diminishLevel = unit->GetDiminishing(m_diminishGroup);
         DiminishingReturnsType type = GetDiminishingReturnsGroupType(m_diminishGroup);
         // Increase Diminishing on unit, current informations for actually casts will use values above
         if ((type == DRTYPE_PLAYER &&
             (unit->GetCharmerOrOwnerPlayerOrPlayerItself() || (unit->GetTypeId() == TYPEID_UNIT && unit->ToCreature()->GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_ALL_DIMINISH))) ||
             type == DRTYPE_ALL)
             unit->IncrDiminishing(m_diminishGroup);
     }
 
     if (aura_effmask)
     {
         // Select rank for aura with level requirements only in specific cases
         // Unit has to be target only of aura effect, both caster and target have to be players, target has to be other than unit target
         SpellInfo const* aurSpellInfo = m_spellInfo;
         int32 basePoints[MAX_SPELL_EFFECTS];
         if (scaleAura)
         {
             aurSpellInfo = m_spellInfo->GetAuraRankForLevel(unitTarget->getLevel());
             ASSERT(aurSpellInfo);
             for (SpellEffectInfo const* effect : aurSpellInfo->GetEffectsForDifficulty(0))
             {
                 basePoints[effect->EffectIndex] = effect->BasePoints;
                 if (SpellEffectInfo const* myEffect = GetEffect(effect->EffectIndex))
                 {
                     if (myEffect->Effect != effect->Effect)
                     {
                         aurSpellInfo = m_spellInfo;
                         break;
                     }
                 }
             }
         }
 
         if (m_originalCaster)
         {
             bool refresh = false;
             m_spellAura = Aura::TryRefreshStackOrCreate(aurSpellInfo, effectMask, unit,
                 m_originalCaster, (aurSpellInfo == m_spellInfo) ? m_spellValue->EffectBasePoints : basePoints,
                 m_CastItem, ObjectGuid::Empty, &refresh, m_castItemLevel);
             if (m_spellAura)
             {
                 // Set aura stack amount to desired value
                 if (m_spellValue->AuraStackAmount > 1)
                 {
                     if (!refresh)
                         m_spellAura->SetStackAmount(m_spellValue->AuraStackAmount);
                     else
                         m_spellAura->ModStackAmount(m_spellValue->AuraStackAmount);
                 }
 
                 // Now Reduce spell duration using data received at spell hit
                 int32 duration = m_spellAura->GetMaxDuration();
                 int32 limitduration = m_diminishGroup ? GetDiminishingReturnsLimitDuration(aurSpellInfo) : 0;
                 float diminishMod = unit->ApplyDiminishingToDuration(m_diminishGroup, duration, m_originalCaster, m_diminishLevel, limitduration);
 
                 // unit is immune to aura if it was diminished to 0 duration
                 if (diminishMod == 0.0f)
                 {
                     m_spellAura->Remove();
                     bool found = false;
                     for (SpellEffectInfo const* effect : GetEffects())
                         if (effect && (effectMask & (1 << effect->EffectIndex) && effect->Effect != SPELL_EFFECT_APPLY_AURA))
                             found = true;
                     if (!found)
                         return SPELL_MISS_IMMUNE;
                 }
                 else
                 {
                     ((UnitAura*)m_spellAura)->SetDiminishGroup(m_diminishGroup);
 
                     bool positive = m_spellAura->GetSpellInfo()->IsPositive();
                     if (AuraApplication* aurApp = m_spellAura->GetApplicationOfTarget(m_originalCaster->GetGUID()))
                         positive = aurApp->IsPositive();
 
                     duration = m_originalCaster->ModSpellDuration(aurSpellInfo, unit, duration, positive, effectMask);
 
                     if (duration > 0)
                     {
                         // Haste modifies duration of channeled spells
                         if (m_spellInfo->IsChanneled())
                             m_originalCaster->ModSpellDurationTime(aurSpellInfo, duration, this);
                         else if (m_spellInfo->HasAttribute(SPELL_ATTR5_HASTE_AFFECT_DURATION))
                         {
                             int32 origDuration = duration;
                             duration = 0;
                             for (SpellEffectInfo const* effect : GetEffects())
                                 if (effect)
                                     if (AuraEffect const* eff = m_spellAura->GetEffect(effect->EffectIndex))
                                         if (int32 period = eff->GetPeriod())  // period is hastened by UNIT_MOD_CAST_SPEED
                                             duration = std::max(std::max(origDuration / period, 1) * period, duration);
 
                             // if there is no periodic effect
                             if (!duration)
                                 duration = int32(origDuration * m_originalCaster->GetFloatValue(UNIT_MOD_CAST_SPEED));
                         }
                     }
 
                     if (duration != m_spellAura->GetMaxDuration())
                     {
                         m_spellAura->SetMaxDuration(duration);
                         m_spellAura->SetDuration(duration);
                     }
                     m_spellAura->_RegisterForTargets();
                 }
             }
         }
     }
 
     for (SpellEffectInfo const* effect : GetEffects())
         if (effect && (effectMask & (1 << effect->EffectIndex)))
             HandleEffects(unit, NULL, NULL, effect->EffectIndex, SPELL_EFFECT_HANDLE_HIT_TARGET);
 
     return SPELL_MISS_NONE;
 }

Here is the caller graph for this function:

void Spell::DoTriggersOnSpellHit	(	Unit *	unit,
		uint8	effMask
	)

protected

Todo:: move this code to scripts

Todo:: remove/cleanup this, as this table is not documented and people are doing stupid things with it

 {
     // Apply additional spell effects to target
     if (m_preCastSpell)
     {
         // Paladin immunity shields
         if (m_preCastSpell == 61988)
         {
             // Cast Forbearance
             m_caster->CastSpell(unit, 25771, true);
             // Cast Avenging Wrath Marker
             unit->CastSpell(unit, 61987, true);
         }
 
         // Avenging Wrath
         if (m_preCastSpell == 61987)
             // Cast the serverside immunity shield marker
             m_caster->CastSpell(unit, 61988, true);
 
         if (sSpellMgr->GetSpellInfo(m_preCastSpell))
             // Blizz seems to just apply aura without bothering to cast
             m_caster->AddAura(m_preCastSpell, unit);
     }
 
     // handle SPELL_AURA_ADD_TARGET_TRIGGER auras
     // this is executed after spell proc spells on target hit
     // spells are triggered for each hit spell target
     // info confirmed with retail sniffs of permafrost and shadow weaving
     if (!m_hitTriggerSpells.empty())
     {
         int _duration = 0;
         for (HitTriggerSpellList::const_iterator i = m_hitTriggerSpells.begin(); i != m_hitTriggerSpells.end(); ++i)
         {
             if (CanExecuteTriggersOnHit(effMask, i->triggeredByAura) && roll_chance_i(i->chance))
             {
                 m_caster->CastSpell(unit, i->triggeredSpell, TriggerCastFlags(TRIGGERED_FULL_MASK & ~TRIGGERED_IGNORE_TARGET_CHECK));
                 TC_LOG_DEBUG("spells", "Spell %d triggered spell %d by SPELL_AURA_ADD_TARGET_TRIGGER aura", m_spellInfo->Id, i->triggeredSpell->Id);
 
                 // SPELL_AURA_ADD_TARGET_TRIGGER auras shouldn't trigger auras without duration
                 // set duration of current aura to the triggered spell
                 if (i->triggeredSpell->GetDuration() == -1)
                 {
                     if (Aura* triggeredAur = unit->GetAura(i->triggeredSpell->Id, m_caster->GetGUID()))
                     {
                         // get duration from aura-only once
                         if (!_duration)
                         {
                             Aura* aur = unit->GetAura(m_spellInfo->Id, m_caster->GetGUID());
                             _duration = aur ? aur->GetDuration() : -1;
                         }
                         triggeredAur->SetDuration(_duration);
                     }
                 }
             }
         }
     }
 
     // trigger linked auras remove/apply
     if (std::vector<int32> const* spellTriggered = sSpellMgr->GetSpellLinked(m_spellInfo->Id + SPELL_LINK_HIT))
     {
         for (std::vector<int32>::const_iterator i = spellTriggered->begin(); i != spellTriggered->end(); ++i)
         {
             if (*i < 0)
                 unit->RemoveAurasDueToSpell(-(*i));
             else
                 unit->CastSpell(unit, *i, true, nullptr, nullptr, m_caster->GetGUID());
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::EffectActivateGarrisonBuilding ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     if (Garrison* garrison = unitTarget->ToPlayer()->GetGarrison())
         garrison->ActivateBuilding(GetEffect(effIndex)->MiscValue);
 }

Here is the call graph for this function:

void Spell::EffectActivateObject ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!gameObjTarget)
         return;
 
     ScriptInfo activateCommand;
     activateCommand.command = SCRIPT_COMMAND_ACTIVATE_OBJECT;
 
     // int32 unk = effectInfo->MiscValue; // This is set for EffectActivateObject spells; needs research
 
     gameObjTarget->GetMap()->ScriptCommandStart(activateCommand, 0, m_caster, gameObjTarget);
 }

Here is the call graph for this function:

void Spell::EffectActivateRune ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH)
         return;
 
     if (m_caster->GetTypeId() != TYPEID_PLAYER)
         return;
 
     Player* player = m_caster->ToPlayer();
 
     if (player->getClass() != CLASS_DEATH_KNIGHT)
         return;
 
     // needed later
     m_runesState = m_caster->ToPlayer()->GetRunesState();
 
     uint32 count = damage;
     if (count == 0) count = 1;
     for (uint32 j = 0; j < MAX_RUNES && count > 0; ++j)
     {
         if (player->GetRuneCooldown(j) && player->GetCurrentRune(j) == RuneType(effectInfo->MiscValue))
         {
             if (m_spellInfo->Id == 45529)
                 if (player->GetBaseRune(j) != RuneType(effectInfo->MiscValueB))
                     continue;
             player->SetRuneCooldown(j, 0);
             --count;
         }
     }
 
     // Blood Tap
     if (m_spellInfo->Id == 45529 && count > 0)
     {
         for (uint32 l = 0; l + 1 < MAX_RUNES && count > 0; ++l)
         {
             // Check if both runes are on cd as that is the only time when this needs to come into effect
             if ((player->GetRuneCooldown(l) && player->GetCurrentRune(l) == RuneType(effectInfo->MiscValueB)) && (player->GetRuneCooldown(l + 1) && player->GetCurrentRune(l + 1) == RuneType(effectInfo->MiscValueB)))
             {
                 // Should always update the rune with the lowest cd
                 if (l + 1 < MAX_RUNES && player->GetRuneCooldown(l) >= player->GetRuneCooldown(l+1))
                     l++;
                 player->SetRuneCooldown(l, 0);
                 --count;
                 // is needed to push through to the client that the rune is active
                 player->ResyncRunes(MAX_RUNES);
             }
             else
                 break;
         }
     }
 
     // Empower rune weapon
     if (m_spellInfo->Id == 47568)
     {
         // Need to do this just once
         if (effIndex != 0)
             return;
 
         for (uint32 i = 0; i < MAX_RUNES; ++i)
         {
             if (player->GetRuneCooldown(i) && (player->GetCurrentRune(i) == RUNE_FROST ||  player->GetCurrentRune(i) == RUNE_DEATH))
                 player->SetRuneCooldown(i, 0);
         }
     }
 }

Here is the call graph for this function:

void Spell::EffectActivateSpec ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     unitTarget->ToPlayer()->ActivateTalentGroup(damage-1);  // damage is 1 or 2, spec is 0 or 1
 }

Here is the call graph for this function:

void Spell::EffectAddComboPoints ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget)
         return;
 
     if (!m_caster->m_movedPlayer)
         return;
 
     if (damage <= 0)
         return;
 
     m_caster->m_movedPlayer->AddComboPoints(damage, this);
 }

void Spell::EffectAddExtraAttacks ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || !unitTarget->IsAlive())
         return;
 
     if (unitTarget->m_extraAttacks)
         return;
 
     unitTarget->m_extraAttacks = damage;
 
     ExecuteLogEffectExtraAttacks(effIndex, unitTarget, damage);
 }

Here is the call graph for this function:

void Spell::EffectAddFarsight ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     if (m_caster->GetTypeId() != TYPEID_PLAYER)
         return;
 
     float radius = effectInfo->CalcRadius();
     int32 duration = m_spellInfo->GetDuration();
     // Caster not in world, might be spell triggered from aura removal
     if (!m_caster->IsInWorld())
         return;
 
     DynamicObject* dynObj = new DynamicObject(true);
     if (!dynObj->CreateDynamicObject(m_caster->GetMap()->GenerateLowGuid<HighGuid::DynamicObject>(), m_caster, m_spellInfo, *destTarget, radius, DYNAMIC_OBJECT_FARSIGHT_FOCUS))
     {
         delete dynObj;
         return;
     }
 
     dynObj->SetDuration(duration);
     dynObj->SetCasterViewpoint();
 }

Here is the call graph for this function:

void Spell::EffectAddGarrisonFollower ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     if (Garrison* garrison = unitTarget->ToPlayer()->GetGarrison())
         garrison->AddFollower(GetEffect(effIndex)->MiscValue);
 }

Here is the call graph for this function:

void Spell::EffectApplyAreaAura ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!m_spellAura || !unitTarget)
         return;
     ASSERT (unitTarget == m_spellAura->GetOwner());
     m_spellAura->_ApplyEffectForTargets(effIndex);
 }

Here is the call graph for this function:

void Spell::EffectApplyAura ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!m_spellAura || !unitTarget)
         return;
     ASSERT(unitTarget == m_spellAura->GetOwner());
     m_spellAura->_ApplyEffectForTargets(effIndex);
 }

Here is the call graph for this function:

void Spell::EffectApplyGlyph ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     if (m_misc.GlyphSlot >= MAX_GLYPH_SLOT_INDEX)
         return;
 
     Player* player = m_caster->ToPlayer();
     if (!player)
         return;
 
     // glyph sockets level requirement
     uint8 minLevel = 0;
     switch (m_misc.GlyphSlot)
     {
         case 0:
         case 1:
         case 6: minLevel = 25; break;
         case 2:
         case 3:
         case 7: minLevel = 50; break;
         case 4:
         case 5:
         case 8: minLevel = 75; break;
     }
 
     if (minLevel && m_caster->getLevel() < minLevel)
     {
         SendCastResult(SPELL_FAILED_GLYPH_SOCKET_LOCKED);
         return;
     }
 
     // apply new one
     if (uint32 newGlyph = effectInfo->MiscValue)
     {
         if (GlyphPropertiesEntry const* newGlyphProperties = sGlyphPropertiesStore.LookupEntry(newGlyph))
         {
             if (GlyphSlotEntry const* newGlyphSlot = sGlyphSlotStore.LookupEntry(player->GetGlyphSlot(m_misc.GlyphSlot)))
             {
                 if (newGlyphProperties->Type != newGlyphSlot->Type)
                 {
                     SendCastResult(SPELL_FAILED_INVALID_GLYPH);
                     return;                                 // glyph slot mismatch
                 }
             }
 
             // remove old glyph
             if (uint32 oldGlyph = player->GetGlyph(player->GetActiveTalentGroup(), m_misc.GlyphSlot))
             {
                 if (GlyphPropertiesEntry const* oldGlyphProperties = sGlyphPropertiesStore.LookupEntry(oldGlyph))
                 {
                     player->RemoveAurasDueToSpell(oldGlyphProperties->SpellID);
                     player->SetGlyph(m_misc.GlyphSlot, 0);
                 }
             }
 
             player->CastSpell(m_caster, newGlyphProperties->SpellID, true);
             player->SetGlyph(m_misc.GlyphSlot, newGlyph);
             player->SendTalentsInfoData();
         }
     }
     else if (uint32 oldGlyph = player->GetGlyph(player->GetActiveTalentGroup(), m_misc.GlyphSlot)) // Removing the glyph, get the old one
     {
         if (GlyphPropertiesEntry const* oldGlyphProperties = sGlyphPropertiesStore.LookupEntry(oldGlyph))
         {
             player->RemoveAurasDueToSpell(oldGlyphProperties->SpellID);
             player->SetGlyph(m_misc.GlyphSlot, 0);
             player->SendTalentsInfoData();
         }
     }
 }

Here is the call graph for this function:

void Spell::EffectBind ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     Player* player = unitTarget->ToPlayer();
 
     WorldLocation homeLoc;
     uint32 areaId = player->GetAreaId();
 
     if (effectInfo->MiscValue)
         areaId = effectInfo->MiscValue;
 
     if (m_targets.HasDst())
         homeLoc.WorldRelocate(*destTarget);
     else
         homeLoc = player->GetWorldLocation();
 
     player->SetHomebind(homeLoc, areaId);
     player->SendBindPointUpdate();
 
     TC_LOG_DEBUG("spells", "EffectBind: New homebind X: %f, Y: %f, Z: %f, MapId: %u, AreaId: %u",
         homeLoc.GetPositionX(), homeLoc.GetPositionY(), homeLoc.GetPositionZ(), homeLoc.GetMapId(), areaId);
 
     // zone update
     WorldPackets::Misc::PlayerBound packet(m_caster->GetGUID(), areaId);
     player->SendDirectMessage(packet.Write());
 }

Here is the call graph for this function:

void Spell::EffectBlock ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     if (m_caster->GetTypeId() == TYPEID_PLAYER)
         m_caster->ToPlayer()->SetCanBlock(true);
 }

Here is the call graph for this function:

void Spell::EffectCastButtons ( SpellEffIndex effIndex )

Action button data is unverified when it's set so it can be "hacked" to contain invalid spells, so filter here.

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     if (m_caster->GetTypeId() != TYPEID_PLAYER)
         return;
 
     Player* p_caster = m_caster->ToPlayer();
     uint32 button_id = effectInfo->MiscValue + 132;
     uint32 n_buttons = effectInfo->MiscValueB;
 
     for (; n_buttons; --n_buttons, ++button_id)
     {
         ActionButton const* ab = p_caster->GetActionButton(button_id);
         if (!ab || ab->GetType() != ACTION_BUTTON_SPELL)
             continue;
 
         uint32 spell_id = ab->GetAction();
         if (!spell_id)
             continue;
 
         SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spell_id);
         if (!spellInfo)
             continue;
 
         if (!p_caster->HasSpell(spell_id) || p_caster->GetSpellHistory()->HasCooldown(spell_id))
             continue;
 
         if (!spellInfo->HasAttribute(SPELL_ATTR9_SUMMON_PLAYER_TOTEM))
             continue;
 
         TriggerCastFlags triggerFlags = TriggerCastFlags(TRIGGERED_IGNORE_GCD | TRIGGERED_IGNORE_CAST_IN_PROGRESS | TRIGGERED_CAST_DIRECTLY | TRIGGERED_DONT_REPORT_CAST_ERROR);
         m_caster->CastSpell(m_caster, spell_id, triggerFlags);
     }
 }

Here is the call graph for this function:

void Spell::EffectChangeRaidMarker ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     Player* player = m_caster->ToPlayer();
     if (!player || !m_targets.HasDst())
         return;
 
     Group* group = player->GetGroup();
     if (!group || (group->isRaidGroup() && !group->IsLeader(player->GetGUID()) && !group->IsAssistant(player->GetGUID())))
         return;
 
     float x, y, z;
     destTarget->GetPosition(x, y, z);
 
     group->AddRaidMarker(damage, player->GetMapId(), x, y, z);
 }

Here is the call graph for this function:

void Spell::EffectCharge ( SpellEffIndex effIndex )

 {
     if (!unitTarget)
         return;
 
     if (effectHandleMode == SPELL_EFFECT_HANDLE_LAUNCH_TARGET)
     {
         float speed = G3D::fuzzyGt(m_spellInfo->Speed, 0.0f) ? m_spellInfo->Speed : SPEED_CHARGE;
         // Spell is not using explicit target - no generated path
         if (m_preGeneratedPath.GetPathType() == PATHFIND_BLANK)
         {
             //unitTarget->GetContactPoint(m_caster, pos.m_positionX, pos.m_positionY, pos.m_positionZ);
             Position pos = unitTarget->GetFirstCollisionPosition(unitTarget->GetObjectSize(), unitTarget->GetRelativeAngle(m_caster));
             m_caster->GetMotionMaster()->MoveCharge(pos.m_positionX, pos.m_positionY, pos.m_positionZ, speed);
         }
         else
             m_caster->GetMotionMaster()->MoveCharge(m_preGeneratedPath, speed);
     }
 
     if (effectHandleMode == SPELL_EFFECT_HANDLE_HIT_TARGET)
     {
         // not all charge effects used in negative spells
         if (!m_spellInfo->IsPositive() && m_caster->GetTypeId() == TYPEID_PLAYER)
             m_caster->Attack(unitTarget, true);
 
         if (effectInfo->TriggerSpell)
             m_caster->CastSpell(unitTarget, effectInfo->TriggerSpell, true, nullptr, nullptr, m_originalCasterGUID);
     }
 }

Here is the call graph for this function:

void Spell::EffectChargeDest ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH)
         return;
 
     if (m_targets.HasDst())
     {
         Position pos = destTarget->GetPosition();
         float angle = m_caster->GetRelativeAngle(pos.GetPositionX(), pos.GetPositionY());
         float dist = m_caster->GetDistance(pos);
         pos = m_caster->GetFirstCollisionPosition(dist, angle);
 
         m_caster->GetMotionMaster()->MoveCharge(pos.m_positionX, pos.m_positionY, pos.m_positionZ);
     }
 }

Here is the call graph for this function:

void Spell::EffectCreateAreaTrigger ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     Position pos;
     if (!m_targets.HasDst())
         pos = GetCaster()->GetPosition();
     else
         pos = destTarget->GetPosition();
 
     // trigger entry/miscvalue relation is currently unknown, for now use MiscValue as trigger entry
     uint32 triggerEntry = effectInfo->MiscValue;
 
     AreaTrigger * areaTrigger = new AreaTrigger;
     if (!areaTrigger->CreateAreaTrigger(GetCaster()->GetMap()->GenerateLowGuid<HighGuid::AreaTrigger>(), triggerEntry, GetCaster(), GetSpellInfo(), pos))
         delete areaTrigger;
 }

Here is the call graph for this function:

void Spell::EffectCreateGarrison ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     unitTarget->ToPlayer()->CreateGarrison(GetEffect(effIndex)->MiscValue);
 }

Here is the call graph for this function:

void Spell::EffectCreateHeirloomItem ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     Player* player = m_caster->ToPlayer();
     if (!player)
         return;
 
     CollectionMgr* collectionMgr = player->GetSession()->GetCollectionMgr();
     if (!collectionMgr)
         return;
 
     std::vector<int32> bonusList;
     bonusList.push_back(collectionMgr->GetHeirloomBonus(m_misc.Raw.Data[0]));
 
     DoCreateItem(effIndex, m_misc.Raw.Data[0], bonusList);
     ExecuteLogEffectCreateItem(effIndex, m_misc.Raw.Data[0]);
 }

Here is the call graph for this function:

void Spell::EffectCreateItem ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     DoCreateItem(effIndex, effectInfo->ItemType);
     ExecuteLogEffectCreateItem(effIndex, effectInfo->ItemType);
 }

Here is the call graph for this function:

void Spell::EffectCreateItem2 ( SpellEffIndex effIndex )

Todo:: ExecuteLogEffectCreateItem(i, m_spellInfo->Effects[i].ItemType);

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     Player* player = unitTarget->ToPlayer();
 
     uint32 item_id = effectInfo->ItemType;
 
     if (item_id)
         DoCreateItem(effIndex, item_id);
 
     // special case: fake item replaced by generate using spell_loot_template
     if (m_spellInfo->IsLootCrafting())
     {
         if (item_id)
         {
             if (!player->HasItemCount(item_id))
                 return;
 
             // remove reagent
             uint32 count = 1;
             player->DestroyItemCount(item_id, count, true);
 
             // create some random items
             player->AutoStoreLoot(m_spellInfo->Id, LootTemplates_Spell);
         }
         else
             player->AutoStoreLoot(m_spellInfo->Id, LootTemplates_Spell);    // create some random items
     }
 }

Here is the call graph for this function:

void Spell::EffectCreateRandomItem ( SpellEffIndex effIndex )

Todo:: ExecuteLogEffectCreateItem(i, m_spellInfo->Effects[i].ItemType);

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
     Player* player = unitTarget->ToPlayer();
 
     // create some random items
     player->AutoStoreLoot(m_spellInfo->Id, LootTemplates_Spell);
 }

Here is the call graph for this function:

void Spell::EffectCreateTamedPet ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER || !unitTarget->GetPetGUID().IsEmpty() || unitTarget->getClass() != CLASS_HUNTER)
         return;
 
     uint32 creatureEntry = effectInfo->MiscValue;
     Pet* pet = unitTarget->CreateTamedPetFrom(creatureEntry, m_spellInfo->Id);
     if (!pet)
         return;
 
     // relocate
     float px, py, pz;
     unitTarget->GetClosePoint(px, py, pz, pet->GetObjectSize(), PET_FOLLOW_DIST, pet->GetFollowAngle());
     pet->Relocate(px, py, pz, unitTarget->GetOrientation());
 
     // add to world
     pet->GetMap()->AddToMap(pet->ToCreature());
 
     // unitTarget has pet now
     unitTarget->SetMinion(pet, true);
 
     pet->InitTalentForLevel();
 
     if (unitTarget->GetTypeId() == TYPEID_PLAYER)
     {
         pet->SavePetToDB(PET_SAVE_AS_CURRENT);
         unitTarget->ToPlayer()->PetSpellInitialize();
     }
 }

Here is the call graph for this function:

void Spell::EffectDamageFromMaxHealthPCT ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget)
         return;
 
     m_damage += unitTarget->CountPctFromMaxHealth(damage);
 }

Here is the call graph for this function:

void Spell::EffectDestroyAllTotems ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     int32 mana = 0;
     for (uint8 slot = SUMMON_SLOT_TOTEM; slot < MAX_TOTEM_SLOT; ++slot)
     {
         if (!m_caster->m_SummonSlot[slot])
             continue;
 
         Creature* totem = m_caster->GetMap()->GetCreature(m_caster->m_SummonSlot[slot]);
         if (totem && totem->IsTotem())
         {
             uint32 spell_id = totem->GetUInt32Value(UNIT_CREATED_BY_SPELL);
             SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spell_id);
             if (spellInfo)
             {
                 std::vector<SpellInfo::CostData> costs = spellInfo->CalcPowerCost(m_caster, spellInfo->GetSchoolMask());
                 auto m = std::find_if(costs.begin(), costs.end(), [](SpellInfo::CostData const& cost) { return cost.Power == POWER_MANA; });
                 if (m != costs.end())
                     mana += m->Amount;
             }
 
             totem->ToTotem()->UnSummon();
         }
     }
 
     ApplyPct(mana, damage);
 
     if (mana)
         m_caster->CastCustomSpell(m_caster, 39104, &mana, NULL, NULL, true);
 }

Here is the call graph for this function:

void Spell::EffectDestroyItem ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     Player* player = unitTarget->ToPlayer();
     SpellEffectInfo const* effect = GetEffect(effIndex);
     uint32 itemId = effect->ItemType;
     if (Item* item = player->GetItemByEntry(itemId))
         player->DestroyItem(item->GetBagSlot(), item->GetSlot(), true);
 }

Here is the call graph for this function:

void Spell::EffectDiscoverTaxi ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
     uint32 nodeid = effectInfo->MiscValue;
     if (sTaxiNodesStore.LookupEntry(nodeid))
         unitTarget->ToPlayer()->GetSession()->SendDiscoverNewTaxiNode(nodeid);
 }

Here is the call graph for this function:

void Spell::EffectDisEnchant ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!itemTarget || !itemTarget->GetTemplate()->DisenchantID)
         return;
 
     if (Player* caster = m_caster->ToPlayer())
     {
         caster->UpdateCraftSkill(m_spellInfo->Id);
         caster->SendLoot(itemTarget->GetGUID(), LOOT_DISENCHANTING);
     }
 
     // item will be removed at disenchanting end
 }

Here is the call graph for this function:

void Spell::EffectDismissPet ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || !unitTarget->IsPet())
         return;
 
     Pet* pet = unitTarget->ToPet();
 
     ExecuteLogEffectUnsummonObject(effIndex, pet);
     pet->GetOwner()->RemovePet(pet, PET_SAVE_NOT_IN_SLOT);
 }

Here is the call graph for this function:

void Spell::EffectDispel ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget)
         return;
 
     // Create dispel mask by dispel type
     uint32 dispel_type = effectInfo->MiscValue;
     uint32 dispelMask  = SpellInfo::GetDispelMask(DispelType(dispel_type));
 
     DispelChargesList dispel_list;
     unitTarget->GetDispellableAuraList(m_caster, dispelMask, dispel_list);
     if (dispel_list.empty())
         return;
 
     // Ok if exist some buffs for dispel try dispel it
     DispelChargesList success_list;
     WorldPackets::Spells::DispelFailed dispelFailed;
     dispelFailed.CasterGUID = m_caster->GetGUID();
     dispelFailed.VictimGUID = unitTarget->GetGUID();
     dispelFailed.SpellID = m_spellInfo->Id;
 
     // dispel N = damage buffs (or while exist buffs for dispel)
     for (int32 count = 0; count < damage && !dispel_list.empty();)
     {
         // Random select buff for dispel
         DispelChargesList::iterator itr = dispel_list.begin();
         std::advance(itr, urand(0, dispel_list.size() - 1));
 
         int32 chance = itr->first->CalcDispelChance(unitTarget, !unitTarget->IsFriendlyTo(m_caster));
         // 2.4.3 Patch Notes: "Dispel effects will no longer attempt to remove effects that have 100% dispel resistance."
         if (!chance)
         {
             dispel_list.erase(itr);
             continue;
         }
         else
         {
             if (roll_chance_i(chance))
             {
                 bool alreadyListed = false;
                 for (DispelChargesList::iterator successItr = success_list.begin(); successItr != success_list.end(); ++successItr)
                 {
                     if (successItr->first->GetId() == itr->first->GetId())
                     {
                         ++successItr->second;
                         alreadyListed = true;
                     }
                 }
                 if (!alreadyListed)
                     success_list.push_back(std::make_pair(itr->first, 1));
                 --itr->second;
                 if (itr->second <= 0)
                     dispel_list.erase(itr);
             }
             else
                 dispelFailed.FailedSpells.push_back(int32(itr->first->GetId()));
 
             ++count;
         }
     }
 
     if (!dispelFailed.FailedSpells.empty())
         m_caster->SendMessageToSet(dispelFailed.Write(), true);
 
     if (success_list.empty())
         return;
 
     WorldPackets::CombatLog::SpellDispellLog spellDispellLog;
     spellDispellLog.IsBreak = false; // TODO: use me
     spellDispellLog.IsSteal = false;
 
     spellDispellLog.TargetGUID = unitTarget->GetGUID();
     spellDispellLog.CasterGUID = m_caster->GetGUID();
     spellDispellLog.DispelledBySpellID = m_spellInfo->Id;
 
     for (std::pair<Aura*, uint8> const& dispellCharge : success_list)
     {
         WorldPackets::CombatLog::SpellDispellData dispellData;
         dispellData.SpellID = dispellCharge.first->GetId();
         dispellData.Harmful = false;      // TODO: use me
         dispellData.Rolled = boost::none; // TODO: use me
         dispellData.Needed = boost::none; // TODO: use me
 
         unitTarget->RemoveAurasDueToSpellByDispel(dispellCharge.first->GetId(), m_spellInfo->Id, dispellCharge.first->GetCasterGUID(), m_caster, dispellCharge.second);
 
         spellDispellLog.DispellData.emplace_back(dispellData);
     }
 
     m_caster->SendMessageToSet(spellDispellLog.Write(), true);
 
     CallScriptSuccessfulDispel(effIndex);
 }

Here is the call graph for this function:

void Spell::EffectDispelMechanic ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget)
         return;
 
     uint32 mechanic = effectInfo->MiscValue;
     DispelList dispel_list;
     Unit::AuraMap const& auras = unitTarget->GetOwnedAuras();
     for (Unit::AuraMap::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
     {
         Aura* aura = itr->second;
         if (!aura->GetApplicationOfTarget(unitTarget->GetGUID()))
             continue;
         if (roll_chance_i(aura->CalcDispelChance(unitTarget, !unitTarget->IsFriendlyTo(m_caster))))
             if ((aura->GetSpellInfo()->GetAllEffectsMechanicMask() & (1 << mechanic)))
                 dispel_list.push_back(std::make_pair(aura->GetId(), aura->GetCasterGUID()));
     }
 
     while (!dispel_list.empty())
     {
         unitTarget->RemoveAura(dispel_list.front().first, dispel_list.front().second, 0, AURA_REMOVE_BY_ENEMY_SPELL);
         dispel_list.pop_front();
     }
 }

Here is the call graph for this function:

void Spell::EffectDistract ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     // Check for possible target
     if (!unitTarget || unitTarget->IsInCombat())
         return;
 
     // target must be OK to do this
     if (unitTarget->HasUnitState(UNIT_STATE_CONFUSED | UNIT_STATE_STUNNED | UNIT_STATE_FLEEING))
         return;
 
     unitTarget->SetFacingTo(unitTarget->GetAngle(destTarget));
     unitTarget->ClearUnitState(UNIT_STATE_MOVING);
 
     if (unitTarget->GetTypeId() == TYPEID_UNIT)
         unitTarget->GetMotionMaster()->MoveDistract(damage * IN_MILLISECONDS);
 }

Here is the call graph for this function:

void Spell::EffectDualWield ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     unitTarget->SetCanDualWield(true);
 }

Here is the call graph for this function:

void Spell::EffectDuel ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || m_caster->GetTypeId() != TYPEID_PLAYER || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     Player* caster = m_caster->ToPlayer();
     Player* target = unitTarget->ToPlayer();
 
     // caster or target already have requested duel
     if (caster->duel || target->duel || !target->GetSocial() || target->GetSocial()->HasIgnore(caster->GetGUID()))
         return;
 
     // Players can only fight a duel in zones with this flag
     AreaTableEntry const* casterAreaEntry = sAreaTableStore.LookupEntry(caster->GetAreaId());
     if (casterAreaEntry && !(casterAreaEntry->Flags[0] & AREA_FLAG_ALLOW_DUELS))
     {
         SendCastResult(SPELL_FAILED_NO_DUELING);            // Dueling isn't allowed here
         return;
     }
 
     AreaTableEntry const* targetAreaEntry = sAreaTableStore.LookupEntry(target->GetAreaId());
     if (targetAreaEntry && !(targetAreaEntry->Flags[0] & AREA_FLAG_ALLOW_DUELS))
     {
         SendCastResult(SPELL_FAILED_NO_DUELING);            // Dueling isn't allowed here
         return;
     }
 
     //CREATE DUEL FLAG OBJECT
     GameObject* pGameObj = new GameObject;
 
     uint32 gameobject_id = effectInfo->MiscValue;
 
     Map* map = m_caster->GetMap();
     if (!pGameObj->Create(map->GenerateLowGuid<HighGuid::GameObject>(), gameobject_id,
         map, 0,
         m_caster->GetPositionX()+(unitTarget->GetPositionX()-m_caster->GetPositionX())/2,
         m_caster->GetPositionY()+(unitTarget->GetPositionY()-m_caster->GetPositionY())/2,
         m_caster->GetPositionZ(),
         m_caster->GetOrientation(), 0.0f, 0.0f, 0.0f, 0.0f, 0, GO_STATE_READY))
     {
         delete pGameObj;
         return;
     }
 
     pGameObj->CopyPhaseFrom(m_caster);
 
     pGameObj->SetUInt32Value(GAMEOBJECT_FACTION, m_caster->getFaction());
     pGameObj->SetUInt32Value(GAMEOBJECT_LEVEL, m_caster->getLevel()+1);
     int32 duration = m_spellInfo->GetDuration();
     pGameObj->SetRespawnTime(duration > 0 ? duration/IN_MILLISECONDS : 0);
     pGameObj->SetSpellId(m_spellInfo->Id);
 
     ExecuteLogEffectSummonObject(effIndex, pGameObj);
 
     m_caster->AddGameObject(pGameObj);
     map->AddToMap(pGameObj);
     //END
 
     // Send request
     WorldPackets::Duel::DuelRequested packet;
     packet.ArbiterGUID = pGameObj->GetGUID();
     packet.RequestedByGUID = caster->GetGUID();
     packet.RequestedByWowAccount = caster->GetSession()->GetAccountGUID();
 
     WorldPacket const* worldPacket = packet.Write();
     caster->GetSession()->SendPacket(worldPacket);
     target->GetSession()->SendPacket(worldPacket);
 
     // create duel-info
     DuelInfo* duel   = new DuelInfo;
     duel->initiator  = caster;
     duel->opponent   = target;
     duel->startTime  = 0;
     duel->startTimer = 0;
     duel->isMounted  = (GetSpellInfo()->Id == 62875); // Mounted Duel
     caster->duel     = duel;
 
     DuelInfo* duel2   = new DuelInfo;
     duel2->initiator  = caster;
     duel2->opponent   = caster;
     duel2->startTime  = 0;
     duel2->startTimer = 0;
     duel2->isMounted  = (GetSpellInfo()->Id == 62875); // Mounted Duel
     target->duel      = duel2;
 
     caster->SetGuidValue(PLAYER_DUEL_ARBITER, pGameObj->GetGUID());
     target->SetGuidValue(PLAYER_DUEL_ARBITER, pGameObj->GetGUID());
 
     sScriptMgr->OnPlayerDuelRequest(target, caster);
 }

Here is the call graph for this function:

void Spell::EffectDummy ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget && !gameObjTarget && !itemTarget)
         return;
 
     // selection by spell family
     switch (m_spellInfo->SpellFamilyName)
     {
         case SPELLFAMILY_PALADIN:
             switch (m_spellInfo->Id)
             {
                 case 31789:                                 // Righteous Defense (step 1)
                 {
                     // Clear targets for eff 1
                     for (std::vector<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
                         ihit->effectMask &= ~(1<<1);
 
                     // not empty (checked), copy
                     Unit::AttackerSet attackers = unitTarget->getAttackers();
 
                     // remove invalid attackers
                     for (Unit::AttackerSet::iterator aItr = attackers.begin(); aItr != attackers.end();)
                         if (!(*aItr)->IsValidAttackTarget(m_caster))
                             attackers.erase(aItr++);
                         else
                             ++aItr;
 
                     // selected from list 3
                     uint32 maxTargets = std::min<uint32>(3, attackers.size());
                     for (uint32 i = 0; i < maxTargets; ++i)
                     {
                         Unit* attacker = Trinity::Containers::SelectRandomContainerElement(attackers);
                         AddUnitTarget(attacker, 1 << 1);
                         attackers.erase(attacker);
                     }
 
                     // now let next effect cast spell at each target.
                     return;
                 }
             }
             break;
         default:
             break;
     }
 
     // pet auras
     if (PetAura const* petSpell = sSpellMgr->GetPetAura(m_spellInfo->Id, effIndex))
     {
         m_caster->AddPetAura(petSpell);
         return;
     }
 
     // normal DB scripted effect
     TC_LOG_DEBUG("spells", "Spell ScriptStart spellid %u in EffectDummy(%u)", m_spellInfo->Id, effIndex);
     m_caster->GetMap()->ScriptsStart(sSpellScripts, uint32(m_spellInfo->Id | (effIndex << 24)), m_caster, unitTarget);
 
     // Script based implementation. Must be used only for not good for implementation in core spell effects
     // So called only for not proccessed cases
     if (gameObjTarget)
         sScriptMgr->OnDummyEffect(m_caster, m_spellInfo->Id, effIndex, gameObjTarget);
     else if (unitTarget && unitTarget->GetTypeId() == TYPEID_UNIT)
         sScriptMgr->OnDummyEffect(m_caster, m_spellInfo->Id, effIndex, unitTarget->ToCreature());
     else if (itemTarget)
         sScriptMgr->OnDummyEffect(m_caster, m_spellInfo->Id, effIndex, itemTarget);
 }

Here is the call graph for this function:

void Spell::EffectDurabilityDamage ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     int32 slot = effectInfo->MiscValue;
 
     // -1 means all player equipped items and -2 all items
     if (slot < 0)
     {
         unitTarget->ToPlayer()->DurabilityPointsLossAll(damage, (slot < -1));
         ExecuteLogEffectDurabilityDamage(effIndex, unitTarget, -1, -1);
         return;
     }
 
     // invalid slot value
     if (slot >= INVENTORY_SLOT_BAG_END)
         return;
 
     if (Item* item = unitTarget->ToPlayer()->GetItemByPos(INVENTORY_SLOT_BAG_0, slot))
     {
         unitTarget->ToPlayer()->DurabilityPointsLoss(item, damage);
         ExecuteLogEffectDurabilityDamage(effIndex, unitTarget, item->GetEntry(), slot);
     }
 }

Here is the call graph for this function:

void Spell::EffectDurabilityDamagePCT ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     int32 slot = effectInfo->MiscValue;
 
     // FIXME: some spells effects have value -1/-2
     // Possibly its mean -1 all player equipped items and -2 all items
     if (slot < 0)
     {
         unitTarget->ToPlayer()->DurabilityLossAll(float(damage) / 100.0f, (slot < -1));
         return;
     }
 
     // invalid slot value
     if (slot >= INVENTORY_SLOT_BAG_END)
         return;
 
     if (damage <= 0)
         return;
 
     if (Item* item = unitTarget->ToPlayer()->GetItemByPos(INVENTORY_SLOT_BAG_0, slot))
         unitTarget->ToPlayer()->DurabilityLoss(item, float(damage) / 100.0f);
 }

Here is the call graph for this function:

void Spell::EffectEnableBattlePets ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     Player* plr = unitTarget->ToPlayer();
     plr->SetFlag(PLAYER_FLAGS, PLAYER_FLAGS_PET_BATTLES_UNLOCKED);
     plr->GetSession()->GetBattlePetMgr()->UnlockSlot(0);
 }

Here is the call graph for this function:

void Spell::EffectEnchantHeldItem ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     // this is only item spell effect applied to main-hand weapon of target player (players in area)
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     Player* item_owner = unitTarget->ToPlayer();
     Item* item = item_owner->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND);
 
     if (!item)
         return;
 
     // must be equipped
     if (!item->IsEquipped())
         return;
 
     if (effectInfo->MiscValue)
     {
         uint32 enchant_id = effectInfo->MiscValue;
         int32 duration = m_spellInfo->GetDuration(); //Try duration index first ..
         if (!duration)
             duration = damage;//+1;                  //Base points after ..
         if (!duration)
             duration = 10 * IN_MILLISECONDS;         //10 seconds for enchants which don't have listed duration
 
         if (m_spellInfo->Id == 14792) // Venomhide Poison
             duration = 5 * MINUTE * IN_MILLISECONDS;
 
         SpellItemEnchantmentEntry const* pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
         if (!pEnchant)
             return;
 
         // Always go to temp enchantment slot
         EnchantmentSlot slot = TEMP_ENCHANTMENT_SLOT;
 
         // Enchantment will not be applied if a different one already exists
         if (item->GetEnchantmentId(slot) && item->GetEnchantmentId(slot) != enchant_id)
             return;
 
         // Apply the temporary enchantment
         item->SetEnchantment(slot, enchant_id, duration, 0, m_caster->GetGUID());
         item_owner->ApplyEnchantment(item, slot, true);
     }
 }

Here is the call graph for this function:

void Spell::EffectEnchantItemPerm ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!itemTarget)
         return;
 
     Player* player = m_caster->ToPlayer();
     if (!player)
         return;
 
     // Handle vellums
     if (itemTarget->IsVellum())
     {
         // destroy one vellum from stack
         uint32 count = 1;
         player->DestroyItemCount(itemTarget, count, true);
         unitTarget = player;
         // and add a scroll
         DoCreateItem(effIndex, effectInfo->ItemType);
         itemTarget = NULL;
         m_targets.SetItemTarget(NULL);
     }
     else
     {
         // do not increase skill if vellum used
         if (!(m_CastItem && m_CastItem->GetTemplate()->GetFlags() & ITEM_FLAG_TRIGGERED_CAST))
             player->UpdateCraftSkill(m_spellInfo->Id);
 
         uint32 enchant_id = effectInfo->MiscValue;
         if (!enchant_id)
             return;
 
         SpellItemEnchantmentEntry const* pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
         if (!pEnchant)
             return;
 
         // item can be in trade slot and have owner diff. from caster
         Player* item_owner = itemTarget->GetOwner();
         if (!item_owner)
             return;
 
         if (item_owner != player && player->GetSession()->HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))
         {
             sLog->outCommand(player->GetSession()->GetAccountId(), "GM %s (Account: %u) enchanting(perm): %s (Entry: %d) for player: %s (Account: %u)",
                 player->GetName().c_str(), player->GetSession()->GetAccountId(),
                 itemTarget->GetTemplate()->GetDefaultLocaleName(), itemTarget->GetEntry(),
                 item_owner->GetName().c_str(), item_owner->GetSession()->GetAccountId());
         }
 
         // remove old enchanting before applying new if equipped
         item_owner->ApplyEnchantment(itemTarget, PERM_ENCHANTMENT_SLOT, false);
 
         itemTarget->SetEnchantment(PERM_ENCHANTMENT_SLOT, enchant_id, 0, 0, m_caster->GetGUID());
 
         // add new enchanting if equipped
         item_owner->ApplyEnchantment(itemTarget, PERM_ENCHANTMENT_SLOT, true);
 
         item_owner->RemoveTradeableItem(itemTarget);
         itemTarget->ClearSoulboundTradeable(item_owner);
     }
 }

Here is the call graph for this function:

void Spell::EffectEnchantItemPrismatic ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!itemTarget)
         return;
 
     Player* player = m_caster->ToPlayer();
     if (!player)
         return;
 
     uint32 enchantId = effectInfo->MiscValue;
     if (!enchantId)
         return;
 
     SpellItemEnchantmentEntry const* enchant = sSpellItemEnchantmentStore.LookupEntry(enchantId);
     if (!enchant)
         return;
 
     // support only enchantings with add socket in this slot
     {
         bool add_socket = false;
         for (uint8 i = 0; i < MAX_ITEM_ENCHANTMENT_EFFECTS; ++i)
         {
             if (enchant->Effect[i] == ITEM_ENCHANTMENT_TYPE_PRISMATIC_SOCKET)
             {
                 add_socket = true;
                 break;
             }
         }
         if (!add_socket)
         {
             TC_LOG_ERROR("spells", "Spell::EffectEnchantItemPrismatic: attempt apply enchant spell %u with SPELL_EFFECT_ENCHANT_ITEM_PRISMATIC (%u) but without ITEM_ENCHANTMENT_TYPE_PRISMATIC_SOCKET (%u), not suppoted yet.",
                 m_spellInfo->Id, SPELL_EFFECT_ENCHANT_ITEM_PRISMATIC, ITEM_ENCHANTMENT_TYPE_PRISMATIC_SOCKET);
             return;
         }
     }
 
     // item can be in trade slot and have owner diff. from caster
     Player* item_owner = itemTarget->GetOwner();
     if (!item_owner)
         return;
 
     if (item_owner != player && player->GetSession()->HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))
     {
         sLog->outCommand(player->GetSession()->GetAccountId(), "GM %s (Account: %u) enchanting(perm): %s (Entry: %d) for player: %s (Account: %u)",
             player->GetName().c_str(), player->GetSession()->GetAccountId(),
             itemTarget->GetTemplate()->GetDefaultLocaleName(), itemTarget->GetEntry(),
             item_owner->GetName().c_str(), item_owner->GetSession()->GetAccountId());
     }
 
     // remove old enchanting before applying new if equipped
     item_owner->ApplyEnchantment(itemTarget, PRISMATIC_ENCHANTMENT_SLOT, false);
 
     itemTarget->SetEnchantment(PRISMATIC_ENCHANTMENT_SLOT, enchantId, 0, 0, m_caster->GetGUID());
 
     // add new enchanting if equipped
     item_owner->ApplyEnchantment(itemTarget, PRISMATIC_ENCHANTMENT_SLOT, true);
 
     item_owner->RemoveTradeableItem(itemTarget);
     itemTarget->ClearSoulboundTradeable(item_owner);
 }

Here is the call graph for this function:

void Spell::EffectEnchantItemTmp ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     Player* player = m_caster->ToPlayer();
     if (!player)
         return;
 
     if (!itemTarget)
         return;
 
     uint32 enchant_id = effectInfo->MiscValue;
 
     if (!enchant_id)
     {
         TC_LOG_ERROR("spells", "Spell %u Effect %u (SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY) have 0 as enchanting id", m_spellInfo->Id, effIndex);
         return;
     }
 
     SpellItemEnchantmentEntry const* pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
     if (!pEnchant)
     {
         TC_LOG_ERROR("spells", "Spell %u Effect %u (SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY) have not existed enchanting id %u ", m_spellInfo->Id, effIndex, enchant_id);
         return;
     }
 
     // select enchantment duration
     uint32 duration;
 
     // rogue family enchantments exception by duration
     if (m_spellInfo->Id == 38615)
         duration = 1800;                                    // 30 mins
     // other rogue family enchantments always 1 hour (some have spell damage=0, but some have wrong data in EffBasePoints)
     else if (m_spellInfo->SpellFamilyName == SPELLFAMILY_ROGUE)
         duration = 3600;                                    // 1 hour
     // shaman family enchantments
     else if (m_spellInfo->SpellFamilyName == SPELLFAMILY_SHAMAN)
         duration = 3600;                                    // 30 mins
     // other cases with this SpellVisual already selected
     else if (m_spellInfo->GetSpellVisual(DIFFICULTY_NONE) == 215)
         duration = 1800;                                    // 30 mins
     // some fishing pole bonuses except Glow Worm which lasts full hour
     else if (m_spellInfo->GetSpellVisual(DIFFICULTY_NONE) == 563 && m_spellInfo->Id != 64401)
         duration = 600;                                     // 10 mins
     else if (m_spellInfo->Id == 29702)
         duration = 300;                                     // 5 mins
     else if (m_spellInfo->Id == 37360)
         duration = 300;                                     // 5 mins
     // default case
     else
         duration = 3600;                                    // 1 hour
 
     // item can be in trade slot and have owner diff. from caster
     Player* item_owner = itemTarget->GetOwner();
     if (!item_owner)
         return;
 
     if (item_owner != player && player->GetSession()->HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))
     {
         sLog->outCommand(player->GetSession()->GetAccountId(), "GM %s (Account: %u) enchanting(temp): %s (Entry: %d) for player: %s (Account: %u)",
             player->GetName().c_str(), player->GetSession()->GetAccountId(),
             itemTarget->GetTemplate()->GetDefaultLocaleName(), itemTarget->GetEntry(),
             item_owner->GetName().c_str(), item_owner->GetSession()->GetAccountId());
     }
 
     // remove old enchanting before applying new if equipped
     item_owner->ApplyEnchantment(itemTarget, TEMP_ENCHANTMENT_SLOT, false);
 
     itemTarget->SetEnchantment(TEMP_ENCHANTMENT_SLOT, enchant_id, duration * 1000, 0, m_caster->GetGUID());
 
     // add new enchanting if equipped
     item_owner->ApplyEnchantment(itemTarget, TEMP_ENCHANTMENT_SLOT, true);
 }

Here is the call graph for this function:

void Spell::EffectEnergize ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget)
         return;
     if (!unitTarget->IsAlive())
         return;
 
     if (effectInfo->MiscValue < 0 || effectInfo->MiscValue >= int8(MAX_POWERS))
         return;
 
     Powers power = Powers(effectInfo->MiscValue);
 
     if (unitTarget->GetTypeId() == TYPEID_PLAYER && unitTarget->getPowerType() != power && !m_spellInfo->HasAttribute(SPELL_ATTR7_CAN_RESTORE_SECONDARY_POWER))
         return;
 
     if (unitTarget->GetMaxPower(power) == 0)
         return;
 
     // Some level depends spells
     int level_multiplier = 0;
     int level_diff = 0;
     switch (m_spellInfo->Id)
     {
         case 9512:                                          // Restore Energy
             level_diff = m_caster->getLevel() - 40;
             level_multiplier = 2;
             break;
         case 24571:                                         // Blood Fury
             level_diff = m_caster->getLevel() - 60;
             level_multiplier = 10;
             break;
         case 24532:                                         // Burst of Energy
             level_diff = m_caster->getLevel() - 60;
             level_multiplier = 4;
             break;
         case 31930:                                         // Judgements of the Wise
         case 63375:                                         // Primal Wisdom
         case 68082:                                         // Glyph of Seal of Command
             damage = int32(CalculatePct(unitTarget->GetCreateMana(), damage));
             break;
         case 67490:                                         // Runic Mana Injector (mana gain increased by 25% for engineers - 3.2.0 patch change)
         {
             if (Player* player = m_caster->ToPlayer())
                 if (player->HasSkill(SKILL_ENGINEERING))
                     AddPct(damage, 25);
             break;
         }
         default:
             break;
     }
 
     if (level_diff > 0)
         damage -= level_multiplier * level_diff;
 
     if (damage < 0 && power != POWER_ECLIPSE)
         return;
 
     m_caster->EnergizeBySpell(unitTarget, m_spellInfo->Id, damage, power);
 
     // Mad Alchemist's Potion
     if (m_spellInfo->Id == 45051)
     {
         // find elixirs on target
         bool guardianFound = false;
         bool battleFound = false;
         Unit::AuraApplicationMap& Auras = unitTarget->GetAppliedAuras();
         for (Unit::AuraApplicationMap::iterator itr = Auras.begin(); itr != Auras.end(); ++itr)
         {
             uint32 spell_id = itr->second->GetBase()->GetId();
             if (!guardianFound)
                 if (sSpellMgr->IsSpellMemberOfSpellGroup(spell_id, SPELL_GROUP_ELIXIR_GUARDIAN))
                     guardianFound = true;
             if (!battleFound)
                 if (sSpellMgr->IsSpellMemberOfSpellGroup(spell_id, SPELL_GROUP_ELIXIR_BATTLE))
                     battleFound = true;
             if (battleFound && guardianFound)
                 break;
         }
 
         // get all available elixirs by mask and spell level
         std::set<uint32> avalibleElixirs;
         if (!guardianFound)
             sSpellMgr->GetSetOfSpellsInSpellGroup(SPELL_GROUP_ELIXIR_GUARDIAN, avalibleElixirs);
         if (!battleFound)
             sSpellMgr->GetSetOfSpellsInSpellGroup(SPELL_GROUP_ELIXIR_BATTLE, avalibleElixirs);
         for (std::set<uint32>::iterator itr = avalibleElixirs.begin(); itr != avalibleElixirs.end();)
         {
             SpellInfo const* spellInfo = sSpellMgr->AssertSpellInfo(*itr);
             if (spellInfo->SpellLevel < m_spellInfo->SpellLevel || spellInfo->SpellLevel > unitTarget->getLevel())
                 avalibleElixirs.erase(itr++);
             else if (sSpellMgr->IsSpellMemberOfSpellGroup(*itr, SPELL_GROUP_ELIXIR_SHATTRATH))
                 avalibleElixirs.erase(itr++);
             else if (sSpellMgr->IsSpellMemberOfSpellGroup(*itr, SPELL_GROUP_ELIXIR_UNSTABLE))
                 avalibleElixirs.erase(itr++);
             else
                 ++itr;
         }
 
         if (!avalibleElixirs.empty())
         {
             // cast random elixir on target
             m_caster->CastSpell(unitTarget, Trinity::Containers::SelectRandomContainerElement(avalibleElixirs), true, m_CastItem);
         }
     }
 }

Here is the call graph for this function:

void Spell::EffectEnergizePct ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget)
         return;
     if (!unitTarget->IsAlive())
         return;
 
     if (effectInfo->MiscValue < 0 || effectInfo->MiscValue >= int8(MAX_POWERS))
         return;
 
     Powers power = Powers(effectInfo->MiscValue);
 
     if (unitTarget->GetTypeId() == TYPEID_PLAYER && unitTarget->getPowerType() != power && !m_spellInfo->HasAttribute(SPELL_ATTR7_CAN_RESTORE_SECONDARY_POWER))
         return;
 
     uint32 maxPower = unitTarget->GetMaxPower(power);
     if (maxPower == 0)
         return;
 
     uint32 gain = CalculatePct(maxPower, damage);
     m_caster->EnergizeBySpell(unitTarget, m_spellInfo->Id, gain, power);
 }

Here is the call graph for this function:

void Spell::EffectEnvironmentalDMG ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || !unitTarget->IsAlive())
         return;
 
     uint32 absorb = 0;
     uint32 resist = 0;
 
     m_caster->CalcAbsorbResist(unitTarget, m_spellInfo->GetSchoolMask(), SPELL_DIRECT_DAMAGE, damage, &absorb, &resist, m_spellInfo);
     SpellNonMeleeDamage log(m_caster, unitTarget, m_spellInfo->Id, m_spellInfo->GetSchoolMask());
     log.damage = damage - absorb - resist;
     log.absorb = absorb;
     log.resist = resist;
     if (unitTarget->GetTypeId() == TYPEID_PLAYER)
         unitTarget->ToPlayer()->EnvironmentalDamage(DAMAGE_FIRE, damage);
 
     m_caster->SendSpellNonMeleeDamageLog(&log);
 }

Here is the call graph for this function:

void Spell::EffectFeedPet ( SpellEffIndex effIndex )

Todo:: fix crash when a spell has two effects, both pointed at the same item target

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     Player* player = m_caster->ToPlayer();
     if (!player)
         return;
 
     Item* foodItem = itemTarget;
     if (!foodItem)
         return;
 
     Pet* pet = player->GetPet();
     if (!pet)
         return;
 
     if (!pet->IsAlive())
         return;
 
     int32 benefit = pet->GetCurrentFoodBenefitLevel(foodItem->GetTemplate()->GetBaseItemLevel());
     if (benefit <= 0)
         return;
 
     ExecuteLogEffectDestroyItem(effIndex, foodItem->GetEntry());
 
     uint32 count = 1;
     player->DestroyItemCount(foodItem, count, true);
 
     m_caster->CastCustomSpell(pet, effectInfo->TriggerSpell, &benefit, NULL, NULL, true);
 }

Here is the call graph for this function:

void Spell::EffectForceCast ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget)
         return;
 
     uint32 triggered_spell_id = effectInfo->TriggerSpell;
 
     // normal case
     SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(triggered_spell_id);
 
     if (!spellInfo)
     {
         TC_LOG_ERROR("spells", "Spell::EffectForceCast of spell %u: triggering unknown spell id %i", m_spellInfo->Id, triggered_spell_id);
         return;
     }
 
     if (effectInfo->Effect == SPELL_EFFECT_FORCE_CAST && damage)
     {
         switch (m_spellInfo->Id)
         {
             case 52588: // Skeletal Gryphon Escape
             case 48598: // Ride Flamebringer Cue
                 unitTarget->RemoveAura(damage);
                 break;
             case 52463: // Hide In Mine Car
             case 52349: // Overtake
                 unitTarget->CastCustomSpell(unitTarget, spellInfo->Id, &damage, NULL, NULL, true, NULL, NULL, m_originalCasterGUID);
                 return;
         }
     }
 
     switch (spellInfo->Id)
     {
         case 72298: // Malleable Goo Summon
             unitTarget->CastSpell(unitTarget, spellInfo->Id, true, NULL, NULL, m_originalCasterGUID);
             return;
     }
 
     CustomSpellValues values;
     // set basepoints for trigger with value effect
     if (effectInfo->Effect == SPELL_EFFECT_FORCE_CAST_WITH_VALUE)
     {
         // maybe need to set value only when basepoints == 0?
         values.AddSpellMod(SPELLVALUE_BASE_POINT0, damage);
         values.AddSpellMod(SPELLVALUE_BASE_POINT1, damage);
         values.AddSpellMod(SPELLVALUE_BASE_POINT2, damage);
     }
 
     SpellCastTargets targets;
     targets.SetUnitTarget(m_caster);
 
     unitTarget->CastSpell(targets, spellInfo, &values, TRIGGERED_FULL_MASK);
 }

Here is the call graph for this function:

void Spell::EffectForceDeselect ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     WorldPackets::Spells::ClearTarget clearTarget;
     clearTarget.Guid = m_caster->GetGUID();
     m_caster->SendMessageToSet(clearTarget.Write(), true);
 }

Here is the call graph for this function:

void Spell::EffectGameObjectDamage ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!gameObjTarget)
         return;
 
     Unit* caster = m_originalCaster;
     if (!caster)
         return;
 
     FactionTemplateEntry const* casterFaction = caster->GetFactionTemplateEntry();
     FactionTemplateEntry const* targetFaction = sFactionTemplateStore.LookupEntry(gameObjTarget->GetUInt32Value(GAMEOBJECT_FACTION));
     // Do not allow to damage GO's of friendly factions (ie: Wintergrasp Walls/Ulduar Storm Beacons)
     if (!targetFaction || (casterFaction && targetFaction && !casterFaction->IsFriendlyTo(*targetFaction)))
         gameObjTarget->ModifyHealth(-damage, caster, GetSpellInfo()->Id);
 }

Here is the call graph for this function:

void Spell::EffectGameObjectRepair ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!gameObjTarget)
         return;
 
     gameObjTarget->ModifyHealth(damage, m_caster);
 }

Here is the call graph for this function:

void Spell::EffectGameObjectSetDestructionState ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!gameObjTarget || !m_originalCaster)
         return;
 
     Player* player = m_originalCaster->GetCharmerOrOwnerPlayerOrPlayerItself();
     gameObjTarget->SetDestructibleState(GameObjectDestructibleState(effectInfo->MiscValue), player, true);
 }

Here is the call graph for this function:

void Spell::EffectGiveCurrency ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     unitTarget->ToPlayer()->ModifyCurrency(effectInfo->MiscValue, damage);
 }

Here is the call graph for this function:

void Spell::EffectHeal ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)
         return;
 
     if (unitTarget && unitTarget->IsAlive() && damage >= 0)
     {
         // Try to get original caster
         Unit* caster = !m_originalCasterGUID.IsEmpty() ? m_originalCaster : m_caster;
 
         // Skip if m_originalCaster not available
         if (!caster)
             return;
 
         int32 addhealth = damage;
 
         // Vessel of the Naaru (Vial of the Sunwell trinket)
         if (m_spellInfo->Id == 45064)
         {
             // Amount of heal - depends from stacked Holy Energy
             int damageAmount = 0;
             if (AuraEffect const* aurEff = m_caster->GetAuraEffect(45062, 0))
             {
                 damageAmount+= aurEff->GetAmount();
                 m_caster->RemoveAurasDueToSpell(45062);
             }
 
             addhealth += damageAmount;
         }
         // Runic Healing Injector (heal increased by 25% for engineers - 3.2.0 patch change)
         else if (m_spellInfo->Id == 67489)
         {
             if (Player* player = m_caster->ToPlayer())
                 if (player->HasSkill(SKILL_ENGINEERING))
                     AddPct(addhealth, 25);
         }
         // Swiftmend - consumes Regrowth or Rejuvenation
         else if (m_spellInfo->TargetAuraState == AURA_STATE_SWIFTMEND && unitTarget->HasAuraState(AURA_STATE_SWIFTMEND, m_spellInfo, m_caster))
         {
             Unit::AuraEffectList const& RejorRegr = unitTarget->GetAuraEffectsByType(SPELL_AURA_PERIODIC_HEAL);
             // find most short by duration
             AuraEffect* targetAura = NULL;
             for (Unit::AuraEffectList::const_iterator i = RejorRegr.begin(); i != RejorRegr.end(); ++i)
             {
                 if ((*i)->GetSpellInfo()->SpellFamilyName == SPELLFAMILY_DRUID
                     && (*i)->GetSpellInfo()->SpellFamilyFlags[0] & 0x50)
                 {
                     if (!targetAura || (*i)->GetBase()->GetDuration() < targetAura->GetBase()->GetDuration())
                         targetAura = *i;
                 }
             }
 
             if (!targetAura)
             {
                 TC_LOG_ERROR("spells", "Target (%s) has aurastate AURA_STATE_SWIFTMEND but no matching aura.", unitTarget->GetGUID().ToString().c_str());
                 return;
             }
 
             int32 tickheal = targetAura->GetAmount();
             if (Unit* auraCaster = targetAura->GetCaster())
                 tickheal = auraCaster->SpellHealingBonusDone(unitTarget, targetAura->GetSpellInfo(), tickheal, DOT, effectInfo);
             //int32 tickheal = targetAura->GetSpellInfo()->EffectBasePoints[idx] + 1;
             //It is said that talent bonus should not be included
 
             int32 tickcount = 0;
             // Rejuvenation
             if (targetAura->GetSpellInfo()->SpellFamilyFlags[0] & 0x10)
                 tickcount = 4;
             // Regrowth
             else // if (targetAura->GetSpellInfo()->SpellFamilyFlags[0] & 0x40)
                 tickcount = 6;
 
             addhealth += tickheal * tickcount;
 
             // Glyph of Swiftmend
             if (!caster->HasAura(54824))
                 unitTarget->RemoveAura(targetAura->GetId(), targetAura->GetCasterGUID());
 
             //addhealth += tickheal * tickcount;
             //addhealth = caster->SpellHealingBonus(m_spellInfo, addhealth, HEAL, unitTarget);
         }
         // Death Pact - return pct of max health to caster
         else if (m_spellInfo->SpellFamilyName == SPELLFAMILY_DEATHKNIGHT && m_spellInfo->SpellFamilyFlags[0] & 0x00080000)
             addhealth = caster->SpellHealingBonusDone(unitTarget, m_spellInfo, int32(caster->CountPctFromMaxHealth(damage)), HEAL, effectInfo);
         else
         {
             addhealth = caster->SpellHealingBonusDone(unitTarget, m_spellInfo, addhealth, HEAL, effectInfo);
             uint32 bonus = caster->SpellHealingBonusDone(unitTarget, m_spellInfo, addhealth, HEAL, effectInfo);
             damage = bonus + uint32(bonus * variance);
         }
 
         addhealth = unitTarget->SpellHealingBonusTaken(caster, m_spellInfo, addhealth, HEAL, effectInfo);
 
         // Remove Grievious bite if fully healed
         if (unitTarget->HasAura(48920) && (unitTarget->GetHealth() + addhealth >= unitTarget->GetMaxHealth()))
             unitTarget->RemoveAura(48920);
 
         m_damage -= addhealth;
     }
 }

Here is the call graph for this function:

void Spell::EffectHealBattlePetPct ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     if (BattlePetMgr* battlePetMgr = unitTarget->ToPlayer()->GetSession()->GetBattlePetMgr())
         battlePetMgr->HealBattlePetsPct(GetEffect(effIndex)->BasePoints);
 }

Here is the call graph for this function:

void Spell::EffectHealMaxHealth ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || !unitTarget->IsAlive())
         return;
 
     int32 addhealth = 0;
 
     // damage == 0 - heal for caster max health
     if (damage == 0)
         addhealth = m_caster->GetMaxHealth();
     else
         addhealth = unitTarget->GetMaxHealth() - unitTarget->GetHealth();
 
     m_healing += addhealth;
 }

Here is the call graph for this function:

void Spell::EffectHealMechanical ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || !unitTarget->IsAlive() || damage < 0)
         return;
 
     // Skip if m_originalCaster not available
     if (!m_originalCaster)
         return;
 
     uint32 heal = m_originalCaster->SpellHealingBonusDone(unitTarget, m_spellInfo, uint32(damage), HEAL, effectInfo);
     heal += uint32(heal * variance);
 
     m_healing += unitTarget->SpellHealingBonusTaken(m_originalCaster, m_spellInfo, heal, HEAL, effectInfo);
 }

Here is the call graph for this function:

void Spell::EffectHealPct ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || !unitTarget->IsAlive() || damage < 0)
         return;
 
     // Skip if m_originalCaster not available
     if (!m_originalCaster)
         return;
 
     uint32 heal = m_originalCaster->SpellHealingBonusDone(unitTarget, m_spellInfo, unitTarget->CountPctFromMaxHealth(damage), HEAL, effectInfo);
     heal = unitTarget->SpellHealingBonusTaken(m_originalCaster, m_spellInfo, heal, HEAL, effectInfo);
 
     m_healing += heal;
 }

Here is the call graph for this function:

void Spell::EffectHealthLeech ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || !unitTarget->IsAlive() || damage < 0)
         return;
 
     uint32 bonus = m_caster->SpellDamageBonusDone(unitTarget, m_spellInfo, (uint32)damage, SPELL_DIRECT_DAMAGE, effectInfo);
     damage = bonus + uint32(bonus * variance);
     damage = unitTarget->SpellDamageBonusTaken(m_caster, m_spellInfo, uint32(damage), SPELL_DIRECT_DAMAGE, effectInfo);
 
     TC_LOG_DEBUG("spells", "HealthLeech :%i", damage);
 
     float healMultiplier = effectInfo->CalcValueMultiplier(m_originalCaster, this);
 
     m_damage += damage;
     // get max possible damage, don't count overkill for heal
     uint32 healthGain = uint32(-unitTarget->GetHealthGain(-damage) * healMultiplier);
 
     if (m_caster->IsAlive())
     {
         healthGain = m_caster->SpellHealingBonusDone(m_caster, m_spellInfo, healthGain, HEAL, effectInfo);
         healthGain = m_caster->SpellHealingBonusTaken(m_caster, m_spellInfo, healthGain, HEAL, effectInfo);
 
         m_caster->HealBySpell(m_caster, m_spellInfo, uint32(healthGain));
     }
 }

Here is the call graph for this function:

void Spell::EffectInebriate ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     Player* player = unitTarget->ToPlayer();
     uint8 currentDrunk = player->GetDrunkValue();
     uint8 drunkMod = damage;
     if (currentDrunk + drunkMod > 100)
     {
         currentDrunk = 100;
         if (rand_chance() < 25.0f)
             player->CastSpell(player, 67468, false);    // Drunken Vomit
     }
     else
         currentDrunk += drunkMod;
 
     player->SetDrunkValue(currentDrunk, m_CastItem ? m_CastItem->GetEntry() : 0);
 }

Here is the call graph for this function:

void Spell::EffectInstaKill ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || !unitTarget->IsAlive())
         return;
 
     if (unitTarget->GetTypeId() == TYPEID_PLAYER)
         if (unitTarget->ToPlayer()->GetCommandStatus(CHEAT_GOD))
             return;
 
     if (m_caster == unitTarget)                              // prevent interrupt message
         finish();
 
     WorldPackets::CombatLog::SpellInstakillLog data;
     data.Target = unitTarget->GetGUID();
     data.Caster = m_caster->GetGUID();
     data.SpellID = m_spellInfo->Id;
 
     m_caster->SendMessageToSet(data.Write(), true);
 
     m_caster->DealDamage(unitTarget, unitTarget->GetHealth(), NULL, NODAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
 }

Here is the call graph for this function:

void Spell::EffectInterruptCast ( SpellEffIndex effIndex )

Todo:: not all spells that used this effect apply cooldown at school spells

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || !unitTarget->IsAlive())
         return;
 
     // also exist case: apply cooldown to interrupted cast only and to all spells
     // there is no CURRENT_AUTOREPEAT_SPELL spells that can be interrupted
     for (uint32 i = CURRENT_FIRST_NON_MELEE_SPELL; i < CURRENT_AUTOREPEAT_SPELL; ++i)
     {
         if (Spell* spell = unitTarget->GetCurrentSpell(CurrentSpellTypes(i)))
         {
             SpellInfo const* curSpellInfo = spell->m_spellInfo;
             // check if we can interrupt spell
             if ((spell->getState() == SPELL_STATE_CASTING
                 || (spell->getState() == SPELL_STATE_PREPARING && spell->GetCastTime() > 0.0f))
                 && (curSpellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE || curSpellInfo->PreventionType == SPELL_PREVENTION_TYPE_UNK)
                 && ((i == CURRENT_GENERIC_SPELL && curSpellInfo->InterruptFlags & SPELL_INTERRUPT_FLAG_INTERRUPT)
                 || (i == CURRENT_CHANNELED_SPELL && curSpellInfo->ChannelInterruptFlags & CHANNEL_INTERRUPT_FLAG_INTERRUPT)))
             {
                 if (m_originalCaster)
                 {
                     int32 duration = m_spellInfo->GetDuration();
                     unitTarget->GetSpellHistory()->LockSpellSchool(curSpellInfo->GetSchoolMask(), unitTarget->ModSpellDuration(m_spellInfo, unitTarget, duration, false, 1 << effIndex));
                 }
                 ExecuteLogEffectInterruptCast(effIndex, unitTarget, curSpellInfo->Id);
                 unitTarget->InterruptSpell(CurrentSpellTypes(i), false);
             }
         }
     }
 }

Here is the call graph for this function:

void Spell::EffectJump ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)
         return;
 
     if (m_caster->IsInFlight())
         return;
 
     if (!unitTarget)
         return;
 
     float x, y, z;
     unitTarget->GetContactPoint(m_caster, x, y, z, CONTACT_DISTANCE);
 
     float speedXY, speedZ;
     CalculateJumpSpeeds(effectInfo, m_caster->GetExactDist2d(x, y), speedXY, speedZ);
     m_caster->GetMotionMaster()->MoveJump(x, y, z, 0.0f, speedXY, speedZ, EVENT_JUMP, false, effectInfo->TriggerSpell, unitTarget->GetGUID());
 }

Here is the call graph for this function:

void Spell::EffectJumpDest ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH)
         return;
 
     if (m_caster->IsInFlight())
         return;
 
     if (!m_targets.HasDst())
         return;
 
     float speedXY, speedZ;
     CalculateJumpSpeeds(effectInfo, m_caster->GetExactDist2d(destTarget), speedXY, speedZ);
     m_caster->GetMotionMaster()->MoveJump(*destTarget, speedXY, speedZ, EVENT_JUMP, true, effectInfo->TriggerSpell);
 }

Here is the call graph for this function:

void Spell::EffectKillCredit ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     int32 creatureEntry = effectInfo->MiscValue;
     if (!creatureEntry)
     {
         if (m_spellInfo->Id == 42793) // Burn Body
             creatureEntry = 24008; // Fallen Combatant
     }
 
     if (creatureEntry)
         unitTarget->ToPlayer()->RewardPlayerAndGroupAtEvent(creatureEntry, unitTarget);
 }

Here is the call graph for this function:

void Spell::EffectKillCreditPersonal ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     unitTarget->ToPlayer()->KilledMonsterCredit(effectInfo->MiscValue);
 }

Here is the call graph for this function:

void Spell::EffectKnockBack ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget)
         return;
 
     if (Creature* creatureTarget = unitTarget->ToCreature())
         if (creatureTarget->isWorldBoss() || creatureTarget->IsDungeonBoss())
             return;
 
     // Spells with SPELL_EFFECT_KNOCK_BACK (like Thunderstorm) can't knockback target if target has ROOT/STUN
     if (unitTarget->HasUnitState(UNIT_STATE_ROOT | UNIT_STATE_STUNNED))
         return;
 
     // Instantly interrupt non melee spells being cast
     if (unitTarget->IsNonMeleeSpellCast(true))
         unitTarget->InterruptNonMeleeSpells(true);
 
     float ratio = 0.1f;
     float speedxy = float(effectInfo->MiscValue) * ratio;
     float speedz = float(damage) * ratio;
     if (speedxy < 0.1f && speedz < 0.1f)
         return;
 
     float x, y;
     if (effectInfo->Effect == SPELL_EFFECT_KNOCK_BACK_DEST)
     {
         if (m_targets.HasDst())
             destTarget->GetPosition(x, y);
         else
             return;
     }
     else //if (m_spellInfo->Effects[i].Effect == SPELL_EFFECT_KNOCK_BACK)
     {
         m_caster->GetPosition(x, y);
     }
 
     unitTarget->KnockbackFrom(x, y, speedxy, speedz);
 }

Here is the call graph for this function:

void Spell::EffectLeap ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->IsInFlight())
         return;
 
     if (!m_targets.HasDst())
         return;
 
     Position pos = destTarget->GetPosition();
     pos = unitTarget->GetFirstCollisionPosition(unitTarget->GetDistance(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ()), 0.0f);
     unitTarget->NearTeleportTo(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), pos.GetOrientation(), unitTarget == m_caster);
 }

Here is the call graph for this function:

void Spell::EffectLeapBack ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)
         return;
 
     if (!unitTarget)
         return;
 
     float speedxy = effectInfo->MiscValue / 10.f;
     float speedz = damage / 10.f;
     //1891: Disengage
     m_caster->JumpTo(speedxy, speedz, m_spellInfo->SpellIconID != 1891);
 }

Here is the call graph for this function:

void Spell::EffectLearnGarrisonBuilding ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     if (Garrison* garrison = unitTarget->ToPlayer()->GetGarrison())
         garrison->LearnBlueprint(GetEffect(effIndex)->MiscValue);
 }

Here is the call graph for this function:

void Spell::EffectLearnPetSpell ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget)
         return;
 
     if (unitTarget->ToPlayer())
     {
         EffectLearnSpell(effIndex);
         return;
     }
     Pet* pet = unitTarget->ToPet();
     if (!pet)
         return;
 
     SpellInfo const* learn_spellproto = sSpellMgr->GetSpellInfo(effectInfo->TriggerSpell);
     if (!learn_spellproto)
         return;
 
     pet->learnSpell(learn_spellproto->Id);
     pet->SavePetToDB(PET_SAVE_AS_CURRENT);
     pet->GetOwner()->PetSpellInitialize();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::EffectLearnSkill ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     if (damage < 0)
         return;
 
     uint32 skillid = effectInfo->MiscValue;
     SkillRaceClassInfoEntry const* rcEntry = GetSkillRaceClassInfo(skillid, unitTarget->getRace(), unitTarget->getClass());
     if (!rcEntry)
         return;
 
     SkillTiersEntry const* tier = sObjectMgr->GetSkillTier(rcEntry->SkillTierID);
     if (!tier)
         return;
 
     uint16 skillval = unitTarget->ToPlayer()->GetPureSkillValue(skillid);
     unitTarget->ToPlayer()->SetSkill(skillid, effectInfo->CalcValue(), std::max<uint16>(skillval, 1), tier->Value[damage - 1]);
 }

Here is the call graph for this function:

void Spell::EffectLearnSpell ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget)
         return;
 
     if (unitTarget->GetTypeId() != TYPEID_PLAYER)
     {
         if (unitTarget->ToPet())
             EffectLearnPetSpell(effIndex);
         return;
     }
 
     Player* player = unitTarget->ToPlayer();
 
     uint32 spellToLearn = (m_spellInfo->Id == 483 || m_spellInfo->Id == 55884) ? damage : effectInfo->TriggerSpell;
     player->LearnSpell(spellToLearn, false);
 
     if (m_spellInfo->Id == 55884)
     {
         if (BattlePetMgr* battlePetMgr = player->GetSession()->GetBattlePetMgr())
         {
             for (auto entry : sBattlePetSpeciesStore)
             {
                 if (entry->SummonSpellID == spellToLearn)
                 {
                     battlePetMgr->AddPet(entry->ID, entry->CreatureID, BattlePetMgr::RollPetBreed(entry->ID), BattlePetMgr::GetDefaultPetQuality(entry->ID));
                     player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_OWN_BATTLE_PET_COUNT);
                     break;
                 }
             }
         }
     }
 
     TC_LOG_DEBUG("spells", "Spell: %s has learned spell %u from %s", player->GetGUID().ToString().c_str(), spellToLearn, m_caster->GetGUID().ToString().c_str());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::EffectMilling ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     Player* player = m_caster->ToPlayer();
     if (!player)
         return;
 
     if (!itemTarget || !(itemTarget->GetTemplate()->GetFlags() & ITEM_FLAG_MILLABLE))
         return;
 
     if (itemTarget->GetCount() < 5)
         return;
 
     if (sWorld->getBoolConfig(CONFIG_SKILL_MILLING))
     {
         uint32 SkillValue = player->GetPureSkillValue(SKILL_INSCRIPTION);
         uint32 reqSkillValue = itemTarget->GetTemplate()->GetRequiredSkillRank();
         player->UpdateGatherSkill(SKILL_INSCRIPTION, SkillValue, reqSkillValue);
     }
 
     player->SendLoot(itemTarget->GetGUID(), LOOT_MILLING);
 }

Here is the call graph for this function:

void Spell::EffectModifyThreatPercent ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget)
         return;
 
     unitTarget->getThreatManager().modifyThreatPercent(m_caster, damage);
 }

Here is the call graph for this function:

void Spell::EffectNULL ( SpellEffIndex effIndex )

 {
     TC_LOG_DEBUG("spells", "WORLD: Spell Effect DUMMY");
 }

Here is the caller graph for this function:

void Spell::EffectOpenLock ( SpellEffIndex effIndex )

Todo:: Add script for spell 41920 - Filling, becouse server it freze when use this spell

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (m_caster->GetTypeId() != TYPEID_PLAYER)
     {
         TC_LOG_DEBUG("spells", "WORLD: Open Lock - No Player Caster!");
         return;
     }
 
     Player* player = m_caster->ToPlayer();
 
     uint32 lockId = 0;
     ObjectGuid guid;
 
     // Get lockId
     if (gameObjTarget)
     {
         GameObjectTemplate const* goInfo = gameObjTarget->GetGOInfo();
         // Arathi Basin banner opening. /// @todo Verify correctness of this check
         if ((goInfo->type == GAMEOBJECT_TYPE_BUTTON && goInfo->button.noDamageImmune) ||
             (goInfo->type == GAMEOBJECT_TYPE_GOOBER && goInfo->goober.requireLOS))
         {
             //CanUseBattlegroundObject() already called in CheckCast()
             // in battleground check
             if (Battleground* bg = player->GetBattleground())
             {
                 bg->EventPlayerClickedOnFlag(player, gameObjTarget);
                 return;
             }
         }
         else if (goInfo->type == GAMEOBJECT_TYPE_FLAGSTAND)
         {
             //CanUseBattlegroundObject() already called in CheckCast()
             // in battleground check
             if (Battleground* bg = player->GetBattleground())
             {
                 if (bg->GetTypeID(true) == BATTLEGROUND_EY)
                     bg->EventPlayerClickedOnFlag(player, gameObjTarget);
                 return;
             }
         }
         else if (m_spellInfo->Id == 1842 && gameObjTarget->GetGOInfo()->type == GAMEOBJECT_TYPE_TRAP && gameObjTarget->GetOwner())
         {
             gameObjTarget->SetLootState(GO_JUST_DEACTIVATED);
             return;
         }
         // handle outdoor pvp object opening, return true if go was registered for handling
         // these objects must have been spawned by outdoorpvp!
         else if (gameObjTarget->GetGOInfo()->type == GAMEOBJECT_TYPE_GOOBER && sOutdoorPvPMgr->HandleOpenGo(player, gameObjTarget))
             return;
         lockId = goInfo->GetLockId();
         guid = gameObjTarget->GetGUID();
     }
     else if (itemTarget)
     {
         lockId = itemTarget->GetTemplate()->GetLockID();
         guid = itemTarget->GetGUID();
     }
     else
     {
         TC_LOG_DEBUG("spells", "WORLD: Open Lock - No GameObject/Item Target!");
         return;
     }
 
     SkillType skillId = SKILL_NONE;
     int32 reqSkillValue = 0;
     int32 skillValue;
 
     SpellCastResult res = CanOpenLock(effIndex, lockId, skillId, reqSkillValue, skillValue);
     if (res != SPELL_CAST_OK)
     {
         SendCastResult(res);
         return;
     }
 
     if (gameObjTarget)
         SendLoot(guid, LOOT_SKINNING);
     else if (itemTarget)
         itemTarget->SetFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_UNLOCKED);
 
     // not allow use skill grow at item base open
     if (!m_CastItem && skillId != SKILL_NONE)
     {
         // update skill if really known
         if (uint32 pureSkillValue = player->GetPureSkillValue(skillId))
         {
             if (gameObjTarget)
             {
                 // Allow one skill-up until respawned
                 if (!gameObjTarget->IsInSkillupList(player->GetGUID()) &&
                     player->UpdateGatherSkill(skillId, pureSkillValue, reqSkillValue))
                     gameObjTarget->AddToSkillupList(player->GetGUID());
             }
             else if (itemTarget)
             {
                 // Do one skill-up
                 player->UpdateGatherSkill(skillId, pureSkillValue, reqSkillValue);
             }
         }
     }
     ExecuteLogEffectOpenLock(effIndex, gameObjTarget ? (Object*)gameObjTarget : (Object*)itemTarget);
 }

Here is the call graph for this function:

void Spell::EffectParry ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     if (m_caster->GetTypeId() == TYPEID_PLAYER)
         m_caster->ToPlayer()->SetCanParry(true);
 }

Here is the call graph for this function:

void Spell::EffectPersistentAA ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     if (!m_spellAura)
     {
         Unit* caster = m_caster->GetEntry() == WORLD_TRIGGER ? m_originalCaster : m_caster;
         float radius = effectInfo->CalcRadius(caster);
 
         // Caster not in world, might be spell triggered from aura removal
         if (!caster->IsInWorld())
             return;
         DynamicObject* dynObj = new DynamicObject(false);
         if (!dynObj->CreateDynamicObject(caster->GetMap()->GenerateLowGuid<HighGuid::DynamicObject>(), caster, m_spellInfo, *destTarget, radius, DYNAMIC_OBJECT_AREA_SPELL))
         {
             delete dynObj;
             return;
         }
 
         if (Aura* aura = Aura::TryCreate(m_spellInfo, MAX_EFFECT_MASK, dynObj, caster, &m_spellValue->EffectBasePoints[0], nullptr, ObjectGuid::Empty, m_castItemLevel))
         {
             m_spellAura = aura;
             m_spellAura->_RegisterForTargets();
         }
         else
             return;
     }
 
     ASSERT(m_spellAura->GetDynobjOwner());
     m_spellAura->_ApplyEffectForTargets(effIndex);
 }

Here is the call graph for this function:

void Spell::EffectPickPocket ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (m_caster->GetTypeId() != TYPEID_PLAYER)
         return;
 
     // victim must be creature and attackable
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_UNIT || m_caster->IsFriendlyTo(unitTarget))
         return;
 
     // victim have to be alive and humanoid or undead
     if (unitTarget->IsAlive() && (unitTarget->GetCreatureTypeMask() &CREATURE_TYPEMASK_HUMANOID_OR_UNDEAD) != 0)
         m_caster->ToPlayer()->SendLoot(unitTarget->GetGUID(), LOOT_PICKPOCKETING);
 }

Here is the call graph for this function:

void Spell::EffectPlayMovie ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     uint32 movieId = effectInfo->MiscValue;
     if (!sMovieStore.LookupEntry(movieId))
         return;
 
     unitTarget->ToPlayer()->SendMovieStart(movieId);
 }

Here is the call graph for this function:

void Spell::EffectPlayMusic ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     uint32 soundid = effectInfo->MiscValue;
 
     if (!sSoundEntriesStore.LookupEntry(soundid))
     {
         TC_LOG_ERROR("spells", "EffectPlayMusic: Sound (Id: %u) not exist in spell %u.", soundid, m_spellInfo->Id);
         return;
     }
 
     unitTarget->ToPlayer()->GetSession()->SendPacket(WorldPackets::Misc::PlayMusic(soundid).Write());
 }

Here is the call graph for this function:

void Spell::EffectPlaySound ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget)
         return;
 
     Player* player = unitTarget->ToPlayer();
     if (!player)
         return;
 
     switch (m_spellInfo->Id)
     {
         case 91604: // Restricted Flight Area
             player->GetSession()->SendNotification(LANG_ZONE_NOFLYZONE);
             break;
         default:
             break;
     }
 
     uint32 soundId = effectInfo->MiscValue;
 
     if (!sSoundEntriesStore.LookupEntry(soundId))
     {
         TC_LOG_ERROR("spells", "EffectPlaySound: Sound (Id: %u) not exist in spell %u.", soundId, m_spellInfo->Id);
         return;
     }
 
     player->PlayDirectSound(soundId, player);
 }

Here is the call graph for this function:

void Spell::EffectPowerBurn ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (effectInfo->MiscValue < 0 || effectInfo->MiscValue >= int8(MAX_POWERS))
         return;
 
     Powers powerType = Powers(effectInfo->MiscValue);
 
     if (!unitTarget || !unitTarget->IsAlive() || unitTarget->getPowerType() != powerType || damage < 0)
         return;
 
     // burn x% of target's mana, up to maximum of 2x% of caster's mana (Mana Burn)
     if (m_spellInfo->Id == 8129)
     {
         int32 maxDamage = int32(CalculatePct(m_caster->GetMaxPower(powerType), damage * 2));
         damage = int32(CalculatePct(unitTarget->GetMaxPower(powerType), damage));
         damage = std::min(damage, maxDamage);
     }
 
     int32 newDamage = -(unitTarget->ModifyPower(powerType, -damage));
 
     // NO - Not a typo - EffectPowerBurn uses effect value multiplier - not effect damage multiplier
     float dmgMultiplier = effectInfo->CalcValueMultiplier(m_originalCaster, this);
 
     // add log data before multiplication (need power amount, not damage)
     ExecuteLogEffectTakeTargetPower(effIndex, unitTarget, powerType, newDamage, 0.0f);
 
     newDamage = int32(newDamage* dmgMultiplier);
 
     m_damage += newDamage;
 }

Here is the call graph for this function:

void Spell::EffectPowerDrain ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (effectInfo->MiscValue < 0 || effectInfo->MiscValue >= int8(MAX_POWERS))
         return;
 
     Powers powerType = Powers(effectInfo->MiscValue);
 
     if (!unitTarget || !unitTarget->IsAlive() || unitTarget->getPowerType() != powerType || damage < 0)
         return;
 
     // add spell damage bonus
     uint32 bonus = m_caster->SpellDamageBonusDone(unitTarget, m_spellInfo, (uint32)damage, SPELL_DIRECT_DAMAGE, effectInfo);
     damage = bonus + uint32(bonus * variance);
     damage = unitTarget->SpellDamageBonusTaken(m_caster, m_spellInfo, uint32(damage), SPELL_DIRECT_DAMAGE, effectInfo);
 
     int32 newDamage = -(unitTarget->ModifyPower(powerType, -damage));
 
     float gainMultiplier = 0.0f;
 
     // Don't restore from self drain
     if (m_caster != unitTarget)
     {
         gainMultiplier = effectInfo->CalcValueMultiplier(m_originalCaster, this);
 
         int32 gain = int32(newDamage* gainMultiplier);
 
         m_caster->EnergizeBySpell(m_caster, m_spellInfo->Id, gain, powerType);
     }
     ExecuteLogEffectTakeTargetPower(effIndex, unitTarget, powerType, newDamage, gainMultiplier);
 }

Here is the call graph for this function:

void Spell::EffectProficiency ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     if (m_caster->GetTypeId() != TYPEID_PLAYER)
         return;
     Player* p_target = m_caster->ToPlayer();
 
     uint32 subClassMask = m_spellInfo->EquippedItemSubClassMask;
     if (m_spellInfo->EquippedItemClass == ITEM_CLASS_WEAPON && !(p_target->GetWeaponProficiency() & subClassMask))
     {
         p_target->AddWeaponProficiency(subClassMask);
         p_target->SendProficiency(ITEM_CLASS_WEAPON, p_target->GetWeaponProficiency());
     }
     if (m_spellInfo->EquippedItemClass == ITEM_CLASS_ARMOR && !(p_target->GetArmorProficiency() & subClassMask))
     {
         p_target->AddArmorProficiency(subClassMask);
         p_target->SendProficiency(ITEM_CLASS_ARMOR, p_target->GetArmorProficiency());
     }
 }

Here is the call graph for this function:

void Spell::EffectProspecting ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     Player* player = m_caster->ToPlayer();
     if (!player)
         return;
 
     if (!itemTarget || !(itemTarget->GetTemplate()->GetFlags() & ITEM_FLAG_PROSPECTABLE))
         return;
 
     if (itemTarget->GetCount() < 5)
         return;
 
     if (sWorld->getBoolConfig(CONFIG_SKILL_PROSPECTING))
     {
         uint32 SkillValue = player->GetPureSkillValue(SKILL_JEWELCRAFTING);
         uint32 reqSkillValue = itemTarget->GetTemplate()->GetRequiredSkillRank();
         player->UpdateGatherSkill(SKILL_JEWELCRAFTING, SkillValue, reqSkillValue);
     }
 
     player->SendLoot(itemTarget->GetGUID(), LOOT_PROSPECTING);
 }

Here is the call graph for this function:

void Spell::EffectPull ( SpellEffIndex effIndex )

Todo:: create a proper pull towards distract spell center for distract

 {
     EffectNULL(effIndex);
 }

Here is the call graph for this function:

void Spell::EffectPullTowards ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget)
         return;
 
     Position pos;
     if (effectInfo->Effect == SPELL_EFFECT_PULL_TOWARDS_DEST)
     {
         if (m_targets.HasDst())
             pos.Relocate(*destTarget);
         else
             return;
     }
     else //if (m_spellInfo->Effects[i].Effect == SPELL_EFFECT_PULL_TOWARDS)
     {
         pos.Relocate(m_caster);
     }
 
     float speedXY = float(effectInfo->MiscValue) * 0.1f;
     float speedZ = unitTarget->GetDistance(pos) / speedXY * 0.5f * Movement::gravity;
 
     unitTarget->GetMotionMaster()->MoveJump(pos, speedXY, speedZ);
 }

Here is the call graph for this function:

void Spell::EffectQuestClear ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
     Player* player = unitTarget->ToPlayer();
 
     uint32 quest_id = effectInfo->MiscValue;
 
     Quest const* quest = sObjectMgr->GetQuestTemplate(quest_id);
 
     if (!quest)
         return;
 
     // Player has never done this quest
     if (player->GetQuestStatus(quest_id) == QUEST_STATUS_NONE)
         return;
 
     // remove all quest entries for 'entry' from quest log
     for (uint8 slot = 0; slot < MAX_QUEST_LOG_SIZE; ++slot)
     {
         uint32 logQuest = player->GetQuestSlotQuestId(slot);
         if (logQuest == quest_id)
         {
             player->SetQuestSlot(slot, 0);
 
             // we ignore unequippable quest items in this case, it's still be equipped
             player->TakeQuestSourceItem(logQuest, false);
 
             if (quest->HasFlag(QUEST_FLAGS_FLAGS_PVP))
             {
                 player->pvpInfo.IsHostile = player->pvpInfo.IsInHostileArea || player->HasPvPForcingQuest();
                 player->UpdatePvPState();
             }
         }
     }
 
     player->RemoveActiveQuest(quest_id, false);
     player->RemoveRewardedQuest(quest_id);
 }

Here is the call graph for this function:

void Spell::EffectQuestComplete ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
     Player* player = unitTarget->ToPlayer();
 
     uint32 questId = effectInfo->MiscValue;
     if (questId)
     {
         Quest const* quest = sObjectMgr->GetQuestTemplate(questId);
         if (!quest)
             return;
 
         uint16 logSlot = player->FindQuestSlot(questId);
         if (logSlot < MAX_QUEST_LOG_SIZE)
             player->AreaExploredOrEventHappens(questId);
         else if (player->CanTakeQuest(quest, false))    // never rewarded before
             player->CompleteQuest(questId);             // quest not in log - for internal use
     }
 }

Here is the call graph for this function:

void Spell::EffectQuestFail ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     unitTarget->ToPlayer()->FailQuest(effectInfo->MiscValue);
 }

Here is the call graph for this function:

void Spell::EffectQuestStart ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget)
         return;
 
     Player* player = unitTarget->ToPlayer();
     if (!player)
         return;
 
     if (Quest const* quest = sObjectMgr->GetQuestTemplate(effectInfo->MiscValue))
     {
         if (!player->CanTakeQuest(quest, false))
             return;
 
         if (quest->IsAutoAccept() && player->CanAddQuest(quest, false))
             player->AddQuestAndCheckCompletion(quest, player);
 
         player->PlayerTalkClass->SendQuestGiverQuestDetails(quest, player->GetGUID(), true);
     }
 }

Here is the call graph for this function:

void Spell::EffectRechargeManaGem ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     Player* player = m_caster->ToPlayer();
 
     if (!player)
         return;
     if (SpellEffectInfo const* effect = GetEffect(EFFECT_0))
     {
         uint32 item_id = effect->ItemType;
 
         ItemTemplate const* pProto = sObjectMgr->GetItemTemplate(item_id);
         if (!pProto)
         {
             player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL);
             return;
         }
 
         if (Item* pItem = player->GetItemByEntry(item_id))
         {
             for (size_t x = 0; x < pProto->Effects.size() && x < 5; ++x)
                 pItem->SetSpellCharges(x, pProto->Effects[x]->Charges);
             pItem->SetState(ITEM_CHANGED, player);
         }
     }
 }

Here is the call graph for this function:

void Spell::EffectRedirectThreat ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (unitTarget)
         m_caster->SetRedirectThreat(unitTarget->GetGUID(), uint32(damage));
 }

Here is the call graph for this function:

void Spell::EffectRemoveAura ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget)
         return;
     // there may be need of specifying casterguid of removed auras
     unitTarget->RemoveAurasDueToSpell(effectInfo->TriggerSpell);
 }

Here is the call graph for this function:

void Spell::EffectRemoveTalent ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     TalentEntry const* talent = sTalentStore.LookupEntry(m_misc.TalentId);
     if (!talent)
         return;
 
     Player* player = unitTarget ? unitTarget->ToPlayer() : nullptr;
     if (!player)
         return;
 
     player->RemoveTalent(talent);
     player->SendTalentsInfoData();
 }

Here is the call graph for this function:

void Spell::EffectRenamePet ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_UNIT ||
         !unitTarget->IsPet() || ((Pet*)unitTarget)->getPetType() != HUNTER_PET)
         return;
 
     unitTarget->SetByteFlag(UNIT_FIELD_BYTES_2, 2, UNIT_CAN_BE_RENAMED);
 }

Here is the call graph for this function:

void Spell::EffectReputation ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     Player* player = unitTarget->ToPlayer();
 
     int32  repChange = damage;
 
     uint32 factionId = effectInfo->MiscValue;
 
     FactionEntry const* factionEntry = sFactionStore.LookupEntry(factionId);
     if (!factionEntry)
         return;
 
     repChange = player->CalculateReputationGain(REPUTATION_SOURCE_SPELL, 0, repChange, factionId);
 
     player->GetReputationMgr().ModifyReputation(factionEntry, repChange);
 }

Here is the call graph for this function:

void Spell::EffectResurrect ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     if (unitTarget->IsAlive() || !unitTarget->IsInWorld())
         return;
 
     Player* target = unitTarget->ToPlayer();
 
     if (target->IsResurrectRequested())       // already have one active request
         return;
 
     uint32 health = target->CountPctFromMaxHealth(damage);
     uint32 mana   = CalculatePct(target->GetMaxPower(POWER_MANA), damage);
 
     ExecuteLogEffectResurrect(effIndex, target);
 
     target->SetResurrectRequestData(m_caster, health, mana, 0);
     SendResurrectRequest(target);
 }

Here is the call graph for this function:

void Spell::EffectResurrectNew ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->IsAlive())
         return;
 
     if (unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     if (!unitTarget->IsInWorld())
         return;
 
     Player* target = unitTarget->ToPlayer();
 
     if (target->IsResurrectRequested())       // already have one active request
         return;
 
     uint32 health = damage;
     uint32 mana = effectInfo->MiscValue;
     ExecuteLogEffectResurrect(effIndex, target);
     target->SetResurrectRequestData(m_caster, health, mana, 0);
     SendResurrectRequest(target);
 }

Here is the call graph for this function:

void Spell::EffectResurrectPet ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     if (damage < 0)
         return;
 
     Player* player = m_caster->ToPlayer();
     if (!player)
         return;
 
     // Maybe player dismissed dead pet or pet despawned?
     bool hadPet = true;
 
     if (!player->GetPet())
     {
         // Position passed to SummonPet is irrelevant with current implementation,
         // pet will be relocated without using these coords in Pet::LoadPetFromDB
         player->SummonPet(0, 0.0f, 0.0f, 0.0f, 0.0f, SUMMON_PET, 0);
         hadPet = false;
     }
 
     // TODO: Better to fail Hunter's "Revive Pet" at cast instead of here when casting ends
     Pet* pet = player->GetPet(); // Attempt to get current pet
     if (!pet || pet->IsAlive())
         return;
 
     // If player did have a pet before reviving, teleport it
     if (hadPet)
     {
         // Reposition the pet's corpse before reviving so as not to grab aggro
         // We can use a different, more accurate version of GetClosePoint() since we have a pet
         float x, y, z; // Will be used later to reposition the pet if we have one
         player->GetClosePoint(x, y, z, pet->GetObjectSize(), PET_FOLLOW_DIST, pet->GetFollowAngle());
         pet->NearTeleportTo(x, y, z, player->GetOrientation());
         pet->Relocate(x, y, z, player->GetOrientation()); // This is needed so SaveStayPosition() will get the proper coords.
     }
 
     pet->SetUInt32Value(OBJECT_DYNAMIC_FLAGS, UNIT_DYNFLAG_NONE);
     pet->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE);
     pet->setDeathState(ALIVE);
     pet->ClearUnitState(uint32(UNIT_STATE_ALL_STATE));
     pet->SetHealth(pet->CountPctFromMaxHealth(damage));
 
     // Reset things for when the AI to takes over
     CharmInfo *ci = pet->GetCharmInfo();
     if (ci)
     {
         // In case the pet was at stay, we don't want it running back
         ci->SaveStayPosition();
         ci->SetIsAtStay(ci->HasCommandState(COMMAND_STAY));
 
         ci->SetIsFollowing(false);
         ci->SetIsCommandAttack(false);
         ci->SetIsCommandFollow(false);
         ci->SetIsReturning(false);
     }
 
     pet->SavePetToDB(PET_SAVE_AS_CURRENT);
 }

Here is the call graph for this function:

void Spell::EffectResurrectWithAura ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || !unitTarget->IsInWorld())
         return;
 
     Player* target = unitTarget->ToPlayer();
     if (!target)
         return;
 
     if (unitTarget->IsAlive())
         return;
 
     if (target->IsResurrectRequested())       // already have one active request
         return;
 
     uint32 health = target->CountPctFromMaxHealth(damage);
     uint32 mana   = CalculatePct(target->GetMaxPower(POWER_MANA), damage);
     uint32 resurrectAura = 0;
     if (sSpellMgr->GetSpellInfo(effectInfo->TriggerSpell))
         resurrectAura = effectInfo->TriggerSpell;
 
     if (resurrectAura && target->HasAura(resurrectAura))
         return;
 
     ExecuteLogEffectResurrect(effIndex, target);
     target->SetResurrectRequestData(m_caster, health, mana, resurrectAura);
     SendResurrectRequest(target);
 }

Here is the call graph for this function:

void Spell::EffectSanctuary ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget)
         return;
 
     unitTarget->getHostileRefManager().UpdateVisibility();
 
     Unit::AttackerSet const& attackers = unitTarget->getAttackers();
     for (Unit::AttackerSet::const_iterator itr = attackers.begin(); itr != attackers.end();)
     {
         if (!(*itr)->CanSeeOrDetect(unitTarget))
             (*(itr++))->AttackStop();
         else
             ++itr;
     }
 
     unitTarget->m_lastSanctuaryTime = getMSTime();
 
     // Vanish allows to remove all threat and cast regular stealth so other spells can be used
     if (m_caster->GetTypeId() == TYPEID_PLAYER
         && m_spellInfo->SpellFamilyName == SPELLFAMILY_ROGUE
         && (m_spellInfo->SpellFamilyFlags[0] & SPELLFAMILYFLAG0_ROGUE_VANISH))
     {
         m_caster->ToPlayer()->RemoveAurasByType(SPELL_AURA_MOD_ROOT);
         // Overkill
         if (m_caster->ToPlayer()->HasSpell(58426))
            m_caster->CastSpell(m_caster, 58427, true);
     }
 }

Here is the call graph for this function:

void Spell::EffectSchoolDMG ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)
         return;
 
     if (unitTarget && unitTarget->IsAlive())
     {
         bool apply_direct_bonus = true;
         switch (m_spellInfo->SpellFamilyName)
         {
             case SPELLFAMILY_GENERIC:
             {
                 // Meteor like spells (divided damage to targets)
                 if (m_spellInfo->HasAttribute(SPELL_ATTR0_CU_SHARE_DAMAGE))
                 {
                     uint32 count = 0;
                     for (std::vector<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
                         if (ihit->effectMask & (1<<effIndex))
                             ++count;
 
                     damage /= count;                    // divide to all targets
                 }
 
                 switch (m_spellInfo->Id)                     // better way to check unknown
                 {
                     // Consumption
                     case 28865:
                         damage = (m_caster->GetMap()->GetDifficultyID() == DIFFICULTY_NONE ? 2750 : 4250);
                         break;
                     // percent from health with min
                     case 25599:                             // Thundercrash
                     {
                         damage = unitTarget->GetHealth() / 2;
                         if (damage < 200)
                             damage = 200;
                         break;
                     }
                     // arcane charge. must only affect demons (also undead?)
                     case 45072:
                     {
                         if (unitTarget->GetCreatureType() != CREATURE_TYPE_DEMON
                             && unitTarget->GetCreatureType() != CREATURE_TYPE_UNDEAD)
                             return;
                         break;
                     }
                     // Gargoyle Strike
                     case 51963:
                     {
                         // about +4 base spell dmg per level
                         damage = (m_caster->getLevel() - 60) * 4 + 60;
                         break;
                     }
                 }
                 break;
             }
             case SPELLFAMILY_WARRIOR:
             {
                 // Victory Rush
                 if (m_spellInfo->Id == 34428)
                     ApplyPct(damage, m_caster->GetTotalAttackPowerValue(BASE_ATTACK));
                 // Shockwave
                 else if (m_spellInfo->Id == 46968)
                 {
                     int32 pct = m_caster->CalculateSpellDamage(unitTarget, m_spellInfo, 2);
                     if (pct > 0)
                         damage += int32(CalculatePct(m_caster->GetTotalAttackPowerValue(BASE_ATTACK), pct));
                     break;
                 }
                 break;
             }
             case SPELLFAMILY_WARLOCK:
             {
                 // Incinerate Rank 1 & 2
                 if ((m_spellInfo->SpellFamilyFlags[1] & 0x000040) && m_spellInfo->SpellIconID == 2128)
                 {
                     // Incinerate does more dmg (dmg/6) if the target have Immolate debuff.
                     // Check aura state for speed but aura state set not only for Immolate spell
                     if (unitTarget->HasAuraState(AURA_STATE_CONFLAGRATE))
                     {
                         if (unitTarget->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_WARLOCK, flag128(0x4, 0, 0)))
                             damage += damage / 6;
                     }
                 }
                 break;
             }
             case SPELLFAMILY_PRIEST:
             {
                 break;
             }
             case SPELLFAMILY_DRUID:
             {
                 // Ferocious Bite
                 if (m_caster->GetTypeId() == TYPEID_PLAYER && m_spellInfo->SpellFamilyFlags[3] & 0x1000)
                 {
                     // converts each extra point of energy ( up to 25 energy ) into additional damage
                     int32 energy = -(m_caster->ModifyPower(POWER_ENERGY, -25));
                     // 25 energy = 100% more damage
                     AddPct(damage, energy * 4);
                 }
                 break;
             }
             case SPELLFAMILY_ROGUE:
             {
                 // Envenom
                 if (m_spellInfo->SpellFamilyFlags[1] & 0x00000008)
                 {
                     if (Player* player = m_caster->ToPlayer())
                     {
                         // consume from stack dozes not more that have combo-points
                         if (uint32 combo = player->GetComboPoints())
                         {
                             // Lookup for Deadly poison (only attacker applied)
                             if (AuraEffect const* aurEff = unitTarget->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_ROGUE, flag128(0x00010000, 0, 0), m_caster->GetGUID()))
                             {
                                 // count consumed deadly poison doses at target
                                 uint32 spellId = aurEff->GetId();
 
                                 uint32 doses = aurEff->GetBase()->GetStackAmount();
                                 if (doses > combo)
                                     doses = combo;
 
                                 for (uint32 i = 0; i < doses; ++i)
                                     unitTarget->RemoveAuraFromStack(spellId, m_caster->GetGUID());
 
                                 damage *= doses;
                                 damage += int32(player->GetTotalAttackPowerValue(BASE_ATTACK) * 0.09f * combo);
                             }
 
                             // Eviscerate and Envenom Bonus Damage (item set effect)
                             if (m_caster->HasAura(37169))
                                 damage += combo * 40;
                         }
                     }
                 }
                 // Eviscerate
                 else if (m_spellInfo->SpellFamilyFlags[0] & 0x00020000)
                 {
                     if (Player* player = m_caster->ToPlayer())
                     {
                         if (uint32 combo = player->GetComboPoints())
                         {
                             float ap = m_caster->GetTotalAttackPowerValue(BASE_ATTACK);
                             damage += irand(int32(ap * combo * 0.03f), int32(ap * combo * 0.07f));
 
                             // Eviscerate and Envenom Bonus Damage (item set effect)
                             if (m_caster->HasAura(37169))
                                 damage += combo*40;
                         }
                     }
                 }
                 break;
             }
             case SPELLFAMILY_DEATHKNIGHT:
             {
                 // Blood Boil - bonus for diseased targets
                 if (m_spellInfo->SpellFamilyFlags[0] & 0x00040000)
                 {
                     if (unitTarget->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_DEATHKNIGHT, flag128(0, 0, 0x00000002), m_caster->GetGUID()))
                     {
                         damage += m_damage / 2;
                         damage += int32(m_caster->GetTotalAttackPowerValue(BASE_ATTACK) * 0.035f);
                     }
                 }
                 break;
             }
         }
 
         if (m_originalCaster && apply_direct_bonus)
         {
             uint32 bonus = m_originalCaster->SpellDamageBonusDone(unitTarget, m_spellInfo, (uint32)damage, SPELL_DIRECT_DAMAGE, effectInfo);
             damage = bonus + uint32(bonus * variance);
             damage = unitTarget->SpellDamageBonusTaken(m_originalCaster, m_spellInfo, (uint32)damage, SPELL_DIRECT_DAMAGE, effectInfo);
         }
 
         m_damage += damage;
     }
 }

Here is the call graph for this function:

void Spell::EffectScriptEffect ( SpellEffIndex effIndex )

Todo:: we must implement hunter pet summon at login there (spell 6962)

Todo:: a hack, range = 11, should after some time cast, otherwise too far

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
 
     switch (m_spellInfo->SpellFamilyName)
     {
         case SPELLFAMILY_GENERIC:
         {
             switch (m_spellInfo->Id)
             {
                 // Glyph of Backstab
                 case 63975:
                 {
                     // search our Rupture aura on target
                     if (AuraEffect const* aurEff = unitTarget->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_ROGUE, flag128(0x00100000, 0, 0), m_caster->GetGUID()))
                     {
                         uint32 countMin = aurEff->GetBase()->GetMaxDuration();
                         uint32 countMax = 12000; // this can be wrong, duration should be based on combo-points
                         countMax += m_caster->HasAura(56801) ? 4000 : 0;
 
                         if (countMin < countMax)
                         {
                             aurEff->GetBase()->SetDuration(uint32(aurEff->GetBase()->GetDuration() + 3000));
                             aurEff->GetBase()->SetMaxDuration(countMin + 2000);
                         }
 
                     }
                     return;
                 }
                 // Glyph of Scourge Strike
                 case 69961:
                 {
                     Unit::AuraEffectList const &mPeriodic = unitTarget->GetAuraEffectsByType(SPELL_AURA_PERIODIC_DAMAGE);
                     for (Unit::AuraEffectList::const_iterator i = mPeriodic.begin(); i != mPeriodic.end(); ++i)
                     {
                         AuraEffect const* aurEff = *i;
                         SpellInfo const* spellInfo = aurEff->GetSpellInfo();
                         // search our Blood Plague and Frost Fever on target
                         if (spellInfo->SpellFamilyName == SPELLFAMILY_DEATHKNIGHT && spellInfo->SpellFamilyFlags[2] & 0x2 &&
                             aurEff->GetCasterGUID() == m_caster->GetGUID())
                         {
                             uint32 countMin = aurEff->GetBase()->GetMaxDuration();
                             uint32 countMax = spellInfo->GetMaxDuration();
 
                             // this Glyph
                             countMax += 9000;
                             // talent Epidemic
                             if (AuraEffect const* epidemic = m_caster->GetAuraEffect(SPELL_AURA_ADD_FLAT_MODIFIER, SPELLFAMILY_DEATHKNIGHT, 234, EFFECT_0))
                                 countMax += epidemic->GetAmount();
 
                             if (countMin < countMax)
                             {
                                 aurEff->GetBase()->SetDuration(aurEff->GetBase()->GetDuration() + 3000);
                                 aurEff->GetBase()->SetMaxDuration(countMin + 3000);
                             }
                         }
                     }
                     return;
                 }
                 case 55693:                                 // Remove Collapsing Cave Aura
                     if (!unitTarget)
                         return;
                     unitTarget->RemoveAurasDueToSpell(effectInfo->CalcValue());
                     break;
                 // Bending Shinbone
                 case 8856:
                 {
                     if (!itemTarget && m_caster->GetTypeId() != TYPEID_PLAYER)
                         return;
 
                     uint32 spell_id = roll_chance_i(20) ? 8854 : 8855;
 
                     m_caster->CastSpell(m_caster, spell_id, true, NULL);
                     return;
                 }
                 // Brittle Armor - need remove one 24575 Brittle Armor aura
                 case 24590:
                     unitTarget->RemoveAuraFromStack(24575);
                     return;
                 // Mercurial Shield - need remove one 26464 Mercurial Shield aura
                 case 26465:
                     unitTarget->RemoveAuraFromStack(26464);
                     return;
                 // Shadow Flame (All script effects, not just end ones to prevent player from dodging the last triggered spell)
                 case 22539:
                 case 22972:
                 case 22975:
                 case 22976:
                 case 22977:
                 case 22978:
                 case 22979:
                 case 22980:
                 case 22981:
                 case 22982:
                 case 22983:
                 case 22984:
                 case 22985:
                 {
                     if (!unitTarget || !unitTarget->IsAlive())
                         return;
 
                     // Onyxia Scale Cloak
                     if (unitTarget->HasAura(22683))
                         return;
 
                     // Shadow Flame
                     m_caster->CastSpell(unitTarget, 22682, true);
                     return;
                 }
                 // Decimate
                 case 28374:
                 case 54426:
                     if (unitTarget)
                     {
                         int32 decimateDamage = int32(unitTarget->GetHealth()) - int32(unitTarget->CountPctFromMaxHealth(5));
                         if (decimateDamage > 0)
                             m_caster->CastCustomSpell(28375, SPELLVALUE_BASE_POINT0, decimateDamage, unitTarget);
                     }
                     return;
                 // Mirren's Drinking Hat
                 case 29830:
                 {
                     uint32 item = 0;
                     switch (urand(1, 6))
                     {
                         case 1:
                         case 2:
                         case 3:
                             item = 23584; break;            // Loch Modan Lager
                         case 4:
                         case 5:
                             item = 23585; break;            // Stouthammer Lite
                         case 6:
                             item = 23586; break;            // Aerie Peak Pale Ale
                     }
                     if (item)
                         DoCreateItem(effIndex, item);
                     break;
                 }
                 case 20589: // Escape artist
                 case 30918: // Improved Sprint
                 {
                     // Removes snares and roots.
                     unitTarget->RemoveMovementImpairingAuras();
                     break;
                 }
                 // Plant Warmaul Ogre Banner
                 case 32307:
                     if (Player* caster = m_caster->ToPlayer())
                     {
                         caster->RewardPlayerAndGroupAtEvent(18388, unitTarget);
                         if (Creature* target = unitTarget->ToCreature())
                         {
                             target->setDeathState(CORPSE);
                             target->RemoveCorpse();
                         }
                     }
                     break;
                 // Mug Transformation
                 case 41931:
                 {
                     if (m_caster->GetTypeId() != TYPEID_PLAYER)
                         return;
 
                     uint8 bag = 19;
                     uint8 slot = 0;
                     Item* item = NULL;
 
                     while (bag) // 256 = 0 due to var type
                     {
                         item = m_caster->ToPlayer()->GetItemByPos(bag, slot);
                         if (item && item->GetEntry() == 38587)
                             break;
 
                         ++slot;
                         if (slot == 39)
                         {
                             slot = 0;
                             ++bag;
                         }
                     }
                     if (bag)
                     {
                         if (m_caster->ToPlayer()->GetItemByPos(bag, slot)->GetCount() == 1) m_caster->ToPlayer()->RemoveItem(bag, slot, true);
                         else m_caster->ToPlayer()->GetItemByPos(bag, slot)->SetCount(m_caster->ToPlayer()->GetItemByPos(bag, slot)->GetCount()-1);
                         // Spell 42518 (Braufest - Gratisprobe des Braufest herstellen)
                         m_caster->CastSpell(m_caster, 42518, true);
                         return;
                     }
                     break;
                 }
                 // Brutallus - Burn
                 case 45141:
                 case 45151:
                 {
                     //Workaround for Range ... should be global for every ScriptEffect
                     float radius = effectInfo->CalcRadius();
                     if (unitTarget && unitTarget->GetTypeId() == TYPEID_PLAYER && unitTarget->GetDistance(m_caster) >= radius && !unitTarget->HasAura(46394) && unitTarget != m_caster)
                         unitTarget->CastSpell(unitTarget, 46394, true);
 
                     break;
                 }
                 // Goblin Weather Machine
                 case 46203:
                 {
                     if (!unitTarget)
                         return;
 
                     uint32 spellId = 0;
                     switch (rand32() % 4)
                     {
                         case 0: spellId = 46740; break;
                         case 1: spellId = 46739; break;
                         case 2: spellId = 46738; break;
                         case 3: spellId = 46736; break;
                     }
                     unitTarget->CastSpell(unitTarget, spellId, true);
                     break;
                 }
                 // 5, 000 Gold
                 case 46642:
                 {
                     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
                         return;
 
                     unitTarget->ToPlayer()->ModifyMoney(5000 * GOLD);
 
                     break;
                 }
                 // Roll Dice - Decahedral Dwarven Dice
                 case 47770:
                 {
                     char buf[128];
                     const char *gender = "his";
                     if (m_caster->getGender() > 0)
                         gender = "her";
                     sprintf(buf, "%s rubs %s [Decahedral Dwarven Dice] between %s hands and rolls. One %u and one %u.", m_caster->GetName().c_str(), gender, gender, urand(1, 10), urand(1, 10));
                     m_caster->TextEmote(buf);
                     break;
                 }
                 // Roll 'dem Bones - Worn Troll Dice
                 case 47776:
                 {
                     char buf[128];
                     const char *gender = "his";
                     if (m_caster->getGender() > 0)
                         gender = "her";
                     sprintf(buf, "%s causually tosses %s [Worn Troll Dice]. One %u and one %u.", m_caster->GetName().c_str(), gender, urand(1, 6), urand(1, 6));
                     m_caster->TextEmote(buf);
                     break;
                 }
                 // Death Knight Initiate Visual
                 case 51519:
                 {
                     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_UNIT)
                         return;
 
                     uint32 iTmpSpellId = 0;
                     switch (unitTarget->GetDisplayId())
                     {
                         case 25369: iTmpSpellId = 51552; break; // bloodelf female
                         case 25373: iTmpSpellId = 51551; break; // bloodelf male
                         case 25363: iTmpSpellId = 51542; break; // draenei female
                         case 25357: iTmpSpellId = 51541; break; // draenei male
                         case 25361: iTmpSpellId = 51537; break; // dwarf female
                         case 25356: iTmpSpellId = 51538; break; // dwarf male
                         case 25372: iTmpSpellId = 51550; break; // forsaken female
                         case 25367: iTmpSpellId = 51549; break; // forsaken male
                         case 25362: iTmpSpellId = 51540; break; // gnome female
                         case 25359: iTmpSpellId = 51539; break; // gnome male
                         case 25355: iTmpSpellId = 51534; break; // human female
                         case 25354: iTmpSpellId = 51520; break; // human male
                         case 25360: iTmpSpellId = 51536; break; // nightelf female
                         case 25358: iTmpSpellId = 51535; break; // nightelf male
                         case 25368: iTmpSpellId = 51544; break; // orc female
                         case 25364: iTmpSpellId = 51543; break; // orc male
                         case 25371: iTmpSpellId = 51548; break; // tauren female
                         case 25366: iTmpSpellId = 51547; break; // tauren male
                         case 25370: iTmpSpellId = 51545; break; // troll female
                         case 25365: iTmpSpellId = 51546; break; // troll male
                         default: return;
                     }
 
                     unitTarget->CastSpell(unitTarget, iTmpSpellId, true);
                     Creature* npc = unitTarget->ToCreature();
                     npc->LoadEquipment();
                     return;
                 }
                 // Deathbolt from Thalgran Blightbringer
                 // reflected by Freya's Ward
                 // Retribution by Sevenfold Retribution
                 case 51854:
                 {
                     if (!unitTarget)
                         return;
                     if (unitTarget->HasAura(51845))
                         unitTarget->CastSpell(m_caster, 51856, true);
                     else
                         m_caster->CastSpell(unitTarget, 51855, true);
                     break;
                 }
                 // Summon Ghouls On Scarlet Crusade
                 case 51904:
                 {
                     if (!m_targets.HasDst())
                         return;
 
                     float x, y, z;
                     float radius = effectInfo->CalcRadius();
                     for (uint8 i = 0; i < 15; ++i)
                     {
                         m_caster->GetRandomPoint(*destTarget, radius, x, y, z);
                         m_caster->CastSpell(x, y, z, 54522, true);
                     }
                     break;
                 }
                 case 52173: // Coyote Spirit Despawn
                 case 60243: // Blood Parrot Despawn
                     if (unitTarget->GetTypeId() == TYPEID_UNIT && unitTarget->IsSummon())
                         unitTarget->ToTempSummon()->UnSummon();
                     return;
                 case 52479: // Gift of the Harvester
                     if (unitTarget && m_originalCaster)
                         m_originalCaster->CastSpell(unitTarget, urand(0, 1) ? damage : 52505, true);
                     return;
                 case 53110: // Devour Humanoid
                     if (unitTarget)
                         unitTarget->CastSpell(m_caster, damage, true);
                     return;
                 case 57347: // Retrieving (Wintergrasp RP-GG pickup spell)
                 {
                     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_UNIT || m_caster->GetTypeId() != TYPEID_PLAYER)
                         return;
 
                     unitTarget->ToCreature()->DespawnOrUnsummon();
 
                     return;
                 }
                 case 57349: // Drop RP-GG (Wintergrasp RP-GG at death drop spell)
                 {
                     if (m_caster->GetTypeId() != TYPEID_PLAYER)
                         return;
 
                     // Delete item from inventory at death
                     m_caster->ToPlayer()->DestroyItemCount(damage, 5, true);
 
                     return;
                 }
                 case 58418:                                 // Portal to Orgrimmar
                 case 58420:                                 // Portal to Stormwind
                 {
                     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER || effIndex != 0)
                         return;
 
                     // Effects for 58418 and 58420 are all DIFFICULTY_NONE so always valid
                     uint32 spellID = GetEffect(EFFECT_0)->CalcValue();
                     uint32 questID = GetEffect(EFFECT_1)->CalcValue();
 
                     if (unitTarget->ToPlayer()->GetQuestStatus(questID) == QUEST_STATUS_COMPLETE)
                         unitTarget->CastSpell(unitTarget, spellID, true);
 
                     return;
                 }
                 case 58983: // Big Blizzard Bear
                 {
                     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
                         return;
 
                     // Prevent stacking of mounts and client crashes upon dismounting
                     unitTarget->RemoveAurasByType(SPELL_AURA_MOUNTED);
 
                     // Triggered spell id dependent on riding skill
                     if (uint16 skillval = unitTarget->ToPlayer()->GetSkillValue(SKILL_RIDING))
                     {
                         if (skillval >= 150)
                             unitTarget->CastSpell(unitTarget, 58999, true);
                         else
                             unitTarget->CastSpell(unitTarget, 58997, true);
                     }
                     return;
                 }
                 case 59317:                                 // Teleporting
                 {
 
                     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
                         return;
 
                     // return from top
                     if (unitTarget->ToPlayer()->GetAreaId() == 4637)
                         unitTarget->CastSpell(unitTarget, 59316, true);
                     // teleport atop
                     else
                         unitTarget->CastSpell(unitTarget, 59314, true);
 
                     return;
                 }
                 case 62482: // Grab Crate
                 {
                     if (unitTarget)
                     {
                         if (Unit* seat = m_caster->GetVehicleBase())
                         {
                             if (Unit* parent = seat->GetVehicleBase())
                             {
                                 m_caster->CastSpell(parent, 62496, true);
                                 unitTarget->CastSpell(parent, GetEffect(EFFECT_0)->CalcValue()); // DIFFICULTY_NONE, so effect always valid
                             }
                         }
                     }
                     return;
                 }
                 case 60123: // Lightwell
                 {
                     if (m_caster->GetTypeId() != TYPEID_UNIT || !m_caster->IsSummon())
                         return;
 
                     uint32 spell_heal;
 
                     switch (m_caster->GetEntry())
                     {
                         case 31897: spell_heal = 7001; break;
                         case 31896: spell_heal = 27873; break;
                         case 31895: spell_heal = 27874; break;
                         case 31894: spell_heal = 28276; break;
                         case 31893: spell_heal = 48084; break;
                         case 31883: spell_heal = 48085; break;
                         default:
                             TC_LOG_ERROR("spells", "Unknown Lightwell spell caster %u", m_caster->GetEntry());
                             return;
                     }
 
                     // proc a spellcast
                     if (Aura* chargesAura = m_caster->GetAura(59907))
                     {
                         m_caster->CastSpell(unitTarget, spell_heal, true, NULL, NULL, m_caster->ToTempSummon()->GetSummonerGUID());
                         if (chargesAura->ModCharges(-1))
                             m_caster->ToTempSummon()->UnSummon();
                     }
 
                     return;
                 }
                 // Stoneclaw Totem
                 case 55328: // Rank 1
                 case 55329: // Rank 2
                 case 55330: // Rank 3
                 case 55332: // Rank 4
                 case 55333: // Rank 5
                 case 55335: // Rank 6
                 case 55278: // Rank 7
                 case 58589: // Rank 8
                 case 58590: // Rank 9
                 case 58591: // Rank 10
                 {
                     int32 basepoints0 = damage;
                     // Cast Absorb on totems
                     for (uint8 slot = SUMMON_SLOT_TOTEM; slot < MAX_TOTEM_SLOT; ++slot)
                     {
                         if (!unitTarget->m_SummonSlot[slot])
                             continue;
 
                         Creature* totem = unitTarget->GetMap()->GetCreature(unitTarget->m_SummonSlot[slot]);
                         if (totem && totem->IsTotem())
                         {
                             m_caster->CastCustomSpell(totem, 55277, &basepoints0, NULL, NULL, true);
                         }
                     }
                     // Glyph of Stoneclaw Totem
                     if (AuraEffect* aur=unitTarget->GetAuraEffect(63298, 0))
                     {
                         basepoints0 *= aur->GetAmount();
                         m_caster->CastCustomSpell(unitTarget, 55277, &basepoints0, NULL, NULL, true);
                     }
                     break;
                 }
                 case 45668:                                 // Ultra-Advanced Proto-Typical Shortening Blaster
                 {
                     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_UNIT)
                         return;
 
                     if (roll_chance_i(50))                  // chance unknown, using 50
                         return;
 
                     static uint32 const spellPlayer[5] =
                     {
                         45674,                            // Bigger!
                         45675,                            // Shrunk
                         45678,                            // Yellow
                         45682,                            // Ghost
                         45684                             // Polymorph
                     };
 
                     static uint32 const spellTarget[5] =
                     {
                         45673,                            // Bigger!
                         45672,                            // Shrunk
                         45677,                            // Yellow
                         45681,                            // Ghost
                         45683                             // Polymorph
                     };
 
                     m_caster->CastSpell(m_caster, spellPlayer[urand(0, 4)], true);
                     unitTarget->CastSpell(unitTarget, spellTarget[urand(0, 4)], true);
                     break;
                 }
             }
             break;
         }
     }
 
     // normal DB scripted effect
     TC_LOG_DEBUG("spells", "Spell ScriptStart spellid %u in EffectScriptEffect(%u)", m_spellInfo->Id, effIndex);
     m_caster->GetMap()->ScriptsStart(sSpellScripts, uint32(m_spellInfo->Id | (effIndex << 24)), m_caster, unitTarget);
 }

void Spell::EffectSelfResurrect ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     if (!m_caster || m_caster->IsAlive())
         return;
     if (m_caster->GetTypeId() != TYPEID_PLAYER)
         return;
     if (!m_caster->IsInWorld())
         return;
 
     uint32 health = 0;
     uint32 mana = 0;
 
     // flat case
     if (damage < 0)
     {
         health = uint32(-damage);
         mana = effectInfo->MiscValue;
     }
     // percent case
     else
     {
         health = m_caster->CountPctFromMaxHealth(damage);
         if (m_caster->GetMaxPower(POWER_MANA) > 0)
             mana = CalculatePct(m_caster->GetMaxPower(POWER_MANA), damage);
     }
 
     Player* player = m_caster->ToPlayer();
     player->ResurrectPlayer(0.0f);
 
     player->SetHealth(health);
     player->SetPower(POWER_MANA, mana);
     player->SetPower(POWER_RAGE, 0);
     player->SetPower(POWER_ENERGY, player->GetMaxPower(POWER_ENERGY));
     player->SetPower(POWER_FOCUS, 0);
 
     player->SpawnCorpseBones();
 }

Here is the call graph for this function:

void Spell::EffectSendEvent ( SpellEffIndex effIndex )

Todo:: there should be a possibility to pass dest target to event script

 {
     // we do not handle a flag dropping or clicking on flag in battleground by sendevent system
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET
         && effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     WorldObject* target = NULL;
 
     // call events for object target if present
     if (effectHandleMode == SPELL_EFFECT_HANDLE_HIT_TARGET)
     {
         if (unitTarget)
             target = unitTarget;
         else if (gameObjTarget)
             target = gameObjTarget;
     }
     else // if (effectHandleMode == SPELL_EFFECT_HANDLE_HIT)
     {
         // let's prevent executing effect handler twice in case when spell effect is capable of targeting an object
         // this check was requested by scripters, but it has some downsides:
         // now it's impossible to script (using sEventScripts) a cast which misses all targets
         // or to have an ability to script the moment spell hits dest (in a case when there are object targets present)
         if (effectInfo->GetProvidedTargetMask() & (TARGET_FLAG_UNIT_MASK | TARGET_FLAG_GAMEOBJECT_MASK))
             return;
         // some spells have no target entries in dbc and they use focus target
         if (focusObject)
             target = focusObject;
     }
 
     TC_LOG_DEBUG("spells", "Spell ScriptStart %u for spellid %u in EffectSendEvent ", effectInfo->MiscValue, m_spellInfo->Id);
 
     if (ZoneScript* zoneScript = m_caster->GetZoneScript())
         zoneScript->ProcessEvent(target, effectInfo->MiscValue);
     else if (InstanceScript* instanceScript = m_caster->GetInstanceScript())    // needed in case Player is the caster
         instanceScript->ProcessEvent(target, effectInfo->MiscValue);
 
     m_caster->GetMap()->ScriptsStart(sEventScripts, effectInfo->MiscValue, m_caster, target);
 }

Here is the call graph for this function:

void Spell::EffectSendTaxi ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     unitTarget->ToPlayer()->ActivateTaxiPathTo(effectInfo->MiscValue, m_spellInfo->Id);
 }

Here is the call graph for this function:

void Spell::EffectSkill ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     TC_LOG_DEBUG("spells", "WORLD: SkillEFFECT");
 }

void Spell::EffectSkinning ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (unitTarget->GetTypeId() != TYPEID_UNIT)
         return;
     if (m_caster->GetTypeId() != TYPEID_PLAYER)
         return;
 
     Creature* creature = unitTarget->ToCreature();
     int32 targetLevel = creature->getLevel();
 
     uint32 skill = creature->GetCreatureTemplate()->GetRequiredLootSkill();
 
     m_caster->ToPlayer()->SendLoot(creature->GetGUID(), LOOT_SKINNING);
     creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE);
     creature->SetFlag(OBJECT_DYNAMIC_FLAGS, UNIT_DYNFLAG_LOOTABLE);
 
     int32 reqValue = targetLevel < 10 ? 0 : targetLevel < 20 ? (targetLevel-10)*10 : targetLevel*5;
 
     int32 skillValue = m_caster->ToPlayer()->GetPureSkillValue(skill);
 
     // Double chances for elites
     m_caster->ToPlayer()->UpdateGatherSkill(skill, skillValue, reqValue, creature->isElite() ? 2 : 1);
 }

Here is the call graph for this function:

void Spell::EffectSkinPlayerCorpse ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     TC_LOG_DEBUG("spells", "Effect: SkinPlayerCorpse");
 
     Player* player = m_caster->ToPlayer();
     Player* target = unitTarget->ToPlayer();
     if (!player || !target || target->IsAlive())
         return;
 
     target->RemovedInsignia(player);
 }

Here is the call graph for this function:

void Spell::EffectSpecCount ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     unitTarget->ToPlayer()->UpdateTalentGroupCount(damage);
 }

Here is the call graph for this function:

void Spell::EffectSpiritHeal ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     /*
     if (unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
     if (!unitTarget->IsInWorld())
         return;
 
     //m_spellInfo->Effects[i].BasePoints; == 99 (percent?)
     //unitTarget->ToPlayer()->setResurrect(m_caster->GetGUID(), unitTarget->GetPositionX(), unitTarget->GetPositionY(), unitTarget->GetPositionZ(), unitTarget->GetMaxHealth(), unitTarget->GetMaxPower(POWER_MANA));
     unitTarget->ToPlayer()->ResurrectPlayer(1.0f);
     unitTarget->ToPlayer()->SpawnCorpseBones();
     */
 }

void Spell::EffectStealBeneficialBuff ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     TC_LOG_DEBUG("spells", "Effect: StealBeneficialBuff");
 
     if (!unitTarget || unitTarget == m_caster)                 // can't steal from self
         return;
 
     DispelChargesList steal_list;
 
     // Create dispel mask by dispel type
     uint32 dispelMask = SpellInfo::GetDispelMask(DispelType(effectInfo->MiscValue));
     Unit::AuraMap const& auras = unitTarget->GetOwnedAuras();
     for (Unit::AuraMap::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
     {
         Aura* aura = itr->second;
         AuraApplication * aurApp = aura->GetApplicationOfTarget(unitTarget->GetGUID());
         if (!aurApp)
             continue;
 
         if ((aura->GetSpellInfo()->GetDispelMask()) & dispelMask)
         {
             // Need check for passive? this
             if (!aurApp->IsPositive() || aura->IsPassive() || aura->GetSpellInfo()->AttributesEx4 & SPELL_ATTR4_NOT_STEALABLE)
                 continue;
 
             // The charges / stack amounts don't count towards the total number of auras that can be dispelled.
             // Ie: A dispel on a target with 5 stacks of Winters Chill and a Polymorph has 1 / (1 + 1) -> 50% chance to dispell
             // Polymorph instead of 1 / (5 + 1) -> 16%.
             bool dispel_charges = (aura->GetSpellInfo()->AttributesEx7 & SPELL_ATTR7_DISPEL_CHARGES) != 0;
             uint8 charges = dispel_charges ? aura->GetCharges() : aura->GetStackAmount();
             if (charges > 0)
                 steal_list.push_back(std::make_pair(aura, charges));
         }
     }
 
     if (steal_list.empty())
         return;
 
     // Ok if exist some buffs for dispel try dispel it
     DispelList success_list;
     WorldPackets::Spells::DispelFailed dispelFailed;
     dispelFailed.CasterGUID = m_caster->GetGUID();
     dispelFailed.VictimGUID = unitTarget->GetGUID();
     dispelFailed.SpellID = m_spellInfo->Id;
 
     // dispel N = damage buffs (or while exist buffs for dispel)
     for (int32 count = 0; count < damage && !steal_list.empty();)
     {
         // Random select buff for dispel
         DispelChargesList::iterator itr = steal_list.begin();
         std::advance(itr, urand(0, steal_list.size() - 1));
 
         int32 chance = itr->first->CalcDispelChance(unitTarget, !unitTarget->IsFriendlyTo(m_caster));
         // 2.4.3 Patch Notes: "Dispel effects will no longer attempt to remove effects that have 100% dispel resistance."
         if (!chance)
         {
             steal_list.erase(itr);
             continue;
         }
         else
         {
             if (roll_chance_i(chance))
             {
                 success_list.push_back(std::make_pair(itr->first->GetId(), itr->first->GetCasterGUID()));
                 --itr->second;
                 if (itr->second <= 0)
                     steal_list.erase(itr);
             }
             else
                 dispelFailed.FailedSpells.push_back(int32(itr->first->GetId()));
 
             ++count;
         }
     }
 
     if (!dispelFailed.FailedSpells.empty())
         m_caster->SendMessageToSet(dispelFailed.Write(), true);
 
     if (success_list.empty())
         return;
 
     WorldPackets::CombatLog::SpellDispellLog spellDispellLog;
     spellDispellLog.IsBreak = false; // TODO: use me
     spellDispellLog.IsSteal = true;
 
     spellDispellLog.TargetGUID = unitTarget->GetGUID();
     spellDispellLog.CasterGUID = m_caster->GetGUID();
     spellDispellLog.DispelledBySpellID = m_spellInfo->Id;
 
     for (std::pair<uint32, ObjectGuid> const& dispell : success_list)
     {
         WorldPackets::CombatLog::SpellDispellData dispellData;
         dispellData.SpellID = dispell.first;
         dispellData.Harmful = false;      // TODO: use me
         dispellData.Rolled = boost::none; // TODO: use me
         dispellData.Needed = boost::none; // TODO: use me
 
         unitTarget->RemoveAurasDueToSpellBySteal(dispell.first, dispell.second, m_caster);
 
         spellDispellLog.DispellData.emplace_back(dispellData);
     }
 
     m_caster->SendMessageToSet(spellDispellLog.Write(), true);
 }

Here is the call graph for this function:

void Spell::EffectStuck ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     if (!sWorld->getBoolConfig(CONFIG_CAST_UNSTUCK))
         return;
 
     Player* player = m_caster->ToPlayer();
     if (!player)
         return;
 
     TC_LOG_DEBUG("spells", "Spell Effect: Stuck");
     TC_LOG_DEBUG("spells", "Player %s (%s) used auto-unstuck future at map %u (%f, %f, %f)", player->GetName().c_str(), player->GetGUID().ToString().c_str(), player->GetMapId(), player->GetPositionX(), player->GetPositionY(), player->GetPositionZ());
 
     if (player->IsInFlight())
         return;
 
     // if player is dead without death timer is teleported to graveyard, otherwise not apply the effect
     if (player->isDead())
     {
         if (!player->GetDeathTimer())
             player->RepopAtGraveyard();
 
         return;
     }
 
     // the player dies if hearthstone is in cooldown, else the player is teleported to home
     if (player->GetSpellHistory()->HasCooldown(8690))
     {
         player->Kill(player);
         return;
     }
 
     player->TeleportTo(player->m_homebindMapId, player->m_homebindX, player->m_homebindY, player->m_homebindZ, player->GetOrientation(), TELE_TO_SPELL);
 
     // Stuck spell trigger Hearthstone cooldown
     SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(8690);
     if (!spellInfo)
         return;
     Spell spell(player, spellInfo, TRIGGERED_FULL_MASK);
     spell.SendSpellCooldown();
 }

Here is the call graph for this function:

void Spell::EffectSummonChangeItem ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     if (m_caster->GetTypeId() != TYPEID_PLAYER)
         return;
 
     Player* player = m_caster->ToPlayer();
 
     // applied only to using item
     if (!m_CastItem)
         return;
 
     // ... only to item in own inventory/bank/equip_slot
     if (m_CastItem->GetOwnerGUID() != player->GetGUID())
         return;
 
     uint32 newitemid = effectInfo->ItemType;
     if (!newitemid)
         return;
 
     uint16 pos = m_CastItem->GetPos();
 
     Item* pNewItem = Item::CreateItem(newitemid, 1, player);
     if (!pNewItem)
         return;
 
     for (uint8 j = PERM_ENCHANTMENT_SLOT; j <= TEMP_ENCHANTMENT_SLOT; ++j)
         if (m_CastItem->GetEnchantmentId(EnchantmentSlot(j)))
             pNewItem->SetEnchantment(EnchantmentSlot(j), m_CastItem->GetEnchantmentId(EnchantmentSlot(j)), m_CastItem->GetEnchantmentDuration(EnchantmentSlot(j)), m_CastItem->GetEnchantmentCharges(EnchantmentSlot(j)));
 
     if (m_CastItem->GetUInt32Value(ITEM_FIELD_DURABILITY) < m_CastItem->GetUInt32Value(ITEM_FIELD_MAXDURABILITY))
     {
         double lossPercent = 1 - m_CastItem->GetUInt32Value(ITEM_FIELD_DURABILITY) / double(m_CastItem->GetUInt32Value(ITEM_FIELD_MAXDURABILITY));
         player->DurabilityLoss(pNewItem, lossPercent);
     }
 
     if (player->IsInventoryPos(pos))
     {
         ItemPosCountVec dest;
         InventoryResult msg = player->CanStoreItem(m_CastItem->GetBagSlot(), m_CastItem->GetSlot(), dest, pNewItem, true);
         if (msg == EQUIP_ERR_OK)
         {
             player->DestroyItem(m_CastItem->GetBagSlot(), m_CastItem->GetSlot(), true);
 
             // prevent crash at access and unexpected charges counting with item update queue corrupt
             if (m_CastItem == m_targets.GetItemTarget())
                 m_targets.SetItemTarget(NULL);
 
             m_CastItem = NULL;
             m_castItemGUID.Clear();
             m_castItemEntry = 0;
             m_castItemLevel = -1;
 
             player->StoreItem(dest, pNewItem, true);
             return;
         }
     }
     else if (player->IsBankPos(pos))
     {
         ItemPosCountVec dest;
         uint8 msg = player->CanBankItem(m_CastItem->GetBagSlot(), m_CastItem->GetSlot(), dest, pNewItem, true);
         if (msg == EQUIP_ERR_OK)
         {
             player->DestroyItem(m_CastItem->GetBagSlot(), m_CastItem->GetSlot(), true);
 
             // prevent crash at access and unexpected charges counting with item update queue corrupt
             if (m_CastItem == m_targets.GetItemTarget())
                 m_targets.SetItemTarget(NULL);
 
             m_CastItem = NULL;
             m_castItemGUID.Clear();
             m_castItemEntry = 0;
             m_castItemLevel = -1;
 
             player->BankItem(dest, pNewItem, true);
             return;
         }
     }
     else if (player->IsEquipmentPos(pos))
     {
         uint16 dest;
 
         player->DestroyItem(m_CastItem->GetBagSlot(), m_CastItem->GetSlot(), true);
 
         uint8 msg = player->CanEquipItem(m_CastItem->GetSlot(), dest, pNewItem, true);
 
         if (msg == EQUIP_ERR_OK || msg == EQUIP_ERR_CLIENT_LOCKED_OUT)
         {
             if (msg == EQUIP_ERR_CLIENT_LOCKED_OUT) dest = EQUIPMENT_SLOT_MAINHAND;
 
             // prevent crash at access and unexpected charges counting with item update queue corrupt
             if (m_CastItem == m_targets.GetItemTarget())
                 m_targets.SetItemTarget(NULL);
 
             m_CastItem = NULL;
             m_castItemGUID.Clear();
             m_castItemEntry = 0;
             m_castItemLevel = -1;
 
             player->EquipItem(dest, pNewItem, true);
             player->AutoUnequipOffhandIfNeed();
             return;
         }
     }
 
     // fail
     delete pNewItem;
 }

Here is the call graph for this function:

void Spell::EffectSummonCritter ( SpellEffIndex effIndex )

void Spell::EffectSummonObject ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     uint32 go_id = effectInfo->MiscValue;
     uint8 slot = effectInfo->Effect - SPELL_EFFECT_SUMMON_OBJECT_SLOT1;
     ObjectGuid guid = m_caster->m_ObjectSlot[slot];
     if (!guid.IsEmpty())
     {
         if (GameObject* obj = m_caster->GetMap()->GetGameObject(guid))
         {
             // Recast case - null spell id to make auras not be removed on object remove from world
             if (m_spellInfo->Id == obj->GetSpellId())
                 obj->SetSpellId(0);
             m_caster->RemoveGameObject(obj, true);
         }
         m_caster->m_ObjectSlot[slot].Clear();
     }
 
     GameObject* go = new GameObject();
 
     float x, y, z;
     // If dest location if present
     if (m_targets.HasDst())
         destTarget->GetPosition(x, y, z);
     // Summon in random point all other units if location present
     else
         m_caster->GetClosePoint(x, y, z, DEFAULT_WORLD_OBJECT_SIZE);
 
     Map* map = m_caster->GetMap();
     if (!go->Create(map->GenerateLowGuid<HighGuid::GameObject>(), go_id, map,
         0, x, y, z, m_caster->GetOrientation(), 0.0f, 0.0f, 0.0f, 0.0f, 0, GO_STATE_READY))
     {
         delete go;
         return;
     }
 
     go->CopyPhaseFrom(m_caster);
 
     //pGameObj->SetUInt32Value(GAMEOBJECT_LEVEL, m_caster->getLevel());
     int32 duration = m_spellInfo->GetDuration();
     go->SetRespawnTime(duration > 0 ? duration/IN_MILLISECONDS : 0);
     go->SetSpellId(m_spellInfo->Id);
     m_caster->AddGameObject(go);
 
     ExecuteLogEffectSummonObject(effIndex, go);
 
     map->AddToMap(go);
 
     m_caster->m_ObjectSlot[slot] = go->GetGUID();
 }

Here is the call graph for this function:

void Spell::EffectSummonObjectWild ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     uint32 gameobject_id = effectInfo->MiscValue;
 
     GameObject* pGameObj = new GameObject;
 
     WorldObject* target = focusObject;
     if (!target)
         target = m_caster;
 
     float x, y, z;
     if (m_targets.HasDst())
         destTarget->GetPosition(x, y, z);
     else
         m_caster->GetClosePoint(x, y, z, DEFAULT_WORLD_OBJECT_SIZE);
 
     Map* map = target->GetMap();
 
     if (!pGameObj->Create(map->GenerateLowGuid<HighGuid::GameObject>(), gameobject_id, map,
         m_caster->GetPhaseMask(), x, y, z, target->GetOrientation(), 0.0f, 0.0f, 0.0f, 0.0f, 100, GO_STATE_READY))
     {
         delete pGameObj;
         return;
     }
 
     pGameObj->CopyPhaseFrom(m_caster);
 
     int32 duration = m_spellInfo->GetDuration();
 
     pGameObj->SetRespawnTime(duration > 0 ? duration/IN_MILLISECONDS : 0);
     pGameObj->SetSpellId(m_spellInfo->Id);
 
     ExecuteLogEffectSummonObject(effIndex, pGameObj);
 
     // Wild object not have owner and check clickable by players
     map->AddToMap(pGameObj);
 
     if (pGameObj->GetGoType() == GAMEOBJECT_TYPE_FLAGDROP)
         if (Player* player = m_caster->ToPlayer())
             if (Battleground* bg = player->GetBattleground())
                 bg->SetDroppedFlagGUID(pGameObj->GetGUID(), player->GetTeam() == ALLIANCE ? TEAM_HORDE: TEAM_ALLIANCE);
 
     if (uint32 linkedEntry = pGameObj->GetGOInfo()->GetLinkedGameObjectEntry())
     {
         GameObject* linkedGO = new GameObject;
         if (linkedGO->Create(map->GenerateLowGuid<HighGuid::GameObject>(), linkedEntry, map,
             m_caster->GetPhaseMask(), x, y, z, target->GetOrientation(), 0.0f, 0.0f, 0.0f, 0.0f, 100, GO_STATE_READY))
         {
             linkedGO->CopyPhaseFrom(m_caster);
 
             linkedGO->SetRespawnTime(duration > 0 ? duration/IN_MILLISECONDS : 0);
             linkedGO->SetSpellId(m_spellInfo->Id);
 
             ExecuteLogEffectSummonObject(effIndex, linkedGO);
 
             // Wild object not have owner and check clickable by players
             map->AddToMap(linkedGO);
         }
         else
         {
             delete linkedGO;
             linkedGO = NULL;
             return;
         }
     }
 }

Here is the call graph for this function:

void Spell::EffectSummonPet ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     Player* owner = NULL;
     if (m_originalCaster)
     {
         owner = m_originalCaster->ToPlayer();
         if (!owner && m_originalCaster->IsTotem())
             owner = m_originalCaster->GetCharmerOrOwnerPlayerOrPlayerItself();
     }
 
     uint32 petentry = effectInfo->MiscValue;
 
     if (!owner)
     {
         SummonPropertiesEntry const* properties = sSummonPropertiesStore.LookupEntry(67);
         if (properties)
             SummonGuardian(effIndex, petentry, properties, 1);
         return;
     }
 
     Pet* OldSummon = owner->GetPet();
 
     // if pet requested type already exist
     if (OldSummon)
     {
         if (petentry == 0 || OldSummon->GetEntry() == petentry)
         {
             // pet in corpse state can't be summoned
             if (OldSummon->isDead())
                 return;
 
             ASSERT(OldSummon->GetMap() == owner->GetMap());
 
             //OldSummon->GetMap()->Remove(OldSummon->ToCreature(), false);
 
             float px, py, pz;
             owner->GetClosePoint(px, py, pz, OldSummon->GetObjectSize());
 
             OldSummon->NearTeleportTo(px, py, pz, OldSummon->GetOrientation());
             //OldSummon->Relocate(px, py, pz, OldSummon->GetOrientation());
             //OldSummon->SetMap(owner->GetMap());
             //owner->GetMap()->Add(OldSummon->ToCreature());
 
             if (owner->GetTypeId() == TYPEID_PLAYER && OldSummon->isControlled())
                 owner->ToPlayer()->PetSpellInitialize();
 
             return;
         }
 
         if (owner->GetTypeId() == TYPEID_PLAYER)
             owner->ToPlayer()->RemovePet(OldSummon, (OldSummon->getPetType() == HUNTER_PET ? PET_SAVE_AS_DELETED : PET_SAVE_NOT_IN_SLOT), false);
         else
             return;
     }
 
     float x, y, z;
     owner->GetClosePoint(x, y, z, owner->GetObjectSize());
     Pet* pet = owner->SummonPet(petentry, x, y, z, owner->GetOrientation(), SUMMON_PET, 0);
     if (!pet)
         return;
 
     if (m_caster->GetTypeId() == TYPEID_UNIT)
     {
         if (m_caster->IsTotem())
             pet->SetReactState(REACT_AGGRESSIVE);
         else
             pet->SetReactState(REACT_DEFENSIVE);
     }
 
     pet->SetUInt32Value(UNIT_CREATED_BY_SPELL, m_spellInfo->Id);
 
     // generate new name for summon pet
     std::string new_name=sObjectMgr->GeneratePetName(petentry);
     if (!new_name.empty())
         pet->SetName(new_name);
 
     ExecuteLogEffectSummonObject(effIndex, pet);
 }

Here is the call graph for this function:

void Spell::EffectSummonPlayer ( SpellEffIndex effIndex )

 {
     // workaround - this effect should not use target map
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     // Evil Twin (ignore player summon, but hide this for summoner)
     if (unitTarget->HasAura(23445))
         return;
 
     float x, y, z;
     m_caster->GetPosition(x, y, z);
 
     unitTarget->ToPlayer()->SetSummonPoint(m_caster->GetMapId(), x, y, z);
 
     WorldPacket data(SMSG_SUMMON_REQUEST, 8+4+4);
     data << m_caster->GetGUID();                            // summoner guid
     data << uint32(m_caster->GetZoneId());                  // summoner zone
     data << uint32(MAX_PLAYER_SUMMON_DELAY*IN_MILLISECONDS); // auto decline after msecs
     unitTarget->ToPlayer()->GetSession()->SendPacket(&data);
 }

Here is the call graph for this function:

void Spell::EffectSummonRaFFriend ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (m_caster->GetTypeId() != TYPEID_PLAYER || !unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     m_caster->CastSpell(unitTarget, effectInfo->TriggerSpell, true);
 }

Here is the call graph for this function:

void Spell::EffectSummonType ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     uint32 entry = effectInfo->MiscValue;
     if (!entry)
         return;
 
     SummonPropertiesEntry const* properties = sSummonPropertiesStore.LookupEntry(effectInfo->MiscValueB);
     if (!properties)
     {
         TC_LOG_ERROR("spells", "EffectSummonType: Unhandled summon type %u", effectInfo->MiscValueB);
         return;
     }
 
     if (!m_originalCaster)
         return;
 
     int32 duration = m_spellInfo->GetDuration();
     if (Player* modOwner = m_originalCaster->GetSpellModOwner())
         modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_DURATION, duration);
 
     TempSummon* summon = NULL;
 
     // determine how many units should be summoned
     uint32 numSummons;
 
     // some spells need to summon many units, for those spells number of summons is stored in effect value
     // however so far noone found a generic check to find all of those (there's no related data in summonproperties.dbc
     // and in spell attributes, possibly we need to add a table for those)
     // so here's a list of MiscValueB values, which is currently most generic check
     switch (properties->ID)
     {
         case 64:
         case 61:
         case 1101:
         case 66:
         case 648:
         case 2301:
         case 1061:
         case 1261:
         case 629:
         case 181:
         case 715:
         case 1562:
         case 833:
         case 1161:
         case 713:
             numSummons = (damage > 0) ? damage : 1;
             break;
         default:
             numSummons = 1;
             break;
     }
 
     switch (properties->Category)
     {
         case SUMMON_CATEGORY_WILD:
         case SUMMON_CATEGORY_ALLY:
         case SUMMON_CATEGORY_UNK:
             if (properties->Flags & 512)
             {
                 SummonGuardian(effIndex, entry, properties, numSummons);
                 break;
             }
             switch (properties->Type)
             {
                 case SUMMON_TYPE_PET:
                 case SUMMON_TYPE_GUARDIAN:
                 case SUMMON_TYPE_GUARDIAN2:
                 case SUMMON_TYPE_MINION:
                     SummonGuardian(effIndex, entry, properties, numSummons);
                     break;
                 // Summons a vehicle, but doesn't force anyone to enter it (see SUMMON_CATEGORY_VEHICLE)
                 case SUMMON_TYPE_VEHICLE:
                 case SUMMON_TYPE_VEHICLE2:
                     summon = m_caster->GetMap()->SummonCreature(entry, *destTarget, properties, duration, m_originalCaster, m_spellInfo->Id);
                     break;
                 case SUMMON_TYPE_LIGHTWELL:
                 case SUMMON_TYPE_TOTEM:
                 {
                     summon = m_caster->GetMap()->SummonCreature(entry, *destTarget, properties, duration, m_originalCaster, m_spellInfo->Id);
                     if (!summon || !summon->IsTotem())
                         return;
 
                     // Mana Tide Totem
                     if (m_spellInfo->Id == 16190)
                         damage = m_caster->CountPctFromMaxHealth(10);
 
                     if (damage)                                            // if not spell info, DB values used
                     {
                         summon->SetMaxHealth(damage);
                         summon->SetHealth(damage);
                     }
                     break;
                 }
                 case SUMMON_TYPE_MINIPET:
                 {
                     summon = m_caster->GetMap()->SummonCreature(entry, *destTarget, properties, duration, m_originalCaster, m_spellInfo->Id);
                     if (!summon || !summon->HasUnitTypeMask(UNIT_MASK_MINION))
                         return;
 
                     summon->SelectLevel();       // some summoned creaters have different from 1 DB data for level/hp
                     summon->SetUInt64Value(UNIT_NPC_FLAGS, summon->GetCreatureTemplate()->npcflag);
 
                     summon->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC | UNIT_FLAG_IMMUNE_TO_NPC);
 
                     summon->AI()->EnterEvadeMode();
                     break;
                 }
                 default:
                 {
                     float radius = effectInfo->CalcRadius();
 
                     TempSummonType summonType = (duration == 0) ? TEMPSUMMON_DEAD_DESPAWN : TEMPSUMMON_TIMED_DESPAWN;
 
                     for (uint32 count = 0; count < numSummons; ++count)
                     {
                         Position pos;
                         if (count == 0)
                             pos = *destTarget;
                         else
                             // randomize position for multiple summons
                             pos = m_caster->GetRandomPoint(*destTarget, radius);
 
                         summon = m_originalCaster->SummonCreature(entry, pos, summonType, duration);
                         if (!summon)
                             continue;
 
                         if (properties->Category == SUMMON_CATEGORY_ALLY)
                         {
                             summon->SetOwnerGUID(m_originalCaster->GetGUID());
                             summon->setFaction(m_originalCaster->getFaction());
                             summon->SetUInt32Value(UNIT_CREATED_BY_SPELL, m_spellInfo->Id);
                         }
 
                         ExecuteLogEffectSummonObject(effIndex, summon);
                     }
                     return;
                 }
             }//switch
             break;
         case SUMMON_CATEGORY_PET:
             SummonGuardian(effIndex, entry, properties, numSummons);
             break;
         case SUMMON_CATEGORY_PUPPET:
             summon = m_caster->GetMap()->SummonCreature(entry, *destTarget, properties, duration, m_originalCaster, m_spellInfo->Id);
             break;
         case SUMMON_CATEGORY_VEHICLE:
             // Summoning spells (usually triggered by npc_spellclick) that spawn a vehicle and that cause the clicker
             // to cast a ride vehicle spell on the summoned unit.
             summon = m_originalCaster->GetMap()->SummonCreature(entry, *destTarget, properties, duration, m_caster, m_spellInfo->Id);
             if (!summon || !summon->IsVehicle())
                 return;
 
             // The spell that this effect will trigger. It has SPELL_AURA_CONTROL_VEHICLE
             uint32 spellId = VEHICLE_SPELL_RIDE_HARDCODED;
             SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(effectInfo->CalcValue());
             if (spellInfo && spellInfo->HasAura(m_originalCaster->GetMap()->GetDifficultyID(), SPELL_AURA_CONTROL_VEHICLE))
                 spellId = spellInfo->Id;
 
             // Hard coded enter vehicle spell
             m_originalCaster->CastSpell(summon, spellId, true);
 
             uint32 faction = properties->Faction;
             if (!faction)
                 faction = m_originalCaster->getFaction();
 
             summon->setFaction(faction);
             break;
     }
 
     if (summon)
     {
         summon->SetCreatorGUID(m_originalCaster->GetGUID());
         ExecuteLogEffectSummonObject(effIndex, summon);
     }
 }

Here is the call graph for this function:

void Spell::EffectTameCreature ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!m_caster->GetPetGUID().IsEmpty())
         return;
 
     if (!unitTarget)
         return;
 
     if (unitTarget->GetTypeId() != TYPEID_UNIT)
         return;
 
     Creature* creatureTarget = unitTarget->ToCreature();
 
     if (creatureTarget->IsPet())
         return;
 
     if (m_caster->getClass() != CLASS_HUNTER)
         return;
 
     // cast finish successfully
     //SendChannelUpdate(0);
     finish();
 
     Pet* pet = m_caster->CreateTamedPetFrom(creatureTarget, m_spellInfo->Id);
     if (!pet)                                               // in very specific state like near world end/etc.
         return;
 
     // "kill" original creature
     creatureTarget->DespawnOrUnsummon();
 
     uint8 level = (creatureTarget->getLevel() < (m_caster->getLevel() - 5)) ? (m_caster->getLevel() - 5) : creatureTarget->getLevel();
 
     // prepare visual effect for levelup
     pet->SetUInt32Value(UNIT_FIELD_LEVEL, level - 1);
 
     // add to world
     pet->GetMap()->AddToMap(pet->ToCreature());
 
     // visual effect for levelup
     pet->SetUInt32Value(UNIT_FIELD_LEVEL, level);
 
     // caster have pet now
     m_caster->SetMinion(pet, true);
 
     pet->InitTalentForLevel();
 
     if (m_caster->GetTypeId() == TYPEID_PLAYER)
     {
         pet->SavePetToDB(PET_SAVE_AS_CURRENT);
         m_caster->ToPlayer()->PetSpellInitialize();
     }
 }

Here is the call graph for this function:

void Spell::EffectTaunt ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget)
         return;
 
     // this effect use before aura Taunt apply for prevent taunt already attacking target
     // for spell as marked "non effective at already attacking target"
     if (!unitTarget || !unitTarget->CanHaveThreatList()
         || unitTarget->GetVictim() == m_caster)
     {
         SendCastResult(SPELL_FAILED_DONT_REPORT);
         return;
     }
 
     if (!unitTarget->getThreatManager().getOnlineContainer().empty())
     {
         // Also use this effect to set the taunter's threat to the taunted creature's highest value
         float myThreat = unitTarget->getThreatManager().getThreat(m_caster);
         float topThreat = unitTarget->getThreatManager().getOnlineContainer().getMostHated()->getThreat();
         if (topThreat > myThreat)
             unitTarget->getThreatManager().doAddThreat(m_caster, topThreat - myThreat);
 
         //Set aggro victim to caster
         if (HostileReference* forcedVictim = unitTarget->getThreatManager().getOnlineContainer().getReferenceByTarget(m_caster))
             unitTarget->getThreatManager().setCurrentVictim(forcedVictim);
     }
 
     if (unitTarget->ToCreature()->IsAIEnabled && !unitTarget->ToCreature()->HasReactState(REACT_PASSIVE))
         unitTarget->ToCreature()->AI()->AttackStart(m_caster);
 }

Here is the call graph for this function:

void Spell::EffectTeleportUnits ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->IsInFlight())
         return;
 
     // If not exist data for dest location - return
     if (!m_targets.HasDst())
     {
         TC_LOG_ERROR("spells", "Spell::EffectTeleportUnits - does not have destination for spellId %u.", m_spellInfo->Id);
         return;
     }
 
     // Init dest coordinates
     uint32 mapid = destTarget->GetMapId();
     if (mapid == MAPID_INVALID)
         mapid = unitTarget->GetMapId();
     float x, y, z, orientation;
     destTarget->GetPosition(x, y, z, orientation);
     if (!orientation && m_targets.GetUnitTarget())
         orientation = m_targets.GetUnitTarget()->GetOrientation();
     TC_LOG_DEBUG("spells", "Spell::EffectTeleportUnits - teleport unit to %u %f %f %f %f\n", mapid, x, y, z, orientation);
 
     if (unitTarget->GetTypeId() == TYPEID_PLAYER)
         unitTarget->ToPlayer()->TeleportTo(mapid, x, y, z, orientation, unitTarget == m_caster ? TELE_TO_SPELL | TELE_TO_NOT_LEAVE_COMBAT : 0);
     else if (mapid == unitTarget->GetMapId())
         unitTarget->NearTeleportTo(x, y, z, orientation, unitTarget == m_caster);
     else
     {
         TC_LOG_ERROR("spells", "Spell::EffectTeleportUnits - spellId %u attempted to teleport creature to a different map.", m_spellInfo->Id);
         return;
     }
 
     // post effects for TARGET_DEST_DB
     switch (m_spellInfo->Id)
     {
         // Dimensional Ripper - Everlook
         case 23442:
         {
             int32 r = irand(0, 119);
             if (r >= 70)                                  // 7/12 success
             {
                 if (r < 100)                              // 4/12 evil twin
                     m_caster->CastSpell(m_caster, 23445, true);
                 else                                        // 1/12 fire
                     m_caster->CastSpell(m_caster, 23449, true);
             }
             return;
         }
         // Ultrasafe Transporter: Toshley's Station
         case 36941:
         {
             if (roll_chance_i(50))                        // 50% success
             {
                 int32 rand_eff = urand(1, 7);
                 switch (rand_eff)
                 {
                     case 1:
                         // soul split - evil
                         m_caster->CastSpell(m_caster, 36900, true);
                         break;
                     case 2:
                         // soul split - good
                         m_caster->CastSpell(m_caster, 36901, true);
                         break;
                     case 3:
                         // Increase the size
                         m_caster->CastSpell(m_caster, 36895, true);
                         break;
                     case 4:
                         // Decrease the size
                         m_caster->CastSpell(m_caster, 36893, true);
                         break;
                     case 5:
                     // Transform
                     {
                         if (m_caster->ToPlayer()->GetTeam() == ALLIANCE)
                             m_caster->CastSpell(m_caster, 36897, true);
                         else
                             m_caster->CastSpell(m_caster, 36899, true);
                         break;
                     }
                     case 6:
                         // chicken
                         m_caster->CastSpell(m_caster, 36940, true);
                         break;
                     case 7:
                         // evil twin
                         m_caster->CastSpell(m_caster, 23445, true);
                         break;
                 }
             }
             return;
         }
         // Dimensional Ripper - Area 52
         case 36890:
         {
             if (roll_chance_i(50))                        // 50% success
             {
                 int32 rand_eff = urand(1, 4);
                 switch (rand_eff)
                 {
                     case 1:
                         // soul split - evil
                         m_caster->CastSpell(m_caster, 36900, true);
                         break;
                     case 2:
                         // soul split - good
                         m_caster->CastSpell(m_caster, 36901, true);
                         break;
                     case 3:
                         // Increase the size
                         m_caster->CastSpell(m_caster, 36895, true);
                         break;
                     case 4:
                         // Transform
                     {
                         if (m_caster->ToPlayer()->GetTeam() == ALLIANCE)
                             m_caster->CastSpell(m_caster, 36897, true);
                         else
                             m_caster->CastSpell(m_caster, 36899, true);
                         break;
                     }
                 }
             }
             return;
         }
     }
 }

Here is the call graph for this function:

void Spell::EffectTeleUnitsFaceCaster ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget)
         return;
 
     if (unitTarget->IsInFlight())
         return;
 
     float dis = effectInfo->CalcRadius(m_caster);
 
     float fx, fy, fz;
     m_caster->GetClosePoint(fx, fy, fz, unitTarget->GetObjectSize(), dis);
 
     unitTarget->NearTeleportTo(fx, fy, fz, -m_caster->GetOrientation(), unitTarget == m_caster);
 }

Here is the call graph for this function:

void Spell::EffectThreat ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || !unitTarget->IsAlive() || !m_caster->IsAlive())
         return;
 
     if (!unitTarget->CanHaveThreatList())
         return;
 
     unitTarget->AddThreat(m_caster, float(damage));
 }

Here is the call graph for this function:

void Spell::EffectTitanGrip ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     if (m_caster->GetTypeId() == TYPEID_PLAYER)
         m_caster->ToPlayer()->SetCanTitanGrip(true);
 }

Here is the call graph for this function:

void Spell::EffectTradeSkill ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     if (m_caster->GetTypeId() != TYPEID_PLAYER)
         return;
     // uint32 skillid =  m_spellInfo->Effects[i].MiscValue;
     // uint16 skillmax = unitTarget->ToPlayer()->(skillid);
     // m_caster->ToPlayer()->SetSkill(skillid, skillval?skillval:1, skillmax+75);
 }

Here is the call graph for this function:

void Spell::EffectTransmitted ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     uint32 name_id = effectInfo->MiscValue;
 
     GameObjectTemplate const* goinfo = sObjectMgr->GetGameObjectTemplate(name_id);
 
     if (!goinfo)
     {
         TC_LOG_ERROR("sql.sql", "Gameobject (Entry: %u) not exist and not created at spell (ID: %u) cast", name_id, m_spellInfo->Id);
         return;
     }
 
     float fx, fy, fz;
 
     if (m_targets.HasDst())
         destTarget->GetPosition(fx, fy, fz);
     //FIXME: this can be better check for most objects but still hack
     else if (effectInfo->HasRadius() && m_spellInfo->Speed == 0)
     {
         float dis = effectInfo->CalcRadius(m_originalCaster);
         m_caster->GetClosePoint(fx, fy, fz, DEFAULT_WORLD_OBJECT_SIZE, dis);
     }
     else
     {
         //GO is always friendly to it's creator, get range for friends
         float min_dis = m_spellInfo->GetMinRange(true);
         float max_dis = m_spellInfo->GetMaxRange(true);
         float dis = (float)rand_norm() * (max_dis - min_dis) + min_dis;
 
         m_caster->GetClosePoint(fx, fy, fz, DEFAULT_WORLD_OBJECT_SIZE, dis);
     }
 
     Map* cMap = m_caster->GetMap();
     // if gameobject is summoning object, it should be spawned right on caster's position
     if (goinfo->type == GAMEOBJECT_TYPE_RITUAL)
         m_caster->GetPosition(fx, fy, fz);
 
     GameObject* pGameObj = new GameObject;
 
     if (!pGameObj->Create(cMap->GenerateLowGuid<HighGuid::GameObject>(), name_id, cMap,
         0, fx, fy, fz, m_caster->GetOrientation(), 0.0f, 0.0f, 0.0f, 0.0f, 100, GO_STATE_READY))
     {
         delete pGameObj;
         return;
     }
 
     pGameObj->CopyPhaseFrom(m_caster);
 
     int32 duration = m_spellInfo->GetDuration();
 
     switch (goinfo->type)
     {
         case GAMEOBJECT_TYPE_FISHINGNODE:
         {
             m_caster->SetChannelObjectGuid(pGameObj->GetGUID());
             m_caster->AddGameObject(pGameObj);              // will removed at spell cancel
 
             // end time of range when possible catch fish (FISHING_BOBBER_READY_TIME..GetDuration(m_spellInfo))
             // start time == fish-FISHING_BOBBER_READY_TIME (0..GetDuration(m_spellInfo)-FISHING_BOBBER_READY_TIME)
             int32 lastSec = 0;
             switch (urand(0, 3))
             {
                 case 0: lastSec =  3; break;
                 case 1: lastSec =  7; break;
                 case 2: lastSec = 13; break;
                 case 3: lastSec = 17; break;
             }
 
             duration = duration - lastSec*IN_MILLISECONDS + FISHING_BOBBER_READY_TIME*IN_MILLISECONDS;
             break;
         }
         case GAMEOBJECT_TYPE_RITUAL:
         {
             if (m_caster->GetTypeId() == TYPEID_PLAYER)
             {
                 pGameObj->AddUniqueUse(m_caster->ToPlayer());
                 m_caster->AddGameObject(pGameObj);      // will be removed at spell cancel
             }
             break;
         }
         case GAMEOBJECT_TYPE_DUEL_ARBITER: // 52991
             m_caster->AddGameObject(pGameObj);
             break;
         case GAMEOBJECT_TYPE_FISHINGHOLE:
         case GAMEOBJECT_TYPE_CHEST:
         default:
             break;
     }
 
     pGameObj->SetRespawnTime(duration > 0 ? duration/IN_MILLISECONDS : 0);
 
     pGameObj->SetOwnerGUID(m_caster->GetGUID());
 
     //pGameObj->SetUInt32Value(GAMEOBJECT_LEVEL, m_caster->getLevel());
     pGameObj->SetSpellId(m_spellInfo->Id);
 
     ExecuteLogEffectSummonObject(effIndex, pGameObj);
 
     TC_LOG_DEBUG("spells", "AddObject at SpellEfects.cpp EffectTransmitted");
     //m_caster->AddGameObject(pGameObj);
     //m_ObjToDel.push_back(pGameObj);
 
     cMap->AddToMap(pGameObj);
 
     if (uint32 linkedEntry = pGameObj->GetGOInfo()->GetLinkedGameObjectEntry())
     {
         GameObject* linkedGO = new GameObject;
         if (linkedGO->Create(cMap->GenerateLowGuid<HighGuid::GameObject>(), linkedEntry, cMap,
             0, fx, fy, fz, m_caster->GetOrientation(), 0.0f, 0.0f, 0.0f, 0.0f, 100, GO_STATE_READY))
         {
             linkedGO->CopyPhaseFrom(m_caster);
 
             linkedGO->SetRespawnTime(duration > 0 ? duration/IN_MILLISECONDS : 0);
             //linkedGO->SetUInt32Value(GAMEOBJECT_LEVEL, m_caster->getLevel());
             linkedGO->SetSpellId(m_spellInfo->Id);
             linkedGO->SetOwnerGUID(m_caster->GetGUID());
 
             ExecuteLogEffectSummonObject(effIndex, linkedGO);
 
             linkedGO->GetMap()->AddToMap(linkedGO);
         }
         else
         {
             delete linkedGO;
             linkedGO = NULL;
             return;
         }
     }
 }

Here is the call graph for this function:

void Spell::EffectTriggerMissileSpell ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET
         && effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     uint32 triggered_spell_id = effectInfo->TriggerSpell;
 
     // normal case
     SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(triggered_spell_id);
     if (!spellInfo)
     {
         TC_LOG_ERROR("spells", "Spell::EffectTriggerMissileSpell spell %u tried to trigger unknown spell %u", m_spellInfo->Id, triggered_spell_id);
         return;
     }
 
     SpellCastTargets targets;
     if (effectHandleMode == SPELL_EFFECT_HANDLE_HIT_TARGET)
     {
         if (!spellInfo->NeedsToBeTriggeredByCaster(m_spellInfo, m_caster->GetMap()->GetDifficultyID()))
             return;
         targets.SetUnitTarget(unitTarget);
     }
     else //if (effectHandleMode == SPELL_EFFECT_HANDLE_HIT)
     {
         if (spellInfo->NeedsToBeTriggeredByCaster(m_spellInfo, m_caster->GetMap()->GetDifficultyID()) && (effectInfo->GetProvidedTargetMask() & TARGET_FLAG_UNIT_MASK))
             return;
 
         if (spellInfo->GetExplicitTargetMask() & TARGET_FLAG_DEST_LOCATION)
             targets.SetDst(m_targets);
 
         targets.SetUnitTarget(m_caster);
     }
 
     CustomSpellValues values;
     // set basepoints for trigger with value effect
     if (effectInfo->Effect == SPELL_EFFECT_TRIGGER_MISSILE_SPELL_WITH_VALUE)
     {
         // maybe need to set value only when basepoints == 0?
         values.AddSpellMod(SPELLVALUE_BASE_POINT0, damage);
         values.AddSpellMod(SPELLVALUE_BASE_POINT1, damage);
         values.AddSpellMod(SPELLVALUE_BASE_POINT2, damage);
     }
 
     // original caster guid only for GO cast
     m_caster->CastSpell(targets, spellInfo, &values, TRIGGERED_FULL_MASK, NULL, NULL, m_originalCasterGUID);
 }

Here is the call graph for this function:

void Spell::EffectTriggerRitualOfSummoning ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     uint32 triggered_spell_id = effectInfo->TriggerSpell;
     SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(triggered_spell_id);
 
     if (!spellInfo)
     {
         TC_LOG_ERROR("spells", "EffectTriggerRitualOfSummoning of spell %u: triggering unknown spell id %i", m_spellInfo->Id, triggered_spell_id);
         return;
     }
 
     finish();
 
     m_caster->CastSpell((Unit*)NULL, spellInfo, false);
 }

Here is the call graph for this function:

void Spell::EffectTriggerSpell ( SpellEffIndex effIndex )

Todo:: move those to spell scripts

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET
         && effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH)
         return;
 
     uint32 triggered_spell_id = effectInfo->TriggerSpell;
 
     if (effectInfo->Effect == SPELL_EFFECT_TRIGGER_SPELL
         && effectHandleMode == SPELL_EFFECT_HANDLE_LAUNCH_TARGET)
     {
         // special cases
         switch (triggered_spell_id)
         {
             // Vanish (not exist)
             case 18461:
             {
                 unitTarget->RemoveMovementImpairingAuras();
                 unitTarget->RemoveAurasByType(SPELL_AURA_MOD_STALKED);
 
                 // If this spell is given to an NPC, it must handle the rest using its own AI
                 if (unitTarget->GetTypeId() != TYPEID_PLAYER)
                     return;
 
                 // See if we already are stealthed. If so, we're done.
                 if (unitTarget->HasAura(1784))
                     return;
 
                 // Reset cooldown on stealth if needed
                 unitTarget->GetSpellHistory()->ResetCooldown(1784);
                 unitTarget->CastSpell(unitTarget, 1784, true);
                 return;
             }
             // Demonic Empowerment -- succubus
             case 54437:
             {
                 unitTarget->RemoveMovementImpairingAuras();
                 unitTarget->RemoveAurasByType(SPELL_AURA_MOD_STALKED);
                 unitTarget->RemoveAurasByType(SPELL_AURA_MOD_STUN);
 
                 // Cast Lesser Invisibility
                 unitTarget->CastSpell(unitTarget, 7870, true);
                 return;
             }
             // Brittle Armor - (need add max stack of 24575 Brittle Armor)
             case 29284:
             {
                 // Brittle Armor
                 SpellInfo const* spell = sSpellMgr->GetSpellInfo(24575);
                 if (!spell)
                     return;
 
                 for (uint32 j = 0; j < spell->StackAmount; ++j)
                     m_caster->CastSpell(unitTarget, spell->Id, true);
                 return;
             }
             // Mercurial Shield - (need add max stack of 26464 Mercurial Shield)
             case 29286:
             {
                 // Mercurial Shield
                 SpellInfo const* spell = sSpellMgr->GetSpellInfo(26464);
                 if (!spell)
                     return;
 
                 for (uint32 j = 0; j < spell->StackAmount; ++j)
                     m_caster->CastSpell(unitTarget, spell->Id, true);
                 return;
             }
             // Cloak of Shadows
             case 35729:
             {
                 uint32 dispelMask = SpellInfo::GetDispelMask(DISPEL_ALL);
                 Unit::AuraApplicationMap& Auras = unitTarget->GetAppliedAuras();
                 for (Unit::AuraApplicationMap::iterator iter = Auras.begin(); iter != Auras.end();)
                 {
                     // remove all harmful spells on you...
                     SpellInfo const* spell = iter->second->GetBase()->GetSpellInfo();
                     if (((spell->DmgClass == SPELL_DAMAGE_CLASS_MAGIC && spell->GetSchoolMask() != SPELL_SCHOOL_MASK_NORMAL) // only affect magic spells
                         || (spell->GetDispelMask() & dispelMask)) &&
                         // ignore positive and passive auras
                         !iter->second->IsPositive() && !iter->second->GetBase()->IsPassive())
                     {
                         m_caster->RemoveAura(iter);
                     }
                     else
                         ++iter;
                 }
                 return;
             }
         }
     }
 
     // normal case
     SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(triggered_spell_id);
     if (!spellInfo)
     {
         TC_LOG_ERROR("spells", "Spell::EffectTriggerSpell spell %u tried to trigger unknown spell %u", m_spellInfo->Id, triggered_spell_id);
         return;
     }
 
     SpellCastTargets targets;
     if (effectHandleMode == SPELL_EFFECT_HANDLE_LAUNCH_TARGET)
     {
         if (!spellInfo->NeedsToBeTriggeredByCaster(m_spellInfo, m_caster->GetMap()->GetDifficultyID()))
             return;
         targets.SetUnitTarget(unitTarget);
     }
     else //if (effectHandleMode == SPELL_EFFECT_HANDLE_LAUNCH)
     {
         if (spellInfo->NeedsToBeTriggeredByCaster(m_spellInfo, m_caster->GetMap()->GetDifficultyID()) && (effectInfo->GetProvidedTargetMask() & TARGET_FLAG_UNIT_MASK))
             return;
 
         if (spellInfo->GetExplicitTargetMask() & TARGET_FLAG_DEST_LOCATION)
             targets.SetDst(m_targets);
 
         if (Unit* target = m_targets.GetUnitTarget())
             targets.SetUnitTarget(target);
         else
             targets.SetUnitTarget(m_caster);
     }
 
     CustomSpellValues values;
     // set basepoints for trigger with value effect
     if (effectInfo->Effect == SPELL_EFFECT_TRIGGER_SPELL_WITH_VALUE)
     {
         values.AddSpellMod(SPELLVALUE_BASE_POINT0, damage);
         values.AddSpellMod(SPELLVALUE_BASE_POINT1, damage);
         values.AddSpellMod(SPELLVALUE_BASE_POINT2, damage);
     }
 
     // original caster guid only for GO cast
     m_caster->CastSpell(targets, spellInfo, &values, TRIGGERED_FULL_MASK, NULL, NULL, m_originalCasterGUID);
 }

Here is the call graph for this function:

void Spell::EffectUncageBattlePet ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     if (!m_CastItem || !m_caster || m_caster->GetTypeId() != TYPEID_PLAYER)
         return;
 
     Player* plr = m_caster->ToPlayer();
 
     // are we allowed to learn battle pets without it?
     /*if (plr->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_PET_BATTLES_UNLOCKED))
         return; // send some error*/
 
     uint32 speciesId = m_CastItem->GetModifier(ITEM_MODIFIER_BATTLE_PET_SPECIES_ID);
     uint16 breed = m_CastItem->GetModifier(ITEM_MODIFIER_BATTLE_PET_BREED_DATA) & 0xFFFFFF;
     uint8 quality = (m_CastItem->GetModifier(ITEM_MODIFIER_BATTLE_PET_BREED_DATA) >> 24) & 0xFF;
     uint16 level = m_CastItem->GetModifier(ITEM_MODIFIER_BATTLE_PET_LEVEL);
     uint32 creatureId = m_CastItem->GetModifier(ITEM_MODIFIER_BATTLE_PET_DISPLAY_ID);
 
     BattlePetSpeciesEntry const* speciesEntry = sBattlePetSpeciesStore.LookupEntry(speciesId);
     if (!speciesEntry)
         return;
 
     BattlePetMgr* battlePetMgr = plr->GetSession()->GetBattlePetMgr();
     if (!battlePetMgr)
         return;
 
     uint16 maxLearnedLevel = 0;
 
     for (auto pet : battlePetMgr->GetLearnedPets())
         maxLearnedLevel = std::max(pet.PacketInfo.Level, maxLearnedLevel);
 
     // TODO: This means if you put your highest lvl pet into cage, you won't be able to uncage it again which is probably wrong.
     // We will need to store maxLearnedLevel somewhere to avoid this behaviour.
     if (maxLearnedLevel < level)
     {
         battlePetMgr->SendError(BATTLEPETRESULT_TOO_HIGH_LEVEL_TO_UNCAGE, creatureId); // or speciesEntry.CreatureID
         SendCastResult(SPELL_FAILED_CANT_ADD_BATTLE_PET);
         return;
     }
 
     if (battlePetMgr->GetPetCount(speciesId) >= MAX_BATTLE_PETS_PER_SPECIES)
     {
         battlePetMgr->SendError(BATTLEPETRESULT_CANT_HAVE_MORE_PETS_OF_THAT_TYPE, creatureId); // or speciesEntry.CreatureID
         SendCastResult(SPELL_FAILED_CANT_ADD_BATTLE_PET);
         return;
     }
 
     if (!plr->HasSpell(speciesEntry->SummonSpellID))
         plr->LearnSpell(speciesEntry->SummonSpellID, false);
 
     battlePetMgr->AddPet(speciesId, creatureId, breed, quality, level);
     plr->DestroyItem(m_CastItem->GetBagSlot(), m_CastItem->GetSlot(), true);
     m_CastItem = nullptr;
 }

Here is the call graph for this function:

void Spell::EffectUnlearnSpecialization ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
     Player* player = unitTarget->ToPlayer();
     uint32 spellToUnlearn = effectInfo->TriggerSpell;
 
     player->RemoveSpell(spellToUnlearn);
 
     TC_LOG_DEBUG("spells", "Spell: %s has unlearned spell %u from %s", player->GetGUID().ToString().c_str(), spellToUnlearn, m_caster->GetGUID().ToString().c_str());
 }

Here is the call graph for this function:

void Spell::EffectUnlockGuildVaultTab ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     // Safety checks done in Spell::CheckCast
     Player* caster = m_caster->ToPlayer();
     if (Guild* guild = caster->GetGuild())
         guild->HandleBuyBankTab(caster->GetSession(), effectInfo->BasePoints - 1); // Bank tabs start at zero internally
 }

Here is the call graph for this function:

void Spell::EffectUntrainTalents ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT_TARGET)
         return;
 
     if (!unitTarget || m_caster->GetTypeId() == TYPEID_PLAYER)
         return;
 
     unitTarget->ToPlayer()->SendRespecWipeConfirm(m_caster->GetGUID(), sWorld->getBoolConfig(CONFIG_NO_RESET_TALENT_COST) ? 0 : unitTarget->ToPlayer()->GetNextResetTalentsCost());
 }

Here is the call graph for this function:

void Spell::EffectUnused ( SpellEffIndex effIndex )

 {
     // NOT USED BY ANY SPELL OR USELESS OR IMPLEMENTED IN DIFFERENT WAY IN TRINITY
 }

void Spell::EffectUpgradeHeirloom ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_HIT)
         return;
 
     if (Player* player = m_caster->ToPlayer())
         if (CollectionMgr* collectionMgr = player->GetSession()->GetCollectionMgr())
             collectionMgr->UpgradeHeirloom(m_misc.Raw.Data[0], m_castItemEntry);
 }

Here is the call graph for this function:

void Spell::EffectWeaponDmg ( SpellEffIndex effIndex )

 {
     if (effectHandleMode != SPELL_EFFECT_HANDLE_LAUNCH_TARGET)
         return;
 
     if (!unitTarget || !unitTarget->IsAlive())
         return;
 
     // multiple weapon dmg effect workaround
     // execute only the last weapon damage
     // and handle all effects at once
     for (uint8 index = effIndex + 1; index < MAX_SPELL_EFFECTS; ++index)
     {
         SpellEffectInfo const* effect = GetEffect(index);
         if (!effect)
             continue;
         switch (effect->Effect)
         {
             case SPELL_EFFECT_WEAPON_DAMAGE:
             case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL:
             case SPELL_EFFECT_NORMALIZED_WEAPON_DMG:
             case SPELL_EFFECT_WEAPON_PERCENT_DAMAGE:
                 return;     // we must calculate only at last weapon effect
             break;
         }
     }
 
     // some spell specific modifiers
     float totalDamagePercentMod  = 1.0f;                    // applied to final bonus+weapon damage
     int32 fixed_bonus = 0;
     int32 spell_bonus = 0;                                  // bonus specific for spell
 
     switch (m_spellInfo->SpellFamilyName)
     {
         case SPELLFAMILY_WARRIOR:
         {
             // Devastate (player ones)
             if (m_spellInfo->SpellFamilyFlags[1] & 0x40)
             {
                 // Player can apply only 58567 Sunder Armor effect.
                 bool needCast = !unitTarget->HasAura(58567, m_caster->GetGUID());
                 if (needCast)
                     m_caster->CastSpell(unitTarget, 58567, true);
 
                 if (Aura* aur = unitTarget->GetAura(58567, m_caster->GetGUID()))
                 {
                     if (int32 num = (needCast ? 0 : 1))
                         aur->ModStackAmount(num);
                     fixed_bonus += (aur->GetStackAmount() - 1) * CalculateDamage(2, unitTarget);
                 }
             }
             break;
         }
         case SPELLFAMILY_ROGUE:
         {
             // Hemorrhage
             if (m_spellInfo->SpellFamilyFlags[0] & 0x2000000)
             {
                 if (m_caster->GetTypeId() == TYPEID_PLAYER)
                     m_caster->ToPlayer()->AddComboPoints(1, this);
                 // 50% more damage with daggers
                 if (m_caster->GetTypeId() == TYPEID_PLAYER)
                     if (Item* item = m_caster->ToPlayer()->GetWeaponForAttack(m_attackType, true))
                         if (item->GetTemplate()->GetSubClass() == ITEM_SUBCLASS_WEAPON_DAGGER)
                             totalDamagePercentMod *= 1.5f;
             }
             break;
         }
         case SPELLFAMILY_SHAMAN:
         {
             // Skyshatter Harness item set bonus
             // Stormstrike
             if (AuraEffect* aurEff = m_caster->IsScriptOverriden(m_spellInfo, 5634))
                 m_caster->CastSpell(m_caster, 38430, true, NULL, aurEff);
             break;
         }
         case SPELLFAMILY_DRUID:
         {
             // Mangle (Cat): CP
             if (m_spellInfo->SpellFamilyFlags[1] & 0x400)
             {
                 if (m_caster->GetTypeId() == TYPEID_PLAYER)
                     m_caster->ToPlayer()->AddComboPoints(1, this);
             }
             // Shred, Maul - Rend and Tear
             else if (m_spellInfo->SpellFamilyFlags[0] & 0x00008800 && unitTarget->HasAuraState(AURA_STATE_BLEEDING))
             {
                 if (AuraEffect const* rendAndTear = m_caster->GetDummyAuraEffect(SPELLFAMILY_DRUID, 2859, 0))
                     AddPct(totalDamagePercentMod, rendAndTear->GetAmount());
             }
             break;
         }
         case SPELLFAMILY_HUNTER:
         {
             // Kill Shot - bonus damage from Ranged Attack Power
             if (m_spellInfo->SpellFamilyFlags[1] & 0x800000)
                 spell_bonus += int32(0.45f * m_caster->GetTotalAttackPowerValue(RANGED_ATTACK));
             break;
         }
         case SPELLFAMILY_DEATHKNIGHT:
         {
             // Blood Strike
             if (m_spellInfo->SpellFamilyFlags[0] & 0x400000)
             {
                 if (SpellEffectInfo const* effect = GetEffect(EFFECT_2))
                 {
                     float bonusPct = effect->CalcValue(m_caster) * unitTarget->GetDiseasesByCaster(m_caster->GetGUID()) / 2.0f;
                     // Death Knight T8 Melee 4P Bonus
                     if (AuraEffect const* aurEff = m_caster->GetAuraEffect(64736, EFFECT_0))
                         AddPct(bonusPct, aurEff->GetAmount());
                     AddPct(totalDamagePercentMod, bonusPct);
                 }
                 break;
             }
             break;
         }
     }
 
     bool normalized = false;
     float weaponDamagePercentMod = 1.0f;
     for (SpellEffectInfo const* effect : GetEffects())
     {
         if (!effect)
             continue;
         switch (effect->Effect)
         {
             case SPELL_EFFECT_WEAPON_DAMAGE:
             case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL:
                 fixed_bonus += CalculateDamage(effect->EffectIndex, unitTarget);
                 break;
             case SPELL_EFFECT_NORMALIZED_WEAPON_DMG:
                 fixed_bonus += CalculateDamage(effect->EffectIndex, unitTarget);
                 normalized = true;
                 break;
             case SPELL_EFFECT_WEAPON_PERCENT_DAMAGE:
                 ApplyPct(weaponDamagePercentMod, CalculateDamage(effect->EffectIndex, unitTarget));
                 break;
             default:
                 break;                                      // not weapon damage effect, just skip
         }
     }
 
     // apply to non-weapon bonus weapon total pct effect, weapon total flat effect included in weapon damage
     if (fixed_bonus || spell_bonus)
     {
         UnitMods unitMod;
         switch (m_attackType)
         {
             default:
             case BASE_ATTACK:   unitMod = UNIT_MOD_DAMAGE_MAINHAND; break;
             case OFF_ATTACK:    unitMod = UNIT_MOD_DAMAGE_OFFHAND;  break;
             case RANGED_ATTACK: unitMod = UNIT_MOD_DAMAGE_RANGED;   break;
         }
 
         float weapon_total_pct = 1.0f;
         if (m_spellInfo->SchoolMask & SPELL_SCHOOL_MASK_NORMAL)
              weapon_total_pct = m_caster->GetModifierValue(unitMod, TOTAL_PCT);
 
         if (fixed_bonus)
             fixed_bonus = int32(fixed_bonus * weapon_total_pct);
         if (spell_bonus)
             spell_bonus = int32(spell_bonus * weapon_total_pct);
     }
 
     int32 weaponDamage = m_caster->CalculateDamage(m_attackType, normalized, true);
 
     // Sequence is important
     for (SpellEffectInfo const* effect : GetEffects())
     {
         if (!effect)
             continue;
         // We assume that a spell have at most one fixed_bonus
         // and at most one weaponDamagePercentMod
         switch (effect->Effect)
         {
             case SPELL_EFFECT_WEAPON_DAMAGE:
             case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL:
             case SPELL_EFFECT_NORMALIZED_WEAPON_DMG:
                 weaponDamage += fixed_bonus;
                 break;
             case SPELL_EFFECT_WEAPON_PERCENT_DAMAGE:
                 weaponDamage = int32(weaponDamage* weaponDamagePercentMod);
             default:
                 break;                                      // not weapon damage effect, just skip
         }
     }
 
     if (spell_bonus)
         weaponDamage += spell_bonus;
 
     if (totalDamagePercentMod != 1.0f)
         weaponDamage = int32(weaponDamage* totalDamagePercentMod);
 
     // prevent negative damage
     uint32 eff_damage(std::max(weaponDamage, 0));
 
     // Add melee damage bonuses (also check for negative)
     uint32 damageBonusDone = m_caster->MeleeDamageBonusDone(unitTarget, eff_damage, m_attackType, m_spellInfo);
 
     m_damage += unitTarget->MeleeDamageBonusTaken(m_caster, damageBonusDone, m_attackType, m_spellInfo);
 }

Here is the call graph for this function:

void Spell::ExecuteLogEffectCreateItem	(	uint8	effIndex,
		uint32	entry
	)

 {
     SpellLogEffectTradeSkillItemParams spellLogEffectTradeSkillItemParams;
     spellLogEffectTradeSkillItemParams.ItemID = entry;
 
     _tradeSkillTargets[effIndex].push_back(spellLogEffectTradeSkillItemParams);
 }

Here is the caller graph for this function:

void Spell::ExecuteLogEffectDestroyItem	(	uint8	effIndex,
		uint32	entry
	)

 {
     SpellLogEffectFeedPetParams spellLogEffectFeedPetParams;
     spellLogEffectFeedPetParams.ItemID = entry;
 
     _feedPetTargets[effIndex].push_back(spellLogEffectFeedPetParams);
 }

Here is the caller graph for this function:

void Spell::ExecuteLogEffectDurabilityDamage	(	uint8	effIndex,
		Unit *	victim,
		int32	itemId,
		int32	amount
	)

 {
     SpellLogEffectDurabilityDamageParams spellLogEffectDurabilityDamageParams;
     spellLogEffectDurabilityDamageParams.Victim = victim->GetGUID();
     spellLogEffectDurabilityDamageParams.ItemID = itemId;
     spellLogEffectDurabilityDamageParams.Amount = amount;
 
     _durabilityDamageTargets[effIndex].push_back(spellLogEffectDurabilityDamageParams);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::ExecuteLogEffectExtraAttacks	(	uint8	effIndex,
		Unit *	victim,
		uint32	numAttacks
	)

 {
     SpellLogEffectExtraAttacksParams spellLogEffectExtraAttacksParams;
     spellLogEffectExtraAttacksParams.Victim = victim->GetGUID();
     spellLogEffectExtraAttacksParams.NumAttacks = numAttacks;
 
     _extraAttacksTargets[effIndex].push_back(spellLogEffectExtraAttacksParams);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::ExecuteLogEffectInterruptCast	(	uint8	effIndex,
		Unit *	victim,
		uint32	spellId
	)

 {
     WorldPackets::CombatLog::SpellInterruptLog data;
     data.Caster = m_caster->GetGUID();
     data.Victim = victim->GetGUID();
     data.InterruptedSpellID = m_spellInfo->Id;
     data.SpellID = spellId;
 
     m_caster->SendMessageToSet(data.Write(), true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::ExecuteLogEffectOpenLock	(	uint8	effIndex,
		Object *	obj
	)

 {
     SpellLogEffectGenericVictimParams spellLogEffectGenericVictimParams;
     spellLogEffectGenericVictimParams.Victim = obj->GetGUID();
 
     _genericVictimTargets[effIndex].push_back(spellLogEffectGenericVictimParams);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::ExecuteLogEffectResurrect	(	uint8	effIndex,
		Unit *	target
	)

 {
     SpellLogEffectGenericVictimParams spellLogEffectGenericVictimParams;
     spellLogEffectGenericVictimParams.Victim = target->GetGUID();
 
     _genericVictimTargets[effect].push_back(spellLogEffectGenericVictimParams);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::ExecuteLogEffectSummonObject	(	uint8	effIndex,
		WorldObject *	obj
	)

 {
     SpellLogEffectGenericVictimParams spellLogEffectGenericVictimParams;
     spellLogEffectGenericVictimParams.Victim = obj->GetGUID();
 
     _genericVictimTargets[effIndex].push_back(spellLogEffectGenericVictimParams);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::ExecuteLogEffectTakeTargetPower	(	uint8	effIndex,
		Unit *	target,
		uint32	powerType,
		uint32	points,
		float	amplitude
	)

 {
     SpellLogEffectPowerDrainParams spellLogEffectPowerDrainParams;
 
     spellLogEffectPowerDrainParams.Victim = target->GetGUID();
     spellLogEffectPowerDrainParams.Points = points;
     spellLogEffectPowerDrainParams.PowerType = powerType;
     spellLogEffectPowerDrainParams.Amplitude = amplitude;
 
     _powerDrainTargets[effIndex].push_back(spellLogEffectPowerDrainParams);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::ExecuteLogEffectUnsummonObject	(	uint8	effIndex,
		WorldObject *	obj
	)

 {
     SpellLogEffectGenericVictimParams spellLogEffectGenericVictimParams;
     spellLogEffectGenericVictimParams.Victim = obj->GetGUID();
 
     _genericVictimTargets[effIndex].push_back(spellLogEffectGenericVictimParams);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::finish ( bool ok = true )

 {
     if (!m_caster)
         return;
 
     if (m_spellState == SPELL_STATE_FINISHED)
         return;
     m_spellState = SPELL_STATE_FINISHED;
 
     if (m_spellInfo->IsChanneled())
         m_caster->UpdateInterruptMask();
 
     if (m_caster->HasUnitState(UNIT_STATE_CASTING) && !m_caster->IsNonMeleeSpellCast(false, false, true))
         m_caster->ClearUnitState(UNIT_STATE_CASTING);
 
     // Unsummon summon as possessed creatures on spell cancel
     if (m_spellInfo->IsChanneled() && m_caster->GetTypeId() == TYPEID_PLAYER)
     {
         if (Unit* charm = m_caster->GetCharm())
             if (charm->GetTypeId() == TYPEID_UNIT
                 && charm->ToCreature()->HasUnitTypeMask(UNIT_MASK_PUPPET)
                 && charm->GetUInt32Value(UNIT_CREATED_BY_SPELL) == m_spellInfo->Id)
                 ((Puppet*)charm)->UnSummon();
     }
 
     if (Creature* creatureCaster = m_caster->ToCreature())
         creatureCaster->ReleaseFocus(this);
 
     if (!ok)
         return;
 
     if (m_caster->GetTypeId() == TYPEID_UNIT && m_caster->IsSummon())
     {
         // Unsummon statue
         uint32 spell = m_caster->GetUInt32Value(UNIT_CREATED_BY_SPELL);
         SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spell);
         if (spellInfo && spellInfo->SpellIconID == 2056)
         {
             TC_LOG_DEBUG("spells", "Statue %s is unsummoned in spell %d finish", m_caster->GetGUID().ToString().c_str(), m_spellInfo->Id);
             m_caster->setDeathState(JUST_DIED);
             return;
         }
     }
 
     if (IsAutoActionResetSpell())
     {
         bool found = false;
         Unit::AuraEffectList const& vIgnoreReset = m_caster->GetAuraEffectsByType(SPELL_AURA_IGNORE_MELEE_RESET);
         for (Unit::AuraEffectList::const_iterator i = vIgnoreReset.begin(); i != vIgnoreReset.end(); ++i)
         {
             if ((*i)->IsAffectingSpell(m_spellInfo))
             {
                 found = true;
                 break;
             }
         }
         if (!found && !m_spellInfo->HasAttribute(SPELL_ATTR2_NOT_RESET_AUTO_ACTIONS))
         {
             m_caster->resetAttackTimer(BASE_ATTACK);
             if (m_caster->haveOffhandWeapon())
                 m_caster->resetAttackTimer(OFF_ATTACK);
             m_caster->resetAttackTimer(RANGED_ATTACK);
         }
     }
 
     // potions disabled by client, send event "not in combat" if need
     if (m_caster->GetTypeId() == TYPEID_PLAYER)
     {
         if (!m_triggeredByAuraSpell)
             m_caster->ToPlayer()->UpdatePotionCooldown(this);
 
         // triggered spell pointer can be not set in some cases
         // this is needed for proper apply of triggered spell mods
         m_caster->ToPlayer()->SetSpellModTakingSpell(this, true);
 
         // Take mods after trigger spell (needed for 14177 to affect 48664)
         // mods are taken only on succesfull cast and independantly from targets of the spell
         m_caster->ToPlayer()->RemoveSpellMods(this);
         m_caster->ToPlayer()->SetSpellModTakingSpell(this, false);
     }
 
     // Stop Attack for some spells
     if (m_spellInfo->HasAttribute(SPELL_ATTR0_STOP_ATTACK_TARGET))
         m_caster->AttackStop();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::FinishTargetProcessing ( )

protected

 {
     SendSpellExecuteLog();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Unit* Spell::GetCaster ( ) const

inline

612 { return m_caster; }

Spell::m_caster

Unit *const m_caster

Definition: Spell.h:647

Here is the caller graph for this function:

int32 Spell::GetCastTime ( ) const

inline

590 { return m_casttime; }

Spell::m_casttime

int32 m_casttime

Definition: Spell.h:660

Here is the caller graph for this function:

CurrentSpellTypes Spell::GetCurrentContainer ( ) const

 {
     if (IsNextMeleeSwingSpell())
         return(CURRENT_MELEE_SPELL);
     else if (IsAutoRepeat())
         return(CURRENT_AUTOREPEAT_SPELL);
     else if (m_spellInfo->IsChanneled())
         return(CURRENT_CHANNELED_SPELL);
     else
         return(CURRENT_GENERIC_SPELL);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint64 Spell::GetDelayMoment ( ) const

inline

606 { return m_delayMoment; }

Spell::m_delayMoment

uint64 m_delayMoment

Definition: Spell.h:679

Here is the caller graph for this function:

uint64 Spell::GetDelayStart ( ) const

inline

604 { return m_delayStart; }

Spell::m_delayStart

uint64 m_delayStart

Definition: Spell.h:678

Here is the caller graph for this function:

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

inline

         {
             if (index >= _effects.size())
                 return nullptr;
 
             return _effects[index];
         }

Here is the caller graph for this function:

SpellEffectInfoVector const& Spell::GetEffects ( ) const

inline

623 { return _effects; }

Spell::_effects

SpellEffectInfoVector _effects

Definition: Spell.h:850

Here is the caller graph for this function:

Unit* Spell::GetOriginalCaster ( ) const

inline

613 { return m_originalCaster; }

Spell::m_originalCaster

Unit * m_originalCaster

Definition: Spell.h:653

Here is the caller graph for this function:

std::vector<SpellInfo::CostData> Spell::GetPowerCost ( ) const

inline

615 { return m_powerCost; }

Spell::m_powerCost

std::vector< SpellInfo::CostData > m_powerCost

Definition: Spell.h:659

uint32 Spell::GetSearcherTypeMask	(	SpellTargetObjectTypes	objType,
		ConditionContainer *	condList
	)

 {
     // this function selects which containers need to be searched for spell target
     uint32 retMask = GRID_MAP_TYPE_MASK_ALL;
 
     // filter searchers based on searched object type
     switch (objType)
     {
         case TARGET_OBJECT_TYPE_UNIT:
         case TARGET_OBJECT_TYPE_UNIT_AND_DEST:
         case TARGET_OBJECT_TYPE_CORPSE:
         case TARGET_OBJECT_TYPE_CORPSE_ENEMY:
         case TARGET_OBJECT_TYPE_CORPSE_ALLY:
             retMask &= GRID_MAP_TYPE_MASK_PLAYER | GRID_MAP_TYPE_MASK_CORPSE | GRID_MAP_TYPE_MASK_CREATURE;
             break;
         case TARGET_OBJECT_TYPE_GOBJ:
         case TARGET_OBJECT_TYPE_GOBJ_ITEM:
             retMask &= GRID_MAP_TYPE_MASK_GAMEOBJECT;
             break;
         default:
             break;
     }
     if (!m_spellInfo->HasAttribute(SPELL_ATTR2_CAN_TARGET_DEAD))
         retMask &= ~GRID_MAP_TYPE_MASK_CORPSE;
     if (m_spellInfo->HasAttribute(SPELL_ATTR3_ONLY_TARGET_PLAYERS))
         retMask &= GRID_MAP_TYPE_MASK_CORPSE | GRID_MAP_TYPE_MASK_PLAYER;
     if (m_spellInfo->HasAttribute(SPELL_ATTR3_ONLY_TARGET_GHOSTS))
         retMask &= GRID_MAP_TYPE_MASK_PLAYER;
 
     if (condList)
         retMask &= sConditionMgr->GetSearcherTypeMaskForConditionList(*condList);
     return retMask;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SpellInfo const* Spell::GetSpellInfo ( ) const

inline

614 { return m_spellInfo; }

Spell::m_spellInfo

SpellInfo const *const m_spellInfo

Definition: Spell.h:547

Here is the caller graph for this function:

uint32 Spell::getState ( ) const

inline

509 { return m_spellState; }

Spell::m_spellState

uint32 m_spellState

Definition: Spell.h:818

Here is the caller graph for this function:

int32 Spell::GetTimer ( ) const

inline

638 { return m_timer; }

Spell::m_timer

int32 m_timer

Definition: Spell.h:819

SpellInfo const* Spell::GetTriggeredByAuraSpell ( ) const

inline

636 { return m_triggeredByAuraSpell; }

Spell::m_triggeredByAuraSpell

SpellInfo const * m_triggeredByAuraSpell

Definition: Spell.h:826

uint64 Spell::handle_delayed ( uint64 t_offset )

 {
     if (!UpdatePointers())
     {
         // finish the spell if UpdatePointers() returned false, something wrong happened there
         finish(false);
         return 0;
     }
 
     if (m_caster->GetTypeId() == TYPEID_PLAYER)
         m_caster->ToPlayer()->SetSpellModTakingSpell(this, true);
 
     uint64 next_time = 0;
 
     PrepareTargetProcessing();
 
     if (!m_immediateHandled)
     {
         _handle_immediate_phase();
         m_immediateHandled = true;
     }
 
     bool single_missile = (m_targets.HasDst());
 
     // now recheck units targeting correctness (need before any effects apply to prevent adding immunity at first effect not allow apply second spell effect and similar cases)
     for (std::vector<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
     {
         if (ihit->processed == false)
         {
             if (single_missile || ihit->timeDelay <= t_offset)
             {
                 ihit->timeDelay = t_offset;
                 DoAllEffectOnTarget(&(*ihit));
             }
             else if (next_time == 0 || ihit->timeDelay < next_time)
                 next_time = ihit->timeDelay;
         }
     }
 
     // now recheck gameobject targeting correctness
     for (std::vector<GOTargetInfo>::iterator ighit = m_UniqueGOTargetInfo.begin(); ighit != m_UniqueGOTargetInfo.end(); ++ighit)
     {
         if (ighit->processed == false)
         {
             if (single_missile || ighit->timeDelay <= t_offset)
                 DoAllEffectOnTarget(&(*ighit));
             else if (next_time == 0 || ighit->timeDelay < next_time)
                 next_time = ighit->timeDelay;
         }
     }
 
     FinishTargetProcessing();
 
     if (m_caster->GetTypeId() == TYPEID_PLAYER)
         m_caster->ToPlayer()->SetSpellModTakingSpell(this, false);
 
     // All targets passed - need finish phase
     if (next_time == 0)
     {
         // spell is finished, perform some last features of the spell here
         _handle_finish_phase();
 
         finish(true);                                       // successfully finish spell cast
 
         // return zero, spell is finished now
         return 0;
     }
     else
     {
         // spell is unfinished, return next execution time
         return next_time;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::handle_immediate ( )

 {
     // start channeling if applicable
     if (m_spellInfo->IsChanneled())
     {
         int32 duration = m_spellInfo->GetDuration();
         if (duration > 0)
         {
             // First mod_duration then haste - see Missile Barrage
             // Apply duration mod
             if (Player* modOwner = m_caster->GetSpellModOwner())
                 modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_DURATION, duration);
 
             // Apply haste mods
             m_caster->ModSpellDurationTime(m_spellInfo, duration, this);
 
             m_spellState = SPELL_STATE_CASTING;
             m_caster->AddInterruptMask(m_spellInfo->ChannelInterruptFlags);
             m_channeledDuration = duration;
             SendChannelStart(duration);
         }
         else if (duration == -1)
         {
             m_spellState = SPELL_STATE_CASTING;
             m_caster->AddInterruptMask(m_spellInfo->ChannelInterruptFlags);
             SendChannelStart(duration);
         }
     }
 
     PrepareTargetProcessing();
 
     // process immediate effects (items, ground, etc.) also initialize some variables
     _handle_immediate_phase();
 
     for (std::vector<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
         DoAllEffectOnTarget(&(*ihit));
 
     for (std::vector<GOTargetInfo>::iterator ihit = m_UniqueGOTargetInfo.begin(); ihit != m_UniqueGOTargetInfo.end(); ++ihit)
         DoAllEffectOnTarget(&(*ihit));
 
     FinishTargetProcessing();
 
     // spell is finished, perform some last features of the spell here
     _handle_finish_phase();
 
     // Remove used for cast item if need (it can be already NULL after TakeReagents call
     TakeCastItem();
 
     if (m_spellState != SPELL_STATE_CASTING)
         finish(true);                                       // successfully finish spell cast (not last in case autorepeat or channel spell)
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::HandleEffects	(	Unit *	pUnitTarget,
		Item *	pItemTarget,
		GameObject *	pGOTarget,
		uint32	i,
		SpellEffectHandleMode	mode
	)

 {
     effectHandleMode = mode;
     unitTarget = pUnitTarget;
     itemTarget = pItemTarget;
     gameObjTarget = pGOTarget;
     destTarget = &m_destTargets[i]._position;
 
     effectInfo = GetEffect(i);
     if (!effectInfo)
     {
         TC_LOG_ERROR("spells", "Spell: %u HandleEffects at EffectIndex: %u missing effect", m_spellInfo->Id, i);
         return;
     }
     uint32 eff = effectInfo->Effect;
 
     TC_LOG_DEBUG("spells", "Spell: %u Effect: %u", m_spellInfo->Id, eff);
 
     damage = CalculateDamage(i, unitTarget, &variance);
 
     bool preventDefault = CallScriptEffectHandlers((SpellEffIndex)i, mode);
 
     if (!preventDefault && eff < TOTAL_SPELL_EFFECTS)
     {
         (this->*SpellEffects[eff])((SpellEffIndex)i);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::HandleLaunchPhase ( )

protected

 {
     // handle effects with SPELL_EFFECT_HANDLE_LAUNCH mode
     for (SpellEffectInfo const* effect : GetEffects())
     {
         // don't do anything for empty effect
         if (!effect || !effect->IsEffect())
             continue;
 
         HandleEffects(NULL, NULL, NULL, effect->EffectIndex, SPELL_EFFECT_HANDLE_LAUNCH);
     }
 
     float multiplier[MAX_SPELL_EFFECTS];
     for (SpellEffectInfo const* effect : GetEffects())
         if (effect && (m_applyMultiplierMask & (1 << effect->EffectIndex)))
             multiplier[effect->EffectIndex] = effect->CalcDamageMultiplier(m_originalCaster, this);
 
     for (std::vector<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
     {
         TargetInfo& target = *ihit;
 
         uint32 mask = target.effectMask;
         if (!mask)
             continue;
 
         DoAllEffectOnLaunchTarget(target, multiplier);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::HandleThreatSpells ( )

 {
     if (m_UniqueTargetInfo.empty())
         return;
 
     if ((m_spellInfo->AttributesEx  & SPELL_ATTR1_NO_THREAT) ||
         (m_spellInfo->HasAttribute(SPELL_ATTR3_NO_INITIAL_AGGRO)))
         return;
 
     float threat = 0.0f;
     if (SpellThreatEntry const* threatEntry = sSpellMgr->GetSpellThreatEntry(m_spellInfo->Id))
     {
         if (threatEntry->apPctMod != 0.0f)
             threat += threatEntry->apPctMod * m_caster->GetTotalAttackPowerValue(BASE_ATTACK);
 
         threat += threatEntry->flatMod;
     }
     else if ((m_spellInfo->HasAttribute(SPELL_ATTR0_CU_NO_INITIAL_THREAT)) == 0)
         threat += m_spellInfo->SpellLevel;
 
     // past this point only multiplicative effects occur
     if (threat == 0.0f)
         return;
 
     // since 2.0.1 threat from positive effects also is distributed among all targets, so the overall caused threat is at most the defined bonus
     threat /= m_UniqueTargetInfo.size();
 
     for (std::vector<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
     {
         float threatToAdd = threat;
         if (ihit->missCondition != SPELL_MISS_NONE)
             threatToAdd = 0.0f;
 
         Unit* target = ObjectAccessor::GetUnit(*m_caster, ihit->targetGUID);
         if (!target)
             continue;
 
         // positive spells distribute threat among all units that are in combat with target, like healing
         if (m_spellInfo->_IsPositiveSpell())
             target->getHostileRefManager().threatAssist(m_caster, threatToAdd, m_spellInfo);
         // for negative spells threat gets distributed among affected targets
         else
         {
             if (!target->CanHaveThreatList())
                 continue;
 
             target->AddThreat(m_caster, threatToAdd, m_spellInfo->GetSchoolMask(), m_spellInfo);
         }
     }
     TC_LOG_DEBUG("spells", "Spell %u, added an additional %f threat for %s %u target(s)", m_spellInfo->Id, threat, m_spellInfo->_IsPositiveSpell() ? "assisting" : "harming", uint32(m_UniqueTargetInfo.size()));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Spell::HasEffect ( SpellEffectName effect ) const

 {
     for (SpellEffectInfo const* eff : GetEffects())
     {
         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 Spell::HasGlobalCooldown ( ) const

protected

 {
     // Only players or controlled units have global cooldown
     if (m_caster->GetTypeId() != TYPEID_PLAYER && !m_caster->GetCharmInfo())
         return false;
 
     return m_caster->GetSpellHistory()->HasGlobalCooldown(m_spellInfo);
 }

Here is the caller graph for this function:

bool Spell::HaveTargetsForEffect ( uint8 effect ) const

 {
     for (std::vector<TargetInfo>::const_iterator itr = m_UniqueTargetInfo.begin(); itr != m_UniqueTargetInfo.end(); ++itr)
         if (itr->effectMask & (1 << effect))
             return true;
 
     for (std::vector<GOTargetInfo>::const_iterator itr = m_UniqueGOTargetInfo.begin(); itr != m_UniqueGOTargetInfo.end(); ++itr)
         if (itr->effectMask & (1 << effect))
             return true;
 
     for (std::vector<ItemTargetInfo>::const_iterator itr = m_UniqueItemInfo.begin(); itr != m_UniqueItemInfo.end(); ++itr)
         if (itr->effectMask & (1 << effect))
             return true;
 
     return false;
 }

void Spell::InitExplicitTargets ( SpellCastTargets const & targets )

 {
     m_targets = targets;
     m_targets.SetOrigUnitTarget(m_targets.GetUnitTarget());
     // this function tries to correct spell explicit targets for spell
     // client doesn't send explicit targets correctly sometimes - we need to fix such spells serverside
     // this also makes sure that we correctly send explicit targets to client (removes redundant data)
     uint32 neededTargets = m_spellInfo->GetExplicitTargetMask();
 
     if (WorldObject* target = m_targets.GetObjectTarget())
     {
         // check if object target is valid with needed target flags
         // for unit case allow corpse target mask because player with not released corpse is a unit target
         if ((target->ToUnit() && !(neededTargets & (TARGET_FLAG_UNIT_MASK | TARGET_FLAG_CORPSE_MASK)))
             || (target->ToGameObject() && !(neededTargets & TARGET_FLAG_GAMEOBJECT_MASK))
             || (target->ToCorpse() && !(neededTargets & TARGET_FLAG_CORPSE_MASK)))
             m_targets.RemoveObjectTarget();
     }
     else
     {
         // try to select correct unit target if not provided by client or by serverside cast
         if (neededTargets & (TARGET_FLAG_UNIT_MASK))
         {
             Unit* unit = NULL;
             // try to use player selection as a target
             if (Player* playerCaster = m_caster->ToPlayer())
             {
                 // selection has to be found and to be valid target for the spell
                 if (Unit* selectedUnit = ObjectAccessor::GetUnit(*m_caster, playerCaster->GetTarget()))
                     if (m_spellInfo->CheckExplicitTarget(m_caster, selectedUnit) == SPELL_CAST_OK)
                         unit = selectedUnit;
             }
             // try to use attacked unit as a target
             else if ((m_caster->GetTypeId() == TYPEID_UNIT) && neededTargets & (TARGET_FLAG_UNIT_ENEMY | TARGET_FLAG_UNIT))
                 unit = m_caster->GetVictim();
 
             // didn't find anything - let's use self as target
             if (!unit && neededTargets & (TARGET_FLAG_UNIT_RAID | TARGET_FLAG_UNIT_PARTY | TARGET_FLAG_UNIT_ALLY))
                 unit = m_caster;
 
             m_targets.SetUnitTarget(unit);
         }
     }
 
     // check if spell needs dst target
     if (neededTargets & TARGET_FLAG_DEST_LOCATION)
     {
         // and target isn't set
         if (!m_targets.HasDst())
         {
             // try to use unit target if provided
             if (WorldObject* target = targets.GetObjectTarget())
                 m_targets.SetDst(*target);
             // or use self if not available
             else
                 m_targets.SetDst(*m_caster);
         }
     }
     else
         m_targets.RemoveDst();
 
     if (neededTargets & TARGET_FLAG_SOURCE_LOCATION)
     {
         if (!targets.HasSrc())
             m_targets.SetSrc(*m_caster);
     }
     else
         m_targets.RemoveSrc();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Spell::IsAutoActionResetSpell ( ) const

Todo:: changed SPELL_INTERRUPT_FLAG_AUTOATTACK -> SPELL_INTERRUPT_FLAG_INTERRUPT to fix compile - is this check correct at all?

 {
     return !IsTriggered() && (m_spellInfo->InterruptFlags & SPELL_INTERRUPT_FLAG_INTERRUPT);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Spell::IsAutoRepeat ( ) const

inline

591 { return m_autoRepeat; }

Spell::m_autoRepeat

bool m_autoRepeat

Definition: Spell.h:663

Here is the caller graph for this function:

bool Spell::IsChannelActive ( ) const

inline

597 { return m_caster->GetUInt32Value(UNIT_CHANNEL_SPELL) != 0; }

Spell::m_caster

Unit *const m_caster

Definition: Spell.h:647

Object::GetUInt32Value

uint32 GetUInt32Value(uint16 index) const

Definition: Object.cpp:300

UNIT_CHANNEL_SPELL

Definition: UpdateFields.h:93

bool Spell::isDelayableNoMore ( )

inlineprotected

         {
             if (m_delayAtDamageCount >= 2)
                 return true;
 
             m_delayAtDamageCount++;
             return false;
         }

Here is the caller graph for this function:

bool Spell::IsDeletable ( ) const

inline

600 { return !m_referencedFromCurrentSpell && !m_executedCurrently; }

Spell::m_executedCurrently

bool m_executedCurrently

Definition: Spell.h:684

Spell::m_referencedFromCurrentSpell

bool m_referencedFromCurrentSpell

Definition: Spell.h:683

Here is the caller graph for this function:

bool Spell::IsIgnoringCooldowns ( ) const

inline

596 { return (_triggeredCastFlags & TRIGGERED_IGNORE_SPELL_AND_CATEGORY_CD) != 0; }

TRIGGERED_IGNORE_SPELL_AND_CATEGORY_CD

Will ignore GCD.

Definition: Unit.h:462

Spell::_triggeredCastFlags

TriggerCastFlags _triggeredCastFlags

Definition: Spell.h:821

Here is the caller graph for this function:

bool Spell::IsInterruptable ( ) const

inline

602 { return !m_executedCurrently; }

Spell::m_executedCurrently

bool m_executedCurrently

Definition: Spell.h:684

Here is the caller graph for this function:

bool Spell::IsNeedSendToClient ( ) const

 {
     return m_spellInfo->GetSpellXSpellVisualId(m_caster->GetMap()->GetDifficultyID()) || m_spellInfo->IsChanneled() ||
         (m_spellInfo->HasAttribute(SPELL_ATTR8_AURA_SEND_AMOUNT)) || m_spellInfo->Speed > 0.0f || (!m_triggeredByAuraSpell && !IsTriggered());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Spell::IsNextMeleeSwingSpell ( ) const

 {
     return m_spellInfo->HasAttribute(SPELL_ATTR0_ON_NEXT_SWING);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Spell::IsTriggered ( ) const

inline

595 { return (_triggeredCastFlags & TRIGGERED_FULL_MASK) != 0; }

TRIGGERED_FULL_MASK

Will ignore most target checks (mostly DBC target checks)

Definition: Unit.h:479

Spell::_triggeredCastFlags

TriggerCastFlags _triggeredCastFlags

Definition: Spell.h:821

Here is the caller graph for this function:

bool Spell::IsValidDeadOrAliveTarget ( Unit const * target ) const

protected

 {
     if (target->IsAlive())
         return !m_spellInfo->IsRequiringDeadTarget();
     if (m_spellInfo->IsAllowingDeadTarget())
         return true;
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::LoadScripts ( )

protected

 {
     sScriptMgr->CreateSpellScripts(m_spellInfo->Id, m_loadedScripts);
     for (std::list<SpellScript*>::iterator itr = m_loadedScripts.begin(); itr != m_loadedScripts.end();)
     {
         if (!(*itr)->_Load(this))
         {
             std::list<SpellScript*>::iterator bitr = itr;
             ++itr;
             delete (*bitr);
             m_loadedScripts.erase(bitr);
             continue;
         }
         TC_LOG_DEBUG("spells", "Spell::LoadScripts: Script `%s` for spell `%u` is loaded now", (*itr)->_GetScriptName()->c_str(), m_spellInfo->Id);
         (*itr)->Register();
         ++itr;
     }
 }

Here is the caller graph for this function:

Spell& Spell::operator= ( Spell const & right )

protecteddelete

void Spell::prepare	(	SpellCastTargets const *	targets,
		AuraEffect const *	triggeredByAura = `NULL`
	)

this to all cast spells if needed

 {
     if (m_CastItem)
     {
         m_castItemGUID = m_CastItem->GetGUID();
         m_castItemEntry = m_CastItem->GetEntry();
 
         if (Player* owner = m_CastItem->GetOwner())
             m_castItemLevel = int32(m_CastItem->GetItemLevel(owner));
         else if (m_CastItem->GetOwnerGUID() == m_caster->GetGUID())
             m_castItemLevel = int32(m_CastItem->GetItemLevel(m_caster->ToPlayer()));
         else
         {
             SendCastResult(SPELL_FAILED_EQUIPPED_ITEM);
             finish(false);
             return;
         }
     }
 
     InitExplicitTargets(*targets);
 
     // Fill aura scaling information
     if (m_caster->IsControlledByPlayer() && !m_spellInfo->IsPassive() && m_spellInfo->SpellLevel && !m_spellInfo->IsChanneled() && !(_triggeredCastFlags & TRIGGERED_IGNORE_AURA_SCALING))
     {
         for (SpellEffectInfo const* effect : GetEffects())
         {
             if (effect && effect->Effect == SPELL_EFFECT_APPLY_AURA)
             {
                 // Change aura with ranks only if basepoints are taken from spellInfo and aura is positive
                 if (m_spellInfo->IsPositiveEffect(effect->EffectIndex))
                 {
                     m_auraScaleMask |= (1 << effect->EffectIndex);
                     if (m_spellValue->EffectBasePoints[effect->EffectIndex] != effect->BasePoints)
                     {
                         m_auraScaleMask = 0;
                         break;
                     }
                 }
             }
         }
     }
 
     m_spellState = SPELL_STATE_PREPARING;
 
     if (triggeredByAura)
     {
         m_triggeredByAuraSpell = triggeredByAura->GetSpellInfo();
         m_castItemLevel = triggeredByAura->GetBase()->GetCastItemLevel();
     }
 
     // create and add update event for this spell
     SpellEvent* Event = new SpellEvent(this);
     m_caster->m_Events.AddEvent(Event, m_caster->m_Events.CalculateTime(1));
 
     //Prevent casting at cast another spell (ServerSide check)
     if (!(_triggeredCastFlags & TRIGGERED_IGNORE_CAST_IN_PROGRESS) && m_caster->IsNonMeleeSpellCast(false, true, true) && m_cast_count)
     {
         SendCastResult(SPELL_FAILED_SPELL_IN_PROGRESS);
         finish(false);
         return;
     }
 
     if (DisableMgr::IsDisabledFor(DISABLE_TYPE_SPELL, m_spellInfo->Id, m_caster))
     {
         SendCastResult(SPELL_FAILED_SPELL_UNAVAILABLE);
         finish(false);
         return;
     }
     LoadScripts();
 
     if (m_caster->GetTypeId() == TYPEID_PLAYER)
         m_caster->ToPlayer()->SetSpellModTakingSpell(this, true);
     // Fill cost data (not use power for item casts
     if (!m_CastItem)
         m_powerCost = m_spellInfo->CalcPowerCost(m_caster, m_spellSchoolMask);
     if (m_caster->GetTypeId() == TYPEID_PLAYER)
         m_caster->ToPlayer()->SetSpellModTakingSpell(this, false);
 
     // Set combo point requirement
     if ((_triggeredCastFlags & TRIGGERED_IGNORE_COMBO_POINTS) || m_CastItem || !m_caster->m_movedPlayer)
         m_needComboPoints = false;
 
     SpellCastResult result = CheckCast(true);
     // target is checked in too many locations and with different results to handle each of them
     // handle just the general SPELL_FAILED_BAD_TARGETS result which is the default result for most DBC target checks
     if (_triggeredCastFlags & TRIGGERED_IGNORE_TARGET_CHECK && result == SPELL_FAILED_BAD_TARGETS)
         result = SPELL_CAST_OK;
     if (result != SPELL_CAST_OK && !IsAutoRepeat())          //always cast autorepeat dummy for triggering
     {
         // Periodic auras should be interrupted when aura triggers a spell which can't be cast
         // for example bladestorm aura should be removed on disarm as of patch 3.3.5
         // channeled periodic spells should be affected by this (arcane missiles, penance, etc)
         // a possible alternative sollution for those would be validating aura target on unit state change
         if (triggeredByAura && triggeredByAura->IsPeriodic() && !triggeredByAura->GetBase()->IsPassive())
         {
             SendChannelUpdate(0);
             triggeredByAura->GetBase()->SetDuration(0);
         }
 
         if (m_caster->GetTypeId() == TYPEID_PLAYER)
         {
             m_caster->ToPlayer()->RestoreSpellMods(this);
             // cleanup after mod system
             // triggered spell pointer can be not removed in some cases
             m_caster->ToPlayer()->SetSpellModTakingSpell(this, false);
         }
 
         SendCastResult(result);
 
         finish(false);
         return;
     }
 
     // Prepare data for triggers
     prepareDataForTriggerSystem(triggeredByAura);
 
     if (Player* player = m_caster->ToPlayer())
     {
         if (!player->GetCommandStatus(CHEAT_CASTTIME))
         {
             player->SetSpellModTakingSpell(this, true);
             // calculate cast time (calculated after first CheckCast check to prevent charge counting for first CheckCast fail)
             m_casttime = m_spellInfo->CalcCastTime(player->getLevel(), this);
             player->SetSpellModTakingSpell(this, false);
         }
         else
             m_casttime = 0; // Set cast time to 0 if .cheat casttime is enabled.
     }
     else
         m_casttime = m_spellInfo->CalcCastTime(m_caster->getLevel(), this);
 
     if (m_caster->GetTypeId() == TYPEID_UNIT && !m_caster->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PLAYER_CONTROLLED)) // _UNIT actually means creature. for some reason.
         if (!(IsNextMeleeSwingSpell() || IsAutoRepeat() || _triggeredCastFlags & TRIGGERED_IGNORE_SET_FACING))
         {
             if (m_targets.GetObjectTarget() && m_caster != m_targets.GetObjectTarget())
             {
                 if (m_caster->ToCreature()->FocusTarget(this, m_targets.GetObjectTarget()))
                 {
                     m_isDelayedInstantCast = true;
                     m_timer = 100; // 100ms delay ensures client has updated creature orientation when cast goes off
                 }
             }
             else if (m_spellInfo->HasAttribute(SPELL_ATTR5_DONT_TURN_DURING_CAST))
             {
                 if (m_caster->ToCreature()->FocusTarget(this, nullptr))
                 {
                     m_isDelayedInstantCast = true;
                     m_timer = 100;
                 }
             }
         }
 
     // don't allow channeled spells / spells with cast time to be cast while moving
     // (even if they are interrupted on moving, spells with almost immediate effect get to have their effect processed before movement interrupter kicks in)
     // don't cancel spells which are affected by a SPELL_AURA_CAST_WHILE_WALKING effect
     if (((m_spellInfo->IsChanneled() || m_casttime) && m_caster->GetTypeId() == TYPEID_PLAYER && m_caster->isMoving() &&
         m_spellInfo->InterruptFlags & SPELL_INTERRUPT_FLAG_MOVEMENT) && !m_caster->HasAuraTypeWithAffectMask(SPELL_AURA_CAST_WHILE_WALKING, m_spellInfo))
     {
         SendCastResult(SPELL_FAILED_MOVING);
         finish(false);
         return;
     }
 
     // set timer base at cast time
     ReSetTimer();
 
     TC_LOG_DEBUG("spells", "Spell::prepare: spell id %u source %u caster %d customCastFlags %u mask %u", m_spellInfo->Id, m_caster->GetEntry(), m_originalCaster ? m_originalCaster->GetEntry() : -1, _triggeredCastFlags, m_targets.GetTargetMask());
 
     //Containers for channeled spells have to be set
     // Why check duration? 29350: channelled triggers channelled
     if ((_triggeredCastFlags & TRIGGERED_CAST_DIRECTLY) && (!m_spellInfo->IsChanneled() || !m_spellInfo->GetMaxDuration()))
         cast(true);
     else
     {
         // stealth must be removed at cast starting (at show channel bar)
         // skip triggered spell (item equip spell casting and other not explicit character casts/item uses)
         if (!(_triggeredCastFlags & TRIGGERED_IGNORE_AURA_INTERRUPT_FLAGS) && m_spellInfo->IsBreakingStealth())
         {
             m_caster->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_CAST);
             for (SpellEffectInfo const* effect : GetEffects())
                 if (effect && effect->GetUsedTargetObjectType() == TARGET_OBJECT_TYPE_UNIT)
                 {
                     m_caster->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_SPELL_ATTACK);
                     break;
                 }
         }
 
         m_caster->SetCurrentCastSpell(this);
         if (!m_isDelayedInstantCast)
             SendSpellStart();
 
         if (!(_triggeredCastFlags & TRIGGERED_IGNORE_GCD))
             TriggerGlobalCooldown();
 
         //item: first cast may destroy item and second cast causes crash
         if (!m_casttime && !m_isDelayedInstantCast && !m_spellInfo->StartRecoveryTime && !m_castItemGUID && GetCurrentContainer() == CURRENT_GENERIC_SPELL)
             cast(true);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::prepareDataForTriggerSystem ( AuraEffect const * triggeredByAura )

protected

 {
     //==========================================================================================
     // Now fill data for trigger system, need know:
     // can spell trigger another or not (m_canTrigger)
     // Create base triggers flags for Attacker and Victim (m_procAttacker, m_procVictim and m_procEx)
     //==========================================================================================
 
     m_procVictim = m_procAttacker = 0;
     // Get data for type of attack and fill base info for trigger
     switch (m_spellInfo->DmgClass)
     {
         case SPELL_DAMAGE_CLASS_MELEE:
             m_procAttacker = PROC_FLAG_DONE_SPELL_MELEE_DMG_CLASS;
             if (m_attackType == OFF_ATTACK)
                 m_procAttacker |= PROC_FLAG_DONE_OFFHAND_ATTACK;
             else
                 m_procAttacker |= PROC_FLAG_DONE_MAINHAND_ATTACK;
             m_procVictim   = PROC_FLAG_TAKEN_SPELL_MELEE_DMG_CLASS;
             break;
         case SPELL_DAMAGE_CLASS_RANGED:
             // Auto attack
             if (m_spellInfo->HasAttribute(SPELL_ATTR2_AUTOREPEAT_FLAG))
             {
                 m_procAttacker = PROC_FLAG_DONE_RANGED_AUTO_ATTACK;
                 m_procVictim   = PROC_FLAG_TAKEN_RANGED_AUTO_ATTACK;
             }
             else // Ranged spell attack
             {
                 m_procAttacker = PROC_FLAG_DONE_SPELL_RANGED_DMG_CLASS;
                 m_procVictim   = PROC_FLAG_TAKEN_SPELL_RANGED_DMG_CLASS;
             }
             break;
         default:
             if (m_spellInfo->EquippedItemClass == ITEM_CLASS_WEAPON &&
                 m_spellInfo->EquippedItemSubClassMask & (1<<ITEM_SUBCLASS_WEAPON_WAND)
                 && m_spellInfo->HasAttribute(SPELL_ATTR2_AUTOREPEAT_FLAG)) // Wands auto attack
             {
                 m_procAttacker = PROC_FLAG_DONE_RANGED_AUTO_ATTACK;
                 m_procVictim   = PROC_FLAG_TAKEN_RANGED_AUTO_ATTACK;
             }
             // For other spells trigger procflags are set in Spell::DoAllEffectOnTarget
             // Because spell positivity is dependant on target
     }
     m_procEx = PROC_EX_NONE;
 
     // Hunter trap spells - activation proc for Lock and Load, Entrapment and Misdirection
     if (m_spellInfo->SpellFamilyName == SPELLFAMILY_HUNTER &&
         (m_spellInfo->SpellFamilyFlags[0] & 0x18 ||     // Freezing and Frost Trap, Freezing Arrow
         m_spellInfo->Id == 57879 ||                     // Snake Trap - done this way to avoid double proc
         m_spellInfo->SpellFamilyFlags[2] & 0x00024000)) // Explosive and Immolation Trap
     {
         m_procAttacker |= PROC_FLAG_DONE_TRAP_ACTIVATION;
     }
 
     /* Effects which are result of aura proc from triggered spell cannot proc
         to prevent chain proc of these spells */
 
     // Hellfire Effect - trigger as DOT
     if (m_spellInfo->SpellFamilyName == SPELLFAMILY_WARLOCK && m_spellInfo->SpellFamilyFlags[0] & 0x00000040)
     {
         m_procAttacker = PROC_FLAG_DONE_PERIODIC;
         m_procVictim   = PROC_FLAG_TAKEN_PERIODIC;
     }
 
     // Ranged autorepeat attack is set as triggered spell - ignore it
     if (!(m_procAttacker & PROC_FLAG_DONE_RANGED_AUTO_ATTACK))
     {
         if (_triggeredCastFlags & TRIGGERED_DISALLOW_PROC_EVENTS &&
             (m_spellInfo->HasAttribute(SPELL_ATTR2_TRIGGERED_CAN_TRIGGER_PROC) ||
             m_spellInfo->HasAttribute(SPELL_ATTR3_TRIGGERED_CAN_TRIGGER_PROC_2)))
             m_procEx |= PROC_EX_INTERNAL_CANT_PROC;
         else if (_triggeredCastFlags & TRIGGERED_DISALLOW_PROC_EVENTS)
             m_procEx |= PROC_EX_INTERNAL_TRIGGERED;
     }
     // Totem casts require spellfamilymask defined in spell_proc_event to proc
     if (m_originalCaster && m_caster != m_originalCaster && m_caster->GetTypeId() == TYPEID_UNIT && m_caster->IsTotem() && m_caster->IsControlledByPlayer())
         m_procEx |= PROC_EX_INTERNAL_REQ_FAMILY;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::PrepareScriptHitHandlers ( )

protected

 {
     for (std::list<SpellScript*>::iterator scritr = m_loadedScripts.begin(); scritr != m_loadedScripts.end(); ++scritr)
         (*scritr)->_InitHit();
 }

Here is the caller graph for this function:

void Spell::PrepareTargetProcessing ( )

protected

7020 {

7021 }

Here is the caller graph for this function:

void Spell::PrepareTriggersExecutedOnHit ( )

protected

Todo:: move this to scripts

Todo:: move this to scripts

 {
     if (m_spellInfo->SpellFamilyName)
     {
         SpellInfo const* excludeCasterSpellInfo = sSpellMgr->GetSpellInfo(m_spellInfo->ExcludeCasterAuraSpell);
         if (excludeCasterSpellInfo && !excludeCasterSpellInfo->IsPositive())
             m_preCastSpell = m_spellInfo->ExcludeCasterAuraSpell;
         SpellInfo const* excludeTargetSpellInfo = sSpellMgr->GetSpellInfo(m_spellInfo->ExcludeTargetAuraSpell);
         if (excludeTargetSpellInfo && !excludeTargetSpellInfo->IsPositive())
             m_preCastSpell = m_spellInfo->ExcludeTargetAuraSpell;
     }
 
     switch (m_spellInfo->SpellFamilyName)
     {
         case SPELLFAMILY_MAGE:
         {
              // Permafrost
              if (m_spellInfo->SpellFamilyFlags[1] & 0x00001000 ||  m_spellInfo->SpellFamilyFlags[0] & 0x00100220)
                  m_preCastSpell = 68391;
              break;
         }
     }
 
     // handle SPELL_AURA_ADD_TARGET_TRIGGER auras:
     // save auras which were present on spell caster on cast, to prevent triggered auras from affecting caster
     // and to correctly calculate proc chance when combopoints are present
     Unit::AuraEffectList const& targetTriggers = m_caster->GetAuraEffectsByType(SPELL_AURA_ADD_TARGET_TRIGGER);
     for (Unit::AuraEffectList::const_iterator i = targetTriggers.begin(); i != targetTriggers.end(); ++i)
     {
         if (!(*i)->IsAffectingSpell(m_spellInfo))
             continue;
         SpellInfo const* auraSpellInfo = (*i)->GetSpellInfo();
         uint32 auraSpellIdx = (*i)->GetEffIndex();
         // todo 6.x
         if (SpellEffectInfo const* auraEffect = auraSpellInfo->GetEffect(m_caster->GetMap()->GetDifficultyID(), auraSpellIdx))
         {
             if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(auraEffect->TriggerSpell))
             {
                 // calculate the chance using spell base amount, because aura amount is not updated on combo-points change
                 // this possibly needs fixing
                 int32 auraBaseAmount = (*i)->GetBaseAmount();
                 // proc chance is stored in effect amount
                 int32 chance = m_caster->CalculateSpellDamage(NULL, auraSpellInfo, auraSpellIdx, &auraBaseAmount);
                 // build trigger and add to the list
                 HitTriggerSpell spellTriggerInfo;
                 spellTriggerInfo.triggeredSpell = spellInfo;
                 spellTriggerInfo.triggeredByAura = auraSpellInfo;
                 spellTriggerInfo.chance = chance * (*i)->GetBase()->GetStackAmount();
                 m_hitTriggerSpells.push_back(spellTriggerInfo);
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::ReSetTimer ( )

inline

593 { m_timer = m_casttime > 0 ? m_casttime : 0; }

Spell::m_casttime

int32 m_casttime

Definition: Spell.h:660

Spell::m_timer

int32 m_timer

Definition: Spell.h:819

Here is the caller graph for this function:

void Spell::SearchAreaTargets	(	std::list< WorldObject * > &	targets,
		float	range,
		Position const *	position,
		Unit *	referer,
		SpellTargetObjectTypes	objectType,
		SpellTargetCheckTypes	selectionType,
		ConditionContainer *	condList
	)

 {
     uint32 containerTypeMask = GetSearcherTypeMask(objectType, condList);
     if (!containerTypeMask)
         return;
     Trinity::WorldObjectSpellAreaTargetCheck check(range, position, m_caster, referer, m_spellInfo, selectionType, condList);
     Trinity::WorldObjectListSearcher<Trinity::WorldObjectSpellAreaTargetCheck> searcher(m_caster, targets, check, containerTypeMask);
     SearchTargets<Trinity::WorldObjectListSearcher<Trinity::WorldObjectSpellAreaTargetCheck> > (searcher, containerTypeMask, m_caster, position, range);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SearchChainTargets	(	std::list< WorldObject * > &	targets,
		uint32	chainTargets,
		WorldObject *	target,
		SpellTargetObjectTypes	objectType,
		SpellTargetCheckTypes	selectType,
		ConditionContainer *	condList,
		bool	isChainHeal
	)

 {
     // max dist for jump target selection
     float jumpRadius = 0.0f;
     switch (m_spellInfo->DmgClass)
     {
         case SPELL_DAMAGE_CLASS_RANGED:
             // 7.5y for multi shot
             jumpRadius = 7.5f;
             break;
         case SPELL_DAMAGE_CLASS_MELEE:
             // 5y for swipe, cleave and similar
             jumpRadius = 5.0f;
             break;
         case SPELL_DAMAGE_CLASS_NONE:
         case SPELL_DAMAGE_CLASS_MAGIC:
             // 12.5y for chain heal spell since 3.2 patch
             if (isChainHeal)
                 jumpRadius = 12.5f;
             // 10y as default for magic chain spells
             else
                 jumpRadius = 10.0f;
             break;
     }
 
     if (Player* modOwner = m_caster->GetSpellModOwner())
         modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_JUMP_DISTANCE, jumpRadius, this);
 
     // chain lightning/heal spells and similar - allow to jump at larger distance and go out of los
     bool isBouncingFar = (m_spellInfo->HasAttribute(SPELL_ATTR4_AREA_TARGET_CHAIN)
         || m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_NONE
         || m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_MAGIC);
 
     // max dist which spell can reach
     float searchRadius = jumpRadius;
     if (isBouncingFar)
         searchRadius *= chainTargets;
 
     std::list<WorldObject*> tempTargets;
     SearchAreaTargets(tempTargets, searchRadius, target, m_caster, objectType, selectType, condList);
     tempTargets.remove(target);
 
     // remove targets which are always invalid for chain spells
     // for some spells allow only chain targets in front of caster (swipe for example)
     if (!isBouncingFar)
     {
         for (std::list<WorldObject*>::iterator itr = tempTargets.begin(); itr != tempTargets.end();)
         {
             std::list<WorldObject*>::iterator checkItr = itr++;
             if (!m_caster->HasInArc(static_cast<float>(M_PI), *checkItr))
                 tempTargets.erase(checkItr);
         }
     }
 
     while (chainTargets)
     {
         // try to get unit for next chain jump
         std::list<WorldObject*>::iterator foundItr = tempTargets.end();
         // get unit with highest hp deficit in dist
         if (isChainHeal)
         {
             uint32 maxHPDeficit = 0;
             for (std::list<WorldObject*>::iterator itr = tempTargets.begin(); itr != tempTargets.end(); ++itr)
             {
                 if (Unit* unit = (*itr)->ToUnit())
                 {
                     uint32 deficit = unit->GetMaxHealth() - unit->GetHealth();
                     if ((deficit > maxHPDeficit || foundItr == tempTargets.end()) && target->IsWithinDist(unit, jumpRadius) && target->IsWithinLOSInMap(unit))
                     {
                         foundItr = itr;
                         maxHPDeficit = deficit;
                     }
                 }
             }
         }
         // get closest object
         else
         {
             for (std::list<WorldObject*>::iterator itr = tempTargets.begin(); itr != tempTargets.end(); ++itr)
             {
                 if (foundItr == tempTargets.end())
                 {
                     if ((!isBouncingFar || target->IsWithinDist(*itr, jumpRadius)) && target->IsWithinLOSInMap(*itr))
                         foundItr = itr;
                 }
                 else if (target->GetDistanceOrder(*itr, *foundItr) && target->IsWithinLOSInMap(*itr))
                     foundItr = itr;
             }
         }
         // not found any valid target - chain ends
         if (foundItr == tempTargets.end())
             break;
         target = *foundItr;
         tempTargets.erase(foundItr);
         targets.push_back(target);
         --chainTargets;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

WorldObject * Spell::SearchNearbyTarget	(	float	range,
		SpellTargetObjectTypes	objectType,
		SpellTargetCheckTypes	selectionType,
		ConditionContainer *	condList = `NULL`
	)

 {
     WorldObject* target = NULL;
     uint32 containerTypeMask = GetSearcherTypeMask(objectType, condList);
     if (!containerTypeMask)
         return NULL;
     Trinity::WorldObjectSpellNearbyTargetCheck check(range, m_caster, m_spellInfo, selectionType, condList);
     Trinity::WorldObjectLastSearcher<Trinity::WorldObjectSpellNearbyTargetCheck> searcher(m_caster, target, check, containerTypeMask);
     SearchTargets<Trinity::WorldObjectLastSearcher<Trinity::WorldObjectSpellNearbyTargetCheck> > (searcher, containerTypeMask, m_caster, m_caster, range);
     return target;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

GameObject * Spell::SearchSpellFocus ( )

 {
     GameObject* focus = NULL;
     Trinity::GameObjectFocusCheck check(m_caster, m_spellInfo->RequiresSpellFocus);
     Trinity::GameObjectSearcher<Trinity::GameObjectFocusCheck> searcher(m_caster, focus, check);
     SearchTargets<Trinity::GameObjectSearcher<Trinity::GameObjectFocusCheck> > (searcher, GRID_MAP_TYPE_MASK_GAMEOBJECT, m_caster, m_caster, m_caster->GetVisibilityRange());
     return focus;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class SEARCHER >

void Spell::SearchTargets	(	SEARCHER &	searcher,
		uint32	containerMask,
		Unit *	referer,
		Position const *	pos,
		float	radius
	)

 {
     if (!containerMask)
         return;
 
     // search world and grid for possible targets
     bool searchInGrid = (containerMask & (GRID_MAP_TYPE_MASK_CREATURE | GRID_MAP_TYPE_MASK_GAMEOBJECT)) != 0;
     bool searchInWorld = (containerMask & (GRID_MAP_TYPE_MASK_CREATURE | GRID_MAP_TYPE_MASK_PLAYER | GRID_MAP_TYPE_MASK_CORPSE)) != 0;
     if (searchInGrid || searchInWorld)
     {
         float x, y;
         x = pos->GetPositionX();
         y = pos->GetPositionY();
 
         CellCoord p(Trinity::ComputeCellCoord(x, y));
         Cell cell(p);
         cell.SetNoCreate();
 
         Map& map = *(referer->GetMap());
 
         if (searchInWorld)
         {
             TypeContainerVisitor<SEARCHER, WorldTypeMapContainer> world_object_notifier(searcher);
             cell.Visit(p, world_object_notifier, map, radius, x, y);
         }
         if (searchInGrid)
         {
             TypeContainerVisitor<SEARCHER, GridTypeMapContainer >  grid_object_notifier(searcher);
             cell.Visit(p, grid_object_notifier, map, radius, x, y);
         }
     }
 }

Here is the call graph for this function:

void Spell::SelectEffectImplicitTargets	(	SpellEffIndex	effIndex,
		SpellImplicitTargetInfo const &	targetType,
		uint32 &	processedEffectMask
	)

 {
     if (!targetType.GetTarget())
         return;
 
     uint32 effectMask = 1 << effIndex;
     // set the same target list for all effects
     // some spells appear to need this, however this requires more research
     switch (targetType.GetSelectionCategory())
     {
         case TARGET_SELECT_CATEGORY_NEARBY:
         case TARGET_SELECT_CATEGORY_CONE:
         case TARGET_SELECT_CATEGORY_AREA:
             // targets for effect already selected
             if (effectMask & processedEffectMask)
                 return;
             if (SpellEffectInfo const* _effect = GetEffect(effIndex))
             {
                 // choose which targets we can select at once
                 for (SpellEffectInfo const* effect : GetEffects())
                 {
                     //for (uint32 j = effIndex + 1; j < MAX_SPELL_EFFECTS; ++j)
                     if (!effect || effect->EffectIndex <= uint32(effIndex))
                         continue;
                     if (effect->IsEffect() &&
                         _effect->TargetA.GetTarget() == effect->TargetA.GetTarget() &&
                         _effect->TargetB.GetTarget() == effect->TargetB.GetTarget() &&
                         _effect->ImplicitTargetConditions == effect->ImplicitTargetConditions &&
                         _effect->CalcRadius(m_caster) == effect->CalcRadius(m_caster) &&
                         CheckScriptEffectImplicitTargets(effIndex, effect->EffectIndex))
                     {
                         effectMask |= 1 << effect->EffectIndex;
                     }
                 }
             }
             processedEffectMask |= effectMask;
             break;
         default:
             break;
     }
 
     switch (targetType.GetSelectionCategory())
     {
         case TARGET_SELECT_CATEGORY_CHANNEL:
             SelectImplicitChannelTargets(effIndex, targetType);
             break;
         case TARGET_SELECT_CATEGORY_NEARBY:
             SelectImplicitNearbyTargets(effIndex, targetType, effectMask);
             break;
         case TARGET_SELECT_CATEGORY_CONE:
             SelectImplicitConeTargets(effIndex, targetType, effectMask);
             break;
         case TARGET_SELECT_CATEGORY_AREA:
             SelectImplicitAreaTargets(effIndex, targetType, effectMask);
             break;
         case TARGET_SELECT_CATEGORY_DEFAULT:
             switch (targetType.GetObjectType())
             {
                 case TARGET_OBJECT_TYPE_SRC:
                     switch (targetType.GetReferenceType())
                     {
                         case TARGET_REFERENCE_TYPE_CASTER:
                             m_targets.SetSrc(*m_caster);
                             break;
                         default:
                             ASSERT(false && "Spell::SelectEffectImplicitTargets: received not implemented select target reference type for TARGET_TYPE_OBJECT_SRC");
                             break;
                     }
                     break;
                 case TARGET_OBJECT_TYPE_DEST:
                      switch (targetType.GetReferenceType())
                      {
                          case TARGET_REFERENCE_TYPE_CASTER:
                              SelectImplicitCasterDestTargets(effIndex, targetType);
                              break;
                          case TARGET_REFERENCE_TYPE_TARGET:
                              SelectImplicitTargetDestTargets(effIndex, targetType);
                              break;
                          case TARGET_REFERENCE_TYPE_DEST:
                              SelectImplicitDestDestTargets(effIndex, targetType);
                              break;
                          default:
                              ASSERT(false && "Spell::SelectEffectImplicitTargets: received not implemented select target reference type for TARGET_TYPE_OBJECT_DEST");
                              break;
                      }
                      break;
                 default:
                     switch (targetType.GetReferenceType())
                     {
                         case TARGET_REFERENCE_TYPE_CASTER:
                             SelectImplicitCasterObjectTargets(effIndex, targetType);
                             break;
                         case TARGET_REFERENCE_TYPE_TARGET:
                             SelectImplicitTargetObjectTargets(effIndex, targetType);
                             break;
                         default:
                             ASSERT(false && "Spell::SelectEffectImplicitTargets: received not implemented select target reference type for TARGET_TYPE_OBJECT");
                             break;
                     }
                     break;
             }
             break;
         case TARGET_SELECT_CATEGORY_NYI:
             TC_LOG_DEBUG("spells", "SPELL: target type %u, found in spellID %u, effect %u is not implemented yet!", m_spellInfo->Id, effIndex, targetType.GetTarget());
             break;
         default:
             ASSERT(false && "Spell::SelectEffectImplicitTargets: received not implemented select target category");
             break;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SelectEffectTypeImplicitTargets ( uint32 effIndex )

Todo:: this is a workaround - target shouldn't be stored in target map for those spells

Todo:: this is a workaround - corpses should be added to spell target map too, but we can't do that so we add owner instead

 {
     // special case for SPELL_EFFECT_SUMMON_RAF_FRIEND and SPELL_EFFECT_SUMMON_PLAYER
     SpellEffectInfo const* effect = GetEffect(effIndex);
     if (!effect)
         return;
     switch (effect->Effect)
     {
         case SPELL_EFFECT_SUMMON_RAF_FRIEND:
         case SPELL_EFFECT_SUMMON_PLAYER:
             if (m_caster->GetTypeId() == TYPEID_PLAYER && !m_caster->GetTarget().IsEmpty())
             {
                 WorldObject* target = ObjectAccessor::FindPlayer(m_caster->GetTarget());
 
                 CallScriptObjectTargetSelectHandlers(target, SpellEffIndex(effIndex), SpellImplicitTargetInfo());
 
                 if (target && target->ToPlayer())
                     AddUnitTarget(target->ToUnit(), 1 << effIndex, false);
             }
             return;
         default:
             break;
     }
 
     // select spell implicit targets based on effect type
     if (!effect->GetImplicitTargetType())
         return;
 
     uint32 targetMask = effect->GetMissingTargetMask();
 
     if (!targetMask)
         return;
 
     WorldObject* target = NULL;
 
     switch (effect->GetImplicitTargetType())
     {
         // add explicit object target or self to the target map
         case EFFECT_IMPLICIT_TARGET_EXPLICIT:
             // player which not released his spirit is Unit, but target flag for it is TARGET_FLAG_CORPSE_MASK
             if (targetMask & (TARGET_FLAG_UNIT_MASK | TARGET_FLAG_CORPSE_MASK))
             {
                 if (Unit* unit = m_targets.GetUnitTarget())
                     target = unit;
                 else if (targetMask & TARGET_FLAG_CORPSE_MASK)
                 {
                     if (Corpse* corpseTarget = m_targets.GetCorpseTarget())
                     {
                         if (Player* owner = ObjectAccessor::FindPlayer(corpseTarget->GetOwnerGUID()))
                             target = owner;
                     }
                 }
                 else //if (targetMask & TARGET_FLAG_UNIT_MASK)
                     target = m_caster;
             }
             if (targetMask & TARGET_FLAG_ITEM_MASK)
             {
                 if (Item* item = m_targets.GetItemTarget())
                     AddItemTarget(item, 1 << effIndex);
                 return;
             }
             if (targetMask & TARGET_FLAG_GAMEOBJECT_MASK)
                 target = m_targets.GetGOTarget();
             break;
         // add self to the target map
         case EFFECT_IMPLICIT_TARGET_CASTER:
             if (targetMask & TARGET_FLAG_UNIT_MASK)
                 target = m_caster;
             break;
         default:
             break;
     }
 
     CallScriptObjectTargetSelectHandlers(target, SpellEffIndex(effIndex), SpellImplicitTargetInfo());
 
     if (target)
     {
         if (target->ToUnit())
             AddUnitTarget(target->ToUnit(), 1 << effIndex, false);
         else if (target->ToGameObject())
             AddGOTarget(target->ToGameObject(), 1 << effIndex);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SelectExplicitTargets ( )

 {
     // here go all explicit target changes made to explicit targets after spell prepare phase is finished
     if (Unit* target = m_targets.GetUnitTarget())
     {
         // check for explicit target redirection, for Grounding Totem for example
         if (m_spellInfo->GetExplicitTargetMask() & TARGET_FLAG_UNIT_ENEMY
             || (m_spellInfo->GetExplicitTargetMask() & TARGET_FLAG_UNIT && !m_caster->IsFriendlyTo(target)))
         {
             Unit* redirect;
             switch (m_spellInfo->DmgClass)
             {
                 case SPELL_DAMAGE_CLASS_MAGIC:
                     redirect = m_caster->GetMagicHitRedirectTarget(target, m_spellInfo);
                     break;
                 case SPELL_DAMAGE_CLASS_MELEE:
                 case SPELL_DAMAGE_CLASS_RANGED:
                     redirect = m_caster->GetMeleeHitRedirectTarget(target, m_spellInfo);
                     break;
                 default:
                     redirect = NULL;
                     break;
             }
             if (redirect && (redirect != target))
                 m_targets.SetUnitTarget(redirect);
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SelectImplicitAreaTargets	(	SpellEffIndex	effIndex,
		SpellImplicitTargetInfo const &	targetType,
		uint32	effMask
	)

 {
     Unit* referer = NULL;
     switch (targetType.GetReferenceType())
     {
         case TARGET_REFERENCE_TYPE_SRC:
         case TARGET_REFERENCE_TYPE_DEST:
         case TARGET_REFERENCE_TYPE_CASTER:
             referer = m_caster;
             break;
         case TARGET_REFERENCE_TYPE_TARGET:
             referer = m_targets.GetUnitTarget();
             break;
         case TARGET_REFERENCE_TYPE_LAST:
         {
             // find last added target for this effect
             for (std::vector<TargetInfo>::reverse_iterator ihit = m_UniqueTargetInfo.rbegin(); ihit != m_UniqueTargetInfo.rend(); ++ihit)
             {
                 if (ihit->effectMask & (1<<effIndex))
                 {
                     referer = ObjectAccessor::GetUnit(*m_caster, ihit->targetGUID);
                     break;
                 }
             }
             break;
         }
         default:
             ASSERT(false && "Spell::SelectImplicitAreaTargets: received not implemented target reference type");
             return;
     }
 
     if (!referer)
         return;
 
     Position const* center = NULL;
     switch (targetType.GetReferenceType())
     {
         case TARGET_REFERENCE_TYPE_SRC:
             center = m_targets.GetSrcPos();
             break;
         case TARGET_REFERENCE_TYPE_DEST:
             center = m_targets.GetDstPos();
             break;
         case TARGET_REFERENCE_TYPE_CASTER:
         case TARGET_REFERENCE_TYPE_TARGET:
         case TARGET_REFERENCE_TYPE_LAST:
             center = referer;
             break;
          default:
              ASSERT(false && "Spell::SelectImplicitAreaTargets: received not implemented target reference type");
              return;
     }
 
     std::list<WorldObject*> targets;
     SpellEffectInfo const* effect = GetEffect(effIndex);
     if (!effect)
         return;
     float radius = effect->CalcRadius(m_caster) * m_spellValue->RadiusMod;
     SearchAreaTargets(targets, radius, center, referer, targetType.GetObjectType(), targetType.GetCheckType(), effect->ImplicitTargetConditions);
 
     CallScriptObjectAreaTargetSelectHandlers(targets, effIndex, targetType);
 
     if (!targets.empty())
     {
         // Other special target selection goes here
         if (uint32 maxTargets = m_spellValue->MaxAffectedTargets)
             Trinity::Containers::RandomResizeList(targets, maxTargets);
 
         for (std::list<WorldObject*>::iterator itr = targets.begin(); itr != targets.end(); ++itr)
         {
             if (Unit* unit = (*itr)->ToUnit())
                 AddUnitTarget(unit, effMask, false, true, center);
             else if (GameObject* gObjTarget = (*itr)->ToGameObject())
                 AddGOTarget(gObjTarget, effMask);
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SelectImplicitCasterDestTargets	(	SpellEffIndex	effIndex,
		SpellImplicitTargetInfo const &	targetType
	)

Todo:: fix this check

 {
     SpellDestination dest(*m_caster);
 
     switch (targetType.GetTarget())
     {
         case TARGET_DEST_CASTER:
             break;
         case TARGET_DEST_HOME:
             if (Player* playerCaster = m_caster->ToPlayer())
                 dest = SpellDestination(playerCaster->m_homebindX, playerCaster->m_homebindY, playerCaster->m_homebindZ, playerCaster->GetOrientation(), playerCaster->m_homebindMapId);
             break;
         case TARGET_DEST_DB:
             if (SpellTargetPosition const* st = sSpellMgr->GetSpellTargetPosition(m_spellInfo->Id, effIndex))
             {
                 if (HasEffect(SPELL_EFFECT_TELEPORT_UNITS) || HasEffect(SPELL_EFFECT_BIND))
                     dest = SpellDestination(st->target_X, st->target_Y, st->target_Z, st->target_Orientation, (int32)st->target_mapId);
                 else if (st->target_mapId == m_caster->GetMapId())
                     dest = SpellDestination(st->target_X, st->target_Y, st->target_Z, st->target_Orientation);
             }
             else
             {
                 TC_LOG_DEBUG("spells", "SPELL: unknown target coordinates for spell ID %u", m_spellInfo->Id);
                 if (WorldObject* target = m_targets.GetObjectTarget())
                     dest = SpellDestination(*target);
             }
             break;
         case TARGET_DEST_CASTER_FISHING:
         {
             float minDist = m_spellInfo->GetMinRange(true);
             float maxDist = m_spellInfo->GetMaxRange(true);
             float dist = frand(minDist, maxDist);
             float x, y, z;
             float angle = float(rand_norm()) * static_cast<float>(M_PI * 35.0f / 180.0f) - static_cast<float>(M_PI * 17.5f / 180.0f);
             m_caster->GetClosePoint(x, y, z, DEFAULT_WORLD_OBJECT_SIZE, dist, angle);
 
             float ground = m_caster->GetMap()->GetHeight(m_caster->GetPhaseMask(), x, y, z, true, 50.0f);
             float liquidLevel = VMAP_INVALID_HEIGHT_VALUE;
             LiquidData liquidData;
             if (m_caster->GetMap()->getLiquidStatus(x, y, z, MAP_ALL_LIQUIDS, &liquidData))
                 liquidLevel = liquidData.level;
 
             if (liquidLevel <= ground) // When there is no liquid Map::GetWaterOrGroundLevel returns ground level
             {
                 SendCastResult(SPELL_FAILED_NOT_HERE);
                 SendChannelUpdate(0);
                 finish(false);
                 return;
             }
 
             if (ground + 0.75 > liquidLevel)
             {
                 SendCastResult(SPELL_FAILED_TOO_SHALLOW);
                 SendChannelUpdate(0);
                 finish(false);
                 return;
             }
 
             dest = SpellDestination(x, y, liquidLevel, m_caster->GetOrientation());
             break;
         }
         default:
         {
             if (SpellEffectInfo const* effect = GetEffect(effIndex))
             {
                 float dist;
                 float angle = targetType.CalcDirectionAngle();
                 float objSize = m_caster->GetObjectSize();
                 if (targetType.GetTarget() == TARGET_DEST_CASTER_SUMMON)
                     dist = PET_FOLLOW_DIST;
                 else
                     dist = effect->CalcRadius(m_caster);
 
                 if (dist < objSize)
                     dist = objSize;
                 else if (targetType.GetTarget() == TARGET_DEST_CASTER_RANDOM)
                     dist = objSize + (dist - objSize) * float(rand_norm());
 
                 Position pos = dest._position;
                 m_caster->MovePositionToFirstCollision(pos, dist, angle);
 
                 dest.Relocate(pos);
             }
             break;
         }
     }
 
     CallScriptDestinationTargetSelectHandlers(dest, effIndex, targetType);
     m_targets.SetDst(dest);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SelectImplicitCasterObjectTargets	(	SpellEffIndex	effIndex,
		SpellImplicitTargetInfo const &	targetType
	)

 {
     WorldObject* target = NULL;
     bool checkIfValid = true;
 
     switch (targetType.GetTarget())
     {
         case TARGET_UNIT_CASTER:
             target = m_caster;
             checkIfValid = false;
             break;
         case TARGET_UNIT_MASTER:
             target = m_caster->GetCharmerOrOwner();
             break;
         case TARGET_UNIT_PET:
             target = m_caster->GetGuardianPet();
             break;
         case TARGET_UNIT_SUMMONER:
             if (m_caster->IsSummon())
                 target = m_caster->ToTempSummon()->GetSummoner();
             break;
         case TARGET_UNIT_VEHICLE:
             target = m_caster->GetVehicleBase();
             break;
         case TARGET_UNIT_PASSENGER_0:
         case TARGET_UNIT_PASSENGER_1:
         case TARGET_UNIT_PASSENGER_2:
         case TARGET_UNIT_PASSENGER_3:
         case TARGET_UNIT_PASSENGER_4:
         case TARGET_UNIT_PASSENGER_5:
         case TARGET_UNIT_PASSENGER_6:
         case TARGET_UNIT_PASSENGER_7:
             if (m_caster->GetTypeId() == TYPEID_UNIT && m_caster->IsVehicle())
                 target = m_caster->GetVehicleKit()->GetPassenger(targetType.GetTarget() - TARGET_UNIT_PASSENGER_0);
             break;
         default:
             break;
     }
 
     CallScriptObjectTargetSelectHandlers(target, effIndex, targetType);
 
     if (target && target->ToUnit())
         AddUnitTarget(target->ToUnit(), 1 << effIndex, checkIfValid);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SelectImplicitChainTargets	(	SpellEffIndex	effIndex,
		SpellImplicitTargetInfo const &	targetType,
		WorldObject *	target,
		uint32	effMask
	)

 {
     SpellEffectInfo const* effect = GetEffect(effIndex);
     if (!effect)
         return;
 
     uint32 maxTargets = effect->ChainTargets;
     if (Player* modOwner = m_caster->GetSpellModOwner())
         modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_JUMP_TARGETS, maxTargets, this);
 
     if (maxTargets > 1)
     {
         // mark damage multipliers as used
         for (SpellEffectInfo const* eff : GetEffects())
             if (eff && (effMask & (1 << eff->EffectIndex)))
                 m_damageMultipliers[eff->EffectIndex] = 1.0f;
         m_applyMultiplierMask |= effMask;
 
         std::list<WorldObject*> targets;
         SearchChainTargets(targets, maxTargets - 1, target, targetType.GetObjectType(), targetType.GetCheckType()
             , effect->ImplicitTargetConditions, targetType.GetTarget() == TARGET_UNIT_TARGET_CHAINHEAL_ALLY);
 
         // Chain primary target is added earlier
         CallScriptObjectAreaTargetSelectHandlers(targets, effIndex, targetType);
 
         for (std::list<WorldObject*>::iterator itr = targets.begin(); itr != targets.end(); ++itr)
             if (Unit* unit = (*itr)->ToUnit())
                 AddUnitTarget(unit, effMask, false);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SelectImplicitChannelTargets	(	SpellEffIndex	effIndex,
		SpellImplicitTargetInfo const &	targetType
	)

 {
     if (targetType.GetReferenceType() != TARGET_REFERENCE_TYPE_CASTER)
     {
         ASSERT(false && "Spell::SelectImplicitChannelTargets: received not implemented target reference type");
         return;
     }
 
     Spell* channeledSpell = m_originalCaster->GetCurrentSpell(CURRENT_CHANNELED_SPELL);
     if (!channeledSpell)
     {
         TC_LOG_DEBUG("spells", "Spell::SelectImplicitChannelTargets: cannot find channel spell for spell ID %u, effect %u", m_spellInfo->Id, effIndex);
         return;
     }
     switch (targetType.GetTarget())
     {
         case TARGET_UNIT_CHANNEL_TARGET:
         {
             WorldObject* target = ObjectAccessor::GetUnit(*m_caster, m_originalCaster->GetChannelObjectGuid());
             CallScriptObjectTargetSelectHandlers(target, effIndex, targetType);
             // unit target may be no longer avalible - teleported out of map for example
             if (target && target->ToUnit())
                 AddUnitTarget(target->ToUnit(), 1 << effIndex);
             else
                 TC_LOG_DEBUG("spells", "SPELL: cannot find channel spell target for spell ID %u, effect %u", m_spellInfo->Id, effIndex);
             break;
         }
         case TARGET_DEST_CHANNEL_TARGET:
             if (channeledSpell->m_targets.HasDst())
                 m_targets.SetDst(channeledSpell->m_targets);
             else if (WorldObject* target = ObjectAccessor::GetWorldObject(*m_caster, m_originalCaster->GetChannelObjectGuid()))
             {
                 CallScriptObjectTargetSelectHandlers(target, effIndex, targetType);
                 if (target)
                     m_targets.SetDst(*target);
             }
             else
                 TC_LOG_DEBUG("spells", "SPELL: cannot find channel spell destination for spell ID %u, effect %u", m_spellInfo->Id, effIndex);
             break;
         case TARGET_DEST_CHANNEL_CASTER:
             m_targets.SetDst(*channeledSpell->GetCaster());
             break;
         default:
             ASSERT(false && "Spell::SelectImplicitChannelTargets: received not implemented target type");
             break;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SelectImplicitConeTargets	(	SpellEffIndex	effIndex,
		SpellImplicitTargetInfo const &	targetType,
		uint32	effMask
	)

 {
     if (targetType.GetReferenceType() != TARGET_REFERENCE_TYPE_CASTER)
     {
         ASSERT(false && "Spell::SelectImplicitConeTargets: received not implemented target reference type");
         return;
     }
     std::list<WorldObject*> targets;
     SpellTargetObjectTypes objectType = targetType.GetObjectType();
     SpellTargetCheckTypes selectionType = targetType.GetCheckType();
     SpellEffectInfo const* effect = GetEffect(effIndex);
     if (!effect)
         return;
     ConditionContainer* condList = effect->ImplicitTargetConditions;
     float coneAngle = float(M_PI) / 2;
     float radius = effect->CalcRadius(m_caster) * m_spellValue->RadiusMod;
 
     if (uint32 containerTypeMask = GetSearcherTypeMask(objectType, condList))
     {
         Trinity::WorldObjectSpellConeTargetCheck check(coneAngle, radius, m_caster, m_spellInfo, selectionType, condList);
         Trinity::WorldObjectListSearcher<Trinity::WorldObjectSpellConeTargetCheck> searcher(m_caster, targets, check, containerTypeMask);
         SearchTargets<Trinity::WorldObjectListSearcher<Trinity::WorldObjectSpellConeTargetCheck> >(searcher, containerTypeMask, m_caster, m_caster, radius);
 
         CallScriptObjectAreaTargetSelectHandlers(targets, effIndex, targetType);
 
         if (!targets.empty())
         {
             // Other special target selection goes here
             if (uint32 maxTargets = m_spellValue->MaxAffectedTargets)
                 Trinity::Containers::RandomResizeList(targets, maxTargets);
 
             for (std::list<WorldObject*>::iterator itr = targets.begin(); itr != targets.end(); ++itr)
             {
                 if (Unit* unit = (*itr)->ToUnit())
                     AddUnitTarget(unit, effMask, false);
                 else if (GameObject* gObjTarget = (*itr)->ToGameObject())
                     AddGOTarget(gObjTarget, effMask);
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SelectImplicitDestDestTargets	(	SpellEffIndex	effIndex,
		SpellImplicitTargetInfo const &	targetType
	)

 {
     // set destination to caster if no dest provided
     // can only happen if previous destination target could not be set for some reason
     // (not found nearby target, or channel target for example
     // maybe we should abort the spell in such case?
     CheckDst();
 
     SpellDestination dest(*m_targets.GetDst());
 
     switch (targetType.GetTarget())
     {
         case TARGET_DEST_DYNOBJ_ENEMY:
         case TARGET_DEST_DYNOBJ_ALLY:
         case TARGET_DEST_DYNOBJ_NONE:
         case TARGET_DEST_DEST:
             return;
         case TARGET_DEST_TRAJ:
             SelectImplicitTrajTargets(effIndex);
             return;
         default:
         {
             if (SpellEffectInfo const* effect = GetEffect(effIndex))
             {
                 float angle = targetType.CalcDirectionAngle();
                 float dist = effect->CalcRadius(m_caster);
                 if (targetType.GetTarget() == TARGET_DEST_DEST_RANDOM)
                     dist *= float(rand_norm());
 
                 Position pos = dest._position;
                 m_caster->MovePositionToFirstCollision(pos, dist, angle);
 
                 dest.Relocate(pos);
             }
             break;
         }
     }
 
     CallScriptDestinationTargetSelectHandlers(dest, effIndex, targetType);
     m_targets.ModDst(dest);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SelectImplicitNearbyTargets	(	SpellEffIndex	effIndex,
		SpellImplicitTargetInfo const &	targetType,
		uint32	effMask
	)

 {
     if (targetType.GetReferenceType() != TARGET_REFERENCE_TYPE_CASTER)
     {
         ASSERT(false && "Spell::SelectImplicitNearbyTargets: received not implemented target reference type");
         return;
     }
 
     SpellEffectInfo const* effect = GetEffect(effIndex);
     if (!effect)
         return;
 
     float range = 0.0f;
     switch (targetType.GetCheckType())
     {
         case TARGET_CHECK_ENEMY:
             range = m_spellInfo->GetMaxRange(false, m_caster, this);
             break;
         case TARGET_CHECK_ALLY:
         case TARGET_CHECK_PARTY:
         case TARGET_CHECK_RAID:
         case TARGET_CHECK_RAID_CLASS:
             range = m_spellInfo->GetMaxRange(true, m_caster, this);
             break;
         case TARGET_CHECK_ENTRY:
         case TARGET_CHECK_DEFAULT:
             range = m_spellInfo->GetMaxRange(m_spellInfo->IsPositive(), m_caster, this);
             break;
         default:
             ASSERT(false && "Spell::SelectImplicitNearbyTargets: received not implemented selection check type");
             break;
     }
 
     ConditionContainer* condList = effect->ImplicitTargetConditions;
 
     // handle emergency case - try to use other provided targets if no conditions provided
     if (targetType.GetCheckType() == TARGET_CHECK_ENTRY && (!condList || condList->empty()))
     {
         TC_LOG_DEBUG("spells", "Spell::SelectImplicitNearbyTargets: no conditions entry for target with TARGET_CHECK_ENTRY of spell ID %u, effect %u - selecting default targets", m_spellInfo->Id, effIndex);
         switch (targetType.GetObjectType())
         {
             case TARGET_OBJECT_TYPE_GOBJ:
                 if (m_spellInfo->RequiresSpellFocus)
                 {
                     if (focusObject)
                         AddGOTarget(focusObject, effMask);
                     return;
                 }
                 break;
             case TARGET_OBJECT_TYPE_DEST:
                 if (m_spellInfo->RequiresSpellFocus)
                 {
                     if (focusObject)
                         m_targets.SetDst(*focusObject);
                     return;
                 }
                 break;
             default:
                 break;
         }
     }
 
     WorldObject* target = SearchNearbyTarget(range, targetType.GetObjectType(), targetType.GetCheckType(), condList);
     if (!target)
     {
         TC_LOG_DEBUG("spells", "Spell::SelectImplicitNearbyTargets: cannot find nearby target for spell ID %u, effect %u", m_spellInfo->Id, effIndex);
         return;
     }
 
     CallScriptObjectTargetSelectHandlers(target, effIndex, targetType);
     if (!target)
     {
         TC_LOG_DEBUG("spells", "Spell::SelectImplicitNearbyTargets: OnObjectTargetSelect script hook for spell Id %u set NULL target, effect %u", m_spellInfo->Id, effIndex);
         return;
     }
 
     switch (targetType.GetObjectType())
     {
         case TARGET_OBJECT_TYPE_UNIT:
         {
             if (Unit* unit = target->ToUnit())
                 AddUnitTarget(unit, effMask, true, false);
             else
             {
                 TC_LOG_DEBUG("spells", "Spell::SelectImplicitNearbyTargets: OnObjectTargetSelect script hook for spell Id %u set object of wrong type, expected unit, got %s, effect %u", m_spellInfo->Id, target->GetGUID().GetTypeName(), effMask);
                 return;
             }
             break;
         }
         case TARGET_OBJECT_TYPE_GOBJ:
             if (GameObject* gobjTarget = target->ToGameObject())
                 AddGOTarget(gobjTarget, effMask);
             else
             {
                 TC_LOG_DEBUG("spells", "Spell::SelectImplicitNearbyTargets: OnObjectTargetSelect script hook for spell Id %u set object of wrong type, expected gameobject, got %s, effect %u", m_spellInfo->Id, target->GetGUID().GetTypeName(), effMask);
                 return;
             }
             break;
         case TARGET_OBJECT_TYPE_DEST:
             m_targets.SetDst(*target);
             break;
         default:
             ASSERT(false && "Spell::SelectImplicitNearbyTargets: received not implemented target object type");
             break;
     }
 
     SelectImplicitChainTargets(effIndex, targetType, target, effMask);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SelectImplicitTargetDestTargets	(	SpellEffIndex	effIndex,
		SpellImplicitTargetInfo const &	targetType
	)

 {
     ASSERT(m_targets.GetObjectTarget() && "Spell::SelectImplicitTargetDestTargets - no explicit object target available!");
     WorldObject* target = m_targets.GetObjectTarget();
 
     SpellDestination dest(*target);
 
     switch (targetType.GetTarget())
     {
         case TARGET_DEST_TARGET_ENEMY:
         case TARGET_DEST_TARGET_ANY:
             break;
         default:
         {
             if (SpellEffectInfo const* effect = GetEffect(effIndex))
             {
                 float angle = targetType.CalcDirectionAngle();
                 float objSize = target->GetObjectSize();
                 float dist = effect->CalcRadius(m_caster);
                 if (dist < objSize)
                     dist = objSize;
                 else if (targetType.GetTarget() == TARGET_DEST_TARGET_RANDOM)
                     dist = objSize + (dist - objSize) * float(rand_norm());
 
                 Position pos = dest._position;
                 target->MovePositionToFirstCollision(pos, dist, angle);
 
                 dest.Relocate(pos);
             }
             break;
         }
     }
 
     CallScriptDestinationTargetSelectHandlers(dest, effIndex, targetType);
     m_targets.SetDst(dest);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SelectImplicitTargetObjectTargets	(	SpellEffIndex	effIndex,
		SpellImplicitTargetInfo const &	targetType
	)

 {
     ASSERT((m_targets.GetObjectTarget() || m_targets.GetItemTarget()) && "Spell::SelectImplicitTargetObjectTargets - no explicit object or item target available!");
 
     WorldObject* target = m_targets.GetObjectTarget();
 
     CallScriptObjectTargetSelectHandlers(target, effIndex, targetType);
 
     if (target)
     {
         if (Unit* unit = target->ToUnit())
             AddUnitTarget(unit, 1 << effIndex, true, false);
         else if (GameObject* gobj = target->ToGameObject())
             AddGOTarget(gobj, 1 << effIndex);
 
         SelectImplicitChainTargets(effIndex, targetType, target, 1 << effIndex);
     }
     // Script hook can remove object target and we would wrongly land here
     else if (Item* item = m_targets.GetItemTarget())
         AddItemTarget(item, 1 << effIndex);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SelectImplicitTrajTargets ( SpellEffIndex effIndex )

Todo:: all calculation should be based on src instead of m_caster

 {
     if (!m_targets.HasTraj())
         return;
 
     float dist2d = m_targets.GetDist2d();
     if (!dist2d)
         return;
 
     float srcToDestDelta = m_targets.GetDstPos()->m_positionZ - m_targets.GetSrcPos()->m_positionZ;
 
     std::list<WorldObject*> targets;
     Trinity::WorldObjectSpellTrajTargetCheck check(dist2d, m_targets.GetSrcPos(), m_caster, m_spellInfo);
     Trinity::WorldObjectListSearcher<Trinity::WorldObjectSpellTrajTargetCheck> searcher(m_caster, targets, check, GRID_MAP_TYPE_MASK_ALL);
     SearchTargets<Trinity::WorldObjectListSearcher<Trinity::WorldObjectSpellTrajTargetCheck> > (searcher, GRID_MAP_TYPE_MASK_ALL, m_caster, m_targets.GetSrcPos(), dist2d);
     if (targets.empty())
         return;
 
     targets.sort(Trinity::ObjectDistanceOrderPred(m_caster));
 
     float b = tangent(m_targets.GetPitch());
     float a = (srcToDestDelta - dist2d * b) / (dist2d * dist2d);
     if (a > -0.0001f)
         a = 0;
     DEBUG_TRAJ(TC_LOG_ERROR("spells", "Spell::SelectTrajTargets: a %f b %f", a, b);)
 
     float bestDist = m_spellInfo->GetMaxRange(false);
 
     std::list<WorldObject*>::const_iterator itr = targets.begin();
     for (; itr != targets.end(); ++itr)
     {
         if (!m_caster->HasInLine(*itr, 5.0f))
             continue;
 
         if (m_spellInfo->CheckTarget(m_caster, *itr, true) != SPELL_CAST_OK)
             continue;
 
         if (Unit* unit = (*itr)->ToUnit())
         {
             if (m_caster == *itr || m_caster->IsOnVehicle(unit) || unit->GetVehicle())
                 continue;
 
             if (Creature* creatureTarget = unit->ToCreature())
             {
                 if (!(creatureTarget->GetCreatureTemplate()->type_flags & CREATURE_TYPEFLAGS_PROJECTILE_COLLISION))
                     continue;
             }
         }
 
         const float size = std::max((*itr)->GetObjectSize() * 0.7f, 1.0f); // 1/sqrt(3)
         const float objDist2d = m_targets.GetSrcPos()->GetExactDist2d(*itr) * std::cos(m_targets.GetSrcPos()->GetRelativeAngle(*itr));
         const float dz = (*itr)->GetPositionZ() - m_targets.GetSrcPos()->m_positionZ;
 
         DEBUG_TRAJ(TC_LOG_ERROR("spells", "Spell::SelectTrajTargets: check %u, dist between %f %f, height between %f %f.", (*itr)->GetEntry(), objDist2d - size, objDist2d + size, dz - size, dz + size);)
 
         float dist = objDist2d - size;
         float height = dist * (a * dist + b);
         DEBUG_TRAJ(TC_LOG_ERROR("spells", "Spell::SelectTrajTargets: dist %f, height %f.", dist, height);)
         if (dist < bestDist && height < dz + size && height > dz - size)
         {
             bestDist = dist > 0 ? dist : 0;
             break;
         }
 
 #define CHECK_DIST {\
             DEBUG_TRAJ(TC_LOG_ERROR("spells", "Spell::SelectTrajTargets: dist %f, height %f.", dist, height);)\
             if (dist > bestDist)\
                 continue;\
             if (dist < objDist2d + size && dist > objDist2d - size)\
             {\
                 bestDist = dist;\
                 break;\
             }\
         }
 
         if (!a)
         {
             height = dz - size;
             dist = height / b;
             CHECK_DIST;
 
             height = dz + size;
             dist = height / b;
             CHECK_DIST;
 
             continue;
         }
 
         height = dz - size;
         float sqrt1 = b * b + 4 * a * height;
         if (sqrt1 > 0)
         {
             sqrt1 = std::sqrt(sqrt1);
             dist = (sqrt1 - b) / (2 * a);
             CHECK_DIST;
         }
 
         height = dz + size;
         float sqrt2 = b * b + 4 * a * height;
         if (sqrt2 > 0)
         {
             sqrt2 = std::sqrt(sqrt2);
             dist = (sqrt2 - b) / (2 * a);
             CHECK_DIST;
 
             dist = (-sqrt2 - b) / (2 * a);
             CHECK_DIST;
         }
 
         if (sqrt1 > 0)
         {
             dist = (-sqrt1 - b) / (2 * a);
             CHECK_DIST;
         }
     }
 
     if (m_targets.GetSrcPos()->GetExactDist2d(m_targets.GetDstPos()) > bestDist)
     {
         float x = m_targets.GetSrcPos()->m_positionX + std::cos(m_caster->GetOrientation()) * bestDist;
         float y = m_targets.GetSrcPos()->m_positionY + std::sin(m_caster->GetOrientation()) * bestDist;
         float z = m_targets.GetSrcPos()->m_positionZ + bestDist * (a * bestDist + b);
 
         if (itr != targets.end())
         {
             float distSq = (*itr)->GetExactDistSq(x, y, z);
             float sizeSq = (*itr)->GetObjectSize();
             sizeSq *= sizeSq;
             DEBUG_TRAJ(TC_LOG_ERROR("spells", "Initial %f %f %f %f %f", x, y, z, distSq, sizeSq);)
             if (distSq > sizeSq)
             {
                 float factor = 1 - std::sqrt(sizeSq / distSq);
                 x += factor * ((*itr)->GetPositionX() - x);
                 y += factor * ((*itr)->GetPositionY() - y);
                 z += factor * ((*itr)->GetPositionZ() - z);
 
                 distSq = (*itr)->GetExactDistSq(x, y, z);
                 DEBUG_TRAJ(TC_LOG_ERROR("spells", "Initial %f %f %f %f %f", x, y, z, distSq, sizeSq);)
             }
         }
 
         Position trajDst;
         trajDst.Relocate(x, y, z, m_caster->GetOrientation());
         SpellDestination dest(*m_targets.GetDst());
         dest.Relocate(trajDst);
 
         CallScriptDestinationTargetSelectHandlers(dest, effIndex, SpellImplicitTargetInfo(TARGET_DEST_TRAJ));
         m_targets.ModDst(dest);
     }
 
     if (Vehicle* veh = m_caster->GetVehicleKit())
         veh->SetLastShootPos(*m_targets.GetDstPos());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SelectSpellTargets ( )

 {
     // select targets for cast phase
     SelectExplicitTargets();
 
     uint32 processedAreaEffectsMask = 0;
 
     for (SpellEffectInfo const* effect : GetEffects())
     {
         if (!effect)
             continue;
 
         // not call for empty effect.
         // Also some spells use not used effect targets for store targets for dummy effect in triggered spells
         if (!effect->IsEffect())
             continue;
 
         // set expected type of implicit targets to be sent to client
         uint32 implicitTargetMask = GetTargetFlagMask(effect->TargetA.GetObjectType()) | GetTargetFlagMask(effect->TargetB.GetObjectType());
         if (implicitTargetMask & TARGET_FLAG_UNIT)
             m_targets.SetTargetFlag(TARGET_FLAG_UNIT);
         if (implicitTargetMask & (TARGET_FLAG_GAMEOBJECT | TARGET_FLAG_GAMEOBJECT_ITEM))
             m_targets.SetTargetFlag(TARGET_FLAG_GAMEOBJECT);
 
         SelectEffectImplicitTargets(SpellEffIndex(effect->EffectIndex), effect->TargetA, processedAreaEffectsMask);
         SelectEffectImplicitTargets(SpellEffIndex(effect->EffectIndex), effect->TargetB, processedAreaEffectsMask);
 
         // Select targets of effect based on effect type
         // those are used when no valid target could be added for spell effect based on spell target type
         // some spell effects use explicit target as a default target added to target map (like SPELL_EFFECT_LEARN_SPELL)
         // some spell effects add target to target map only when target type specified (like SPELL_EFFECT_WEAPON)
         // some spell effects don't add anything to target map (confirmed with sniffs) (like SPELL_EFFECT_DESTROY_ALL_TOTEMS)
         SelectEffectTypeImplicitTargets(effect->EffectIndex);
 
         if (m_targets.HasDst())
             AddDestTarget(*m_targets.GetDst(), effect->EffectIndex);
 
         if (m_spellInfo->IsChanneled())
         {
             uint32 mask = (1 << effect->EffectIndex);
             for (std::vector<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
             {
                 if (ihit->effectMask & mask)
                 {
                     m_channelTargetEffectMask |= mask;
                     break;
                 }
             }
         }
         else if (m_auraScaleMask)
         {
             bool checkLvl = !m_UniqueTargetInfo.empty();
             for (std::vector<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end();)
             {
                 // remove targets which did not pass min level check
                 if (m_auraScaleMask && ihit->effectMask == m_auraScaleMask)
                 {
                     // Do not check for selfcast
                     if (!ihit->scaleAura && ihit->targetGUID != m_caster->GetGUID())
                     {
                         ihit = m_UniqueTargetInfo.erase(ihit);
                         continue;
                     }
                 }
 
                 ++ihit;
             }
 
             if (checkLvl && m_UniqueTargetInfo.empty())
             {
                 SendCastResult(SPELL_FAILED_LOWLEVEL);
                 finish(false);
             }
         }
     }
 
     if (m_targets.HasDst())
     {
         if (m_targets.HasTraj())
         {
             float speed = m_targets.GetSpeedXY();
             if (speed > 0.0f)
                 m_delayMoment = uint64(std::floor(m_targets.GetDist2d() / speed * 1000.0f));
         }
         else if (m_spellInfo->Speed > 0.0f)
         {
             float dist = m_caster->GetDistance(*m_targets.GetDstPos());
             if (!m_spellInfo->HasAttribute(SPELL_ATTR9_SPECIAL_DELAY_CALCULATION))
                 m_delayMoment = uint64(std::floor(dist / m_spellInfo->Speed * 1000.0f));
             else
                 m_delayMoment = uint64(m_spellInfo->Speed * 1000.0f);
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SendCastResult	(	Player *	caster,
		SpellInfo const *	spellInfo,
		uint8	cast_count,
		SpellCastResult	result,
		SpellCustomErrors	customError = `SPELL_CUSTOM_ERROR_NONE`,
		OpcodeServer	opcode = `SMSG_CAST_FAILED`,
		uint32 *	misc = `nullptr`
	)

static

 {
     if (result == SPELL_CAST_OK)
         return;
 
     WorldPackets::Spells::CastFailed packet(opcode);
     packet.CastID = cast_count;
     packet.SpellID = spellInfo->Id;
     packet.Reason = result;
 
     switch (result)
     {
         case SPELL_FAILED_NOT_READY:
             packet.FailedArg1 = 0;                              // unknown (value 1 update cooldowns on client flag)
             break;
         case SPELL_FAILED_REQUIRES_SPELL_FOCUS:
             packet.FailedArg1 = spellInfo->RequiresSpellFocus;  // SpellFocusObject.dbc id
             break;
         case SPELL_FAILED_REQUIRES_AREA:                    // AreaTable.dbc id
             // hardcode areas limitation case
             switch (spellInfo->Id)
             {
                 case 41617:                                 // Cenarion Mana Salve
                 case 41619:                                 // Cenarion Healing Salve
                     packet.FailedArg1 = 3905;
                     break;
                 case 41618:                                 // Bottled Nethergon Energy
                 case 41620:                                 // Bottled Nethergon Vapor
                     packet.FailedArg1 = 3842;
                     break;
                 case 45373:                                 // Bloodberry Elixir
                     packet.FailedArg1 = 4075;
                     break;
                 default:                                    // default case (don't must be)
                     packet.FailedArg1 = 0;
                     break;
             }
             break;
         case SPELL_FAILED_TOTEMS:
             if (spellInfo->Totem[0])
                 packet.FailedArg1 = spellInfo->Totem[0];
             if (spellInfo->Totem[1])
                 packet.FailedArg2 = spellInfo->Totem[1];
             break;
         case SPELL_FAILED_TOTEM_CATEGORY:
             if (spellInfo->TotemCategory[0])
                 packet.FailedArg1 = spellInfo->TotemCategory[0];
             if (spellInfo->TotemCategory[1])
                 packet.FailedArg2 = spellInfo->TotemCategory[1];
             break;
         case SPELL_FAILED_EQUIPPED_ITEM_CLASS:
         case SPELL_FAILED_EQUIPPED_ITEM_CLASS_MAINHAND:
         case SPELL_FAILED_EQUIPPED_ITEM_CLASS_OFFHAND:
             packet.FailedArg1 = spellInfo->EquippedItemClass;
             packet.FailedArg2 = spellInfo->EquippedItemSubClassMask;
             break;
         case SPELL_FAILED_TOO_MANY_OF_ITEM:
         {
             uint32 item = 0;
             for (SpellEffectInfo const* effect : spellInfo->GetEffectsForDifficulty(caster->GetMap()->GetDifficultyID()))
                 if (effect->ItemType)
                     item = effect->ItemType;
             ItemTemplate const* proto = sObjectMgr->GetItemTemplate(item);
             if (proto && proto->GetItemLimitCategory())
                 packet.FailedArg1 = proto->GetItemLimitCategory();
             break;
         }
         case SPELL_FAILED_PREVENTED_BY_MECHANIC:
             packet.FailedArg1 = spellInfo->GetAllEffectsMechanicMask();  // SpellMechanic.dbc id
             break;
         case SPELL_FAILED_NEED_EXOTIC_AMMO:
             packet.FailedArg1 = spellInfo->EquippedItemSubClassMask; // seems correct...
             break;
         case SPELL_FAILED_NEED_MORE_ITEMS:
             packet.FailedArg1 = 0;                              // Item id
             packet.FailedArg2 = 0;                              // Item count?
             break;
         case SPELL_FAILED_MIN_SKILL:
             packet.FailedArg1 = 0;                              // SkillLine.dbc id
             packet.FailedArg2 = 0;                              // required skill value
             break;
         case SPELL_FAILED_FISHING_TOO_LOW:
             packet.FailedArg1 = 0;                              // required fishing skill
             break;
         case SPELL_FAILED_CUSTOM_ERROR:
             packet.FailedArg1 = customError;
             break;
         case SPELL_FAILED_SILENCED:
             packet.FailedArg1 = 0;                              // Unknown
             break;
         case SPELL_FAILED_REAGENTS:
         {
             uint32 missingItem = 0;
             for (uint32 i = 0; i < MAX_SPELL_REAGENTS; i++)
             {
                 if (spellInfo->Reagent[i] <= 0)
                     continue;
 
                 uint32 itemid    = spellInfo->Reagent[i];
                 uint32 itemcount = spellInfo->ReagentCount[i];
 
                 if (!caster->HasItemCount(itemid, itemcount))
                 {
                     missingItem = itemid;
                     break;
                 }
             }
 
             packet.FailedArg1 = missingItem;  // first missing item
             break;
         }
         case SPELL_FAILED_CANT_UNTALENT:
         {
             if (misc)
                 if (TalentEntry const* talent = sTalentStore.LookupEntry(misc[0]))
                     packet.FailedArg1 = talent->SpellID;
             break;
         }
         // TODO: SPELL_FAILED_NOT_STANDING
         default:
             break;
     }
 
     caster->GetSession()->SendPacket(packet.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SendCastResult ( SpellCastResult result )

 {
     if (result == SPELL_CAST_OK)
         return;
 
     if (m_caster->GetTypeId() != TYPEID_PLAYER)
         return;
 
     if (m_caster->ToPlayer()->GetSession()->PlayerLoading())  // don't send cast results at loading time
         return;
 
     SendCastResult(m_caster->ToPlayer(), m_spellInfo, m_cast_count, result, m_customError, SMSG_CAST_FAILED, m_misc.Raw.Data);
 }

Here is the call graph for this function:

void Spell::SendChannelStart ( uint32 duration )

 {
     ObjectGuid channelTarget = m_targets.GetObjectTargetGUID();
     if (!channelTarget && !m_spellInfo->NeedsExplicitUnitTarget())
         if (m_UniqueTargetInfo.size() + m_UniqueGOTargetInfo.size() == 1)   // this is for TARGET_SELECT_CATEGORY_NEARBY
             channelTarget = !m_UniqueTargetInfo.empty() ? m_UniqueTargetInfo.front().targetGUID : m_UniqueGOTargetInfo.front().targetGUID;
 
     WorldPackets::Spells::SpellChannelStart spellChannelStart;
     spellChannelStart.CasterGUID = m_caster->GetGUID();
     spellChannelStart.SpellID = m_spellInfo->Id;
     spellChannelStart.ChannelDuration = duration;
     m_caster->SendMessageToSet(spellChannelStart.Write(), true);
 
     uint32 schoolImmunityMask = m_caster->GetSchoolImmunityMask();
     uint32 mechanicImmunityMask = m_caster->GetMechanicImmunityMask();
 
     if (schoolImmunityMask || mechanicImmunityMask)
     {
         spellChannelStart.InterruptImmunities = boost::in_place();
         spellChannelStart.InterruptImmunities->SchoolImmunities = schoolImmunityMask;
         spellChannelStart.InterruptImmunities->Immunities = mechanicImmunityMask;
     }
 
     m_timer = duration;
     if (!channelTarget.IsEmpty())
         m_caster->SetChannelObjectGuid(channelTarget);
 
     m_caster->SetUInt32Value(UNIT_CHANNEL_SPELL, m_spellInfo->Id);
     m_caster->SetUInt32Value(UNIT_CHANNEL_SPELL_X_SPELL_VISUAL, m_spellInfo->GetSpellXSpellVisualId(m_caster->GetMap()->GetDifficultyID()));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SendChannelUpdate ( uint32 time )

 {
     if (time == 0)
     {
         m_caster->SetChannelObjectGuid(ObjectGuid::Empty);
         m_caster->SetUInt32Value(UNIT_CHANNEL_SPELL, 0);
     }
 
     WorldPackets::Spells::SpellChannelUpdate spellChannelUpdate;
     spellChannelUpdate.CasterGUID = m_caster->GetGUID();
     spellChannelUpdate.TimeRemaining = time;
     m_caster->SendMessageToSet(spellChannelUpdate.Write(), true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SendInterrupted ( uint8 result )

 {
     WorldPackets::Spells::SpellFailure failurePacket;
     failurePacket.CasterUnit = m_caster->GetGUID();
     failurePacket.CastID = m_cast_count;
     failurePacket.SpellID = m_spellInfo->Id;
     failurePacket.SpelXSpellVisualID = m_SpellVisual;
     failurePacket.Reason = result;
     m_caster->SendMessageToSet(failurePacket.Write(), true);
 
     WorldPackets::Spells::SpellFailedOther failedPacket;
     failedPacket.CasterUnit = m_caster->GetGUID();
     failedPacket.CastID = m_cast_count;
     failedPacket.SpellID = m_spellInfo->Id;
     failedPacket.Reason = result;
     m_caster->SendMessageToSet(failedPacket.Write(), true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SendLoot	(	ObjectGuid	guid,
		LootType	loottype
	)

protected

Todo:: possible must be moved to loot release (in different from linked triggering)

 {
     Player* player = m_caster->ToPlayer();
     if (!player)
         return;
 
     if (gameObjTarget)
     {
         // Players shouldn't be able to loot gameobjects that are currently despawned
         if (!gameObjTarget->isSpawned() && !player->IsGameMaster())
         {
             TC_LOG_ERROR("spells", "Possible hacking attempt: Player %s [%s] tried to loot a gameobject [%s] which is on respawn time without being in GM mode!",
                 player->GetName().c_str(), player->GetGUID().ToString().c_str(), gameObjTarget->GetGUID().ToString().c_str());
             return;
         }
         // special case, already has GossipHello inside so return and avoid calling twice
         if (gameObjTarget->GetGoType() == GAMEOBJECT_TYPE_GOOBER)
         {
             gameObjTarget->Use(m_caster);
             return;
         }
 
         if (sScriptMgr->OnGossipHello(player, gameObjTarget))
             return;
 
         if (gameObjTarget->AI()->GossipHello(player))
             return;
 
         switch (gameObjTarget->GetGoType())
         {
             case GAMEOBJECT_TYPE_DOOR:
             case GAMEOBJECT_TYPE_BUTTON:
                 gameObjTarget->UseDoorOrButton(0, false, player);
                 return;
 
             case GAMEOBJECT_TYPE_QUESTGIVER:
                 player->PrepareGossipMenu(gameObjTarget, gameObjTarget->GetGOInfo()->questgiver.gossipID, true);
                 player->SendPreparedGossip(gameObjTarget);
                 return;
 
             case GAMEOBJECT_TYPE_SPELL_FOCUS:
                 // triggering linked GO
                 if (uint32 trapEntry = gameObjTarget->GetGOInfo()->spellFocus.linkedTrap)
                     gameObjTarget->TriggeringLinkedGameObject(trapEntry, m_caster);
                 return;
 
             case GAMEOBJECT_TYPE_CHEST:
                 if (gameObjTarget->GetGOInfo()->chest.triggeredEvent)
                 {
                     TC_LOG_DEBUG("spells", "Chest ScriptStart id %u for GO " UI64FMTD, gameObjTarget->GetGOInfo()->chest.triggeredEvent, gameObjTarget->GetSpawnId());
                     player->GetMap()->ScriptsStart(sEventScripts, gameObjTarget->GetGOInfo()->chest.triggeredEvent, player, gameObjTarget);
                 }
 
                 // triggering linked GO
                 if (uint32 trapEntry = gameObjTarget->GetGOInfo()->chest.linkedTrap)
                     gameObjTarget->TriggeringLinkedGameObject(trapEntry, m_caster);
 
                 // Don't return, let loots been taken
             default:
                 break;
         }
     }
 
     // Send loot
     player->SendLoot(guid, loottype);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SendPetCastResult ( SpellCastResult result )

 {
     if (result == SPELL_CAST_OK)
         return;
 
     Unit* owner = m_caster->GetCharmerOrOwner();
     if (!owner || owner->GetTypeId() != TYPEID_PLAYER)
         return;
 
     SendCastResult(owner->ToPlayer(), m_spellInfo, m_cast_count, result, SPELL_CUSTOM_ERROR_NONE, SMSG_PET_CAST_FAILED, m_misc.Raw.Data);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SendResurrectRequest ( Player * target )

 {
     // get resurrector name for creature resurrections, otherwise packet will be not accepted
     // for player resurrections the name is looked up by guid
     std::string const sentName(m_caster->GetTypeId() == TYPEID_PLAYER
         ? "" : m_caster->GetNameForLocaleIdx(target->GetSession()->GetSessionDbLocaleIndex()));
 
     WorldPackets::Spells::ResurrectRequest resurrectRequest;
     resurrectRequest.ResurrectOffererGUID =  m_caster->GetGUID();
     resurrectRequest.ResurrectOffererVirtualRealmAddress = GetVirtualRealmAddress();
 
     if (Pet* pet = target->GetPet())
     {
         if (CharmInfo* charmInfo = pet->GetCharmInfo())
             resurrectRequest.PetNumber = charmInfo->GetPetNumber();
     }
 
     resurrectRequest.SpellID = m_spellInfo->Id;
 
     //packet.ReadBit("UseTimer"); /// @todo: 6.x Has to be implemented
     resurrectRequest.Sickness = m_caster->GetTypeId() != TYPEID_PLAYER; // "you'll be afflicted with resurrection sickness"
 
     resurrectRequest.Name = sentName;
 
     target->GetSession()->SendPacket(resurrectRequest.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SendSpellCooldown ( )

 {
     if (m_CastItem)
         m_caster->GetSpellHistory()->HandleCooldowns(m_spellInfo, m_CastItem, this);
     else
         m_caster->GetSpellHistory()->HandleCooldowns(m_spellInfo, m_castItemEntry, this);
 }

Here is the caller graph for this function:

void Spell::SendSpellExecuteLog ( )

 {
     WorldPackets::CombatLog::SpellExecuteLog spellExecuteLog;
 
     spellExecuteLog.Caster = m_caster->GetGUID();
     spellExecuteLog.SpellID = m_spellInfo->Id;
 
     if (_powerDrainTargets->empty() && _extraAttacksTargets->empty() &&
         _durabilityDamageTargets->empty() && _genericVictimTargets->empty() &&
         _tradeSkillTargets->empty() && _feedPetTargets->empty())
         return;
 
     for (SpellEffectInfo const* effect : GetEffects())
     {
         WorldPackets::CombatLog::SpellExecuteLog::SpellLogEffect spellLogEffect;
         if (!effect)
             continue;
 
         spellLogEffect.Effect = effect->Effect;
 
         for (SpellLogEffectPowerDrainParams const& powerDrainParam : _powerDrainTargets[effect->EffectIndex])
             spellLogEffect.PowerDrainTargets.push_back(powerDrainParam);
 
         for (SpellLogEffectExtraAttacksParams const& extraAttacksTarget : _extraAttacksTargets[effect->EffectIndex])
             spellLogEffect.ExtraAttacksTargets.push_back(extraAttacksTarget);
 
         for (SpellLogEffectDurabilityDamageParams const& durabilityDamageTarget : _durabilityDamageTargets[effect->EffectIndex])
             spellLogEffect.DurabilityDamageTargets.push_back(durabilityDamageTarget);
 
         for (SpellLogEffectGenericVictimParams const& genericVictimTarget : _genericVictimTargets[effect->EffectIndex])
             spellLogEffect.GenericVictimTargets.push_back(genericVictimTarget);
 
         for (SpellLogEffectTradeSkillItemParams const& tradeSkillTarget : _tradeSkillTargets[effect->EffectIndex])
             spellLogEffect.TradeSkillTargets.push_back(tradeSkillTarget);
 
         for (SpellLogEffectFeedPetParams const& feedPetTarget : _feedPetTargets[effect->EffectIndex])
             spellLogEffect.FeedPetTargets.push_back(feedPetTarget);
 
         spellExecuteLog.Effects.push_back(spellLogEffect);
     }
 
     m_caster->SendCombatLogMessage(&spellExecuteLog);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SendSpellGo ( )

 {
     // not send invisible spell casting
     if (!IsNeedSendToClient())
         return;
 
     TC_LOG_DEBUG("spells", "Sending SMSG_SPELL_GO id=%u", m_spellInfo->Id);
 
     uint32 castFlags = CAST_FLAG_UNKNOWN_9;
 
     // triggered spells with spell visual != 0
     if ((IsTriggered() && !m_spellInfo->IsAutoRepeatRangedSpell()) || m_triggeredByAuraSpell)
         castFlags |= CAST_FLAG_PENDING;
 
     if ((m_caster->GetTypeId() == TYPEID_PLAYER ||
         (m_caster->GetTypeId() == TYPEID_UNIT && m_caster->IsPet()))
         && std::find_if(m_powerCost.begin(), m_powerCost.end(), [](SpellInfo::CostData const& cost) { return cost.Power != POWER_HEALTH; }) != m_powerCost.end())
         castFlags |= CAST_FLAG_POWER_LEFT_SELF; // should only be sent to self, but the current messaging doesn't make that possible
 
     if ((m_caster->GetTypeId() == TYPEID_PLAYER)
         && (m_caster->getClass() == CLASS_DEATH_KNIGHT)
         && m_spellInfo->RuneCostID
         && std::find_if(m_powerCost.begin(), m_powerCost.end(), [](SpellInfo::CostData const& cost) { return cost.Power == POWER_RUNES; }) != m_powerCost.end()
         && !(_triggeredCastFlags & TRIGGERED_IGNORE_POWER_AND_REAGENT_COST))
     {
         castFlags |= CAST_FLAG_NO_GCD;                       // not needed, but Blizzard sends it
         castFlags |= CAST_FLAG_RUNE_LIST;                    // rune cooldowns list
     }
 
     if (HasEffect(SPELL_EFFECT_ACTIVATE_RUNE))
         castFlags |= CAST_FLAG_RUNE_LIST;                    // rune cooldowns list
 
     if (m_targets.HasTraj())
         castFlags |= CAST_FLAG_ADJUST_MISSILE;
 
     if (!m_spellInfo->StartRecoveryTime)
         castFlags |= CAST_FLAG_NO_GCD;
 
     WorldPackets::Spells::SpellGo packet;
     WorldPackets::Spells::SpellCastData& castData = packet.Cast;
 
     if (m_CastItem)
         castData.CasterGUID = m_CastItem->GetGUID();
     else
         castData.CasterGUID = m_caster->GetGUID();
 
     castData.CasterUnit = m_caster->GetGUID();
     castData.CastID = m_cast_count; // pending spell cast?
     castData.SpellID = m_spellInfo->Id;
     castData.SpellXSpellVisualID = m_SpellVisual;
     castData.CastFlags = castFlags;
     castData.CastFlagsEx = m_castFlagsEx;
     castData.CastTime = getMSTime();
 
     UpdateSpellCastDataTargets(castData);
 
     m_targets.Write(castData.Target);
 
     if (castFlags & CAST_FLAG_POWER_LEFT_SELF)
     {
         for (SpellInfo::CostData const& cost : m_powerCost)
         {
             WorldPackets::Spells::SpellPowerData powerData;
             powerData.Type = cost.Power;
             powerData.Cost = m_caster->GetPower(cost.Power);
             castData.RemainingPower.push_back(powerData);
         }
     }
 
     if (castFlags & CAST_FLAG_RUNE_LIST) // rune cooldowns list
     {
         castData.RemainingRunes = boost::in_place();
 
         //TODO: There is a crash caused by a spell with CAST_FLAG_RUNE_LIST casted by a creature
         //The creature is the mover of a player, so HandleCastSpellOpcode uses it as the caster
         if (Player* player = m_caster->ToPlayer())
         {
             castData.RemainingRunes->Start = m_runesState; // runes state before
             castData.RemainingRunes->Count = player->GetRunesState(); // runes state after
             for (uint8 i = 0; i < MAX_RUNES; ++i)
             {
                 // float casts ensure the division is performed on floats as we need float result
                 float baseCd = float(player->GetRuneBaseCooldown(i));
                 castData.RemainingRunes->Cooldowns.push_back((baseCd - float(player->GetRuneCooldown(i))) / baseCd * 255); // rune cooldown passed
             }
         }
         else
         {
             castData.RemainingRunes->Start = 0;
             castData.RemainingRunes->Count = 0;
             for (uint8 i = 0; i < MAX_RUNES; ++i)
                 castData.RemainingRunes->Cooldowns.push_back(0);
         }
     }
 
     if (castFlags & CAST_FLAG_ADJUST_MISSILE)
     {
         castData.MissileTrajectory.TravelTime = m_delayMoment;
         castData.MissileTrajectory.Pitch = m_targets.GetPitch();
     }
 
     m_caster->SendMessageToSet(packet.Write(), true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SendSpellStart ( )

Todo:: implement spell ammo packet data if (castFlags & CAST_FLAG_PROJECTILE) { castData.Ammo.DisplayID = 0; castData.Ammo.InventoryType = 0; }

Todo:: implement heal prediction packet data if (castFlags & CAST_FLAG_HEAL_PREDICTION) { castData.Predict.BeconGUID = ?? castData.Predict.Points = 0; castData.Predict.Type = 0; }

 {
     if (!IsNeedSendToClient())
         return;
 
     TC_LOG_DEBUG("spells", "Sending SMSG_SPELL_START id=%u", m_spellInfo->Id);
 
     uint32 castFlags = CAST_FLAG_HAS_TRAJECTORY;
     uint32 schoolImmunityMask = m_caster->GetSchoolImmunityMask();
     uint32 mechanicImmunityMask = m_caster->GetMechanicImmunityMask();
     if (schoolImmunityMask || mechanicImmunityMask)
         castFlags |= CAST_FLAG_IMMUNITY;
 
     if ((IsTriggered() && !m_spellInfo->IsAutoRepeatRangedSpell()) || m_triggeredByAuraSpell)
         castFlags |= CAST_FLAG_PENDING;
 
     if ((m_caster->GetTypeId() == TYPEID_PLAYER ||
         (m_caster->GetTypeId() == TYPEID_UNIT && m_caster->IsPet()))
         && std::find_if(m_powerCost.begin(), m_powerCost.end(), [](SpellInfo::CostData const& cost) { return cost.Power != POWER_HEALTH; }) != m_powerCost.end())
         castFlags |= CAST_FLAG_POWER_LEFT_SELF;
 
     if (m_spellInfo->RuneCostID &&
         std::find_if(m_powerCost.begin(), m_powerCost.end(), [](SpellInfo::CostData const& cost) { return cost.Power == POWER_RUNES; }) != m_powerCost.end())
         castFlags |= CAST_FLAG_NO_GCD; // not needed, but Blizzard sends it
 
     WorldPackets::Spells::SpellStart packet;
     WorldPackets::Spells::SpellCastData& castData = packet.Cast;
 
     if (m_CastItem)
         castData.CasterGUID = m_CastItem->GetGUID();
     else
         castData.CasterGUID = m_caster->GetGUID();
 
     castData.CasterUnit = m_caster->GetGUID();
     castData.CastID = m_cast_count; // pending spell cast?
     castData.SpellID = m_spellInfo->Id;
     castData.SpellXSpellVisualID = m_SpellVisual;
     castData.CastFlags = castFlags;
     castData.CastFlagsEx = m_castFlagsEx;
     castData.CastTime = m_casttime;
 
     m_targets.Write(castData.Target);
 
     if (castFlags & CAST_FLAG_POWER_LEFT_SELF)
     {
         for (SpellInfo::CostData const& cost : m_powerCost)
         {
             WorldPackets::Spells::SpellPowerData powerData;
             powerData.Type = cost.Power;
             powerData.Cost = m_caster->GetPower(cost.Power);
             castData.RemainingPower.push_back(powerData);
         }
     }
 
     if (castFlags & CAST_FLAG_RUNE_LIST) // rune cooldowns list
     {
         castData.RemainingRunes = boost::in_place();
 
         //TODO: There is a crash caused by a spell with CAST_FLAG_RUNE_LIST casted by a creature
         //The creature is the mover of a player, so HandleCastSpellOpcode uses it as the caster
         if (Player* player = m_caster->ToPlayer())
         {
             castData.RemainingRunes->Start = m_runesState; // runes state before
             castData.RemainingRunes->Count = player->GetRunesState(); // runes state after
             for (uint8 i = 0; i < MAX_RUNES; ++i)
             {
                 // float casts ensure the division is performed on floats as we need float result
                 float baseCd = float(player->GetRuneBaseCooldown(i));
                 castData.RemainingRunes->Cooldowns.push_back((baseCd - float(player->GetRuneCooldown(i))) / baseCd * 255); // rune cooldown passed
             }
         }
         else
         {
             castData.RemainingRunes->Start = 0;
             castData.RemainingRunes->Count = 0;
             for (uint8 i = 0; i < MAX_RUNES; ++i)
                 castData.RemainingRunes->Cooldowns.push_back(0);
         }
     }
 
     if (castFlags & CAST_FLAG_IMMUNITY)
     {
         castData.Immunities.School = schoolImmunityMask;
         castData.Immunities.Value = mechanicImmunityMask;
     }
 
     m_caster->SendMessageToSet(packet.Write(), true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::SetAutoRepeat ( bool rep )

inline

592 { m_autoRepeat = rep; }

Spell::m_autoRepeat

bool m_autoRepeat

Definition: Spell.h:663

void Spell::SetDelayStart ( uint64 m_time )

inline

605 { m_delayStart = m_time; }

Spell::m_delayStart

uint64 m_delayStart

Definition: Spell.h:678

Here is the caller graph for this function:

void Spell::SetExecutedCurrently ( bool yes )

inline

603 {m_executedCurrently = yes;}

Spell::m_executedCurrently

bool m_executedCurrently

Definition: Spell.h:684

Here is the caller graph for this function:

void Spell::SetReferencedFromCurrent ( bool yes )

inline

601 { m_referencedFromCurrentSpell = yes; }

Spell::m_referencedFromCurrentSpell

bool m_referencedFromCurrentSpell

Definition: Spell.h:683

Here is the caller graph for this function:

void Spell::SetSpellValue	(	SpellValueMod	mod,
		int32	value
	)

 {
     if (mod < SPELLVALUE_BASE_POINT_END)
     {
         if (SpellEffectInfo const* effect = GetEffect(mod))
             m_spellValue->EffectBasePoints[mod] = effect->CalcBaseValue(value);
         return;
     }
 
     switch (mod)
     {
         case SPELLVALUE_RADIUS_MOD:
             m_spellValue->RadiusMod = (float)value / 10000;
             break;
         case SPELLVALUE_MAX_TARGETS:
             m_spellValue->MaxAffectedTargets = (uint32)value;
             break;
         case SPELLVALUE_AURA_STACK:
             m_spellValue->AuraStackAmount = uint8(value);
             break;
         default:
             break;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::setState ( uint32 state )

inline

510 { m_spellState = state; }

Spell::m_spellState

uint32 m_spellState

Definition: Spell.h:818

void Spell::SummonGuardian	(	uint32	i,
		uint32	entry,
		SummonPropertiesEntry const *	properties,
		uint32	numSummons
	)

protected

 {
     Unit* caster = m_originalCaster;
     if (!caster)
         return;
 
     if (caster->IsTotem())
         caster = caster->ToTotem()->GetOwner();
 
     // in another case summon new
     uint8 level = caster->getLevel();
 
     // level of pet summoned using engineering item based at engineering skill level
     if (m_CastItem && caster->GetTypeId() == TYPEID_PLAYER)
         if (ItemTemplate const* proto = m_CastItem->GetTemplate())
             if (proto->GetRequiredSkill() == SKILL_ENGINEERING)
                 if (uint16 skill202 = caster->ToPlayer()->GetSkillValue(SKILL_ENGINEERING))
                     level = skill202 / 5;
 
     float radius = 5.0f;
     int32 duration = m_spellInfo->GetDuration();
 
     if (Player* modOwner = m_originalCaster->GetSpellModOwner())
         modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_DURATION, duration);
 
     //TempSummonType summonType = (duration == 0) ? TEMPSUMMON_DEAD_DESPAWN : TEMPSUMMON_TIMED_DESPAWN;
     Map* map = caster->GetMap();
 
     for (uint32 count = 0; count < numGuardians; ++count)
     {
         Position pos;
         if (count == 0)
             pos = *destTarget;
         else
             // randomize position for multiple summons
             pos = m_caster->GetRandomPoint(*destTarget, radius);
 
         TempSummon* summon = map->SummonCreature(entry, pos, properties, duration, caster, m_spellInfo->Id);
         if (!summon)
             return;
 
         if (summon->HasUnitTypeMask(UNIT_MASK_GUARDIAN))
             ((Guardian*)summon)->InitStatsForLevel(level);
 
         if (properties && properties->Category == SUMMON_CATEGORY_ALLY)
             summon->setFaction(caster->getFaction());
 
         if (summon->HasUnitTypeMask(UNIT_MASK_MINION) && m_targets.HasDst())
             ((Minion*)summon)->SetFollowAngle(m_caster->GetAngle(summon));
 
         if (summon->GetEntry() == 27893)
         {
             if (uint32 weapon = m_caster->GetUInt32Value(PLAYER_VISIBLE_ITEM + VISIBLE_ITEM_ENTRY_OFFSET + (EQUIPMENT_SLOT_MAINHAND * 2)))
             {
                 summon->SetDisplayId(11686); // modelid2
                 summon->SetVirtualItem(0, weapon);
             }
             else
                 summon->SetDisplayId(1126); // modelid1
         }
 
         summon->AI()->EnterEvadeMode();
 
         ExecuteLogEffectSummonObject(i, summon);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::TakeCastItem ( )

 {
     if (!m_CastItem)
         return;
 
     Player* player = m_caster->ToPlayer();
     if (!player)
         return;
 
     // not remove cast item at triggered spell (equipping, weapon damage, etc)
     if (_triggeredCastFlags & TRIGGERED_IGNORE_CAST_ITEM)
         return;
 
     ItemTemplate const* proto = m_CastItem->GetTemplate();
 
     if (!proto)
     {
         // This code is to avoid a crash
         // I'm not sure, if this is really an error, but I guess every item needs a prototype
         TC_LOG_ERROR("spells", "Cast item has no item prototype %s", m_CastItem->GetGUID().ToString().c_str());
         return;
     }
 
     bool expendable = false;
     bool withoutCharges = false;
 
     for (uint8 i = 0; i < proto->Effects.size() && i < 5; ++i)
     {
         // item has limited charges
         if (proto->Effects[i]->Charges)
         {
             if (proto->Effects[i]->Charges < 0)
                 expendable = true;
 
             int32 charges = m_CastItem->GetSpellCharges(i);
 
             // item has charges left
             if (charges)
             {
                 (charges > 0) ? --charges : ++charges;  // abs(charges) less at 1 after use
                 if (proto->GetMaxStackSize() == 1)
                     m_CastItem->SetSpellCharges(i, charges);
                 m_CastItem->SetState(ITEM_CHANGED, player);
             }
 
             // all charges used
             withoutCharges = (charges == 0);
         }
     }
 
     if (expendable && withoutCharges)
     {
         uint32 count = 1;
         m_caster->ToPlayer()->DestroyItemCount(m_CastItem, count, true);
 
         // prevent crash at access to deleted m_targets.GetItemTarget
         if (m_CastItem == m_targets.GetItemTarget())
             m_targets.SetItemTarget(NULL);
 
         m_CastItem = NULL;
         m_castItemGUID.Clear();
         m_castItemEntry = 0;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::TakePower ( )

 {
     if (m_CastItem || m_triggeredByAuraSpell)
         return;
 
     //Don't take power if the spell is cast while .cheat power is enabled.
     if (m_caster->GetTypeId() == TYPEID_PLAYER)
     {
         if (m_caster->ToPlayer()->GetCommandStatus(CHEAT_POWER))
             return;
     }
 
     for (SpellInfo::CostData& cost : m_powerCost)
     {
         Powers powerType = Powers(cost.Power);
         bool hit = true;
         if (m_caster->GetTypeId() == TYPEID_PLAYER)
         {
             if (powerType == POWER_RAGE || powerType == POWER_ENERGY || powerType == POWER_RUNES)
             {
                 ObjectGuid targetGUID = m_targets.GetUnitTargetGUID();
                 if (!targetGUID.IsEmpty())
                 {
                     for (std::vector<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
                     {
                         if (ihit->targetGUID == targetGUID)
                         {
                             if (ihit->missCondition != SPELL_MISS_NONE)
                             {
                                 hit = false;
                                 //lower spell cost on fail (by talent aura)
                                 if (Player* modOwner = m_caster->ToPlayer()->GetSpellModOwner())
                                     modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_SPELL_COST_REFUND_ON_FAIL, cost.Amount);
                             }
                             break;
                         }
                     }
                 }
             }
         }
 
         if (powerType == POWER_RUNES)
         {
             TakeRunePower(hit);
             continue;
         }
 
         if (!cost.Amount)
             continue;
 
         // health as power used
         if (powerType == POWER_HEALTH)
         {
             m_caster->ModifyHealth(-cost.Amount);
             continue;
         }
 
         if (powerType >= MAX_POWERS)
         {
             TC_LOG_ERROR("spells", "Spell::TakePower: Unknown power type '%d'", powerType);
             continue;
         }
 
         if (hit)
             m_caster->ModifyPower(powerType, -cost.Amount);
         else
             m_caster->ModifyPower(powerType, -irand(0, cost.Amount / 4));
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::TakeReagents ( )

 {
     if (m_caster->GetTypeId() != TYPEID_PLAYER)
         return;
 
     ItemTemplate const* castItemTemplate = m_CastItem ? m_CastItem->GetTemplate() : NULL;
 
     // do not take reagents for these item casts
     if (castItemTemplate && castItemTemplate->GetFlags() & ITEM_FLAG_TRIGGERED_CAST)
         return;
 
     Player* p_caster = m_caster->ToPlayer();
     if (p_caster->CanNoReagentCast(m_spellInfo))
         return;
 
     for (uint32 x = 0; x < MAX_SPELL_REAGENTS; ++x)
     {
         if (m_spellInfo->Reagent[x] <= 0)
             continue;
 
         uint32 itemid = m_spellInfo->Reagent[x];
         uint32 itemcount = m_spellInfo->ReagentCount[x];
 
         // if CastItem is also spell reagent
         if (castItemTemplate && castItemTemplate->GetId() == itemid)
         {
             for (uint8 s = 0; s < castItemTemplate->Effects.size() && s < 5; ++s)
             {
                 // CastItem will be used up and does not count as reagent
                 int32 charges = m_CastItem->GetSpellCharges(s);
                 if (castItemTemplate->Effects[s]->Charges < 0 && abs(charges) < 2)
                 {
                     ++itemcount;
                     break;
                 }
             }
 
             m_CastItem = NULL;
             m_castItemGUID.Clear();
             m_castItemEntry = 0;
         }
 
         // if GetItemTarget is also spell reagent
         if (m_targets.GetItemTargetEntry() == itemid)
             m_targets.SetItemTarget(NULL);
 
         p_caster->DestroyItemCount(itemid, itemcount, true);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::TakeRunePower ( bool didHit )

 {
     if (m_caster->GetTypeId() != TYPEID_PLAYER || m_caster->getClass() != CLASS_DEATH_KNIGHT)
         return;
 
     SpellRuneCostEntry const* runeCostData = sSpellRuneCostStore.LookupEntry(m_spellInfo->RuneCostID);
     if (!runeCostData || (runeCostData->NoRuneCost() && runeCostData->NoRunicPowerGain()))
         return;
 
     Player* player = m_caster->ToPlayer();
     m_runesState = player->GetRunesState();                 // store previous state
 
     int32 runeCost[NUM_RUNE_TYPES];                         // blood, frost, unholy, death
 
     for (uint32 i = 0; i < NUM_RUNE_TYPES; ++i)
     {
         runeCost[i] = runeCostData->RuneCost[i];
         if (Player* modOwner = m_caster->GetSpellModOwner())
             modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_COST, runeCost[i], this);
     }
 
     // Let's say we use a skill that requires a Frost rune. This is the order:
     // - Frost rune
     // - Death rune, originally a Frost rune
     // - Death rune, any kind
     for (uint32 i = 0; i < MAX_RUNES; ++i)
     {
         RuneType rune = player->GetCurrentRune(i);
         if (!player->GetRuneCooldown(i) && runeCost[rune] > 0)
         {
             player->SetRuneCooldown(i, didHit ? player->GetRuneBaseCooldown(i) : uint32(RUNE_MISS_COOLDOWN), true);
             player->SetLastUsedRune(rune);
             runeCost[rune]--;
         }
     }
 
     // Find a Death rune where the base rune matches the one we need
     runeCost[RUNE_DEATH] += runeCost[RUNE_BLOOD] + runeCost[RUNE_UNHOLY] + runeCost[RUNE_FROST];
     if (runeCost[RUNE_DEATH] > 0)
     {
         for (uint32 i = 0; i < MAX_RUNES; ++i)
         {
             RuneType rune = player->GetCurrentRune(i);
             RuneType baseRune = player->GetBaseRune(i);
             if (!player->GetRuneCooldown(i) && rune == RUNE_DEATH && runeCost[baseRune] > 0)
             {
                 player->SetRuneCooldown(i, didHit ? player->GetRuneBaseCooldown(i) : uint32(RUNE_MISS_COOLDOWN), true);
                 player->SetLastUsedRune(rune);
                 runeCost[baseRune]--;
                 runeCost[rune]--;
 
                 // keep Death Rune type if missed
                 if (didHit)
                     player->RestoreBaseRune(i);
 
                 if (runeCost[RUNE_DEATH] == 0)
                     break;
             }
         }
     }
 
     // Grab any Death rune
     if (runeCost[RUNE_DEATH] > 0)
     {
         for (uint32 i = 0; i < MAX_RUNES; ++i)
         {
             RuneType rune = player->GetCurrentRune(i);
             if (!player->GetRuneCooldown(i) && rune == RUNE_DEATH)
             {
                 player->SetRuneCooldown(i, didHit ? player->GetRuneBaseCooldown(i) : uint32(RUNE_MISS_COOLDOWN), true);
                 player->SetLastUsedRune(rune);
                 runeCost[rune]--;
 
                 // keep Death Rune type if missed
                 if (didHit)
                     player->RestoreBaseRune(i);
 
                 if (runeCost[RUNE_DEATH] == 0)
                     break;
             }
         }
     }
 
     // you can gain some runic power when use runes
     if (didHit)
         if (int32 rp = int32(runeCostData->RunicPower * sWorld->getRate(RATE_POWER_RUNICPOWER_INCOME)))
             player->ModifyPower(POWER_RUNIC_POWER, int32(rp));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::TriggerGlobalCooldown ( )

protected

 {
     int32 gcd = m_spellInfo->StartRecoveryTime;
     if (!gcd)
         return;
 
     // Only players or controlled units have global cooldown
     if (m_caster->GetTypeId() != TYPEID_PLAYER && !m_caster->GetCharmInfo())
         return;
 
     if (m_caster->GetTypeId() == TYPEID_PLAYER)
         if (m_caster->ToPlayer()->GetCommandStatus(CHEAT_COOLDOWN))
             return;
 
     // Global cooldown can't leave range 1..1.5 secs
     // There are some spells (mostly not cast directly by player) that have < 1 sec and > 1.5 sec global cooldowns
     // but as tests show are not affected by any spell mods.
     if (m_spellInfo->StartRecoveryTime >= MIN_GCD && m_spellInfo->StartRecoveryTime <= MAX_GCD)
     {
         // gcd modifier auras are applied only to own spells and only players have such mods
         if (m_caster->GetTypeId() == TYPEID_PLAYER)
             m_caster->ToPlayer()->ApplySpellMod(m_spellInfo->Id, SPELLMOD_GLOBAL_COOLDOWN, gcd, this);
 
         // Apply haste rating
         gcd = int32(float(gcd) * m_caster->GetFloatValue(UNIT_MOD_CAST_SPEED));
         if (gcd < MIN_GCD)
             gcd = MIN_GCD;
         else if (gcd > MAX_GCD)
             gcd = MAX_GCD;
     }
 
     m_caster->GetSpellHistory()->AddGlobalCooldown(m_spellInfo, gcd);
 }

Here is the caller graph for this function:

void Spell::update ( uint32 difftime )

 {
     // update pointers based at it's GUIDs
     if (!UpdatePointers())
     {
         // cancel the spell if UpdatePointers() returned false, something wrong happened there
         cancel();
         return;
     }
 
     if (!m_targets.GetUnitTargetGUID().IsEmpty() && !m_targets.GetUnitTarget())
     {
         TC_LOG_DEBUG("spells", "Spell %u is cancelled due to removal of target.", m_spellInfo->Id);
         cancel();
         return;
     }
 
     // check if the player caster has moved before the spell finished
     // with the exception of spells affected with SPELL_AURA_CAST_WHILE_WALKING effect
     SpellEffectInfo const* effect = GetEffect(EFFECT_0);
     if ((m_caster->GetTypeId() == TYPEID_PLAYER && m_timer != 0) &&
         m_caster->isMoving() && (m_spellInfo->InterruptFlags & SPELL_INTERRUPT_FLAG_MOVEMENT) &&
         ((effect && effect->Effect != SPELL_EFFECT_STUCK) || !m_caster->HasUnitMovementFlag(MOVEMENTFLAG_FALLING_FAR)) &&
         !m_caster->HasAuraTypeWithAffectMask(SPELL_AURA_CAST_WHILE_WALKING, m_spellInfo))
     {
         // don't cancel for melee, autorepeat, triggered and instant spells
         if (!IsNextMeleeSwingSpell() && !IsAutoRepeat() && !IsTriggered())
             cancel();
     }
 
     switch (m_spellState)
     {
         case SPELL_STATE_PREPARING:
         {
             if (m_timer > 0)
             {
                 if (difftime >= (uint32)m_timer)
                     m_timer = 0;
                 else
                     m_timer -= difftime;
             }
 
             if (m_timer == 0 && !IsNextMeleeSwingSpell() && !IsAutoRepeat())
                 // don't CheckCast for instant spells - done in spell::prepare, skip duplicate checks, needed for range checks for example
                 cast(!m_casttime);
             break;
         }
         case SPELL_STATE_CASTING:
         {
             if (m_timer)
             {
                 // check if there are alive targets left
                 if (!UpdateChanneledTargetList())
                 {
                     TC_LOG_DEBUG("spells", "Channeled spell %d is removed due to lack of targets", m_spellInfo->Id);
                     SendChannelUpdate(0);
                     finish();
                 }
 
                 if (m_timer > 0)
                 {
                     if (difftime >= (uint32)m_timer)
                         m_timer = 0;
                     else
                         m_timer -= difftime;
                 }
             }
 
             if (m_timer == 0)
             {
                 SendChannelUpdate(0);
                 finish();
             }
             break;
         }
         default:
             break;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Spell::UpdateChanneledTargetList ( )

protected

 {
     // Not need check return true
     if (m_channelTargetEffectMask == 0)
         return true;
 
     uint32 channelTargetEffectMask = m_channelTargetEffectMask;
     uint32 channelAuraMask = 0;
     for (SpellEffectInfo const* effect : GetEffects())
         if (effect && effect->Effect == SPELL_EFFECT_APPLY_AURA)
             channelAuraMask |= 1 << effect->EffectIndex;
 
     channelAuraMask &= channelTargetEffectMask;
 
     float range = 0;
     if (channelAuraMask)
     {
         range = m_spellInfo->GetMaxRange(m_spellInfo->IsPositive());
         if (Player* modOwner = m_caster->GetSpellModOwner())
             modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_RANGE, range, this);
     }
 
     for (std::vector<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
     {
         if (ihit->missCondition == SPELL_MISS_NONE && (channelTargetEffectMask & ihit->effectMask))
         {
             Unit* unit = m_caster->GetGUID() == ihit->targetGUID ? m_caster : ObjectAccessor::GetUnit(*m_caster, ihit->targetGUID);
 
             if (!unit)
                 continue;
 
             if (IsValidDeadOrAliveTarget(unit))
             {
                 if (channelAuraMask & ihit->effectMask)
                 {
                     if (AuraApplication * aurApp = unit->GetAuraApplication(m_spellInfo->Id, m_originalCasterGUID))
                     {
                         if (m_caster != unit && !m_caster->IsWithinDistInMap(unit, range))
                         {
                             ihit->effectMask &= ~aurApp->GetEffectMask();
                             unit->RemoveAura(aurApp);
                             continue;
                         }
                     }
                     else // aura is dispelled
                         continue;
                 }
 
                 channelTargetEffectMask &= ~ihit->effectMask;   // remove from need alive mask effect that have alive target
             }
         }
     }
 
     // is all effects from m_needAliveTargetMask have alive targets
     return channelTargetEffectMask == 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Spell::UpdatePointers ( )

 {
     if (m_originalCasterGUID == m_caster->GetGUID())
         m_originalCaster = m_caster;
     else
     {
         m_originalCaster = ObjectAccessor::GetUnit(*m_caster, m_originalCasterGUID);
         if (m_originalCaster && !m_originalCaster->IsInWorld())
             m_originalCaster = NULL;
     }
 
     if (!m_castItemGUID.IsEmpty() && m_caster->GetTypeId() == TYPEID_PLAYER)
     {
         m_CastItem = m_caster->ToPlayer()->GetItemByGuid(m_castItemGUID);
         m_castItemLevel = -1;
         // cast item not found, somehow the item is no longer where we expected
         if (!m_CastItem)
             return false;
 
         // check if the item is really the same, in case it has been wrapped for example
         if (m_castItemEntry != m_CastItem->GetEntry())
             return false;
 
         m_castItemLevel = int32(m_CastItem->GetItemLevel(m_caster->ToPlayer()));
     }
 
     m_targets.Update(m_caster);
 
     // further actions done only for dest targets
     if (!m_targets.HasDst())
         return true;
 
     // cache last transport
     WorldObject* transport = NULL;
 
     // update effect destinations (in case of moved transport dest target)
     for (SpellEffectInfo const* effect : GetEffects())
     {
         if (!effect)
             continue;
 
         SpellDestination& dest = m_destTargets[effect->EffectIndex];
         if (!dest._transportGUID)
             continue;
 
         if (!transport || transport->GetGUID() != dest._transportGUID)
             transport = ObjectAccessor::GetWorldObject(*m_caster, dest._transportGUID);
 
         if (transport)
         {
             dest._position.Relocate(transport);
             dest._position.RelocateOffset(dest._transportOffset);
         }
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Spell::UpdateSpellCastDataTargets ( WorldPackets::Spells::SpellCastData & data )

protected

Writes miss and hit targets for a SMSG_SPELL_GO packet.

 {
     // This function also fill data for channeled spells:
     // m_needAliveTargetMask req for stop channeling if one target die
     for (TargetInfo& targetInfo : m_UniqueTargetInfo)
     {
         if (targetInfo.effectMask == 0) // No effect apply - all immune add state
             // possibly SPELL_MISS_IMMUNE2 for this??
             targetInfo.missCondition = SPELL_MISS_IMMUNE2;
 
         if (targetInfo.missCondition == SPELL_MISS_NONE) // hits
         {
             data.HitTargets.push_back(targetInfo.targetGUID);
 
             m_channelTargetEffectMask |= targetInfo.effectMask;
         }
         else // misses
         {
             data.MissTargets.push_back(targetInfo.targetGUID);
 
             WorldPackets::Spells::SpellMissStatus missStatus;
             missStatus.Reason = targetInfo.missCondition;
             if (targetInfo.missCondition == SPELL_MISS_REFLECT)
                 missStatus.ReflectStatus = targetInfo.reflectResult;
 
             data.MissStatus.push_back(missStatus);
         }
     }
 
     for (GOTargetInfo const& targetInfo : m_UniqueGOTargetInfo)
         data.HitTargets.push_back(targetInfo.targetGUID); // Always hits
 
     // Reset m_needAliveTargetMask for non channeled spell
     if (!m_spellInfo->IsChanneled())
         m_channelTargetEffectMask = 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

friend class SpellScript

friend

void Unit::SetCurrentCastSpell ( Spell * pSpell )

friend

Member Data Documentation

std::vector<SpellLogEffectDurabilityDamageParams> Spell::_durabilityDamageTargets[MAX_SPELL_EFFECTS]

protected

SpellEffectInfoVector Spell::_effects

protected

std::vector<SpellLogEffectExtraAttacksParams> Spell::_extraAttacksTargets[MAX_SPELL_EFFECTS]

protected

std::vector<SpellLogEffectFeedPetParams> Spell::_feedPetTargets[MAX_SPELL_EFFECTS]

protected

std::vector<SpellLogEffectGenericVictimParams> Spell::_genericVictimTargets[MAX_SPELL_EFFECTS]

protected

std::vector<SpellLogEffectPowerDrainParams> Spell::_powerDrainTargets[MAX_SPELL_EFFECTS]

protected

std::vector<SpellLogEffectTradeSkillItemParams> Spell::_tradeSkillTargets[MAX_SPELL_EFFECTS]

protected

TriggerCastFlags Spell::_triggeredCastFlags

protected

uint32 Spell::AbilityId

int32 Spell::damage

protected

uint32 Spell::Data[2]

WorldLocation* Spell::destTarget

protected

SpellEffectHandleMode Spell::effectHandleMode

protected

SpellEffectInfo const* Spell::effectInfo

protected

GameObject* Spell::focusObject

protected

GameObject* Spell::gameObjTarget

protected

struct { ... } Spell::GarrFollower

uint32 Spell::GarrMissionId

uint32 Spell::GlyphSlot

uint32 Spell::Id

uint32 Spell::ItemId

Item* Spell::itemTarget

protected

UsedSpellMods Spell::m_appliedMods

uint8 Spell::m_applyMultiplierMask

protected

WeaponAttackType Spell::m_attackType

protected

uint32 Spell::m_auraScaleMask

protected

bool Spell::m_autoRepeat

protected

bool Spell::m_canReflect

protected

uint8 Spell::m_cast_count

Unit* const Spell::m_caster

protected

uint32 Spell::m_castFlagsEx

Item* Spell::m_CastItem

uint32 Spell::m_castItemEntry

ObjectGuid Spell::m_castItemGUID

int32 Spell::m_castItemLevel

int32 Spell::m_casttime

protected

int32 Spell::m_channeledDuration

protected

uint32 Spell::m_channelTargetEffectMask

protected

int8 Spell::m_comboPointGain

SpellCustomErrors Spell::m_customError

int32 Spell::m_damage

protected

float Spell::m_damageMultipliers[3]

protected

uint8 Spell::m_delayAtDamageCount

protected

uint64 Spell::m_delayMoment

protected

uint64 Spell::m_delayStart

protected

SpellDestination Spell::m_destTargets[MAX_SPELL_EFFECTS]

protected

DiminishingGroup Spell::m_diminishGroup

protected

DiminishingLevels Spell::m_diminishLevel

protected

bool Spell::m_executedCurrently

protected

int32 Spell::m_healing

protected

HitTriggerSpellList Spell::m_hitTriggerSpells

protected

bool Spell::m_immediateHandled

protected

bool Spell::m_isDelayedInstantCast

protected

std::list<SpellScript*> Spell::m_loadedScripts

protected

union { ... } Spell::m_misc

bool Spell::m_needComboPoints

protected

Unit* Spell::m_originalCaster

protected

ObjectGuid Spell::m_originalCasterGUID

protected

std::vector<SpellInfo::CostData> Spell::m_powerCost

protected

uint32 Spell::m_preCastSpell

PathGenerator Spell::m_preGeneratedPath

protected

uint32 Spell::m_procAttacker

protected

uint32 Spell::m_procEx

protected

uint32 Spell::m_procVictim

protected

bool Spell::m_referencedFromCurrentSpell

protected

uint8 Spell::m_runesState

protected

Spell** Spell::m_selfContainer

bool Spell::m_skipCheck

protected

Aura* Spell::m_spellAura

protected

SpellInfo const* const Spell::m_spellInfo

SpellSchoolMask Spell::m_spellSchoolMask

protected

uint32 Spell::m_spellState

protected

SpellValue* const Spell::m_spellValue

protected

uint32 Spell::m_SpellVisual

SpellCastTargets Spell::m_targets

int32 Spell::m_timer

protected

SpellInfo const* Spell::m_triggeredByAuraSpell

protected

std::vector<GOTargetInfo> Spell::m_UniqueGOTargetInfo

protected

std::vector<ItemTargetInfo> Spell::m_UniqueItemInfo

protected

std::vector<TargetInfo> Spell::m_UniqueTargetInfo

protected

struct { ... } Spell::Raw

uint32 Spell::TalentId

Unit* Spell::unitTarget

protected

float Spell::variance

protected

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

src/server/game/Spells/Spell.h
src/server/game/Spells/Spell.cpp
src/server/game/Spells/SpellEffects.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Friends

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation